main.tsx

// These side-effects must run before all other imports:
// 1. profileCheckpoint marks entry before heavy module evaluation begins
// 2. startMdmRawRead fires MDM subprocesses (plutil/reg query) so they run in
//    parallel with the remaining ~135ms of imports below
// 3. startKeychainPrefetch fires both macOS keychain reads (OAuth + legacy API
//    key) in parallel — isRemoteManagedSettingsEligible() otherwise reads them
//    sequentially via sync spawn inside applySafeConfigEnvironmentVariables()
//    (~65ms on every macOS startup)
import { profileCheckpoint, profileReport } from './utils/startupProfiler.js';

// eslint-disable-next-line custom-rules/no-top-level-side-effects
profileCheckpoint('main_tsx_entry');
import { startMdmRawRead } from './utils/settings/mdm/rawRead.js';

// eslint-disable-next-line custom-rules/no-top-level-side-effects
startMdmRawRead();
import { ensureKeychainPrefetchCompleted, startKeychainPrefetch } from './utils/secureStorage/keychainPrefetch.js';

// eslint-disable-next-line custom-rules/no-top-level-side-effects
startKeychainPrefetch();
import { feature } from 'bun:bundle';
import { Command as CommanderCommand, InvalidArgumentError, Option } from '@commander-js/extra-typings';
import chalk from 'chalk';
import { readFileSync } from 'fs';
import mapValues from 'lodash-es/mapValues.js';
import pickBy from 'lodash-es/pickBy.js';
import uniqBy from 'lodash-es/uniqBy.js';
import React from 'react';
import { getOauthConfig } from './constants/oauth.js';
import { getRemoteSessionUrl } from './constants/product.js';
import { getSystemContext, getUserContext } from './context.js';
import { init, initializeTelemetryAfterTrust } from './entrypoints/init.js';
import { addToHistory } from './history.js';
import type { Root } from './ink.js';
import { launchRepl } from './replLauncher.js';
import { hasGrowthBookEnvOverride, initializeGrowthBook, refreshGrowthBookAfterAuthChange } from './services/analytics/growthbook.js';
import { fetchBootstrapData } from './services/api/bootstrap.js';
import { type DownloadResult, downloadSessionFiles, type FilesApiConfig, parseFileSpecs } from './services/api/filesApi.js';
import { prefetchPassesEligibility } from './services/api/referral.js';
import { prefetchOfficialMcpUrls } from './services/mcp/officialRegistry.js';
import type { McpSdkServerConfig, McpServerConfig, ScopedMcpServerConfig } from './services/mcp/types.js';
import { isPolicyAllowed, loadPolicyLimits, refreshPolicyLimits, waitForPolicyLimitsToLoad } from './services/policyLimits/index.js';
import { loadRemoteManagedSettings, refreshRemoteManagedSettings } from './services/remoteManagedSettings/index.js';
import type { ToolInputJSONSchema } from './Tool.js';
import { createSyntheticOutputTool, isSyntheticOutputToolEnabled } from './tools/SyntheticOutputTool/SyntheticOutputTool.js';
import { getTools } from './tools.js';
import { canUserConfigureAdvisor, getInitialAdvisorSetting, isAdvisorEnabled, isValidAdvisorModel, modelSupportsAdvisor } from './utils/advisor.js';
import { isAgentSwarmsEnabled } from './utils/agentSwarmsEnabled.js';
import { count, uniq } from './utils/array.js';
import { installAsciicastRecorder } from './utils/asciicast.js';
import { getSubscriptionType, isClaudeAISubscriber, prefetchAwsCredentialsAndBedRockInfoIfSafe, prefetchGcpCredentialsIfSafe, validateForceLoginOrg } from './utils/auth.js';
import { checkHasTrustDialogAccepted, getGlobalConfig, getRemoteControlAtStartup, isAutoUpdaterDisabled, saveGlobalConfig } from './utils/config.js';
import { seedEarlyInput, stopCapturingEarlyInput } from './utils/earlyInput.js';
import { getInitialEffortSetting, parseEffortValue } from './utils/effort.js';
import { getInitialFastModeSetting, isFastModeEnabled, prefetchFastModeStatus, resolveFastModeStatusFromCache } from './utils/fastMode.js';
import { applyConfigEnvironmentVariables } from './utils/managedEnv.js';
import { createSystemMessage, createUserMessage } from './utils/messages.js';
import { getPlatform } from './utils/platform.js';
import { getBaseRenderOptions } from './utils/renderOptions.js';
import { getSessionIngressAuthToken } from './utils/sessionIngressAuth.js';
import { settingsChangeDetector } from './utils/settings/changeDetector.js';
import { skillChangeDetector } from './utils/skills/skillChangeDetector.js';
import { jsonParse, writeFileSync_DEPRECATED } from './utils/slowOperations.js';
import { computeInitialTeamContext } from './utils/swarm/reconnection.js';
import { initializeWarningHandler } from './utils/warningHandler.js';
import { isWorktreeModeEnabled } from './utils/worktreeModeEnabled.js';

// Lazy require to avoid circular dependency: teammate.ts -> AppState.tsx -> ... -> main.tsx
/* eslint-disable @typescript-eslint/no-require-imports */
const getTeammateUtils = () => require('./utils/teammate.js') as typeof import('./utils/teammate.js');
const getTeammatePromptAddendum = () => require('./utils/swarm/teammatePromptAddendum.js') as typeof import('./utils/swarm/teammatePromptAddendum.js');
const getTeammateModeSnapshot = () => require('./utils/swarm/backends/teammateModeSnapshot.js') as typeof import('./utils/swarm/backends/teammateModeSnapshot.js');
/* eslint-enable @typescript-eslint/no-require-imports */
// Dead code elimination: conditional import for COORDINATOR_MODE
/* eslint-disable @typescript-eslint/no-require-imports */
const coordinatorModeModule = feature('COORDINATOR_MODE') ? require('./coordinator/coordinatorMode.js') as typeof import('./coordinator/coordinatorMode.js') : null;
/* eslint-enable @typescript-eslint/no-require-imports */
// Dead code elimination: conditional import for KAIROS (assistant mode)
/* eslint-disable @typescript-eslint/no-require-imports */
const assistantModule = feature('KAIROS') ? require('./assistant/index.js') as typeof import('./assistant/index.js') : null;
const kairosGate = feature('KAIROS') ? require('./assistant/gate.js') as typeof import('./assistant/gate.js') : null;
import { relative, resolve } from 'path';
import { isAnalyticsDisabled } from 'src/services/analytics/config.js';
import { getFeatureValue_CACHED_MAY_BE_STALE } from 'src/services/analytics/growthbook.js';
import { type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, logEvent } from 'src/services/analytics/index.js';
import { initializeAnalyticsGates } from 'src/services/analytics/sink.js';
import { getOriginalCwd, setAdditionalDirectoriesForClaudeMd, setIsRemoteMode, setMainLoopModelOverride, setMainThreadAgentType, setTeleportedSessionInfo } from './bootstrap/state.js';
import { filterCommandsForRemoteMode, getCommands } from './commands.js';
import type { StatsStore } from './context/stats.js';
import { launchAssistantInstallWizard, launchAssistantSessionChooser, launchInvalidSettingsDialog, launchResumeChooser, launchSnapshotUpdateDialog, launchTeleportRepoMismatchDialog, launchTeleportResumeWrapper } from './dialogLaunchers.js';
import { SHOW_CURSOR } from './ink/termio/dec.js';
import { exitWithError, exitWithMessage, getRenderContext, renderAndRun, showSetupScreens } from './interactiveHelpers.js';
import { initBuiltinPlugins } from './plugins/bundled/index.js';
/* eslint-enable @typescript-eslint/no-require-imports */
import { checkQuotaStatus } from './services/claudeAiLimits.js';
import { getMcpToolsCommandsAndResources, prefetchAllMcpResources } from './services/mcp/client.js';
import { VALID_INSTALLABLE_SCOPES, VALID_UPDATE_SCOPES } from './services/plugins/pluginCliCommands.js';
import { initBundledSkills } from './skills/bundled/index.js';
import type { AgentColorName } from './tools/AgentTool/agentColorManager.js';
import { getActiveAgentsFromList, getAgentDefinitionsWithOverrides, isBuiltInAgent, isCustomAgent, parseAgentsFromJson } from './tools/AgentTool/loadAgentsDir.js';
import type { LogOption } from './types/logs.js';
import type { Message as MessageType } from './types/message.js';
import { assertMinVersion } from './utils/autoUpdater.js';
import { CLAUDE_IN_CHROME_SKILL_HINT, CLAUDE_IN_CHROME_SKILL_HINT_WITH_WEBBROWSER } from './utils/claudeInChrome/prompt.js';
import { setupClaudeInChrome, shouldAutoEnableClaudeInChrome, shouldEnableClaudeInChrome } from './utils/claudeInChrome/setup.js';
import { getContextWindowForModel } from './utils/context.js';
import { loadConversationForResume } from './utils/conversationRecovery.js';
import { buildDeepLinkBanner } from './utils/deepLink/banner.js';
import { hasNodeOption, isBareMode, isEnvTruthy, isInProtectedNamespace } from './utils/envUtils.js';
import { refreshExampleCommands } from './utils/exampleCommands.js';
import type { FpsMetrics } from './utils/fpsTracker.js';
import { getWorktreePaths } from './utils/getWorktreePaths.js';
import { findGitRoot, getBranch, getIsGit, getWorktreeCount } from './utils/git.js';
import { getGhAuthStatus } from './utils/github/ghAuthStatus.js';
import { safeParseJSON } from './utils/json.js';
import { logError } from './utils/log.js';
import { getModelDeprecationWarning } from './utils/model/deprecation.js';
import { getDefaultMainLoopModel, getUserSpecifiedModelSetting, normalizeModelStringForAPI, parseUserSpecifiedModel } from './utils/model/model.js';
import { ensureModelStringsInitialized } from './utils/model/modelStrings.js';
import { PERMISSION_MODES } from './utils/permissions/PermissionMode.js';
import { checkAndDisableBypassPermissions, getAutoModeEnabledStateIfCached, initializeToolPermissionContext, initialPermissionModeFromCLI, isDefaultPermissionModeAuto, parseToolListFromCLI, removeDangerousPermissions, stripDangerousPermissionsForAutoMode, verifyAutoModeGateAccess } from './utils/permissions/permissionSetup.js';
import { cleanupOrphanedPluginVersionsInBackground } from './utils/plugins/cacheUtils.js';
import { initializeVersionedPlugins } from './utils/plugins/installedPluginsManager.js';
import { getManagedPluginNames } from './utils/plugins/managedPlugins.js';
import { getGlobExclusionsForPluginCache } from './utils/plugins/orphanedPluginFilter.js';
import { getPluginSeedDirs } from './utils/plugins/pluginDirectories.js';
import { countFilesRoundedRg } from './utils/ripgrep.js';
import { processSessionStartHooks, processSetupHooks } from './utils/sessionStart.js';
import { cacheSessionTitle, getSessionIdFromLog, loadTranscriptFromFile, saveAgentSetting, saveMode, searchSessionsByCustomTitle, sessionIdExists } from './utils/sessionStorage.js';
import { ensureMdmSettingsLoaded } from './utils/settings/mdm/settings.js';
import { getInitialSettings, getManagedSettingsKeysForLogging, getSettingsForSource, getSettingsWithErrors } from './utils/settings/settings.js';
import { resetSettingsCache } from './utils/settings/settingsCache.js';
import type { ValidationError } from './utils/settings/validation.js';
import { DEFAULT_TASKS_MODE_TASK_LIST_ID, TASK_STATUSES } from './utils/tasks.js';
import { logPluginLoadErrors, logPluginsEnabledForSession } from './utils/telemetry/pluginTelemetry.js';
import { logSkillsLoaded } from './utils/telemetry/skillLoadedEvent.js';
import { generateTempFilePath } from './utils/tempfile.js';
import { validateUuid } from './utils/uuid.js';
// Plugin startup checks are now handled non-blockingly in REPL.tsx

import { registerMcpAddCommand } from 'src/commands/mcp/addCommand.js';
import { registerMcpXaaIdpCommand } from 'src/commands/mcp/xaaIdpCommand.js';
import { logPermissionContextForAnts } from 'src/services/internalLogging.js';
import { fetchClaudeAIMcpConfigsIfEligible } from 'src/services/mcp/claudeai.js';
import { clearServerCache } from 'src/services/mcp/client.js';
import { areMcpConfigsAllowedWithEnterpriseMcpConfig, dedupClaudeAiMcpServers, doesEnterpriseMcpConfigExist, filterMcpServersByPolicy, getClaudeCodeMcpConfigs, getMcpServerSignature, parseMcpConfig, parseMcpConfigFromFilePath } from 'src/services/mcp/config.js';
import { excludeCommandsByServer, excludeResourcesByServer } from 'src/services/mcp/utils.js';
import { isXaaEnabled } from 'src/services/mcp/xaaIdpLogin.js';
import { getRelevantTips } from 'src/services/tips/tipRegistry.js';
import { logContextMetrics } from 'src/utils/api.js';
import { CLAUDE_IN_CHROME_MCP_SERVER_NAME, isClaudeInChromeMCPServer } from 'src/utils/claudeInChrome/common.js';
import { registerCleanup } from 'src/utils/cleanupRegistry.js';
import { eagerParseCliFlag } from 'src/utils/cliArgs.js';
import { createEmptyAttributionState } from 'src/utils/commitAttribution.js';
import { countConcurrentSessions, registerSession, updateSessionName } from 'src/utils/concurrentSessions.js';
import { getCwd } from 'src/utils/cwd.js';
import { logForDebugging, setHasFormattedOutput } from 'src/utils/debug.js';
import { errorMessage, getErrnoCode, isENOENT, TeleportOperationError, toError } from 'src/utils/errors.js';
import { getFsImplementation, safeResolvePath } from 'src/utils/fsOperations.js';
import { gracefulShutdown, gracefulShutdownSync } from 'src/utils/gracefulShutdown.js';
import { setAllHookEventsEnabled } from 'src/utils/hooks/hookEvents.js';
import { refreshModelCapabilities } from 'src/utils/model/modelCapabilities.js';
import { peekForStdinData, writeToStderr } from 'src/utils/process.js';
import { setCwd } from 'src/utils/Shell.js';
import { type ProcessedResume, processResumedConversation } from 'src/utils/sessionRestore.js';
import { parseSettingSourcesFlag } from 'src/utils/settings/constants.js';
import { plural } from 'src/utils/stringUtils.js';
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';

/* eslint-disable @typescript-eslint/no-require-imports */
const autoModeStateModule = feature('TRANSCRIPT_CLASSIFIER') ? require('./utils/permissions/autoModeState.js') as typeof import('./utils/permissions/autoModeState.js') : null;

// TeleportRepoMismatchDialog, TeleportResumeWrapper dynamically imported at call sites
import { migrateAutoUpdatesToSettings } from './migrations/migrateAutoUpdatesToSettings.js';
import { migrateBypassPermissionsAcceptedToSettings } from './migrations/migrateBypassPermissionsAcceptedToSettings.js';
import { migrateEnableAllProjectMcpServersToSettings } from './migrations/migrateEnableAllProjectMcpServersToSettings.js';
import { migrateFennecToOpus } from './migrations/migrateFennecToOpus.js';
import { migrateLegacyOpusToCurrent } from './migrations/migrateLegacyOpusToCurrent.js';
import { migrateOpusToOpus1m } from './migrations/migrateOpusToOpus1m.js';
import { migrateReplBridgeEnabledToRemoteControlAtStartup } from './migrations/migrateReplBridgeEnabledToRemoteControlAtStartup.js';
import { migrateSonnet1mToSonnet45 } from './migrations/migrateSonnet1mToSonnet45.js';
import { migrateSonnet45ToSonnet46 } from './migrations/migrateSonnet45ToSonnet46.js';
import { resetAutoModeOptInForDefaultOffer } from './migrations/resetAutoModeOptInForDefaultOffer.js';
import { resetProToOpusDefault } from './migrations/resetProToOpusDefault.js';
import { createRemoteSessionConfig } from './remote/RemoteSessionManager.js';
/* eslint-enable @typescript-eslint/no-require-imports */
// teleportWithProgress dynamically imported at call site
import { createDirectConnectSession, DirectConnectError } from './server/createDirectConnectSession.js';
import { initializeLspServerManager } from './services/lsp/manager.js';
import { shouldEnablePromptSuggestion } from './services/PromptSuggestion/promptSuggestion.js';
import { type AppState, getDefaultAppState, IDLE_SPECULATION_STATE } from './state/AppStateStore.js';
import { onChangeAppState } from './state/onChangeAppState.js';
import { createStore } from './state/store.js';
import { asSessionId } from './types/ids.js';
import { filterAllowedSdkBetas } from './utils/betas.js';
import { isInBundledMode, isRunningWithBun } from './utils/bundledMode.js';
import { logForDiagnosticsNoPII } from './utils/diagLogs.js';
import { filterExistingPaths, getKnownPathsForRepo } from './utils/githubRepoPathMapping.js';
import { clearPluginCache, loadAllPluginsCacheOnly } from './utils/plugins/pluginLoader.js';
import { migrateChangelogFromConfig } from './utils/releaseNotes.js';
import { SandboxManager } from './utils/sandbox/sandbox-adapter.js';
import { fetchSession, prepareApiRequest } from './utils/teleport/api.js';
import { checkOutTeleportedSessionBranch, processMessagesForTeleportResume, teleportToRemoteWithErrorHandling, validateGitState, validateSessionRepository } from './utils/teleport.js';
import { shouldEnableThinkingByDefault, type ThinkingConfig } from './utils/thinking.js';
import { initUser, resetUserCache } from './utils/user.js';
import { getTmuxInstallInstructions, isTmuxAvailable, parsePRReference } from './utils/worktree.js';

// eslint-disable-next-line custom-rules/no-top-level-side-effects
profileCheckpoint('main_tsx_imports_loaded');

/**
 * Log managed settings keys to Statsig for analytics.
 * This is called after init() completes to ensure settings are loaded
 * and environment variables are applied before model resolution.
 */
function logManagedSettings(): void {
  try {
    const policySettings = getSettingsForSource('policySettings');
    if (policySettings) {
      const allKeys = getManagedSettingsKeysForLogging(policySettings);
      logEvent('tengu_managed_settings_loaded', {
        keyCount: allKeys.length,
        keys: allKeys.join(',') as unknown as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
      });
    }
  } catch {
    // Silently ignore errors - this is just for analytics
  }
}

// Check if running in debug/inspection mode
function isBeingDebugged() {
  const isBun = isRunningWithBun();

  // Check for inspect flags in process arguments (including all variants)
  const hasInspectArg = process.execArgv.some(arg => {
    if (isBun) {
      // Note: Bun has an issue with single-file executables where application arguments
      // from process.argv leak into process.execArgv (similar to https://github.com/oven-sh/bun/issues/11673)
      // This breaks use of --debug mode if we omit this branch
      // We're fine to skip that check, because Bun doesn't support Node.js legacy --debug or --debug-brk flags
      return /--inspect(-brk)?/.test(arg);
    } else {
      // In Node.js, check for both --inspect and legacy --debug flags
      return /--inspect(-brk)?|--debug(-brk)?/.test(arg);
    }
  });

  // Check if NODE_OPTIONS contains inspect flags
  const hasInspectEnv = process.env.NODE_OPTIONS && /--inspect(-brk)?|--debug(-brk)?/.test(process.env.NODE_OPTIONS);

  // Check if inspector is available and active (indicates debugging)
  try {
    // Dynamic import would be better but is async - use global object instead
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    const inspector = (global as any).require('inspector');
    const hasInspectorUrl = !!inspector.url();
    return hasInspectorUrl || hasInspectArg || hasInspectEnv;
  } catch {
    // Ignore error and fall back to argument detection
    return hasInspectArg || hasInspectEnv;
  }
}

// Exit if we detect node debugging or inspection
if ("external" !== 'ant' && isBeingDebugged()) {
  // Use process.exit directly here since we're in the top-level code before imports
  // and gracefulShutdown is not yet available
  // eslint-disable-next-line custom-rules/no-top-level-side-effects
  process.exit(1);
}

/**
 * Per-session skill/plugin telemetry. Called from both the interactive path
 * and the headless -p path (before runHeadless) — both go through
 * main.tsx but branch before the interactive startup path, so it needs two
 * call sites here rather than one here + one in QueryEngine.
 */
function logSessionTelemetry(): void {
  const model = parseUserSpecifiedModel(getInitialMainLoopModel() ?? getDefaultMainLoopModel());
  void logSkillsLoaded(getCwd(), getContextWindowForModel(model, getSdkBetas()));
  void loadAllPluginsCacheOnly().then(({
    enabled,
    errors
  }) => {
    const managedNames = getManagedPluginNames();
    logPluginsEnabledForSession(enabled, managedNames, getPluginSeedDirs());
    logPluginLoadErrors(errors, managedNames);
  }).catch(err => logError(err));
}
function getCertEnvVarTelemetry(): Record<string, boolean> {
  const result: Record<string, boolean> = {};
  if (process.env.NODE_EXTRA_CA_CERTS) {
    result.has_node_extra_ca_certs = true;
  }
  if (process.env.CLAUDE_CODE_CLIENT_CERT) {
    result.has_client_cert = true;
  }
  if (hasNodeOption('--use-system-ca')) {
    result.has_use_system_ca = true;
  }
  if (hasNodeOption('--use-openssl-ca')) {
    result.has_use_openssl_ca = true;
  }
  return result;
}
async function logStartupTelemetry(): Promise<void> {
  if (isAnalyticsDisabled()) return;
  const [isGit, worktreeCount, ghAuthStatus] = await Promise.all([getIsGit(), getWorktreeCount(), getGhAuthStatus()]);
  logEvent('tengu_startup_telemetry', {
    is_git: isGit,
    worktree_count: worktreeCount,
    gh_auth_status: ghAuthStatus as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
    sandbox_enabled: SandboxManager.isSandboxingEnabled(),
    are_unsandboxed_commands_allowed: SandboxManager.areUnsandboxedCommandsAllowed(),
    is_auto_bash_allowed_if_sandbox_enabled: SandboxManager.isAutoAllowBashIfSandboxedEnabled(),
    auto_updater_disabled: isAutoUpdaterDisabled(),
    prefers_reduced_motion: getInitialSettings().prefersReducedMotion ?? false,
    ...getCertEnvVarTelemetry()
  });
}

// @[MODEL LAUNCH]: Consider any migrations you may need for model strings. See migrateSonnet1mToSonnet45.ts for an example.
// Bump this when adding a new sync migration so existing users re-run the set.
const CURRENT_MIGRATION_VERSION = 11;
function runMigrations(): void {
  if (getGlobalConfig().migrationVersion !== CURRENT_MIGRATION_VERSION) {
    migrateAutoUpdatesToSettings();
    migrateBypassPermissionsAcceptedToSettings();
    migrateEnableAllProjectMcpServersToSettings();
    resetProToOpusDefault();
    migrateSonnet1mToSonnet45();
    migrateLegacyOpusToCurrent();
    migrateSonnet45ToSonnet46();
    migrateOpusToOpus1m();
    migrateReplBridgeEnabledToRemoteControlAtStartup();
    if (feature('TRANSCRIPT_CLASSIFIER')) {
      resetAutoModeOptInForDefaultOffer();
    }
    if ("external" === 'ant') {
      migrateFennecToOpus();
    }
    saveGlobalConfig(prev => prev.migrationVersion === CURRENT_MIGRATION_VERSION ? prev : {
      ...prev,
      migrationVersion: CURRENT_MIGRATION_VERSION
    });
  }
  // Async migration - fire and forget since it's non-blocking
  migrateChangelogFromConfig().catch(() => {
    // Silently ignore migration errors - will retry on next startup
  });
}

/**
 * Prefetch system context (including git status) only when it's safe to do so.
 * Git commands can execute arbitrary code via hooks and config (e.g., core.fsmonitor,
 * diff.external), so we must only run them after trust is established or in
 * non-interactive mode where trust is implicit.
 */
function prefetchSystemContextIfSafe(): void {
  const isNonInteractiveSession = getIsNonInteractiveSession();

  // In non-interactive mode (--print), trust dialog is skipped and
  // execution is considered trusted (as documented in help text)
  if (isNonInteractiveSession) {
    logForDiagnosticsNoPII('info', 'prefetch_system_context_non_interactive');
    void getSystemContext();
    return;
  }

  // In interactive mode, only prefetch if trust has already been established
  const hasTrust = checkHasTrustDialogAccepted();
  if (hasTrust) {
    logForDiagnosticsNoPII('info', 'prefetch_system_context_has_trust');
    void getSystemContext();
  } else {
    logForDiagnosticsNoPII('info', 'prefetch_system_context_skipped_no_trust');
  }
  // Otherwise, don't prefetch - wait for trust to be established first
}

/**
 * Start background prefetches and housekeeping that are NOT needed before first render.
 * These are deferred from setup() to reduce event loop contention and child process
 * spawning during the critical startup path.
 * Call this after the REPL has been rendered.
 */
