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';
// 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';
// 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;
// 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: () => {}
});
// 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 : () => {};
// 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 : () => ({});
/* 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 { 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;
/* 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';
/* 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;
/* 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';
/* 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;
/* eslint-enable @typescript-eslint/no-require-imports */
import { IssueFlagBanner } from '../components/PromptInput/IssueFlagBanner.js';
import { useIssueFlagBanner } from '../hooks/useIssueFlagBanner.js';
import { CompanionSprite, CompanionFloatingBubble, MIN_COLS_FOR_FULL_SPRITE } from '../buddy/CompanionSprite.js';
import { DevBar } from '../components/DevBar.js';
// 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';

// 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[] = [];

// 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) => {}
};
// Window after a user-initiated scroll during which type-into-empty does NOT
// repin to bottom. Josh Rosen's workflow: Claude emits long output → scroll
// up to read the start → start typing → before this fix, snapped to bottom.
// https://anthropic.slack.com/archives/C07VBSHV7EV/p1773545449871739
const RECENT_SCROLL_REPIN_WINDOW_MS = 3000;

// Use LRU cache to prevent unbounded memory growth
// 100 files should be sufficient for most coding sessions while preventing
// memory issues when working across many files in large projects

function median(values: 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]!;
}

/**
 * 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;
}

/** less-style / bar. 1-row, same border-top styling as TranscriptModeFooter
 *  so swapping them in the bottom slot doesn't shift ScrollBox height.
 *  useSearchInput handles readline editing; we report query changes and
 *  render the counter. Incremental — re-search + highlight per keystroke. */
