lcclaude 1.0.0

package/dist/src/cli/print.js

@@ -0,0 +1,3112 @@
+import { readFile, stat } from "fs/promises";
+import { dirname } from "path";
+import {
+  downloadUserSettings,
+  redownloadUserSettings
+} from "../services/settingsSync/index.js";
+import { waitForRemoteManagedSettingsToLoad } from "../services/remoteManagedSettings/index.js";
+import { StructuredIO } from "./structuredIO.js";
+import { RemoteIO } from "./remoteIO.js";
+import {
+  formatDescriptionWithSource,
+  getCommandName
+} from "../commands.js";
+import { createStreamlinedTransformer } from "../utils/streamlinedTransform.js";
+import { installStreamJsonStdoutGuard } from "../utils/streamJsonStdoutGuard.js";
+import { assembleToolPool, filterToolsByDenyRules } from "../tools.js";
+import uniqBy from "lodash-es/uniqBy.js";
+import { uniq } from "../utils/array.js";
+import { mergeAndFilterTools } from "../utils/toolPool.js";
+import {
+  logEvent
+} from "../services/analytics/index.js";
+import { getFeatureValue_CACHED_MAY_BE_STALE } from "../services/analytics/growthbook.js";
+import { logForDebugging } from "../utils/debug.js";
+import {
+  logForDiagnosticsNoPII,
+  withDiagnosticsTiming
+} from "../utils/diagLogs.js";
+import { toolMatchesName } from "../Tool.js";
+import {
+  isBuiltInAgent,
+  parseAgentsFromJson
+} from "../tools/AgentTool/loadAgentsDir.js";
+import {
+  dequeue,
+  dequeueAllMatching,
+  enqueue,
+  hasCommandsInQueue,
+  peek,
+  subscribeToCommandQueue,
+  getCommandsByMaxPriority
+} from "../utils/messageQueueManager.js";
+import { notifyCommandLifecycle } from "../utils/commandLifecycle.js";
+import {
+  getSessionState,
+  notifySessionStateChanged,
+  notifySessionMetadataChanged,
+  setPermissionModeChangedListener
+} from "../utils/sessionState.js";
+import { externalMetadataToAppState } from "../state/onChangeAppState.js";
+import { getInMemoryErrors, logError, logMCPDebug } from "../utils/log.js";
+import {
+  writeToStdout,
+  registerProcessOutputErrorHandlers
+} from "../utils/process.js";
+import { EMPTY_USAGE } from "../services/api/logging.js";
+import {
+  loadConversationForResume
+} from "../utils/conversationRecovery.js";
+import {
+  ChannelMessageNotificationSchema,
+  gateChannelServer,
+  wrapChannelMessage,
+  findChannelEntry
+} from "../services/mcp/channelNotification.js";
+import {
+  isChannelAllowlisted,
+  isChannelsEnabled
+} from "../services/mcp/channelAllowlist.js";
+import { parsePluginIdentifier } from "../utils/plugins/pluginIdentifier.js";
+import { validateUuid } from "../utils/uuid.js";
+import { fromArray } from "../utils/generators.js";
+import { ask } from "../QueryEngine.js";
+import {
+  createFileStateCacheWithSizeLimit,
+  mergeFileStateCaches,
+  READ_FILE_STATE_CACHE_SIZE
+} from "../utils/fileStateCache.js";
+import { expandPath } from "../utils/path.js";
+import { extractReadFilesFromMessages } from "../utils/queryHelpers.js";
+import { registerHookEventHandler } from "../utils/hooks/hookEvents.js";
+import { executeFilePersistence } from "../utils/filePersistence/filePersistence.js";
+import { finalizePendingAsyncHooks } from "../utils/hooks/AsyncHookRegistry.js";
+import {
+  gracefulShutdown,
+  gracefulShutdownSync,
+  isShuttingDown
+} from "../utils/gracefulShutdown.js";
+import { registerCleanup } from "../utils/cleanupRegistry.js";
+import { createIdleTimeoutManager } from "../utils/idleTimeout.js";
+import { cwd } from "process";
+import { getCwd } from "../utils/cwd.js";
+import omit from "lodash-es/omit.js";
+import reject from "lodash-es/reject.js";
+import { isPolicyAllowed } from "../services/policyLimits/index.js";
+import { getRemoteSessionUrl } from "../constants/product.js";
+import { buildBridgeConnectUrl } from "../bridge/bridgeStatusUtil.js";
+import { extractInboundMessageFields } from "../bridge/inboundMessages.js";
+import { resolveAndPrepend } from "../bridge/inboundAttachments.js";
+import { hasPermissionsToUseTool } from "../utils/permissions/permissions.js";
+import { safeParseJSON } from "../utils/json.js";
+import {
+  outputSchema as permissionToolOutputSchema,
+  permissionPromptToolResultToPermissionDecision
+} from "../utils/permissions/PermissionPromptToolResultSchema.js";
+import { createAbortController } from "../utils/abortController.js";
+import { createCombinedAbortSignal } from "../utils/combinedAbortSignal.js";
+import { generateSessionTitle } from "../utils/sessionTitle.js";
+import { buildSideQuestionFallbackParams } from "../utils/queryContext.js";
+import { runSideQuestion } from "../utils/sideQuestion.js";
+import {
+  processSessionStartHooks,
+  processSetupHooks,
+  takeInitialUserMessage
+} from "../utils/sessionStart.js";
+import {
+  DEFAULT_OUTPUT_STYLE_NAME,
+  getAllOutputStyles
+} from "../constants/outputStyles.js";
+import { TEAMMATE_MESSAGE_TAG, TICK_TAG } from "../constants/xml.js";
+import {
+  getSettings_DEPRECATED,
+  getSettingsWithSources
+} from "../utils/settings/settings.js";
+import { settingsChangeDetector } from "../utils/settings/changeDetector.js";
+import { applySettingsChange } from "../utils/settings/applySettingsChange.js";
+import {
+  isFastModeAvailable,
+  isFastModeEnabled,
+  isFastModeSupportedByModel,
+  getFastModeState
+} from "../utils/fastMode.js";
+import {
+  isAutoModeGateEnabled,
+  getAutoModeUnavailableNotification,
+  getAutoModeUnavailableReason,
+  isBypassPermissionsModeDisabled,
+  transitionPermissionMode
+} from "../utils/permissions/permissionSetup.js";
+import {
+  tryGenerateSuggestion,
+  logSuggestionOutcome,
+  logSuggestionSuppressed
+} from "../services/PromptSuggestion/promptSuggestion.js";
+import { getLastCacheSafeParams } from "../utils/forkedAgent.js";
+import { getAccountInformation } from "../utils/auth.js";
+import { OAuthService } from "../services/oauth/index.js";
+import { installOAuthTokens } from "./handlers/auth.js";
+import { getAPIProvider } from "../utils/model/providers.js";
+import { AwsAuthStatusManager } from "../utils/awsAuthStatusManager.js";
+import {
+  registerHookCallbacks,
+  setInitJsonSchema,
+  getInitJsonSchema,
+  setSdkAgentProgressSummariesEnabled
+} from "../bootstrap/state.js";
+import { createSyntheticOutputTool } from "../tools/SyntheticOutputTool/SyntheticOutputTool.js";
+import { parseSessionIdentifier } from "../utils/sessionUrl.js";
+import {
+  hydrateRemoteSession,
+  hydrateFromCCRv2InternalEvents,
+  resetSessionFilePointer,
+  doesMessageExistInSession,
+  findUnresolvedToolUse,
+  recordAttributionSnapshot,
+  saveAgentSetting,
+  saveMode,
+  saveAiGeneratedTitle,
+  restoreSessionMetadata
+} from "../utils/sessionStorage.js";
+import { incrementPromptCount } from "../utils/commitAttribution.js";
+import {
+  setupSdkMcpClients,
+  connectToServer,
+  clearServerCache,
+  fetchToolsForClient,
+  areMcpConfigsEqual,
+  reconnectMcpServerImpl
+} from "../services/mcp/client.js";
+import {
+  filterMcpServersByPolicy,
+  getMcpConfigByName,
+  isMcpServerDisabled,
+  setMcpServerEnabled
+} from "../services/mcp/config.js";
+import {
+  performMCPOAuthFlow,
+  revokeServerTokens
+} from "../services/mcp/auth.js";
+import {
+  runElicitationHooks,
+  runElicitationResultHooks
+} from "../services/mcp/elicitationHandler.js";
+import { executeNotificationHooks } from "../utils/hooks.js";
+import {
+  ElicitRequestSchema,
+  ElicitationCompleteNotificationSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { getMcpPrefix } from "../services/mcp/mcpStringUtils.js";
+import {
+  commandBelongsToServer,
+  filterToolsByServer
+} from "../services/mcp/utils.js";
+import { setupVscodeSdkMcp } from "../services/mcp/vscodeSdkMcp.js";
+import { getAllMcpConfigs } from "../services/mcp/config.js";
+import {
+  isQualifiedForGrove,
+  checkGroveForNonInteractive
+} from "../services/api/grove.js";
+import {
+  toInternalMessages,
+  toSDKRateLimitInfo
+} from "../utils/messages/mappers.js";
+import { createModelSwitchBreadcrumbs } from "../utils/messages.js";
+import { collectContextData } from "../commands/context/context-noninteractive.js";
+import { LOCAL_COMMAND_STDOUT_TAG } from "../constants/xml.js";
+import {
+  statusListeners
+} from "../services/claudeAiLimits.js";
+import {
+  getDefaultMainLoopModel,
+  getMainLoopModel,
+  modelDisplayString,
+  parseUserSpecifiedModel
+} from "../utils/model/model.js";
+import { getModelOptions } from "../utils/model/modelOptions.js";
+import {
+  modelSupportsEffort,
+  modelSupportsMaxEffort,
+  EFFORT_LEVELS,
+  resolveAppliedEffort
+} from "../utils/effort.js";
+import { modelSupportsAdaptiveThinking } from "../utils/thinking.js";
+import { modelSupportsAutoMode } from "../utils/betas.js";
+import { ensureModelStringsInitialized } from "../utils/model/modelStrings.js";
+import {
+  getSessionId,
+  setMainLoopModelOverride,
+  setMainThreadAgentType,
+  switchSession,
+  isSessionPersistenceDisabled,
+  getIsRemoteMode,
+  getFlagSettingsInline,
+  setFlagSettingsInline,
+  getMainThreadAgentType,
+  getAllowedChannels,
+  setAllowedChannels
+} from "../bootstrap/state.js";
+import { runWithWorkload, WORKLOAD_CRON } from "../utils/workloadContext.js";
+import { randomUUID } from "crypto";
+import {
+  fileHistoryRewind,
+  fileHistoryCanRestore,
+  fileHistoryEnabled,
+  fileHistoryGetDiffStats
+} from "../utils/fileHistory.js";
+import {
+  restoreAgentFromSession,
+  restoreSessionStateFromLog
+} from "../utils/sessionRestore.js";
+import { SandboxManager } from "../utils/sandbox/sandbox-adapter.js";
+import {
+  headlessProfilerStartTurn,
+  headlessProfilerCheckpoint,
+  logHeadlessProfilerTurn
+} from "../utils/headlessProfiler.js";
+import {
+  startQueryProfile,
+  logQueryProfileReport
+} from "../utils/queryProfiler.js";
+import { asSessionId } from "../types/ids.js";
+import { jsonStringify } from "../utils/slowOperations.js";
+import { skillChangeDetector } from "../utils/skills/skillChangeDetector.js";
+import { getCommands, clearCommandsCache } from "../commands.js";
+import {
+  isBareMode,
+  isEnvTruthy,
+  isEnvDefinedFalsy
+} from "../utils/envUtils.js";
+import { installPluginsForHeadless } from "../utils/plugins/headlessPluginInstall.js";
+import { refreshActivePlugins } from "../utils/plugins/refresh.js";
+import { loadAllPluginsCacheOnly } from "../utils/plugins/pluginLoader.js";
+import {
+  isTeamLead,
+  hasActiveInProcessTeammates,
+  hasWorkingInProcessTeammates,
+  waitForTeammatesToBecomeIdle
+} from "../utils/teammate.js";
+import {
+  readUnreadMessages,
+  markMessagesAsRead,
+  isShutdownApproved
+} from "../utils/teammateMailbox.js";
+import { removeTeammateFromTeamFile } from "../utils/swarm/teamHelpers.js";
+import { unassignTeammateTasks } from "../utils/tasks.js";
+import { getRunningTasks } from "../utils/task/framework.js";
+import { isBackgroundTask } from "../tasks/types.js";
+import { stopTask } from "../tasks/stopTask.js";
+import { drainSdkEvents } from "../utils/sdkEventQueue.js";
+import { initializeGrowthBook } from "../services/analytics/growthbook.js";
+import { errorMessage, toError } from "../utils/errors.js";
+import { sleep } from "../utils/sleep.js";
+import { isExtractModeActive } from "../memdir/paths.js";
+const coordinatorModeModule = null;
+const proactiveModule = null;
+const cronSchedulerModule = null;
+const cronJitterConfigModule = null;
+const cronGate = null;
+const extractMemoriesModule = null;
+const SHUTDOWN_TEAM_PROMPT = `<system-reminder>
+You are running in non-interactive mode and cannot return a response to the user until your team is shut down.
+
+You MUST shut down your team before preparing your final response:
+1. Use requestShutdown to ask each team member to shut down gracefully
+2. Wait for shutdown approvals
+3. Use the cleanup operation to clean up the team
+4. Only then provide your final response to the user
+
+The user cannot receive your response until the team is completely shut down.
+</system-reminder>
+
+Shut down your team and prepare your final response for the user.`;
+const MAX_RECEIVED_UUIDS = 1e4;
+const receivedMessageUuids = new Set;
+const receivedMessageUuidsOrder = [];
+function trackReceivedMessageUuid(uuid) {
+  if (receivedMessageUuids.has(uuid)) {
+    return false;
+  }
+  receivedMessageUuids.add(uuid);
+  receivedMessageUuidsOrder.push(uuid);
+  if (receivedMessageUuidsOrder.length > MAX_RECEIVED_UUIDS) {
+    const toEvict = receivedMessageUuidsOrder.splice(0, receivedMessageUuidsOrder.length - MAX_RECEIVED_UUIDS);
+    for (const old of toEvict) {
+      receivedMessageUuids.delete(old);
+    }
+  }
+  return true;
+}
+function toBlocks(v) {
+  return typeof v === "string" ? [{ type: "text", text: v }] : v;
+}
+export function joinPromptValues(values) {
+  if (values.length === 1)
+    return values[0];
+  if (values.every((v) => typeof v === "string")) {
+    return values.join(`
+`);
+  }
+  return values.flatMap(toBlocks);
+}
+export function canBatchWith(head, next) {
+  return next !== undefined && next.mode === "prompt" && next.workload === head.workload && next.isMeta === head.isMeta;
+}
+export async function runHeadless(inputPrompt, getAppState, setAppState, commands, tools, sdkMcpConfigs, agents, options) {
+  if (process.env.USER_TYPE === "ant" && isEnvTruthy(process.env.CLAUDE_CODE_EXIT_AFTER_FIRST_RENDER)) {
+    process.stderr.write(`
+Startup time: ${Math.round(process.uptime() * 1000)}ms
+`);
+    process.exit(0);
+  }
+  if (false) {}
+  settingsChangeDetector.subscribe((source) => {
+    applySettingsChange(source, setAppState);
+    if (isFastModeEnabled()) {
+      setAppState((prev) => {
+        const s = prev.settings;
+        const fastMode = s.fastMode === true && !s.fastModePerSessionOptIn;
+        return { ...prev, fastMode };
+      });
+    }
+  });
+  if (false) {}
+  if (typeof Bun !== "undefined") {
+    const gcTimer = setInterval(Bun.gc, 1000);
+    gcTimer.unref();
+  }
+  headlessProfilerStartTurn();
+  headlessProfilerCheckpoint("runHeadless_entry");
+  if (await isQualifiedForGrove()) {
+    await checkGroveForNonInteractive();
+  }
+  headlessProfilerCheckpoint("after_grove_check");
+  initializeGrowthBook();
+  if (options.resumeSessionAt && !options.resume) {
+    process.stderr.write(`Error: --resume-session-at requires --resume
+`);
+    gracefulShutdownSync(1);
+    return;
+  }
+  if (options.rewindFiles && !options.resume) {
+    process.stderr.write(`Error: --rewind-files requires --resume
+`);
+    gracefulShutdownSync(1);
+    return;
+  }
+  if (options.rewindFiles && inputPrompt) {
+    process.stderr.write(`Error: --rewind-files is a standalone operation and cannot be used with a prompt
+`);
+    gracefulShutdownSync(1);
+    return;
+  }
+  const structuredIO = getStructuredIO(inputPrompt, options);
+  if (options.outputFormat === "stream-json") {
+    installStreamJsonStdoutGuard();
+  }
+  const sandboxUnavailableReason = SandboxManager.getSandboxUnavailableReason();
+  if (sandboxUnavailableReason) {
+    if (SandboxManager.isSandboxRequired()) {
+      process.stderr.write(`
+Error: sandbox required but unavailable: ${sandboxUnavailableReason}
+` + `  sandbox.failIfUnavailable is set — refusing to start without a working sandbox.
+
+`);
+      gracefulShutdownSync(1);
+      return;
+    }
+    process.stderr.write(`
+⚠ Sandbox disabled: ${sandboxUnavailableReason}
+` + `  Commands will run WITHOUT sandboxing. Network and filesystem restrictions will NOT be enforced.
+
+`);
+  } else if (SandboxManager.isSandboxingEnabled()) {
+    try {
+      await SandboxManager.initialize(structuredIO.createSandboxAskCallback());
+    } catch (err) {
+      process.stderr.write(`
+❌ Sandbox Error: ${errorMessage(err)}
+`);
+      gracefulShutdownSync(1, "other");
+      return;
+    }
+  }
+  if (options.outputFormat === "stream-json" && options.verbose) {
+    registerHookEventHandler((event) => {
+      const message = (() => {
+        switch (event.type) {
+          case "started":
+            return {
+              type: "system",
+              subtype: "hook_started",
+              hook_id: event.hookId,
+              hook_name: event.hookName,
+              hook_event: event.hookEvent,
+              uuid: randomUUID(),
+              session_id: getSessionId()
+            };
+          case "progress":
+            return {
+              type: "system",
+              subtype: "hook_progress",
+              hook_id: event.hookId,
+              hook_name: event.hookName,
+              hook_event: event.hookEvent,
+              stdout: event.stdout,
+              stderr: event.stderr,
+              output: event.output,
+              uuid: randomUUID(),
+              session_id: getSessionId()
+            };
+          case "response":
+            return {
+              type: "system",
+              subtype: "hook_response",
+              hook_id: event.hookId,
+              hook_name: event.hookName,
+              hook_event: event.hookEvent,
+              output: event.output,
+              stdout: event.stdout,
+              stderr: event.stderr,
+              exit_code: event.exitCode,
+              outcome: event.outcome,
+              uuid: randomUUID(),
+              session_id: getSessionId()
+            };
+        }
+      })();
+      structuredIO.write(message);
+    });
+  }
+  if (options.setupTrigger) {
+    await processSetupHooks(options.setupTrigger);
+  }
+  headlessProfilerCheckpoint("before_loadInitialMessages");
+  const appState = getAppState();
+  const {
+    messages: initialMessages,
+    turnInterruptionState,
+    agentSetting: resumedAgentSetting
+  } = await loadInitialMessages(setAppState, {
+    continue: options.continue,
+    teleport: options.teleport,
+    resume: options.resume,
+    resumeSessionAt: options.resumeSessionAt,
+    forkSession: options.forkSession,
+    outputFormat: options.outputFormat,
+    sessionStartHooksPromise: options.sessionStartHooksPromise,
+    restoredWorkerState: structuredIO.restoredWorkerState
+  });
+  const hookInitialUserMessage = takeInitialUserMessage();
+  if (hookInitialUserMessage) {
+    structuredIO.prependUserMessage(hookInitialUserMessage);
+  }
+  if (!options.agent && !getMainThreadAgentType() && resumedAgentSetting) {
+    const { agentDefinition: restoredAgent } = restoreAgentFromSession(resumedAgentSetting, undefined, { activeAgents: agents, allAgents: agents });
+    if (restoredAgent) {
+      setAppState((prev) => ({ ...prev, agent: restoredAgent.agentType }));
+      if (!options.systemPrompt && !isBuiltInAgent(restoredAgent)) {
+        const agentSystemPrompt = restoredAgent.getSystemPrompt();
+        if (agentSystemPrompt) {
+          options.systemPrompt = agentSystemPrompt;
+        }
+      }
+      saveAgentSetting(restoredAgent.agentType);
+    }
+  }
+  if (initialMessages.length === 0 && process.exitCode !== undefined) {
+    return;
+  }
+  if (options.rewindFiles) {
+    const targetMessage = initialMessages.find((m) => m.uuid === options.rewindFiles);
+    if (!targetMessage || targetMessage.type !== "user") {
+      process.stderr.write(`Error: --rewind-files requires a user message UUID, but ${options.rewindFiles} is not a user message in this session
+`);
+      gracefulShutdownSync(1);
+      return;
+    }
+    const currentAppState = getAppState();
+    const result = await handleRewindFiles(options.rewindFiles, currentAppState, setAppState, false);
+    if (!result.canRewind) {
+      process.stderr.write(`Error: ${result.error || "Unexpected error"}
+`);
+      gracefulShutdownSync(1);
+      return;
+    }
+    process.stdout.write(`Files rewound to state at message ${options.rewindFiles}
+`);
+    gracefulShutdownSync(0);
+    return;
+  }
+  const hasValidResumeSessionId = typeof options.resume === "string" && (Boolean(validateUuid(options.resume)) || options.resume.endsWith(".jsonl"));
+  const isUsingSdkUrl = Boolean(options.sdkUrl);
+  if (!inputPrompt && !hasValidResumeSessionId && !isUsingSdkUrl) {
+    process.stderr.write(`Error: Input must be provided either through stdin or as a prompt argument when using --print
+`);
+    gracefulShutdownSync(1);
+    return;
+  }
+  if (options.outputFormat === "stream-json" && !options.verbose) {
+    process.stderr.write(`Error: When using --print, --output-format=stream-json requires --verbose
+`);
+    gracefulShutdownSync(1);
+    return;
+  }
+  const allowedMcpTools = filterToolsByDenyRules(appState.mcp.tools, appState.toolPermissionContext);
+  let filteredTools = [...tools, ...allowedMcpTools];
+  const effectivePermissionPromptToolName = options.sdkUrl ? "stdio" : options.permissionPromptToolName;
+  const onPermissionPrompt = (details) => {
+    if (false) {}
+    notifySessionStateChanged("requires_action", details);
+  };
+  const canUseTool = getCanUseToolFn(effectivePermissionPromptToolName, structuredIO, () => getAppState().mcp.tools, onPermissionPrompt);
+  if (options.permissionPromptToolName) {
+    filteredTools = filteredTools.filter((tool) => !toolMatchesName(tool, options.permissionPromptToolName));
+  }
+  registerProcessOutputErrorHandlers();
+  headlessProfilerCheckpoint("after_loadInitialMessages");
+  await ensureModelStringsInitialized();
+  headlessProfilerCheckpoint("after_modelStrings");
+  const needsFullArray = options.outputFormat === "json" && options.verbose;
+  const messages = [];
+  let lastMessage;
+  const transformToStreamlined = null;
+  headlessProfilerCheckpoint("before_runHeadlessStreaming");
+  for await (const message of runHeadlessStreaming(structuredIO, appState.mcp.clients, [...commands, ...appState.mcp.commands], filteredTools, initialMessages, canUseTool, sdkMcpConfigs, getAppState, setAppState, agents, options, turnInterruptionState)) {
+    if (transformToStreamlined) {
+      const transformed = transformToStreamlined(message);
+      if (transformed) {
+        await structuredIO.write(transformed);
+      }
+    } else if (options.outputFormat === "stream-json" && options.verbose) {
+      await structuredIO.write(message);
+    }
+    if (message.type !== "control_response" && message.type !== "control_request" && message.type !== "control_cancel_request" && !(message.type === "system" && (message.subtype === "session_state_changed" || message.subtype === "task_notification" || message.subtype === "task_started" || message.subtype === "task_progress" || message.subtype === "post_turn_summary")) && message.type !== "stream_event" && message.type !== "keep_alive" && message.type !== "streamlined_text" && message.type !== "streamlined_tool_use_summary" && message.type !== "prompt_suggestion") {
+      if (needsFullArray) {
+        messages.push(message);
+      }
+      lastMessage = message;
+    }
+  }
+  switch (options.outputFormat) {
+    case "json":
+      if (!lastMessage || lastMessage.type !== "result") {
+        throw new Error("No messages returned");
+      }
+      if (options.verbose) {
+        writeToStdout(jsonStringify(messages) + `
+`);
+        break;
+      }
+      writeToStdout(jsonStringify(lastMessage) + `
+`);
+      break;
+    case "stream-json":
+      break;
+    default:
+      if (!lastMessage || lastMessage.type !== "result") {
+        throw new Error("No messages returned");
+      }
+      switch (lastMessage.subtype) {
+        case "success":
+          writeToStdout(lastMessage.result.endsWith(`
+`) ? lastMessage.result : lastMessage.result + `
+`);
+          break;
+        case "error_during_execution":
+          writeToStdout(`Execution error`);
+          break;
+        case "error_max_turns":
+          writeToStdout(`Error: Reached max turns (${options.maxTurns})`);
+          break;
+        case "error_max_budget_usd":
+          writeToStdout(`Error: Exceeded USD budget (${options.maxBudgetUsd})`);
+          break;
+        case "error_max_structured_output_retries":
+          writeToStdout(`Error: Failed to provide valid structured output after maximum retries`);
+      }
+  }
+  logHeadlessProfilerTurn();
+  if (false) {}
+  gracefulShutdownSync(lastMessage?.type === "result" && lastMessage?.is_error ? 1 : 0);
+}
+function runHeadlessStreaming(structuredIO, mcpClients, commands, tools, initialMessages, canUseTool, sdkMcpConfigs, getAppState, setAppState, agents, options, turnInterruptionState) {
+  let running = false;
+  let runPhase;
+  let inputClosed = false;
+  let shutdownPromptInjected = false;
+  let heldBackResult = null;
+  let abortController;
+  const output = structuredIO.outbound;
+  const sigintHandler = () => {
+    logForDiagnosticsNoPII("info", "shutdown_signal", { signal: "SIGINT" });
+    if (abortController && !abortController.signal.aborted) {
+      abortController.abort();
+    }
+    gracefulShutdown(0);
+  };
+  process.on("SIGINT", sigintHandler);
+  registerCleanup(async () => {
+    const bg = {};
+    for (const t of getRunningTasks(getAppState())) {
+      if (isBackgroundTask(t))
+        bg[t.type] = (bg[t.type] ?? 0) + 1;
+    }
+    logForDiagnosticsNoPII("info", "run_state_at_shutdown", {
+      run_active: running,
+      run_phase: runPhase,
+      worker_status: getSessionState(),
+      internal_events_pending: structuredIO.internalEventsPending,
+      bg_tasks: bg
+    });
+  });
+  setPermissionModeChangedListener((newMode) => {
+    if (newMode === "default" || newMode === "acceptEdits" || newMode === "bypassPermissions" || newMode === "plan" || newMode === false || newMode === "dontAsk") {
+      output.enqueue({
+        type: "system",
+        subtype: "status",
+        status: null,
+        permissionMode: newMode,
+        uuid: randomUUID(),
+        session_id: getSessionId()
+      });
+    }
+  });
+  const suggestionState = {
+    abortController: null,
+    inflightPromise: null,
+    lastEmitted: null,
+    pendingSuggestion: null,
+    pendingLastEmittedEntry: null
+  };
+  let unsubscribeAuthStatus;
+  if (options.enableAuthStatus) {
+    const authStatusManager = AwsAuthStatusManager.getInstance();
+    unsubscribeAuthStatus = authStatusManager.subscribe((status) => {
+      output.enqueue({
+        type: "auth_status",
+        isAuthenticating: status.isAuthenticating,
+        output: status.output,
+        error: status.error,
+        uuid: randomUUID(),
+        session_id: getSessionId()
+      });
+    });
+  }
+  const rateLimitListener = (limits) => {
+    const rateLimitInfo = toSDKRateLimitInfo(limits);
+    if (rateLimitInfo) {
+      output.enqueue({
+        type: "rate_limit_event",
+        rate_limit_info: rateLimitInfo,
+        uuid: randomUUID(),
+        session_id: getSessionId()
+      });
+    }
+  };
+  statusListeners.add(rateLimitListener);
+  const mutableMessages = initialMessages;
+  let readFileState = extractReadFilesFromMessages(initialMessages, cwd(), READ_FILE_STATE_CACHE_SIZE);
+  const pendingSeeds = createFileStateCacheWithSizeLimit(READ_FILE_STATE_CACHE_SIZE);
+  const resumeInterruptedTurnEnv = process.env.CLAUDE_CODE_RESUME_INTERRUPTED_TURN;
+  if (turnInterruptionState && turnInterruptionState.kind !== "none" && resumeInterruptedTurnEnv) {
+    logForDebugging(`[print.ts] Auto-resuming interrupted turn (kind: ${turnInterruptionState.kind})`);
+    removeInterruptedMessage(mutableMessages, turnInterruptionState.message);
+    enqueue({
+      mode: "prompt",
+      value: turnInterruptionState.message.message.content,
+      uuid: randomUUID()
+    });
+  }
+  const modelOptions = getModelOptions();
+  const modelInfos = modelOptions.map((option) => {
+    const modelId = option.value === null ? "default" : option.value;
+    const resolvedModel = modelId === "default" ? getDefaultMainLoopModel() : parseUserSpecifiedModel(modelId);
+    const hasEffort = modelSupportsEffort(resolvedModel);
+    const hasAdaptiveThinking = modelSupportsAdaptiveThinking(resolvedModel);
+    const hasFastMode = isFastModeSupportedByModel(option.value);
+    const hasAutoMode = modelSupportsAutoMode(resolvedModel);
+    return {
+      value: modelId,
+      displayName: option.label,
+      description: option.description,
+      ...hasEffort && {
+        supportsEffort: true,
+        supportedEffortLevels: modelSupportsMaxEffort(resolvedModel) ? [...EFFORT_LEVELS] : EFFORT_LEVELS.filter((l) => l !== "max")
+      },
+      ...hasAdaptiveThinking && { supportsAdaptiveThinking: true },
+      ...hasFastMode && { supportsFastMode: true },
+      ...hasAutoMode && { supportsAutoMode: true }
+    };
+  });
+  let activeUserSpecifiedModel = options.userSpecifiedModel;
+  function injectModelSwitchBreadcrumbs(modelArg, resolvedModel) {
+    const breadcrumbs = createModelSwitchBreadcrumbs(modelArg, modelDisplayString(resolvedModel));
+    mutableMessages.push(...breadcrumbs);
+    for (const crumb of breadcrumbs) {
+      if (typeof crumb.message.content === "string" && crumb.message.content.includes(`<${LOCAL_COMMAND_STDOUT_TAG}>`)) {
+        output.enqueue({
+          type: "user",
+          message: crumb.message,
+          session_id: getSessionId(),
+          parent_tool_use_id: null,
+          uuid: crumb.uuid,
+          timestamp: crumb.timestamp,
+          isReplay: true
+        });
+      }
+    }
+  }
+  let sdkClients = [];
+  let sdkTools = [];
+  const elicitationRegistered = new Set;
+  function registerElicitationHandlers(clients) {
+    for (const connection of clients) {
+      if (connection.type !== "connected" || elicitationRegistered.has(connection.name)) {
+        continue;
+      }
+      if (connection.config.type === "sdk") {
+        continue;
+      }
+      const serverName = connection.name;
+      try {
+        connection.client.setRequestHandler(ElicitRequestSchema, async (request, extra) => {
+          logMCPDebug(serverName, `Elicitation request received in print mode: ${jsonStringify(request)}`);
+          const mode = request.params.mode === "url" ? "url" : "form";
+          logEvent("tengu_mcp_elicitation_shown", {
+            mode
+          });
+          const hookResponse = await runElicitationHooks(serverName, request.params, extra.signal);
+          if (hookResponse) {
+            logMCPDebug(serverName, `Elicitation resolved by hook: ${jsonStringify(hookResponse)}`);
+            logEvent("tengu_mcp_elicitation_response", {
+              mode,
+              action: hookResponse.action
+            });
+            return hookResponse;
+          }
+          const url = "url" in request.params ? request.params.url : undefined;
+          const requestedSchema = "requestedSchema" in request.params ? request.params.requestedSchema : undefined;
+          const elicitationId = "elicitationId" in request.params ? request.params.elicitationId : undefined;
+          const rawResult = await structuredIO.handleElicitation(serverName, request.params.message, requestedSchema, extra.signal, mode, url, elicitationId);
+          const result = await runElicitationResultHooks(serverName, rawResult, extra.signal, mode, elicitationId);
+          logEvent("tengu_mcp_elicitation_response", {
+            mode,
+            action: result.action
+          });
+          return result;
+        });
+        connection.client.setNotificationHandler(ElicitationCompleteNotificationSchema, (notification) => {
+          const { elicitationId } = notification.params;
+          logMCPDebug(serverName, `Elicitation completion notification: ${elicitationId}`);
+          executeNotificationHooks({
+            message: `MCP server "${serverName}" confirmed elicitation ${elicitationId} complete`,
+            notificationType: "elicitation_complete"
+          });
+          output.enqueue({
+            type: "system",
+            subtype: "elicitation_complete",
+            mcp_server_name: serverName,
+            elicitation_id: elicitationId,
+            uuid: randomUUID(),
+            session_id: getSessionId()
+          });
+        });
+        elicitationRegistered.add(serverName);
+      } catch {}
+    }
+  }
+  async function updateSdkMcp() {
+    const currentServerNames = new Set(Object.keys(sdkMcpConfigs));
+    const connectedServerNames = new Set(sdkClients.map((c) => c.name));
+    const hasNewServers = Array.from(currentServerNames).some((name) => !connectedServerNames.has(name));
+    const hasRemovedServers = Array.from(connectedServerNames).some((name) => !currentServerNames.has(name));
+    const hasPendingSdkClients = sdkClients.some((c) => c.type === "pending");
+    const hasFailedSdkClients = sdkClients.some((c) => c.type === "failed");
+    const haveServersChanged = hasNewServers || hasRemovedServers || hasPendingSdkClients || hasFailedSdkClients;
+    if (haveServersChanged) {
+      for (const client of sdkClients) {
+        if (!currentServerNames.has(client.name)) {
+          if (client.type === "connected") {
+            await client.cleanup();
+          }
+        }
+      }
+      const sdkSetup = await setupSdkMcpClients(sdkMcpConfigs, (serverName, message) => structuredIO.sendMcpMessage(serverName, message));
+      sdkClients = sdkSetup.clients;
+      sdkTools = sdkSetup.tools;
+      const allSdkNames = uniq([...connectedServerNames, ...currentServerNames]);
+      setAppState((prev) => ({
+        ...prev,
+        mcp: {
+          ...prev.mcp,
+          tools: [
+            ...prev.mcp.tools.filter((t) => !allSdkNames.some((name) => t.name.startsWith(getMcpPrefix(name)))),
+            ...sdkTools
+          ]
+        }
+      }));
+      setupVscodeSdkMcp(sdkClients);
+    }
+  }
+  updateSdkMcp();
+  let dynamicMcpState = {
+    clients: [],
+    tools: [],
+    configs: {}
+  };
+  const buildAllTools = (appState) => {
+    const assembledTools = assembleToolPool(appState.toolPermissionContext, appState.mcp.tools);
+    let allTools = uniqBy(mergeAndFilterTools([...tools, ...sdkTools, ...dynamicMcpState.tools], assembledTools, appState.toolPermissionContext.mode), "name");
+    if (options.permissionPromptToolName) {
+      allTools = allTools.filter((tool) => !toolMatchesName(tool, options.permissionPromptToolName));
+    }
+    const initJsonSchema = getInitJsonSchema();
+    if (initJsonSchema && !options.jsonSchema) {
+      const syntheticOutputResult = createSyntheticOutputTool(initJsonSchema);
+      if ("tool" in syntheticOutputResult) {
+        allTools = [...allTools, syntheticOutputResult.tool];
+      }
+    }
+    return allTools;
+  };
+  let bridgeHandle = null;
+  let bridgeLastForwardedIndex = 0;
+  function forwardMessagesToBridge() {
+    if (!bridgeHandle)
+      return;
+    const startIndex = Math.min(bridgeLastForwardedIndex, mutableMessages.length);
+    const newMessages = mutableMessages.slice(startIndex).filter((m) => m.type === "user" || m.type === "assistant");
+    bridgeLastForwardedIndex = mutableMessages.length;
+    if (newMessages.length > 0) {
+      bridgeHandle.writeMessages(newMessages);
+    }
+  }
+  let mcpChangesPromise = Promise.resolve({
+    response: {
+      added: [],
+      removed: [],
+      errors: {}
+    },
+    sdkServersChanged: false
+  });
+  function applyMcpServerChanges(servers) {
+    const doWork = async () => {
+      const oldSdkClientNames = new Set(sdkClients.map((c) => c.name));
+      const result = await handleMcpSetServers(servers, { configs: sdkMcpConfigs, clients: sdkClients, tools: sdkTools }, dynamicMcpState, setAppState);
+      for (const key of Object.keys(sdkMcpConfigs)) {
+        delete sdkMcpConfigs[key];
+      }
+      Object.assign(sdkMcpConfigs, result.newSdkState.configs);
+      sdkClients = result.newSdkState.clients;
+      sdkTools = result.newSdkState.tools;
+      dynamicMcpState = result.newDynamicState;
+      if (result.sdkServersChanged) {
+        const newSdkClientNames = new Set(sdkClients.map((c) => c.name));
+        const allSdkNames = uniq([...oldSdkClientNames, ...newSdkClientNames]);
+        setAppState((prev) => ({
+          ...prev,
+          mcp: {
+            ...prev.mcp,
+            tools: [
+              ...prev.mcp.tools.filter((t) => !allSdkNames.some((name) => t.name.startsWith(getMcpPrefix(name)))),
+              ...sdkTools
+            ]
+          }
+        }));
+      }
+      return {
+        response: result.response,
+        sdkServersChanged: result.sdkServersChanged
+      };
+    };
+    mcpChangesPromise = mcpChangesPromise.then(doWork, doWork);
+    return mcpChangesPromise;
+  }
+  function buildMcpServerStatuses() {
+    const currentAppState = getAppState();
+    const currentMcpClients = currentAppState.mcp.clients;
+    const allMcpTools = uniqBy([...currentAppState.mcp.tools, ...dynamicMcpState.tools], "name");
+    const existingNames = new Set([
+      ...currentMcpClients.map((c) => c.name),
+      ...sdkClients.map((c) => c.name)
+    ]);
+    return [
+      ...currentMcpClients,
+      ...sdkClients,
+      ...dynamicMcpState.clients.filter((c) => !existingNames.has(c.name))
+    ].map((connection) => {
+      let config;
+      if (connection.config.type === "sse" || connection.config.type === "http") {
+        config = {
+          type: connection.config.type,
+          url: connection.config.url,
+          headers: connection.config.headers,
+          oauth: connection.config.oauth
+        };
+      } else if (connection.config.type === "claudeai-proxy") {
+        config = {
+          type: "claudeai-proxy",
+          url: connection.config.url,
+          id: connection.config.id
+        };
+      } else if (connection.config.type === "stdio" || connection.config.type === undefined) {
+        config = {
+          type: "stdio",
+          command: connection.config.command,
+          args: connection.config.args
+        };
+      }
+      const serverTools = connection.type === "connected" ? filterToolsByServer(allMcpTools, connection.name).map((tool) => ({
+        name: tool.mcpInfo?.toolName ?? tool.name,
+        annotations: {
+          readOnly: tool.isReadOnly({}) || undefined,
+          destructive: tool.isDestructive?.({}) || undefined,
+          openWorld: tool.isOpenWorld?.({}) || undefined
+        }
+      })) : undefined;
+      let capabilities;
+      if (false) {}
+      return {
+        name: connection.name,
+        status: connection.type,
+        serverInfo: connection.type === "connected" ? connection.serverInfo : undefined,
+        error: connection.type === "failed" ? connection.error : undefined,
+        config,
+        scope: connection.config.scope,
+        tools: serverTools,
+        capabilities
+      };
+    });
+  }
+  async function installPluginsAndApplyMcpInBackground() {
+    try {
+      await Promise.all([
+        Promise.resolve(),
+        withDiagnosticsTiming("headless_managed_settings_wait", () => waitForRemoteManagedSettingsToLoad())
+      ]);
+      const pluginsInstalled = await installPluginsForHeadless();
+      if (pluginsInstalled) {
+        await applyPluginMcpDiff();
+      }
+    } catch (error) {
+      logError(error);
+    }
+  }
+  let pluginInstallPromise = null;
+  if (!isBareMode()) {
+    if (isEnvTruthy(process.env.CLAUDE_CODE_SYNC_PLUGIN_INSTALL)) {
+      pluginInstallPromise = installPluginsAndApplyMcpInBackground();
+    } else {
+      installPluginsAndApplyMcpInBackground();
+    }
+  }
+  const idleTimeout = createIdleTimeoutManager(() => !running);
+  let currentCommands = commands;
+  let currentAgents = agents;
+  async function refreshPluginState() {
+    const { agentDefinitions: freshAgentDefs } = await refreshActivePlugins(setAppState);
+    currentCommands = await getCommands(cwd());
+    const sdkAgents = currentAgents.filter((a) => a.source === "flagSettings");
+    currentAgents = [...freshAgentDefs.allAgents, ...sdkAgents];
+  }
+  async function applyPluginMcpDiff() {
+    const { servers: newConfigs } = await getAllMcpConfigs();
+    const supportedConfigs = {};
+    for (const [name, config] of Object.entries(newConfigs)) {
+      const type = config.type;
+      if (type === undefined || type === "stdio" || type === "sse" || type === "http" || type === "sdk") {
+        supportedConfigs[name] = config;
+      }
+    }
+    for (const [name, config] of Object.entries(sdkMcpConfigs)) {
+      if (config.type === "sdk" && !(name in supportedConfigs)) {
+        supportedConfigs[name] = config;
+      }
+    }
+    const { response, sdkServersChanged } = await applyMcpServerChanges(supportedConfigs);
+    if (sdkServersChanged) {
+      updateSdkMcp();
+    }
+    logForDebugging(`Headless MCP refresh: added=${response.added.length}, removed=${response.removed.length}`);
+  }
+  const unsubscribeSkillChanges = skillChangeDetector.subscribe(() => {
+    clearCommandsCache();
+    getCommands(cwd()).then((newCommands) => {
+      currentCommands = newCommands;
+    });
+  });
+  const scheduleProactiveTick = undefined;
+  subscribeToCommandQueue(() => {
+    if (abortController && getCommandsByMaxPriority("now").length > 0) {
+      abortController.abort("interrupt");
+    }
+  });
+  const run = async () => {
+    if (running) {
+      return;
+    }
+    running = true;
+    runPhase = undefined;
+    notifySessionStateChanged("running");
+    idleTimeout.stop();
+    headlessProfilerCheckpoint("run_entry");
+    await updateSdkMcp();
+    headlessProfilerCheckpoint("after_updateSdkMcp");
+    if (pluginInstallPromise) {
+      const timeoutMs = parseInt(process.env.CLAUDE_CODE_SYNC_PLUGIN_INSTALL_TIMEOUT_MS || "", 10);
+      if (timeoutMs > 0) {
+        const timeout = sleep(timeoutMs).then(() => "timeout");
+        const result = await Promise.race([pluginInstallPromise, timeout]);
+        if (result === "timeout") {
+          logError(new Error(`CLAUDE_CODE_SYNC_PLUGIN_INSTALL: plugin installation timed out after ${timeoutMs}ms`));
+          logEvent("tengu_sync_plugin_install_timeout", {
+            timeout_ms: timeoutMs
+          });
+        }
+      } else {
+        await pluginInstallPromise;
+      }
+      pluginInstallPromise = null;
+      await refreshPluginState();
+      const { setupPluginHookHotReload } = await import("../utils/plugins/loadPluginHooks.js");
+      setupPluginHookHotReload();
+    }
+    const isMainThread = (cmd) => cmd.agentId === undefined;
+    try {
+      let command;
+      let waitingForAgents = false;
+      const drainCommandQueue = async () => {
+        while (command = dequeue(isMainThread)) {
+          if (command.mode !== "prompt" && command.mode !== "orphaned-permission" && command.mode !== "task-notification") {
+            throw new Error("only prompt commands are supported in streaming mode");
+          }
+          const batch = [command];
+          if (command.mode === "prompt") {
+            while (canBatchWith(command, peek(isMainThread))) {
+              batch.push(dequeue(isMainThread));
+            }
+            if (batch.length > 1) {
+              command = {
+                ...command,
+                value: joinPromptValues(batch.map((c) => c.value)),
+                uuid: batch.findLast((c) => c.uuid)?.uuid ?? command.uuid
+              };
+            }
+          }
+          const batchUuids = batch.map((c) => c.uuid).filter((u) => u !== undefined);
+          if (options.replayUserMessages && batch.length > 1) {
+            for (const c of batch) {
+              if (c.uuid && c.uuid !== command.uuid) {
+                output.enqueue({
+                  type: "user",
+                  message: { role: "user", content: c.value },
+                  session_id: getSessionId(),
+                  parent_tool_use_id: null,
+                  uuid: c.uuid,
+                  isReplay: true
+                });
+              }
+            }
+          }
+          const appState = getAppState();
+          const allMcpClients = [
+            ...appState.mcp.clients,
+            ...sdkClients,
+            ...dynamicMcpState.clients
+          ];
+          registerElicitationHandlers(allMcpClients);
+          for (const client of allMcpClients) {
+            reregisterChannelHandlerAfterReconnect(client);
+          }
+          const allTools = buildAllTools(appState);
+          for (const uuid of batchUuids) {
+            notifyCommandLifecycle(uuid, "started");
+          }
+          if (command.mode === "task-notification") {
+            const notificationText = typeof command.value === "string" ? command.value : "";
+            const taskIdMatch = notificationText.match(/<task-id>([^<]+)<\/task-id>/);
+            const toolUseIdMatch = notificationText.match(/<tool-use-id>([^<]+)<\/tool-use-id>/);
+            const outputFileMatch = notificationText.match(/<output-file>([^<]+)<\/output-file>/);
+            const statusMatch = notificationText.match(/<status>([^<]+)<\/status>/);
+            const summaryMatch = notificationText.match(/<summary>([^<]+)<\/summary>/);
+            const isValidStatus = (s) => s === "completed" || s === "failed" || s === "stopped" || s === "killed";
+            const rawStatus = statusMatch?.[1];
+            const status = isValidStatus(rawStatus) ? rawStatus === "killed" ? "stopped" : rawStatus : "completed";
+            const usageMatch = notificationText.match(/<usage>([\s\S]*?)<\/usage>/);
+            const usageContent = usageMatch?.[1] ?? "";
+            const totalTokensMatch = usageContent.match(/<total_tokens>(\d+)<\/total_tokens>/);
+            const toolUsesMatch = usageContent.match(/<tool_uses>(\d+)<\/tool_uses>/);
+            const durationMsMatch = usageContent.match(/<duration_ms>(\d+)<\/duration_ms>/);
+            if (statusMatch) {
+              output.enqueue({
+                type: "system",
+                subtype: "task_notification",
+                task_id: taskIdMatch?.[1] ?? "",
+                tool_use_id: toolUseIdMatch?.[1],
+                status,
+                output_file: outputFileMatch?.[1] ?? "",
+                summary: summaryMatch?.[1] ?? "",
+                usage: totalTokensMatch && toolUsesMatch ? {
+                  total_tokens: parseInt(totalTokensMatch[1], 10),
+                  tool_uses: parseInt(toolUsesMatch[1], 10),
+                  duration_ms: durationMsMatch ? parseInt(durationMsMatch[1], 10) : 0
+                } : undefined,
+                session_id: getSessionId(),
+                uuid: randomUUID()
+              });
+            }
+          }
+          const input = command.value;
+          if (structuredIO instanceof RemoteIO && command.mode === "prompt") {
+            logEvent("tengu_bridge_message_received", {
+              is_repl: false
+            });
+          }
+          suggestionState.abortController?.abort();
+          suggestionState.abortController = null;
+          suggestionState.pendingSuggestion = null;
+          suggestionState.pendingLastEmittedEntry = null;
+          if (suggestionState.lastEmitted) {
+            if (command.mode === "prompt") {
+              const inputText = typeof input === "string" ? input : input.find((b) => b.type === "text")?.text;
+              if (typeof inputText === "string") {
+                logSuggestionOutcome(suggestionState.lastEmitted.text, inputText, suggestionState.lastEmitted.emittedAt, suggestionState.lastEmitted.promptId, suggestionState.lastEmitted.generationRequestId);
+              }
+              suggestionState.lastEmitted = null;
+            }
+          }
+          abortController = createAbortController();
+          const turnStartTime = undefined;
+          headlessProfilerCheckpoint("before_ask");
+          startQueryProfile();
+          const cmd = command;
+          await runWithWorkload(cmd.workload ?? options.workload, async () => {
+            for await (const message of ask({
+              commands: uniqBy([...currentCommands, ...appState.mcp.commands], "name"),
+              prompt: input,
+              promptUuid: cmd.uuid,
+              isMeta: cmd.isMeta,
+              cwd: cwd(),
+              tools: allTools,
+              verbose: options.verbose,
+              mcpClients: allMcpClients,
+              thinkingConfig: options.thinkingConfig,
+              maxTurns: options.maxTurns,
+              maxBudgetUsd: options.maxBudgetUsd,
+              taskBudget: options.taskBudget,
+              canUseTool,
+              userSpecifiedModel: activeUserSpecifiedModel,
+              fallbackModel: options.fallbackModel,
+              jsonSchema: getInitJsonSchema() ?? options.jsonSchema,
+              mutableMessages,
+              getReadFileCache: () => pendingSeeds.size === 0 ? readFileState : mergeFileStateCaches(readFileState, pendingSeeds),
+              setReadFileCache: (cache) => {
+                readFileState = cache;
+                for (const [path, seed] of pendingSeeds.entries()) {
+                  const existing = readFileState.get(path);
+                  if (!existing || seed.timestamp > existing.timestamp) {
+                    readFileState.set(path, seed);
+                  }
+                }
+                pendingSeeds.clear();
+              },
+              customSystemPrompt: options.systemPrompt,
+              appendSystemPrompt: options.appendSystemPrompt,
+              getAppState,
+              setAppState,
+              abortController,
+              replayUserMessages: options.replayUserMessages,
+              includePartialMessages: options.includePartialMessages,
+              handleElicitation: (serverName, params, elicitSignal) => structuredIO.handleElicitation(serverName, params.message, undefined, elicitSignal, params.mode, params.url, "elicitationId" in params ? params.elicitationId : undefined),
+              agents: currentAgents,
+              orphanedPermission: cmd.orphanedPermission,
+              setSDKStatus: (status) => {
+                output.enqueue({
+                  type: "system",
+                  subtype: "status",
+                  status,
+                  session_id: getSessionId(),
+                  uuid: randomUUID()
+                });
+              }
+            })) {
+              forwardMessagesToBridge();
+              if (message.type === "result") {
+                for (const event of drainSdkEvents()) {
+                  output.enqueue(event);
+                }
+                const currentState = getAppState();
+                if (getRunningTasks(currentState).some((t) => (t.type === "local_agent" || t.type === "local_workflow") && isBackgroundTask(t))) {
+                  heldBackResult = message;
+                } else {
+                  heldBackResult = null;
+                  output.enqueue(message);
+                }
+              } else {
+                for (const event of drainSdkEvents()) {
+                  output.enqueue(event);
+                }
+                output.enqueue(message);
+              }
+            }
+          });
+          for (const uuid of batchUuids) {
+            notifyCommandLifecycle(uuid, "completed");
+          }
+          forwardMessagesToBridge();
+          bridgeHandle?.sendResult();
+          if (false) {}
+          if (options.promptSuggestions && !isEnvDefinedFalsy(process.env.CLAUDE_CODE_ENABLE_PROMPT_SUGGESTION)) {
+            const state = suggestionState;
+            state.abortController?.abort();
+            const localAbort = new AbortController;
+            suggestionState.abortController = localAbort;
+            const cacheSafeParams = getLastCacheSafeParams();
+            if (!cacheSafeParams) {
+              logSuggestionSuppressed("sdk_no_params", undefined, undefined, "sdk");
+            } else {
+              const ref = { promise: null };
+              ref.promise = (async () => {
+                try {
+                  const result = await tryGenerateSuggestion(localAbort, mutableMessages, getAppState, cacheSafeParams, "sdk");
+                  if (!result || localAbort.signal.aborted)
+                    return;
+                  const suggestionMsg = {
+                    type: "prompt_suggestion",
+                    suggestion: result.suggestion,
+                    uuid: randomUUID(),
+                    session_id: getSessionId()
+                  };
+                  const lastEmittedEntry = {
+                    text: result.suggestion,
+                    emittedAt: Date.now(),
+                    promptId: result.promptId,
+                    generationRequestId: result.generationRequestId
+                  };
+                  if (heldBackResult) {
+                    suggestionState.pendingSuggestion = suggestionMsg;
+                    suggestionState.pendingLastEmittedEntry = {
+                      text: lastEmittedEntry.text,
+                      promptId: lastEmittedEntry.promptId,
+                      generationRequestId: lastEmittedEntry.generationRequestId
+                    };
+                  } else {
+                    suggestionState.lastEmitted = lastEmittedEntry;
+                    output.enqueue(suggestionMsg);
+                  }
+                } catch (error) {
+                  if (error instanceof Error && (error.name === "AbortError" || error.name === "APIUserAbortError")) {
+                    logSuggestionSuppressed("aborted", undefined, undefined, "sdk");
+                    return;
+                  }
+                  logError(toError(error));
+                } finally {
+                  if (suggestionState.inflightPromise === ref.promise) {
+                    suggestionState.inflightPromise = null;
+                  }
+                }
+              })();
+              suggestionState.inflightPromise = ref.promise;
+            }
+          }
+          logHeadlessProfilerTurn();
+          logQueryProfileReport();
+          headlessProfilerStartTurn();
+        }
+      };
+      do {
+        for (const event of drainSdkEvents()) {
+          output.enqueue(event);
+        }
+        runPhase = "draining_commands";
+        await drainCommandQueue();
+        waitingForAgents = false;
+        {
+          const state = getAppState();
+          const hasRunningBg = getRunningTasks(state).some((t) => isBackgroundTask(t) && t.type !== "in_process_teammate");
+          const hasMainThreadQueued = peek(isMainThread) !== undefined;
+          if (hasRunningBg || hasMainThreadQueued) {
+            waitingForAgents = true;
+            if (!hasMainThreadQueued) {
+              runPhase = "waiting_for_agents";
+              await sleep(100);
+            }
+          }
+        }
+      } while (waitingForAgents);
+      if (heldBackResult) {
+        output.enqueue(heldBackResult);
+        heldBackResult = null;
+        if (suggestionState.pendingSuggestion) {
+          output.enqueue(suggestionState.pendingSuggestion);
+          if (suggestionState.pendingLastEmittedEntry) {
+            suggestionState.lastEmitted = {
+              ...suggestionState.pendingLastEmittedEntry,
+              emittedAt: Date.now()
+            };
+            suggestionState.pendingLastEmittedEntry = null;
+          }
+          suggestionState.pendingSuggestion = null;
+        }
+      }
+    } catch (error) {
+      try {
+        await structuredIO.write({
+          type: "result",
+          subtype: "error_during_execution",
+          duration_ms: 0,
+          duration_api_ms: 0,
+          is_error: true,
+          num_turns: 0,
+          stop_reason: null,
+          session_id: getSessionId(),
+          total_cost_usd: 0,
+          usage: EMPTY_USAGE,
+          modelUsage: {},
+          permission_denials: [],
+          uuid: randomUUID(),
+          errors: [
+            errorMessage(error),
+            ...getInMemoryErrors().map((_) => _.error)
+          ]
+        });
+      } catch {}
+      suggestionState.abortController?.abort();
+      gracefulShutdownSync(1);
+      return;
+    } finally {
+      runPhase = "finally_flush";
+      await structuredIO.flushInternalEvents();
+      runPhase = "finally_post_flush";
+      if (!isShuttingDown()) {
+        notifySessionStateChanged("idle");
+        for (const event of drainSdkEvents()) {
+          output.enqueue(event);
+        }
+      }
+      running = false;
+      idleTimeout.start();
+    }
+    if (false) {}
+    if (peek(isMainThread) !== undefined) {
+      run();
+      return;
+    }
+    {
+      const currentAppState = getAppState();
+      const teamContext = currentAppState.teamContext;
+      if (teamContext && isTeamLead(teamContext)) {
+        const agentName = "team-lead";
+        const POLL_INTERVAL_MS = 500;
+        while (true) {
+          const refreshedState = getAppState();
+          const hasActiveTeammates = hasActiveInProcessTeammates(refreshedState) || refreshedState.teamContext && Object.keys(refreshedState.teamContext.teammates).length > 0;
+          if (!hasActiveTeammates) {
+            logForDebugging("[print.ts] No more active teammates, stopping poll");
+            break;
+          }
+          const unread = await readUnreadMessages(agentName, refreshedState.teamContext?.teamName);
+          if (unread.length > 0) {
+            logForDebugging(`[print.ts] Team-lead found ${unread.length} unread messages`);
+            await markMessagesAsRead(agentName, refreshedState.teamContext?.teamName);
+            const teamName = refreshedState.teamContext?.teamName;
+            for (const m of unread) {
+              const shutdownApproval = isShutdownApproved(m.text);
+              if (shutdownApproval && teamName) {
+                const teammateToRemove = shutdownApproval.from;
+                logForDebugging(`[print.ts] Processing shutdown_approved from ${teammateToRemove}`);
+                const teammateId = refreshedState.teamContext?.teammates ? Object.entries(refreshedState.teamContext.teammates).find(([, t]) => t.name === teammateToRemove)?.[0] : undefined;
+                if (teammateId) {
+                  removeTeammateFromTeamFile(teamName, {
+                    agentId: teammateId,
+                    name: teammateToRemove
+                  });
+                  logForDebugging(`[print.ts] Removed ${teammateToRemove} from team file`);
+                  await unassignTeammateTasks(teamName, teammateId, teammateToRemove, "shutdown");
+                  setAppState((prev) => {
+                    if (!prev.teamContext?.teammates)
+                      return prev;
+                    if (!(teammateId in prev.teamContext.teammates))
+                      return prev;
+                    const { [teammateId]: _, ...remainingTeammates } = prev.teamContext.teammates;
+                    return {
+                      ...prev,
+                      teamContext: {
+                        ...prev.teamContext,
+                        teammates: remainingTeammates
+                      }
+                    };
+                  });
+                }
+              }
+            }
+            const formatted = unread.map((m) => `<${TEAMMATE_MESSAGE_TAG} teammate_id="${m.from}"${m.color ? ` color="${m.color}"` : ""}>
+${m.text}
+</${TEAMMATE_MESSAGE_TAG}>`).join(`
+
+`);
+            enqueue({
+              mode: "prompt",
+              value: formatted,
+              uuid: randomUUID()
+            });
+            run();
+            return;
+          }
+          if (inputClosed && !shutdownPromptInjected) {
+            shutdownPromptInjected = true;
+            logForDebugging("[print.ts] Input closed with active teammates, injecting shutdown prompt");
+            enqueue({
+              mode: "prompt",
+              value: SHUTDOWN_TEAM_PROMPT,
+              uuid: randomUUID()
+            });
+            run();
+            return;
+          }
+          await sleep(POLL_INTERVAL_MS);
+        }
+      }
+    }
+    if (inputClosed) {
+      const hasActiveSwarm = await (async () => {
+        const currentAppState = getAppState();
+        if (hasWorkingInProcessTeammates(currentAppState)) {
+          await waitForTeammatesToBecomeIdle(setAppState, currentAppState);
+        }
+        const refreshedAppState = getAppState();
+        const refreshedTeamContext = refreshedAppState.teamContext;
+        const hasTeamMembersNotCleanedUp = refreshedTeamContext && Object.keys(refreshedTeamContext.teammates).length > 0;
+        return hasTeamMembersNotCleanedUp || hasActiveInProcessTeammates(refreshedAppState);
+      })();
+      if (hasActiveSwarm) {
+        enqueue({
+          mode: "prompt",
+          value: SHUTDOWN_TEAM_PROMPT,
+          uuid: randomUUID()
+        });
+        run();
+      } else {
+        if (suggestionState.inflightPromise) {
+          await Promise.race([suggestionState.inflightPromise, sleep(5000)]);
+        }
+        suggestionState.abortController?.abort();
+        suggestionState.abortController = null;
+        await finalizePendingAsyncHooks();
+        unsubscribeSkillChanges();
+        unsubscribeAuthStatus?.();
+        statusListeners.delete(rateLimitListener);
+        output.done();
+      }
+    }
+  };
+  if (false) {}
+  let cronScheduler = null;
+  if (false) {}
+  const sendControlResponseSuccess = function(message, response) {
+    output.enqueue({
+      type: "control_response",
+      response: {
+        subtype: "success",
+        request_id: message.request_id,
+        response
+      }
+    });
+  };
+  const sendControlResponseError = function(message, errorMessage) {
+    output.enqueue({
+      type: "control_response",
+      response: {
+        subtype: "error",
+        request_id: message.request_id,
+        error: errorMessage
+      }
+    });
+  };
+  const handledOrphanedToolUseIds = new Set;
+  structuredIO.setUnexpectedResponseCallback(async (message) => {
+    await handleOrphanedPermissionResponse({
+      message,
+      setAppState,
+      handledToolUseIds: handledOrphanedToolUseIds,
+      onEnqueued: () => {
+        run();
+      }
+    });
+  });
+  const activeOAuthFlows = new Map;
+  const oauthCallbackSubmitters = new Map;
+  const oauthManualCallbackUsed = new Set;
+  const oauthAuthPromises = new Map;
+  let claudeOAuth = null;
+  (async () => {
+    let initialized = false;
+    logForDiagnosticsNoPII("info", "cli_message_loop_started");
+    for await (const message of structuredIO.structuredInput) {
+      const eventId = "uuid" in message ? message.uuid : undefined;
+      if (eventId && message.type !== "user" && message.type !== "control_response") {
+        notifyCommandLifecycle(eventId, "completed");
+      }
+      if (message.type === "control_request") {
+        if (message.request.subtype === "interrupt") {
+          if (false) {}
+          if (abortController) {
+            abortController.abort();
+          }
+          suggestionState.abortController?.abort();
+          suggestionState.abortController = null;
+          suggestionState.lastEmitted = null;
+          suggestionState.pendingSuggestion = null;
+          sendControlResponseSuccess(message);
+        } else if (message.request.subtype === "end_session") {
+          logForDebugging(`[print.ts] end_session received, reason=${message.request.reason ?? "unspecified"}`);
+          if (abortController) {
+            abortController.abort();
+          }
+          suggestionState.abortController?.abort();
+          suggestionState.abortController = null;
+          suggestionState.lastEmitted = null;
+          suggestionState.pendingSuggestion = null;
+          sendControlResponseSuccess(message);
+          break;
+        } else if (message.request.subtype === "initialize") {
+          if (message.request.sdkMcpServers && message.request.sdkMcpServers.length > 0) {
+            for (const serverName of message.request.sdkMcpServers) {
+              sdkMcpConfigs[serverName] = {
+                type: "sdk",
+                name: serverName
+              };
+            }
+          }
+          await handleInitializeRequest(message.request, message.request_id, initialized, output, commands, modelInfos, structuredIO, !!options.enableAuthStatus, options, agents, getAppState);
+          if (message.request.promptSuggestions) {
+            setAppState((prev) => {
+              if (prev.promptSuggestionEnabled)
+                return prev;
+              return { ...prev, promptSuggestionEnabled: true };
+            });
+          }
+          if (message.request.agentProgressSummaries && getFeatureValue_CACHED_MAY_BE_STALE("tengu_slate_prism", true)) {
+            setSdkAgentProgressSummariesEnabled(true);
+          }
+          initialized = true;
+          if (hasCommandsInQueue()) {
+            run();
+          }
+        } else if (message.request.subtype === "set_permission_mode") {
+          const m = message.request;
+          setAppState((prev) => ({
+            ...prev,
+            toolPermissionContext: handleSetPermissionMode(m, message.request_id, prev.toolPermissionContext, output),
+            isUltraplanMode: m.ultraplan ?? prev.isUltraplanMode
+          }));
+        } else if (message.request.subtype === "set_model") {
+          const requestedModel = message.request.model ?? "default";
+          const model = requestedModel === "default" ? getDefaultMainLoopModel() : requestedModel;
+          activeUserSpecifiedModel = model;
+          setMainLoopModelOverride(model);
+          notifySessionMetadataChanged({ model });
+          injectModelSwitchBreadcrumbs(requestedModel, model);
+          sendControlResponseSuccess(message);
+        } else if (message.request.subtype === "set_max_thinking_tokens") {
+          if (message.request.max_thinking_tokens === null) {
+            options.thinkingConfig = undefined;
+          } else if (message.request.max_thinking_tokens === 0) {
+            options.thinkingConfig = { type: "disabled" };
+          } else {
+            options.thinkingConfig = {
+              type: "enabled",
+              budgetTokens: message.request.max_thinking_tokens
+            };
+          }
+          sendControlResponseSuccess(message);
+        } else if (message.request.subtype === "mcp_status") {
+          sendControlResponseSuccess(message, {
+            mcpServers: buildMcpServerStatuses()
+          });
+        } else if (message.request.subtype === "get_context_usage") {
+          try {
+            const appState = getAppState();
+            const data = await collectContextData({
+              messages: mutableMessages,
+              getAppState,
+              options: {
+                mainLoopModel: getMainLoopModel(),
+                tools: buildAllTools(appState),
+                agentDefinitions: appState.agentDefinitions,
+                customSystemPrompt: options.systemPrompt,
+                appendSystemPrompt: options.appendSystemPrompt
+              }
+            });
+            sendControlResponseSuccess(message, { ...data });
+          } catch (error) {
+            sendControlResponseError(message, errorMessage(error));
+          }
+        } else if (message.request.subtype === "mcp_message") {
+          const mcpRequest = message.request;
+          const sdkClient = sdkClients.find((client) => client.name === mcpRequest.server_name);
+          if (sdkClient && sdkClient.type === "connected" && sdkClient.client?.transport?.onmessage) {
+            sdkClient.client.transport.onmessage(mcpRequest.message);
+          }
+          sendControlResponseSuccess(message);
+        } else if (message.request.subtype === "rewind_files") {
+          const appState = getAppState();
+          const result = await handleRewindFiles(message.request.user_message_id, appState, setAppState, message.request.dry_run ?? false);
+          if (result.canRewind || message.request.dry_run) {
+            sendControlResponseSuccess(message, result);
+          } else {
+            sendControlResponseError(message, result.error ?? "Unexpected error");
+          }
+        } else if (message.request.subtype === "cancel_async_message") {
+          const targetUuid = message.request.message_uuid;
+          const removed = dequeueAllMatching((cmd) => cmd.uuid === targetUuid);
+          sendControlResponseSuccess(message, {
+            cancelled: removed.length > 0
+          });
+        } else if (message.request.subtype === "seed_read_state") {
+          try {
+            const normalizedPath = expandPath(message.request.path);
+            const diskMtime = Math.floor((await stat(normalizedPath)).mtimeMs);
+            if (diskMtime <= message.request.mtime) {
+              const raw = await readFile(normalizedPath, "utf-8");
+              const content = (raw.charCodeAt(0) === 65279 ? raw.slice(1) : raw).replaceAll(`\r
+`, `
+`);
+              pendingSeeds.set(normalizedPath, {
+                content,
+                timestamp: diskMtime,
+                offset: undefined,
+                limit: undefined
+              });
+            }
+          } catch {}
+          sendControlResponseSuccess(message);
+        } else if (message.request.subtype === "mcp_set_servers") {
+          const { response, sdkServersChanged } = await applyMcpServerChanges(message.request.servers);
+          sendControlResponseSuccess(message, response);
+          if (sdkServersChanged) {
+            updateSdkMcp();
+          }
+        } else if (message.request.subtype === "reload_plugins") {
+          try {
+            if (false) {}
+            const r = await refreshActivePlugins(setAppState);
+            const sdkAgents = currentAgents.filter((a) => a.source === "flagSettings");
+            currentAgents = [...r.agentDefinitions.allAgents, ...sdkAgents];
+            let plugins = [];
+            const [cmdsR, mcpR, pluginsR] = await Promise.allSettled([
+              getCommands(cwd()),
+              applyPluginMcpDiff(),
+              loadAllPluginsCacheOnly()
+            ]);
+            if (cmdsR.status === "fulfilled") {
+              currentCommands = cmdsR.value;
+            } else {
+              logError(cmdsR.reason);
+            }
+            if (mcpR.status === "rejected") {
+              logError(mcpR.reason);
+            }
+            if (pluginsR.status === "fulfilled") {
+              plugins = pluginsR.value.enabled.map((p) => ({
+                name: p.name,
+                path: p.path,
+                source: p.source
+              }));
+            } else {
+              logError(pluginsR.reason);
+            }
+            sendControlResponseSuccess(message, {
+              commands: currentCommands.filter((cmd) => cmd.userInvocable !== false).map((cmd) => ({
+                name: getCommandName(cmd),
+                description: formatDescriptionWithSource(cmd),
+                argumentHint: cmd.argumentHint || ""
+              })),
+              agents: currentAgents.map((a) => ({
+                name: a.agentType,
+                description: a.whenToUse,
+                model: a.model === "inherit" ? undefined : a.model
+              })),
+              plugins,
+              mcpServers: buildMcpServerStatuses(),
+              error_count: r.error_count
+            });
+          } catch (error) {
+            sendControlResponseError(message, errorMessage(error));
+          }
+        } else if (message.request.subtype === "mcp_reconnect") {
+          const currentAppState = getAppState();
+          const { serverName } = message.request;
+          elicitationRegistered.delete(serverName);
+          const config = getMcpConfigByName(serverName) ?? mcpClients.find((c) => c.name === serverName)?.config ?? sdkClients.find((c) => c.name === serverName)?.config ?? dynamicMcpState.clients.find((c) => c.name === serverName)?.config ?? currentAppState.mcp.clients.find((c) => c.name === serverName)?.config ?? null;
+          if (!config) {
+            sendControlResponseError(message, `Server not found: ${serverName}`);
+          } else {
+            const result = await reconnectMcpServerImpl(serverName, config);
+            const prefix = getMcpPrefix(serverName);
+            setAppState((prev) => ({
+              ...prev,
+              mcp: {
+                ...prev.mcp,
+                clients: prev.mcp.clients.map((c) => c.name === serverName ? result.client : c),
+                tools: [
+                  ...reject(prev.mcp.tools, (t) => t.name?.startsWith(prefix)),
+                  ...result.tools
+                ],
+                commands: [
+                  ...reject(prev.mcp.commands, (c) => commandBelongsToServer(c, serverName)),
+                  ...result.commands
+                ],
+                resources: result.resources && result.resources.length > 0 ? { ...prev.mcp.resources, [serverName]: result.resources } : omit(prev.mcp.resources, serverName)
+              }
+            }));
+            dynamicMcpState = {
+              ...dynamicMcpState,
+              clients: [
+                ...dynamicMcpState.clients.filter((c) => c.name !== serverName),
+                result.client
+              ],
+              tools: [
+                ...dynamicMcpState.tools.filter((t) => !t.name?.startsWith(prefix)),
+                ...result.tools
+              ]
+            };
+            if (result.client.type === "connected") {
+              registerElicitationHandlers([result.client]);
+              reregisterChannelHandlerAfterReconnect(result.client);
+              sendControlResponseSuccess(message);
+            } else {
+              const errorMessage = result.client.type === "failed" ? result.client.error ?? "Connection failed" : `Server status: ${result.client.type}`;
+              sendControlResponseError(message, errorMessage);
+            }
+          }
+        } else if (message.request.subtype === "mcp_toggle") {
+          const currentAppState = getAppState();
+          const { serverName, enabled } = message.request;
+          elicitationRegistered.delete(serverName);
+          const config = getMcpConfigByName(serverName) ?? mcpClients.find((c) => c.name === serverName)?.config ?? sdkClients.find((c) => c.name === serverName)?.config ?? dynamicMcpState.clients.find((c) => c.name === serverName)?.config ?? currentAppState.mcp.clients.find((c) => c.name === serverName)?.config ?? null;
+          if (!config) {
+            sendControlResponseError(message, `Server not found: ${serverName}`);
+          } else if (!enabled) {
+            setMcpServerEnabled(serverName, false);
+            const client = [
+              ...mcpClients,
+              ...sdkClients,
+              ...dynamicMcpState.clients,
+              ...currentAppState.mcp.clients
+            ].find((c) => c.name === serverName);
+            if (client && client.type === "connected") {
+              await clearServerCache(serverName, config);
+            }
+            const prefix = getMcpPrefix(serverName);
+            setAppState((prev) => ({
+              ...prev,
+              mcp: {
+                ...prev.mcp,
+                clients: prev.mcp.clients.map((c) => c.name === serverName ? { name: serverName, type: "disabled", config } : c),
+                tools: reject(prev.mcp.tools, (t) => t.name?.startsWith(prefix)),
+                commands: reject(prev.mcp.commands, (c) => commandBelongsToServer(c, serverName)),
+                resources: omit(prev.mcp.resources, serverName)
+              }
+            }));
+            sendControlResponseSuccess(message);
+          } else {
+            setMcpServerEnabled(serverName, true);
+            const result = await reconnectMcpServerImpl(serverName, config);
+            const prefix = getMcpPrefix(serverName);
+            setAppState((prev) => ({
+              ...prev,
+              mcp: {
+                ...prev.mcp,
+                clients: prev.mcp.clients.map((c) => c.name === serverName ? result.client : c),
+                tools: [
+                  ...reject(prev.mcp.tools, (t) => t.name?.startsWith(prefix)),
+                  ...result.tools
+                ],
+                commands: [
+                  ...reject(prev.mcp.commands, (c) => commandBelongsToServer(c, serverName)),
+                  ...result.commands
+                ],
+                resources: result.resources && result.resources.length > 0 ? { ...prev.mcp.resources, [serverName]: result.resources } : omit(prev.mcp.resources, serverName)
+              }
+            }));
+            if (result.client.type === "connected") {
+              registerElicitationHandlers([result.client]);
+              reregisterChannelHandlerAfterReconnect(result.client);
+              sendControlResponseSuccess(message);
+            } else {
+              const errorMessage = result.client.type === "failed" ? result.client.error ?? "Connection failed" : `Server status: ${result.client.type}`;
+              sendControlResponseError(message, errorMessage);
+            }
+          }
+        } else if (message.request.subtype === "channel_enable") {
+          const currentAppState = getAppState();
+          handleChannelEnable(message.request_id, message.request.serverName, [
+            ...currentAppState.mcp.clients,
+            ...sdkClients,
+            ...dynamicMcpState.clients
+          ], output);
+        } else if (message.request.subtype === "mcp_authenticate") {
+          const { serverName } = message.request;
+          const currentAppState = getAppState();
+          const config = getMcpConfigByName(serverName) ?? mcpClients.find((c) => c.name === serverName)?.config ?? currentAppState.mcp.clients.find((c) => c.name === serverName)?.config ?? null;
+          if (!config) {
+            sendControlResponseError(message, `Server not found: ${serverName}`);
+          } else if (config.type !== "sse" && config.type !== "http") {
+            sendControlResponseError(message, `Server type "${config.type}" does not support OAuth authentication`);
+          } else {
+            try {
+              activeOAuthFlows.get(serverName)?.abort();
+              const controller = new AbortController;
+              activeOAuthFlows.set(serverName, controller);
+              let resolveAuthUrl;
+              const authUrlPromise = new Promise((resolve) => {
+                resolveAuthUrl = resolve;
+              });
+              const oauthPromise = performMCPOAuthFlow(serverName, config, (url) => resolveAuthUrl(url), controller.signal, {
+                skipBrowserOpen: true,
+                onWaitingForCallback: (submit) => {
+                  oauthCallbackSubmitters.set(serverName, submit);
+                }
+              });
+              const authUrl = await Promise.race([
+                authUrlPromise,
+                oauthPromise.then(() => null)
+              ]);
+              if (authUrl) {
+                sendControlResponseSuccess(message, {
+                  authUrl,
+                  requiresUserAction: true
+                });
+              } else {
+                sendControlResponseSuccess(message, {
+                  requiresUserAction: false
+                });
+              }
+              oauthAuthPromises.set(serverName, oauthPromise);
+              const fullFlowPromise = oauthPromise.then(async () => {
+                if (isMcpServerDisabled(serverName)) {
+                  return;
+                }
+                if (oauthManualCallbackUsed.has(serverName)) {
+                  return;
+                }
+                const result = await reconnectMcpServerImpl(serverName, config);
+                const prefix = getMcpPrefix(serverName);
+                setAppState((prev) => ({
+                  ...prev,
+                  mcp: {
+                    ...prev.mcp,
+                    clients: prev.mcp.clients.map((c) => c.name === serverName ? result.client : c),
+                    tools: [
+                      ...reject(prev.mcp.tools, (t) => t.name?.startsWith(prefix)),
+                      ...result.tools
+                    ],
+                    commands: [
+                      ...reject(prev.mcp.commands, (c) => commandBelongsToServer(c, serverName)),
+                      ...result.commands
+                    ],
+                    resources: result.resources && result.resources.length > 0 ? {
+                      ...prev.mcp.resources,
+                      [serverName]: result.resources
+                    } : omit(prev.mcp.resources, serverName)
+                  }
+                }));
+                dynamicMcpState = {
+                  ...dynamicMcpState,
+                  clients: [
+                    ...dynamicMcpState.clients.filter((c) => c.name !== serverName),
+                    result.client
+                  ],
+                  tools: [
+                    ...dynamicMcpState.tools.filter((t) => !t.name?.startsWith(prefix)),
+                    ...result.tools
+                  ]
+                };
+              }).catch((error) => {
+                logForDebugging(`MCP OAuth failed for ${serverName}: ${error}`, { level: "error" });
+              }).finally(() => {
+                if (activeOAuthFlows.get(serverName) === controller) {
+                  activeOAuthFlows.delete(serverName);
+                  oauthCallbackSubmitters.delete(serverName);
+                  oauthManualCallbackUsed.delete(serverName);
+                  oauthAuthPromises.delete(serverName);
+                }
+              });
+            } catch (error) {
+              sendControlResponseError(message, errorMessage(error));
+            }
+          }
+        } else if (message.request.subtype === "mcp_oauth_callback_url") {
+          const { serverName, callbackUrl } = message.request;
+          const submit = oauthCallbackSubmitters.get(serverName);
+          if (submit) {
+            let hasCodeOrError = false;
+            try {
+              const parsed = new URL(callbackUrl);
+              hasCodeOrError = parsed.searchParams.has("code") || parsed.searchParams.has("error");
+            } catch {}
+            if (!hasCodeOrError) {
+              sendControlResponseError(message, "Invalid callback URL: missing authorization code. Please paste the full redirect URL including the code parameter.");
+            } else {
+              oauthManualCallbackUsed.add(serverName);
+              submit(callbackUrl);
+              const authPromise = oauthAuthPromises.get(serverName);
+              if (authPromise) {
+                try {
+                  await authPromise;
+                  sendControlResponseSuccess(message);
+                } catch (error) {
+                  sendControlResponseError(message, error instanceof Error ? error.message : "OAuth authentication failed");
+                }
+              } else {
+                sendControlResponseSuccess(message);
+              }
+            }
+          } else {
+            sendControlResponseError(message, `No active OAuth flow for server: ${serverName}`);
+          }
+        } else if (message.request.subtype === "claude_authenticate") {
+          const { loginWithClaudeAi } = message.request;
+          claudeOAuth?.service.cleanup();
+          logEvent("tengu_oauth_flow_start", {
+            loginWithClaudeAi: loginWithClaudeAi ?? true
+          });
+          const service = new OAuthService;
+          let urlResolver;
+          const urlPromise = new Promise((resolve) => {
+            urlResolver = resolve;
+          });
+          const flow = service.startOAuthFlow(async (manualUrl, automaticUrl) => {
+            urlResolver({ manualUrl, automaticUrl });
+          }, {
+            loginWithClaudeAi: loginWithClaudeAi ?? true,
+            skipBrowserOpen: true
+          }).then(async (tokens) => {
+            await installOAuthTokens(tokens);
+            logEvent("tengu_oauth_success", {
+              loginWithClaudeAi: loginWithClaudeAi ?? true
+            });
+          }).finally(() => {
+            service.cleanup();
+            if (claudeOAuth?.service === service) {
+              claudeOAuth = null;
+            }
+          });
+          claudeOAuth = { service, flow };
+          flow.catch((err) => logForDebugging(`claude_authenticate flow ended: ${err}`, {
+            level: "info"
+          }));
+          try {
+            const { manualUrl, automaticUrl } = await Promise.race([
+              urlPromise,
+              flow.then(() => {
+                throw new Error("OAuth flow completed without producing auth URLs");
+              })
+            ]);
+            sendControlResponseSuccess(message, {
+              manualUrl,
+              automaticUrl
+            });
+          } catch (error) {
+            sendControlResponseError(message, errorMessage(error));
+          }
+        } else if (message.request.subtype === "claude_oauth_callback" || message.request.subtype === "claude_oauth_wait_for_completion") {
+          if (!claudeOAuth) {
+            sendControlResponseError(message, "No active claude_authenticate flow");
+          } else {
+            if (message.request.subtype === "claude_oauth_callback") {
+              claudeOAuth.service.handleManualAuthCodeInput({
+                authorizationCode: message.request.authorizationCode,
+                state: message.request.state
+              });
+            }
+            const { flow } = claudeOAuth;
+            flow.then(() => {
+              const accountInfo = getAccountInformation();
+              sendControlResponseSuccess(message, {
+                account: {
+                  email: accountInfo?.email,
+                  organization: accountInfo?.organization,
+                  subscriptionType: accountInfo?.subscription,
+                  tokenSource: accountInfo?.tokenSource,
+                  apiKeySource: accountInfo?.apiKeySource,
+                  apiProvider: getAPIProvider()
+                }
+              });
+            }, (error) => sendControlResponseError(message, errorMessage(error)));
+          }
+        } else if (message.request.subtype === "mcp_clear_auth") {
+          const { serverName } = message.request;
+          const currentAppState = getAppState();
+          const config = getMcpConfigByName(serverName) ?? mcpClients.find((c) => c.name === serverName)?.config ?? currentAppState.mcp.clients.find((c) => c.name === serverName)?.config ?? null;
+          if (!config) {
+            sendControlResponseError(message, `Server not found: ${serverName}`);
+          } else if (config.type !== "sse" && config.type !== "http") {
+            sendControlResponseError(message, `Cannot clear auth for server type "${config.type}"`);
+          } else {
+            await revokeServerTokens(serverName, config);
+            const result = await reconnectMcpServerImpl(serverName, config);
+            const prefix = getMcpPrefix(serverName);
+            setAppState((prev) => ({
+              ...prev,
+              mcp: {
+                ...prev.mcp,
+                clients: prev.mcp.clients.map((c) => c.name === serverName ? result.client : c),
+                tools: [
+                  ...reject(prev.mcp.tools, (t) => t.name?.startsWith(prefix)),
+                  ...result.tools
+                ],
+                commands: [
+                  ...reject(prev.mcp.commands, (c) => commandBelongsToServer(c, serverName)),
+                  ...result.commands
+                ],
+                resources: result.resources && result.resources.length > 0 ? {
+                  ...prev.mcp.resources,
+                  [serverName]: result.resources
+                } : omit(prev.mcp.resources, serverName)
+              }
+            }));
+            sendControlResponseSuccess(message, {});
+          }
+        } else if (message.request.subtype === "apply_flag_settings") {
+          const prevModel = getMainLoopModel();
+          const existing = getFlagSettingsInline() ?? {};
+          const incoming = message.request.settings;
+          const merged = { ...existing, ...incoming };
+          for (const key of Object.keys(merged)) {
+            if (merged[key] === null) {
+              delete merged[key];
+            }
+          }
+          setFlagSettingsInline(merged);
+          settingsChangeDetector.notifyChange("flagSettings");
+          if ("model" in incoming) {
+            if (incoming.model != null) {
+              setMainLoopModelOverride(String(incoming.model));
+            } else {
+              setMainLoopModelOverride(undefined);
+            }
+          }
+          const newModel = getMainLoopModel();
+          if (newModel !== prevModel) {
+            activeUserSpecifiedModel = newModel;
+            const modelArg = incoming.model ? String(incoming.model) : "default";
+            notifySessionMetadataChanged({ model: newModel });
+            injectModelSwitchBreadcrumbs(modelArg, newModel);
+          }
+          sendControlResponseSuccess(message);
+        } else if (message.request.subtype === "get_settings") {
+          const currentAppState = getAppState();
+          const model = getMainLoopModel();
+          const effort = modelSupportsEffort(model) ? resolveAppliedEffort(model, currentAppState.effortValue) : undefined;
+          sendControlResponseSuccess(message, {
+            ...getSettingsWithSources(),
+            applied: {
+              model,
+              effort: typeof effort === "string" ? effort : null
+            }
+          });
+        } else if (message.request.subtype === "stop_task") {
+          const { task_id: taskId } = message.request;
+          try {
+            await stopTask(taskId, {
+              getAppState,
+              setAppState
+            });
+            sendControlResponseSuccess(message, {});
+          } catch (error) {
+            sendControlResponseError(message, errorMessage(error));
+          }
+        } else if (message.request.subtype === "generate_session_title") {
+          const { description, persist } = message.request;
+          const titleSignal = (abortController && !abortController.signal.aborted ? abortController : createAbortController()).signal;
+          (async () => {
+            try {
+              const title = await generateSessionTitle(description, titleSignal);
+              if (title && persist) {
+                try {
+                  saveAiGeneratedTitle(getSessionId(), title);
+                } catch (e) {
+                  logError(e);
+                }
+              }
+              sendControlResponseSuccess(message, { title });
+            } catch (e) {
+              sendControlResponseError(message, errorMessage(e));
+            }
+          })();
+        } else if (message.request.subtype === "side_question") {
+          const { question } = message.request;
+          (async () => {
+            try {
+              const saved = getLastCacheSafeParams();
+              const cacheSafeParams = saved ? {
+                ...saved,
+                toolUseContext: {
+                  ...saved.toolUseContext,
+                  abortController: createAbortController()
+                }
+              } : await buildSideQuestionFallbackParams({
+                tools: buildAllTools(getAppState()),
+                commands: currentCommands,
+                mcpClients: [
+                  ...getAppState().mcp.clients,
+                  ...sdkClients,
+                  ...dynamicMcpState.clients
+                ],
+                messages: mutableMessages,
+                readFileState,
+                getAppState,
+                setAppState,
+                customSystemPrompt: options.systemPrompt,
+                appendSystemPrompt: options.appendSystemPrompt,
+                thinkingConfig: options.thinkingConfig,
+                agents: currentAgents
+              });
+              const result = await runSideQuestion({
+                question,
+                cacheSafeParams
+              });
+              sendControlResponseSuccess(message, { response: result.response });
+            } catch (e) {
+              sendControlResponseError(message, errorMessage(e));
+            }
+          })();
+        } else if (false) {} else if (message.request.subtype === "remote_control") {
+          if (message.request.enabled) {
+            if (bridgeHandle) {
+              sendControlResponseSuccess(message, {
+                session_url: getRemoteSessionUrl(bridgeHandle.bridgeSessionId, bridgeHandle.sessionIngressUrl),
+                connect_url: buildBridgeConnectUrl(bridgeHandle.environmentId, bridgeHandle.sessionIngressUrl),
+                environment_id: bridgeHandle.environmentId
+              });
+            } else {
+              let bridgeFailureDetail;
+              try {
+                const { initReplBridge } = await import("../bridge/initReplBridge.js");
+                const handle = await initReplBridge({
+                  onInboundMessage(msg) {
+                    const fields = extractInboundMessageFields(msg);
+                    if (!fields)
+                      return;
+                    const { content, uuid } = fields;
+                    enqueue({
+                      value: content,
+                      mode: "prompt",
+                      uuid,
+                      skipSlashCommands: true
+                    });
+                    run();
+                  },
+                  onPermissionResponse(response) {
+                    structuredIO.injectControlResponse(response);
+                  },
+                  onInterrupt() {
+                    abortController?.abort();
+                  },
+                  onSetModel(model) {
+                    const resolved = model === "default" ? getDefaultMainLoopModel() : model;
+                    activeUserSpecifiedModel = resolved;
+                    setMainLoopModelOverride(resolved);
+                  },
+                  onSetMaxThinkingTokens(maxTokens) {
+                    if (maxTokens === null) {
+                      options.thinkingConfig = undefined;
+                    } else if (maxTokens === 0) {
+                      options.thinkingConfig = { type: "disabled" };
+                    } else {
+                      options.thinkingConfig = {
+                        type: "enabled",
+                        budgetTokens: maxTokens
+                      };
+                    }
+                  },
+                  onStateChange(state, detail) {
+                    if (state === "failed") {
+                      bridgeFailureDetail = detail;
+                    }
+                    logForDebugging(`[bridge:sdk] State change: ${state}${detail ? ` — ${detail}` : ""}`);
+                    output.enqueue({
+                      type: "system",
+                      subtype: "bridge_state",
+                      state,
+                      detail,
+                      uuid: randomUUID(),
+                      session_id: getSessionId()
+                    });
+                  },
+                  initialMessages: mutableMessages.length > 0 ? mutableMessages : undefined
+                });
+                if (!handle) {
+                  sendControlResponseError(message, bridgeFailureDetail ?? "Remote Control initialization failed");
+                } else {
+                  bridgeHandle = handle;
+                  bridgeLastForwardedIndex = mutableMessages.length;
+                  structuredIO.setOnControlRequestSent((request) => {
+                    handle.sendControlRequest(request);
+                  });
+                  structuredIO.setOnControlRequestResolved((requestId) => {
+                    handle.sendControlCancelRequest(requestId);
+                  });
+                  sendControlResponseSuccess(message, {
+                    session_url: getRemoteSessionUrl(handle.bridgeSessionId, handle.sessionIngressUrl),
+                    connect_url: buildBridgeConnectUrl(handle.environmentId, handle.sessionIngressUrl),
+                    environment_id: handle.environmentId
+                  });
+                }
+              } catch (err) {
+                sendControlResponseError(message, errorMessage(err));
+              }
+            }
+          } else {
+            if (bridgeHandle) {
+              structuredIO.setOnControlRequestSent(undefined);
+              structuredIO.setOnControlRequestResolved(undefined);
+              await bridgeHandle.teardown();
+              bridgeHandle = null;
+            }
+            sendControlResponseSuccess(message);
+          }
+        } else {
+          sendControlResponseError(message, `Unsupported control request subtype: ${message.request.subtype}`);
+        }
+        continue;
+      } else if (message.type === "control_response") {
+        if (options.replayUserMessages) {
+          output.enqueue(message);
+        }
+        continue;
+      } else if (message.type === "keep_alive") {
+        continue;
+      } else if (message.type === "update_environment_variables") {
+        continue;
+      } else if (message.type === "assistant" || message.type === "system") {
+        const internalMsgs = toInternalMessages([message]);
+        mutableMessages.push(...internalMsgs);
+        if (message.type === "assistant" && options.replayUserMessages) {
+          output.enqueue(message);
+        }
+        continue;
+      }
+      if (message.type !== "user") {
+        continue;
+      }
+      initialized = true;
+      if (message.uuid) {
+        const sessionId = getSessionId();
+        const existsInSession = await doesMessageExistInSession(sessionId, message.uuid);
+        if (existsInSession || receivedMessageUuids.has(message.uuid)) {
+          logForDebugging(`Skipping duplicate user message: ${message.uuid}`);
+          if (options.replayUserMessages) {
+            logForDebugging(`Sending acknowledgment for duplicate user message: ${message.uuid}`);
+            output.enqueue({
+              type: "user",
+              message: message.message,
+              session_id: sessionId,
+              parent_tool_use_id: null,
+              uuid: message.uuid,
+              timestamp: message.timestamp,
+              isReplay: true
+            });
+          }
+          if (existsInSession) {
+            notifyCommandLifecycle(message.uuid, "completed");
+          }
+          continue;
+        }
+        trackReceivedMessageUuid(message.uuid);
+      }
+      enqueue({
+        mode: "prompt",
+        value: await resolveAndPrepend(message, message.message.content),
+        uuid: message.uuid,
+        priority: message.priority
+      });
+      if (false) {}
+      run();
+    }
+    inputClosed = true;
+    cronScheduler?.stop();
+    if (!running) {
+      if (suggestionState.inflightPromise) {
+        await Promise.race([suggestionState.inflightPromise, sleep(5000)]);
+      }
+      suggestionState.abortController?.abort();
+      suggestionState.abortController = null;
+      await finalizePendingAsyncHooks();
+      unsubscribeSkillChanges();
+      unsubscribeAuthStatus?.();
+      statusListeners.delete(rateLimitListener);
+      output.done();
+    }
+  })();
+  return output;
+}
+export function createCanUseToolWithPermissionPrompt(permissionPromptTool) {
+  const canUseTool = async (tool, input, toolUseContext, assistantMessage, toolUseId, forceDecision) => {
+    const mainPermissionResult = forceDecision ?? await hasPermissionsToUseTool(tool, input, toolUseContext, assistantMessage, toolUseId);
+    if (mainPermissionResult.behavior === "allow" || mainPermissionResult.behavior === "deny") {
+      return mainPermissionResult;
+    }
+    const { signal: combinedSignal, cleanup: cleanupAbortListener } = createCombinedAbortSignal(toolUseContext.abortController.signal);
+    if (combinedSignal.aborted) {
+      cleanupAbortListener();
+      return {
+        behavior: "deny",
+        message: "Permission prompt was aborted.",
+        decisionReason: {
+          type: "permissionPromptTool",
+          permissionPromptToolName: tool.name,
+          toolResult: undefined
+        }
+      };
+    }
+    const abortPromise = new Promise((resolve) => {
+      combinedSignal.addEventListener("abort", () => resolve("aborted"), {
+        once: true
+      });
+    });
+    const toolCallPromise = permissionPromptTool.call({
+      tool_name: tool.name,
+      input,
+      tool_use_id: toolUseId
+    }, toolUseContext, canUseTool, assistantMessage);
+    const raceResult = await Promise.race([toolCallPromise, abortPromise]);
+    cleanupAbortListener();
+    if (raceResult === "aborted" || combinedSignal.aborted) {
+      return {
+        behavior: "deny",
+        message: "Permission prompt was aborted.",
+        decisionReason: {
+          type: "permissionPromptTool",
+          permissionPromptToolName: tool.name,
+          toolResult: undefined
+        }
+      };
+    }
+    const result = raceResult;
+    const permissionToolResultBlockParam = permissionPromptTool.mapToolResultToToolResultBlockParam(result.data, "1");
+    if (!permissionToolResultBlockParam.content || !Array.isArray(permissionToolResultBlockParam.content) || !permissionToolResultBlockParam.content[0] || permissionToolResultBlockParam.content[0].type !== "text" || typeof permissionToolResultBlockParam.content[0].text !== "string") {
+      throw new Error('Permission prompt tool returned an invalid result. Expected a single text block param with type="text" and a string text value.');
+    }
+    return permissionPromptToolResultToPermissionDecision(permissionToolOutputSchema().parse(safeParseJSON(permissionToolResultBlockParam.content[0].text)), permissionPromptTool, input, toolUseContext);
+  };
+  return canUseTool;
+}
+export function getCanUseToolFn(permissionPromptToolName, structuredIO, getMcpTools, onPermissionPrompt) {
+  if (permissionPromptToolName === "stdio") {
+    return structuredIO.createCanUseTool(onPermissionPrompt);
+  }
+  if (!permissionPromptToolName) {
+    return async (tool, input, toolUseContext, assistantMessage, toolUseId, forceDecision) => forceDecision ?? await hasPermissionsToUseTool(tool, input, toolUseContext, assistantMessage, toolUseId);
+  }
+  let resolved = null;
+  return async (tool, input, toolUseContext, assistantMessage, toolUseId, forceDecision) => {
+    if (!resolved) {
+      const mcpTools = getMcpTools();
+      const permissionPromptTool = mcpTools.find((t) => toolMatchesName(t, permissionPromptToolName));
+      if (!permissionPromptTool) {
+        const error = `Error: MCP tool ${permissionPromptToolName} (passed via --permission-prompt-tool) not found. Available MCP tools: ${mcpTools.map((t) => t.name).join(", ") || "none"}`;
+        process.stderr.write(`${error}
+`);
+        gracefulShutdownSync(1);
+        throw new Error(error);
+      }
+      if (!permissionPromptTool.inputJSONSchema) {
+        const error = `Error: tool ${permissionPromptToolName} (passed via --permission-prompt-tool) must be an MCP tool`;
+        process.stderr.write(`${error}
+`);
+        gracefulShutdownSync(1);
+        throw new Error(error);
+      }
+      resolved = createCanUseToolWithPermissionPrompt(permissionPromptTool);
+    }
+    return resolved(tool, input, toolUseContext, assistantMessage, toolUseId, forceDecision);
+  };
+}
+async function handleInitializeRequest(request, requestId, initialized, output, commands, modelInfos, structuredIO, enableAuthStatus, options, agents, getAppState) {
+  if (initialized) {
+    output.enqueue({
+      type: "control_response",
+      response: {
+        subtype: "error",
+        error: "Already initialized",
+        request_id: requestId,
+        pending_permission_requests: structuredIO.getPendingPermissionRequests()
+      }
+    });
+    return;
+  }
+  if (request.systemPrompt !== undefined) {
+    options.systemPrompt = request.systemPrompt;
+  }
+  if (request.appendSystemPrompt !== undefined) {
+    options.appendSystemPrompt = request.appendSystemPrompt;
+  }
+  if (request.promptSuggestions !== undefined) {
+    options.promptSuggestions = request.promptSuggestions;
+  }
+  if (request.agents) {
+    const stdinAgents = parseAgentsFromJson(request.agents, "flagSettings");
+    agents.push(...stdinAgents);
+  }
+  if (options.agent) {
+    const alreadyResolved = getMainThreadAgentType() === options.agent;
+    const mainThreadAgent = agents.find((a) => a.agentType === options.agent);
+    if (mainThreadAgent && !alreadyResolved) {
+      setMainThreadAgentType(mainThreadAgent.agentType);
+      if (!options.systemPrompt && !isBuiltInAgent(mainThreadAgent)) {
+        const agentSystemPrompt = mainThreadAgent.getSystemPrompt();
+        if (agentSystemPrompt) {
+          options.systemPrompt = agentSystemPrompt;
+        }
+      }
+      if (!options.userSpecifiedModel && mainThreadAgent.model && mainThreadAgent.model !== "inherit") {
+        const agentModel = parseUserSpecifiedModel(mainThreadAgent.model);
+        setMainLoopModelOverride(agentModel);
+      }
+      if (mainThreadAgent.initialPrompt) {
+        structuredIO.prependUserMessage(mainThreadAgent.initialPrompt);
+      }
+    } else if (mainThreadAgent?.initialPrompt) {
+      structuredIO.prependUserMessage(mainThreadAgent.initialPrompt);
+    }
+  }
+  const settings = getSettings_DEPRECATED();
+  const outputStyle = settings?.outputStyle || DEFAULT_OUTPUT_STYLE_NAME;
+  const availableOutputStyles = await getAllOutputStyles(getCwd());
+  const accountInfo = getAccountInformation();
+  if (request.hooks) {
+    const hooks = {};
+    for (const [event, matchers] of Object.entries(request.hooks)) {
+      hooks[event] = matchers.map((matcher) => {
+        const callbacks = matcher.hookCallbackIds.map((callbackId) => {
+          return structuredIO.createHookCallback(callbackId, matcher.timeout);
+        });
+        return {
+          matcher: matcher.matcher,
+          hooks: callbacks
+        };
+      });
+    }
+    registerHookCallbacks(hooks);
+  }
+  if (request.jsonSchema) {
+    setInitJsonSchema(request.jsonSchema);
+  }
+  const initResponse = {
+    commands: commands.filter((cmd) => cmd.userInvocable !== false).map((cmd) => ({
+      name: getCommandName(cmd),
+      description: formatDescriptionWithSource(cmd),
+      argumentHint: cmd.argumentHint || ""
+    })),
+    agents: agents.map((agent) => ({
+      name: agent.agentType,
+      description: agent.whenToUse,
+      model: agent.model === "inherit" ? undefined : agent.model
+    })),
+    output_style: outputStyle,
+    available_output_styles: Object.keys(availableOutputStyles),
+    models: modelInfos,
+    account: {
+      email: accountInfo?.email,
+      organization: accountInfo?.organization,
+      subscriptionType: accountInfo?.subscription,
+      tokenSource: accountInfo?.tokenSource,
+      apiKeySource: accountInfo?.apiKeySource,
+      apiProvider: getAPIProvider()
+    },
+    pid: process.pid
+  };
+  if (isFastModeEnabled() && isFastModeAvailable()) {
+    const appState = getAppState();
+    initResponse.fast_mode_state = getFastModeState(options.userSpecifiedModel ?? null, appState.fastMode);
+  }
+  output.enqueue({
+    type: "control_response",
+    response: {
+      subtype: "success",
+      request_id: requestId,
+      response: initResponse
+    }
+  });
+  if (enableAuthStatus) {
+    const authStatusManager = AwsAuthStatusManager.getInstance();
+    const status = authStatusManager.getStatus();
+    if (status) {
+      output.enqueue({
+        type: "auth_status",
+        isAuthenticating: status.isAuthenticating,
+        output: status.output,
+        error: status.error,
+        uuid: randomUUID(),
+        session_id: getSessionId()
+      });
+    }
+  }
+}
+async function handleRewindFiles(userMessageId, appState, setAppState, dryRun) {
+  if (!fileHistoryEnabled()) {
+    return { canRewind: false, error: "File rewinding is not enabled." };
+  }
+  if (!fileHistoryCanRestore(appState.fileHistory, userMessageId)) {
+    return {
+      canRewind: false,
+      error: "No file checkpoint found for this message."
+    };
+  }
+  if (dryRun) {
+    const diffStats = await fileHistoryGetDiffStats(appState.fileHistory, userMessageId);
+    return {
+      canRewind: true,
+      filesChanged: diffStats?.filesChanged,
+      insertions: diffStats?.insertions,
+      deletions: diffStats?.deletions
+    };
+  }
+  try {
+    await fileHistoryRewind((updater) => setAppState((prev) => ({
+      ...prev,
+      fileHistory: updater(prev.fileHistory)
+    })), userMessageId);
+  } catch (error) {
+    return {
+      canRewind: false,
+      error: `Failed to rewind: ${errorMessage(error)}`
+    };
+  }
+  return { canRewind: true };
+}
+function handleSetPermissionMode(request, requestId, toolPermissionContext, output) {
+  if (request.mode === "bypassPermissions") {
+    if (isBypassPermissionsModeDisabled()) {
+      output.enqueue({
+        type: "control_response",
+        response: {
+          subtype: "error",
+          request_id: requestId,
+          error: "Cannot set permission mode to bypassPermissions because it is disabled by settings or configuration"
+        }
+      });
+      return toolPermissionContext;
+    }
+    if (!toolPermissionContext.isBypassPermissionsModeAvailable) {
+      output.enqueue({
+        type: "control_response",
+        response: {
+          subtype: "error",
+          request_id: requestId,
+          error: "Cannot set permission mode to bypassPermissions because the session was not launched with --dangerously-skip-permissions"
+        }
+      });
+      return toolPermissionContext;
+    }
+  }
+  if (false) {}
+  output.enqueue({
+    type: "control_response",
+    response: {
+      subtype: "success",
+      request_id: requestId,
+      response: {
+        mode: request.mode
+      }
+    }
+  });
+  return {
+    ...transitionPermissionMode(toolPermissionContext.mode, request.mode, toolPermissionContext),
+    mode: request.mode
+  };
+}
+function handleChannelEnable(requestId, serverName, connectionPool, output) {
+  const respondError = (error) => output.enqueue({
+    type: "control_response",
+    response: { subtype: "error", request_id: requestId, error }
+  });
+  if (true) {
+    return respondError("channels feature not available in this build");
+  }
+  const connection = connectionPool.find((c) => c.name === serverName && c.type === "connected");
+  if (!connection || connection.type !== "connected") {
+    return respondError(`server ${serverName} is not connected`);
+  }
+  const pluginSource = connection.config.pluginSource;
+  const parsed = pluginSource ? parsePluginIdentifier(pluginSource) : undefined;
+  if (!parsed?.marketplace) {
+    return respondError(`server ${serverName} is not plugin-sourced; channel_enable requires a marketplace plugin`);
+  }
+  const entry = {
+    kind: "plugin",
+    name: parsed.name,
+    marketplace: parsed.marketplace
+  };
+  const prior = getAllowedChannels();
+  const already = prior.some((e) => e.kind === "plugin" && e.name === entry.name && e.marketplace === entry.marketplace);
+  if (!already)
+    setAllowedChannels([...prior, entry]);
+  const gate = gateChannelServer(serverName, connection.capabilities, pluginSource);
+  if (gate.action === "skip") {
+    if (!already)
+      setAllowedChannels(prior);
+    return respondError(gate.reason);
+  }
+  const pluginId = `${entry.name}@${entry.marketplace}`;
+  logMCPDebug(serverName, "Channel notifications registered");
+  logEvent("tengu_mcp_channel_enable", { plugin: pluginId });
+  connection.client.setNotificationHandler(ChannelMessageNotificationSchema(), async (notification) => {
+    const { content, meta } = notification.params;
+    logMCPDebug(serverName, `notifications/claude/channel: ${content.slice(0, 80)}`);
+    logEvent("tengu_mcp_channel_message", {
+      content_length: content.length,
+      meta_key_count: Object.keys(meta ?? {}).length,
+      entry_kind: "plugin",
+      is_dev: false,
+      plugin: pluginId
+    });
+    enqueue({
+      mode: "prompt",
+      value: wrapChannelMessage(serverName, content, meta),
+      priority: "next",
+      isMeta: true,
+      origin: { kind: "channel", server: serverName },
+      skipSlashCommands: true
+    });
+  });
+  output.enqueue({
+    type: "control_response",
+    response: {
+      subtype: "success",
+      request_id: requestId,
+      response: undefined
+    }
+  });
+}
+function reregisterChannelHandlerAfterReconnect(connection) {
+  if (true)
+    return;
+  if (connection.type !== "connected")
+    return;
+  const gate = gateChannelServer(connection.name, connection.capabilities, connection.config.pluginSource);
+  if (gate.action !== "register")
+    return;
+  const entry = findChannelEntry(connection.name, getAllowedChannels());
+  const pluginId = entry?.kind === "plugin" ? `${entry.name}@${entry.marketplace}` : undefined;
+  logMCPDebug(connection.name, "Channel notifications re-registered after reconnect");
+  connection.client.setNotificationHandler(ChannelMessageNotificationSchema(), async (notification) => {
+    const { content, meta } = notification.params;
+    logMCPDebug(connection.name, `notifications/claude/channel: ${content.slice(0, 80)}`);
+    logEvent("tengu_mcp_channel_message", {
+      content_length: content.length,
+      meta_key_count: Object.keys(meta ?? {}).length,
+      entry_kind: entry?.kind,
+      is_dev: entry?.dev ?? false,
+      plugin: pluginId
+    });
+    enqueue({
+      mode: "prompt",
+      value: wrapChannelMessage(connection.name, content, meta),
+      priority: "next",
+      isMeta: true,
+      origin: { kind: "channel", server: connection.name },
+      skipSlashCommands: true
+    });
+  });
+}
+function emitLoadError(message, outputFormat) {
+  if (outputFormat === "stream-json") {
+    const errorResult = {
+      type: "result",
+      subtype: "error_during_execution",
+      duration_ms: 0,
+      duration_api_ms: 0,
+      is_error: true,
+      num_turns: 0,
+      stop_reason: null,
+      session_id: getSessionId(),
+      total_cost_usd: 0,
+      usage: EMPTY_USAGE,
+      modelUsage: {},
+      permission_denials: [],
+      uuid: randomUUID(),
+      errors: [message]
+    };
+    process.stdout.write(jsonStringify(errorResult) + `
+`);
+  } else {
+    process.stderr.write(message + `
+`);
+  }
+}
+export function removeInterruptedMessage(messages, interruptedUserMessage) {
+  const idx = messages.findIndex((m) => m.uuid === interruptedUserMessage.uuid);
+  if (idx !== -1) {
+    messages.splice(idx, 2);
+  }
+}
+async function loadInitialMessages(setAppState, options) {
+  const persistSession = !isSessionPersistenceDisabled();
+  if (options.continue) {
+    try {
+      logEvent("tengu_continue_print", {});
+      const result = await loadConversationForResume(undefined, undefined);
+      if (result) {
+        if (false) {}
+        if (!options.forkSession) {
+          if (result.sessionId) {
+            switchSession(asSessionId(result.sessionId), result.fullPath ? dirname(result.fullPath) : null);
+            if (persistSession) {
+              await resetSessionFilePointer();
+            }
+          }
+        }
+        restoreSessionStateFromLog(result, setAppState);
+        restoreSessionMetadata(options.forkSession ? { ...result, worktreeSession: undefined } : result);
+        if (false) {}
+        return {
+          messages: result.messages,
+          turnInterruptionState: result.turnInterruptionState,
+          agentSetting: result.agentSetting
+        };
+      }
+    } catch (error) {
+      logError(error);
+      gracefulShutdownSync(1);
+      return { messages: [] };
+    }
+  }
+  if (options.teleport) {
+    try {
+      if (!isPolicyAllowed("allow_remote_sessions")) {
+        throw new Error("Remote sessions are disabled by your organization's policy.");
+      }
+      logEvent("tengu_teleport_print", {});
+      if (typeof options.teleport !== "string") {
+        throw new Error("No session ID provided for teleport");
+      }
+      const {
+        checkOutTeleportedSessionBranch,
+        processMessagesForTeleportResume,
+        teleportResumeCodeSession,
+        validateGitState
+      } = await import("../utils/teleport.js");
+      await validateGitState();
+      const teleportResult = await teleportResumeCodeSession(options.teleport);
+      const { branchError } = await checkOutTeleportedSessionBranch(teleportResult.branch);
+      return {
+        messages: processMessagesForTeleportResume(teleportResult.log, branchError)
+      };
+    } catch (error) {
+      logError(error);
+      gracefulShutdownSync(1);
+      return { messages: [] };
+    }
+  }
+  if (options.resume) {
+    try {
+      logEvent("tengu_resume_print", {});
+      const parsedSessionId = parseSessionIdentifier(typeof options.resume === "string" ? options.resume : "");
+      if (!parsedSessionId) {
+        let errorMessage = "Error: --resume requires a valid session ID when used with --print. Usage: lcclaude -p --resume <session-id>";
+        if (typeof options.resume === "string") {
+          errorMessage += `. Session IDs must be in UUID format (e.g., 550e8400-e29b-41d4-a716-446655440000). Provided value "${options.resume}" is not a valid UUID`;
+        }
+        emitLoadError(errorMessage, options.outputFormat);
+        gracefulShutdownSync(1);
+        return { messages: [] };
+      }
+      if (isEnvTruthy(process.env.CLAUDE_CODE_USE_CCR_V2)) {
+        const [, metadata] = await Promise.all([
+          hydrateFromCCRv2InternalEvents(parsedSessionId.sessionId),
+          options.restoredWorkerState
+        ]);
+        if (metadata) {
+          setAppState(externalMetadataToAppState(metadata));
+          if (typeof metadata.model === "string") {
+            setMainLoopModelOverride(metadata.model);
+          }
+        }
+      } else if (parsedSessionId.isUrl && parsedSessionId.ingressUrl && isEnvTruthy(process.env.ENABLE_SESSION_PERSISTENCE)) {
+        await hydrateRemoteSession(parsedSessionId.sessionId, parsedSessionId.ingressUrl);
+      }
+      const result = await loadConversationForResume(parsedSessionId.sessionId, parsedSessionId.jsonlFile || undefined);
+      if (!result || result.messages.length === 0) {
+        if (parsedSessionId.isUrl || isEnvTruthy(process.env.CLAUDE_CODE_USE_CCR_V2)) {
+          return {
+            messages: await (options.sessionStartHooksPromise ?? processSessionStartHooks("startup"))
+          };
+        } else {
+          emitLoadError(`No conversation found with session ID: ${parsedSessionId.sessionId}`, options.outputFormat);
+          gracefulShutdownSync(1);
+          return { messages: [] };
+        }
+      }
+      if (options.resumeSessionAt) {
+        const index = result.messages.findIndex((m) => m.uuid === options.resumeSessionAt);
+        if (index < 0) {
+          emitLoadError(`No message found with message.uuid of: ${options.resumeSessionAt}`, options.outputFormat);
+          gracefulShutdownSync(1);
+          return { messages: [] };
+        }
+        result.messages = index >= 0 ? result.messages.slice(0, index + 1) : [];
+      }
+      if (false) {}
+      if (!options.forkSession && result.sessionId) {
+        switchSession(asSessionId(result.sessionId), result.fullPath ? dirname(result.fullPath) : null);
+        if (persistSession) {
+          await resetSessionFilePointer();
+        }
+      }
+      restoreSessionStateFromLog(result, setAppState);
+      restoreSessionMetadata(options.forkSession ? { ...result, worktreeSession: undefined } : result);
+      if (false) {}
+      return {
+        messages: result.messages,
+        turnInterruptionState: result.turnInterruptionState,
+        agentSetting: result.agentSetting
+      };
+    } catch (error) {
+      logError(error);
+      const errorMessage = error instanceof Error ? `Failed to resume session: ${error.message}` : "Failed to resume session with --print mode";
+      emitLoadError(errorMessage, options.outputFormat);
+      gracefulShutdownSync(1);
+      return { messages: [] };
+    }
+  }
+  return {
+    messages: await (options.sessionStartHooksPromise ?? processSessionStartHooks("startup"))
+  };
+}
+function getStructuredIO(inputPrompt, options) {
+  let inputStream;
+  if (typeof inputPrompt === "string") {
+    if (inputPrompt.trim() !== "") {
+      inputStream = fromArray([
+        jsonStringify({
+          type: "user",
+          session_id: "",
+          message: {
+            role: "user",
+            content: inputPrompt
+          },
+          parent_tool_use_id: null
+        })
+      ]);
+    } else {
+      inputStream = fromArray([]);
+    }
+  } else {
+    inputStream = inputPrompt;
+  }
+  return options.sdkUrl ? new RemoteIO(options.sdkUrl, inputStream, options.replayUserMessages) : new StructuredIO(inputStream, options.replayUserMessages);
+}
+export async function handleOrphanedPermissionResponse({
+  message,
+  setAppState,
+  onEnqueued,
+  handledToolUseIds
+}) {
+  if (message.response.subtype === "success" && message.response.response?.toolUseID && typeof message.response.response.toolUseID === "string") {
+    const permissionResult = message.response.response;
+    const { toolUseID } = permissionResult;
+    if (!toolUseID) {
+      return false;
+    }
+    logForDebugging(`handleOrphanedPermissionResponse: received orphaned control_response for toolUseID=${toolUseID} request_id=${message.response.request_id}`);
+    if (handledToolUseIds.has(toolUseID)) {
+      logForDebugging(`handleOrphanedPermissionResponse: skipping duplicate orphaned permission for toolUseID=${toolUseID} (already handled)`);
+      return false;
+    }
+    const assistantMessage = await findUnresolvedToolUse(toolUseID);
+    if (!assistantMessage) {
+      logForDebugging(`handleOrphanedPermissionResponse: no unresolved tool_use found for toolUseID=${toolUseID} (already resolved in transcript)`);
+      return false;
+    }
+    handledToolUseIds.add(toolUseID);
+    logForDebugging(`handleOrphanedPermissionResponse: enqueuing orphaned permission for toolUseID=${toolUseID} messageID=${assistantMessage.message.id}`);
+    enqueue({
+      mode: "orphaned-permission",
+      value: [],
+      orphanedPermission: {
+        permissionResult,
+        assistantMessage
+      }
+    });
+    onEnqueued?.();
+    return true;
+  }
+  return false;
+}
+function toScopedConfig(config) {
+  return { ...config, scope: "dynamic" };
+}
+export async function handleMcpSetServers(servers, sdkState, dynamicState, setAppState) {
+  const { allowed: allowedServers, blocked } = filterMcpServersByPolicy(servers);
+  const policyErrors = {};
+  for (const name of blocked) {
+    policyErrors[name] = "Blocked by enterprise policy (allowedMcpServers/deniedMcpServers)";
+  }
+  const sdkServers = {};
+  const processServers = {};
+  for (const [name, config] of Object.entries(allowedServers)) {
+    if (config.type === "sdk") {
+      sdkServers[name] = config;
+    } else {
+      processServers[name] = config;
+    }
+  }
+  const currentSdkNames = new Set(Object.keys(sdkState.configs));
+  const newSdkNames = new Set(Object.keys(sdkServers));
+  const sdkAdded = [];
+  const sdkRemoved = [];
+  const newSdkConfigs = { ...sdkState.configs };
+  let newSdkClients = [...sdkState.clients];
+  let newSdkTools = [...sdkState.tools];
+  for (const name of currentSdkNames) {
+    if (!newSdkNames.has(name)) {
+      const client = newSdkClients.find((c) => c.name === name);
+      if (client && client.type === "connected") {
+        await client.cleanup();
+      }
+      newSdkClients = newSdkClients.filter((c) => c.name !== name);
+      const prefix = `mcp__${name}__`;
+      newSdkTools = newSdkTools.filter((t) => !t.name.startsWith(prefix));
+      delete newSdkConfigs[name];
+      sdkRemoved.push(name);
+    }
+  }
+  for (const [name, config] of Object.entries(sdkServers)) {
+    if (!currentSdkNames.has(name)) {
+      newSdkConfigs[name] = config;
+      const pendingClient = {
+        type: "pending",
+        name,
+        config: { ...config, scope: "dynamic" }
+      };
+      newSdkClients = [...newSdkClients, pendingClient];
+      sdkAdded.push(name);
+    }
+  }
+  const processResult = await reconcileMcpServers(processServers, dynamicState, setAppState);
+  return {
+    response: {
+      added: [...sdkAdded, ...processResult.response.added],
+      removed: [...sdkRemoved, ...processResult.response.removed],
+      errors: { ...policyErrors, ...processResult.response.errors }
+    },
+    newSdkState: {
+      configs: newSdkConfigs,
+      clients: newSdkClients,
+      tools: newSdkTools
+    },
+    newDynamicState: processResult.newState,
+    sdkServersChanged: sdkAdded.length > 0 || sdkRemoved.length > 0
+  };
+}
+export async function reconcileMcpServers(desiredConfigs, currentState, setAppState) {
+  const currentNames = new Set(Object.keys(currentState.configs));
+  const desiredNames = new Set(Object.keys(desiredConfigs));
+  const toRemove = [...currentNames].filter((n) => !desiredNames.has(n));
+  const toAdd = [...desiredNames].filter((n) => !currentNames.has(n));
+  const toCheck = [...currentNames].filter((n) => desiredNames.has(n));
+  const toReplace = toCheck.filter((name) => {
+    const currentConfig = currentState.configs[name];
+    const desiredConfigRaw = desiredConfigs[name];
+    if (!currentConfig || !desiredConfigRaw)
+      return true;
+    const desiredConfig = toScopedConfig(desiredConfigRaw);
+    return !areMcpConfigsEqual(currentConfig, desiredConfig);
+  });
+  const removed = [];
+  const added = [];
+  const errors = {};
+  let newClients = [...currentState.clients];
+  let newTools = [...currentState.tools];
+  for (const name of [...toRemove, ...toReplace]) {
+    const client = newClients.find((c) => c.name === name);
+    const config = currentState.configs[name];
+    if (client && config) {
+      if (client.type === "connected") {
+        try {
+          await client.cleanup();
+        } catch (e) {
+          logError(e);
+        }
+      }
+      await clearServerCache(name, config);
+    }
+    const prefix = `mcp__${name}__`;
+    newTools = newTools.filter((t) => !t.name.startsWith(prefix));
+    newClients = newClients.filter((c) => c.name !== name);
+    if (toRemove.includes(name)) {
+      removed.push(name);
+    }
+  }
+  for (const name of [...toAdd, ...toReplace]) {
+    const config = desiredConfigs[name];
+    if (!config)
+      continue;
+    const scopedConfig = toScopedConfig(config);
+    if (config.type === "sdk") {
+      added.push(name);
+      continue;
+    }
+    try {
+      const client = await connectToServer(name, scopedConfig);
+      newClients.push(client);
+      if (client.type === "connected") {
+        const serverTools = await fetchToolsForClient(client);
+        newTools.push(...serverTools);
+      } else if (client.type === "failed") {
+        errors[name] = client.error || "Connection failed";
+      }
+      added.push(name);
+    } catch (e) {
+      const err = toError(e);
+      errors[name] = err.message;
+      logError(err);
+    }
+  }
+  const newConfigs = {};
+  for (const name of desiredNames) {
+    const config = desiredConfigs[name];
+    if (config) {
+      newConfigs[name] = toScopedConfig(config);
+    }
+  }
+  const newState = {
+    clients: newClients,
+    tools: newTools,
+    configs: newConfigs
+  };
+  setAppState((prev) => {
+    const allDynamicServerNames = new Set([
+      ...Object.keys(currentState.configs),
+      ...Object.keys(newConfigs)
+    ]);
+    const nonDynamicTools = prev.mcp.tools.filter((t) => {
+      for (const serverName of allDynamicServerNames) {
+        if (t.name.startsWith(`mcp__${serverName}__`)) {
+          return false;
+        }
+      }
+      return true;
+    });
+    const nonDynamicClients = prev.mcp.clients.filter((c) => {
+      return !allDynamicServerNames.has(c.name);
+    });
+    return {
+      ...prev,
+      mcp: {
+        ...prev.mcp,
+        tools: [...nonDynamicTools, ...newTools],
+        clients: [...nonDynamicClients, ...newClients]
+      }
+    };
+  });
+  return {
+    response: { added, removed, errors },
+    newState
+  };
+}