lcclaude 1.0.0

package/dist/src/main.js

@@ -0,0 +1,2489 @@
+import { profileCheckpoint, profileReport } from "./utils/startupProfiler.js";
+profileCheckpoint("main_tsx_entry");
+import { startMdmRawRead } from "./utils/settings/mdm/rawRead.js";
+startMdmRawRead();
+import { ensureKeychainPrefetchCompleted, startKeychainPrefetch } from "./utils/secureStorage/keychainPrefetch.js";
+startKeychainPrefetch();
+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 { launchRepl } from "./replLauncher.js";
+import { hasGrowthBookEnvOverride, initializeGrowthBook, refreshGrowthBookAfterAuthChange } from "./services/analytics/growthbook.js";
+import { fetchBootstrapData } from "./services/api/bootstrap.js";
+import { downloadSessionFiles, parseFileSpecs } from "./services/api/filesApi.js";
+import { prefetchPassesEligibility } from "./services/api/referral.js";
+import { prefetchOfficialMcpUrls } from "./services/mcp/officialRegistry.js";
+import { isPolicyAllowed, loadPolicyLimits, refreshPolicyLimits, waitForPolicyLimitsToLoad } from "./services/policyLimits/index.js";
+import { loadRemoteManagedSettings, refreshRemoteManagedSettings } from "./services/remoteManagedSettings/index.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";
+const getTeammateUtils = () => require("./utils/teammate.js");
+const getTeammatePromptAddendum = () => require("./utils/swarm/teammatePromptAddendum.js");
+const getTeammateModeSnapshot = () => require("./utils/swarm/backends/teammateModeSnapshot.js");
+const coordinatorModeModule = null;
+const assistantModule = null;
+const kairosGate = null;
+import { relative, resolve } from "path";
+import { isAnalyticsDisabled } from "./services/analytics/config.js";
+import { getFeatureValue_CACHED_MAY_BE_STALE } from "./services/analytics/growthbook.js";
+import { logEvent } from "./services/analytics/index.js";
+import { initializeAnalyticsGates } from "./services/analytics/sink.js";
+import { getOriginalCwd, setAdditionalDirectoriesForClaudeMd, setIsRemoteMode, setMainLoopModelOverride, setMainThreadAgentType, setTeleportedSessionInfo } from "./bootstrap/state.js";
+import { filterCommandsForRemoteMode, getCommands } from "./commands.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";
+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 { getActiveAgentsFromList, getAgentDefinitionsWithOverrides, isBuiltInAgent, isCustomAgent, parseAgentsFromJson } from "./tools/AgentTool/loadAgentsDir.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 { 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 { 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";
+import { registerMcpAddCommand } from "./commands/mcp/addCommand.js";
+import { registerMcpXaaIdpCommand } from "./commands/mcp/xaaIdpCommand.js";
+import { logPermissionContextForAnts } from "./services/internalLogging.js";
+import { fetchClaudeAIMcpConfigsIfEligible } from "./services/mcp/claudeai.js";
+import { clearServerCache } from "./services/mcp/client.js";
+import { areMcpConfigsAllowedWithEnterpriseMcpConfig, dedupClaudeAiMcpServers, doesEnterpriseMcpConfigExist, filterMcpServersByPolicy, getClaudeCodeMcpConfigs, getMcpServerSignature, parseMcpConfig, parseMcpConfigFromFilePath } from "./services/mcp/config.js";
+import { excludeCommandsByServer, excludeResourcesByServer } from "./services/mcp/utils.js";
+import { isXaaEnabled } from "./services/mcp/xaaIdpLogin.js";
+import { getRelevantTips } from "./services/tips/tipRegistry.js";
+import { logContextMetrics } from "./utils/api.js";
+import { CLAUDE_IN_CHROME_MCP_SERVER_NAME, isClaudeInChromeMCPServer } from "./utils/claudeInChrome/common.js";
+import { registerCleanup } from "./utils/cleanupRegistry.js";
+import { eagerParseCliFlag } from "./utils/cliArgs.js";
+import { createEmptyAttributionState } from "./utils/commitAttribution.js";
+import { countConcurrentSessions, registerSession, updateSessionName } from "./utils/concurrentSessions.js";
+import { getCwd } from "./utils/cwd.js";
+import { logForDebugging, setHasFormattedOutput } from "./utils/debug.js";
+import { errorMessage, getErrnoCode, isENOENT, TeleportOperationError, toError } from "./utils/errors.js";
+import { getFsImplementation, safeResolvePath } from "./utils/fsOperations.js";
+import { gracefulShutdown, gracefulShutdownSync } from "./utils/gracefulShutdown.js";
+import { setAllHookEventsEnabled } from "./utils/hooks/hookEvents.js";
+import { refreshModelCapabilities } from "./utils/model/modelCapabilities.js";
+import { peekForStdinData, writeToStderr } from "./utils/process.js";
+import { setCwd } from "./utils/Shell.js";
+import { processResumedConversation } from "./utils/sessionRestore.js";
+import { parseSettingSourcesFlag } from "./utils/settings/constants.js";
+import { plural } from "./utils/stringUtils.js";
+import { getInitialMainLoopModel, getIsNonInteractiveSession, getSdkBetas, getSessionId, getUserMsgOptIn, setAllowedChannels, setAllowedSettingSources, setChromeFlagOverride, setClientType, setCwdState, setDirectConnectServerUrl, setFlagSettingsPath, setInitialMainLoopModel, setInlinePlugins, setIsInteractive, setKairosActive, setOriginalCwd, setProjectRoot, setQuestionPreviewFormat, setSdkBetas, setSessionBypassPermissionsMode, setSessionPersistenceDisabled, setSessionSource, setUserMsgOptIn, switchSession } from "./bootstrap/state.js";
+const autoModeStateModule = null;
+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";
+import { createDirectConnectSession, DirectConnectError } from "./server/createDirectConnectSession.js";
+import { initializeLspServerManager } from "./services/lsp/manager.js";
+import { shouldEnablePromptSuggestion } from "./services/PromptSuggestion/promptSuggestion.js";
+import { 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 } from "./utils/thinking.js";
+import { initUser, resetUserCache } from "./utils/user.js";
+import { getTmuxInstallInstructions, isTmuxAvailable, parsePRReference } from "./utils/worktree.js";
+profileCheckpoint("main_tsx_imports_loaded");
+function logManagedSettings() {
+  try {
+    const policySettings = getSettingsForSource("policySettings");
+    if (policySettings) {
+      const allKeys = getManagedSettingsKeysForLogging(policySettings);
+      logEvent("tengu_managed_settings_loaded", {
+        keyCount: allKeys.length,
+        keys: allKeys.join(",")
+      });
+    }
+  } catch {}
+}
+function isBeingDebugged() {
+  const isBun = isRunningWithBun();
+  const hasInspectArg = process.execArgv.some((arg) => {
+    if (isBun) {
+      return /--inspect(-brk)?/.test(arg);
+    } else {
+      return /--inspect(-brk)?|--debug(-brk)?/.test(arg);
+    }
+  });
+  const hasInspectEnv = process.env.NODE_OPTIONS && /--inspect(-brk)?|--debug(-brk)?/.test(process.env.NODE_OPTIONS);
+  try {
+    const inspector = global.require("inspector");
+    const hasInspectorUrl = !!inspector.url();
+    return hasInspectorUrl || hasInspectArg || hasInspectEnv;
+  } catch {
+    return hasInspectArg || hasInspectEnv;
+  }
+}
+if (isBeingDebugged()) {
+  process.exit(1);
+}
+function logSessionTelemetry() {
+  const model = parseUserSpecifiedModel(getInitialMainLoopModel() ?? getDefaultMainLoopModel());
+  logSkillsLoaded(getCwd(), getContextWindowForModel(model, getSdkBetas()));
+  loadAllPluginsCacheOnly().then(({
+    enabled,
+    errors
+  }) => {
+    const managedNames = getManagedPluginNames();
+    logPluginsEnabledForSession(enabled, managedNames, getPluginSeedDirs());
+    logPluginLoadErrors(errors, managedNames);
+  }).catch((err) => logError(err));
+}
+function getCertEnvVarTelemetry() {
+  const result = {};
+  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() {
+  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,
+    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()
+  });
+}
+const CURRENT_MIGRATION_VERSION = 11;
+function runMigrations() {
+  if (getGlobalConfig().migrationVersion !== CURRENT_MIGRATION_VERSION) {
+    migrateAutoUpdatesToSettings();
+    migrateBypassPermissionsAcceptedToSettings();
+    migrateEnableAllProjectMcpServersToSettings();
+    resetProToOpusDefault();
+    migrateSonnet1mToSonnet45();
+    migrateLegacyOpusToCurrent();
+    migrateSonnet45ToSonnet46();
+    migrateOpusToOpus1m();
+    migrateReplBridgeEnabledToRemoteControlAtStartup();
+    if (false) {}
+    if (false) {}
+    saveGlobalConfig((prev) => prev.migrationVersion === CURRENT_MIGRATION_VERSION ? prev : {
+      ...prev,
+      migrationVersion: CURRENT_MIGRATION_VERSION
+    });
+  }
+  migrateChangelogFromConfig().catch(() => {});
+}
+function prefetchSystemContextIfSafe() {
+  const isNonInteractiveSession = getIsNonInteractiveSession();
+  if (isNonInteractiveSession) {
+    logForDiagnosticsNoPII("info", "prefetch_system_context_non_interactive");
+    getSystemContext();
+    return;
+  }
+  const hasTrust = checkHasTrustDialogAccepted();
+  if (hasTrust) {
+    logForDiagnosticsNoPII("info", "prefetch_system_context_has_trust");
+    getSystemContext();
+  } else {
+    logForDiagnosticsNoPII("info", "prefetch_system_context_skipped_no_trust");
+  }
+}
+export function startDeferredPrefetches() {
+  if (isEnvTruthy(process.env.CLAUDE_CODE_EXIT_AFTER_FIRST_RENDER) || isBareMode()) {
+    return;
+  }
+  initUser();
+  getUserContext();
+  prefetchSystemContextIfSafe();
+  getRelevantTips();
+  if (isEnvTruthy(process.env.CLAUDE_CODE_USE_BEDROCK) && !isEnvTruthy(process.env.CLAUDE_CODE_SKIP_BEDROCK_AUTH)) {
+    prefetchAwsCredentialsAndBedRockInfoIfSafe();
+  }
+  if (isEnvTruthy(process.env.CLAUDE_CODE_USE_VERTEX) && !isEnvTruthy(process.env.CLAUDE_CODE_SKIP_VERTEX_AUTH)) {
+    prefetchGcpCredentialsIfSafe();
+  }
+  countFilesRoundedRg(getCwd(), AbortSignal.timeout(3000), []);
+  initializeAnalyticsGates();
+  prefetchOfficialMcpUrls();
+  refreshModelCapabilities();
+  settingsChangeDetector.initialize();
+  if (!isBareMode()) {
+    skillChangeDetector.initialize();
+  }
+  if (false) {}
+}
+function loadSettingsFromFlag(settingsFile) {
+  try {
+    const trimmedSettings = settingsFile.trim();
+    const looksLikeJson = trimmedSettings.startsWith("{") && trimmedSettings.endsWith("}");
+    let settingsPath;
+    if (looksLikeJson) {
+      const parsedJson = safeParseJSON(trimmedSettings);
+      if (!parsedJson) {
+        process.stderr.write(chalk.red(`Error: Invalid JSON provided to --settings
+`));
+        process.exit(1);
+      }
+      settingsPath = generateTempFilePath("claude-settings", ".json", {
+        contentHash: trimmedSettings
+      });
+      writeFileSync_DEPRECATED(settingsPath, trimmedSettings, "utf8");
+    } else {
+      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}
+`));
+          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)}
+`));
+    process.exit(1);
+  }
+}
+function loadSettingSourcesFromFlag(settingSourcesArg) {
+  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)}
+`));
+    process.exit(1);
+  }
+}
+function eagerLoadSettings() {
+  profileCheckpoint("eagerLoadSettings_start");
+  const settingsFile = eagerParseCliFlag("--settings");
+  if (settingsFile) {
+    loadSettingsFromFlag(settingsFile);
+  }
+  const settingSourcesArg = eagerParseCliFlag("--setting-sources");
+  if (settingSourcesArg !== undefined) {
+    loadSettingSourcesFromFlag(settingSourcesArg);
+  }
+  profileCheckpoint("eagerLoadSettings_end");
+}
+function initializeEntrypoint(isNonInteractive) {
+  if (process.env.CLAUDE_CODE_ENTRYPOINT) {
+    return;
+  }
+  const cliArgs = process.argv.slice(2);
+  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;
+  }
+  process.env.CLAUDE_CODE_ENTRYPOINT = isNonInteractive ? "sdk-cli" : "cli";
+}
+const _pendingConnect = undefined;
+const _pendingAssistantChat = undefined;
+const _pendingSSH = undefined;
+export async function main() {
+  profileCheckpoint("main_function_start");
+  process.env.NoDefaultCurrentDirectoryInExePath = "1";
+  initializeWarningHandler();
+  process.on("exit", () => {
+    resetCursor();
+  });
+  process.on("SIGINT", () => {
+    if (process.argv.includes("-p") || process.argv.includes("--print")) {
+      return;
+    }
+    process.exit(0);
+  });
+  profileCheckpoint("main_warning_handler_initialized");
+  if (false) {}
+  if (false) {}
+  if (false) {}
+  if (false) {}
+  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;
+  if (isNonInteractive) {
+    stopCapturingEarlyInput();
+  }
+  const isInteractive = !isNonInteractive;
+  setIsInteractive(isInteractive);
+  initializeEntrypoint(isNonInteractive);
+  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";
+    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-") && clientType !== "claude-desktop" && clientType !== "local-agent" && clientType !== "remote") {
+    setQuestionPreviewFormat("markdown");
+  }
+  if (process.env.CLAUDE_CODE_ENVIRONMENT_KIND === "bridge") {
+    setSessionSource("remote-control");
+  }
+  profileCheckpoint("main_client_type_determined");
+  eagerLoadSettings();
+  profileCheckpoint("main_before_run");
+  await run();
+  profileCheckpoint("main_after_run");
+}
+async function getInputPrompt(prompt, inputFormat) {
+  if (!process.stdin.isTTY && !process.argv.includes("mcp")) {
+    if (inputFormat === "stream-json") {
+      return process.stdin;
+    }
+    process.stdin.setEncoding("utf8");
+    let data = "";
+    const onData = (chunk) => {
+      data += chunk;
+    };
+    process.stdin.on("data", onData);
+    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.
+`);
+    }
+    return [prompt, data].filter(Boolean).join(`
+`);
+  }
+  return prompt;
+}
+async function run() {
+  profileCheckpoint("run_function_start");
+  function createSortedHelpConfig() {
+    const getOptionSortKey = (opt) => opt.long?.replace(/^--/, "") ?? opt.short?.replace(/^-/, "") ?? "";
+    return Object.assign({
+      sortSubcommands: true,
+      sortOptions: true
+    }, {
+      compareOptions: (a, b) => getOptionSortKey(a).localeCompare(getOptionSortKey(b))
+    });
+  }
+  const program = new CommanderCommand().configureHelp(createSortedHelpConfig()).enablePositionalOptions();
+  profileCheckpoint("run_commander_initialized");
+  program.hook("preAction", async (thisCommand) => {
+    profileCheckpoint("preAction_start");
+    await Promise.all([ensureMdmSettingsLoaded(), ensureKeychainPrefetchCompleted()]);
+    profileCheckpoint("preAction_after_mdm");
+    await init();
+    profileCheckpoint("preAction_after_init");
+    if (!isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_TERMINAL_TITLE)) {
+      process.title = "claude";
+    }
+    const {
+      initSinks
+    } = await import("./utils/sinks.js");
+    initSinks();
+    profileCheckpoint("preAction_after_sinks");
+    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");
+    loadRemoteManagedSettings();
+    loadPolicyLimits();
+    profileCheckpoint("preAction_after_remote_settings");
+    if (false) {}
+    profileCheckpoint("preAction_after_settings_sync");
+  });
+  program.name("lcclaude").description(`Claude Code - starts an interactive session by default, use -p/--print for non-interactive output`).argument("[prompt]", "Your prompt", String).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) => {
+    return true;
+  }).addOption(new Option("--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()).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) => {
+    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).").option("--plugin-dir <path>", "Load plugins from a directory for this session only (repeatable: --plugin-dir A --plugin-dir B)", (val, prev) => [...prev, val], []).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");
+    if (options.bare) {
+      process.env.CLAUDE_CODE_SIMPLE = "1";
+    }
+    if (prompt === "code") {
+      logEvent("tengu_code_prompt_ignored", {});
+      console.warn(chalk.yellow("Tip: You can launch Claude Code with just `lcclaude`"));
+      prompt = undefined;
+    }
+    if (prompt && typeof prompt === "string" && !/\s/.test(prompt) && prompt.length > 0) {
+      logEvent("tengu_single_word_prompt", {
+        length: prompt.length
+      });
+    }
+    let kairosEnabled = false;
+    let assistantTeamContext;
+    if (false) {}
+    if (false) {}
+    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);
+    }
+    let fileDownloadPromise;
+    const agentsJson = options.agents;
+    const agentCli = options.agent;
+    if (false) {}
+    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;
+    const disableSlashCommands = options.disableSlashCommands || false;
+    const tasksOption = false;
+    const taskListId = tasksOption ? typeof tasksOption === "string" ? tasksOption : DEFAULT_TASKS_MODE_TASK_LIST_ID : undefined;
+    if (false) {}
+    const worktreeOption = isWorktreeModeEnabled() ? options.worktree : undefined;
+    let worktreeName = typeof worktreeOption === "string" ? worktreeOption : undefined;
+    const worktreeEnabled = worktreeOption !== undefined;
+    let worktreePRNumber;
+    if (worktreeName) {
+      const prNum = parsePRReference(worktreeName);
+      if (prNum !== null) {
+        worktreePRNumber = prNum;
+        worktreeName = undefined;
+      }
+    }
+    const tmuxEnabled = isWorktreeModeEnabled() && options.tmux === true;
+    if (tmuxEnabled) {
+      if (!worktreeEnabled) {
+        process.stderr.write(chalk.red(`Error: --tmux requires --worktree
+`));
+        process.exit(1);
+      }
+      if (getPlatform() === "windows") {
+        process.stderr.write(chalk.red(`Error: --tmux is not supported on Windows
+`));
+        process.exit(1);
+      }
+      if (!await isTmuxAvailable()) {
+        process.stderr.write(chalk.red(`Error: tmux is not installed.
+${getTmuxInstallInstructions()}
+`));
+        process.exit(1);
+      }
+    }
+    let storedTeammateOpts;
+    if (isAgentSwarmsEnabled()) {
+      const teammateOpts = extractTeammateOptions(options);
+      storedTeammateOpts = teammateOpts;
+      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
+`));
+        process.exit(1);
+      }
+      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
+        });
+      }
+      if (teammateOpts.teammateMode) {
+        getTeammateModeSnapshot().setCliTeammateModeOverride?.(teammateOpts.teammateMode);
+      }
+    }
+    const sdkUrl = options.sdkUrl ?? undefined;
+    const effectiveIncludePartialMessages = includePartialMessages || isEnvTruthy(process.env.CLAUDE_CODE_INCLUDE_PARTIAL_MESSAGES);
+    if (includeHookEvents || isEnvTruthy(process.env.CLAUDE_CODE_REMOTE)) {
+      setAllHookEventsEnabled(true);
+    }
+    if (sdkUrl) {
+      if (!inputFormat) {
+        inputFormat = "stream-json";
+      }
+      if (!outputFormat) {
+        outputFormat = "stream-json";
+      }
+      if (options.verbose === undefined) {
+        verbose = true;
+      }
+      if (!options.print) {
+        print = true;
+      }
+    }
+    const teleport = options.teleport ?? null;
+    const remoteOption = options.remote;
+    const remote = remoteOption === true ? "" : remoteOption ?? null;
+    const remoteControlOption = options.remoteControl ?? options.rc;
+    let remoteControl = false;
+    const remoteControlName = typeof remoteControlOption === "string" && remoteControlOption.length > 0 ? remoteControlOption : undefined;
+    if (sessionId) {
+      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.
+`));
+        process.exit(1);
+      }
+      if (!sdkUrl) {
+        const validatedSessionId = validateUuid(sessionId);
+        if (!validatedSessionId) {
+          process.stderr.write(chalk.red(`Error: Invalid session ID. Must be a valid UUID.
+`));
+          process.exit(1);
+        }
+        if (sessionIdExists(validatedSessionId)) {
+          process.stderr.write(chalk.red(`Error: Session ID ${validatedSessionId} is already in use.
+`));
+          process.exit(1);
+        }
+      }
+    }
+    const fileSpecs = options.file;
+    if (fileSpecs && fileSpecs.length > 0) {
+      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.
+`));
+        process.exit(1);
+      }
+      const fileSessionId = process.env.CLAUDE_CODE_REMOTE_SESSION_ID || getSessionId();
+      const files = parseFileSpecs(fileSpecs);
+      if (files.length > 0) {
+        const config = {
+          baseUrl: process.env.ANTHROPIC_BASE_URL || getOauthConfig().BASE_API_URL,
+          oauthToken: sessionToken,
+          sessionId: fileSessionId
+        };
+        fileDownloadPromise = downloadSessionFiles(files, config);
+      }
+    }
+    const isNonInteractiveSession = getIsNonInteractiveSession();
+    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.
+`));
+      process.exit(1);
+    }
+    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.
+`));
+        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)}
+`));
+          process.exit(1);
+        }
+        process.stderr.write(chalk.red(`Error reading system prompt file: ${errorMessage(error)}
+`));
+        process.exit(1);
+      }
+    }
+    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.
+`));
+        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)}
+`));
+          process.exit(1);
+        }
+        process.stderr.write(chalk.red(`Error reading append system prompt file: ${errorMessage(error)}
+`));
+        process.exit(1);
+      }
+    }
+    if (isAgentSwarmsEnabled() && storedTeammateOpts?.agentId && storedTeammateOpts?.agentName && storedTeammateOpts?.teamName) {
+      const addendum = getTeammatePromptAddendum().TEAMMATE_SYSTEM_PROMPT_ADDENDUM;
+      appendSystemPrompt = appendSystemPrompt ? `${appendSystemPrompt}
+
+${addendum}` : addendum;
+    }
+    const {
+      mode: permissionMode,
+      notification: permissionModeNotification
+    } = initialPermissionModeFromCLI({
+      permissionModeCli,
+      dangerouslySkipPermissions
+    });
+    setSessionBypassPermissionsMode(permissionMode === "bypassPermissions");
+    if (false) {}
+    let dynamicMcpConfig = {};
+    if (mcpConfig && mcpConfig.length > 0) {
+      const processedConfigs = mcpConfig.map((config) => config.trim()).filter((config) => config.length > 0);
+      let allConfigs = {};
+      const allErrors = [];
+      for (const configItem of processedConfigs) {
+        let configs = null;
+        let errors = [];
+        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 {
+          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) {
+          allConfigs = {
+            ...allConfigs,
+            ...configs
+          };
+        }
+      }
+      if (allErrors.length > 0) {
+        const formattedErrors = allErrors.map((err) => `${err.path ? err.path + ": " : ""}${err.message}`).join(`
+`);
+        logForDebugging(`--mcp-config validation failed (${allErrors.length} errors): ${formattedErrors}`, {
+          level: "error"
+        });
+        process.stderr.write(`Error: Invalid MCP configuration:
+${formattedErrors}
+`);
+        process.exit(1);
+      }
+      if (Object.keys(allConfigs).length > 0) {
+        const nonSdkConfigNames = Object.entries(allConfigs).filter(([, config]) => config.type !== "sdk").map(([name]) => name);
+        let reservedNameError = null;
+        if (nonSdkConfigNames.some(isClaudeInChromeMCPServer)) {
+          reservedNameError = `Invalid MCP configuration: "${CLAUDE_IN_CHROME_MCP_SERVER_NAME}" is a reserved MCP name.`;
+        } else if (false) {}
+        if (reservedNameError) {
+          process.stderr.write(`Error: ${reservedNameError}
+`);
+          process.exit(1);
+        }
+        const scopedConfigs = mapValues(allConfigs, (config) => ({
+          ...config,
+          scope: "dynamic"
+        }));
+        const {
+          allowed,
+          blocked
+        } = filterMcpServersByPolicy(scopedConfigs);
+        if (blocked.length > 0) {
+          process.stderr.write(`Warning: MCP ${plural(blocked.length, "server")} blocked by enterprise policy: ${blocked.join(", ")}
+`);
+        }
+        dynamicMcpConfig = {
+          ...dynamicMcpConfig,
+          ...allowed
+        };
+      }
+    }
+    const chromeOpts = options;
+    setChromeFlagOverride(chromeOpts.chrome);
+    const enableClaudeInChrome = shouldEnableClaudeInChrome(chromeOpts.chrome) && isClaudeAISubscriber();
+    const autoEnableClaudeInChrome = !enableClaudeInChrome && shouldAutoEnableClaudeInChrome();
+    if (enableClaudeInChrome) {
+      const platform = getPlatform();
+      try {
+        logEvent("tengu_claude_in_chrome_setup", {
+          platform
+        });
+        const {
+          mcpConfig: chromeMcpConfig,
+          allowedTools: chromeMcpTools,
+          systemPrompt: chromeSystemPrompt
+        } = setupClaudeInChrome();
+        dynamicMcpConfig = {
+          ...dynamicMcpConfig,
+          ...chromeMcpConfig
+        };
+        allowedTools.push(...chromeMcpTools);
+        if (chromeSystemPrompt) {
+          appendSystemPrompt = appendSystemPrompt ? `${chromeSystemPrompt}
+
+${appendSystemPrompt}` : chromeSystemPrompt;
+        }
+      } catch (error) {
+        logEvent("tengu_claude_in_chrome_setup_failed", {
+          platform
+        });
+        logForDebugging(`[Claude in Chrome] Error: ${error}`);
+        logError(error);
+        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 = CLAUDE_IN_CHROME_SKILL_HINT;
+        appendSystemPrompt = appendSystemPrompt ? `${appendSystemPrompt}
+
+${hint}` : hint;
+      } catch (error) {
+        logForDebugging(`[Claude in Chrome] Error (auto-enable): ${error}`);
+      }
+    }
+    const strictMcpConfig = options.strictMcpConfig || false;
+    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);
+      }
+      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);
+      }
+    }
+    if (false) {}
+    setAdditionalDirectoriesForClaudeMd(addDir);
+    let devChannels;
+    if (false) {}
+    if (false) {}
+    const initResult = await initializeToolPermissionContext({
+      allowedToolsCli: allowedTools,
+      disallowedToolsCli: disallowedTools,
+      baseToolsCli: baseTools,
+      permissionMode,
+      allowDangerouslySkipPermissions,
+      addDirs: addDir
+    });
+    let toolPermissionContext = initResult.toolPermissionContext;
+    const {
+      warnings,
+      dangerousPermissions,
+      overlyBroadBashPermissions
+    } = initResult;
+    if (false) {}
+    if (false) {}
+    warnings.forEach((warning) => {
+      console.error(warning);
+    });
+    assertMinVersion();
+    const claudeaiConfigPromise = isNonInteractiveSession && !strictMcpConfig && !doesEnterpriseMcpConfigExist() && !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(", ")}
+`);
+      }
+      return allowed;
+    }) : Promise.resolve({});
+    logForDebugging("[STARTUP] Loading MCP configs...");
+    const mcpConfigStart = Date.now();
+    let mcpConfigResolvedMs;
+    const mcpConfigPromise = (strictMcpConfig || isBareMode() ? Promise.resolve({
+      servers: {}
+    }) : getClaudeCodeMcpConfigs(dynamicMcpConfig)).then((result) => {
+      mcpConfigResolvedMs = Date.now() - mcpConfigStart;
+      return result;
+    });
+    if (inputFormat && inputFormat !== "text" && inputFormat !== "stream-json") {
+      console.error(`Error: Invalid input format "${inputFormat}".`);
+      process.exit(1);
+    }
+    if (inputFormat === "stream-json" && outputFormat !== "stream-json") {
+      console.error(`Error: --input-format=stream-json requires output-format=stream-json.`);
+      process.exit(1);
+    }
+    if (sdkUrl) {
+      if (inputFormat !== "stream-json" || outputFormat !== "stream-json") {
+        console.error(`Error: --sdk-url requires both --input-format=stream-json and --output-format=stream-json.`);
+        process.exit(1);
+      }
+    }
+    if (options.replayUserMessages) {
+      if (inputFormat !== "stream-json" || outputFormat !== "stream-json") {
+        console.error(`Error: --replay-user-messages requires both --input-format=stream-json and --output-format=stream-json.`);
+        process.exit(1);
+      }
+    }
+    if (effectiveIncludePartialMessages) {
+      if (!isNonInteractiveSession || outputFormat !== "stream-json") {
+        writeToStderr(`Error: --include-partial-messages requires --print and --output-format=stream-json.`);
+        process.exit(1);
+      }
+    }
+    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");
+    profileCheckpoint("action_after_input_prompt");
+    maybeActivateProactive(options);
+    let tools = getTools(toolPermissionContext);
+    if (false) {}
+    profileCheckpoint("action_tools_loaded");
+    let jsonSchema;
+    if (isSyntheticOutputToolEnabled({
+      isNonInteractiveSession
+    }) && options.jsonSchema) {
+      jsonSchema = jsonParse(options.jsonSchema);
+    }
+    if (jsonSchema) {
+      const syntheticOutputResult = createSyntheticOutputTool(jsonSchema);
+      if ("tool" in syntheticOutputResult) {
+        tools = [...tools, syntheticOutputResult.tool];
+        logEvent("tengu_structured_output_enabled", {
+          schema_property_count: Object.keys(jsonSchema.properties || {}).length,
+          has_required_fields: Boolean(jsonSchema.required)
+        });
+      } else {
+        logEvent("tengu_structured_output_failure", {
+          error: "Invalid JSON schema"
+        });
+      }
+    }
+    profileCheckpoint("action_before_setup");
+    logForDebugging("[STARTUP] Running setup()...");
+    const setupStart = Date.now();
+    const messagingSocketPath = undefined;
+    const preSetupCwd = getCwd();
+    if (process.env.CLAUDE_CODE_ENTRYPOINT !== "local-agent") {
+      initBuiltinPlugins();
+      initBundledSkills();
+    }
+    const setupPromise = process.env.CLAUDE_CODE_LOCAL_RECOVERY === "1" ? (async () => {
+      setOriginalCwd(preSetupCwd);
+      setProjectRoot(preSetupCwd);
+      logForDebugging("[STARTUP] setup() skipped in local recovery mode");
+    })() : (async () => {
+      const {
+        setup
+      } = await import("./setup.js");
+      await 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);
+    commandsPromise?.catch(() => {});
+    agentDefsPromise?.catch(() => {});
+    await setupPromise;
+    logForDebugging(`[STARTUP] setup() completed in ${Date.now() - setupStart}ms`);
+    profileCheckpoint("action_after_setup");
+    let effectiveReplayUserMessages = !!options.replayUserMessages;
+    if (false) {}
+    if (getIsNonInteractiveSession()) {
+      applyConfigEnvironmentVariables();
+      getSystemContext();
+      getUserContext();
+      ensureModelStringsInitialized();
+    }
+    const sessionNameArg = options.name?.trim();
+    if (sessionNameArg) {
+      cacheSessionTitle(sessionNameArg);
+    }
+    const explicitModel = options.model || process.env.ANTHROPIC_MODEL;
+    if (false) {}
+    const userSpecifiedModel = options.model === "default" ? getDefaultMainLoopModel() : options.model;
+    const userSpecifiedFallbackModel = fallbackModel === "default" ? getDefaultMainLoopModel() : fallbackModel;
+    const currentCwd = worktreeEnabled ? getCwd() : preSetupCwd;
+    logForDebugging("[STARTUP] Loading commands and agents...");
+    const commandsStart = Date.now();
+    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");
+    let cliAgents = [];
+    if (agentsJson) {
+      try {
+        const parsedAgents = safeParseJSON(agentsJson);
+        if (parsedAgents) {
+          cliAgents = parseAgentsFromJson(parsedAgents, "flagSettings");
+        }
+      } catch (error) {
+        logError(error);
+      }
+    }
+    const allAgents = [...agentDefinitionsResult.allAgents, ...cliAgents];
+    const agentDefinitions = {
+      ...agentDefinitionsResult,
+      allAgents,
+      activeAgents: getActiveAgentsFromList(allAgents)
+    };
+    const agentSetting = agentCli ?? getInitialSettings().agent;
+    let mainThreadAgentDefinition;
+    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.`);
+      }
+    }
+    setMainThreadAgentType(mainThreadAgentDefinition?.agentType);
+    if (mainThreadAgentDefinition) {
+      logEvent("tengu_agent_flag", {
+        agentType: isBuiltInAgent(mainThreadAgentDefinition) ? mainThreadAgentDefinition.agentType : "custom",
+        ...agentCli && {
+          source: "cli"
+        }
+      });
+    }
+    if (mainThreadAgentDefinition?.agentType) {
+      saveAgentSetting(mainThreadAgentDefinition.agentType);
+    }
+    if (isNonInteractiveSession && mainThreadAgentDefinition && !systemPrompt && !isBuiltInAgent(mainThreadAgentDefinition)) {
+      const agentSystemPrompt = mainThreadAgentDefinition.getSystemPrompt();
+      if (agentSystemPrompt) {
+        systemPrompt = agentSystemPrompt;
+      }
+    }
+    if (mainThreadAgentDefinition?.initialPrompt) {
+      if (typeof inputPrompt === "string") {
+        inputPrompt = inputPrompt ? `${mainThreadAgentDefinition.initialPrompt}
+
+${inputPrompt}` : mainThreadAgentDefinition.initialPrompt;
+      } else if (!inputPrompt) {
+        inputPrompt = mainThreadAgentDefinition.initialPrompt;
+      }
+    }
+    let effectiveModel = userSpecifiedModel;
+    if (!effectiveModel && mainThreadAgentDefinition?.model && mainThreadAgentDefinition.model !== "inherit") {
+      effectiveModel = parseUserSpecifiedModel(mainThreadAgentDefinition.model);
+    }
+    setMainLoopModelOverride(effectiveModel);
+    setInitialMainLoopModel(getUserSpecifiedModelSetting() || null);
+    const initialMainLoopModel = getInitialMainLoopModel();
+    const resolvedInitialModel = parseUserSpecifiedModel(initialMainLoopModel ?? getDefaultMainLoopModel());
+    let advisorModel;
+    if (isAdvisorEnabled()) {
+      const advisorOption = canUserConfigureAdvisor() ? options.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.
+`));
+          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.
+`));
+          process.exit(1);
+        }
+      }
+      advisorModel = canUserConfigureAdvisor() ? advisorOption ?? getInitialAdvisorSetting() : advisorOption;
+      if (advisorModel) {
+        logForDebugging(`[AdvisorTool] Advisor model: ${advisorModel}`);
+      }
+    }
+    if (isAgentSwarmsEnabled() && storedTeammateOpts?.agentId && storedTeammateOpts?.agentName && storedTeammateOpts?.teamName && storedTeammateOpts?.agentType) {
+      const customAgent = agentDefinitions.activeAgents.find((a) => a.agentType === storedTeammateOpts.agentType);
+      if (customAgent) {
+        let customPrompt;
+        if (customAgent.source === "built-in") {
+          logForDebugging(`[teammate] Built-in agent ${storedTeammateOpts.agentType} - skipping custom prompt (not supported)`);
+        } else {
+          customPrompt = customAgent.getSystemPrompt();
+        }
+        if (customAgent.memory) {
+          logEvent("tengu_agent_memory_loaded", {
+            ...false,
+            scope: customAgent.memory,
+            source: "teammate"
+          });
+        }
+        if (customPrompt) {
+          const customInstructions = `
+# Custom Agent Instructions
+${customPrompt}`;
+          appendSystemPrompt = appendSystemPrompt ? `${appendSystemPrompt}
+
+${customInstructions}` : customInstructions;
+        }
+      } else {
+        logForDebugging(`[teammate] Custom agent ${storedTeammateOpts.agentType} not found in available agents`);
+      }
+    }
+    maybeActivateBrief(options);
+    if (false) {}
+    if (false) {}
+    if (false) {}
+    let root;
+    let getFpsMetrics;
+    let stats;
+    if (!isNonInteractiveSession) {
+      const ctx = getRenderContext(false);
+      getFpsMetrics = ctx.getFpsMetrics;
+      stats = ctx.stats;
+      if (false) {}
+      const {
+        createRoot
+      } = await import("./ink.js");
+      root = await createRoot(ctx.renderOptions);
+      logEvent("tengu_timer", {
+        event: "startup",
+        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`);
+      if (false) {}
+      if (false) {}
+      if (onboardingShown && prompt?.trim().toLowerCase() === "/login") {
+        prompt = "";
+      }
+      if (onboardingShown) {
+        refreshRemoteManagedSettings();
+        refreshPolicyLimits();
+        resetUserCache();
+        refreshGrowthBookAfterAuthChange();
+        import("./bridge/trustedDevice.js").then((m) => {
+          m.clearTrustedDeviceToken();
+          return m.enrollTrustedDevice();
+        });
+      }
+      const orgValidation = await validateForceLoginOrg();
+      if (!orgValidation.valid) {
+        await exitWithError(root, orgValidation.message);
+      }
+    }
+    if (process.exitCode !== undefined) {
+      logForDebugging("Graceful shutdown initiated, skipping further initialization");
+      return;
+    }
+    initializeLspServerManager();
+    if (!isNonInteractiveSession) {
+      const {
+        errors
+      } = getSettingsWithErrors();
+      const nonMcpErrors = errors.filter((e) => !e.mcpErrorMetadata);
+      if (nonMcpErrors.length > 0) {
+        await launchInvalidSettingsDialog(root, {
+          settingsErrors: nonMcpErrors,
+          onExit: () => gracefulShutdownSync(1)
+        });
+      }
+    }
+    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));
+      fetchBootstrapData();
+      prefetchPassesEligibility();
+      if (!getFeatureValue_CACHED_MAY_BE_STALE("tengu_miraculo_the_bard", false)) {
+        prefetchFastModeStatus();
+      } else {
+        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`);
+      resolveFastModeStatusFromCache();
+    }
+    if (!isNonInteractiveSession) {
+      refreshExampleCommands();
+    }
+    const {
+      servers: existingMcpConfigs
+    } = await mcpConfigPromise;
+    logForDebugging(`[STARTUP] MCP configs resolved in ${mcpConfigResolvedMs}ms (awaited at +${Date.now() - mcpConfigStart}ms)`);
+    const allMcpConfigs = {
+      ...existingMcpConfigs,
+      ...dynamicMcpConfig
+    };
+    const sdkMcpConfigs = {};
+    const regularMcpConfigs = {};
+    for (const [name, config] of Object.entries(allMcpConfigs)) {
+      const typedConfig = config;
+      if (typedConfig.type === "sdk") {
+        sdkMcpConfigs[name] = typedConfig;
+      } else {
+        regularMcpConfigs[name] = typedConfig;
+      }
+    }
+    profileCheckpoint("action_mcp_configs_loaded");
+    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: []
+    });
+    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")
+    }));
+    const hooksPromise = initOnly || init || maintenance || isNonInteractiveSession || options.continue || options.resume ? null : processSessionStartHooks("startup", {
+      agentType: mainThreadAgentDefinition?.agentType,
+      model: resolvedInitialModel
+    });
+    const hookMessages = [];
+    mcpPromise.catch(() => {});
+    const mcpClients = [];
+    const mcpTools = [];
+    const mcpCommands = [];
+    let thinkingEnabled = shouldEnableThinkingByDefault();
+    let 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");
+    });
+    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: undefined
+    });
+    logContextMetrics(regularMcpConfigs, toolPermissionContext);
+    logPermissionContextForAnts(null, "initialization");
+    logManagedSettings();
+    registerSession().then((registered) => {
+      if (!registered)
+        return;
+      if (sessionNameArg) {
+        updateSessionName(sessionNameArg);
+      }
+      countConcurrentSessions().then((count) => {
+        if (count >= 2) {
+          logEvent("tengu_concurrent_sessions", {
+            num_sessions: count
+          });
+        }
+      });
+    });
+    if (isBareMode()) {} else if (isNonInteractiveSession) {
+      await initializeVersionedPlugins();
+      profileCheckpoint("action_after_plugins_init");
+      cleanupOrphanedPluginVersionsInBackground().then(() => getGlobExclusionsForPluginCache());
+    } else {
+      initializeVersionedPlugins().then(async () => {
+        profileCheckpoint("action_after_plugins_init");
+        await cleanupOrphanedPluginVersionsInBackground();
+        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;
+    }
+    if (isNonInteractiveSession) {
+      if (outputFormat === "stream-json" || outputFormat === "json") {
+        setHasFormattedOutput(true);
+      }
+      applyConfigEnvironmentVariables();
+      initializeTelemetryAfterTrust();
+      const sessionStartHooksPromise = options.continue || options.resume || teleport || setupTrigger ? undefined : processSessionStartHooks("startup");
+      sessionStartHooksPromise?.catch(() => {});
+      profileCheckpoint("before_validateForceLoginOrg");
+      const orgValidation = await validateForceLoginOrg();
+      if (!orgValidation.valid) {
+        process.stderr.write(orgValidation.message + `
+`);
+        process.exit(1);
+      }
+      const commandsHeadless = disableSlashCommands ? [] : commands.filter((command) => command.type === "prompt" && !command.disableNonInteractive || command.type === "local" && command.supportsNonInteractive);
+      const defaultState = getDefaultAppState();
+      const headlessInitialState = {
+        ...defaultState,
+        mcp: {
+          ...defaultState.mcp,
+          clients: mcpClients,
+          commands: mcpCommands,
+          tools: mcpTools
+        },
+        toolPermissionContext,
+        effortValue: parseEffortValue(options.effort) ?? getInitialEffortSetting(),
+        ...isFastModeEnabled() && {
+          fastMode: getInitialFastModeSetting(effectiveModel ?? null)
+        },
+        ...isAdvisorEnabled() && advisorModel && {
+          advisorModel
+        },
+        ...{}
+      };
+      const headlessStore = createStore(headlessInitialState, onChangeAppState);
+      if (toolPermissionContext.mode === "bypassPermissions" || allowDangerouslySkipPermissions) {
+        checkAndDisableBypassPermissions(toolPermissionContext);
+      }
+      if (false) {}
+      if (options.sessionPersistence === false) {
+        setSessionPersistenceDisabled(true);
+      }
+      setSdkBetas(filterAllowedSdkBetas(betas));
+      const connectMcpBatch = (configs, label) => {
+        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",
+              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}`));
+      };
+      profileCheckpoint("before_connectMcp");
+      await connectMcpBatch(regularMcpConfigs, "regular");
+      profileCheckpoint("after_connectMcp");
+      const CLAUDE_AI_MCP_TIMEOUT_MS = 5000;
+      const claudeaiConnect = claudeaiConfigPromise.then((claudeaiConfigs) => {
+        if (Object.keys(claudeaiConfigs).length > 0) {
+          const claudeaiSigs = new Set;
+          for (const config of Object.values(claudeaiConfigs)) {
+            const sig = getMcpServerSignature(config);
+            if (sig)
+              claudeaiSigs.add(sig);
+          }
+          const suppressed = new Set;
+          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(", ")}`);
+            for (const c of headlessStore.getState().mcp.clients) {
+              if (!suppressed.has(c.name) || c.type !== "connected")
+                continue;
+              c.client.onclose = undefined;
+              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
+                }
+              };
+            });
+          }
+        }
+        const nonPluginConfigs = pickBy(regularMcpConfigs, (_, n) => !n.startsWith("plugin:"));
+        const {
+          servers: dedupedClaudeAi
+        } = dedupClaudeAiMcpServers(claudeaiConfigs, nonPluginConfigs);
+        return connectMcpBatch(dedupedClaudeAi, "claudeai");
+      });
+      let claudeaiTimer;
+      const claudeaiTimedOut = await Promise.race([claudeaiConnect.then(() => false), new Promise((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");
+      if (!isBareMode()) {
+        startDeferredPrefetches();
+        import("./utils/backgroundHousekeeping.js").then((m) => m.startBackgroundHousekeeping());
+        if (false) {}
+      }
+      logSessionTelemetry();
+      profileCheckpoint("before_print_import");
+      const {
+        runHeadless
+      } = await import("./cli/print.js");
+      profileCheckpoint("after_print_import");
+      runHeadless(inputPrompt, () => headlessStore.getState(), headlessStore.setState, commandsHeadless, tools, sdkMcpConfigs, agentDefinitions.activeAgents, {
+        continue: options.continue,
+        resume: options.resume,
+        verbose,
+        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;
+    }
+    logEvent("tengu_startup_manual_model_config", {
+      cli_flag: options.model,
+      env_var: process.env.ANTHROPIC_MODEL,
+      settings_file: (getInitialSettings() || {}).model,
+      subscriptionType: getSubscriptionType(),
+      agent: agentSetting
+    });
+    const deprecationWarning = getModelDeprecationWarning(resolvedInitialModel);
+    const initialNotifications = [];
+    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 — not available for Ants, please use auto-mode instead`,
+        color: "warning",
+        priority: "high"
+      });
+    }
+    const effectiveToolPermissionContext = {
+      ...toolPermissionContext,
+      mode: isAgentSwarmsEnabled() && getTeammateUtils().isPlanModeRequired() ? "plan" : toolPermissionContext.mode
+    };
+    const initialIsBriefOnly = false;
+    const fullRemoteControl = remoteControl || getRemoteControlAtStartup() || kairosEnabled;
+    let ccrMirrorEnabled = false;
+    if (false) {}
+    const initialState = {
+      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,
+      fastMode: getInitialFastModeSetting(resolvedInitialModel),
+      ...isAdvisorEnabled() && advisorModel && {
+        advisorModel
+      },
+      teamContext: computeInitialTeamContext?.()
+    };
+    if (inputPrompt) {
+      addToHistory(String(inputPrompt));
+    }
+    const initialTools = mcpTools;
+    saveGlobalConfig((current) => ({
+      ...current,
+      numStartups: (current.numStartups ?? 0) + 1
+    }));
+    setImmediate(() => {
+      logStartupTelemetry();
+      logSessionTelemetry();
+    });
+    const sessionUploaderPromise = null;
+    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) => {
+          uploaderReady.then((uploader) => uploader?.(messages));
+        }
+      }
+    };
+    const resumeContext = {
+      modeApi: coordinatorModeModule,
+      mainThreadAgentDefinition,
+      agentDefinitions,
+      currentCwd,
+      cliAgents,
+      initialState
+    };
+    if (options.continue) {
+      let resumeSucceeded = false;
+      try {
+        const resumeStart = performance.now();
+        const {
+          clearSessionCaches
+        } = await import("./commands/clear/caches.js");
+        clearSessionCaches();
+        const result = await loadConversationForResume(undefined, undefined);
+        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 (false) {} else if (false) {} else if (false) {} else if (options.resume || options.fromPr || teleport || remote !== null) {
+      const {
+        clearSessionCaches
+      } = await import("./commands/clear/caches.js");
+      clearSessionCaches();
+      let messages = null;
+      let processedResume = undefined;
+      let maybeSessionId = validateUuid(options.resume);
+      let searchTerm = undefined;
+      let matchedLog = null;
+      let filterByPr = undefined;
+      if (options.fromPr) {
+        if (options.fromPr === true) {
+          filterByPr = true;
+        } else if (typeof options.fromPr === "string") {
+          filterByPr = options.fromPr;
+        }
+      }
+      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) {
+            matchedLog = matches[0];
+            maybeSessionId = getSessionIdFromLog(matchedLog) ?? null;
+          } else {
+            searchTerm = trimmedValue;
+          }
+        }
+      }
+      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) {
+        const hasInitialPrompt = remote.length > 0;
+        const isRemoteTuiEnabled = getFeatureValue_CACHED_MAY_BE_STALE("tengu_remote_backend", false);
+        if (!isRemoteTuiEnabled && !hasInitialPrompt) {
+          return await exitWithError(root, `Error: --remote requires a description.
+Usage: lcclaude --remote "your task description"`, () => gracefulShutdown(1));
+        }
+        logEvent("tengu_remote_create_session", {
+          has_initial_prompt: String(hasInitialPrompt)
+        });
+        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"
+          });
+          return await exitWithError(root, "Error: Unable to create remote session", () => gracefulShutdown(1));
+        }
+        logEvent("tengu_remote_create_session_success", {
+          session_id: createdSession.id
+        });
+        if (!isRemoteTuiEnabled) {
+          process.stdout.write(`Created remote session: ${createdSession.title}
+`);
+          process.stdout.write(`View: ${getRemoteSessionUrl(createdSession.id)}?m=0
+`);
+          process.stdout.write(`Resume with: claude --teleport ${createdSession.id}
+`);
+          await gracefulShutdown(0);
+          process.exit(0);
+        }
+        setIsRemoteMode(true);
+        switchSession(asSessionId(createdSession.id));
+        let apiCreds;
+        try {
+          apiCreds = await prepareApiRequest();
+        } catch (error) {
+          logError(toError(error));
+          return await exitWithError(root, `Error: ${errorMessage(error) || "Failed to authenticate"}`, () => gracefulShutdown(1));
+        }
+        const {
+          getClaudeAIOAuthTokens: getTokensForRemote
+        } = await import("./utils/auth.js");
+        const getAccessTokenForRemote = () => getTokensForRemote()?.accessToken ?? apiCreds.accessToken;
+        const remoteSessionConfig = createRemoteSessionConfig(createdSession.id, getAccessTokenForRemote, apiCreds.orgUUID, hasInitialPrompt);
+        const remoteSessionUrl = `${getRemoteSessionUrl(createdSession.id)}?m=0`;
+        const remoteInfoMessage = createSystemMessage(`/remote-control is active. Code in CLI or at ${remoteSessionUrl}`, "info");
+        const initialUserMessage = hasInitialPrompt ? createUserMessage({
+          content: remote
+        }) : null;
+        const remoteInitialState = {
+          ...initialState,
+          remoteSessionUrl
+        };
+        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 === "") {
+          logEvent("tengu_teleport_interactive_mode", {});
+          logForDebugging("selectAndResumeTeleportTask: Starting teleport flow...");
+          const teleportResult = await launchTeleportResumeWrapper(root);
+          if (!teleportResult) {
+            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"
+          });
+          try {
+            const sessionData = await fetchSession(teleport);
+            const repoValidation = await validateSessionRepository(sessionData);
+            if (repoValidation.status === "mismatch" || repoValidation.status === "not_in_repo") {
+              const sessionRepo = repoValidation.sessionRepo;
+              if (sessionRepo) {
+                const knownPaths = getKnownPathsForRepo(sessionRepo);
+                const existingPaths = await filterExistingPaths(knownPaths);
+                if (existingPaths.length > 0) {
+                  const selectedPath = await launchTeleportRepoMismatchDialog(root, {
+                    targetRepo: sessionRepo,
+                    initialPaths: existingPaths
+                  });
+                  if (selectedPath) {
+                    process.chdir(selectedPath);
+                    setCwd(selectedPath);
+                    setOriginalCwd(selectedPath);
+                  } else {
+                    await gracefulShutdown(0);
+                  }
+                } else {
+                  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)}.
+`));
+                }
+              }
+            } else if (repoValidation.status === "error") {
+              throw new TeleportOperationError(repoValidation.errorMessage || "Failed to validate session", chalk.red(`Error: ${repoValidation.errorMessage || "Failed to validate session"}
+`));
+            }
+            await validateGitState();
+            const {
+              teleportWithProgress
+            } = await import("./components/TeleportProgress.js");
+            const result = await teleportWithProgress(root, teleport);
+            setTeleportedSessionInfo({
+              sessionId: teleport
+            });
+            messages = result.messages;
+          } catch (error) {
+            if (error instanceof TeleportOperationError) {
+              process.stderr.write(error.formattedMessage + `
+`);
+            } else {
+              logError(error);
+              process.stderr.write(chalk.red(`Error: ${errorMessage(error)}
+`));
+            }
+            await gracefulShutdown(1);
+          }
+        }
+      }
+      if (false) {}
+      if (maybeSessionId) {
+        const sessionId = maybeSessionId;
+        try {
+          const resumeStart = performance.now();
+          const result = await loadConversationForResume(matchedLog ?? sessionId, undefined);
+          if (!result) {
+            logEvent("tengu_session_resumed", {
+              entrypoint: "cli_flag",
+              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",
+            success: true,
+            resume_duration_ms: Math.round(performance.now() - resumeStart)
+          });
+        } catch (error) {
+          logEvent("tengu_session_resumed", {
+            entrypoint: "cli_flag",
+            success: false
+          });
+          logError(error);
+          await exitWithError(root, `Failed to resume session ${sessionId}`);
+        }
+      }
+      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.
+`));
+          }
+        } catch (error) {
+          return await exitWithError(root, `Error downloading files: ${errorMessage(error)}`);
+        }
+      }
+      const resumeData = processedResume ?? (Array.isArray(messages) ? {
+        messages,
+        fileHistorySnapshots: undefined,
+        agentName: undefined,
+        agentColor: 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 {
+        await launchResumeChooser(root, {
+          getFpsMetrics,
+          stats,
+          initialState
+        }, getWorktreePaths(getOriginalCwd()), {
+          ...sessionConfig,
+          initialSearchQuery: searchTerm,
+          forkSession: options.forkSession,
+          filterByPr
+        });
+      }
+    } else {
+      const pendingHookMessages = hooksPromise && hookMessages.length === 0 ? hooksPromise : undefined;
+      profileCheckpoint("action_after_hooks");
+      maybeActivateProactive(options);
+      maybeActivateBrief(options);
+      if (false) {}
+      let deepLinkBanner = null;
+      if (false) {}
+      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");
+  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 (false) {}
+  if (false) {}
+  if (false) {}
+  if (false) {}
+  if (false) {}
+  if (false) {}
+  if (false) {}
+  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());
+  program.addOption(new Option("--sdk-url <url>", "Use remote WebSocket endpoint for SDK I/O streaming (only with -p and stream-json format)").hideHelp());
+  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 (false) {}
+  if (false) {}
+  profileCheckpoint("run_main_options_built");
+  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;
+  }
+  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
+  }) => {
+    const {
+      mcpServeHandler
+    } = await import("./cli/handlers/mcp.js");
+    await mcpServeHandler({
+      debug,
+      verbose
+    });
+  });
+  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, options) => {
+    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) => {
+    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, json, options) => {
+    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) => {
+    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();
+  });
+  if (false) {}
+  if (false) {}
+  if (false) {}
+  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
+  }) => {
+    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) => {
+    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();
+  });
+  const coworkOption = () => new Option("--cowork", "Use cowork_plugins directory").hideHelp();
+  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, options) => {
+    const {
+      pluginValidateHandler
+    } = await import("./cli/handlers/plugins.js");
+    await pluginValidateHandler(manifestPath, options);
+  });
+  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) => {
+    const {
+      pluginListHandler
+    } = await import("./cli/handlers/plugins.js");
+    await pluginListHandler(options);
+  });
+  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, options) => {
+    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) => {
+    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, options) => {
+    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, options) => {
+    const {
+      marketplaceUpdateHandler
+    } = await import("./cli/handlers/plugins.js");
+    await marketplaceUpdateHandler(name, options);
+  });
+  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, options) => {
+    const {
+      pluginInstallHandler
+    } = await import("./cli/handlers/plugins.js");
+    await pluginInstallHandler(plugin, options);
+  });
+  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, options) => {
+    const {
+      pluginUninstallHandler
+    } = await import("./cli/handlers/plugins.js");
+    await pluginUninstallHandler(plugin, options);
+  });
+  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, options) => {
+    const {
+      pluginEnableHandler
+    } = await import("./cli/handlers/plugins.js");
+    await pluginEnableHandler(plugin, options);
+  });
+  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, options) => {
+    const {
+      pluginDisableHandler
+    } = await import("./cli/handlers/plugins.js");
+    await pluginDisableHandler(plugin, options);
+  });
+  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, options) => {
+    const {
+      pluginUpdateHandler
+    } = await import("./cli/handlers/plugins.js");
+    await pluginUpdateHandler(plugin, options);
+  });
+  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);
+  });
+  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 (false) {}
+  if (false) {}
+  if (false) {}
+  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);
+  });
+  program.command("update").alias("upgrade").description("Check for updates and install if available").action(async () => {
+    const {
+      update
+    } = await import("./cli/update.js");
+    await update();
+  });
+  if (false) {}
+  if (false) {}
+  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, options) => {
+    const {
+      installHandler
+    } = await import("./cli/handlers/util.js");
+    await installHandler(target, options);
+  });
+  if (false) {}
+  profileCheckpoint("run_before_parse");
+  await program.parseAsync(process.argv);
+  profileCheckpoint("run_after_parse");
+  profileCheckpoint("main_after_run");
+  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
+}) {
+  try {
+    logEvent("tengu_init", {
+      entrypoint: "claude",
+      hasInitialPrompt,
+      hasStdin,
+      verbose,
+      debug,
+      debugToStderr,
+      print,
+      outputFormat,
+      inputFormat,
+      numAllowedTools,
+      numDisallowedTools,
+      mcpClientCount,
+      worktree: worktreeEnabled,
+      skipWebFetchPreflight,
+      ...githubActionInputs && {
+        githubActionInputs
+      },
+      dangerouslySkipPermissionsPassed,
+      permissionMode,
+      modeIsBypass,
+      inProtectedNamespace: isInProtectedNamespace(),
+      allowDangerouslySkipPermissionsPassed,
+      thinkingType: thinkingConfig.type,
+      ...systemPromptFlag && {
+        systemPromptFlag
+      },
+      ...appendSystemPromptFlag && {
+        appendSystemPromptFlag
+      },
+      is_simple: isBareMode() || undefined,
+      is_coordinator: undefined,
+      ...assistantActivationPath && {
+        assistantActivationPath
+      },
+      autoUpdatesChannel: getInitialSettings().autoUpdatesChannel ?? "latest",
+      ...{}
+    });
+  } catch (error) {
+    logError(error);
+  }
+}
+function maybeActivateProactive(options) {
+  if (false) {}
+}
+function maybeActivateBrief(options) {
+  if (true)
+    return;
+  const briefFlag = options.brief;
+  const briefEnv = isEnvTruthy(process.env.CLAUDE_CODE_BRIEF);
+  if (!briefFlag && !briefEnv)
+    return;
+  const {
+    isBriefEntitled
+  } = require("./tools/BriefTool/BriefTool.js");
+  const entitled = isBriefEntitled();
+  if (entitled) {
+    setUserMsgOptIn(true);
+  }
+  logEvent("tengu_brief_mode_enabled", {
+    enabled: entitled,
+    gated: !entitled,
+    source: briefEnv ? "env" : "flag"
+  });
+}
+function resetCursor() {
+  const terminal = process.stderr.isTTY ? process.stderr : process.stdout.isTTY ? process.stdout : undefined;
+  terminal?.write(SHOW_CURSOR);
+}
+function extractTeammateOptions(options) {
+  if (typeof options !== "object" || options === null) {
+    return {};
+  }
+  const opts = options;
+  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
+  };
+}