@xmem-ai/memcode 4.0.2

package/dist/main.js

@@ -0,0 +1,3574 @@
+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();
+async function failOpenStartupGate(name, promise, timeoutMs = 1500) {
+  let timedOut = false;
+  let timeout;
+  const guarded = promise.catch((error) => {
+    logForDebugging(`[STARTUP] ${name} failed open: ${error}`);
+  });
+  try {
+    await Promise.race([
+      guarded,
+      new Promise((resolve2) => {
+        timeout = setTimeout(() => {
+          timedOut = true;
+          resolve2();
+        }, timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+  if (timedOut) {
+    logForDebugging(`[STARTUP] ${name} timed out after ${timeoutMs}ms; continuing`);
+  }
+}
+import { feature } from "bun:bundle";
+import { Command as CommanderCommand, InvalidArgumentError, Option } from "@commander-js/extra-typings";
+import chalk from "chalk";
+import { readFileSync, writeFileSync } from "fs";
+import mapValues from "lodash-es/mapValues.js";
+import pickBy from "lodash-es/pickBy.js";
+import uniqBy from "lodash-es/uniqBy.js";
+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 { 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 "./utils/asciicast.js";
+import { getClaudeAIOAuthTokensAsync, getConfiguredApiKeyHelper, getSubscriptionType, isClaudeAISubscriber, prefetchAwsCredentialsAndBedRockInfoIfSafe, prefetchGcpCredentialsIfSafe, validateForceLoginOrg } from "./utils/auth.js";
+import { resolveOpenRouterApiKey } from "./utils/apiKeyHelper.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 = feature("COORDINATOR_MODE") ? require("./coordinator/coordinatorMode.js") : null;
+const assistantModule = feature("KAIROS") ? require("./assistant/index.js") : null;
+const kairosGate = feature("KAIROS") ? require("./assistant/gate.js") : null;
+import { resolve } from "path";
+import { isAnalyticsDisabled } from "src/services/analytics/config.js";
+import { getFeatureValue_CACHED_MAY_BE_STALE } from "src/services/analytics/growthbook.js";
+import { logEvent } from "src/services/analytics/index.js";
+import { initializeAnalyticsGates } from "src/services/analytics/sink.js";
+import { getOriginalCwd, setAdditionalDirectoriesForClaudeMd, setIsRemoteMode, setMainLoopModelOverride, setMainThreadAgentType, setTeleportedSessionInfo } from "./bootstrap/state.js";
+import { filterCommandsForRemoteMode, getCommands } from "./commands.js";
+import { 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/memcodeLimits.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 { XCODE_IN_CHROME_SKILL_HINT, XCODE_IN_CHROME_SKILL_HINT_WITH_WEBBROWSER } from "./utils/memcodeInChrome/prompt.js";
+import { setupmemCodeInChrome, shouldAutoEnablememCodeInChrome, shouldEnablememCodeInChrome } from "./utils/memcodeInChrome/setup.js";
+import { isBridgeModeAvailable } from "./bridge/bridgeEnabled.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, isUpstreamFeatureEnabled } from "./utils/envUtils.js";
+import { refreshExampleCommands } from "./utils/exampleCommands.js";
+import { getWorktreePaths } from "./utils/getWorktreePaths.js";
+import { 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, 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, 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 } 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 { XCODE_DEFAULT_NVIDIA_API_KEY } from "./constants/memcodeDefaults.js";
+async function validatePrintCredentialsOrExit() {
+  if (isEnvTruthy(process.env.XCODE_USE_BEDROCK) || isEnvTruthy(process.env.XCODE_USE_VERTEX) || isEnvTruthy(process.env.XCODE_USE_FOUNDRY)) {
+    return;
+  }
+  if (resolveOpenRouterApiKey() || process.env.OPENAI_API_KEY || process.env.OPENAI_API_TOKEN || process.env.XCODE_OPENAI_API_KEY || process.env.XCODE_API_URL || process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN || process.env.GEMINI_API_KEY || process.env.NVIDIA_API_KEY || XCODE_DEFAULT_NVIDIA_API_KEY || getConfiguredApiKeyHelper()) {
+    return;
+  }
+  const oauthTokens = await getClaudeAIOAuthTokensAsync();
+  if (oauthTokens?.accessToken) return;
+  process.stderr.write(
+    "Error: No API credentials found for --print mode. Set OPENROUTER_API_KEY, OPENAI_API_KEY, GEMINI_API_KEY, XCODE_API_URL, or another provider-specific credential.\n"
+  );
+  process.exit(1);
+}
+function isHeadlessLocalSlashCommand(inputPrompt, commands) {
+  if (typeof inputPrompt !== "string") return false;
+  const trimmed = inputPrompt.trim();
+  if (!trimmed.startsWith("/")) return false;
+  const commandName = trimmed.slice(1).split(/\s+/, 1)[0];
+  if (!commandName) return false;
+  return commands.some(
+    (command) => command.type === "local" && command.supportsNonInteractive && (command.name === commandName || command.aliases?.includes(commandName))
+  );
+}
+import { registerMcpAddCommand } from "src/commands/mcp/addCommand.js";
+import { registerMcpXaaIdpCommand } from "src/commands/mcp/xaaIdpCommand.js";
+import { logPermissionContextForAnts } from "src/services/internalLogging.js";
+import { fetchmemCodeProxyMcpConfigsIfEligible } from "src/services/mcp/memcodeProxy.js";
+import { clearServerCache } from "src/services/mcp/client.js";
+import { areMcpConfigsAllowedWithEnterpriseMcpConfig, dedupClaudeAiMcpServers, doesEnterpriseMcpConfigExist, filterMcpServersByPolicy, getClaudeCodeMcpConfigs, getMcpServerSignature, parseMcpConfig, parseMcpConfigFromFilePath } from "src/services/mcp/config.js";
+import { excludeCommandsByServer, excludeResourcesByServer } from "src/services/mcp/utils.js";
+import { isXaaEnabled } from "src/services/mcp/xaaIdpLogin.js";
+import { getRelevantTips } from "src/services/tips/tipRegistry.js";
+import { logContextMetrics } from "src/utils/api.js";
+import { XCODE_IN_CHROME_MCP_SERVER_NAME, ismemCodeInChromeMCPServer } from "src/utils/memcodeInChrome/common.js";
+import { registerCleanup } from "src/utils/cleanupRegistry.js";
+import { eagerParseCliFlag } from "src/utils/cliArgs.js";
+import { createEmptyAttributionState } from "src/utils/commitAttribution.js";
+import { countConcurrentSessions, registerSession, updateSessionName } from "src/utils/concurrentSessions.js";
+import { getCwd } from "src/utils/cwd.js";
+import { logForDebugging, setHasFormattedOutput } from "src/utils/debug.js";
+import { errorMessage, getErrnoCode, isENOENT, TeleportOperationError, toError } from "src/utils/errors.js";
+import { getFsImplementation, safeResolvePath } from "src/utils/fsOperations.js";
+import { gracefulShutdown, gracefulShutdownSync } from "src/utils/gracefulShutdown.js";
+import { setAllHookEventsEnabled } from "src/utils/hooks/hookEvents.js";
+import { refreshModelCapabilities } from "src/utils/model/modelCapabilities.js";
+import { peekForStdinData, writeToStderr } from "src/utils/process.js";
+import { setCwd } from "src/utils/Shell.js";
+import { processResumedConversation } from "src/utils/sessionRestore.js";
+import { parseSettingSourcesFlag } from "src/utils/settings/constants.js";
+import { plural } from "src/utils/stringUtils.js";
+import { getInitialMainLoopModel, getIsNonInteractiveSession, getSdkBetas, getSessionId, getUserMsgOptIn, setAllowedChannels, setAllowedSettingSources, setChromeFlagOverride, setClientType, setCwdState, setDirectConnectServerUrl, setFlagSettingsPath, setInitialMainLoopModel, setInlinePlugins, setIsInteractive, setKairosActive, setOriginalCwd, setQuestionPreviewFormat, setSdkBetas, setSessionBypassPermissionsMode, setSessionPersistenceDisabled, setSessionSource, setUserMsgOptIn, switchSession } from "./bootstrap/state.js";
+const autoModeStateModule = feature("TRANSCRIPT_CLASSIFIER") ? require("./utils/permissions/autoModeState.js") : null;
+import { migrateAutoUpdatesToSettings } from "./migrations/migrateAutoUpdatesToSettings.js";
+import { migrateBypassPermissionsAcceptedToSettings } from "./migrations/migrateBypassPermissionsAcceptedToSettings.js";
+import { migrateEnableAllProjectMcpServersToSettings } from "./migrations/migrateEnableAllProjectMcpServersToSettings.js";
+import "./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());
+  void logSkillsLoaded(getCwd(), getContextWindowForModel(model, getSdkBetas()));
+  void loadAllPluginsCacheOnly().then(({
+    enabled,
+    errors
+  }) => {
+    const managedNames = getManagedPluginNames();
+    logPluginsEnabledForSession(enabled, managedNames, getPluginSeedDirs());
+    logPluginLoadErrors(errors, managedNames);
+  }).catch((err) => logError(err));
+}
+function getCertEnvVarTelemetry() {
+  const result = {};
+  if (process.env.NODE_EXTRA_CA_CERTS) {
+    result.has_node_extra_ca_certs = true;
+  }
+  if (process.env.XCODE_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 (feature("TRANSCRIPT_CLASSIFIER")) {
+      resetAutoModeOptInForDefaultOffer();
+    }
+    if (false) {
+      migrateFennecToOpus();
+    }
+    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");
+    void getSystemContext();
+    return;
+  }
+  const hasTrust = checkHasTrustDialogAccepted();
+  if (hasTrust) {
+    logForDiagnosticsNoPII("info", "prefetch_system_context_has_trust");
+    void getSystemContext();
+  } else {
+    logForDiagnosticsNoPII("info", "prefetch_system_context_skipped_no_trust");
+  }
+}
+function startDeferredPrefetches() {
+  if (isEnvTruthy(process.env.XCODE_EXIT_AFTER_FIRST_RENDER) || // --bare: skip ALL prefetches. These are cache-warms for the REPL's
+  // first-turn responsiveness (initUser, getUserContext, tips, countFiles,
+  // modelCapabilities, change detectors). Scripted -p calls don't have a
+  // "user is typing" window to hide this work in — it's pure overhead on
+  // the critical path.
+  isBareMode()) {
+    return;
+  }
+  void initUser();
+  void getUserContext();
+  prefetchSystemContextIfSafe();
+  void getRelevantTips();
+  if (isEnvTruthy(process.env.XCODE_USE_BEDROCK) && !isEnvTruthy(process.env.XCODE_SKIP_BEDROCK_AUTH)) {
+    void prefetchAwsCredentialsAndBedRockInfoIfSafe();
+  }
+  if (isEnvTruthy(process.env.XCODE_USE_VERTEX) && !isEnvTruthy(process.env.XCODE_SKIP_VERTEX_AUTH)) {
+    void prefetchGcpCredentialsIfSafe();
+  }
+  void countFilesRoundedRg(getCwd(), AbortSignal.timeout(3e3), []);
+  void initializeAnalyticsGates();
+  void prefetchOfficialMcpUrls();
+  void refreshModelCapabilities();
+  void settingsChangeDetector.initialize();
+  if (!isBareMode()) {
+    void skillChangeDetector.initialize();
+  }
+  if (false) {
+    void null.then((m) => m.startEventLoopStallDetector());
+  }
+}
+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\n"));
+        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 !== void 0) {
+    loadSettingSourcesFromFlag(settingSourcesArg);
+  }
+  profileCheckpoint("eagerLoadSettings_end");
+}
+function initializeEntrypoint(isNonInteractive) {
+  if (process.env.XCODE_ENTRYPOINT) {
+    return;
+  }
+  const cliArgs = process.argv.slice(2);
+  const mcpIndex = cliArgs.indexOf("mcp");
+  if (mcpIndex !== -1 && cliArgs[mcpIndex + 1] === "serve") {
+    process.env.XCODE_ENTRYPOINT = "mcp";
+    return;
+  }
+  if (isEnvTruthy(process.env.XCODE_ACTION)) {
+    process.env.XCODE_ENTRYPOINT = "memcode-github-action";
+    return;
+  }
+  process.env.XCODE_ENTRYPOINT = isNonInteractive ? "sdk-cli" : "cli";
+}
+const _pendingConnect = feature("DIRECT_CONNECT") ? {
+  url: void 0,
+  authToken: void 0,
+  dangerouslySkipPermissions: false
+} : void 0;
+const _pendingAssistantChat = feature("KAIROS") ? {
+  sessionId: void 0,
+  discover: false
+} : void 0;
+const _pendingSSH = feature("SSH_REMOTE") ? {
+  host: void 0,
+  cwd: void 0,
+  permissionMode: void 0,
+  dangerouslySkipPermissions: false,
+  local: false,
+  extraCliArgs: []
+} : void 0;
+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 (feature("DIRECT_CONNECT")) {
+    const rawCliArgs = process.argv.slice(2);
+    const ccIdx = rawCliArgs.findIndex((a) => a.startsWith("cc://") || a.startsWith("cc+unix://"));
+    if (ccIdx !== -1 && _pendingConnect) {
+      const ccUrl = rawCliArgs[ccIdx];
+      const {
+        parseConnectUrl
+      } = await import("./server/parseConnectUrl.js");
+      const parsed = parseConnectUrl(ccUrl);
+      _pendingConnect.dangerouslySkipPermissions = rawCliArgs.includes("--dangerously-skip-permissions");
+      if (rawCliArgs.includes("-p") || rawCliArgs.includes("--print")) {
+        const stripped = rawCliArgs.filter((_, i) => i !== ccIdx);
+        const dspIdx = stripped.indexOf("--dangerously-skip-permissions");
+        if (dspIdx !== -1) {
+          stripped.splice(dspIdx, 1);
+        }
+        process.argv = [process.argv[0], process.argv[1], "open", ccUrl, ...stripped];
+      } else {
+        _pendingConnect.url = parsed.serverUrl;
+        _pendingConnect.authToken = parsed.authToken;
+        const stripped = rawCliArgs.filter((_, i) => i !== ccIdx);
+        const dspIdx = stripped.indexOf("--dangerously-skip-permissions");
+        if (dspIdx !== -1) {
+          stripped.splice(dspIdx, 1);
+        }
+        process.argv = [process.argv[0], process.argv[1], ...stripped];
+      }
+    }
+  }
+  if (feature("LODESTONE")) {
+    const handleUriIdx = process.argv.indexOf("--handle-uri");
+    if (handleUriIdx !== -1 && process.argv[handleUriIdx + 1]) {
+      const {
+        enableConfigs
+      } = await import("./utils/config.js");
+      enableConfigs();
+      const uri = process.argv[handleUriIdx + 1];
+      const {
+        handleDeepLinkUri
+      } = await import("./utils/deepLink/protocolHandler.js");
+      const exitCode = await handleDeepLinkUri(uri);
+      process.exit(exitCode);
+    }
+    if (process.platform === "darwin" && process.env.__CFBundleIdentifier === "com.xortex.memcode-url-handler") {
+      const {
+        enableConfigs
+      } = await import("./utils/config.js");
+      enableConfigs();
+      const {
+        handleUrlSchemeLaunch
+      } = await import("./utils/deepLink/protocolHandler.js");
+      const urlSchemeResult = await handleUrlSchemeLaunch();
+      process.exit(urlSchemeResult ?? 1);
+    }
+  }
+  if (feature("KAIROS") && _pendingAssistantChat) {
+    const rawArgs = process.argv.slice(2);
+    if (rawArgs[0] === "assistant") {
+      const nextArg = rawArgs[1];
+      if (nextArg && !nextArg.startsWith("-")) {
+        _pendingAssistantChat.sessionId = nextArg;
+        rawArgs.splice(0, 2);
+        process.argv = [process.argv[0], process.argv[1], ...rawArgs];
+      } else if (!nextArg) {
+        _pendingAssistantChat.discover = true;
+        rawArgs.splice(0, 1);
+        process.argv = [process.argv[0], process.argv[1], ...rawArgs];
+      }
+    }
+  }
+  if (feature("SSH_REMOTE") && _pendingSSH) {
+    const rawCliArgs = process.argv.slice(2);
+    if (rawCliArgs[0] === "ssh") {
+      const localIdx = rawCliArgs.indexOf("--local");
+      if (localIdx !== -1) {
+        _pendingSSH.local = true;
+        rawCliArgs.splice(localIdx, 1);
+      }
+      const dspIdx = rawCliArgs.indexOf("--dangerously-skip-permissions");
+      if (dspIdx !== -1) {
+        _pendingSSH.dangerouslySkipPermissions = true;
+        rawCliArgs.splice(dspIdx, 1);
+      }
+      const pmIdx = rawCliArgs.indexOf("--permission-mode");
+      if (pmIdx !== -1 && rawCliArgs[pmIdx + 1] && !rawCliArgs[pmIdx + 1].startsWith("-")) {
+        _pendingSSH.permissionMode = rawCliArgs[pmIdx + 1];
+        rawCliArgs.splice(pmIdx, 2);
+      }
+      const pmEqIdx = rawCliArgs.findIndex((a) => a.startsWith("--permission-mode="));
+      if (pmEqIdx !== -1) {
+        _pendingSSH.permissionMode = rawCliArgs[pmEqIdx].split("=")[1];
+        rawCliArgs.splice(pmEqIdx, 1);
+      }
+      const extractFlag = (flag, opts = {}) => {
+        const i = rawCliArgs.indexOf(flag);
+        if (i !== -1) {
+          _pendingSSH.extraCliArgs.push(opts.as ?? flag);
+          const val = rawCliArgs[i + 1];
+          if (opts.hasValue && val && !val.startsWith("-")) {
+            _pendingSSH.extraCliArgs.push(val);
+            rawCliArgs.splice(i, 2);
+          } else {
+            rawCliArgs.splice(i, 1);
+          }
+        }
+        const eqI = rawCliArgs.findIndex((a) => a.startsWith(`${flag}=`));
+        if (eqI !== -1) {
+          _pendingSSH.extraCliArgs.push(opts.as ?? flag, rawCliArgs[eqI].slice(flag.length + 1));
+          rawCliArgs.splice(eqI, 1);
+        }
+      };
+      extractFlag("-c", {
+        as: "--continue"
+      });
+      extractFlag("--continue");
+      extractFlag("--resume", {
+        hasValue: true
+      });
+      extractFlag("--model", {
+        hasValue: true
+      });
+    }
+    if (rawCliArgs[0] === "ssh" && rawCliArgs[1] && !rawCliArgs[1].startsWith("-")) {
+      _pendingSSH.host = rawCliArgs[1];
+      let consumed = 2;
+      if (rawCliArgs[2] && !rawCliArgs[2].startsWith("-")) {
+        _pendingSSH.cwd = rawCliArgs[2];
+        consumed = 3;
+      }
+      const rest = rawCliArgs.slice(consumed);
+      if (rest.includes("-p") || rest.includes("--print")) {
+        process.stderr.write("Error: headless (-p/--print) mode is not supported with claude ssh\n");
+        gracefulShutdownSync(1);
+        return;
+      }
+      process.argv = [process.argv[0], process.argv[1], ...rest];
+    }
+  }
+  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 forceInteractive = !hasPrintFlag;
+  const isNonInteractive = hasPrintFlag || hasInitOnlyFlag || hasSdkUrl || !forceInteractive && !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.XCODE_ENTRYPOINT === "sdk-ts") return "sdk-typescript";
+    if (process.env.XCODE_ENTRYPOINT === "sdk-py") return "sdk-python";
+    if (process.env.XCODE_ENTRYPOINT === "sdk-cli") return "sdk-cli";
+    if (process.env.XCODE_ENTRYPOINT === "memcode-vscode") return "memcode-vscode";
+    if (process.env.XCODE_ENTRYPOINT === "local-agent") return "local-agent";
+    if (process.env.XCODE_ENTRYPOINT === "memcode-desktop" || process.env.XCODE_ENTRYPOINT === "claude-desktop") return "memcode-desktop";
+    const hasSessionIngressToken = process.env.XCODE_SESSION_ACCESS_TOKEN || process.env.XCODE_WEBSOCKET_AUTH_FILE_DESCRIPTOR;
+    if (process.env.XCODE_ENTRYPOINT === "remote" || hasSessionIngressToken) {
+      return "remote";
+    }
+    return "cli";
+  })();
+  setClientType(clientType);
+  const previewFormat = process.env.XCODE_QUESTION_PREVIEW_FORMAT;
+  if (previewFormat === "markdown" || previewFormat === "html") {
+    setQuestionPreviewFormat(previewFormat);
+  } else if (!clientType.startsWith("sdk-") && // Desktop and CCR pass previewFormat via toolConfig; when the feature is
+  // gated off they pass undefined — don't override that with markdown.
+  clientType !== "memcode-desktop" && clientType !== "local-agent" && clientType !== "remote") {
+    setQuestionPreviewFormat("markdown");
+  }
+  if (process.env.XCODE_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 (isEnvTruthy(process.env.XCODE_SKIP_STDIN_PROBE)) {
+    logForDebugging("[STARTUP] Skipping stdin probe due to XCODE_SKIP_STDIN_PROBE");
+    return prompt;
+  }
+  if (!process.stdin.isTTY && // Input hijacking breaks MCP.
+  !process.argv.includes("mcp")) {
+    if (inputFormat === "stream-json") {
+      return process.stdin;
+    }
+    process.stdin.setEncoding("utf8");
+    let data = "";
+    const onData = (chunk) => {
+      data += chunk;
+    };
+    process.stdin.on("data", onData);
+    const timedOut = await peekForStdinData(process.stdin, 3e3);
+    process.stdin.off("data", onData);
+    if (timedOut) {
+      process.stderr.write("Warning: no stdin data received in 3s, proceeding without it. If piping from a slow command, redirect stdin explicitly: < /dev/null to skip, or wait longer.\n");
+    }
+    return [prompt, data].filter(Boolean).join("\n");
+  }
+  return prompt;
+}
+async function run() {
+  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([
+      failOpenStartupGate("MDM settings", ensureMdmSettingsLoaded()),
+      failOpenStartupGate("keychain prefetch", ensureKeychainPrefetchCompleted())
+    ]);
+    profileCheckpoint("preAction_after_mdm");
+    await init();
+    profileCheckpoint("preAction_after_init");
+    if (!isEnvTruthy(process.env.XCODE_DISABLE_TERMINAL_TITLE)) {
+      process.title = "memcode";
+    }
+    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");
+    void loadRemoteManagedSettings();
+    void loadPolicyLimits();
+    profileCheckpoint("preAction_after_remote_settings");
+    if (feature("UPLOAD_USER_SETTINGS")) {
+      void import("./services/settingsSync/index.js").then((m) => m.uploadUserSettingsInBackground());
+    }
+    profileCheckpoint("preAction_after_settings_sync");
+  });
+  program.name("memcode").description(`memCode - 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 in -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 XCODE.md auto-discovery. Sets XCODE_SIMPLE=1. Use OPENROUTER_API_KEY, OPENAI_API_KEY, XCODE_API_URL, GEMINI_API_KEY, or --settings for credentials. Explicitly provide context via: --system-prompt[-file], --append-system-prompt[-file], --add-dir (XCODE.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 : void 0;
+  }).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. Examples: 'gpt', 'gpt-4o', 'gemini', 'kimi', 'deepseek', or a full provider model name.`).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).addOption(new Option("--chrome", "Enable upstream Chrome integration").hideHelp()).addOption(new Option("--no-chrome", "Disable upstream Chrome integration").hideHelp()).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.XCODE_SIMPLE = "1";
+    }
+    if (prompt === "code") {
+      logEvent("tengu_code_prompt_ignored", {});
+      console.warn(chalk.yellow("Tip: You can launch memCode with just `memcode`"));
+      prompt = void 0;
+    }
+    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 (feature("KAIROS") && options.assistant && assistantModule) {
+      assistantModule.markAssistantForced();
+    }
+    if (feature("KAIROS") && assistantModule?.isAssistantMode() && // Spawned teammates share the leader's cwd + settings.json, so
+    // isAssistantMode() is true for them too. --agent-id being set
+    // means we ARE a spawned teammate (extractTeammateOptions runs
+    // ~170 lines later so check the raw commander option) — don't
+    // re-init the team or override teammateMode/proactive/brief.
+    !options.agentId && kairosGate) {
+      if (!checkHasTrustDialogAccepted()) {
+        console.warn(chalk.yellow("Assistant mode disabled: directory is not trusted. Accept the trust dialog and restart."));
+      } else {
+        kairosEnabled = assistantModule.isAssistantForced() || await kairosGate.isKairosEnabled();
+        if (kairosEnabled) {
+          const opts = options;
+          opts.brief = true;
+          setKairosActive(true);
+          assistantTeamContext = await assistantModule.initializeAssistantTeam();
+        }
+      }
+    }
+    const {
+      debug = false,
+      debugToStderr = false,
+      dangerouslySkipPermissions,
+      allowDangerouslySkipPermissions = false,
+      tools: baseTools = [],
+      allowedTools = [],
+      disallowedTools = [],
+      mcpConfig = [],
+      permissionMode: permissionModeCli,
+      addDir = [],
+      fallbackModel,
+      betas = [],
+      ide = false,
+      sessionId,
+      includeHookEvents,
+      includePartialMessages
+    } = options;
+    if (options.prefill) {
+      seedEarlyInput(options.prefill);
+    }
+    let fileDownloadPromise;
+    const agentsJson = options.agents;
+    const agentCli = options.agent;
+    if (feature("BG_SESSIONS") && agentCli) {
+      process.env.XCODE_AGENT = agentCli;
+    }
+    let outputFormat = options.outputFormat;
+    let inputFormat = options.inputFormat;
+    let verbose = options.verbose ?? getGlobalConfig().verbose;
+    let print = options.print;
+    const init2 = 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 : void 0;
+    if (false) {
+      process.env.XCODE_TASK_LIST_ID = taskListId;
+    }
+    const worktreeOption = isWorktreeModeEnabled() ? options.worktree : void 0;
+    let worktreeName = typeof worktreeOption === "string" ? worktreeOption : void 0;
+    const worktreeEnabled = worktreeOption !== void 0;
+    let worktreePRNumber;
+    if (worktreeName) {
+      const prNum = parsePRReference(worktreeName);
+      if (prNum !== null) {
+        worktreePRNumber = prNum;
+        worktreeName = void 0;
+      }
+    }
+    const tmuxEnabled = isWorktreeModeEnabled() && options.tmux === true;
+    if (tmuxEnabled) {
+      if (!worktreeEnabled) {
+        process.stderr.write(chalk.red("Error: --tmux requires --worktree\n"));
+        process.exit(1);
+      }
+      if (getPlatform() === "windows") {
+        process.stderr.write(chalk.red("Error: --tmux is not supported on Windows\n"));
+        process.exit(1);
+      }
+      if (!await isTmuxAvailable()) {
+        process.stderr.write(chalk.red(`Error: tmux is not installed.
+${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\n"));
+        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 ?? void 0;
+    const effectiveIncludePartialMessages = includePartialMessages || isEnvTruthy(process.env.XCODE_INCLUDE_PARTIAL_MESSAGES);
+    if (includeHookEvents || isEnvTruthy(process.env.XCODE_REMOTE)) {
+      setAllHookEventsEnabled(true);
+    }
+    if (sdkUrl) {
+      if (!inputFormat) {
+        inputFormat = "stream-json";
+      }
+      if (!outputFormat) {
+        outputFormat = "stream-json";
+      }
+      if (options.verbose === void 0) {
+        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 : void 0;
+    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.\n"));
+        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.\n"));
+          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. XCODE_SESSION_ACCESS_TOKEN must be set.\n"));
+        process.exit(1);
+      }
+      const fileSessionId = process.env.XCODE_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.\n"));
+      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.\n"));
+        process.exit(1);
+      }
+      try {
+        const filePath = resolve(options.systemPromptFile);
+        systemPrompt = readFileSync(filePath, "utf8");
+      } catch (error) {
+        const code = getErrnoCode(error);
+        if (code === "ENOENT") {
+          process.stderr.write(chalk.red(`Error: System prompt file not found: ${resolve(options.systemPromptFile)}
+`));
+          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.\n"));
+        process.exit(1);
+      }
+      try {
+        const filePath = resolve(options.appendSystemPromptFile);
+        appendSystemPrompt = readFileSync(filePath, "utf8");
+      } catch (error) {
+        const code = getErrnoCode(error);
+        if (code === "ENOENT") {
+          process.stderr.write(chalk.red(`Error: Append system prompt file not found: ${resolve(options.appendSystemPromptFile)}
+`));
+          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 (feature("TRANSCRIPT_CLASSIFIER")) {
+      if (options.enableAutoMode || permissionModeCli === "auto" || permissionMode === "auto" || !permissionModeCli && isDefaultPermissionModeAuto()) {
+        autoModeStateModule?.setAutoModeFlagCli(true);
+      }
+    }
+    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("\n");
+        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(ismemCodeInChromeMCPServer)) {
+          reservedNameError = `Invalid MCP configuration: "${XCODE_IN_CHROME_MCP_SERVER_NAME}" is a reserved MCP name.`;
+        } else if (feature("CHICAGO_MCP")) {
+          const {
+            isComputerUseMCPServer,
+            COMPUTER_USE_MCP_SERVER_NAME
+          } = await import("src/utils/computerUse/common.js");
+          if (nonSdkConfigNames.some(isComputerUseMCPServer)) {
+            reservedNameError = `Invalid MCP configuration: "${COMPUTER_USE_MCP_SERVER_NAME}" is a reserved MCP name.`;
+          }
+        }
+        if (reservedNameError) {
+          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 upstreamFeaturesEnabled = isUpstreamFeatureEnabled();
+    const enablememCodeInChrome = upstreamFeaturesEnabled && shouldEnablememCodeInChrome(chromeOpts.chrome) && isClaudeAISubscriber();
+    const autoEnablememCodeInChrome = upstreamFeaturesEnabled && !enablememCodeInChrome && shouldAutoEnablememCodeInChrome();
+    if (enablememCodeInChrome) {
+      const platform = getPlatform();
+      try {
+        logEvent("memcode_in_chrome_setup", {
+          platform
+        });
+        const {
+          mcpConfig: chromeMcpConfig,
+          allowedTools: chromeMcpTools,
+          systemPrompt: chromeSystemPrompt
+        } = setupmemCodeInChrome();
+        dynamicMcpConfig = {
+          ...dynamicMcpConfig,
+          ...chromeMcpConfig
+        };
+        allowedTools.push(...chromeMcpTools);
+        if (chromeSystemPrompt) {
+          appendSystemPrompt = appendSystemPrompt ? `${chromeSystemPrompt}
+
+${appendSystemPrompt}` : chromeSystemPrompt;
+        }
+      } catch (error) {
+        logEvent("memcode_in_chrome_setup_failed", {
+          platform
+        });
+        logForDebugging(`[memCode in Chrome] Error: ${error}`);
+        logError(error);
+        console.error(`Error: Failed to run with memCode in Chrome.`);
+        process.exit(1);
+      }
+    } else if (autoEnablememCodeInChrome) {
+      try {
+        const {
+          mcpConfig: chromeMcpConfig
+        } = setupmemCodeInChrome();
+        dynamicMcpConfig = {
+          ...dynamicMcpConfig,
+          ...chromeMcpConfig
+        };
+        const hint = feature("WEB_BROWSER_TOOL") && typeof Bun !== "undefined" && "WebView" in Bun ? XCODE_IN_CHROME_SKILL_HINT_WITH_WEBBROWSER : XCODE_IN_CHROME_SKILL_HINT;
+        appendSystemPrompt = appendSystemPrompt ? `${appendSystemPrompt}
+
+${hint}` : hint;
+      } catch (error) {
+        logForDebugging(`[memCode 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 (feature("CHICAGO_MCP") && getPlatform() === "macos" && !getIsNonInteractiveSession()) {
+      try {
+        const {
+          getChicagoEnabled
+        } = await import("src/utils/computerUse/gates.js");
+        if (getChicagoEnabled()) {
+          const {
+            setupComputerUseMCP
+          } = await import("src/utils/computerUse/setup.js");
+          const {
+            mcpConfig: mcpConfig2,
+            allowedTools: cuTools
+          } = setupComputerUseMCP();
+          dynamicMcpConfig = {
+            ...dynamicMcpConfig,
+            ...mcpConfig2
+          };
+          allowedTools.push(...cuTools);
+        }
+      } catch (error) {
+        logForDebugging(`[Computer Use MCP] Setup failed: ${errorMessage(error)}`);
+      }
+    }
+    setAdditionalDirectoriesForClaudeMd(addDir);
+    let devChannels;
+    if (feature("KAIROS") || feature("KAIROS_CHANNELS")) {
+      const parseChannelEntries = (raw, flag) => {
+        const entries = [];
+        const bad = [];
+        for (const c of raw) {
+          if (c.startsWith("plugin:")) {
+            const rest = c.slice(7);
+            const at = rest.indexOf("@");
+            if (at <= 0 || at === rest.length - 1) {
+              bad.push(c);
+            } else {
+              entries.push({
+                kind: "plugin",
+                name: rest.slice(0, at),
+                marketplace: rest.slice(at + 1)
+              });
+            }
+          } else if (c.startsWith("server:") && c.length > 7) {
+            entries.push({
+              kind: "server",
+              name: c.slice(7)
+            });
+          } else {
+            bad.push(c);
+          }
+        }
+        if (bad.length > 0) {
+          process.stderr.write(chalk.red(`${flag} entries must be tagged: ${bad.join(", ")}
+  plugin:<name>@<marketplace>  \u2014 plugin-provided channel (allowlist enforced)
+  server:<name>                \u2014 manually configured MCP server
+`));
+          process.exit(1);
+        }
+        return entries;
+      };
+      const channelOpts = options;
+      const rawChannels = channelOpts.channels;
+      const rawDev = channelOpts.dangerouslyLoadDevelopmentChannels;
+      let channelEntries = [];
+      if (rawChannels && rawChannels.length > 0) {
+        channelEntries = parseChannelEntries(rawChannels, "--channels");
+        setAllowedChannels(channelEntries);
+      }
+      if (!isNonInteractiveSession) {
+        if (rawDev && rawDev.length > 0) {
+          devChannels = parseChannelEntries(rawDev, "--dangerously-load-development-channels");
+        }
+      }
+      if (channelEntries.length > 0 || (devChannels?.length ?? 0) > 0) {
+        const joinPluginIds = (entries) => {
+          const ids = entries.flatMap((e) => e.kind === "plugin" ? [`${e.name}@${e.marketplace}`] : []);
+          return ids.length > 0 ? ids.sort().join(",") : void 0;
+        };
+        logEvent("tengu_mcp_channel_flags", {
+          channels_count: channelEntries.length,
+          dev_count: devChannels?.length ?? 0,
+          plugins: joinPluginIds(channelEntries),
+          dev_plugins: joinPluginIds(devChannels ?? [])
+        });
+      }
+    }
+    if (isNonInteractiveSession) {
+      applyConfigEnvironmentVariables();
+    }
+    if ((feature("KAIROS") || feature("KAIROS_BRIEF")) && baseTools.length > 0) {
+      const {
+        BRIEF_TOOL_NAME,
+        LEGACY_BRIEF_TOOL_NAME
+      } = require("./tools/BriefTool/prompt.js");
+      const {
+        isBriefEntitled
+      } = require("./tools/BriefTool/BriefTool.js");
+      const parsed = parseToolListFromCLI(baseTools);
+      if ((parsed.includes(BRIEF_TOOL_NAME) || parsed.includes(LEGACY_BRIEF_TOOL_NAME)) && isBriefEntitled()) {
+        setUserMsgOptIn(true);
+      }
+    }
+    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) {
+      for (const permission of overlyBroadBashPermissions) {
+        logForDebugging(`Ignoring overly broad shell permission ${permission.ruleDisplay} from ${permission.sourceDisplay}`);
+      }
+      toolPermissionContext = removeDangerousPermissions(toolPermissionContext, overlyBroadBashPermissions);
+    }
+    if (feature("TRANSCRIPT_CLASSIFIER") && dangerousPermissions.length > 0) {
+      toolPermissionContext = stripDangerousPermissionsForAutoMode(toolPermissionContext);
+    }
+    warnings.forEach((warning) => {
+      console.error(warning);
+    });
+    void assertMinVersion();
+    const claudeaiConfigPromise = isNonInteractiveSession && !strictMcpConfig && !doesEnterpriseMcpConfigExist() && // --bare / SIMPLE: skip claude.ai proxy servers (datadog, Gmail,
+    // Slack, BigQuery, PubMed — 6-14s each to connect). Scripted calls
+    // that need MCP pass --mcp-config explicitly.
+    !isBareMode() ? fetchmemCodeProxyMcpConfigsIfEligible().then((configs) => {
+      const {
+        allowed,
+        blocked
+      } = filterMcpServersByPolicy(configs);
+      if (blocked.length > 0) {
+        process.stderr.write(`Warning: memCode 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 || "";
+    logForDebugging("[STARTUP] Resolving input prompt, stdinTTY=" + process.stdin.isTTY + ", stdoutTTY=" + process.stdout.isTTY);
+    let inputPrompt = await getInputPrompt(effectivePrompt, inputFormat ?? "text");
+    logForDebugging("[STARTUP] Input prompt resolved");
+    profileCheckpoint("action_after_input_prompt");
+    maybeActivateProactive(options);
+    logForDebugging("[STARTUP] Loading built-in tools...");
+    let tools = getTools(toolPermissionContext);
+    logForDebugging("[STARTUP] Built-in tools loaded: " + tools.length);
+    if (feature("COORDINATOR_MODE") && isEnvTruthy(process.env.XCODE_COORDINATOR_MODE)) {
+      const {
+        applyCoordinatorToolFilter
+      } = await import("./utils/toolPool.js");
+      tools = applyCoordinatorToolFilter(tools);
+    }
+    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 {
+      setup
+    } = await import("./setup.js");
+    const messagingSocketPath = feature("UDS_INBOX") ? options.messagingSocketPath : void 0;
+    const preSetupCwd = getCwd();
+    if (process.env.XCODE_ENTRYPOINT !== "local-agent") {
+      initBuiltinPlugins();
+      initBundledSkills();
+    }
+    logForDebugging("[STARTUP] Starting setup() promise...");
+    const setupPromise = setup(preSetupCwd, permissionMode, allowDangerouslySkipPermissions, worktreeEnabled, worktreeName, tmuxEnabled, sessionId ? validateUuid(sessionId) : void 0, 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 (feature("UDS_INBOX")) {
+      if (!effectiveReplayUserMessages && outputFormat === "stream-json") {
+        effectiveReplayUserMessages = !!options.messagingSocketPath;
+      }
+    }
+    if (getIsNonInteractiveSession()) {
+      applyConfigEnvironmentVariables();
+      void getSystemContext();
+      void getUserContext();
+      void ensureModelStringsInitialized();
+    }
+    const sessionNameArg = options.name?.trim();
+    if (sessionNameArg) {
+      cacheSessionTitle(sessionNameArg);
+    }
+    const explicitModel = options.model || process.env.XCODE_MODEL || process.env.ANTHROPIC_MODEL;
+    if (false) {
+      await initializeGrowthBook();
+    }
+    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 : void 0;
+      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 ((feature("KAIROS") || feature("KAIROS_BRIEF")) && !getIsNonInteractiveSession() && !getUserMsgOptIn() && getInitialSettings().defaultView === "chat") {
+      const {
+        isBriefEntitled
+      } = require("./tools/BriefTool/BriefTool.js");
+      if (isBriefEntitled()) {
+        setUserMsgOptIn(true);
+      }
+    }
+    if ((feature("PROACTIVE") || feature("KAIROS")) && (options.proactive || isEnvTruthy(process.env.XCODE_PROACTIVE)) && !coordinatorModeModule?.isCoordinatorMode()) {
+      const briefVisibility = feature("KAIROS") || feature("KAIROS_BRIEF") ? require("./tools/BriefTool/BriefTool.js").isBriefEnabled() ? "Call SendUserMessage at checkpoints to mark where things stand." : "The user will see any text you output." : "The user will see any text you output.";
+      const proactivePrompt = `
+# Proactive Mode
+
+You are in proactive mode. Take initiative \u2014 explore, act, and make progress without waiting for instructions.
+
+Start by briefly greeting the user.
+
+You will receive periodic <tick> prompts. These are check-ins. Do whatever seems most useful, or call Sleep if there's nothing to do. ${briefVisibility}`;
+      appendSystemPrompt = appendSystemPrompt ? `${appendSystemPrompt}
+
+${proactivePrompt}` : proactivePrompt;
+    }
+    if (feature("KAIROS") && kairosEnabled && assistantModule) {
+      const assistantAddendum = assistantModule.getAssistantSystemPromptAddendum();
+      appendSystemPrompt = appendSystemPrompt ? `${appendSystemPrompt}
+
+${assistantAddendum}` : assistantAddendum;
+    }
+    let root;
+    let getFpsMetrics;
+    let stats;
+    if (!isNonInteractiveSession) {
+      const ctx = getRenderContext(false);
+      getFpsMetrics = ctx.getFpsMetrics;
+      stats = ctx.stats;
+      if (false) {
+        installAsciicastRecorder();
+      }
+      const {
+        createRoot
+      } = await import("./ink.js");
+      root = await createRoot(ctx.renderOptions);
+      logEvent("tengu_timer", {
+        event: "startup",
+        durationMs: Math.round(process.uptime() * 1e3)
+      });
+      logForDebugging("[STARTUP] Running showSetupScreens()...");
+      const setupScreensStart = Date.now();
+      const onboardingShown = await showSetupScreens(root, permissionMode, allowDangerouslySkipPermissions, commands, enablememCodeInChrome, devChannels);
+      profileCheckpoint("interactive_after_setup_screens");
+      logForDebugging(`[STARTUP] showSetupScreens() completed in ${Date.now() - setupScreensStart}ms`);
+      if (isBridgeModeAvailable() && remoteControlOption !== void 0) {
+        const {
+          getBridgeDisabledReason
+        } = await import("./bridge/bridgeEnabled.js");
+        const disabledReason = await getBridgeDisabledReason();
+        remoteControl = disabledReason === null;
+        if (disabledReason) {
+          process.stderr.write(chalk.yellow(`${disabledReason}
+--rc flag ignored.
+`));
+        }
+      }
+      if (feature("AGENT_MEMORY_SNAPSHOT") && mainThreadAgentDefinition && isCustomAgent(mainThreadAgentDefinition) && mainThreadAgentDefinition.memory && mainThreadAgentDefinition.pendingSnapshotUpdate) {
+        const agentDef = mainThreadAgentDefinition;
+        const choice = await launchSnapshotUpdateDialog(root, {
+          agentType: agentDef.agentType,
+          scope: agentDef.memory,
+          snapshotTimestamp: agentDef.pendingSnapshotUpdate.snapshotTimestamp
+        });
+        if (choice === "merge") {
+          const {
+            buildMergePrompt
+          } = await import("./components/agents/SnapshotUpdateDialog.js");
+          const mergePrompt = buildMergePrompt(agentDef.agentType, agentDef.memory);
+          inputPrompt = inputPrompt ? `${mergePrompt}
+
+${inputPrompt}` : mergePrompt;
+        }
+        agentDef.pendingSnapshotUpdate = void 0;
+      }
+      if (onboardingShown && prompt?.trim().toLowerCase() === "/login") {
+        prompt = "";
+      }
+      if (onboardingShown) {
+        void refreshRemoteManagedSettings();
+        void refreshPolicyLimits();
+        resetUserCache();
+        refreshGrowthBookAfterAuthChange();
+        void 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 !== void 0) {
+      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) / 1e3)}s ago` : "";
+      logForDebugging(`Starting background startup prefetches${lastPrefetchedInfo}`);
+      checkQuotaStatus().catch((error) => logError(error));
+      void fetchBootstrapData();
+      void prefetchPassesEligibility();
+      if (!getFeatureValue_CACHED_MAY_BE_STALE("tengu_miraculo_the_bard", false)) {
+        void prefetchFastModeStatus();
+      } else {
+        resolveFastModeStatusFromCache();
+      }
+      if (bgRefreshThrottleMs > 0) {
+        saveGlobalConfig((current) => ({
+          ...current,
+          startupPrefetchedAt: Date.now()
+        }));
+      }
+    } else {
+      logForDebugging(`Skipping startup prefetches, last ran ${Math.round((Date.now() - lastPrefetched) / 1e3)}s ago`);
+      resolveFastModeStatusFromCache();
+    }
+    if (!isNonInteractiveSession) {
+      void 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 || init2 || 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 !== void 0) {
+        if (maxThinkingTokens > 0) {
+          thinkingEnabled = true;
+          thinkingConfig = {
+            type: "enabled",
+            budgetTokens: maxThinkingTokens
+          };
+        } else if (maxThinkingTokens === 0) {
+          thinkingEnabled = false;
+          thinkingConfig = {
+            type: "disabled"
+          };
+        }
+      }
+    }
+    logForDiagnosticsNoPII("info", "started", {
+      version: MACRO.VERSION,
+      is_native_binary: isInBundledMode()
+    });
+    registerCleanup(async () => {
+      logForDiagnosticsNoPII("info", "exited");
+    });
+    void logTenguInit({
+      hasInitialPrompt: Boolean(prompt),
+      hasStdin: Boolean(inputPrompt),
+      verbose,
+      debug,
+      debugToStderr,
+      print: print ?? false,
+      outputFormat: outputFormat ?? "text",
+      inputFormat: inputFormat ?? "text",
+      numAllowedTools: allowedTools.length,
+      numDisallowedTools: disallowedTools.length,
+      mcpClientCount: Object.keys(allMcpConfigs).length,
+      worktreeEnabled,
+      skipWebFetchPreflight: getInitialSettings().skipWebFetchPreflight,
+      githubActionInputs: process.env.GITHUB_ACTION_INPUTS,
+      dangerouslySkipPermissionsPassed: dangerouslySkipPermissions ?? false,
+      permissionMode,
+      modeIsBypass: permissionMode === "bypassPermissions",
+      allowDangerouslySkipPermissionsPassed: allowDangerouslySkipPermissions,
+      systemPromptFlag: systemPrompt ? options.systemPromptFile ? "file" : "flag" : void 0,
+      appendSystemPromptFlag: appendSystemPrompt ? options.appendSystemPromptFile ? "file" : "flag" : void 0,
+      thinkingConfig,
+      assistantActivationPath: feature("KAIROS") && kairosEnabled ? assistantModule?.getAssistantActivationPath() : void 0
+    });
+    void logContextMetrics(regularMcpConfigs, toolPermissionContext);
+    void logPermissionContextForAnts(null, "initialization");
+    logManagedSettings();
+    void registerSession().then((registered) => {
+      if (!registered) return;
+      if (sessionNameArg) {
+        void updateSessionName(sessionNameArg);
+      }
+      void countConcurrentSessions().then((count2) => {
+        if (count2 >= 2) {
+          logEvent("tengu_concurrent_sessions", {
+            num_sessions: count2
+          });
+        }
+      });
+    });
+    if (isBareMode()) {
+    } else if (isNonInteractiveSession) {
+      await initializeVersionedPlugins();
+      profileCheckpoint("action_after_plugins_init");
+      void cleanupOrphanedPluginVersionsInBackground().then(() => getGlobExclusionsForPluginCache());
+    } else {
+      void initializeVersionedPlugins().then(async () => {
+        profileCheckpoint("action_after_plugins_init");
+        await cleanupOrphanedPluginVersionsInBackground();
+        void getGlobExclusionsForPluginCache();
+      });
+    }
+    const setupTrigger = initOnly || init2 ? "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 ? void 0 : processSessionStartHooks("startup");
+      sessionStartHooksPromise?.catch(() => {
+      });
+      const commandsHeadless = disableSlashCommands ? [] : commands.filter((command) => command.type === "prompt" && !command.disableNonInteractive || command.type === "local" && command.supportsNonInteractive);
+      const isLocalHeadlessCommand = isHeadlessLocalSlashCommand(inputPrompt, commandsHeadless);
+      if (!isLocalHeadlessCommand) {
+        logForDebugging("[STARTUP] Print mode validating auth/org...");
+        await validatePrintCredentialsOrExit();
+        profileCheckpoint("before_validateForceLoginOrg");
+        const orgValidation = await validateForceLoginOrg();
+        if (!orgValidation.valid) {
+          process.stderr.write(orgValidation.message + "\n");
+          process.exit(1);
+        }
+        logForDebugging("[STARTUP] Print mode auth/org validation complete");
+      } else {
+        logForDebugging("[STARTUP] Print mode skipping credential validation for local slash command");
+      }
+      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
+        },
+        // kairosEnabled gates the async fire-and-forget path in
+        // executeForkedSlashCommand (processSlashCommand.tsx:132) and
+        // AgentTool's shouldRunAsync. The REPL initialState sets this at
+        // ~3459; headless was defaulting to false, so the daemon child's
+        // scheduled tasks and Agent-tool calls ran synchronously — N
+        // overdue cron tasks on spawn = N serial subagent turns blocking
+        // user input. Computed at :1620, well before this branch.
+        ...feature("KAIROS") ? {
+          kairosEnabled
+        } : {}
+      };
+      const headlessStore = createStore(headlessInitialState, onChangeAppState);
+      if (toolPermissionContext.mode === "bypassPermissions" || allowDangerouslySkipPermissions) {
+        void checkAndDisableBypassPermissions(toolPermissionContext);
+      }
+      if (feature("TRANSCRIPT_CLASSIFIER")) {
+        void verifyAutoModeGateAccess(toolPermissionContext, headlessStore.getState().fastMode).then(({
+          updateContext
+        }) => {
+          headlessStore.setState((prev) => {
+            const nextCtx = updateContext(prev.toolPermissionContext);
+            if (nextCtx === prev.toolPermissionContext) return prev;
+            return {
+              ...prev,
+              toolPermissionContext: nextCtx
+            };
+          });
+        });
+      }
+      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: tools2,
+          commands: commands2
+        }) => {
+          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, ...tools2], "name"),
+              commands: uniqBy([...prev.mcp.commands, ...commands2], "name")
+            }
+          }));
+        }, configs).catch((err) => logForDebugging(`[MCP] ${label} connect error: ${err}`));
+      };
+      profileCheckpoint("before_connectMcp");
+      logForDebugging("[STARTUP] Print mode connecting MCP servers...");
+      await connectMcpBatch(regularMcpConfigs, "regular");
+      profileCheckpoint("after_connectMcp");
+      logForDebugging("[STARTUP] Print mode regular MCP connect complete");
+      const CLAUDE_AI_MCP_TIMEOUT_MS = 5e3;
+      const claudeaiConnect = claudeaiConfigPromise.then((claudeaiConfigs) => {
+        if (Object.keys(claudeaiConfigs).length > 0) {
+          const claudeaiSigs = /* @__PURE__ */ new Set();
+          for (const config of Object.values(claudeaiConfigs)) {
+            const sig = getMcpServerSignature(config);
+            if (sig) claudeaiSigs.add(sig);
+          }
+          const suppressed = /* @__PURE__ */ 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 = void 0;
+              void clearServerCache(c.name, c.config).catch(() => {
+              });
+            }
+            headlessStore.setState((prev) => {
+              let {
+                clients,
+                tools: tools2,
+                commands: commands2,
+                resources
+              } = prev.mcp;
+              clients = clients.filter((c) => !suppressed.has(c.name));
+              tools2 = tools2.filter((t) => !t.mcpInfo || !suppressed.has(t.mcpInfo.serverName));
+              for (const name of suppressed) {
+                commands2 = excludeCommandsByServer(commands2, name);
+                resources = excludeResourcesByServer(resources, name);
+              }
+              return {
+                ...prev,
+                mcp: {
+                  ...prev.mcp,
+                  clients,
+                  tools: tools2,
+                  commands: commands2,
+                  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((resolve2) => {
+        claudeaiTimer = setTimeout((r) => r(true), CLAUDE_AI_MCP_TIMEOUT_MS, resolve2);
+      })]);
+      if (claudeaiTimer) clearTimeout(claudeaiTimer);
+      if (claudeaiTimedOut) {
+        logForDebugging(`[MCP] claude.ai connectors not ready after ${CLAUDE_AI_MCP_TIMEOUT_MS}ms \u2014 proceeding; background connection continues`);
+      }
+      profileCheckpoint("after_connectMcp_claudeai");
+      logForDebugging("[STARTUP] Print mode claude.ai MCP connect complete");
+      if (!isBareMode()) {
+        startDeferredPrefetches();
+        void import("./utils/backgroundHousekeeping.js").then((m) => m.startBackgroundHousekeeping());
+        if (false) {
+          void null.then((m) => m.startSdkMemoryMonitor());
+        }
+      }
+      logSessionTelemetry();
+      profileCheckpoint("before_print_import");
+      const {
+        runHeadless
+      } = await import("src/cli/print.js");
+      profileCheckpoint("after_print_import");
+      logForDebugging("[STARTUP] Print mode starting headless runner");
+      await 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
+        } : void 0,
+        systemPrompt,
+        appendSystemPrompt,
+        userSpecifiedModel: effectiveModel,
+        fallbackModel: userSpecifiedFallbackModel,
+        teleport,
+        sdkUrl,
+        replayUserMessages: effectiveReplayUserMessages,
+        includePartialMessages: effectiveIncludePartialMessages,
+        forkSession: options.forkSession || false,
+        resumeSessionAt: options.resumeSessionAt || void 0,
+        rewindFiles: options.rewindFiles,
+        enableAuthStatus: options.enableAuthStatus,
+        agent: agentCli,
+        workload: options.workload,
+        setupTrigger: setupTrigger ?? void 0,
+        sessionStartHooksPromise
+      });
+      logForDebugging("[STARTUP] Print mode headless runner completed");
+      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 \u2014 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 = feature("KAIROS") || feature("KAIROS_BRIEF") ? getUserMsgOptIn() : false;
+    const fullRemoteControl = remoteControl || getRemoteControlAtStartup() || kairosEnabled;
+    let ccrMirrorEnabled = false;
+    if (feature("CCR_MIRROR") && !fullRemoteControl) {
+      const {
+        isCcrMirrorEnabled
+      } = require("./bridge/bridgeEnabled.js");
+      ccrMirrorEnabled = isCcrMirrorEnabled();
+    }
+    const initialState = {
+      settings: getInitialSettings(),
+      tasks: {},
+      agentNameRegistry: /* @__PURE__ */ new Map(),
+      verbose: verbose ?? getGlobalConfig().verbose ?? false,
+      mainLoopModel: initialMainLoopModel,
+      mainLoopModelForSession: null,
+      isBriefOnly: initialIsBriefOnly,
+      expandedView: getGlobalConfig().showSpinnerTree ? "teammates" : getGlobalConfig().showExpandedTodos ? "tasks" : "none",
+      showTeammateMessagePreview: isAgentSwarmsEnabled() ? false : void 0,
+      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: void 0,
+      kairosEnabled,
+      remoteSessionUrl: void 0,
+      remoteConnectionStatus: "connecting",
+      remoteBackgroundTaskCount: 0,
+      replBridgeEnabled: fullRemoteControl || ccrMirrorEnabled,
+      replBridgeExplicit: remoteControl,
+      replBridgeOutboundOnly: ccrMirrorEnabled,
+      replBridgeConnected: false,
+      replBridgeSessionActive: false,
+      replBridgeReconnecting: false,
+      replBridgeConnectUrl: void 0,
+      replBridgeSessionUrl: void 0,
+      replBridgeEnvironmentId: void 0,
+      replBridgeSessionId: void 0,
+      replBridgeError: void 0,
+      replBridgeInitialName: remoteControlName,
+      showRemoteCallout: false,
+      notifications: {
+        current: null,
+        queue: initialNotifications
+      },
+      elicitation: {
+        queue: []
+      },
+      todos: {},
+      remoteAgentTaskSuggestions: [],
+      fileHistory: {
+        snapshots: [],
+        trackedFiles: /* @__PURE__ */ new Set(),
+        snapshotSequence: 0
+      },
+      attribution: createEmptyAttributionState(),
+      thinkingEnabled,
+      promptSuggestionEnabled: shouldEnablePromptSuggestion(),
+      sessionHooks: /* @__PURE__ */ 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: /* @__PURE__ */ new Set(),
+      fastMode: getInitialFastModeSetting(resolvedInitialModel),
+      ...isAdvisorEnabled() && advisorModel && {
+        advisorModel
+      },
+      // Compute teamContext synchronously to avoid useEffect setState during render.
+      // KAIROS: assistantTeamContext takes precedence — set earlier in the
+      // KAIROS block so Agent(name: "foo") can spawn in-process teammates
+      // without TeamCreate. computeInitialTeamContext() is for tmux-spawned
+      // teammates reading their own identity, not the assistant-mode leader.
+      teamContext: feature("KAIROS") ? assistantTeamContext ?? computeInitialTeamContext?.() : computeInitialTeamContext?.()
+    };
+    if (inputPrompt) {
+      addToHistory(String(inputPrompt));
+    }
+    const initialTools = mcpTools;
+    saveGlobalConfig((current) => ({
+      ...current,
+      numStartups: (current.numStartups ?? 0) + 1
+    }));
+    setImmediate(() => {
+      void logStartupTelemetry();
+      logSessionTelemetry();
+    });
+    const sessionUploaderPromise = false ? null : 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) => {
+          void 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(
+          void 0,
+          void 0
+          /* sourceFile */
+        );
+        if (!result) {
+          logEvent("tengu_continue", {
+            success: false
+          });
+          return await exitWithError(root, "No conversation found to continue");
+        }
+        const loaded = await processResumedConversation(result, {
+          forkSession: !!options.forkSession,
+          includeAttribution: true,
+          transcriptPath: result.fullPath
+        }, resumeContext);
+        if (loaded.restoredAgentDef) {
+          mainThreadAgentDefinition = loaded.restoredAgentDef;
+        }
+        maybeActivateProactive(options);
+        maybeActivateBrief(options);
+        logEvent("tengu_continue", {
+          success: true,
+          resume_duration_ms: Math.round(performance.now() - resumeStart)
+        });
+        resumeSucceeded = true;
+        await launchRepl(root, {
+          getFpsMetrics,
+          stats,
+          initialState: loaded.initialState
+        }, {
+          ...sessionConfig,
+          mainThreadAgentDefinition: loaded.restoredAgentDef ?? mainThreadAgentDefinition,
+          initialMessages: loaded.messages,
+          initialFileHistorySnapshots: loaded.fileHistorySnapshots,
+          initialContentReplacements: loaded.contentReplacements,
+          initialAgentName: loaded.agentName,
+          initialAgentColor: loaded.agentColor
+        }, renderAndRun);
+      } catch (error) {
+        if (!resumeSucceeded) {
+          logEvent("tengu_continue", {
+            success: false
+          });
+        }
+        logError(error);
+        process.exit(1);
+      }
+    } else if (feature("DIRECT_CONNECT") && _pendingConnect?.url) {
+      let directConnectConfig;
+      try {
+        const session = await createDirectConnectSession({
+          serverUrl: _pendingConnect.url,
+          authToken: _pendingConnect.authToken,
+          cwd: getOriginalCwd(),
+          dangerouslySkipPermissions: _pendingConnect.dangerouslySkipPermissions
+        });
+        if (session.workDir) {
+          setOriginalCwd(session.workDir);
+          setCwdState(session.workDir);
+        }
+        setDirectConnectServerUrl(_pendingConnect.url);
+        directConnectConfig = session.config;
+      } catch (err) {
+        return await exitWithError(root, err instanceof DirectConnectError ? err.message : String(err), () => gracefulShutdown(1));
+      }
+      const connectInfoMessage = createSystemMessage(`Connected to server at ${_pendingConnect.url}
+Session: ${directConnectConfig.sessionId}`, "info");
+      await launchRepl(root, {
+        getFpsMetrics,
+        stats,
+        initialState
+      }, {
+        debug: debug || debugToStderr,
+        commands,
+        initialTools: [],
+        initialMessages: [connectInfoMessage],
+        mcpClients: [],
+        autoConnectIdeFlag: ide,
+        mainThreadAgentDefinition,
+        disableSlashCommands,
+        directConnectConfig,
+        thinkingConfig
+      }, renderAndRun);
+      return;
+    } else if (feature("SSH_REMOTE") && _pendingSSH?.host) {
+      const {
+        createSSHSession,
+        createLocalSSHSession,
+        SSHSessionError
+      } = await import("./ssh/createSSHSession.js");
+      let sshSession;
+      try {
+        if (_pendingSSH.local) {
+          process.stderr.write("Starting local ssh-proxy test session...\n");
+          sshSession = createLocalSSHSession({
+            cwd: _pendingSSH.cwd,
+            permissionMode: _pendingSSH.permissionMode,
+            dangerouslySkipPermissions: _pendingSSH.dangerouslySkipPermissions
+          });
+        } else {
+          process.stderr.write(`Connecting to ${_pendingSSH.host}\u2026
+`);
+          const isTTY = process.stderr.isTTY;
+          let hadProgress = false;
+          sshSession = await createSSHSession({
+            host: _pendingSSH.host,
+            cwd: _pendingSSH.cwd,
+            localVersion: MACRO.VERSION,
+            permissionMode: _pendingSSH.permissionMode,
+            dangerouslySkipPermissions: _pendingSSH.dangerouslySkipPermissions,
+            extraCliArgs: _pendingSSH.extraCliArgs
+          }, isTTY ? {
+            onProgress: (msg) => {
+              hadProgress = true;
+              process.stderr.write(`\r  ${msg}\x1B[K`);
+            }
+          } : {});
+          if (hadProgress) process.stderr.write("\n");
+        }
+        setOriginalCwd(sshSession.remoteCwd);
+        setCwdState(sshSession.remoteCwd);
+        setDirectConnectServerUrl(_pendingSSH.local ? "local" : _pendingSSH.host);
+      } catch (err) {
+        return await exitWithError(root, err instanceof SSHSessionError ? err.message : String(err), () => gracefulShutdown(1));
+      }
+      const sshInfoMessage = createSystemMessage(_pendingSSH.local ? `Local ssh-proxy test session
+cwd: ${sshSession.remoteCwd}
+Auth: unix socket \u2192 local proxy` : `SSH session to ${_pendingSSH.host}
+Remote cwd: ${sshSession.remoteCwd}
+Auth: unix socket -R \u2192 local proxy`, "info");
+      await launchRepl(root, {
+        getFpsMetrics,
+        stats,
+        initialState
+      }, {
+        debug: debug || debugToStderr,
+        commands,
+        initialTools: [],
+        initialMessages: [sshInfoMessage],
+        mcpClients: [],
+        autoConnectIdeFlag: ide,
+        mainThreadAgentDefinition,
+        disableSlashCommands,
+        sshSession,
+        thinkingConfig
+      }, renderAndRun);
+      return;
+    } else if (feature("KAIROS") && _pendingAssistantChat && (_pendingAssistantChat.sessionId || _pendingAssistantChat.discover)) {
+      const {
+        discoverAssistantSessions
+      } = await import("./assistant/sessionDiscovery.js");
+      let targetSessionId = _pendingAssistantChat.sessionId;
+      if (!targetSessionId) {
+        let sessions;
+        try {
+          sessions = await discoverAssistantSessions();
+        } catch (e) {
+          return await exitWithError(root, `Failed to discover sessions: ${e instanceof Error ? e.message : e}`, () => gracefulShutdown(1));
+        }
+        if (sessions.length === 0) {
+          let installedDir;
+          try {
+            installedDir = await launchAssistantInstallWizard(root);
+          } catch (e) {
+            return await exitWithError(root, `Assistant installation failed: ${e instanceof Error ? e.message : e}`, () => gracefulShutdown(1));
+          }
+          if (installedDir === null) {
+            await gracefulShutdown(0);
+            process.exit(0);
+          }
+          return await exitWithMessage(root, `Assistant installed in ${installedDir}. The daemon is starting up \u2014 run \`claude assistant\` again in a few seconds to connect.`, {
+            exitCode: 0,
+            beforeExit: () => gracefulShutdown(0)
+          });
+        }
+        if (sessions.length === 1) {
+          targetSessionId = sessions[0].id;
+        } else {
+          const picked = await launchAssistantSessionChooser(root, {
+            sessions
+          });
+          if (!picked) {
+            await gracefulShutdown(0);
+            process.exit(0);
+          }
+          targetSessionId = picked;
+        }
+      }
+      const {
+        checkAndRefreshOAuthTokenIfNeeded,
+        getClaudeAIOAuthTokens
+      } = await import("./utils/auth.js");
+      await checkAndRefreshOAuthTokenIfNeeded();
+      let apiCreds;
+      try {
+        apiCreds = await prepareApiRequest();
+      } catch (e) {
+        return await exitWithError(root, `Error: ${e instanceof Error ? e.message : "Failed to authenticate"}`, () => gracefulShutdown(1));
+      }
+      const getAccessToken = () => getClaudeAIOAuthTokens()?.accessToken ?? apiCreds.accessToken;
+      setKairosActive(true);
+      setUserMsgOptIn(true);
+      setIsRemoteMode(true);
+      const remoteSessionConfig = createRemoteSessionConfig(
+        targetSessionId,
+        getAccessToken,
+        apiCreds.orgUUID,
+        /* hasInitialPrompt */
+        false,
+        /* viewerOnly */
+        true
+      );
+      const infoMessage = createSystemMessage(`Attached to assistant session ${targetSessionId.slice(0, 8)}\u2026`, "info");
+      const assistantInitialState = {
+        ...initialState,
+        isBriefOnly: true,
+        kairosEnabled: false,
+        replBridgeEnabled: false
+      };
+      const remoteCommands = filterCommandsForRemoteMode(commands);
+      await launchRepl(root, {
+        getFpsMetrics,
+        stats,
+        initialState: assistantInitialState
+      }, {
+        debug: debug || debugToStderr,
+        commands: remoteCommands,
+        initialTools: [],
+        initialMessages: [infoMessage],
+        mcpClients: [],
+        autoConnectIdeFlag: ide,
+        mainThreadAgentDefinition,
+        disableSlashCommands,
+        remoteSessionConfig,
+        thinkingConfig
+      }, renderAndRun);
+      return;
+    } else if (options.resume || options.fromPr || teleport || remote !== null) {
+      const {
+        clearSessionCaches
+      } = await import("./commands/clear/caches.js");
+      clearSessionCaches();
+      let messages = null;
+      let processedResume = void 0;
+      let maybeSessionId = validateUuid(options.resume);
+      let searchTerm = void 0;
+      let matchedLog = null;
+      let filterByPr = void 0;
+      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.\nUsage: memcode --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 || void 0);
+        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: memcode --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 memcode --teleport ${teleport} from a checkout of ${sessionRepo}.`, chalk.red(`You must run memcode --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 + "\n");
+            } else {
+              logError(error);
+              process.stderr.write(chalk.red(`Error: ${errorMessage(error)}
+`));
+            }
+            await gracefulShutdown(1);
+          }
+        }
+      }
+      if (false) {
+        if (options.resume && typeof options.resume === "string" && !maybeSessionId) {
+          const {
+            parseCcshareId,
+            loadCcshare
+          } = await null;
+          const ccshareId = parseCcshareId(options.resume);
+          if (ccshareId) {
+            try {
+              const resumeStart = performance.now();
+              const logOption = await loadCcshare(ccshareId);
+              const result = await loadConversationForResume(logOption, void 0);
+              if (result) {
+                processedResume = await processResumedConversation(result, {
+                  forkSession: true,
+                  transcriptPath: result.fullPath
+                }, resumeContext);
+                if (processedResume.restoredAgentDef) {
+                  mainThreadAgentDefinition = processedResume.restoredAgentDef;
+                }
+                logEvent("tengu_session_resumed", {
+                  entrypoint: "ccshare",
+                  success: true,
+                  resume_duration_ms: Math.round(performance.now() - resumeStart)
+                });
+              } else {
+                logEvent("tengu_session_resumed", {
+                  entrypoint: "ccshare",
+                  success: false
+                });
+              }
+            } catch (error) {
+              logEvent("tengu_session_resumed", {
+                entrypoint: "ccshare",
+                success: false
+              });
+              logError(error);
+              await exitWithError(root, `Unable to resume from ccshare: ${errorMessage(error)}`, () => gracefulShutdown(1));
+            }
+          } else {
+            const resolvedPath = resolve(options.resume);
+            try {
+              const resumeStart = performance.now();
+              let logOption;
+              try {
+                logOption = await loadTranscriptFromFile(resolvedPath);
+              } catch (error) {
+                if (!isENOENT(error)) throw error;
+              }
+              if (logOption) {
+                const result = await loadConversationForResume(
+                  logOption,
+                  void 0
+                  /* sourceFile */
+                );
+                if (result) {
+                  processedResume = await processResumedConversation(result, {
+                    forkSession: !!options.forkSession,
+                    transcriptPath: result.fullPath
+                  }, resumeContext);
+                  if (processedResume.restoredAgentDef) {
+                    mainThreadAgentDefinition = processedResume.restoredAgentDef;
+                  }
+                  logEvent("tengu_session_resumed", {
+                    entrypoint: "file",
+                    success: true,
+                    resume_duration_ms: Math.round(performance.now() - resumeStart)
+                  });
+                } else {
+                  logEvent("tengu_session_resumed", {
+                    entrypoint: "file",
+                    success: false
+                  });
+                }
+              }
+            } catch (error) {
+              logEvent("tengu_session_resumed", {
+                entrypoint: "file",
+                success: false
+              });
+              logError(error);
+              await exitWithError(root, `Unable to load transcript from file: ${options.resume}`, () => gracefulShutdown(1));
+            }
+          }
+        }
+      }
+      if (maybeSessionId) {
+        const sessionId2 = maybeSessionId;
+        try {
+          const resumeStart = performance.now();
+          const result = await loadConversationForResume(matchedLog ?? sessionId2, void 0);
+          if (!result) {
+            logEvent("tengu_session_resumed", {
+              entrypoint: "cli_flag",
+              success: false
+            });
+            return await exitWithError(root, `No conversation found with session ID: ${sessionId2}`);
+          }
+          const fullPath = matchedLog?.fullPath ?? result.fullPath;
+          processedResume = await processResumedConversation(result, {
+            forkSession: !!options.forkSession,
+            sessionIdOverride: sessionId2,
+            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 ${sessionId2}`);
+        }
+      }
+      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: void 0,
+        agentName: void 0,
+        agentColor: void 0,
+        restoredAgentDef: mainThreadAgentDefinition,
+        initialState,
+        contentReplacements: void 0
+      } : void 0);
+      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 : void 0;
+      profileCheckpoint("action_after_hooks");
+      maybeActivateProactive(options);
+      maybeActivateBrief(options);
+      if (feature("COORDINATOR_MODE")) {
+        saveMode(coordinatorModeModule?.isCoordinatorMode() ? "coordinator" : "normal");
+      }
+      let deepLinkBanner = null;
+      if (feature("LODESTONE")) {
+        if (options.deepLinkOrigin) {
+          logEvent("tengu_deep_link_opened", {
+            has_prefill: Boolean(options.prefill),
+            has_repo: Boolean(options.deepLinkRepo)
+          });
+          deepLinkBanner = createSystemMessage(buildDeepLinkBanner({
+            cwd: getCwd(),
+            prefillLength: options.prefill?.length,
+            repo: options.deepLinkRepo,
+            lastFetch: options.deepLinkLastFetch !== void 0 ? new Date(options.deepLinkLastFetch) : void 0
+          }), "warning");
+        } else if (options.prefill) {
+          deepLinkBanner = createSystemMessage("Launched with a pre-filled prompt \u2014 review it before pressing Enter.", "warning");
+        }
+      }
+      const initialMessages = deepLinkBanner ? [deepLinkBanner, ...hookMessages] : hookMessages.length > 0 ? hookMessages : void 0;
+      await launchRepl(root, {
+        getFpsMetrics,
+        stats,
+        initialState
+      }, {
+        ...sessionConfig,
+        initialMessages,
+        pendingHookMessages
+      }, renderAndRun);
+    }
+  }).version(`${MACRO.VERSION} (memcode)`, "-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.");
+  program.addOption(new Option("--no-animation", "Disable animated terminal UI elements").hideHelp());
+  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) {
+    program.addOption(new Option("--delegate-permissions", "[ANT-ONLY] Alias for --permission-mode auto.").implies({
+      permissionMode: "auto"
+    }));
+    program.addOption(new Option("--dangerously-skip-permissions-with-classifiers", "[ANT-ONLY] Deprecated alias for --permission-mode auto.").hideHelp().implies({
+      permissionMode: "auto"
+    }));
+    program.addOption(new Option("--afk", "[ANT-ONLY] Deprecated alias for --permission-mode auto.").hideHelp().implies({
+      permissionMode: "auto"
+    }));
+    program.addOption(new Option("--tasks [id]", '[ANT-ONLY] Tasks mode: watch for tasks and auto-process them. Optional id is used as both the task list ID and agent ID (defaults to "tasklist").').argParser(String).hideHelp());
+    program.option("--agent-teams", "[ANT-ONLY] Force memCode to use multi-agent mode for solving problems", () => true);
+  }
+  if (feature("TRANSCRIPT_CLASSIFIER")) {
+    program.addOption(new Option("--enable-auto-mode", "Opt in to auto mode").hideHelp());
+  }
+  if (feature("PROACTIVE") || feature("KAIROS")) {
+    program.addOption(new Option("--proactive", "Start in proactive autonomous mode"));
+  }
+  if (feature("UDS_INBOX")) {
+    program.addOption(new Option("--messaging-socket-path <path>", "Unix domain socket path for the UDS messaging server (defaults to a tmp path)"));
+  }
+  if (feature("KAIROS") || feature("KAIROS_BRIEF")) {
+    program.addOption(new Option("--brief", "Enable SendUserMessage tool for agent-to-user communication"));
+  }
+  if (feature("KAIROS")) {
+    program.addOption(new Option("--assistant", "Force assistant mode (Agent SDK daemon use)").hideHelp());
+  }
+  if (feature("KAIROS") || feature("KAIROS_CHANNELS")) {
+    program.addOption(new Option("--channels <servers...>", "MCP servers whose channel notifications (inbound push) should register this session. Space-separated server names.").hideHelp());
+    program.addOption(new Option("--dangerously-load-development-channels <servers...>", "Load channel servers not on the approved allowlist. For local channel development only. Shows a confirmation dialog at startup.").hideHelp());
+  }
+  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 (isBridgeModeAvailable()) {
+    program.addOption(new Option("--remote-control [name]", "Start an interactive session with Remote Control enabled (optionally named)").argParser((value) => value || true).hideHelp());
+    program.addOption(new Option("--rc [name]", "Alias for --remote-control").argParser((value) => value || true).hideHelp());
+  }
+  if (feature("HARD_FAIL")) {
+    program.addOption(new Option("--hard-fail", "Crash on logError calls instead of silently logging").hideHelp());
+  }
+  profileCheckpoint("run_main_options_built");
+  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 memCode 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-memcode-desktop", { hidden: !isUpstreamFeatureEnabled() }).description("Import MCP servers from memCode 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("add-from-claude-desktop", { hidden: true }).description("Import MCP servers from memCode 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 (feature("DIRECT_CONNECT")) {
+    program.command("server").description("Start a memCode session server").option("--port <number>", "HTTP port", "0").option("--host <string>", "Bind address", "0.0.0.0").option("--auth-token <token>", "Bearer token for auth").option("--unix <path>", "Listen on a unix domain socket").option("--workspace <dir>", "Default working directory for sessions that do not specify cwd").option("--idle-timeout <ms>", "Idle timeout for detached sessions in ms (0 = never expire)", "600000").option("--max-sessions <n>", "Maximum concurrent sessions (0 = unlimited)", "32").action(async (opts) => {
+      const {
+        randomBytes
+      } = await import("crypto");
+      const {
+        startServer
+      } = await import("./server/server.js");
+      const {
+        SessionManager
+      } = await import("./server/sessionManager.js");
+      const {
+        DangerousBackend
+      } = await import("./server/backends/dangerousBackend.js");
+      const {
+        printBanner
+      } = await import("./server/serverBanner.js");
+      const {
+        createServerLogger
+      } = await import("./server/serverLog.js");
+      const {
+        writeServerLock,
+        removeServerLock,
+        probeRunningServer
+      } = await import("./server/lockfile.js");
+      const existing = await probeRunningServer();
+      if (existing) {
+        process.stderr.write(`A claude server is already running (pid ${existing.pid}) at ${existing.httpUrl}
+`);
+        process.exit(1);
+      }
+      const authToken = opts.authToken ?? `sk-ant-cc-${randomBytes(16).toString("base64url")}`;
+      const config = {
+        port: parseInt(opts.port, 10),
+        host: opts.host,
+        authToken,
+        unix: opts.unix,
+        workspace: opts.workspace,
+        idleTimeoutMs: parseInt(opts.idleTimeout, 10),
+        maxSessions: parseInt(opts.maxSessions, 10)
+      };
+      const backend = new DangerousBackend();
+      const sessionManager = new SessionManager(backend, {
+        idleTimeoutMs: config.idleTimeoutMs,
+        maxSessions: config.maxSessions
+      });
+      const logger = createServerLogger();
+      const server = startServer(config, sessionManager, logger);
+      const actualPort = server.port ?? config.port;
+      printBanner(config, authToken, actualPort);
+      await writeServerLock({
+        pid: process.pid,
+        port: actualPort,
+        host: config.host,
+        httpUrl: config.unix ? `unix:${config.unix}` : `http://${config.host}:${actualPort}`,
+        startedAt: Date.now()
+      });
+      let shuttingDown = false;
+      const shutdown = async () => {
+        if (shuttingDown) return;
+        shuttingDown = true;
+        server.stop(true);
+        await sessionManager.destroyAll();
+        await removeServerLock();
+        process.exit(0);
+      };
+      process.once("SIGINT", () => void shutdown());
+      process.once("SIGTERM", () => void shutdown());
+    });
+  }
+  if (feature("SSH_REMOTE")) {
+    program.command("ssh <host> [dir]").description("Run memCode on a remote host over SSH. Deploys the binary and tunnels API auth back through your local machine \u2014 no remote setup needed.").option("--permission-mode <mode>", "Permission mode for the remote session").option("--dangerously-skip-permissions", "Skip all permission prompts on the remote (dangerous)").option("--local", "e2e test mode \u2014 spawn the child CLI locally (skip ssh/deploy). Exercises the auth proxy and unix-socket plumbing without a remote host.").action(async () => {
+      process.stderr.write("Usage: memcode ssh <user@host | ssh-config-alias> [dir]\n\nRuns memCode on a remote Linux host. You don't need to install\nanything on the remote or run `memcode auth login` there \u2014 the binary is\ndeployed over SSH and API auth tunnels back through your local machine.\n");
+      process.exit(1);
+    });
+  }
+  if (feature("DIRECT_CONNECT")) {
+    program.command("open <cc-url>").description("Connect to a memCode server (internal \u2014 use cc:// URLs)").option("-p, --print [prompt]", "Print mode (headless)").option("--output-format <format>", "Output format: text, json, stream-json", "text").action(async (ccUrl, opts) => {
+      const {
+        parseConnectUrl
+      } = await import("./server/parseConnectUrl.js");
+      const {
+        serverUrl,
+        authToken
+      } = parseConnectUrl(ccUrl);
+      let connectConfig;
+      try {
+        const session = await createDirectConnectSession({
+          serverUrl,
+          authToken,
+          cwd: getOriginalCwd(),
+          dangerouslySkipPermissions: _pendingConnect?.dangerouslySkipPermissions
+        });
+        if (session.workDir) {
+          setOriginalCwd(session.workDir);
+          setCwdState(session.workDir);
+        }
+        setDirectConnectServerUrl(serverUrl);
+        connectConfig = session.config;
+      } catch (err) {
+        console.error(err instanceof DirectConnectError ? err.message : String(err));
+        process.exit(1);
+      }
+      const {
+        runConnectHeadless
+      } = await import("./server/connectHeadless.js");
+      const prompt = typeof opts.print === "string" ? opts.print : "";
+      const interactive = opts.print === true;
+      await runConnectHeadless(connectConfig, prompt, opts.outputFormat, interactive);
+    });
+  }
+  const auth = program.command("auth").description("Manage authentication").configureHelp(createSortedHelpConfig());
+  auth.command("login", { hidden: !isUpstreamFeatureEnabled() }).description("Sign in to an upstream account").option("--email <email>", "Pre-populate email address on the login page").option("--sso", "Force SSO login flow").option("--console", "Use Console API usage billing instead of subscription auth").option("--claudeai", "Use subscription auth (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", { hidden: !isUpstreamFeatureEnabled() }).description("Log out from an upstream 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 memCode 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 memCode 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 (~/.memcode/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", { hidden: true }).description("Set up a long-lived authentication token").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 (feature("TRANSCRIPT_CLASSIFIER")) {
+    if (getAutoModeEnabledStateIfCached() !== "disabled") {
+      const autoModeCmd = program.command("auto-mode").description("Inspect auto mode classifier configuration");
+      autoModeCmd.command("defaults").description("Print the default auto mode environment, allow, and deny rules as JSON").action(async () => {
+        const {
+          autoModeDefaultsHandler
+        } = await import("./cli/handlers/autoMode.js");
+        autoModeDefaultsHandler();
+        process.exit(0);
+      });
+      autoModeCmd.command("config").description("Print the effective auto mode config as JSON: your settings where set, defaults otherwise").action(async () => {
+        const {
+          autoModeConfigHandler
+        } = await import("./cli/handlers/autoMode.js");
+        autoModeConfigHandler();
+        process.exit(0);
+      });
+      autoModeCmd.command("critique").description("Get AI feedback on your custom auto mode rules").option("--model <model>", "Override which model is used").action(async (options) => {
+        const {
+          autoModeCritiqueHandler
+        } = await import("./cli/handlers/autoMode.js");
+        await autoModeCritiqueHandler(options);
+        process.exit();
+      });
+    }
+  }
+  if (isBridgeModeAvailable()) {
+    program.command("remote-control", {
+      hidden: true
+    }).alias("rc").description("Connect your local environment for remote-control sessions via memCode").action(async () => {
+      const {
+        bridgeMain
+      } = await import("./bridge/bridgeMain.js");
+      await bridgeMain(process.argv.slice(3));
+    });
+  }
+  if (feature("KAIROS")) {
+    program.command("assistant [sessionId]").description("Attach the REPL as a client to a running bridge session. Discovers sessions via API if no sessionId given.").action(() => {
+      process.stderr.write("Usage: memcode assistant [sessionId]\n\nAttach the REPL as a viewer client to a running bridge session.\nOmit sessionId to discover and pick from available sessions.\n");
+      process.exit(1);
+    });
+  }
+  program.command("doctor").description("Check the health of your memCode 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
+    } = await import("./cli/handlers/util.js");
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+      await doctorHandler({
+        render() {
+        },
+        unmount() {
+        }
+      });
+      return;
+    }
+    const {
+      createRoot
+    } = await 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("src/cli/update.js");
+    await update();
+  });
+  if (false) {
+    program.command("up").description('[ANT-ONLY] Initialize or upgrade the local dev environment using the "# claude up" section of the nearest XCODE.md').action(async () => {
+      const {
+        up
+      } = await null;
+      await up();
+    });
+  }
+  if (false) {
+    program.command("rollback [target]").description("[ANT-ONLY] Roll back to a previous release\n\nExamples:\n  memcode rollback                                    Go 1 version back from current\n  memcode rollback 3                                  Go 3 versions back from current\n  memcode rollback 2.0.73-dev.20251217.t190658        Roll back to a specific version").option("-l, --list", "List recent published versions with ages").option("--dry-run", "Show what would be installed without installing").option("--safe", "Roll back to the server-pinned safe version (set by oncall during incidents)").action(async (target, options) => {
+      const {
+        rollback
+      } = await null;
+      await rollback(target, options);
+    });
+  }
+  program.command("install [target]").description("Install memCode 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) {
+    const validateLogId = (value) => {
+      const maybeSessionId = validateUuid(value);
+      if (maybeSessionId) return maybeSessionId;
+      return Number(value);
+    };
+    program.command("log").description("[ANT-ONLY] Manage conversation logs.").argument("[number|sessionId]", "A number (0, 1, 2, etc.) to display a specific log, or the sesssion ID (uuid) of a log", validateLogId).action(async (logId) => {
+      const {
+        logHandler
+      } = await null;
+      await logHandler(logId);
+    });
+    program.command("error").description("[ANT-ONLY] View error logs. Optionally provide a number (0, -1, -2, etc.) to display a specific log.").argument("[number]", "A number (0, 1, 2, etc.) to display a specific log", parseInt).action(async (number) => {
+      const {
+        errorHandler
+      } = await null;
+      await errorHandler(number);
+    });
+    program.command("export").description("[ANT-ONLY] Export a conversation to a text file.").usage("<source> <outputFile>").argument("<source>", "Session ID, log index (0, 1, 2...), or path to a .json/.jsonl log file").argument("<outputFile>", "Output file path for the exported text").addHelpText("after", `
+Examples:
+  $ claude export 0 conversation.txt                Export conversation at log index 0
+  $ claude export <uuid> conversation.txt           Export conversation by session ID
+  $ claude export input.json output.txt             Render JSON log file to text
+  $ claude export <uuid>.jsonl output.txt           Render JSONL session file to text`).action(async (source, outputFile) => {
+      const {
+        exportHandler
+      } = await null;
+      await exportHandler(source, outputFile);
+    });
+    if (false) {
+      const taskCmd = program.command("task").description("[ANT-ONLY] Manage task list tasks");
+      taskCmd.command("create <subject>").description("Create a new task").option("-d, --description <text>", "Task description").option("-l, --list <id>", 'Task list ID (defaults to "tasklist")').action(async (subject, opts) => {
+        const {
+          taskCreateHandler
+        } = await null;
+        await taskCreateHandler(subject, opts);
+      });
+      taskCmd.command("list").description("List all tasks").option("-l, --list <id>", 'Task list ID (defaults to "tasklist")').option("--pending", "Show only pending tasks").option("--json", "Output as JSON").action(async (opts) => {
+        const {
+          taskListHandler
+        } = await null;
+        await taskListHandler(opts);
+      });
+      taskCmd.command("get <id>").description("Get details of a task").option("-l, --list <id>", 'Task list ID (defaults to "tasklist")').action(async (id, opts) => {
+        const {
+          taskGetHandler
+        } = await null;
+        await taskGetHandler(id, opts);
+      });
+      taskCmd.command("update <id>").description("Update a task").option("-l, --list <id>", 'Task list ID (defaults to "tasklist")').option("-s, --status <status>", `Set status (${TASK_STATUSES.join(", ")})`).option("--subject <text>", "Update subject").option("-d, --description <text>", "Update description").option("--owner <agentId>", "Set owner").option("--clear-owner", "Clear owner").action(async (id, opts) => {
+        const {
+          taskUpdateHandler
+        } = await null;
+        await taskUpdateHandler(id, opts);
+      });
+      taskCmd.command("dir").description("Show the tasks directory path").option("-l, --list <id>", 'Task list ID (defaults to "tasklist")').action(async (opts) => {
+        const {
+          taskDirHandler
+        } = await null;
+        await taskDirHandler(opts);
+      });
+    }
+    program.command("completion <shell>", {
+      hidden: true
+    }).description("Generate shell completion script (bash, zsh, or fish)").option("--output <file>", "Write completion script directly to a file instead of stdout").action(async (shell, opts) => {
+      const {
+        completionHandler
+      } = await null;
+      await completionHandler(shell, opts, program);
+    });
+  }
+  program.command("completion <shell>").description("Generate shell completion script (bash, zsh, or fish)").option("--output <file>", "Write completion script directly to a file instead of stdout").action(async (shell, opts) => {
+    const commands = program.commands.map((command) => command.name()).sort().join(" ");
+    let script;
+    switch (shell) {
+      case "bash":
+        script = `# bash completion for memcode
+_memcode_completions() {
+  local cur
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  if [[ \${COMP_CWORD} -eq 1 ]]; then
+    COMPREPLY=( $(compgen -W "${commands}" -- "$cur") )
+  fi
+}
+complete -F _memcode_completions memcode
+`;
+        break;
+      case "zsh":
+        script = `#compdef memcode
+_memcode() {
+  local -a commands
+  commands=(${commands})
+  _describe 'command' commands
+}
+compdef _memcode memcode
+`;
+        break;
+      case "fish":
+        script = `# fish completion for memcode
+complete -c memcode -f -a "${commands}"
+`;
+        break;
+      default:
+        process.stderr.write("Unsupported shell. Expected one of: bash, zsh, fish\n");
+        process.exit(1);
+    }
+    if (opts.output) {
+      writeFileSync(opts.output, script);
+    } else {
+      process.stdout.write(script);
+    }
+    process.exit(0);
+  });
+  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() || void 0,
+      is_coordinator: feature("COORDINATOR_MODE") && coordinatorModeModule?.isCoordinatorMode() ? true : void 0,
+      ...assistantActivationPath && {
+        assistantActivationPath
+      },
+      autoUpdatesChannel: getInitialSettings().autoUpdatesChannel ?? "latest",
+      ...false ? (() => {
+        const cwd = getCwd();
+        const gitRoot = findGitRoot(cwd);
+        const rp = gitRoot ? relative(gitRoot, cwd) || "." : void 0;
+        return rp ? {
+          relativeProjectPath: rp
+        } : {};
+      })() : {}
+    });
+  } catch (error) {
+    logError(error);
+  }
+}
+function maybeActivateProactive(options) {
+  if ((feature("PROACTIVE") || feature("KAIROS")) && (options.proactive || isEnvTruthy(process.env.XCODE_PROACTIVE))) {
+    const proactiveModule = require("./proactive/index.js");
+    if (!proactiveModule.isProactiveActive()) {
+      proactiveModule.activateProactive("command");
+    }
+  }
+}
+function maybeActivateBrief(options) {
+  if (!(feature("KAIROS") || feature("KAIROS_BRIEF"))) return;
+  const briefFlag = options.brief;
+  const briefEnv = isEnvTruthy(process.env.XCODE_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 : void 0;
+  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 : void 0,
+    agentName: typeof opts.agentName === "string" ? opts.agentName : void 0,
+    teamName: typeof opts.teamName === "string" ? opts.teamName : void 0,
+    agentColor: typeof opts.agentColor === "string" ? opts.agentColor : void 0,
+    planModeRequired: typeof opts.planModeRequired === "boolean" ? opts.planModeRequired : void 0,
+    parentSessionId: typeof opts.parentSessionId === "string" ? opts.parentSessionId : void 0,
+    teammateMode: teammateMode === "auto" || teammateMode === "tmux" || teammateMode === "in-process" ? teammateMode : void 0,
+    agentType: typeof opts.agentType === "string" ? opts.agentType : void 0
+  };
+}
+export {
+  main,
+  startDeferredPrefetches
+};