function TranscriptSearchBar({
  jumpRef,
  count,
  current,
  onClose,
  onCancel,
  setHighlight,
  initialQuery
}: {
  jumpRef: RefObject<JumpHandle | null>;
  count: number;
  current: number;
  /** Enter — commit. Query persists for n/N. */
  onClose: (lastQuery: string) => void;
  /** Esc/ctrl+c/ctrl+g — undo to pre-/ state. */
  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;
}): React.ReactNode {
  const {
    query,
    cursorOffset
  } = useSearchInput({
    isActive: true,
    initialQuery,
    onExit: () => onClose(query),
    onCancel
  });
  // Index warm-up runs before the query effect so it measures the real
  // cost — otherwise setSearchQuery fills the cache first and warm
  // reports ~0ms while the user felt the actual lag.
  // First / in a transcript session pays the extractSearchText cost.
  // Subsequent / return 0 immediately (indexWarmed ref in VML).
  // Transcript is frozen at ctrl+o so the cache stays valid.
  // Initial 'building' so warmDone is false on mount — the [query] effect
  // waits for the warm effect's first resolve instead of racing it. With
  // null initial, warmDone would be true on mount → [query] fires →
  // setSearchQuery fills cache → warm reports ~0ms while the user felt
  // the real lag.
  const [indexStatus, setIndexStatus] = React.useState<'building' | {
    ms: number;
  } | null>('building');
  React.useEffect(() => {
    let alive = true;
    const warm = jumpRef.current?.warmSearchIndex;
    if (!warm) {
      setIndexStatus(null); // VML not mounted yet — rare, skip indicator
      return;
    }
    setIndexStatus('building');
    warm().then(ms => {
      if (!alive) return;
      // <20ms = imperceptible. No point showing "indexed in 3ms".
      if (ms < 20) {
        setIndexStatus(null);
      } else {
        setIndexStatus({
          ms
        });
        setTimeout(() => alive && setIndexStatus(null), 2000);
      }
    });
    return () => {
      alive = false;
    };
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, []); // mount-only: bar opens once per /
  // Gate the query effect on warm completion. setHighlight stays instant
  // (screen-space overlay, no indexing). setSearchQuery (the scan) waits.
  const warmDone = indexStatus !== 'building';
  useEffect(() => {
    if (!warmDone) return;
    jumpRef.current?.setSearchQuery(query);
    setHighlight(query);
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [query, warmDone]);
  const off = cursorOffset;
  const cursorChar = off < query.length ? query[off] : ' ';
  return <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>
          {current}/{count}
          {'  '}
        </Text> : null}
    </Box>;
}
const TITLE_ANIMATION_FRAMES = ['⠂', '⠐'];
const TITLE_STATIC_PREFIX = '✳';
const TITLE_ANIMATION_INTERVAL_MS = 960;

/**
 * Sets the terminal tab title, with an animated prefix glyph while a query
 * is running. Isolated from REPL so the 960ms animation tick re-renders only
 * this leaf component (which returns null — pure side-effect) instead of the
 * entire REPL tree. Before extraction, the tick was ~1 REPL render/sec for
 * the duration of every turn, dragging PromptInput and friends along.
 */
function AnimatedTerminalTitle(t0) {
  const $ = _c(6);
  const {
    isAnimating,
    title,
    disabled,
    noPrefix
  } = t0;
  const terminalFocused = useTerminalFocus();
  const [frame, setFrame] = useState(0);
  let t1;
  let t2;
  if ($[0] !== disabled || $[1] !== isAnimating || $[2] !== noPrefix || $[3] !== terminalFocused) {
    t1 = () => {
      if (disabled || noPrefix || !isAnimating || !terminalFocused) {
        return;
      }
      const interval = setInterval(_temp2, TITLE_ANIMATION_INTERVAL_MS, setFrame);
      return () => clearInterval(interval);
    };
    t2 = [disabled, noPrefix, isAnimating, terminalFocused];
    $[0] = disabled;
    $[1] = isAnimating;
    $[2] = noPrefix;
    $[3] = terminalFocused;
    $[4] = t1;
    $[5] = t2;
  } else {
    t1 = $[4];
    t2 = $[5];
  }
  useEffect(t1, t2);
  const prefix = isAnimating ? TITLE_ANIMATION_FRAMES[frame] ?? TITLE_STATIC_PREFIX : TITLE_STATIC_PREFIX;
  useTerminalTitle(disabled ? null : noPrefix ? title : `${prefix} ${title}`);
  return null;
}
function _temp2(setFrame_0) {
  return setFrame_0(_temp);
}
function _temp(f) {
  return (f + 1) % TITLE_ANIMATION_FRAMES.length;
}
export type Props = {
  commands: Command[];
  debug: boolean;
  initialTools: Tool[];
  // Initial messages to populate the REPL with
  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[];
  // Content-replacement records from a resumed session's transcript — used to
  // reconstruct contentReplacementState so the same results are re-replaced
  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;
  // 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>;
  // Optional callback when a turn completes (model finishes responding)
  onTurnComplete?: (messages: MessageType[]) => void | Promise<void>;
  // When true, disables REPL input (hides prompt and prevents message selector)
  disabled?: boolean;
  // Optional agent definition to use for the main thread
  mainThreadAgentDefinition?: AgentDefinition;
  // When true, disables all slash commands
  disableSlashCommands?: boolean;
  // Task list id: when set, enables tasks mode that watches a task list and auto-processes tasks.
  taskListId?: string;
  // Remote session config for --remote mode (uses CCR as execution engine)
  remoteSessionConfig?: RemoteSessionConfig;
  // Direct connect config for `claude connect` mode (connects to a claude server)
  directConnectConfig?: DirectConnectConfig;
  // SSH session for `claude ssh` mode (local REPL, remote tools over ssh)
  sshSession?: SSHSession;
  // Thinking configuration to use when thinking is enabled
  thinkingConfig: ThinkingConfig;
};
export type Screen = 'prompt' | 'transcript';
export function REPL({
  commands: initialCommands,
  debug,
  initialTools,
  initialMessages,
  pendingHookMessages,
  initialFileHistorySnapshots,
  initialContentReplacements,
  initialAgentName,
  initialAgentColor,
  mcpClients: initialMcpClients,
  dynamicMcpConfig: initialDynamicMcpConfig,
  autoConnectIdeFlag,
  strictMcpConfig = false,
  systemPrompt: customSystemPrompt,
  appendSystemPrompt,
  onBeforeQuery,
  onTurnComplete,
  disabled = false,
  mainThreadAgentDefinition: initialMainThreadAgentDefinition,
  disableSlashCommands = false,
  taskListId,
  remoteSessionConfig,
  directConnectConfig,
  sshSession,
  thinkingConfig
}: Props): React.ReactNode {
  const isRemoteSession = !!remoteSessionConfig;

  // Env-var gates hoisted to mount-time — isEnvTruthy does toLowerCase+trim+
  // includes, and these were on the render path (hot during PageUp spam).
  const titleDisabled = useMemo(() => isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_TERMINAL_TITLE), []);
  const moreRightEnabled = useMemo(() => "external" === 'ant' && isEnvTruthy(process.env.CLAUDE_MORERIGHT), []);
  const disableVirtualScroll = useMemo(() => isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_VIRTUAL_SCROLL), []);
  const disableMessageActions = feature('MESSAGE_ACTIONS') ?
  // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
  useMemo(() => isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_MESSAGE_ACTIONS), []) : false;

  // Log REPL mount/unmount lifecycle
  useEffect(() => {
    logForDebugging(`[REPL:mount] REPL mounted, disabled=${disabled}`);
    return () => logForDebugging(`[REPL:unmount] REPL unmounting`);
  }, [disabled]);

  // Agent definition is state so /resume can update it mid-session
  const [mainThreadAgentDefinition, setMainThreadAgentDefinition] = useState(initialMainThreadAgentDefinition);
  const toolPermissionContext = useAppState(s => s.toolPermissionContext);
  const verbose = useAppState(s => s.verbose);
  const mcp = useAppState(s => s.mcp);
  const plugins = useAppState(s => s.plugins);
  const agentDefinitions = useAppState(s => s.agentDefinitions);
  const fileHistory = useAppState(s => s.fileHistory);
  const initialMessage = useAppState(s => s.initialMessage);
  const queuedCommands = useCommandQueue();
  // feature() is a build-time constant — dead code elimination removes the hook
  // call entirely in external builds, so this is safe despite looking conditional.
  // These fields contain excluded strings that must not appear in external builds.
  const spinnerTip = useAppState(s => s.spinnerTip);
  const showExpandedTodos = useAppState(s => s.expandedView) === 'tasks';
  const pendingWorkerRequest = useAppState(s => s.pendingWorkerRequest);
  const pendingSandboxRequest = useAppState(s => s.pendingSandboxRequest);
  const teamContext = useAppState(s => s.teamContext);
  const tasks = useAppState(s => s.tasks);
  const workerSandboxPermissions = useAppState(s => s.workerSandboxPermissions);
  const elicitation = useAppState(s => s.elicitation);
  const ultraplanPendingChoice = useAppState(s => s.ultraplanPendingChoice);
  const ultraplanLaunchPending = useAppState(s => s.ultraplanLaunchPending);
  const viewingAgentTaskId = useAppState(s => s.viewingAgentTaskId);
  const setAppState = useSetAppState();

  // Bootstrap: retained local_agent that hasn't loaded disk yet → read
  // sidechain JSONL and UUID-merge with whatever stream has appended so far.
  // Stream appends immediately on retain (no defer); bootstrap fills the
  // prefix. Disk-write-before-yield means live is always a suffix of disk.
  const viewedLocalAgent = viewingAgentTaskId ? tasks[viewingAgentTaskId] : undefined;
  const needsBootstrap = isLocalAgentTask(viewedLocalAgent) && viewedLocalAgent.retain && !viewedLocalAgent.diskLoaded;
  useEffect(() => {
    if (!viewingAgentTaskId || !needsBootstrap) return;
    const taskId = viewingAgentTaskId;
    void getAgentTranscript(asAgentId(taskId)).then(result => {
      setAppState(prev => {
        const t = prev.tasks[taskId];
        if (!isLocalAgentTask(t) || t.diskLoaded || !t.retain) return prev;
        const live = t.messages ?? [];
        const liveUuids = new Set(live.map(m => m.uuid));
        const diskOnly = result ? result.messages.filter(m => !liveUuids.has(m.uuid)) : [];
        return {
          ...prev,
          tasks: {
            ...prev.tasks,
            [taskId]: {
              ...t,
              messages: [...diskOnly, ...live],
              diskLoaded: true
            }
          }
        };
      });
    });
  }, [viewingAgentTaskId, needsBootstrap, setAppState]);
  const store = useAppStateStore();
  const terminal = useTerminalNotification();
  const mainLoopModel = useMainLoopModel();

  // Note: standaloneAgentContext is initialized in main.tsx (via initialState) or
  // ResumeConversation.tsx (via setAppState before rendering REPL) to avoid
  // useEffect-based state initialization on mount (per CLAUDE.md guidelines)

  // Local state for commands (hot-reloadable when skill files change)
  const [localCommands, setLocalCommands] = useState(initialCommands);

  // Watch for skill file changes and reload all commands
  useSkillsChange(isRemoteSession ? undefined : getProjectRoot(), setLocalCommands);

  // Track proactive mode for tools dependency - SleepTool filters by proactive state
  const proactiveActive = React.useSyncExternalStore(proactiveModule?.subscribeToProactiveChanges ?? PROACTIVE_NO_OP_SUBSCRIBE, proactiveModule?.isProactiveActive ?? PROACTIVE_FALSE);

  // BriefTool.isEnabled() reads getUserMsgOptIn() from bootstrap state, which
  // /brief flips mid-session alongside isBriefOnly. The memo below needs a
  // React-visible dep to re-run getTools() when that happens; isBriefOnly is
  // the AppState mirror that triggers the re-render. Without this, toggling
  // /brief mid-session leaves the stale tool list (no SendUserMessage) and
  // the model emits plain text the brief filter hides.
  const isBriefOnly = useAppState(s => s.isBriefOnly);
  const localTools = useMemo(() => getTools(toolPermissionContext), [toolPermissionContext, proactiveActive, isBriefOnly]);
  useKickOffCheckAndDisableBypassPermissionsIfNeeded();
  useKickOffCheckAndDisableAutoModeIfNeeded();
  const [dynamicMcpConfig, setDynamicMcpConfig] = useState<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);
  // v-for-editor render progress. Inline in the footer — notifications
  // render inside PromptInput which isn't mounted in transcript.
  const [editorStatus, setEditorStatus] = useState('');
  // Incremented on transcript exit. Async v-render captures this at start;
  // each status write no-ops if stale (user left transcript mid-render —
  // the stable setState would otherwise stamp a ghost toast into the next
  // session). Also clears any pending 4s auto-clear.
  const editorGenRef = useRef(0);
  const editorTimerRef = useRef<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);

  // 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);
  // Dead code elimination: model switch callout state (ant-only)
  const [showModelSwitchCallout, setShowModelSwitchCallout] = useState(() => {
    if ("external" === 'ant') {
      return shouldShowAntModelSwitch();
    }
    return false;
  });
  const [showEffortCallout, setShowEffortCallout] = useState(() => shouldShowEffortCallout(mainLoopModel));
  const showRemoteCallout = useAppState(s => s.showRemoteCallout);
  const [showDesktopUpsellStartup, setShowDesktopUpsellStartup] = useState(() => shouldShowDesktopUpsellStartup());
  // notifications
  useModelMigrationNotifications();
  useCanSwitchToExistingSubscription();
  useIDEStatusIndicator({
    ideSelection,
    mcpClients,
    ideInstallationStatus
  });
  useMcpConnectivityStatus({
    mcpClients
  });
  useAutoModeUnavailableNotification();
  usePluginInstallationStatus();
  usePluginAutoupdateNotification();
  useSettingsErrors();
  useRateLimitWarningNotification(mainLoopModel);
  useFastModeNotification();
  useDeprecationWarningNotification(mainLoopModel);
  useNpmDeprecationNotification();
  useAntOrgWarningNotification();
  useInstallMessages();
  useChromeExtensionNotification();
  useOfficialMarketplaceNotification();
  useLspInitializationNotification();
  useTeammateLifecycleNotification();
  const {
    recommendation: lspRecommendation,
    handleResponse: handleLspResponse
  } = useLspPluginRecommendation();
  const {
    recommendation: hintRecommendation,
    handleResponse: handleHintResponse
  } = useClaudeCodeHintRecommendation();

  // Memoize the combined initial tools array to prevent reference changes
  const combinedInitialTools = useMemo(() => {
    return [...localTools, ...initialTools];
  }, [localTools, initialTools]);

  // Initialize plugin management
  useManagePlugins({
    enabled: !isRemoteSession
  });
  const tasksV2 = useTasksV2WithCollapseEffect();

  // Start background plugin installations

  // SECURITY: This code is guaranteed to run ONLY after the "trust this folder" dialog
  // has been confirmed by the user. The trust dialog is shown in cli.tsx (line ~387)
  // before the REPL component is rendered. The dialog blocks execution until the user
  // accepts, and only then is the REPL component mounted and this effect runs.
  // This ensures that plugin installations from repository and user settings only
  // happen after explicit user consent to trust the current working directory.
  useEffect(() => {
    if (isRemoteSession) return;
    void performStartupChecks(setAppState);
  }, [setAppState, isRemoteSession]);

  // Allow Claude in Chrome MCP to send prompts through MCP notifications
  // and sync permission mode changes to the Chrome extension
  usePromptsFromClaudeInChrome(isRemoteSession ? EMPTY_MCP_CLIENTS : mcpClients, toolPermissionContext.mode);

  // Initialize swarm features: teammate hooks and context
  // Handles both fresh spawns and resumed teammate sessions
  useSwarmInitialization(setAppState, initialMessages, {
    enabled: !isRemoteSession
  });
  const mergedTools = useMergedTools(combinedInitialTools, mcp.tools, toolPermissionContext);

  // Apply agent tool restrictions if mainThreadAgentDefinition is set
  const {
    tools,
    allowedAgentTypes
  } = useMemo(() => {
    if (!mainThreadAgentDefinition) {
      return {
        tools: mergedTools,
        allowedAgentTypes: undefined as string[] | undefined
      };
    }
    const resolved = resolveAgentTools(mainThreadAgentDefinition, mergedTools, false, true);
    return {
      tools: resolved.resolvedTools,
      allowedAgentTypes: resolved.allowedAgentTypes
    };
  }, [mainThreadAgentDefinition, mergedTools]);

  // Merge commands from local state, plugins, and MCP
  const commandsWithPlugins = useMergedCommands(localCommands, plugins.commands 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');
  // Ref mirror so onSubmit can read the latest value without adding
  // streamMode to its deps. streamMode flips between
  // requesting/responding/tool-use ~10x per turn during streaming; having it
  // in onSubmit's deps was recreating onSubmit on every flip, which
  // cascaded into PromptInput prop churn and downstream useCallback/useMemo
  // invalidation. The only consumers inside callbacks are debug logging and
  // telemetry (handlePromptSubmit.ts), so a stale-by-one-render value is
  // harmless — but ref mirrors sync on every render anyway so it's fresh.
  const streamModeRef = useRef(streamMode);
  streamModeRef.current = streamMode;
  const [streamingToolUses, setStreamingToolUses] = useState<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 (remaining > 0) {
        const timer = setTimeout(setStreamingThinking, remaining, null);
        return () => clearTimeout(timer);
      } else {
        setStreamingThinking(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;

  // 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>(() => {});

  // 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>(() => {});

  // 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);
  // 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);
  // Timestamp of the last user-initiated scroll (wheel, PgUp/PgDn, ctrl+u,
  // End/Home, G, drag-to-scroll). Stamped in composedOnScroll — the single
  // chokepoint ScrollKeybindingHandler calls for every user scroll action.
  // Programmatic scrolls (repinScroll's scrollToBottom, sticky auto-follow)
  // do NOT go through composedOnScroll, so they don't stamp this. Ref not
  // state: no re-render on every wheel tick.
  const lastUserScrollTsRef = useRef(0);

  // Synchronous state machine for the query lifecycle. Replaces the
  // error-prone dual-state pattern where isLoading (React state, async
  // batched) and isQueryRunning (ref, sync) could desync. See QueryGuard.ts.
  const queryGuard = React.useRef(new QueryGuard()).current;

  // Subscribe to the guard — true during dispatching or running.
  // This is the single source of truth for "is a local query in flight".
  const isQueryActive = React.useSyncExternalStore(queryGuard.subscribe, queryGuard.getSnapshot);

  // Separate loading flag for operations outside the local query guard:
  // remote sessions (useRemoteSession / useDirectConnect) and foregrounded
  // background tasks (useSessionBackgrounding). These don't route through
  // onQuery / queryGuard, so they need their own spinner-visibility state.
  // Initialize true if remote mode with initial prompt (CCR processing it).
  const [isExternalLoading, setIsExternalLoadingRaw] = React.useState(remoteSessionConfig?.hasInitialPrompt ?? false);

  // Derived: any loading source active. Read-only — no setter. Local query
  // loading is driven by queryGuard (reserve/tryStart/end/cancelReservation),
  // external loading by setIsExternalLoading.
  const isLoading = isQueryActive || isExternalLoading;

  // Elapsed time is computed by SpinnerWithVerb from these refs on each
  // animation frame, avoiding a useInterval that re-renders the entire REPL.
  const [userInputOnProcessing, setUserInputOnProcessingRaw] = React.useState<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);
  // True while the submitted prompt is being processed but its user message
  // hasn't reached setMessages yet. setMessages uses this to keep the
  // baseline in sync when unrelated async messages (bridge status, hook
  // results, scheduled tasks) land during that window.
  const userMessagePendingRef = React.useRef(false);

  // Wall-clock time tracking refs for accurate elapsed time calculation
  const loadingStartTimeRef = React.useRef<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;
  }, []);

  // Reset timing refs inline when isQueryActive transitions false→true.
  // queryGuard.reserve() (in executeUserInput) fires BEFORE processUserInput's
  // first await, but the ref reset in onQuery's try block runs AFTER. During
  // that gap, React renders the spinner with loadingStartTimeRef=0, computing
  // elapsedTimeMs = Date.now() - 0 ≈ 56 years. This inline reset runs on the
  // first render where isQueryActive is observed true — the same render that
  // first shows the spinner — so the ref is correct by the time the spinner
  // reads it. See INC-4549.
  const wasQueryActiveRef = React.useRef(false);
  if (isQueryActive && !wasQueryActiveRef.current) {
    resetTimingRefs();
  }
  wasQueryActiveRef.current = isQueryActive;

  // Wrapper for setIsExternalLoading that resets timing refs on transition
  // to true — SpinnerWithVerb reads these for elapsed time, so they must be
  // reset for remote sessions / foregrounded tasks too (not just local
  // queries, which reset them in onQuery). Without this, a remote-only
  // session would show ~56 years elapsed (Date.now() - 0).
  const setIsExternalLoading = React.useCallback((value: 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);

  // 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);

  // How long after the last keystroke before deferred dialogs are shown
  const PROMPT_SUPPRESSION_MS = 1500;
  // True when user is actively typing — defers interrupt dialogs so keystrokes
  // don't accidentally dismiss or answer a permission prompt the user hasn't read yet.
  const [isPromptInputActive, setIsPromptInputActive] = React.useState(false);
  const [autoUpdaterResult, setAutoUpdaterResult] = useState<AutoUpdaterResult | null>(null);
  useEffect(() => {
    if (autoUpdaterResult?.notifications) {
      autoUpdaterResult.notifications.forEach(notification => {
        addNotification({
          key: 'auto-updater-notification',
          text: notification,
          priority: 'low'
        });
      });
    }
  }, [autoUpdaterResult, addNotification]);

  // tmux + fullscreen + `mouse off`: one-time hint that wheel won't scroll.
  // We no longer mutate tmux's session-scoped mouse option (it poisoned
  // sibling panes); tmux users already know this tradeoff from vim/less.
  useEffect(() => {
    if (isFullscreenEnvEnabled()) {
      void maybeGetTmuxMouseHint().then(hint => {
        if (hint) {
          addNotification({
            key: 'tmux-mouse-hint',
            text: hint,
            priority: 'low'
          });
        }
      });
    }
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, []);
  const [showUndercoverCallout, setShowUndercoverCallout] = useState(false);
  useEffect(() => {
    if ("external" === 'ant') {
      void (async () => {
        // Wait for repo classification to settle (memoized, no-op if primed).
        const {
          isInternalModelRepo
        } = await import('../utils/commitAttribution.js');
        await isInternalModelRepo();
        const {
          shouldShowUndercoverAutoNotice
        } = await import('../utils/undercover.js');
        if (shouldShowUndercoverAutoNotice()) {
          setShowUndercoverCallout(true);
        }
      })();
    }
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, []);
  const [toolJSX, setToolJSXInternal] = useState<{
    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);

  // Wrapper for setToolJSX that preserves local JSX commands (like /btw).
  // When a local JSX command is active, we ignore updates from tools
  // unless they explicitly set clearLocalJSX: true (from onDone callbacks).
  //
  // TO ADD A NEW IMMEDIATE COMMAND:
  // 1. Set `immediate: true` in the command definition
  // 2. Set `isLocalJSXCommand: true` when calling setToolJSX in the command's JSX
  // 3. In the onDone callback, use `setToolJSX({ jsx: null, shouldHidePromptInput: false, clearLocalJSX: true })`
  //    to explicitly clear the overlay when the user dismisses it
  const setToolJSX = useCallback((args: {
    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;
      }
      // 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[]>([]);
  // 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;
  }>>([]);

  // 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());

  // -- 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>();
  // 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 ?? '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;
  // Title animation state lives in <AnimatedTerminalTitle> so the 960ms tick
  // doesn't re-render REPL. titleDisabled/terminalTitle are still computed
  // here because onQueryImpl reads them (background session description,
  // haiku title extraction gate).

  // Prevent macOS from sleeping while Claude is working
  useEffect(() => {
    if (isLoading && !isWaitingForApproval && !isShowingLocalJSXCommand) {
      startPreventSleep();
      return () => stopPreventSleep();
    }
  }, [isLoading, isWaitingForApproval, isShowingLocalJSXCommand]);
  const sessionStatus: 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
      });
    }
  }, [sessionStatus, waitingFor]);

  // 3P default: off — OSC 21337 is ant-only while the spec stabilizes.
  // Gated so we can roll back if the sidebar indicator conflicts with
  // the title spinner in terminals that render both. When the flag is
  // on, the user-facing config setting controls whether it's active.
  const tabStatusGateEnabled = getFeatureValue_CACHED_MAY_BE_STALE('tengu_terminal_sidebar', false);
  const showStatusInTerminalTab = tabStatusGateEnabled && (getGlobalConfig().showStatusInTerminalTab ?? false);
  useTabStatus(titleDisabled || !showStatusInTerminalTab ? null : sessionStatus);

  // Register the leader's setToolUseConfirmQueue for in-process teammates
  useEffect(() => {
    registerLeaderToolUseConfirmQueue(setToolUseConfirmQueue);
    return () => unregisterLeaderToolUseConfirmQueue();
  }, [setToolUseConfirmQueue]);
  const [messages, rawSetMessages] = useState<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);
  // Wrap setMessages so messagesRef is always current the instant the
  // call returns — not when React later processes the batch.  Apply the
  // updater eagerly against the ref, then hand React the computed value
  // (not the function).  rawSetMessages batching becomes last-write-wins,
  // and the last write is correct because each call composes against the
  // already-updated ref.  This is the Zustand pattern: ref is source of
  // truth, React state is the render projection.  Without this, paths
  // that queue functional updaters then synchronously read the ref
  // (e.g. handleSpeculationAccept → onQuery) see stale data.
  const setMessages = useCallback((action: 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);
  }, []);
  // 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;
    } else {
      userMessagePendingRef.current = false;
    }
    setUserInputOnProcessingRaw(input);
  }, []);
  // Fullscreen: track the unseen-divider position. dividerIndex changes
  // only ~twice/scroll-session (first scroll-away + repin). pillVisible
  // and stickyPrompt now live in FullscreenLayout — they subscribe to
  // ScrollBox directly so per-frame scroll never re-renders REPL.
  const {
    dividerIndex,
    dividerYRef,
    onScrollAway,
    onRepin,
    jumpToNew,
    shiftDivider
  } = useUnseenDivider(messages.length);
  if (feature('AWAY_SUMMARY')) {
    // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
    useAwaySummary(messages, setMessages, isLoading);
  }
  const [cursor, setCursor] = useState<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]);
  // Re-pin scroll to bottom and clear the unseen-messages baseline. Called
  // on any user-driven return-to-live action (submit, type-into-empty,
  // overlay appear/dismiss).
  const repinScroll = useCallback(() => {
    scrollRef.current?.scrollToBottom();
    onRepin();
    setCursor(null);
  }, [onRepin, setCursor]);
  // Backstop for the submit-handler repin at onSubmit. If a buffered stdin
  // event (wheel/drag) races between handler-fire and state-commit, the
  // handler's scrollToBottom can be undone. This effect fires on the render
  // where the user's message actually lands — tied to React's commit cycle,
  // so it can't race with stdin. Keyed on lastMsg identity (not messages.length)
  // so useAssistantHistory's prepends don't spuriously repin.
  const lastMsg = messages.at(-1);
  const lastMsgIsHuman = lastMsg != null && isHumanTurn(lastMsg);
  useEffect(() => {
    if (lastMsgIsHuman) {
      repinScroll();
    }
  }, [lastMsgIsHuman, lastMsg, repinScroll]);
  // Assistant-chat: lazy-load remote history on scroll-up. No-op unless
  // KAIROS build + config.viewerOnly. feature() is build-time constant so
  // the branch is dead-code-eliminated in non-KAIROS builds (same pattern
  // as useUnseenDivider above).
  const {
    maybeLoadOlder
  } = feature('KAIROS') ?
  // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
  useAssistantHistory({
    config: remoteSessionConfig,
    setMessages,
    scrollRef,
    onPrepend: shiftDivider
  }) : HISTORY_STUB;
  // Compose useUnseenDivider's callbacks with the lazy-load trigger.
  const composedOnScroll = useCallback((sticky: 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]);
  // Deferred SessionStart hook messages — REPL renders immediately and
  // hook messages are injected when they resolve. awaitPendingHooks()
  // must be called before the first API call so the model sees hook context.
  const awaitPendingHooks = useDeferredHookMessages(pendingHookMessages, setMessages);

  // Deferred messages for the Messages component — renders at transition
  // priority so the reconciler yields every 5ms, keeping input responsive
  // while the expensive message processing pipeline runs.
  const deferredMessages = useDeferredValue(messages);
  const deferredBehind = messages.length - deferredMessages.length;
  if (deferredBehind > 0) {
    logForDebugging(`[useDeferredValue] Messages deferred by ${deferredBehind} (${deferredMessages.length}→${messages.length})`);
  }

  // Frozen state for transcript mode - stores lengths instead of cloning arrays for memory efficiency
  const [frozenTranscriptState, setFrozenTranscriptState] = useState<{
    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 insertTextRef = useRef<{
    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]);

  // 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>();

  // 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);

  // Remote session hook - manages WebSocket connection and message handling for --remote mode
  const remoteSession = useRemoteSession({
    config: remoteSessionConfig,
    setMessages,
    setIsLoading: setIsExternalLoading,
    onInit: handleRemoteInit,
    setToolUseConfirmQueue,
    tools: combinedInitialTools,
    setStreamingToolUses,
    setStreamMode,
    setInProgressToolUseIDs
  });

  // Direct connect hook - manages WebSocket to a claude server for `claude connect` mode
  const directConnect = useDirectConnect({
    config: directConnectConfig,
    setMessages,
    setIsLoading: setIsExternalLoading,
    setToolUseConfirmQueue,
    tools: combinedInitialTools
  });

  // SSH session hook - manages ssh child process for `claude ssh` mode.
  // Same callback shape as useDirectConnect; only the transport under the
  // hood differs (ChildProcess stdin/stdout vs WebSocket).
  const sshRemote = useSSHSession({
    session: sshSession,
    setMessages,
    setIsLoading: setIsExternalLoading,
    setToolUseConfirmQueue,
    tools: combinedInitialTools
  });

  // Use whichever remote mode is active
  const activeRemote = sshRemote.isRemoteMode ? sshRemote : directConnect.isRemoteMode ? directConnect : remoteSession;
  const [pastedContents, setPastedContents] = useState<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);
  // 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 setResponseLength = useCallback((f: (prev: number) => number) => {
    const prev = responseLengthRef.current;
    responseLengthRef.current = f(prev);
    // When content is added (not a compaction reset), update the latest
    // metrics entry so OTPS reflects all content generation activity.
    // Updating lastTokenTime here ensures the denominator includes both
    // streaming time AND subagent execution time, preventing inflation.
    if (responseLengthRef.current > prev) {
      const entries = apiMetricsRef.current;
      if (entries.length > 0) {
        const lastEntry = entries.at(-1)!;
        lastEntry.lastTokenTime = Date.now();
        lastEntry.endResponseLength = responseLengthRef.current;
      }
    }
  }, []);

  // Streaming text display: set state directly per delta (Ink's 16ms render
  // throttle batches rapid updates). Cleared on message arrival (messages.ts)
  // so displayedMessages switches from deferredMessages to messages atomically.
  const [streamingText, setStreamingText] = useState<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());

  // 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;

  // Aggregate tool result budget: per-conversation decision tracking.
  // When the GrowthBook flag is on, query.ts enforces the budget; when
  // off (undefined), enforcement is skipped entirely. Stale entries after
  // /clear, rewind, or compact are harmless (tool_use_ids are UUIDs, stale
  // keys are never looked up). Memory is bounded by total replacement count
  // × ~2KB preview over the REPL lifetime — negligible.
  //
  // Lazy init via useState initializer — useRef(expr) evaluates expr on every
  // render (React ignores it after first, but the computation still runs).
  // For large resumed sessions, reconstruction does O(messages × blocks)
  // work; we only want that once.
  const [contentReplacementStateRef] = useState(() => ({
    current: provisionContentReplacementState(initialMessages, initialContentReplacements)
  }));
  const [haveShownCostDialog, setHaveShownCostDialog] = useState(getGlobalConfig().hasAcknowledgedCostThreshold);
  const [vimMode, setVimMode] = useState<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
  // unmounts (focusedInputDialog → 'ultraplan-choice') but this stays true;
  // after accepting, PromptInput remounts into an empty "No tasks" dialog
  // (the completed ultraplan task has been filtered out). Close it here.
  useEffect(() => {
    if (ultraplanPendingChoice && showBashesDialog) {
      setShowBashesDialog(false);
    }
  }, [ultraplanPendingChoice, showBashesDialog]);
  const isTerminalFocused = useTerminalFocus();
  const terminalFocusRef = useRef(isTerminalFocused);
  terminalFocusRef.current = isTerminalFocused;
  const [theme] = useTheme();

  // resetLoadingState runs twice per turn (onQueryImpl tail + onQuery finally).
  // Without this guard, both calls pick a tip → two recordShownTip → two
  // saveGlobalConfig writes back-to-back. Reset at submit in onSubmit.
  const tipPickedThisTurnRef = React.useRef(false);
  const pickNewSpinnerTip = useCallback(() => {
    if (tipPickedThisTurnRef.current) return;
    tipPickedThisTurnRef.current = true;
    const newMessages = messagesRef.current.slice(bashToolsProcessedIdx.current);
    for (const tool of extractBashToolsFromMessages(newMessages)) {
      bashTools.current.add(tool);
    }
    bashToolsProcessedIdx.current = messagesRef.current.length;
    void getTipToShowOnSpinner({
      theme,
      readFileState: readFileState.current,
      bashTools: bashTools.current
    }).then(async tip => {
      if (tip) {
        const content = await tip.content({
          theme
        });
        setAppState(prev => ({
          ...prev,
          spinnerTip: content
        }));
        recordShownTip(tip);
      } else {
        setAppState(prev => {
          if (prev.spinnerTip === undefined) return prev;
          return {
            ...prev,
            spinnerTip: undefined
          };
        });
      }
    });
  }, [setAppState, theme]);

  // Resets UI loading state. Does NOT call onTurnComplete - that should be
  // called explicitly only when a query turn actually completes.
  const resetLoadingState = useCallback(() => {
    // isLoading is now derived from queryGuard — no setter call needed.
    // queryGuard.end() (onQuery finally) or cancelReservation() (executeUserInput
    // finally) have already transitioned the guard to idle by the time this runs.
    // External loading (remote/backgrounding) is reset separately by those hooks.
    setIsExternalLoading(false);
    setUserInputOnProcessing(undefined);
    responseLengthRef.current = 0;
    apiMetricsRef.current = [];
    setStreamingText(null);
    setStreamingToolUses([]);
    setSpinnerMessage(null);
    setSpinnerColor(null);
    setSpinnerShimmerColor(null);
    pickNewSpinnerTip();
    endInteractionSpan();
    // Speculative bash classifier checks are only valid for the current
    // turn's commands — clear after each turn to avoid accumulating
    // Promise chains for unconsumed checks (denied/aborted paths).
    clearSpeculativeChecks();
  }, [pickNewSpinnerTip]);

  // Session backgrounding — hook is below, after getToolUseContext

  const hasRunningTeammates = useMemo(() => getAllInProcessTeammateTasks(tasks).some(t => t.status === 'running'), [tasks]);

  // Show deferred turn duration message once all swarm teammates finish
  useEffect(() => {
    if (!hasRunningTeammates && swarmStartTimeRef.current !== null) {
      const totalMs = Date.now() - swarmStartTimeRef.current;
      const deferredBudget = swarmBudgetInfoRef.current;
      swarmStartTimeRef.current = null;
      swarmBudgetInfoRef.current = undefined;
      setMessages(prev => [...prev, createTurnDurationMessage(totalMs, deferredBudget,
      // Count only what recordTranscript will persist — ephemeral
      // progress ticks and non-ant attachments are filtered by
      // isLoggableMessage and never reach disk. Using raw prev.length
      // would make checkResumeConsistency report false delta<0 for
      // every turn that ran a progress-emitting tool.
      count(prev, isLoggableMessage))]);
    }
  }, [hasRunningTeammates, setMessages]);

  // Show auto permissions warning when entering auto mode
  // (either via Shift+Tab toggle or on startup). Debounced to avoid
  // flashing when the user is cycling through modes quickly.
  // Only shown 3 times total across sessions.
  const safeYoloMessageShownRef = useRef(false);
  useEffect(() => {
    if (feature('TRANSCRIPT_CLASSIFIER')) {
      if (toolPermissionContext.mode !== 'auto') {
        safeYoloMessageShownRef.current = false;
        return;
      }
      if (safeYoloMessageShownRef.current) return;
      const config = getGlobalConfig();
      const count = config.autoPermissionsNotificationCount ?? 0;
      if (count >= 3) return;
      const timer = setTimeout((ref, setMessages) => {
        ref.current = true;
        saveGlobalConfig(prev => {
          const prevCount = prev.autoPermissionsNotificationCount ?? 0;
          if (prevCount >= 3) return prev;
          return {
            ...prev,
            autoPermissionsNotificationCount: prevCount + 1
          };
        });
        setMessages(prev => [...prev, createSystemMessage(AUTO_MODE_DESCRIPTION, 'warning')]);
      }, 800, safeYoloMessageShownRef, setMessages);
      return () => clearTimeout(timer);
    }
  }, [toolPermissionContext.mode, setMessages]);

  // If worktree creation was slow and sparse-checkout isn't configured,
  // nudge the user toward settings.worktree.sparsePaths.
  const worktreeTipShownRef = useRef(false);
  useEffect(() => {
    if (worktreeTipShownRef.current) return;
    const wt = getCurrentWorktreeSession();
    if (!wt?.creationDurationMs || wt.usedSparsePaths) return;
    if (wt.creationDurationMs < 15_000) return;
    worktreeTipShownRef.current = true;
    const secs = Math.round(wt.creationDurationMs / 1000);
    setMessages(prev => [...prev, createSystemMessage(`Worktree creation took ${secs}s. For large repos, set \`worktree.sparsePaths\` in .claude/settings.json to check out only the directories you need — e.g. \`{"worktree": {"sparsePaths": ["src", "packages/foo"]}}\`.`, 'info')]);
  }, [setMessages]);

  // Hide spinner when the only in-progress tool is Sleep
  const onlySleepToolActive = useMemo(() => {
    const lastAssistant = messages.findLast(m => m.type === 'assistant');
    if (lastAssistant?.type !== 'assistant') return false;
    const inProgressToolUses = lastAssistant.message.content.filter(b => b.type === 'tool_use' && inProgressToolUseIDs.has(b.id));
    return inProgressToolUses.length > 0 && inProgressToolUses.every(b => b.type === 'tool_use' && b.name === SLEEP_TOOL_NAME);
  }, [messages, inProgressToolUseIDs]);
  const {
    onBeforeQuery: mrOnBeforeQuery,
    onTurnComplete: mrOnTurnComplete,
    render: mrRender
  } = useMoreRight({
    enabled: moreRightEnabled,
    setMessages,
    inputValue,
    setInputValue,
    setToolJSX
  });
  const showSpinner = (!toolJSX || toolJSX.showSpinner === true) && toolUseConfirmQueue.length === 0 && promptQueue.length === 0 && (
  // Show spinner during input processing, API call, while teammates are running,
  // or while pending task notifications are queued (prevents spinner bounce between consecutive notifications)
  isLoading || userInputOnProcessing || hasRunningTeammates ||
  // Keep spinner visible while task notifications are queued for processing.
  // Without this, the spinner briefly disappears between consecutive notifications
  // (e.g., multiple background agents completing in rapid succession) because
  // isLoading goes false momentarily between processing each one.
  getCommandQueueLength() > 0) &&
  // Hide spinner when waiting for leader to approve permission request
  !pendingWorkerRequest && !onlySleepToolActive && (
  // Hide spinner when streaming text is visible (the text IS the feedback),
  // but keep it when isBriefOnly suppresses the streaming text display
  !visibleStreamingText || isBriefOnly);

  // Check if any permission or ask question prompt is currently visible
  // This is used to prevent the survey from opening while prompts are active
  const hasActivePrompt = toolUseConfirmQueue.length > 0 || promptQueue.length > 0 || sandboxPermissionRequestQueue.length > 0 || elicitation.queue.length > 0 || workerSandboxPermissions.queue.length > 0;
  const feedbackSurveyOriginal = useFeedbackSurvey(messages, isLoading, submitCount, 'session', hasActivePrompt);
  const skillImprovementSurvey = useSkillImprovementSurvey(setMessages);
  const showIssueFlagBanner = useIssueFlagBanner(messages, submitCount);

  // Wrap feedback survey handler to trigger auto-run /issue
  const feedbackSurvey = useMemo(() => ({
    ...feedbackSurveyOriginal,
    handleSelect: (selected: '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
  });

  // Memory survey: shown when the assistant mentions memory and a memory file
  // was read this conversation
  const memorySurvey = useMemorySurvey(messages, isLoading, hasActivePrompt, {
    enabled: !isRemoteSession
  });

  // Frustration detection: show transcript sharing prompt after detecting frustrated messages
  const frustrationDetection = useFrustrationDetection(messages, isLoading, hasActivePrompt, feedbackSurvey.state !== 'closed' || postCompactSurvey.state !== 'closed' || memorySurvey.state !== 'closed');

  // Initialize IDE integration
  useIDEIntegration({
    autoConnectIdeFlag,
    ideToInstallExtension,
    setDynamicMcpConfig,
    setShowIdeOnboarding,
    setIDEInstallationState: setIDEInstallationStatus
  });
  useFileHistorySnapshotInit(initialFileHistorySnapshots, fileHistory, fileHistoryState => setAppState(prev => ({
    ...prev,
    fileHistory: fileHistoryState
  })));
  const resume = useCallback(async (sessionId: 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
          /* 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));
      }

      // Restore file history and attribution state from the resumed conversation
      restoreSessionStateFromLog(log, setAppState);
      if (log.fileHistorySnapshots) {
        void copyFileHistoryForResume(log);
      }

      // Restore agent setting from the resumed conversation
      // Always reset to the new session's values (or clear if none),
      // matching the standaloneAgentContext pattern below
      const {
        agentDefinition: restoredAgent
      } = restoreAgentFromSession(log.agentSetting, initialMainThreadAgentDefinition, agentDefinitions);
      setMainThreadAgentDefinition(restoredAgent);
      setAppState(prev => ({
        ...prev,
        agent: restoredAgent?.agentType
      }));

      // Restore standalone agent context from the resumed conversation
      // Always reset to the new session's values (or clear if none)
      setAppState(prev => ({
        ...prev,
        standaloneAgentContext: computeStandaloneAgentContext(log.agentName, log.agentColor)
      }));
      void updateSessionName(log.agentName);

      // Restore read file state from the message history
      restoreReadFileState(messages, log.projectPath ?? getOriginalCwd());

      // Clear any active loading state (no queryId since we're not in a query)
      resetLoadingState();
      setAbortController(null);
      setConversationId(sessionId);

      // Get target session's costs BEFORE saving current session
      // (saveCurrentSessionCosts overwrites the config, so we need to read first)
      const targetSessionCosts = getStoredSessionCosts(sessionId);

      // Save current session's costs before switching to avoid losing accumulated costs
      saveCurrentSessionCosts();

      // Reset cost state for clean slate before restoring target session
      resetCostState();

      // Switch session (id + project dir atomically). fullPath may point to
      // a different project (cross-worktree, /branch); null derives from
      // current originalCwd.
      switchSession(asSessionId(sessionId), log.fullPath ? dirname(log.fullPath) : null);
      // Rename asciicast recording to match the resumed session ID
      const {
        renameRecordingForSession
      } = await import('../utils/asciicast.js');
      await renameRecordingForSession();
      await resetSessionFilePointer();

      // Clear then restore session metadata so it's re-appended on exit via
      // reAppendSessionMetadata. clearSessionMetadata must be called first:
      // restoreSessionMetadata only sets-if-truthy, so without the clear,
      // a session without an agent name would inherit the previous session's
      // cached name and write it to the wrong transcript on first message.
      clearSessionMetadata();
      restoreSessionMetadata(log);
      // Resumed sessions shouldn't re-title from mid-conversation context
      // (same reasoning as the useRef seed), and the previous session's
      // Haiku title shouldn't carry over.
      haikuTitleAttemptedRef.current = true;
      setHaikuTitle(undefined);

      // Exit any worktree a prior /resume entered, then cd into the one
      // this session was in. Without the exit, resuming from worktree B
      // to non-worktree C leaves cwd/currentWorktreeSession stale;
      // resuming B→C where C is also a worktree fails entirely
      // (getCurrentWorktreeSession guard blocks the switch).
      //
      // Skipped for /branch: forkLog doesn't carry worktreeSession, so
      // this would kick the user out of a worktree they're still working
      // in. Same fork skip as processResumedConversation for the adopt —
      // fork materializes its own file via recordTranscript on REPL mount.
      if (entrypoint !== 'fork') {
        exitRestoredWorktree();
        restoreWorktreeForResume(log.worktreeSession);
        adoptResumedSessionFile();
        void restoreRemoteAgentTasks({
          abortController: new AbortController(),
          getAppState: () => store.getState(),
          setAppState
        });
      } else {
        // Fork: same re-persist as /clear (conversation.ts). The clear
        // above wiped currentSessionWorktree, forkLog doesn't carry it,
        // and the process is still in the same worktree.
        const ws = getCurrentWorktreeSession();
        if (ws) saveWorktreeState(ws);
      }

      // Persist the current mode so future resumes know what mode this session was in
      if (feature('COORDINATOR_MODE')) {
        /* eslint-disable @typescript-eslint/no-require-imports */
        const {
          saveMode
        } = require('../utils/sessionStorage.js');
        const {
          isCoordinatorMode
        } = require('../coordinator/coordinatorMode.js') 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);
      }

      // 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;
    }
  }, [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);
  // 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>());
  // 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>());

  // 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);
    }
  }, []);

  // Extract read file state from initialMessages on mount
  // This handles CLI flag resume (--resume-session) and ResumeConversation screen
  // where messages are passed as props rather than through the resume callback
  useEffect(() => {
    if (initialMessages && initialMessages.length > 0) {
      restoreReadFileState(initialMessages, getOriginalCwd());
      void restoreRemoteAgentTasks({
        abortController: new AbortController(),
        getAppState: () => store.getState(),
        setAppState
      });
    }
    // Only run on mount - initialMessages shouldn't change during component lifetime
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, []);
  const {
    status: apiKeyStatus,
    reverify
  } = useApiKeyVerification();

  // Auto-run /issue state
  const [autoRunIssueReason, setAutoRunIssueReason] = useState<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);

  // State for exit feedback flow
  const [exitFlow, setExitFlow] = useState<React.ReactNode>(null);
  const [isExiting, setIsExiting] = useState(false);

  // Calculate if cost dialog should be shown
  const showingCostDialog = !isLoading && showCostDialog;

  // Determine which dialog should have focus (if any)
  // Permission and interactive dialogs can show even when toolJSX is set,
  // as long as shouldContinueAnimation is true. This prevents deadlocks when
  // agents set background hints while waiting for user interaction.
  function getFocusedInputDialog(): '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;

    // High priority dialogs (always show regardless of typing)
    if (isMessageSelectorVisible) return 'message-selector';

    // Suppress interrupt dialogs while user is actively typing
    if (isPromptInputActive) return undefined;
    if (sandboxPermissionRequestQueue[0]) return 'sandbox-permission';

    // Permission/interactive dialogs (show unless blocked by toolJSX)
    const allowDialogsWithAnimation = !toolJSX || toolJSX.shouldContinueAnimation;
    if (allowDialogsWithAnimation && toolUseConfirmQueue[0]) return 'tool-permission';
    if (allowDialogsWithAnimation && promptQueue[0]) return 'prompt';
    // Worker sandbox permission prompts (network access) from swarm workers
    if (allowDialogsWithAnimation && workerSandboxPermissions.queue[0]) return 'worker-sandbox-permission';
    if (allowDialogsWithAnimation && elicitation.queue[0]) return 'elicitation';
    if (allowDialogsWithAnimation && showingCostDialog) return 'cost';
    if (allowDialogsWithAnimation && idleReturnPending) return 'idle-return';
    if (feature('ULTRAPLAN') && allowDialogsWithAnimation && !isLoading && ultraplanPendingChoice) return 'ultraplan-choice';
    if (feature('ULTRAPLAN') && allowDialogsWithAnimation && !isLoading && ultraplanLaunchPending) return 'ultraplan-launch';

    // Onboarding dialogs (special conditions)
    if (allowDialogsWithAnimation && showIdeOnboarding) return 'ide-onboarding';

    // Model switch callout (ant-only, eliminated from external builds)
    if ("external" === 'ant' && allowDialogsWithAnimation && showModelSwitchCallout) return 'model-switch';

    // Undercover auto-enable explainer (ant-only, eliminated from external builds)
    if ("external" === 'ant' && allowDialogsWithAnimation && showUndercoverCallout) return 'undercover-callout';

    // Effort callout (shown once for Opus 4.6 users when effort is enabled)
    if (allowDialogsWithAnimation && showEffortCallout) return 'effort-callout';

    // Remote callout (shown once before first bridge enable)
    if (allowDialogsWithAnimation && showRemoteCallout) return 'remote-callout';

    // LSP plugin recommendation (lowest priority - non-blocking suggestion)
    if (allowDialogsWithAnimation && lspRecommendation) return 'lsp-recommendation';

    // Plugin hint from CLI/SDK stderr (same priority band as LSP rec)
    if (allowDialogsWithAnimation && hintRecommendation) return 'plugin-hint';

    // Desktop app upsell (max 3 launches, lowest priority)
    if (allowDialogsWithAnimation && showDesktopUpsellStartup) return 'desktop-upsell';
    return undefined;
  }
  const focusedInputDialog = getFocusedInputDialog();

  // True when permission prompts exist but are hidden because the user is typing
  const hasSuppressedDialogs = isPromptInputActive && (sandboxPermissionRequestQueue[0] || toolUseConfirmQueue[0] || promptQueue[0] || workerSandboxPermissions.queue[0] || elicitation.queue[0] || showingCostDialog);

  // Keep ref in sync so timer callbacks can read the current value
  focusedInputDialogRef.current = focusedInputDialog;

  // Immediately capture pause/resume when focusedInputDialog changes
  // This ensures accurate timing even under high system load, rather than
  // relying on the 100ms polling interval to detect state changes
  useEffect(() => {
    if (!isLoading) return;
    const isPaused = focusedInputDialog === 'tool-permission';
    const now = Date.now();
    if (isPaused && pauseStartTimeRef.current === null) {
      // Just entered pause state - record the exact moment
      pauseStartTimeRef.current = now;
    } else if (!isPaused && pauseStartTimeRef.current !== null) {
      // Just exited pause state - accumulate paused time immediately
      totalPausedMsRef.current += now - pauseStartTimeRef.current;
      pauseStartTimeRef.current = null;
    }
  }, [focusedInputDialog, isLoading]);

  // Re-pin scroll to bottom whenever the permission overlay appears or
  // dismisses. Overlay now renders below messages inside the same
  // ScrollBox (no remount), so we need an explicit scrollToBottom for:
  //  - appear: user may have been scrolled up (sticky broken) — the
  //    dialog is blocking and must be visible
  //  - dismiss: user may have scrolled up to read context during the
  //    overlay, and onScroll was suppressed so the pill state is stale
  // useLayoutEffect so the re-pin commits before the Ink frame renders —
  // no 1-frame flash of the wrong scroll position.
  const prevDialogRef = useRef(focusedInputDialog);
  useLayoutEffect(() => {
    const was = prevDialogRef.current === 'tool-permission';
    const now = focusedInputDialog === 'tool-permission';
    if (was !== now) repinScroll();
    prevDialogRef.current = focusedInputDialog;
  }, [focusedInputDialog, repinScroll]);
  function onCancel() {
    if (focusedInputDialog === 'elicitation') {
      // Elicitation dialog handles its own Escape, and closing it shouldn't affect any loading state.
      return;
    }
    logForDebugging(`[onCancel] focusedInputDialog=${focusedInputDialog} streamMode=${streamMode}`);

    // Pause proactive mode so the user gets control back.
    // It will resume when they submit their next input (see onSubmit).
    if (feature('PROACTIVE') || feature('KAIROS')) {
      proactiveModule?.pauseProactive();
    }
    queryGuard.forceEnd();
    skipIdleCheckRef.current = false;

    // Preserve partially-streamed text so the user can read what was
    // generated before pressing Esc. Pushed before resetLoadingState clears
    // streamingText, and before query.ts yields the async interrupt marker,
    // giving final order [user, partial-assistant, [Request interrupted by user]].
    if (streamingText?.trim()) {
      setMessages(prev => [...prev, createAssistantMessage({
        content: streamingText
      })]);
    }
    resetLoadingState();

    // Clear any active token budget so the backstop doesn't fire on
    // a stale budget if the query generator hasn't exited yet.
    if (feature('TOKEN_BUDGET')) {
      snapshotOutputTokensForTurn(null);
    }
    if (focusedInputDialog === 'tool-permission') {
      // Tool use confirm handles the abort signal itself
      toolUseConfirmQueue[0]?.onAbort();
      setToolUseConfirmQueue([]);
    } else if (focusedInputDialog === 'prompt') {
      // Reject all pending prompts and clear the queue
      for (const item of promptQueue) {
        item.reject(new Error('Prompt cancelled by user'));
      }
      setPromptQueue([]);
      abortController?.abort('user-cancel');
    } else if (activeRemote.isRemoteMode) {
      // Remote mode: send interrupt signal to CCR
      activeRemote.cancelRequest();
    } else {
      abortController?.abort('user-cancel');
    }

    // Clear the controller so subsequent Escape presses don't see a stale
    // aborted signal. Without this, canCancelRunningTask is false (signal
    // defined but .aborted === true), so isActive becomes false if no other
    // activating conditions hold — leaving the Escape keybinding inactive.
    setAbortController(null);

    // forceEnd() skips the finally path — fire directly (aborted=true).
    void mrOnTurnComplete(messagesRef.current, true);
  }

  // Function to handle queued command when canceling a permission request
  const handleQueuedCommandOnCancel = useCallback(() => {
    const result = popAllEditable(inputValue, 0);
    if (!result) return;
    setInputValue(result.text);
    setInputMode('prompt');

    // Restore images from queued commands to pastedContents
    if (result.images.length > 0) {
      setPastedContents(prev => {
        const newContents = {
          ...prev
        };
        for (const image of result.images) {
          newContents[image.id] = image;
        }
        return newContents;
      });
    }
  }, [setInputValue, setInputMode, inputValue, setPastedContents]);

  // CancelRequestHandler props - rendered inside KeybindingSetup
  const cancelRequestProps = {
    setToolUseConfirmQueue,
    onCancel,
    onAgentsKilled: () => setMessages(prev => [...prev, createAgentsKilledMessage()]),
    isMessageSelectorVisible: isMessageSelectorVisible || !!showBashesDialog,
    screen,
    abortSignal: abortController?.signal,
    popCommandFromQueue: handleQueuedCommandOnCancel,
    vimMode,
    isLocalJSXCommand: toolJSX?.isLocalJSXCommand,
    isSearchingHistory,
    isHelpOpen,
    inputMode,
    inputValue,
    streamMode
  };
  useEffect(() => {
    const totalCost = getTotalCost();
    if (totalCost >= 5 /* $5 */ && !showCostDialog && !haveShownCostDialog) {
      logEvent('tengu_cost_threshold_reached', {});
      // Mark as shown even if the dialog won't render (no console billing
      // access). Otherwise this effect re-fires on every message change for
      // the rest of the session — 200k+ spurious events observed.
      setHaveShownCostDialog(true);
      if (hasConsoleBillingAccess()) {
        setShowCostDialog(true);
      }
    }
  }, [messages, showCostDialog, haveShownCostDialog]);
  const sandboxAskCallback: 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;
        }

        // Register the callback for when the leader responds
        registerSandboxPermissionCallback({
          requestId,
          host: hostPattern.host,
          resolve: resolveShouldAllowHost
        });

        // Update AppState to show pending indicator
        setAppState(prev => ({
          ...prev,
          pendingSandboxRequest: {
            requestId,
            host: hostPattern.host
          }
        }));
      });
    }

    // Normal flow for non-workers: show local UI and optionally race
    // against the REPL bridge (Remote Control) if connected.
    return new Promise(resolveShouldAllowHost => {
      let resolved = false;
      function resolveOnce(allow: 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);
          };
          const existing = sandboxBridgeCleanupRef.current.get(hostPattern.host) ?? [];
          existing.push(cleanup);
          sandboxBridgeCleanupRef.current.set(hostPattern.host, existing);
        }
      }
    });
  }, [setAppState, store]);

  // #34044: if user explicitly set sandbox.enabled=true but deps are missing,
  // isSandboxingEnabled() returns false silently. Surface the reason once at
  // mount so users know their security config isn't being enforced. Full
  // reason goes to debug log; notification points to /sandbox for details.
  // addNotification is stable (useCallback) so the effect fires once.
  useEffect(() => {
    const reason = SandboxManager.getSandboxUnavailableReason();
    if (!reason) return;
    if (SandboxManager.isSandboxRequired()) {
      process.stderr.write(`\nError: sandbox required but unavailable: ${reason}\n` + `  sandbox.failIfUnavailable is set — refusing to start without a working sandbox.\n\n`);
      gracefulShutdownSync(1, 'other');
      return;
    }
    logForDebugging(`sandbox disabled: ${reason}`, {
      level: 'warn'
    });
    addNotification({
      key: 'sandbox-unavailable',
      jsx: <>
          <Text color="warning">sandbox disabled</Text>
          <Text dimColor> · /sandbox</Text>
        </>,
      priority: 'medium'
    });
  }, [addNotification]);
  if (SandboxManager.isSandboxingEnabled()) {
    // If sandboxing is enabled (setting.sandbox is defined, initialise the manager)
    SandboxManager.initialize(sandboxAskCallback).catch(err => {
      // Initialization/validation failed - display error and exit
      process.stderr.write(`\n❌ Sandbox Error: ${errorMessage(err)}\n`);
      gracefulShutdownSync(1, 'other');
    });
  }
  const setToolPermissionContext = useCallback((context: 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'
        },
        // Merge fresh from store rather than closing over useMergedClients'
        // memoized output. initialMcpClients is a prop (session-constant).
        mcpClients: mergeClients(initialMcpClients, s.mcp.clients),
        mcpResources: s.mcp.resources,
        ideInstallationStatus: ideInstallationStatus,
        isNonInteractiveSession: false,
        dynamicMcpConfig,
        theme,
        agentDefinitions: allowedAgentTypes ? {
          ...s.agentDefinitions,
          allowedAgentTypes
        } : s.agentDefinitions,
        customSystemPrompt,
        appendSystemPrompt,
        refreshTools: computeTools
      },
      getAppState: () => store.getState(),
      setAppState,
      messages,
      setMessages,
      updateFileHistoryState(updater: (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, reverify, addNotification, setMessages, onChangeDynamicMcpConfig, resume, requestPrompt, disabled, customSystemPrompt, appendSystemPrompt, setConversationId]);

  // Session backgrounding (Ctrl+B to background/foreground)
  const handleBackgroundQuery = useCallback(() => {
    // Stop the foreground query so the background one takes over
    abortController?.abort('background');
    // Aborting subagents may produce task-completed notifications.
    // Clear task notifications so the queue processor doesn't immediately
    // start a new foreground query; forward them to the background session.
    const removedNotifications = removeByFilter(cmd => cmd.mode === 'task-notification');
    void (async () => {
      const toolUseContext = getToolUseContext(messagesRef.current, [], new AbortController(), mainLoopModel);
      const [defaultSystemPrompt, userContext, systemContext] = await Promise.all([getSystemPrompt(toolUseContext.options.tools, mainLoopModel, Array.from(toolPermissionContext.additionalWorkingDirectories.keys()), toolUseContext.options.mcpClients), getUserContext(), getSystemContext()]);
      const systemPrompt = buildEffectiveSystemPrompt({
        mainThreadAgentDefinition,
        toolUseContext,
        customSystemPrompt,
        defaultSystemPrompt,
        appendSystemPrompt
      });
      toolUseContext.renderedSystemPrompt = systemPrompt;
      const notificationAttachments = await getQueuedCommandAttachments(removedNotifications).catch(() => []);
      const notificationMessages = notificationAttachments.map(createAttachmentMessage);

      // Deduplicate: if the query loop already yielded a notification into
      // messagesRef before we removed it from the queue, skip duplicates.
      // We use prompt text for dedup because source_uuid is not set on
      // task-notification QueuedCommands (enqueuePendingNotification callers
      // don't pass uuid), so it would always be undefined.
      const existingPrompts = new Set<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);
        }
      }
      const uniqueNotifications = notificationMessages.filter(m => m.attachment.type === 'queued_command' && (typeof m.attachment.prompt !== 'string' || !existingPrompts.has(m.attachment.prompt)));
      startBackgroundSession({
        messages: [...messagesRef.current, ...uniqueNotifications],
        queryParams: {
          systemPrompt,
          userContext,
          systemContext,
          canUseTool,
          toolUseContext,
          querySource: getQuerySourceForREPL()
        },
        description: terminalTitle,
        setAppState,
        agentDefinition: mainThreadAgentDefinition
      });
    })();
  }, [abortController, mainLoopModel, toolPermissionContext, mainThreadAgentDefinition, getToolUseContext, customSystemPrompt, appendSystemPrompt, canUseTool, setAppState]);
  const {
    handleBackgroundSession
  } = useSessionBackgrounding({
    setMessages,
    setIsLoading: setIsExternalLoading,
    resetLoadingState,
    setAbortController,
    onBackgroundQuery: handleBackgroundQuery
  });
  const onQueryEvent = useCallback((event: 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;
      }
      return {
        ...prev,
        toolPermissionContext: {
          ...prev.toolPermissionContext,
          alwaysAllowRules: {
            ...prev.toolPermissionContext.alwaysAllowRules,
            command: additionalAllowedTools
          }
        }
      };
    });

    // The last message is an assistant message if the user input was a bash command,
    // or if the user input was an invalid slash command.
    if (!shouldQuery) {
      // Manual /compact sets messages directly (shouldQuery=false) bypassing
      // handleMessageFromStream. Clear context-blocked if a compact boundary
      // is present so proactive ticks resume after compaction.
      if (newMessages.some(isCompactBoundaryMessage)) {
        // Bump conversationId so Messages.tsx row keys change and
        // stale memoized rows remount with post-compact content.
        setConversationId(randomUUID());
        if (feature('PROACTIVE') || feature('KAIROS')) {
          proactiveModule?.setContextBlocked(false);
        }
      }
      resetLoadingState();
      setAbortController(null);
      return;
    }
    const toolUseContext = getToolUseContext(messagesIncludingNewMessages, newMessages, abortController, mainLoopModelParam);
    // getToolUseContext reads tools/mcpClients fresh from store.getState()
    // (via computeTools/mergeClients). Use those rather than the closure-
    // captured `tools`/`mcpClients` — useManageMCPConnections may have
    // flushed new MCP state between the render that captured this closure
    // and now. Turn 1 via processInitialMessage is the main beneficiary.
    const {
      tools: freshTools,
      mcpClients: freshMcpClients
    } = toolUseContext.options;

    // Scope the skill's effort override to this turn's context only —
    // wrapping getAppState keeps the override out of the global store so
    // background agents and UI subscribers (Spinner, LogoV2) never see it.
    if (effort !== undefined) {
      const previousGetAppState = toolUseContext.getAppState;
      toolUseContext.getAppState = () => ({
        ...previousGetAppState(),
        effortValue: effort
      });
    }
    queryCheckpoint('query_context_loading_start');
    const [,, defaultSystemPrompt, baseUserContext, systemContext] = await Promise.all([
    // IMPORTANT: do this after setMessages() above, to avoid UI jank
    checkAndDisableBypassPermissionsIfNeeded(toolPermissionContext, setAppState),
    // Gated on TRANSCRIPT_CLASSIFIER so GrowthBook kill switch runs wherever auto mode is built in
    feature('TRANSCRIPT_CLASSIFIER') ? checkAndDisableAutoModeIfNeeded(toolPermissionContext, setAppState, store.getState().fastMode) : undefined, getSystemPrompt(freshTools, mainLoopModelParam, Array.from(toolPermissionContext.additionalWorkingDirectories.keys()), freshMcpClients), getUserContext(), getSystemContext()]);
    const userContext = {
      ...baseUserContext,
      ...getCoordinatorUserContext(freshMcpClients, isScratchpadEnabled() ? getScratchpadDir() : undefined),
      ...((feature('PROACTIVE') || feature('KAIROS')) && proactiveModule?.isProactiveActive() && !terminalFocusRef.current ? {
        terminalFocus: 'The terminal is unfocused \u2014 the user is not actively watching.'
      } : {})
    };
    queryCheckpoint('query_context_loading_end');
    const systemPrompt = buildEffectiveSystemPrompt({
      mainThreadAgentDefinition,
      toolUseContext,
      customSystemPrompt,
      defaultSystemPrompt,
      appendSystemPrompt
    });
    toolUseContext.renderedSystemPrompt = systemPrompt;
    queryCheckpoint('query_query_start');
    resetTurnHookDuration();
    resetTurnToolDuration();
    resetTurnClassifierDuration();
    for await (const event of query({
      messages: messagesIncludingNewMessages,
      systemPrompt,
      userContext,
      systemContext,
      canUseTool,
      toolUseContext,
      querySource: getQuerySourceForREPL()
    })) {
      onQueryEvent(event);
    }
    if (feature('BUDDY')) {
      void fireCompanionObserver(messagesRef.current, reaction => setAppState(prev => prev.companionReaction === reaction ? prev : {
        ...prev,
        companionReaction: reaction
      }));
    }
    queryCheckpoint('query_end');

    // Capture ant-only API metrics before resetLoadingState clears the ref.
    // For multi-request turns (tool use loops), compute P50 across all requests.
    if ("external" === 'ant' && apiMetricsRef.current.length > 0) {
      const entries = apiMetricsRef.current;
      const ttfts = entries.map(e => e.ttftMs);
      // Compute per-request OTPS using only active streaming time and
      // streaming-only content. endResponseLength tracks content added by
      // streaming deltas only, excluding subagent/compaction inflation.
      const otpsValues = entries.map(e => {
        const delta = Math.round((e.endResponseLength - e.responseLengthBaseline) / 4);
        const samplingMs = e.lastTokenTime - e.firstTokenTime;
        return samplingMs > 0 ? Math.round(delta / (samplingMs / 1000)) : 0;
      });
      const isMultiRequest = entries.length > 1;
      const hookMs = getTurnHookDurationMs();
      const hookCount = getTurnHookCount();
      const toolMs = getTurnToolDurationMs();
      const toolCount = getTurnToolCount();
      const classifierMs = getTurnClassifierDurationMs();
      const classifierCount = getTurnClassifierCount();
      const turnMs = Date.now() - loadingStartTimeRef.current;
      setMessages(prev => [...prev, createApiMetricsMessage({
        ttftMs: isMultiRequest ? median(ttfts) : ttfts[0]!,
        otps: isMultiRequest ? median(otpsValues) : otpsValues[0]!,
        isP50: isMultiRequest,
        hookDurationMs: hookMs > 0 ? hookMs : undefined,
        hookCount: hookCount > 0 ? hookCount : undefined,
        turnDurationMs: turnMs > 0 ? turnMs : undefined,
        toolDurationMs: toolMs > 0 ? toolMs : undefined,
        toolCount: toolCount > 0 ? toolCount : undefined,
        classifierDurationMs: classifierMs > 0 ? classifierMs : undefined,
        classifierCount: classifierCount > 0 ? classifierCount : undefined,
        configWriteCount: getGlobalConfigWriteCount()
      })]);
    }
    resetLoadingState();

    // Log query profiling report if enabled
    logQueryProfileReport();

    // Signal that a query turn has completed successfully
    await onTurnComplete?.(messagesRef.current);
  }, [initialMcpClients, resetLoadingState, getToolUseContext, toolPermissionContext, setAppState, customSystemPrompt, onTurnComplete, appendSystemPrompt, canUseTool, mainThreadAgentDefinition, onQueryEvent, sessionTitle, titleDisabled]);
  const onQuery = useCallback(async (newMessages: 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', {});
        }
      });
      return;
    }
    try {
      // isLoading is derived from queryGuard — tryStart() above already
      // transitioned dispatching→running, so no setter call needed here.
      resetTimingRefs();
      setMessages(oldMessages => [...oldMessages, ...newMessages]);
      responseLengthRef.current = 0;
      if (feature('TOKEN_BUDGET')) {
        const parsedBudget = input ? parseTokenBudget(input) : null;
        snapshotOutputTokensForTurn(parsedBudget ?? getCurrentTurnTokenBudget());
      }
      apiMetricsRef.current = [];
      setStreamingToolUses([]);
      setStreamingText(null);

      // messagesRef is updated synchronously by the setMessages wrapper
      // above, so it already includes newMessages from the append at the
      // top of this try block.  No reconstruction needed, no waiting for
      // React's scheduler (previously cost 20-56ms per prompt; the 56ms
      // case was a GC pause caught during the await).
      const latestMessages = messagesRef.current;
      if (input) {
        await mrOnBeforeQuery(input, latestMessages, newMessages.length);
      }

      // Pass full conversation history to callback
      if (onBeforeQueryCallback && input) {
        const shouldProceed = await onBeforeQueryCallback(input, latestMessages);
        if (!shouldProceed) {
          return;
        }
      }
      await onQueryImpl(latestMessages, newMessages, abortController, shouldQuery, additionalAllowedTools, mainLoopModelParam, effort);
    } finally {
      // queryGuard.end() atomically checks generation and transitions
      // running→idle. Returns false if a newer query owns the guard
      // (cancel+resubmit race where the stale finally fires as a microtask).
      if (queryGuard.end(thisGeneration)) {
        setLastQueryCompletionTime(Date.now());
        skipIdleCheckRef.current = false;
        // Always reset loading state in finally - this ensures cleanup even
        // if onQueryImpl throws. onTurnComplete is called separately in
        // onQueryImpl only on successful completion.
        resetLoadingState();
        await mrOnTurnComplete(messagesRef.current, abortController.signal.aborted);

        // Notify bridge clients that the turn is complete so mobile apps
        // can stop the spark animation and show post-turn UI.
        sendBridgeResultRef.current();

        // Auto-hide tungsten panel content at turn end (ant-only), but keep
        // tungstenActiveSession set so the pill stays in the footer and the user
        // can reopen the panel. Background tmux tasks (e.g. /hunter) run for
        // minutes — wiping the session made the pill disappear entirely, forcing
        // the user to re-invoke Tmux just to peek. Skip on abort so the panel
        // stays open for inspection (matches the turn-duration guard below).
        if ("external" === 'ant' && !abortController.signal.aborted) {
          setAppState(prev => {
            if (prev.tungstenActiveSession === undefined) return prev;
            if (prev.tungstenPanelAutoHidden === true) return prev;
            return {
              ...prev,
              tungstenPanelAutoHidden: true
            };
          });
        }

        // Capture budget info before clearing (ant-only)
        let budgetInfo: {
          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()
            };
          }
          snapshotOutputTokensForTurn(null);
        }

        // Add turn duration message for turns longer than 30s or with a budget
        // Skip if user aborted or if in loop mode (too noisy between ticks)
        // Defer if swarm teammates are still running (show when they finish)
        const turnDurationMs = Date.now() - loadingStartTimeRef.current - totalPausedMsRef.current;
        if ((turnDurationMs > 30000 || budgetInfo !== undefined) && !abortController.signal.aborted && !proactiveActive) {
          const hasRunningSwarmAgents = getAllInProcessTeammateTasks(store.getState().tasks).some(t => t.status === 'running');
          if (hasRunningSwarmAgents) {
            // Only record start time on the first deferred turn
            if (swarmStartTimeRef.current === null) {
              swarmStartTimeRef.current = loadingStartTimeRef.current;
            }
            // Always update budget — later turns may carry the actual budget
            if (budgetInfo) {
              swarmBudgetInfoRef.current = budgetInfo;
            }
          } else {
            setMessages(prev => [...prev, createTurnDurationMessage(turnDurationMs, budgetInfo, count(prev, isLoggableMessage))]);
          }
        }
        // Clear the controller so CancelRequestHandler's canCancelRunningTask
        // reads false at the idle prompt. Without this, the stale non-aborted
        // controller makes ctrl+c fire onCancel() (aborting nothing) instead of
        // propagating to the double-press exit flow.
        setAbortController(null);
      }

      // Auto-restore: if the user interrupted before any meaningful response
      // arrived, rewind the conversation and restore their prompt — same as
      // opening the message selector and picking the last message.
      // This runs OUTSIDE the queryGuard.end() check because onCancel calls
      // forceEnd(), which bumps the generation so end() returns false above.
      // Guards: reason === 'user-cancel' (onCancel/Esc; programmatic aborts
      // use 'background'/'interrupt' and must not rewind — note abort() with
      // no args sets reason to a DOMException, not undefined), !isActive (no
      // newer query started — cancel+resubmit race), empty input (don't
      // clobber text typed during loading), no queued commands (user queued
      // B while A was loading → they've moved on, don't restore A; also
      // avoids removeLastFromHistory removing B's entry instead of A's),
      // not viewing a teammate (messagesRef is the main conversation — the
      // old Up-arrow quick-restore had this guard, preserve it).
      if (abortController.signal.reason === 'user-cancel' && !queryGuard.isActive && inputValueRef.current === '' && getCommandQueueLength() === 0 && !store.getState().viewingAgentTaskId) {
        const msgs = messagesRef.current;
        const lastUserMsg = msgs.findLast(selectableUserMessagesFilter);
        if (lastUserMsg) {
          const idx = msgs.lastIndexOf(lastUserMsg);
          if (messagesAfterAreOnlySynthetic(msgs, idx)) {
            // The submit is being undone — undo its history entry too,
            // otherwise Up-arrow shows the restored text twice.
            removeLastFromHistory();
            restoreMessageSyncRef.current(lastUserMsg);
          }
        }
      }
    }
  }, [onQueryImpl, setAppState, resetLoadingState, queryGuard, mrOnBeforeQuery, mrOnTurnComplete]);

  // Handle initial message (from CLI args or plan mode exit with context clear)
  // This effect runs when isLoading becomes false and there's a pending message
  const initialMessageRef = useRef(false);
  useEffect(() => {
    const pending = initialMessage;
    if (!pending || isLoading || initialMessageRef.current) return;

    // Mark as processing to prevent re-entry
    initialMessageRef.current = true;
    async function processInitialMessage(initialMsg: 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');
        await clearConversation({
          setMessages,
          readFileState: readFileState.current,
          discoveredSkillNames: discoveredSkillNamesRef.current,
          loadedNestedMemoryPaths: loadedNestedMemoryPathsRef.current,
          getAppState: () => store.getState(),
          setAppState,
          setConversationId
        });
        haikuTitleAttemptedRef.current = false;
        setHaikuTitle(undefined);
        bashTools.current.clear();
        bashToolsProcessedIdx.current = 0;

        // Restore the plan slug for the new session so getPlan() finds the file
        if (oldPlanSlug) {
          setPlanSlug(getSessionId(), oldPlanSlug);
        }
      }

      // Atomically: clear initial message, set permission mode and rules, and store plan for verification
      const shouldStorePlanForVerification = initialMsg.message.planContent && "external" === 'ant' && isEnvTruthy(undefined);
      setAppState(prev => {
        // Build and apply permission updates (mode + allowedPrompts rules)
        let updatedToolPermissionContext = initialMsg.mode ? applyPermissionUpdates(prev.toolPermissionContext, buildPermissionUpdates(initialMsg.mode, initialMsg.allowedPrompts)) : prev.toolPermissionContext;
        // For auto, override the mode (buildPermissionUpdates maps
        // it to 'default' via toExternalPermissionMode) and strip dangerous rules
        if (feature('TRANSCRIPT_CLASSIFIER') && initialMsg.mode === 'auto') {
          updatedToolPermissionContext = stripDangerousPermissionsForAutoMode({
            ...updatedToolPermissionContext,
            mode: 'auto',
            prePlanMode: undefined
          });
        }
        return {
          ...prev,
          initialMessage: null,
          toolPermissionContext: updatedToolPermissionContext,
          ...(shouldStorePlanForVerification && {
            pendingPlanVerification: {
              plan: initialMsg.message.planContent!,
              verificationStarted: false,
              verificationCompleted: false
            }
          })
        };
      });

      // Create file history snapshot for code rewind
      if (fileHistoryEnabled()) {
        void fileHistoryMakeSnapshot((updater: (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();

      // Route all initial prompts through onSubmit to ensure UserPromptSubmit hooks fire
      // TODO: Simplify by always routing through onSubmit once it supports
      // ContentBlockParam arrays (images) as input
      const content = initialMsg.message.message.content;

      // Route all string content through onSubmit to ensure hooks fire
      // For complex content (images, etc.), fall back to direct onQuery
      // Plan messages bypass onSubmit to preserve planContent metadata for rendering
      if (typeof content === 'string' && !initialMsg.message.planContent) {
        // Route through onSubmit for proper processing including UserPromptSubmit hooks
        void onSubmit(content, {
          setCursorOffset: () => {},
          clearBuffer: () => {},
          resetHistory: () => {}
        });
      } else {
        // Plan messages or complex content (images, etc.) - send directly to model
        // Plan messages use onQuery to preserve planContent metadata for rendering
        // TODO: Once onSubmit supports ContentBlockParam arrays, remove this branch
        const newAbortController = createAbortController();
        setAbortController(newAbortController);
        void onQuery([initialMsg.message], newAbortController, true,
        // shouldQuery
        [],
        // additionalAllowedTools
        mainLoopModel);
      }

      // Reset ref after a delay to allow new initial messages
      setTimeout(ref => {
        ref.current = false;
      }, 100, initialMessageRef);
    }
    void processInitialMessage(pending);
  }, [initialMessage, isLoading, setMessages, setAppState, onQuery, mainLoopModel, tools]);
  const onSubmit = useCallback(async (input: 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();
    }

    // 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 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);
            }
          };

          // Build context for the command (reuses existing getToolUseContext).
          // Read messages via ref to keep onSubmit stable across message
          // updates — matches the pattern at L2384/L2400/L2662 and avoids
          // pinning stale REPL render scopes in downstream closures.
          const context = getToolUseContext(messagesRef.current, [], createAbortController(), mainLoopModel);
          const mod = await matchingCommand.load();
          const jsx = await mod.call(onDone, context, commandArgs);

          // Skip if onDone already fired — prevents stuck isLocalJSXCommand
          // (see processSlashCommand.tsx local-jsx case for full mechanism).
          if (jsx && !doneWasCalled) {
            // shouldHidePromptInput: false keeps Notifications mounted
            // so the onDone result isn't lost
            setToolJSX({
              jsx,
              shouldHidePromptInput: false,
              isLocalJSXCommand: true
            });
          }
        };
        void executeImmediateCommand();
        return; // Always return early - don't add to history or queue
      }
    }

    // Remote mode: skip empty input early before any state mutations
    if (activeRemote.isRemoteMode && !input.trim()) {
      return;
    }

    // Idle-return: prompt returning users to start fresh when the
    // conversation is large and the cache is cold. tengu_willow_mode
    // controls treatment: "dialog" (blocking), "hint" (notification), "off".
    {
      const willowMode = getFeatureValue_CACHED_MAY_BE_STALE('tengu_willow_mode', 'off');
      const idleThresholdMin = Number(process.env.CLAUDE_CODE_IDLE_THRESHOLD_MINUTES ?? 75);
      const tokenThreshold = Number(process.env.CLAUDE_CODE_IDLE_TOKEN_THRESHOLD ?? 100_000);
      if (willowMode !== 'off' && !getGlobalConfig().idleReturnDismissed && !skipIdleCheckRef.current && !speculationAccept && !input.trim().startsWith('/') && lastQueryCompletionTimeRef.current > 0 && getTotalInputTokens() >= tokenThreshold) {
        const idleMs = Date.now() - lastQueryCompletionTimeRef.current;
        const idleMinutes = idleMs / 60_000;
        if (idleMinutes >= idleThresholdMin && willowMode === 'dialog') {
          setIdleReturnPending({
            input,
            idleMinutes
          });
          setInputValue('');
          helpers.setCursorOffset(0);
          helpers.clearBuffer();
          return;
        }
      }
    }

    // Add to history for direct user submissions.
    // Queued command processing (executeQueuedInput) doesn't call onSubmit,
    // so notifications and already-queued user input won't be added to history here.
    // Skip history for keybinding-triggered commands (user didn't type the command).
    if (!options?.fromKeybinding) {
      addToHistory({
        display: speculationAccept ? input : prependModeCharacterToInput(input, inputMode),
        pastedContents: speculationAccept ? {} : pastedContents
      });
      // Add the just-submitted command to the front of the ghost-text
      // cache so it's suggested immediately (not after the 60s TTL).
      if (inputMode === 'bash') {
        prependToShellHistoryCache(input.trim());
      }
    }

    // Restore stash if present, but NOT for slash commands or when loading.
    // - Slash commands (especially interactive ones like /model, /context) hide
    //   the prompt and show a picker UI. Restoring the stash during a command would
    //   place the text in a hidden input, and the user would lose it by typing the
    //   next command. Instead, preserve the stash so it survives across command runs.
    // - When loading, the submitted input will be queued and handlePromptSubmit
    //   will clear the input field (onInputChange('')), which would clobber the
    //   restored stash. Defer restoration to after handlePromptSubmit (below).
    //   Remote mode is exempt: it sends via WebSocket and returns early without
    //   calling handlePromptSubmit, so there's no clobbering risk — restore eagerly.
    // In both deferred cases, the stash is restored after await handlePromptSubmit.
    const isSlashCommand = !speculationAccept && input.trim().startsWith('/');
    // Submit runs "now" (not queued) when not already loading, or when
    // accepting speculation, or in remote mode (which sends via WS and
    // returns early without calling handlePromptSubmit).
    const submitsNow = !isLoading || speculationAccept || activeRemote.isRemoteMode;
    if (stashedPrompt !== undefined && !isSlashCommand && submitsNow) {
      setInputValue(stashedPrompt.text);
      helpers.setCursorOffset(stashedPrompt.cursorOffset);
      setPastedContents(stashedPrompt.pastedContents);
      setStashedPrompt(undefined);
    } else if (submitsNow) {
      if (!options?.fromKeybinding) {
        // Clear input when not loading or accepting speculation.
        // Preserve input for keybinding-triggered commands.
        setInputValue('');
        helpers.setCursorOffset(0);
      }
      setPastedContents({});
    }
    if (submitsNow) {
      setInputMode('prompt');
      setIDESelection(undefined);
      setSubmitCount(_ => _ + 1);
      helpers.clearBuffer();
      tipPickedThisTurnRef.current = false;

      // Show the placeholder in the same React batch as setInputValue('').
      // Skip for slash/bash (they have their own echo), speculation and remote
      // mode (both setMessages directly with no gap to bridge).
      if (!isSlashCommand && inputMode === 'prompt' && !speculationAccept && !activeRemote.isRemoteMode) {
        setUserInputOnProcessing(input);
        // showSpinner includes userInputOnProcessing, so the spinner appears
        // on this render. Reset timing refs now (before queryGuard.reserve()
        // would) so elapsed time doesn't read as Date.now() - 0. The
        // isQueryActive transition above does the same reset — idempotent.
        resetTimingRefs();
      }

      // Increment prompt count for attribution tracking and save snapshot
      // The snapshot persists promptCount so it survives compaction
      if (feature('COMMIT_ATTRIBUTION')) {
        setAppState(prev => ({
          ...prev,
          attribution: incrementPromptCount(prev.attribution, snapshot => {
            void recordAttributionSnapshot(snapshot).catch(error => {
              logForDebugging(`Attribution: Failed to save snapshot: ${error}`);
            });
          })
        }));
      }
    }

    // Handle speculation acceptance
    if (speculationAccept) {
      const {
        queryRequired
      } = await handleSpeculationAccept(speculationAccept.state, speculationAccept.speculationSessionTimeSavedMs, speculationAccept.setAppState, input, {
        setMessages,
        readFileState,
        cwd: getOriginalCwd()
      });
      if (queryRequired) {
        const newAbortController = createAbortController();
        setAbortController(newAbortController);
        void onQuery([], newAbortController, true, [], mainLoopModel);
      }
      return;
    }

    // Remote mode: send input via stream-json instead of local query.
    // Permission requests from the remote are bridged into toolUseConfirmQueue
    // and rendered using the standard PermissionRequest component.
    //
    // local-jsx slash commands (e.g. /agents, /config) render UI in THIS
    // process — they have no remote equivalent. Let those fall through to
    // handlePromptSubmit so they execute locally. Prompt commands and
    // plain text go to the remote.
    if (activeRemote.isRemoteMode && !(isSlashCommand && commands.find(c => {
      const name = input.trim().slice(1).split(/\s/)[0];
      return isCommandEnabled(c) && (c.name === name || c.aliases?.includes(name!) || getCommandName(c) === name);
    })?.type === 'local-jsx')) {
      // Build content blocks when there are pasted attachments (images)
      const pastedValues = Object.values(pastedContents);
      const imageContents = pastedValues.filter(c => c.type === 'image');
      const imagePasteIds = imageContents.length > 0 ? imageContents.map(c => c.id) : undefined;
      let messageContent: 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;
      }

      // Create and add user message to UI
      // Note: empty input already handled by early return above
      const userMessage = createUserMessage({
        content: messageContent,
        imagePasteIds
      });
      setMessages(prev => [...prev, userMessage]);

      // Send to remote session
      await activeRemote.sendMessage(remoteContent, {
        uuid: userMessage.uuid
      });
      return;
    }

    // Ensure SessionStart hook context is available before the first API call.
    await awaitPendingHooks();
    await handlePromptSubmit({
      input,
      helpers,
      queryGuard,
      isExternalLoading,
      mode: inputMode,
      commands,
      onInputChange: setInputValue,
      setPastedContents,
      setToolJSX,
      getToolUseContext,
      messages: messagesRef.current,
      mainLoopModel,
      pastedContents,
      ideSelection,
      setUserInputOnProcessing,
      setAbortController,
      abortController,
      onQuery,
      setAppState,
      querySource: getQuerySourceForREPL(),
      onBeforeQuery,
      canUseTool,
      addNotification,
      setMessages,
      // Read via ref so streamMode can be dropped from onSubmit deps —
      // handlePromptSubmit only uses it for debug log + telemetry event.
      streamMode: streamModeRef.current,
      hasInterruptibleToolInProgress: hasInterruptibleToolInProgressRef.current
    });

    // Restore stash that was deferred above. Two cases:
    // - Slash command: handlePromptSubmit awaited the full command execution
    //   (including interactive pickers). Restoring now places the stash back in
    //   the visible input.
    // - Loading (queued): handlePromptSubmit enqueued + cleared input, then
    //   returned quickly. Restoring now places the stash back after the clear.
    if ((isSlashCommand || isLoading) && stashedPrompt !== undefined) {
      setInputValue(stashedPrompt.text);
      helpers.setCursorOffset(stashedPrompt.cursorOffset);
      setPastedContents(stashedPrompt.pastedContents);
      setStashedPrompt(undefined);
    }
  }, [queryGuard,
  // isLoading is read at the !isLoading checks above for input-clearing
  // and submitCount gating. It's derived from isQueryActive || isExternalLoading,
  // so including it here ensures the closure captures the fresh value.
  isLoading, isExternalLoading, inputMode, commands, setInputValue, setInputMode, setPastedContents, setSubmitCount, setIDESelection, setToolJSX, getToolUseContext,
  // messages is read via messagesRef.current inside the callback to
  // keep onSubmit stable across message updates (see L2384/L2400/L2662).
  // Without this, each setMessages call (~30× per turn) recreates
  // onSubmit, pinning the REPL render scope (1776B) + that render's
  // messages array in downstream closures (PromptInput, handleAutoRunIssue).
  // Heap analysis showed ~9 REPL scopes and ~15 messages array versions
  // accumulating after #20174/#20175, all traced to this dep.
  mainLoopModel, pastedContents, ideSelection, setUserInputOnProcessing, setAbortController, addNotification, onQuery, stashedPrompt, setStashedPrompt, setAppState, onBeforeQuery, canUseTool, remoteSession, setMessages, awaitPendingHooks, repinScroll]);

  // Callback for when user submits input while viewing a teammate's transcript
  const onAgentSubmit = useCallback(async (input: 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'
          });
        });
      }
    } else {
      injectUserMessageToTeammate(task.id, input, setAppState);
    }
    setInputValue('');
    helpers.setCursorOffset(0);
    helpers.clearBuffer();
  }, [setAppState, setInputValue, getToolUseContext, canUseTool, mainLoopModel, addNotification]);

  // Handlers for auto-run /issue or /good-claude (defined after onSubmit)
  const handleAutoRunIssue = useCallback(() => {
    const command = autoRunIssueReason ? getAutoRunCommand(autoRunIssueReason) : '/issue';
    setAutoRunIssueReason(null); // Clear the state
    onSubmit(command, {
      setCursorOffset: () => {},
      clearBuffer: () => {},
      resetHistory: () => {}
    }).catch(err => {
      logForDebugging(`Auto-run ${command} failed: ${errorMessage(err)}`);
    });
  }, [onSubmit, autoRunIssueReason]);
  const handleCancelAutoRunIssue = useCallback(() => {
    setAutoRunIssueReason(null);
  }, []);

  // Handler for when user presses 1 on survey thanks screen to share details
  const handleSurveyRequestFeedback = useCallback(() => {
    const command = "external" === 'ant' ? '/issue' : '/feedback';
    onSubmit(command, {
      setCursorOffset: () => {},
      clearBuffer: () => {},
      resetHistory: () => {}
    }).catch(err => {
      logForDebugging(`Survey feedback request failed: ${err instanceof Error ? err.message : String(err)}`);
    });
  }, [onSubmit]);

  // onSubmit is unstable (deps include `messages` which changes every turn).
  // `handleOpenRateLimitOptions` is prop-drilled to every MessageRow, and each
  // MessageRow fiber pins the closure (and transitively the entire REPL render
  // scope, ~1.8KB) at mount time. Using a ref keeps this callback stable so
  // old REPL scopes can be GC'd — saves ~35MB over a 1000-turn session.
  const onSubmitRef = useRef(onSubmit);
  onSubmitRef.current = onSubmit;
  const handleOpenRateLimitOptions = useCallback(() => {
    void onSubmitRef.current('/rate-limit-options', {
      setCursorOffset: () => {},
      clearBuffer: () => {},
      resetHistory: () => {}
    });
  }, []);
  const handleExit = useCallback(async () => {
    setIsExiting(true);
    // In bg sessions, always detach instead of kill — even when a worktree is
    // active. Without this guard, the worktree branch below short-circuits into
    // ExitFlow (which calls gracefulShutdown) before exit.tsx is ever loaded.
    if (feature('BG_SESSIONS') && isBgSession()) {
      spawnSync('tmux', ['detach-client'], {
        stdio: 'ignore'
      });
      setIsExiting(false);
      return;
    }
    const showWorktree = getCurrentWorktreeSession() !== null;
    if (showWorktree) {
      setExitFlow(<ExitFlow showWorktree onDone={() => {}} onCancel={() => {
        setExitFlow(null);
        setIsExiting(false);
      }} />);
      return;
    }
    const exitMod = await exit.load();
    const exitFlowResult = await exitMod.call(() => {});
    setExitFlow(exitFlowResult);
    // If call() returned without killing the process (bg session detach),
    // clear isExiting so the UI is usable on reattach. No-op on the normal
    // path — gracefulShutdown's process.exit() means we never get here.
    if (exitFlowResult === null) {
      setIsExiting(false);
    }
  }, []);
  const handleShowMessageSelector = useCallback(() => {
    setIsMessageSelectorVisible(prev => !prev);
  }, []);

  // Rewind conversation state to just before `message`: slice messages,
  // reset conversation ID, microcompact state, permission mode, prompt suggestion.
  // Does NOT touch the prompt input. Index is computed from messagesRef (always
  // fresh via the setMessages wrapper) so callers don't need to worry about
  // stale closures.
  const rewindConversationTo = useCallback((message: 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
      }
    }));
  }, [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);
    }

    // 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;

  // 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]);

  // 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 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
      });
    }),
    edit: async msg => {
      // Same skip-confirm check as /rewind: lossless → direct, else confirm dialog.
      const rawIdx = findRawIndex(msg.uuid);
      const raw = rawIdx >= 0 ? messages[rawIdx] : undefined;
      if (!raw || !selectableUserMessagesFilter(raw)) return;
      const noFileChanges = !(await fileHistoryHasAnyChanges(fileHistory, raw.uuid));
      const onlySynthetic = messagesAfterAreOnlySynthetic(messages, rawIdx);
      if (noFileChanges && onlySynthetic) {
        // rewindConversationTo's setMessages races stream appends — cancel first (idempotent).
        onCancel();
        // handleRestoreMessage also restores pasted images.
        void handleRestoreMessage(raw);
      } else {
        // Dialog path: onPreRestore (= onCancel) fires when user CONFIRMS, not on nevermind.
        setMessageSelectorPreselect(raw);
        setIsMessageSelectorVisible(true);
      }
    }
  };
  const {
    enter: enterMessageActions,
    handlers: messageActionHandlers
  } = useMessageActions(cursor, setCursor, cursorNavRef, messageActionCaps);
  async function onInit() {
    // Always verify API key on startup, so we can show the user an error in the
    // bottom right corner of the screen if the API key is invalid.
    void reverify();

    // Populate readFileState with CLAUDE.md files at startup
    const memoryFiles = await getMemoryFiles();
    if (memoryFiles.length > 0) {
      const fileList = memoryFiles.map(f => `  [${f.type}] ${f.path} (${f.content.length} chars)${f.parent ? ` (included by ${f.parent})` : ''}`).join('\n');
      logForDebugging(`Loaded ${memoryFiles.length} CLAUDE.md/rules files:\n${fileList}`);
    } else {
      logForDebugging('No CLAUDE.md/rules files found');
    }
    for (const file of memoryFiles) {
      // When the injected content doesn't match disk (stripped HTML comments,
      // stripped frontmatter, MEMORY.md truncation), cache the RAW disk bytes
      // with isPartialView so Edit/Write require a real Read first while
      // getChangedFiles + nested_memory dedup still work.
      readFileState.current.set(file.path, {
        content: file.contentDiffersFromDisk ? file.rawContent ?? file.content : file.content,
        timestamp: Date.now(),
        offset: undefined,
        limit: undefined,
        isPartialView: file.contentDiffersFromDisk
      });
    }

    // Initial message handling is done via the initialMessage effect
  }

  // Register cost summary tracker
  useCostSummary(useFpsMetrics());

  // Record transcripts locally, for debugging and conversation recovery
  // Don't record conversation if we only have initial messages; optimizes
  // the case where user resumes a conversation then quites before doing
  // anything else
  useLogMessages(messages, messages.length === initialMessages?.length);

  // REPL Bridge: replicate user/assistant messages to the bridge session
  // for remote access via claude.ai. No-op in external builds or when not enabled.
  const {
    sendBridgeResult
  } = useReplBridge(messages, setMessages, abortControllerRef, commands, mainLoopModel);
  sendBridgeResultRef.current = sendBridgeResult;
  useAfterFirstRender();

  // Track prompt queue usage for analytics. Fire once per transition from
  // empty to non-empty, not on every length change -- otherwise a render loop
  // (concurrent onQuery thrashing, etc.) spams saveGlobalConfig, which hits
  // ELOCKED under concurrent sessions and falls back to unlocked writes.
  // That write storm is the primary trigger for ~/.claude.json corruption
  // (GH #3117).
  const hasCountedQueueUseRef = useRef(false);
  useEffect(() => {
    if (queuedCommands.length < 1) {
      hasCountedQueueUseRef.current = false;
      return;
    }
    if (hasCountedQueueUseRef.current) return;
    hasCountedQueueUseRef.current = true;
    saveGlobalConfig(current => ({
      ...current,
      promptQueueUseCount: (current.promptQueueUseCount ?? 0) + 1
    }));
  }, [queuedCommands.length]);

  // Process queued commands when query completes and queue has items

  const executeQueuedInput = useCallback(async (queuedCommands: 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, setToolJSX, getToolUseContext, messages, mainLoopModel, ideSelection, setUserInputOnProcessing, canUseTool, setAbortController, onQuery, addNotification, setAppState, onBeforeQuery]);
  useQueueProcessor({
    executeQueuedInput,
    hasActiveLocalJsxUI: isShowingLocalJSXCommand,
    queryGuard
  });

  // We'll use the global lastInteractionTime from state.ts

  // Update last interaction time when input changes.
  // Must be immediate because useEffect runs after the Ink render cycle flush.
  useEffect(() => {
    activityManager.recordUserActivity();
    updateLastInteractionTime(true);
  }, [inputValue, submitCount]);
  useEffect(() => {
    if (submitCount === 1) {
      startBackgroundHousekeeping();
    }
  }, [submitCount]);

  // Show notification when Claude is done responding and user is idle
  useEffect(() => {
    // Don't set up notification if Claude is busy
    if (isLoading) return;

    // Only enable notifications after the first new interaction in this session
    if (submitCount === 0) return;

    // No query has completed yet
    if (lastQueryCompletionTime === 0) return;

    // Set timeout to check idle state
    const timer = setTimeout((lastQueryCompletionTime, isLoading, toolJSX, focusedInputDialogRef, terminal) => {
      // Check if user has interacted since the response ended
      const lastUserInteraction = getLastInteractionTime();
      if (lastUserInteraction > lastQueryCompletionTime) {
        // User has interacted since Claude finished - they're not idle, don't notify
        return;
      }

      // User hasn't interacted since response ended, check other conditions
      const idleTimeSinceResponse = Date.now() - lastQueryCompletionTime;
      if (!isLoading && !toolJSX &&
      // Use ref to get current dialog state, avoiding stale closure
      focusedInputDialogRef.current === undefined && idleTimeSinceResponse >= getGlobalConfig().messageIdleNotifThresholdMs) {
        void sendNotification({
          message: 'Claude is waiting for your input',
          notificationType: 'idle_prompt'
        }, terminal);
      }
    }, getGlobalConfig().messageIdleNotifThresholdMs, lastQueryCompletionTime, isLoading, toolJSX, focusedInputDialogRef, terminal);
    return () => clearTimeout(timer);
  }, [isLoading, toolJSX, submitCount, lastQueryCompletionTime, terminal]);

  // Idle-return hint: show notification when idle threshold is exceeded.
  // Timer fires after the configured idle period; notification persists until
  // dismissed or the user submits.
  useEffect(() => {
    if (lastQueryCompletionTime === 0) return;
    if (isLoading) return;
    const willowMode: 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">
                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);
    return () => {
      clearTimeout(timer);
      removeNotification('idle-return-hint');
      idleHintShownRef.current = false;
    };
  }, [lastQueryCompletionTime, isLoading, addNotification, removeNotification]);

  // Submits incoming prompts from teammate messages or tasks mode as new turns
  // Returns true if submission succeeded, false if a query is already running
  const handleIncomingPrompt = useCallback((content: 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
  };
  useInboxPoller({
    enabled: isAgentSwarmsEnabled(),
    isLoading,
    focusedInputDialog,
    onSubmitMessage: handleIncomingPrompt
  });
  useMailboxBridge({
    isLoading,
    onSubmitMessage: handleIncomingPrompt
  });

  // Scheduled tasks from .claude/scheduled_tasks.json (CronCreate/Delete/List)
  if (feature('AGENT_TRIGGERS')) {
    // Assistant mode bypasses the isLoading gate (the proactive tick →
    // Sleep → tick loop would otherwise starve the scheduler).
    // kairosEnabled is set once in initialState (main.tsx) and never mutated — no
    // subscription needed. The tengu_kairos_cron runtime gate is checked inside
    // useScheduledTasks's effect (not here) since wrapping a hook call in a dynamic
    // condition would break rules-of-hooks.
    const assistantMode = store.getState().kairosEnabled;
    // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
    useScheduledTasks!({
      isLoading,
      assistantMode,
      setMessages
    });
  }

  // Note: Permission polling is now handled by useInboxPoller
  // - Workers receive permission responses via mailbox messages
  // - Leaders receive permission requests via mailbox messages

  if ("external" === 'ant') {
    // Tasks mode: watch for tasks and auto-process them
    // eslint-disable-next-line react-hooks/rules-of-hooks
    // biome-ignore lint/correctness/useHookAtTopLevel: conditional for dead code elimination in external builds
    useTaskListWatcher({
      taskListId,
      isLoading,
      onSubmitTask: handleIncomingPrompt
    });

    // Loop mode: auto-tick when enabled (via /job command)
    // eslint-disable-next-line react-hooks/rules-of-hooks
    // biome-ignore lint/correctness/useHookAtTopLevel: conditional for dead code elimination in external builds
    useProactive?.({
      // Suppress ticks while an initial message is pending — the initial
      // message will be processed asynchronously and a premature tick would
      // race with it, causing concurrent-query enqueue of expanded skill text.
      isLoading: isLoading || initialMessage !== null,
      queuedCommandsLength: queuedCommands.length,
      hasActiveLocalJsxUI: isShowingLocalJSXCommand,
      isInPlanMode: toolPermissionContext.mode === 'plan',
      onSubmitTick: (prompt: 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');
    }
  }, [queuedCommands]);

  // Initial load
  useEffect(() => {
    void onInit();

    // Cleanup on unmount
    return () => {
      void diagnosticTracker.shutdown();
    };
    // TODO: fix this
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, []);

  // Listen for suspend/resume events
  const {
    internal_eventEmitter
  } = useStdin();
  const [remountKey, setRemountKey] = useState(0);
  useEffect(() => {
    const handleSuspend = () => {
      // Print suspension instructions
      process.stdout.write(`\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);
    return () => {
      internal_eventEmitter?.off('suspend', handleSuspend);
      internal_eventEmitter?.off('resume', handleResume);
    };
  }, [internal_eventEmitter]);

  // Derive stop hook spinner suffix from messages state
  const stopHookSpinnerSuffix = useMemo(() => {
    if (!isLoading) return null;

    // Find stop hook progress messages
    const progressMsgs = messages.filter((m): m 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;

    // Check if there's already a summary message for this execution (hooks completed)
    const hasSummaryForCurrentExecution = messages.some(m => m.type === 'system' && m.subtype === 'stop_hook_summary' && m.toolUseID === currentToolUseID);
    if (hasSummaryForCurrentExecution) return null;
    const currentHooks = progressMsgs.filter(p => p.toolUseID === currentToolUseID);
    const total = currentHooks.length;

    // Count completed hooks
    const completedCount = count(messages, m => {
      if (m.type !== 'attachment') return false;
      const attachment = m.attachment;
      return 'hookEvent' in attachment && (attachment.hookEvent === 'Stop' || attachment.hookEvent === 'SubagentStop') && 'toolUseID' in attachment && attachment.toolUseID === currentToolUseID;
    });

    // Check if any hook has a custom status message
    const customMessage = currentHooks.find(p => p.data.statusMessage)?.data.statusMessage;
    if (customMessage) {
      // Use custom message with progress counter if multiple hooks
      return total === 1 ? `${customMessage}…` : `${customMessage}… ${completedCount}/${total}`;
    }

    // Fall back to default behavior
    const hookType = currentHooks[0]?.data.hookEvent === 'SubagentStop' ? 'subagent stop' : 'stop';
    if ("external" === 'ant') {
      const cmd = currentHooks[completedCount]?.data.command;
      const label = cmd ? ` '${truncateToWidth(cmd, 40)}'` : '';
      return total === 1 ? `running ${hookType} hook${label}` : `running ${hookType} hook${label}\u2026 ${completedCount}/${total}`;
    }
    return total === 1 ? `running ${hookType} hook` : `running stop hooks… ${completedCount}/${total}`;
  }, [messages, isLoading]);

  // Callback to capture frozen state when entering transcript mode
  const handleEnterTranscript = useCallback(() => {
    setFrozenTranscriptState({
      messagesLength: messages.length,
      streamingToolUsesLength: streamingToolUses.length
    });
  }, [messages.length, streamingToolUses.length]);

  // Callback to clear frozen state when exiting transcript mode
  const handleExitTranscript = useCallback(() => {
    setFrozenTranscriptState(null);
  }, []);

  // Props for GlobalKeybindingHandlers component (rendered inside KeybindingSetup)
  const virtualScrollActive = isFullscreenEnvEnabled() && !disableVirtualScroll;

  // Transcript search state. Hooks must be unconditional so they live here
  // (not inside the `if (screen === 'transcript')` branch below); isActive
  // gates the useInput. Query persists across bar open/close so n/N keep
  // working after Enter dismisses the bar (less semantics).
  const jumpRef = useRef<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();

  // Resize → abort search. Positions are (msg, query, WIDTH)-keyed —
  // cached positions are stale after a width change (new layout, new
  // wrapping). Clearing searchQuery triggers VML's setSearchQuery('')
  // which clears positionsCache + setPositions(null). Bar closes.
  // User hits / again → fresh everything.
  const transcriptCols = useTerminalSize().columns;
  const prevColsRef = React.useRef(transcriptCols);
  React.useEffect(() => {
    if (prevColsRef.current !== transcriptCols) {
      prevColsRef.current = transcriptCols;
      if (searchQuery || searchOpen) {
        setSearchOpen(false);
        setSearchQuery('');
        setSearchCount(0);
        setSearchCurrent(0);
        jumpRef.current?.disarmSearch();
        setHighlight('');
      }
    }
  }, [transcriptCols, searchQuery, searchOpen, setHighlight]);

  // Transcript escape hatches. Bare letters in modal context (no prompt
  // competing for input) — same class as g/G/j/k in ScrollKeybindingHandler.
  useInput((input, key, event) => {
    if (key.ctrl || key.meta) return;
    if (input === 'q') {
      // less: q quits the pager. ctrl+o toggles; q is the lineage exit.
      handleExitTranscript();
      event.stopImmediatePropagation();
      return;
    }
    if (input === '[' && !dumpMode) {
      // Force dump-to-scrollback. Also expand + uncap — no point dumping
      // a subset. Terminal/tmux cmd-F can now find anything. Guard here
      // (not in isActive) so v still works post-[ — dump-mode footer at
      // ~4898 wires editorStatus, confirming v is meant to stay live.
      setDumpMode(true);
      setShowAllInTranscript(true);
      event.stopImmediatePropagation();
    } else if (input === 'v') {
      // less-style: v opens the file in $VISUAL/$EDITOR. Render the full
      // transcript (same path /export uses), write to tmp, hand off.
      // openFileInExternalEditor handles alt-screen suspend/resume for
      // terminal editors; GUI editors spawn detached.
      event.stopImmediatePropagation();
      // Drop double-taps: the render is async and a second press before it
      // completes would run a second parallel render (double memory, two
      // tempfiles, two editor spawns). editorGenRef only guards
      // transcript-exit staleness, not same-session concurrency.
      if (editorRenderingRef.current) return;
      editorRenderingRef.current = true;
      // Capture generation + make a staleness-aware setter. Each write
      // checks gen (transcript exit bumps it → late writes from the
      // async render go silent).
      const gen = editorGenRef.current;
      const setStatus = (s: 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)}`);
        }
        editorRenderingRef.current = false;
        if (gen !== editorGenRef.current) return;
        editorTimerRef.current = setTimeout(s => s(''), 4000, setEditorStatus);
      })();
    }
  },
  // !searchOpen: typing 'v' or '[' in the search bar is search input, not
  // a command. No !dumpMode here — v should work after [ (the [ handler
  // guards itself inline).
  {
    isActive: screen === 'transcript' && virtualScrollActive && !searchOpen
  });

  // Fresh `less` per transcript entry. Prevents stale highlights matching
  // unrelated normal-mode text (overlay is alt-screen-global) and avoids
  // surprise n/N on re-entry. Same exit resets [ dump mode — each ctrl+o
  // entry is a fresh instance.
  const inTranscript = screen === 'transcript' && virtualScrollActive;
  useEffect(() => {
    if (!inTranscript) {
      setSearchQuery('');
      setSearchCount(0);
      setSearchCurrent(0);
      setSearchOpen(false);
      editorGenRef.current++;
      clearTimeout(editorTimerRef.current);
      setDumpMode(false);
      setEditorStatus('');
    }
  }, [inTranscript]);
  useEffect(() => {
    setHighlight(inTranscript ? searchQuery : '');
    // Clear the position-based CURRENT (yellow) overlay too. setHighlight
    // only clears the scan-based inverse. Without this, the yellow box
    // persists at its last screen coords after ctrl-c exits transcript.
    if (!inTranscript) setPositions(null);
  }, [inTranscript, searchQuery, setHighlight, setPositions]);
  const globalKeybindingProps = {
    screen,
    setScreen,
    showAllInTranscript,
    setShowAllInTranscript,
    messageCount: messages.length,
    onEnterTranscript: handleEnterTranscript,
    onExitTranscript: handleExitTranscript,
    virtualScrollActive,
    // Bar-open is a mode (owns keystrokes — j/k type, Esc cancels).
    // Navigating (query set, bar closed) is NOT — Esc exits transcript,
    // same as less q with highlights still visible. useSearchInput
    // doesn't stopPropagation, so without this gate transcript:exit
    // would fire on the same Esc that cancels the bar (child registers
    // first, fires first, bubbles).
    searchBarOpen: searchOpen
  };

  // Use frozen lengths to slice arrays, avoiding memory overhead of cloning
  const transcriptMessages = frozenTranscriptState ? deferredMessages.slice(0, frozenTranscriptState.messagesLength) : deferredMessages;
  const transcriptStreamingToolUses = frozenTranscriptState ? streamingToolUses.slice(0, frozenTranscriptState.streamingToolUsesLength) : streamingToolUses;

  // Handle shift+down for teammate navigation and background task management.
  // Guard onOpenBackgroundTasks when a local-jsx dialog (e.g. /mcp) is open —
  // otherwise Shift+Down stacks BackgroundTasksDialog on top and deadlocks input.
  useBackgroundTaskNavigation({
    onOpenBackgroundTasks: isShowingLocalJSXCommand ? undefined : () => setShowBashesDialog(true)
  });
  // Auto-exit viewing mode when teammate completes or errors
  useTeammateViewAutoExit();
  if (screen === 'transcript') {
    // Virtual scroll replaces the 30-message cap: everything is scrollable
    // and memory is bounded by the viewport. Without it, wrapping transcript
    // in a ScrollBox would mount all messages (~250 MB on long sessions —
    // the exact problem), so the kill switch and non-fullscreen paths must
    // fall through to the legacy render: no alt screen, dump to terminal
    // scrollback, 30-cap + Ctrl+E. Reusing scrollRef is safe — normal-mode
    // and transcript-mode are mutually exclusive (this early return), so
    // only one ScrollBox is ever mounted at a time.
    const transcriptScrollRef = isFullscreenEnvEnabled() && !disableVirtualScroll && !dumpMode ? scrollRef : undefined;
    const transcriptMessagesElement = <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} />
        <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}
        <CancelRequestHandler {...cancelRequestProps} />
        {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} />} /> : <>
            {transcriptMessagesElement}
            {transcriptToolJSX}
            <SandboxViolationExpandedView />
            <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,
    // scrollTop pins at 0, and Ink's screen buffer sizes to the full
    // spacer (200×5k+ rows on long sessions). Same root type + props as
    // normal mode's wrap below so React reconciles and the alt buffer
    // stays entered across toggle. The 30-cap dump branch stays
    // unwrapped — it wants native terminal scrollback.
    if (transcriptScrollRef) {
      return <AlternateScreen mouseTracking={isMouseTrackingEnabled()}>
          {transcriptReturn}
        </AlternateScreen>;
    }
    return transcriptReturn;
  }

  // Get viewed agent task (inlined from selectors for explicit data flow).
  // viewedAgentTask: teammate OR local_agent — drives the boolean checks
  // below. viewedTeammateTask: teammate-only narrowed, for teammate-specific
  // field access (inProgressToolUseIDs).
  const viewedTask = viewingAgentTaskId ? tasks[viewingAgentTaskId] : undefined;
  const viewedTeammateTask = viewedTask && isInProcessTeammateTask(viewedTask) ? viewedTask : undefined;
  const viewedAgentTask = viewedTeammateTask ?? (viewedTask && isLocalAgentTask(viewedTask) ? viewedTask : undefined);

  // Bypass useDeferredValue when streaming text is showing so Messages renders
  // the final message in the same frame streaming text clears. Also bypass when
  // not loading — deferredMessages only matters during streaming (keeps input
  // responsive); after the turn ends, showing messages immediately prevents a
  // jitter gap where the spinner is gone but the answer hasn't appeared yet.
  // Only reducedMotion users keep the deferred path during loading.
  const usesSyncMessages = showStreamingText || !isLoading;
  // When viewing an agent, never fall through to leader — empty until
  // bootstrap/stream fills. Closes the see-leader-type-agent footgun.
  const displayedMessages = viewedAgentTask ? viewedAgentTask.messages ?? [] : usesSyncMessages ? messages : deferredMessages;
  // Show the placeholder until the real user message appears in
  // displayedMessages. userInputOnProcessing stays set for the whole turn
  // (cleared in resetLoadingState); this length check hides it once
  // displayedMessages grows past the baseline captured at submit time.
  // Covers both gaps: before setMessages is called (processUserInput), and
  // while deferredMessages lags behind messages. Suppressed when viewing an
  // agent — displayedMessages is a different array there, and onAgentSubmit
  // doesn't use the placeholder anyway.
  const placeholderText = userInputOnProcessing && !viewedAgentTask && displayedMessages.length <= userInputBaselineRef.current ? userInputOnProcessing : undefined;
  const toolPermissionOverlay = focusedInputDialog === 'tool-permission' ? <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;
  // Hide the sprite when PromptInput early-returns BackgroundTasksDialog.
  // The sprite sits as a row sibling of PromptInput, so the dialog's Pane
  // divider draws at useTerminalSize() width but only gets terminalWidth -
  // spriteWidth — divider stops short and dialog text wraps early. Don't
  // check footerSelection: pill FOCUS (arrow-down to tasks pill) must keep
  // the sprite visible so arrow-right can navigate to it.
  const companionVisible = !toolJSX?.shouldHidePromptInput && !focusedInputDialog && !showBashesDialog;

  // In fullscreen, ALL local-jsx slash commands float in the modal slot —
  // FullscreenLayout wraps them in an absolute-positioned bottom-anchored
  // pane (▔ divider, ModalContext). Pane/Dialog inside detect the context
  // and skip their own top-level frame. Non-fullscreen keeps the inline
  // render paths below. Commands that used to route through bottom
  // (immediate: /model, /mcp, /btw, ...) and scrollable (non-immediate:
  // /config, /theme, /diff, ...) both go here now.
  const toolJsxCentered = isFullscreenEnvEnabled() && toolJSX?.isLocalJSXCommand === true;
  const centeredModal: 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} />
      <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} />
      {/* 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.
          PgUp/PgDn/wheel always scroll the transcript behind the modal —
          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}
      <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={<>
              <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} />
              <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%">
                    {toolJSX.jsx}
                  </Box>}
              {"external" === 'ant' && <TungstenLiveMonitor />}
              {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 />}
              {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}
              <Box flexDirection="column" flexGrow={1}>
                {permissionStickyFooter}
                {/* Immediate local-jsx commands (/btw, /sandbox, /assistant,
                  /issue) render here, NOT inside scrollable. They stay mounted
                  while the main conversation streams behind them, so ScrollBox
                  relayouts on each new message would drag them around. bottom
                  is flexShrink={0} outside the ScrollBox — it never moves.
                  Non-immediate local-jsx (/diff, /status, /theme, ~40 others)
                  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.jsx}
                    </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);
          }} />}
                {/* Show pending indicator on worker while waiting for leader approval */}
                {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}`} />}
                {/* 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
                })
              };
            });
          }} />}

                {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}

                {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} />}
                      {/* Frustration-triggered transcript sharing prompt */}
                      {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} />}
                      {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);
          }} />}
                {"external" === 'ant' && <DevBar />}
              </Box>
              {feature('BUDDY') && !(companionNarrow && isFullscreenEnvEnabled()) && companionVisible ? <CompanionSprite /> : null}
            </Box>} />
      </MCPConnectionManager>
    </KeybindingSetup>;
  if (isFullscreenEnvEnabled()) {
    return <AlternateScreen mouseTracking={isMouseTrackingEnabled()}>
        {mainReturn}
      </AlternateScreen>;
  }
  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":[]}