export function startDeferredPrefetches(): void {
  // This function runs after first render, so it doesn't block the initial paint.
  // However, the spawned processes and async work still contend for CPU and event
  // loop time, which skews startup benchmarks (CPU profiles, time-to-first-render
  // measurements). Skip all of it when we're only measuring startup performance.
  if (isEnvTruthy(process.env.CLAUDE_CODE_EXIT_AFTER_FIRST_RENDER) ||
  // --bare: skip ALL prefetches. These are cache-warms for the REPL's
  // first-turn responsiveness (initUser, getUserContext, tips, countFiles,
  // modelCapabilities, change detectors). Scripted -p calls don't have a
  // "user is typing" window to hide this work in — it's pure overhead on
  // the critical path.
  isBareMode()) {
    return;
  }

  // Process-spawning prefetches (consumed at first API call, user is still typing)
  void initUser();
  void getUserContext();
  prefetchSystemContextIfSafe();
  void getRelevantTips();
  if (isEnvTruthy(process.env.CLAUDE_CODE_USE_BEDROCK) && !isEnvTruthy(process.env.CLAUDE_CODE_SKIP_BEDROCK_AUTH)) {
    void prefetchAwsCredentialsAndBedRockInfoIfSafe();
  }
  if (isEnvTruthy(process.env.CLAUDE_CODE_USE_VERTEX) && !isEnvTruthy(process.env.CLAUDE_CODE_SKIP_VERTEX_AUTH)) {
    void prefetchGcpCredentialsIfSafe();
  }
  void countFilesRoundedRg(getCwd(), AbortSignal.timeout(3000), []);

  // Analytics and feature flag initialization
  void initializeAnalyticsGates();
  void prefetchOfficialMcpUrls();
  void refreshModelCapabilities();

  // File change detectors deferred from init() to unblock first render
  void settingsChangeDetector.initialize();
  if (!isBareMode()) {
    void skillChangeDetector.initialize();
  }

  // Event loop stall detector — logs when the main thread is blocked >500ms
  if ("external" === 'ant') {
    void import('./utils/eventLoopStallDetector.js').then(m => m.startEventLoopStallDetector());
  }
}
function loadSettingsFromFlag(settingsFile: string): void {
  try {
    const trimmedSettings = settingsFile.trim();
    const looksLikeJson = trimmedSettings.startsWith('{') && trimmedSettings.endsWith('}');
    let settingsPath: string;
    if (looksLikeJson) {
      // It's a JSON string - validate and create temp file
      const parsedJson = safeParseJSON(trimmedSettings);
      if (!parsedJson) {
        process.stderr.write(chalk.red('Error: Invalid JSON provided to --settings\n'));
        process.exit(1);
      }

      // Create a temporary file and write the JSON to it.
      // Use a content-hash-based path instead of random UUID to avoid
      // busting the Anthropic API prompt cache. The settings path ends up
      // in the Bash tool's sandbox denyWithinAllow list, which is part of
      // the tool description sent to the API. A random UUID per subprocess
      // changes the tool description on every query() call, invalidating
      // the cache prefix and causing a 12x input token cost penalty.
      // The content hash ensures identical settings produce the same path
      // across process boundaries (each SDK query() spawns a new process).
      settingsPath = generateTempFilePath('claude-settings', '.json', {
        contentHash: trimmedSettings
      });
      writeFileSync_DEPRECATED(settingsPath, trimmedSettings, 'utf8');
    } else {
      // It's a file path - resolve and validate by attempting to read
      const {
        resolvedPath: resolvedSettingsPath
      } = safeResolvePath(getFsImplementation(), settingsFile);
      try {
        readFileSync(resolvedSettingsPath, 'utf8');
      } catch (e) {
        if (isENOENT(e)) {
          process.stderr.write(chalk.red(`Error: Settings file not found: ${resolvedSettingsPath}\n`));
          process.exit(1);
        }
        throw e;
      }
      settingsPath = resolvedSettingsPath;
    }
    setFlagSettingsPath(settingsPath);
    resetSettingsCache();
  } catch (error) {
    if (error instanceof Error) {
      logError(error);
    }
    process.stderr.write(chalk.red(`Error processing settings: ${errorMessage(error)}\n`));
    process.exit(1);
  }
}
function loadSettingSourcesFromFlag(settingSourcesArg: string): void {
  try {
    const sources = parseSettingSourcesFlag(settingSourcesArg);
    setAllowedSettingSources(sources);
    resetSettingsCache();
  } catch (error) {
    if (error instanceof Error) {
      logError(error);
    }
    process.stderr.write(chalk.red(`Error processing --setting-sources: ${errorMessage(error)}\n`));
    process.exit(1);
  }
}

/**
 * Parse and load settings flags early, before init()
 * This ensures settings are filtered from the start of initialization
 */
function eagerLoadSettings(): void {
  profileCheckpoint('eagerLoadSettings_start');
  // Parse --settings flag early to ensure settings are loaded before init()
  const settingsFile = eagerParseCliFlag('--settings');
  if (settingsFile) {
    loadSettingsFromFlag(settingsFile);
  }

  // Parse --setting-sources flag early to control which sources are loaded
  const settingSourcesArg = eagerParseCliFlag('--setting-sources');
  if (settingSourcesArg !== undefined) {
    loadSettingSourcesFromFlag(settingSourcesArg);
  }
  profileCheckpoint('eagerLoadSettings_end');
}
function initializeEntrypoint(isNonInteractive: boolean): void {
  // Skip if already set (e.g., by SDK or other entrypoints)
  if (process.env.CLAUDE_CODE_ENTRYPOINT) {
    return;
  }
  const cliArgs = process.argv.slice(2);

  // Check for MCP serve command (handle flags before mcp serve, e.g., --debug mcp serve)
  const mcpIndex = cliArgs.indexOf('mcp');
  if (mcpIndex !== -1 && cliArgs[mcpIndex + 1] === 'serve') {
    process.env.CLAUDE_CODE_ENTRYPOINT = 'mcp';
    return;
  }
  if (isEnvTruthy(process.env.CLAUDE_CODE_ACTION)) {
    process.env.CLAUDE_CODE_ENTRYPOINT = 'claude-code-github-action';
    return;
  }

  // Note: 'local-agent' entrypoint is set by the local agent mode launcher
  // via CLAUDE_CODE_ENTRYPOINT env var (handled by early return above)

  // Set based on interactive status
  process.env.CLAUDE_CODE_ENTRYPOINT = isNonInteractive ? 'sdk-cli' : 'cli';
}

// Set by early argv processing when `claude open <url>` is detected (interactive mode only)
type PendingConnect = {
  url: string | undefined;
  authToken: string | undefined;
  dangerouslySkipPermissions: boolean;
};
const _pendingConnect: PendingConnect | undefined = feature('DIRECT_CONNECT') ? {
  url: undefined,
  authToken: undefined,
  dangerouslySkipPermissions: false
} : undefined;

// Set by early argv processing when `claude assistant [sessionId]` is detected
type PendingAssistantChat = {
  sessionId?: string;
  discover: boolean;
};
const _pendingAssistantChat: PendingAssistantChat | undefined = feature('KAIROS') ? {
  sessionId: undefined,
  discover: false
} : undefined;

