1  // These side-effects must run before all other imports:
   2  // 1. profileCheckpoint marks entry before heavy module evaluation begins
   3  // 2. startMdmRawRead fires MDM subprocesses (plutil/reg query) so they run in
   4  //    parallel with the remaining ~135ms of imports below
   5  // 3. startKeychainPrefetch fires both macOS keychain reads (OAuth + legacy API
   6  //    key) in parallel — isRemoteManagedSettingsEligible() otherwise reads them
   7  //    sequentially via sync spawn inside applySafeConfigEnvironmentVariables()
   8  //    (~65ms on every macOS startup)
   9  import { profileCheckpoint, profileReport } from './utils/startupProfiler.js';
  10  
  11  // eslint-disable-next-line custom-rules/no-top-level-side-effects
  12  profileCheckpoint('main_tsx_entry');
  13  import { startMdmRawRead } from './utils/settings/mdm/rawRead.js';
  14  
  15  // eslint-disable-next-line custom-rules/no-top-level-side-effects
  16  startMdmRawRead();
  17  import { ensureKeychainPrefetchCompleted, startKeychainPrefetch } from './utils/secureStorage/keychainPrefetch.js';
  18  
  19  // eslint-disable-next-line custom-rules/no-top-level-side-effects
  20  startKeychainPrefetch();
  21  import { feature } from 'bun:bundle';
  22  import { Command as CommanderCommand, InvalidArgumentError, Option } from '@commander-js/extra-typings';
  23  import chalk from 'chalk';
  24  import { readFileSync } from 'fs';
  25  import mapValues from 'lodash-es/mapValues.js';
  26  import pickBy from 'lodash-es/pickBy.js';
  27  import uniqBy from 'lodash-es/uniqBy.js';
  28  import React from 'react';
  29  import { getOauthConfig } from './constants/oauth.js';
  30  import { getRemoteSessionUrl } from './constants/product.js';
  31  import { getSystemContext, getUserContext } from './context.js';
  32  import { init, initializeTelemetryAfterTrust } from './entrypoints/init.js';
  33  import { addToHistory } from './history.js';
  34  import type { Root } from './ink.js';
  35  import { launchRepl } from './replLauncher.js';
  36  import { hasGrowthBookEnvOverride, initializeGrowthBook, refreshGrowthBookAfterAuthChange } from './services/analytics/growthbook.js';
  37  import { fetchBootstrapData } from './services/api/bootstrap.js';
  38  import { type DownloadResult, downloadSessionFiles, type FilesApiConfig, parseFileSpecs } from './services/api/filesApi.js';
  39  import { prefetchPassesEligibility } from './services/api/referral.js';
  40  import { prefetchOfficialMcpUrls } from './services/mcp/officialRegistry.js';
  41  import type { McpSdkServerConfig, McpServerConfig, ScopedMcpServerConfig } from './services/mcp/types.js';
  42  import { isPolicyAllowed, loadPolicyLimits, refreshPolicyLimits, waitForPolicyLimitsToLoad } from './services/policyLimits/index.js';
  43  import { loadRemoteManagedSettings, refreshRemoteManagedSettings } from './services/remoteManagedSettings/index.js';
  44  import type { ToolInputJSONSchema } from './Tool.js';
  45  import { createSyntheticOutputTool, isSyntheticOutputToolEnabled } from './tools/SyntheticOutputTool/SyntheticOutputTool.js';
  46  import { getTools } from './tools.js';
  47  import { canUserConfigureAdvisor, getInitialAdvisorSetting, isAdvisorEnabled, isValidAdvisorModel, modelSupportsAdvisor } from './utils/advisor.js';
  48  import { isAgentSwarmsEnabled } from './utils/agentSwarmsEnabled.js';
  49  import { count, uniq } from './utils/array.js';
  50  import { installAsciicastRecorder } from './utils/asciicast.js';
  51  import { getSubscriptionType, isClaudeAISubscriber, prefetchAwsCredentialsAndBedRockInfoIfSafe, prefetchGcpCredentialsIfSafe, validateForceLoginOrg } from './utils/auth.js';
  52  import { checkHasTrustDialogAccepted, getGlobalConfig, getRemoteControlAtStartup, isAutoUpdaterDisabled, saveGlobalConfig } from './utils/config.js';
  53  import { seedEarlyInput, stopCapturingEarlyInput } from './utils/earlyInput.js';
  54  import { getInitialEffortSetting, parseEffortValue } from './utils/effort.js';
  55  import { getInitialFastModeSetting, isFastModeEnabled, prefetchFastModeStatus, resolveFastModeStatusFromCache } from './utils/fastMode.js';
  56  import { applyConfigEnvironmentVariables } from './utils/managedEnv.js';
  57  import { createSystemMessage, createUserMessage } from './utils/messages.js';
  58  import { getPlatform } from './utils/platform.js';
  59  import { getBaseRenderOptions } from './utils/renderOptions.js';
  60  import { getSessionIngressAuthToken } from './utils/sessionIngressAuth.js';
  61  import { settingsChangeDetector } from './utils/settings/changeDetector.js';
  62  import { skillChangeDetector } from './utils/skills/skillChangeDetector.js';
  63  import { jsonParse, writeFileSync_DEPRECATED } from './utils/slowOperations.js';
  64  import { computeInitialTeamContext } from './utils/swarm/reconnection.js';
  65  import { initializeWarningHandler } from './utils/warningHandler.js';
  66  import { isWorktreeModeEnabled } from './utils/worktreeModeEnabled.js';
  67  
  68  // Lazy require to avoid circular dependency: teammate.ts -> AppState.tsx -> ... -> main.tsx
  69  /* eslint-disable @typescript-eslint/no-require-imports */
  70  const getTeammateUtils = () => require('./utils/teammate.js') as typeof import('./utils/teammate.js');
  71  const getTeammatePromptAddendum = () => require('./utils/swarm/teammatePromptAddendum.js') as typeof import('./utils/swarm/teammatePromptAddendum.js');
  72  const getTeammateModeSnapshot = () => require('./utils/swarm/backends/teammateModeSnapshot.js') as typeof import('./utils/swarm/backends/teammateModeSnapshot.js');
  73  /* eslint-enable @typescript-eslint/no-require-imports */
  74  // Dead code elimination: conditional import for COORDINATOR_MODE
  75  /* eslint-disable @typescript-eslint/no-require-imports */
  76  const coordinatorModeModule = feature('COORDINATOR_MODE') ? require('./coordinator/coordinatorMode.js') as typeof import('./coordinator/coordinatorMode.js') : null;
  77  /* eslint-enable @typescript-eslint/no-require-imports */
  78  // Dead code elimination: conditional import for KAIROS (assistant mode)
  79  /* eslint-disable @typescript-eslint/no-require-imports */
  80  const assistantModule = feature('KAIROS') ? require('./assistant/index.js') as typeof import('./assistant/index.js') : null;
  81  const kairosGate = feature('KAIROS') ? require('./assistant/gate.js') as typeof import('./assistant/gate.js') : null;
  82  import { relative, resolve } from 'path';
  83  import { isAnalyticsDisabled } from 'src/services/analytics/config.js';
  84  import { getFeatureValue_CACHED_MAY_BE_STALE } from 'src/services/analytics/growthbook.js';
  85  import { type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, logEvent } from 'src/services/analytics/index.js';
  86  import { initializeAnalyticsGates } from 'src/services/analytics/sink.js';
  87  import { getOriginalCwd, setAdditionalDirectoriesForClaudeMd, setIsRemoteMode, setMainLoopModelOverride, setMainThreadAgentType, setTeleportedSessionInfo } from './bootstrap/state.js';
  88  import { filterCommandsForRemoteMode, getCommands } from './commands.js';
  89  import type { StatsStore } from './context/stats.js';
  90  import { launchAssistantInstallWizard, launchAssistantSessionChooser, launchInvalidSettingsDialog, launchResumeChooser, launchSnapshotUpdateDialog, launchTeleportRepoMismatchDialog, launchTeleportResumeWrapper } from './dialogLaunchers.js';
  91  import { SHOW_CURSOR } from './ink/termio/dec.js';
  92  import { exitWithError, exitWithMessage, getRenderContext, renderAndRun, showSetupScreens } from './interactiveHelpers.js';
  93  import { initBuiltinPlugins } from './plugins/bundled/index.js';
  94  /* eslint-enable @typescript-eslint/no-require-imports */
  95  import { checkQuotaStatus } from './services/claudeAiLimits.js';
  96  import { getMcpToolsCommandsAndResources, prefetchAllMcpResources } from './services/mcp/client.js';
  97  import { VALID_INSTALLABLE_SCOPES, VALID_UPDATE_SCOPES } from './services/plugins/pluginCliCommands.js';
  98  import { initBundledSkills } from './skills/bundled/index.js';
  99  import type { AgentColorName } from './tools/AgentTool/agentColorManager.js';
 100  import { getActiveAgentsFromList, getAgentDefinitionsWithOverrides, isBuiltInAgent, isCustomAgent, parseAgentsFromJson } from './tools/AgentTool/loadAgentsDir.js';
 101  import type { LogOption } from './types/logs.js';
 102  import type { Message as MessageType } from './types/message.js';
 103  import { assertMinVersion } from './utils/autoUpdater.js';
 104  import { CLAUDE_IN_CHROME_SKILL_HINT, CLAUDE_IN_CHROME_SKILL_HINT_WITH_WEBBROWSER } from './utils/claudeInChrome/prompt.js';
 105  import { setupClaudeInChrome, shouldAutoEnableClaudeInChrome, shouldEnableClaudeInChrome } from './utils/claudeInChrome/setup.js';
 106  import { getContextWindowForModel } from './utils/context.js';
 107  import { loadConversationForResume } from './utils/conversationRecovery.js';
 108  import { buildDeepLinkBanner } from './utils/deepLink/banner.js';
 109  import { hasNodeOption, isBareMode, isEnvTruthy, isInProtectedNamespace } from './utils/envUtils.js';
 110  import { refreshExampleCommands } from './utils/exampleCommands.js';
 111  import type { FpsMetrics } from './utils/fpsTracker.js';
 112  import { getWorktreePaths } from './utils/getWorktreePaths.js';
 113  import { findGitRoot, getBranch, getIsGit, getWorktreeCount } from './utils/git.js';
 114  import { getGhAuthStatus } from './utils/github/ghAuthStatus.js';
 115  import { safeParseJSON } from './utils/json.js';
 116  import { logError } from './utils/log.js';
 117  import { getModelDeprecationWarning } from './utils/model/deprecation.js';
 118  import { getDefaultMainLoopModel, getUserSpecifiedModelSetting, normalizeModelStringForAPI, parseUserSpecifiedModel } from './utils/model/model.js';
 119  import { ensureModelStringsInitialized } from './utils/model/modelStrings.js';
 120  import { PERMISSION_MODES } from './utils/permissions/PermissionMode.js';
 121  import { checkAndDisableBypassPermissions, getAutoModeEnabledStateIfCached, initializeToolPermissionContext, initialPermissionModeFromCLI, isDefaultPermissionModeAuto, parseToolListFromCLI, removeDangerousPermissions, stripDangerousPermissionsForAutoMode, verifyAutoModeGateAccess } from './utils/permissions/permissionSetup.js';
 122  import { cleanupOrphanedPluginVersionsInBackground } from './utils/plugins/cacheUtils.js';
 123  import { initializeVersionedPlugins } from './utils/plugins/installedPluginsManager.js';
 124  import { getManagedPluginNames } from './utils/plugins/managedPlugins.js';
 125  import { getGlobExclusionsForPluginCache } from './utils/plugins/orphanedPluginFilter.js';
 126  import { getPluginSeedDirs } from './utils/plugins/pluginDirectories.js';
 127  import { countFilesRoundedRg } from './utils/ripgrep.js';
 128  import { processSessionStartHooks, processSetupHooks } from './utils/sessionStart.js';
 129  import { cacheSessionTitle, getSessionIdFromLog, loadTranscriptFromFile, saveAgentSetting, saveMode, searchSessionsByCustomTitle, sessionIdExists } from './utils/sessionStorage.js';
 130  import { ensureMdmSettingsLoaded } from './utils/settings/mdm/settings.js';
 131  import { getInitialSettings, getManagedSettingsKeysForLogging, getSettingsForSource, getSettingsWithErrors } from './utils/settings/settings.js';
 132  import { resetSettingsCache } from './utils/settings/settingsCache.js';
 133  import type { ValidationError } from './utils/settings/validation.js';
 134  import { DEFAULT_TASKS_MODE_TASK_LIST_ID, TASK_STATUSES } from './utils/tasks.js';
 135  import { logPluginLoadErrors, logPluginsEnabledForSession } from './utils/telemetry/pluginTelemetry.js';
 136  import { logSkillsLoaded } from './utils/telemetry/skillLoadedEvent.js';
 137  import { generateTempFilePath } from './utils/tempfile.js';
 138  import { validateUuid } from './utils/uuid.js';
 139  // Plugin startup checks are now handled non-blockingly in REPL.tsx
 140  
 141  import { registerMcpAddCommand } from 'src/commands/mcp/addCommand.js';
 142  import { registerMcpXaaIdpCommand } from 'src/commands/mcp/xaaIdpCommand.js';
 143  import { logPermissionContextForAnts } from 'src/services/internalLogging.js';
 144  import { fetchClaudeAIMcpConfigsIfEligible } from 'src/services/mcp/claudeai.js';
 145  import { clearServerCache } from 'src/services/mcp/client.js';
 146  import { areMcpConfigsAllowedWithEnterpriseMcpConfig, dedupClaudeAiMcpServers, doesEnterpriseMcpConfigExist, filterMcpServersByPolicy, getClaudeCodeMcpConfigs, getMcpServerSignature, parseMcpConfig, parseMcpConfigFromFilePath } from 'src/services/mcp/config.js';
 147  import { excludeCommandsByServer, excludeResourcesByServer } from 'src/services/mcp/utils.js';
 148  import { isXaaEnabled } from 'src/services/mcp/xaaIdpLogin.js';
 149  import { getRelevantTips } from 'src/services/tips/tipRegistry.js';
 150  import { logContextMetrics } from 'src/utils/api.js';
 151  import { CLAUDE_IN_CHROME_MCP_SERVER_NAME, isClaudeInChromeMCPServer } from 'src/utils/claudeInChrome/common.js';
 152  import { registerCleanup } from 'src/utils/cleanupRegistry.js';
 153  import { eagerParseCliFlag } from 'src/utils/cliArgs.js';
 154  import { createEmptyAttributionState } from 'src/utils/commitAttribution.js';
 155  import { countConcurrentSessions, registerSession, updateSessionName } from 'src/utils/concurrentSessions.js';
 156  import { getCwd } from 'src/utils/cwd.js';
 157  import { logForDebugging, setHasFormattedOutput } from 'src/utils/debug.js';
 158  import { errorMessage, getErrnoCode, isENOENT, TeleportOperationError, toError } from 'src/utils/errors.js';
 159  import { getFsImplementation, safeResolvePath } from 'src/utils/fsOperations.js';
 160  import { gracefulShutdown, gracefulShutdownSync } from 'src/utils/gracefulShutdown.js';
 161  import { setAllHookEventsEnabled } from 'src/utils/hooks/hookEvents.js';
 162  import { refreshModelCapabilities } from 'src/utils/model/modelCapabilities.js';
 163  import { peekForStdinData, writeToStderr } from 'src/utils/process.js';
 164  import { setCwd } from 'src/utils/Shell.js';
 165  import { type ProcessedResume, processResumedConversation } from 'src/utils/sessionRestore.js';
 166  import { parseSettingSourcesFlag } from 'src/utils/settings/constants.js';
 167  import { plural } from 'src/utils/stringUtils.js';
 168  import { type ChannelEntry, getInitialMainLoopModel, getIsNonInteractiveSession, getSdkBetas, getSessionId, getUserMsgOptIn, setAllowedChannels, setAllowedSettingSources, setChromeFlagOverride, setClientType, setCwdState, setDirectConnectServerUrl, setFlagSettingsPath, setInitialMainLoopModel, setInlinePlugins, setIsInteractive, setKairosActive, setOriginalCwd, setQuestionPreviewFormat, setSdkBetas, setSessionBypassPermissionsMode, setSessionPersistenceDisabled, setSessionSource, setUserMsgOptIn, switchSession } from './bootstrap/state.js';
 169  
 170  /* eslint-disable @typescript-eslint/no-require-imports */
 171  const autoModeStateModule = feature('TRANSCRIPT_CLASSIFIER') ? require('./utils/permissions/autoModeState.js') as typeof import('./utils/permissions/autoModeState.js') : null;
 172  
 173  // TeleportRepoMismatchDialog, TeleportResumeWrapper dynamically imported at call sites
 174  import { migrateAutoUpdatesToSettings } from './migrations/migrateAutoUpdatesToSettings.js';
 175  import { migrateBypassPermissionsAcceptedToSettings } from './migrations/migrateBypassPermissionsAcceptedToSettings.js';
 176  import { migrateEnableAllProjectMcpServersToSettings } from './migrations/migrateEnableAllProjectMcpServersToSettings.js';
 177  import { migrateFennecToOpus } from './migrations/migrateFennecToOpus.js';
 178  import { migrateLegacyOpusToCurrent } from './migrations/migrateLegacyOpusToCurrent.js';
 179  import { migrateOpusToOpus1m } from './migrations/migrateOpusToOpus1m.js';
 180  import { migrateReplBridgeEnabledToRemoteControlAtStartup } from './migrations/migrateReplBridgeEnabledToRemoteControlAtStartup.js';
 181  import { migrateSonnet1mToSonnet45 } from './migrations/migrateSonnet1mToSonnet45.js';
 182  import { migrateSonnet45ToSonnet46 } from './migrations/migrateSonnet45ToSonnet46.js';
 183  import { resetAutoModeOptInForDefaultOffer } from './migrations/resetAutoModeOptInForDefaultOffer.js';
 184  import { resetProToOpusDefault } from './migrations/resetProToOpusDefault.js';
 185  import { createRemoteSessionConfig } from './remote/RemoteSessionManager.js';
 186  /* eslint-enable @typescript-eslint/no-require-imports */
 187  // teleportWithProgress dynamically imported at call site
 188  import { createDirectConnectSession, DirectConnectError } from './server/createDirectConnectSession.js';
 189  import { initializeLspServerManager } from './services/lsp/manager.js';
 190  import { shouldEnablePromptSuggestion } from './services/PromptSuggestion/promptSuggestion.js';
 191  import { type AppState, getDefaultAppState, IDLE_SPECULATION_STATE } from './state/AppStateStore.js';
 192  import { onChangeAppState } from './state/onChangeAppState.js';
 193  import { createStore } from './state/store.js';
 194  import { asSessionId } from './types/ids.js';
 195  import { filterAllowedSdkBetas } from './utils/betas.js';
 196  import { isInBundledMode, isRunningWithBun } from './utils/bundledMode.js';
 197  import { logForDiagnosticsNoPII } from './utils/diagLogs.js';
 198  import { filterExistingPaths, getKnownPathsForRepo } from './utils/githubRepoPathMapping.js';
 199  import { clearPluginCache, loadAllPluginsCacheOnly } from './utils/plugins/pluginLoader.js';
 200  import { migrateChangelogFromConfig } from './utils/releaseNotes.js';
 201  import { SandboxManager } from './utils/sandbox/sandbox-adapter.js';
 202  import { fetchSession, prepareApiRequest } from './utils/teleport/api.js';
 203  import { checkOutTeleportedSessionBranch, processMessagesForTeleportResume, teleportToRemoteWithErrorHandling, validateGitState, validateSessionRepository } from './utils/teleport.js';
 204  import { shouldEnableThinkingByDefault, type ThinkingConfig } from './utils/thinking.js';
 205  import { initUser, resetUserCache } from './utils/user.js';
 206  import { getTmuxInstallInstructions, isTmuxAvailable, parsePRReference } from './utils/worktree.js';
 207  
 208  // eslint-disable-next-line custom-rules/no-top-level-side-effects
 209  profileCheckpoint('main_tsx_imports_loaded');
 210  
 211  /**
 212   * Log managed settings keys to Statsig for analytics.
 213   * This is called after init() completes to ensure settings are loaded
 214   * and environment variables are applied before model resolution.
 215   */
 216  function logManagedSettings(): void {
 217    try {
 218      const policySettings = getSettingsForSource('policySettings');
 219      if (policySettings) {
 220        const allKeys = getManagedSettingsKeysForLogging(policySettings);
 221        logEvent('tengu_managed_settings_loaded', {
 222          keyCount: allKeys.length,
 223          keys: allKeys.join(',') as unknown as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
 224        });
 225      }
 226    } catch {
 227      // Silently ignore errors - this is just for analytics
 228    }
 229  }
 230  
 231  // Check if running in debug/inspection mode
 232  function isBeingDebugged() {
 233    const isBun = isRunningWithBun();
 234  
 235    // Check for inspect flags in process arguments (including all variants)
 236    const hasInspectArg = process.execArgv.some(arg => {
 237      if (isBun) {
 238        // Note: Bun has an issue with single-file executables where application arguments
 239        // from process.argv leak into process.execArgv (similar to https://github.com/oven-sh/bun/issues/11673)
 240        // This breaks use of --debug mode if we omit this branch
 241        // We're fine to skip that check, because Bun doesn't support Node.js legacy --debug or --debug-brk flags
 242        return /--inspect(-brk)?/.test(arg);
 243      } else {
 244        // In Node.js, check for both --inspect and legacy --debug flags
 245        return /--inspect(-brk)?|--debug(-brk)?/.test(arg);
 246      }
 247    });
 248  
 249    // Check if NODE_OPTIONS contains inspect flags
 250    const hasInspectEnv = process.env.NODE_OPTIONS && /--inspect(-brk)?|--debug(-brk)?/.test(process.env.NODE_OPTIONS);
 251  
 252    // Check if inspector is available and active (indicates debugging)
 253    try {
 254      // Dynamic import would be better but is async - use global object instead
 255      // eslint-disable-next-line @typescript-eslint/no-explicit-any
 256      const inspector = (global as any).require('inspector');
 257      const hasInspectorUrl = !!inspector.url();
 258      return hasInspectorUrl || hasInspectArg || hasInspectEnv;
 259    } catch {
 260      // Ignore error and fall back to argument detection
 261      return hasInspectArg || hasInspectEnv;
 262    }
 263  }
 264  
 265  // Exit if we detect node debugging or inspection
 266  if ("external" !== 'ant' && isBeingDebugged()) {
 267    // Use process.exit directly here since we're in the top-level code before imports
 268    // and gracefulShutdown is not yet available
 269    // eslint-disable-next-line custom-rules/no-top-level-side-effects
 270    process.exit(1);
 271  }
 272  
 273  /**
 274   * Per-session skill/plugin telemetry. Called from both the interactive path
 275   * and the headless -p path (before runHeadless) — both go through
 276   * main.tsx but branch before the interactive startup path, so it needs two
 277   * call sites here rather than one here + one in QueryEngine.
 278   */
 279  function logSessionTelemetry(): void {
 280    const model = parseUserSpecifiedModel(getInitialMainLoopModel() ?? getDefaultMainLoopModel());
 281    void logSkillsLoaded(getCwd(), getContextWindowForModel(model, getSdkBetas()));
 282    void loadAllPluginsCacheOnly().then(({
 283      enabled,
 284      errors
 285    }) => {
 286      const managedNames = getManagedPluginNames();
 287      logPluginsEnabledForSession(enabled, managedNames, getPluginSeedDirs());
 288      logPluginLoadErrors(errors, managedNames);
 289    }).catch(err => logError(err));
 290  }
 291  function getCertEnvVarTelemetry(): Record<string, boolean> {
 292    const result: Record<string, boolean> = {};
 293    if (process.env.NODE_EXTRA_CA_CERTS) {
 294      result.has_node_extra_ca_certs = true;
 295    }
 296    if (process.env.CLAUDE_CODE_CLIENT_CERT) {
 297      result.has_client_cert = true;
 298    }
 299    if (hasNodeOption('--use-system-ca')) {
 300      result.has_use_system_ca = true;
 301    }
 302    if (hasNodeOption('--use-openssl-ca')) {
 303      result.has_use_openssl_ca = true;
 304    }
 305    return result;
 306  }
 307  async function logStartupTelemetry(): Promise<void> {
 308    if (isAnalyticsDisabled()) return;
 309    const [isGit, worktreeCount, ghAuthStatus] = await Promise.all([getIsGit(), getWorktreeCount(), getGhAuthStatus()]);
 310    logEvent('tengu_startup_telemetry', {
 311      is_git: isGit,
 312      worktree_count: worktreeCount,
 313      gh_auth_status: ghAuthStatus as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
 314      sandbox_enabled: SandboxManager.isSandboxingEnabled(),
 315      are_unsandboxed_commands_allowed: SandboxManager.areUnsandboxedCommandsAllowed(),
 316      is_auto_bash_allowed_if_sandbox_enabled: SandboxManager.isAutoAllowBashIfSandboxedEnabled(),
 317      auto_updater_disabled: isAutoUpdaterDisabled(),
 318      prefers_reduced_motion: getInitialSettings().prefersReducedMotion ?? false,
 319      ...getCertEnvVarTelemetry()
 320    });
 321  }
 322  
 323  // @[MODEL LAUNCH]: Consider any migrations you may need for model strings. See migrateSonnet1mToSonnet45.ts for an example.
 324  // Bump this when adding a new sync migration so existing users re-run the set.
 325  const CURRENT_MIGRATION_VERSION = 11;
 326  function runMigrations(): void {
 327    if (getGlobalConfig().migrationVersion !== CURRENT_MIGRATION_VERSION) {
 328      migrateAutoUpdatesToSettings();
 329      migrateBypassPermissionsAcceptedToSettings();
 330      migrateEnableAllProjectMcpServersToSettings();
 331      resetProToOpusDefault();
 332      migrateSonnet1mToSonnet45();
 333      migrateLegacyOpusToCurrent();
 334      migrateSonnet45ToSonnet46();
 335      migrateOpusToOpus1m();
 336      migrateReplBridgeEnabledToRemoteControlAtStartup();
 337      if (feature('TRANSCRIPT_CLASSIFIER')) {
 338        resetAutoModeOptInForDefaultOffer();
 339      }
 340      if ("external" === 'ant') {
 341        migrateFennecToOpus();
 342      }
 343      saveGlobalConfig(prev => prev.migrationVersion === CURRENT_MIGRATION_VERSION ? prev : {
 344        ...prev,
 345        migrationVersion: CURRENT_MIGRATION_VERSION
 346      });
 347    }
 348    // Async migration - fire and forget since it's non-blocking
 349    migrateChangelogFromConfig().catch(() => {
 350      // Silently ignore migration errors - will retry on next startup
 351    });
 352  }
 353  
 354  /**
 355   * Prefetch system context (including git status) only when it's safe to do so.
 356   * Git commands can execute arbitrary code via hooks and config (e.g., core.fsmonitor,
 357   * diff.external), so we must only run them after trust is established or in
 358   * non-interactive mode where trust is implicit.
 359   */
 360  function prefetchSystemContextIfSafe(): void {
 361    const isNonInteractiveSession = getIsNonInteractiveSession();
 362  
 363    // In non-interactive mode (--print), trust dialog is skipped and
 364    // execution is considered trusted (as documented in help text)
 365    if (isNonInteractiveSession) {
 366      logForDiagnosticsNoPII('info', 'prefetch_system_context_non_interactive');
 367      void getSystemContext();
 368      return;
 369    }
 370  
 371    // In interactive mode, only prefetch if trust has already been established
 372    const hasTrust = checkHasTrustDialogAccepted();
 373    if (hasTrust) {
 374      logForDiagnosticsNoPII('info', 'prefetch_system_context_has_trust');
 375      void getSystemContext();
 376    } else {
 377      logForDiagnosticsNoPII('info', 'prefetch_system_context_skipped_no_trust');
 378    }
 379    // Otherwise, don't prefetch - wait for trust to be established first
 380  }
 381  
 382  /**
 383   * Start background prefetches and housekeeping that are NOT needed before first render.
 384   * These are deferred from setup() to reduce event loop contention and child process
 385   * spawning during the critical startup path.
 386   * Call this after the REPL has been rendered.
 387   */
 388  export function startDeferredPrefetches(): void {
 389    // This function runs after first render, so it doesn't block the initial paint.
 390    // However, the spawned processes and async work still contend for CPU and event
 391    // loop time, which skews startup benchmarks (CPU profiles, time-to-first-render
 392    // measurements). Skip all of it when we're only measuring startup performance.
 393    if (isEnvTruthy(process.env.CLAUDE_CODE_EXIT_AFTER_FIRST_RENDER) ||
 394    // --bare: skip ALL prefetches. These are cache-warms for the REPL's
 395    // first-turn responsiveness (initUser, getUserContext, tips, countFiles,
 396    // modelCapabilities, change detectors). Scripted -p calls don't have a
 397    // "user is typing" window to hide this work in — it's pure overhead on
 398    // the critical path.
 399    isBareMode()) {
 400      return;
 401    }
 402  
 403    // Process-spawning prefetches (consumed at first API call, user is still typing)
 404    void initUser();
 405    void getUserContext();
 406    prefetchSystemContextIfSafe();
 407    void getRelevantTips();
 408    if (isEnvTruthy(process.env.CLAUDE_CODE_USE_BEDROCK) && !isEnvTruthy(process.env.CLAUDE_CODE_SKIP_BEDROCK_AUTH)) {
 409      void prefetchAwsCredentialsAndBedRockInfoIfSafe();
 410    }
 411    if (isEnvTruthy(process.env.CLAUDE_CODE_USE_VERTEX) && !isEnvTruthy(process.env.CLAUDE_CODE_SKIP_VERTEX_AUTH)) {
 412      void prefetchGcpCredentialsIfSafe();
 413    }
 414    void countFilesRoundedRg(getCwd(), AbortSignal.timeout(3000), []);
 415  
 416    // Analytics and feature flag initialization
 417    void initializeAnalyticsGates();
 418    void prefetchOfficialMcpUrls();
 419    void refreshModelCapabilities();
 420  
 421    // File change detectors deferred from init() to unblock first render
 422    void settingsChangeDetector.initialize();
 423    if (!isBareMode()) {
 424      void skillChangeDetector.initialize();
 425    }
 426  
 427    // Event loop stall detector — logs when the main thread is blocked >500ms
 428    if ("external" === 'ant') {
 429      void import('./utils/eventLoopStallDetector.js').then(m => m.startEventLoopStallDetector());
 430    }
 431  }
 432  function loadSettingsFromFlag(settingsFile: string): void {
 433    try {
 434      const trimmedSettings = settingsFile.trim();
 435      const looksLikeJson = trimmedSettings.startsWith('{') && trimmedSettings.endsWith('}');
 436      let settingsPath: string;
 437      if (looksLikeJson) {
 438        // It's a JSON string - validate and create temp file
 439        const parsedJson = safeParseJSON(trimmedSettings);
 440        if (!parsedJson) {
 441          process.stderr.write(chalk.red('Error: Invalid JSON provided to --settings\n'));
 442          process.exit(1);
 443        }
 444  
 445        // Create a temporary file and write the JSON to it.
 446        // Use a content-hash-based path instead of random UUID to avoid
 447        // busting the Anthropic API prompt cache. The settings path ends up
 448        // in the Bash tool's sandbox denyWithinAllow list, which is part of
 449        // the tool description sent to the API. A random UUID per subprocess
 450        // changes the tool description on every query() call, invalidating
 451        // the cache prefix and causing a 12x input token cost penalty.
 452        // The content hash ensures identical settings produce the same path
 453        // across process boundaries (each SDK query() spawns a new process).
 454        settingsPath = generateTempFilePath('claude-settings', '.json', {
 455          contentHash: trimmedSettings
 456        });
 457        writeFileSync_DEPRECATED(settingsPath, trimmedSettings, 'utf8');
 458      } else {
 459        // It's a file path - resolve and validate by attempting to read
 460        const {
 461          resolvedPath: resolvedSettingsPath
 462        } = safeResolvePath(getFsImplementation(), settingsFile);
 463        try {
 464          readFileSync(resolvedSettingsPath, 'utf8');
 465        } catch (e) {
 466          if (isENOENT(e)) {
 467            process.stderr.write(chalk.red(`Error: Settings file not found: ${resolvedSettingsPath}\n`));
 468            process.exit(1);
 469          }
 470          throw e;
 471        }
 472        settingsPath = resolvedSettingsPath;
 473      }
 474      setFlagSettingsPath(settingsPath);
 475      resetSettingsCache();
 476    } catch (error) {
 477      if (error instanceof Error) {
 478        logError(error);
 479      }
 480      process.stderr.write(chalk.red(`Error processing settings: ${errorMessage(error)}\n`));
 481      process.exit(1);
 482    }
 483  }
 484  function loadSettingSourcesFromFlag(settingSourcesArg: string): void {
 485    try {
 486      const sources = parseSettingSourcesFlag(settingSourcesArg);
 487      setAllowedSettingSources(sources);
 488      resetSettingsCache();
 489    } catch (error) {
 490      if (error instanceof Error) {
 491        logError(error);
 492      }
 493      process.stderr.write(chalk.red(`Error processing --setting-sources: ${errorMessage(error)}\n`));
 494      process.exit(1);
 495    }
 496  }
 497  
 498  /**
 499   * Parse and load settings flags early, before init()
 500   * This ensures settings are filtered from the start of initialization
 501   */
 502  function eagerLoadSettings(): void {
 503    profileCheckpoint('eagerLoadSettings_start');
 504    // Parse --settings flag early to ensure settings are loaded before init()
 505    const settingsFile = eagerParseCliFlag('--settings');
 506    if (settingsFile) {
 507      loadSettingsFromFlag(settingsFile);
 508    }
 509  
 510    // Parse --setting-sources flag early to control which sources are loaded
 511    const settingSourcesArg = eagerParseCliFlag('--setting-sources');
 512    if (settingSourcesArg !== undefined) {
 513      loadSettingSourcesFromFlag(settingSourcesArg);
 514    }
 515    profileCheckpoint('eagerLoadSettings_end');
 516  }
 517  function initializeEntrypoint(isNonInteractive: boolean): void {
 518    // Skip if already set (e.g., by SDK or other entrypoints)
 519    if (process.env.CLAUDE_CODE_ENTRYPOINT) {
 520      return;
 521    }
 522    const cliArgs = process.argv.slice(2);
 523  
 524    // Check for MCP serve command (handle flags before mcp serve, e.g., --debug mcp serve)
 525    const mcpIndex = cliArgs.indexOf('mcp');
 526    if (mcpIndex !== -1 && cliArgs[mcpIndex + 1] === 'serve') {
 527      process.env.CLAUDE_CODE_ENTRYPOINT = 'mcp';
 528      return;
 529    }
 530    if (isEnvTruthy(process.env.CLAUDE_CODE_ACTION)) {
 531      process.env.CLAUDE_CODE_ENTRYPOINT = 'claude-code-github-action';
 532      return;
 533    }
 534  
 535    // Note: 'local-agent' entrypoint is set by the local agent mode launcher
 536    // via CLAUDE_CODE_ENTRYPOINT env var (handled by early return above)
 537  
 538    // Set based on interactive status
 539    process.env.CLAUDE_CODE_ENTRYPOINT = isNonInteractive ? 'sdk-cli' : 'cli';
 540  }
 541  
 542  // Set by early argv processing when `claude open <url>` is detected (interactive mode only)
 543  type PendingConnect = {
 544    url: string | undefined;
 545    authToken: string | undefined;
 546    dangerouslySkipPermissions: boolean;
 547  };
 548  const _pendingConnect: PendingConnect | undefined = feature('DIRECT_CONNECT') ? {
 549    url: undefined,
 550    authToken: undefined,
 551    dangerouslySkipPermissions: false
 552  } : undefined;
 553  
 554  // Set by early argv processing when `claude assistant [sessionId]` is detected
 555  type PendingAssistantChat = {
 556    sessionId?: string;
 557    discover: boolean;
 558  };
 559  const _pendingAssistantChat: PendingAssistantChat | undefined = feature('KAIROS') ? {
 560    sessionId: undefined,
 561    discover: false
 562  } : undefined;
 563  
 564  // `claude ssh <host> [dir]` — parsed from argv early (same pattern as
 565  // DIRECT_CONNECT above) so the main command path can pick it up and hand
 566  // the REPL an SSH-backed session instead of a local one.
 567  type PendingSSH = {
 568    host: string | undefined;
 569    cwd: string | undefined;
 570    permissionMode: string | undefined;
 571    dangerouslySkipPermissions: boolean;
 572    /** --local: spawn the child CLI directly, skip ssh/probe/deploy. e2e test mode. */
 573    local: boolean;
 574    /** Extra CLI args to forward to the remote CLI on initial spawn (--resume, -c). */
 575    extraCliArgs: string[];
 576  };
 577  const _pendingSSH: PendingSSH | undefined = feature('SSH_REMOTE') ? {
 578    host: undefined,
 579    cwd: undefined,
 580    permissionMode: undefined,
 581    dangerouslySkipPermissions: false,
 582    local: false,
 583    extraCliArgs: []
 584  } : undefined;
 585  export async function main() {
 586    profileCheckpoint('main_function_start');
 587  
 588    // SECURITY: Prevent Windows from executing commands from current directory
 589    // This must be set before ANY command execution to prevent PATH hijacking attacks
 590    // See: https://docs.microsoft.com/en-us/windows/win32/api/processenv/nf-processenv-searchpathw
 591    process.env.NoDefaultCurrentDirectoryInExePath = '1';
 592  
 593    // Initialize warning handler early to catch warnings
 594    initializeWarningHandler();
 595    process.on('exit', () => {
 596      resetCursor();
 597    });
 598    process.on('SIGINT', () => {
 599      // In print mode, print.ts registers its own SIGINT handler that aborts
 600      // the in-flight query and calls gracefulShutdown; skip here to avoid
 601      // preempting it with a synchronous process.exit().
 602      if (process.argv.includes('-p') || process.argv.includes('--print')) {
 603        return;
 604      }
 605      process.exit(0);
 606    });
 607    profileCheckpoint('main_warning_handler_initialized');
 608  
 609    // Check for cc:// or cc+unix:// URL in argv — rewrite so the main command
 610    // handles it, giving the full interactive TUI instead of a stripped-down subcommand.
 611    // For headless (-p), we rewrite to the internal `open` subcommand.
 612    if (feature('DIRECT_CONNECT')) {
 613      const rawCliArgs = process.argv.slice(2);
 614      const ccIdx = rawCliArgs.findIndex(a => a.startsWith('cc://') || a.startsWith('cc+unix://'));
 615      if (ccIdx !== -1 && _pendingConnect) {
 616        const ccUrl = rawCliArgs[ccIdx]!;
 617        const {
 618          parseConnectUrl
 619        } = await import('./server/parseConnectUrl.js');
 620        const parsed = parseConnectUrl(ccUrl);
 621        _pendingConnect.dangerouslySkipPermissions = rawCliArgs.includes('--dangerously-skip-permissions');
 622        if (rawCliArgs.includes('-p') || rawCliArgs.includes('--print')) {
 623          // Headless: rewrite to internal `open` subcommand
 624          const stripped = rawCliArgs.filter((_, i) => i !== ccIdx);
 625          const dspIdx = stripped.indexOf('--dangerously-skip-permissions');
 626          if (dspIdx !== -1) {
 627            stripped.splice(dspIdx, 1);
 628          }
 629          process.argv = [process.argv[0]!, process.argv[1]!, 'open', ccUrl, ...stripped];
 630        } else {
 631          // Interactive: strip cc:// URL and flags, run main command
 632          _pendingConnect.url = parsed.serverUrl;
 633          _pendingConnect.authToken = parsed.authToken;
 634          const stripped = rawCliArgs.filter((_, i) => i !== ccIdx);
 635          const dspIdx = stripped.indexOf('--dangerously-skip-permissions');
 636          if (dspIdx !== -1) {
 637            stripped.splice(dspIdx, 1);
 638          }
 639          process.argv = [process.argv[0]!, process.argv[1]!, ...stripped];
 640        }
 641      }
 642    }
 643  
 644    // Handle deep link URIs early — this is invoked by the OS protocol handler
 645    // and should bail out before full init since it only needs to parse the URI
 646    // and open a terminal.
 647    if (feature('LODESTONE')) {
 648      const handleUriIdx = process.argv.indexOf('--handle-uri');
 649      if (handleUriIdx !== -1 && process.argv[handleUriIdx + 1]) {
 650        const {
 651          enableConfigs
 652        } = await import('./utils/config.js');
 653        enableConfigs();
 654        const uri = process.argv[handleUriIdx + 1]!;
 655        const {
 656          handleDeepLinkUri
 657        } = await import('./utils/deepLink/protocolHandler.js');
 658        const exitCode = await handleDeepLinkUri(uri);
 659        process.exit(exitCode);
 660      }
 661  
 662      // macOS URL handler: when LaunchServices launches our .app bundle, the
 663      // URL arrives via Apple Event (not argv). LaunchServices overwrites
 664      // __CFBundleIdentifier to the launching bundle's ID, which is a precise
 665      // positive signal — cheaper than importing and guessing with heuristics.
 666      if (process.platform === 'darwin' && process.env.__CFBundleIdentifier === 'com.anthropic.claude-code-url-handler') {
 667        const {
 668          enableConfigs
 669        } = await import('./utils/config.js');
 670        enableConfigs();
 671        const {
 672          handleUrlSchemeLaunch
 673        } = await import('./utils/deepLink/protocolHandler.js');
 674        const urlSchemeResult = await handleUrlSchemeLaunch();
 675        process.exit(urlSchemeResult ?? 1);
 676      }
 677    }
 678  
 679    // `claude assistant [sessionId]` — stash and strip so the main
 680    // command handles it, giving the full interactive TUI. Position-0 only
 681    // (matching the ssh pattern below) — indexOf would false-positive on
 682    // `claude -p "explain assistant"`. Root-flag-before-subcommand
 683    // (e.g. `--debug assistant`) falls through to the stub, which
 684    // prints usage.
 685    if (feature('KAIROS') && _pendingAssistantChat) {
 686      const rawArgs = process.argv.slice(2);
 687      if (rawArgs[0] === 'assistant') {
 688        const nextArg = rawArgs[1];
 689        if (nextArg && !nextArg.startsWith('-')) {
 690          _pendingAssistantChat.sessionId = nextArg;
 691          rawArgs.splice(0, 2); // drop 'assistant' and sessionId
 692          process.argv = [process.argv[0]!, process.argv[1]!, ...rawArgs];
 693        } else if (!nextArg) {
 694          _pendingAssistantChat.discover = true;
 695          rawArgs.splice(0, 1); // drop 'assistant'
 696          process.argv = [process.argv[0]!, process.argv[1]!, ...rawArgs];
 697        }
 698        // else: `claude assistant --help` → fall through to stub
 699      }
 700    }
 701  
 702    // `claude ssh <host> [dir]` — strip from argv so the main command handler
 703    // runs (full interactive TUI), stash the host/dir for the REPL branch at
 704    // ~line 3720 to pick up. Headless (-p) mode not supported in v1: SSH
 705    // sessions need the local REPL to drive them (interrupt, permissions).
 706    if (feature('SSH_REMOTE') && _pendingSSH) {
 707      const rawCliArgs = process.argv.slice(2);
 708      // SSH-specific flags can appear before the host positional (e.g.
 709      // `ssh --permission-mode auto host /tmp` — standard POSIX flags-before-
 710      // positionals). Pull them all out BEFORE checking whether a host was
 711      // given, so `claude ssh --permission-mode auto host` and `claude ssh host
 712      // --permission-mode auto` are equivalent. The host check below only needs
 713      // to guard against `-h`/`--help` (which commander should handle).
 714      if (rawCliArgs[0] === 'ssh') {
 715        const localIdx = rawCliArgs.indexOf('--local');
 716        if (localIdx !== -1) {
 717          _pendingSSH.local = true;
 718          rawCliArgs.splice(localIdx, 1);
 719        }
 720        const dspIdx = rawCliArgs.indexOf('--dangerously-skip-permissions');
 721        if (dspIdx !== -1) {
 722          _pendingSSH.dangerouslySkipPermissions = true;
 723          rawCliArgs.splice(dspIdx, 1);
 724        }
 725        const pmIdx = rawCliArgs.indexOf('--permission-mode');
 726        if (pmIdx !== -1 && rawCliArgs[pmIdx + 1] && !rawCliArgs[pmIdx + 1]!.startsWith('-')) {
 727          _pendingSSH.permissionMode = rawCliArgs[pmIdx + 1];
 728          rawCliArgs.splice(pmIdx, 2);
 729        }
 730        const pmEqIdx = rawCliArgs.findIndex(a => a.startsWith('--permission-mode='));
 731        if (pmEqIdx !== -1) {
 732          _pendingSSH.permissionMode = rawCliArgs[pmEqIdx]!.split('=')[1];
 733          rawCliArgs.splice(pmEqIdx, 1);
 734        }
 735        // Forward session-resume + model flags to the remote CLI's initial spawn.
 736        // --continue/-c and --resume <uuid> operate on the REMOTE session history
 737        // (which persists under the remote's ~/.claude/projects/<cwd>/).
 738        // --model controls which model the remote uses.
 739        const extractFlag = (flag: string, opts: {
 740          hasValue?: boolean;
 741          as?: string;
 742        } = {}) => {
 743          const i = rawCliArgs.indexOf(flag);
 744          if (i !== -1) {
 745            _pendingSSH.extraCliArgs.push(opts.as ?? flag);
 746            const val = rawCliArgs[i + 1];
 747            if (opts.hasValue && val && !val.startsWith('-')) {
 748              _pendingSSH.extraCliArgs.push(val);
 749              rawCliArgs.splice(i, 2);
 750            } else {
 751              rawCliArgs.splice(i, 1);
 752            }
 753          }
 754          const eqI = rawCliArgs.findIndex(a => a.startsWith(`${flag}=`));
 755          if (eqI !== -1) {
 756            _pendingSSH.extraCliArgs.push(opts.as ?? flag, rawCliArgs[eqI]!.slice(flag.length + 1));
 757            rawCliArgs.splice(eqI, 1);
 758          }
 759        };
 760        extractFlag('-c', {
 761          as: '--continue'
 762        });
 763        extractFlag('--continue');
 764        extractFlag('--resume', {
 765          hasValue: true
 766        });
 767        extractFlag('--model', {
 768          hasValue: true
 769        });
 770      }
 771      // After pre-extraction, any remaining dash-arg at [1] is either -h/--help
 772      // (commander handles) or an unknown-to-ssh flag (fall through to commander
 773      // so it surfaces a proper error). Only a non-dash arg is the host.
 774      if (rawCliArgs[0] === 'ssh' && rawCliArgs[1] && !rawCliArgs[1].startsWith('-')) {
 775        _pendingSSH.host = rawCliArgs[1];
 776        // Optional positional cwd.
 777        let consumed = 2;
 778        if (rawCliArgs[2] && !rawCliArgs[2].startsWith('-')) {
 779          _pendingSSH.cwd = rawCliArgs[2];
 780          consumed = 3;
 781        }
 782        const rest = rawCliArgs.slice(consumed);
 783  
 784        // Headless (-p) mode is not supported with SSH in v1 — reject early
 785        // so the flag doesn't silently cause local execution.
 786        if (rest.includes('-p') || rest.includes('--print')) {
 787          process.stderr.write('Error: headless (-p/--print) mode is not supported with claude ssh\n');
 788          gracefulShutdownSync(1);
 789          return;
 790        }
 791  
 792        // Rewrite argv so the main command sees remaining flags but not `ssh`.
 793        process.argv = [process.argv[0]!, process.argv[1]!, ...rest];
 794      }
 795    }
 796  
 797    // Check for -p/--print and --init-only flags early to set isInteractiveSession before init()
 798    // This is needed because telemetry initialization calls auth functions that need this flag
 799    const cliArgs = process.argv.slice(2);
 800    const hasPrintFlag = cliArgs.includes('-p') || cliArgs.includes('--print');
 801    const hasInitOnlyFlag = cliArgs.includes('--init-only');
 802    const hasSdkUrl = cliArgs.some(arg => arg.startsWith('--sdk-url'));
 803    const isNonInteractive = hasPrintFlag || hasInitOnlyFlag || hasSdkUrl || !process.stdout.isTTY;
 804  
 805    // Stop capturing early input for non-interactive modes
 806    if (isNonInteractive) {
 807      stopCapturingEarlyInput();
 808    }
 809  
 810    // Set simplified tracking fields
 811    const isInteractive = !isNonInteractive;
 812    setIsInteractive(isInteractive);
 813  
 814    // Initialize entrypoint based on mode - needs to be set before any event is logged
 815    initializeEntrypoint(isNonInteractive);
 816  
 817    // Determine client type
 818    const clientType = (() => {
 819      if (isEnvTruthy(process.env.GITHUB_ACTIONS)) return 'github-action';
 820      if (process.env.CLAUDE_CODE_ENTRYPOINT === 'sdk-ts') return 'sdk-typescript';
 821      if (process.env.CLAUDE_CODE_ENTRYPOINT === 'sdk-py') return 'sdk-python';
 822      if (process.env.CLAUDE_CODE_ENTRYPOINT === 'sdk-cli') return 'sdk-cli';
 823      if (process.env.CLAUDE_CODE_ENTRYPOINT === 'claude-vscode') return 'claude-vscode';
 824      if (process.env.CLAUDE_CODE_ENTRYPOINT === 'local-agent') return 'local-agent';
 825      if (process.env.CLAUDE_CODE_ENTRYPOINT === 'claude-desktop') return 'claude-desktop';
 826  
 827      // Check if session-ingress token is provided (indicates remote session)
 828      const hasSessionIngressToken = process.env.CLAUDE_CODE_SESSION_ACCESS_TOKEN || process.env.CLAUDE_CODE_WEBSOCKET_AUTH_FILE_DESCRIPTOR;
 829      if (process.env.CLAUDE_CODE_ENTRYPOINT === 'remote' || hasSessionIngressToken) {
 830        return 'remote';
 831      }
 832      return 'cli';
 833    })();
 834    setClientType(clientType);
 835    const previewFormat = process.env.CLAUDE_CODE_QUESTION_PREVIEW_FORMAT;
 836    if (previewFormat === 'markdown' || previewFormat === 'html') {
 837      setQuestionPreviewFormat(previewFormat);
 838    } else if (!clientType.startsWith('sdk-') &&
 839    // Desktop and CCR pass previewFormat via toolConfig; when the feature is
 840    // gated off they pass undefined — don't override that with markdown.
 841    clientType !== 'claude-desktop' && clientType !== 'local-agent' && clientType !== 'remote') {
 842      setQuestionPreviewFormat('markdown');
 843    }
 844  
 845    // Tag sessions created via `claude remote-control` so the backend can identify them
 846    if (process.env.CLAUDE_CODE_ENVIRONMENT_KIND === 'bridge') {
 847      setSessionSource('remote-control');
 848    }
 849    profileCheckpoint('main_client_type_determined');
 850  
 851    // Parse and load settings flags early, before init()
 852    eagerLoadSettings();
 853    profileCheckpoint('main_before_run');
 854    await run();
 855    profileCheckpoint('main_after_run');
 856  }
 857  async function getInputPrompt(prompt: string, inputFormat: 'text' | 'stream-json'): Promise<string | AsyncIterable<string>> {
 858    if (!process.stdin.isTTY &&
 859    // Input hijacking breaks MCP.
 860    !process.argv.includes('mcp')) {
 861      if (inputFormat === 'stream-json') {
 862        return process.stdin;
 863      }
 864      process.stdin.setEncoding('utf8');
 865      let data = '';
 866      const onData = (chunk: string) => {
 867        data += chunk;
 868      };
 869      process.stdin.on('data', onData);
 870      // If no data arrives in 3s, stop waiting and warn. Stdin is likely an
 871      // inherited pipe from a parent that isn't writing (subprocess spawned
 872      // without explicit stdin handling). 3s covers slow producers like curl,
 873      // jq on large files, python with import overhead. The warning makes
 874      // silent data loss visible for the rare producer that's slower still.
 875      const timedOut = await peekForStdinData(process.stdin, 3000);
 876      process.stdin.off('data', onData);
 877      if (timedOut) {
 878        process.stderr.write('Warning: no stdin data received in 3s, proceeding without it. ' + 'If piping from a slow command, redirect stdin explicitly: < /dev/null to skip, or wait longer.\n');
 879      }
 880      return [prompt, data].filter(Boolean).join('\n');
 881    }
 882    return prompt;
 883  }
 884  async function run(): Promise<CommanderCommand> {
 885    profileCheckpoint('run_function_start');
 886  
 887    // Create help config that sorts options by long option name.
 888    // Commander supports compareOptions at runtime but @commander-js/extra-typings
 889    // doesn't include it in the type definitions, so we use Object.assign to add it.
 890    function createSortedHelpConfig(): {
 891      sortSubcommands: true;
 892      sortOptions: true;
 893    } {
 894      const getOptionSortKey = (opt: Option): string => opt.long?.replace(/^--/, '') ?? opt.short?.replace(/^-/, '') ?? '';
 895      return Object.assign({
 896        sortSubcommands: true,
 897        sortOptions: true
 898      } as const, {
 899        compareOptions: (a: Option, b: Option) => getOptionSortKey(a).localeCompare(getOptionSortKey(b))
 900      });
 901    }
 902    const program = new CommanderCommand().configureHelp(createSortedHelpConfig()).enablePositionalOptions();
 903    profileCheckpoint('run_commander_initialized');
 904  
 905    // Use preAction hook to run initialization only when executing a command,
 906    // not when displaying help. This avoids the need for env variable signaling.
 907    program.hook('preAction', async thisCommand => {
 908      profileCheckpoint('preAction_start');
 909      // Await async subprocess loads started at module evaluation (lines 12-20).
 910      // Nearly free — subprocesses complete during the ~135ms of imports above.
 911      // Must resolve before init() which triggers the first settings read
 912      // (applySafeConfigEnvironmentVariables → getSettingsForSource('policySettings')
 913      // → isRemoteManagedSettingsEligible → sync keychain reads otherwise ~65ms).
 914      await Promise.all([ensureMdmSettingsLoaded(), ensureKeychainPrefetchCompleted()]);
 915      profileCheckpoint('preAction_after_mdm');
 916      await init();
 917      profileCheckpoint('preAction_after_init');
 918  
 919      // process.title on Windows sets the console title directly; on POSIX,
 920      // terminal shell integration may mirror the process name to the tab.
 921      // After init() so settings.json env can also gate this (gh-4765).
 922      if (!isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_TERMINAL_TITLE)) {
 923        process.title = 'claude';
 924      }
 925  
 926      // Attach logging sinks so subcommand handlers can use logEvent/logError.
 927      // Before PR #11106 logEvent dispatched directly; after, events queue until
 928      // a sink attaches. setup() attaches sinks for the default command, but
 929      // subcommands (doctor, mcp, plugin, auth) never call setup() and would
 930      // silently drop events on process.exit(). Both inits are idempotent.
 931      const {
 932        initSinks
 933      } = await import('./utils/sinks.js');
 934      initSinks();
 935      profileCheckpoint('preAction_after_sinks');
 936  
 937      // gh-33508: --plugin-dir is a top-level program option. The default
 938      // action reads it from its own options destructure, but subcommands
 939      // (plugin list, plugin install, mcp *) have their own actions and
 940      // never see it. Wire it up here so getInlinePlugins() works everywhere.
 941      // thisCommand.opts() is typed {} here because this hook is attached
 942      // before .option('--plugin-dir', ...) in the chain — extra-typings
 943      // builds the type as options are added. Narrow with a runtime guard;
 944      // the collect accumulator + [] default guarantee string[] in practice.
 945      const pluginDir = thisCommand.getOptionValue('pluginDir');
 946      if (Array.isArray(pluginDir) && pluginDir.length > 0 && pluginDir.every(p => typeof p === 'string')) {
 947        setInlinePlugins(pluginDir);
 948        clearPluginCache('preAction: --plugin-dir inline plugins');
 949      }
 950      runMigrations();
 951      profileCheckpoint('preAction_after_migrations');
 952  
 953      // Load remote managed settings for enterprise customers (non-blocking)
 954      // Fails open - if fetch fails, continues without remote settings
 955      // Settings are applied via hot-reload when they arrive
 956      // Must happen after init() to ensure config reading is allowed
 957      void loadRemoteManagedSettings();
 958      void loadPolicyLimits();
 959      profileCheckpoint('preAction_after_remote_settings');
 960  
 961      // Load settings sync (non-blocking, fail-open)
 962      // CLI: uploads local settings to remote (CCR download is handled by print.ts)
 963      if (feature('UPLOAD_USER_SETTINGS')) {
 964        void import('./services/settingsSync/index.js').then(m => m.uploadUserSettingsInBackground());
 965      }
 966      profileCheckpoint('preAction_after_settings_sync');
 967    });
 968    program.name('claude').description(`Claude Code - starts an interactive session by default, use -p/--print for non-interactive output`).argument('[prompt]', 'Your prompt', String)
 969    // Subcommands inherit helpOption via commander's copyInheritedSettings —
 970    // setting it once here covers mcp, plugin, auth, and all other subcommands.
 971    .helpOption('-h, --help', 'Display help for command').option('-d, --debug [filter]', 'Enable debug mode with optional category filtering (e.g., "api,hooks" or "!1p,!file")', (_value: string | true) => {
 972      // If value is provided, it will be the filter string
 973      // If not provided but flag is present, value will be true
 974      // The actual filtering is handled in debug.ts by parsing process.argv
 975      return true;
 976    }).addOption(new Option('-d2e, --debug-to-stderr', 'Enable debug mode (to stderr)').argParser(Boolean).hideHelp()).option('--debug-file <path>', 'Write debug logs to a specific file path (implicitly enables debug mode)', () => true).option('--verbose', 'Override verbose mode setting from config', () => true).option('-p, --print', 'Print response and exit (useful for pipes). Note: The workspace trust dialog is skipped when Claude is run with the -p mode. Only use this flag in directories you trust.', () => true).option('--bare', 'Minimal mode: skip hooks, LSP, plugin sync, attribution, auto-memory, background prefetches, keychain reads, and CLAUDE.md auto-discovery. Sets CLAUDE_CODE_SIMPLE=1. Anthropic auth is strictly ANTHROPIC_API_KEY or apiKeyHelper via --settings (OAuth and keychain are never read). 3P providers (Bedrock/Vertex/Foundry) use their own credentials. Skills still resolve via /skill-name. Explicitly provide context via: --system-prompt[-file], --append-system-prompt[-file], --add-dir (CLAUDE.md dirs), --mcp-config, --settings, --agents, --plugin-dir.', () => true).addOption(new Option('--init', 'Run Setup hooks with init trigger, then continue').hideHelp()).addOption(new Option('--init-only', 'Run Setup and SessionStart:startup hooks, then exit').hideHelp()).addOption(new Option('--maintenance', 'Run Setup hooks with maintenance trigger, then continue').hideHelp()).addOption(new Option('--output-format <format>', 'Output format (only works with --print): "text" (default), "json" (single result), or "stream-json" (realtime streaming)').choices(['text', 'json', 'stream-json'])).addOption(new Option('--json-schema <schema>', 'JSON Schema for structured output validation. ' + 'Example: {"type":"object","properties":{"name":{"type":"string"}},"required":["name"]}').argParser(String)).option('--include-hook-events', 'Include all hook lifecycle events in the output stream (only works with --output-format=stream-json)', () => true).option('--include-partial-messages', 'Include partial message chunks as they arrive (only works with --print and --output-format=stream-json)', () => true).addOption(new Option('--input-format <format>', 'Input format (only works with --print): "text" (default), or "stream-json" (realtime streaming input)').choices(['text', 'stream-json'])).option('--mcp-debug', '[DEPRECATED. Use --debug instead] Enable MCP debug mode (shows MCP server errors)', () => true).option('--dangerously-skip-permissions', 'Bypass all permission checks. Recommended only for sandboxes with no internet access.', () => true).option('--allow-dangerously-skip-permissions', 'Enable bypassing all permission checks as an option, without it being enabled by default. Recommended only for sandboxes with no internet access.', () => true).addOption(new Option('--thinking <mode>', 'Thinking mode: enabled (equivalent to adaptive), disabled').choices(['enabled', 'adaptive', 'disabled']).hideHelp()).addOption(new Option('--max-thinking-tokens <tokens>', '[DEPRECATED. Use --thinking instead for newer models] Maximum number of thinking tokens (only works with --print)').argParser(Number).hideHelp()).addOption(new Option('--max-turns <turns>', 'Maximum number of agentic turns in non-interactive mode. This will early exit the conversation after the specified number of turns. (only works with --print)').argParser(Number).hideHelp()).addOption(new Option('--max-budget-usd <amount>', 'Maximum dollar amount to spend on API calls (only works with --print)').argParser(value => {
 977      const amount = Number(value);
 978      if (isNaN(amount) || amount <= 0) {
 979        throw new Error('--max-budget-usd must be a positive number greater than 0');
 980      }
 981      return amount;
 982    })).addOption(new Option('--task-budget <tokens>', 'API-side task budget in tokens (output_config.task_budget)').argParser(value => {
 983      const tokens = Number(value);
 984      if (isNaN(tokens) || tokens <= 0 || !Number.isInteger(tokens)) {
 985        throw new Error('--task-budget must be a positive integer');
 986      }
 987      return tokens;
 988    }).hideHelp()).option('--replay-user-messages', 'Re-emit user messages from stdin back on stdout for acknowledgment (only works with --input-format=stream-json and --output-format=stream-json)', () => true).addOption(new Option('--enable-auth-status', 'Enable auth status messages in SDK mode').default(false).hideHelp()).option('--allowedTools, --allowed-tools <tools...>', 'Comma or space-separated list of tool names to allow (e.g. "Bash(git:*) Edit")').option('--tools <tools...>', 'Specify the list of available tools from the built-in set. Use "" to disable all tools, "default" to use all tools, or specify tool names (e.g. "Bash,Edit,Read").').option('--disallowedTools, --disallowed-tools <tools...>', 'Comma or space-separated list of tool names to deny (e.g. "Bash(git:*) Edit")').option('--mcp-config <configs...>', 'Load MCP servers from JSON files or strings (space-separated)').addOption(new Option('--permission-prompt-tool <tool>', 'MCP tool to use for permission prompts (only works with --print)').argParser(String).hideHelp()).addOption(new Option('--system-prompt <prompt>', 'System prompt to use for the session').argParser(String)).addOption(new Option('--system-prompt-file <file>', 'Read system prompt from a file').argParser(String).hideHelp()).addOption(new Option('--append-system-prompt <prompt>', 'Append a system prompt to the default system prompt').argParser(String)).addOption(new Option('--append-system-prompt-file <file>', 'Read system prompt from a file and append to the default system prompt').argParser(String).hideHelp()).addOption(new Option('--permission-mode <mode>', 'Permission mode to use for the session').argParser(String).choices(PERMISSION_MODES)).option('-c, --continue', 'Continue the most recent conversation in the current directory', () => true).option('-r, --resume [value]', 'Resume a conversation by session ID, or open interactive picker with optional search term', value => value || true).option('--fork-session', 'When resuming, create a new session ID instead of reusing the original (use with --resume or --continue)', () => true).addOption(new Option('--prefill <text>', 'Pre-fill the prompt input with text without submitting it').hideHelp()).addOption(new Option('--deep-link-origin', 'Signal that this session was launched from a deep link').hideHelp()).addOption(new Option('--deep-link-repo <slug>', 'Repo slug the deep link ?repo= parameter resolved to the current cwd').hideHelp()).addOption(new Option('--deep-link-last-fetch <ms>', 'FETCH_HEAD mtime in epoch ms, precomputed by the deep link trampoline').argParser(v => {
 989      const n = Number(v);
 990      return Number.isFinite(n) ? n : undefined;
 991    }).hideHelp()).option('--from-pr [value]', 'Resume a session linked to a PR by PR number/URL, or open interactive picker with optional search term', value => value || true).option('--no-session-persistence', 'Disable session persistence - sessions will not be saved to disk and cannot be resumed (only works with --print)').addOption(new Option('--resume-session-at <message id>', 'When resuming, only messages up to and including the assistant message with <message.id> (use with --resume in print mode)').argParser(String).hideHelp()).addOption(new Option('--rewind-files <user-message-id>', 'Restore files to state at the specified user message and exit (requires --resume)').hideHelp())
 992    // @[MODEL LAUNCH]: Update the example model ID in the --model help text.
 993    .option('--model <model>', `Model for the current session. Provide an alias for the latest model (e.g. 'sonnet' or 'opus') or a model's full name (e.g. 'claude-sonnet-4-6').`).addOption(new Option('--effort <level>', `Effort level for the current session (low, medium, high, max)`).argParser((rawValue: string) => {
 994      const value = rawValue.toLowerCase();
 995      const allowed = ['low', 'medium', 'high', 'max'];
 996      if (!allowed.includes(value)) {
 997        throw new InvalidArgumentError(`It must be one of: ${allowed.join(', ')}`);
 998      }
 999      return value;
1000    })).option('--agent <agent>', `Agent for the current session. Overrides the 'agent' setting.`).option('--betas <betas...>', 'Beta headers to include in API requests (API key users only)').option('--fallback-model <model>', 'Enable automatic fallback to specified model when default model is overloaded (only works with --print)').addOption(new Option('--workload <tag>', 'Workload tag for billing-header attribution (cc_workload). Process-scoped; set by SDK daemon callers that spawn subprocesses for cron work. (only works with --print)').hideHelp()).option('--settings <file-or-json>', 'Path to a settings JSON file or a JSON string to load additional settings from').option('--add-dir <directories...>', 'Additional directories to allow tool access to').option('--ide', 'Automatically connect to IDE on startup if exactly one valid IDE is available', () => true).option('--strict-mcp-config', 'Only use MCP servers from --mcp-config, ignoring all other MCP configurations', () => true).option('--session-id <uuid>', 'Use a specific session ID for the conversation (must be a valid UUID)').option('-n, --name <name>', 'Set a display name for this session (shown in /resume and terminal title)').option('--agents <json>', 'JSON object defining custom agents (e.g. \'{"reviewer": {"description": "Reviews code", "prompt": "You are a code reviewer"}}\')').option('--setting-sources <sources>', 'Comma-separated list of setting sources to load (user, project, local).')
1001    // gh-33508: <paths...> (variadic) consumed everything until the next
1002    // --flag. `claude --plugin-dir /path mcp add --transport http` swallowed
1003    // `mcp` and `add` as paths, then choked on --transport as an unknown
1004    // top-level option. Single-value + collect accumulator means each
1005    // --plugin-dir takes exactly one arg; repeat the flag for multiple dirs.
1006    .option('--plugin-dir <path>', 'Load plugins from a directory for this session only (repeatable: --plugin-dir A --plugin-dir B)', (val: string, prev: string[]) => [...prev, val], [] as string[]).option('--disable-slash-commands', 'Disable all skills', () => true).option('--chrome', 'Enable Claude in Chrome integration').option('--no-chrome', 'Disable Claude in Chrome integration').option('--file <specs...>', 'File resources to download at startup. Format: file_id:relative_path (e.g., --file file_abc:doc.txt file_def:img.png)').action(async (prompt, options) => {
1007      profileCheckpoint('action_handler_start');
1008  
1009      // --bare = one-switch minimal mode. Sets SIMPLE so all the existing
1010      // gates fire (CLAUDE.md, skills, hooks inside executeHooks, agent
1011      // dir-walk). Must be set before setup() / any of the gated work runs.
1012      if ((options as {
1013        bare?: boolean;
1014      }).bare) {
1015        process.env.CLAUDE_CODE_SIMPLE = '1';
1016      }
1017  
1018      // Ignore "code" as a prompt - treat it the same as no prompt
1019      if (prompt === 'code') {
1020        logEvent('tengu_code_prompt_ignored', {});
1021        // biome-ignore lint/suspicious/noConsole:: intentional console output
1022        console.warn(chalk.yellow('Tip: You can launch Claude Code with just `claude`'));
1023        prompt = undefined;
1024      }
1025  
1026      // Log event for any single-word prompt
1027      if (prompt && typeof prompt === 'string' && !/\s/.test(prompt) && prompt.length > 0) {
1028        logEvent('tengu_single_word_prompt', {
1029          length: prompt.length
1030        });
1031      }
1032  
1033      // Assistant mode: when .claude/settings.json has assistant: true AND
1034      // the tengu_kairos GrowthBook gate is on, force brief on. Permission
1035      // mode is left to the user — settings defaultMode or --permission-mode
1036      // apply as normal. REPL-typed messages already default to 'next'
1037      // priority (messageQueueManager.enqueue) so they drain mid-turn between
1038      // tool calls. SendUserMessage (BriefTool) is enabled via the brief env
1039      // var. SleepTool stays disabled (its isEnabled() gates on proactive).
1040      // kairosEnabled is computed once here and reused at the
1041      // getAssistantSystemPromptAddendum() call site further down.
1042      //
1043      // Trust gate: .claude/settings.json is attacker-controllable in an
1044      // untrusted clone. We run ~1000 lines before showSetupScreens() shows
1045      // the trust dialog, and by then we've already appended
1046      // .claude/agents/assistant.md to the system prompt. Refuse to activate
1047      // until the directory has been explicitly trusted.
1048      let kairosEnabled = false;
1049      let assistantTeamContext: Awaited<ReturnType<NonNullable<typeof assistantModule>['initializeAssistantTeam']>> | undefined;
1050      if (feature('KAIROS') && (options as {
1051        assistant?: boolean;
1052      }).assistant && assistantModule) {
1053        // --assistant (Agent SDK daemon mode): force the latch before
1054        // isAssistantMode() runs below. The daemon has already checked
1055        // entitlement — don't make the child re-check tengu_kairos.
1056        assistantModule.markAssistantForced();
1057      }
1058      if (feature('KAIROS') && assistantModule?.isAssistantMode() &&
1059      // Spawned teammates share the leader's cwd + settings.json, so
1060      // isAssistantMode() is true for them too. --agent-id being set
1061      // means we ARE a spawned teammate (extractTeammateOptions runs
1062      // ~170 lines later so check the raw commander option) — don't
1063      // re-init the team or override teammateMode/proactive/brief.
1064      !(options as {
1065        agentId?: unknown;
1066      }).agentId && kairosGate) {
1067        if (!checkHasTrustDialogAccepted()) {
1068          // biome-ignore lint/suspicious/noConsole:: intentional console output
1069          console.warn(chalk.yellow('Assistant mode disabled: directory is not trusted. Accept the trust dialog and restart.'));
1070        } else {
1071          // Blocking gate check — returns cached `true` instantly; if disk
1072          // cache is false/missing, lazily inits GrowthBook and fetches fresh
1073          // (max ~5s). --assistant skips the gate entirely (daemon is
1074          // pre-entitled).
1075          kairosEnabled = assistantModule.isAssistantForced() || (await kairosGate.isKairosEnabled());
1076          if (kairosEnabled) {
1077            const opts = options as {
1078              brief?: boolean;
1079            };
1080            opts.brief = true;
1081            setKairosActive(true);
1082            // Pre-seed an in-process team so Agent(name: "foo") spawns
1083            // teammates without TeamCreate. Must run BEFORE setup() captures
1084            // the teammateMode snapshot (initializeAssistantTeam calls
1085            // setCliTeammateModeOverride internally).
1086            assistantTeamContext = await assistantModule.initializeAssistantTeam();
1087          }
1088        }
1089      }
1090      const {
1091        debug = false,
1092        debugToStderr = false,
1093        dangerouslySkipPermissions,
1094        allowDangerouslySkipPermissions = false,
1095        tools: baseTools = [],
1096        allowedTools = [],
1097        disallowedTools = [],
1098        mcpConfig = [],
1099        permissionMode: permissionModeCli,
1100        addDir = [],
1101        fallbackModel,
1102        betas = [],
1103        ide = false,
1104        sessionId,
1105        includeHookEvents,
1106        includePartialMessages
1107      } = options;
1108      if (options.prefill) {
1109        seedEarlyInput(options.prefill);
1110      }
1111  
1112      // Promise for file downloads - started early, awaited before REPL renders
1113      let fileDownloadPromise: Promise<DownloadResult[]> | undefined;
1114      const agentsJson = options.agents;
1115      const agentCli = options.agent;
1116      if (feature('BG_SESSIONS') && agentCli) {
1117        process.env.CLAUDE_CODE_AGENT = agentCli;
1118      }
1119  
1120      // NOTE: LSP manager initialization is intentionally deferred until after
1121      // the trust dialog is accepted. This prevents plugin LSP servers from
1122      // executing code in untrusted directories before user consent.
1123  
1124      // Extract these separately so they can be modified if needed
1125      let outputFormat = options.outputFormat;
1126      let inputFormat = options.inputFormat;
1127      let verbose = options.verbose ?? getGlobalConfig().verbose;
1128      let print = options.print;
1129      const init = options.init ?? false;
1130      const initOnly = options.initOnly ?? false;
1131      const maintenance = options.maintenance ?? false;
1132  
1133      // Extract disable slash commands flag
1134      const disableSlashCommands = options.disableSlashCommands || false;
1135  
1136      // Extract tasks mode options (ant-only)
1137      const tasksOption = "external" === 'ant' && (options as {
1138        tasks?: boolean | string;
1139      }).tasks;
1140      const taskListId = tasksOption ? typeof tasksOption === 'string' ? tasksOption : DEFAULT_TASKS_MODE_TASK_LIST_ID : undefined;
1141      if ("external" === 'ant' && taskListId) {
1142        process.env.CLAUDE_CODE_TASK_LIST_ID = taskListId;
1143      }
1144  
1145      // Extract worktree option
1146      // worktree can be true (flag without value) or a string (custom name or PR reference)
1147      const worktreeOption = isWorktreeModeEnabled() ? (options as {
1148        worktree?: boolean | string;
1149      }).worktree : undefined;
1150      let worktreeName = typeof worktreeOption === 'string' ? worktreeOption : undefined;
1151      const worktreeEnabled = worktreeOption !== undefined;
1152  
1153      // Check if worktree name is a PR reference (#N or GitHub PR URL)
1154      let worktreePRNumber: number | undefined;
1155      if (worktreeName) {
1156        const prNum = parsePRReference(worktreeName);
1157        if (prNum !== null) {
1158          worktreePRNumber = prNum;
1159          worktreeName = undefined; // slug will be generated in setup()
1160        }
1161      }
1162  
1163      // Extract tmux option (requires --worktree)
1164      const tmuxEnabled = isWorktreeModeEnabled() && (options as {
1165        tmux?: boolean;
1166      }).tmux === true;
1167  
1168      // Validate tmux option
1169      if (tmuxEnabled) {
1170        if (!worktreeEnabled) {
1171          process.stderr.write(chalk.red('Error: --tmux requires --worktree\n'));
1172          process.exit(1);
1173        }
1174        if (getPlatform() === 'windows') {
1175          process.stderr.write(chalk.red('Error: --tmux is not supported on Windows\n'));
1176          process.exit(1);
1177        }
1178        if (!(await isTmuxAvailable())) {
1179          process.stderr.write(chalk.red(`Error: tmux is not installed.\n${getTmuxInstallInstructions()}\n`));
1180          process.exit(1);
1181        }
1182      }
1183  
1184      // Extract teammate options (for tmux-spawned agents)
1185      // Declared outside the if block so it's accessible later for system prompt addendum
1186      let storedTeammateOpts: TeammateOptions | undefined;
1187      if (isAgentSwarmsEnabled()) {
1188        // Extract agent identity options (for tmux-spawned agents)
1189        // These replace the CLAUDE_CODE_* environment variables
1190        const teammateOpts = extractTeammateOptions(options);
1191        storedTeammateOpts = teammateOpts;
1192  
1193        // If any teammate identity option is provided, all three required ones must be present
1194        const hasAnyTeammateOpt = teammateOpts.agentId || teammateOpts.agentName || teammateOpts.teamName;
1195        const hasAllRequiredTeammateOpts = teammateOpts.agentId && teammateOpts.agentName && teammateOpts.teamName;
1196        if (hasAnyTeammateOpt && !hasAllRequiredTeammateOpts) {
1197          process.stderr.write(chalk.red('Error: --agent-id, --agent-name, and --team-name must all be provided together\n'));
1198          process.exit(1);
1199        }
1200  
1201        // If teammate identity is provided via CLI, set up dynamicTeamContext
1202        if (teammateOpts.agentId && teammateOpts.agentName && teammateOpts.teamName) {
1203          getTeammateUtils().setDynamicTeamContext?.({
1204            agentId: teammateOpts.agentId,
1205            agentName: teammateOpts.agentName,
1206            teamName: teammateOpts.teamName,
1207            color: teammateOpts.agentColor,
1208            planModeRequired: teammateOpts.planModeRequired ?? false,
1209            parentSessionId: teammateOpts.parentSessionId
1210          });
1211        }
1212  
1213        // Set teammate mode CLI override if provided
1214        // This must be done before setup() captures the snapshot
1215        if (teammateOpts.teammateMode) {
1216          getTeammateModeSnapshot().setCliTeammateModeOverride?.(teammateOpts.teammateMode);
1217        }
1218      }
1219  
1220      // Extract remote sdk options
1221      const sdkUrl = (options as {
1222        sdkUrl?: string;
1223      }).sdkUrl ?? undefined;
1224  
1225      // Allow env var to enable partial messages (used by sandbox gateway for baku)
1226      const effectiveIncludePartialMessages = includePartialMessages || isEnvTruthy(process.env.CLAUDE_CODE_INCLUDE_PARTIAL_MESSAGES);
1227  
1228      // Enable all hook event types when explicitly requested via SDK option
1229      // or when running in CLAUDE_CODE_REMOTE mode (CCR needs them).
1230      // Without this, only SessionStart and Setup events are emitted.
1231      if (includeHookEvents || isEnvTruthy(process.env.CLAUDE_CODE_REMOTE)) {
1232        setAllHookEventsEnabled(true);
1233      }
1234  
1235      // Auto-set input/output formats, verbose mode, and print mode when SDK URL is provided
1236      if (sdkUrl) {
1237        // If SDK URL is provided, automatically use stream-json formats unless explicitly set
1238        if (!inputFormat) {
1239          inputFormat = 'stream-json';
1240        }
1241        if (!outputFormat) {
1242          outputFormat = 'stream-json';
1243        }
1244        // Auto-enable verbose mode unless explicitly disabled or already set
1245        if (options.verbose === undefined) {
1246          verbose = true;
1247        }
1248        // Auto-enable print mode unless explicitly disabled
1249        if (!options.print) {
1250          print = true;
1251        }
1252      }
1253  
1254      // Extract teleport option
1255      const teleport = (options as {
1256        teleport?: string | true;
1257      }).teleport ?? null;
1258  
1259      // Extract remote option (can be true if no description provided, or a string)
1260      const remoteOption = (options as {
1261        remote?: string | true;
1262      }).remote;
1263      const remote = remoteOption === true ? '' : remoteOption ?? null;
1264  
1265      // Extract --remote-control / --rc flag (enable bridge in interactive session)
1266      const remoteControlOption = (options as {
1267        remoteControl?: string | true;
1268      }).remoteControl ?? (options as {
1269        rc?: string | true;
1270      }).rc;
1271      // Actual bridge check is deferred to after showSetupScreens() so that
1272      // trust is established and GrowthBook has auth headers.
1273      let remoteControl = false;
1274      const remoteControlName = typeof remoteControlOption === 'string' && remoteControlOption.length > 0 ? remoteControlOption : undefined;
1275  
1276      // Validate session ID if provided
1277      if (sessionId) {
1278        // Check for conflicting flags
1279        // --session-id can be used with --continue or --resume when --fork-session is also provided
1280        // (to specify a custom ID for the forked session)
1281        if ((options.continue || options.resume) && !options.forkSession) {
1282          process.stderr.write(chalk.red('Error: --session-id can only be used with --continue or --resume if --fork-session is also specified.\n'));
1283          process.exit(1);
1284        }
1285  
1286        // When --sdk-url is provided (bridge/remote mode), the session ID is a
1287        // server-assigned tagged ID (e.g. "session_local_01...") rather than a
1288        // UUID. Skip UUID validation and local existence checks in that case.
1289        if (!sdkUrl) {
1290          const validatedSessionId = validateUuid(sessionId);
1291          if (!validatedSessionId) {
1292            process.stderr.write(chalk.red('Error: Invalid session ID. Must be a valid UUID.\n'));
1293            process.exit(1);
1294          }
1295  
1296          // Check if session ID already exists
1297          if (sessionIdExists(validatedSessionId)) {
1298            process.stderr.write(chalk.red(`Error: Session ID ${validatedSessionId} is already in use.\n`));
1299            process.exit(1);
1300          }
1301        }
1302      }
1303  
1304      // Download file resources if specified via --file flag
1305      const fileSpecs = (options as {
1306        file?: string[];
1307      }).file;
1308      if (fileSpecs && fileSpecs.length > 0) {
1309        // Get session ingress token (provided by EnvManager via CLAUDE_CODE_SESSION_ACCESS_TOKEN)
1310        const sessionToken = getSessionIngressAuthToken();
1311        if (!sessionToken) {
1312          process.stderr.write(chalk.red('Error: Session token required for file downloads. CLAUDE_CODE_SESSION_ACCESS_TOKEN must be set.\n'));
1313          process.exit(1);
1314        }
1315  
1316        // Resolve session ID: prefer remote session ID, fall back to internal session ID
1317        const fileSessionId = process.env.CLAUDE_CODE_REMOTE_SESSION_ID || getSessionId();
1318        const files = parseFileSpecs(fileSpecs);
1319        if (files.length > 0) {
1320          // Use ANTHROPIC_BASE_URL if set (by EnvManager), otherwise use OAuth config
1321          // This ensures consistency with session ingress API in all environments
1322          const config: FilesApiConfig = {
1323            baseUrl: process.env.ANTHROPIC_BASE_URL || getOauthConfig().BASE_API_URL,
1324            oauthToken: sessionToken,
1325            sessionId: fileSessionId
1326          };
1327  
1328          // Start download without blocking startup - await before REPL renders
1329          fileDownloadPromise = downloadSessionFiles(files, config);
1330        }
1331      }
1332  
1333      // Get isNonInteractiveSession from state (was set before init())
1334      const isNonInteractiveSession = getIsNonInteractiveSession();
1335  
1336      // Validate that fallback model is different from main model
1337      if (fallbackModel && options.model && fallbackModel === options.model) {
1338        process.stderr.write(chalk.red('Error: Fallback model cannot be the same as the main model. Please specify a different model for --fallback-model.\n'));
1339        process.exit(1);
1340      }
1341  
1342      // Handle system prompt options
1343      let systemPrompt = options.systemPrompt;
1344      if (options.systemPromptFile) {
1345        if (options.systemPrompt) {
1346          process.stderr.write(chalk.red('Error: Cannot use both --system-prompt and --system-prompt-file. Please use only one.\n'));
1347          process.exit(1);
1348        }
1349        try {
1350          const filePath = resolve(options.systemPromptFile);
1351          systemPrompt = readFileSync(filePath, 'utf8');
1352        } catch (error) {
1353          const code = getErrnoCode(error);
1354          if (code === 'ENOENT') {
1355            process.stderr.write(chalk.red(`Error: System prompt file not found: ${resolve(options.systemPromptFile)}\n`));
1356            process.exit(1);
1357          }
1358          process.stderr.write(chalk.red(`Error reading system prompt file: ${errorMessage(error)}\n`));
1359          process.exit(1);
1360        }
1361      }
1362  
1363      // Handle append system prompt options
1364      let appendSystemPrompt = options.appendSystemPrompt;
1365      if (options.appendSystemPromptFile) {
1366        if (options.appendSystemPrompt) {
1367          process.stderr.write(chalk.red('Error: Cannot use both --append-system-prompt and --append-system-prompt-file. Please use only one.\n'));
1368          process.exit(1);
1369        }
1370        try {
1371          const filePath = resolve(options.appendSystemPromptFile);
1372          appendSystemPrompt = readFileSync(filePath, 'utf8');
1373        } catch (error) {
1374          const code = getErrnoCode(error);
1375          if (code === 'ENOENT') {
1376            process.stderr.write(chalk.red(`Error: Append system prompt file not found: ${resolve(options.appendSystemPromptFile)}\n`));
1377            process.exit(1);
1378          }
1379          process.stderr.write(chalk.red(`Error reading append system prompt file: ${errorMessage(error)}\n`));
1380          process.exit(1);
1381        }
1382      }
1383  
1384      // Add teammate-specific system prompt addendum for tmux teammates
1385      if (isAgentSwarmsEnabled() && storedTeammateOpts?.agentId && storedTeammateOpts?.agentName && storedTeammateOpts?.teamName) {
1386        const addendum = getTeammatePromptAddendum().TEAMMATE_SYSTEM_PROMPT_ADDENDUM;
1387        appendSystemPrompt = appendSystemPrompt ? `${appendSystemPrompt}\n\n${addendum}` : addendum;
1388      }
1389      const {
1390        mode: permissionMode,
1391        notification: permissionModeNotification
1392      } = initialPermissionModeFromCLI({
1393        permissionModeCli,
1394        dangerouslySkipPermissions
1395      });
1396  
1397      // Store session bypass permissions mode for trust dialog check
1398      setSessionBypassPermissionsMode(permissionMode === 'bypassPermissions');
1399      if (feature('TRANSCRIPT_CLASSIFIER')) {
1400        // autoModeFlagCli is the "did the user intend auto this session" signal.
1401        // Set when: --enable-auto-mode, --permission-mode auto, resolved mode
1402        // is auto, OR settings defaultMode is auto but the gate denied it
1403        // (permissionMode resolved to default with no explicit CLI override).
1404        // Used by verifyAutoModeGateAccess to decide whether to notify on
1405        // auto-unavailable, and by tengu_auto_mode_config opt-in carousel.
1406        if ((options as {
1407          enableAutoMode?: boolean;
1408        }).enableAutoMode || permissionModeCli === 'auto' || permissionMode === 'auto' || !permissionModeCli && isDefaultPermissionModeAuto()) {
1409          autoModeStateModule?.setAutoModeFlagCli(true);
1410        }
1411      }
1412  
1413      // Parse the MCP config files/strings if provided
1414      let dynamicMcpConfig: Record<string, ScopedMcpServerConfig> = {};
1415      if (mcpConfig && mcpConfig.length > 0) {
1416        // Process mcpConfig array
1417        const processedConfigs = mcpConfig.map(config => config.trim()).filter(config => config.length > 0);
1418        let allConfigs: Record<string, McpServerConfig> = {};
1419        const allErrors: ValidationError[] = [];
1420        for (const configItem of processedConfigs) {
1421          let configs: Record<string, McpServerConfig> | null = null;
1422          let errors: ValidationError[] = [];
1423  
1424          // First try to parse as JSON string
1425          const parsedJson = safeParseJSON(configItem);
1426          if (parsedJson) {
1427            const result = parseMcpConfig({
1428              configObject: parsedJson,
1429              filePath: 'command line',
1430              expandVars: true,
1431              scope: 'dynamic'
1432            });
1433            if (result.config) {
1434              configs = result.config.mcpServers;
1435            } else {
1436              errors = result.errors;
1437            }
1438          } else {
1439            // Try as file path
1440            const configPath = resolve(configItem);
1441            const result = parseMcpConfigFromFilePath({
1442              filePath: configPath,
1443              expandVars: true,
1444              scope: 'dynamic'
1445            });
1446            if (result.config) {
1447              configs = result.config.mcpServers;
1448            } else {
1449              errors = result.errors;
1450            }
1451          }
1452          if (errors.length > 0) {
1453            allErrors.push(...errors);
1454          } else if (configs) {
1455            // Merge configs, later ones override earlier ones
1456            allConfigs = {
1457              ...allConfigs,
1458              ...configs
1459            };
1460          }
1461        }
1462        if (allErrors.length > 0) {
1463          const formattedErrors = allErrors.map(err => `${err.path ? err.path + ': ' : ''}${err.message}`).join('\n');
1464          logForDebugging(`--mcp-config validation failed (${allErrors.length} errors): ${formattedErrors}`, {
1465            level: 'error'
1466          });
1467          process.stderr.write(`Error: Invalid MCP configuration:\n${formattedErrors}\n`);
1468          process.exit(1);
1469        }
1470        if (Object.keys(allConfigs).length > 0) {
1471          // SDK hosts (Nest/Desktop) own their server naming and may reuse
1472          // built-in names — skip reserved-name checks for type:'sdk'.
1473          const nonSdkConfigNames = Object.entries(allConfigs).filter(([, config]) => config.type !== 'sdk').map(([name]) => name);
1474          let reservedNameError: string | null = null;
1475          if (nonSdkConfigNames.some(isClaudeInChromeMCPServer)) {
1476            reservedNameError = `Invalid MCP configuration: "${CLAUDE_IN_CHROME_MCP_SERVER_NAME}" is a reserved MCP name.`;
1477          } else if (feature('CHICAGO_MCP')) {
1478            const {
1479              isComputerUseMCPServer,
1480              COMPUTER_USE_MCP_SERVER_NAME
1481            } = await import('src/utils/computerUse/common.js');
1482            if (nonSdkConfigNames.some(isComputerUseMCPServer)) {
1483              reservedNameError = `Invalid MCP configuration: "${COMPUTER_USE_MCP_SERVER_NAME}" is a reserved MCP name.`;
1484            }
1485          }
1486          if (reservedNameError) {
1487            // stderr+exit(1) — a throw here becomes a silent unhandled
1488            // rejection in stream-json mode (void main() in cli.tsx).
1489            process.stderr.write(`Error: ${reservedNameError}\n`);
1490            process.exit(1);
1491          }
1492  
1493          // Add dynamic scope to all configs. type:'sdk' entries pass through
1494          // unchanged — they're extracted into sdkMcpConfigs downstream and
1495          // passed to print.ts. The Python SDK relies on this path (it doesn't
1496          // send sdkMcpServers in the initialize message). Dropping them here
1497          // broke Coworker (inc-5122). The policy filter below already exempts
1498          // type:'sdk', and the entries are inert without an SDK transport on
1499          // stdin, so there's no bypass risk from letting them through.
1500          const scopedConfigs = mapValues(allConfigs, config => ({
1501            ...config,
1502            scope: 'dynamic' as const
1503          }));
1504  
1505          // Enforce managed policy (allowedMcpServers / deniedMcpServers) on
1506          // --mcp-config servers. Without this, the CLI flag bypasses the
1507          // enterprise allowlist that user/project/local configs go through in
1508          // getClaudeCodeMcpConfigs — callers spread dynamicMcpConfig back on
1509          // top of filtered results. Filter here at the source so all
1510          // downstream consumers see the policy-filtered set.
1511          const {
1512            allowed,
1513            blocked
1514          } = filterMcpServersByPolicy(scopedConfigs);
1515          if (blocked.length > 0) {
1516            process.stderr.write(`Warning: MCP ${plural(blocked.length, 'server')} blocked by enterprise policy: ${blocked.join(', ')}\n`);
1517          }
1518          dynamicMcpConfig = {
1519            ...dynamicMcpConfig,
1520            ...allowed
1521          };
1522        }
1523      }
1524  
1525      // Extract Claude in Chrome option and enforce claude.ai subscriber check (unless user is ant)
1526      const chromeOpts = options as {
1527        chrome?: boolean;
1528      };
1529      // Store the explicit CLI flag so teammates can inherit it
1530      setChromeFlagOverride(chromeOpts.chrome);
1531      const enableClaudeInChrome = shouldEnableClaudeInChrome(chromeOpts.chrome) && ("external" === 'ant' || isClaudeAISubscriber());
1532      const autoEnableClaudeInChrome = !enableClaudeInChrome && shouldAutoEnableClaudeInChrome();
1533      if (enableClaudeInChrome) {
1534        const platform = getPlatform();
1535        try {
1536          logEvent('tengu_claude_in_chrome_setup', {
1537            platform: platform as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
1538          });
1539          const {
1540            mcpConfig: chromeMcpConfig,
1541            allowedTools: chromeMcpTools,
1542            systemPrompt: chromeSystemPrompt
1543          } = setupClaudeInChrome();
1544          dynamicMcpConfig = {
1545            ...dynamicMcpConfig,
1546            ...chromeMcpConfig
1547          };
1548          allowedTools.push(...chromeMcpTools);
1549          if (chromeSystemPrompt) {
1550            appendSystemPrompt = appendSystemPrompt ? `${chromeSystemPrompt}\n\n${appendSystemPrompt}` : chromeSystemPrompt;
1551          }
1552        } catch (error) {
1553          logEvent('tengu_claude_in_chrome_setup_failed', {
1554            platform: platform as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
1555          });
1556          logForDebugging(`[Claude in Chrome] Error: ${error}`);
1557          logError(error);
1558          // biome-ignore lint/suspicious/noConsole:: intentional console output
1559          console.error(`Error: Failed to run with Claude in Chrome.`);
1560          process.exit(1);
1561        }
1562      } else if (autoEnableClaudeInChrome) {
1563        try {
1564          const {
1565            mcpConfig: chromeMcpConfig
1566          } = setupClaudeInChrome();
1567          dynamicMcpConfig = {
1568            ...dynamicMcpConfig,
1569            ...chromeMcpConfig
1570          };
1571          const hint = feature('WEB_BROWSER_TOOL') && typeof Bun !== 'undefined' && 'WebView' in Bun ? CLAUDE_IN_CHROME_SKILL_HINT_WITH_WEBBROWSER : CLAUDE_IN_CHROME_SKILL_HINT;
1572          appendSystemPrompt = appendSystemPrompt ? `${appendSystemPrompt}\n\n${hint}` : hint;
1573        } catch (error) {
1574          // Silently skip any errors for the auto-enable
1575          logForDebugging(`[Claude in Chrome] Error (auto-enable): ${error}`);
1576        }
1577      }
1578  
1579      // Extract strict MCP config flag
1580      const strictMcpConfig = options.strictMcpConfig || false;
1581  
1582      // Check if enterprise MCP configuration exists. When it does, only allow dynamic MCP
1583      // configs that contain special server types (sdk)
1584      if (doesEnterpriseMcpConfigExist()) {
1585        if (strictMcpConfig) {
1586          process.stderr.write(chalk.red('You cannot use --strict-mcp-config when an enterprise MCP config is present'));
1587          process.exit(1);
1588        }
1589  
1590        // For --mcp-config, allow if all servers are internal types (sdk)
1591        if (dynamicMcpConfig && !areMcpConfigsAllowedWithEnterpriseMcpConfig(dynamicMcpConfig)) {
1592          process.stderr.write(chalk.red('You cannot dynamically configure MCP servers when an enterprise MCP config is present'));
1593          process.exit(1);
1594        }
1595      }
1596  
1597      // chicago MCP: guarded Computer Use (app allowlist + frontmost gate +
1598      // SCContentFilter screenshots). Ant-only, GrowthBook-gated — failures
1599      // are silent (this is dogfooding). Platform + interactive checks inline
1600      // so non-macOS / print-mode ants skip the heavy @ant/computer-use-mcp
1601      // import entirely. gates.js is light (type-only package import).
1602      //
1603      // Placed AFTER the enterprise-MCP-config check: that check rejects any
1604      // dynamicMcpConfig entry with `type !== 'sdk'`, and our config is
1605      // `type: 'stdio'`. An enterprise-config ant with the GB gate on would
1606      // otherwise process.exit(1). Chrome has the same latent issue but has
1607      // shipped without incident; chicago places itself correctly.
1608      if (feature('CHICAGO_MCP') && getPlatform() === 'macos' && !getIsNonInteractiveSession()) {
1609        try {
1610          const {
1611            getChicagoEnabled
1612          } = await import('src/utils/computerUse/gates.js');
1613          if (getChicagoEnabled()) {
1614            const {
1615              setupComputerUseMCP
1616            } = await import('src/utils/computerUse/setup.js');
1617            const {
1618              mcpConfig,
1619              allowedTools: cuTools
1620            } = setupComputerUseMCP();
1621            dynamicMcpConfig = {
1622              ...dynamicMcpConfig,
1623              ...mcpConfig
1624            };
1625            allowedTools.push(...cuTools);
1626          }
1627        } catch (error) {
1628          logForDebugging(`[Computer Use MCP] Setup failed: ${errorMessage(error)}`);
1629        }
1630      }
1631  
1632      // Store additional directories for CLAUDE.md loading (controlled by env var)
1633      setAdditionalDirectoriesForClaudeMd(addDir);
1634  
1635      // Channel server allowlist from --channels flag — servers whose
1636      // inbound push notifications should register this session. The option
1637      // is added inside a feature() block so TS doesn't know about it
1638      // on the options type — same pattern as --assistant at main.tsx:1824.
1639      // devChannels is deferred: showSetupScreens shows a confirmation dialog
1640      // and only appends to allowedChannels on accept.
1641      let devChannels: ChannelEntry[] | undefined;
1642      if (feature('KAIROS') || feature('KAIROS_CHANNELS')) {
1643        // Parse plugin:name@marketplace / server:Y tags into typed entries.
1644        // Tag decides trust model downstream: plugin-kind hits marketplace
1645        // verification + GrowthBook allowlist, server-kind always fails
1646        // allowlist (schema is plugin-only) unless dev flag is set.
1647        // Untagged or marketplace-less plugin entries are hard errors —
1648        // silently not-matching in the gate would look like channels are
1649        // "on" but nothing ever fires.
1650        const parseChannelEntries = (raw: string[], flag: string): ChannelEntry[] => {
1651          const entries: ChannelEntry[] = [];
1652          const bad: string[] = [];
1653          for (const c of raw) {
1654            if (c.startsWith('plugin:')) {
1655              const rest = c.slice(7);
1656              const at = rest.indexOf('@');
1657              if (at <= 0 || at === rest.length - 1) {
1658                bad.push(c);
1659              } else {
1660                entries.push({
1661                  kind: 'plugin',
1662                  name: rest.slice(0, at),
1663                  marketplace: rest.slice(at + 1)
1664                });
1665              }
1666            } else if (c.startsWith('server:') && c.length > 7) {
1667              entries.push({
1668                kind: 'server',
1669                name: c.slice(7)
1670              });
1671            } else {
1672              bad.push(c);
1673            }
1674          }
1675          if (bad.length > 0) {
1676            process.stderr.write(chalk.red(`${flag} entries must be tagged: ${bad.join(', ')}\n` + `  plugin:<name>@<marketplace>  — plugin-provided channel (allowlist enforced)\n` + `  server:<name>                — manually configured MCP server\n`));
1677            process.exit(1);
1678          }
1679          return entries;
1680        };
1681        const channelOpts = options as {
1682          channels?: string[];
1683          dangerouslyLoadDevelopmentChannels?: string[];
1684        };
1685        const rawChannels = channelOpts.channels;
1686        const rawDev = channelOpts.dangerouslyLoadDevelopmentChannels;
1687        // Always parse + set. ChannelsNotice reads getAllowedChannels() and
1688        // renders the appropriate branch (disabled/noAuth/policyBlocked/
1689        // listening) in the startup screen. gateChannelServer() enforces.
1690        // --channels works in both interactive and print/SDK modes; dev-channels
1691        // stays interactive-only (requires a confirmation dialog).
1692        let channelEntries: ChannelEntry[] = [];
1693        if (rawChannels && rawChannels.length > 0) {
1694          channelEntries = parseChannelEntries(rawChannels, '--channels');
1695          setAllowedChannels(channelEntries);
1696        }
1697        if (!isNonInteractiveSession) {
1698          if (rawDev && rawDev.length > 0) {
1699            devChannels = parseChannelEntries(rawDev, '--dangerously-load-development-channels');
1700          }
1701        }
1702        // Flag-usage telemetry. Plugin identifiers are logged (same tier as
1703        // tengu_plugin_installed — public-registry-style names); server-kind
1704        // names are not (MCP-server-name tier, opt-in-only elsewhere).
1705        // Per-server gate outcomes land in tengu_mcp_channel_gate once
1706        // servers connect. Dev entries go through a confirmation dialog after
1707        // this — dev_plugins captures what was typed, not what was accepted.
1708        if (channelEntries.length > 0 || (devChannels?.length ?? 0) > 0) {
1709          const joinPluginIds = (entries: ChannelEntry[]) => {
1710            const ids = entries.flatMap(e => e.kind === 'plugin' ? [`${e.name}@${e.marketplace}`] : []);
1711            return ids.length > 0 ? ids.sort().join(',') as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS : undefined;
1712          };
1713          logEvent('tengu_mcp_channel_flags', {
1714            channels_count: channelEntries.length,
1715            dev_count: devChannels?.length ?? 0,
1716            plugins: joinPluginIds(channelEntries),
1717            dev_plugins: joinPluginIds(devChannels ?? [])
1718          });
1719        }
1720      }
1721  
1722      // SDK opt-in for SendUserMessage via --tools. All sessions require
1723      // explicit opt-in; listing it in --tools signals intent. Runs BEFORE
1724      // initializeToolPermissionContext so getToolsForDefaultPreset() sees
1725      // the tool as enabled when computing the base-tools disallow filter.
1726      // Conditional require avoids leaking the tool-name string into
1727      // external builds.
1728      if ((feature('KAIROS') || feature('KAIROS_BRIEF')) && baseTools.length > 0) {
1729        /* eslint-disable @typescript-eslint/no-require-imports */
1730        const {
1731          BRIEF_TOOL_NAME,
1732          LEGACY_BRIEF_TOOL_NAME
1733        } = require('./tools/BriefTool/prompt.js') as typeof import('./tools/BriefTool/prompt.js');
1734        const {
1735          isBriefEntitled
1736        } = require('./tools/BriefTool/BriefTool.js') as typeof import('./tools/BriefTool/BriefTool.js');
1737        /* eslint-enable @typescript-eslint/no-require-imports */
1738        const parsed = parseToolListFromCLI(baseTools);
1739        if ((parsed.includes(BRIEF_TOOL_NAME) || parsed.includes(LEGACY_BRIEF_TOOL_NAME)) && isBriefEntitled()) {
1740          setUserMsgOptIn(true);
1741        }
1742      }
1743  
1744      // This await replaces blocking existsSync/statSync calls that were already in
1745      // the startup path. Wall-clock time is unchanged; we just yield to the event
1746      // loop during the fs I/O instead of blocking it. See #19661.
1747      const initResult = await initializeToolPermissionContext({
1748        allowedToolsCli: allowedTools,
1749        disallowedToolsCli: disallowedTools,
1750        baseToolsCli: baseTools,
1751        permissionMode,
1752        allowDangerouslySkipPermissions,
1753        addDirs: addDir
1754      });
1755      let toolPermissionContext = initResult.toolPermissionContext;
1756      const {
1757        warnings,
1758        dangerousPermissions,
1759        overlyBroadBashPermissions
1760      } = initResult;
1761  
1762      // Handle overly broad shell allow rules for ant users (Bash(*), PowerShell(*))
1763      if ("external" === 'ant' && overlyBroadBashPermissions.length > 0) {
1764        for (const permission of overlyBroadBashPermissions) {
1765          logForDebugging(`Ignoring overly broad shell permission ${permission.ruleDisplay} from ${permission.sourceDisplay}`);
1766        }
1767        toolPermissionContext = removeDangerousPermissions(toolPermissionContext, overlyBroadBashPermissions);
1768      }
1769      if (feature('TRANSCRIPT_CLASSIFIER') && dangerousPermissions.length > 0) {
1770        toolPermissionContext = stripDangerousPermissionsForAutoMode(toolPermissionContext);
1771      }
1772  
1773      // Print any warnings from initialization
1774      warnings.forEach(warning => {
1775        // biome-ignore lint/suspicious/noConsole:: intentional console output
1776        console.error(warning);
1777      });
1778      void assertMinVersion();
1779  
1780      // claude.ai config fetch: -p mode only (interactive uses useManageMCPConnections
1781      // two-phase loading). Kicked off here to overlap with setup(); awaited
1782      // before runHeadless so single-turn -p sees connectors. Skipped under
1783      // enterprise/strict MCP to preserve policy boundaries.
1784      const claudeaiConfigPromise: Promise<Record<string, ScopedMcpServerConfig>> = isNonInteractiveSession && !strictMcpConfig && !doesEnterpriseMcpConfigExist() &&
1785      // --bare / SIMPLE: skip claude.ai proxy servers (datadog, Gmail,
1786      // Slack, BigQuery, PubMed — 6-14s each to connect). Scripted calls
1787      // that need MCP pass --mcp-config explicitly.
1788      !isBareMode() ? fetchClaudeAIMcpConfigsIfEligible().then(configs => {
1789        const {
1790          allowed,
1791          blocked
1792        } = filterMcpServersByPolicy(configs);
1793        if (blocked.length > 0) {
1794          process.stderr.write(`Warning: claude.ai MCP ${plural(blocked.length, 'server')} blocked by enterprise policy: ${blocked.join(', ')}\n`);
1795        }
1796        return allowed;
1797      }) : Promise.resolve({});
1798  
1799      // Kick off MCP config loading early (safe - just reads files, no execution).
1800      // Both interactive and -p use getClaudeCodeMcpConfigs (local file reads only).
1801      // The local promise is awaited later (before prefetchAllMcpResources) to
1802      // overlap config I/O with setup(), commands loading, and trust dialog.
1803      logForDebugging('[STARTUP] Loading MCP configs...');
1804      const mcpConfigStart = Date.now();
1805      let mcpConfigResolvedMs: number | undefined;
1806      // --bare skips auto-discovered MCP (.mcp.json, user settings, plugins) —
1807      // only explicit --mcp-config works. dynamicMcpConfig is spread onto
1808      // allMcpConfigs downstream so it survives this skip.
1809      const mcpConfigPromise = (strictMcpConfig || isBareMode() ? Promise.resolve({
1810        servers: {} as Record<string, ScopedMcpServerConfig>
1811      }) : getClaudeCodeMcpConfigs(dynamicMcpConfig)).then(result => {
1812        mcpConfigResolvedMs = Date.now() - mcpConfigStart;
1813        return result;
1814      });
1815  
1816      // NOTE: We do NOT call prefetchAllMcpResources here - that's deferred until after trust dialog
1817  
1818      if (inputFormat && inputFormat !== 'text' && inputFormat !== 'stream-json') {
1819        // biome-ignore lint/suspicious/noConsole:: intentional console output
1820        console.error(`Error: Invalid input format "${inputFormat}".`);
1821        process.exit(1);
1822      }
1823      if (inputFormat === 'stream-json' && outputFormat !== 'stream-json') {
1824        // biome-ignore lint/suspicious/noConsole:: intentional console output
1825        console.error(`Error: --input-format=stream-json requires output-format=stream-json.`);
1826        process.exit(1);
1827      }
1828  
1829      // Validate sdkUrl is only used with appropriate formats (formats are auto-set above)
1830      if (sdkUrl) {
1831        if (inputFormat !== 'stream-json' || outputFormat !== 'stream-json') {
1832          // biome-ignore lint/suspicious/noConsole:: intentional console output
1833          console.error(`Error: --sdk-url requires both --input-format=stream-json and --output-format=stream-json.`);
1834          process.exit(1);
1835        }
1836      }
1837  
1838      // Validate replayUserMessages is only used with stream-json formats
1839      if (options.replayUserMessages) {
1840        if (inputFormat !== 'stream-json' || outputFormat !== 'stream-json') {
1841          // biome-ignore lint/suspicious/noConsole:: intentional console output
1842          console.error(`Error: --replay-user-messages requires both --input-format=stream-json and --output-format=stream-json.`);
1843          process.exit(1);
1844        }
1845      }
1846  
1847      // Validate includePartialMessages is only used with print mode and stream-json output
1848      if (effectiveIncludePartialMessages) {
1849        if (!isNonInteractiveSession || outputFormat !== 'stream-json') {
1850          writeToStderr(`Error: --include-partial-messages requires --print and --output-format=stream-json.`);
1851          process.exit(1);
1852        }
1853      }
1854  
1855      // Validate --no-session-persistence is only used with print mode
1856      if (options.sessionPersistence === false && !isNonInteractiveSession) {
1857        writeToStderr(`Error: --no-session-persistence can only be used with --print mode.`);
1858        process.exit(1);
1859      }
1860      const effectivePrompt = prompt || '';
1861      let inputPrompt = await getInputPrompt(effectivePrompt, (inputFormat ?? 'text') as 'text' | 'stream-json');
1862      profileCheckpoint('action_after_input_prompt');
1863  
1864      // Activate proactive mode BEFORE getTools() so SleepTool.isEnabled()
1865      // (which returns isProactiveActive()) passes and Sleep is included.
1866      // The later REPL-path maybeActivateProactive() calls are idempotent.
1867      maybeActivateProactive(options);
1868      let tools = getTools(toolPermissionContext);
1869  
1870      // Apply coordinator mode tool filtering for headless path
1871      // (mirrors useMergedTools.ts filtering for REPL/interactive path)
1872      if (feature('COORDINATOR_MODE') && isEnvTruthy(process.env.CLAUDE_CODE_COORDINATOR_MODE)) {
1873        const {
1874          applyCoordinatorToolFilter
1875        } = await import('./utils/toolPool.js');
1876        tools = applyCoordinatorToolFilter(tools);
1877      }
1878      profileCheckpoint('action_tools_loaded');
1879      let jsonSchema: ToolInputJSONSchema | undefined;
1880      if (isSyntheticOutputToolEnabled({
1881        isNonInteractiveSession
1882      }) && options.jsonSchema) {
1883        jsonSchema = jsonParse(options.jsonSchema) as ToolInputJSONSchema;
1884      }
1885      if (jsonSchema) {
1886        const syntheticOutputResult = createSyntheticOutputTool(jsonSchema);
1887        if ('tool' in syntheticOutputResult) {
1888          // Add SyntheticOutputTool to the tools array AFTER getTools() filtering.
1889          // This tool is excluded from normal filtering (see tools.ts) because it's
1890          // an implementation detail for structured output, not a user-controlled tool.
1891          tools = [...tools, syntheticOutputResult.tool];
1892          logEvent('tengu_structured_output_enabled', {
1893            schema_property_count: Object.keys(jsonSchema.properties as Record<string, unknown> || {}).length as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
1894            has_required_fields: Boolean(jsonSchema.required) as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
1895          });
1896        } else {
1897          logEvent('tengu_structured_output_failure', {
1898            error: 'Invalid JSON schema' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
1899          });
1900        }
1901      }
1902  
1903      // IMPORTANT: setup() must be called before any other code that depends on the cwd or worktree setup
1904      profileCheckpoint('action_before_setup');
1905      logForDebugging('[STARTUP] Running setup()...');
1906      const setupStart = Date.now();
1907      const {
1908        setup
1909      } = await import('./setup.js');
1910      const messagingSocketPath = feature('UDS_INBOX') ? (options as {
1911        messagingSocketPath?: string;
1912      }).messagingSocketPath : undefined;
1913      // Parallelize setup() with commands+agents loading. setup()'s ~28ms is
1914      // mostly startUdsMessaging (socket bind, ~20ms) — not disk-bound, so it
1915      // doesn't contend with getCommands' file reads. Gated on !worktreeEnabled
1916      // since --worktree makes setup() process.chdir() (setup.ts:203), and
1917      // commands/agents need the post-chdir cwd.
1918      const preSetupCwd = getCwd();
1919      // Register bundled skills/plugins before kicking getCommands() — they're
1920      // pure in-memory array pushes (<1ms, zero I/O) that getBundledSkills()
1921      // reads synchronously. Previously ran inside setup() after ~20ms of
1922      // await points, so the parallel getCommands() memoized an empty list.
1923      if (process.env.CLAUDE_CODE_ENTRYPOINT !== 'local-agent') {
1924        initBuiltinPlugins();
1925        initBundledSkills();
1926      }
1927      const setupPromise = setup(preSetupCwd, permissionMode, allowDangerouslySkipPermissions, worktreeEnabled, worktreeName, tmuxEnabled, sessionId ? validateUuid(sessionId) : undefined, worktreePRNumber, messagingSocketPath);
1928      const commandsPromise = worktreeEnabled ? null : getCommands(preSetupCwd);
1929      const agentDefsPromise = worktreeEnabled ? null : getAgentDefinitionsWithOverrides(preSetupCwd);
1930      // Suppress transient unhandledRejection if these reject during the
1931      // ~28ms setupPromise await before Promise.all joins them below.
1932      commandsPromise?.catch(() => {});
1933      agentDefsPromise?.catch(() => {});
1934      await setupPromise;
1935      logForDebugging(`[STARTUP] setup() completed in ${Date.now() - setupStart}ms`);
1936      profileCheckpoint('action_after_setup');
1937  
1938      // Replay user messages into stream-json only when the socket was
1939      // explicitly requested. The auto-generated socket is passive — it
1940      // lets tools inject if they want to, but turning it on by default
1941      // shouldn't reshape stream-json for SDK consumers who never touch it.
1942      // Callers who inject and also want those injections visible in the
1943      // stream pass --messaging-socket-path explicitly (or --replay-user-messages).
1944      let effectiveReplayUserMessages = !!options.replayUserMessages;
1945      if (feature('UDS_INBOX')) {
1946        if (!effectiveReplayUserMessages && outputFormat === 'stream-json') {
1947          effectiveReplayUserMessages = !!(options as {
1948            messagingSocketPath?: string;
1949          }).messagingSocketPath;
1950        }
1951      }
1952      if (getIsNonInteractiveSession()) {
1953        // Apply full merged settings env now (including project-scoped
1954        // .claude/settings.json PATH/GIT_DIR/GIT_WORK_TREE) so gitExe() and
1955        // the git spawn below see it. Trust is implicit in -p mode; the
1956        // docstring at managedEnv.ts:96-97 says this applies "potentially
1957        // dangerous environment variables such as LD_PRELOAD, PATH" from all
1958        // sources. The later call in the isNonInteractiveSession block below
1959        // is idempotent (Object.assign, configureGlobalAgents ejects prior
1960        // interceptor) and picks up any plugin-contributed env after plugin
1961        // init. Project settings are already loaded here:
1962        // applySafeConfigEnvironmentVariables in init() called
1963        // getSettings_DEPRECATED at managedEnv.ts:86 which merges all enabled
1964        // sources including projectSettings/localSettings.
1965        applyConfigEnvironmentVariables();
1966  
1967        // Spawn git status/log/branch now so the subprocess execution overlaps
1968        // with the getCommands await below and startDeferredPrefetches. After
1969        // setup() so cwd is final (setup.ts:254 may process.chdir(worktreePath)
1970        // for --worktree) and after the applyConfigEnvironmentVariables above
1971        // so PATH/GIT_DIR/GIT_WORK_TREE from all sources (trusted + project)
1972        // are applied. getSystemContext is memoized; the
1973        // prefetchSystemContextIfSafe call in startDeferredPrefetches becomes
1974        // a cache hit. The microtask from await getIsGit() drains at the
1975        // getCommands Promise.all await below. Trust is implicit in -p mode
1976        // (same gate as prefetchSystemContextIfSafe).
1977        void getSystemContext();
1978        // Kick getUserContext now too — its first await (fs.readFile in
1979        // getMemoryFiles) yields naturally, so the CLAUDE.md directory walk
1980        // runs during the ~280ms overlap window before the context
1981        // Promise.all join in print.ts. The void getUserContext() in
1982        // startDeferredPrefetches becomes a memoize cache-hit.
1983        void getUserContext();
1984        // Kick ensureModelStringsInitialized now — for Bedrock this triggers
1985        // a 100-200ms profile fetch that was awaited serially at
1986        // print.ts:739. updateBedrockModelStrings is sequential()-wrapped so
1987        // the await joins the in-flight fetch. Non-Bedrock is a sync
1988        // early-return (zero-cost).
1989        void ensureModelStringsInitialized();
1990      }
1991  
1992      // Apply --name: cache-only so no orphan file is created before the
1993      // session ID is finalized by --continue/--resume. materializeSessionFile
1994      // persists it on the first user message; REPL's useTerminalTitle reads it
1995      // via getCurrentSessionTitle.
1996      const sessionNameArg = options.name?.trim();
1997      if (sessionNameArg) {
1998        cacheSessionTitle(sessionNameArg);
1999      }
2000  
2001      // Ant model aliases (capybara-fast etc.) resolve via the
2002      // tengu_ant_model_override GrowthBook flag. _CACHED_MAY_BE_STALE reads
2003      // disk synchronously; disk is populated by a fire-and-forget write. On a
2004      // cold cache, parseUserSpecifiedModel returns the unresolved alias, the
2005      // API 404s, and -p exits before the async write lands — crashloop on
2006      // fresh pods. Awaiting init here populates the in-memory payload map that
2007      // _CACHED_MAY_BE_STALE now checks first. Gated so the warm path stays
2008      // non-blocking:
2009      //  - explicit model via --model or ANTHROPIC_MODEL (both feed alias resolution)
2010      //  - no env override (which short-circuits _CACHED_MAY_BE_STALE before disk)
2011      //  - flag absent from disk (== null also catches pre-#22279 poisoned null)
2012      const explicitModel = options.model || process.env.ANTHROPIC_MODEL;
2013      if ("external" === 'ant' && explicitModel && explicitModel !== 'default' && !hasGrowthBookEnvOverride('tengu_ant_model_override') && getGlobalConfig().cachedGrowthBookFeatures?.['tengu_ant_model_override'] == null) {
2014        await initializeGrowthBook();
2015      }
2016  
2017      // Special case the default model with the null keyword
2018      // NOTE: Model resolution happens after setup() to ensure trust is established before AWS auth
2019      const userSpecifiedModel = options.model === 'default' ? getDefaultMainLoopModel() : options.model;
2020      const userSpecifiedFallbackModel = fallbackModel === 'default' ? getDefaultMainLoopModel() : fallbackModel;
2021  
2022      // Reuse preSetupCwd unless setup() chdir'd (worktreeEnabled). Saves a
2023      // getCwd() syscall in the common path.
2024      const currentCwd = worktreeEnabled ? getCwd() : preSetupCwd;
2025      logForDebugging('[STARTUP] Loading commands and agents...');
2026      const commandsStart = Date.now();
2027      // Join the promises kicked before setup() (or start fresh if
2028      // worktreeEnabled gated the early kick). Both memoized by cwd.
2029      const [commands, agentDefinitionsResult] = await Promise.all([commandsPromise ?? getCommands(currentCwd), agentDefsPromise ?? getAgentDefinitionsWithOverrides(currentCwd)]);
2030      logForDebugging(`[STARTUP] Commands and agents loaded in ${Date.now() - commandsStart}ms`);
2031      profileCheckpoint('action_commands_loaded');
2032  
2033      // Parse CLI agents if provided via --agents flag
2034      let cliAgents: typeof agentDefinitionsResult.activeAgents = [];
2035      if (agentsJson) {
2036        try {
2037          const parsedAgents = safeParseJSON(agentsJson);
2038          if (parsedAgents) {
2039            cliAgents = parseAgentsFromJson(parsedAgents, 'flagSettings');
2040          }
2041        } catch (error) {
2042          logError(error);
2043        }
2044      }
2045  
2046      // Merge CLI agents with existing ones
2047      const allAgents = [...agentDefinitionsResult.allAgents, ...cliAgents];
2048      const agentDefinitions = {
2049        ...agentDefinitionsResult,
2050        allAgents,
2051        activeAgents: getActiveAgentsFromList(allAgents)
2052      };
2053  
2054      // Look up main thread agent from CLI flag or settings
2055      const agentSetting = agentCli ?? getInitialSettings().agent;
2056      let mainThreadAgentDefinition: (typeof agentDefinitions.activeAgents)[number] | undefined;
2057      if (agentSetting) {
2058        mainThreadAgentDefinition = agentDefinitions.activeAgents.find(agent => agent.agentType === agentSetting);
2059        if (!mainThreadAgentDefinition) {
2060          logForDebugging(`Warning: agent "${agentSetting}" not found. ` + `Available agents: ${agentDefinitions.activeAgents.map(a => a.agentType).join(', ')}. ` + `Using default behavior.`);
2061        }
2062      }
2063  
2064      // Store the main thread agent type in bootstrap state so hooks can access it
2065      setMainThreadAgentType(mainThreadAgentDefinition?.agentType);
2066  
2067      // Log agent flag usage — only log agent name for built-in agents to avoid leaking custom agent names
2068      if (mainThreadAgentDefinition) {
2069        logEvent('tengu_agent_flag', {
2070          agentType: isBuiltInAgent(mainThreadAgentDefinition) ? mainThreadAgentDefinition.agentType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS : 'custom' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
2071          ...(agentCli && {
2072            source: 'cli' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
2073          })
2074        });
2075      }
2076  
2077      // Persist agent setting to session transcript for resume view display and restoration
2078      if (mainThreadAgentDefinition?.agentType) {
2079        saveAgentSetting(mainThreadAgentDefinition.agentType);
2080      }
2081  
2082      // Apply the agent's system prompt for non-interactive sessions
2083      // (interactive mode uses buildEffectiveSystemPrompt instead)
2084      if (isNonInteractiveSession && mainThreadAgentDefinition && !systemPrompt && !isBuiltInAgent(mainThreadAgentDefinition)) {
2085        const agentSystemPrompt = mainThreadAgentDefinition.getSystemPrompt();
2086        if (agentSystemPrompt) {
2087          systemPrompt = agentSystemPrompt;
2088        }
2089      }
2090  
2091      // initialPrompt goes first so its slash command (if any) is processed;
2092      // user-provided text becomes trailing context.
2093      // Only concatenate when inputPrompt is a string. When it's an
2094      // AsyncIterable (SDK stream-json mode), template interpolation would
2095      // call .toString() producing "[object Object]". The AsyncIterable case
2096      // is handled in print.ts via structuredIO.prependUserMessage().
2097      if (mainThreadAgentDefinition?.initialPrompt) {
2098        if (typeof inputPrompt === 'string') {
2099          inputPrompt = inputPrompt ? `${mainThreadAgentDefinition.initialPrompt}\n\n${inputPrompt}` : mainThreadAgentDefinition.initialPrompt;
2100        } else if (!inputPrompt) {
2101          inputPrompt = mainThreadAgentDefinition.initialPrompt;
2102        }
2103      }
2104  
2105      // Compute effective model early so hooks can run in parallel with MCP
2106      // If user didn't specify a model but agent has one, use the agent's model
2107      let effectiveModel = userSpecifiedModel;
2108      if (!effectiveModel && mainThreadAgentDefinition?.model && mainThreadAgentDefinition.model !== 'inherit') {
2109        effectiveModel = parseUserSpecifiedModel(mainThreadAgentDefinition.model);
2110      }
2111      setMainLoopModelOverride(effectiveModel);
2112  
2113      // Compute resolved model for hooks (use user-specified model at launch)
2114      setInitialMainLoopModel(getUserSpecifiedModelSetting() || null);
2115      const initialMainLoopModel = getInitialMainLoopModel();
2116      const resolvedInitialModel = parseUserSpecifiedModel(initialMainLoopModel ?? getDefaultMainLoopModel());
2117      let advisorModel: string | undefined;
2118      if (isAdvisorEnabled()) {
2119        const advisorOption = canUserConfigureAdvisor() ? (options as {
2120          advisor?: string;
2121        }).advisor : undefined;
2122        if (advisorOption) {
2123          logForDebugging(`[AdvisorTool] --advisor ${advisorOption}`);
2124          if (!modelSupportsAdvisor(resolvedInitialModel)) {
2125            process.stderr.write(chalk.red(`Error: The model "${resolvedInitialModel}" does not support the advisor tool.\n`));
2126            process.exit(1);
2127          }
2128          const normalizedAdvisorModel = normalizeModelStringForAPI(parseUserSpecifiedModel(advisorOption));
2129          if (!isValidAdvisorModel(normalizedAdvisorModel)) {
2130            process.stderr.write(chalk.red(`Error: The model "${advisorOption}" cannot be used as an advisor.\n`));
2131            process.exit(1);
2132          }
2133        }
2134        advisorModel = canUserConfigureAdvisor() ? advisorOption ?? getInitialAdvisorSetting() : advisorOption;
2135        if (advisorModel) {
2136          logForDebugging(`[AdvisorTool] Advisor model: ${advisorModel}`);
2137        }
2138      }
2139  
2140      // For tmux teammates with --agent-type, append the custom agent's prompt
2141      if (isAgentSwarmsEnabled() && storedTeammateOpts?.agentId && storedTeammateOpts?.agentName && storedTeammateOpts?.teamName && storedTeammateOpts?.agentType) {
2142        // Look up the custom agent definition
2143        const customAgent = agentDefinitions.activeAgents.find(a => a.agentType === storedTeammateOpts.agentType);
2144        if (customAgent) {
2145          // Get the prompt - need to handle both built-in and custom agents
2146          let customPrompt: string | undefined;
2147          if (customAgent.source === 'built-in') {
2148            // Built-in agents have getSystemPrompt that takes toolUseContext
2149            // We can't access full toolUseContext here, so skip for now
2150            logForDebugging(`[teammate] Built-in agent ${storedTeammateOpts.agentType} - skipping custom prompt (not supported)`);
2151          } else {
2152            // Custom agents have getSystemPrompt that takes no args
2153            customPrompt = customAgent.getSystemPrompt();
2154          }
2155  
2156          // Log agent memory loaded event for tmux teammates
2157          if (customAgent.memory) {
2158            logEvent('tengu_agent_memory_loaded', {
2159              ...("external" === 'ant' && {
2160                agent_type: customAgent.agentType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
2161              }),
2162              scope: customAgent.memory as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
2163              source: 'teammate' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
2164            });
2165          }
2166          if (customPrompt) {
2167            const customInstructions = `\n# Custom Agent Instructions\n${customPrompt}`;
2168            appendSystemPrompt = appendSystemPrompt ? `${appendSystemPrompt}\n\n${customInstructions}` : customInstructions;
2169          }
2170        } else {
2171          logForDebugging(`[teammate] Custom agent ${storedTeammateOpts.agentType} not found in available agents`);
2172        }
2173      }
2174      maybeActivateBrief(options);
2175      // defaultView: 'chat' is a persisted opt-in — check entitlement and set
2176      // userMsgOptIn so the tool + prompt section activate. Interactive-only:
2177      // defaultView is a display preference; SDK sessions have no display, and
2178      // the assistant installer writes defaultView:'chat' to settings.local.json
2179      // which would otherwise leak into --print sessions in the same directory.
2180      // Runs right after maybeActivateBrief() so all startup opt-in paths fire
2181      // BEFORE any isBriefEnabled() read below (proactive prompt's
2182      // briefVisibility). A persisted 'chat' after a GB kill-switch falls
2183      // through (entitlement fails).
2184      if ((feature('KAIROS') || feature('KAIROS_BRIEF')) && !getIsNonInteractiveSession() && !getUserMsgOptIn() && getInitialSettings().defaultView === 'chat') {
2185        /* eslint-disable @typescript-eslint/no-require-imports */
2186        const {
2187          isBriefEntitled
2188        } = require('./tools/BriefTool/BriefTool.js') as typeof import('./tools/BriefTool/BriefTool.js');
2189        /* eslint-enable @typescript-eslint/no-require-imports */
2190        if (isBriefEntitled()) {
2191          setUserMsgOptIn(true);
2192        }
2193      }
2194      // Coordinator mode has its own system prompt and filters out Sleep, so
2195      // the generic proactive prompt would tell it to call a tool it can't
2196      // access and conflict with delegation instructions.
2197      if ((feature('PROACTIVE') || feature('KAIROS')) && ((options as {
2198        proactive?: boolean;
2199      }).proactive || isEnvTruthy(process.env.CLAUDE_CODE_PROACTIVE)) && !coordinatorModeModule?.isCoordinatorMode()) {
2200        /* eslint-disable @typescript-eslint/no-require-imports */
2201        const briefVisibility = feature('KAIROS') || feature('KAIROS_BRIEF') ? (require('./tools/BriefTool/BriefTool.js') as typeof import('./tools/BriefTool/BriefTool.js')).isBriefEnabled() ? 'Call SendUserMessage at checkpoints to mark where things stand.' : 'The user will see any text you output.' : 'The user will see any text you output.';
2202        /* eslint-enable @typescript-eslint/no-require-imports */
2203        const proactivePrompt = `\n# Proactive Mode\n\nYou are in proactive mode. Take initiative — explore, act, and make progress without waiting for instructions.\n\nStart by briefly greeting the user.\n\nYou will receive periodic <tick> prompts. These are check-ins. Do whatever seems most useful, or call Sleep if there's nothing to do. ${briefVisibility}`;
2204        appendSystemPrompt = appendSystemPrompt ? `${appendSystemPrompt}\n\n${proactivePrompt}` : proactivePrompt;
2205      }
2206      if (feature('KAIROS') && kairosEnabled && assistantModule) {
2207        const assistantAddendum = assistantModule.getAssistantSystemPromptAddendum();
2208        appendSystemPrompt = appendSystemPrompt ? `${appendSystemPrompt}\n\n${assistantAddendum}` : assistantAddendum;
2209      }
2210  
2211      // Ink root is only needed for interactive sessions — patchConsole in the
2212      // Ink constructor would swallow console output in headless mode.
2213      let root!: Root;
2214      let getFpsMetrics!: () => FpsMetrics | undefined;
2215      let stats!: StatsStore;
2216  
2217      // Show setup screens after commands are loaded
2218      if (!isNonInteractiveSession) {
2219        const ctx = getRenderContext(false);
2220        getFpsMetrics = ctx.getFpsMetrics;
2221        stats = ctx.stats;
2222        // Install asciicast recorder before Ink mounts (ant-only, opt-in via CLAUDE_CODE_TERMINAL_RECORDING=1)
2223        if ("external" === 'ant') {
2224          installAsciicastRecorder();
2225        }
2226        const {
2227          createRoot
2228        } = await import('./ink.js');
2229        root = await createRoot(ctx.renderOptions);
2230  
2231        // Log startup time now, before any blocking dialog renders. Logging
2232        // from REPL's first render (the old location) included however long
2233        // the user sat on trust/OAuth/onboarding/resume-picker — p99 was ~70s
2234        // dominated by dialog-wait time, not code-path startup.
2235        logEvent('tengu_timer', {
2236          event: 'startup' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
2237          durationMs: Math.round(process.uptime() * 1000)
2238        });
2239        logForDebugging('[STARTUP] Running showSetupScreens()...');
2240        const setupScreensStart = Date.now();
2241        const onboardingShown = await showSetupScreens(root, permissionMode, allowDangerouslySkipPermissions, commands, enableClaudeInChrome, devChannels);
2242        logForDebugging(`[STARTUP] showSetupScreens() completed in ${Date.now() - setupScreensStart}ms`);
2243  
2244        // Now that trust is established and GrowthBook has auth headers,
2245        // resolve the --remote-control / --rc entitlement gate.
2246        if (feature('BRIDGE_MODE') && remoteControlOption !== undefined) {
2247          const {
2248            getBridgeDisabledReason
2249          } = await import('./bridge/bridgeEnabled.js');
2250          const disabledReason = await getBridgeDisabledReason();
2251          remoteControl = disabledReason === null;
2252          if (disabledReason) {
2253            process.stderr.write(chalk.yellow(`${disabledReason}\n--rc flag ignored.\n`));
2254          }
2255        }
2256  
2257        // Check for pending agent memory snapshot updates (only for --agent mode, ant-only)
2258        if (feature('AGENT_MEMORY_SNAPSHOT') && mainThreadAgentDefinition && isCustomAgent(mainThreadAgentDefinition) && mainThreadAgentDefinition.memory && mainThreadAgentDefinition.pendingSnapshotUpdate) {
2259          const agentDef = mainThreadAgentDefinition;
2260          const choice = await launchSnapshotUpdateDialog(root, {
2261            agentType: agentDef.agentType,
2262            scope: agentDef.memory!,
2263            snapshotTimestamp: agentDef.pendingSnapshotUpdate!.snapshotTimestamp
2264          });
2265          if (choice === 'merge') {
2266            const {
2267              buildMergePrompt
2268            } = await import('./components/agents/SnapshotUpdateDialog.js');
2269            const mergePrompt = buildMergePrompt(agentDef.agentType, agentDef.memory!);
2270            inputPrompt = inputPrompt ? `${mergePrompt}\n\n${inputPrompt}` : mergePrompt;
2271          }
2272          agentDef.pendingSnapshotUpdate = undefined;
2273        }
2274  
2275        // Skip executing /login if we just completed onboarding for it
2276        if (onboardingShown && prompt?.trim().toLowerCase() === '/login') {
2277          prompt = '';
2278        }
2279        if (onboardingShown) {
2280          // Refresh auth-dependent services now that the user has logged in during onboarding.
2281          // Keep in sync with the post-login logic in src/commands/login.tsx
2282          void refreshRemoteManagedSettings();
2283          void refreshPolicyLimits();
2284          // Clear user data cache BEFORE GrowthBook refresh so it picks up fresh credentials
2285          resetUserCache();
2286          // Refresh GrowthBook after login to get updated feature flags (e.g., for claude.ai MCPs)
2287          refreshGrowthBookAfterAuthChange();
2288          // Clear any stale trusted device token then enroll for Remote Control.
2289          // Both self-gate on tengu_sessions_elevated_auth_enforcement internally
2290          // — enrollTrustedDevice() via checkGate_CACHED_OR_BLOCKING (awaits
2291          // the GrowthBook reinit above), clearTrustedDeviceToken() via the
2292          // sync cached check (acceptable since clear is idempotent).
2293          void import('./bridge/trustedDevice.js').then(m => {
2294            m.clearTrustedDeviceToken();
2295            return m.enrollTrustedDevice();
2296          });
2297        }
2298  
2299        // Validate that the active token's org matches forceLoginOrgUUID (if set
2300        // in managed settings). Runs after onboarding so managed settings and
2301        // login state are fully loaded.
2302        const orgValidation = await validateForceLoginOrg();
2303        if (!orgValidation.valid) {
2304          await exitWithError(root, orgValidation.message);
2305        }
2306      }
2307  
2308      // If gracefulShutdown was initiated (e.g., user rejected trust dialog),
2309      // process.exitCode will be set. Skip all subsequent operations that could
2310      // trigger code execution before the process exits (e.g. we don't want apiKeyHelper
2311      // to run if trust was not established).
2312      if (process.exitCode !== undefined) {
2313        logForDebugging('Graceful shutdown initiated, skipping further initialization');
2314        return;
2315      }
2316  
2317      // Initialize LSP manager AFTER trust is established (or in non-interactive mode
2318      // where trust is implicit). This prevents plugin LSP servers from executing
2319      // code in untrusted directories before user consent.
2320      // Must be after inline plugins are set (if any) so --plugin-dir LSP servers are included.
2321      initializeLspServerManager();
2322  
2323      // Show settings validation errors after trust is established
2324      // MCP config errors don't block settings from loading, so exclude them
2325      if (!isNonInteractiveSession) {
2326        const {
2327          errors
2328        } = getSettingsWithErrors();
2329        const nonMcpErrors = errors.filter(e => !e.mcpErrorMetadata);
2330        if (nonMcpErrors.length > 0) {
2331          await launchInvalidSettingsDialog(root, {
2332            settingsErrors: nonMcpErrors,
2333            onExit: () => gracefulShutdownSync(1)
2334          });
2335        }
2336      }
2337  
2338      // Check quota status, fast mode, passes eligibility, and bootstrap data
2339      // after trust is established. These make API calls which could trigger
2340      // apiKeyHelper execution.
2341      // --bare / SIMPLE: skip — these are cache-warms for the REPL's
2342      // first-turn responsiveness (quota, passes, fastMode, bootstrap data). Fast
2343      // mode doesn't apply to the Agent SDK anyway (see getFastModeUnavailableReason).
2344      const bgRefreshThrottleMs = getFeatureValue_CACHED_MAY_BE_STALE('tengu_cicada_nap_ms', 0);
2345      const lastPrefetched = getGlobalConfig().startupPrefetchedAt ?? 0;
2346      const skipStartupPrefetches = isBareMode() || bgRefreshThrottleMs > 0 && Date.now() - lastPrefetched < bgRefreshThrottleMs;
2347      if (!skipStartupPrefetches) {
2348        const lastPrefetchedInfo = lastPrefetched > 0 ? ` last ran ${Math.round((Date.now() - lastPrefetched) / 1000)}s ago` : '';
2349        logForDebugging(`Starting background startup prefetches${lastPrefetchedInfo}`);
2350        checkQuotaStatus().catch(error => logError(error));
2351  
2352        // Fetch bootstrap data from the server and update all cache values.
2353        void fetchBootstrapData();
2354  
2355        // TODO: Consolidate other prefetches into a single bootstrap request.
2356        void prefetchPassesEligibility();
2357        if (!getFeatureValue_CACHED_MAY_BE_STALE('tengu_miraculo_the_bard', false)) {
2358          void prefetchFastModeStatus();
2359        } else {
2360          // Kill switch skips the network call, not org-policy enforcement.
2361          // Resolve from cache so orgStatus doesn't stay 'pending' (which
2362          // getFastModeUnavailableReason treats as permissive).
2363          resolveFastModeStatusFromCache();
2364        }
2365        if (bgRefreshThrottleMs > 0) {
2366          saveGlobalConfig(current => ({
2367            ...current,
2368            startupPrefetchedAt: Date.now()
2369          }));
2370        }
2371      } else {
2372        logForDebugging(`Skipping startup prefetches, last ran ${Math.round((Date.now() - lastPrefetched) / 1000)}s ago`);
2373        // Resolve fast mode org status from cache (no network)
2374        resolveFastModeStatusFromCache();
2375      }
2376      if (!isNonInteractiveSession) {
2377        void refreshExampleCommands(); // Pre-fetch example commands (runs git log, no API call)
2378      }
2379  
2380      // Resolve MCP configs (started early, overlaps with setup/trust dialog work)
2381      const {
2382        servers: existingMcpConfigs
2383      } = await mcpConfigPromise;
2384      logForDebugging(`[STARTUP] MCP configs resolved in ${mcpConfigResolvedMs}ms (awaited at +${Date.now() - mcpConfigStart}ms)`);
2385      // CLI flag (--mcp-config) should override file-based configs, matching settings precedence
2386      const allMcpConfigs = {
2387        ...existingMcpConfigs,
2388        ...dynamicMcpConfig
2389      };
2390  
2391      // Separate SDK configs from regular MCP configs
2392      const sdkMcpConfigs: Record<string, McpSdkServerConfig> = {};
2393      const regularMcpConfigs: Record<string, ScopedMcpServerConfig> = {};
2394      for (const [name, config] of Object.entries(allMcpConfigs)) {
2395        const typedConfig = config as ScopedMcpServerConfig | McpSdkServerConfig;
2396        if (typedConfig.type === 'sdk') {
2397          sdkMcpConfigs[name] = typedConfig as McpSdkServerConfig;
2398        } else {
2399          regularMcpConfigs[name] = typedConfig as ScopedMcpServerConfig;
2400        }
2401      }
2402      profileCheckpoint('action_mcp_configs_loaded');
2403  
2404      // Prefetch MCP resources after trust dialog (this is where execution happens).
2405      // Interactive mode only: print mode defers connects until headlessStore exists
2406      // and pushes per-server (below), so ToolSearch's pending-client handling works
2407      // and one slow server doesn't block the batch.
2408      const localMcpPromise = isNonInteractiveSession ? Promise.resolve({
2409        clients: [],
2410        tools: [],
2411        commands: []
2412      }) : prefetchAllMcpResources(regularMcpConfigs);
2413      const claudeaiMcpPromise = isNonInteractiveSession ? Promise.resolve({
2414        clients: [],
2415        tools: [],
2416        commands: []
2417      }) : claudeaiConfigPromise.then(configs => Object.keys(configs).length > 0 ? prefetchAllMcpResources(configs) : {
2418        clients: [],
2419        tools: [],
2420        commands: []
2421      });
2422      // Merge with dedup by name: each prefetchAllMcpResources call independently
2423      // adds helper tools (ListMcpResourcesTool, ReadMcpResourceTool) via
2424      // local dedup flags, so merging two calls can yield duplicates. print.ts
2425      // already uniqBy's the final tool pool, but dedup here keeps appState clean.
2426      const mcpPromise = Promise.all([localMcpPromise, claudeaiMcpPromise]).then(([local, claudeai]) => ({
2427        clients: [...local.clients, ...claudeai.clients],
2428        tools: uniqBy([...local.tools, ...claudeai.tools], 'name'),
2429        commands: uniqBy([...local.commands, ...claudeai.commands], 'name')
2430      }));
2431  
2432      // Start hooks early so they run in parallel with MCP connections.
2433      // Skip for initOnly/init/maintenance (handled separately), non-interactive
2434      // (handled via setupTrigger), and resume/continue (conversationRecovery.ts
2435      // fires 'resume' instead — without this guard, hooks fire TWICE on /resume
2436      // and the second systemMessage clobbers the first. gh-30825)
2437      const hooksPromise = initOnly || init || maintenance || isNonInteractiveSession || options.continue || options.resume ? null : processSessionStartHooks('startup', {
2438        agentType: mainThreadAgentDefinition?.agentType,
2439        model: resolvedInitialModel
2440      });
2441  
2442      // MCP never blocks REPL render OR turn 1 TTFT. useManageMCPConnections
2443      // populates appState.mcp async as servers connect (connectToServer is
2444      // memoized — the prefetch calls above and the hook converge on the same
2445      // connections). getToolUseContext reads store.getState() fresh via
2446      // computeTools(), so turn 1 sees whatever's connected by query time.
2447      // Slow servers populate for turn 2+. Matches interactive-no-prompt
2448      // behavior. Print mode: per-server push into headlessStore (below).
2449      const hookMessages: Awaited<NonNullable<typeof hooksPromise>> = [];
2450      // Suppress transient unhandledRejection — the prefetch warms the
2451      // memoized connectToServer cache but nobody awaits it in interactive.
2452      mcpPromise.catch(() => {});
2453      const mcpClients: Awaited<typeof mcpPromise>['clients'] = [];
2454      const mcpTools: Awaited<typeof mcpPromise>['tools'] = [];
2455      const mcpCommands: Awaited<typeof mcpPromise>['commands'] = [];
2456      let thinkingEnabled = shouldEnableThinkingByDefault();
2457      let thinkingConfig: ThinkingConfig = thinkingEnabled !== false ? {
2458        type: 'adaptive'
2459      } : {
2460        type: 'disabled'
2461      };
2462      if (options.thinking === 'adaptive' || options.thinking === 'enabled') {
2463        thinkingEnabled = true;
2464        thinkingConfig = {
2465          type: 'adaptive'
2466        };
2467      } else if (options.thinking === 'disabled') {
2468        thinkingEnabled = false;
2469        thinkingConfig = {
2470          type: 'disabled'
2471        };
2472      } else {
2473        const maxThinkingTokens = process.env.MAX_THINKING_TOKENS ? parseInt(process.env.MAX_THINKING_TOKENS, 10) : options.maxThinkingTokens;
2474        if (maxThinkingTokens !== undefined) {
2475          if (maxThinkingTokens > 0) {
2476            thinkingEnabled = true;
2477            thinkingConfig = {
2478              type: 'enabled',
2479              budgetTokens: maxThinkingTokens
2480            };
2481          } else if (maxThinkingTokens === 0) {
2482            thinkingEnabled = false;
2483            thinkingConfig = {
2484              type: 'disabled'
2485            };
2486          }
2487        }
2488      }
2489      logForDiagnosticsNoPII('info', 'started', {
2490        version: MACRO.VERSION,
2491        is_native_binary: isInBundledMode()
2492      });
2493      registerCleanup(async () => {
2494        logForDiagnosticsNoPII('info', 'exited');
2495      });
2496      void logTenguInit({
2497        hasInitialPrompt: Boolean(prompt),
2498        hasStdin: Boolean(inputPrompt),
2499        verbose,
2500        debug,
2501        debugToStderr,
2502        print: print ?? false,
2503        outputFormat: outputFormat ?? 'text',
2504        inputFormat: inputFormat ?? 'text',
2505        numAllowedTools: allowedTools.length,
2506        numDisallowedTools: disallowedTools.length,
2507        mcpClientCount: Object.keys(allMcpConfigs).length,
2508        worktreeEnabled,
2509        skipWebFetchPreflight: getInitialSettings().skipWebFetchPreflight,
2510        githubActionInputs: process.env.GITHUB_ACTION_INPUTS,
2511        dangerouslySkipPermissionsPassed: dangerouslySkipPermissions ?? false,
2512        permissionMode,
2513        modeIsBypass: permissionMode === 'bypassPermissions',
2514        allowDangerouslySkipPermissionsPassed: allowDangerouslySkipPermissions,
2515        systemPromptFlag: systemPrompt ? options.systemPromptFile ? 'file' : 'flag' : undefined,
2516        appendSystemPromptFlag: appendSystemPrompt ? options.appendSystemPromptFile ? 'file' : 'flag' : undefined,
2517        thinkingConfig,
2518        assistantActivationPath: feature('KAIROS') && kairosEnabled ? assistantModule?.getAssistantActivationPath() : undefined
2519      });
2520  
2521      // Log context metrics once at initialization
2522      void logContextMetrics(regularMcpConfigs, toolPermissionContext);
2523      void logPermissionContextForAnts(null, 'initialization');
2524      logManagedSettings();
2525  
2526      // Register PID file for concurrent-session detection (~/.claude/sessions/)
2527      // and fire multi-clauding telemetry. Lives here (not init.ts) so only the
2528      // REPL path registers — not subcommands like `claude doctor`. Chained:
2529      // count must run after register's write completes or it misses our own file.
2530      void registerSession().then(registered => {
2531        if (!registered) return;
2532        if (sessionNameArg) {
2533          void updateSessionName(sessionNameArg);
2534        }
2535        void countConcurrentSessions().then(count => {
2536          if (count >= 2) {
2537            logEvent('tengu_concurrent_sessions', {
2538              num_sessions: count
2539            });
2540          }
2541        });
2542      });
2543  
2544      // Initialize versioned plugins system (triggers V1→V2 migration if
2545      // needed). Then run orphan GC, THEN warm the Grep/Glob exclusion cache.
2546      // Sequencing matters: the warmup scans disk for .orphaned_at markers,
2547      // so it must see the GC's Pass 1 (remove markers from reinstalled
2548      // versions) and Pass 2 (stamp unmarked orphans) already applied. The
2549      // warm also lands before autoupdate (fires on first submit in REPL)
2550      // can orphan this session's active version underneath us.
2551      // --bare / SIMPLE: skip plugin version sync + orphan cleanup. These
2552      // are install/upgrade bookkeeping that scripted calls don't need —
2553      // the next interactive session will reconcile. The await here was
2554      // blocking -p on a marketplace round-trip.
2555      if (isBareMode()) {
2556        // skip — no-op
2557      } else if (isNonInteractiveSession) {
2558        // In headless mode, await to ensure plugin sync completes before CLI exits
2559        await initializeVersionedPlugins();
2560        profileCheckpoint('action_after_plugins_init');
2561        void cleanupOrphanedPluginVersionsInBackground().then(() => getGlobExclusionsForPluginCache());
2562      } else {
2563        // In interactive mode, fire-and-forget — this is purely bookkeeping
2564        // that doesn't affect runtime behavior of the current session
2565        void initializeVersionedPlugins().then(async () => {
2566          profileCheckpoint('action_after_plugins_init');
2567          await cleanupOrphanedPluginVersionsInBackground();
2568          void getGlobExclusionsForPluginCache();
2569        });
2570      }
2571      const setupTrigger = initOnly || init ? 'init' : maintenance ? 'maintenance' : null;
2572      if (initOnly) {
2573        applyConfigEnvironmentVariables();
2574        await processSetupHooks('init', {
2575          forceSyncExecution: true
2576        });
2577        await processSessionStartHooks('startup', {
2578          forceSyncExecution: true
2579        });
2580        gracefulShutdownSync(0);
2581        return;
2582      }
2583  
2584      // --print mode
2585      if (isNonInteractiveSession) {
2586        if (outputFormat === 'stream-json' || outputFormat === 'json') {
2587          setHasFormattedOutput(true);
2588        }
2589  
2590        // Apply full environment variables in print mode since trust dialog is bypassed
2591        // This includes potentially dangerous environment variables from untrusted sources
2592        // but print mode is considered trusted (as documented in help text)
2593        applyConfigEnvironmentVariables();
2594  
2595        // Initialize telemetry after env vars are applied so OTEL endpoint env vars and
2596        // otelHeadersHelper (which requires trust to execute) are available.
2597        initializeTelemetryAfterTrust();
2598  
2599        // Kick SessionStart hooks now so the subprocess spawn overlaps with
2600        // MCP connect + plugin init + print.ts import below. loadInitialMessages
2601        // joins this at print.ts:4397. Guarded same as loadInitialMessages —
2602        // continue/resume/teleport paths don't fire startup hooks (or fire them
2603        // conditionally inside the resume branch, where this promise is
2604        // undefined and the ?? fallback runs). Also skip when setupTrigger is
2605        // set — those paths run setup hooks first (print.ts:544), and session
2606        // start hooks must wait until setup completes.
2607        const sessionStartHooksPromise = options.continue || options.resume || teleport || setupTrigger ? undefined : processSessionStartHooks('startup');
2608        // Suppress transient unhandledRejection if this rejects before
2609        // loadInitialMessages awaits it. Downstream await still observes the
2610        // rejection — this just prevents the spurious global handler fire.
2611        sessionStartHooksPromise?.catch(() => {});
2612        profileCheckpoint('before_validateForceLoginOrg');
2613        // Validate org restriction for non-interactive sessions
2614        const orgValidation = await validateForceLoginOrg();
2615        if (!orgValidation.valid) {
2616          process.stderr.write(orgValidation.message + '\n');
2617          process.exit(1);
2618        }
2619  
2620        // Headless mode supports all prompt commands and some local commands
2621        // If disableSlashCommands is true, return empty array
2622        const commandsHeadless = disableSlashCommands ? [] : commands.filter(command => command.type === 'prompt' && !command.disableNonInteractive || command.type === 'local' && command.supportsNonInteractive);
2623        const defaultState = getDefaultAppState();
2624        const headlessInitialState: AppState = {
2625          ...defaultState,
2626          mcp: {
2627            ...defaultState.mcp,
2628            clients: mcpClients,
2629            commands: mcpCommands,
2630            tools: mcpTools
2631          },
2632          toolPermissionContext,
2633          effortValue: parseEffortValue(options.effort) ?? getInitialEffortSetting(),
2634          ...(isFastModeEnabled() && {
2635            fastMode: getInitialFastModeSetting(effectiveModel ?? null)
2636          }),
2637          ...(isAdvisorEnabled() && advisorModel && {
2638            advisorModel
2639          }),
2640          // kairosEnabled gates the async fire-and-forget path in
2641          // executeForkedSlashCommand (processSlashCommand.tsx:132) and
2642          // AgentTool's shouldRunAsync. The REPL initialState sets this at
2643          // ~3459; headless was defaulting to false, so the daemon child's
2644          // scheduled tasks and Agent-tool calls ran synchronously — N
2645          // overdue cron tasks on spawn = N serial subagent turns blocking
2646          // user input. Computed at :1620, well before this branch.
2647          ...(feature('KAIROS') ? {
2648            kairosEnabled
2649          } : {})
2650        };
2651  
2652        // Init app state
2653        const headlessStore = createStore(headlessInitialState, onChangeAppState);
2654  
2655        // Check if bypassPermissions should be disabled based on Statsig gate
2656        // This runs in parallel to the code below, to avoid blocking the main loop.
2657        if (toolPermissionContext.mode === 'bypassPermissions' || allowDangerouslySkipPermissions) {
2658          void checkAndDisableBypassPermissions(toolPermissionContext);
2659        }
2660  
2661        // Async check of auto mode gate — corrects state and disables auto if needed.
2662        // Gated on TRANSCRIPT_CLASSIFIER (not USER_TYPE) so GrowthBook kill switch runs for external builds too.
2663        if (feature('TRANSCRIPT_CLASSIFIER')) {
2664          void verifyAutoModeGateAccess(toolPermissionContext, headlessStore.getState().fastMode).then(({
2665            updateContext
2666          }) => {
2667            headlessStore.setState(prev => {
2668              const nextCtx = updateContext(prev.toolPermissionContext);
2669              if (nextCtx === prev.toolPermissionContext) return prev;
2670              return {
2671                ...prev,
2672                toolPermissionContext: nextCtx
2673              };
2674            });
2675          });
2676        }
2677  
2678        // Set global state for session persistence
2679        if (options.sessionPersistence === false) {
2680          setSessionPersistenceDisabled(true);
2681        }
2682  
2683        // Store SDK betas in global state for context window calculation
2684        // Only store allowed betas (filters by allowlist and subscriber status)
2685        setSdkBetas(filterAllowedSdkBetas(betas));
2686  
2687        // Print-mode MCP: per-server incremental push into headlessStore.
2688        // Mirrors useManageMCPConnections — push pending first (so ToolSearch's
2689        // pending-check at ToolSearchTool.ts:334 sees them), then replace with
2690        // connected/failed as each server settles.
2691        const connectMcpBatch = (configs: Record<string, ScopedMcpServerConfig>, label: string): Promise<void> => {
2692          if (Object.keys(configs).length === 0) return Promise.resolve();
2693          headlessStore.setState(prev => ({
2694            ...prev,
2695            mcp: {
2696              ...prev.mcp,
2697              clients: [...prev.mcp.clients, ...Object.entries(configs).map(([name, config]) => ({
2698                name,
2699                type: 'pending' as const,
2700                config
2701              }))]
2702            }
2703          }));
2704          return getMcpToolsCommandsAndResources(({
2705            client,
2706            tools,
2707            commands
2708          }) => {
2709            headlessStore.setState(prev => ({
2710              ...prev,
2711              mcp: {
2712                ...prev.mcp,
2713                clients: prev.mcp.clients.some(c => c.name === client.name) ? prev.mcp.clients.map(c => c.name === client.name ? client : c) : [...prev.mcp.clients, client],
2714                tools: uniqBy([...prev.mcp.tools, ...tools], 'name'),
2715                commands: uniqBy([...prev.mcp.commands, ...commands], 'name')
2716              }
2717            }));
2718          }, configs).catch(err => logForDebugging(`[MCP] ${label} connect error: ${err}`));
2719        };
2720        // Await all MCP configs — print mode is often single-turn, so
2721        // "late-connecting servers visible next turn" doesn't help. SDK init
2722        // message and turn-1 tool list both need configured MCP tools present.
2723        // Zero-server case is free via the early return in connectMcpBatch.
2724        // Connectors parallelize inside getMcpToolsCommandsAndResources
2725        // (processBatched with Promise.all). claude.ai is awaited too — its
2726        // fetch was kicked off early (line ~2558) so only residual time blocks
2727        // here. --bare skips claude.ai entirely for perf-sensitive scripts.
2728        profileCheckpoint('before_connectMcp');
2729        await connectMcpBatch(regularMcpConfigs, 'regular');
2730        profileCheckpoint('after_connectMcp');
2731        // Dedup: suppress plugin MCP servers that duplicate a claude.ai
2732        // connector (connector wins), then connect claude.ai servers.
2733        // Bounded wait — #23725 made this blocking so single-turn -p sees
2734        // connectors, but with 40+ slow connectors tengu_startup_perf p99
2735        // climbed to 76s. If fetch+connect doesn't finish in time, proceed;
2736        // the promise keeps running and updates headlessStore in the
2737        // background so turn 2+ still sees connectors.
2738        const CLAUDE_AI_MCP_TIMEOUT_MS = 5_000;
2739        const claudeaiConnect = claudeaiConfigPromise.then(claudeaiConfigs => {
2740          if (Object.keys(claudeaiConfigs).length > 0) {
2741            const claudeaiSigs = new Set<string>();
2742            for (const config of Object.values(claudeaiConfigs)) {
2743              const sig = getMcpServerSignature(config);
2744              if (sig) claudeaiSigs.add(sig);
2745            }
2746            const suppressed = new Set<string>();
2747            for (const [name, config] of Object.entries(regularMcpConfigs)) {
2748              if (!name.startsWith('plugin:')) continue;
2749              const sig = getMcpServerSignature(config);
2750              if (sig && claudeaiSigs.has(sig)) suppressed.add(name);
2751            }
2752            if (suppressed.size > 0) {
2753              logForDebugging(`[MCP] Lazy dedup: suppressing ${suppressed.size} plugin server(s) that duplicate claude.ai connectors: ${[...suppressed].join(', ')}`);
2754              // Disconnect before filtering from state. Only connected
2755              // servers need cleanup — clearServerCache on a never-connected
2756              // server triggers a real connect just to kill it (memoize
2757              // cache-miss path, see useManageMCPConnections.ts:870).
2758              for (const c of headlessStore.getState().mcp.clients) {
2759                if (!suppressed.has(c.name) || c.type !== 'connected') continue;
2760                c.client.onclose = undefined;
2761                void clearServerCache(c.name, c.config).catch(() => {});
2762              }
2763              headlessStore.setState(prev => {
2764                let {
2765                  clients,
2766                  tools,
2767                  commands,
2768                  resources
2769                } = prev.mcp;
2770                clients = clients.filter(c => !suppressed.has(c.name));
2771                tools = tools.filter(t => !t.mcpInfo || !suppressed.has(t.mcpInfo.serverName));
2772                for (const name of suppressed) {
2773                  commands = excludeCommandsByServer(commands, name);
2774                  resources = excludeResourcesByServer(resources, name);
2775                }
2776                return {
2777                  ...prev,
2778                  mcp: {
2779                    ...prev.mcp,
2780                    clients,
2781                    tools,
2782                    commands,
2783                    resources
2784                  }
2785                };
2786              });
2787            }
2788          }
2789          // Suppress claude.ai connectors that duplicate an enabled
2790          // manual server (URL-signature match). Plugin dedup above only
2791          // handles `plugin:*` keys; this catches manual `.mcp.json` entries.
2792          // plugin:* must be excluded here — step 1 already suppressed
2793          // those (claude.ai wins); leaving them in suppresses the
2794          // connector too, and neither survives (gh-39974).
2795          const nonPluginConfigs = pickBy(regularMcpConfigs, (_, n) => !n.startsWith('plugin:'));
2796          const {
2797            servers: dedupedClaudeAi
2798          } = dedupClaudeAiMcpServers(claudeaiConfigs, nonPluginConfigs);
2799          return connectMcpBatch(dedupedClaudeAi, 'claudeai');
2800        });
2801        let claudeaiTimer: ReturnType<typeof setTimeout> | undefined;
2802        const claudeaiTimedOut = await Promise.race([claudeaiConnect.then(() => false), new Promise<boolean>(resolve => {
2803          claudeaiTimer = setTimeout(r => r(true), CLAUDE_AI_MCP_TIMEOUT_MS, resolve);
2804        })]);
2805        if (claudeaiTimer) clearTimeout(claudeaiTimer);
2806        if (claudeaiTimedOut) {
2807          logForDebugging(`[MCP] claude.ai connectors not ready after ${CLAUDE_AI_MCP_TIMEOUT_MS}ms — proceeding; background connection continues`);
2808        }
2809        profileCheckpoint('after_connectMcp_claudeai');
2810  
2811        // In headless mode, start deferred prefetches immediately (no user typing delay)
2812        // --bare / SIMPLE: startDeferredPrefetches early-returns internally.
2813        // backgroundHousekeeping (initExtractMemories, pruneShellSnapshots,
2814        // cleanupOldMessageFiles) and sdkHeapDumpMonitor are all bookkeeping
2815        // that scripted calls don't need — the next interactive session reconciles.
2816        if (!isBareMode()) {
2817          startDeferredPrefetches();
2818          void import('./utils/backgroundHousekeeping.js').then(m => m.startBackgroundHousekeeping());
2819          if ("external" === 'ant') {
2820            void import('./utils/sdkHeapDumpMonitor.js').then(m => m.startSdkMemoryMonitor());
2821          }
2822        }
2823        logSessionTelemetry();
2824        profileCheckpoint('before_print_import');
2825        const {
2826          runHeadless
2827        } = await import('src/cli/print.js');
2828        profileCheckpoint('after_print_import');
2829        void runHeadless(inputPrompt, () => headlessStore.getState(), headlessStore.setState, commandsHeadless, tools, sdkMcpConfigs, agentDefinitions.activeAgents, {
2830          continue: options.continue,
2831          resume: options.resume,
2832          verbose: verbose,
2833          outputFormat: outputFormat,
2834          jsonSchema,
2835          permissionPromptToolName: options.permissionPromptTool,
2836          allowedTools,
2837          thinkingConfig,
2838          maxTurns: options.maxTurns,
2839          maxBudgetUsd: options.maxBudgetUsd,
2840          taskBudget: options.taskBudget ? {
2841            total: options.taskBudget
2842          } : undefined,
2843          systemPrompt,
2844          appendSystemPrompt,
2845          userSpecifiedModel: effectiveModel,
2846          fallbackModel: userSpecifiedFallbackModel,
2847          teleport,
2848          sdkUrl,
2849          replayUserMessages: effectiveReplayUserMessages,
2850          includePartialMessages: effectiveIncludePartialMessages,
2851          forkSession: options.forkSession || false,
2852          resumeSessionAt: options.resumeSessionAt || undefined,
2853          rewindFiles: options.rewindFiles,
2854          enableAuthStatus: options.enableAuthStatus,
2855          agent: agentCli,
2856          workload: options.workload,
2857          setupTrigger: setupTrigger ?? undefined,
2858          sessionStartHooksPromise
2859        });
2860        return;
2861      }
2862  
2863      // Log model config at startup
2864      logEvent('tengu_startup_manual_model_config', {
2865        cli_flag: options.model as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
2866        env_var: process.env.ANTHROPIC_MODEL as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
2867        settings_file: (getInitialSettings() || {}).model as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
2868        subscriptionType: getSubscriptionType() as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
2869        agent: agentSetting as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
2870      });
2871  
2872      // Get deprecation warning for the initial model (resolvedInitialModel computed earlier for hooks parallelization)
2873      const deprecationWarning = getModelDeprecationWarning(resolvedInitialModel);
2874  
2875      // Build initial notification queue
2876      const initialNotifications: Array<{
2877        key: string;
2878        text: string;
2879        color?: 'warning';
2880        priority: 'high';
2881      }> = [];
2882      if (permissionModeNotification) {
2883        initialNotifications.push({
2884          key: 'permission-mode-notification',
2885          text: permissionModeNotification,
2886          priority: 'high'
2887        });
2888      }
2889      if (deprecationWarning) {
2890        initialNotifications.push({
2891          key: 'model-deprecation-warning',
2892          text: deprecationWarning,
2893          color: 'warning',
2894          priority: 'high'
2895        });
2896      }
2897      if (overlyBroadBashPermissions.length > 0) {
2898        const displayList = uniq(overlyBroadBashPermissions.map(p => p.ruleDisplay));
2899        const displays = displayList.join(', ');
2900        const sources = uniq(overlyBroadBashPermissions.map(p => p.sourceDisplay)).join(', ');
2901        const n = displayList.length;
2902        initialNotifications.push({
2903          key: 'overly-broad-bash-notification',
2904          text: `${displays} allow ${plural(n, 'rule')} from ${sources} ${plural(n, 'was', 'were')} ignored \u2014 not available for Ants, please use auto-mode instead`,
2905          color: 'warning',
2906          priority: 'high'
2907        });
2908      }
2909      const effectiveToolPermissionContext = {
2910        ...toolPermissionContext,
2911        mode: isAgentSwarmsEnabled() && getTeammateUtils().isPlanModeRequired() ? 'plan' as const : toolPermissionContext.mode
2912      };
2913      // All startup opt-in paths (--tools, --brief, defaultView) have fired
2914      // above; initialIsBriefOnly just reads the resulting state.
2915      const initialIsBriefOnly = feature('KAIROS') || feature('KAIROS_BRIEF') ? getUserMsgOptIn() : false;
2916      const fullRemoteControl = remoteControl || getRemoteControlAtStartup() || kairosEnabled;
2917      let ccrMirrorEnabled = false;
2918      if (feature('CCR_MIRROR') && !fullRemoteControl) {
2919        /* eslint-disable @typescript-eslint/no-require-imports */
2920        const {
2921          isCcrMirrorEnabled
2922        } = require('./bridge/bridgeEnabled.js') as typeof import('./bridge/bridgeEnabled.js');
2923        /* eslint-enable @typescript-eslint/no-require-imports */
2924        ccrMirrorEnabled = isCcrMirrorEnabled();
2925      }
2926      const initialState: AppState = {
2927        settings: getInitialSettings(),
2928        tasks: {},
2929        agentNameRegistry: new Map(),
2930        verbose: verbose ?? getGlobalConfig().verbose ?? false,
2931        mainLoopModel: initialMainLoopModel,
2932        mainLoopModelForSession: null,
2933        isBriefOnly: initialIsBriefOnly,
2934        expandedView: getGlobalConfig().showSpinnerTree ? 'teammates' : getGlobalConfig().showExpandedTodos ? 'tasks' : 'none',
2935        showTeammateMessagePreview: isAgentSwarmsEnabled() ? false : undefined,
2936        selectedIPAgentIndex: -1,
2937        coordinatorTaskIndex: -1,
2938        viewSelectionMode: 'none',
2939        footerSelection: null,
2940        toolPermissionContext: effectiveToolPermissionContext,
2941        agent: mainThreadAgentDefinition?.agentType,
2942        agentDefinitions,
2943        mcp: {
2944          clients: [],
2945          tools: [],
2946          commands: [],
2947          resources: {},
2948          pluginReconnectKey: 0
2949        },
2950        plugins: {
2951          enabled: [],
2952          disabled: [],
2953          commands: [],
2954          errors: [],
2955          installationStatus: {
2956            marketplaces: [],
2957            plugins: []
2958          },
2959          needsRefresh: false
2960        },
2961        statusLineText: undefined,
2962        kairosEnabled,
2963        remoteSessionUrl: undefined,
2964        remoteConnectionStatus: 'connecting',
2965        remoteBackgroundTaskCount: 0,
2966        replBridgeEnabled: fullRemoteControl || ccrMirrorEnabled,
2967        replBridgeExplicit: remoteControl,
2968        replBridgeOutboundOnly: ccrMirrorEnabled,
2969        replBridgeConnected: false,
2970        replBridgeSessionActive: false,
2971        replBridgeReconnecting: false,
2972        replBridgeConnectUrl: undefined,
2973        replBridgeSessionUrl: undefined,
2974        replBridgeEnvironmentId: undefined,
2975        replBridgeSessionId: undefined,
2976        replBridgeError: undefined,
2977        replBridgeInitialName: remoteControlName,
2978        showRemoteCallout: false,
2979        notifications: {
2980          current: null,
2981          queue: initialNotifications
2982        },
2983        elicitation: {
2984          queue: []
2985        },
2986        todos: {},
2987        remoteAgentTaskSuggestions: [],
2988        fileHistory: {
2989          snapshots: [],
2990          trackedFiles: new Set(),
2991          snapshotSequence: 0
2992        },
2993        attribution: createEmptyAttributionState(),
2994        thinkingEnabled,
2995        promptSuggestionEnabled: shouldEnablePromptSuggestion(),
2996        sessionHooks: new Map(),
2997        inbox: {
2998          messages: []
2999        },
3000        promptSuggestion: {
3001          text: null,
3002          promptId: null,
3003          shownAt: 0,
3004          acceptedAt: 0,
3005          generationRequestId: null
3006        },
3007        speculation: IDLE_SPECULATION_STATE,
3008        speculationSessionTimeSavedMs: 0,
3009        skillImprovement: {
3010          suggestion: null
3011        },
3012        workerSandboxPermissions: {
3013          queue: [],
3014          selectedIndex: 0
3015        },
3016        pendingWorkerRequest: null,
3017        pendingSandboxRequest: null,
3018        authVersion: 0,
3019        initialMessage: inputPrompt ? {
3020          message: createUserMessage({
3021            content: String(inputPrompt)
3022          })
3023        } : null,
3024        effortValue: parseEffortValue(options.effort) ?? getInitialEffortSetting(),
3025        activeOverlays: new Set<string>(),
3026        fastMode: getInitialFastModeSetting(resolvedInitialModel),
3027        ...(isAdvisorEnabled() && advisorModel && {
3028          advisorModel
3029        }),
3030        // Compute teamContext synchronously to avoid useEffect setState during render.
3031        // KAIROS: assistantTeamContext takes precedence — set earlier in the
3032        // KAIROS block so Agent(name: "foo") can spawn in-process teammates
3033        // without TeamCreate. computeInitialTeamContext() is for tmux-spawned
3034        // teammates reading their own identity, not the assistant-mode leader.
3035        teamContext: feature('KAIROS') ? assistantTeamContext ?? computeInitialTeamContext?.() : computeInitialTeamContext?.()
3036      };
3037  
3038      // Add CLI initial prompt to history
3039      if (inputPrompt) {
3040        addToHistory(String(inputPrompt));
3041      }
3042      const initialTools = mcpTools;
3043  
3044      // Increment numStartups synchronously — first-render readers like
3045      // shouldShowEffortCallout (via useState initializer) need the updated
3046      // value before setImmediate fires. Defer only telemetry.
3047      saveGlobalConfig(current => ({
3048        ...current,
3049        numStartups: (current.numStartups ?? 0) + 1
3050      }));
3051      setImmediate(() => {
3052        void logStartupTelemetry();
3053        logSessionTelemetry();
3054      });
3055  
3056      // Set up per-turn session environment data uploader (ant-only build).
3057      // Default-enabled for all ant users when working in an Anthropic-owned
3058      // repo. Captures git/filesystem state (NOT transcripts) at each turn so
3059      // environments can be recreated at any user message index. Gating:
3060      //   - Build-time: this import is stubbed in external builds.
3061      //   - Runtime: uploader checks github.com/anthropics/* remote + gcloud auth.
3062      //   - Safety: CLAUDE_CODE_DISABLE_SESSION_DATA_UPLOAD=1 bypasses (tests set this).
3063      // Import is dynamic + async to avoid adding startup latency.
3064      const sessionUploaderPromise = "external" === 'ant' ? import('./utils/sessionDataUploader.js') : null;
3065  
3066      // Defer session uploader resolution to the onTurnComplete callback to avoid
3067      // adding a new top-level await in main.tsx (performance-critical path).
3068      // The per-turn auth logic in sessionDataUploader.ts handles unauthenticated
3069      // state gracefully (re-checks each turn, so auth recovery mid-session works).
3070      const uploaderReady = sessionUploaderPromise ? sessionUploaderPromise.then(mod => mod.createSessionTurnUploader()).catch(() => null) : null;
3071      const sessionConfig = {
3072        debug: debug || debugToStderr,
3073        commands: [...commands, ...mcpCommands],
3074        initialTools,
3075        mcpClients,
3076        autoConnectIdeFlag: ide,
3077        mainThreadAgentDefinition,
3078        disableSlashCommands,
3079        dynamicMcpConfig,
3080        strictMcpConfig,
3081        systemPrompt,
3082        appendSystemPrompt,
3083        taskListId,
3084        thinkingConfig,
3085        ...(uploaderReady && {
3086          onTurnComplete: (messages: MessageType[]) => {
3087            void uploaderReady.then(uploader => uploader?.(messages));
3088          }
3089        })
3090      };
3091  
3092      // Shared context for processResumedConversation calls
3093      const resumeContext = {
3094        modeApi: coordinatorModeModule,
3095        mainThreadAgentDefinition,
3096        agentDefinitions,
3097        currentCwd,
3098        cliAgents,
3099        initialState
3100      };
3101      if (options.continue) {
3102        // Continue the most recent conversation directly
3103        let resumeSucceeded = false;
3104        try {
3105          const resumeStart = performance.now();
3106  
3107          // Clear stale caches before resuming to ensure fresh file/skill discovery
3108          const {
3109            clearSessionCaches
3110          } = await import('./commands/clear/caches.js');
3111          clearSessionCaches();
3112          const result = await loadConversationForResume(undefined /* sessionId */, undefined /* sourceFile */);
3113          if (!result) {
3114            logEvent('tengu_continue', {
3115              success: false
3116            });
3117            return await exitWithError(root, 'No conversation found to continue');
3118          }
3119          const loaded = await processResumedConversation(result, {
3120            forkSession: !!options.forkSession,
3121            includeAttribution: true,
3122            transcriptPath: result.fullPath
3123          }, resumeContext);
3124          if (loaded.restoredAgentDef) {
3125            mainThreadAgentDefinition = loaded.restoredAgentDef;
3126          }
3127          maybeActivateProactive(options);
3128          maybeActivateBrief(options);
3129          logEvent('tengu_continue', {
3130            success: true,
3131            resume_duration_ms: Math.round(performance.now() - resumeStart)
3132          });
3133          resumeSucceeded = true;
3134          await launchRepl(root, {
3135            getFpsMetrics,
3136            stats,
3137            initialState: loaded.initialState
3138          }, {
3139            ...sessionConfig,
3140            mainThreadAgentDefinition: loaded.restoredAgentDef ?? mainThreadAgentDefinition,
3141            initialMessages: loaded.messages,
3142            initialFileHistorySnapshots: loaded.fileHistorySnapshots,
3143            initialContentReplacements: loaded.contentReplacements,
3144            initialAgentName: loaded.agentName,
3145            initialAgentColor: loaded.agentColor
3146          }, renderAndRun);
3147        } catch (error) {
3148          if (!resumeSucceeded) {
3149            logEvent('tengu_continue', {
3150              success: false
3151            });
3152          }
3153          logError(error);
3154          process.exit(1);
3155        }
3156      } else if (feature('DIRECT_CONNECT') && _pendingConnect?.url) {
3157        // `claude connect <url>` — full interactive TUI connected to a remote server
3158        let directConnectConfig;
3159        try {
3160          const session = await createDirectConnectSession({
3161            serverUrl: _pendingConnect.url,
3162            authToken: _pendingConnect.authToken,
3163            cwd: getOriginalCwd(),
3164            dangerouslySkipPermissions: _pendingConnect.dangerouslySkipPermissions
3165          });
3166          if (session.workDir) {
3167            setOriginalCwd(session.workDir);
3168            setCwdState(session.workDir);
3169          }
3170          setDirectConnectServerUrl(_pendingConnect.url);
3171          directConnectConfig = session.config;
3172        } catch (err) {
3173          return await exitWithError(root, err instanceof DirectConnectError ? err.message : String(err), () => gracefulShutdown(1));
3174        }
3175        const connectInfoMessage = createSystemMessage(`Connected to server at ${_pendingConnect.url}\nSession: ${directConnectConfig.sessionId}`, 'info');
3176        await launchRepl(root, {
3177          getFpsMetrics,
3178          stats,
3179          initialState
3180        }, {
3181          debug: debug || debugToStderr,
3182          commands,
3183          initialTools: [],
3184          initialMessages: [connectInfoMessage],
3185          mcpClients: [],
3186          autoConnectIdeFlag: ide,
3187          mainThreadAgentDefinition,
3188          disableSlashCommands,
3189          directConnectConfig,
3190          thinkingConfig
3191        }, renderAndRun);
3192        return;
3193      } else if (feature('SSH_REMOTE') && _pendingSSH?.host) {
3194        // `claude ssh <host> [dir]` — probe remote, deploy binary if needed,
3195        // spawn ssh with unix-socket -R forward to a local auth proxy, hand
3196        // the REPL an SSHSession. Tools run remotely, UI renders locally.
3197        // `--local` skips probe/deploy/ssh and spawns the current binary
3198        // directly with the same env — e2e test of the proxy/auth plumbing.
3199        const {
3200          createSSHSession,
3201          createLocalSSHSession,
3202          SSHSessionError
3203        } = await import('./ssh/createSSHSession.js');
3204        let sshSession;
3205        try {
3206          if (_pendingSSH.local) {
3207            process.stderr.write('Starting local ssh-proxy test session...\n');
3208            sshSession = createLocalSSHSession({
3209              cwd: _pendingSSH.cwd,
3210              permissionMode: _pendingSSH.permissionMode,
3211              dangerouslySkipPermissions: _pendingSSH.dangerouslySkipPermissions
3212            });
3213          } else {
3214            process.stderr.write(`Connecting to ${_pendingSSH.host}…\n`);
3215            // In-place progress: \r + EL0 (erase to end of line). Final \n on
3216            // success so the next message lands on a fresh line. No-op when
3217            // stderr isn't a TTY (piped/redirected) — \r would just emit noise.
3218            const isTTY = process.stderr.isTTY;
3219            let hadProgress = false;
3220            sshSession = await createSSHSession({
3221              host: _pendingSSH.host,
3222              cwd: _pendingSSH.cwd,
3223              localVersion: MACRO.VERSION,
3224              permissionMode: _pendingSSH.permissionMode,
3225              dangerouslySkipPermissions: _pendingSSH.dangerouslySkipPermissions,
3226              extraCliArgs: _pendingSSH.extraCliArgs
3227            }, isTTY ? {
3228              onProgress: msg => {
3229                hadProgress = true;
3230                process.stderr.write(`\r  ${msg}\x1b[K`);
3231              }
3232            } : {});
3233            if (hadProgress) process.stderr.write('\n');
3234          }
3235          setOriginalCwd(sshSession.remoteCwd);
3236          setCwdState(sshSession.remoteCwd);
3237          setDirectConnectServerUrl(_pendingSSH.local ? 'local' : _pendingSSH.host);
3238        } catch (err) {
3239          return await exitWithError(root, err instanceof SSHSessionError ? err.message : String(err), () => gracefulShutdown(1));
3240        }
3241        const sshInfoMessage = createSystemMessage(_pendingSSH.local ? `Local ssh-proxy test session\ncwd: ${sshSession.remoteCwd}\nAuth: unix socket → local proxy` : `SSH session to ${_pendingSSH.host}\nRemote cwd: ${sshSession.remoteCwd}\nAuth: unix socket -R → local proxy`, 'info');
3242        await launchRepl(root, {
3243          getFpsMetrics,
3244          stats,
3245          initialState
3246        }, {
3247          debug: debug || debugToStderr,
3248          commands,
3249          initialTools: [],
3250          initialMessages: [sshInfoMessage],
3251          mcpClients: [],
3252          autoConnectIdeFlag: ide,
3253          mainThreadAgentDefinition,
3254          disableSlashCommands,
3255          sshSession,
3256          thinkingConfig
3257        }, renderAndRun);
3258        return;
3259      } else if (feature('KAIROS') && _pendingAssistantChat && (_pendingAssistantChat.sessionId || _pendingAssistantChat.discover)) {
3260        // `claude assistant [sessionId]` — REPL as a pure viewer client
3261        // of a remote assistant session. The agentic loop runs remotely; this
3262        // process streams live events and POSTs messages. History is lazy-
3263        // loaded by useAssistantHistory on scroll-up (no blocking fetch here).
3264        const {
3265          discoverAssistantSessions
3266        } = await import('./assistant/sessionDiscovery.js');
3267        let targetSessionId = _pendingAssistantChat.sessionId;
3268  
3269        // Discovery flow — list bridge environments, filter sessions
3270        if (!targetSessionId) {
3271          let sessions;
3272          try {
3273            sessions = await discoverAssistantSessions();
3274          } catch (e) {
3275            return await exitWithError(root, `Failed to discover sessions: ${e instanceof Error ? e.message : e}`, () => gracefulShutdown(1));
3276          }
3277          if (sessions.length === 0) {
3278            let installedDir: string | null;
3279            try {
3280              installedDir = await launchAssistantInstallWizard(root);
3281            } catch (e) {
3282              return await exitWithError(root, `Assistant installation failed: ${e instanceof Error ? e.message : e}`, () => gracefulShutdown(1));
3283            }
3284            if (installedDir === null) {
3285              await gracefulShutdown(0);
3286              process.exit(0);
3287            }
3288            // The daemon needs a few seconds to spin up its worker and
3289            // establish a bridge session before discovery will find it.
3290            return await exitWithMessage(root, `Assistant installed in ${installedDir}. The daemon is starting up — run \`claude assistant\` again in a few seconds to connect.`, {
3291              exitCode: 0,
3292              beforeExit: () => gracefulShutdown(0)
3293            });
3294          }
3295          if (sessions.length === 1) {
3296            targetSessionId = sessions[0]!.id;
3297          } else {
3298            const picked = await launchAssistantSessionChooser(root, {
3299              sessions
3300            });
3301            if (!picked) {
3302              await gracefulShutdown(0);
3303              process.exit(0);
3304            }
3305            targetSessionId = picked;
3306          }
3307        }
3308  
3309        // Auth — call prepareApiRequest() once for orgUUID, but use a
3310        // getAccessToken closure for the token so reconnects get fresh tokens.
3311        const {
3312          checkAndRefreshOAuthTokenIfNeeded,
3313          getClaudeAIOAuthTokens
3314        } = await import('./utils/auth.js');
3315        await checkAndRefreshOAuthTokenIfNeeded();
3316        let apiCreds;
3317        try {
3318          apiCreds = await prepareApiRequest();
3319        } catch (e) {
3320          return await exitWithError(root, `Error: ${e instanceof Error ? e.message : 'Failed to authenticate'}`, () => gracefulShutdown(1));
3321        }
3322        const getAccessToken = (): string => getClaudeAIOAuthTokens()?.accessToken ?? apiCreds.accessToken;
3323  
3324        // Brief mode activation: setKairosActive(true) satisfies BOTH opt-in
3325        // and entitlement for isBriefEnabled() (BriefTool.ts:124-132).
3326        setKairosActive(true);
3327        setUserMsgOptIn(true);
3328        setIsRemoteMode(true);
3329        const remoteSessionConfig = createRemoteSessionConfig(targetSessionId, getAccessToken, apiCreds.orgUUID, /* hasInitialPrompt */false, /* viewerOnly */true);
3330        const infoMessage = createSystemMessage(`Attached to assistant session ${targetSessionId.slice(0, 8)}…`, 'info');
3331        const assistantInitialState: AppState = {
3332          ...initialState,
3333          isBriefOnly: true,
3334          kairosEnabled: false,
3335          replBridgeEnabled: false
3336        };
3337        const remoteCommands = filterCommandsForRemoteMode(commands);
3338        await launchRepl(root, {
3339          getFpsMetrics,
3340          stats,
3341          initialState: assistantInitialState
3342        }, {
3343          debug: debug || debugToStderr,
3344          commands: remoteCommands,
3345          initialTools: [],
3346          initialMessages: [infoMessage],
3347          mcpClients: [],
3348          autoConnectIdeFlag: ide,
3349          mainThreadAgentDefinition,
3350          disableSlashCommands,
3351          remoteSessionConfig,
3352          thinkingConfig
3353        }, renderAndRun);
3354        return;
3355      } else if (options.resume || options.fromPr || teleport || remote !== null) {
3356        // Handle resume flow - from file (ant-only), session ID, or interactive selector
3357  
3358        // Clear stale caches before resuming to ensure fresh file/skill discovery
3359        const {
3360          clearSessionCaches
3361        } = await import('./commands/clear/caches.js');
3362        clearSessionCaches();
3363        let messages: MessageType[] | null = null;
3364        let processedResume: ProcessedResume | undefined = undefined;
3365        let maybeSessionId = validateUuid(options.resume);
3366        let searchTerm: string | undefined = undefined;
3367        // Store full LogOption when found by custom title (for cross-worktree resume)
3368        let matchedLog: LogOption | null = null;
3369        // PR filter for --from-pr flag
3370        let filterByPr: boolean | number | string | undefined = undefined;
3371  
3372        // Handle --from-pr flag
3373        if (options.fromPr) {
3374          if (options.fromPr === true) {
3375            // Show all sessions with linked PRs
3376            filterByPr = true;
3377          } else if (typeof options.fromPr === 'string') {
3378            // Could be a PR number or URL
3379            filterByPr = options.fromPr;
3380          }
3381        }
3382  
3383        // If resume value is not a UUID, try exact match by custom title first
3384        if (options.resume && typeof options.resume === 'string' && !maybeSessionId) {
3385          const trimmedValue = options.resume.trim();
3386          if (trimmedValue) {
3387            const matches = await searchSessionsByCustomTitle(trimmedValue, {
3388              exact: true
3389            });
3390            if (matches.length === 1) {
3391              // Exact match found - store full LogOption for cross-worktree resume
3392              matchedLog = matches[0]!;
3393              maybeSessionId = getSessionIdFromLog(matchedLog) ?? null;
3394            } else {
3395              // No match or multiple matches - use as search term for picker
3396              searchTerm = trimmedValue;
3397            }
3398          }
3399        }
3400  
3401        // --remote and --teleport both create/resume Claude Code Web (CCR) sessions.
3402        // Remote Control (--rc) is a separate feature gated in initReplBridge.ts.
3403        if (remote !== null || teleport) {
3404          await waitForPolicyLimitsToLoad();
3405          if (!isPolicyAllowed('allow_remote_sessions')) {
3406            return await exitWithError(root, "Error: Remote sessions are disabled by your organization's policy.", () => gracefulShutdown(1));
3407          }
3408        }
3409        if (remote !== null) {
3410          // Create remote session (optionally with initial prompt)
3411          const hasInitialPrompt = remote.length > 0;
3412  
3413          // Check if TUI mode is enabled - description is only optional in TUI mode
3414          const isRemoteTuiEnabled = getFeatureValue_CACHED_MAY_BE_STALE('tengu_remote_backend', false);
3415          if (!isRemoteTuiEnabled && !hasInitialPrompt) {
3416            return await exitWithError(root, 'Error: --remote requires a description.\nUsage: claude --remote "your task description"', () => gracefulShutdown(1));
3417          }
3418          logEvent('tengu_remote_create_session', {
3419            has_initial_prompt: String(hasInitialPrompt) as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
3420          });
3421  
3422          // Pass current branch so CCR clones the repo at the right revision
3423          const currentBranch = await getBranch();
3424          const createdSession = await teleportToRemoteWithErrorHandling(root, hasInitialPrompt ? remote : null, new AbortController().signal, currentBranch || undefined);
3425          if (!createdSession) {
3426            logEvent('tengu_remote_create_session_error', {
3427              error: 'unable_to_create_session' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
3428            });
3429            return await exitWithError(root, 'Error: Unable to create remote session', () => gracefulShutdown(1));
3430          }
3431          logEvent('tengu_remote_create_session_success', {
3432            session_id: createdSession.id as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
3433          });
3434  
3435          // Check if new remote TUI mode is enabled via feature gate
3436          if (!isRemoteTuiEnabled) {
3437            // Original behavior: print session info and exit
3438            process.stdout.write(`Created remote session: ${createdSession.title}\n`);
3439            process.stdout.write(`View: ${getRemoteSessionUrl(createdSession.id)}?m=0\n`);
3440            process.stdout.write(`Resume with: claude --teleport ${createdSession.id}\n`);
3441            await gracefulShutdown(0);
3442            process.exit(0);
3443          }
3444  
3445          // New behavior: start local TUI with CCR engine
3446          // Mark that we're in remote mode for command visibility
3447          setIsRemoteMode(true);
3448          switchSession(asSessionId(createdSession.id));
3449  
3450          // Get OAuth credentials for remote session
3451          let apiCreds: {
3452            accessToken: string;
3453            orgUUID: string;
3454          };
3455          try {
3456            apiCreds = await prepareApiRequest();
3457          } catch (error) {
3458            logError(toError(error));
3459            return await exitWithError(root, `Error: ${errorMessage(error) || 'Failed to authenticate'}`, () => gracefulShutdown(1));
3460          }
3461  
3462          // Create remote session config for the REPL
3463          const {
3464            getClaudeAIOAuthTokens: getTokensForRemote
3465          } = await import('./utils/auth.js');
3466          const getAccessTokenForRemote = (): string => getTokensForRemote()?.accessToken ?? apiCreds.accessToken;
3467          const remoteSessionConfig = createRemoteSessionConfig(createdSession.id, getAccessTokenForRemote, apiCreds.orgUUID, hasInitialPrompt);
3468  
3469          // Add remote session info as initial system message
3470          const remoteSessionUrl = `${getRemoteSessionUrl(createdSession.id)}?m=0`;
3471          const remoteInfoMessage = createSystemMessage(`/remote-control is active. Code in CLI or at ${remoteSessionUrl}`, 'info');
3472  
3473          // Create initial user message from the prompt if provided (CCR echoes it back but we ignore that)
3474          const initialUserMessage = hasInitialPrompt ? createUserMessage({
3475            content: remote
3476          }) : null;
3477  
3478          // Set remote session URL in app state for footer indicator
3479          const remoteInitialState = {
3480            ...initialState,
3481            remoteSessionUrl
3482          };
3483  
3484          // Pre-filter commands to only include remote-safe ones.
3485          // CCR's init response may further refine the list (via handleRemoteInit in REPL).
3486          const remoteCommands = filterCommandsForRemoteMode(commands);
3487          await launchRepl(root, {
3488            getFpsMetrics,
3489            stats,
3490            initialState: remoteInitialState
3491          }, {
3492            debug: debug || debugToStderr,
3493            commands: remoteCommands,
3494            initialTools: [],
3495            initialMessages: initialUserMessage ? [remoteInfoMessage, initialUserMessage] : [remoteInfoMessage],
3496            mcpClients: [],
3497            autoConnectIdeFlag: ide,
3498            mainThreadAgentDefinition,
3499            disableSlashCommands,
3500            remoteSessionConfig,
3501            thinkingConfig
3502          }, renderAndRun);
3503          return;
3504        } else if (teleport) {
3505          if (teleport === true || teleport === '') {
3506            // Interactive mode: show task selector and handle resume
3507            logEvent('tengu_teleport_interactive_mode', {});
3508            logForDebugging('selectAndResumeTeleportTask: Starting teleport flow...');
3509            const teleportResult = await launchTeleportResumeWrapper(root);
3510            if (!teleportResult) {
3511              // User cancelled or error occurred
3512              await gracefulShutdown(0);
3513              process.exit(0);
3514            }
3515            const {
3516              branchError
3517            } = await checkOutTeleportedSessionBranch(teleportResult.branch);
3518            messages = processMessagesForTeleportResume(teleportResult.log, branchError);
3519          } else if (typeof teleport === 'string') {
3520            logEvent('tengu_teleport_resume_session', {
3521              mode: 'direct' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
3522            });
3523            try {
3524              // First, fetch session and validate repository before checking git state
3525              const sessionData = await fetchSession(teleport);
3526              const repoValidation = await validateSessionRepository(sessionData);
3527  
3528              // Handle repo mismatch or not in repo cases
3529              if (repoValidation.status === 'mismatch' || repoValidation.status === 'not_in_repo') {
3530                const sessionRepo = repoValidation.sessionRepo;
3531                if (sessionRepo) {
3532                  // Check for known paths
3533                  const knownPaths = getKnownPathsForRepo(sessionRepo);
3534                  const existingPaths = await filterExistingPaths(knownPaths);
3535                  if (existingPaths.length > 0) {
3536                    // Show directory switch dialog
3537                    const selectedPath = await launchTeleportRepoMismatchDialog(root, {
3538                      targetRepo: sessionRepo,
3539                      initialPaths: existingPaths
3540                    });
3541                    if (selectedPath) {
3542                      // Change to the selected directory
3543                      process.chdir(selectedPath);
3544                      setCwd(selectedPath);
3545                      setOriginalCwd(selectedPath);
3546                    } else {
3547                      // User cancelled
3548                      await gracefulShutdown(0);
3549                    }
3550                  } else {
3551                    // No known paths - show original error
3552                    throw new TeleportOperationError(`You must run claude --teleport ${teleport} from a checkout of ${sessionRepo}.`, chalk.red(`You must run claude --teleport ${teleport} from a checkout of ${chalk.bold(sessionRepo)}.\n`));
3553                  }
3554                }
3555              } else if (repoValidation.status === 'error') {
3556                throw new TeleportOperationError(repoValidation.errorMessage || 'Failed to validate session', chalk.red(`Error: ${repoValidation.errorMessage || 'Failed to validate session'}\n`));
3557              }
3558              await validateGitState();
3559  
3560              // Use progress UI for teleport
3561              const {
3562                teleportWithProgress
3563              } = await import('./components/TeleportProgress.js');
3564              const result = await teleportWithProgress(root, teleport);
3565              // Track teleported session for reliability logging
3566              setTeleportedSessionInfo({
3567                sessionId: teleport
3568              });
3569              messages = result.messages;
3570            } catch (error) {
3571              if (error instanceof TeleportOperationError) {
3572                process.stderr.write(error.formattedMessage + '\n');
3573              } else {
3574                logError(error);
3575                process.stderr.write(chalk.red(`Error: ${errorMessage(error)}\n`));
3576              }
3577              await gracefulShutdown(1);
3578            }
3579          }
3580        }
3581        if ("external" === 'ant') {
3582          if (options.resume && typeof options.resume === 'string' && !maybeSessionId) {
3583            // Check for ccshare URL (e.g. https://go/ccshare/boris-20260311-211036)
3584            const {
3585              parseCcshareId,
3586              loadCcshare
3587            } = await import('./utils/ccshareResume.js');
3588            const ccshareId = parseCcshareId(options.resume);
3589            if (ccshareId) {
3590              try {
3591                const resumeStart = performance.now();
3592                const logOption = await loadCcshare(ccshareId);
3593                const result = await loadConversationForResume(logOption, undefined);
3594                if (result) {
3595                  processedResume = await processResumedConversation(result, {
3596                    forkSession: true,
3597                    transcriptPath: result.fullPath
3598                  }, resumeContext);
3599                  if (processedResume.restoredAgentDef) {
3600                    mainThreadAgentDefinition = processedResume.restoredAgentDef;
3601                  }
3602                  logEvent('tengu_session_resumed', {
3603                    entrypoint: 'ccshare' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
3604                    success: true,
3605                    resume_duration_ms: Math.round(performance.now() - resumeStart)
3606                  });
3607                } else {
3608                  logEvent('tengu_session_resumed', {
3609                    entrypoint: 'ccshare' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
3610                    success: false
3611                  });
3612                }
3613              } catch (error) {
3614                logEvent('tengu_session_resumed', {
3615                  entrypoint: 'ccshare' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
3616                  success: false
3617                });
3618                logError(error);
3619                await exitWithError(root, `Unable to resume from ccshare: ${errorMessage(error)}`, () => gracefulShutdown(1));
3620              }
3621            } else {
3622              const resolvedPath = resolve(options.resume);
3623              try {
3624                const resumeStart = performance.now();
3625                let logOption;
3626                try {
3627                  // Attempt to load as a transcript file; ENOENT falls through to session-ID handling
3628                  logOption = await loadTranscriptFromFile(resolvedPath);
3629                } catch (error) {
3630                  if (!isENOENT(error)) throw error;
3631                  // ENOENT: not a file path — fall through to session-ID handling
3632                }
3633                if (logOption) {
3634                  const result = await loadConversationForResume(logOption, undefined /* sourceFile */);
3635                  if (result) {
3636                    processedResume = await processResumedConversation(result, {
3637                      forkSession: !!options.forkSession,
3638                      transcriptPath: result.fullPath
3639                    }, resumeContext);
3640                    if (processedResume.restoredAgentDef) {
3641                      mainThreadAgentDefinition = processedResume.restoredAgentDef;
3642                    }
3643                    logEvent('tengu_session_resumed', {
3644                      entrypoint: 'file' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
3645                      success: true,
3646                      resume_duration_ms: Math.round(performance.now() - resumeStart)
3647                    });
3648                  } else {
3649                    logEvent('tengu_session_resumed', {
3650                      entrypoint: 'file' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
3651                      success: false
3652                    });
3653                  }
3654                }
3655              } catch (error) {
3656                logEvent('tengu_session_resumed', {
3657                  entrypoint: 'file' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
3658                  success: false
3659                });
3660                logError(error);
3661                await exitWithError(root, `Unable to load transcript from file: ${options.resume}`, () => gracefulShutdown(1));
3662              }
3663            }
3664          }
3665        }
3666  
3667        // If not loaded as a file, try as session ID
3668        if (maybeSessionId) {
3669          // Resume specific session by ID
3670          const sessionId = maybeSessionId;
3671          try {
3672            const resumeStart = performance.now();
3673            // Use matchedLog if available (for cross-worktree resume by custom title)
3674            // Otherwise fall back to sessionId string (for direct UUID resume)
3675            const result = await loadConversationForResume(matchedLog ?? sessionId, undefined);
3676            if (!result) {
3677              logEvent('tengu_session_resumed', {
3678                entrypoint: 'cli_flag' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
3679                success: false
3680              });
3681              return await exitWithError(root, `No conversation found with session ID: ${sessionId}`);
3682            }
3683            const fullPath = matchedLog?.fullPath ?? result.fullPath;
3684            processedResume = await processResumedConversation(result, {
3685              forkSession: !!options.forkSession,
3686              sessionIdOverride: sessionId,
3687              transcriptPath: fullPath
3688            }, resumeContext);
3689            if (processedResume.restoredAgentDef) {
3690              mainThreadAgentDefinition = processedResume.restoredAgentDef;
3691            }
3692            logEvent('tengu_session_resumed', {
3693              entrypoint: 'cli_flag' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
3694              success: true,
3695              resume_duration_ms: Math.round(performance.now() - resumeStart)
3696            });
3697          } catch (error) {
3698            logEvent('tengu_session_resumed', {
3699              entrypoint: 'cli_flag' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
3700              success: false
3701            });
3702            logError(error);
3703            await exitWithError(root, `Failed to resume session ${sessionId}`);
3704          }
3705        }
3706  
3707        // Await file downloads before rendering REPL (files must be available)
3708        if (fileDownloadPromise) {
3709          try {
3710            const results = await fileDownloadPromise;
3711            const failedCount = count(results, r => !r.success);
3712            if (failedCount > 0) {
3713              process.stderr.write(chalk.yellow(`Warning: ${failedCount}/${results.length} file(s) failed to download.\n`));
3714            }
3715          } catch (error) {
3716            return await exitWithError(root, `Error downloading files: ${errorMessage(error)}`);
3717          }
3718        }
3719  
3720        // If we have a processed resume or teleport messages, render the REPL
3721        const resumeData = processedResume ?? (Array.isArray(messages) ? {
3722          messages,
3723          fileHistorySnapshots: undefined,
3724          agentName: undefined,
3725          agentColor: undefined as AgentColorName | undefined,
3726          restoredAgentDef: mainThreadAgentDefinition,
3727          initialState,
3728          contentReplacements: undefined
3729        } : undefined);
3730        if (resumeData) {
3731          maybeActivateProactive(options);
3732          maybeActivateBrief(options);
3733          await launchRepl(root, {
3734            getFpsMetrics,
3735            stats,
3736            initialState: resumeData.initialState
3737          }, {
3738            ...sessionConfig,
3739            mainThreadAgentDefinition: resumeData.restoredAgentDef ?? mainThreadAgentDefinition,
3740            initialMessages: resumeData.messages,
3741            initialFileHistorySnapshots: resumeData.fileHistorySnapshots,
3742            initialContentReplacements: resumeData.contentReplacements,
3743            initialAgentName: resumeData.agentName,
3744            initialAgentColor: resumeData.agentColor
3745          }, renderAndRun);
3746        } else {
3747          // Show interactive selector (includes same-repo worktrees)
3748          // Note: ResumeConversation loads logs internally to ensure proper GC after selection
3749          await launchResumeChooser(root, {
3750            getFpsMetrics,
3751            stats,
3752            initialState
3753          }, getWorktreePaths(getOriginalCwd()), {
3754            ...sessionConfig,
3755            initialSearchQuery: searchTerm,
3756            forkSession: options.forkSession,
3757            filterByPr
3758          });
3759        }
3760      } else {
3761        // Pass unresolved hooks promise to REPL so it can render immediately
3762        // instead of blocking ~500ms waiting for SessionStart hooks to finish.
3763        // REPL will inject hook messages when they resolve and await them before
3764        // the first API call so the model always sees hook context.
3765        const pendingHookMessages = hooksPromise && hookMessages.length === 0 ? hooksPromise : undefined;
3766        profileCheckpoint('action_after_hooks');
3767        maybeActivateProactive(options);
3768        maybeActivateBrief(options);
3769        // Persist the current mode for fresh sessions so future resumes know what mode was used
3770        if (feature('COORDINATOR_MODE')) {
3771          saveMode(coordinatorModeModule?.isCoordinatorMode() ? 'coordinator' : 'normal');
3772        }
3773  
3774        // If launched via a deep link, show a provenance banner so the user
3775        // knows the session originated externally. Linux xdg-open and
3776        // browsers with "always allow" set dispatch the link with no OS-level
3777        // confirmation, so this is the only signal the user gets that the
3778        // prompt — and the working directory / CLAUDE.md it implies — came
3779        // from an external source rather than something they typed.
3780        let deepLinkBanner: ReturnType<typeof createSystemMessage> | null = null;
3781        if (feature('LODESTONE')) {
3782          if (options.deepLinkOrigin) {
3783            logEvent('tengu_deep_link_opened', {
3784              has_prefill: Boolean(options.prefill),
3785              has_repo: Boolean(options.deepLinkRepo)
3786            });
3787            deepLinkBanner = createSystemMessage(buildDeepLinkBanner({
3788              cwd: getCwd(),
3789              prefillLength: options.prefill?.length,
3790              repo: options.deepLinkRepo,
3791              lastFetch: options.deepLinkLastFetch !== undefined ? new Date(options.deepLinkLastFetch) : undefined
3792            }), 'warning');
3793          } else if (options.prefill) {
3794            deepLinkBanner = createSystemMessage('Launched with a pre-filled prompt — review it before pressing Enter.', 'warning');
3795          }
3796        }
3797        const initialMessages = deepLinkBanner ? [deepLinkBanner, ...hookMessages] : hookMessages.length > 0 ? hookMessages : undefined;
3798        await launchRepl(root, {
3799          getFpsMetrics,
3800          stats,
3801          initialState
3802        }, {
3803          ...sessionConfig,
3804          initialMessages,
3805          pendingHookMessages
3806        }, renderAndRun);
3807      }
3808    }).version(`${MACRO.VERSION} (Claude Code)`, '-v, --version', 'Output the version number');
3809  
3810    // Worktree flags
3811    program.option('-w, --worktree [name]', 'Create a new git worktree for this session (optionally specify a name)');
3812    program.option('--tmux', 'Create a tmux session for the worktree (requires --worktree). Uses iTerm2 native panes when available; use --tmux=classic for traditional tmux.');
3813    if (canUserConfigureAdvisor()) {
3814      program.addOption(new Option('--advisor <model>', 'Enable the server-side advisor tool with the specified model (alias or full ID).').hideHelp());
3815    }
3816    if ("external" === 'ant') {
3817      program.addOption(new Option('--delegate-permissions', '[ANT-ONLY] Alias for --permission-mode auto.').implies({
3818        permissionMode: 'auto'
3819      }));
3820      program.addOption(new Option('--dangerously-skip-permissions-with-classifiers', '[ANT-ONLY] Deprecated alias for --permission-mode auto.').hideHelp().implies({
3821        permissionMode: 'auto'
3822      }));
3823      program.addOption(new Option('--afk', '[ANT-ONLY] Deprecated alias for --permission-mode auto.').hideHelp().implies({
3824        permissionMode: 'auto'
3825      }));
3826      program.addOption(new Option('--tasks [id]', '[ANT-ONLY] Tasks mode: watch for tasks and auto-process them. Optional id is used as both the task list ID and agent ID (defaults to "tasklist").').argParser(String).hideHelp());
3827      program.option('--agent-teams', '[ANT-ONLY] Force Claude to use multi-agent mode for solving problems', () => true);
3828    }
3829    if (feature('TRANSCRIPT_CLASSIFIER')) {
3830      program.addOption(new Option('--enable-auto-mode', 'Opt in to auto mode').hideHelp());
3831    }
3832    if (feature('PROACTIVE') || feature('KAIROS')) {
3833      program.addOption(new Option('--proactive', 'Start in proactive autonomous mode'));
3834    }
3835    if (feature('UDS_INBOX')) {
3836      program.addOption(new Option('--messaging-socket-path <path>', 'Unix domain socket path for the UDS messaging server (defaults to a tmp path)'));
3837    }
3838    if (feature('KAIROS') || feature('KAIROS_BRIEF')) {
3839      program.addOption(new Option('--brief', 'Enable SendUserMessage tool for agent-to-user communication'));
3840    }
3841    if (feature('KAIROS')) {
3842      program.addOption(new Option('--assistant', 'Force assistant mode (Agent SDK daemon use)').hideHelp());
3843    }
3844    if (feature('KAIROS') || feature('KAIROS_CHANNELS')) {
3845      program.addOption(new Option('--channels <servers...>', 'MCP servers whose channel notifications (inbound push) should register this session. Space-separated server names.').hideHelp());
3846      program.addOption(new Option('--dangerously-load-development-channels <servers...>', 'Load channel servers not on the approved allowlist. For local channel development only. Shows a confirmation dialog at startup.').hideHelp());
3847    }
3848  
3849    // Teammate identity options (set by leader when spawning tmux teammates)
3850    // These replace the CLAUDE_CODE_* environment variables
3851    program.addOption(new Option('--agent-id <id>', 'Teammate agent ID').hideHelp());
3852    program.addOption(new Option('--agent-name <name>', 'Teammate display name').hideHelp());
3853    program.addOption(new Option('--team-name <name>', 'Team name for swarm coordination').hideHelp());
3854    program.addOption(new Option('--agent-color <color>', 'Teammate UI color').hideHelp());
3855    program.addOption(new Option('--plan-mode-required', 'Require plan mode before implementation').hideHelp());
3856    program.addOption(new Option('--parent-session-id <id>', 'Parent session ID for analytics correlation').hideHelp());
3857    program.addOption(new Option('--teammate-mode <mode>', 'How to spawn teammates: "tmux", "in-process", or "auto"').choices(['auto', 'tmux', 'in-process']).hideHelp());
3858    program.addOption(new Option('--agent-type <type>', 'Custom agent type for this teammate').hideHelp());
3859  
3860    // Enable SDK URL for all builds but hide from help
3861    program.addOption(new Option('--sdk-url <url>', 'Use remote WebSocket endpoint for SDK I/O streaming (only with -p and stream-json format)').hideHelp());
3862  
3863    // Enable teleport/remote flags for all builds but keep them undocumented until GA
3864    program.addOption(new Option('--teleport [session]', 'Resume a teleport session, optionally specify session ID').hideHelp());
3865    program.addOption(new Option('--remote [description]', 'Create a remote session with the given description').hideHelp());
3866    if (feature('BRIDGE_MODE')) {
3867      program.addOption(new Option('--remote-control [name]', 'Start an interactive session with Remote Control enabled (optionally named)').argParser(value => value || true).hideHelp());
3868      program.addOption(new Option('--rc [name]', 'Alias for --remote-control').argParser(value => value || true).hideHelp());
3869    }
3870    if (feature('HARD_FAIL')) {
3871      program.addOption(new Option('--hard-fail', 'Crash on logError calls instead of silently logging').hideHelp());
3872    }
3873    profileCheckpoint('run_main_options_built');
3874  
3875    // -p/--print mode: skip subcommand registration. The 52 subcommands
3876    // (mcp, auth, plugin, skill, task, config, doctor, update, etc.) are
3877    // never dispatched in print mode — commander routes the prompt to the
3878    // default action. The subcommand registration path was measured at ~65ms
3879    // on baseline — mostly the isBridgeEnabled() call (25ms settings Zod parse
3880    // + 40ms sync keychain subprocess), both hidden by the try/catch that
3881    // always returns false before enableConfigs(). cc:// URLs are rewritten to
3882    // `open` at main() line ~851 BEFORE this runs, so argv check is safe here.
3883    const isPrintMode = process.argv.includes('-p') || process.argv.includes('--print');
3884    const isCcUrl = process.argv.some(a => a.startsWith('cc://') || a.startsWith('cc+unix://'));
3885    if (isPrintMode && !isCcUrl) {
3886      profileCheckpoint('run_before_parse');
3887      await program.parseAsync(process.argv);
3888      profileCheckpoint('run_after_parse');
3889      return program;
3890    }
3891  
3892    // claude mcp
3893  
3894    const mcp = program.command('mcp').description('Configure and manage MCP servers').configureHelp(createSortedHelpConfig()).enablePositionalOptions();
3895    mcp.command('serve').description(`Start the Claude Code MCP server`).option('-d, --debug', 'Enable debug mode', () => true).option('--verbose', 'Override verbose mode setting from config', () => true).action(async ({
3896      debug,
3897      verbose
3898    }: {
3899      debug?: boolean;
3900      verbose?: boolean;
3901    }) => {
3902      const {
3903        mcpServeHandler
3904      } = await import('./cli/handlers/mcp.js');
3905      await mcpServeHandler({
3906        debug,
3907        verbose
3908      });
3909    });
3910  
3911    // Register the mcp add subcommand (extracted for testability)
3912    registerMcpAddCommand(mcp);
3913    if (isXaaEnabled()) {
3914      registerMcpXaaIdpCommand(mcp);
3915    }
3916    mcp.command('remove <name>').description('Remove an MCP server').option('-s, --scope <scope>', 'Configuration scope (local, user, or project) - if not specified, removes from whichever scope it exists in').action(async (name: string, options: {
3917      scope?: string;
3918    }) => {
3919      const {
3920        mcpRemoveHandler
3921      } = await import('./cli/handlers/mcp.js');
3922      await mcpRemoveHandler(name, options);
3923    });
3924    mcp.command('list').description('List configured MCP servers. Note: The workspace trust dialog is skipped and stdio servers from .mcp.json are spawned for health checks. Only use this command in directories you trust.').action(async () => {
3925      const {
3926        mcpListHandler
3927      } = await import('./cli/handlers/mcp.js');
3928      await mcpListHandler();
3929    });
3930    mcp.command('get <name>').description('Get details about an MCP server. Note: The workspace trust dialog is skipped and stdio servers from .mcp.json are spawned for health checks. Only use this command in directories you trust.').action(async (name: string) => {
3931      const {
3932        mcpGetHandler
3933      } = await import('./cli/handlers/mcp.js');
3934      await mcpGetHandler(name);
3935    });
3936    mcp.command('add-json <name> <json>').description('Add an MCP server (stdio or SSE) with a JSON string').option('-s, --scope <scope>', 'Configuration scope (local, user, or project)', 'local').option('--client-secret', 'Prompt for OAuth client secret (or set MCP_CLIENT_SECRET env var)').action(async (name: string, json: string, options: {
3937      scope?: string;
3938      clientSecret?: true;
3939    }) => {
3940      const {
3941        mcpAddJsonHandler
3942      } = await import('./cli/handlers/mcp.js');
3943      await mcpAddJsonHandler(name, json, options);
3944    });
3945    mcp.command('add-from-claude-desktop').description('Import MCP servers from Claude Desktop (Mac and WSL only)').option('-s, --scope <scope>', 'Configuration scope (local, user, or project)', 'local').action(async (options: {
3946      scope?: string;
3947    }) => {
3948      const {
3949        mcpAddFromDesktopHandler
3950      } = await import('./cli/handlers/mcp.js');
3951      await mcpAddFromDesktopHandler(options);
3952    });
3953    mcp.command('reset-project-choices').description('Reset all approved and rejected project-scoped (.mcp.json) servers within this project').action(async () => {
3954      const {
3955        mcpResetChoicesHandler
3956      } = await import('./cli/handlers/mcp.js');
3957      await mcpResetChoicesHandler();
3958    });
3959  
3960    // claude server
3961    if (feature('DIRECT_CONNECT')) {
3962      program.command('server').description('Start a Claude Code session server').option('--port <number>', 'HTTP port', '0').option('--host <string>', 'Bind address', '0.0.0.0').option('--auth-token <token>', 'Bearer token for auth').option('--unix <path>', 'Listen on a unix domain socket').option('--workspace <dir>', 'Default working directory for sessions that do not specify cwd').option('--idle-timeout <ms>', 'Idle timeout for detached sessions in ms (0 = never expire)', '600000').option('--max-sessions <n>', 'Maximum concurrent sessions (0 = unlimited)', '32').action(async (opts: {
3963        port: string;
3964        host: string;
3965        authToken?: string;
3966        unix?: string;
3967        workspace?: string;
3968        idleTimeout: string;
3969        maxSessions: string;
3970      }) => {
3971        const {
3972          randomBytes
3973        } = await import('crypto');
3974        const {
3975          startServer
3976        } = await import('./server/server.js');
3977        const {
3978          SessionManager
3979        } = await import('./server/sessionManager.js');
3980        const {
3981          DangerousBackend
3982        } = await import('./server/backends/dangerousBackend.js');
3983        const {
3984          printBanner
3985        } = await import('./server/serverBanner.js');
3986        const {
3987          createServerLogger
3988        } = await import('./server/serverLog.js');
3989        const {
3990          writeServerLock,
3991          removeServerLock,
3992          probeRunningServer
3993        } = await import('./server/lockfile.js');
3994        const existing = await probeRunningServer();
3995        if (existing) {
3996          process.stderr.write(`A claude server is already running (pid ${existing.pid}) at ${existing.httpUrl}\n`);
3997          process.exit(1);
3998        }
3999        const authToken = opts.authToken ?? `sk-ant-cc-${randomBytes(16).toString('base64url')}`;
4000        const config = {
4001          port: parseInt(opts.port, 10),
4002          host: opts.host,
4003          authToken,
4004          unix: opts.unix,
4005          workspace: opts.workspace,
4006          idleTimeoutMs: parseInt(opts.idleTimeout, 10),
4007          maxSessions: parseInt(opts.maxSessions, 10)
4008        };
4009        const backend = new DangerousBackend();
4010        const sessionManager = new SessionManager(backend, {
4011          idleTimeoutMs: config.idleTimeoutMs,
4012          maxSessions: config.maxSessions
4013        });
4014        const logger = createServerLogger();
4015        const server = startServer(config, sessionManager, logger);
4016        const actualPort = server.port ?? config.port;
4017        printBanner(config, authToken, actualPort);
4018        await writeServerLock({
4019          pid: process.pid,
4020          port: actualPort,
4021          host: config.host,
4022          httpUrl: config.unix ? `unix:${config.unix}` : `http://${config.host}:${actualPort}`,
4023          startedAt: Date.now()
4024        });
4025        let shuttingDown = false;
4026        const shutdown = async () => {
4027          if (shuttingDown) return;
4028          shuttingDown = true;
4029          // Stop accepting new connections before tearing down sessions.
4030          server.stop(true);
4031          await sessionManager.destroyAll();
4032          await removeServerLock();
4033          process.exit(0);
4034        };
4035        process.once('SIGINT', () => void shutdown());
4036        process.once('SIGTERM', () => void shutdown());
4037      });
4038    }
4039  
4040    // `claude ssh <host> [dir]` — registered here only so --help shows it.
4041    // The actual interactive flow is handled by early argv rewriting in main()
4042    // (parallels the DIRECT_CONNECT/cc:// pattern above). If commander reaches
4043    // this action it means the argv rewrite didn't fire (e.g. user ran
4044    // `claude ssh` with no host) — just print usage.
4045    if (feature('SSH_REMOTE')) {
4046      program.command('ssh <host> [dir]').description('Run Claude Code on a remote host over SSH. Deploys the binary and ' + 'tunnels API auth back through your local machine — no remote setup needed.').option('--permission-mode <mode>', 'Permission mode for the remote session').option('--dangerously-skip-permissions', 'Skip all permission prompts on the remote (dangerous)').option('--local', 'e2e test mode — spawn the child CLI locally (skip ssh/deploy). ' + 'Exercises the auth proxy and unix-socket plumbing without a remote host.').action(async () => {
4047        // Argv rewriting in main() should have consumed `ssh <host>` before
4048        // commander runs. Reaching here means host was missing or the
4049        // rewrite predicate didn't match.
4050        process.stderr.write('Usage: claude ssh <user@host | ssh-config-alias> [dir]\n\n' + "Runs Claude Code on a remote Linux host. You don't need to install\n" + 'anything on the remote or run `claude auth login` there — the binary is\n' + 'deployed over SSH and API auth tunnels back through your local machine.\n');
4051        process.exit(1);
4052      });
4053    }
4054  
4055    // claude connect — subcommand only handles -p (headless) mode.
4056    // Interactive mode (without -p) is handled by early argv rewriting in main()
4057    // which redirects to the main command with full TUI support.
4058    if (feature('DIRECT_CONNECT')) {
4059      program.command('open <cc-url>').description('Connect to a Claude Code server (internal — use cc:// URLs)').option('-p, --print [prompt]', 'Print mode (headless)').option('--output-format <format>', 'Output format: text, json, stream-json', 'text').action(async (ccUrl: string, opts: {
4060        print?: string | boolean;
4061        outputFormat: string;
4062      }) => {
4063        const {
4064          parseConnectUrl
4065        } = await import('./server/parseConnectUrl.js');
4066        const {
4067          serverUrl,
4068          authToken
4069        } = parseConnectUrl(ccUrl);
4070        let connectConfig;
4071        try {
4072          const session = await createDirectConnectSession({
4073            serverUrl,
4074            authToken,
4075            cwd: getOriginalCwd(),
4076            dangerouslySkipPermissions: _pendingConnect?.dangerouslySkipPermissions
4077          });
4078          if (session.workDir) {
4079            setOriginalCwd(session.workDir);
4080            setCwdState(session.workDir);
4081          }
4082          setDirectConnectServerUrl(serverUrl);
4083          connectConfig = session.config;
4084        } catch (err) {
4085          // biome-ignore lint/suspicious/noConsole: intentional error output
4086          console.error(err instanceof DirectConnectError ? err.message : String(err));
4087          process.exit(1);
4088        }
4089        const {
4090          runConnectHeadless
4091        } = await import('./server/connectHeadless.js');
4092        const prompt = typeof opts.print === 'string' ? opts.print : '';
4093        const interactive = opts.print === true;
4094        await runConnectHeadless(connectConfig, prompt, opts.outputFormat, interactive);
4095      });
4096    }
4097  
4098    // claude auth
4099  
4100    const auth = program.command('auth').description('Manage authentication').configureHelp(createSortedHelpConfig());
4101    auth.command('login').description('Sign in to your Anthropic account').option('--email <email>', 'Pre-populate email address on the login page').option('--sso', 'Force SSO login flow').option('--console', 'Use Anthropic Console (API usage billing) instead of Claude subscription').option('--claudeai', 'Use Claude subscription (default)').action(async ({
4102      email,
4103      sso,
4104      console: useConsole,
4105      claudeai
4106    }: {
4107      email?: string;
4108      sso?: boolean;
4109      console?: boolean;
4110      claudeai?: boolean;
4111    }) => {
4112      const {
4113        authLogin
4114      } = await import('./cli/handlers/auth.js');
4115      await authLogin({
4116        email,
4117        sso,
4118        console: useConsole,
4119        claudeai
4120      });
4121    });
4122    auth.command('status').description('Show authentication status').option('--json', 'Output as JSON (default)').option('--text', 'Output as human-readable text').action(async (opts: {
4123      json?: boolean;
4124      text?: boolean;
4125    }) => {
4126      const {
4127        authStatus
4128      } = await import('./cli/handlers/auth.js');
4129      await authStatus(opts);
4130    });
4131    auth.command('logout').description('Log out from your Anthropic account').action(async () => {
4132      const {
4133        authLogout
4134      } = await import('./cli/handlers/auth.js');
4135      await authLogout();
4136    });
4137  
4138    /**
4139     * Helper function to handle marketplace command errors consistently.
4140     * Logs the error and exits the process with status 1.
4141     * @param error The error that occurred
4142     * @param action Description of the action that failed
4143     */
4144    // Hidden flag on all plugin/marketplace subcommands to target cowork_plugins.
4145    const coworkOption = () => new Option('--cowork', 'Use cowork_plugins directory').hideHelp();
4146  
4147    // Plugin validate command
4148    const pluginCmd = program.command('plugin').alias('plugins').description('Manage Claude Code plugins').configureHelp(createSortedHelpConfig());
4149    pluginCmd.command('validate <path>').description('Validate a plugin or marketplace manifest').addOption(coworkOption()).action(async (manifestPath: string, options: {
4150      cowork?: boolean;
4151    }) => {
4152      const {
4153        pluginValidateHandler
4154      } = await import('./cli/handlers/plugins.js');
4155      await pluginValidateHandler(manifestPath, options);
4156    });
4157  
4158    // Plugin list command
4159    pluginCmd.command('list').description('List installed plugins').option('--json', 'Output as JSON').option('--available', 'Include available plugins from marketplaces (requires --json)').addOption(coworkOption()).action(async (options: {
4160      json?: boolean;
4161      available?: boolean;
4162      cowork?: boolean;
4163    }) => {
4164      const {
4165        pluginListHandler
4166      } = await import('./cli/handlers/plugins.js');
4167      await pluginListHandler(options);
4168    });
4169  
4170    // Marketplace subcommands
4171    const marketplaceCmd = pluginCmd.command('marketplace').description('Manage Claude Code marketplaces').configureHelp(createSortedHelpConfig());
4172    marketplaceCmd.command('add <source>').description('Add a marketplace from a URL, path, or GitHub repo').addOption(coworkOption()).option('--sparse <paths...>', 'Limit checkout to specific directories via git sparse-checkout (for monorepos). Example: --sparse .claude-plugin plugins').option('--scope <scope>', 'Where to declare the marketplace: user (default), project, or local').action(async (source: string, options: {
4173      cowork?: boolean;
4174      sparse?: string[];
4175      scope?: string;
4176    }) => {
4177      const {
4178        marketplaceAddHandler
4179      } = await import('./cli/handlers/plugins.js');
4180      await marketplaceAddHandler(source, options);
4181    });
4182    marketplaceCmd.command('list').description('List all configured marketplaces').option('--json', 'Output as JSON').addOption(coworkOption()).action(async (options: {
4183      json?: boolean;
4184      cowork?: boolean;
4185    }) => {
4186      const {
4187        marketplaceListHandler
4188      } = await import('./cli/handlers/plugins.js');
4189      await marketplaceListHandler(options);
4190    });
4191    marketplaceCmd.command('remove <name>').alias('rm').description('Remove a configured marketplace').addOption(coworkOption()).action(async (name: string, options: {
4192      cowork?: boolean;
4193    }) => {
4194      const {
4195        marketplaceRemoveHandler
4196      } = await import('./cli/handlers/plugins.js');
4197      await marketplaceRemoveHandler(name, options);
4198    });
4199    marketplaceCmd.command('update [name]').description('Update marketplace(s) from their source - updates all if no name specified').addOption(coworkOption()).action(async (name: string | undefined, options: {
4200      cowork?: boolean;
4201    }) => {
4202      const {
4203        marketplaceUpdateHandler
4204      } = await import('./cli/handlers/plugins.js');
4205      await marketplaceUpdateHandler(name, options);
4206    });
4207  
4208    // Plugin install command
4209    pluginCmd.command('install <plugin>').alias('i').description('Install a plugin from available marketplaces (use plugin@marketplace for specific marketplace)').option('-s, --scope <scope>', 'Installation scope: user, project, or local', 'user').addOption(coworkOption()).action(async (plugin: string, options: {
4210      scope?: string;
4211      cowork?: boolean;
4212    }) => {
4213      const {
4214        pluginInstallHandler
4215      } = await import('./cli/handlers/plugins.js');
4216      await pluginInstallHandler(plugin, options);
4217    });
4218  
4219    // Plugin uninstall command
4220    pluginCmd.command('uninstall <plugin>').alias('remove').alias('rm').description('Uninstall an installed plugin').option('-s, --scope <scope>', 'Uninstall from scope: user, project, or local', 'user').option('--keep-data', "Preserve the plugin's persistent data directory (~/.claude/plugins/data/{id}/)").addOption(coworkOption()).action(async (plugin: string, options: {
4221      scope?: string;
4222      cowork?: boolean;
4223      keepData?: boolean;
4224    }) => {
4225      const {
4226        pluginUninstallHandler
4227      } = await import('./cli/handlers/plugins.js');
4228      await pluginUninstallHandler(plugin, options);
4229    });
4230  
4231    // Plugin enable command
4232    pluginCmd.command('enable <plugin>').description('Enable a disabled plugin').option('-s, --scope <scope>', `Installation scope: ${VALID_INSTALLABLE_SCOPES.join(', ')} (default: auto-detect)`).addOption(coworkOption()).action(async (plugin: string, options: {
4233      scope?: string;
4234      cowork?: boolean;
4235    }) => {
4236      const {
4237        pluginEnableHandler
4238      } = await import('./cli/handlers/plugins.js');
4239      await pluginEnableHandler(plugin, options);
4240    });
4241  
4242    // Plugin disable command
4243    pluginCmd.command('disable [plugin]').description('Disable an enabled plugin').option('-a, --all', 'Disable all enabled plugins').option('-s, --scope <scope>', `Installation scope: ${VALID_INSTALLABLE_SCOPES.join(', ')} (default: auto-detect)`).addOption(coworkOption()).action(async (plugin: string | undefined, options: {
4244      scope?: string;
4245      cowork?: boolean;
4246      all?: boolean;
4247    }) => {
4248      const {
4249        pluginDisableHandler
4250      } = await import('./cli/handlers/plugins.js');
4251      await pluginDisableHandler(plugin, options);
4252    });
4253  
4254    // Plugin update command
4255    pluginCmd.command('update <plugin>').description('Update a plugin to the latest version (restart required to apply)').option('-s, --scope <scope>', `Installation scope: ${VALID_UPDATE_SCOPES.join(', ')} (default: user)`).addOption(coworkOption()).action(async (plugin: string, options: {
4256      scope?: string;
4257      cowork?: boolean;
4258    }) => {
4259      const {
4260        pluginUpdateHandler
4261      } = await import('./cli/handlers/plugins.js');
4262      await pluginUpdateHandler(plugin, options);
4263    });
4264    // END ANT-ONLY
4265  
4266    // Setup token command
4267    program.command('setup-token').description('Set up a long-lived authentication token (requires Claude subscription)').action(async () => {
4268      const [{
4269        setupTokenHandler
4270      }, {
4271        createRoot
4272      }] = await Promise.all([import('./cli/handlers/util.js'), import('./ink.js')]);
4273      const root = await createRoot(getBaseRenderOptions(false));
4274      await setupTokenHandler(root);
4275    });
4276  
4277    // Agents command - list configured agents
4278    program.command('agents').description('List configured agents').option('--setting-sources <sources>', 'Comma-separated list of setting sources to load (user, project, local).').action(async () => {
4279      const {
4280        agentsHandler
4281      } = await import('./cli/handlers/agents.js');
4282      await agentsHandler();
4283      process.exit(0);
4284    });
4285    if (feature('TRANSCRIPT_CLASSIFIER')) {
4286      // Skip when tengu_auto_mode_config.enabled === 'disabled' (circuit breaker).
4287      // Reads from disk cache — GrowthBook isn't initialized at registration time.
4288      if (getAutoModeEnabledStateIfCached() !== 'disabled') {
4289        const autoModeCmd = program.command('auto-mode').description('Inspect auto mode classifier configuration');
4290        autoModeCmd.command('defaults').description('Print the default auto mode environment, allow, and deny rules as JSON').action(async () => {
4291          const {
4292            autoModeDefaultsHandler
4293          } = await import('./cli/handlers/autoMode.js');
4294          autoModeDefaultsHandler();
4295          process.exit(0);
4296        });
4297        autoModeCmd.command('config').description('Print the effective auto mode config as JSON: your settings where set, defaults otherwise').action(async () => {
4298          const {
4299            autoModeConfigHandler
4300          } = await import('./cli/handlers/autoMode.js');
4301          autoModeConfigHandler();
4302          process.exit(0);
4303        });
4304        autoModeCmd.command('critique').description('Get AI feedback on your custom auto mode rules').option('--model <model>', 'Override which model is used').action(async options => {
4305          const {
4306            autoModeCritiqueHandler
4307          } = await import('./cli/handlers/autoMode.js');
4308          await autoModeCritiqueHandler(options);
4309          process.exit();
4310        });
4311      }
4312    }
4313  
4314    // Remote Control command — connect local environment to claude.ai/code.
4315    // The actual command is intercepted by the fast-path in cli.tsx before
4316    // Commander.js runs, so this registration exists only for help output.
4317    // Always hidden: isBridgeEnabled() at this point (before enableConfigs)
4318    // would throw inside isClaudeAISubscriber → getGlobalConfig and return
4319    // false via the try/catch — but not before paying ~65ms of side effects
4320    // (25ms settings Zod parse + 40ms sync `security` keychain subprocess).
4321    // The dynamic visibility never worked; the command was always hidden.
4322    if (feature('BRIDGE_MODE')) {
4323      program.command('remote-control', {
4324        hidden: true
4325      }).alias('rc').description('Connect your local environment for remote-control sessions via claude.ai/code').action(async () => {
4326        // Unreachable — cli.tsx fast-path handles this command before main.tsx loads.
4327        // If somehow reached, delegate to bridgeMain.
4328        const {
4329          bridgeMain
4330        } = await import('./bridge/bridgeMain.js');
4331        await bridgeMain(process.argv.slice(3));
4332      });
4333    }
4334    if (feature('KAIROS')) {
4335      program.command('assistant [sessionId]').description('Attach the REPL as a client to a running bridge session. Discovers sessions via API if no sessionId given.').action(() => {
4336        // Argv rewriting above should have consumed `assistant [id]`
4337        // before commander runs. Reaching here means a root flag came first
4338        // (e.g. `--debug assistant`) and the position-0 predicate
4339        // didn't match. Print usage like the ssh stub does.
4340        process.stderr.write('Usage: claude assistant [sessionId]\n\n' + 'Attach the REPL as a viewer client to a running bridge session.\n' + 'Omit sessionId to discover and pick from available sessions.\n');
4341        process.exit(1);
4342      });
4343    }
4344  
4345    // Doctor command - check installation health
4346    program.command('doctor').description('Check the health of your Claude Code auto-updater. Note: The workspace trust dialog is skipped and stdio servers from .mcp.json are spawned for health checks. Only use this command in directories you trust.').action(async () => {
4347      const [{
4348        doctorHandler
4349      }, {
4350        createRoot
4351      }] = await Promise.all([import('./cli/handlers/util.js'), import('./ink.js')]);
4352      const root = await createRoot(getBaseRenderOptions(false));
4353      await doctorHandler(root);
4354    });
4355  
4356    // claude update
4357    //
4358    // For SemVer-compliant versioning with build metadata (X.X.X+SHA):
4359    // - We perform exact string comparison (including SHA) to detect any change
4360    // - This ensures users always get the latest build, even when only the SHA changes
4361    // - UI shows both versions including build metadata for clarity
4362    program.command('update').alias('upgrade').description('Check for updates and install if available').action(async () => {
4363      const {
4364        update
4365      } = await import('src/cli/update.js');
4366      await update();
4367    });
4368  
4369    // claude up — run the project's CLAUDE.md "# claude up" setup instructions.
4370    if ("external" === 'ant') {
4371      program.command('up').description('[ANT-ONLY] Initialize or upgrade the local dev environment using the "# claude up" section of the nearest CLAUDE.md').action(async () => {
4372        const {
4373          up
4374        } = await import('src/cli/up.js');
4375        await up();
4376      });
4377    }
4378  
4379    // claude rollback (ant-only)
4380    // Rolls back to previous releases
4381    if ("external" === 'ant') {
4382      program.command('rollback [target]').description('[ANT-ONLY] Roll back to a previous release\n\nExamples:\n  claude rollback                                    Go 1 version back from current\n  claude rollback 3                                  Go 3 versions back from current\n  claude rollback 2.0.73-dev.20251217.t190658        Roll back to a specific version').option('-l, --list', 'List recent published versions with ages').option('--dry-run', 'Show what would be installed without installing').option('--safe', 'Roll back to the server-pinned safe version (set by oncall during incidents)').action(async (target?: string, options?: {
4383        list?: boolean;
4384        dryRun?: boolean;
4385        safe?: boolean;
4386      }) => {
4387        const {
4388          rollback
4389        } = await import('src/cli/rollback.js');
4390        await rollback(target, options);
4391      });
4392    }
4393  
4394    // claude install
4395    program.command('install [target]').description('Install Claude Code native build. Use [target] to specify version (stable, latest, or specific version)').option('--force', 'Force installation even if already installed').action(async (target: string | undefined, options: {
4396      force?: boolean;
4397    }) => {
4398      const {
4399        installHandler
4400      } = await import('./cli/handlers/util.js');
4401      await installHandler(target, options);
4402    });
4403  
4404    // ant-only commands
4405    if ("external" === 'ant') {
4406      const validateLogId = (value: string) => {
4407        const maybeSessionId = validateUuid(value);
4408        if (maybeSessionId) return maybeSessionId;
4409        return Number(value);
4410      };
4411      // claude log
4412      program.command('log').description('[ANT-ONLY] Manage conversation logs.').argument('[number|sessionId]', 'A number (0, 1, 2, etc.) to display a specific log, or the sesssion ID (uuid) of a log', validateLogId).action(async (logId: string | number | undefined) => {
4413        const {
4414          logHandler
4415        } = await import('./cli/handlers/ant.js');
4416        await logHandler(logId);
4417      });
4418  
4419      // claude error
4420      program.command('error').description('[ANT-ONLY] View error logs. Optionally provide a number (0, -1, -2, etc.) to display a specific log.').argument('[number]', 'A number (0, 1, 2, etc.) to display a specific log', parseInt).action(async (number: number | undefined) => {
4421        const {
4422          errorHandler
4423        } = await import('./cli/handlers/ant.js');
4424        await errorHandler(number);
4425      });
4426  
4427      // claude export
4428      program.command('export').description('[ANT-ONLY] Export a conversation to a text file.').usage('<source> <outputFile>').argument('<source>', 'Session ID, log index (0, 1, 2...), or path to a .json/.jsonl log file').argument('<outputFile>', 'Output file path for the exported text').addHelpText('after', `
4429  Examples:
4430    $ claude export 0 conversation.txt                Export conversation at log index 0
4431    $ claude export <uuid> conversation.txt           Export conversation by session ID
4432    $ claude export input.json output.txt             Render JSON log file to text
4433    $ claude export <uuid>.jsonl output.txt           Render JSONL session file to text`).action(async (source: string, outputFile: string) => {
4434        const {
4435          exportHandler
4436        } = await import('./cli/handlers/ant.js');
4437        await exportHandler(source, outputFile);
4438      });
4439      if ("external" === 'ant') {
4440        const taskCmd = program.command('task').description('[ANT-ONLY] Manage task list tasks');
4441        taskCmd.command('create <subject>').description('Create a new task').option('-d, --description <text>', 'Task description').option('-l, --list <id>', 'Task list ID (defaults to "tasklist")').action(async (subject: string, opts: {
4442          description?: string;
4443          list?: string;
4444        }) => {
4445          const {
4446            taskCreateHandler
4447          } = await import('./cli/handlers/ant.js');
4448          await taskCreateHandler(subject, opts);
4449        });
4450        taskCmd.command('list').description('List all tasks').option('-l, --list <id>', 'Task list ID (defaults to "tasklist")').option('--pending', 'Show only pending tasks').option('--json', 'Output as JSON').action(async (opts: {
4451          list?: string;
4452          pending?: boolean;
4453          json?: boolean;
4454        }) => {
4455          const {
4456            taskListHandler
4457          } = await import('./cli/handlers/ant.js');
4458          await taskListHandler(opts);
4459        });
4460        taskCmd.command('get <id>').description('Get details of a task').option('-l, --list <id>', 'Task list ID (defaults to "tasklist")').action(async (id: string, opts: {
4461          list?: string;
4462        }) => {
4463          const {
4464            taskGetHandler
4465          } = await import('./cli/handlers/ant.js');
4466          await taskGetHandler(id, opts);
4467        });
4468        taskCmd.command('update <id>').description('Update a task').option('-l, --list <id>', 'Task list ID (defaults to "tasklist")').option('-s, --status <status>', `Set status (${TASK_STATUSES.join(', ')})`).option('--subject <text>', 'Update subject').option('-d, --description <text>', 'Update description').option('--owner <agentId>', 'Set owner').option('--clear-owner', 'Clear owner').action(async (id: string, opts: {
4469          list?: string;
4470          status?: string;
4471          subject?: string;
4472          description?: string;
4473          owner?: string;
4474          clearOwner?: boolean;
4475        }) => {
4476          const {
4477            taskUpdateHandler
4478          } = await import('./cli/handlers/ant.js');
4479          await taskUpdateHandler(id, opts);
4480        });
4481        taskCmd.command('dir').description('Show the tasks directory path').option('-l, --list <id>', 'Task list ID (defaults to "tasklist")').action(async (opts: {
4482          list?: string;
4483        }) => {
4484          const {
4485            taskDirHandler
4486          } = await import('./cli/handlers/ant.js');
4487          await taskDirHandler(opts);
4488        });
4489      }
4490  
4491      // claude completion <shell>
4492      program.command('completion <shell>', {
4493        hidden: true
4494      }).description('Generate shell completion script (bash, zsh, or fish)').option('--output <file>', 'Write completion script directly to a file instead of stdout').action(async (shell: string, opts: {
4495        output?: string;
4496      }) => {
4497        const {
4498          completionHandler
4499        } = await import('./cli/handlers/ant.js');
4500        await completionHandler(shell, opts, program);
4501      });
4502    }
4503    profileCheckpoint('run_before_parse');
4504    await program.parseAsync(process.argv);
4505    profileCheckpoint('run_after_parse');
4506  
4507    // Record final checkpoint for total_time calculation
4508    profileCheckpoint('main_after_run');
4509  
4510    // Log startup perf to Statsig (sampled) and output detailed report if enabled
4511    profileReport();
4512    return program;
4513  }
4514  async function logTenguInit({
4515    hasInitialPrompt,
4516    hasStdin,
4517    verbose,
4518    debug,
4519    debugToStderr,
4520    print,
4521    outputFormat,
4522    inputFormat,
4523    numAllowedTools,
4524    numDisallowedTools,
4525    mcpClientCount,
4526    worktreeEnabled,
4527    skipWebFetchPreflight,
4528    githubActionInputs,
4529    dangerouslySkipPermissionsPassed,
4530    permissionMode,
4531    modeIsBypass,
4532    allowDangerouslySkipPermissionsPassed,
4533    systemPromptFlag,
4534    appendSystemPromptFlag,
4535    thinkingConfig,
4536    assistantActivationPath
4537  }: {
4538    hasInitialPrompt: boolean;
4539    hasStdin: boolean;
4540    verbose: boolean;
4541    debug: boolean;
4542    debugToStderr: boolean;
4543    print: boolean;
4544    outputFormat: string;
4545    inputFormat: string;
4546    numAllowedTools: number;
4547    numDisallowedTools: number;
4548    mcpClientCount: number;
4549    worktreeEnabled: boolean;
4550    skipWebFetchPreflight: boolean | undefined;
4551    githubActionInputs: string | undefined;
4552    dangerouslySkipPermissionsPassed: boolean;
4553    permissionMode: string;
4554    modeIsBypass: boolean;
4555    allowDangerouslySkipPermissionsPassed: boolean;
4556    systemPromptFlag: 'file' | 'flag' | undefined;
4557    appendSystemPromptFlag: 'file' | 'flag' | undefined;
4558    thinkingConfig: ThinkingConfig;
4559    assistantActivationPath: string | undefined;
4560  }): Promise<void> {
4561    try {
4562      logEvent('tengu_init', {
4563        entrypoint: 'claude' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
4564        hasInitialPrompt,
4565        hasStdin,
4566        verbose,
4567        debug,
4568        debugToStderr,
4569        print,
4570        outputFormat: outputFormat as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
4571        inputFormat: inputFormat as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
4572        numAllowedTools,
4573        numDisallowedTools,
4574        mcpClientCount,
4575        worktree: worktreeEnabled,
4576        skipWebFetchPreflight,
4577        ...(githubActionInputs && {
4578          githubActionInputs: githubActionInputs as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
4579        }),
4580        dangerouslySkipPermissionsPassed,
4581        permissionMode: permissionMode as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
4582        modeIsBypass,
4583        inProtectedNamespace: isInProtectedNamespace(),
4584        allowDangerouslySkipPermissionsPassed,
4585        thinkingType: thinkingConfig.type as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
4586        ...(systemPromptFlag && {
4587          systemPromptFlag: systemPromptFlag as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
4588        }),
4589        ...(appendSystemPromptFlag && {
4590          appendSystemPromptFlag: appendSystemPromptFlag as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
4591        }),
4592        is_simple: isBareMode() || undefined,
4593        is_coordinator: feature('COORDINATOR_MODE') && coordinatorModeModule?.isCoordinatorMode() ? true : undefined,
4594        ...(assistantActivationPath && {
4595          assistantActivationPath: assistantActivationPath as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
4596        }),
4597        autoUpdatesChannel: (getInitialSettings().autoUpdatesChannel ?? 'latest') as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
4598        ...("external" === 'ant' ? (() => {
4599          const cwd = getCwd();
4600          const gitRoot = findGitRoot(cwd);
4601          const rp = gitRoot ? relative(gitRoot, cwd) || '.' : undefined;
4602          return rp ? {
4603            relativeProjectPath: rp as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
4604          } : {};
4605        })() : {})
4606      });
4607    } catch (error) {
4608      logError(error);
4609    }
4610  }
4611  function maybeActivateProactive(options: unknown): void {
4612    if ((feature('PROACTIVE') || feature('KAIROS')) && ((options as {
4613      proactive?: boolean;
4614    }).proactive || isEnvTruthy(process.env.CLAUDE_CODE_PROACTIVE))) {
4615      // eslint-disable-next-line @typescript-eslint/no-require-imports
4616      const proactiveModule = require('./proactive/index.js');
4617      if (!proactiveModule.isProactiveActive()) {
4618        proactiveModule.activateProactive('command');
4619      }
4620    }
4621  }
4622  function maybeActivateBrief(options: unknown): void {
4623    if (!(feature('KAIROS') || feature('KAIROS_BRIEF'))) return;
4624    const briefFlag = (options as {
4625      brief?: boolean;
4626    }).brief;
4627    const briefEnv = isEnvTruthy(process.env.CLAUDE_CODE_BRIEF);
4628    if (!briefFlag && !briefEnv) return;
4629    // --brief / CLAUDE_CODE_BRIEF are explicit opt-ins: check entitlement,
4630    // then set userMsgOptIn to activate the tool + prompt section. The env
4631    // var also grants entitlement (isBriefEntitled() reads it), so setting
4632    // CLAUDE_CODE_BRIEF=1 alone force-enables for dev/testing — no GB gate
4633    // needed. initialIsBriefOnly reads getUserMsgOptIn() directly.
4634    // Conditional require: static import would leak the tool name string
4635    // into external builds via BriefTool.ts → prompt.ts.
4636    /* eslint-disable @typescript-eslint/no-require-imports */
4637    const {
4638      isBriefEntitled
4639    } = require('./tools/BriefTool/BriefTool.js') as typeof import('./tools/BriefTool/BriefTool.js');
4640    /* eslint-enable @typescript-eslint/no-require-imports */
4641    const entitled = isBriefEntitled();
4642    if (entitled) {
4643      setUserMsgOptIn(true);
4644    }
4645    // Fire unconditionally once intent is seen: enabled=false captures the
4646    // "user tried but was gated" failure mode in Datadog.
4647    logEvent('tengu_brief_mode_enabled', {
4648      enabled: entitled,
4649      gated: !entitled,
4650      source: (briefEnv ? 'env' : 'flag') as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
4651    });
4652  }
4653  function resetCursor() {
4654    const terminal = process.stderr.isTTY ? process.stderr : process.stdout.isTTY ? process.stdout : undefined;
4655    terminal?.write(SHOW_CURSOR);
4656  }
4657  type TeammateOptions = {
4658    agentId?: string;
4659    agentName?: string;
4660    teamName?: string;
4661    agentColor?: string;
4662    planModeRequired?: boolean;
4663    parentSessionId?: string;
4664    teammateMode?: 'auto' | 'tmux' | 'in-process';
4665    agentType?: string;
4666  };
4667  function extractTeammateOptions(options: unknown): TeammateOptions {
4668    if (typeof options !== 'object' || options === null) {
4669      return {};
4670    }
4671    const opts = options as Record<string, unknown>;
4672    const teammateMode = opts.teammateMode;
4673    return {
4674      agentId: typeof opts.agentId === 'string' ? opts.agentId : undefined,
4675      agentName: typeof opts.agentName === 'string' ? opts.agentName : undefined,
4676      teamName: typeof opts.teamName === 'string' ? opts.teamName : undefined,
4677      agentColor: typeof opts.agentColor === 'string' ? opts.agentColor : undefined,
4678      planModeRequired: typeof opts.planModeRequired === 'boolean' ? opts.planModeRequired : undefined,
4679      parentSessionId: typeof opts.parentSessionId === 'string' ? opts.parentSessionId : undefined,
4680      teammateMode: teammateMode === 'auto' || teammateMode === 'tmux' || teammateMode === 'in-process' ? teammateMode : undefined,
4681      agentType: typeof opts.agentType === 'string' ? opts.agentType : undefined
4682    };
4683  }
4684  //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["profileCheckpoint","profileReport","startMdmRawRead","ensureKeychainPrefetchCompleted","startKeychainPrefetch","feature","Command","CommanderCommand","InvalidArgumentError","Option","chalk","readFileSync","mapValues","pickBy","uniqBy","React","getOauthConfig","getRemoteSessionUrl","getSystemContext","getUserContext","init","initializeTelemetryAfterTrust","addToHistory","Root","launchRepl","hasGrowthBookEnvOverride","initializeGrowthBook","refreshGrowthBookAfterAuthChange","fetchBootstrapData","DownloadResult","downloadSessionFiles","FilesApiConfig","parseFileSpecs","prefetchPassesEligibility","prefetchOfficialMcpUrls","McpSdkServerConfig","McpServerConfig","ScopedMcpServerConfig","isPolicyAllowed","loadPolicyLimits","refreshPolicyLimits","waitForPolicyLimitsToLoad","loadRemoteManagedSettings","refreshRemoteManagedSettings","ToolInputJSONSchema","createSyntheticOutputTool","isSyntheticOutputToolEnabled","getTools","canUserConfigureAdvisor","getInitialAdvisorSetting","isAdvisorEnabled","isValidAdvisorModel","modelSupportsAdvisor","isAgentSwarmsEnabled","count","uniq","installAsciicastRecorder","getSubscriptionType","isClaudeAISubscriber","prefetchAwsCredentialsAndBedRockInfoIfSafe","prefetchGcpCredentialsIfSafe","validateForceLoginOrg","checkHasTrustDialogAccepted","getGlobalConfig","getRemoteControlAtStartup","isAutoUpdaterDisabled","saveGlobalConfig","seedEarlyInput","stopCapturingEarlyInput","getInitialEffortSetting","parseEffortValue","getInitialFastModeSetting","isFastModeEnabled","prefetchFastModeStatus","resolveFastModeStatusFromCache","applyConfigEnvironmentVariables","createSystemMessage","createUserMessage","getPlatform","getBaseRenderOptions","getSessionIngressAuthToken","settingsChangeDetector","skillChangeDetector","jsonParse","writeFileSync_DEPRECATED","computeInitialTeamContext","initializeWarningHandler","isWorktreeModeEnabled","getTeammateUtils","require","getTeammatePromptAddendum","getTeammateModeSnapshot","coordinatorModeModule","assistantModule","kairosGate","relative","resolve","isAnalyticsDisabled","getFeatureValue_CACHED_MAY_BE_STALE","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","logEvent","initializeAnalyticsGates","getOriginalCwd","setAdditionalDirectoriesForClaudeMd","setIsRemoteMode","setMainLoopModelOverride","setMainThreadAgentType","setTeleportedSessionInfo","filterCommandsForRemoteMode","getCommands","StatsStore","launchAssistantInstallWizard","launchAssistantSessionChooser","launchInvalidSettingsDialog","launchResumeChooser","launchSnapshotUpdateDialog","launchTeleportRepoMismatchDialog","launchTeleportResumeWrapper","SHOW_CURSOR","exitWithError","exitWithMessage","getRenderContext","renderAndRun","showSetupScreens","initBuiltinPlugins","checkQuotaStatus","getMcpToolsCommandsAndResources","prefetchAllMcpResources","VALID_INSTALLABLE_SCOPES","VALID_UPDATE_SCOPES","initBundledSkills","AgentColorName","getActiveAgentsFromList","getAgentDefinitionsWithOverrides","isBuiltInAgent","isCustomAgent","parseAgentsFromJson","LogOption","Message","MessageType","assertMinVersion","CLAUDE_IN_CHROME_SKILL_HINT","CLAUDE_IN_CHROME_SKILL_HINT_WITH_WEBBROWSER","setupClaudeInChrome","shouldAutoEnableClaudeInChrome","shouldEnableClaudeInChrome","getContextWindowForModel","loadConversationForResume","buildDeepLinkBanner","hasNodeOption","isBareMode","isEnvTruthy","isInProtectedNamespace","refreshExampleCommands","FpsMetrics","getWorktreePaths","findGitRoot","getBranch","getIsGit","getWorktreeCount","getGhAuthStatus","safeParseJSON","logError","getModelDeprecationWarning","getDefaultMainLoopModel","getUserSpecifiedModelSetting","normalizeModelStringForAPI","parseUserSpecifiedModel","ensureModelStringsInitialized","PERMISSION_MODES","checkAndDisableBypassPermissions","getAutoModeEnabledStateIfCached","initializeToolPermissionContext","initialPermissionModeFromCLI","isDefaultPermissionModeAuto","parseToolListFromCLI","removeDangerousPermissions","stripDangerousPermissionsForAutoMode","verifyAutoModeGateAccess","cleanupOrphanedPluginVersionsInBackground","initializeVersionedPlugins","getManagedPluginNames","getGlobExclusionsForPluginCache","getPluginSeedDirs","countFilesRoundedRg","processSessionStartHooks","processSetupHooks","cacheSessionTitle","getSessionIdFromLog","loadTranscriptFromFile","saveAgentSetting","saveMode","searchSessionsByCustomTitle","sessionIdExists","ensureMdmSettingsLoaded","getInitialSettings","getManagedSettingsKeysForLogging","getSettingsForSource","getSettingsWithErrors","resetSettingsCache","ValidationError","DEFAULT_TASKS_MODE_TASK_LIST_ID","TASK_STATUSES","logPluginLoadErrors","logPluginsEnabledForSession","logSkillsLoaded","generateTempFilePath","validateUuid","registerMcpAddCommand","registerMcpXaaIdpCommand","logPermissionContextForAnts","fetchClaudeAIMcpConfigsIfEligible","clearServerCache","areMcpConfigsAllowedWithEnterpriseMcpConfig","dedupClaudeAiMcpServers","doesEnterpriseMcpConfigExist","filterMcpServersByPolicy","getClaudeCodeMcpConfigs","getMcpServerSignature","parseMcpConfig","parseMcpConfigFromFilePath","excludeCommandsByServer","excludeResourcesByServer","isXaaEnabled","getRelevantTips","logContextMetrics","CLAUDE_IN_CHROME_MCP_SERVER_NAME","isClaudeInChromeMCPServer","registerCleanup","eagerParseCliFlag","createEmptyAttributionState","countConcurrentSessions","registerSession","updateSessionName","getCwd","logForDebugging","setHasFormattedOutput","errorMessage","getErrnoCode","isENOENT","TeleportOperationError","toError","getFsImplementation","safeResolvePath","gracefulShutdown","gracefulShutdownSync","setAllHookEventsEnabled","refreshModelCapabilities","peekForStdinData","writeToStderr","setCwd","ProcessedResume","processResumedConversation","parseSettingSourcesFlag","plural","ChannelEntry","getInitialMainLoopModel","getIsNonInteractiveSession","getSdkBetas","getSessionId","getUserMsgOptIn","setAllowedChannels","setAllowedSettingSources","setChromeFlagOverride","setClientType","setCwdState","setDirectConnectServerUrl","setFlagSettingsPath","setInitialMainLoopModel","setInlinePlugins","setIsInteractive","setKairosActive","setOriginalCwd","setQuestionPreviewFormat","setSdkBetas","setSessionBypassPermissionsMode","setSessionPersistenceDisabled","setSessionSource","setUserMsgOptIn","switchSession","autoModeStateModule","migrateAutoUpdatesToSettings","migrateBypassPermissionsAcceptedToSettings","migrateEnableAllProjectMcpServersToSettings","migrateFennecToOpus","migrateLegacyOpusToCurrent","migrateOpusToOpus1m","migrateReplBridgeEnabledToRemoteControlAtStartup","migrateSonnet1mToSonnet45","migrateSonnet45ToSonnet46","resetAutoModeOptInForDefaultOffer","resetProToOpusDefault","createRemoteSessionConfig","createDirectConnectSession","DirectConnectError","initializeLspServerManager","shouldEnablePromptSuggestion","AppState","getDefaultAppState","IDLE_SPECULATION_STATE","onChangeAppState","createStore","asSessionId","filterAllowedSdkBetas","isInBundledMode","isRunningWithBun","logForDiagnosticsNoPII","filterExistingPaths","getKnownPathsForRepo","clearPluginCache","loadAllPluginsCacheOnly","migrateChangelogFromConfig","SandboxManager","fetchSession","prepareApiRequest","checkOutTeleportedSessionBranch","processMessagesForTeleportResume","teleportToRemoteWithErrorHandling","validateGitState","validateSessionRepository","shouldEnableThinkingByDefault","ThinkingConfig","initUser","resetUserCache","getTmuxInstallInstructions","isTmuxAvailable","parsePRReference","logManagedSettings","policySettings","allKeys","keyCount","length","keys","join","isBeingDebugged","isBun","hasInspectArg","process","execArgv","some","arg","test","hasInspectEnv","env","NODE_OPTIONS","inspector","global","hasInspectorUrl","url","exit","logSessionTelemetry","model","then","enabled","errors","managedNames","catch","err","getCertEnvVarTelemetry","Record","result","NODE_EXTRA_CA_CERTS","has_node_extra_ca_certs","CLAUDE_CODE_CLIENT_CERT","has_client_cert","has_use_system_ca","has_use_openssl_ca","logStartupTelemetry","Promise","isGit","worktreeCount","ghAuthStatus","all","is_git","worktree_count","gh_auth_status","sandbox_enabled","isSandboxingEnabled","are_unsandboxed_commands_allowed","areUnsandboxedCommandsAllowed","is_auto_bash_allowed_if_sandbox_enabled","isAutoAllowBashIfSandboxedEnabled","auto_updater_disabled","prefers_reduced_motion","prefersReducedMotion","CURRENT_MIGRATION_VERSION","runMigrations","migrationVersion","prev","prefetchSystemContextIfSafe","isNonInteractiveSession","hasTrust","startDeferredPrefetches","CLAUDE_CODE_EXIT_AFTER_FIRST_RENDER","CLAUDE_CODE_USE_BEDROCK","CLAUDE_CODE_SKIP_BEDROCK_AUTH","CLAUDE_CODE_USE_VERTEX","CLAUDE_CODE_SKIP_VERTEX_AUTH","AbortSignal","timeout","initialize","m","startEventLoopStallDetector","loadSettingsFromFlag","settingsFile","trimmedSettings","trim","looksLikeJson","startsWith","endsWith","settingsPath","parsedJson","stderr","write","red","contentHash","resolvedPath","resolvedSettingsPath","e","error","Error","loadSettingSourcesFromFlag","settingSourcesArg","sources","eagerLoadSettings","undefined","initializeEntrypoint","isNonInteractive","CLAUDE_CODE_ENTRYPOINT","cliArgs","argv","slice","mcpIndex","indexOf","CLAUDE_CODE_ACTION","PendingConnect","authToken","dangerouslySkipPermissions","_pendingConnect","PendingAssistantChat","sessionId","discover","_pendingAssistantChat","PendingSSH","host","cwd","permissionMode","local","extraCliArgs","_pendingSSH","main","NoDefaultCurrentDirectoryInExePath","on","resetCursor","includes","rawCliArgs","ccIdx","findIndex","a","ccUrl","parseConnectUrl","parsed","stripped","filter","_","i","dspIdx","splice","serverUrl","handleUriIdx","enableConfigs","uri","handleDeepLinkUri","exitCode","platform","__CFBundleIdentifier","handleUrlSchemeLaunch","urlSchemeResult","rawArgs","nextArg","localIdx","pmIdx","pmEqIdx","split","extractFlag","flag","opts","hasValue","as","push","val","eqI","consumed","rest","hasPrintFlag","hasInitOnlyFlag","hasSdkUrl","stdout","isTTY","isInteractive","clientType","GITHUB_ACTIONS","hasSessionIngressToken","CLAUDE_CODE_SESSION_ACCESS_TOKEN","CLAUDE_CODE_WEBSOCKET_AUTH_FILE_DESCRIPTOR","previewFormat","CLAUDE_CODE_QUESTION_PREVIEW_FORMAT","CLAUDE_CODE_ENVIRONMENT_KIND","run","getInputPrompt","prompt","inputFormat","AsyncIterable","stdin","setEncoding","data","onData","chunk","timedOut","off","Boolean","createSortedHelpConfig","sortSubcommands","sortOptions","getOptionSortKey","opt","long","replace","short","Object","assign","const","compareOptions","b","localeCompare","program","configureHelp","enablePositionalOptions","hook","thisCommand","CLAUDE_CODE_DISABLE_TERMINAL_TITLE","title","initSinks","pluginDir","getOptionValue","Array","isArray","every","p","uploadUserSettingsInBackground","name","description","argument","String","helpOption","option","_value","addOption","argParser","hideHelp","choices","Number","value","amount","isNaN","tokens","isInteger","default","v","n","isFinite","rawValue","toLowerCase","allowed","action","options","bare","CLAUDE_CODE_SIMPLE","console","warn","yellow","kairosEnabled","assistantTeamContext","Awaited","ReturnType","NonNullable","assistant","markAssistantForced","isAssistantMode","agentId","isAssistantForced","isKairosEnabled","brief","initializeAssistantTeam","debug","debugToStderr","allowDangerouslySkipPermissions","tools","baseTools","allowedTools","disallowedTools","mcpConfig","permissionModeCli","addDir","fallbackModel","betas","ide","includeHookEvents","includePartialMessages","prefill","fileDownloadPromise","agentsJson","agents","agentCli","agent","CLAUDE_CODE_AGENT","outputFormat","verbose","print","initOnly","maintenance","disableSlashCommands","tasksOption","tasks","taskListId","CLAUDE_CODE_TASK_LIST_ID","worktreeOption","worktree","worktreeName","worktreeEnabled","worktreePRNumber","prNum","tmuxEnabled","tmux","storedTeammateOpts","TeammateOptions","teammateOpts","extractTeammateOptions","hasAnyTeammateOpt","agentName","teamName","hasAllRequiredTeammateOpts","setDynamicTeamContext","color","agentColor","planModeRequired","parentSessionId","teammateMode","setCliTeammateModeOverride","sdkUrl","effectiveIncludePartialMessages","CLAUDE_CODE_INCLUDE_PARTIAL_MESSAGES","CLAUDE_CODE_REMOTE","teleport","remoteOption","remote","remoteControlOption","remoteControl","rc","remoteControlName","continue","resume","forkSession","validatedSessionId","fileSpecs","file","sessionToken","fileSessionId","CLAUDE_CODE_REMOTE_SESSION_ID","files","config","baseUrl","ANTHROPIC_BASE_URL","BASE_API_URL","oauthToken","systemPrompt","systemPromptFile","filePath","code","appendSystemPrompt","appendSystemPromptFile","addendum","TEAMMATE_SYSTEM_PROMPT_ADDENDUM","mode","notification","permissionModeNotification","enableAutoMode","setAutoModeFlagCli","dynamicMcpConfig","processedConfigs","map","allConfigs","allErrors","configItem","configs","configObject","expandVars","scope","mcpServers","configPath","formattedErrors","path","message","level","nonSdkConfigNames","entries","type","reservedNameError","isComputerUseMCPServer","COMPUTER_USE_MCP_SERVER_NAME","scopedConfigs","blocked","chromeOpts","chrome","enableClaudeInChrome","autoEnableClaudeInChrome","chromeMcpConfig","chromeMcpTools","chromeSystemPrompt","hint","Bun","strictMcpConfig","getChicagoEnabled","setupComputerUseMCP","cuTools","devChannels","parseChannelEntries","raw","bad","c","at","kind","marketplace","channelOpts","channels","dangerouslyLoadDevelopmentChannels","rawChannels","rawDev","channelEntries","joinPluginIds","ids","flatMap","sort","channels_count","dev_count","plugins","dev_plugins","BRIEF_TOOL_NAME","LEGACY_BRIEF_TOOL_NAME","isBriefEntitled","initResult","allowedToolsCli","disallowedToolsCli","baseToolsCli","addDirs","toolPermissionContext","warnings","dangerousPermissions","overlyBroadBashPermissions","permission","ruleDisplay","sourceDisplay","forEach","warning","claudeaiConfigPromise","mcpConfigStart","Date","now","mcpConfigResolvedMs","mcpConfigPromise","servers","replayUserMessages","sessionPersistence","effectivePrompt","inputPrompt","maybeActivateProactive","CLAUDE_CODE_COORDINATOR_MODE","applyCoordinatorToolFilter","jsonSchema","syntheticOutputResult","tool","schema_property_count","properties","has_required_fields","required","setupStart","setup","messagingSocketPath","preSetupCwd","setupPromise","commandsPromise","agentDefsPromise","effectiveReplayUserMessages","sessionNameArg","explicitModel","ANTHROPIC_MODEL","cachedGrowthBookFeatures","userSpecifiedModel","userSpecifiedFallbackModel","currentCwd","commandsStart","commands","agentDefinitionsResult","cliAgents","activeAgents","parsedAgents","allAgents","agentDefinitions","agentSetting","mainThreadAgentDefinition","find","agentType","source","agentSystemPrompt","getSystemPrompt","initialPrompt","effectiveModel","initialMainLoopModel","resolvedInitialModel","advisorModel","advisorOption","advisor","normalizedAdvisorModel","customAgent","customPrompt","memory","agent_type","customInstructions","maybeActivateBrief","defaultView","proactive","CLAUDE_CODE_PROACTIVE","isCoordinatorMode","briefVisibility","isBriefEnabled","proactivePrompt","assistantAddendum","getAssistantSystemPromptAddendum","root","getFpsMetrics","stats","ctx","createRoot","renderOptions","event","durationMs","Math","round","uptime","setupScreensStart","onboardingShown","getBridgeDisabledReason","disabledReason","pendingSnapshotUpdate","agentDef","choice","snapshotTimestamp","buildMergePrompt","mergePrompt","clearTrustedDeviceToken","enrollTrustedDevice","orgValidation","valid","nonMcpErrors","mcpErrorMetadata","settingsErrors","onExit","bgRefreshThrottleMs","lastPrefetched","startupPrefetchedAt","skipStartupPrefetches","lastPrefetchedInfo","current","existingMcpConfigs","allMcpConfigs","sdkMcpConfigs","regularMcpConfigs","typedConfig","localMcpPromise","clients","claudeaiMcpPromise","mcpPromise","claudeai","hooksPromise","hookMessages","mcpClients","mcpTools","mcpCommands","thinkingEnabled","thinkingConfig","thinking","maxThinkingTokens","MAX_THINKING_TOKENS","parseInt","budgetTokens","version","MACRO","VERSION","is_native_binary","logTenguInit","hasInitialPrompt","hasStdin","numAllowedTools","numDisallowedTools","mcpClientCount","skipWebFetchPreflight","githubActionInputs","GITHUB_ACTION_INPUTS","dangerouslySkipPermissionsPassed","modeIsBypass","allowDangerouslySkipPermissionsPassed","systemPromptFlag","appendSystemPromptFlag","assistantActivationPath","getAssistantActivationPath","registered","num_sessions","setupTrigger","forceSyncExecution","sessionStartHooksPromise","commandsHeadless","command","disableNonInteractive","supportsNonInteractive","defaultState","headlessInitialState","mcp","effortValue","effort","fastMode","headlessStore","getState","updateContext","setState","nextCtx","connectMcpBatch","label","client","CLAUDE_AI_MCP_TIMEOUT_MS","claudeaiConnect","claudeaiConfigs","claudeaiSigs","Set","values","sig","add","suppressed","has","size","onclose","resources","t","mcpInfo","serverName","nonPluginConfigs","dedupedClaudeAi","claudeaiTimer","setTimeout","claudeaiTimedOut","race","r","clearTimeout","startBackgroundHousekeeping","startSdkMemoryMonitor","runHeadless","permissionPromptToolName","permissionPromptTool","maxTurns","maxBudgetUsd","taskBudget","total","resumeSessionAt","rewindFiles","enableAuthStatus","workload","cli_flag","env_var","settings_file","subscriptionType","deprecationWarning","initialNotifications","key","text","priority","displayList","displays","effectiveToolPermissionContext","isPlanModeRequired","initialIsBriefOnly","fullRemoteControl","ccrMirrorEnabled","isCcrMirrorEnabled","initialState","settings","agentNameRegistry","Map","mainLoopModel","mainLoopModelForSession","isBriefOnly","expandedView","showSpinnerTree","showExpandedTodos","showTeammateMessagePreview","selectedIPAgentIndex","coordinatorTaskIndex","viewSelectionMode","footerSelection","pluginReconnectKey","disabled","installationStatus","marketplaces","needsRefresh","statusLineText","remoteSessionUrl","remoteConnectionStatus","remoteBackgroundTaskCount","replBridgeEnabled","replBridgeExplicit","replBridgeOutboundOnly","replBridgeConnected","replBridgeSessionActive","replBridgeReconnecting","replBridgeConnectUrl","replBridgeSessionUrl","replBridgeEnvironmentId","replBridgeSessionId","replBridgeError","replBridgeInitialName","showRemoteCallout","notifications","queue","elicitation","todos","remoteAgentTaskSuggestions","fileHistory","snapshots","trackedFiles","snapshotSequence","attribution","promptSuggestionEnabled","sessionHooks","inbox","messages","promptSuggestion","promptId","shownAt","acceptedAt","generationRequestId","speculation","speculationSessionTimeSavedMs","skillImprovement","suggestion","workerSandboxPermissions","selectedIndex","pendingWorkerRequest","pendingSandboxRequest","authVersion","initialMessage","content","activeOverlays","teamContext","initialTools","numStartups","setImmediate","sessionUploaderPromise","uploaderReady","mod","createSessionTurnUploader","sessionConfig","autoConnectIdeFlag","onTurnComplete","uploader","resumeContext","modeApi","resumeSucceeded","resumeStart","performance","clearSessionCaches","success","loaded","includeAttribution","transcriptPath","fullPath","restoredAgentDef","resume_duration_ms","initialMessages","initialFileHistorySnapshots","fileHistorySnapshots","initialContentReplacements","contentReplacements","initialAgentName","initialAgentColor","directConnectConfig","session","workDir","connectInfoMessage","createSSHSession","createLocalSSHSession","SSHSessionError","sshSession","hadProgress","localVersion","onProgress","msg","remoteCwd","sshInfoMessage","discoverAssistantSessions","targetSessionId","sessions","installedDir","beforeExit","id","picked","checkAndRefreshOAuthTokenIfNeeded","getClaudeAIOAuthTokens","apiCreds","getAccessToken","accessToken","remoteSessionConfig","orgUUID","infoMessage","assistantInitialState","remoteCommands","fromPr","processedResume","maybeSessionId","searchTerm","matchedLog","filterByPr","trimmedValue","matches","exact","isRemoteTuiEnabled","has_initial_prompt","currentBranch","createdSession","AbortController","signal","session_id","getTokensForRemote","getAccessTokenForRemote","remoteInfoMessage","initialUserMessage","remoteInitialState","teleportResult","branchError","branch","log","sessionData","repoValidation","status","sessionRepo","knownPaths","existingPaths","selectedPath","targetRepo","initialPaths","chdir","bold","teleportWithProgress","formattedMessage","parseCcshareId","loadCcshare","ccshareId","logOption","entrypoint","sessionIdOverride","results","failedCount","resumeData","initialSearchQuery","pendingHookMessages","deepLinkBanner","deepLinkOrigin","has_prefill","has_repo","deepLinkRepo","prefillLength","repo","lastFetch","deepLinkLastFetch","implies","isPrintMode","isCcUrl","parseAsync","mcpServeHandler","mcpRemoveHandler","mcpListHandler","mcpGetHandler","json","clientSecret","mcpAddJsonHandler","mcpAddFromDesktopHandler","mcpResetChoicesHandler","port","unix","workspace","idleTimeout","maxSessions","randomBytes","startServer","SessionManager","DangerousBackend","printBanner","createServerLogger","writeServerLock","removeServerLock","probeRunningServer","existing","pid","httpUrl","toString","idleTimeoutMs","backend","sessionManager","logger","server","actualPort","startedAt","shuttingDown","shutdown","stop","destroyAll","once","connectConfig","runConnectHeadless","interactive","auth","email","sso","useConsole","authLogin","authStatus","authLogout","coworkOption","pluginCmd","alias","manifestPath","cowork","pluginValidateHandler","available","pluginListHandler","marketplaceCmd","sparse","marketplaceAddHandler","marketplaceListHandler","marketplaceRemoveHandler","marketplaceUpdateHandler","plugin","pluginInstallHandler","keepData","pluginUninstallHandler","pluginEnableHandler","pluginDisableHandler","pluginUpdateHandler","setupTokenHandler","agentsHandler","autoModeCmd","autoModeDefaultsHandler","autoModeConfigHandler","autoModeCritiqueHandler","hidden","bridgeMain","doctorHandler","update","up","target","list","dryRun","safe","rollback","force","installHandler","validateLogId","logId","logHandler","number","errorHandler","usage","addHelpText","outputFile","exportHandler","taskCmd","subject","taskCreateHandler","pending","taskListHandler","taskGetHandler","owner","clearOwner","taskUpdateHandler","taskDirHandler","shell","output","completionHandler","inProtectedNamespace","thinkingType","is_simple","is_coordinator","autoUpdatesChannel","gitRoot","rp","relativeProjectPath","proactiveModule","isProactiveActive","activateProactive","briefFlag","briefEnv","CLAUDE_CODE_BRIEF","entitled","gated","terminal"],"sources":["main.tsx"],"sourcesContent":["// These side-effects must run before all other imports:\n// 1. profileCheckpoint marks entry before heavy module evaluation begins\n// 2. startMdmRawRead fires MDM subprocesses (plutil/reg query) so they run in\n//    parallel with the remaining ~135ms of imports below\n// 3. startKeychainPrefetch fires both macOS keychain reads (OAuth + legacy API\n//    key) in parallel — isRemoteManagedSettingsEligible() otherwise reads them\n//    sequentially via sync spawn inside applySafeConfigEnvironmentVariables()\n//    (~65ms on every macOS startup)\nimport { profileCheckpoint, profileReport } from './utils/startupProfiler.js'\n\n// eslint-disable-next-line custom-rules/no-top-level-side-effects\nprofileCheckpoint('main_tsx_entry')\n\nimport { startMdmRawRead } from './utils/settings/mdm/rawRead.js'\n\n// eslint-disable-next-line custom-rules/no-top-level-side-effects\nstartMdmRawRead()\n\nimport {\n  ensureKeychainPrefetchCompleted,\n  startKeychainPrefetch,\n} from './utils/secureStorage/keychainPrefetch.js'\n\n// eslint-disable-next-line custom-rules/no-top-level-side-effects\nstartKeychainPrefetch()\n\nimport { feature } from 'bun:bundle'\nimport {\n  Command as CommanderCommand,\n  InvalidArgumentError,\n  Option,\n} from '@commander-js/extra-typings'\nimport chalk from 'chalk'\nimport { readFileSync } from 'fs'\nimport mapValues from 'lodash-es/mapValues.js'\nimport pickBy from 'lodash-es/pickBy.js'\nimport uniqBy from 'lodash-es/uniqBy.js'\nimport React from 'react'\nimport { getOauthConfig } from './constants/oauth.js'\nimport { getRemoteSessionUrl } from './constants/product.js'\nimport { getSystemContext, getUserContext } from './context.js'\nimport { init, initializeTelemetryAfterTrust } from './entrypoints/init.js'\nimport { addToHistory } from './history.js'\nimport type { Root } from './ink.js'\nimport { launchRepl } from './replLauncher.js'\nimport {\n  hasGrowthBookEnvOverride,\n  initializeGrowthBook,\n  refreshGrowthBookAfterAuthChange,\n} from './services/analytics/growthbook.js'\nimport { fetchBootstrapData } from './services/api/bootstrap.js'\nimport {\n  type DownloadResult,\n  downloadSessionFiles,\n  type FilesApiConfig,\n  parseFileSpecs,\n} from './services/api/filesApi.js'\nimport { prefetchPassesEligibility } from './services/api/referral.js'\nimport { prefetchOfficialMcpUrls } from './services/mcp/officialRegistry.js'\nimport type {\n  McpSdkServerConfig,\n  McpServerConfig,\n  ScopedMcpServerConfig,\n} from './services/mcp/types.js'\nimport {\n  isPolicyAllowed,\n  loadPolicyLimits,\n  refreshPolicyLimits,\n  waitForPolicyLimitsToLoad,\n} from './services/policyLimits/index.js'\nimport {\n  loadRemoteManagedSettings,\n  refreshRemoteManagedSettings,\n} from './services/remoteManagedSettings/index.js'\nimport type { ToolInputJSONSchema } from './Tool.js'\nimport {\n  createSyntheticOutputTool,\n  isSyntheticOutputToolEnabled,\n} from './tools/SyntheticOutputTool/SyntheticOutputTool.js'\nimport { getTools } from './tools.js'\nimport {\n  canUserConfigureAdvisor,\n  getInitialAdvisorSetting,\n  isAdvisorEnabled,\n  isValidAdvisorModel,\n  modelSupportsAdvisor,\n} from './utils/advisor.js'\nimport { isAgentSwarmsEnabled } from './utils/agentSwarmsEnabled.js'\nimport { count, uniq } from './utils/array.js'\nimport { installAsciicastRecorder } from './utils/asciicast.js'\nimport {\n  getSubscriptionType,\n  isClaudeAISubscriber,\n  prefetchAwsCredentialsAndBedRockInfoIfSafe,\n  prefetchGcpCredentialsIfSafe,\n  validateForceLoginOrg,\n} from './utils/auth.js'\nimport {\n  checkHasTrustDialogAccepted,\n  getGlobalConfig,\n  getRemoteControlAtStartup,\n  isAutoUpdaterDisabled,\n  saveGlobalConfig,\n} from './utils/config.js'\nimport { seedEarlyInput, stopCapturingEarlyInput } from './utils/earlyInput.js'\nimport { getInitialEffortSetting, parseEffortValue } from './utils/effort.js'\nimport {\n  getInitialFastModeSetting,\n  isFastModeEnabled,\n  prefetchFastModeStatus,\n  resolveFastModeStatusFromCache,\n} from './utils/fastMode.js'\nimport { applyConfigEnvironmentVariables } from './utils/managedEnv.js'\nimport { createSystemMessage, createUserMessage } from './utils/messages.js'\nimport { getPlatform } from './utils/platform.js'\nimport { getBaseRenderOptions } from './utils/renderOptions.js'\nimport { getSessionIngressAuthToken } from './utils/sessionIngressAuth.js'\nimport { settingsChangeDetector } from './utils/settings/changeDetector.js'\nimport { skillChangeDetector } from './utils/skills/skillChangeDetector.js'\nimport { jsonParse, writeFileSync_DEPRECATED } from './utils/slowOperations.js'\nimport { computeInitialTeamContext } from './utils/swarm/reconnection.js'\nimport { initializeWarningHandler } from './utils/warningHandler.js'\nimport { isWorktreeModeEnabled } from './utils/worktreeModeEnabled.js'\n\n// Lazy require to avoid circular dependency: teammate.ts -> AppState.tsx -> ... -> main.tsx\n/* eslint-disable @typescript-eslint/no-require-imports */\nconst getTeammateUtils = () =>\n  require('./utils/teammate.js') as typeof import('./utils/teammate.js')\nconst getTeammatePromptAddendum = () =>\n  require('./utils/swarm/teammatePromptAddendum.js') as typeof import('./utils/swarm/teammatePromptAddendum.js')\nconst getTeammateModeSnapshot = () =>\n  require('./utils/swarm/backends/teammateModeSnapshot.js') as typeof import('./utils/swarm/backends/teammateModeSnapshot.js')\n/* eslint-enable @typescript-eslint/no-require-imports */\n// Dead code elimination: conditional import for COORDINATOR_MODE\n/* eslint-disable @typescript-eslint/no-require-imports */\nconst coordinatorModeModule = feature('COORDINATOR_MODE')\n  ? (require('./coordinator/coordinatorMode.js') as typeof import('./coordinator/coordinatorMode.js'))\n  : null\n/* eslint-enable @typescript-eslint/no-require-imports */\n// Dead code elimination: conditional import for KAIROS (assistant mode)\n/* eslint-disable @typescript-eslint/no-require-imports */\nconst assistantModule = feature('KAIROS')\n  ? (require('./assistant/index.js') as typeof import('./assistant/index.js'))\n  : null\nconst kairosGate = feature('KAIROS')\n  ? (require('./assistant/gate.js') as typeof import('./assistant/gate.js'))\n  : null\n\nimport { relative, resolve } from 'path'\nimport { isAnalyticsDisabled } from 'src/services/analytics/config.js'\nimport { getFeatureValue_CACHED_MAY_BE_STALE } from 'src/services/analytics/growthbook.js'\nimport {\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  logEvent,\n} from 'src/services/analytics/index.js'\nimport { initializeAnalyticsGates } from 'src/services/analytics/sink.js'\nimport {\n  getOriginalCwd,\n  setAdditionalDirectoriesForClaudeMd,\n  setIsRemoteMode,\n  setMainLoopModelOverride,\n  setMainThreadAgentType,\n  setTeleportedSessionInfo,\n} from './bootstrap/state.js'\nimport { filterCommandsForRemoteMode, getCommands } from './commands.js'\nimport type { StatsStore } from './context/stats.js'\nimport {\n  launchAssistantInstallWizard,\n  launchAssistantSessionChooser,\n  launchInvalidSettingsDialog,\n  launchResumeChooser,\n  launchSnapshotUpdateDialog,\n  launchTeleportRepoMismatchDialog,\n  launchTeleportResumeWrapper,\n} from './dialogLaunchers.js'\nimport { SHOW_CURSOR } from './ink/termio/dec.js'\nimport {\n  exitWithError,\n  exitWithMessage,\n  getRenderContext,\n  renderAndRun,\n  showSetupScreens,\n} from './interactiveHelpers.js'\nimport { initBuiltinPlugins } from './plugins/bundled/index.js'\n/* eslint-enable @typescript-eslint/no-require-imports */\nimport { checkQuotaStatus } from './services/claudeAiLimits.js'\nimport {\n  getMcpToolsCommandsAndResources,\n  prefetchAllMcpResources,\n} from './services/mcp/client.js'\nimport {\n  VALID_INSTALLABLE_SCOPES,\n  VALID_UPDATE_SCOPES,\n} from './services/plugins/pluginCliCommands.js'\nimport { initBundledSkills } from './skills/bundled/index.js'\nimport type { AgentColorName } from './tools/AgentTool/agentColorManager.js'\nimport {\n  getActiveAgentsFromList,\n  getAgentDefinitionsWithOverrides,\n  isBuiltInAgent,\n  isCustomAgent,\n  parseAgentsFromJson,\n} from './tools/AgentTool/loadAgentsDir.js'\nimport type { LogOption } from './types/logs.js'\nimport type { Message as MessageType } from './types/message.js'\nimport { assertMinVersion } from './utils/autoUpdater.js'\nimport {\n  CLAUDE_IN_CHROME_SKILL_HINT,\n  CLAUDE_IN_CHROME_SKILL_HINT_WITH_WEBBROWSER,\n} from './utils/claudeInChrome/prompt.js'\nimport {\n  setupClaudeInChrome,\n  shouldAutoEnableClaudeInChrome,\n  shouldEnableClaudeInChrome,\n} from './utils/claudeInChrome/setup.js'\nimport { getContextWindowForModel } from './utils/context.js'\nimport { loadConversationForResume } from './utils/conversationRecovery.js'\nimport { buildDeepLinkBanner } from './utils/deepLink/banner.js'\nimport {\n  hasNodeOption,\n  isBareMode,\n  isEnvTruthy,\n  isInProtectedNamespace,\n} from './utils/envUtils.js'\nimport { refreshExampleCommands } from './utils/exampleCommands.js'\nimport type { FpsMetrics } from './utils/fpsTracker.js'\nimport { getWorktreePaths } from './utils/getWorktreePaths.js'\nimport {\n  findGitRoot,\n  getBranch,\n  getIsGit,\n  getWorktreeCount,\n} from './utils/git.js'\nimport { getGhAuthStatus } from './utils/github/ghAuthStatus.js'\nimport { safeParseJSON } from './utils/json.js'\nimport { logError } from './utils/log.js'\nimport { getModelDeprecationWarning } from './utils/model/deprecation.js'\nimport {\n  getDefaultMainLoopModel,\n  getUserSpecifiedModelSetting,\n  normalizeModelStringForAPI,\n  parseUserSpecifiedModel,\n} from './utils/model/model.js'\nimport { ensureModelStringsInitialized } from './utils/model/modelStrings.js'\nimport { PERMISSION_MODES } from './utils/permissions/PermissionMode.js'\nimport {\n  checkAndDisableBypassPermissions,\n  getAutoModeEnabledStateIfCached,\n  initializeToolPermissionContext,\n  initialPermissionModeFromCLI,\n  isDefaultPermissionModeAuto,\n  parseToolListFromCLI,\n  removeDangerousPermissions,\n  stripDangerousPermissionsForAutoMode,\n  verifyAutoModeGateAccess,\n} from './utils/permissions/permissionSetup.js'\nimport { cleanupOrphanedPluginVersionsInBackground } from './utils/plugins/cacheUtils.js'\nimport { initializeVersionedPlugins } from './utils/plugins/installedPluginsManager.js'\nimport { getManagedPluginNames } from './utils/plugins/managedPlugins.js'\nimport { getGlobExclusionsForPluginCache } from './utils/plugins/orphanedPluginFilter.js'\nimport { getPluginSeedDirs } from './utils/plugins/pluginDirectories.js'\nimport { countFilesRoundedRg } from './utils/ripgrep.js'\nimport {\n  processSessionStartHooks,\n  processSetupHooks,\n} from './utils/sessionStart.js'\nimport {\n  cacheSessionTitle,\n  getSessionIdFromLog,\n  loadTranscriptFromFile,\n  saveAgentSetting,\n  saveMode,\n  searchSessionsByCustomTitle,\n  sessionIdExists,\n} from './utils/sessionStorage.js'\nimport { ensureMdmSettingsLoaded } from './utils/settings/mdm/settings.js'\nimport {\n  getInitialSettings,\n  getManagedSettingsKeysForLogging,\n  getSettingsForSource,\n  getSettingsWithErrors,\n} from './utils/settings/settings.js'\nimport { resetSettingsCache } from './utils/settings/settingsCache.js'\nimport type { ValidationError } from './utils/settings/validation.js'\nimport {\n  DEFAULT_TASKS_MODE_TASK_LIST_ID,\n  TASK_STATUSES,\n} from './utils/tasks.js'\nimport {\n  logPluginLoadErrors,\n  logPluginsEnabledForSession,\n} from './utils/telemetry/pluginTelemetry.js'\nimport { logSkillsLoaded } from './utils/telemetry/skillLoadedEvent.js'\nimport { generateTempFilePath } from './utils/tempfile.js'\nimport { validateUuid } from './utils/uuid.js'\n// Plugin startup checks are now handled non-blockingly in REPL.tsx\n\nimport { registerMcpAddCommand } from 'src/commands/mcp/addCommand.js'\nimport { registerMcpXaaIdpCommand } from 'src/commands/mcp/xaaIdpCommand.js'\nimport { logPermissionContextForAnts } from 'src/services/internalLogging.js'\nimport { fetchClaudeAIMcpConfigsIfEligible } from 'src/services/mcp/claudeai.js'\nimport { clearServerCache } from 'src/services/mcp/client.js'\nimport {\n  areMcpConfigsAllowedWithEnterpriseMcpConfig,\n  dedupClaudeAiMcpServers,\n  doesEnterpriseMcpConfigExist,\n  filterMcpServersByPolicy,\n  getClaudeCodeMcpConfigs,\n  getMcpServerSignature,\n  parseMcpConfig,\n  parseMcpConfigFromFilePath,\n} from 'src/services/mcp/config.js'\nimport {\n  excludeCommandsByServer,\n  excludeResourcesByServer,\n} from 'src/services/mcp/utils.js'\nimport { isXaaEnabled } from 'src/services/mcp/xaaIdpLogin.js'\nimport { getRelevantTips } from 'src/services/tips/tipRegistry.js'\nimport { logContextMetrics } from 'src/utils/api.js'\nimport {\n  CLAUDE_IN_CHROME_MCP_SERVER_NAME,\n  isClaudeInChromeMCPServer,\n} from 'src/utils/claudeInChrome/common.js'\nimport { registerCleanup } from 'src/utils/cleanupRegistry.js'\nimport { eagerParseCliFlag } from 'src/utils/cliArgs.js'\nimport { createEmptyAttributionState } from 'src/utils/commitAttribution.js'\nimport {\n  countConcurrentSessions,\n  registerSession,\n  updateSessionName,\n} from 'src/utils/concurrentSessions.js'\nimport { getCwd } from 'src/utils/cwd.js'\nimport { logForDebugging, setHasFormattedOutput } from 'src/utils/debug.js'\nimport {\n  errorMessage,\n  getErrnoCode,\n  isENOENT,\n  TeleportOperationError,\n  toError,\n} from 'src/utils/errors.js'\nimport { getFsImplementation, safeResolvePath } from 'src/utils/fsOperations.js'\nimport {\n  gracefulShutdown,\n  gracefulShutdownSync,\n} from 'src/utils/gracefulShutdown.js'\nimport { setAllHookEventsEnabled } from 'src/utils/hooks/hookEvents.js'\nimport { refreshModelCapabilities } from 'src/utils/model/modelCapabilities.js'\nimport { peekForStdinData, writeToStderr } from 'src/utils/process.js'\nimport { setCwd } from 'src/utils/Shell.js'\nimport {\n  type ProcessedResume,\n  processResumedConversation,\n} from 'src/utils/sessionRestore.js'\nimport { parseSettingSourcesFlag } from 'src/utils/settings/constants.js'\nimport { plural } from 'src/utils/stringUtils.js'\nimport {\n  type ChannelEntry,\n  getInitialMainLoopModel,\n  getIsNonInteractiveSession,\n  getSdkBetas,\n  getSessionId,\n  getUserMsgOptIn,\n  setAllowedChannels,\n  setAllowedSettingSources,\n  setChromeFlagOverride,\n  setClientType,\n  setCwdState,\n  setDirectConnectServerUrl,\n  setFlagSettingsPath,\n  setInitialMainLoopModel,\n  setInlinePlugins,\n  setIsInteractive,\n  setKairosActive,\n  setOriginalCwd,\n  setQuestionPreviewFormat,\n  setSdkBetas,\n  setSessionBypassPermissionsMode,\n  setSessionPersistenceDisabled,\n  setSessionSource,\n  setUserMsgOptIn,\n  switchSession,\n} from './bootstrap/state.js'\n\n/* eslint-disable @typescript-eslint/no-require-imports */\nconst autoModeStateModule = feature('TRANSCRIPT_CLASSIFIER')\n  ? (require('./utils/permissions/autoModeState.js') as typeof import('./utils/permissions/autoModeState.js'))\n  : null\n\n// TeleportRepoMismatchDialog, TeleportResumeWrapper dynamically imported at call sites\nimport { migrateAutoUpdatesToSettings } from './migrations/migrateAutoUpdatesToSettings.js'\nimport { migrateBypassPermissionsAcceptedToSettings } from './migrations/migrateBypassPermissionsAcceptedToSettings.js'\nimport { migrateEnableAllProjectMcpServersToSettings } from './migrations/migrateEnableAllProjectMcpServersToSettings.js'\nimport { migrateFennecToOpus } from './migrations/migrateFennecToOpus.js'\nimport { migrateLegacyOpusToCurrent } from './migrations/migrateLegacyOpusToCurrent.js'\nimport { migrateOpusToOpus1m } from './migrations/migrateOpusToOpus1m.js'\nimport { migrateReplBridgeEnabledToRemoteControlAtStartup } from './migrations/migrateReplBridgeEnabledToRemoteControlAtStartup.js'\nimport { migrateSonnet1mToSonnet45 } from './migrations/migrateSonnet1mToSonnet45.js'\nimport { migrateSonnet45ToSonnet46 } from './migrations/migrateSonnet45ToSonnet46.js'\nimport { resetAutoModeOptInForDefaultOffer } from './migrations/resetAutoModeOptInForDefaultOffer.js'\nimport { resetProToOpusDefault } from './migrations/resetProToOpusDefault.js'\nimport { createRemoteSessionConfig } from './remote/RemoteSessionManager.js'\n/* eslint-enable @typescript-eslint/no-require-imports */\n// teleportWithProgress dynamically imported at call site\nimport {\n  createDirectConnectSession,\n  DirectConnectError,\n} from './server/createDirectConnectSession.js'\nimport { initializeLspServerManager } from './services/lsp/manager.js'\nimport { shouldEnablePromptSuggestion } from './services/PromptSuggestion/promptSuggestion.js'\nimport {\n  type AppState,\n  getDefaultAppState,\n  IDLE_SPECULATION_STATE,\n} from './state/AppStateStore.js'\nimport { onChangeAppState } from './state/onChangeAppState.js'\nimport { createStore } from './state/store.js'\nimport { asSessionId } from './types/ids.js'\nimport { filterAllowedSdkBetas } from './utils/betas.js'\nimport { isInBundledMode, isRunningWithBun } from './utils/bundledMode.js'\nimport { logForDiagnosticsNoPII } from './utils/diagLogs.js'\nimport {\n  filterExistingPaths,\n  getKnownPathsForRepo,\n} from './utils/githubRepoPathMapping.js'\nimport {\n  clearPluginCache,\n  loadAllPluginsCacheOnly,\n} from './utils/plugins/pluginLoader.js'\nimport { migrateChangelogFromConfig } from './utils/releaseNotes.js'\nimport { SandboxManager } from './utils/sandbox/sandbox-adapter.js'\nimport { fetchSession, prepareApiRequest } from './utils/teleport/api.js'\nimport {\n  checkOutTeleportedSessionBranch,\n  processMessagesForTeleportResume,\n  teleportToRemoteWithErrorHandling,\n  validateGitState,\n  validateSessionRepository,\n} from './utils/teleport.js'\nimport {\n  shouldEnableThinkingByDefault,\n  type ThinkingConfig,\n} from './utils/thinking.js'\nimport { initUser, resetUserCache } from './utils/user.js'\nimport {\n  getTmuxInstallInstructions,\n  isTmuxAvailable,\n  parsePRReference,\n} from './utils/worktree.js'\n\n// eslint-disable-next-line custom-rules/no-top-level-side-effects\nprofileCheckpoint('main_tsx_imports_loaded')\n\n/**\n * Log managed settings keys to Statsig for analytics.\n * This is called after init() completes to ensure settings are loaded\n * and environment variables are applied before model resolution.\n */\nfunction logManagedSettings(): void {\n  try {\n    const policySettings = getSettingsForSource('policySettings')\n    if (policySettings) {\n      const allKeys = getManagedSettingsKeysForLogging(policySettings)\n      logEvent('tengu_managed_settings_loaded', {\n        keyCount: allKeys.length,\n        keys: allKeys.join(\n          ',',\n        ) as unknown as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      })\n    }\n  } catch {\n    // Silently ignore errors - this is just for analytics\n  }\n}\n\n// Check if running in debug/inspection mode\nfunction isBeingDebugged() {\n  const isBun = isRunningWithBun()\n\n  // Check for inspect flags in process arguments (including all variants)\n  const hasInspectArg = process.execArgv.some(arg => {\n    if (isBun) {\n      // Note: Bun has an issue with single-file executables where application arguments\n      // from process.argv leak into process.execArgv (similar to https://github.com/oven-sh/bun/issues/11673)\n      // This breaks use of --debug mode if we omit this branch\n      // We're fine to skip that check, because Bun doesn't support Node.js legacy --debug or --debug-brk flags\n      return /--inspect(-brk)?/.test(arg)\n    } else {\n      // In Node.js, check for both --inspect and legacy --debug flags\n      return /--inspect(-brk)?|--debug(-brk)?/.test(arg)\n    }\n  })\n\n  // Check if NODE_OPTIONS contains inspect flags\n  const hasInspectEnv =\n    process.env.NODE_OPTIONS &&\n    /--inspect(-brk)?|--debug(-brk)?/.test(process.env.NODE_OPTIONS)\n\n  // Check if inspector is available and active (indicates debugging)\n  try {\n    // Dynamic import would be better but is async - use global object instead\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const inspector = (global as any).require('inspector')\n    const hasInspectorUrl = !!inspector.url()\n    return hasInspectorUrl || hasInspectArg || hasInspectEnv\n  } catch {\n    // Ignore error and fall back to argument detection\n    return hasInspectArg || hasInspectEnv\n  }\n}\n\n// Exit if we detect node debugging or inspection\nif (\"external\" !== 'ant' && isBeingDebugged()) {\n  // Use process.exit directly here since we're in the top-level code before imports\n  // and gracefulShutdown is not yet available\n  // eslint-disable-next-line custom-rules/no-top-level-side-effects\n  process.exit(1)\n}\n\n/**\n * Per-session skill/plugin telemetry. Called from both the interactive path\n * and the headless -p path (before runHeadless) — both go through\n * main.tsx but branch before the interactive startup path, so it needs two\n * call sites here rather than one here + one in QueryEngine.\n */\nfunction logSessionTelemetry(): void {\n  const model = parseUserSpecifiedModel(\n    getInitialMainLoopModel() ?? getDefaultMainLoopModel(),\n  )\n  void logSkillsLoaded(getCwd(), getContextWindowForModel(model, getSdkBetas()))\n  void loadAllPluginsCacheOnly()\n    .then(({ enabled, errors }) => {\n      const managedNames = getManagedPluginNames()\n      logPluginsEnabledForSession(enabled, managedNames, getPluginSeedDirs())\n      logPluginLoadErrors(errors, managedNames)\n    })\n    .catch(err => logError(err))\n}\n\nfunction getCertEnvVarTelemetry(): Record<string, boolean> {\n  const result: Record<string, boolean> = {}\n  if (process.env.NODE_EXTRA_CA_CERTS) {\n    result.has_node_extra_ca_certs = true\n  }\n  if (process.env.CLAUDE_CODE_CLIENT_CERT) {\n    result.has_client_cert = true\n  }\n  if (hasNodeOption('--use-system-ca')) {\n    result.has_use_system_ca = true\n  }\n  if (hasNodeOption('--use-openssl-ca')) {\n    result.has_use_openssl_ca = true\n  }\n  return result\n}\n\nasync function logStartupTelemetry(): Promise<void> {\n  if (isAnalyticsDisabled()) return\n  const [isGit, worktreeCount, ghAuthStatus] = await Promise.all([\n    getIsGit(),\n    getWorktreeCount(),\n    getGhAuthStatus(),\n  ])\n\n  logEvent('tengu_startup_telemetry', {\n    is_git: isGit,\n    worktree_count: worktreeCount,\n    gh_auth_status:\n      ghAuthStatus as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n    sandbox_enabled: SandboxManager.isSandboxingEnabled(),\n    are_unsandboxed_commands_allowed:\n      SandboxManager.areUnsandboxedCommandsAllowed(),\n    is_auto_bash_allowed_if_sandbox_enabled:\n      SandboxManager.isAutoAllowBashIfSandboxedEnabled(),\n    auto_updater_disabled: isAutoUpdaterDisabled(),\n    prefers_reduced_motion: getInitialSettings().prefersReducedMotion ?? false,\n    ...getCertEnvVarTelemetry(),\n  })\n}\n\n// @[MODEL LAUNCH]: Consider any migrations you may need for model strings. See migrateSonnet1mToSonnet45.ts for an example.\n// Bump this when adding a new sync migration so existing users re-run the set.\nconst CURRENT_MIGRATION_VERSION = 11\nfunction runMigrations(): void {\n  if (getGlobalConfig().migrationVersion !== CURRENT_MIGRATION_VERSION) {\n    migrateAutoUpdatesToSettings()\n    migrateBypassPermissionsAcceptedToSettings()\n    migrateEnableAllProjectMcpServersToSettings()\n    resetProToOpusDefault()\n    migrateSonnet1mToSonnet45()\n    migrateLegacyOpusToCurrent()\n    migrateSonnet45ToSonnet46()\n    migrateOpusToOpus1m()\n    migrateReplBridgeEnabledToRemoteControlAtStartup()\n    if (feature('TRANSCRIPT_CLASSIFIER')) {\n      resetAutoModeOptInForDefaultOffer()\n    }\n    if (\"external\" === 'ant') {\n      migrateFennecToOpus()\n    }\n    saveGlobalConfig(prev =>\n      prev.migrationVersion === CURRENT_MIGRATION_VERSION\n        ? prev\n        : { ...prev, migrationVersion: CURRENT_MIGRATION_VERSION },\n    )\n  }\n  // Async migration - fire and forget since it's non-blocking\n  migrateChangelogFromConfig().catch(() => {\n    // Silently ignore migration errors - will retry on next startup\n  })\n}\n\n/**\n * Prefetch system context (including git status) only when it's safe to do so.\n * Git commands can execute arbitrary code via hooks and config (e.g., core.fsmonitor,\n * diff.external), so we must only run them after trust is established or in\n * non-interactive mode where trust is implicit.\n */\nfunction prefetchSystemContextIfSafe(): void {\n  const isNonInteractiveSession = getIsNonInteractiveSession()\n\n  // In non-interactive mode (--print), trust dialog is skipped and\n  // execution is considered trusted (as documented in help text)\n  if (isNonInteractiveSession) {\n    logForDiagnosticsNoPII('info', 'prefetch_system_context_non_interactive')\n    void getSystemContext()\n    return\n  }\n\n  // In interactive mode, only prefetch if trust has already been established\n  const hasTrust = checkHasTrustDialogAccepted()\n  if (hasTrust) {\n    logForDiagnosticsNoPII('info', 'prefetch_system_context_has_trust')\n    void getSystemContext()\n  } else {\n    logForDiagnosticsNoPII('info', 'prefetch_system_context_skipped_no_trust')\n  }\n  // Otherwise, don't prefetch - wait for trust to be established first\n}\n\n/**\n * Start background prefetches and housekeeping that are NOT needed before first render.\n * These are deferred from setup() to reduce event loop contention and child process\n * spawning during the critical startup path.\n * Call this after the REPL has been rendered.\n */\nexport function startDeferredPrefetches(): void {\n  // This function runs after first render, so it doesn't block the initial paint.\n  // However, the spawned processes and async work still contend for CPU and event\n  // loop time, which skews startup benchmarks (CPU profiles, time-to-first-render\n  // measurements). Skip all of it when we're only measuring startup performance.\n  if (\n    isEnvTruthy(process.env.CLAUDE_CODE_EXIT_AFTER_FIRST_RENDER) ||\n    // --bare: skip ALL prefetches. These are cache-warms for the REPL's\n    // first-turn responsiveness (initUser, getUserContext, tips, countFiles,\n    // modelCapabilities, change detectors). Scripted -p calls don't have a\n    // \"user is typing\" window to hide this work in — it's pure overhead on\n    // the critical path.\n    isBareMode()\n  ) {\n    return\n  }\n\n  // Process-spawning prefetches (consumed at first API call, user is still typing)\n  void initUser()\n  void getUserContext()\n  prefetchSystemContextIfSafe()\n  void getRelevantTips()\n  if (\n    isEnvTruthy(process.env.CLAUDE_CODE_USE_BEDROCK) &&\n    !isEnvTruthy(process.env.CLAUDE_CODE_SKIP_BEDROCK_AUTH)\n  ) {\n    void prefetchAwsCredentialsAndBedRockInfoIfSafe()\n  }\n  if (\n    isEnvTruthy(process.env.CLAUDE_CODE_USE_VERTEX) &&\n    !isEnvTruthy(process.env.CLAUDE_CODE_SKIP_VERTEX_AUTH)\n  ) {\n    void prefetchGcpCredentialsIfSafe()\n  }\n  void countFilesRoundedRg(getCwd(), AbortSignal.timeout(3000), [])\n\n  // Analytics and feature flag initialization\n  void initializeAnalyticsGates()\n  void prefetchOfficialMcpUrls()\n\n  void refreshModelCapabilities()\n\n  // File change detectors deferred from init() to unblock first render\n  void settingsChangeDetector.initialize()\n  if (!isBareMode()) {\n    void skillChangeDetector.initialize()\n  }\n\n  // Event loop stall detector — logs when the main thread is blocked >500ms\n  if (\"external\" === 'ant') {\n    void import('./utils/eventLoopStallDetector.js').then(m =>\n      m.startEventLoopStallDetector(),\n    )\n  }\n}\n\nfunction loadSettingsFromFlag(settingsFile: string): void {\n  try {\n    const trimmedSettings = settingsFile.trim()\n    const looksLikeJson =\n      trimmedSettings.startsWith('{') && trimmedSettings.endsWith('}')\n\n    let settingsPath: string\n\n    if (looksLikeJson) {\n      // It's a JSON string - validate and create temp file\n      const parsedJson = safeParseJSON(trimmedSettings)\n      if (!parsedJson) {\n        process.stderr.write(\n          chalk.red('Error: Invalid JSON provided to --settings\\n'),\n        )\n        process.exit(1)\n      }\n\n      // Create a temporary file and write the JSON to it.\n      // Use a content-hash-based path instead of random UUID to avoid\n      // busting the Anthropic API prompt cache. The settings path ends up\n      // in the Bash tool's sandbox denyWithinAllow list, which is part of\n      // the tool description sent to the API. A random UUID per subprocess\n      // changes the tool description on every query() call, invalidating\n      // the cache prefix and causing a 12x input token cost penalty.\n      // The content hash ensures identical settings produce the same path\n      // across process boundaries (each SDK query() spawns a new process).\n      settingsPath = generateTempFilePath('claude-settings', '.json', {\n        contentHash: trimmedSettings,\n      })\n      writeFileSync_DEPRECATED(settingsPath, trimmedSettings, 'utf8')\n    } else {\n      // It's a file path - resolve and validate by attempting to read\n      const { resolvedPath: resolvedSettingsPath } = safeResolvePath(\n        getFsImplementation(),\n        settingsFile,\n      )\n      try {\n        readFileSync(resolvedSettingsPath, 'utf8')\n      } catch (e) {\n        if (isENOENT(e)) {\n          process.stderr.write(\n            chalk.red(\n              `Error: Settings file not found: ${resolvedSettingsPath}\\n`,\n            ),\n          )\n          process.exit(1)\n        }\n        throw e\n      }\n      settingsPath = resolvedSettingsPath\n    }\n\n    setFlagSettingsPath(settingsPath)\n    resetSettingsCache()\n  } catch (error) {\n    if (error instanceof Error) {\n      logError(error)\n    }\n    process.stderr.write(\n      chalk.red(`Error processing settings: ${errorMessage(error)}\\n`),\n    )\n    process.exit(1)\n  }\n}\n\nfunction loadSettingSourcesFromFlag(settingSourcesArg: string): void {\n  try {\n    const sources = parseSettingSourcesFlag(settingSourcesArg)\n    setAllowedSettingSources(sources)\n    resetSettingsCache()\n  } catch (error) {\n    if (error instanceof Error) {\n      logError(error)\n    }\n    process.stderr.write(\n      chalk.red(`Error processing --setting-sources: ${errorMessage(error)}\\n`),\n    )\n    process.exit(1)\n  }\n}\n\n/**\n * Parse and load settings flags early, before init()\n * This ensures settings are filtered from the start of initialization\n */\nfunction eagerLoadSettings(): void {\n  profileCheckpoint('eagerLoadSettings_start')\n  // Parse --settings flag early to ensure settings are loaded before init()\n  const settingsFile = eagerParseCliFlag('--settings')\n  if (settingsFile) {\n    loadSettingsFromFlag(settingsFile)\n  }\n\n  // Parse --setting-sources flag early to control which sources are loaded\n  const settingSourcesArg = eagerParseCliFlag('--setting-sources')\n  if (settingSourcesArg !== undefined) {\n    loadSettingSourcesFromFlag(settingSourcesArg)\n  }\n  profileCheckpoint('eagerLoadSettings_end')\n}\n\nfunction initializeEntrypoint(isNonInteractive: boolean): void {\n  // Skip if already set (e.g., by SDK or other entrypoints)\n  if (process.env.CLAUDE_CODE_ENTRYPOINT) {\n    return\n  }\n\n  const cliArgs = process.argv.slice(2)\n\n  // Check for MCP serve command (handle flags before mcp serve, e.g., --debug mcp serve)\n  const mcpIndex = cliArgs.indexOf('mcp')\n  if (mcpIndex !== -1 && cliArgs[mcpIndex + 1] === 'serve') {\n    process.env.CLAUDE_CODE_ENTRYPOINT = 'mcp'\n    return\n  }\n\n  if (isEnvTruthy(process.env.CLAUDE_CODE_ACTION)) {\n    process.env.CLAUDE_CODE_ENTRYPOINT = 'claude-code-github-action'\n    return\n  }\n\n  // Note: 'local-agent' entrypoint is set by the local agent mode launcher\n  // via CLAUDE_CODE_ENTRYPOINT env var (handled by early return above)\n\n  // Set based on interactive status\n  process.env.CLAUDE_CODE_ENTRYPOINT = isNonInteractive ? 'sdk-cli' : 'cli'\n}\n\n// Set by early argv processing when `claude open <url>` is detected (interactive mode only)\ntype PendingConnect = {\n  url: string | undefined\n  authToken: string | undefined\n  dangerouslySkipPermissions: boolean\n}\nconst _pendingConnect: PendingConnect | undefined = feature('DIRECT_CONNECT')\n  ? { url: undefined, authToken: undefined, dangerouslySkipPermissions: false }\n  : undefined\n\n// Set by early argv processing when `claude assistant [sessionId]` is detected\ntype PendingAssistantChat = { sessionId?: string; discover: boolean }\nconst _pendingAssistantChat: PendingAssistantChat | undefined = feature(\n  'KAIROS',\n)\n  ? { sessionId: undefined, discover: false }\n  : undefined\n\n// `claude ssh <host> [dir]` — parsed from argv early (same pattern as\n// DIRECT_CONNECT above) so the main command path can pick it up and hand\n// the REPL an SSH-backed session instead of a local one.\ntype PendingSSH = {\n  host: string | undefined\n  cwd: string | undefined\n  permissionMode: string | undefined\n  dangerouslySkipPermissions: boolean\n  /** --local: spawn the child CLI directly, skip ssh/probe/deploy. e2e test mode. */\n  local: boolean\n  /** Extra CLI args to forward to the remote CLI on initial spawn (--resume, -c). */\n  extraCliArgs: string[]\n}\nconst _pendingSSH: PendingSSH | undefined = feature('SSH_REMOTE')\n  ? {\n      host: undefined,\n      cwd: undefined,\n      permissionMode: undefined,\n      dangerouslySkipPermissions: false,\n      local: false,\n      extraCliArgs: [],\n    }\n  : undefined\n\nexport async function main() {\n  profileCheckpoint('main_function_start')\n\n  // SECURITY: Prevent Windows from executing commands from current directory\n  // This must be set before ANY command execution to prevent PATH hijacking attacks\n  // See: https://docs.microsoft.com/en-us/windows/win32/api/processenv/nf-processenv-searchpathw\n  process.env.NoDefaultCurrentDirectoryInExePath = '1'\n\n  // Initialize warning handler early to catch warnings\n  initializeWarningHandler()\n\n  process.on('exit', () => {\n    resetCursor()\n  })\n  process.on('SIGINT', () => {\n    // In print mode, print.ts registers its own SIGINT handler that aborts\n    // the in-flight query and calls gracefulShutdown; skip here to avoid\n    // preempting it with a synchronous process.exit().\n    if (process.argv.includes('-p') || process.argv.includes('--print')) {\n      return\n    }\n    process.exit(0)\n  })\n  profileCheckpoint('main_warning_handler_initialized')\n\n  // Check for cc:// or cc+unix:// URL in argv — rewrite so the main command\n  // handles it, giving the full interactive TUI instead of a stripped-down subcommand.\n  // For headless (-p), we rewrite to the internal `open` subcommand.\n  if (feature('DIRECT_CONNECT')) {\n    const rawCliArgs = process.argv.slice(2)\n    const ccIdx = rawCliArgs.findIndex(\n      a => a.startsWith('cc://') || a.startsWith('cc+unix://'),\n    )\n    if (ccIdx !== -1 && _pendingConnect) {\n      const ccUrl = rawCliArgs[ccIdx]!\n      const { parseConnectUrl } = await import('./server/parseConnectUrl.js')\n      const parsed = parseConnectUrl(ccUrl)\n      _pendingConnect.dangerouslySkipPermissions = rawCliArgs.includes(\n        '--dangerously-skip-permissions',\n      )\n\n      if (rawCliArgs.includes('-p') || rawCliArgs.includes('--print')) {\n        // Headless: rewrite to internal `open` subcommand\n        const stripped = rawCliArgs.filter((_, i) => i !== ccIdx)\n        const dspIdx = stripped.indexOf('--dangerously-skip-permissions')\n        if (dspIdx !== -1) {\n          stripped.splice(dspIdx, 1)\n        }\n        process.argv = [\n          process.argv[0]!,\n          process.argv[1]!,\n          'open',\n          ccUrl,\n          ...stripped,\n        ]\n      } else {\n        // Interactive: strip cc:// URL and flags, run main command\n        _pendingConnect.url = parsed.serverUrl\n        _pendingConnect.authToken = parsed.authToken\n        const stripped = rawCliArgs.filter((_, i) => i !== ccIdx)\n        const dspIdx = stripped.indexOf('--dangerously-skip-permissions')\n        if (dspIdx !== -1) {\n          stripped.splice(dspIdx, 1)\n        }\n        process.argv = [process.argv[0]!, process.argv[1]!, ...stripped]\n      }\n    }\n  }\n\n  // Handle deep link URIs early — this is invoked by the OS protocol handler\n  // and should bail out before full init since it only needs to parse the URI\n  // and open a terminal.\n  if (feature('LODESTONE')) {\n    const handleUriIdx = process.argv.indexOf('--handle-uri')\n    if (handleUriIdx !== -1 && process.argv[handleUriIdx + 1]) {\n      const { enableConfigs } = await import('./utils/config.js')\n      enableConfigs()\n      const uri = process.argv[handleUriIdx + 1]!\n      const { handleDeepLinkUri } = await import(\n        './utils/deepLink/protocolHandler.js'\n      )\n      const exitCode = await handleDeepLinkUri(uri)\n      process.exit(exitCode)\n    }\n\n    // macOS URL handler: when LaunchServices launches our .app bundle, the\n    // URL arrives via Apple Event (not argv). LaunchServices overwrites\n    // __CFBundleIdentifier to the launching bundle's ID, which is a precise\n    // positive signal — cheaper than importing and guessing with heuristics.\n    if (\n      process.platform === 'darwin' &&\n      process.env.__CFBundleIdentifier ===\n        'com.anthropic.claude-code-url-handler'\n    ) {\n      const { enableConfigs } = await import('./utils/config.js')\n      enableConfigs()\n      const { handleUrlSchemeLaunch } = await import(\n        './utils/deepLink/protocolHandler.js'\n      )\n      const urlSchemeResult = await handleUrlSchemeLaunch()\n      process.exit(urlSchemeResult ?? 1)\n    }\n  }\n\n  // `claude assistant [sessionId]` — stash and strip so the main\n  // command handles it, giving the full interactive TUI. Position-0 only\n  // (matching the ssh pattern below) — indexOf would false-positive on\n  // `claude -p \"explain assistant\"`. Root-flag-before-subcommand\n  // (e.g. `--debug assistant`) falls through to the stub, which\n  // prints usage.\n  if (feature('KAIROS') && _pendingAssistantChat) {\n    const rawArgs = process.argv.slice(2)\n    if (rawArgs[0] === 'assistant') {\n      const nextArg = rawArgs[1]\n      if (nextArg && !nextArg.startsWith('-')) {\n        _pendingAssistantChat.sessionId = nextArg\n        rawArgs.splice(0, 2) // drop 'assistant' and sessionId\n        process.argv = [process.argv[0]!, process.argv[1]!, ...rawArgs]\n      } else if (!nextArg) {\n        _pendingAssistantChat.discover = true\n        rawArgs.splice(0, 1) // drop 'assistant'\n        process.argv = [process.argv[0]!, process.argv[1]!, ...rawArgs]\n      }\n      // else: `claude assistant --help` → fall through to stub\n    }\n  }\n\n  // `claude ssh <host> [dir]` — strip from argv so the main command handler\n  // runs (full interactive TUI), stash the host/dir for the REPL branch at\n  // ~line 3720 to pick up. Headless (-p) mode not supported in v1: SSH\n  // sessions need the local REPL to drive them (interrupt, permissions).\n  if (feature('SSH_REMOTE') && _pendingSSH) {\n    const rawCliArgs = process.argv.slice(2)\n    // SSH-specific flags can appear before the host positional (e.g.\n    // `ssh --permission-mode auto host /tmp` — standard POSIX flags-before-\n    // positionals). Pull them all out BEFORE checking whether a host was\n    // given, so `claude ssh --permission-mode auto host` and `claude ssh host\n    // --permission-mode auto` are equivalent. The host check below only needs\n    // to guard against `-h`/`--help` (which commander should handle).\n    if (rawCliArgs[0] === 'ssh') {\n      const localIdx = rawCliArgs.indexOf('--local')\n      if (localIdx !== -1) {\n        _pendingSSH.local = true\n        rawCliArgs.splice(localIdx, 1)\n      }\n      const dspIdx = rawCliArgs.indexOf('--dangerously-skip-permissions')\n      if (dspIdx !== -1) {\n        _pendingSSH.dangerouslySkipPermissions = true\n        rawCliArgs.splice(dspIdx, 1)\n      }\n      const pmIdx = rawCliArgs.indexOf('--permission-mode')\n      if (\n        pmIdx !== -1 &&\n        rawCliArgs[pmIdx + 1] &&\n        !rawCliArgs[pmIdx + 1]!.startsWith('-')\n      ) {\n        _pendingSSH.permissionMode = rawCliArgs[pmIdx + 1]\n        rawCliArgs.splice(pmIdx, 2)\n      }\n      const pmEqIdx = rawCliArgs.findIndex(a =>\n        a.startsWith('--permission-mode='),\n      )\n      if (pmEqIdx !== -1) {\n        _pendingSSH.permissionMode = rawCliArgs[pmEqIdx]!.split('=')[1]\n        rawCliArgs.splice(pmEqIdx, 1)\n      }\n      // Forward session-resume + model flags to the remote CLI's initial spawn.\n      // --continue/-c and --resume <uuid> operate on the REMOTE session history\n      // (which persists under the remote's ~/.claude/projects/<cwd>/).\n      // --model controls which model the remote uses.\n      const extractFlag = (\n        flag: string,\n        opts: { hasValue?: boolean; as?: string } = {},\n      ) => {\n        const i = rawCliArgs.indexOf(flag)\n        if (i !== -1) {\n          _pendingSSH.extraCliArgs.push(opts.as ?? flag)\n          const val = rawCliArgs[i + 1]\n          if (opts.hasValue && val && !val.startsWith('-')) {\n            _pendingSSH.extraCliArgs.push(val)\n            rawCliArgs.splice(i, 2)\n          } else {\n            rawCliArgs.splice(i, 1)\n          }\n        }\n        const eqI = rawCliArgs.findIndex(a => a.startsWith(`${flag}=`))\n        if (eqI !== -1) {\n          _pendingSSH.extraCliArgs.push(\n            opts.as ?? flag,\n            rawCliArgs[eqI]!.slice(flag.length + 1),\n          )\n          rawCliArgs.splice(eqI, 1)\n        }\n      }\n      extractFlag('-c', { as: '--continue' })\n      extractFlag('--continue')\n      extractFlag('--resume', { hasValue: true })\n      extractFlag('--model', { hasValue: true })\n    }\n    // After pre-extraction, any remaining dash-arg at [1] is either -h/--help\n    // (commander handles) or an unknown-to-ssh flag (fall through to commander\n    // so it surfaces a proper error). Only a non-dash arg is the host.\n    if (\n      rawCliArgs[0] === 'ssh' &&\n      rawCliArgs[1] &&\n      !rawCliArgs[1].startsWith('-')\n    ) {\n      _pendingSSH.host = rawCliArgs[1]\n      // Optional positional cwd.\n      let consumed = 2\n      if (rawCliArgs[2] && !rawCliArgs[2].startsWith('-')) {\n        _pendingSSH.cwd = rawCliArgs[2]\n        consumed = 3\n      }\n      const rest = rawCliArgs.slice(consumed)\n\n      // Headless (-p) mode is not supported with SSH in v1 — reject early\n      // so the flag doesn't silently cause local execution.\n      if (rest.includes('-p') || rest.includes('--print')) {\n        process.stderr.write(\n          'Error: headless (-p/--print) mode is not supported with claude ssh\\n',\n        )\n        gracefulShutdownSync(1)\n        return\n      }\n\n      // Rewrite argv so the main command sees remaining flags but not `ssh`.\n      process.argv = [process.argv[0]!, process.argv[1]!, ...rest]\n    }\n  }\n\n  // Check for -p/--print and --init-only flags early to set isInteractiveSession before init()\n  // This is needed because telemetry initialization calls auth functions that need this flag\n  const cliArgs = process.argv.slice(2)\n  const hasPrintFlag = cliArgs.includes('-p') || cliArgs.includes('--print')\n  const hasInitOnlyFlag = cliArgs.includes('--init-only')\n  const hasSdkUrl = cliArgs.some(arg => arg.startsWith('--sdk-url'))\n  const isNonInteractive =\n    hasPrintFlag || hasInitOnlyFlag || hasSdkUrl || !process.stdout.isTTY\n\n  // Stop capturing early input for non-interactive modes\n  if (isNonInteractive) {\n    stopCapturingEarlyInput()\n  }\n\n  // Set simplified tracking fields\n  const isInteractive = !isNonInteractive\n  setIsInteractive(isInteractive)\n\n  // Initialize entrypoint based on mode - needs to be set before any event is logged\n  initializeEntrypoint(isNonInteractive)\n\n  // Determine client type\n  const clientType = (() => {\n    if (isEnvTruthy(process.env.GITHUB_ACTIONS)) return 'github-action'\n    if (process.env.CLAUDE_CODE_ENTRYPOINT === 'sdk-ts') return 'sdk-typescript'\n    if (process.env.CLAUDE_CODE_ENTRYPOINT === 'sdk-py') return 'sdk-python'\n    if (process.env.CLAUDE_CODE_ENTRYPOINT === 'sdk-cli') return 'sdk-cli'\n    if (process.env.CLAUDE_CODE_ENTRYPOINT === 'claude-vscode')\n      return 'claude-vscode'\n    if (process.env.CLAUDE_CODE_ENTRYPOINT === 'local-agent')\n      return 'local-agent'\n    if (process.env.CLAUDE_CODE_ENTRYPOINT === 'claude-desktop')\n      return 'claude-desktop'\n\n    // Check if session-ingress token is provided (indicates remote session)\n    const hasSessionIngressToken =\n      process.env.CLAUDE_CODE_SESSION_ACCESS_TOKEN ||\n      process.env.CLAUDE_CODE_WEBSOCKET_AUTH_FILE_DESCRIPTOR\n    if (\n      process.env.CLAUDE_CODE_ENTRYPOINT === 'remote' ||\n      hasSessionIngressToken\n    ) {\n      return 'remote'\n    }\n\n    return 'cli'\n  })()\n  setClientType(clientType)\n\n  const previewFormat = process.env.CLAUDE_CODE_QUESTION_PREVIEW_FORMAT\n  if (previewFormat === 'markdown' || previewFormat === 'html') {\n    setQuestionPreviewFormat(previewFormat)\n  } else if (\n    !clientType.startsWith('sdk-') &&\n    // Desktop and CCR pass previewFormat via toolConfig; when the feature is\n    // gated off they pass undefined — don't override that with markdown.\n    clientType !== 'claude-desktop' &&\n    clientType !== 'local-agent' &&\n    clientType !== 'remote'\n  ) {\n    setQuestionPreviewFormat('markdown')\n  }\n\n  // Tag sessions created via `claude remote-control` so the backend can identify them\n  if (process.env.CLAUDE_CODE_ENVIRONMENT_KIND === 'bridge') {\n    setSessionSource('remote-control')\n  }\n\n  profileCheckpoint('main_client_type_determined')\n\n  // Parse and load settings flags early, before init()\n  eagerLoadSettings()\n\n  profileCheckpoint('main_before_run')\n\n  await run()\n  profileCheckpoint('main_after_run')\n}\n\nasync function getInputPrompt(\n  prompt: string,\n  inputFormat: 'text' | 'stream-json',\n): Promise<string | AsyncIterable<string>> {\n  if (\n    !process.stdin.isTTY &&\n    // Input hijacking breaks MCP.\n    !process.argv.includes('mcp')\n  ) {\n    if (inputFormat === 'stream-json') {\n      return process.stdin\n    }\n    process.stdin.setEncoding('utf8')\n    let data = ''\n    const onData = (chunk: string) => {\n      data += chunk\n    }\n    process.stdin.on('data', onData)\n    // If no data arrives in 3s, stop waiting and warn. Stdin is likely an\n    // inherited pipe from a parent that isn't writing (subprocess spawned\n    // without explicit stdin handling). 3s covers slow producers like curl,\n    // jq on large files, python with import overhead. The warning makes\n    // silent data loss visible for the rare producer that's slower still.\n    const timedOut = await peekForStdinData(process.stdin, 3000)\n    process.stdin.off('data', onData)\n    if (timedOut) {\n      process.stderr.write(\n        'Warning: no stdin data received in 3s, proceeding without it. ' +\n          'If piping from a slow command, redirect stdin explicitly: < /dev/null to skip, or wait longer.\\n',\n      )\n    }\n    return [prompt, data].filter(Boolean).join('\\n')\n  }\n  return prompt\n}\n\nasync function run(): Promise<CommanderCommand> {\n  profileCheckpoint('run_function_start')\n\n  // Create help config that sorts options by long option name.\n  // Commander supports compareOptions at runtime but @commander-js/extra-typings\n  // doesn't include it in the type definitions, so we use Object.assign to add it.\n  function createSortedHelpConfig(): {\n    sortSubcommands: true\n    sortOptions: true\n  } {\n    const getOptionSortKey = (opt: Option): string =>\n      opt.long?.replace(/^--/, '') ?? opt.short?.replace(/^-/, '') ?? ''\n    return Object.assign(\n      { sortSubcommands: true, sortOptions: true } as const,\n      {\n        compareOptions: (a: Option, b: Option) =>\n          getOptionSortKey(a).localeCompare(getOptionSortKey(b)),\n      },\n    )\n  }\n  const program = new CommanderCommand()\n    .configureHelp(createSortedHelpConfig())\n    .enablePositionalOptions()\n  profileCheckpoint('run_commander_initialized')\n\n  // Use preAction hook to run initialization only when executing a command,\n  // not when displaying help. This avoids the need for env variable signaling.\n  program.hook('preAction', async thisCommand => {\n    profileCheckpoint('preAction_start')\n    // Await async subprocess loads started at module evaluation (lines 12-20).\n    // Nearly free — subprocesses complete during the ~135ms of imports above.\n    // Must resolve before init() which triggers the first settings read\n    // (applySafeConfigEnvironmentVariables → getSettingsForSource('policySettings')\n    // → isRemoteManagedSettingsEligible → sync keychain reads otherwise ~65ms).\n    await Promise.all([\n      ensureMdmSettingsLoaded(),\n      ensureKeychainPrefetchCompleted(),\n    ])\n    profileCheckpoint('preAction_after_mdm')\n    await init()\n    profileCheckpoint('preAction_after_init')\n\n    // process.title on Windows sets the console title directly; on POSIX,\n    // terminal shell integration may mirror the process name to the tab.\n    // After init() so settings.json env can also gate this (gh-4765).\n    if (!isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_TERMINAL_TITLE)) {\n      process.title = 'claude'\n    }\n\n    // Attach logging sinks so subcommand handlers can use logEvent/logError.\n    // Before PR #11106 logEvent dispatched directly; after, events queue until\n    // a sink attaches. setup() attaches sinks for the default command, but\n    // subcommands (doctor, mcp, plugin, auth) never call setup() and would\n    // silently drop events on process.exit(). Both inits are idempotent.\n    const { initSinks } = await import('./utils/sinks.js')\n    initSinks()\n    profileCheckpoint('preAction_after_sinks')\n\n    // gh-33508: --plugin-dir is a top-level program option. The default\n    // action reads it from its own options destructure, but subcommands\n    // (plugin list, plugin install, mcp *) have their own actions and\n    // never see it. Wire it up here so getInlinePlugins() works everywhere.\n    // thisCommand.opts() is typed {} here because this hook is attached\n    // before .option('--plugin-dir', ...) in the chain — extra-typings\n    // builds the type as options are added. Narrow with a runtime guard;\n    // the collect accumulator + [] default guarantee string[] in practice.\n    const pluginDir = thisCommand.getOptionValue('pluginDir')\n    if (\n      Array.isArray(pluginDir) &&\n      pluginDir.length > 0 &&\n      pluginDir.every(p => typeof p === 'string')\n    ) {\n      setInlinePlugins(pluginDir)\n      clearPluginCache('preAction: --plugin-dir inline plugins')\n    }\n\n    runMigrations()\n    profileCheckpoint('preAction_after_migrations')\n\n    // Load remote managed settings for enterprise customers (non-blocking)\n    // Fails open - if fetch fails, continues without remote settings\n    // Settings are applied via hot-reload when they arrive\n    // Must happen after init() to ensure config reading is allowed\n    void loadRemoteManagedSettings()\n    void loadPolicyLimits()\n\n    profileCheckpoint('preAction_after_remote_settings')\n\n    // Load settings sync (non-blocking, fail-open)\n    // CLI: uploads local settings to remote (CCR download is handled by print.ts)\n    if (feature('UPLOAD_USER_SETTINGS')) {\n      void import('./services/settingsSync/index.js').then(m =>\n        m.uploadUserSettingsInBackground(),\n      )\n    }\n\n    profileCheckpoint('preAction_after_settings_sync')\n  })\n\n  program\n    .name('claude')\n    .description(\n      `Claude Code - starts an interactive session by default, use -p/--print for non-interactive output`,\n    )\n    .argument('[prompt]', 'Your prompt', String)\n    // Subcommands inherit helpOption via commander's copyInheritedSettings —\n    // setting it once here covers mcp, plugin, auth, and all other subcommands.\n    .helpOption('-h, --help', 'Display help for command')\n    .option(\n      '-d, --debug [filter]',\n      'Enable debug mode with optional category filtering (e.g., \"api,hooks\" or \"!1p,!file\")',\n      (_value: string | true) => {\n        // If value is provided, it will be the filter string\n        // If not provided but flag is present, value will be true\n        // The actual filtering is handled in debug.ts by parsing process.argv\n        return true\n      },\n    )\n    .addOption(\n      new Option('-d2e, --debug-to-stderr', 'Enable debug mode (to stderr)')\n        .argParser(Boolean)\n        .hideHelp(),\n    )\n    .option(\n      '--debug-file <path>',\n      'Write debug logs to a specific file path (implicitly enables debug mode)',\n      () => true,\n    )\n    .option(\n      '--verbose',\n      'Override verbose mode setting from config',\n      () => true,\n    )\n    .option(\n      '-p, --print',\n      'Print response and exit (useful for pipes). Note: The workspace trust dialog is skipped when Claude is run with the -p mode. Only use this flag in directories you trust.',\n      () => true,\n    )\n    .option(\n      '--bare',\n      'Minimal mode: skip hooks, LSP, plugin sync, attribution, auto-memory, background prefetches, keychain reads, and CLAUDE.md auto-discovery. Sets CLAUDE_CODE_SIMPLE=1. Anthropic auth is strictly ANTHROPIC_API_KEY or apiKeyHelper via --settings (OAuth and keychain are never read). 3P providers (Bedrock/Vertex/Foundry) use their own credentials. Skills still resolve via /skill-name. Explicitly provide context via: --system-prompt[-file], --append-system-prompt[-file], --add-dir (CLAUDE.md dirs), --mcp-config, --settings, --agents, --plugin-dir.',\n      () => true,\n    )\n    .addOption(\n      new Option(\n        '--init',\n        'Run Setup hooks with init trigger, then continue',\n      ).hideHelp(),\n    )\n    .addOption(\n      new Option(\n        '--init-only',\n        'Run Setup and SessionStart:startup hooks, then exit',\n      ).hideHelp(),\n    )\n    .addOption(\n      new Option(\n        '--maintenance',\n        'Run Setup hooks with maintenance trigger, then continue',\n      ).hideHelp(),\n    )\n    .addOption(\n      new Option(\n        '--output-format <format>',\n        'Output format (only works with --print): \"text\" (default), \"json\" (single result), or \"stream-json\" (realtime streaming)',\n      ).choices(['text', 'json', 'stream-json']),\n    )\n    .addOption(\n      new Option(\n        '--json-schema <schema>',\n        'JSON Schema for structured output validation. ' +\n          'Example: {\"type\":\"object\",\"properties\":{\"name\":{\"type\":\"string\"}},\"required\":[\"name\"]}',\n      ).argParser(String),\n    )\n    .option(\n      '--include-hook-events',\n      'Include all hook lifecycle events in the output stream (only works with --output-format=stream-json)',\n      () => true,\n    )\n    .option(\n      '--include-partial-messages',\n      'Include partial message chunks as they arrive (only works with --print and --output-format=stream-json)',\n      () => true,\n    )\n    .addOption(\n      new Option(\n        '--input-format <format>',\n        'Input format (only works with --print): \"text\" (default), or \"stream-json\" (realtime streaming input)',\n      ).choices(['text', 'stream-json']),\n    )\n    .option(\n      '--mcp-debug',\n      '[DEPRECATED. Use --debug instead] Enable MCP debug mode (shows MCP server errors)',\n      () => true,\n    )\n    .option(\n      '--dangerously-skip-permissions',\n      'Bypass all permission checks. Recommended only for sandboxes with no internet access.',\n      () => true,\n    )\n    .option(\n      '--allow-dangerously-skip-permissions',\n      'Enable bypassing all permission checks as an option, without it being enabled by default. Recommended only for sandboxes with no internet access.',\n      () => true,\n    )\n    .addOption(\n      new Option(\n        '--thinking <mode>',\n        'Thinking mode: enabled (equivalent to adaptive), disabled',\n      )\n        .choices(['enabled', 'adaptive', 'disabled'])\n        .hideHelp(),\n    )\n    .addOption(\n      new Option(\n        '--max-thinking-tokens <tokens>',\n        '[DEPRECATED. Use --thinking instead for newer models] Maximum number of thinking tokens (only works with --print)',\n      )\n        .argParser(Number)\n        .hideHelp(),\n    )\n    .addOption(\n      new Option(\n        '--max-turns <turns>',\n        'Maximum number of agentic turns in non-interactive mode. This will early exit the conversation after the specified number of turns. (only works with --print)',\n      )\n        .argParser(Number)\n        .hideHelp(),\n    )\n    .addOption(\n      new Option(\n        '--max-budget-usd <amount>',\n        'Maximum dollar amount to spend on API calls (only works with --print)',\n      ).argParser(value => {\n        const amount = Number(value)\n        if (isNaN(amount) || amount <= 0) {\n          throw new Error(\n            '--max-budget-usd must be a positive number greater than 0',\n          )\n        }\n        return amount\n      }),\n    )\n    .addOption(\n      new Option(\n        '--task-budget <tokens>',\n        'API-side task budget in tokens (output_config.task_budget)',\n      )\n        .argParser(value => {\n          const tokens = Number(value)\n          if (isNaN(tokens) || tokens <= 0 || !Number.isInteger(tokens)) {\n            throw new Error('--task-budget must be a positive integer')\n          }\n          return tokens\n        })\n        .hideHelp(),\n    )\n    .option(\n      '--replay-user-messages',\n      'Re-emit user messages from stdin back on stdout for acknowledgment (only works with --input-format=stream-json and --output-format=stream-json)',\n      () => true,\n    )\n    .addOption(\n      new Option(\n        '--enable-auth-status',\n        'Enable auth status messages in SDK mode',\n      )\n        .default(false)\n        .hideHelp(),\n    )\n    .option(\n      '--allowedTools, --allowed-tools <tools...>',\n      'Comma or space-separated list of tool names to allow (e.g. \"Bash(git:*) Edit\")',\n    )\n    .option(\n      '--tools <tools...>',\n      'Specify the list of available tools from the built-in set. Use \"\" to disable all tools, \"default\" to use all tools, or specify tool names (e.g. \"Bash,Edit,Read\").',\n    )\n    .option(\n      '--disallowedTools, --disallowed-tools <tools...>',\n      'Comma or space-separated list of tool names to deny (e.g. \"Bash(git:*) Edit\")',\n    )\n    .option(\n      '--mcp-config <configs...>',\n      'Load MCP servers from JSON files or strings (space-separated)',\n    )\n    .addOption(\n      new Option(\n        '--permission-prompt-tool <tool>',\n        'MCP tool to use for permission prompts (only works with --print)',\n      )\n        .argParser(String)\n        .hideHelp(),\n    )\n    .addOption(\n      new Option(\n        '--system-prompt <prompt>',\n        'System prompt to use for the session',\n      ).argParser(String),\n    )\n    .addOption(\n      new Option(\n        '--system-prompt-file <file>',\n        'Read system prompt from a file',\n      )\n        .argParser(String)\n        .hideHelp(),\n    )\n    .addOption(\n      new Option(\n        '--append-system-prompt <prompt>',\n        'Append a system prompt to the default system prompt',\n      ).argParser(String),\n    )\n    .addOption(\n      new Option(\n        '--append-system-prompt-file <file>',\n        'Read system prompt from a file and append to the default system prompt',\n      )\n        .argParser(String)\n        .hideHelp(),\n    )\n    .addOption(\n      new Option(\n        '--permission-mode <mode>',\n        'Permission mode to use for the session',\n      )\n        .argParser(String)\n        .choices(PERMISSION_MODES),\n    )\n    .option(\n      '-c, --continue',\n      'Continue the most recent conversation in the current directory',\n      () => true,\n    )\n    .option(\n      '-r, --resume [value]',\n      'Resume a conversation by session ID, or open interactive picker with optional search term',\n      value => value || true,\n    )\n    .option(\n      '--fork-session',\n      'When resuming, create a new session ID instead of reusing the original (use with --resume or --continue)',\n      () => true,\n    )\n    .addOption(\n      new Option(\n        '--prefill <text>',\n        'Pre-fill the prompt input with text without submitting it',\n      ).hideHelp(),\n    )\n    .addOption(\n      new Option(\n        '--deep-link-origin',\n        'Signal that this session was launched from a deep link',\n      ).hideHelp(),\n    )\n    .addOption(\n      new Option(\n        '--deep-link-repo <slug>',\n        'Repo slug the deep link ?repo= parameter resolved to the current cwd',\n      ).hideHelp(),\n    )\n    .addOption(\n      new Option(\n        '--deep-link-last-fetch <ms>',\n        'FETCH_HEAD mtime in epoch ms, precomputed by the deep link trampoline',\n      )\n        .argParser(v => {\n          const n = Number(v)\n          return Number.isFinite(n) ? n : undefined\n        })\n        .hideHelp(),\n    )\n    .option(\n      '--from-pr [value]',\n      'Resume a session linked to a PR by PR number/URL, or open interactive picker with optional search term',\n      value => value || true,\n    )\n    .option(\n      '--no-session-persistence',\n      'Disable session persistence - sessions will not be saved to disk and cannot be resumed (only works with --print)',\n    )\n    .addOption(\n      new Option(\n        '--resume-session-at <message id>',\n        'When resuming, only messages up to and including the assistant message with <message.id> (use with --resume in print mode)',\n      )\n        .argParser(String)\n        .hideHelp(),\n    )\n    .addOption(\n      new Option(\n        '--rewind-files <user-message-id>',\n        'Restore files to state at the specified user message and exit (requires --resume)',\n      ).hideHelp(),\n    )\n    // @[MODEL LAUNCH]: Update the example model ID in the --model help text.\n    .option(\n      '--model <model>',\n      `Model for the current session. Provide an alias for the latest model (e.g. 'sonnet' or 'opus') or a model's full name (e.g. 'claude-sonnet-4-6').`,\n    )\n    .addOption(\n      new Option(\n        '--effort <level>',\n        `Effort level for the current session (low, medium, high, max)`,\n      ).argParser((rawValue: string) => {\n        const value = rawValue.toLowerCase()\n        const allowed = ['low', 'medium', 'high', 'max']\n        if (!allowed.includes(value)) {\n          throw new InvalidArgumentError(\n            `It must be one of: ${allowed.join(', ')}`,\n          )\n        }\n        return value\n      }),\n    )\n    .option(\n      '--agent <agent>',\n      `Agent for the current session. Overrides the 'agent' setting.`,\n    )\n    .option(\n      '--betas <betas...>',\n      'Beta headers to include in API requests (API key users only)',\n    )\n    .option(\n      '--fallback-model <model>',\n      'Enable automatic fallback to specified model when default model is overloaded (only works with --print)',\n    )\n    .addOption(\n      new Option(\n        '--workload <tag>',\n        'Workload tag for billing-header attribution (cc_workload). Process-scoped; set by SDK daemon callers that spawn subprocesses for cron work. (only works with --print)',\n      ).hideHelp(),\n    )\n    .option(\n      '--settings <file-or-json>',\n      'Path to a settings JSON file or a JSON string to load additional settings from',\n    )\n    .option(\n      '--add-dir <directories...>',\n      'Additional directories to allow tool access to',\n    )\n    .option(\n      '--ide',\n      'Automatically connect to IDE on startup if exactly one valid IDE is available',\n      () => true,\n    )\n    .option(\n      '--strict-mcp-config',\n      'Only use MCP servers from --mcp-config, ignoring all other MCP configurations',\n      () => true,\n    )\n    .option(\n      '--session-id <uuid>',\n      'Use a specific session ID for the conversation (must be a valid UUID)',\n    )\n    .option(\n      '-n, --name <name>',\n      'Set a display name for this session (shown in /resume and terminal title)',\n    )\n    .option(\n      '--agents <json>',\n      'JSON object defining custom agents (e.g. \\'{\"reviewer\": {\"description\": \"Reviews code\", \"prompt\": \"You are a code reviewer\"}}\\')',\n    )\n    .option(\n      '--setting-sources <sources>',\n      'Comma-separated list of setting sources to load (user, project, local).',\n    )\n    // gh-33508: <paths...> (variadic) consumed everything until the next\n    // --flag. `claude --plugin-dir /path mcp add --transport http` swallowed\n    // `mcp` and `add` as paths, then choked on --transport as an unknown\n    // top-level option. Single-value + collect accumulator means each\n    // --plugin-dir takes exactly one arg; repeat the flag for multiple dirs.\n    .option(\n      '--plugin-dir <path>',\n      'Load plugins from a directory for this session only (repeatable: --plugin-dir A --plugin-dir B)',\n      (val: string, prev: string[]) => [...prev, val],\n      [] as string[],\n    )\n    .option('--disable-slash-commands', 'Disable all skills', () => true)\n    .option('--chrome', 'Enable Claude in Chrome integration')\n    .option('--no-chrome', 'Disable Claude in Chrome integration')\n    .option(\n      '--file <specs...>',\n      'File resources to download at startup. Format: file_id:relative_path (e.g., --file file_abc:doc.txt file_def:img.png)',\n    )\n    .action(async (prompt, options) => {\n      profileCheckpoint('action_handler_start')\n\n      // --bare = one-switch minimal mode. Sets SIMPLE so all the existing\n      // gates fire (CLAUDE.md, skills, hooks inside executeHooks, agent\n      // dir-walk). Must be set before setup() / any of the gated work runs.\n      if ((options as { bare?: boolean }).bare) {\n        process.env.CLAUDE_CODE_SIMPLE = '1'\n      }\n\n      // Ignore \"code\" as a prompt - treat it the same as no prompt\n      if (prompt === 'code') {\n        logEvent('tengu_code_prompt_ignored', {})\n        // biome-ignore lint/suspicious/noConsole:: intentional console output\n        console.warn(\n          chalk.yellow('Tip: You can launch Claude Code with just `claude`'),\n        )\n        prompt = undefined\n      }\n\n      // Log event for any single-word prompt\n      if (\n        prompt &&\n        typeof prompt === 'string' &&\n        !/\\s/.test(prompt) &&\n        prompt.length > 0\n      ) {\n        logEvent('tengu_single_word_prompt', { length: prompt.length })\n      }\n\n      // Assistant mode: when .claude/settings.json has assistant: true AND\n      // the tengu_kairos GrowthBook gate is on, force brief on. Permission\n      // mode is left to the user — settings defaultMode or --permission-mode\n      // apply as normal. REPL-typed messages already default to 'next'\n      // priority (messageQueueManager.enqueue) so they drain mid-turn between\n      // tool calls. SendUserMessage (BriefTool) is enabled via the brief env\n      // var. SleepTool stays disabled (its isEnabled() gates on proactive).\n      // kairosEnabled is computed once here and reused at the\n      // getAssistantSystemPromptAddendum() call site further down.\n      //\n      // Trust gate: .claude/settings.json is attacker-controllable in an\n      // untrusted clone. We run ~1000 lines before showSetupScreens() shows\n      // the trust dialog, and by then we've already appended\n      // .claude/agents/assistant.md to the system prompt. Refuse to activate\n      // until the directory has been explicitly trusted.\n      let kairosEnabled = false\n      let assistantTeamContext:\n        | Awaited<\n            ReturnType<\n              NonNullable<typeof assistantModule>['initializeAssistantTeam']\n            >\n          >\n        | undefined\n      if (\n        feature('KAIROS') &&\n        (options as { assistant?: boolean }).assistant &&\n        assistantModule\n      ) {\n        // --assistant (Agent SDK daemon mode): force the latch before\n        // isAssistantMode() runs below. The daemon has already checked\n        // entitlement — don't make the child re-check tengu_kairos.\n        assistantModule.markAssistantForced()\n      }\n      if (\n        feature('KAIROS') &&\n        assistantModule?.isAssistantMode() &&\n        // Spawned teammates share the leader's cwd + settings.json, so\n        // isAssistantMode() is true for them too. --agent-id being set\n        // means we ARE a spawned teammate (extractTeammateOptions runs\n        // ~170 lines later so check the raw commander option) — don't\n        // re-init the team or override teammateMode/proactive/brief.\n        !(options as { agentId?: unknown }).agentId &&\n        kairosGate\n      ) {\n        if (!checkHasTrustDialogAccepted()) {\n          // biome-ignore lint/suspicious/noConsole:: intentional console output\n          console.warn(\n            chalk.yellow(\n              'Assistant mode disabled: directory is not trusted. Accept the trust dialog and restart.',\n            ),\n          )\n        } else {\n          // Blocking gate check — returns cached `true` instantly; if disk\n          // cache is false/missing, lazily inits GrowthBook and fetches fresh\n          // (max ~5s). --assistant skips the gate entirely (daemon is\n          // pre-entitled).\n          kairosEnabled =\n            assistantModule.isAssistantForced() ||\n            (await kairosGate.isKairosEnabled())\n          if (kairosEnabled) {\n            const opts = options as { brief?: boolean }\n            opts.brief = true\n            setKairosActive(true)\n            // Pre-seed an in-process team so Agent(name: \"foo\") spawns\n            // teammates without TeamCreate. Must run BEFORE setup() captures\n            // the teammateMode snapshot (initializeAssistantTeam calls\n            // setCliTeammateModeOverride internally).\n            assistantTeamContext =\n              await assistantModule.initializeAssistantTeam()\n          }\n        }\n      }\n\n      const {\n        debug = false,\n        debugToStderr = false,\n        dangerouslySkipPermissions,\n        allowDangerouslySkipPermissions = false,\n        tools: baseTools = [],\n        allowedTools = [],\n        disallowedTools = [],\n        mcpConfig = [],\n        permissionMode: permissionModeCli,\n        addDir = [],\n        fallbackModel,\n        betas = [],\n        ide = false,\n        sessionId,\n        includeHookEvents,\n        includePartialMessages,\n      } = options\n\n      if (options.prefill) {\n        seedEarlyInput(options.prefill)\n      }\n\n      // Promise for file downloads - started early, awaited before REPL renders\n      let fileDownloadPromise: Promise<DownloadResult[]> | undefined\n\n      const agentsJson = options.agents\n      const agentCli = options.agent\n      if (feature('BG_SESSIONS') && agentCli) {\n        process.env.CLAUDE_CODE_AGENT = agentCli\n      }\n\n      // NOTE: LSP manager initialization is intentionally deferred until after\n      // the trust dialog is accepted. This prevents plugin LSP servers from\n      // executing code in untrusted directories before user consent.\n\n      // Extract these separately so they can be modified if needed\n      let outputFormat = options.outputFormat\n      let inputFormat = options.inputFormat\n      let verbose = options.verbose ?? getGlobalConfig().verbose\n      let print = options.print\n      const init = options.init ?? false\n      const initOnly = options.initOnly ?? false\n      const maintenance = options.maintenance ?? false\n\n      // Extract disable slash commands flag\n      const disableSlashCommands = options.disableSlashCommands || false\n\n      // Extract tasks mode options (ant-only)\n      const tasksOption =\n        \"external\" === 'ant' &&\n        (options as { tasks?: boolean | string }).tasks\n      const taskListId = tasksOption\n        ? typeof tasksOption === 'string'\n          ? tasksOption\n          : DEFAULT_TASKS_MODE_TASK_LIST_ID\n        : undefined\n      if (\"external\" === 'ant' && taskListId) {\n        process.env.CLAUDE_CODE_TASK_LIST_ID = taskListId\n      }\n\n      // Extract worktree option\n      // worktree can be true (flag without value) or a string (custom name or PR reference)\n      const worktreeOption = isWorktreeModeEnabled()\n        ? (options as { worktree?: boolean | string }).worktree\n        : undefined\n      let worktreeName =\n        typeof worktreeOption === 'string' ? worktreeOption : undefined\n      const worktreeEnabled = worktreeOption !== undefined\n\n      // Check if worktree name is a PR reference (#N or GitHub PR URL)\n      let worktreePRNumber: number | undefined\n      if (worktreeName) {\n        const prNum = parsePRReference(worktreeName)\n        if (prNum !== null) {\n          worktreePRNumber = prNum\n          worktreeName = undefined // slug will be generated in setup()\n        }\n      }\n\n      // Extract tmux option (requires --worktree)\n      const tmuxEnabled =\n        isWorktreeModeEnabled() && (options as { tmux?: boolean }).tmux === true\n\n      // Validate tmux option\n      if (tmuxEnabled) {\n        if (!worktreeEnabled) {\n          process.stderr.write(chalk.red('Error: --tmux requires --worktree\\n'))\n          process.exit(1)\n        }\n        if (getPlatform() === 'windows') {\n          process.stderr.write(\n            chalk.red('Error: --tmux is not supported on Windows\\n'),\n          )\n          process.exit(1)\n        }\n        if (!(await isTmuxAvailable())) {\n          process.stderr.write(\n            chalk.red(\n              `Error: tmux is not installed.\\n${getTmuxInstallInstructions()}\\n`,\n            ),\n          )\n          process.exit(1)\n        }\n      }\n\n      // Extract teammate options (for tmux-spawned agents)\n      // Declared outside the if block so it's accessible later for system prompt addendum\n      let storedTeammateOpts: TeammateOptions | undefined\n      if (isAgentSwarmsEnabled()) {\n        // Extract agent identity options (for tmux-spawned agents)\n        // These replace the CLAUDE_CODE_* environment variables\n        const teammateOpts = extractTeammateOptions(options)\n        storedTeammateOpts = teammateOpts\n\n        // If any teammate identity option is provided, all three required ones must be present\n        const hasAnyTeammateOpt =\n          teammateOpts.agentId ||\n          teammateOpts.agentName ||\n          teammateOpts.teamName\n        const hasAllRequiredTeammateOpts =\n          teammateOpts.agentId &&\n          teammateOpts.agentName &&\n          teammateOpts.teamName\n\n        if (hasAnyTeammateOpt && !hasAllRequiredTeammateOpts) {\n          process.stderr.write(\n            chalk.red(\n              'Error: --agent-id, --agent-name, and --team-name must all be provided together\\n',\n            ),\n          )\n          process.exit(1)\n        }\n\n        // If teammate identity is provided via CLI, set up dynamicTeamContext\n        if (\n          teammateOpts.agentId &&\n          teammateOpts.agentName &&\n          teammateOpts.teamName\n        ) {\n          getTeammateUtils().setDynamicTeamContext?.({\n            agentId: teammateOpts.agentId,\n            agentName: teammateOpts.agentName,\n            teamName: teammateOpts.teamName,\n            color: teammateOpts.agentColor,\n            planModeRequired: teammateOpts.planModeRequired ?? false,\n            parentSessionId: teammateOpts.parentSessionId,\n          })\n        }\n\n        // Set teammate mode CLI override if provided\n        // This must be done before setup() captures the snapshot\n        if (teammateOpts.teammateMode) {\n          getTeammateModeSnapshot().setCliTeammateModeOverride?.(\n            teammateOpts.teammateMode,\n          )\n        }\n      }\n\n      // Extract remote sdk options\n      const sdkUrl = (options as { sdkUrl?: string }).sdkUrl ?? undefined\n\n      // Allow env var to enable partial messages (used by sandbox gateway for baku)\n      const effectiveIncludePartialMessages =\n        includePartialMessages ||\n        isEnvTruthy(process.env.CLAUDE_CODE_INCLUDE_PARTIAL_MESSAGES)\n\n      // Enable all hook event types when explicitly requested via SDK option\n      // or when running in CLAUDE_CODE_REMOTE mode (CCR needs them).\n      // Without this, only SessionStart and Setup events are emitted.\n      if (includeHookEvents || isEnvTruthy(process.env.CLAUDE_CODE_REMOTE)) {\n        setAllHookEventsEnabled(true)\n      }\n\n      // Auto-set input/output formats, verbose mode, and print mode when SDK URL is provided\n      if (sdkUrl) {\n        // If SDK URL is provided, automatically use stream-json formats unless explicitly set\n        if (!inputFormat) {\n          inputFormat = 'stream-json'\n        }\n        if (!outputFormat) {\n          outputFormat = 'stream-json'\n        }\n        // Auto-enable verbose mode unless explicitly disabled or already set\n        if (options.verbose === undefined) {\n          verbose = true\n        }\n        // Auto-enable print mode unless explicitly disabled\n        if (!options.print) {\n          print = true\n        }\n      }\n\n      // Extract teleport option\n      const teleport =\n        (options as { teleport?: string | true }).teleport ?? null\n\n      // Extract remote option (can be true if no description provided, or a string)\n      const remoteOption = (options as { remote?: string | true }).remote\n      const remote = remoteOption === true ? '' : (remoteOption ?? null)\n\n      // Extract --remote-control / --rc flag (enable bridge in interactive session)\n      const remoteControlOption =\n        (options as { remoteControl?: string | true }).remoteControl ??\n        (options as { rc?: string | true }).rc\n      // Actual bridge check is deferred to after showSetupScreens() so that\n      // trust is established and GrowthBook has auth headers.\n      let remoteControl = false\n      const remoteControlName =\n        typeof remoteControlOption === 'string' &&\n        remoteControlOption.length > 0\n          ? remoteControlOption\n          : undefined\n\n      // Validate session ID if provided\n      if (sessionId) {\n        // Check for conflicting flags\n        // --session-id can be used with --continue or --resume when --fork-session is also provided\n        // (to specify a custom ID for the forked session)\n        if ((options.continue || options.resume) && !options.forkSession) {\n          process.stderr.write(\n            chalk.red(\n              'Error: --session-id can only be used with --continue or --resume if --fork-session is also specified.\\n',\n            ),\n          )\n          process.exit(1)\n        }\n\n        // When --sdk-url is provided (bridge/remote mode), the session ID is a\n        // server-assigned tagged ID (e.g. \"session_local_01...\") rather than a\n        // UUID. Skip UUID validation and local existence checks in that case.\n        if (!sdkUrl) {\n          const validatedSessionId = validateUuid(sessionId)\n          if (!validatedSessionId) {\n            process.stderr.write(\n              chalk.red('Error: Invalid session ID. Must be a valid UUID.\\n'),\n            )\n            process.exit(1)\n          }\n\n          // Check if session ID already exists\n          if (sessionIdExists(validatedSessionId)) {\n            process.stderr.write(\n              chalk.red(\n                `Error: Session ID ${validatedSessionId} is already in use.\\n`,\n              ),\n            )\n            process.exit(1)\n          }\n        }\n      }\n\n      // Download file resources if specified via --file flag\n      const fileSpecs = (options as { file?: string[] }).file\n      if (fileSpecs && fileSpecs.length > 0) {\n        // Get session ingress token (provided by EnvManager via CLAUDE_CODE_SESSION_ACCESS_TOKEN)\n        const sessionToken = getSessionIngressAuthToken()\n        if (!sessionToken) {\n          process.stderr.write(\n            chalk.red(\n              'Error: Session token required for file downloads. CLAUDE_CODE_SESSION_ACCESS_TOKEN must be set.\\n',\n            ),\n          )\n          process.exit(1)\n        }\n\n        // Resolve session ID: prefer remote session ID, fall back to internal session ID\n        const fileSessionId =\n          process.env.CLAUDE_CODE_REMOTE_SESSION_ID || getSessionId()\n\n        const files = parseFileSpecs(fileSpecs)\n        if (files.length > 0) {\n          // Use ANTHROPIC_BASE_URL if set (by EnvManager), otherwise use OAuth config\n          // This ensures consistency with session ingress API in all environments\n          const config: FilesApiConfig = {\n            baseUrl:\n              process.env.ANTHROPIC_BASE_URL || getOauthConfig().BASE_API_URL,\n            oauthToken: sessionToken,\n            sessionId: fileSessionId,\n          }\n\n          // Start download without blocking startup - await before REPL renders\n          fileDownloadPromise = downloadSessionFiles(files, config)\n        }\n      }\n\n      // Get isNonInteractiveSession from state (was set before init())\n      const isNonInteractiveSession = getIsNonInteractiveSession()\n\n      // Validate that fallback model is different from main model\n      if (fallbackModel && options.model && fallbackModel === options.model) {\n        process.stderr.write(\n          chalk.red(\n            'Error: Fallback model cannot be the same as the main model. Please specify a different model for --fallback-model.\\n',\n          ),\n        )\n        process.exit(1)\n      }\n\n      // Handle system prompt options\n      let systemPrompt = options.systemPrompt\n      if (options.systemPromptFile) {\n        if (options.systemPrompt) {\n          process.stderr.write(\n            chalk.red(\n              'Error: Cannot use both --system-prompt and --system-prompt-file. Please use only one.\\n',\n            ),\n          )\n          process.exit(1)\n        }\n\n        try {\n          const filePath = resolve(options.systemPromptFile)\n          systemPrompt = readFileSync(filePath, 'utf8')\n        } catch (error) {\n          const code = getErrnoCode(error)\n          if (code === 'ENOENT') {\n            process.stderr.write(\n              chalk.red(\n                `Error: System prompt file not found: ${resolve(options.systemPromptFile)}\\n`,\n              ),\n            )\n            process.exit(1)\n          }\n          process.stderr.write(\n            chalk.red(\n              `Error reading system prompt file: ${errorMessage(error)}\\n`,\n            ),\n          )\n          process.exit(1)\n        }\n      }\n\n      // Handle append system prompt options\n      let appendSystemPrompt = options.appendSystemPrompt\n      if (options.appendSystemPromptFile) {\n        if (options.appendSystemPrompt) {\n          process.stderr.write(\n            chalk.red(\n              'Error: Cannot use both --append-system-prompt and --append-system-prompt-file. Please use only one.\\n',\n            ),\n          )\n          process.exit(1)\n        }\n\n        try {\n          const filePath = resolve(options.appendSystemPromptFile)\n          appendSystemPrompt = readFileSync(filePath, 'utf8')\n        } catch (error) {\n          const code = getErrnoCode(error)\n          if (code === 'ENOENT') {\n            process.stderr.write(\n              chalk.red(\n                `Error: Append system prompt file not found: ${resolve(options.appendSystemPromptFile)}\\n`,\n              ),\n            )\n            process.exit(1)\n          }\n          process.stderr.write(\n            chalk.red(\n              `Error reading append system prompt file: ${errorMessage(error)}\\n`,\n            ),\n          )\n          process.exit(1)\n        }\n      }\n\n      // Add teammate-specific system prompt addendum for tmux teammates\n      if (\n        isAgentSwarmsEnabled() &&\n        storedTeammateOpts?.agentId &&\n        storedTeammateOpts?.agentName &&\n        storedTeammateOpts?.teamName\n      ) {\n        const addendum =\n          getTeammatePromptAddendum().TEAMMATE_SYSTEM_PROMPT_ADDENDUM\n        appendSystemPrompt = appendSystemPrompt\n          ? `${appendSystemPrompt}\\n\\n${addendum}`\n          : addendum\n      }\n\n      const { mode: permissionMode, notification: permissionModeNotification } =\n        initialPermissionModeFromCLI({\n          permissionModeCli,\n          dangerouslySkipPermissions,\n        })\n\n      // Store session bypass permissions mode for trust dialog check\n      setSessionBypassPermissionsMode(permissionMode === 'bypassPermissions')\n      if (feature('TRANSCRIPT_CLASSIFIER')) {\n        // autoModeFlagCli is the \"did the user intend auto this session\" signal.\n        // Set when: --enable-auto-mode, --permission-mode auto, resolved mode\n        // is auto, OR settings defaultMode is auto but the gate denied it\n        // (permissionMode resolved to default with no explicit CLI override).\n        // Used by verifyAutoModeGateAccess to decide whether to notify on\n        // auto-unavailable, and by tengu_auto_mode_config opt-in carousel.\n        if (\n          (options as { enableAutoMode?: boolean }).enableAutoMode ||\n          permissionModeCli === 'auto' ||\n          permissionMode === 'auto' ||\n          (!permissionModeCli && isDefaultPermissionModeAuto())\n        ) {\n          autoModeStateModule?.setAutoModeFlagCli(true)\n        }\n      }\n\n      // Parse the MCP config files/strings if provided\n      let dynamicMcpConfig: Record<string, ScopedMcpServerConfig> = {}\n\n      if (mcpConfig && mcpConfig.length > 0) {\n        // Process mcpConfig array\n        const processedConfigs = mcpConfig\n          .map(config => config.trim())\n          .filter(config => config.length > 0)\n\n        let allConfigs: Record<string, McpServerConfig> = {}\n        const allErrors: ValidationError[] = []\n\n        for (const configItem of processedConfigs) {\n          let configs: Record<string, McpServerConfig> | null = null\n          let errors: ValidationError[] = []\n\n          // First try to parse as JSON string\n          const parsedJson = safeParseJSON(configItem)\n          if (parsedJson) {\n            const result = parseMcpConfig({\n              configObject: parsedJson,\n              filePath: 'command line',\n              expandVars: true,\n              scope: 'dynamic',\n            })\n            if (result.config) {\n              configs = result.config.mcpServers\n            } else {\n              errors = result.errors\n            }\n          } else {\n            // Try as file path\n            const configPath = resolve(configItem)\n            const result = parseMcpConfigFromFilePath({\n              filePath: configPath,\n              expandVars: true,\n              scope: 'dynamic',\n            })\n            if (result.config) {\n              configs = result.config.mcpServers\n            } else {\n              errors = result.errors\n            }\n          }\n\n          if (errors.length > 0) {\n            allErrors.push(...errors)\n          } else if (configs) {\n            // Merge configs, later ones override earlier ones\n            allConfigs = { ...allConfigs, ...configs }\n          }\n        }\n\n        if (allErrors.length > 0) {\n          const formattedErrors = allErrors\n            .map(err => `${err.path ? err.path + ': ' : ''}${err.message}`)\n            .join('\\n')\n          logForDebugging(\n            `--mcp-config validation failed (${allErrors.length} errors): ${formattedErrors}`,\n            { level: 'error' },\n          )\n          process.stderr.write(\n            `Error: Invalid MCP configuration:\\n${formattedErrors}\\n`,\n          )\n          process.exit(1)\n        }\n\n        if (Object.keys(allConfigs).length > 0) {\n          // SDK hosts (Nest/Desktop) own their server naming and may reuse\n          // built-in names — skip reserved-name checks for type:'sdk'.\n          const nonSdkConfigNames = Object.entries(allConfigs)\n            .filter(([, config]) => config.type !== 'sdk')\n            .map(([name]) => name)\n\n          let reservedNameError: string | null = null\n          if (nonSdkConfigNames.some(isClaudeInChromeMCPServer)) {\n            reservedNameError = `Invalid MCP configuration: \"${CLAUDE_IN_CHROME_MCP_SERVER_NAME}\" is a reserved MCP name.`\n          } else if (feature('CHICAGO_MCP')) {\n            const { isComputerUseMCPServer, COMPUTER_USE_MCP_SERVER_NAME } =\n              await import('src/utils/computerUse/common.js')\n            if (nonSdkConfigNames.some(isComputerUseMCPServer)) {\n              reservedNameError = `Invalid MCP configuration: \"${COMPUTER_USE_MCP_SERVER_NAME}\" is a reserved MCP name.`\n            }\n          }\n          if (reservedNameError) {\n            // stderr+exit(1) — a throw here becomes a silent unhandled\n            // rejection in stream-json mode (void main() in cli.tsx).\n            process.stderr.write(`Error: ${reservedNameError}\\n`)\n            process.exit(1)\n          }\n\n          // Add dynamic scope to all configs. type:'sdk' entries pass through\n          // unchanged — they're extracted into sdkMcpConfigs downstream and\n          // passed to print.ts. The Python SDK relies on this path (it doesn't\n          // send sdkMcpServers in the initialize message). Dropping them here\n          // broke Coworker (inc-5122). The policy filter below already exempts\n          // type:'sdk', and the entries are inert without an SDK transport on\n          // stdin, so there's no bypass risk from letting them through.\n          const scopedConfigs = mapValues(allConfigs, config => ({\n            ...config,\n            scope: 'dynamic' as const,\n          }))\n\n          // Enforce managed policy (allowedMcpServers / deniedMcpServers) on\n          // --mcp-config servers. Without this, the CLI flag bypasses the\n          // enterprise allowlist that user/project/local configs go through in\n          // getClaudeCodeMcpConfigs — callers spread dynamicMcpConfig back on\n          // top of filtered results. Filter here at the source so all\n          // downstream consumers see the policy-filtered set.\n          const { allowed, blocked } = filterMcpServersByPolicy(scopedConfigs)\n          if (blocked.length > 0) {\n            process.stderr.write(\n              `Warning: MCP ${plural(blocked.length, 'server')} blocked by enterprise policy: ${blocked.join(', ')}\\n`,\n            )\n          }\n          dynamicMcpConfig = { ...dynamicMcpConfig, ...allowed }\n        }\n      }\n\n      // Extract Claude in Chrome option and enforce claude.ai subscriber check (unless user is ant)\n      const chromeOpts = options as { chrome?: boolean }\n      // Store the explicit CLI flag so teammates can inherit it\n      setChromeFlagOverride(chromeOpts.chrome)\n      const enableClaudeInChrome =\n        shouldEnableClaudeInChrome(chromeOpts.chrome) &&\n        (\"external\" === 'ant' || isClaudeAISubscriber())\n      const autoEnableClaudeInChrome =\n        !enableClaudeInChrome && shouldAutoEnableClaudeInChrome()\n\n      if (enableClaudeInChrome) {\n        const platform = getPlatform()\n        try {\n          logEvent('tengu_claude_in_chrome_setup', {\n            platform:\n              platform as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n          })\n\n          const {\n            mcpConfig: chromeMcpConfig,\n            allowedTools: chromeMcpTools,\n            systemPrompt: chromeSystemPrompt,\n          } = setupClaudeInChrome()\n          dynamicMcpConfig = { ...dynamicMcpConfig, ...chromeMcpConfig }\n          allowedTools.push(...chromeMcpTools)\n          if (chromeSystemPrompt) {\n            appendSystemPrompt = appendSystemPrompt\n              ? `${chromeSystemPrompt}\\n\\n${appendSystemPrompt}`\n              : chromeSystemPrompt\n          }\n        } catch (error) {\n          logEvent('tengu_claude_in_chrome_setup_failed', {\n            platform:\n              platform as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n          })\n          logForDebugging(`[Claude in Chrome] Error: ${error}`)\n          logError(error)\n          // biome-ignore lint/suspicious/noConsole:: intentional console output\n          console.error(`Error: Failed to run with Claude in Chrome.`)\n          process.exit(1)\n        }\n      } else if (autoEnableClaudeInChrome) {\n        try {\n          const { mcpConfig: chromeMcpConfig } = setupClaudeInChrome()\n          dynamicMcpConfig = { ...dynamicMcpConfig, ...chromeMcpConfig }\n\n          const hint =\n            feature('WEB_BROWSER_TOOL') &&\n            typeof Bun !== 'undefined' &&\n            'WebView' in Bun\n              ? CLAUDE_IN_CHROME_SKILL_HINT_WITH_WEBBROWSER\n              : CLAUDE_IN_CHROME_SKILL_HINT\n          appendSystemPrompt = appendSystemPrompt\n            ? `${appendSystemPrompt}\\n\\n${hint}`\n            : hint\n        } catch (error) {\n          // Silently skip any errors for the auto-enable\n          logForDebugging(`[Claude in Chrome] Error (auto-enable): ${error}`)\n        }\n      }\n\n      // Extract strict MCP config flag\n      const strictMcpConfig = options.strictMcpConfig || false\n\n      // Check if enterprise MCP configuration exists. When it does, only allow dynamic MCP\n      // configs that contain special server types (sdk)\n      if (doesEnterpriseMcpConfigExist()) {\n        if (strictMcpConfig) {\n          process.stderr.write(\n            chalk.red(\n              'You cannot use --strict-mcp-config when an enterprise MCP config is present',\n            ),\n          )\n          process.exit(1)\n        }\n\n        // For --mcp-config, allow if all servers are internal types (sdk)\n        if (\n          dynamicMcpConfig &&\n          !areMcpConfigsAllowedWithEnterpriseMcpConfig(dynamicMcpConfig)\n        ) {\n          process.stderr.write(\n            chalk.red(\n              'You cannot dynamically configure MCP servers when an enterprise MCP config is present',\n            ),\n          )\n          process.exit(1)\n        }\n      }\n\n      // chicago MCP: guarded Computer Use (app allowlist + frontmost gate +\n      // SCContentFilter screenshots). Ant-only, GrowthBook-gated — failures\n      // are silent (this is dogfooding). Platform + interactive checks inline\n      // so non-macOS / print-mode ants skip the heavy @ant/computer-use-mcp\n      // import entirely. gates.js is light (type-only package import).\n      //\n      // Placed AFTER the enterprise-MCP-config check: that check rejects any\n      // dynamicMcpConfig entry with `type !== 'sdk'`, and our config is\n      // `type: 'stdio'`. An enterprise-config ant with the GB gate on would\n      // otherwise process.exit(1). Chrome has the same latent issue but has\n      // shipped without incident; chicago places itself correctly.\n      if (\n        feature('CHICAGO_MCP') &&\n        getPlatform() === 'macos' &&\n        !getIsNonInteractiveSession()\n      ) {\n        try {\n          const { getChicagoEnabled } = await import(\n            'src/utils/computerUse/gates.js'\n          )\n          if (getChicagoEnabled()) {\n            const { setupComputerUseMCP } = await import(\n              'src/utils/computerUse/setup.js'\n            )\n            const { mcpConfig, allowedTools: cuTools } = setupComputerUseMCP()\n            dynamicMcpConfig = { ...dynamicMcpConfig, ...mcpConfig }\n            allowedTools.push(...cuTools)\n          }\n        } catch (error) {\n          logForDebugging(\n            `[Computer Use MCP] Setup failed: ${errorMessage(error)}`,\n          )\n        }\n      }\n\n      // Store additional directories for CLAUDE.md loading (controlled by env var)\n      setAdditionalDirectoriesForClaudeMd(addDir)\n\n      // Channel server allowlist from --channels flag — servers whose\n      // inbound push notifications should register this session. The option\n      // is added inside a feature() block so TS doesn't know about it\n      // on the options type — same pattern as --assistant at main.tsx:1824.\n      // devChannels is deferred: showSetupScreens shows a confirmation dialog\n      // and only appends to allowedChannels on accept.\n      let devChannels: ChannelEntry[] | undefined\n      if (feature('KAIROS') || feature('KAIROS_CHANNELS')) {\n        // Parse plugin:name@marketplace / server:Y tags into typed entries.\n        // Tag decides trust model downstream: plugin-kind hits marketplace\n        // verification + GrowthBook allowlist, server-kind always fails\n        // allowlist (schema is plugin-only) unless dev flag is set.\n        // Untagged or marketplace-less plugin entries are hard errors —\n        // silently not-matching in the gate would look like channels are\n        // \"on\" but nothing ever fires.\n        const parseChannelEntries = (\n          raw: string[],\n          flag: string,\n        ): ChannelEntry[] => {\n          const entries: ChannelEntry[] = []\n          const bad: string[] = []\n          for (const c of raw) {\n            if (c.startsWith('plugin:')) {\n              const rest = c.slice(7)\n              const at = rest.indexOf('@')\n              if (at <= 0 || at === rest.length - 1) {\n                bad.push(c)\n              } else {\n                entries.push({\n                  kind: 'plugin',\n                  name: rest.slice(0, at),\n                  marketplace: rest.slice(at + 1),\n                })\n              }\n            } else if (c.startsWith('server:') && c.length > 7) {\n              entries.push({ kind: 'server', name: c.slice(7) })\n            } else {\n              bad.push(c)\n            }\n          }\n          if (bad.length > 0) {\n            process.stderr.write(\n              chalk.red(\n                `${flag} entries must be tagged: ${bad.join(', ')}\\n` +\n                  `  plugin:<name>@<marketplace>  — plugin-provided channel (allowlist enforced)\\n` +\n                  `  server:<name>                — manually configured MCP server\\n`,\n              ),\n            )\n            process.exit(1)\n          }\n          return entries\n        }\n\n        const channelOpts = options as {\n          channels?: string[]\n          dangerouslyLoadDevelopmentChannels?: string[]\n        }\n        const rawChannels = channelOpts.channels\n        const rawDev = channelOpts.dangerouslyLoadDevelopmentChannels\n        // Always parse + set. ChannelsNotice reads getAllowedChannels() and\n        // renders the appropriate branch (disabled/noAuth/policyBlocked/\n        // listening) in the startup screen. gateChannelServer() enforces.\n        // --channels works in both interactive and print/SDK modes; dev-channels\n        // stays interactive-only (requires a confirmation dialog).\n        let channelEntries: ChannelEntry[] = []\n        if (rawChannels && rawChannels.length > 0) {\n          channelEntries = parseChannelEntries(rawChannels, '--channels')\n          setAllowedChannels(channelEntries)\n        }\n        if (!isNonInteractiveSession) {\n          if (rawDev && rawDev.length > 0) {\n            devChannels = parseChannelEntries(\n              rawDev,\n              '--dangerously-load-development-channels',\n            )\n          }\n        }\n        // Flag-usage telemetry. Plugin identifiers are logged (same tier as\n        // tengu_plugin_installed — public-registry-style names); server-kind\n        // names are not (MCP-server-name tier, opt-in-only elsewhere).\n        // Per-server gate outcomes land in tengu_mcp_channel_gate once\n        // servers connect. Dev entries go through a confirmation dialog after\n        // this — dev_plugins captures what was typed, not what was accepted.\n        if (channelEntries.length > 0 || (devChannels?.length ?? 0) > 0) {\n          const joinPluginIds = (entries: ChannelEntry[]) => {\n            const ids = entries.flatMap(e =>\n              e.kind === 'plugin' ? [`${e.name}@${e.marketplace}`] : [],\n            )\n            return ids.length > 0\n              ? (ids\n                  .sort()\n                  .join(\n                    ',',\n                  ) as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS)\n              : undefined\n          }\n          logEvent('tengu_mcp_channel_flags', {\n            channels_count: channelEntries.length,\n            dev_count: devChannels?.length ?? 0,\n            plugins: joinPluginIds(channelEntries),\n            dev_plugins: joinPluginIds(devChannels ?? []),\n          })\n        }\n      }\n\n      // SDK opt-in for SendUserMessage via --tools. All sessions require\n      // explicit opt-in; listing it in --tools signals intent. Runs BEFORE\n      // initializeToolPermissionContext so getToolsForDefaultPreset() sees\n      // the tool as enabled when computing the base-tools disallow filter.\n      // Conditional require avoids leaking the tool-name string into\n      // external builds.\n      if (\n        (feature('KAIROS') || feature('KAIROS_BRIEF')) &&\n        baseTools.length > 0\n      ) {\n        /* eslint-disable @typescript-eslint/no-require-imports */\n        const { BRIEF_TOOL_NAME, LEGACY_BRIEF_TOOL_NAME } =\n          require('./tools/BriefTool/prompt.js') as typeof import('./tools/BriefTool/prompt.js')\n        const { isBriefEntitled } =\n          require('./tools/BriefTool/BriefTool.js') as typeof import('./tools/BriefTool/BriefTool.js')\n        /* eslint-enable @typescript-eslint/no-require-imports */\n        const parsed = parseToolListFromCLI(baseTools)\n        if (\n          (parsed.includes(BRIEF_TOOL_NAME) ||\n            parsed.includes(LEGACY_BRIEF_TOOL_NAME)) &&\n          isBriefEntitled()\n        ) {\n          setUserMsgOptIn(true)\n        }\n      }\n\n      // This await replaces blocking existsSync/statSync calls that were already in\n      // the startup path. Wall-clock time is unchanged; we just yield to the event\n      // loop during the fs I/O instead of blocking it. See #19661.\n      const initResult = await initializeToolPermissionContext({\n        allowedToolsCli: allowedTools,\n        disallowedToolsCli: disallowedTools,\n        baseToolsCli: baseTools,\n        permissionMode,\n        allowDangerouslySkipPermissions,\n        addDirs: addDir,\n      })\n      let toolPermissionContext = initResult.toolPermissionContext\n      const { warnings, dangerousPermissions, overlyBroadBashPermissions } =\n        initResult\n\n      // Handle overly broad shell allow rules for ant users (Bash(*), PowerShell(*))\n      if (\n        \"external\" === 'ant' &&\n        overlyBroadBashPermissions.length > 0\n      ) {\n        for (const permission of overlyBroadBashPermissions) {\n          logForDebugging(\n            `Ignoring overly broad shell permission ${permission.ruleDisplay} from ${permission.sourceDisplay}`,\n          )\n        }\n        toolPermissionContext = removeDangerousPermissions(\n          toolPermissionContext,\n          overlyBroadBashPermissions,\n        )\n      }\n\n      if (feature('TRANSCRIPT_CLASSIFIER') && dangerousPermissions.length > 0) {\n        toolPermissionContext = stripDangerousPermissionsForAutoMode(\n          toolPermissionContext,\n        )\n      }\n\n      // Print any warnings from initialization\n      warnings.forEach(warning => {\n        // biome-ignore lint/suspicious/noConsole:: intentional console output\n        console.error(warning)\n      })\n\n      void assertMinVersion()\n\n      // claude.ai config fetch: -p mode only (interactive uses useManageMCPConnections\n      // two-phase loading). Kicked off here to overlap with setup(); awaited\n      // before runHeadless so single-turn -p sees connectors. Skipped under\n      // enterprise/strict MCP to preserve policy boundaries.\n      const claudeaiConfigPromise: Promise<\n        Record<string, ScopedMcpServerConfig>\n      > =\n        isNonInteractiveSession &&\n        !strictMcpConfig &&\n        !doesEnterpriseMcpConfigExist() &&\n        // --bare / SIMPLE: skip claude.ai proxy servers (datadog, Gmail,\n        // Slack, BigQuery, PubMed — 6-14s each to connect). Scripted calls\n        // that need MCP pass --mcp-config explicitly.\n        !isBareMode()\n          ? fetchClaudeAIMcpConfigsIfEligible().then(configs => {\n              const { allowed, blocked } = filterMcpServersByPolicy(configs)\n              if (blocked.length > 0) {\n                process.stderr.write(\n                  `Warning: claude.ai MCP ${plural(blocked.length, 'server')} blocked by enterprise policy: ${blocked.join(', ')}\\n`,\n                )\n              }\n              return allowed\n            })\n          : Promise.resolve({})\n\n      // Kick off MCP config loading early (safe - just reads files, no execution).\n      // Both interactive and -p use getClaudeCodeMcpConfigs (local file reads only).\n      // The local promise is awaited later (before prefetchAllMcpResources) to\n      // overlap config I/O with setup(), commands loading, and trust dialog.\n      logForDebugging('[STARTUP] Loading MCP configs...')\n      const mcpConfigStart = Date.now()\n      let mcpConfigResolvedMs: number | undefined\n      // --bare skips auto-discovered MCP (.mcp.json, user settings, plugins) —\n      // only explicit --mcp-config works. dynamicMcpConfig is spread onto\n      // allMcpConfigs downstream so it survives this skip.\n      const mcpConfigPromise = (\n        strictMcpConfig || isBareMode()\n          ? Promise.resolve({\n              servers: {} as Record<string, ScopedMcpServerConfig>,\n            })\n          : getClaudeCodeMcpConfigs(dynamicMcpConfig)\n      ).then(result => {\n        mcpConfigResolvedMs = Date.now() - mcpConfigStart\n        return result\n      })\n\n      // NOTE: We do NOT call prefetchAllMcpResources here - that's deferred until after trust dialog\n\n      if (\n        inputFormat &&\n        inputFormat !== 'text' &&\n        inputFormat !== 'stream-json'\n      ) {\n        // biome-ignore lint/suspicious/noConsole:: intentional console output\n        console.error(`Error: Invalid input format \"${inputFormat}\".`)\n        process.exit(1)\n      }\n      if (inputFormat === 'stream-json' && outputFormat !== 'stream-json') {\n        // biome-ignore lint/suspicious/noConsole:: intentional console output\n        console.error(\n          `Error: --input-format=stream-json requires output-format=stream-json.`,\n        )\n        process.exit(1)\n      }\n\n      // Validate sdkUrl is only used with appropriate formats (formats are auto-set above)\n      if (sdkUrl) {\n        if (inputFormat !== 'stream-json' || outputFormat !== 'stream-json') {\n          // biome-ignore lint/suspicious/noConsole:: intentional console output\n          console.error(\n            `Error: --sdk-url requires both --input-format=stream-json and --output-format=stream-json.`,\n          )\n          process.exit(1)\n        }\n      }\n\n      // Validate replayUserMessages is only used with stream-json formats\n      if (options.replayUserMessages) {\n        if (inputFormat !== 'stream-json' || outputFormat !== 'stream-json') {\n          // biome-ignore lint/suspicious/noConsole:: intentional console output\n          console.error(\n            `Error: --replay-user-messages requires both --input-format=stream-json and --output-format=stream-json.`,\n          )\n          process.exit(1)\n        }\n      }\n\n      // Validate includePartialMessages is only used with print mode and stream-json output\n      if (effectiveIncludePartialMessages) {\n        if (!isNonInteractiveSession || outputFormat !== 'stream-json') {\n          writeToStderr(\n            `Error: --include-partial-messages requires --print and --output-format=stream-json.`,\n          )\n          process.exit(1)\n        }\n      }\n\n      // Validate --no-session-persistence is only used with print mode\n      if (options.sessionPersistence === false && !isNonInteractiveSession) {\n        writeToStderr(\n          `Error: --no-session-persistence can only be used with --print mode.`,\n        )\n        process.exit(1)\n      }\n\n      const effectivePrompt = prompt || ''\n      let inputPrompt = await getInputPrompt(\n        effectivePrompt,\n        (inputFormat ?? 'text') as 'text' | 'stream-json',\n      )\n      profileCheckpoint('action_after_input_prompt')\n\n      // Activate proactive mode BEFORE getTools() so SleepTool.isEnabled()\n      // (which returns isProactiveActive()) passes and Sleep is included.\n      // The later REPL-path maybeActivateProactive() calls are idempotent.\n      maybeActivateProactive(options)\n\n      let tools = getTools(toolPermissionContext)\n\n      // Apply coordinator mode tool filtering for headless path\n      // (mirrors useMergedTools.ts filtering for REPL/interactive path)\n      if (\n        feature('COORDINATOR_MODE') &&\n        isEnvTruthy(process.env.CLAUDE_CODE_COORDINATOR_MODE)\n      ) {\n        const { applyCoordinatorToolFilter } = await import(\n          './utils/toolPool.js'\n        )\n        tools = applyCoordinatorToolFilter(tools)\n      }\n\n      profileCheckpoint('action_tools_loaded')\n\n      let jsonSchema: ToolInputJSONSchema | undefined\n      if (\n        isSyntheticOutputToolEnabled({ isNonInteractiveSession }) &&\n        options.jsonSchema\n      ) {\n        jsonSchema = jsonParse(options.jsonSchema) as ToolInputJSONSchema\n      }\n\n      if (jsonSchema) {\n        const syntheticOutputResult = createSyntheticOutputTool(jsonSchema)\n        if ('tool' in syntheticOutputResult) {\n          // Add SyntheticOutputTool to the tools array AFTER getTools() filtering.\n          // This tool is excluded from normal filtering (see tools.ts) because it's\n          // an implementation detail for structured output, not a user-controlled tool.\n          tools = [...tools, syntheticOutputResult.tool]\n\n          logEvent('tengu_structured_output_enabled', {\n            schema_property_count: Object.keys(\n              (jsonSchema.properties as Record<string, unknown>) || {},\n            )\n              .length as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n            has_required_fields: Boolean(\n              jsonSchema.required,\n            ) as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n          })\n        } else {\n          logEvent('tengu_structured_output_failure', {\n            error:\n              'Invalid JSON schema' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n          })\n        }\n      }\n\n      // IMPORTANT: setup() must be called before any other code that depends on the cwd or worktree setup\n      profileCheckpoint('action_before_setup')\n      logForDebugging('[STARTUP] Running setup()...')\n      const setupStart = Date.now()\n      const { setup } = await import('./setup.js')\n      const messagingSocketPath = feature('UDS_INBOX')\n        ? (options as { messagingSocketPath?: string }).messagingSocketPath\n        : undefined\n      // Parallelize setup() with commands+agents loading. setup()'s ~28ms is\n      // mostly startUdsMessaging (socket bind, ~20ms) — not disk-bound, so it\n      // doesn't contend with getCommands' file reads. Gated on !worktreeEnabled\n      // since --worktree makes setup() process.chdir() (setup.ts:203), and\n      // commands/agents need the post-chdir cwd.\n      const preSetupCwd = getCwd()\n      // Register bundled skills/plugins before kicking getCommands() — they're\n      // pure in-memory array pushes (<1ms, zero I/O) that getBundledSkills()\n      // reads synchronously. Previously ran inside setup() after ~20ms of\n      // await points, so the parallel getCommands() memoized an empty list.\n      if (process.env.CLAUDE_CODE_ENTRYPOINT !== 'local-agent') {\n        initBuiltinPlugins()\n        initBundledSkills()\n      }\n      const setupPromise = setup(\n        preSetupCwd,\n        permissionMode,\n        allowDangerouslySkipPermissions,\n        worktreeEnabled,\n        worktreeName,\n        tmuxEnabled,\n        sessionId ? validateUuid(sessionId) : undefined,\n        worktreePRNumber,\n        messagingSocketPath,\n      )\n      const commandsPromise = worktreeEnabled ? null : getCommands(preSetupCwd)\n      const agentDefsPromise = worktreeEnabled\n        ? null\n        : getAgentDefinitionsWithOverrides(preSetupCwd)\n      // Suppress transient unhandledRejection if these reject during the\n      // ~28ms setupPromise await before Promise.all joins them below.\n      commandsPromise?.catch(() => {})\n      agentDefsPromise?.catch(() => {})\n      await setupPromise\n      logForDebugging(\n        `[STARTUP] setup() completed in ${Date.now() - setupStart}ms`,\n      )\n      profileCheckpoint('action_after_setup')\n\n      // Replay user messages into stream-json only when the socket was\n      // explicitly requested. The auto-generated socket is passive — it\n      // lets tools inject if they want to, but turning it on by default\n      // shouldn't reshape stream-json for SDK consumers who never touch it.\n      // Callers who inject and also want those injections visible in the\n      // stream pass --messaging-socket-path explicitly (or --replay-user-messages).\n      let effectiveReplayUserMessages = !!options.replayUserMessages\n      if (feature('UDS_INBOX')) {\n        if (!effectiveReplayUserMessages && outputFormat === 'stream-json') {\n          effectiveReplayUserMessages = !!(\n            options as { messagingSocketPath?: string }\n          ).messagingSocketPath\n        }\n      }\n\n      if (getIsNonInteractiveSession()) {\n        // Apply full merged settings env now (including project-scoped\n        // .claude/settings.json PATH/GIT_DIR/GIT_WORK_TREE) so gitExe() and\n        // the git spawn below see it. Trust is implicit in -p mode; the\n        // docstring at managedEnv.ts:96-97 says this applies \"potentially\n        // dangerous environment variables such as LD_PRELOAD, PATH\" from all\n        // sources. The later call in the isNonInteractiveSession block below\n        // is idempotent (Object.assign, configureGlobalAgents ejects prior\n        // interceptor) and picks up any plugin-contributed env after plugin\n        // init. Project settings are already loaded here:\n        // applySafeConfigEnvironmentVariables in init() called\n        // getSettings_DEPRECATED at managedEnv.ts:86 which merges all enabled\n        // sources including projectSettings/localSettings.\n        applyConfigEnvironmentVariables()\n\n        // Spawn git status/log/branch now so the subprocess execution overlaps\n        // with the getCommands await below and startDeferredPrefetches. After\n        // setup() so cwd is final (setup.ts:254 may process.chdir(worktreePath)\n        // for --worktree) and after the applyConfigEnvironmentVariables above\n        // so PATH/GIT_DIR/GIT_WORK_TREE from all sources (trusted + project)\n        // are applied. getSystemContext is memoized; the\n        // prefetchSystemContextIfSafe call in startDeferredPrefetches becomes\n        // a cache hit. The microtask from await getIsGit() drains at the\n        // getCommands Promise.all await below. Trust is implicit in -p mode\n        // (same gate as prefetchSystemContextIfSafe).\n        void getSystemContext()\n        // Kick getUserContext now too — its first await (fs.readFile in\n        // getMemoryFiles) yields naturally, so the CLAUDE.md directory walk\n        // runs during the ~280ms overlap window before the context\n        // Promise.all join in print.ts. The void getUserContext() in\n        // startDeferredPrefetches becomes a memoize cache-hit.\n        void getUserContext()\n        // Kick ensureModelStringsInitialized now — for Bedrock this triggers\n        // a 100-200ms profile fetch that was awaited serially at\n        // print.ts:739. updateBedrockModelStrings is sequential()-wrapped so\n        // the await joins the in-flight fetch. Non-Bedrock is a sync\n        // early-return (zero-cost).\n        void ensureModelStringsInitialized()\n      }\n\n      // Apply --name: cache-only so no orphan file is created before the\n      // session ID is finalized by --continue/--resume. materializeSessionFile\n      // persists it on the first user message; REPL's useTerminalTitle reads it\n      // via getCurrentSessionTitle.\n      const sessionNameArg = options.name?.trim()\n      if (sessionNameArg) {\n        cacheSessionTitle(sessionNameArg)\n      }\n\n      // Ant model aliases (capybara-fast etc.) resolve via the\n      // tengu_ant_model_override GrowthBook flag. _CACHED_MAY_BE_STALE reads\n      // disk synchronously; disk is populated by a fire-and-forget write. On a\n      // cold cache, parseUserSpecifiedModel returns the unresolved alias, the\n      // API 404s, and -p exits before the async write lands — crashloop on\n      // fresh pods. Awaiting init here populates the in-memory payload map that\n      // _CACHED_MAY_BE_STALE now checks first. Gated so the warm path stays\n      // non-blocking:\n      //  - explicit model via --model or ANTHROPIC_MODEL (both feed alias resolution)\n      //  - no env override (which short-circuits _CACHED_MAY_BE_STALE before disk)\n      //  - flag absent from disk (== null also catches pre-#22279 poisoned null)\n      const explicitModel = options.model || process.env.ANTHROPIC_MODEL\n      if (\n        \"external\" === 'ant' &&\n        explicitModel &&\n        explicitModel !== 'default' &&\n        !hasGrowthBookEnvOverride('tengu_ant_model_override') &&\n        getGlobalConfig().cachedGrowthBookFeatures?.[\n          'tengu_ant_model_override'\n        ] == null\n      ) {\n        await initializeGrowthBook()\n      }\n\n      // Special case the default model with the null keyword\n      // NOTE: Model resolution happens after setup() to ensure trust is established before AWS auth\n      const userSpecifiedModel =\n        options.model === 'default' ? getDefaultMainLoopModel() : options.model\n      const userSpecifiedFallbackModel =\n        fallbackModel === 'default' ? getDefaultMainLoopModel() : fallbackModel\n\n      // Reuse preSetupCwd unless setup() chdir'd (worktreeEnabled). Saves a\n      // getCwd() syscall in the common path.\n      const currentCwd = worktreeEnabled ? getCwd() : preSetupCwd\n      logForDebugging('[STARTUP] Loading commands and agents...')\n      const commandsStart = Date.now()\n      // Join the promises kicked before setup() (or start fresh if\n      // worktreeEnabled gated the early kick). Both memoized by cwd.\n      const [commands, agentDefinitionsResult] = await Promise.all([\n        commandsPromise ?? getCommands(currentCwd),\n        agentDefsPromise ?? getAgentDefinitionsWithOverrides(currentCwd),\n      ])\n      logForDebugging(\n        `[STARTUP] Commands and agents loaded in ${Date.now() - commandsStart}ms`,\n      )\n      profileCheckpoint('action_commands_loaded')\n\n      // Parse CLI agents if provided via --agents flag\n      let cliAgents: typeof agentDefinitionsResult.activeAgents = []\n      if (agentsJson) {\n        try {\n          const parsedAgents = safeParseJSON(agentsJson)\n          if (parsedAgents) {\n            cliAgents = parseAgentsFromJson(parsedAgents, 'flagSettings')\n          }\n        } catch (error) {\n          logError(error)\n        }\n      }\n\n      // Merge CLI agents with existing ones\n      const allAgents = [...agentDefinitionsResult.allAgents, ...cliAgents]\n      const agentDefinitions = {\n        ...agentDefinitionsResult,\n        allAgents,\n        activeAgents: getActiveAgentsFromList(allAgents),\n      }\n\n      // Look up main thread agent from CLI flag or settings\n      const agentSetting = agentCli ?? getInitialSettings().agent\n      let mainThreadAgentDefinition:\n        | (typeof agentDefinitions.activeAgents)[number]\n        | undefined\n      if (agentSetting) {\n        mainThreadAgentDefinition = agentDefinitions.activeAgents.find(\n          agent => agent.agentType === agentSetting,\n        )\n        if (!mainThreadAgentDefinition) {\n          logForDebugging(\n            `Warning: agent \"${agentSetting}\" not found. ` +\n              `Available agents: ${agentDefinitions.activeAgents.map(a => a.agentType).join(', ')}. ` +\n              `Using default behavior.`,\n          )\n        }\n      }\n\n      // Store the main thread agent type in bootstrap state so hooks can access it\n      setMainThreadAgentType(mainThreadAgentDefinition?.agentType)\n\n      // Log agent flag usage — only log agent name for built-in agents to avoid leaking custom agent names\n      if (mainThreadAgentDefinition) {\n        logEvent('tengu_agent_flag', {\n          agentType: isBuiltInAgent(mainThreadAgentDefinition)\n            ? (mainThreadAgentDefinition.agentType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS)\n            : ('custom' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS),\n          ...(agentCli && {\n            source:\n              'cli' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n          }),\n        })\n      }\n\n      // Persist agent setting to session transcript for resume view display and restoration\n      if (mainThreadAgentDefinition?.agentType) {\n        saveAgentSetting(mainThreadAgentDefinition.agentType)\n      }\n\n      // Apply the agent's system prompt for non-interactive sessions\n      // (interactive mode uses buildEffectiveSystemPrompt instead)\n      if (\n        isNonInteractiveSession &&\n        mainThreadAgentDefinition &&\n        !systemPrompt &&\n        !isBuiltInAgent(mainThreadAgentDefinition)\n      ) {\n        const agentSystemPrompt = mainThreadAgentDefinition.getSystemPrompt()\n        if (agentSystemPrompt) {\n          systemPrompt = agentSystemPrompt\n        }\n      }\n\n      // initialPrompt goes first so its slash command (if any) is processed;\n      // user-provided text becomes trailing context.\n      // Only concatenate when inputPrompt is a string. When it's an\n      // AsyncIterable (SDK stream-json mode), template interpolation would\n      // call .toString() producing \"[object Object]\". The AsyncIterable case\n      // is handled in print.ts via structuredIO.prependUserMessage().\n      if (mainThreadAgentDefinition?.initialPrompt) {\n        if (typeof inputPrompt === 'string') {\n          inputPrompt = inputPrompt\n            ? `${mainThreadAgentDefinition.initialPrompt}\\n\\n${inputPrompt}`\n            : mainThreadAgentDefinition.initialPrompt\n        } else if (!inputPrompt) {\n          inputPrompt = mainThreadAgentDefinition.initialPrompt\n        }\n      }\n\n      // Compute effective model early so hooks can run in parallel with MCP\n      // If user didn't specify a model but agent has one, use the agent's model\n      let effectiveModel = userSpecifiedModel\n      if (\n        !effectiveModel &&\n        mainThreadAgentDefinition?.model &&\n        mainThreadAgentDefinition.model !== 'inherit'\n      ) {\n        effectiveModel = parseUserSpecifiedModel(\n          mainThreadAgentDefinition.model,\n        )\n      }\n\n      setMainLoopModelOverride(effectiveModel)\n\n      // Compute resolved model for hooks (use user-specified model at launch)\n      setInitialMainLoopModel(getUserSpecifiedModelSetting() || null)\n      const initialMainLoopModel = getInitialMainLoopModel()\n      const resolvedInitialModel = parseUserSpecifiedModel(\n        initialMainLoopModel ?? getDefaultMainLoopModel(),\n      )\n\n      let advisorModel: string | undefined\n      if (isAdvisorEnabled()) {\n        const advisorOption = canUserConfigureAdvisor()\n          ? (options as { advisor?: string }).advisor\n          : undefined\n        if (advisorOption) {\n          logForDebugging(`[AdvisorTool] --advisor ${advisorOption}`)\n          if (!modelSupportsAdvisor(resolvedInitialModel)) {\n            process.stderr.write(\n              chalk.red(\n                `Error: The model \"${resolvedInitialModel}\" does not support the advisor tool.\\n`,\n              ),\n            )\n            process.exit(1)\n          }\n          const normalizedAdvisorModel = normalizeModelStringForAPI(\n            parseUserSpecifiedModel(advisorOption),\n          )\n          if (!isValidAdvisorModel(normalizedAdvisorModel)) {\n            process.stderr.write(\n              chalk.red(\n                `Error: The model \"${advisorOption}\" cannot be used as an advisor.\\n`,\n              ),\n            )\n            process.exit(1)\n          }\n        }\n        advisorModel = canUserConfigureAdvisor()\n          ? (advisorOption ?? getInitialAdvisorSetting())\n          : advisorOption\n        if (advisorModel) {\n          logForDebugging(`[AdvisorTool] Advisor model: ${advisorModel}`)\n        }\n      }\n\n      // For tmux teammates with --agent-type, append the custom agent's prompt\n      if (\n        isAgentSwarmsEnabled() &&\n        storedTeammateOpts?.agentId &&\n        storedTeammateOpts?.agentName &&\n        storedTeammateOpts?.teamName &&\n        storedTeammateOpts?.agentType\n      ) {\n        // Look up the custom agent definition\n        const customAgent = agentDefinitions.activeAgents.find(\n          a => a.agentType === storedTeammateOpts.agentType,\n        )\n        if (customAgent) {\n          // Get the prompt - need to handle both built-in and custom agents\n          let customPrompt: string | undefined\n          if (customAgent.source === 'built-in') {\n            // Built-in agents have getSystemPrompt that takes toolUseContext\n            // We can't access full toolUseContext here, so skip for now\n            logForDebugging(\n              `[teammate] Built-in agent ${storedTeammateOpts.agentType} - skipping custom prompt (not supported)`,\n            )\n          } else {\n            // Custom agents have getSystemPrompt that takes no args\n            customPrompt = customAgent.getSystemPrompt()\n          }\n\n          // Log agent memory loaded event for tmux teammates\n          if (customAgent.memory) {\n            logEvent('tengu_agent_memory_loaded', {\n              ...(\"external\" === 'ant' && {\n                agent_type:\n                  customAgent.agentType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n              }),\n              scope:\n                customAgent.memory as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n              source:\n                'teammate' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n            })\n          }\n\n          if (customPrompt) {\n            const customInstructions = `\\n# Custom Agent Instructions\\n${customPrompt}`\n            appendSystemPrompt = appendSystemPrompt\n              ? `${appendSystemPrompt}\\n\\n${customInstructions}`\n              : customInstructions\n          }\n        } else {\n          logForDebugging(\n            `[teammate] Custom agent ${storedTeammateOpts.agentType} not found in available agents`,\n          )\n        }\n      }\n\n      maybeActivateBrief(options)\n      // defaultView: 'chat' is a persisted opt-in — check entitlement and set\n      // userMsgOptIn so the tool + prompt section activate. Interactive-only:\n      // defaultView is a display preference; SDK sessions have no display, and\n      // the assistant installer writes defaultView:'chat' to settings.local.json\n      // which would otherwise leak into --print sessions in the same directory.\n      // Runs right after maybeActivateBrief() so all startup opt-in paths fire\n      // BEFORE any isBriefEnabled() read below (proactive prompt's\n      // briefVisibility). A persisted 'chat' after a GB kill-switch falls\n      // through (entitlement fails).\n      if (\n        (feature('KAIROS') || feature('KAIROS_BRIEF')) &&\n        !getIsNonInteractiveSession() &&\n        !getUserMsgOptIn() &&\n        getInitialSettings().defaultView === 'chat'\n      ) {\n        /* eslint-disable @typescript-eslint/no-require-imports */\n        const { isBriefEntitled } =\n          require('./tools/BriefTool/BriefTool.js') as typeof import('./tools/BriefTool/BriefTool.js')\n        /* eslint-enable @typescript-eslint/no-require-imports */\n        if (isBriefEntitled()) {\n          setUserMsgOptIn(true)\n        }\n      }\n      // Coordinator mode has its own system prompt and filters out Sleep, so\n      // the generic proactive prompt would tell it to call a tool it can't\n      // access and conflict with delegation instructions.\n      if (\n        (feature('PROACTIVE') || feature('KAIROS')) &&\n        ((options as { proactive?: boolean }).proactive ||\n          isEnvTruthy(process.env.CLAUDE_CODE_PROACTIVE)) &&\n        !coordinatorModeModule?.isCoordinatorMode()\n      ) {\n        /* eslint-disable @typescript-eslint/no-require-imports */\n        const briefVisibility =\n          feature('KAIROS') || feature('KAIROS_BRIEF')\n            ? (\n                require('./tools/BriefTool/BriefTool.js') as typeof import('./tools/BriefTool/BriefTool.js')\n              ).isBriefEnabled()\n              ? 'Call SendUserMessage at checkpoints to mark where things stand.'\n              : 'The user will see any text you output.'\n            : 'The user will see any text you output.'\n        /* eslint-enable @typescript-eslint/no-require-imports */\n        const proactivePrompt = `\\n# Proactive Mode\\n\\nYou are in proactive mode. Take initiative — explore, act, and make progress without waiting for instructions.\\n\\nStart by briefly greeting the user.\\n\\nYou will receive periodic <tick> prompts. These are check-ins. Do whatever seems most useful, or call Sleep if there's nothing to do. ${briefVisibility}`\n        appendSystemPrompt = appendSystemPrompt\n          ? `${appendSystemPrompt}\\n\\n${proactivePrompt}`\n          : proactivePrompt\n      }\n\n      if (feature('KAIROS') && kairosEnabled && assistantModule) {\n        const assistantAddendum =\n          assistantModule.getAssistantSystemPromptAddendum()\n        appendSystemPrompt = appendSystemPrompt\n          ? `${appendSystemPrompt}\\n\\n${assistantAddendum}`\n          : assistantAddendum\n      }\n\n      // Ink root is only needed for interactive sessions — patchConsole in the\n      // Ink constructor would swallow console output in headless mode.\n      let root!: Root\n      let getFpsMetrics!: () => FpsMetrics | undefined\n      let stats!: StatsStore\n\n      // Show setup screens after commands are loaded\n      if (!isNonInteractiveSession) {\n        const ctx = getRenderContext(false)\n        getFpsMetrics = ctx.getFpsMetrics\n        stats = ctx.stats\n        // Install asciicast recorder before Ink mounts (ant-only, opt-in via CLAUDE_CODE_TERMINAL_RECORDING=1)\n        if (\"external\" === 'ant') {\n          installAsciicastRecorder()\n        }\n\n        const { createRoot } = await import('./ink.js')\n        root = await createRoot(ctx.renderOptions)\n\n        // Log startup time now, before any blocking dialog renders. Logging\n        // from REPL's first render (the old location) included however long\n        // the user sat on trust/OAuth/onboarding/resume-picker — p99 was ~70s\n        // dominated by dialog-wait time, not code-path startup.\n        logEvent('tengu_timer', {\n          event:\n            'startup' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n          durationMs: Math.round(process.uptime() * 1000),\n        })\n\n        logForDebugging('[STARTUP] Running showSetupScreens()...')\n        const setupScreensStart = Date.now()\n        const onboardingShown = await showSetupScreens(\n          root,\n          permissionMode,\n          allowDangerouslySkipPermissions,\n          commands,\n          enableClaudeInChrome,\n          devChannels,\n        )\n        logForDebugging(\n          `[STARTUP] showSetupScreens() completed in ${Date.now() - setupScreensStart}ms`,\n        )\n\n        // Now that trust is established and GrowthBook has auth headers,\n        // resolve the --remote-control / --rc entitlement gate.\n        if (feature('BRIDGE_MODE') && remoteControlOption !== undefined) {\n          const { getBridgeDisabledReason } = await import(\n            './bridge/bridgeEnabled.js'\n          )\n          const disabledReason = await getBridgeDisabledReason()\n          remoteControl = disabledReason === null\n          if (disabledReason) {\n            process.stderr.write(\n              chalk.yellow(`${disabledReason}\\n--rc flag ignored.\\n`),\n            )\n          }\n        }\n\n        // Check for pending agent memory snapshot updates (only for --agent mode, ant-only)\n        if (\n          feature('AGENT_MEMORY_SNAPSHOT') &&\n          mainThreadAgentDefinition &&\n          isCustomAgent(mainThreadAgentDefinition) &&\n          mainThreadAgentDefinition.memory &&\n          mainThreadAgentDefinition.pendingSnapshotUpdate\n        ) {\n          const agentDef = mainThreadAgentDefinition\n          const choice = await launchSnapshotUpdateDialog(root, {\n            agentType: agentDef.agentType,\n            scope: agentDef.memory!,\n            snapshotTimestamp:\n              agentDef.pendingSnapshotUpdate!.snapshotTimestamp,\n          })\n          if (choice === 'merge') {\n            const { buildMergePrompt } = await import(\n              './components/agents/SnapshotUpdateDialog.js'\n            )\n            const mergePrompt = buildMergePrompt(\n              agentDef.agentType,\n              agentDef.memory!,\n            )\n            inputPrompt = inputPrompt\n              ? `${mergePrompt}\\n\\n${inputPrompt}`\n              : mergePrompt\n          }\n          agentDef.pendingSnapshotUpdate = undefined\n        }\n\n        // Skip executing /login if we just completed onboarding for it\n        if (onboardingShown && prompt?.trim().toLowerCase() === '/login') {\n          prompt = ''\n        }\n\n        if (onboardingShown) {\n          // Refresh auth-dependent services now that the user has logged in during onboarding.\n          // Keep in sync with the post-login logic in src/commands/login.tsx\n          void refreshRemoteManagedSettings()\n          void refreshPolicyLimits()\n          // Clear user data cache BEFORE GrowthBook refresh so it picks up fresh credentials\n          resetUserCache()\n          // Refresh GrowthBook after login to get updated feature flags (e.g., for claude.ai MCPs)\n          refreshGrowthBookAfterAuthChange()\n          // Clear any stale trusted device token then enroll for Remote Control.\n          // Both self-gate on tengu_sessions_elevated_auth_enforcement internally\n          // — enrollTrustedDevice() via checkGate_CACHED_OR_BLOCKING (awaits\n          // the GrowthBook reinit above), clearTrustedDeviceToken() via the\n          // sync cached check (acceptable since clear is idempotent).\n          void import('./bridge/trustedDevice.js').then(m => {\n            m.clearTrustedDeviceToken()\n            return m.enrollTrustedDevice()\n          })\n        }\n\n        // Validate that the active token's org matches forceLoginOrgUUID (if set\n        // in managed settings). Runs after onboarding so managed settings and\n        // login state are fully loaded.\n        const orgValidation = await validateForceLoginOrg()\n        if (!orgValidation.valid) {\n          await exitWithError(root, orgValidation.message)\n        }\n      }\n\n      // If gracefulShutdown was initiated (e.g., user rejected trust dialog),\n      // process.exitCode will be set. Skip all subsequent operations that could\n      // trigger code execution before the process exits (e.g. we don't want apiKeyHelper\n      // to run if trust was not established).\n      if (process.exitCode !== undefined) {\n        logForDebugging(\n          'Graceful shutdown initiated, skipping further initialization',\n        )\n        return\n      }\n\n      // Initialize LSP manager AFTER trust is established (or in non-interactive mode\n      // where trust is implicit). This prevents plugin LSP servers from executing\n      // code in untrusted directories before user consent.\n      // Must be after inline plugins are set (if any) so --plugin-dir LSP servers are included.\n      initializeLspServerManager()\n\n      // Show settings validation errors after trust is established\n      // MCP config errors don't block settings from loading, so exclude them\n      if (!isNonInteractiveSession) {\n        const { errors } = getSettingsWithErrors()\n        const nonMcpErrors = errors.filter(e => !e.mcpErrorMetadata)\n        if (nonMcpErrors.length > 0) {\n          await launchInvalidSettingsDialog(root, {\n            settingsErrors: nonMcpErrors,\n            onExit: () => gracefulShutdownSync(1),\n          })\n        }\n      }\n\n      // Check quota status, fast mode, passes eligibility, and bootstrap data\n      // after trust is established. These make API calls which could trigger\n      // apiKeyHelper execution.\n      // --bare / SIMPLE: skip — these are cache-warms for the REPL's\n      // first-turn responsiveness (quota, passes, fastMode, bootstrap data). Fast\n      // mode doesn't apply to the Agent SDK anyway (see getFastModeUnavailableReason).\n      const bgRefreshThrottleMs = getFeatureValue_CACHED_MAY_BE_STALE(\n        'tengu_cicada_nap_ms',\n        0,\n      )\n      const lastPrefetched = getGlobalConfig().startupPrefetchedAt ?? 0\n      const skipStartupPrefetches =\n        isBareMode() ||\n        (bgRefreshThrottleMs > 0 &&\n          Date.now() - lastPrefetched < bgRefreshThrottleMs)\n\n      if (!skipStartupPrefetches) {\n        const lastPrefetchedInfo =\n          lastPrefetched > 0\n            ? ` last ran ${Math.round((Date.now() - lastPrefetched) / 1000)}s ago`\n            : ''\n        logForDebugging(\n          `Starting background startup prefetches${lastPrefetchedInfo}`,\n        )\n\n        checkQuotaStatus().catch(error => logError(error))\n\n        // Fetch bootstrap data from the server and update all cache values.\n        void fetchBootstrapData()\n\n        // TODO: Consolidate other prefetches into a single bootstrap request.\n        void prefetchPassesEligibility()\n        if (\n          !getFeatureValue_CACHED_MAY_BE_STALE('tengu_miraculo_the_bard', false)\n        ) {\n          void prefetchFastModeStatus()\n        } else {\n          // Kill switch skips the network call, not org-policy enforcement.\n          // Resolve from cache so orgStatus doesn't stay 'pending' (which\n          // getFastModeUnavailableReason treats as permissive).\n          resolveFastModeStatusFromCache()\n        }\n        if (bgRefreshThrottleMs > 0) {\n          saveGlobalConfig(current => ({\n            ...current,\n            startupPrefetchedAt: Date.now(),\n          }))\n        }\n      } else {\n        logForDebugging(\n          `Skipping startup prefetches, last ran ${Math.round((Date.now() - lastPrefetched) / 1000)}s ago`,\n        )\n        // Resolve fast mode org status from cache (no network)\n        resolveFastModeStatusFromCache()\n      }\n\n      if (!isNonInteractiveSession) {\n        void refreshExampleCommands() // Pre-fetch example commands (runs git log, no API call)\n      }\n\n      // Resolve MCP configs (started early, overlaps with setup/trust dialog work)\n      const { servers: existingMcpConfigs } = await mcpConfigPromise\n      logForDebugging(\n        `[STARTUP] MCP configs resolved in ${mcpConfigResolvedMs}ms (awaited at +${Date.now() - mcpConfigStart}ms)`,\n      )\n      // CLI flag (--mcp-config) should override file-based configs, matching settings precedence\n      const allMcpConfigs = { ...existingMcpConfigs, ...dynamicMcpConfig }\n\n      // Separate SDK configs from regular MCP configs\n      const sdkMcpConfigs: Record<string, McpSdkServerConfig> = {}\n      const regularMcpConfigs: Record<string, ScopedMcpServerConfig> = {}\n\n      for (const [name, config] of Object.entries(allMcpConfigs)) {\n        const typedConfig = config as ScopedMcpServerConfig | McpSdkServerConfig\n        if (typedConfig.type === 'sdk') {\n          sdkMcpConfigs[name] = typedConfig as McpSdkServerConfig\n        } else {\n          regularMcpConfigs[name] = typedConfig as ScopedMcpServerConfig\n        }\n      }\n\n      profileCheckpoint('action_mcp_configs_loaded')\n\n      // Prefetch MCP resources after trust dialog (this is where execution happens).\n      // Interactive mode only: print mode defers connects until headlessStore exists\n      // and pushes per-server (below), so ToolSearch's pending-client handling works\n      // and one slow server doesn't block the batch.\n      const localMcpPromise = isNonInteractiveSession\n        ? Promise.resolve({ clients: [], tools: [], commands: [] })\n        : prefetchAllMcpResources(regularMcpConfigs)\n      const claudeaiMcpPromise = isNonInteractiveSession\n        ? Promise.resolve({ clients: [], tools: [], commands: [] })\n        : claudeaiConfigPromise.then(configs =>\n            Object.keys(configs).length > 0\n              ? prefetchAllMcpResources(configs)\n              : { clients: [], tools: [], commands: [] },\n          )\n      // Merge with dedup by name: each prefetchAllMcpResources call independently\n      // adds helper tools (ListMcpResourcesTool, ReadMcpResourceTool) via\n      // local dedup flags, so merging two calls can yield duplicates. print.ts\n      // already uniqBy's the final tool pool, but dedup here keeps appState clean.\n      const mcpPromise = Promise.all([\n        localMcpPromise,\n        claudeaiMcpPromise,\n      ]).then(([local, claudeai]) => ({\n        clients: [...local.clients, ...claudeai.clients],\n        tools: uniqBy([...local.tools, ...claudeai.tools], 'name'),\n        commands: uniqBy([...local.commands, ...claudeai.commands], 'name'),\n      }))\n\n      // Start hooks early so they run in parallel with MCP connections.\n      // Skip for initOnly/init/maintenance (handled separately), non-interactive\n      // (handled via setupTrigger), and resume/continue (conversationRecovery.ts\n      // fires 'resume' instead — without this guard, hooks fire TWICE on /resume\n      // and the second systemMessage clobbers the first. gh-30825)\n      const hooksPromise =\n        initOnly ||\n        init ||\n        maintenance ||\n        isNonInteractiveSession ||\n        options.continue ||\n        options.resume\n          ? null\n          : processSessionStartHooks('startup', {\n              agentType: mainThreadAgentDefinition?.agentType,\n              model: resolvedInitialModel,\n            })\n\n      // MCP never blocks REPL render OR turn 1 TTFT. useManageMCPConnections\n      // populates appState.mcp async as servers connect (connectToServer is\n      // memoized — the prefetch calls above and the hook converge on the same\n      // connections). getToolUseContext reads store.getState() fresh via\n      // computeTools(), so turn 1 sees whatever's connected by query time.\n      // Slow servers populate for turn 2+. Matches interactive-no-prompt\n      // behavior. Print mode: per-server push into headlessStore (below).\n      const hookMessages: Awaited<NonNullable<typeof hooksPromise>> = []\n      // Suppress transient unhandledRejection — the prefetch warms the\n      // memoized connectToServer cache but nobody awaits it in interactive.\n      mcpPromise.catch(() => {})\n\n      const mcpClients: Awaited<typeof mcpPromise>['clients'] = []\n      const mcpTools: Awaited<typeof mcpPromise>['tools'] = []\n      const mcpCommands: Awaited<typeof mcpPromise>['commands'] = []\n\n      let thinkingEnabled = shouldEnableThinkingByDefault()\n      let thinkingConfig: ThinkingConfig =\n        thinkingEnabled !== false ? { type: 'adaptive' } : { type: 'disabled' }\n\n      if (options.thinking === 'adaptive' || options.thinking === 'enabled') {\n        thinkingEnabled = true\n        thinkingConfig = { type: 'adaptive' }\n      } else if (options.thinking === 'disabled') {\n        thinkingEnabled = false\n        thinkingConfig = { type: 'disabled' }\n      } else {\n        const maxThinkingTokens = process.env.MAX_THINKING_TOKENS\n          ? parseInt(process.env.MAX_THINKING_TOKENS, 10)\n          : options.maxThinkingTokens\n        if (maxThinkingTokens !== undefined) {\n          if (maxThinkingTokens > 0) {\n            thinkingEnabled = true\n            thinkingConfig = {\n              type: 'enabled',\n              budgetTokens: maxThinkingTokens,\n            }\n          } else if (maxThinkingTokens === 0) {\n            thinkingEnabled = false\n            thinkingConfig = { type: 'disabled' }\n          }\n        }\n      }\n\n      logForDiagnosticsNoPII('info', 'started', {\n        version: MACRO.VERSION,\n        is_native_binary: isInBundledMode(),\n      })\n\n      registerCleanup(async () => {\n        logForDiagnosticsNoPII('info', 'exited')\n      })\n\n      void logTenguInit({\n        hasInitialPrompt: Boolean(prompt),\n        hasStdin: Boolean(inputPrompt),\n        verbose,\n        debug,\n        debugToStderr,\n        print: print ?? false,\n        outputFormat: outputFormat ?? 'text',\n        inputFormat: inputFormat ?? 'text',\n        numAllowedTools: allowedTools.length,\n        numDisallowedTools: disallowedTools.length,\n        mcpClientCount: Object.keys(allMcpConfigs).length,\n        worktreeEnabled,\n        skipWebFetchPreflight: getInitialSettings().skipWebFetchPreflight,\n        githubActionInputs: process.env.GITHUB_ACTION_INPUTS,\n        dangerouslySkipPermissionsPassed: dangerouslySkipPermissions ?? false,\n        permissionMode,\n        modeIsBypass: permissionMode === 'bypassPermissions',\n        allowDangerouslySkipPermissionsPassed: allowDangerouslySkipPermissions,\n        systemPromptFlag: systemPrompt\n          ? options.systemPromptFile\n            ? 'file'\n            : 'flag'\n          : undefined,\n        appendSystemPromptFlag: appendSystemPrompt\n          ? options.appendSystemPromptFile\n            ? 'file'\n            : 'flag'\n          : undefined,\n        thinkingConfig,\n        assistantActivationPath:\n          feature('KAIROS') && kairosEnabled\n            ? assistantModule?.getAssistantActivationPath()\n            : undefined,\n      })\n\n      // Log context metrics once at initialization\n      void logContextMetrics(regularMcpConfigs, toolPermissionContext)\n\n      void logPermissionContextForAnts(null, 'initialization')\n\n      logManagedSettings()\n\n      // Register PID file for concurrent-session detection (~/.claude/sessions/)\n      // and fire multi-clauding telemetry. Lives here (not init.ts) so only the\n      // REPL path registers — not subcommands like `claude doctor`. Chained:\n      // count must run after register's write completes or it misses our own file.\n      void registerSession().then(registered => {\n        if (!registered) return\n        if (sessionNameArg) {\n          void updateSessionName(sessionNameArg)\n        }\n        void countConcurrentSessions().then(count => {\n          if (count >= 2) {\n            logEvent('tengu_concurrent_sessions', { num_sessions: count })\n          }\n        })\n      })\n\n      // Initialize versioned plugins system (triggers V1→V2 migration if\n      // needed). Then run orphan GC, THEN warm the Grep/Glob exclusion cache.\n      // Sequencing matters: the warmup scans disk for .orphaned_at markers,\n      // so it must see the GC's Pass 1 (remove markers from reinstalled\n      // versions) and Pass 2 (stamp unmarked orphans) already applied. The\n      // warm also lands before autoupdate (fires on first submit in REPL)\n      // can orphan this session's active version underneath us.\n      // --bare / SIMPLE: skip plugin version sync + orphan cleanup. These\n      // are install/upgrade bookkeeping that scripted calls don't need —\n      // the next interactive session will reconcile. The await here was\n      // blocking -p on a marketplace round-trip.\n      if (isBareMode()) {\n        // skip — no-op\n      } else if (isNonInteractiveSession) {\n        // In headless mode, await to ensure plugin sync completes before CLI exits\n        await initializeVersionedPlugins()\n        profileCheckpoint('action_after_plugins_init')\n        void cleanupOrphanedPluginVersionsInBackground().then(() =>\n          getGlobExclusionsForPluginCache(),\n        )\n      } else {\n        // In interactive mode, fire-and-forget — this is purely bookkeeping\n        // that doesn't affect runtime behavior of the current session\n        void initializeVersionedPlugins().then(async () => {\n          profileCheckpoint('action_after_plugins_init')\n          await cleanupOrphanedPluginVersionsInBackground()\n          void getGlobExclusionsForPluginCache()\n        })\n      }\n\n      const setupTrigger =\n        initOnly || init ? 'init' : maintenance ? 'maintenance' : null\n      if (initOnly) {\n        applyConfigEnvironmentVariables()\n        await processSetupHooks('init', { forceSyncExecution: true })\n        await processSessionStartHooks('startup', { forceSyncExecution: true })\n        gracefulShutdownSync(0)\n        return\n      }\n\n      // --print mode\n      if (isNonInteractiveSession) {\n        if (outputFormat === 'stream-json' || outputFormat === 'json') {\n          setHasFormattedOutput(true)\n        }\n\n        // Apply full environment variables in print mode since trust dialog is bypassed\n        // This includes potentially dangerous environment variables from untrusted sources\n        // but print mode is considered trusted (as documented in help text)\n        applyConfigEnvironmentVariables()\n\n        // Initialize telemetry after env vars are applied so OTEL endpoint env vars and\n        // otelHeadersHelper (which requires trust to execute) are available.\n        initializeTelemetryAfterTrust()\n\n        // Kick SessionStart hooks now so the subprocess spawn overlaps with\n        // MCP connect + plugin init + print.ts import below. loadInitialMessages\n        // joins this at print.ts:4397. Guarded same as loadInitialMessages —\n        // continue/resume/teleport paths don't fire startup hooks (or fire them\n        // conditionally inside the resume branch, where this promise is\n        // undefined and the ?? fallback runs). Also skip when setupTrigger is\n        // set — those paths run setup hooks first (print.ts:544), and session\n        // start hooks must wait until setup completes.\n        const sessionStartHooksPromise =\n          options.continue || options.resume || teleport || setupTrigger\n            ? undefined\n            : processSessionStartHooks('startup')\n        // Suppress transient unhandledRejection if this rejects before\n        // loadInitialMessages awaits it. Downstream await still observes the\n        // rejection — this just prevents the spurious global handler fire.\n        sessionStartHooksPromise?.catch(() => {})\n\n        profileCheckpoint('before_validateForceLoginOrg')\n        // Validate org restriction for non-interactive sessions\n        const orgValidation = await validateForceLoginOrg()\n        if (!orgValidation.valid) {\n          process.stderr.write(orgValidation.message + '\\n')\n          process.exit(1)\n        }\n\n        // Headless mode supports all prompt commands and some local commands\n        // If disableSlashCommands is true, return empty array\n        const commandsHeadless = disableSlashCommands\n          ? []\n          : commands.filter(\n              command =>\n                (command.type === 'prompt' && !command.disableNonInteractive) ||\n                (command.type === 'local' && command.supportsNonInteractive),\n            )\n\n        const defaultState = getDefaultAppState()\n        const headlessInitialState: AppState = {\n          ...defaultState,\n          mcp: {\n            ...defaultState.mcp,\n            clients: mcpClients,\n            commands: mcpCommands,\n            tools: mcpTools,\n          },\n          toolPermissionContext,\n          effortValue:\n            parseEffortValue(options.effort) ?? getInitialEffortSetting(),\n          ...(isFastModeEnabled() && {\n            fastMode: getInitialFastModeSetting(effectiveModel ?? null),\n          }),\n          ...(isAdvisorEnabled() && advisorModel && { advisorModel }),\n          // kairosEnabled gates the async fire-and-forget path in\n          // executeForkedSlashCommand (processSlashCommand.tsx:132) and\n          // AgentTool's shouldRunAsync. The REPL initialState sets this at\n          // ~3459; headless was defaulting to false, so the daemon child's\n          // scheduled tasks and Agent-tool calls ran synchronously — N\n          // overdue cron tasks on spawn = N serial subagent turns blocking\n          // user input. Computed at :1620, well before this branch.\n          ...(feature('KAIROS') ? { kairosEnabled } : {}),\n        }\n\n        // Init app state\n        const headlessStore = createStore(\n          headlessInitialState,\n          onChangeAppState,\n        )\n\n        // Check if bypassPermissions should be disabled based on Statsig gate\n        // This runs in parallel to the code below, to avoid blocking the main loop.\n        if (\n          toolPermissionContext.mode === 'bypassPermissions' ||\n          allowDangerouslySkipPermissions\n        ) {\n          void checkAndDisableBypassPermissions(toolPermissionContext)\n        }\n\n        // Async check of auto mode gate — corrects state and disables auto if needed.\n        // Gated on TRANSCRIPT_CLASSIFIER (not USER_TYPE) so GrowthBook kill switch runs for external builds too.\n        if (feature('TRANSCRIPT_CLASSIFIER')) {\n          void verifyAutoModeGateAccess(\n            toolPermissionContext,\n            headlessStore.getState().fastMode,\n          ).then(({ updateContext }) => {\n            headlessStore.setState(prev => {\n              const nextCtx = updateContext(prev.toolPermissionContext)\n              if (nextCtx === prev.toolPermissionContext) return prev\n              return { ...prev, toolPermissionContext: nextCtx }\n            })\n          })\n        }\n\n        // Set global state for session persistence\n        if (options.sessionPersistence === false) {\n          setSessionPersistenceDisabled(true)\n        }\n\n        // Store SDK betas in global state for context window calculation\n        // Only store allowed betas (filters by allowlist and subscriber status)\n        setSdkBetas(filterAllowedSdkBetas(betas))\n\n        // Print-mode MCP: per-server incremental push into headlessStore.\n        // Mirrors useManageMCPConnections — push pending first (so ToolSearch's\n        // pending-check at ToolSearchTool.ts:334 sees them), then replace with\n        // connected/failed as each server settles.\n        const connectMcpBatch = (\n          configs: Record<string, ScopedMcpServerConfig>,\n          label: string,\n        ): Promise<void> => {\n          if (Object.keys(configs).length === 0) return Promise.resolve()\n          headlessStore.setState(prev => ({\n            ...prev,\n            mcp: {\n              ...prev.mcp,\n              clients: [\n                ...prev.mcp.clients,\n                ...Object.entries(configs).map(([name, config]) => ({\n                  name,\n                  type: 'pending' as const,\n                  config,\n                })),\n              ],\n            },\n          }))\n          return getMcpToolsCommandsAndResources(\n            ({ client, tools, commands }) => {\n              headlessStore.setState(prev => ({\n                ...prev,\n                mcp: {\n                  ...prev.mcp,\n                  clients: prev.mcp.clients.some(c => c.name === client.name)\n                    ? prev.mcp.clients.map(c =>\n                        c.name === client.name ? client : c,\n                      )\n                    : [...prev.mcp.clients, client],\n                  tools: uniqBy([...prev.mcp.tools, ...tools], 'name'),\n                  commands: uniqBy([...prev.mcp.commands, ...commands], 'name'),\n                },\n              }))\n            },\n            configs,\n          ).catch(err =>\n            logForDebugging(`[MCP] ${label} connect error: ${err}`),\n          )\n        }\n        // Await all MCP configs — print mode is often single-turn, so\n        // \"late-connecting servers visible next turn\" doesn't help. SDK init\n        // message and turn-1 tool list both need configured MCP tools present.\n        // Zero-server case is free via the early return in connectMcpBatch.\n        // Connectors parallelize inside getMcpToolsCommandsAndResources\n        // (processBatched with Promise.all). claude.ai is awaited too — its\n        // fetch was kicked off early (line ~2558) so only residual time blocks\n        // here. --bare skips claude.ai entirely for perf-sensitive scripts.\n        profileCheckpoint('before_connectMcp')\n        await connectMcpBatch(regularMcpConfigs, 'regular')\n        profileCheckpoint('after_connectMcp')\n        // Dedup: suppress plugin MCP servers that duplicate a claude.ai\n        // connector (connector wins), then connect claude.ai servers.\n        // Bounded wait — #23725 made this blocking so single-turn -p sees\n        // connectors, but with 40+ slow connectors tengu_startup_perf p99\n        // climbed to 76s. If fetch+connect doesn't finish in time, proceed;\n        // the promise keeps running and updates headlessStore in the\n        // background so turn 2+ still sees connectors.\n        const CLAUDE_AI_MCP_TIMEOUT_MS = 5_000\n        const claudeaiConnect = claudeaiConfigPromise.then(claudeaiConfigs => {\n          if (Object.keys(claudeaiConfigs).length > 0) {\n            const claudeaiSigs = new Set<string>()\n            for (const config of Object.values(claudeaiConfigs)) {\n              const sig = getMcpServerSignature(config)\n              if (sig) claudeaiSigs.add(sig)\n            }\n            const suppressed = new Set<string>()\n            for (const [name, config] of Object.entries(regularMcpConfigs)) {\n              if (!name.startsWith('plugin:')) continue\n              const sig = getMcpServerSignature(config)\n              if (sig && claudeaiSigs.has(sig)) suppressed.add(name)\n            }\n            if (suppressed.size > 0) {\n              logForDebugging(\n                `[MCP] Lazy dedup: suppressing ${suppressed.size} plugin server(s) that duplicate claude.ai connectors: ${[...suppressed].join(', ')}`,\n              )\n              // Disconnect before filtering from state. Only connected\n              // servers need cleanup — clearServerCache on a never-connected\n              // server triggers a real connect just to kill it (memoize\n              // cache-miss path, see useManageMCPConnections.ts:870).\n              for (const c of headlessStore.getState().mcp.clients) {\n                if (!suppressed.has(c.name) || c.type !== 'connected') continue\n                c.client.onclose = undefined\n                void clearServerCache(c.name, c.config).catch(() => {})\n              }\n              headlessStore.setState(prev => {\n                let { clients, tools, commands, resources } = prev.mcp\n                clients = clients.filter(c => !suppressed.has(c.name))\n                tools = tools.filter(\n                  t => !t.mcpInfo || !suppressed.has(t.mcpInfo.serverName),\n                )\n                for (const name of suppressed) {\n                  commands = excludeCommandsByServer(commands, name)\n                  resources = excludeResourcesByServer(resources, name)\n                }\n                return {\n                  ...prev,\n                  mcp: { ...prev.mcp, clients, tools, commands, resources },\n                }\n              })\n            }\n          }\n          // Suppress claude.ai connectors that duplicate an enabled\n          // manual server (URL-signature match). Plugin dedup above only\n          // handles `plugin:*` keys; this catches manual `.mcp.json` entries.\n          // plugin:* must be excluded here — step 1 already suppressed\n          // those (claude.ai wins); leaving them in suppresses the\n          // connector too, and neither survives (gh-39974).\n          const nonPluginConfigs = pickBy(\n            regularMcpConfigs,\n            (_, n) => !n.startsWith('plugin:'),\n          )\n          const { servers: dedupedClaudeAi } = dedupClaudeAiMcpServers(\n            claudeaiConfigs,\n            nonPluginConfigs,\n          )\n          return connectMcpBatch(dedupedClaudeAi, 'claudeai')\n        })\n        let claudeaiTimer: ReturnType<typeof setTimeout> | undefined\n        const claudeaiTimedOut = await Promise.race([\n          claudeaiConnect.then(() => false),\n          new Promise<boolean>(resolve => {\n            claudeaiTimer = setTimeout(\n              r => r(true),\n              CLAUDE_AI_MCP_TIMEOUT_MS,\n              resolve,\n            )\n          }),\n        ])\n        if (claudeaiTimer) clearTimeout(claudeaiTimer)\n        if (claudeaiTimedOut) {\n          logForDebugging(\n            `[MCP] claude.ai connectors not ready after ${CLAUDE_AI_MCP_TIMEOUT_MS}ms — proceeding; background connection continues`,\n          )\n        }\n        profileCheckpoint('after_connectMcp_claudeai')\n\n        // In headless mode, start deferred prefetches immediately (no user typing delay)\n        // --bare / SIMPLE: startDeferredPrefetches early-returns internally.\n        // backgroundHousekeeping (initExtractMemories, pruneShellSnapshots,\n        // cleanupOldMessageFiles) and sdkHeapDumpMonitor are all bookkeeping\n        // that scripted calls don't need — the next interactive session reconciles.\n        if (!isBareMode()) {\n          startDeferredPrefetches()\n          void import('./utils/backgroundHousekeeping.js').then(m =>\n            m.startBackgroundHousekeeping(),\n          )\n          if (\"external\" === 'ant') {\n            void import('./utils/sdkHeapDumpMonitor.js').then(m =>\n              m.startSdkMemoryMonitor(),\n            )\n          }\n        }\n\n        logSessionTelemetry()\n        profileCheckpoint('before_print_import')\n        const { runHeadless } = await import('src/cli/print.js')\n        profileCheckpoint('after_print_import')\n        void runHeadless(\n          inputPrompt,\n          () => headlessStore.getState(),\n          headlessStore.setState,\n          commandsHeadless,\n          tools,\n          sdkMcpConfigs,\n          agentDefinitions.activeAgents,\n          {\n            continue: options.continue,\n            resume: options.resume,\n            verbose: verbose,\n            outputFormat: outputFormat,\n            jsonSchema,\n            permissionPromptToolName: options.permissionPromptTool,\n            allowedTools,\n            thinkingConfig,\n            maxTurns: options.maxTurns,\n            maxBudgetUsd: options.maxBudgetUsd,\n            taskBudget: options.taskBudget\n              ? { total: options.taskBudget }\n              : undefined,\n            systemPrompt,\n            appendSystemPrompt,\n            userSpecifiedModel: effectiveModel,\n            fallbackModel: userSpecifiedFallbackModel,\n            teleport,\n            sdkUrl,\n            replayUserMessages: effectiveReplayUserMessages,\n            includePartialMessages: effectiveIncludePartialMessages,\n            forkSession: options.forkSession || false,\n            resumeSessionAt: options.resumeSessionAt || undefined,\n            rewindFiles: options.rewindFiles,\n            enableAuthStatus: options.enableAuthStatus,\n            agent: agentCli,\n            workload: options.workload,\n            setupTrigger: setupTrigger ?? undefined,\n            sessionStartHooksPromise,\n          },\n        )\n        return\n      }\n\n      // Log model config at startup\n      logEvent('tengu_startup_manual_model_config', {\n        cli_flag:\n          options.model as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        env_var: process.env\n          .ANTHROPIC_MODEL as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        settings_file: (getInitialSettings() || {})\n          .model as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        subscriptionType:\n          getSubscriptionType() as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        agent:\n          agentSetting as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      })\n\n      // Get deprecation warning for the initial model (resolvedInitialModel computed earlier for hooks parallelization)\n      const deprecationWarning =\n        getModelDeprecationWarning(resolvedInitialModel)\n\n      // Build initial notification queue\n      const initialNotifications: Array<{\n        key: string\n        text: string\n        color?: 'warning'\n        priority: 'high'\n      }> = []\n      if (permissionModeNotification) {\n        initialNotifications.push({\n          key: 'permission-mode-notification',\n          text: permissionModeNotification,\n          priority: 'high',\n        })\n      }\n      if (deprecationWarning) {\n        initialNotifications.push({\n          key: 'model-deprecation-warning',\n          text: deprecationWarning,\n          color: 'warning',\n          priority: 'high',\n        })\n      }\n      if (overlyBroadBashPermissions.length > 0) {\n        const displayList = uniq(\n          overlyBroadBashPermissions.map(p => p.ruleDisplay),\n        )\n        const displays = displayList.join(', ')\n        const sources = uniq(\n          overlyBroadBashPermissions.map(p => p.sourceDisplay),\n        ).join(', ')\n        const n = displayList.length\n        initialNotifications.push({\n          key: 'overly-broad-bash-notification',\n          text: `${displays} allow ${plural(n, 'rule')} from ${sources} ${plural(n, 'was', 'were')} ignored \\u2014 not available for Ants, please use auto-mode instead`,\n          color: 'warning',\n          priority: 'high',\n        })\n      }\n\n      const effectiveToolPermissionContext = {\n        ...toolPermissionContext,\n        mode:\n          isAgentSwarmsEnabled() && getTeammateUtils().isPlanModeRequired()\n            ? ('plan' as const)\n            : toolPermissionContext.mode,\n      }\n      // All startup opt-in paths (--tools, --brief, defaultView) have fired\n      // above; initialIsBriefOnly just reads the resulting state.\n      const initialIsBriefOnly =\n        feature('KAIROS') || feature('KAIROS_BRIEF') ? getUserMsgOptIn() : false\n      const fullRemoteControl =\n        remoteControl || getRemoteControlAtStartup() || kairosEnabled\n      let ccrMirrorEnabled = false\n      if (feature('CCR_MIRROR') && !fullRemoteControl) {\n        /* eslint-disable @typescript-eslint/no-require-imports */\n        const { isCcrMirrorEnabled } =\n          require('./bridge/bridgeEnabled.js') as typeof import('./bridge/bridgeEnabled.js')\n        /* eslint-enable @typescript-eslint/no-require-imports */\n        ccrMirrorEnabled = isCcrMirrorEnabled()\n      }\n\n      const initialState: AppState = {\n        settings: getInitialSettings(),\n        tasks: {},\n        agentNameRegistry: new Map(),\n        verbose: verbose ?? getGlobalConfig().verbose ?? false,\n        mainLoopModel: initialMainLoopModel,\n        mainLoopModelForSession: null,\n        isBriefOnly: initialIsBriefOnly,\n        expandedView: getGlobalConfig().showSpinnerTree\n          ? 'teammates'\n          : getGlobalConfig().showExpandedTodos\n            ? 'tasks'\n            : 'none',\n        showTeammateMessagePreview: isAgentSwarmsEnabled() ? false : undefined,\n        selectedIPAgentIndex: -1,\n        coordinatorTaskIndex: -1,\n        viewSelectionMode: 'none',\n        footerSelection: null,\n        toolPermissionContext: effectiveToolPermissionContext,\n        agent: mainThreadAgentDefinition?.agentType,\n        agentDefinitions,\n        mcp: {\n          clients: [],\n          tools: [],\n          commands: [],\n          resources: {},\n          pluginReconnectKey: 0,\n        },\n        plugins: {\n          enabled: [],\n          disabled: [],\n          commands: [],\n          errors: [],\n          installationStatus: {\n            marketplaces: [],\n            plugins: [],\n          },\n          needsRefresh: false,\n        },\n        statusLineText: undefined,\n        kairosEnabled,\n        remoteSessionUrl: undefined,\n        remoteConnectionStatus: 'connecting',\n        remoteBackgroundTaskCount: 0,\n        replBridgeEnabled: fullRemoteControl || ccrMirrorEnabled,\n        replBridgeExplicit: remoteControl,\n        replBridgeOutboundOnly: ccrMirrorEnabled,\n        replBridgeConnected: false,\n        replBridgeSessionActive: false,\n        replBridgeReconnecting: false,\n        replBridgeConnectUrl: undefined,\n        replBridgeSessionUrl: undefined,\n        replBridgeEnvironmentId: undefined,\n        replBridgeSessionId: undefined,\n        replBridgeError: undefined,\n        replBridgeInitialName: remoteControlName,\n        showRemoteCallout: false,\n        notifications: {\n          current: null,\n          queue: initialNotifications,\n        },\n        elicitation: {\n          queue: [],\n        },\n        todos: {},\n        remoteAgentTaskSuggestions: [],\n        fileHistory: {\n          snapshots: [],\n          trackedFiles: new Set(),\n          snapshotSequence: 0,\n        },\n        attribution: createEmptyAttributionState(),\n        thinkingEnabled,\n        promptSuggestionEnabled: shouldEnablePromptSuggestion(),\n        sessionHooks: new Map(),\n        inbox: {\n          messages: [],\n        },\n        promptSuggestion: {\n          text: null,\n          promptId: null,\n          shownAt: 0,\n          acceptedAt: 0,\n          generationRequestId: null,\n        },\n        speculation: IDLE_SPECULATION_STATE,\n        speculationSessionTimeSavedMs: 0,\n        skillImprovement: {\n          suggestion: null,\n        },\n        workerSandboxPermissions: {\n          queue: [],\n          selectedIndex: 0,\n        },\n        pendingWorkerRequest: null,\n        pendingSandboxRequest: null,\n        authVersion: 0,\n        initialMessage: inputPrompt\n          ? { message: createUserMessage({ content: String(inputPrompt) }) }\n          : null,\n        effortValue:\n          parseEffortValue(options.effort) ?? getInitialEffortSetting(),\n        activeOverlays: new Set<string>(),\n        fastMode: getInitialFastModeSetting(resolvedInitialModel),\n        ...(isAdvisorEnabled() && advisorModel && { advisorModel }),\n        // Compute teamContext synchronously to avoid useEffect setState during render.\n        // KAIROS: assistantTeamContext takes precedence — set earlier in the\n        // KAIROS block so Agent(name: \"foo\") can spawn in-process teammates\n        // without TeamCreate. computeInitialTeamContext() is for tmux-spawned\n        // teammates reading their own identity, not the assistant-mode leader.\n        teamContext: feature('KAIROS')\n          ? (assistantTeamContext ?? computeInitialTeamContext?.())\n          : computeInitialTeamContext?.(),\n      }\n\n      // Add CLI initial prompt to history\n      if (inputPrompt) {\n        addToHistory(String(inputPrompt))\n      }\n\n      const initialTools = mcpTools\n\n      // Increment numStartups synchronously — first-render readers like\n      // shouldShowEffortCallout (via useState initializer) need the updated\n      // value before setImmediate fires. Defer only telemetry.\n      saveGlobalConfig(current => ({\n        ...current,\n        numStartups: (current.numStartups ?? 0) + 1,\n      }))\n      setImmediate(() => {\n        void logStartupTelemetry()\n        logSessionTelemetry()\n      })\n\n      // Set up per-turn session environment data uploader (ant-only build).\n      // Default-enabled for all ant users when working in an Anthropic-owned\n      // repo. Captures git/filesystem state (NOT transcripts) at each turn so\n      // environments can be recreated at any user message index. Gating:\n      //   - Build-time: this import is stubbed in external builds.\n      //   - Runtime: uploader checks github.com/anthropics/* remote + gcloud auth.\n      //   - Safety: CLAUDE_CODE_DISABLE_SESSION_DATA_UPLOAD=1 bypasses (tests set this).\n      // Import is dynamic + async to avoid adding startup latency.\n      const sessionUploaderPromise =\n        \"external\" === 'ant'\n          ? import('./utils/sessionDataUploader.js')\n          : null\n\n      // Defer session uploader resolution to the onTurnComplete callback to avoid\n      // adding a new top-level await in main.tsx (performance-critical path).\n      // The per-turn auth logic in sessionDataUploader.ts handles unauthenticated\n      // state gracefully (re-checks each turn, so auth recovery mid-session works).\n      const uploaderReady = sessionUploaderPromise\n        ? sessionUploaderPromise\n            .then(mod => mod.createSessionTurnUploader())\n            .catch(() => null)\n        : null\n\n      const sessionConfig = {\n        debug: debug || debugToStderr,\n        commands: [...commands, ...mcpCommands],\n        initialTools,\n        mcpClients,\n        autoConnectIdeFlag: ide,\n        mainThreadAgentDefinition,\n        disableSlashCommands,\n        dynamicMcpConfig,\n        strictMcpConfig,\n        systemPrompt,\n        appendSystemPrompt,\n        taskListId,\n        thinkingConfig,\n        ...(uploaderReady && {\n          onTurnComplete: (messages: MessageType[]) => {\n            void uploaderReady.then(uploader => uploader?.(messages))\n          },\n        }),\n      }\n\n      // Shared context for processResumedConversation calls\n      const resumeContext = {\n        modeApi: coordinatorModeModule,\n        mainThreadAgentDefinition,\n        agentDefinitions,\n        currentCwd,\n        cliAgents,\n        initialState,\n      }\n\n      if (options.continue) {\n        // Continue the most recent conversation directly\n        let resumeSucceeded = false\n        try {\n          const resumeStart = performance.now()\n\n          // Clear stale caches before resuming to ensure fresh file/skill discovery\n          const { clearSessionCaches } = await import(\n            './commands/clear/caches.js'\n          )\n          clearSessionCaches()\n\n          const result = await loadConversationForResume(\n            undefined /* sessionId */,\n            undefined /* sourceFile */,\n          )\n          if (!result) {\n            logEvent('tengu_continue', {\n              success: false,\n            })\n            return await exitWithError(\n              root,\n              'No conversation found to continue',\n            )\n          }\n\n          const loaded = await processResumedConversation(\n            result,\n            {\n              forkSession: !!options.forkSession,\n              includeAttribution: true,\n              transcriptPath: result.fullPath,\n            },\n            resumeContext,\n          )\n\n          if (loaded.restoredAgentDef) {\n            mainThreadAgentDefinition = loaded.restoredAgentDef\n          }\n\n          maybeActivateProactive(options)\n          maybeActivateBrief(options)\n\n          logEvent('tengu_continue', {\n            success: true,\n            resume_duration_ms: Math.round(performance.now() - resumeStart),\n          })\n          resumeSucceeded = true\n\n          await launchRepl(\n            root,\n            { getFpsMetrics, stats, initialState: loaded.initialState },\n            {\n              ...sessionConfig,\n              mainThreadAgentDefinition:\n                loaded.restoredAgentDef ?? mainThreadAgentDefinition,\n              initialMessages: loaded.messages,\n              initialFileHistorySnapshots: loaded.fileHistorySnapshots,\n              initialContentReplacements: loaded.contentReplacements,\n              initialAgentName: loaded.agentName,\n              initialAgentColor: loaded.agentColor,\n            },\n            renderAndRun,\n          )\n        } catch (error) {\n          if (!resumeSucceeded) {\n            logEvent('tengu_continue', {\n              success: false,\n            })\n          }\n          logError(error)\n          process.exit(1)\n        }\n      } else if (feature('DIRECT_CONNECT') && _pendingConnect?.url) {\n        // `claude connect <url>` — full interactive TUI connected to a remote server\n        let directConnectConfig\n        try {\n          const session = await createDirectConnectSession({\n            serverUrl: _pendingConnect.url,\n            authToken: _pendingConnect.authToken,\n            cwd: getOriginalCwd(),\n            dangerouslySkipPermissions:\n              _pendingConnect.dangerouslySkipPermissions,\n          })\n          if (session.workDir) {\n            setOriginalCwd(session.workDir)\n            setCwdState(session.workDir)\n          }\n          setDirectConnectServerUrl(_pendingConnect.url)\n          directConnectConfig = session.config\n        } catch (err) {\n          return await exitWithError(\n            root,\n            err instanceof DirectConnectError ? err.message : String(err),\n            () => gracefulShutdown(1),\n          )\n        }\n\n        const connectInfoMessage = createSystemMessage(\n          `Connected to server at ${_pendingConnect.url}\\nSession: ${directConnectConfig.sessionId}`,\n          'info',\n        )\n\n        await launchRepl(\n          root,\n          { getFpsMetrics, stats, initialState },\n          {\n            debug: debug || debugToStderr,\n            commands,\n            initialTools: [],\n            initialMessages: [connectInfoMessage],\n            mcpClients: [],\n            autoConnectIdeFlag: ide,\n            mainThreadAgentDefinition,\n            disableSlashCommands,\n            directConnectConfig,\n            thinkingConfig,\n          },\n          renderAndRun,\n        )\n        return\n      } else if (feature('SSH_REMOTE') && _pendingSSH?.host) {\n        // `claude ssh <host> [dir]` — probe remote, deploy binary if needed,\n        // spawn ssh with unix-socket -R forward to a local auth proxy, hand\n        // the REPL an SSHSession. Tools run remotely, UI renders locally.\n        // `--local` skips probe/deploy/ssh and spawns the current binary\n        // directly with the same env — e2e test of the proxy/auth plumbing.\n        const { createSSHSession, createLocalSSHSession, SSHSessionError } =\n          await import('./ssh/createSSHSession.js')\n        let sshSession\n        try {\n          if (_pendingSSH.local) {\n            process.stderr.write('Starting local ssh-proxy test session...\\n')\n            sshSession = createLocalSSHSession({\n              cwd: _pendingSSH.cwd,\n              permissionMode: _pendingSSH.permissionMode,\n              dangerouslySkipPermissions:\n                _pendingSSH.dangerouslySkipPermissions,\n            })\n          } else {\n            process.stderr.write(`Connecting to ${_pendingSSH.host}…\\n`)\n            // In-place progress: \\r + EL0 (erase to end of line). Final \\n on\n            // success so the next message lands on a fresh line. No-op when\n            // stderr isn't a TTY (piped/redirected) — \\r would just emit noise.\n            const isTTY = process.stderr.isTTY\n            let hadProgress = false\n            sshSession = await createSSHSession(\n              {\n                host: _pendingSSH.host,\n                cwd: _pendingSSH.cwd,\n                localVersion: MACRO.VERSION,\n                permissionMode: _pendingSSH.permissionMode,\n                dangerouslySkipPermissions:\n                  _pendingSSH.dangerouslySkipPermissions,\n                extraCliArgs: _pendingSSH.extraCliArgs,\n              },\n              isTTY\n                ? {\n                    onProgress: msg => {\n                      hadProgress = true\n                      process.stderr.write(`\\r  ${msg}\\x1b[K`)\n                    },\n                  }\n                : {},\n            )\n            if (hadProgress) process.stderr.write('\\n')\n          }\n          setOriginalCwd(sshSession.remoteCwd)\n          setCwdState(sshSession.remoteCwd)\n          setDirectConnectServerUrl(\n            _pendingSSH.local ? 'local' : _pendingSSH.host,\n          )\n        } catch (err) {\n          return await exitWithError(\n            root,\n            err instanceof SSHSessionError ? err.message : String(err),\n            () => gracefulShutdown(1),\n          )\n        }\n\n        const sshInfoMessage = createSystemMessage(\n          _pendingSSH.local\n            ? `Local ssh-proxy test session\\ncwd: ${sshSession.remoteCwd}\\nAuth: unix socket → local proxy`\n            : `SSH session to ${_pendingSSH.host}\\nRemote cwd: ${sshSession.remoteCwd}\\nAuth: unix socket -R → local proxy`,\n          'info',\n        )\n\n        await launchRepl(\n          root,\n          { getFpsMetrics, stats, initialState },\n          {\n            debug: debug || debugToStderr,\n            commands,\n            initialTools: [],\n            initialMessages: [sshInfoMessage],\n            mcpClients: [],\n            autoConnectIdeFlag: ide,\n            mainThreadAgentDefinition,\n            disableSlashCommands,\n            sshSession,\n            thinkingConfig,\n          },\n          renderAndRun,\n        )\n        return\n      } else if (\n        feature('KAIROS') &&\n        _pendingAssistantChat &&\n        (_pendingAssistantChat.sessionId || _pendingAssistantChat.discover)\n      ) {\n        // `claude assistant [sessionId]` — REPL as a pure viewer client\n        // of a remote assistant session. The agentic loop runs remotely; this\n        // process streams live events and POSTs messages. History is lazy-\n        // loaded by useAssistantHistory on scroll-up (no blocking fetch here).\n        const { discoverAssistantSessions } = await import(\n          './assistant/sessionDiscovery.js'\n        )\n\n        let targetSessionId = _pendingAssistantChat.sessionId\n\n        // Discovery flow — list bridge environments, filter sessions\n        if (!targetSessionId) {\n          let sessions\n          try {\n            sessions = await discoverAssistantSessions()\n          } catch (e) {\n            return await exitWithError(\n              root,\n              `Failed to discover sessions: ${e instanceof Error ? e.message : e}`,\n              () => gracefulShutdown(1),\n            )\n          }\n          if (sessions.length === 0) {\n            let installedDir: string | null\n            try {\n              installedDir = await launchAssistantInstallWizard(root)\n            } catch (e) {\n              return await exitWithError(\n                root,\n                `Assistant installation failed: ${e instanceof Error ? e.message : e}`,\n                () => gracefulShutdown(1),\n              )\n            }\n            if (installedDir === null) {\n              await gracefulShutdown(0)\n              process.exit(0)\n            }\n            // The daemon needs a few seconds to spin up its worker and\n            // establish a bridge session before discovery will find it.\n            return await exitWithMessage(\n              root,\n              `Assistant installed in ${installedDir}. The daemon is starting up — run \\`claude assistant\\` again in a few seconds to connect.`,\n              { exitCode: 0, beforeExit: () => gracefulShutdown(0) },\n            )\n          }\n          if (sessions.length === 1) {\n            targetSessionId = sessions[0]!.id\n          } else {\n            const picked = await launchAssistantSessionChooser(root, {\n              sessions,\n            })\n            if (!picked) {\n              await gracefulShutdown(0)\n              process.exit(0)\n            }\n            targetSessionId = picked\n          }\n        }\n\n        // Auth — call prepareApiRequest() once for orgUUID, but use a\n        // getAccessToken closure for the token so reconnects get fresh tokens.\n        const { checkAndRefreshOAuthTokenIfNeeded, getClaudeAIOAuthTokens } =\n          await import('./utils/auth.js')\n        await checkAndRefreshOAuthTokenIfNeeded()\n        let apiCreds\n        try {\n          apiCreds = await prepareApiRequest()\n        } catch (e) {\n          return await exitWithError(\n            root,\n            `Error: ${e instanceof Error ? e.message : 'Failed to authenticate'}`,\n            () => gracefulShutdown(1),\n          )\n        }\n        const getAccessToken = (): string =>\n          getClaudeAIOAuthTokens()?.accessToken ?? apiCreds.accessToken\n\n        // Brief mode activation: setKairosActive(true) satisfies BOTH opt-in\n        // and entitlement for isBriefEnabled() (BriefTool.ts:124-132).\n        setKairosActive(true)\n        setUserMsgOptIn(true)\n        setIsRemoteMode(true)\n\n        const remoteSessionConfig = createRemoteSessionConfig(\n          targetSessionId,\n          getAccessToken,\n          apiCreds.orgUUID,\n          /* hasInitialPrompt */ false,\n          /* viewerOnly */ true,\n        )\n\n        const infoMessage = createSystemMessage(\n          `Attached to assistant session ${targetSessionId.slice(0, 8)}…`,\n          'info',\n        )\n\n        const assistantInitialState: AppState = {\n          ...initialState,\n          isBriefOnly: true,\n          kairosEnabled: false,\n          replBridgeEnabled: false,\n        }\n\n        const remoteCommands = filterCommandsForRemoteMode(commands)\n        await launchRepl(\n          root,\n          { getFpsMetrics, stats, initialState: assistantInitialState },\n          {\n            debug: debug || debugToStderr,\n            commands: remoteCommands,\n            initialTools: [],\n            initialMessages: [infoMessage],\n            mcpClients: [],\n            autoConnectIdeFlag: ide,\n            mainThreadAgentDefinition,\n            disableSlashCommands,\n            remoteSessionConfig,\n            thinkingConfig,\n          },\n          renderAndRun,\n        )\n        return\n      } else if (\n        options.resume ||\n        options.fromPr ||\n        teleport ||\n        remote !== null\n      ) {\n        // Handle resume flow - from file (ant-only), session ID, or interactive selector\n\n        // Clear stale caches before resuming to ensure fresh file/skill discovery\n        const { clearSessionCaches } = await import(\n          './commands/clear/caches.js'\n        )\n        clearSessionCaches()\n\n        let messages: MessageType[] | null = null\n        let processedResume: ProcessedResume | undefined = undefined\n\n        let maybeSessionId = validateUuid(options.resume)\n        let searchTerm: string | undefined = undefined\n        // Store full LogOption when found by custom title (for cross-worktree resume)\n        let matchedLog: LogOption | null = null\n        // PR filter for --from-pr flag\n        let filterByPr: boolean | number | string | undefined = undefined\n\n        // Handle --from-pr flag\n        if (options.fromPr) {\n          if (options.fromPr === true) {\n            // Show all sessions with linked PRs\n            filterByPr = true\n          } else if (typeof options.fromPr === 'string') {\n            // Could be a PR number or URL\n            filterByPr = options.fromPr\n          }\n        }\n\n        // If resume value is not a UUID, try exact match by custom title first\n        if (\n          options.resume &&\n          typeof options.resume === 'string' &&\n          !maybeSessionId\n        ) {\n          const trimmedValue = options.resume.trim()\n          if (trimmedValue) {\n            const matches = await searchSessionsByCustomTitle(trimmedValue, {\n              exact: true,\n            })\n\n            if (matches.length === 1) {\n              // Exact match found - store full LogOption for cross-worktree resume\n              matchedLog = matches[0]!\n              maybeSessionId = getSessionIdFromLog(matchedLog) ?? null\n            } else {\n              // No match or multiple matches - use as search term for picker\n              searchTerm = trimmedValue\n            }\n          }\n        }\n\n        // --remote and --teleport both create/resume Claude Code Web (CCR) sessions.\n        // Remote Control (--rc) is a separate feature gated in initReplBridge.ts.\n        if (remote !== null || teleport) {\n          await waitForPolicyLimitsToLoad()\n          if (!isPolicyAllowed('allow_remote_sessions')) {\n            return await exitWithError(\n              root,\n              \"Error: Remote sessions are disabled by your organization's policy.\",\n              () => gracefulShutdown(1),\n            )\n          }\n        }\n\n        if (remote !== null) {\n          // Create remote session (optionally with initial prompt)\n          const hasInitialPrompt = remote.length > 0\n\n          // Check if TUI mode is enabled - description is only optional in TUI mode\n          const isRemoteTuiEnabled = getFeatureValue_CACHED_MAY_BE_STALE(\n            'tengu_remote_backend',\n            false,\n          )\n          if (!isRemoteTuiEnabled && !hasInitialPrompt) {\n            return await exitWithError(\n              root,\n              'Error: --remote requires a description.\\nUsage: claude --remote \"your task description\"',\n              () => gracefulShutdown(1),\n            )\n          }\n\n          logEvent('tengu_remote_create_session', {\n            has_initial_prompt: String(\n              hasInitialPrompt,\n            ) as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n          })\n\n          // Pass current branch so CCR clones the repo at the right revision\n          const currentBranch = await getBranch()\n          const createdSession = await teleportToRemoteWithErrorHandling(\n            root,\n            hasInitialPrompt ? remote : null,\n            new AbortController().signal,\n            currentBranch || undefined,\n          )\n          if (!createdSession) {\n            logEvent('tengu_remote_create_session_error', {\n              error:\n                'unable_to_create_session' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n            })\n            return await exitWithError(\n              root,\n              'Error: Unable to create remote session',\n              () => gracefulShutdown(1),\n            )\n          }\n          logEvent('tengu_remote_create_session_success', {\n            session_id:\n              createdSession.id as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n          })\n\n          // Check if new remote TUI mode is enabled via feature gate\n          if (!isRemoteTuiEnabled) {\n            // Original behavior: print session info and exit\n            process.stdout.write(\n              `Created remote session: ${createdSession.title}\\n`,\n            )\n            process.stdout.write(\n              `View: ${getRemoteSessionUrl(createdSession.id)}?m=0\\n`,\n            )\n            process.stdout.write(\n              `Resume with: claude --teleport ${createdSession.id}\\n`,\n            )\n            await gracefulShutdown(0)\n            process.exit(0)\n          }\n\n          // New behavior: start local TUI with CCR engine\n          // Mark that we're in remote mode for command visibility\n          setIsRemoteMode(true)\n          switchSession(asSessionId(createdSession.id))\n\n          // Get OAuth credentials for remote session\n          let apiCreds: { accessToken: string; orgUUID: string }\n          try {\n            apiCreds = await prepareApiRequest()\n          } catch (error) {\n            logError(toError(error))\n            return await exitWithError(\n              root,\n              `Error: ${errorMessage(error) || 'Failed to authenticate'}`,\n              () => gracefulShutdown(1),\n            )\n          }\n\n          // Create remote session config for the REPL\n          const { getClaudeAIOAuthTokens: getTokensForRemote } = await import(\n            './utils/auth.js'\n          )\n          const getAccessTokenForRemote = (): string =>\n            getTokensForRemote()?.accessToken ?? apiCreds.accessToken\n          const remoteSessionConfig = createRemoteSessionConfig(\n            createdSession.id,\n            getAccessTokenForRemote,\n            apiCreds.orgUUID,\n            hasInitialPrompt,\n          )\n\n          // Add remote session info as initial system message\n          const remoteSessionUrl = `${getRemoteSessionUrl(createdSession.id)}?m=0`\n          const remoteInfoMessage = createSystemMessage(\n            `/remote-control is active. Code in CLI or at ${remoteSessionUrl}`,\n            'info',\n          )\n\n          // Create initial user message from the prompt if provided (CCR echoes it back but we ignore that)\n          const initialUserMessage = hasInitialPrompt\n            ? createUserMessage({ content: remote })\n            : null\n\n          // Set remote session URL in app state for footer indicator\n          const remoteInitialState = {\n            ...initialState,\n            remoteSessionUrl,\n          }\n\n          // Pre-filter commands to only include remote-safe ones.\n          // CCR's init response may further refine the list (via handleRemoteInit in REPL).\n          const remoteCommands = filterCommandsForRemoteMode(commands)\n          await launchRepl(\n            root,\n            { getFpsMetrics, stats, initialState: remoteInitialState },\n            {\n              debug: debug || debugToStderr,\n              commands: remoteCommands,\n              initialTools: [],\n              initialMessages: initialUserMessage\n                ? [remoteInfoMessage, initialUserMessage]\n                : [remoteInfoMessage],\n              mcpClients: [],\n              autoConnectIdeFlag: ide,\n              mainThreadAgentDefinition,\n              disableSlashCommands,\n              remoteSessionConfig,\n              thinkingConfig,\n            },\n            renderAndRun,\n          )\n          return\n        } else if (teleport) {\n          if (teleport === true || teleport === '') {\n            // Interactive mode: show task selector and handle resume\n            logEvent('tengu_teleport_interactive_mode', {})\n            logForDebugging(\n              'selectAndResumeTeleportTask: Starting teleport flow...',\n            )\n            const teleportResult = await launchTeleportResumeWrapper(root)\n            if (!teleportResult) {\n              // User cancelled or error occurred\n              await gracefulShutdown(0)\n              process.exit(0)\n            }\n            const { branchError } = await checkOutTeleportedSessionBranch(\n              teleportResult.branch,\n            )\n            messages = processMessagesForTeleportResume(\n              teleportResult.log,\n              branchError,\n            )\n          } else if (typeof teleport === 'string') {\n            logEvent('tengu_teleport_resume_session', {\n              mode: 'direct' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n            })\n            try {\n              // First, fetch session and validate repository before checking git state\n              const sessionData = await fetchSession(teleport)\n              const repoValidation =\n                await validateSessionRepository(sessionData)\n\n              // Handle repo mismatch or not in repo cases\n              if (\n                repoValidation.status === 'mismatch' ||\n                repoValidation.status === 'not_in_repo'\n              ) {\n                const sessionRepo = repoValidation.sessionRepo\n                if (sessionRepo) {\n                  // Check for known paths\n                  const knownPaths = getKnownPathsForRepo(sessionRepo)\n                  const existingPaths = await filterExistingPaths(knownPaths)\n\n                  if (existingPaths.length > 0) {\n                    // Show directory switch dialog\n                    const selectedPath = await launchTeleportRepoMismatchDialog(\n                      root,\n                      {\n                        targetRepo: sessionRepo,\n                        initialPaths: existingPaths,\n                      },\n                    )\n\n                    if (selectedPath) {\n                      // Change to the selected directory\n                      process.chdir(selectedPath)\n                      setCwd(selectedPath)\n                      setOriginalCwd(selectedPath)\n                    } else {\n                      // User cancelled\n                      await gracefulShutdown(0)\n                    }\n                  } else {\n                    // No known paths - show original error\n                    throw new TeleportOperationError(\n                      `You must run claude --teleport ${teleport} from a checkout of ${sessionRepo}.`,\n                      chalk.red(\n                        `You must run claude --teleport ${teleport} from a checkout of ${chalk.bold(sessionRepo)}.\\n`,\n                      ),\n                    )\n                  }\n                }\n              } else if (repoValidation.status === 'error') {\n                throw new TeleportOperationError(\n                  repoValidation.errorMessage || 'Failed to validate session',\n                  chalk.red(\n                    `Error: ${repoValidation.errorMessage || 'Failed to validate session'}\\n`,\n                  ),\n                )\n              }\n\n              await validateGitState()\n\n              // Use progress UI for teleport\n              const { teleportWithProgress } = await import(\n                './components/TeleportProgress.js'\n              )\n              const result = await teleportWithProgress(root, teleport)\n              // Track teleported session for reliability logging\n              setTeleportedSessionInfo({ sessionId: teleport })\n              messages = result.messages\n            } catch (error) {\n              if (error instanceof TeleportOperationError) {\n                process.stderr.write(error.formattedMessage + '\\n')\n              } else {\n                logError(error)\n                process.stderr.write(\n                  chalk.red(`Error: ${errorMessage(error)}\\n`),\n                )\n              }\n              await gracefulShutdown(1)\n            }\n          }\n        }\n        if (\"external\" === 'ant') {\n          if (\n            options.resume &&\n            typeof options.resume === 'string' &&\n            !maybeSessionId\n          ) {\n            // Check for ccshare URL (e.g. https://go/ccshare/boris-20260311-211036)\n            const { parseCcshareId, loadCcshare } = await import(\n              './utils/ccshareResume.js'\n            )\n            const ccshareId = parseCcshareId(options.resume)\n            if (ccshareId) {\n              try {\n                const resumeStart = performance.now()\n                const logOption = await loadCcshare(ccshareId)\n                const result = await loadConversationForResume(\n                  logOption,\n                  undefined,\n                )\n                if (result) {\n                  processedResume = await processResumedConversation(\n                    result,\n                    {\n                      forkSession: true,\n                      transcriptPath: result.fullPath,\n                    },\n                    resumeContext,\n                  )\n                  if (processedResume.restoredAgentDef) {\n                    mainThreadAgentDefinition = processedResume.restoredAgentDef\n                  }\n                  logEvent('tengu_session_resumed', {\n                    entrypoint:\n                      'ccshare' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n                    success: true,\n                    resume_duration_ms: Math.round(\n                      performance.now() - resumeStart,\n                    ),\n                  })\n                } else {\n                  logEvent('tengu_session_resumed', {\n                    entrypoint:\n                      'ccshare' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n                    success: false,\n                  })\n                }\n              } catch (error) {\n                logEvent('tengu_session_resumed', {\n                  entrypoint:\n                    'ccshare' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n                  success: false,\n                })\n                logError(error)\n                await exitWithError(\n                  root,\n                  `Unable to resume from ccshare: ${errorMessage(error)}`,\n                  () => gracefulShutdown(1),\n                )\n              }\n            } else {\n              const resolvedPath = resolve(options.resume)\n              try {\n                const resumeStart = performance.now()\n                let logOption\n                try {\n                  // Attempt to load as a transcript file; ENOENT falls through to session-ID handling\n                  logOption = await loadTranscriptFromFile(resolvedPath)\n                } catch (error) {\n                  if (!isENOENT(error)) throw error\n                  // ENOENT: not a file path — fall through to session-ID handling\n                }\n                if (logOption) {\n                  const result = await loadConversationForResume(\n                    logOption,\n                    undefined /* sourceFile */,\n                  )\n                  if (result) {\n                    processedResume = await processResumedConversation(\n                      result,\n                      {\n                        forkSession: !!options.forkSession,\n                        transcriptPath: result.fullPath,\n                      },\n                      resumeContext,\n                    )\n                    if (processedResume.restoredAgentDef) {\n                      mainThreadAgentDefinition =\n                        processedResume.restoredAgentDef\n                    }\n                    logEvent('tengu_session_resumed', {\n                      entrypoint:\n                        'file' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n                      success: true,\n                      resume_duration_ms: Math.round(\n                        performance.now() - resumeStart,\n                      ),\n                    })\n                  } else {\n                    logEvent('tengu_session_resumed', {\n                      entrypoint:\n                        'file' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n                      success: false,\n                    })\n                  }\n                }\n              } catch (error) {\n                logEvent('tengu_session_resumed', {\n                  entrypoint:\n                    'file' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n                  success: false,\n                })\n                logError(error)\n                await exitWithError(\n                  root,\n                  `Unable to load transcript from file: ${options.resume}`,\n                  () => gracefulShutdown(1),\n                )\n              }\n            }\n          }\n        }\n\n        // If not loaded as a file, try as session ID\n        if (maybeSessionId) {\n          // Resume specific session by ID\n          const sessionId = maybeSessionId\n          try {\n            const resumeStart = performance.now()\n            // Use matchedLog if available (for cross-worktree resume by custom title)\n            // Otherwise fall back to sessionId string (for direct UUID resume)\n            const result = await loadConversationForResume(\n              matchedLog ?? sessionId,\n              undefined,\n            )\n\n            if (!result) {\n              logEvent('tengu_session_resumed', {\n                entrypoint:\n                  'cli_flag' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n                success: false,\n              })\n              return await exitWithError(\n                root,\n                `No conversation found with session ID: ${sessionId}`,\n              )\n            }\n\n            const fullPath = matchedLog?.fullPath ?? result.fullPath\n            processedResume = await processResumedConversation(\n              result,\n              {\n                forkSession: !!options.forkSession,\n                sessionIdOverride: sessionId,\n                transcriptPath: fullPath,\n              },\n              resumeContext,\n            )\n\n            if (processedResume.restoredAgentDef) {\n              mainThreadAgentDefinition = processedResume.restoredAgentDef\n            }\n            logEvent('tengu_session_resumed', {\n              entrypoint:\n                'cli_flag' 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                'cli_flag' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n              success: false,\n            })\n            logError(error)\n            await exitWithError(root, `Failed to resume session ${sessionId}`)\n          }\n        }\n\n        // Await file downloads before rendering REPL (files must be available)\n        if (fileDownloadPromise) {\n          try {\n            const results = await fileDownloadPromise\n            const failedCount = count(results, r => !r.success)\n            if (failedCount > 0) {\n              process.stderr.write(\n                chalk.yellow(\n                  `Warning: ${failedCount}/${results.length} file(s) failed to download.\\n`,\n                ),\n              )\n            }\n          } catch (error) {\n            return await exitWithError(\n              root,\n              `Error downloading files: ${errorMessage(error)}`,\n            )\n          }\n        }\n\n        // If we have a processed resume or teleport messages, render the REPL\n        const resumeData =\n          processedResume ??\n          (Array.isArray(messages)\n            ? {\n                messages,\n                fileHistorySnapshots: undefined,\n                agentName: undefined,\n                agentColor: undefined as AgentColorName | undefined,\n                restoredAgentDef: mainThreadAgentDefinition,\n                initialState,\n                contentReplacements: undefined,\n              }\n            : undefined)\n        if (resumeData) {\n          maybeActivateProactive(options)\n          maybeActivateBrief(options)\n\n          await launchRepl(\n            root,\n            { getFpsMetrics, stats, initialState: resumeData.initialState },\n            {\n              ...sessionConfig,\n              mainThreadAgentDefinition:\n                resumeData.restoredAgentDef ?? mainThreadAgentDefinition,\n              initialMessages: resumeData.messages,\n              initialFileHistorySnapshots: resumeData.fileHistorySnapshots,\n              initialContentReplacements: resumeData.contentReplacements,\n              initialAgentName: resumeData.agentName,\n              initialAgentColor: resumeData.agentColor,\n            },\n            renderAndRun,\n          )\n        } else {\n          // Show interactive selector (includes same-repo worktrees)\n          // Note: ResumeConversation loads logs internally to ensure proper GC after selection\n          await launchResumeChooser(\n            root,\n            { getFpsMetrics, stats, initialState },\n            getWorktreePaths(getOriginalCwd()),\n            {\n              ...sessionConfig,\n              initialSearchQuery: searchTerm,\n              forkSession: options.forkSession,\n              filterByPr,\n            },\n          )\n        }\n      } else {\n        // Pass unresolved hooks promise to REPL so it can render immediately\n        // instead of blocking ~500ms waiting for SessionStart hooks to finish.\n        // REPL will inject hook messages when they resolve and await them before\n        // the first API call so the model always sees hook context.\n        const pendingHookMessages =\n          hooksPromise && hookMessages.length === 0 ? hooksPromise : undefined\n\n        profileCheckpoint('action_after_hooks')\n        maybeActivateProactive(options)\n        maybeActivateBrief(options)\n        // Persist the current mode for fresh sessions so future resumes know what mode was used\n        if (feature('COORDINATOR_MODE')) {\n          saveMode(\n            coordinatorModeModule?.isCoordinatorMode()\n              ? 'coordinator'\n              : 'normal',\n          )\n        }\n\n        // If launched via a deep link, show a provenance banner so the user\n        // knows the session originated externally. Linux xdg-open and\n        // browsers with \"always allow\" set dispatch the link with no OS-level\n        // confirmation, so this is the only signal the user gets that the\n        // prompt — and the working directory / CLAUDE.md it implies — came\n        // from an external source rather than something they typed.\n        let deepLinkBanner: ReturnType<typeof createSystemMessage> | null = null\n        if (feature('LODESTONE')) {\n          if (options.deepLinkOrigin) {\n            logEvent('tengu_deep_link_opened', {\n              has_prefill: Boolean(options.prefill),\n              has_repo: Boolean(options.deepLinkRepo),\n            })\n            deepLinkBanner = createSystemMessage(\n              buildDeepLinkBanner({\n                cwd: getCwd(),\n                prefillLength: options.prefill?.length,\n                repo: options.deepLinkRepo,\n                lastFetch:\n                  options.deepLinkLastFetch !== undefined\n                    ? new Date(options.deepLinkLastFetch)\n                    : undefined,\n              }),\n              'warning',\n            )\n          } else if (options.prefill) {\n            deepLinkBanner = createSystemMessage(\n              'Launched with a pre-filled prompt — review it before pressing Enter.',\n              'warning',\n            )\n          }\n        }\n        const initialMessages = deepLinkBanner\n          ? [deepLinkBanner, ...hookMessages]\n          : hookMessages.length > 0\n            ? hookMessages\n            : undefined\n\n        await launchRepl(\n          root,\n          { getFpsMetrics, stats, initialState },\n          {\n            ...sessionConfig,\n            initialMessages,\n            pendingHookMessages,\n          },\n          renderAndRun,\n        )\n      }\n    })\n    .version(\n      `${MACRO.VERSION} (Claude Code)`,\n      '-v, --version',\n      'Output the version number',\n    )\n\n  // Worktree flags\n  program.option(\n    '-w, --worktree [name]',\n    'Create a new git worktree for this session (optionally specify a name)',\n  )\n  program.option(\n    '--tmux',\n    'Create a tmux session for the worktree (requires --worktree). Uses iTerm2 native panes when available; use --tmux=classic for traditional tmux.',\n  )\n\n  if (canUserConfigureAdvisor()) {\n    program.addOption(\n      new Option(\n        '--advisor <model>',\n        'Enable the server-side advisor tool with the specified model (alias or full ID).',\n      ).hideHelp(),\n    )\n  }\n\n  if (\"external\" === 'ant') {\n    program.addOption(\n      new Option(\n        '--delegate-permissions',\n        '[ANT-ONLY] Alias for --permission-mode auto.',\n      ).implies({ permissionMode: 'auto' }),\n    )\n    program.addOption(\n      new Option(\n        '--dangerously-skip-permissions-with-classifiers',\n        '[ANT-ONLY] Deprecated alias for --permission-mode auto.',\n      )\n        .hideHelp()\n        .implies({ permissionMode: 'auto' }),\n    )\n    program.addOption(\n      new Option(\n        '--afk',\n        '[ANT-ONLY] Deprecated alias for --permission-mode auto.',\n      )\n        .hideHelp()\n        .implies({ permissionMode: 'auto' }),\n    )\n    program.addOption(\n      new Option(\n        '--tasks [id]',\n        '[ANT-ONLY] Tasks mode: watch for tasks and auto-process them. Optional id is used as both the task list ID and agent ID (defaults to \"tasklist\").',\n      )\n        .argParser(String)\n        .hideHelp(),\n    )\n    program.option(\n      '--agent-teams',\n      '[ANT-ONLY] Force Claude to use multi-agent mode for solving problems',\n      () => true,\n    )\n  }\n\n  if (feature('TRANSCRIPT_CLASSIFIER')) {\n    program.addOption(\n      new Option('--enable-auto-mode', 'Opt in to auto mode').hideHelp(),\n    )\n  }\n\n  if (feature('PROACTIVE') || feature('KAIROS')) {\n    program.addOption(\n      new Option('--proactive', 'Start in proactive autonomous mode'),\n    )\n  }\n\n  if (feature('UDS_INBOX')) {\n    program.addOption(\n      new Option(\n        '--messaging-socket-path <path>',\n        'Unix domain socket path for the UDS messaging server (defaults to a tmp path)',\n      ),\n    )\n  }\n\n  if (feature('KAIROS') || feature('KAIROS_BRIEF')) {\n    program.addOption(\n      new Option(\n        '--brief',\n        'Enable SendUserMessage tool for agent-to-user communication',\n      ),\n    )\n  }\n  if (feature('KAIROS')) {\n    program.addOption(\n      new Option(\n        '--assistant',\n        'Force assistant mode (Agent SDK daemon use)',\n      ).hideHelp(),\n    )\n  }\n  if (feature('KAIROS') || feature('KAIROS_CHANNELS')) {\n    program.addOption(\n      new Option(\n        '--channels <servers...>',\n        'MCP servers whose channel notifications (inbound push) should register this session. Space-separated server names.',\n      ).hideHelp(),\n    )\n    program.addOption(\n      new Option(\n        '--dangerously-load-development-channels <servers...>',\n        'Load channel servers not on the approved allowlist. For local channel development only. Shows a confirmation dialog at startup.',\n      ).hideHelp(),\n    )\n  }\n\n  // Teammate identity options (set by leader when spawning tmux teammates)\n  // These replace the CLAUDE_CODE_* environment variables\n  program.addOption(\n    new Option('--agent-id <id>', 'Teammate agent ID').hideHelp(),\n  )\n  program.addOption(\n    new Option('--agent-name <name>', 'Teammate display name').hideHelp(),\n  )\n  program.addOption(\n    new Option(\n      '--team-name <name>',\n      'Team name for swarm coordination',\n    ).hideHelp(),\n  )\n  program.addOption(\n    new Option('--agent-color <color>', 'Teammate UI color').hideHelp(),\n  )\n  program.addOption(\n    new Option(\n      '--plan-mode-required',\n      'Require plan mode before implementation',\n    ).hideHelp(),\n  )\n  program.addOption(\n    new Option(\n      '--parent-session-id <id>',\n      'Parent session ID for analytics correlation',\n    ).hideHelp(),\n  )\n  program.addOption(\n    new Option(\n      '--teammate-mode <mode>',\n      'How to spawn teammates: \"tmux\", \"in-process\", or \"auto\"',\n    )\n      .choices(['auto', 'tmux', 'in-process'])\n      .hideHelp(),\n  )\n  program.addOption(\n    new Option(\n      '--agent-type <type>',\n      'Custom agent type for this teammate',\n    ).hideHelp(),\n  )\n\n  // Enable SDK URL for all builds but hide from help\n  program.addOption(\n    new Option(\n      '--sdk-url <url>',\n      'Use remote WebSocket endpoint for SDK I/O streaming (only with -p and stream-json format)',\n    ).hideHelp(),\n  )\n\n  // Enable teleport/remote flags for all builds but keep them undocumented until GA\n  program.addOption(\n    new Option(\n      '--teleport [session]',\n      'Resume a teleport session, optionally specify session ID',\n    ).hideHelp(),\n  )\n  program.addOption(\n    new Option(\n      '--remote [description]',\n      'Create a remote session with the given description',\n    ).hideHelp(),\n  )\n  if (feature('BRIDGE_MODE')) {\n    program.addOption(\n      new Option(\n        '--remote-control [name]',\n        'Start an interactive session with Remote Control enabled (optionally named)',\n      )\n        .argParser(value => value || true)\n        .hideHelp(),\n    )\n    program.addOption(\n      new Option('--rc [name]', 'Alias for --remote-control')\n        .argParser(value => value || true)\n        .hideHelp(),\n    )\n  }\n\n  if (feature('HARD_FAIL')) {\n    program.addOption(\n      new Option(\n        '--hard-fail',\n        'Crash on logError calls instead of silently logging',\n      ).hideHelp(),\n    )\n  }\n\n  profileCheckpoint('run_main_options_built')\n\n  // -p/--print mode: skip subcommand registration. The 52 subcommands\n  // (mcp, auth, plugin, skill, task, config, doctor, update, etc.) are\n  // never dispatched in print mode — commander routes the prompt to the\n  // default action. The subcommand registration path was measured at ~65ms\n  // on baseline — mostly the isBridgeEnabled() call (25ms settings Zod parse\n  // + 40ms sync keychain subprocess), both hidden by the try/catch that\n  // always returns false before enableConfigs(). cc:// URLs are rewritten to\n  // `open` at main() line ~851 BEFORE this runs, so argv check is safe here.\n  const isPrintMode =\n    process.argv.includes('-p') || process.argv.includes('--print')\n  const isCcUrl = process.argv.some(\n    a => a.startsWith('cc://') || a.startsWith('cc+unix://'),\n  )\n  if (isPrintMode && !isCcUrl) {\n    profileCheckpoint('run_before_parse')\n    await program.parseAsync(process.argv)\n    profileCheckpoint('run_after_parse')\n    return program\n  }\n\n  // claude mcp\n\n  const mcp = program\n    .command('mcp')\n    .description('Configure and manage MCP servers')\n    .configureHelp(createSortedHelpConfig())\n    .enablePositionalOptions()\n\n  mcp\n    .command('serve')\n    .description(`Start the Claude Code MCP server`)\n    .option('-d, --debug', 'Enable debug mode', () => true)\n    .option(\n      '--verbose',\n      'Override verbose mode setting from config',\n      () => true,\n    )\n    .action(\n      async ({ debug, verbose }: { debug?: boolean; verbose?: boolean }) => {\n        const { mcpServeHandler } = await import('./cli/handlers/mcp.js')\n        await mcpServeHandler({ debug, verbose })\n      },\n    )\n\n  // Register the mcp add subcommand (extracted for testability)\n  registerMcpAddCommand(mcp)\n\n  if (isXaaEnabled()) {\n    registerMcpXaaIdpCommand(mcp)\n  }\n\n  mcp\n    .command('remove <name>')\n    .description('Remove an MCP server')\n    .option(\n      '-s, --scope <scope>',\n      'Configuration scope (local, user, or project) - if not specified, removes from whichever scope it exists in',\n    )\n    .action(async (name: string, options: { scope?: string }) => {\n      const { mcpRemoveHandler } = await import('./cli/handlers/mcp.js')\n      await mcpRemoveHandler(name, options)\n    })\n\n  mcp\n    .command('list')\n    .description(\n      'List configured MCP servers. Note: The workspace trust dialog is skipped and stdio servers from .mcp.json are spawned for health checks. Only use this command in directories you trust.',\n    )\n    .action(async () => {\n      const { mcpListHandler } = await import('./cli/handlers/mcp.js')\n      await mcpListHandler()\n    })\n\n  mcp\n    .command('get <name>')\n    .description(\n      'Get details about an MCP server. Note: The workspace trust dialog is skipped and stdio servers from .mcp.json are spawned for health checks. Only use this command in directories you trust.',\n    )\n    .action(async (name: string) => {\n      const { mcpGetHandler } = await import('./cli/handlers/mcp.js')\n      await mcpGetHandler(name)\n    })\n\n  mcp\n    .command('add-json <name> <json>')\n    .description('Add an MCP server (stdio or SSE) with a JSON string')\n    .option(\n      '-s, --scope <scope>',\n      'Configuration scope (local, user, or project)',\n      'local',\n    )\n    .option(\n      '--client-secret',\n      'Prompt for OAuth client secret (or set MCP_CLIENT_SECRET env var)',\n    )\n    .action(\n      async (\n        name: string,\n        json: string,\n        options: { scope?: string; clientSecret?: true },\n      ) => {\n        const { mcpAddJsonHandler } = await import('./cli/handlers/mcp.js')\n        await mcpAddJsonHandler(name, json, options)\n      },\n    )\n\n  mcp\n    .command('add-from-claude-desktop')\n    .description('Import MCP servers from Claude Desktop (Mac and WSL only)')\n    .option(\n      '-s, --scope <scope>',\n      'Configuration scope (local, user, or project)',\n      'local',\n    )\n    .action(async (options: { scope?: string }) => {\n      const { mcpAddFromDesktopHandler } = await import('./cli/handlers/mcp.js')\n      await mcpAddFromDesktopHandler(options)\n    })\n\n  mcp\n    .command('reset-project-choices')\n    .description(\n      'Reset all approved and rejected project-scoped (.mcp.json) servers within this project',\n    )\n    .action(async () => {\n      const { mcpResetChoicesHandler } = await import('./cli/handlers/mcp.js')\n      await mcpResetChoicesHandler()\n    })\n\n  // claude server\n  if (feature('DIRECT_CONNECT')) {\n    program\n      .command('server')\n      .description('Start a Claude Code session server')\n      .option('--port <number>', 'HTTP port', '0')\n      .option('--host <string>', 'Bind address', '0.0.0.0')\n      .option('--auth-token <token>', 'Bearer token for auth')\n      .option('--unix <path>', 'Listen on a unix domain socket')\n      .option(\n        '--workspace <dir>',\n        'Default working directory for sessions that do not specify cwd',\n      )\n      .option(\n        '--idle-timeout <ms>',\n        'Idle timeout for detached sessions in ms (0 = never expire)',\n        '600000',\n      )\n      .option(\n        '--max-sessions <n>',\n        'Maximum concurrent sessions (0 = unlimited)',\n        '32',\n      )\n      .action(\n        async (opts: {\n          port: string\n          host: string\n          authToken?: string\n          unix?: string\n          workspace?: string\n          idleTimeout: string\n          maxSessions: string\n        }) => {\n          const { randomBytes } = await import('crypto')\n          const { startServer } = await import('./server/server.js')\n          const { SessionManager } = await import('./server/sessionManager.js')\n          const { DangerousBackend } = await import(\n            './server/backends/dangerousBackend.js'\n          )\n          const { printBanner } = await import('./server/serverBanner.js')\n          const { createServerLogger } = await import('./server/serverLog.js')\n          const { writeServerLock, removeServerLock, probeRunningServer } =\n            await import('./server/lockfile.js')\n\n          const existing = await probeRunningServer()\n          if (existing) {\n            process.stderr.write(\n              `A claude server is already running (pid ${existing.pid}) at ${existing.httpUrl}\\n`,\n            )\n            process.exit(1)\n          }\n\n          const authToken =\n            opts.authToken ??\n            `sk-ant-cc-${randomBytes(16).toString('base64url')}`\n\n          const config = {\n            port: parseInt(opts.port, 10),\n            host: opts.host,\n            authToken,\n            unix: opts.unix,\n            workspace: opts.workspace,\n            idleTimeoutMs: parseInt(opts.idleTimeout, 10),\n            maxSessions: parseInt(opts.maxSessions, 10),\n          }\n\n          const backend = new DangerousBackend()\n          const sessionManager = new SessionManager(backend, {\n            idleTimeoutMs: config.idleTimeoutMs,\n            maxSessions: config.maxSessions,\n          })\n          const logger = createServerLogger()\n\n          const server = startServer(config, sessionManager, logger)\n          const actualPort = server.port ?? config.port\n          printBanner(config, authToken, actualPort)\n\n          await writeServerLock({\n            pid: process.pid,\n            port: actualPort,\n            host: config.host,\n            httpUrl: config.unix\n              ? `unix:${config.unix}`\n              : `http://${config.host}:${actualPort}`,\n            startedAt: Date.now(),\n          })\n\n          let shuttingDown = false\n          const shutdown = async () => {\n            if (shuttingDown) return\n            shuttingDown = true\n            // Stop accepting new connections before tearing down sessions.\n            server.stop(true)\n            await sessionManager.destroyAll()\n            await removeServerLock()\n            process.exit(0)\n          }\n          process.once('SIGINT', () => void shutdown())\n          process.once('SIGTERM', () => void shutdown())\n        },\n      )\n  }\n\n  // `claude ssh <host> [dir]` — registered here only so --help shows it.\n  // The actual interactive flow is handled by early argv rewriting in main()\n  // (parallels the DIRECT_CONNECT/cc:// pattern above). If commander reaches\n  // this action it means the argv rewrite didn't fire (e.g. user ran\n  // `claude ssh` with no host) — just print usage.\n  if (feature('SSH_REMOTE')) {\n    program\n      .command('ssh <host> [dir]')\n      .description(\n        'Run Claude Code on a remote host over SSH. Deploys the binary and ' +\n          'tunnels API auth back through your local machine — no remote setup needed.',\n      )\n      .option(\n        '--permission-mode <mode>',\n        'Permission mode for the remote session',\n      )\n      .option(\n        '--dangerously-skip-permissions',\n        'Skip all permission prompts on the remote (dangerous)',\n      )\n      .option(\n        '--local',\n        'e2e test mode — spawn the child CLI locally (skip ssh/deploy). ' +\n          'Exercises the auth proxy and unix-socket plumbing without a remote host.',\n      )\n      .action(async () => {\n        // Argv rewriting in main() should have consumed `ssh <host>` before\n        // commander runs. Reaching here means host was missing or the\n        // rewrite predicate didn't match.\n        process.stderr.write(\n          'Usage: claude ssh <user@host | ssh-config-alias> [dir]\\n\\n' +\n            \"Runs Claude Code on a remote Linux host. You don't need to install\\n\" +\n            'anything on the remote or run `claude auth login` there — the binary is\\n' +\n            'deployed over SSH and API auth tunnels back through your local machine.\\n',\n        )\n        process.exit(1)\n      })\n  }\n\n  // claude connect — subcommand only handles -p (headless) mode.\n  // Interactive mode (without -p) is handled by early argv rewriting in main()\n  // which redirects to the main command with full TUI support.\n  if (feature('DIRECT_CONNECT')) {\n    program\n      .command('open <cc-url>')\n      .description(\n        'Connect to a Claude Code server (internal — use cc:// URLs)',\n      )\n      .option('-p, --print [prompt]', 'Print mode (headless)')\n      .option(\n        '--output-format <format>',\n        'Output format: text, json, stream-json',\n        'text',\n      )\n      .action(\n        async (\n          ccUrl: string,\n          opts: {\n            print?: string | boolean\n            outputFormat: string\n          },\n        ) => {\n          const { parseConnectUrl } = await import(\n            './server/parseConnectUrl.js'\n          )\n          const { serverUrl, authToken } = parseConnectUrl(ccUrl)\n\n          let connectConfig\n          try {\n            const session = await createDirectConnectSession({\n              serverUrl,\n              authToken,\n              cwd: getOriginalCwd(),\n              dangerouslySkipPermissions:\n                _pendingConnect?.dangerouslySkipPermissions,\n            })\n            if (session.workDir) {\n              setOriginalCwd(session.workDir)\n              setCwdState(session.workDir)\n            }\n            setDirectConnectServerUrl(serverUrl)\n            connectConfig = session.config\n          } catch (err) {\n            // biome-ignore lint/suspicious/noConsole: intentional error output\n            console.error(\n              err instanceof DirectConnectError ? err.message : String(err),\n            )\n            process.exit(1)\n          }\n\n          const { runConnectHeadless } = await import(\n            './server/connectHeadless.js'\n          )\n\n          const prompt = typeof opts.print === 'string' ? opts.print : ''\n          const interactive = opts.print === true\n          await runConnectHeadless(\n            connectConfig,\n            prompt,\n            opts.outputFormat,\n            interactive,\n          )\n        },\n      )\n  }\n\n  // claude auth\n\n  const auth = program\n    .command('auth')\n    .description('Manage authentication')\n    .configureHelp(createSortedHelpConfig())\n\n  auth\n    .command('login')\n    .description('Sign in to your Anthropic account')\n    .option('--email <email>', 'Pre-populate email address on the login page')\n    .option('--sso', 'Force SSO login flow')\n    .option(\n      '--console',\n      'Use Anthropic Console (API usage billing) instead of Claude subscription',\n    )\n    .option('--claudeai', 'Use Claude subscription (default)')\n    .action(\n      async ({\n        email,\n        sso,\n        console: useConsole,\n        claudeai,\n      }: {\n        email?: string\n        sso?: boolean\n        console?: boolean\n        claudeai?: boolean\n      }) => {\n        const { authLogin } = await import('./cli/handlers/auth.js')\n        await authLogin({ email, sso, console: useConsole, claudeai })\n      },\n    )\n\n  auth\n    .command('status')\n    .description('Show authentication status')\n    .option('--json', 'Output as JSON (default)')\n    .option('--text', 'Output as human-readable text')\n    .action(async (opts: { json?: boolean; text?: boolean }) => {\n      const { authStatus } = await import('./cli/handlers/auth.js')\n      await authStatus(opts)\n    })\n\n  auth\n    .command('logout')\n    .description('Log out from your Anthropic account')\n    .action(async () => {\n      const { authLogout } = await import('./cli/handlers/auth.js')\n      await authLogout()\n    })\n\n  /**\n   * Helper function to handle marketplace command errors consistently.\n   * Logs the error and exits the process with status 1.\n   * @param error The error that occurred\n   * @param action Description of the action that failed\n   */\n  // Hidden flag on all plugin/marketplace subcommands to target cowork_plugins.\n  const coworkOption = () =>\n    new Option('--cowork', 'Use cowork_plugins directory').hideHelp()\n\n  // Plugin validate command\n  const pluginCmd = program\n    .command('plugin')\n    .alias('plugins')\n    .description('Manage Claude Code plugins')\n    .configureHelp(createSortedHelpConfig())\n\n  pluginCmd\n    .command('validate <path>')\n    .description('Validate a plugin or marketplace manifest')\n    .addOption(coworkOption())\n    .action(async (manifestPath: string, options: { cowork?: boolean }) => {\n      const { pluginValidateHandler } = await import(\n        './cli/handlers/plugins.js'\n      )\n      await pluginValidateHandler(manifestPath, options)\n    })\n\n  // Plugin list command\n  pluginCmd\n    .command('list')\n    .description('List installed plugins')\n    .option('--json', 'Output as JSON')\n    .option(\n      '--available',\n      'Include available plugins from marketplaces (requires --json)',\n    )\n    .addOption(coworkOption())\n    .action(\n      async (options: {\n        json?: boolean\n        available?: boolean\n        cowork?: boolean\n      }) => {\n        const { pluginListHandler } = await import('./cli/handlers/plugins.js')\n        await pluginListHandler(options)\n      },\n    )\n\n  // Marketplace subcommands\n  const marketplaceCmd = pluginCmd\n    .command('marketplace')\n    .description('Manage Claude Code marketplaces')\n    .configureHelp(createSortedHelpConfig())\n\n  marketplaceCmd\n    .command('add <source>')\n    .description('Add a marketplace from a URL, path, or GitHub repo')\n    .addOption(coworkOption())\n    .option(\n      '--sparse <paths...>',\n      'Limit checkout to specific directories via git sparse-checkout (for monorepos). Example: --sparse .claude-plugin plugins',\n    )\n    .option(\n      '--scope <scope>',\n      'Where to declare the marketplace: user (default), project, or local',\n    )\n    .action(\n      async (\n        source: string,\n        options: { cowork?: boolean; sparse?: string[]; scope?: string },\n      ) => {\n        const { marketplaceAddHandler } = await import(\n          './cli/handlers/plugins.js'\n        )\n        await marketplaceAddHandler(source, options)\n      },\n    )\n\n  marketplaceCmd\n    .command('list')\n    .description('List all configured marketplaces')\n    .option('--json', 'Output as JSON')\n    .addOption(coworkOption())\n    .action(async (options: { json?: boolean; cowork?: boolean }) => {\n      const { marketplaceListHandler } = await import(\n        './cli/handlers/plugins.js'\n      )\n      await marketplaceListHandler(options)\n    })\n\n  marketplaceCmd\n    .command('remove <name>')\n    .alias('rm')\n    .description('Remove a configured marketplace')\n    .addOption(coworkOption())\n    .action(async (name: string, options: { cowork?: boolean }) => {\n      const { marketplaceRemoveHandler } = await import(\n        './cli/handlers/plugins.js'\n      )\n      await marketplaceRemoveHandler(name, options)\n    })\n\n  marketplaceCmd\n    .command('update [name]')\n    .description(\n      'Update marketplace(s) from their source - updates all if no name specified',\n    )\n    .addOption(coworkOption())\n    .action(async (name: string | undefined, options: { cowork?: boolean }) => {\n      const { marketplaceUpdateHandler } = await import(\n        './cli/handlers/plugins.js'\n      )\n      await marketplaceUpdateHandler(name, options)\n    })\n\n  // Plugin install command\n  pluginCmd\n    .command('install <plugin>')\n    .alias('i')\n    .description(\n      'Install a plugin from available marketplaces (use plugin@marketplace for specific marketplace)',\n    )\n    .option(\n      '-s, --scope <scope>',\n      'Installation scope: user, project, or local',\n      'user',\n    )\n    .addOption(coworkOption())\n    .action(\n      async (plugin: string, options: { scope?: string; cowork?: boolean }) => {\n        const { pluginInstallHandler } = await import(\n          './cli/handlers/plugins.js'\n        )\n        await pluginInstallHandler(plugin, options)\n      },\n    )\n\n  // Plugin uninstall command\n  pluginCmd\n    .command('uninstall <plugin>')\n    .alias('remove')\n    .alias('rm')\n    .description('Uninstall an installed plugin')\n    .option(\n      '-s, --scope <scope>',\n      'Uninstall from scope: user, project, or local',\n      'user',\n    )\n    .option(\n      '--keep-data',\n      \"Preserve the plugin's persistent data directory (~/.claude/plugins/data/{id}/)\",\n    )\n    .addOption(coworkOption())\n    .action(\n      async (\n        plugin: string,\n        options: { scope?: string; cowork?: boolean; keepData?: boolean },\n      ) => {\n        const { pluginUninstallHandler } = await import(\n          './cli/handlers/plugins.js'\n        )\n        await pluginUninstallHandler(plugin, options)\n      },\n    )\n\n  // Plugin enable command\n  pluginCmd\n    .command('enable <plugin>')\n    .description('Enable a disabled plugin')\n    .option(\n      '-s, --scope <scope>',\n      `Installation scope: ${VALID_INSTALLABLE_SCOPES.join(', ')} (default: auto-detect)`,\n    )\n    .addOption(coworkOption())\n    .action(\n      async (plugin: string, options: { scope?: string; cowork?: boolean }) => {\n        const { pluginEnableHandler } = await import(\n          './cli/handlers/plugins.js'\n        )\n        await pluginEnableHandler(plugin, options)\n      },\n    )\n\n  // Plugin disable command\n  pluginCmd\n    .command('disable [plugin]')\n    .description('Disable an enabled plugin')\n    .option('-a, --all', 'Disable all enabled plugins')\n    .option(\n      '-s, --scope <scope>',\n      `Installation scope: ${VALID_INSTALLABLE_SCOPES.join(', ')} (default: auto-detect)`,\n    )\n    .addOption(coworkOption())\n    .action(\n      async (\n        plugin: string | undefined,\n        options: { scope?: string; cowork?: boolean; all?: boolean },\n      ) => {\n        const { pluginDisableHandler } = await import(\n          './cli/handlers/plugins.js'\n        )\n        await pluginDisableHandler(plugin, options)\n      },\n    )\n\n  // Plugin update command\n  pluginCmd\n    .command('update <plugin>')\n    .description(\n      'Update a plugin to the latest version (restart required to apply)',\n    )\n    .option(\n      '-s, --scope <scope>',\n      `Installation scope: ${VALID_UPDATE_SCOPES.join(', ')} (default: user)`,\n    )\n    .addOption(coworkOption())\n    .action(\n      async (plugin: string, options: { scope?: string; cowork?: boolean }) => {\n        const { pluginUpdateHandler } = await import(\n          './cli/handlers/plugins.js'\n        )\n        await pluginUpdateHandler(plugin, options)\n      },\n    )\n  // END ANT-ONLY\n\n  // Setup token command\n  program\n    .command('setup-token')\n    .description(\n      'Set up a long-lived authentication token (requires Claude subscription)',\n    )\n    .action(async () => {\n      const [{ setupTokenHandler }, { createRoot }] = await Promise.all([\n        import('./cli/handlers/util.js'),\n        import('./ink.js'),\n      ])\n      const root = await createRoot(getBaseRenderOptions(false))\n      await setupTokenHandler(root)\n    })\n\n  // Agents command - list configured agents\n  program\n    .command('agents')\n    .description('List configured agents')\n    .option(\n      '--setting-sources <sources>',\n      'Comma-separated list of setting sources to load (user, project, local).',\n    )\n    .action(async () => {\n      const { agentsHandler } = await import('./cli/handlers/agents.js')\n      await agentsHandler()\n      process.exit(0)\n    })\n\n  if (feature('TRANSCRIPT_CLASSIFIER')) {\n    // Skip when tengu_auto_mode_config.enabled === 'disabled' (circuit breaker).\n    // Reads from disk cache — GrowthBook isn't initialized at registration time.\n    if (getAutoModeEnabledStateIfCached() !== 'disabled') {\n      const autoModeCmd = program\n        .command('auto-mode')\n        .description('Inspect auto mode classifier configuration')\n\n      autoModeCmd\n        .command('defaults')\n        .description(\n          'Print the default auto mode environment, allow, and deny rules as JSON',\n        )\n        .action(async () => {\n          const { autoModeDefaultsHandler } = await import(\n            './cli/handlers/autoMode.js'\n          )\n          autoModeDefaultsHandler()\n          process.exit(0)\n        })\n\n      autoModeCmd\n        .command('config')\n        .description(\n          'Print the effective auto mode config as JSON: your settings where set, defaults otherwise',\n        )\n        .action(async () => {\n          const { autoModeConfigHandler } = await import(\n            './cli/handlers/autoMode.js'\n          )\n          autoModeConfigHandler()\n          process.exit(0)\n        })\n\n      autoModeCmd\n        .command('critique')\n        .description('Get AI feedback on your custom auto mode rules')\n        .option('--model <model>', 'Override which model is used')\n        .action(async options => {\n          const { autoModeCritiqueHandler } = await import(\n            './cli/handlers/autoMode.js'\n          )\n          await autoModeCritiqueHandler(options)\n          process.exit()\n        })\n    }\n  }\n\n  // Remote Control command — connect local environment to claude.ai/code.\n  // The actual command is intercepted by the fast-path in cli.tsx before\n  // Commander.js runs, so this registration exists only for help output.\n  // Always hidden: isBridgeEnabled() at this point (before enableConfigs)\n  // would throw inside isClaudeAISubscriber → getGlobalConfig and return\n  // false via the try/catch — but not before paying ~65ms of side effects\n  // (25ms settings Zod parse + 40ms sync `security` keychain subprocess).\n  // The dynamic visibility never worked; the command was always hidden.\n  if (feature('BRIDGE_MODE')) {\n    program\n      .command('remote-control', { hidden: true })\n      .alias('rc')\n      .description(\n        'Connect your local environment for remote-control sessions via claude.ai/code',\n      )\n      .action(async () => {\n        // Unreachable — cli.tsx fast-path handles this command before main.tsx loads.\n        // If somehow reached, delegate to bridgeMain.\n        const { bridgeMain } = await import('./bridge/bridgeMain.js')\n        await bridgeMain(process.argv.slice(3))\n      })\n  }\n\n  if (feature('KAIROS')) {\n    program\n      .command('assistant [sessionId]')\n      .description(\n        'Attach the REPL as a client to a running bridge session. Discovers sessions via API if no sessionId given.',\n      )\n      .action(() => {\n        // Argv rewriting above should have consumed `assistant [id]`\n        // before commander runs. Reaching here means a root flag came first\n        // (e.g. `--debug assistant`) and the position-0 predicate\n        // didn't match. Print usage like the ssh stub does.\n        process.stderr.write(\n          'Usage: claude assistant [sessionId]\\n\\n' +\n            'Attach the REPL as a viewer client to a running bridge session.\\n' +\n            'Omit sessionId to discover and pick from available sessions.\\n',\n        )\n        process.exit(1)\n      })\n  }\n\n  // Doctor command - check installation health\n  program\n    .command('doctor')\n    .description(\n      'Check the health of your Claude Code auto-updater. Note: The workspace trust dialog is skipped and stdio servers from .mcp.json are spawned for health checks. Only use this command in directories you trust.',\n    )\n    .action(async () => {\n      const [{ doctorHandler }, { createRoot }] = await Promise.all([\n        import('./cli/handlers/util.js'),\n        import('./ink.js'),\n      ])\n      const root = await createRoot(getBaseRenderOptions(false))\n      await doctorHandler(root)\n    })\n\n  // claude update\n  //\n  // For SemVer-compliant versioning with build metadata (X.X.X+SHA):\n  // - We perform exact string comparison (including SHA) to detect any change\n  // - This ensures users always get the latest build, even when only the SHA changes\n  // - UI shows both versions including build metadata for clarity\n  program\n    .command('update')\n    .alias('upgrade')\n    .description('Check for updates and install if available')\n    .action(async () => {\n      const { update } = await import('src/cli/update.js')\n      await update()\n    })\n\n  // claude up — run the project's CLAUDE.md \"# claude up\" setup instructions.\n  if (\"external\" === 'ant') {\n    program\n      .command('up')\n      .description(\n        '[ANT-ONLY] Initialize or upgrade the local dev environment using the \"# claude up\" section of the nearest CLAUDE.md',\n      )\n      .action(async () => {\n        const { up } = await import('src/cli/up.js')\n        await up()\n      })\n  }\n\n  // claude rollback (ant-only)\n  // Rolls back to previous releases\n  if (\"external\" === 'ant') {\n    program\n      .command('rollback [target]')\n      .description(\n        '[ANT-ONLY] Roll back to a previous release\\n\\nExamples:\\n  claude rollback                                    Go 1 version back from current\\n  claude rollback 3                                  Go 3 versions back from current\\n  claude rollback 2.0.73-dev.20251217.t190658        Roll back to a specific version',\n      )\n      .option('-l, --list', 'List recent published versions with ages')\n      .option('--dry-run', 'Show what would be installed without installing')\n      .option(\n        '--safe',\n        'Roll back to the server-pinned safe version (set by oncall during incidents)',\n      )\n      .action(\n        async (\n          target?: string,\n          options?: { list?: boolean; dryRun?: boolean; safe?: boolean },\n        ) => {\n          const { rollback } = await import('src/cli/rollback.js')\n          await rollback(target, options)\n        },\n      )\n  }\n\n  // claude install\n  program\n    .command('install [target]')\n    .description(\n      'Install Claude Code native build. Use [target] to specify version (stable, latest, or specific version)',\n    )\n    .option('--force', 'Force installation even if already installed')\n    .action(\n      async (target: string | undefined, options: { force?: boolean }) => {\n        const { installHandler } = await import('./cli/handlers/util.js')\n        await installHandler(target, options)\n      },\n    )\n\n  // ant-only commands\n  if (\"external\" === 'ant') {\n    const validateLogId = (value: string) => {\n      const maybeSessionId = validateUuid(value)\n      if (maybeSessionId) return maybeSessionId\n      return Number(value)\n    }\n    // claude log\n    program\n      .command('log')\n      .description('[ANT-ONLY] Manage conversation logs.')\n      .argument(\n        '[number|sessionId]',\n        'A number (0, 1, 2, etc.) to display a specific log, or the sesssion ID (uuid) of a log',\n        validateLogId,\n      )\n      .action(async (logId: string | number | undefined) => {\n        const { logHandler } = await import('./cli/handlers/ant.js')\n        await logHandler(logId)\n      })\n\n    // claude error\n    program\n      .command('error')\n      .description(\n        '[ANT-ONLY] View error logs. Optionally provide a number (0, -1, -2, etc.) to display a specific log.',\n      )\n      .argument(\n        '[number]',\n        'A number (0, 1, 2, etc.) to display a specific log',\n        parseInt,\n      )\n      .action(async (number: number | undefined) => {\n        const { errorHandler } = await import('./cli/handlers/ant.js')\n        await errorHandler(number)\n      })\n\n    // claude export\n    program\n      .command('export')\n      .description('[ANT-ONLY] Export a conversation to a text file.')\n      .usage('<source> <outputFile>')\n      .argument(\n        '<source>',\n        'Session ID, log index (0, 1, 2...), or path to a .json/.jsonl log file',\n      )\n      .argument('<outputFile>', 'Output file path for the exported text')\n      .addHelpText(\n        'after',\n        `\nExamples:\n  $ claude export 0 conversation.txt                Export conversation at log index 0\n  $ claude export <uuid> conversation.txt           Export conversation by session ID\n  $ claude export input.json output.txt             Render JSON log file to text\n  $ claude export <uuid>.jsonl output.txt           Render JSONL session file to text`,\n      )\n      .action(async (source: string, outputFile: string) => {\n        const { exportHandler } = await import('./cli/handlers/ant.js')\n        await exportHandler(source, outputFile)\n      })\n\n    if (\"external\" === 'ant') {\n      const taskCmd = program\n        .command('task')\n        .description('[ANT-ONLY] Manage task list tasks')\n\n      taskCmd\n        .command('create <subject>')\n        .description('Create a new task')\n        .option('-d, --description <text>', 'Task description')\n        .option('-l, --list <id>', 'Task list ID (defaults to \"tasklist\")')\n        .action(\n          async (\n            subject: string,\n            opts: { description?: string; list?: string },\n          ) => {\n            const { taskCreateHandler } = await import('./cli/handlers/ant.js')\n            await taskCreateHandler(subject, opts)\n          },\n        )\n\n      taskCmd\n        .command('list')\n        .description('List all tasks')\n        .option('-l, --list <id>', 'Task list ID (defaults to \"tasklist\")')\n        .option('--pending', 'Show only pending tasks')\n        .option('--json', 'Output as JSON')\n        .action(\n          async (opts: {\n            list?: string\n            pending?: boolean\n            json?: boolean\n          }) => {\n            const { taskListHandler } = await import('./cli/handlers/ant.js')\n            await taskListHandler(opts)\n          },\n        )\n\n      taskCmd\n        .command('get <id>')\n        .description('Get details of a task')\n        .option('-l, --list <id>', 'Task list ID (defaults to \"tasklist\")')\n        .action(async (id: string, opts: { list?: string }) => {\n          const { taskGetHandler } = await import('./cli/handlers/ant.js')\n          await taskGetHandler(id, opts)\n        })\n\n      taskCmd\n        .command('update <id>')\n        .description('Update a task')\n        .option('-l, --list <id>', 'Task list ID (defaults to \"tasklist\")')\n        .option(\n          '-s, --status <status>',\n          `Set status (${TASK_STATUSES.join(', ')})`,\n        )\n        .option('--subject <text>', 'Update subject')\n        .option('-d, --description <text>', 'Update description')\n        .option('--owner <agentId>', 'Set owner')\n        .option('--clear-owner', 'Clear owner')\n        .action(\n          async (\n            id: string,\n            opts: {\n              list?: string\n              status?: string\n              subject?: string\n              description?: string\n              owner?: string\n              clearOwner?: boolean\n            },\n          ) => {\n            const { taskUpdateHandler } = await import('./cli/handlers/ant.js')\n            await taskUpdateHandler(id, opts)\n          },\n        )\n\n      taskCmd\n        .command('dir')\n        .description('Show the tasks directory path')\n        .option('-l, --list <id>', 'Task list ID (defaults to \"tasklist\")')\n        .action(async (opts: { list?: string }) => {\n          const { taskDirHandler } = await import('./cli/handlers/ant.js')\n          await taskDirHandler(opts)\n        })\n    }\n\n    // claude completion <shell>\n    program\n      .command('completion <shell>', { hidden: true })\n      .description('Generate shell completion script (bash, zsh, or fish)')\n      .option(\n        '--output <file>',\n        'Write completion script directly to a file instead of stdout',\n      )\n      .action(async (shell: string, opts: { output?: string }) => {\n        const { completionHandler } = await import('./cli/handlers/ant.js')\n        await completionHandler(shell, opts, program)\n      })\n  }\n\n  profileCheckpoint('run_before_parse')\n  await program.parseAsync(process.argv)\n  profileCheckpoint('run_after_parse')\n\n  // Record final checkpoint for total_time calculation\n  profileCheckpoint('main_after_run')\n\n  // Log startup perf to Statsig (sampled) and output detailed report if enabled\n  profileReport()\n\n  return program\n}\n\nasync function logTenguInit({\n  hasInitialPrompt,\n  hasStdin,\n  verbose,\n  debug,\n  debugToStderr,\n  print,\n  outputFormat,\n  inputFormat,\n  numAllowedTools,\n  numDisallowedTools,\n  mcpClientCount,\n  worktreeEnabled,\n  skipWebFetchPreflight,\n  githubActionInputs,\n  dangerouslySkipPermissionsPassed,\n  permissionMode,\n  modeIsBypass,\n  allowDangerouslySkipPermissionsPassed,\n  systemPromptFlag,\n  appendSystemPromptFlag,\n  thinkingConfig,\n  assistantActivationPath,\n}: {\n  hasInitialPrompt: boolean\n  hasStdin: boolean\n  verbose: boolean\n  debug: boolean\n  debugToStderr: boolean\n  print: boolean\n  outputFormat: string\n  inputFormat: string\n  numAllowedTools: number\n  numDisallowedTools: number\n  mcpClientCount: number\n  worktreeEnabled: boolean\n  skipWebFetchPreflight: boolean | undefined\n  githubActionInputs: string | undefined\n  dangerouslySkipPermissionsPassed: boolean\n  permissionMode: string\n  modeIsBypass: boolean\n  allowDangerouslySkipPermissionsPassed: boolean\n  systemPromptFlag: 'file' | 'flag' | undefined\n  appendSystemPromptFlag: 'file' | 'flag' | undefined\n  thinkingConfig: ThinkingConfig\n  assistantActivationPath: string | undefined\n}): Promise<void> {\n  try {\n    logEvent('tengu_init', {\n      entrypoint:\n        'claude' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      hasInitialPrompt,\n      hasStdin,\n      verbose,\n      debug,\n      debugToStderr,\n      print,\n      outputFormat:\n        outputFormat as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      inputFormat:\n        inputFormat as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      numAllowedTools,\n      numDisallowedTools,\n      mcpClientCount,\n      worktree: worktreeEnabled,\n      skipWebFetchPreflight,\n      ...(githubActionInputs && {\n        githubActionInputs:\n          githubActionInputs as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      }),\n      dangerouslySkipPermissionsPassed,\n      permissionMode:\n        permissionMode as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      modeIsBypass,\n      inProtectedNamespace: isInProtectedNamespace(),\n      allowDangerouslySkipPermissionsPassed,\n      thinkingType:\n        thinkingConfig.type as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      ...(systemPromptFlag && {\n        systemPromptFlag:\n          systemPromptFlag as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      }),\n      ...(appendSystemPromptFlag && {\n        appendSystemPromptFlag:\n          appendSystemPromptFlag as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      }),\n      is_simple: isBareMode() || undefined,\n      is_coordinator:\n        feature('COORDINATOR_MODE') &&\n        coordinatorModeModule?.isCoordinatorMode()\n          ? true\n          : undefined,\n      ...(assistantActivationPath && {\n        assistantActivationPath:\n          assistantActivationPath as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      }),\n      autoUpdatesChannel: (getInitialSettings().autoUpdatesChannel ??\n        'latest') as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      ...(\"external\" === 'ant'\n        ? (() => {\n            const cwd = getCwd()\n            const gitRoot = findGitRoot(cwd)\n            const rp = gitRoot ? relative(gitRoot, cwd) || '.' : undefined\n            return rp\n              ? {\n                  relativeProjectPath:\n                    rp as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n                }\n              : {}\n          })()\n        : {}),\n    })\n  } catch (error) {\n    logError(error)\n  }\n}\n\nfunction maybeActivateProactive(options: unknown): void {\n  if (\n    (feature('PROACTIVE') || feature('KAIROS')) &&\n    ((options as { proactive?: boolean }).proactive ||\n      isEnvTruthy(process.env.CLAUDE_CODE_PROACTIVE))\n  ) {\n    // eslint-disable-next-line @typescript-eslint/no-require-imports\n    const proactiveModule = require('./proactive/index.js')\n    if (!proactiveModule.isProactiveActive()) {\n      proactiveModule.activateProactive('command')\n    }\n  }\n}\n\nfunction maybeActivateBrief(options: unknown): void {\n  if (!(feature('KAIROS') || feature('KAIROS_BRIEF'))) return\n  const briefFlag = (options as { brief?: boolean }).brief\n  const briefEnv = isEnvTruthy(process.env.CLAUDE_CODE_BRIEF)\n  if (!briefFlag && !briefEnv) return\n  // --brief / CLAUDE_CODE_BRIEF are explicit opt-ins: check entitlement,\n  // then set userMsgOptIn to activate the tool + prompt section. The env\n  // var also grants entitlement (isBriefEntitled() reads it), so setting\n  // CLAUDE_CODE_BRIEF=1 alone force-enables for dev/testing — no GB gate\n  // needed. initialIsBriefOnly reads getUserMsgOptIn() directly.\n  // Conditional require: static import would leak the tool name string\n  // into external builds via BriefTool.ts → prompt.ts.\n  /* eslint-disable @typescript-eslint/no-require-imports */\n  const { isBriefEntitled } =\n    require('./tools/BriefTool/BriefTool.js') as typeof import('./tools/BriefTool/BriefTool.js')\n  /* eslint-enable @typescript-eslint/no-require-imports */\n  const entitled = isBriefEntitled()\n  if (entitled) {\n    setUserMsgOptIn(true)\n  }\n  // Fire unconditionally once intent is seen: enabled=false captures the\n  // \"user tried but was gated\" failure mode in Datadog.\n  logEvent('tengu_brief_mode_enabled', {\n    enabled: entitled,\n    gated: !entitled,\n    source: (briefEnv\n      ? 'env'\n      : 'flag') as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  })\n}\n\nfunction resetCursor() {\n  const terminal = process.stderr.isTTY\n    ? process.stderr\n    : process.stdout.isTTY\n      ? process.stdout\n      : undefined\n  terminal?.write(SHOW_CURSOR)\n}\n\ntype TeammateOptions = {\n  agentId?: string\n  agentName?: string\n  teamName?: string\n  agentColor?: string\n  planModeRequired?: boolean\n  parentSessionId?: string\n  teammateMode?: 'auto' | 'tmux' | 'in-process'\n  agentType?: string\n}\n\nfunction extractTeammateOptions(options: unknown): TeammateOptions {\n  if (typeof options !== 'object' || options === null) {\n    return {}\n  }\n  const opts = options as Record<string, unknown>\n  const teammateMode = opts.teammateMode\n  return {\n    agentId: typeof opts.agentId === 'string' ? opts.agentId : undefined,\n    agentName: typeof opts.agentName === 'string' ? opts.agentName : undefined,\n    teamName: typeof opts.teamName === 'string' ? opts.teamName : undefined,\n    agentColor:\n      typeof opts.agentColor === 'string' ? opts.agentColor : undefined,\n    planModeRequired:\n      typeof opts.planModeRequired === 'boolean'\n        ? opts.planModeRequired\n        : undefined,\n    parentSessionId:\n      typeof opts.parentSessionId === 'string'\n        ? opts.parentSessionId\n        : undefined,\n    teammateMode:\n      teammateMode === 'auto' ||\n      teammateMode === 'tmux' ||\n      teammateMode === 'in-process'\n        ? teammateMode\n        : undefined,\n    agentType: typeof opts.agentType === 'string' ? opts.agentType : undefined,\n  }\n}\n"],"mappings":"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","ignoreList":[]}