// `claude ssh <host> [dir]` — parsed from argv early (same pattern as
// DIRECT_CONNECT above) so the main command path can pick it up and hand
// the REPL an SSH-backed session instead of a local one.
type PendingSSH = {
  host: string | undefined;
  cwd: string | undefined;
  permissionMode: string | undefined;
  dangerouslySkipPermissions: boolean;
  /** --local: spawn the child CLI directly, skip ssh/probe/deploy. e2e test mode. */
  local: boolean;
  /** Extra CLI args to forward to the remote CLI on initial spawn (--resume, -c). */
  extraCliArgs: string[];
};
const _pendingSSH: PendingSSH | undefined = feature('SSH_REMOTE') ? {
  host: undefined,
  cwd: undefined,
  permissionMode: undefined,
  dangerouslySkipPermissions: false,
  local: false,
  extraCliArgs: []
} : undefined;
export async function main() {
  profileCheckpoint('main_function_start');

  // SECURITY: Prevent Windows from executing commands from current directory
  // This must be set before ANY command execution to prevent PATH hijacking attacks
  // See: https://docs.microsoft.com/en-us/windows/win32/api/processenv/nf-processenv-searchpathw
  process.env.NoDefaultCurrentDirectoryInExePath = '1';

  // Initialize warning handler early to catch warnings
  initializeWarningHandler();
  process.on('exit', () => {
    resetCursor();
  });
  process.on('SIGINT', () => {
    // In print mode, print.ts registers its own SIGINT handler that aborts
    // the in-flight query and calls gracefulShutdown; skip here to avoid
    // preempting it with a synchronous process.exit().
    if (process.argv.includes('-p') || process.argv.includes('--print')) {
      return;
    }
    process.exit(0);
  });
  profileCheckpoint('main_warning_handler_initialized');

  // Check for cc:// or cc+unix:// URL in argv — rewrite so the main command
  // handles it, giving the full interactive TUI instead of a stripped-down subcommand.
  // For headless (-p), we rewrite to the internal `open` subcommand.
  if (feature('DIRECT_CONNECT')) {
    const rawCliArgs = process.argv.slice(2);
    const ccIdx = rawCliArgs.findIndex(a => a.startsWith('cc://') || a.startsWith('cc+unix://'));
    if (ccIdx !== -1 && _pendingConnect) {
      const ccUrl = rawCliArgs[ccIdx]!;
      const {
        parseConnectUrl
      } = await import('./server/parseConnectUrl.js');
      const parsed = parseConnectUrl(ccUrl);
      _pendingConnect.dangerouslySkipPermissions = rawCliArgs.includes('--dangerously-skip-permissions');
      if (rawCliArgs.includes('-p') || rawCliArgs.includes('--print')) {
        // Headless: rewrite to internal `open` subcommand
        const stripped = rawCliArgs.filter((_, i) => i !== ccIdx);
        const dspIdx = stripped.indexOf('--dangerously-skip-permissions');
        if (dspIdx !== -1) {
          stripped.splice(dspIdx, 1);
        }
        process.argv = [process.argv[0]!, process.argv[1]!, 'open', ccUrl, ...stripped];
      } else {
        // Interactive: strip cc:// URL and flags, run main command
        _pendingConnect.url = parsed.serverUrl;
        _pendingConnect.authToken = parsed.authToken;
        const stripped = rawCliArgs.filter((_, i) => i !== ccIdx);
        const dspIdx = stripped.indexOf('--dangerously-skip-permissions');
        if (dspIdx !== -1) {
          stripped.splice(dspIdx, 1);
        }
        process.argv = [process.argv[0]!, process.argv[1]!, ...stripped];
      }
    }
  }

  // Handle deep link URIs early — this is invoked by the OS protocol handler
  // and should bail out before full init since it only needs to parse the URI
  // and open a terminal.
  if (feature('LODESTONE')) {
    const handleUriIdx = process.argv.indexOf('--handle-uri');
    if (handleUriIdx !== -1 && process.argv[handleUriIdx + 1]) {
      const {
        enableConfigs
      } = await import('./utils/config.js');
      enableConfigs();
      const uri = process.argv[handleUriIdx + 1]!;
      const {
        handleDeepLinkUri
      } = await import('./utils/deepLink/protocolHandler.js');
      const exitCode = await handleDeepLinkUri(uri);
      process.exit(exitCode);
    }

    // macOS URL handler: when LaunchServices launches our .app bundle, the
    // URL arrives via Apple Event (not argv). LaunchServices overwrites
    // __CFBundleIdentifier to the launching bundle's ID, which is a precise
    // positive signal — cheaper than importing and guessing with heuristics.
    if (process.platform === 'darwin' && process.env.__CFBundleIdentifier === 'com.anthropic.claude-code-url-handler') {
      const {
        enableConfigs
      } = await import('./utils/config.js');
      enableConfigs();
      const {
        handleUrlSchemeLaunch
      } = await import('./utils/deepLink/protocolHandler.js');
      const urlSchemeResult = await handleUrlSchemeLaunch();
      process.exit(urlSchemeResult ?? 1);
    }
  }

  // `claude assistant [sessionId]` — stash and strip so the main
  // command handles it, giving the full interactive TUI. Position-0 only
  // (matching the ssh pattern below) — indexOf would false-positive on
  // `claude -p "explain assistant"`. Root-flag-before-subcommand
  // (e.g. `--debug assistant`) falls through to the stub, which
  // prints usage.
  if (feature('KAIROS') && _pendingAssistantChat) {
    const rawArgs = process.argv.slice(2);
    if (rawArgs[0] === 'assistant') {
      const nextArg = rawArgs[1];
      if (nextArg && !nextArg.startsWith('-')) {
        _pendingAssistantChat.sessionId = nextArg;
        rawArgs.splice(0, 2); // drop 'assistant' and sessionId
        process.argv = [process.argv[0]!, process.argv[1]!, ...rawArgs];
      } else if (!nextArg) {
        _pendingAssistantChat.discover = true;
        rawArgs.splice(0, 1); // drop 'assistant'
        process.argv = [process.argv[0]!, process.argv[1]!, ...rawArgs];
      }
      // else: `claude assistant --help` → fall through to stub
    }
  }

  // `claude ssh <host> [dir]` — strip from argv so the main command handler
  // runs (full interactive TUI), stash the host/dir for the REPL branch at
  // ~line 3720 to pick up. Headless (-p) mode not supported in v1: SSH
  // sessions need the local REPL to drive them (interrupt, permissions).
  if (feature('SSH_REMOTE') && _pendingSSH) {
    const rawCliArgs = process.argv.slice(2);
    // SSH-specific flags can appear before the host positional (e.g.
    // `ssh --permission-mode auto host /tmp` — standard POSIX flags-before-
    // positionals). Pull them all out BEFORE checking whether a host was
    // given, so `claude ssh --permission-mode auto host` and `claude ssh host
    // --permission-mode auto` are equivalent. The host check below only needs
    // to guard against `-h`/`--help` (which commander should handle).
    if (rawCliArgs[0] === 'ssh') {
      const localIdx = rawCliArgs.indexOf('--local');
      if (localIdx !== -1) {
        _pendingSSH.local = true;
        rawCliArgs.splice(localIdx, 1);
      }
      const dspIdx = rawCliArgs.indexOf('--dangerously-skip-permissions');
      if (dspIdx !== -1) {
        _pendingSSH.dangerouslySkipPermissions = true;
        rawCliArgs.splice(dspIdx, 1);
      }
      const pmIdx = rawCliArgs.indexOf('--permission-mode');
      if (pmIdx !== -1 && rawCliArgs[pmIdx + 1] && !rawCliArgs[pmIdx + 1]!.startsWith('-')) {
        _pendingSSH.permissionMode = rawCliArgs[pmIdx + 1];
        rawCliArgs.splice(pmIdx, 2);
      }
      const pmEqIdx = rawCliArgs.findIndex(a => a.startsWith('--permission-mode='));
      if (pmEqIdx !== -1) {
        _pendingSSH.permissionMode = rawCliArgs[pmEqIdx]!.split('=')[1];
        rawCliArgs.splice(pmEqIdx, 1);
      }
      // Forward session-resume + model flags to the remote CLI's initial spawn.
      // --continue/-c and --resume <uuid> operate on the REMOTE session history
      // (which persists under the remote's ~/.claude/projects/<cwd>/).
      // --model controls which model the remote uses.
      const extractFlag = (flag: string, opts: {
        hasValue?: boolean;
        as?: string;
      } = {}) => {
        const i = rawCliArgs.indexOf(flag);
        if (i !== -1) {
          _pendingSSH.extraCliArgs.push(opts.as ?? flag);
          const val = rawCliArgs[i + 1];
          if (opts.hasValue && val && !val.startsWith('-')) {
            _pendingSSH.extraCliArgs.push(val);
            rawCliArgs.splice(i, 2);
          } else {
            rawCliArgs.splice(i, 1);
          }
        }
        const eqI = rawCliArgs.findIndex(a => a.startsWith(`${flag}=`));
        if (eqI !== -1) {
          _pendingSSH.extraCliArgs.push(opts.as ?? flag, rawCliArgs[eqI]!.slice(flag.length + 1));
          rawCliArgs.splice(eqI, 1);
        }
      };
      extractFlag('-c', {
        as: '--continue'
      });
      extractFlag('--continue');
      extractFlag('--resume', {
        hasValue: true
      });
      extractFlag('--model', {
        hasValue: true
      });
    }
    // After pre-extraction, any remaining dash-arg at [1] is either -h/--help
    // (commander handles) or an unknown-to-ssh flag (fall through to commander
    // so it surfaces a proper error). Only a non-dash arg is the host.
    if (rawCliArgs[0] === 'ssh' && rawCliArgs[1] && !rawCliArgs[1].startsWith('-')) {
      _pendingSSH.host = rawCliArgs[1];
      // Optional positional cwd.
      let consumed = 2;
      if (rawCliArgs[2] && !rawCliArgs[2].startsWith('-')) {
        _pendingSSH.cwd = rawCliArgs[2];
        consumed = 3;
      }
      const rest = rawCliArgs.slice(consumed);

      // Headless (-p) mode is not supported with SSH in v1 — reject early
      // so the flag doesn't silently cause local execution.
      if (rest.includes('-p') || rest.includes('--print')) {
        process.stderr.write('Error: headless (-p/--print) mode is not supported with claude ssh\n');
        gracefulShutdownSync(1);
        return;
      }

      // Rewrite argv so the main command sees remaining flags but not `ssh`.
      process.argv = [process.argv[0]!, process.argv[1]!, ...rest];
    }
  }

  // Check for -p/--print and --init-only flags early to set isInteractiveSession before init()
  // This is needed because telemetry initialization calls auth functions that need this flag
  const cliArgs = process.argv.slice(2);
  const hasPrintFlag = cliArgs.includes('-p') || cliArgs.includes('--print');
  const hasInitOnlyFlag = cliArgs.includes('--init-only');
  const hasSdkUrl = cliArgs.some(arg => arg.startsWith('--sdk-url'));
  const isNonInteractive = hasPrintFlag || hasInitOnlyFlag || hasSdkUrl || !process.stdout.isTTY;

  // Stop capturing early input for non-interactive modes
  if (isNonInteractive) {
    stopCapturingEarlyInput();
  }

  // Set simplified tracking fields
  const isInteractive = !isNonInteractive;
  setIsInteractive(isInteractive);

  // Initialize entrypoint based on mode - needs to be set before any event is logged
  initializeEntrypoint(isNonInteractive);

  // Determine client type
  const clientType = (() => {
    if (isEnvTruthy(process.env.GITHUB_ACTIONS)) return 'github-action';
    if (process.env.CLAUDE_CODE_ENTRYPOINT === 'sdk-ts') return 'sdk-typescript';
    if (process.env.CLAUDE_CODE_ENTRYPOINT === 'sdk-py') return 'sdk-python';
    if (process.env.CLAUDE_CODE_ENTRYPOINT === 'sdk-cli') return 'sdk-cli';
    if (process.env.CLAUDE_CODE_ENTRYPOINT === 'claude-vscode') return 'claude-vscode';
    if (process.env.CLAUDE_CODE_ENTRYPOINT === 'local-agent') return 'local-agent';
    if (process.env.CLAUDE_CODE_ENTRYPOINT === 'claude-desktop') return 'claude-desktop';

    // Check if session-ingress token is provided (indicates remote session)
    const hasSessionIngressToken = process.env.CLAUDE_CODE_SESSION_ACCESS_TOKEN || process.env.CLAUDE_CODE_WEBSOCKET_AUTH_FILE_DESCRIPTOR;
    if (process.env.CLAUDE_CODE_ENTRYPOINT === 'remote' || hasSessionIngressToken) {
      return 'remote';
    }
    return 'cli';
  })();
  setClientType(clientType);
  const previewFormat = process.env.CLAUDE_CODE_QUESTION_PREVIEW_FORMAT;
  if (previewFormat === 'markdown' || previewFormat === 'html') {
    setQuestionPreviewFormat(previewFormat);
  } else if (!clientType.startsWith('sdk-') &&
  // Desktop and CCR pass previewFormat via toolConfig; when the feature is
  // gated off they pass undefined — don't override that with markdown.
  clientType !== 'claude-desktop' && clientType !== 'local-agent' && clientType !== 'remote') {
    setQuestionPreviewFormat('markdown');
  }

  // Tag sessions created via `claude remote-control` so the backend can identify them
  if (process.env.CLAUDE_CODE_ENVIRONMENT_KIND === 'bridge') {
    setSessionSource('remote-control');
  }
  profileCheckpoint('main_client_type_determined');

  // Parse and load settings flags early, before init()
  eagerLoadSettings();
  profileCheckpoint('main_before_run');
  await run();
  profileCheckpoint('main_after_run');
}
async function getInputPrompt(prompt: string, inputFormat: 'text' | 'stream-json'): Promise<string | AsyncIterable<string>> {
  if (!process.stdin.isTTY &&
  // Input hijacking breaks MCP.
  !process.argv.includes('mcp')) {
    if (inputFormat === 'stream-json') {
      return process.stdin;
    }
    process.stdin.setEncoding('utf8');
    let data = '';
    const onData = (chunk: string) => {
      data += chunk;
    };
    process.stdin.on('data', onData);
    // If no data arrives in 3s, stop waiting and warn. Stdin is likely an
    // inherited pipe from a parent that isn't writing (subprocess spawned
    // without explicit stdin handling). 3s covers slow producers like curl,
    // jq on large files, python with import overhead. The warning makes
    // silent data loss visible for the rare producer that's slower still.
    const timedOut = await peekForStdinData(process.stdin, 3000);
    process.stdin.off('data', onData);
    if (timedOut) {
      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');
    }
    return [prompt, data].filter(Boolean).join('\n');
  }
  return prompt;
}
async function run(): Promise<CommanderCommand> {
  profileCheckpoint('run_function_start');

  // Create help config that sorts options by long option name.
  // Commander supports compareOptions at runtime but @commander-js/extra-typings
  // doesn't include it in the type definitions, so we use Object.assign to add it.
  function createSortedHelpConfig(): {
    sortSubcommands: true;
    sortOptions: true;
  } {
    const getOptionSortKey = (opt: Option): string => opt.long?.replace(/^--/, '') ?? opt.short?.replace(/^-/, '') ?? '';
    return Object.assign({
      sortSubcommands: true,
      sortOptions: true
    } as const, {
      compareOptions: (a: Option, b: Option) => getOptionSortKey(a).localeCompare(getOptionSortKey(b))
    });
  }
  const program = new CommanderCommand().configureHelp(createSortedHelpConfig()).enablePositionalOptions();
  profileCheckpoint('run_commander_initialized');

  // Use preAction hook to run initialization only when executing a command,
  // not when displaying help. This avoids the need for env variable signaling.
  program.hook('preAction', async thisCommand => {
    profileCheckpoint('preAction_start');
    // Await async subprocess loads started at module evaluation (lines 12-20).
    // Nearly free — subprocesses complete during the ~135ms of imports above.
    // Must resolve before init() which triggers the first settings read
    // (applySafeConfigEnvironmentVariables → getSettingsForSource('policySettings')
    // → isRemoteManagedSettingsEligible → sync keychain reads otherwise ~65ms).
    await Promise.all([ensureMdmSettingsLoaded(), ensureKeychainPrefetchCompleted()]);
    profileCheckpoint('preAction_after_mdm');
    await init();
    profileCheckpoint('preAction_after_init');

    // process.title on Windows sets the console title directly; on POSIX,
    // terminal shell integration may mirror the process name to the tab.
    // After init() so settings.json env can also gate this (gh-4765).
    if (!isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_TERMINAL_TITLE)) {
      process.title = 'claude';
    }

    // Attach logging sinks so subcommand handlers can use logEvent/logError.
    // Before PR #11106 logEvent dispatched directly; after, events queue until
    // a sink attaches. setup() attaches sinks for the default command, but
    // subcommands (doctor, mcp, plugin, auth) never call setup() and would
    // silently drop events on process.exit(). Both inits are idempotent.
    const {
      initSinks
    } = await import('./utils/sinks.js');
    initSinks();
    profileCheckpoint('preAction_after_sinks');

    // gh-33508: --plugin-dir is a top-level program option. The default
    // action reads it from its own options destructure, but subcommands
    // (plugin list, plugin install, mcp *) have their own actions and
    // never see it. Wire it up here so getInlinePlugins() works everywhere.
    // thisCommand.opts() is typed {} here because this hook is attached
    // before .option('--plugin-dir', ...) in the chain — extra-typings
    // builds the type as options are added. Narrow with a runtime guard;
    // the collect accumulator + [] default guarantee string[] in practice.
    const pluginDir = thisCommand.getOptionValue('pluginDir');
    if (Array.isArray(pluginDir) && pluginDir.length > 0 && pluginDir.every(p => typeof p === 'string')) {
      setInlinePlugins(pluginDir);
      clearPluginCache('preAction: --plugin-dir inline plugins');
    }
    runMigrations();
    profileCheckpoint('preAction_after_migrations');

    // Load remote managed settings for enterprise customers (non-blocking)
    // Fails open - if fetch fails, continues without remote settings
    // Settings are applied via hot-reload when they arrive
    // Must happen after init() to ensure config reading is allowed
    void loadRemoteManagedSettings();
    void loadPolicyLimits();
    profileCheckpoint('preAction_after_remote_settings');

    // Load settings sync (non-blocking, fail-open)
    // CLI: uploads local settings to remote (CCR download is handled by print.ts)
    if (feature('UPLOAD_USER_SETTINGS')) {
      void import('./services/settingsSync/index.js').then(m => m.uploadUserSettingsInBackground());
    }
    profileCheckpoint('preAction_after_settings_sync');
  });
  program.name('claude').description(`Claude Code - starts an interactive session by default, use -p/--print for non-interactive output`).argument('[prompt]', 'Your prompt', String)
  // Subcommands inherit helpOption via commander's copyInheritedSettings —
  // setting it once here covers mcp, plugin, auth, and all other subcommands.
  .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) => {
    // If value is provided, it will be the filter string
    // If not provided but flag is present, value will be true
    // The actual filtering is handled in debug.ts by parsing process.argv
    return true;
  }).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 => {
    const amount = Number(value);
    if (isNaN(amount) || amount <= 0) {
      throw new Error('--max-budget-usd must be a positive number greater than 0');
    }
    return amount;
  })).addOption(new Option('--task-budget <tokens>', 'API-side task budget in tokens (output_config.task_budget)').argParser(value => {
    const tokens = Number(value);
    if (isNaN(tokens) || tokens <= 0 || !Number.isInteger(tokens)) {
      throw new Error('--task-budget must be a positive integer');
    }
    return tokens;
  }).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 => {
    const n = Number(v);
    return Number.isFinite(n) ? n : undefined;
  }).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())
  // @[MODEL LAUNCH]: Update the example model ID in the --model help text.
  .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) => {
    const value = rawValue.toLowerCase();
    const allowed = ['low', 'medium', 'high', 'max'];
    if (!allowed.includes(value)) {
      throw new InvalidArgumentError(`It must be one of: ${allowed.join(', ')}`);
    }
    return value;
  })).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).')
  // gh-33508: <paths...> (variadic) consumed everything until the next
  // --flag. `claude --plugin-dir /path mcp add --transport http` swallowed
  // `mcp` and `add` as paths, then choked on --transport as an unknown
  // top-level option. Single-value + collect accumulator means each
  // --plugin-dir takes exactly one arg; repeat the flag for multiple dirs.
  .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) => {
    profileCheckpoint('action_handler_start');

    // --bare = one-switch minimal mode. Sets SIMPLE so all the existing
    // gates fire (CLAUDE.md, skills, hooks inside executeHooks, agent
    // dir-walk). Must be set before setup() / any of the gated work runs.
    if ((options as {
      bare?: boolean;
    }).bare) {
      process.env.CLAUDE_CODE_SIMPLE = '1';
    }

    // Ignore "code" as a prompt - treat it the same as no prompt
    if (prompt === 'code') {
      logEvent('tengu_code_prompt_ignored', {});
      // biome-ignore lint/suspicious/noConsole:: intentional console output
      console.warn(chalk.yellow('Tip: You can launch Claude Code with just `claude`'));
      prompt = undefined;
    }

    // Log event for any single-word prompt
    if (prompt && typeof prompt === 'string' && !/\s/.test(prompt) && prompt.length > 0) {
      logEvent('tengu_single_word_prompt', {
        length: prompt.length
      });
    }

    // Assistant mode: when .claude/settings.json has assistant: true AND
    // the tengu_kairos GrowthBook gate is on, force brief on. Permission
    // mode is left to the user — settings defaultMode or --permission-mode
    // apply as normal. REPL-typed messages already default to 'next'
    // priority (messageQueueManager.enqueue) so they drain mid-turn between
    // tool calls. SendUserMessage (BriefTool) is enabled via the brief env
    // var. SleepTool stays disabled (its isEnabled() gates on proactive).
    // kairosEnabled is computed once here and reused at the
    // getAssistantSystemPromptAddendum() call site further down.
    //
    // Trust gate: .claude/settings.json is attacker-controllable in an
    // untrusted clone. We run ~1000 lines before showSetupScreens() shows
    // the trust dialog, and by then we've already appended
    // .claude/agents/assistant.md to the system prompt. Refuse to activate
    // until the directory has been explicitly trusted.
    let kairosEnabled = false;
    let assistantTeamContext: Awaited<ReturnType<NonNullable<typeof assistantModule>['initializeAssistantTeam']>> | undefined;
    if (feature('KAIROS') && (options as {
      assistant?: boolean;
    }).assistant && assistantModule) {
      // --assistant (Agent SDK daemon mode): force the latch before
      // isAssistantMode() runs below. The daemon has already checked
      // entitlement — don't make the child re-check tengu_kairos.
      assistantModule.markAssistantForced();
    }
    if (feature('KAIROS') && assistantModule?.isAssistantMode() &&
    // Spawned teammates share the leader's cwd + settings.json, so
    // isAssistantMode() is true for them too. --agent-id being set
    // means we ARE a spawned teammate (extractTeammateOptions runs
    // ~170 lines later so check the raw commander option) — don't
    // re-init the team or override teammateMode/proactive/brief.
    !(options as {
      agentId?: unknown;
    }).agentId && kairosGate) {
      if (!checkHasTrustDialogAccepted()) {
        // biome-ignore lint/suspicious/noConsole:: intentional console output
        console.warn(chalk.yellow('Assistant mode disabled: directory is not trusted. Accept the trust dialog and restart.'));
      } else {
        // Blocking gate check — returns cached `true` instantly; if disk
        // cache is false/missing, lazily inits GrowthBook and fetches fresh
        // (max ~5s). --assistant skips the gate entirely (daemon is
        // pre-entitled).
        kairosEnabled = assistantModule.isAssistantForced() || (await kairosGate.isKairosEnabled());
        if (kairosEnabled) {
          const opts = options as {
            brief?: boolean;
          };
          opts.brief = true;
          setKairosActive(true);
          // Pre-seed an in-process team so Agent(name: "foo") spawns
          // teammates without TeamCreate. Must run BEFORE setup() captures
          // the teammateMode snapshot (initializeAssistantTeam calls
          // setCliTeammateModeOverride internally).
          assistantTeamContext = await assistantModule.initializeAssistantTeam();
        }
      }
    }
    const {
      debug = false,
      debugToStderr = false,
      dangerouslySkipPermissions,
      allowDangerouslySkipPermissions = false,
      tools: baseTools = [],
      allowedTools = [],
      disallowedTools = [],
      mcpConfig = [],
      permissionMode: permissionModeCli,
      addDir = [],
      fallbackModel,
      betas = [],
      ide = false,
      sessionId,
      includeHookEvents,
      includePartialMessages
    } = options;
    if (options.prefill) {
      seedEarlyInput(options.prefill);
    }

    // Promise for file downloads - started early, awaited before REPL renders
    let fileDownloadPromise: Promise<DownloadResult[]> | undefined;
    const agentsJson = options.agents;
    const agentCli = options.agent;
    if (feature('BG_SESSIONS') && agentCli) {
      process.env.CLAUDE_CODE_AGENT = agentCli;
    }

    // NOTE: LSP manager initialization is intentionally deferred until after
    // the trust dialog is accepted. This prevents plugin LSP servers from
    // executing code in untrusted directories before user consent.

    // Extract these separately so they can be modified if needed
    let outputFormat = options.outputFormat;
    let inputFormat = options.inputFormat;
    let verbose = options.verbose ?? getGlobalConfig().verbose;
    let print = options.print;
    const init = options.init ?? false;
    const initOnly = options.initOnly ?? false;
    const maintenance = options.maintenance ?? false;

    // Extract disable slash commands flag
    const disableSlashCommands = options.disableSlashCommands || false;

    // Extract tasks mode options (ant-only)
    const tasksOption = "external" === 'ant' && (options as {
      tasks?: boolean | string;
    }).tasks;
    const taskListId = tasksOption ? typeof tasksOption === 'string' ? tasksOption : DEFAULT_TASKS_MODE_TASK_LIST_ID : undefined;
    if ("external" === 'ant' && taskListId) {
      process.env.CLAUDE_CODE_TASK_LIST_ID = taskListId;
    }

    // Extract worktree option
    // worktree can be true (flag without value) or a string (custom name or PR reference)
    const worktreeOption = isWorktreeModeEnabled() ? (options as {
      worktree?: boolean | string;
    }).worktree : undefined;
    let worktreeName = typeof worktreeOption === 'string' ? worktreeOption : undefined;
    const worktreeEnabled = worktreeOption !== undefined;

    // Check if worktree name is a PR reference (#N or GitHub PR URL)
    let worktreePRNumber: number | undefined;
    if (worktreeName) {
      const prNum = parsePRReference(worktreeName);
      if (prNum !== null) {
        worktreePRNumber = prNum;
        worktreeName = undefined; // slug will be generated in setup()
      }
    }

    // Extract tmux option (requires --worktree)
    const tmuxEnabled = isWorktreeModeEnabled() && (options as {
      tmux?: boolean;
    }).tmux === true;

    // Validate tmux option
    if (tmuxEnabled) {
      if (!worktreeEnabled) {
        process.stderr.write(chalk.red('Error: --tmux requires --worktree\n'));
        process.exit(1);
      }
      if (getPlatform() === 'windows') {
        process.stderr.write(chalk.red('Error: --tmux is not supported on Windows\n'));
        process.exit(1);
      }
      if (!(await isTmuxAvailable())) {
        process.stderr.write(chalk.red(`Error: tmux is not installed.\n${getTmuxInstallInstructions()}\n`));
        process.exit(1);
      }
    }

    // Extract teammate options (for tmux-spawned agents)
    // Declared outside the if block so it's accessible later for system prompt addendum
    let storedTeammateOpts: TeammateOptions | undefined;
    if (isAgentSwarmsEnabled()) {
      // Extract agent identity options (for tmux-spawned agents)
      // These replace the CLAUDE_CODE_* environment variables
      const teammateOpts = extractTeammateOptions(options);
      storedTeammateOpts = teammateOpts;

      // If any teammate identity option is provided, all three required ones must be present
      const hasAnyTeammateOpt = teammateOpts.agentId || teammateOpts.agentName || teammateOpts.teamName;
      const hasAllRequiredTeammateOpts = teammateOpts.agentId && teammateOpts.agentName && teammateOpts.teamName;
      if (hasAnyTeammateOpt && !hasAllRequiredTeammateOpts) {
        process.stderr.write(chalk.red('Error: --agent-id, --agent-name, and --team-name must all be provided together\n'));
        process.exit(1);
      }

      // If teammate identity is provided via CLI, set up dynamicTeamContext
      if (teammateOpts.agentId && teammateOpts.agentName && teammateOpts.teamName) {
        getTeammateUtils().setDynamicTeamContext?.({
          agentId: teammateOpts.agentId,
          agentName: teammateOpts.agentName,
          teamName: teammateOpts.teamName,
          color: teammateOpts.agentColor,
          planModeRequired: teammateOpts.planModeRequired ?? false,
          parentSessionId: teammateOpts.parentSessionId
        });
      }

      // Set teammate mode CLI override if provided
      // This must be done before setup() captures the snapshot
      if (teammateOpts.teammateMode) {
        getTeammateModeSnapshot().setCliTeammateModeOverride?.(teammateOpts.teammateMode);
      }
    }

    // Extract remote sdk options
    const sdkUrl = (options as {
      sdkUrl?: string;
    }).sdkUrl ?? undefined;

    // Allow env var to enable partial messages (used by sandbox gateway for baku)
    const effectiveIncludePartialMessages = includePartialMessages || isEnvTruthy(process.env.CLAUDE_CODE_INCLUDE_PARTIAL_MESSAGES);

    // Enable all hook event types when explicitly requested via SDK option
    // or when running in CLAUDE_CODE_REMOTE mode (CCR needs them).
    // Without this, only SessionStart and Setup events are emitted.
    if (includeHookEvents || isEnvTruthy(process.env.CLAUDE_CODE_REMOTE)) {
      setAllHookEventsEnabled(true);
    }

    // Auto-set input/output formats, verbose mode, and print mode when SDK URL is provided
    if (sdkUrl) {
      // If SDK URL is provided, automatically use stream-json formats unless explicitly set
      if (!inputFormat) {
        inputFormat = 'stream-json';
      }
      if (!outputFormat) {
        outputFormat = 'stream-json';
      }
      // Auto-enable verbose mode unless explicitly disabled or already set
      if (options.verbose === undefined) {
        verbose = true;
      }
      // Auto-enable print mode unless explicitly disabled
      if (!options.print) {
        print = true;
      }
    }

    // Extract teleport option
    const teleport = (options as {
      teleport?: string | true;
    }).teleport ?? null;

    // Extract remote option (can be true if no description provided, or a string)
    const remoteOption = (options as {
      remote?: string | true;
    }).remote;
    const remote = remoteOption === true ? '' : remoteOption ?? null;

    // Extract --remote-control / --rc flag (enable bridge in interactive session)
    const remoteControlOption = (options as {
      remoteControl?: string | true;
    }).remoteControl ?? (options as {
      rc?: string | true;
    }).rc;
    // Actual bridge check is deferred to after showSetupScreens() so that
    // trust is established and GrowthBook has auth headers.
    let remoteControl = false;
    const remoteControlName = typeof remoteControlOption === 'string' && remoteControlOption.length > 0 ? remoteControlOption : undefined;

    // Validate session ID if provided
    if (sessionId) {
      // Check for conflicting flags
      // --session-id can be used with --continue or --resume when --fork-session is also provided
      // (to specify a custom ID for the forked session)
      if ((options.continue || options.resume) && !options.forkSession) {
        process.stderr.write(chalk.red('Error: --session-id can only be used with --continue or --resume if --fork-session is also specified.\n'));
        process.exit(1);
      }

      // When --sdk-url is provided (bridge/remote mode), the session ID is a
      // server-assigned tagged ID (e.g. "session_local_01...") rather than a
      // UUID. Skip UUID validation and local existence checks in that case.
      if (!sdkUrl) {
        const validatedSessionId = validateUuid(sessionId);
        if (!validatedSessionId) {
          process.stderr.write(chalk.red('Error: Invalid session ID. Must be a valid UUID.\n'));
          process.exit(1);
        }

        // Check if session ID already exists
        if (sessionIdExists(validatedSessionId)) {
          process.stderr.write(chalk.red(`Error: Session ID ${validatedSessionId} is already in use.\n`));
          process.exit(1);
        }
      }
    }

    // Download file resources if specified via --file flag
    const fileSpecs = (options as {
      file?: string[];
    }).file;
    if (fileSpecs && fileSpecs.length > 0) {
      // Get session ingress token (provided by EnvManager via CLAUDE_CODE_SESSION_ACCESS_TOKEN)
      const sessionToken = getSessionIngressAuthToken();
      if (!sessionToken) {
        process.stderr.write(chalk.red('Error: Session token required for file downloads. CLAUDE_CODE_SESSION_ACCESS_TOKEN must be set.\n'));
        process.exit(1);
      }

      // Resolve session ID: prefer remote session ID, fall back to internal session ID
      const fileSessionId = process.env.CLAUDE_CODE_REMOTE_SESSION_ID || getSessionId();
      const files = parseFileSpecs(fileSpecs);
      if (files.length > 0) {
        // Use ANTHROPIC_BASE_URL if set (by EnvManager), otherwise use OAuth config
        // This ensures consistency with session ingress API in all environments
        const config: FilesApiConfig = {
          baseUrl: process.env.ANTHROPIC_BASE_URL || getOauthConfig().BASE_API_URL,
          oauthToken: sessionToken,
          sessionId: fileSessionId
        };

        // Start download without blocking startup - await before REPL renders
        fileDownloadPromise = downloadSessionFiles(files, config);
      }
    }

    // Get isNonInteractiveSession from state (was set before init())
    const isNonInteractiveSession = getIsNonInteractiveSession();

    // Validate that fallback model is different from main model
    if (fallbackModel && options.model && fallbackModel === options.model) {
      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'));
      process.exit(1);
    }

    // Handle system prompt options
    let systemPrompt = options.systemPrompt;
    if (options.systemPromptFile) {
      if (options.systemPrompt) {
        process.stderr.write(chalk.red('Error: Cannot use both --system-prompt and --system-prompt-file. Please use only one.\n'));
        process.exit(1);
      }
      try {
        const filePath = resolve(options.systemPromptFile);
        systemPrompt = readFileSync(filePath, 'utf8');
      } catch (error) {
        const code = getErrnoCode(error);
        if (code === 'ENOENT') {
          process.stderr.write(chalk.red(`Error: System prompt file not found: ${resolve(options.systemPromptFile)}\n`));
          process.exit(1);
        }
        process.stderr.write(chalk.red(`Error reading system prompt file: ${errorMessage(error)}\n`));
        process.exit(1);
      }
    }

    // Handle append system prompt options
    let appendSystemPrompt = options.appendSystemPrompt;
    if (options.appendSystemPromptFile) {
      if (options.appendSystemPrompt) {
        process.stderr.write(chalk.red('Error: Cannot use both --append-system-prompt and --append-system-prompt-file. Please use only one.\n'));
        process.exit(1);
      }
      try {
        const filePath = resolve(options.appendSystemPromptFile);
        appendSystemPrompt = readFileSync(filePath, 'utf8');
      } catch (error) {
        const code = getErrnoCode(error);
        if (code === 'ENOENT') {
          process.stderr.write(chalk.red(`Error: Append system prompt file not found: ${resolve(options.appendSystemPromptFile)}\n`));
          process.exit(1);
        }
        process.stderr.write(chalk.red(`Error reading append system prompt file: ${errorMessage(error)}\n`));
        process.exit(1);
      }
    }

    // Add teammate-specific system prompt addendum for tmux teammates
    if (isAgentSwarmsEnabled() && storedTeammateOpts?.agentId && storedTeammateOpts?.agentName && storedTeammateOpts?.teamName) {
      const addendum = getTeammatePromptAddendum().TEAMMATE_SYSTEM_PROMPT_ADDENDUM;
      appendSystemPrompt = appendSystemPrompt ? `${appendSystemPrompt}\n\n${addendum}` : addendum;
    }
    const {
      mode: permissionMode,
      notification: permissionModeNotification
    } = initialPermissionModeFromCLI({
      permissionModeCli,
      dangerouslySkipPermissions
    });

    // Store session bypass permissions mode for trust dialog check
    setSessionBypassPermissionsMode(permissionMode === 'bypassPermissions');
    if (feature('TRANSCRIPT_CLASSIFIER')) {
      // autoModeFlagCli is the "did the user intend auto this session" signal.
      // Set when: --enable-auto-mode, --permission-mode auto, resolved mode
      // is auto, OR settings defaultMode is auto but the gate denied it
      // (permissionMode resolved to default with no explicit CLI override).
      // Used by verifyAutoModeGateAccess to decide whether to notify on
      // auto-unavailable, and by tengu_auto_mode_config opt-in carousel.
      if ((options as {
        enableAutoMode?: boolean;
      }).enableAutoMode || permissionModeCli === 'auto' || permissionMode === 'auto' || !permissionModeCli && isDefaultPermissionModeAuto()) {
        autoModeStateModule?.setAutoModeFlagCli(true);
      }
    }

    // Parse the MCP config files/strings if provided
    let dynamicMcpConfig: Record<string, ScopedMcpServerConfig> = {};
    if (mcpConfig && mcpConfig.length > 0) {
      // Process mcpConfig array
      const processedConfigs = mcpConfig.map(config => config.trim()).filter(config => config.length > 0);
      let allConfigs: Record<string, McpServerConfig> = {};
      const allErrors: ValidationError[] = [];
      for (const configItem of processedConfigs) {
        let configs: Record<string, McpServerConfig> | null = null;
        let errors: ValidationError[] = [];

        // First try to parse as JSON string
        const parsedJson = safeParseJSON(configItem);
        if (parsedJson) {
          const result = parseMcpConfig({
            configObject: parsedJson,
            filePath: 'command line',
            expandVars: true,
            scope: 'dynamic'
          });
          if (result.config) {
            configs = result.config.mcpServers;
          } else {
            errors = result.errors;
          }
        } else {
          // Try as file path
          const configPath = resolve(configItem);
          const result = parseMcpConfigFromFilePath({
            filePath: configPath,
            expandVars: true,
            scope: 'dynamic'
          });
          if (result.config) {
            configs = result.config.mcpServers;
          } else {
            errors = result.errors;
          }
        }
        if (errors.length > 0) {
          allErrors.push(...errors);
        } else if (configs) {
          // Merge configs, later ones override earlier ones
          allConfigs = {
            ...allConfigs,
            ...configs
          };
        }
      }
      if (allErrors.length > 0) {
        const formattedErrors = allErrors.map(err => `${err.path ? err.path + ': ' : ''}${err.message}`).join('\n');
        logForDebugging(`--mcp-config validation failed (${allErrors.length} errors): ${formattedErrors}`, {
          level: 'error'
        });
        process.stderr.write(`Error: Invalid MCP configuration:\n${formattedErrors}\n`);
        process.exit(1);
      }
      if (Object.keys(allConfigs).length > 0) {
        // SDK hosts (Nest/Desktop) own their server naming and may reuse
        // built-in names — skip reserved-name checks for type:'sdk'.
        const nonSdkConfigNames = Object.entries(allConfigs).filter(([, config]) => config.type !== 'sdk').map(([name]) => name);
        let reservedNameError: string | null = null;
        if (nonSdkConfigNames.some(isClaudeInChromeMCPServer)) {
          reservedNameError = `Invalid MCP configuration: "${CLAUDE_IN_CHROME_MCP_SERVER_NAME}" is a reserved MCP name.`;
        } else if (feature('CHICAGO_MCP')) {
          const {
            isComputerUseMCPServer,
            COMPUTER_USE_MCP_SERVER_NAME
          } = await import('src/utils/computerUse/common.js');
          if (nonSdkConfigNames.some(isComputerUseMCPServer)) {
            reservedNameError = `Invalid MCP configuration: "${COMPUTER_USE_MCP_SERVER_NAME}" is a reserved MCP name.`;
          }
        }
        if (reservedNameError) {
          // stderr+exit(1) — a throw here becomes a silent unhandled
          // rejection in stream-json mode (void main() in cli.tsx).
          process.stderr.write(`Error: ${reservedNameError}\n`);
          process.exit(1);
        }

        // Add dynamic scope to all configs. type:'sdk' entries pass through
        // unchanged — they're extracted into sdkMcpConfigs downstream and
        // passed to print.ts. The Python SDK relies on this path (it doesn't
        // send sdkMcpServers in the initialize message). Dropping them here
        // broke Coworker (inc-5122). The policy filter below already exempts
        // type:'sdk', and the entries are inert without an SDK transport on
        // stdin, so there's no bypass risk from letting them through.
        const scopedConfigs = mapValues(allConfigs, config => ({
          ...config,
          scope: 'dynamic' as const
        }));

        // Enforce managed policy (allowedMcpServers / deniedMcpServers) on
        // --mcp-config servers. Without this, the CLI flag bypasses the
        // enterprise allowlist that user/project/local configs go through in
        // getClaudeCodeMcpConfigs — callers spread dynamicMcpConfig back on
        // top of filtered results. Filter here at the source so all
        // downstream consumers see the policy-filtered set.
        const {
          allowed,
          blocked
        } = filterMcpServersByPolicy(scopedConfigs);
        if (blocked.length > 0) {
          process.stderr.write(`Warning: MCP ${plural(blocked.length, 'server')} blocked by enterprise policy: ${blocked.join(', ')}\n`);
        }
        dynamicMcpConfig = {
          ...dynamicMcpConfig,
          ...allowed
        };
      }
    }

    // Extract Claude in Chrome option and enforce claude.ai subscriber check (unless user is ant)
    const chromeOpts = options as {
      chrome?: boolean;
    };
    // Store the explicit CLI flag so teammates can inherit it
    setChromeFlagOverride(chromeOpts.chrome);
    const enableClaudeInChrome = shouldEnableClaudeInChrome(chromeOpts.chrome) && ("external" === 'ant' || isClaudeAISubscriber());
    const autoEnableClaudeInChrome = !enableClaudeInChrome && shouldAutoEnableClaudeInChrome();
    if (enableClaudeInChrome) {
      const platform = getPlatform();
      try {
        logEvent('tengu_claude_in_chrome_setup', {
          platform: platform as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
        });
        const {
          mcpConfig: chromeMcpConfig,
          allowedTools: chromeMcpTools,
          systemPrompt: chromeSystemPrompt
        } = setupClaudeInChrome();
        dynamicMcpConfig = {
          ...dynamicMcpConfig,
          ...chromeMcpConfig
        };
        allowedTools.push(...chromeMcpTools);
        if (chromeSystemPrompt) {
          appendSystemPrompt = appendSystemPrompt ? `${chromeSystemPrompt}\n\n${appendSystemPrompt}` : chromeSystemPrompt;
        }
      } catch (error) {
        logEvent('tengu_claude_in_chrome_setup_failed', {
          platform: platform as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
        });
        logForDebugging(`[Claude in Chrome] Error: ${error}`);
        logError(error);
        // biome-ignore lint/suspicious/noConsole:: intentional console output
        console.error(`Error: Failed to run with Claude in Chrome.`);
        process.exit(1);
      }
    } else if (autoEnableClaudeInChrome) {
      try {
        const {
          mcpConfig: chromeMcpConfig
        } = setupClaudeInChrome();
        dynamicMcpConfig = {
          ...dynamicMcpConfig,
          ...chromeMcpConfig
        };
        const hint = feature('WEB_BROWSER_TOOL') && typeof Bun !== 'undefined' && 'WebView' in Bun ? CLAUDE_IN_CHROME_SKILL_HINT_WITH_WEBBROWSER : CLAUDE_IN_CHROME_SKILL_HINT;
        appendSystemPrompt = appendSystemPrompt ? `${appendSystemPrompt}\n\n${hint}` : hint;
      } catch (error) {
        // Silently skip any errors for the auto-enable
        logForDebugging(`[Claude in Chrome] Error (auto-enable): ${error}`);
      }
    }

    // Extract strict MCP config flag
    const strictMcpConfig = options.strictMcpConfig || false;

    // Check if enterprise MCP configuration exists. When it does, only allow dynamic MCP
    // configs that contain special server types (sdk)
    if (doesEnterpriseMcpConfigExist()) {
      if (strictMcpConfig) {
        process.stderr.write(chalk.red('You cannot use --strict-mcp-config when an enterprise MCP config is present'));
        process.exit(1);
      }

      // For --mcp-config, allow if all servers are internal types (sdk)
      if (dynamicMcpConfig && !areMcpConfigsAllowedWithEnterpriseMcpConfig(dynamicMcpConfig)) {
        process.stderr.write(chalk.red('You cannot dynamically configure MCP servers when an enterprise MCP config is present'));
        process.exit(1);
      }
    }

    // chicago MCP: guarded Computer Use (app allowlist + frontmost gate +
    // SCContentFilter screenshots). Ant-only, GrowthBook-gated — failures
    // are silent (this is dogfooding). Platform + interactive checks inline
    // so non-macOS / print-mode ants skip the heavy @ant/computer-use-mcp
    // import entirely. gates.js is light (type-only package import).
    //
    // Placed AFTER the enterprise-MCP-config check: that check rejects any
    // dynamicMcpConfig entry with `type !== 'sdk'`, and our config is
    // `type: 'stdio'`. An enterprise-config ant with the GB gate on would
    // otherwise process.exit(1). Chrome has the same latent issue but has
    // shipped without incident; chicago places itself correctly.
    if (feature('CHICAGO_MCP') && getPlatform() === 'macos' && !getIsNonInteractiveSession()) {
      try {
        const {
          getChicagoEnabled
        } = await import('src/utils/computerUse/gates.js');
        if (getChicagoEnabled()) {
          const {
            setupComputerUseMCP
          } = await import('src/utils/computerUse/setup.js');
          const {
            mcpConfig,
            allowedTools: cuTools
          } = setupComputerUseMCP();
          dynamicMcpConfig = {
            ...dynamicMcpConfig,
            ...mcpConfig
          };
          allowedTools.push(...cuTools);
        }
      } catch (error) {
        logForDebugging(`[Computer Use MCP] Setup failed: ${errorMessage(error)}`);
      }
    }

    // Store additional directories for CLAUDE.md loading (controlled by env var)
    setAdditionalDirectoriesForClaudeMd(addDir);

    // Channel server allowlist from --channels flag — servers whose
    // inbound push notifications should register this session. The option
    // is added inside a feature() block so TS doesn't know about it
    // on the options type — same pattern as --assistant at main.tsx:1824.
    // devChannels is deferred: showSetupScreens shows a confirmation dialog
    // and only appends to allowedChannels on accept.
    let devChannels: ChannelEntry[] | undefined;
    if (feature('KAIROS') || feature('KAIROS_CHANNELS')) {
      // Parse plugin:name@marketplace / server:Y tags into typed entries.
      // Tag decides trust model downstream: plugin-kind hits marketplace
      // verification + GrowthBook allowlist, server-kind always fails
      // allowlist (schema is plugin-only) unless dev flag is set.
      // Untagged or marketplace-less plugin entries are hard errors —
      // silently not-matching in the gate would look like channels are
      // "on" but nothing ever fires.
      const parseChannelEntries = (raw: string[], flag: string): ChannelEntry[] => {
        const entries: ChannelEntry[] = [];
        const bad: string[] = [];
        for (const c of raw) {
          if (c.startsWith('plugin:')) {
            const rest = c.slice(7);
            const at = rest.indexOf('@');
            if (at <= 0 || at === rest.length - 1) {
              bad.push(c);
            } else {
              entries.push({
                kind: 'plugin',
                name: rest.slice(0, at),
                marketplace: rest.slice(at + 1)
              });
            }
          } else if (c.startsWith('server:') && c.length > 7) {
            entries.push({
              kind: 'server',
              name: c.slice(7)
            });
          } else {
            bad.push(c);
          }
        }
        if (bad.length > 0) {
          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`));
          process.exit(1);
        }
        return entries;
      };
      const channelOpts = options as {
        channels?: string[];
        dangerouslyLoadDevelopmentChannels?: string[];
      };
      const rawChannels = channelOpts.channels;
      const rawDev = channelOpts.dangerouslyLoadDevelopmentChannels;
      // Always parse + set. ChannelsNotice reads getAllowedChannels() and
      // renders the appropriate branch (disabled/noAuth/policyBlocked/
      // listening) in the startup screen. gateChannelServer() enforces.
      // --channels works in both interactive and print/SDK modes; dev-channels
      // stays interactive-only (requires a confirmation dialog).
      let channelEntries: ChannelEntry[] = [];
      if (rawChannels && rawChannels.length > 0) {
        channelEntries = parseChannelEntries(rawChannels, '--channels');
        setAllowedChannels(channelEntries);
      }
      if (!isNonInteractiveSession) {
        if (rawDev && rawDev.length > 0) {
          devChannels = parseChannelEntries(rawDev, '--dangerously-load-development-channels');
        }
      }
      // Flag-usage telemetry. Plugin identifiers are logged (same tier as
      // tengu_plugin_installed — public-registry-style names); server-kind
      // names are not (MCP-server-name tier, opt-in-only elsewhere).
      // Per-server gate outcomes land in tengu_mcp_channel_gate once
      // servers connect. Dev entries go through a confirmation dialog after
      // this — dev_plugins captures what was typed, not what was accepted.
      if (channelEntries.length > 0 || (devChannels?.length ?? 0) > 0) {
        const joinPluginIds = (entries: ChannelEntry[]) => {
          const ids = entries.flatMap(e => e.kind === 'plugin' ? [`${e.name}@${e.marketplace}`] : []);
          return ids.length > 0 ? ids.sort().join(',') as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS : undefined;
        };
        logEvent('tengu_mcp_channel_flags', {
          channels_count: channelEntries.length,
          dev_count: devChannels?.length ?? 0,
          plugins: joinPluginIds(channelEntries),
          dev_plugins: joinPluginIds(devChannels ?? [])
        });
      }
    }

    // SDK opt-in for SendUserMessage via --tools. All sessions require
    // explicit opt-in; listing it in --tools signals intent. Runs BEFORE
    // initializeToolPermissionContext so getToolsForDefaultPreset() sees
    // the tool as enabled when computing the base-tools disallow filter.
    // Conditional require avoids leaking the tool-name string into
    // external builds.
    if ((feature('KAIROS') || feature('KAIROS_BRIEF')) && baseTools.length > 0) {
      /* eslint-disable @typescript-eslint/no-require-imports */
      const {
        BRIEF_TOOL_NAME,
        LEGACY_BRIEF_TOOL_NAME
      } = require('./tools/BriefTool/prompt.js') as typeof import('./tools/BriefTool/prompt.js');
      const {
        isBriefEntitled
      } = require('./tools/BriefTool/BriefTool.js') as typeof import('./tools/BriefTool/BriefTool.js');
      /* eslint-enable @typescript-eslint/no-require-imports */
      const parsed = parseToolListFromCLI(baseTools);
      if ((parsed.includes(BRIEF_TOOL_NAME) || parsed.includes(LEGACY_BRIEF_TOOL_NAME)) && isBriefEntitled()) {
        setUserMsgOptIn(true);
      }
    }

    // This await replaces blocking existsSync/statSync calls that were already in
    // the startup path. Wall-clock time is unchanged; we just yield to the event
    // loop during the fs I/O instead of blocking it. See #19661.
    const initResult = await initializeToolPermissionContext({
      allowedToolsCli: allowedTools,
      disallowedToolsCli: disallowedTools,
      baseToolsCli: baseTools,
      permissionMode,
      allowDangerouslySkipPermissions,
      addDirs: addDir
    });
    let toolPermissionContext = initResult.toolPermissionContext;
    const {
      warnings,
      dangerousPermissions,
      overlyBroadBashPermissions
    } = initResult;

    // Handle overly broad shell allow rules for ant users (Bash(*), PowerShell(*))
    if ("external" === 'ant' && overlyBroadBashPermissions.length > 0) {
      for (const permission of overlyBroadBashPermissions) {
        logForDebugging(`Ignoring overly broad shell permission ${permission.ruleDisplay} from ${permission.sourceDisplay}`);
      }
      toolPermissionContext = removeDangerousPermissions(toolPermissionContext, overlyBroadBashPermissions);
    }
    if (feature('TRANSCRIPT_CLASSIFIER') && dangerousPermissions.length > 0) {
      toolPermissionContext = stripDangerousPermissionsForAutoMode(toolPermissionContext);
    }

    // Print any warnings from initialization
    warnings.forEach(warning => {
      // biome-ignore lint/suspicious/noConsole:: intentional console output
      console.error(warning);
    });
    void assertMinVersion();

    // claude.ai config fetch: -p mode only (interactive uses useManageMCPConnections
    // two-phase loading). Kicked off here to overlap with setup(); awaited
    // before runHeadless so single-turn -p sees connectors. Skipped under
    // enterprise/strict MCP to preserve policy boundaries.
    const claudeaiConfigPromise: Promise<Record<string, ScopedMcpServerConfig>> = isNonInteractiveSession && !strictMcpConfig && !doesEnterpriseMcpConfigExist() &&
    // --bare / SIMPLE: skip claude.ai proxy servers (datadog, Gmail,
    // Slack, BigQuery, PubMed — 6-14s each to connect). Scripted calls
    // that need MCP pass --mcp-config explicitly.
    !isBareMode() ? fetchClaudeAIMcpConfigsIfEligible().then(configs => {
      const {
        allowed,
        blocked
      } = filterMcpServersByPolicy(configs);
      if (blocked.length > 0) {
        process.stderr.write(`Warning: claude.ai MCP ${plural(blocked.length, 'server')} blocked by enterprise policy: ${blocked.join(', ')}\n`);
      }
      return allowed;
    }) : Promise.resolve({});

    // Kick off MCP config loading early (safe - just reads files, no execution).
    // Both interactive and -p use getClaudeCodeMcpConfigs (local file reads only).
    // The local promise is awaited later (before prefetchAllMcpResources) to
    // overlap config I/O with setup(), commands loading, and trust dialog.
    logForDebugging('[STARTUP] Loading MCP configs...');
    const mcpConfigStart = Date.now();
    let mcpConfigResolvedMs: number | undefined;
    // --bare skips auto-discovered MCP (.mcp.json, user settings, plugins) —
    // only explicit --mcp-config works. dynamicMcpConfig is spread onto
    // allMcpConfigs downstream so it survives this skip.
    const mcpConfigPromise = (strictMcpConfig || isBareMode() ? Promise.resolve({
      servers: {} as Record<string, ScopedMcpServerConfig>
    }) : getClaudeCodeMcpConfigs(dynamicMcpConfig)).then(result => {
      mcpConfigResolvedMs = Date.now() - mcpConfigStart;
      return result;
    });

    // NOTE: We do NOT call prefetchAllMcpResources here - that's deferred until after trust dialog

    if (inputFormat && inputFormat !== 'text' && inputFormat !== 'stream-json') {
      // biome-ignore lint/suspicious/noConsole:: intentional console output
      console.error(`Error: Invalid input format "${inputFormat}".`);
      process.exit(1);
    }
    if (inputFormat === 'stream-json' && outputFormat !== 'stream-json') {
      // biome-ignore lint/suspicious/noConsole:: intentional console output
      console.error(`Error: --input-format=stream-json requires output-format=stream-json.`);
      process.exit(1);
    }

    // Validate sdkUrl is only used with appropriate formats (formats are auto-set above)
    if (sdkUrl) {
      if (inputFormat !== 'stream-json' || outputFormat !== 'stream-json') {
        // biome-ignore lint/suspicious/noConsole:: intentional console output
        console.error(`Error: --sdk-url requires both --input-format=stream-json and --output-format=stream-json.`);
        process.exit(1);
      }
    }

    // Validate replayUserMessages is only used with stream-json formats
    if (options.replayUserMessages) {
      if (inputFormat !== 'stream-json' || outputFormat !== 'stream-json') {
        // biome-ignore lint/suspicious/noConsole:: intentional console output
        console.error(`Error: --replay-user-messages requires both --input-format=stream-json and --output-format=stream-json.`);
        process.exit(1);
      }
    }

    // Validate includePartialMessages is only used with print mode and stream-json output
    if (effectiveIncludePartialMessages) {
      if (!isNonInteractiveSession || outputFormat !== 'stream-json') {
        writeToStderr(`Error: --include-partial-messages requires --print and --output-format=stream-json.`);
        process.exit(1);
      }
    }

    // Validate --no-session-persistence is only used with print mode
    if (options.sessionPersistence === false && !isNonInteractiveSession) {
      writeToStderr(`Error: --no-session-persistence can only be used with --print mode.`);
      process.exit(1);
    }
    const effectivePrompt = prompt || '';
    let inputPrompt = await getInputPrompt(effectivePrompt, (inputFormat ?? 'text') as 'text' | 'stream-json');
    profileCheckpoint('action_after_input_prompt');

    // Activate proactive mode BEFORE getTools() so SleepTool.isEnabled()
    // (which returns isProactiveActive()) passes and Sleep is included.
    // The later REPL-path maybeActivateProactive() calls are idempotent.
    maybeActivateProactive(options);
    let tools = getTools(toolPermissionContext);

    // Apply coordinator mode tool filtering for headless path
    // (mirrors useMergedTools.ts filtering for REPL/interactive path)
    if (feature('COORDINATOR_MODE') && isEnvTruthy(process.env.CLAUDE_CODE_COORDINATOR_MODE)) {
      const {
        applyCoordinatorToolFilter
      } = await import('./utils/toolPool.js');
      tools = applyCoordinatorToolFilter(tools);
    }
    profileCheckpoint('action_tools_loaded');
    let jsonSchema: ToolInputJSONSchema | undefined;
    if (isSyntheticOutputToolEnabled({
      isNonInteractiveSession
    }) && options.jsonSchema) {
      jsonSchema = jsonParse(options.jsonSchema) as ToolInputJSONSchema;
    }
    if (jsonSchema) {
      const syntheticOutputResult = createSyntheticOutputTool(jsonSchema);
      if ('tool' in syntheticOutputResult) {
        // Add SyntheticOutputTool to the tools array AFTER getTools() filtering.
        // This tool is excluded from normal filtering (see tools.ts) because it's
        // an implementation detail for structured output, not a user-controlled tool.
        tools = [...tools, syntheticOutputResult.tool];
        logEvent('tengu_structured_output_enabled', {
          schema_property_count: Object.keys(jsonSchema.properties as Record<string, unknown> || {}).length as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
          has_required_fields: Boolean(jsonSchema.required) as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
        });
      } else {
        logEvent('tengu_structured_output_failure', {
          error: 'Invalid JSON schema' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
        });
      }
    }

    // IMPORTANT: setup() must be called before any other code that depends on the cwd or worktree setup
    profileCheckpoint('action_before_setup');
    logForDebugging('[STARTUP] Running setup()...');
    const setupStart = Date.now();
    const {
      setup
    } = await import('./setup.js');
    const messagingSocketPath = feature('UDS_INBOX') ? (options as {
      messagingSocketPath?: string;
    }).messagingSocketPath : undefined;
    // Parallelize setup() with commands+agents loading. setup()'s ~28ms is
    // mostly startUdsMessaging (socket bind, ~20ms) — not disk-bound, so it
    // doesn't contend with getCommands' file reads. Gated on !worktreeEnabled
    // since --worktree makes setup() process.chdir() (setup.ts:203), and
    // commands/agents need the post-chdir cwd.
    const preSetupCwd = getCwd();
    // Register bundled skills/plugins before kicking getCommands() — they're
    // pure in-memory array pushes (<1ms, zero I/O) that getBundledSkills()
    // reads synchronously. Previously ran inside setup() after ~20ms of
    // await points, so the parallel getCommands() memoized an empty list.
    if (process.env.CLAUDE_CODE_ENTRYPOINT !== 'local-agent') {
      initBuiltinPlugins();
      initBundledSkills();
    }
    const setupPromise = setup(preSetupCwd, permissionMode, allowDangerouslySkipPermissions, worktreeEnabled, worktreeName, tmuxEnabled, sessionId ? validateUuid(sessionId) : undefined, worktreePRNumber, messagingSocketPath);
    const commandsPromise = worktreeEnabled ? null : getCommands(preSetupCwd);
    const agentDefsPromise = worktreeEnabled ? null : getAgentDefinitionsWithOverrides(preSetupCwd);
    // Suppress transient unhandledRejection if these reject during the
    // ~28ms setupPromise await before Promise.all joins them below.
    commandsPromise?.catch(() => {});
    agentDefsPromise?.catch(() => {});
    await setupPromise;
    logForDebugging(`[STARTUP] setup() completed in ${Date.now() - setupStart}ms`);
    profileCheckpoint('action_after_setup');

    // Replay user messages into stream-json only when the socket was
    // explicitly requested. The auto-generated socket is passive — it
    // lets tools inject if they want to, but turning it on by default
    // shouldn't reshape stream-json for SDK consumers who never touch it.
    // Callers who inject and also want those injections visible in the
    // stream pass --messaging-socket-path explicitly (or --replay-user-messages).
    let effectiveReplayUserMessages = !!options.replayUserMessages;
    if (feature('UDS_INBOX')) {
      if (!effectiveReplayUserMessages && outputFormat === 'stream-json') {
        effectiveReplayUserMessages = !!(options as {
          messagingSocketPath?: string;
        }).messagingSocketPath;
      }
    }
    if (getIsNonInteractiveSession()) {
      // Apply full merged settings env now (including project-scoped
      // .claude/settings.json PATH/GIT_DIR/GIT_WORK_TREE) so gitExe() and
      // the git spawn below see it. Trust is implicit in -p mode; the
      // docstring at managedEnv.ts:96-97 says this applies "potentially
      // dangerous environment variables such as LD_PRELOAD, PATH" from all
      // sources. The later call in the isNonInteractiveSession block below
      // is idempotent (Object.assign, configureGlobalAgents ejects prior
      // interceptor) and picks up any plugin-contributed env after plugin
      // init. Project settings are already loaded here:
      // applySafeConfigEnvironmentVariables in init() called
      // getSettings_DEPRECATED at managedEnv.ts:86 which merges all enabled
      // sources including projectSettings/localSettings.
      applyConfigEnvironmentVariables();

      // Spawn git status/log/branch now so the subprocess execution overlaps
      // with the getCommands await below and startDeferredPrefetches. After
      // setup() so cwd is final (setup.ts:254 may process.chdir(worktreePath)
      // for --worktree) and after the applyConfigEnvironmentVariables above
      // so PATH/GIT_DIR/GIT_WORK_TREE from all sources (trusted + project)
      // are applied. getSystemContext is memoized; the
      // prefetchSystemContextIfSafe call in startDeferredPrefetches becomes
      // a cache hit. The microtask from await getIsGit() drains at the
      // getCommands Promise.all await below. Trust is implicit in -p mode
      // (same gate as prefetchSystemContextIfSafe).
      void getSystemContext();
      // Kick getUserContext now too — its first await (fs.readFile in
      // getMemoryFiles) yields naturally, so the CLAUDE.md directory walk
      // runs during the ~280ms overlap window before the context
      // Promise.all join in print.ts. The void getUserContext() in
      // startDeferredPrefetches becomes a memoize cache-hit.
      void getUserContext();
      // Kick ensureModelStringsInitialized now — for Bedrock this triggers
      // a 100-200ms profile fetch that was awaited serially at
      // print.ts:739. updateBedrockModelStrings is sequential()-wrapped so
      // the await joins the in-flight fetch. Non-Bedrock is a sync
      // early-return (zero-cost).
      void ensureModelStringsInitialized();
    }

    // Apply --name: cache-only so no orphan file is created before the
    // session ID is finalized by --continue/--resume. materializeSessionFile
    // persists it on the first user message; REPL's useTerminalTitle reads it
    // via getCurrentSessionTitle.
    const sessionNameArg = options.name?.trim();
    if (sessionNameArg) {
      cacheSessionTitle(sessionNameArg);
    }

    // Ant model aliases (capybara-fast etc.) resolve via the
    // tengu_ant_model_override GrowthBook flag. _CACHED_MAY_BE_STALE reads
    // disk synchronously; disk is populated by a fire-and-forget write. On a
    // cold cache, parseUserSpecifiedModel returns the unresolved alias, the
    // API 404s, and -p exits before the async write lands — crashloop on
    // fresh pods. Awaiting init here populates the in-memory payload map that
    // _CACHED_MAY_BE_STALE now checks first. Gated so the warm path stays
    // non-blocking:
    //  - explicit model via --model or ANTHROPIC_MODEL (both feed alias resolution)
    //  - no env override (which short-circuits _CACHED_MAY_BE_STALE before disk)
    //  - flag absent from disk (== null also catches pre-#22279 poisoned null)
    const explicitModel = options.model || process.env.ANTHROPIC_MODEL;
    if ("external" === 'ant' && explicitModel && explicitModel !== 'default' && !hasGrowthBookEnvOverride('tengu_ant_model_override') && getGlobalConfig().cachedGrowthBookFeatures?.['tengu_ant_model_override'] == null) {
      await initializeGrowthBook();
    }

    // Special case the default model with the null keyword
    // NOTE: Model resolution happens after setup() to ensure trust is established before AWS auth
    const userSpecifiedModel = options.model === 'default' ? getDefaultMainLoopModel() : options.model;
    const userSpecifiedFallbackModel = fallbackModel === 'default' ? getDefaultMainLoopModel() : fallbackModel;

    // Reuse preSetupCwd unless setup() chdir'd (worktreeEnabled). Saves a
    // getCwd() syscall in the common path.
    const currentCwd = worktreeEnabled ? getCwd() : preSetupCwd;
    logForDebugging('[STARTUP] Loading commands and agents...');
    const commandsStart = Date.now();
    // Join the promises kicked before setup() (or start fresh if
    // worktreeEnabled gated the early kick). Both memoized by cwd.
    const [commands, agentDefinitionsResult] = await Promise.all([commandsPromise ?? getCommands(currentCwd), agentDefsPromise ?? getAgentDefinitionsWithOverrides(currentCwd)]);
    logForDebugging(`[STARTUP] Commands and agents loaded in ${Date.now() - commandsStart}ms`);
    profileCheckpoint('action_commands_loaded');

    // Parse CLI agents if provided via --agents flag
    let cliAgents: typeof agentDefinitionsResult.activeAgents = [];
    if (agentsJson) {
      try {
        const parsedAgents = safeParseJSON(agentsJson);
        if (parsedAgents) {
          cliAgents = parseAgentsFromJson(parsedAgents, 'flagSettings');
        }
      } catch (error) {
        logError(error);
      }
    }

    // Merge CLI agents with existing ones
    const allAgents = [...agentDefinitionsResult.allAgents, ...cliAgents];
    const agentDefinitions = {
      ...agentDefinitionsResult,
      allAgents,
      activeAgents: getActiveAgentsFromList(allAgents)
    };

    // Look up main thread agent from CLI flag or settings
    const agentSetting = agentCli ?? getInitialSettings().agent;
    let mainThreadAgentDefinition: (typeof agentDefinitions.activeAgents)[number] | undefined;
    if (agentSetting) {
      mainThreadAgentDefinition = agentDefinitions.activeAgents.find(agent => agent.agentType === agentSetting);
      if (!mainThreadAgentDefinition) {
        logForDebugging(`Warning: agent "${agentSetting}" not found. ` + `Available agents: ${agentDefinitions.activeAgents.map(a => a.agentType).join(', ')}. ` + `Using default behavior.`);
      }
    }

    // Store the main thread agent type in bootstrap state so hooks can access it
    setMainThreadAgentType(mainThreadAgentDefinition?.agentType);

    // Log agent flag usage — only log agent name for built-in agents to avoid leaking custom agent names
    if (mainThreadAgentDefinition) {
      logEvent('tengu_agent_flag', {
        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,
        ...(agentCli && {
          source: 'cli' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
        })
      });
    }

    // Persist agent setting to session transcript for resume view display and restoration
    if (mainThreadAgentDefinition?.agentType) {
      saveAgentSetting(mainThreadAgentDefinition.agentType);
    }

    // Apply the agent's system prompt for non-interactive sessions
    // (interactive mode uses buildEffectiveSystemPrompt instead)
    if (isNonInteractiveSession && mainThreadAgentDefinition && !systemPrompt && !isBuiltInAgent(mainThreadAgentDefinition)) {
      const agentSystemPrompt = mainThreadAgentDefinition.getSystemPrompt();
      if (agentSystemPrompt) {
        systemPrompt = agentSystemPrompt;
      }
    }

    // initialPrompt goes first so its slash command (if any) is processed;
    // user-provided text becomes trailing context.
    // Only concatenate when inputPrompt is a string. When it's an
    // AsyncIterable (SDK stream-json mode), template interpolation would
    // call .toString() producing "[object Object]". The AsyncIterable case
    // is handled in print.ts via structuredIO.prependUserMessage().
    if (mainThreadAgentDefinition?.initialPrompt) {
      if (typeof inputPrompt === 'string') {
        inputPrompt = inputPrompt ? `${mainThreadAgentDefinition.initialPrompt}\n\n${inputPrompt}` : mainThreadAgentDefinition.initialPrompt;
      } else if (!inputPrompt) {
        inputPrompt = mainThreadAgentDefinition.initialPrompt;
      }
    }

    // Compute effective model early so hooks can run in parallel with MCP
    // If user didn't specify a model but agent has one, use the agent's model
    let effectiveModel = userSpecifiedModel;
    if (!effectiveModel && mainThreadAgentDefinition?.model && mainThreadAgentDefinition.model !== 'inherit') {
      effectiveModel = parseUserSpecifiedModel(mainThreadAgentDefinition.model);
    }
    setMainLoopModelOverride(effectiveModel);

    // Compute resolved model for hooks (use user-specified model at launch)
    setInitialMainLoopModel(getUserSpecifiedModelSetting() || null);
    const initialMainLoopModel = getInitialMainLoopModel();
    const resolvedInitialModel = parseUserSpecifiedModel(initialMainLoopModel ?? getDefaultMainLoopModel());
    let advisorModel: string | undefined;
    if (isAdvisorEnabled()) {
      const advisorOption = canUserConfigureAdvisor() ? (options as {
        advisor?: string;
      }).advisor : undefined;
      if (advisorOption) {
        logForDebugging(`[AdvisorTool] --advisor ${advisorOption}`);
        if (!modelSupportsAdvisor(resolvedInitialModel)) {
          process.stderr.write(chalk.red(`Error: The model "${resolvedInitialModel}" does not support the advisor tool.\n`));
          process.exit(1);
        }
        const normalizedAdvisorModel = normalizeModelStringForAPI(parseUserSpecifiedModel(advisorOption));
        if (!isValidAdvisorModel(normalizedAdvisorModel)) {
          process.stderr.write(chalk.red(`Error: The model "${advisorOption}" cannot be used as an advisor.\n`));
          process.exit(1);
        }
      }
      advisorModel = canUserConfigureAdvisor() ? advisorOption ?? getInitialAdvisorSetting() : advisorOption;
      if (advisorModel) {
        logForDebugging(`[AdvisorTool] Advisor model: ${advisorModel}`);
      }
    }

    // For tmux teammates with --agent-type, append the custom agent's prompt
    if (isAgentSwarmsEnabled() && storedTeammateOpts?.agentId && storedTeammateOpts?.agentName && storedTeammateOpts?.teamName && storedTeammateOpts?.agentType) {
      // Look up the custom agent definition
      const customAgent = agentDefinitions.activeAgents.find(a => a.agentType === storedTeammateOpts.agentType);
      if (customAgent) {
        // Get the prompt - need to handle both built-in and custom agents
        let customPrompt: string | undefined;
        if (customAgent.source === 'built-in') {
          // Built-in agents have getSystemPrompt that takes toolUseContext
          // We can't access full toolUseContext here, so skip for now
          logForDebugging(`[teammate] Built-in agent ${storedTeammateOpts.agentType} - skipping custom prompt (not supported)`);
        } else {
          // Custom agents have getSystemPrompt that takes no args
          customPrompt = customAgent.getSystemPrompt();
        }

        // Log agent memory loaded event for tmux teammates
        if (customAgent.memory) {
          logEvent('tengu_agent_memory_loaded', {
            ...("external" === 'ant' && {
              agent_type: customAgent.agentType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
            }),
            scope: customAgent.memory as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
            source: 'teammate' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
          });
        }
        if (customPrompt) {
          const customInstructions = `\n# Custom Agent Instructions\n${customPrompt}`;
          appendSystemPrompt = appendSystemPrompt ? `${appendSystemPrompt}\n\n${customInstructions}` : customInstructions;
        }
      } else {
        logForDebugging(`[teammate] Custom agent ${storedTeammateOpts.agentType} not found in available agents`);
      }
    }
    maybeActivateBrief(options);
    // defaultView: 'chat' is a persisted opt-in — check entitlement and set
    // userMsgOptIn so the tool + prompt section activate. Interactive-only:
    // defaultView is a display preference; SDK sessions have no display, and
    // the assistant installer writes defaultView:'chat' to settings.local.json
    // which would otherwise leak into --print sessions in the same directory.
    // Runs right after maybeActivateBrief() so all startup opt-in paths fire
    // BEFORE any isBriefEnabled() read below (proactive prompt's
    // briefVisibility). A persisted 'chat' after a GB kill-switch falls
    // through (entitlement fails).
    if ((feature('KAIROS') || feature('KAIROS_BRIEF')) && !getIsNonInteractiveSession() && !getUserMsgOptIn() && getInitialSettings().defaultView === 'chat') {
      /* eslint-disable @typescript-eslint/no-require-imports */
      const {
        isBriefEntitled
      } = require('./tools/BriefTool/BriefTool.js') as typeof import('./tools/BriefTool/BriefTool.js');
      /* eslint-enable @typescript-eslint/no-require-imports */
      if (isBriefEntitled()) {
        setUserMsgOptIn(true);
      }
    }
    // Coordinator mode has its own system prompt and filters out Sleep, so
    // the generic proactive prompt would tell it to call a tool it can't
    // access and conflict with delegation instructions.
    if ((feature('PROACTIVE') || feature('KAIROS')) && ((options as {
      proactive?: boolean;
    }).proactive || isEnvTruthy(process.env.CLAUDE_CODE_PROACTIVE)) && !coordinatorModeModule?.isCoordinatorMode()) {
      /* eslint-disable @typescript-eslint/no-require-imports */
      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.';
      /* eslint-enable @typescript-eslint/no-require-imports */
      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}`;
      appendSystemPrompt = appendSystemPrompt ? `${appendSystemPrompt}\n\n${proactivePrompt}` : proactivePrompt;
    }
    if (feature('KAIROS') && kairosEnabled && assistantModule) {
      const assistantAddendum = assistantModule.getAssistantSystemPromptAddendum();
      appendSystemPrompt = appendSystemPrompt ? `${appendSystemPrompt}\n\n${assistantAddendum}` : assistantAddendum;
    }

    // Ink root is only needed for interactive sessions — patchConsole in the
    // Ink constructor would swallow console output in headless mode.
    let root!: Root;
    let getFpsMetrics!: () => FpsMetrics | undefined;
    let stats!: StatsStore;

    // Show setup screens after commands are loaded
    if (!isNonInteractiveSession) {
      const ctx = getRenderContext(false);
      getFpsMetrics = ctx.getFpsMetrics;
      stats = ctx.stats;
      // Install asciicast recorder before Ink mounts (ant-only, opt-in via CLAUDE_CODE_TERMINAL_RECORDING=1)
      if ("external" === 'ant') {
        installAsciicastRecorder();
      }
      const {
        createRoot
      } = await import('./ink.js');
      root = await createRoot(ctx.renderOptions);

      // Log startup time now, before any blocking dialog renders. Logging
      // from REPL's first render (the old location) included however long
      // the user sat on trust/OAuth/onboarding/resume-picker — p99 was ~70s
      // dominated by dialog-wait time, not code-path startup.
      logEvent('tengu_timer', {
        event: 'startup' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
        durationMs: Math.round(process.uptime() * 1000)
      });
      logForDebugging('[STARTUP] Running showSetupScreens()...');
      const setupScreensStart = Date.now();
      const onboardingShown = await showSetupScreens(root, permissionMode, allowDangerouslySkipPermissions, commands, enableClaudeInChrome, devChannels);
      logForDebugging(`[STARTUP] showSetupScreens() completed in ${Date.now() - setupScreensStart}ms`);

      // Now that trust is established and GrowthBook has auth headers,
      // resolve the --remote-control / --rc entitlement gate.
      if (feature('BRIDGE_MODE') && remoteControlOption !== undefined) {
        const {
          getBridgeDisabledReason
        } = await import('./bridge/bridgeEnabled.js');
        const disabledReason = await getBridgeDisabledReason();
        remoteControl = disabledReason === null;
        if (disabledReason) {
          process.stderr.write(chalk.yellow(`${disabledReason}\n--rc flag ignored.\n`));
        }
      }

      // Check for pending agent memory snapshot updates (only for --agent mode, ant-only)
      if (feature('AGENT_MEMORY_SNAPSHOT') && mainThreadAgentDefinition && isCustomAgent(mainThreadAgentDefinition) && mainThreadAgentDefinition.memory && mainThreadAgentDefinition.pendingSnapshotUpdate) {
        const agentDef = mainThreadAgentDefinition;
        const choice = await launchSnapshotUpdateDialog(root, {
          agentType: agentDef.agentType,
          scope: agentDef.memory!,
          snapshotTimestamp: agentDef.pendingSnapshotUpdate!.snapshotTimestamp
        });
        if (choice === 'merge') {
          const {
            buildMergePrompt
          } = await import('./components/agents/SnapshotUpdateDialog.js');
          const mergePrompt = buildMergePrompt(agentDef.agentType, agentDef.memory!);
          inputPrompt = inputPrompt ? `${mergePrompt}\n\n${inputPrompt}` : mergePrompt;
        }
        agentDef.pendingSnapshotUpdate = undefined;
      }

      // Skip executing /login if we just completed onboarding for it
      if (onboardingShown && prompt?.trim().toLowerCase() === '/login') {
        prompt = '';
      }
      if (onboardingShown) {
        // Refresh auth-dependent services now that the user has logged in during onboarding.
        // Keep in sync with the post-login logic in src/commands/login.tsx
        void refreshRemoteManagedSettings();
        void refreshPolicyLimits();
        // Clear user data cache BEFORE GrowthBook refresh so it picks up fresh credentials
        resetUserCache();
        // Refresh GrowthBook after login to get updated feature flags (e.g., for claude.ai MCPs)
        refreshGrowthBookAfterAuthChange();
        // Clear any stale trusted device token then enroll for Remote Control.
        // Both self-gate on tengu_sessions_elevated_auth_enforcement internally
        // — enrollTrustedDevice() via checkGate_CACHED_OR_BLOCKING (awaits
        // the GrowthBook reinit above), clearTrustedDeviceToken() via the
        // sync cached check (acceptable since clear is idempotent).
        void import('./bridge/trustedDevice.js').then(m => {
          m.clearTrustedDeviceToken();
          return m.enrollTrustedDevice();
        });
      }

      // Validate that the active token's org matches forceLoginOrgUUID (if set
      // in managed settings). Runs after onboarding so managed settings and
      // login state are fully loaded.
      const orgValidation = await validateForceLoginOrg();
      if (!orgValidation.valid) {
        await exitWithError(root, orgValidation.message);
      }
    }

    // If gracefulShutdown was initiated (e.g., user rejected trust dialog),
    // process.exitCode will be set. Skip all subsequent operations that could
    // trigger code execution before the process exits (e.g. we don't want apiKeyHelper
    // to run if trust was not established).
    if (process.exitCode !== undefined) {
      logForDebugging('Graceful shutdown initiated, skipping further initialization');
      return;
    }

    // Initialize LSP manager AFTER trust is established (or in non-interactive mode
    // where trust is implicit). This prevents plugin LSP servers from executing
    // code in untrusted directories before user consent.
    // Must be after inline plugins are set (if any) so --plugin-dir LSP servers are included.
    initializeLspServerManager();

    // Show settings validation errors after trust is established
    // MCP config errors don't block settings from loading, so exclude them
    if (!isNonInteractiveSession) {
      const {
        errors
      } = getSettingsWithErrors();
      const nonMcpErrors = errors.filter(e => !e.mcpErrorMetadata);
      if (nonMcpErrors.length > 0) {
        await launchInvalidSettingsDialog(root, {
          settingsErrors: nonMcpErrors,
          onExit: () => gracefulShutdownSync(1)
        });
      }
    }

    // Check quota status, fast mode, passes eligibility, and bootstrap data
    // after trust is established. These make API calls which could trigger
    // apiKeyHelper execution.
    // --bare / SIMPLE: skip — these are cache-warms for the REPL's
    // first-turn responsiveness (quota, passes, fastMode, bootstrap data). Fast
    // mode doesn't apply to the Agent SDK anyway (see getFastModeUnavailableReason).
    const bgRefreshThrottleMs = getFeatureValue_CACHED_MAY_BE_STALE('tengu_cicada_nap_ms', 0);
    const lastPrefetched = getGlobalConfig().startupPrefetchedAt ?? 0;
    const skipStartupPrefetches = isBareMode() || bgRefreshThrottleMs > 0 && Date.now() - lastPrefetched < bgRefreshThrottleMs;
    if (!skipStartupPrefetches) {
      const lastPrefetchedInfo = lastPrefetched > 0 ? ` last ran ${Math.round((Date.now() - lastPrefetched) / 1000)}s ago` : '';
      logForDebugging(`Starting background startup prefetches${lastPrefetchedInfo}`);
      checkQuotaStatus().catch(error => logError(error));

      // Fetch bootstrap data from the server and update all cache values.
      void fetchBootstrapData();

      // TODO: Consolidate other prefetches into a single bootstrap request.
      void prefetchPassesEligibility();
      if (!getFeatureValue_CACHED_MAY_BE_STALE('tengu_miraculo_the_bard', false)) {
        void prefetchFastModeStatus();
      } else {
        // Kill switch skips the network call, not org-policy enforcement.
        // Resolve from cache so orgStatus doesn't stay 'pending' (which
        // getFastModeUnavailableReason treats as permissive).
        resolveFastModeStatusFromCache();
      }
      if (bgRefreshThrottleMs > 0) {
        saveGlobalConfig(current => ({
          ...current,
          startupPrefetchedAt: Date.now()
        }));
      }
    } else {
      logForDebugging(`Skipping startup prefetches, last ran ${Math.round((Date.now() - lastPrefetched) / 1000)}s ago`);
      // Resolve fast mode org status from cache (no network)
      resolveFastModeStatusFromCache();
    }
    if (!isNonInteractiveSession) {
      void refreshExampleCommands(); // Pre-fetch example commands (runs git log, no API call)
    }

    // Resolve MCP configs (started early, overlaps with setup/trust dialog work)
    const {
      servers: existingMcpConfigs
    } = await mcpConfigPromise;
    logForDebugging(`[STARTUP] MCP configs resolved in ${mcpConfigResolvedMs}ms (awaited at +${Date.now() - mcpConfigStart}ms)`);
    // CLI flag (--mcp-config) should override file-based configs, matching settings precedence
    const allMcpConfigs = {
      ...existingMcpConfigs,
      ...dynamicMcpConfig
    };

    // Separate SDK configs from regular MCP configs
    const sdkMcpConfigs: Record<string, McpSdkServerConfig> = {};
    const regularMcpConfigs: Record<string, ScopedMcpServerConfig> = {};
    for (const [name, config] of Object.entries(allMcpConfigs)) {
      const typedConfig = config as ScopedMcpServerConfig | McpSdkServerConfig;
      if (typedConfig.type === 'sdk') {
        sdkMcpConfigs[name] = typedConfig as McpSdkServerConfig;
      } else {
        regularMcpConfigs[name] = typedConfig as ScopedMcpServerConfig;
      }
    }
    profileCheckpoint('action_mcp_configs_loaded');

    // Prefetch MCP resources after trust dialog (this is where execution happens).
    // Interactive mode only: print mode defers connects until headlessStore exists
    // and pushes per-server (below), so ToolSearch's pending-client handling works
    // and one slow server doesn't block the batch.
    const localMcpPromise = isNonInteractiveSession ? Promise.resolve({
      clients: [],
      tools: [],
      commands: []
    }) : prefetchAllMcpResources(regularMcpConfigs);
    const claudeaiMcpPromise = isNonInteractiveSession ? Promise.resolve({
      clients: [],
      tools: [],
      commands: []
    }) : claudeaiConfigPromise.then(configs => Object.keys(configs).length > 0 ? prefetchAllMcpResources(configs) : {
      clients: [],
      tools: [],
      commands: []
    });
    // Merge with dedup by name: each prefetchAllMcpResources call independently
    // adds helper tools (ListMcpResourcesTool, ReadMcpResourceTool) via
    // local dedup flags, so merging two calls can yield duplicates. print.ts
    // already uniqBy's the final tool pool, but dedup here keeps appState clean.
    const mcpPromise = Promise.all([localMcpPromise, claudeaiMcpPromise]).then(([local, claudeai]) => ({
      clients: [...local.clients, ...claudeai.clients],
      tools: uniqBy([...local.tools, ...claudeai.tools], 'name'),
      commands: uniqBy([...local.commands, ...claudeai.commands], 'name')
    }));

    // Start hooks early so they run in parallel with MCP connections.
    // Skip for initOnly/init/maintenance (handled separately), non-interactive
    // (handled via setupTrigger), and resume/continue (conversationRecovery.ts
    // fires 'resume' instead — without this guard, hooks fire TWICE on /resume
    // and the second systemMessage clobbers the first. gh-30825)
    const hooksPromise = initOnly || init || maintenance || isNonInteractiveSession || options.continue || options.resume ? null : processSessionStartHooks('startup', {
      agentType: mainThreadAgentDefinition?.agentType,
      model: resolvedInitialModel
    });

    // MCP never blocks REPL render OR turn 1 TTFT. useManageMCPConnections
    // populates appState.mcp async as servers connect (connectToServer is
    // memoized — the prefetch calls above and the hook converge on the same
    // connections). getToolUseContext reads store.getState() fresh via
    // computeTools(), so turn 1 sees whatever's connected by query time.
    // Slow servers populate for turn 2+. Matches interactive-no-prompt
    // behavior. Print mode: per-server push into headlessStore (below).
    const hookMessages: Awaited<NonNullable<typeof hooksPromise>> = [];
    // Suppress transient unhandledRejection — the prefetch warms the
    // memoized connectToServer cache but nobody awaits it in interactive.
    mcpPromise.catch(() => {});
    const mcpClients: Awaited<typeof mcpPromise>['clients'] = [];
    const mcpTools: Awaited<typeof mcpPromise>['tools'] = [];
    const mcpCommands: Awaited<typeof mcpPromise>['commands'] = [];
    let thinkingEnabled = shouldEnableThinkingByDefault();
    let thinkingConfig: ThinkingConfig = thinkingEnabled !== false ? {
      type: 'adaptive'
    } : {
      type: 'disabled'
    };
    if (options.thinking === 'adaptive' || options.thinking === 'enabled') {
      thinkingEnabled = true;
      thinkingConfig = {
        type: 'adaptive'
      };
    } else if (options.thinking === 'disabled') {
      thinkingEnabled = false;
      thinkingConfig = {
        type: 'disabled'
      };
    } else {
      const maxThinkingTokens = process.env.MAX_THINKING_TOKENS ? parseInt(process.env.MAX_THINKING_TOKENS, 10) : options.maxThinkingTokens;
      if (maxThinkingTokens !== undefined) {
        if (maxThinkingTokens > 0) {
          thinkingEnabled = true;
          thinkingConfig = {
            type: 'enabled',
            budgetTokens: maxThinkingTokens
          };
        } else if (maxThinkingTokens === 0) {
          thinkingEnabled = false;
          thinkingConfig = {
            type: 'disabled'
          };
        }
      }
    }
    logForDiagnosticsNoPII('info', 'started', {
      version: MACRO.VERSION,
      is_native_binary: isInBundledMode()
    });
    registerCleanup(async () => {
      logForDiagnosticsNoPII('info', 'exited');
    });
    void logTenguInit({
      hasInitialPrompt: Boolean(prompt),
      hasStdin: Boolean(inputPrompt),
      verbose,
      debug,
      debugToStderr,
      print: print ?? false,
      outputFormat: outputFormat ?? 'text',
      inputFormat: inputFormat ?? 'text',
      numAllowedTools: allowedTools.length,
      numDisallowedTools: disallowedTools.length,
      mcpClientCount: Object.keys(allMcpConfigs).length,
      worktreeEnabled,
      skipWebFetchPreflight: getInitialSettings().skipWebFetchPreflight,
      githubActionInputs: process.env.GITHUB_ACTION_INPUTS,
      dangerouslySkipPermissionsPassed: dangerouslySkipPermissions ?? false,
      permissionMode,
      modeIsBypass: permissionMode === 'bypassPermissions',
      allowDangerouslySkipPermissionsPassed: allowDangerouslySkipPermissions,
      systemPromptFlag: systemPrompt ? options.systemPromptFile ? 'file' : 'flag' : undefined,
      appendSystemPromptFlag: appendSystemPrompt ? options.appendSystemPromptFile ? 'file' : 'flag' : undefined,
      thinkingConfig,
      assistantActivationPath: feature('KAIROS') && kairosEnabled ? assistantModule?.getAssistantActivationPath() : undefined
    });

    // Log context metrics once at initialization
    void logContextMetrics(regularMcpConfigs, toolPermissionContext);
    void logPermissionContextForAnts(null, 'initialization');
    logManagedSettings();

    // Register PID file for concurrent-session detection (~/.claude/sessions/)
    // and fire multi-clauding telemetry. Lives here (not init.ts) so only the
    // REPL path registers — not subcommands like `claude doctor`. Chained:
    // count must run after register's write completes or it misses our own file.
    void registerSession().then(registered => {
      if (!registered) return;
      if (sessionNameArg) {
        void updateSessionName(sessionNameArg);
      }
      void countConcurrentSessions().then(count => {
        if (count >= 2) {
          logEvent('tengu_concurrent_sessions', {
            num_sessions: count
          });
        }
      });
    });

    // Initialize versioned plugins system (triggers V1→V2 migration if
    // needed). Then run orphan GC, THEN warm the Grep/Glob exclusion cache.
    // Sequencing matters: the warmup scans disk for .orphaned_at markers,
    // so it must see the GC's Pass 1 (remove markers from reinstalled
    // versions) and Pass 2 (stamp unmarked orphans) already applied. The
    // warm also lands before autoupdate (fires on first submit in REPL)
    // can orphan this session's active version underneath us.
    // --bare / SIMPLE: skip plugin version sync + orphan cleanup. These
    // are install/upgrade bookkeeping that scripted calls don't need —
    // the next interactive session will reconcile. The await here was
    // blocking -p on a marketplace round-trip.
    if (isBareMode()) {
      // skip — no-op
    } else if (isNonInteractiveSession) {
      // In headless mode, await to ensure plugin sync completes before CLI exits
      await initializeVersionedPlugins();
      profileCheckpoint('action_after_plugins_init');
      void cleanupOrphanedPluginVersionsInBackground().then(() => getGlobExclusionsForPluginCache());
    } else {
      // In interactive mode, fire-and-forget — this is purely bookkeeping
      // that doesn't affect runtime behavior of the current session
      void initializeVersionedPlugins().then(async () => {
        profileCheckpoint('action_after_plugins_init');
        await cleanupOrphanedPluginVersionsInBackground();
        void getGlobExclusionsForPluginCache();
      });
    }
    const setupTrigger = initOnly || init ? 'init' : maintenance ? 'maintenance' : null;
    if (initOnly) {
      applyConfigEnvironmentVariables();
      await processSetupHooks('init', {
        forceSyncExecution: true
      });
      await processSessionStartHooks('startup', {
        forceSyncExecution: true
      });
      gracefulShutdownSync(0);
      return;
    }

    // --print mode
    if (isNonInteractiveSession) {
      if (outputFormat === 'stream-json' || outputFormat === 'json') {
        setHasFormattedOutput(true);
      }

      // Apply full environment variables in print mode since trust dialog is bypassed
      // This includes potentially dangerous environment variables from untrusted sources
      // but print mode is considered trusted (as documented in help text)
      applyConfigEnvironmentVariables();

      // Initialize telemetry after env vars are applied so OTEL endpoint env vars and
      // otelHeadersHelper (which requires trust to execute) are available.
      initializeTelemetryAfterTrust();

      // Kick SessionStart hooks now so the subprocess spawn overlaps with
      // MCP connect + plugin init + print.ts import below. loadInitialMessages
      // joins this at print.ts:4397. Guarded same as loadInitialMessages —
      // continue/resume/teleport paths don't fire startup hooks (or fire them
      // conditionally inside the resume branch, where this promise is
      // undefined and the ?? fallback runs). Also skip when setupTrigger is
      // set — those paths run setup hooks first (print.ts:544), and session
      // start hooks must wait until setup completes.
      const sessionStartHooksPromise = options.continue || options.resume || teleport || setupTrigger ? undefined : processSessionStartHooks('startup');
      // Suppress transient unhandledRejection if this rejects before
      // loadInitialMessages awaits it. Downstream await still observes the
      // rejection — this just prevents the spurious global handler fire.
      sessionStartHooksPromise?.catch(() => {});
      profileCheckpoint('before_validateForceLoginOrg');
      // Validate org restriction for non-interactive sessions
      const orgValidation = await validateForceLoginOrg();
      if (!orgValidation.valid) {
        process.stderr.write(orgValidation.message + '\n');
        process.exit(1);
      }

      // Headless mode supports all prompt commands and some local commands
      // If disableSlashCommands is true, return empty array
      const commandsHeadless = disableSlashCommands ? [] : commands.filter(command => command.type === 'prompt' && !command.disableNonInteractive || command.type === 'local' && command.supportsNonInteractive);
      const defaultState = getDefaultAppState();
      const headlessInitialState: AppState = {
        ...defaultState,
        mcp: {
          ...defaultState.mcp,
          clients: mcpClients,
          commands: mcpCommands,
          tools: mcpTools
        },
        toolPermissionContext,
        effortValue: parseEffortValue(options.effort) ?? getInitialEffortSetting(),
        ...(isFastModeEnabled() && {
          fastMode: getInitialFastModeSetting(effectiveModel ?? null)
        }),
        ...(isAdvisorEnabled() && advisorModel && {
          advisorModel
        }),
        // kairosEnabled gates the async fire-and-forget path in
        // executeForkedSlashCommand (processSlashCommand.tsx:132) and
        // AgentTool's shouldRunAsync. The REPL initialState sets this at
        // ~3459; headless was defaulting to false, so the daemon child's
        // scheduled tasks and Agent-tool calls ran synchronously — N
        // overdue cron tasks on spawn = N serial subagent turns blocking
        // user input. Computed at :1620, well before this branch.
        ...(feature('KAIROS') ? {
          kairosEnabled
        } : {})
      };

      // Init app state
      const headlessStore = createStore(headlessInitialState, onChangeAppState);

      // Check if bypassPermissions should be disabled based on Statsig gate
      // This runs in parallel to the code below, to avoid blocking the main loop.
      if (toolPermissionContext.mode === 'bypassPermissions' || allowDangerouslySkipPermissions) {
        void checkAndDisableBypassPermissions(toolPermissionContext);
      }

      // Async check of auto mode gate — corrects state and disables auto if needed.
      // Gated on TRANSCRIPT_CLASSIFIER (not USER_TYPE) so GrowthBook kill switch runs for external builds too.
      if (feature('TRANSCRIPT_CLASSIFIER')) {
        void verifyAutoModeGateAccess(toolPermissionContext, headlessStore.getState().fastMode).then(({
          updateContext
        }) => {
          headlessStore.setState(prev => {
            const nextCtx = updateContext(prev.toolPermissionContext);
            if (nextCtx === prev.toolPermissionContext) return prev;
            return {
              ...prev,
              toolPermissionContext: nextCtx
            };
          });
        });
      }

      // Set global state for session persistence
      if (options.sessionPersistence === false) {
        setSessionPersistenceDisabled(true);
      }

      // Store SDK betas in global state for context window calculation
      // Only store allowed betas (filters by allowlist and subscriber status)
      setSdkBetas(filterAllowedSdkBetas(betas));

      // Print-mode MCP: per-server incremental push into headlessStore.
      // Mirrors useManageMCPConnections — push pending first (so ToolSearch's
      // pending-check at ToolSearchTool.ts:334 sees them), then replace with
      // connected/failed as each server settles.
      const connectMcpBatch = (configs: Record<string, ScopedMcpServerConfig>, label: string): Promise<void> => {
        if (Object.keys(configs).length === 0) return Promise.resolve();
        headlessStore.setState(prev => ({
          ...prev,
          mcp: {
            ...prev.mcp,
            clients: [...prev.mcp.clients, ...Object.entries(configs).map(([name, config]) => ({
              name,
              type: 'pending' as const,
              config
            }))]
          }
        }));
        return getMcpToolsCommandsAndResources(({
          client,
          tools,
          commands
        }) => {
          headlessStore.setState(prev => ({
            ...prev,
            mcp: {
              ...prev.mcp,
              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],
              tools: uniqBy([...prev.mcp.tools, ...tools], 'name'),
              commands: uniqBy([...prev.mcp.commands, ...commands], 'name')
            }
          }));
        }, configs).catch(err => logForDebugging(`[MCP] ${label} connect error: ${err}`));
      };
      // Await all MCP configs — print mode is often single-turn, so
      // "late-connecting servers visible next turn" doesn't help. SDK init
      // message and turn-1 tool list both need configured MCP tools present.
      // Zero-server case is free via the early return in connectMcpBatch.
      // Connectors parallelize inside getMcpToolsCommandsAndResources
      // (processBatched with Promise.all). claude.ai is awaited too — its
      // fetch was kicked off early (line ~2558) so only residual time blocks
      // here. --bare skips claude.ai entirely for perf-sensitive scripts.
      profileCheckpoint('before_connectMcp');
      await connectMcpBatch(regularMcpConfigs, 'regular');
      profileCheckpoint('after_connectMcp');
      // Dedup: suppress plugin MCP servers that duplicate a claude.ai
      // connector (connector wins), then connect claude.ai servers.
      // Bounded wait — #23725 made this blocking so single-turn -p sees
      // connectors, but with 40+ slow connectors tengu_startup_perf p99
      // climbed to 76s. If fetch+connect doesn't finish in time, proceed;
      // the promise keeps running and updates headlessStore in the
      // background so turn 2+ still sees connectors.
      const CLAUDE_AI_MCP_TIMEOUT_MS = 5_000;
      const claudeaiConnect = claudeaiConfigPromise.then(claudeaiConfigs => {
        if (Object.keys(claudeaiConfigs).length > 0) {
          const claudeaiSigs = new Set<string>();
          for (const config of Object.values(claudeaiConfigs)) {
            const sig = getMcpServerSignature(config);
            if (sig) claudeaiSigs.add(sig);
          }
          const suppressed = new Set<string>();
          for (const [name, config] of Object.entries(regularMcpConfigs)) {
            if (!name.startsWith('plugin:')) continue;
            const sig = getMcpServerSignature(config);
            if (sig && claudeaiSigs.has(sig)) suppressed.add(name);
          }
          if (suppressed.size > 0) {
            logForDebugging(`[MCP] Lazy dedup: suppressing ${suppressed.size} plugin server(s) that duplicate claude.ai connectors: ${[...suppressed].join(', ')}`);
            // Disconnect before filtering from state. Only connected
            // servers need cleanup — clearServerCache on a never-connected
            // server triggers a real connect just to kill it (memoize
            // cache-miss path, see useManageMCPConnections.ts:870).
            for (const c of headlessStore.getState().mcp.clients) {
              if (!suppressed.has(c.name) || c.type !== 'connected') continue;
              c.client.onclose = undefined;
              void clearServerCache(c.name, c.config).catch(() => {});
            }
            headlessStore.setState(prev => {
              let {
                clients,
                tools,
                commands,
                resources
              } = prev.mcp;
              clients = clients.filter(c => !suppressed.has(c.name));
              tools = tools.filter(t => !t.mcpInfo || !suppressed.has(t.mcpInfo.serverName));
              for (const name of suppressed) {
                commands = excludeCommandsByServer(commands, name);
                resources = excludeResourcesByServer(resources, name);
              }
              return {
                ...prev,
                mcp: {
                  ...prev.mcp,
                  clients,
                  tools,
                  commands,
                  resources
                }
              };
            });
          }
        }
        // Suppress claude.ai connectors that duplicate an enabled
        // manual server (URL-signature match). Plugin dedup above only
        // handles `plugin:*` keys; this catches manual `.mcp.json` entries.
        // plugin:* must be excluded here — step 1 already suppressed
        // those (claude.ai wins); leaving them in suppresses the
        // connector too, and neither survives (gh-39974).
        const nonPluginConfigs = pickBy(regularMcpConfigs, (_, n) => !n.startsWith('plugin:'));
        const {
          servers: dedupedClaudeAi
        } = dedupClaudeAiMcpServers(claudeaiConfigs, nonPluginConfigs);
        return connectMcpBatch(dedupedClaudeAi, 'claudeai');
      });
      let claudeaiTimer: ReturnType<typeof setTimeout> | undefined;
      const claudeaiTimedOut = await Promise.race([claudeaiConnect.then(() => false), new Promise<boolean>(resolve => {
        claudeaiTimer = setTimeout(r => r(true), CLAUDE_AI_MCP_TIMEOUT_MS, resolve);
      })]);
      if (claudeaiTimer) clearTimeout(claudeaiTimer);
      if (claudeaiTimedOut) {
        logForDebugging(`[MCP] claude.ai connectors not ready after ${CLAUDE_AI_MCP_TIMEOUT_MS}ms — proceeding; background connection continues`);
      }
      profileCheckpoint('after_connectMcp_claudeai');

      // In headless mode, start deferred prefetches immediately (no user typing delay)
      // --bare / SIMPLE: startDeferredPrefetches early-returns internally.
      // backgroundHousekeeping (initExtractMemories, pruneShellSnapshots,
      // cleanupOldMessageFiles) and sdkHeapDumpMonitor are all bookkeeping
      // that scripted calls don't need — the next interactive session reconciles.
      if (!isBareMode()) {
        startDeferredPrefetches();
        void import('./utils/backgroundHousekeeping.js').then(m => m.startBackgroundHousekeeping());
        if ("external" === 'ant') {
          void import('./utils/sdkHeapDumpMonitor.js').then(m => m.startSdkMemoryMonitor());
        }
      }
      logSessionTelemetry();
      profileCheckpoint('before_print_import');
      const {
        runHeadless
      } = await import('src/cli/print.js');
      profileCheckpoint('after_print_import');
      void runHeadless(inputPrompt, () => headlessStore.getState(), headlessStore.setState, commandsHeadless, tools, sdkMcpConfigs, agentDefinitions.activeAgents, {
        continue: options.continue,
        resume: options.resume,
        verbose: verbose,
        outputFormat: outputFormat,
        jsonSchema,
        permissionPromptToolName: options.permissionPromptTool,
        allowedTools,
        thinkingConfig,
        maxTurns: options.maxTurns,
        maxBudgetUsd: options.maxBudgetUsd,
        taskBudget: options.taskBudget ? {
          total: options.taskBudget
        } : undefined,
        systemPrompt,
        appendSystemPrompt,
        userSpecifiedModel: effectiveModel,
        fallbackModel: userSpecifiedFallbackModel,
        teleport,
        sdkUrl,
        replayUserMessages: effectiveReplayUserMessages,
        includePartialMessages: effectiveIncludePartialMessages,
        forkSession: options.forkSession || false,
        resumeSessionAt: options.resumeSessionAt || undefined,
        rewindFiles: options.rewindFiles,
        enableAuthStatus: options.enableAuthStatus,
        agent: agentCli,
        workload: options.workload,
        setupTrigger: setupTrigger ?? undefined,
        sessionStartHooksPromise
      });
      return;
    }

    // Log model config at startup
    logEvent('tengu_startup_manual_model_config', {
      cli_flag: options.model as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
      env_var: process.env.ANTHROPIC_MODEL as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
      settings_file: (getInitialSettings() || {}).model as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
      subscriptionType: getSubscriptionType() as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
      agent: agentSetting as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
    });

    // Get deprecation warning for the initial model (resolvedInitialModel computed earlier for hooks parallelization)
    const deprecationWarning = getModelDeprecationWarning(resolvedInitialModel);

    // Build initial notification queue
    const initialNotifications: Array<{
      key: string;
      text: string;
      color?: 'warning';
      priority: 'high';
    }> = [];
    if (permissionModeNotification) {
      initialNotifications.push({
        key: 'permission-mode-notification',
        text: permissionModeNotification,
        priority: 'high'
      });
    }
    if (deprecationWarning) {
      initialNotifications.push({
        key: 'model-deprecation-warning',
        text: deprecationWarning,
        color: 'warning',
        priority: 'high'
      });
    }
    if (overlyBroadBashPermissions.length > 0) {
      const displayList = uniq(overlyBroadBashPermissions.map(p => p.ruleDisplay));
      const displays = displayList.join(', ');
      const sources = uniq(overlyBroadBashPermissions.map(p => p.sourceDisplay)).join(', ');
      const n = displayList.length;
      initialNotifications.push({
        key: 'overly-broad-bash-notification',
        text: `${displays} allow ${plural(n, 'rule')} from ${sources} ${plural(n, 'was', 'were')} ignored \u2014 not available for Ants, please use auto-mode instead`,
        color: 'warning',
        priority: 'high'
      });
    }
    const effectiveToolPermissionContext = {
      ...toolPermissionContext,
      mode: isAgentSwarmsEnabled() && getTeammateUtils().isPlanModeRequired() ? 'plan' as const : toolPermissionContext.mode
    };
    // All startup opt-in paths (--tools, --brief, defaultView) have fired
    // above; initialIsBriefOnly just reads the resulting state.
    const initialIsBriefOnly = feature('KAIROS') || feature('KAIROS_BRIEF') ? getUserMsgOptIn() : false;
    const fullRemoteControl = remoteControl || getRemoteControlAtStartup() || kairosEnabled;
    let ccrMirrorEnabled = false;
    if (feature('CCR_MIRROR') && !fullRemoteControl) {
      /* eslint-disable @typescript-eslint/no-require-imports */
      const {
        isCcrMirrorEnabled
      } = require('./bridge/bridgeEnabled.js') as typeof import('./bridge/bridgeEnabled.js');
      /* eslint-enable @typescript-eslint/no-require-imports */
      ccrMirrorEnabled = isCcrMirrorEnabled();
    }
    const initialState: AppState = {
      settings: getInitialSettings(),
      tasks: {},
      agentNameRegistry: new Map(),
      verbose: verbose ?? getGlobalConfig().verbose ?? false,
      mainLoopModel: initialMainLoopModel,
      mainLoopModelForSession: null,
      isBriefOnly: initialIsBriefOnly,
      expandedView: getGlobalConfig().showSpinnerTree ? 'teammates' : getGlobalConfig().showExpandedTodos ? 'tasks' : 'none',
      showTeammateMessagePreview: isAgentSwarmsEnabled() ? false : undefined,
      selectedIPAgentIndex: -1,
      coordinatorTaskIndex: -1,
      viewSelectionMode: 'none',
      footerSelection: null,
      toolPermissionContext: effectiveToolPermissionContext,
      agent: mainThreadAgentDefinition?.agentType,
      agentDefinitions,
      mcp: {
        clients: [],
        tools: [],
        commands: [],
        resources: {},
        pluginReconnectKey: 0
      },
      plugins: {
        enabled: [],
        disabled: [],
        commands: [],
        errors: [],
        installationStatus: {
          marketplaces: [],
          plugins: []
        },
        needsRefresh: false
      },
      statusLineText: undefined,
      kairosEnabled,
      remoteSessionUrl: undefined,
      remoteConnectionStatus: 'connecting',
      remoteBackgroundTaskCount: 0,
      replBridgeEnabled: fullRemoteControl || ccrMirrorEnabled,
      replBridgeExplicit: remoteControl,
      replBridgeOutboundOnly: ccrMirrorEnabled,
      replBridgeConnected: false,
      replBridgeSessionActive: false,
      replBridgeReconnecting: false,
      replBridgeConnectUrl: undefined,
      replBridgeSessionUrl: undefined,
      replBridgeEnvironmentId: undefined,
      replBridgeSessionId: undefined,
      replBridgeError: undefined,
      replBridgeInitialName: remoteControlName,
      showRemoteCallout: false,
      notifications: {
        current: null,
        queue: initialNotifications
      },
      elicitation: {
        queue: []
      },
      todos: {},
      remoteAgentTaskSuggestions: [],
      fileHistory: {
        snapshots: [],
        trackedFiles: new Set(),
        snapshotSequence: 0
      },
      attribution: createEmptyAttributionState(),
      thinkingEnabled,
      promptSuggestionEnabled: shouldEnablePromptSuggestion(),
      sessionHooks: new Map(),
      inbox: {
        messages: []
      },
      promptSuggestion: {
        text: null,
        promptId: null,
        shownAt: 0,
        acceptedAt: 0,
        generationRequestId: null
      },
      speculation: IDLE_SPECULATION_STATE,
      speculationSessionTimeSavedMs: 0,
      skillImprovement: {
        suggestion: null
      },
      workerSandboxPermissions: {
        queue: [],
        selectedIndex: 0
      },
      pendingWorkerRequest: null,
      pendingSandboxRequest: null,
      authVersion: 0,
      initialMessage: inputPrompt ? {
        message: createUserMessage({
          content: String(inputPrompt)
        })
      } : null,
      effortValue: parseEffortValue(options.effort) ?? getInitialEffortSetting(),
      activeOverlays: new Set<string>(),
      fastMode: getInitialFastModeSetting(resolvedInitialModel),
      ...(isAdvisorEnabled() && advisorModel && {
        advisorModel
      }),
      // Compute teamContext synchronously to avoid useEffect setState during render.
      // KAIROS: assistantTeamContext takes precedence — set earlier in the
      // KAIROS block so Agent(name: "foo") can spawn in-process teammates
      // without TeamCreate. computeInitialTeamContext() is for tmux-spawned
      // teammates reading their own identity, not the assistant-mode leader.
      teamContext: feature('KAIROS') ? assistantTeamContext ?? computeInitialTeamContext?.() : computeInitialTeamContext?.()
    };

    // Add CLI initial prompt to history
    if (inputPrompt) {
      addToHistory(String(inputPrompt));
    }
    const initialTools = mcpTools;

    // Increment numStartups synchronously — first-render readers like
    // shouldShowEffortCallout (via useState initializer) need the updated
    // value before setImmediate fires. Defer only telemetry.
    saveGlobalConfig(current => ({
      ...current,
      numStartups: (current.numStartups ?? 0) + 1
    }));
    setImmediate(() => {
      void logStartupTelemetry();
      logSessionTelemetry();
    });

    // Set up per-turn session environment data uploader (ant-only build).
    // Default-enabled for all ant users when working in an Anthropic-owned
    // repo. Captures git/filesystem state (NOT transcripts) at each turn so
    // environments can be recreated at any user message index. Gating:
    //   - Build-time: this import is stubbed in external builds.
    //   - Runtime: uploader checks github.com/anthropics/* remote + gcloud auth.
    //   - Safety: CLAUDE_CODE_DISABLE_SESSION_DATA_UPLOAD=1 bypasses (tests set this).
    // Import is dynamic + async to avoid adding startup latency.
    const sessionUploaderPromise = "external" === 'ant' ? import('./utils/sessionDataUploader.js') : null;

    // Defer session uploader resolution to the onTurnComplete callback to avoid
    // adding a new top-level await in main.tsx (performance-critical path).
    // The per-turn auth logic in sessionDataUploader.ts handles unauthenticated
    // state gracefully (re-checks each turn, so auth recovery mid-session works).
    const uploaderReady = sessionUploaderPromise ? sessionUploaderPromise.then(mod => mod.createSessionTurnUploader()).catch(() => null) : null;
    const sessionConfig = {
      debug: debug || debugToStderr,
      commands: [...commands, ...mcpCommands],
      initialTools,
      mcpClients,
      autoConnectIdeFlag: ide,
      mainThreadAgentDefinition,
      disableSlashCommands,
      dynamicMcpConfig,
      strictMcpConfig,
      systemPrompt,
      appendSystemPrompt,
      taskListId,
      thinkingConfig,
      ...(uploaderReady && {
        onTurnComplete: (messages: MessageType[]) => {
          void uploaderReady.then(uploader => uploader?.(messages));
        }
      })
    };

    // Shared context for processResumedConversation calls
    const resumeContext = {
      modeApi: coordinatorModeModule,
      mainThreadAgentDefinition,
      agentDefinitions,
      currentCwd,
      cliAgents,
      initialState
    };
    if (options.continue) {
      // Continue the most recent conversation directly
      let resumeSucceeded = false;
      try {
        const resumeStart = performance.now();

        // Clear stale caches before resuming to ensure fresh file/skill discovery
        const {
          clearSessionCaches
        } = await import('./commands/clear/caches.js');
        clearSessionCaches();
        const result = await loadConversationForResume(undefined /* sessionId */, undefined /* sourceFile */);
        if (!result) {
          logEvent('tengu_continue', {
            success: false
          });
          return await exitWithError(root, 'No conversation found to continue');
        }
        const loaded = await processResumedConversation(result, {
          forkSession: !!options.forkSession,
          includeAttribution: true,
          transcriptPath: result.fullPath
        }, resumeContext);
        if (loaded.restoredAgentDef) {
          mainThreadAgentDefinition = loaded.restoredAgentDef;
        }
        maybeActivateProactive(options);
        maybeActivateBrief(options);
        logEvent('tengu_continue', {
          success: true,
          resume_duration_ms: Math.round(performance.now() - resumeStart)
        });
        resumeSucceeded = true;
        await launchRepl(root, {
          getFpsMetrics,
          stats,
          initialState: loaded.initialState
        }, {
          ...sessionConfig,
          mainThreadAgentDefinition: loaded.restoredAgentDef ?? mainThreadAgentDefinition,
          initialMessages: loaded.messages,
          initialFileHistorySnapshots: loaded.fileHistorySnapshots,
          initialContentReplacements: loaded.contentReplacements,
          initialAgentName: loaded.agentName,
          initialAgentColor: loaded.agentColor
        }, renderAndRun);
      } catch (error) {
        if (!resumeSucceeded) {
          logEvent('tengu_continue', {
            success: false
          });
        }
        logError(error);
        process.exit(1);
      }
    } else if (feature('DIRECT_CONNECT') && _pendingConnect?.url) {
      // `claude connect <url>` — full interactive TUI connected to a remote server
      let directConnectConfig;
      try {
        const session = await createDirectConnectSession({
          serverUrl: _pendingConnect.url,
          authToken: _pendingConnect.authToken,
          cwd: getOriginalCwd(),
          dangerouslySkipPermissions: _pendingConnect.dangerouslySkipPermissions
        });
        if (session.workDir) {
          setOriginalCwd(session.workDir);
          setCwdState(session.workDir);
        }
        setDirectConnectServerUrl(_pendingConnect.url);
        directConnectConfig = session.config;
      } catch (err) {
        return await exitWithError(root, err instanceof DirectConnectError ? err.message : String(err), () => gracefulShutdown(1));
      }
      const connectInfoMessage = createSystemMessage(`Connected to server at ${_pendingConnect.url}\nSession: ${directConnectConfig.sessionId}`, 'info');
      await launchRepl(root, {
        getFpsMetrics,
        stats,
        initialState
      }, {
        debug: debug || debugToStderr,
        commands,
        initialTools: [],
        initialMessages: [connectInfoMessage],
        mcpClients: [],
        autoConnectIdeFlag: ide,
        mainThreadAgentDefinition,
        disableSlashCommands,
        directConnectConfig,
        thinkingConfig
      }, renderAndRun);
      return;
    } else if (feature('SSH_REMOTE') && _pendingSSH?.host) {
      // `claude ssh <host> [dir]` — probe remote, deploy binary if needed,
      // spawn ssh with unix-socket -R forward to a local auth proxy, hand
      // the REPL an SSHSession. Tools run remotely, UI renders locally.
      // `--local` skips probe/deploy/ssh and spawns the current binary
      // directly with the same env — e2e test of the proxy/auth plumbing.
      const {
        createSSHSession,
        createLocalSSHSession,
        SSHSessionError
      } = await import('./ssh/createSSHSession.js');
      let sshSession;
      try {
        if (_pendingSSH.local) {
          process.stderr.write('Starting local ssh-proxy test session...\n');
          sshSession = createLocalSSHSession({
            cwd: _pendingSSH.cwd,
            permissionMode: _pendingSSH.permissionMode,
            dangerouslySkipPermissions: _pendingSSH.dangerouslySkipPermissions
          });
        } else {
          process.stderr.write(`Connecting to ${_pendingSSH.host}…\n`);
          // In-place progress: \r + EL0 (erase to end of line). Final \n on
          // success so the next message lands on a fresh line. No-op when
          // stderr isn't a TTY (piped/redirected) — \r would just emit noise.
          const isTTY = process.stderr.isTTY;
          let hadProgress = false;
          sshSession = await createSSHSession({
            host: _pendingSSH.host,
            cwd: _pendingSSH.cwd,
            localVersion: MACRO.VERSION,
            permissionMode: _pendingSSH.permissionMode,
            dangerouslySkipPermissions: _pendingSSH.dangerouslySkipPermissions,
            extraCliArgs: _pendingSSH.extraCliArgs
          }, isTTY ? {
            onProgress: msg => {
              hadProgress = true;
              process.stderr.write(`\r  ${msg}\x1b[K`);
            }
          } : {});
          if (hadProgress) process.stderr.write('\n');
        }
        setOriginalCwd(sshSession.remoteCwd);
        setCwdState(sshSession.remoteCwd);
        setDirectConnectServerUrl(_pendingSSH.local ? 'local' : _pendingSSH.host);
      } catch (err) {
        return await exitWithError(root, err instanceof SSHSessionError ? err.message : String(err), () => gracefulShutdown(1));
      }
      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');
      await launchRepl(root, {
        getFpsMetrics,
        stats,
        initialState
      }, {
        debug: debug || debugToStderr,
        commands,
        initialTools: [],
        initialMessages: [sshInfoMessage],
        mcpClients: [],
        autoConnectIdeFlag: ide,
        mainThreadAgentDefinition,
        disableSlashCommands,
        sshSession,
        thinkingConfig
      }, renderAndRun);
      return;
    } else if (feature('KAIROS') && _pendingAssistantChat && (_pendingAssistantChat.sessionId || _pendingAssistantChat.discover)) {
      // `claude assistant [sessionId]` — REPL as a pure viewer client
      // of a remote assistant session. The agentic loop runs remotely; this
      // process streams live events and POSTs messages. History is lazy-
      // loaded by useAssistantHistory on scroll-up (no blocking fetch here).
      const {
        discoverAssistantSessions
      } = await import('./assistant/sessionDiscovery.js');
      let targetSessionId = _pendingAssistantChat.sessionId;

      // Discovery flow — list bridge environments, filter sessions
      if (!targetSessionId) {
        let sessions;
        try {
          sessions = await discoverAssistantSessions();
        } catch (e) {
          return await exitWithError(root, `Failed to discover sessions: ${e instanceof Error ? e.message : e}`, () => gracefulShutdown(1));
        }
        if (sessions.length === 0) {
          let installedDir: string | null;
          try {
            installedDir = await launchAssistantInstallWizard(root);
          } catch (e) {
            return await exitWithError(root, `Assistant installation failed: ${e instanceof Error ? e.message : e}`, () => gracefulShutdown(1));
          }
          if (installedDir === null) {
            await gracefulShutdown(0);
            process.exit(0);
          }
          // The daemon needs a few seconds to spin up its worker and
          // establish a bridge session before discovery will find it.
          return await exitWithMessage(root, `Assistant installed in ${installedDir}. The daemon is starting up — run \`claude assistant\` again in a few seconds to connect.`, {
            exitCode: 0,
            beforeExit: () => gracefulShutdown(0)
          });
        }
        if (sessions.length === 1) {
          targetSessionId = sessions[0]!.id;
        } else {
          const picked = await launchAssistantSessionChooser(root, {
            sessions
          });
          if (!picked) {
            await gracefulShutdown(0);
            process.exit(0);
          }
          targetSessionId = picked;
        }
      }

      // Auth — call prepareApiRequest() once for orgUUID, but use a
      // getAccessToken closure for the token so reconnects get fresh tokens.
      const {
        checkAndRefreshOAuthTokenIfNeeded,
        getClaudeAIOAuthTokens
      } = await import('./utils/auth.js');
      await checkAndRefreshOAuthTokenIfNeeded();
      let apiCreds;
      try {
        apiCreds = await prepareApiRequest();
      } catch (e) {
        return await exitWithError(root, `Error: ${e instanceof Error ? e.message : 'Failed to authenticate'}`, () => gracefulShutdown(1));
      }
      const getAccessToken = (): string => getClaudeAIOAuthTokens()?.accessToken ?? apiCreds.accessToken;

      // Brief mode activation: setKairosActive(true) satisfies BOTH opt-in
      // and entitlement for isBriefEnabled() (BriefTool.ts:124-132).
      setKairosActive(true);
      setUserMsgOptIn(true);
      setIsRemoteMode(true);
      const remoteSessionConfig = createRemoteSessionConfig(targetSessionId, getAccessToken, apiCreds.orgUUID, /* hasInitialPrompt */false, /* viewerOnly */true);
      const infoMessage = createSystemMessage(`Attached to assistant session ${targetSessionId.slice(0, 8)}…`, 'info');
      const assistantInitialState: AppState = {
        ...initialState,
        isBriefOnly: true,
        kairosEnabled: false,
        replBridgeEnabled: false
      };
      const remoteCommands = filterCommandsForRemoteMode(commands);
      await launchRepl(root, {
        getFpsMetrics,
        stats,
        initialState: assistantInitialState
      }, {
        debug: debug || debugToStderr,
        commands: remoteCommands,
        initialTools: [],
        initialMessages: [infoMessage],
        mcpClients: [],
        autoConnectIdeFlag: ide,
        mainThreadAgentDefinition,
        disableSlashCommands,
        remoteSessionConfig,
        thinkingConfig
      }, renderAndRun);
      return;
    } else if (options.resume || options.fromPr || teleport || remote !== null) {
      // Handle resume flow - from file (ant-only), session ID, or interactive selector

      // Clear stale caches before resuming to ensure fresh file/skill discovery
      const {
        clearSessionCaches
      } = await import('./commands/clear/caches.js');
      clearSessionCaches();
      let messages: MessageType[] | null = null;
      let processedResume: ProcessedResume | undefined = undefined;
      let maybeSessionId = validateUuid(options.resume);
      let searchTerm: string | undefined = undefined;
      // Store full LogOption when found by custom title (for cross-worktree resume)
      let matchedLog: LogOption | null = null;
      // PR filter for --from-pr flag
      let filterByPr: boolean | number | string | undefined = undefined;

      // Handle --from-pr flag
      if (options.fromPr) {
        if (options.fromPr === true) {
          // Show all sessions with linked PRs
          filterByPr = true;
        } else if (typeof options.fromPr === 'string') {
          // Could be a PR number or URL
          filterByPr = options.fromPr;
        }
      }

      // If resume value is not a UUID, try exact match by custom title first
      if (options.resume && typeof options.resume === 'string' && !maybeSessionId) {
        const trimmedValue = options.resume.trim();
        if (trimmedValue) {
          const matches = await searchSessionsByCustomTitle(trimmedValue, {
            exact: true
          });
          if (matches.length === 1) {
            // Exact match found - store full LogOption for cross-worktree resume
            matchedLog = matches[0]!;
            maybeSessionId = getSessionIdFromLog(matchedLog) ?? null;
          } else {
            // No match or multiple matches - use as search term for picker
            searchTerm = trimmedValue;
          }
        }
      }

      // --remote and --teleport both create/resume Claude Code Web (CCR) sessions.
      // Remote Control (--rc) is a separate feature gated in initReplBridge.ts.
      if (remote !== null || teleport) {
        await waitForPolicyLimitsToLoad();
        if (!isPolicyAllowed('allow_remote_sessions')) {
          return await exitWithError(root, "Error: Remote sessions are disabled by your organization's policy.", () => gracefulShutdown(1));
        }
      }
      if (remote !== null) {
        // Create remote session (optionally with initial prompt)
        const hasInitialPrompt = remote.length > 0;

        // Check if TUI mode is enabled - description is only optional in TUI mode
        const isRemoteTuiEnabled = getFeatureValue_CACHED_MAY_BE_STALE('tengu_remote_backend', false);
        if (!isRemoteTuiEnabled && !hasInitialPrompt) {
          return await exitWithError(root, 'Error: --remote requires a description.\nUsage: claude --remote "your task description"', () => gracefulShutdown(1));
        }
        logEvent('tengu_remote_create_session', {
          has_initial_prompt: String(hasInitialPrompt) as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
        });

        // Pass current branch so CCR clones the repo at the right revision
        const currentBranch = await getBranch();
        const createdSession = await teleportToRemoteWithErrorHandling(root, hasInitialPrompt ? remote : null, new AbortController().signal, currentBranch || undefined);
        if (!createdSession) {
          logEvent('tengu_remote_create_session_error', {
            error: 'unable_to_create_session' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
          });
          return await exitWithError(root, 'Error: Unable to create remote session', () => gracefulShutdown(1));
        }
        logEvent('tengu_remote_create_session_success', {
          session_id: createdSession.id as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
        });

        // Check if new remote TUI mode is enabled via feature gate
        if (!isRemoteTuiEnabled) {
          // Original behavior: print session info and exit
          process.stdout.write(`Created remote session: ${createdSession.title}\n`);
          process.stdout.write(`View: ${getRemoteSessionUrl(createdSession.id)}?m=0\n`);
          process.stdout.write(`Resume with: claude --teleport ${createdSession.id}\n`);
          await gracefulShutdown(0);
          process.exit(0);
        }

        // New behavior: start local TUI with CCR engine
        // Mark that we're in remote mode for command visibility
        setIsRemoteMode(true);
        switchSession(asSessionId(createdSession.id));

        // Get OAuth credentials for remote session
        let apiCreds: {
          accessToken: string;
          orgUUID: string;
        };
        try {
          apiCreds = await prepareApiRequest();
        } catch (error) {
          logError(toError(error));
          return await exitWithError(root, `Error: ${errorMessage(error) || 'Failed to authenticate'}`, () => gracefulShutdown(1));
        }

        // Create remote session config for the REPL
        const {
          getClaudeAIOAuthTokens: getTokensForRemote
        } = await import('./utils/auth.js');
        const getAccessTokenForRemote = (): string => getTokensForRemote()?.accessToken ?? apiCreds.accessToken;
        const remoteSessionConfig = createRemoteSessionConfig(createdSession.id, getAccessTokenForRemote, apiCreds.orgUUID, hasInitialPrompt);

        // Add remote session info as initial system message
        const remoteSessionUrl = `${getRemoteSessionUrl(createdSession.id)}?m=0`;
        const remoteInfoMessage = createSystemMessage(`/remote-control is active. Code in CLI or at ${remoteSessionUrl}`, 'info');

        // Create initial user message from the prompt if provided (CCR echoes it back but we ignore that)
        const initialUserMessage = hasInitialPrompt ? createUserMessage({
          content: remote
        }) : null;

        // Set remote session URL in app state for footer indicator
        const remoteInitialState = {
          ...initialState,
          remoteSessionUrl
        };

        // Pre-filter commands to only include remote-safe ones.
        // CCR's init response may further refine the list (via handleRemoteInit in REPL).
        const remoteCommands = filterCommandsForRemoteMode(commands);
        await launchRepl(root, {
          getFpsMetrics,
          stats,
          initialState: remoteInitialState
        }, {
          debug: debug || debugToStderr,
          commands: remoteCommands,
          initialTools: [],
          initialMessages: initialUserMessage ? [remoteInfoMessage, initialUserMessage] : [remoteInfoMessage],
          mcpClients: [],
          autoConnectIdeFlag: ide,
          mainThreadAgentDefinition,
          disableSlashCommands,
          remoteSessionConfig,
          thinkingConfig
        }, renderAndRun);
        return;
      } else if (teleport) {
        if (teleport === true || teleport === '') {
          // Interactive mode: show task selector and handle resume
          logEvent('tengu_teleport_interactive_mode', {});
          logForDebugging('selectAndResumeTeleportTask: Starting teleport flow...');
          const teleportResult = await launchTeleportResumeWrapper(root);
          if (!teleportResult) {
            // User cancelled or error occurred
            await gracefulShutdown(0);
            process.exit(0);
          }
          const {
            branchError
          } = await checkOutTeleportedSessionBranch(teleportResult.branch);
          messages = processMessagesForTeleportResume(teleportResult.log, branchError);
        } else if (typeof teleport === 'string') {
          logEvent('tengu_teleport_resume_session', {
            mode: 'direct' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
          });
          try {
            // First, fetch session and validate repository before checking git state
            const sessionData = await fetchSession(teleport);
            const repoValidation = await validateSessionRepository(sessionData);

            // Handle repo mismatch or not in repo cases
            if (repoValidation.status === 'mismatch' || repoValidation.status === 'not_in_repo') {
              const sessionRepo = repoValidation.sessionRepo;
              if (sessionRepo) {
                // Check for known paths
                const knownPaths = getKnownPathsForRepo(sessionRepo);
                const existingPaths = await filterExistingPaths(knownPaths);
                if (existingPaths.length > 0) {
                  // Show directory switch dialog
                  const selectedPath = await launchTeleportRepoMismatchDialog(root, {
                    targetRepo: sessionRepo,
                    initialPaths: existingPaths
                  });
                  if (selectedPath) {
                    // Change to the selected directory
                    process.chdir(selectedPath);
                    setCwd(selectedPath);
                    setOriginalCwd(selectedPath);
                  } else {
                    // User cancelled
                    await gracefulShutdown(0);
                  }
                } else {
                  // No known paths - show original error
                  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`));
                }
              }
            } else if (repoValidation.status === 'error') {
              throw new TeleportOperationError(repoValidation.errorMessage || 'Failed to validate session', chalk.red(`Error: ${repoValidation.errorMessage || 'Failed to validate session'}\n`));
            }
            await validateGitState();

            // Use progress UI for teleport
            const {
              teleportWithProgress
            } = await import('./components/TeleportProgress.js');
            const result = await teleportWithProgress(root, teleport);
            // Track teleported session for reliability logging
            setTeleportedSessionInfo({
              sessionId: teleport
            });
            messages = result.messages;
          } catch (error) {
            if (error instanceof TeleportOperationError) {
              process.stderr.write(error.formattedMessage + '\n');
            } else {
              logError(error);
              process.stderr.write(chalk.red(`Error: ${errorMessage(error)}\n`));
            }
            await gracefulShutdown(1);
          }
        }
      }
      if ("external" === 'ant') {
        if (options.resume && typeof options.resume === 'string' && !maybeSessionId) {
          // Check for ccshare URL (e.g. https://go/ccshare/boris-20260311-211036)
          const {
            parseCcshareId,
            loadCcshare
          } = await import('./utils/ccshareResume.js');
          const ccshareId = parseCcshareId(options.resume);
          if (ccshareId) {
            try {
              const resumeStart = performance.now();
              const logOption = await loadCcshare(ccshareId);
              const result = await loadConversationForResume(logOption, undefined);
              if (result) {
                processedResume = await processResumedConversation(result, {
                  forkSession: true,
                  transcriptPath: result.fullPath
                }, resumeContext);
                if (processedResume.restoredAgentDef) {
                  mainThreadAgentDefinition = processedResume.restoredAgentDef;
                }
                logEvent('tengu_session_resumed', {
                  entrypoint: 'ccshare' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
                  success: true,
                  resume_duration_ms: Math.round(performance.now() - resumeStart)
                });
              } else {
                logEvent('tengu_session_resumed', {
                  entrypoint: 'ccshare' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
                  success: false
                });
              }
            } catch (error) {
              logEvent('tengu_session_resumed', {
                entrypoint: 'ccshare' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
                success: false
              });
              logError(error);
              await exitWithError(root, `Unable to resume from ccshare: ${errorMessage(error)}`, () => gracefulShutdown(1));
            }
          } else {
            const resolvedPath = resolve(options.resume);
            try {
              const resumeStart = performance.now();
              let logOption;
              try {
                // Attempt to load as a transcript file; ENOENT falls through to session-ID handling
                logOption = await loadTranscriptFromFile(resolvedPath);
              } catch (error) {
                if (!isENOENT(error)) throw error;
                // ENOENT: not a file path — fall through to session-ID handling
              }
              if (logOption) {
                const result = await loadConversationForResume(logOption, undefined /* sourceFile */);
                if (result) {
                  processedResume = await processResumedConversation(result, {
                    forkSession: !!options.forkSession,
                    transcriptPath: result.fullPath
                  }, resumeContext);
                  if (processedResume.restoredAgentDef) {
                    mainThreadAgentDefinition = processedResume.restoredAgentDef;
                  }
                  logEvent('tengu_session_resumed', {
                    entrypoint: 'file' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
                    success: true,
                    resume_duration_ms: Math.round(performance.now() - resumeStart)
                  });
                } else {
                  logEvent('tengu_session_resumed', {
                    entrypoint: 'file' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
                    success: false
                  });
                }
              }
            } catch (error) {
              logEvent('tengu_session_resumed', {
                entrypoint: 'file' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
                success: false
              });
              logError(error);
              await exitWithError(root, `Unable to load transcript from file: ${options.resume}`, () => gracefulShutdown(1));
            }
          }
        }
      }

      // If not loaded as a file, try as session ID
      if (maybeSessionId) {
        // Resume specific session by ID
        const sessionId = maybeSessionId;
        try {
          const resumeStart = performance.now();
          // Use matchedLog if available (for cross-worktree resume by custom title)
          // Otherwise fall back to sessionId string (for direct UUID resume)
          const result = await loadConversationForResume(matchedLog ?? sessionId, undefined);
          if (!result) {
            logEvent('tengu_session_resumed', {
              entrypoint: 'cli_flag' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
              success: false
            });
            return await exitWithError(root, `No conversation found with session ID: ${sessionId}`);
          }
          const fullPath = matchedLog?.fullPath ?? result.fullPath;
          processedResume = await processResumedConversation(result, {
            forkSession: !!options.forkSession,
            sessionIdOverride: sessionId,
            transcriptPath: fullPath
          }, resumeContext);
          if (processedResume.restoredAgentDef) {
            mainThreadAgentDefinition = processedResume.restoredAgentDef;
          }
          logEvent('tengu_session_resumed', {
            entrypoint: 'cli_flag' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
            success: true,
            resume_duration_ms: Math.round(performance.now() - resumeStart)
          });
        } catch (error) {
          logEvent('tengu_session_resumed', {
            entrypoint: 'cli_flag' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
            success: false
          });
          logError(error);
          await exitWithError(root, `Failed to resume session ${sessionId}`);
        }
      }

      // Await file downloads before rendering REPL (files must be available)
      if (fileDownloadPromise) {
        try {
          const results = await fileDownloadPromise;
          const failedCount = count(results, r => !r.success);
          if (failedCount > 0) {
            process.stderr.write(chalk.yellow(`Warning: ${failedCount}/${results.length} file(s) failed to download.\n`));
          }
        } catch (error) {
          return await exitWithError(root, `Error downloading files: ${errorMessage(error)}`);
        }
      }

      // If we have a processed resume or teleport messages, render the REPL
      const resumeData = processedResume ?? (Array.isArray(messages) ? {
        messages,
        fileHistorySnapshots: undefined,
        agentName: undefined,
        agentColor: undefined as AgentColorName | undefined,
        restoredAgentDef: mainThreadAgentDefinition,
        initialState,
        contentReplacements: undefined
      } : undefined);
      if (resumeData) {
        maybeActivateProactive(options);
        maybeActivateBrief(options);
        await launchRepl(root, {
          getFpsMetrics,
          stats,
          initialState: resumeData.initialState
        }, {
          ...sessionConfig,
          mainThreadAgentDefinition: resumeData.restoredAgentDef ?? mainThreadAgentDefinition,
          initialMessages: resumeData.messages,
          initialFileHistorySnapshots: resumeData.fileHistorySnapshots,
          initialContentReplacements: resumeData.contentReplacements,
          initialAgentName: resumeData.agentName,
          initialAgentColor: resumeData.agentColor
        }, renderAndRun);
      } else {
        // Show interactive selector (includes same-repo worktrees)
        // Note: ResumeConversation loads logs internally to ensure proper GC after selection
        await launchResumeChooser(root, {
          getFpsMetrics,
          stats,
          initialState
        }, getWorktreePaths(getOriginalCwd()), {
          ...sessionConfig,
          initialSearchQuery: searchTerm,
          forkSession: options.forkSession,
          filterByPr
        });
      }
    } else {
      // Pass unresolved hooks promise to REPL so it can render immediately
      // instead of blocking ~500ms waiting for SessionStart hooks to finish.
      // REPL will inject hook messages when they resolve and await them before
      // the first API call so the model always sees hook context.
      const pendingHookMessages = hooksPromise && hookMessages.length === 0 ? hooksPromise : undefined;
      profileCheckpoint('action_after_hooks');
      maybeActivateProactive(options);
      maybeActivateBrief(options);
      // Persist the current mode for fresh sessions so future resumes know what mode was used
      if (feature('COORDINATOR_MODE')) {
        saveMode(coordinatorModeModule?.isCoordinatorMode() ? 'coordinator' : 'normal');
      }

      // If launched via a deep link, show a provenance banner so the user
      // knows the session originated externally. Linux xdg-open and
      // browsers with "always allow" set dispatch the link with no OS-level
      // confirmation, so this is the only signal the user gets that the
      // prompt — and the working directory / CLAUDE.md it implies — came
      // from an external source rather than something they typed.
      let deepLinkBanner: ReturnType<typeof createSystemMessage> | null = null;
      if (feature('LODESTONE')) {
        if (options.deepLinkOrigin) {
          logEvent('tengu_deep_link_opened', {
            has_prefill: Boolean(options.prefill),
            has_repo: Boolean(options.deepLinkRepo)
          });
          deepLinkBanner = createSystemMessage(buildDeepLinkBanner({
            cwd: getCwd(),
            prefillLength: options.prefill?.length,
            repo: options.deepLinkRepo,
            lastFetch: options.deepLinkLastFetch !== undefined ? new Date(options.deepLinkLastFetch) : undefined
          }), 'warning');
        } else if (options.prefill) {
          deepLinkBanner = createSystemMessage('Launched with a pre-filled prompt — review it before pressing Enter.', 'warning');
        }
      }
      const initialMessages = deepLinkBanner ? [deepLinkBanner, ...hookMessages] : hookMessages.length > 0 ? hookMessages : undefined;
      await launchRepl(root, {
        getFpsMetrics,
        stats,
        initialState
      }, {
        ...sessionConfig,
        initialMessages,
        pendingHookMessages
      }, renderAndRun);
    }
  }).version(`${MACRO.VERSION} (Claude Code)`, '-v, --version', 'Output the version number');

  // Worktree flags
  program.option('-w, --worktree [name]', 'Create a new git worktree for this session (optionally specify a name)');
  program.option('--tmux', 'Create a tmux session for the worktree (requires --worktree). Uses iTerm2 native panes when available; use --tmux=classic for traditional tmux.');
  if (canUserConfigureAdvisor()) {
    program.addOption(new Option('--advisor <model>', 'Enable the server-side advisor tool with the specified model (alias or full ID).').hideHelp());
  }
  if ("external" === 'ant') {
    program.addOption(new Option('--delegate-permissions', '[ANT-ONLY] Alias for --permission-mode auto.').implies({
      permissionMode: 'auto'
    }));
    program.addOption(new Option('--dangerously-skip-permissions-with-classifiers', '[ANT-ONLY] Deprecated alias for --permission-mode auto.').hideHelp().implies({
      permissionMode: 'auto'
    }));
    program.addOption(new Option('--afk', '[ANT-ONLY] Deprecated alias for --permission-mode auto.').hideHelp().implies({
      permissionMode: 'auto'
    }));
    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());
    program.option('--agent-teams', '[ANT-ONLY] Force Claude to use multi-agent mode for solving problems', () => true);
  }
  if (feature('TRANSCRIPT_CLASSIFIER')) {
    program.addOption(new Option('--enable-auto-mode', 'Opt in to auto mode').hideHelp());
  }
  if (feature('PROACTIVE') || feature('KAIROS')) {
    program.addOption(new Option('--proactive', 'Start in proactive autonomous mode'));
  }
  if (feature('UDS_INBOX')) {
    program.addOption(new Option('--messaging-socket-path <path>', 'Unix domain socket path for the UDS messaging server (defaults to a tmp path)'));
  }
  if (feature('KAIROS') || feature('KAIROS_BRIEF')) {
    program.addOption(new Option('--brief', 'Enable SendUserMessage tool for agent-to-user communication'));
  }
  if (feature('KAIROS')) {
    program.addOption(new Option('--assistant', 'Force assistant mode (Agent SDK daemon use)').hideHelp());
  }
  if (feature('KAIROS') || feature('KAIROS_CHANNELS')) {
    program.addOption(new Option('--channels <servers...>', 'MCP servers whose channel notifications (inbound push) should register this session. Space-separated server names.').hideHelp());
    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());
  }

  // Teammate identity options (set by leader when spawning tmux teammates)
  // These replace the CLAUDE_CODE_* environment variables
  program.addOption(new Option('--agent-id <id>', 'Teammate agent ID').hideHelp());
  program.addOption(new Option('--agent-name <name>', 'Teammate display name').hideHelp());
  program.addOption(new Option('--team-name <name>', 'Team name for swarm coordination').hideHelp());
  program.addOption(new Option('--agent-color <color>', 'Teammate UI color').hideHelp());
  program.addOption(new Option('--plan-mode-required', 'Require plan mode before implementation').hideHelp());
  program.addOption(new Option('--parent-session-id <id>', 'Parent session ID for analytics correlation').hideHelp());
  program.addOption(new Option('--teammate-mode <mode>', 'How to spawn teammates: "tmux", "in-process", or "auto"').choices(['auto', 'tmux', 'in-process']).hideHelp());
  program.addOption(new Option('--agent-type <type>', 'Custom agent type for this teammate').hideHelp());

  // Enable SDK URL for all builds but hide from help
  program.addOption(new Option('--sdk-url <url>', 'Use remote WebSocket endpoint for SDK I/O streaming (only with -p and stream-json format)').hideHelp());

  // Enable teleport/remote flags for all builds but keep them undocumented until GA
  program.addOption(new Option('--teleport [session]', 'Resume a teleport session, optionally specify session ID').hideHelp());
  program.addOption(new Option('--remote [description]', 'Create a remote session with the given description').hideHelp());
  if (feature('BRIDGE_MODE')) {
    program.addOption(new Option('--remote-control [name]', 'Start an interactive session with Remote Control enabled (optionally named)').argParser(value => value || true).hideHelp());
    program.addOption(new Option('--rc [name]', 'Alias for --remote-control').argParser(value => value || true).hideHelp());
  }
  if (feature('HARD_FAIL')) {
    program.addOption(new Option('--hard-fail', 'Crash on logError calls instead of silently logging').hideHelp());
  }
  profileCheckpoint('run_main_options_built');

  // -p/--print mode: skip subcommand registration. The 52 subcommands
  // (mcp, auth, plugin, skill, task, config, doctor, update, etc.) are
  // never dispatched in print mode — commander routes the prompt to the
  // default action. The subcommand registration path was measured at ~65ms
  // on baseline — mostly the isBridgeEnabled() call (25ms settings Zod parse
  // + 40ms sync keychain subprocess), both hidden by the try/catch that
  // always returns false before enableConfigs(). cc:// URLs are rewritten to
  // `open` at main() line ~851 BEFORE this runs, so argv check is safe here.
  const isPrintMode = process.argv.includes('-p') || process.argv.includes('--print');
  const isCcUrl = process.argv.some(a => a.startsWith('cc://') || a.startsWith('cc+unix://'));
  if (isPrintMode && !isCcUrl) {
    profileCheckpoint('run_before_parse');
    await program.parseAsync(process.argv);
    profileCheckpoint('run_after_parse');
    return program;
  }

  // claude mcp

  const mcp = program.command('mcp').description('Configure and manage MCP servers').configureHelp(createSortedHelpConfig()).enablePositionalOptions();
  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 ({
    debug,
    verbose
  }: {
    debug?: boolean;
    verbose?: boolean;
  }) => {
    const {
      mcpServeHandler
    } = await import('./cli/handlers/mcp.js');
    await mcpServeHandler({
      debug,
      verbose
    });
  });

  // Register the mcp add subcommand (extracted for testability)
  registerMcpAddCommand(mcp);
  if (isXaaEnabled()) {
    registerMcpXaaIdpCommand(mcp);
  }
  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: {
    scope?: string;
  }) => {
    const {
      mcpRemoveHandler
    } = await import('./cli/handlers/mcp.js');
    await mcpRemoveHandler(name, options);
  });
  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 () => {
    const {
      mcpListHandler
    } = await import('./cli/handlers/mcp.js');
    await mcpListHandler();
  });
  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) => {
    const {
      mcpGetHandler
    } = await import('./cli/handlers/mcp.js');
    await mcpGetHandler(name);
  });
  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: {
    scope?: string;
    clientSecret?: true;
  }) => {
    const {
      mcpAddJsonHandler
    } = await import('./cli/handlers/mcp.js');
    await mcpAddJsonHandler(name, json, options);
  });
  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: {
    scope?: string;
  }) => {
    const {
      mcpAddFromDesktopHandler
    } = await import('./cli/handlers/mcp.js');
    await mcpAddFromDesktopHandler(options);
  });
  mcp.command('reset-project-choices').description('Reset all approved and rejected project-scoped (.mcp.json) servers within this project').action(async () => {
    const {
      mcpResetChoicesHandler
    } = await import('./cli/handlers/mcp.js');
    await mcpResetChoicesHandler();
  });

  // claude server
  if (feature('DIRECT_CONNECT')) {
    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: {
      port: string;
      host: string;
      authToken?: string;
      unix?: string;
      workspace?: string;
      idleTimeout: string;
      maxSessions: string;
    }) => {
      const {
        randomBytes
      } = await import('crypto');
      const {
        startServer
      } = await import('./server/server.js');
      const {
        SessionManager
      } = await import('./server/sessionManager.js');
      const {
        DangerousBackend
      } = await import('./server/backends/dangerousBackend.js');
      const {
        printBanner
      } = await import('./server/serverBanner.js');
      const {
        createServerLogger
      } = await import('./server/serverLog.js');
      const {
        writeServerLock,
        removeServerLock,
        probeRunningServer
      } = await import('./server/lockfile.js');
      const existing = await probeRunningServer();
      if (existing) {
        process.stderr.write(`A claude server is already running (pid ${existing.pid}) at ${existing.httpUrl}\n`);
        process.exit(1);
      }
      const authToken = opts.authToken ?? `sk-ant-cc-${randomBytes(16).toString('base64url')}`;
      const config = {
        port: parseInt(opts.port, 10),
        host: opts.host,
        authToken,
        unix: opts.unix,
        workspace: opts.workspace,
        idleTimeoutMs: parseInt(opts.idleTimeout, 10),
        maxSessions: parseInt(opts.maxSessions, 10)
      };
      const backend = new DangerousBackend();
      const sessionManager = new SessionManager(backend, {
        idleTimeoutMs: config.idleTimeoutMs,
        maxSessions: config.maxSessions
      });
      const logger = createServerLogger();
      const server = startServer(config, sessionManager, logger);
      const actualPort = server.port ?? config.port;
      printBanner(config, authToken, actualPort);
      await writeServerLock({
        pid: process.pid,
        port: actualPort,
        host: config.host,
        httpUrl: config.unix ? `unix:${config.unix}` : `http://${config.host}:${actualPort}`,
        startedAt: Date.now()
      });
      let shuttingDown = false;
      const shutdown = async () => {
        if (shuttingDown) return;
        shuttingDown = true;
        // Stop accepting new connections before tearing down sessions.
        server.stop(true);
        await sessionManager.destroyAll();
        await removeServerLock();
        process.exit(0);
      };
      process.once('SIGINT', () => void shutdown());
      process.once('SIGTERM', () => void shutdown());
    });
  }

  // `claude ssh <host> [dir]` — registered here only so --help shows it.
  // The actual interactive flow is handled by early argv rewriting in main()
  // (parallels the DIRECT_CONNECT/cc:// pattern above). If commander reaches
  // this action it means the argv rewrite didn't fire (e.g. user ran
  // `claude ssh` with no host) — just print usage.
  if (feature('SSH_REMOTE')) {
    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 () => {
      // Argv rewriting in main() should have consumed `ssh <host>` before
      // commander runs. Reaching here means host was missing or the
      // rewrite predicate didn't match.
      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');
      process.exit(1);
    });
  }

  // claude connect — subcommand only handles -p (headless) mode.
  // Interactive mode (without -p) is handled by early argv rewriting in main()
  // which redirects to the main command with full TUI support.
  if (feature('DIRECT_CONNECT')) {
    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: {
      print?: string | boolean;
      outputFormat: string;
    }) => {
      const {
        parseConnectUrl
      } = await import('./server/parseConnectUrl.js');
      const {
        serverUrl,
        authToken
      } = parseConnectUrl(ccUrl);
      let connectConfig;
      try {
        const session = await createDirectConnectSession({
          serverUrl,
          authToken,
          cwd: getOriginalCwd(),
          dangerouslySkipPermissions: _pendingConnect?.dangerouslySkipPermissions
        });
        if (session.workDir) {
          setOriginalCwd(session.workDir);
          setCwdState(session.workDir);
        }
        setDirectConnectServerUrl(serverUrl);
        connectConfig = session.config;
      } catch (err) {
        // biome-ignore lint/suspicious/noConsole: intentional error output
        console.error(err instanceof DirectConnectError ? err.message : String(err));
        process.exit(1);
      }
      const {
        runConnectHeadless
      } = await import('./server/connectHeadless.js');
      const prompt = typeof opts.print === 'string' ? opts.print : '';
      const interactive = opts.print === true;
      await runConnectHeadless(connectConfig, prompt, opts.outputFormat, interactive);
    });
  }

  // claude auth

  const auth = program.command('auth').description('Manage authentication').configureHelp(createSortedHelpConfig());
  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 ({
    email,
    sso,
    console: useConsole,
    claudeai
  }: {
    email?: string;
    sso?: boolean;
    console?: boolean;
    claudeai?: boolean;
  }) => {
    const {
      authLogin
    } = await import('./cli/handlers/auth.js');
    await authLogin({
      email,
      sso,
      console: useConsole,
      claudeai
    });
  });
  auth.command('status').description('Show authentication status').option('--json', 'Output as JSON (default)').option('--text', 'Output as human-readable text').action(async (opts: {
    json?: boolean;
    text?: boolean;
  }) => {
    const {
      authStatus
    } = await import('./cli/handlers/auth.js');
    await authStatus(opts);
  });
  auth.command('logout').description('Log out from your Anthropic account').action(async () => {
    const {
      authLogout
    } = await import('./cli/handlers/auth.js');
    await authLogout();
  });

  /**
   * Helper function to handle marketplace command errors consistently.
   * Logs the error and exits the process with status 1.
   * @param error The error that occurred
   * @param action Description of the action that failed
   */
  // Hidden flag on all plugin/marketplace subcommands to target cowork_plugins.
  const coworkOption = () => new Option('--cowork', 'Use cowork_plugins directory').hideHelp();

  // Plugin validate command
  const pluginCmd = program.command('plugin').alias('plugins').description('Manage Claude Code plugins').configureHelp(createSortedHelpConfig());
  pluginCmd.command('validate <path>').description('Validate a plugin or marketplace manifest').addOption(coworkOption()).action(async (manifestPath: string, options: {
    cowork?: boolean;
  }) => {
    const {
      pluginValidateHandler
    } = await import('./cli/handlers/plugins.js');
    await pluginValidateHandler(manifestPath, options);
  });

  // Plugin list command
  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: {
    json?: boolean;
    available?: boolean;
    cowork?: boolean;
  }) => {
    const {
      pluginListHandler
    } = await import('./cli/handlers/plugins.js');
    await pluginListHandler(options);
  });

  // Marketplace subcommands
  const marketplaceCmd = pluginCmd.command('marketplace').description('Manage Claude Code marketplaces').configureHelp(createSortedHelpConfig());
  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: {
    cowork?: boolean;
    sparse?: string[];
    scope?: string;
  }) => {
    const {
      marketplaceAddHandler
    } = await import('./cli/handlers/plugins.js');
    await marketplaceAddHandler(source, options);
  });
  marketplaceCmd.command('list').description('List all configured marketplaces').option('--json', 'Output as JSON').addOption(coworkOption()).action(async (options: {
    json?: boolean;
    cowork?: boolean;
  }) => {
    const {
      marketplaceListHandler
    } = await import('./cli/handlers/plugins.js');
    await marketplaceListHandler(options);
  });
  marketplaceCmd.command('remove <name>').alias('rm').description('Remove a configured marketplace').addOption(coworkOption()).action(async (name: string, options: {
    cowork?: boolean;
  }) => {
    const {
      marketplaceRemoveHandler
    } = await import('./cli/handlers/plugins.js');
    await marketplaceRemoveHandler(name, options);
  });
  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: {
    cowork?: boolean;
  }) => {
    const {
      marketplaceUpdateHandler
    } = await import('./cli/handlers/plugins.js');
    await marketplaceUpdateHandler(name, options);
  });

  // Plugin install command
  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: {
    scope?: string;
    cowork?: boolean;
  }) => {
    const {
      pluginInstallHandler
    } = await import('./cli/handlers/plugins.js');
    await pluginInstallHandler(plugin, options);
  });

  // Plugin uninstall command
  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: {
    scope?: string;
    cowork?: boolean;
    keepData?: boolean;
  }) => {
    const {
      pluginUninstallHandler
    } = await import('./cli/handlers/plugins.js');
    await pluginUninstallHandler(plugin, options);
  });

  // Plugin enable command
  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: {
    scope?: string;
    cowork?: boolean;
  }) => {
    const {
      pluginEnableHandler
    } = await import('./cli/handlers/plugins.js');
    await pluginEnableHandler(plugin, options);
  });

  // Plugin disable command
  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: {
    scope?: string;
    cowork?: boolean;
    all?: boolean;
  }) => {
    const {
      pluginDisableHandler
    } = await import('./cli/handlers/plugins.js');
    await pluginDisableHandler(plugin, options);
  });

  // Plugin update command
  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: {
    scope?: string;
    cowork?: boolean;
  }) => {
    const {
      pluginUpdateHandler
    } = await import('./cli/handlers/plugins.js');
    await pluginUpdateHandler(plugin, options);
  });
  // END ANT-ONLY

  // Setup token command
  program.command('setup-token').description('Set up a long-lived authentication token (requires Claude subscription)').action(async () => {
    const [{
      setupTokenHandler
    }, {
      createRoot
    }] = await Promise.all([import('./cli/handlers/util.js'), import('./ink.js')]);
    const root = await createRoot(getBaseRenderOptions(false));
    await setupTokenHandler(root);
  });

  // Agents command - list configured agents
  program.command('agents').description('List configured agents').option('--setting-sources <sources>', 'Comma-separated list of setting sources to load (user, project, local).').action(async () => {
    const {
      agentsHandler
    } = await import('./cli/handlers/agents.js');
    await agentsHandler();
    process.exit(0);
  });
  if (feature('TRANSCRIPT_CLASSIFIER')) {
    // Skip when tengu_auto_mode_config.enabled === 'disabled' (circuit breaker).
    // Reads from disk cache — GrowthBook isn't initialized at registration time.
    if (getAutoModeEnabledStateIfCached() !== 'disabled') {
      const autoModeCmd = program.command('auto-mode').description('Inspect auto mode classifier configuration');
      autoModeCmd.command('defaults').description('Print the default auto mode environment, allow, and deny rules as JSON').action(async () => {
        const {
          autoModeDefaultsHandler
        } = await import('./cli/handlers/autoMode.js');
        autoModeDefaultsHandler();
        process.exit(0);
      });
      autoModeCmd.command('config').description('Print the effective auto mode config as JSON: your settings where set, defaults otherwise').action(async () => {
        const {
          autoModeConfigHandler
        } = await import('./cli/handlers/autoMode.js');
        autoModeConfigHandler();
        process.exit(0);
      });
      autoModeCmd.command('critique').description('Get AI feedback on your custom auto mode rules').option('--model <model>', 'Override which model is used').action(async options => {
        const {
          autoModeCritiqueHandler
        } = await import('./cli/handlers/autoMode.js');
        await autoModeCritiqueHandler(options);
        process.exit();
      });
    }
  }

  // Remote Control command — connect local environment to claude.ai/code.
  // The actual command is intercepted by the fast-path in cli.tsx before
  // Commander.js runs, so this registration exists only for help output.
  // Always hidden: isBridgeEnabled() at this point (before enableConfigs)
  // would throw inside isClaudeAISubscriber → getGlobalConfig and return
  // false via the try/catch — but not before paying ~65ms of side effects
  // (25ms settings Zod parse + 40ms sync `security` keychain subprocess).
  // The dynamic visibility never worked; the command was always hidden.
  if (feature('BRIDGE_MODE')) {
    program.command('remote-control', {
      hidden: true
    }).alias('rc').description('Connect your local environment for remote-control sessions via claude.ai/code').action(async () => {
      // Unreachable — cli.tsx fast-path handles this command before main.tsx loads.
      // If somehow reached, delegate to bridgeMain.
      const {
        bridgeMain
      } = await import('./bridge/bridgeMain.js');
      await bridgeMain(process.argv.slice(3));
    });
  }
  if (feature('KAIROS')) {
    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(() => {
      // Argv rewriting above should have consumed `assistant [id]`
      // before commander runs. Reaching here means a root flag came first
      // (e.g. `--debug assistant`) and the position-0 predicate
      // didn't match. Print usage like the ssh stub does.
      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');
      process.exit(1);
    });
  }

  // Doctor command - check installation health
  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 () => {
    const [{
      doctorHandler
    }, {
      createRoot
    }] = await Promise.all([import('./cli/handlers/util.js'), import('./ink.js')]);
    const root = await createRoot(getBaseRenderOptions(false));
    await doctorHandler(root);
  });

  // claude update
  //
  // For SemVer-compliant versioning with build metadata (X.X.X+SHA):
  // - We perform exact string comparison (including SHA) to detect any change
  // - This ensures users always get the latest build, even when only the SHA changes
  // - UI shows both versions including build metadata for clarity
  program.command('update').alias('upgrade').description('Check for updates and install if available').action(async () => {
    const {
      update
    } = await import('src/cli/update.js');
    await update();
  });

  // claude up — run the project's CLAUDE.md "# claude up" setup instructions.
  if ("external" === 'ant') {
    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 () => {
      const {
        up
      } = await import('src/cli/up.js');
      await up();
    });
  }

  // claude rollback (ant-only)
  // Rolls back to previous releases
  if ("external" === 'ant') {
    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?: {
      list?: boolean;
      dryRun?: boolean;
      safe?: boolean;
    }) => {
      const {
        rollback
      } = await import('src/cli/rollback.js');
      await rollback(target, options);
    });
  }

  // claude install
  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: {
    force?: boolean;
  }) => {
    const {
      installHandler
    } = await import('./cli/handlers/util.js');
    await installHandler(target, options);
  });

  // ant-only commands
  if ("external" === 'ant') {
    const validateLogId = (value: string) => {
      const maybeSessionId = validateUuid(value);
      if (maybeSessionId) return maybeSessionId;
      return Number(value);
    };
    // claude log
    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) => {
      const {
        logHandler
      } = await import('./cli/handlers/ant.js');
      await logHandler(logId);
    });

    // claude error
    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) => {
      const {
        errorHandler
      } = await import('./cli/handlers/ant.js');
      await errorHandler(number);
    });

    // claude export
    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', `
Examples:
  $ claude export 0 conversation.txt                Export conversation at log index 0
  $ claude export <uuid> conversation.txt           Export conversation by session ID
  $ claude export input.json output.txt             Render JSON log file to text
  $ claude export <uuid>.jsonl output.txt           Render JSONL session file to text`).action(async (source: string, outputFile: string) => {
      const {
        exportHandler
      } = await import('./cli/handlers/ant.js');
      await exportHandler(source, outputFile);
    });
    if ("external" === 'ant') {
      const taskCmd = program.command('task').description('[ANT-ONLY] Manage task list tasks');
      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: {
        description?: string;
        list?: string;
      }) => {
        const {
          taskCreateHandler
        } = await import('./cli/handlers/ant.js');
        await taskCreateHandler(subject, opts);
      });
      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: {
        list?: string;
        pending?: boolean;
        json?: boolean;
      }) => {
        const {
          taskListHandler
        } = await import('./cli/handlers/ant.js');
        await taskListHandler(opts);
      });
      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: {
        list?: string;
      }) => {
        const {
          taskGetHandler
        } = await import('./cli/handlers/ant.js');
        await taskGetHandler(id, opts);
      });
      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: {
        list?: string;
        status?: string;
        subject?: string;
        description?: string;
        owner?: string;
        clearOwner?: boolean;
      }) => {
        const {
          taskUpdateHandler
        } = await import('./cli/handlers/ant.js');
        await taskUpdateHandler(id, opts);
      });
      taskCmd.command('dir').description('Show the tasks directory path').option('-l, --list <id>', 'Task list ID (defaults to "tasklist")').action(async (opts: {
        list?: string;
      }) => {
        const {
          taskDirHandler
        } = await import('./cli/handlers/ant.js');
        await taskDirHandler(opts);
      });
    }

    // claude completion <shell>
    program.command('completion <shell>', {
      hidden: true
    }).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: {
      output?: string;
    }) => {
      const {
        completionHandler
      } = await import('./cli/handlers/ant.js');
      await completionHandler(shell, opts, program);
    });
  }
  profileCheckpoint('run_before_parse');
  await program.parseAsync(process.argv);
  profileCheckpoint('run_after_parse');

  // Record final checkpoint for total_time calculation
  profileCheckpoint('main_after_run');

  // Log startup perf to Statsig (sampled) and output detailed report if enabled
  profileReport();
  return program;
}
async function logTenguInit({
  hasInitialPrompt,
  hasStdin,
  verbose,
  debug,
  debugToStderr,
  print,
  outputFormat,
  inputFormat,
  numAllowedTools,
  numDisallowedTools,
  mcpClientCount,
  worktreeEnabled,
  skipWebFetchPreflight,
  githubActionInputs,
  dangerouslySkipPermissionsPassed,
  permissionMode,
  modeIsBypass,
  allowDangerouslySkipPermissionsPassed,
  systemPromptFlag,
  appendSystemPromptFlag,
  thinkingConfig,
  assistantActivationPath
}: {
  hasInitialPrompt: boolean;
  hasStdin: boolean;
  verbose: boolean;
  debug: boolean;
  debugToStderr: boolean;
  print: boolean;
  outputFormat: string;
  inputFormat: string;
  numAllowedTools: number;
  numDisallowedTools: number;
  mcpClientCount: number;
  worktreeEnabled: boolean;
  skipWebFetchPreflight: boolean | undefined;
  githubActionInputs: string | undefined;
  dangerouslySkipPermissionsPassed: boolean;
  permissionMode: string;
  modeIsBypass: boolean;
  allowDangerouslySkipPermissionsPassed: boolean;
  systemPromptFlag: 'file' | 'flag' | undefined;
  appendSystemPromptFlag: 'file' | 'flag' | undefined;
  thinkingConfig: ThinkingConfig;
  assistantActivationPath: string | undefined;
}): Promise<void> {
  try {
    logEvent('tengu_init', {
      entrypoint: 'claude' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
      hasInitialPrompt,
      hasStdin,
      verbose,
      debug,
      debugToStderr,
      print,
      outputFormat: outputFormat as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
      inputFormat: inputFormat as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
      numAllowedTools,
      numDisallowedTools,
      mcpClientCount,
      worktree: worktreeEnabled,
      skipWebFetchPreflight,
      ...(githubActionInputs && {
        githubActionInputs: githubActionInputs as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
      }),
      dangerouslySkipPermissionsPassed,
      permissionMode: permissionMode as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
      modeIsBypass,
      inProtectedNamespace: isInProtectedNamespace(),
      allowDangerouslySkipPermissionsPassed,
      thinkingType: thinkingConfig.type as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
      ...(systemPromptFlag && {
        systemPromptFlag: systemPromptFlag as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
      }),
      ...(appendSystemPromptFlag && {
        appendSystemPromptFlag: appendSystemPromptFlag as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
      }),
      is_simple: isBareMode() || undefined,
      is_coordinator: feature('COORDINATOR_MODE') && coordinatorModeModule?.isCoordinatorMode() ? true : undefined,
      ...(assistantActivationPath && {
        assistantActivationPath: assistantActivationPath as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
      }),
      autoUpdatesChannel: (getInitialSettings().autoUpdatesChannel ?? 'latest') as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
      ...("external" === 'ant' ? (() => {
        const cwd = getCwd();
        const gitRoot = findGitRoot(cwd);
        const rp = gitRoot ? relative(gitRoot, cwd) || '.' : undefined;
        return rp ? {
          relativeProjectPath: rp as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
        } : {};
      })() : {})
    });
  } catch (error) {
    logError(error);
  }
}
function maybeActivateProactive(options: unknown): void {
  if ((feature('PROACTIVE') || feature('KAIROS')) && ((options as {
    proactive?: boolean;
  }).proactive || isEnvTruthy(process.env.CLAUDE_CODE_PROACTIVE))) {
    // eslint-disable-next-line @typescript-eslint/no-require-imports
    const proactiveModule = require('./proactive/index.js');
    if (!proactiveModule.isProactiveActive()) {
      proactiveModule.activateProactive('command');
    }
  }
}
function maybeActivateBrief(options: unknown): void {
  if (!(feature('KAIROS') || feature('KAIROS_BRIEF'))) return;
  const briefFlag = (options as {
    brief?: boolean;
  }).brief;
  const briefEnv = isEnvTruthy(process.env.CLAUDE_CODE_BRIEF);
  if (!briefFlag && !briefEnv) return;
  // --brief / CLAUDE_CODE_BRIEF are explicit opt-ins: check entitlement,
  // then set userMsgOptIn to activate the tool + prompt section. The env
  // var also grants entitlement (isBriefEntitled() reads it), so setting
  // CLAUDE_CODE_BRIEF=1 alone force-enables for dev/testing — no GB gate
  // needed. initialIsBriefOnly reads getUserMsgOptIn() directly.
  // Conditional require: static import would leak the tool name string
  // into external builds via BriefTool.ts → prompt.ts.
  /* eslint-disable @typescript-eslint/no-require-imports */
  const {
    isBriefEntitled
  } = require('./tools/BriefTool/BriefTool.js') as typeof import('./tools/BriefTool/BriefTool.js');
  /* eslint-enable @typescript-eslint/no-require-imports */
  const entitled = isBriefEntitled();
  if (entitled) {
    setUserMsgOptIn(true);
  }
  // Fire unconditionally once intent is seen: enabled=false captures the
  // "user tried but was gated" failure mode in Datadog.
  logEvent('tengu_brief_mode_enabled', {
    enabled: entitled,
    gated: !entitled,
    source: (briefEnv ? 'env' : 'flag') as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
  });
}
function resetCursor() {
  const terminal = process.stderr.isTTY ? process.stderr : process.stdout.isTTY ? process.stdout : undefined;
  terminal?.write(SHOW_CURSOR);
}
type TeammateOptions = {
  agentId?: string;
  agentName?: string;
  teamName?: string;
  agentColor?: string;
  planModeRequired?: boolean;
  parentSessionId?: string;
  teammateMode?: 'auto' | 'tmux' | 'in-process';
  agentType?: string;
};
function extractTeammateOptions(options: unknown): TeammateOptions {
  if (typeof options !== 'object' || options === null) {
    return {};
  }
  const opts = options as Record<string, unknown>;
  const teammateMode = opts.teammateMode;
  return {
    agentId: typeof opts.agentId === 'string' ? opts.agentId : undefined,
    agentName: typeof opts.agentName === 'string' ? opts.agentName : undefined,
    teamName: typeof opts.teamName === 'string' ? opts.teamName : undefined,
    agentColor: typeof opts.agentColor === 'string' ? opts.agentColor : undefined,
    planModeRequired: typeof opts.planModeRequired === 'boolean' ? opts.planModeRequired : undefined,
    parentSessionId: typeof opts.parentSessionId === 'string' ? opts.parentSessionId : undefined,
    teammateMode: teammateMode === 'auto' || teammateMode === 'tmux' || teammateMode === 'in-process' ? teammateMode : undefined,
    agentType: typeof opts.agentType === 'string' ? opts.agentType : undefined
  };
}
//# 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":[]}