@qwen-code/qwen-code 0.22.3-nightly.20260831.3a0c4c6108 → 0.23.0

package/chunks/{acpAgent-7I5LLPP3.js → acpAgent-2GTFCIEP.js}

@@ -1,12 +1,14 @@
 // Force strict mode and setup for ESM
 "use strict";
 import {
-  recomputeMcpGating
-} from "./chunk-RAEEQEC5.js";
+  classifyApiError
+} from "./chunk-V7RNNPGC.js";
 import {
-  classifyApiError,
   fireSessionDeleteHook
-} from "./chunk-P5Y23G2L.js";
+} from "./chunk-L34XSHIZ.js";
+import {
+  normalizePartList
+} from "./chunk-5IENVM7Z.js";
 import {
   EXTENSION_CONTEXT_BUDGET,
   buildExtensionMentionContext,
@@ -14,13 +16,9 @@ import {
   extractAtPathCommands,
   matchExtensionByRef,
   matchMcpServerByRef,
-  normalizePartList,
   parseExtensionRef,
   parseMcpServerRef
-} from "./chunk-AKNQMSL2.js";
-import {
-  getCommandSubcommandNames
-} from "./chunk-QE7DTCLX.js";
+} from "./chunk-LOBDDFYK.js";
 import {
   getAvailableCommands,
   getSlashCommandFirstToken,
@@ -29,7 +27,10 @@ import {
   isSlashCommand,
   recordDaemonSessionModel,
   restoreSessionModelThenAuthenticate
-} from "./chunk-BBYTY46C.js";
+} from "./chunk-NVVJTUSL.js";
+import {
+  recomputeMcpGating
+} from "./chunk-UUASLXHW.js";
 import {
   SessionIdConflictError,
   appEvents,
@@ -37,35 +38,40 @@ import {
   buildEnabledSkillNamesProvider,
   cleanupReviewWorktreeLeases,
   loadCliConfig,
-  normalizeDisabledToolList
-} from "./chunk-YOMKOM7E.js";
+  normalizeDisabledToolList,
+  parseApprovalModeValue
+} from "./chunk-MP6YZ4RK.js";
+import {
+  getCommandSubcommandNames
+} from "./chunk-EIY7SUPZ.js";
 import {
   getEffectiveSupportedModes
-} from "./chunk-3NQCZMUB.js";
+} from "./chunk-5RTTI4GE.js";
+import "./chunk-3SH53ANB.js";
 import "./chunk-NYX53SV4.js";
-import "./chunk-JLSZT354.js";
+import "./chunk-M4LBBSVP.js";
 import {
   collectContextData,
   formatContextUsageText
-} from "./chunk-KUDI54QQ.js";
+} from "./chunk-SX2QIMJV.js";
 import "./chunk-4WGODMVR.js";
 import {
   startNonInteractiveOpenAILogHousekeeping
-} from "./chunk-XPDKSOVW.js";
+} from "./chunk-GXUTFQXK.js";
 import "./chunk-KW7NOTN6.js";
-import "./chunk-3SH53ANB.js";
-import "./chunk-BSJOBW4U.js";
+import "./chunk-JHN7UIDW.js";
+import "./chunk-5EIOJGCR.js";
+import "./chunk-37JFWFCD.js";
 import {
   isGoalStatusKind
 } from "./chunk-EKTCKZV5.js";
-import "./chunk-NGKLMNWN.js";
+import "./chunk-UM2FFKXN.js";
 import "./chunk-YAF2MQZ6.js";
-import "./chunk-JHN7UIDW.js";
 import {
   computeCpuPercent
 } from "./chunk-LBOVL47Y.js";
 import "./chunk-24FVUD5P.js";
-import "./chunk-QTMPM6RC.js";
+import "./chunk-EWRW2WQC.js";
 import "./chunk-6H67XLET.js";
 import {
   beginAcpBootstrapConfigProfiling,
@@ -73,8 +79,7 @@ import {
   endAcpBootstrapConfigProfiling,
   markAcpStartup
 } from "./chunk-JZWOCUZ3.js";
-import "./chunk-UKB2TZAO.js";
-import "./chunk-MJBHSZEJ.js";
+import "./chunk-VNAYZAFX.js";
 import {
   GENERATION_MAX_PROMPT_BYTES,
   GENERATION_TIMEOUT_MS,
@@ -95,7 +100,7 @@ import {
   shouldSuppressRememberErrorDetails,
   workspaceMemoryFailureCode,
   workspaceMemoryFailureDiagnostics
-} from "./chunk-BY24DZ4J.js";
+} from "./chunk-WP4AX3XD.js";
 import {
   BaseEmitter,
   HistoryReplayer,
@@ -106,10 +111,10 @@ import {
   hasFullSessionContext,
   observeAcpToolResultProjection,
   observeAcpToolResultWire
-} from "./chunk-L2OKAIUK.js";
+} from "./chunk-QI27MKNQ.js";
 import "./chunk-XEAAO654.js";
+import "./chunk-NRL5CUZT.js";
 import "./chunk-47ECGEJC.js";
-import "./chunk-OQYXJK2V.js";
 import "./chunk-2MIN6GRR.js";
 import "./chunk-QHTIBUWB.js";
 import "./chunk-TXASDT2M.js";
@@ -138,7 +143,7 @@ import {
   normalizeChannelDeliveryText,
   scheduledTaskRunSessionName,
   scheduledTaskRunSourceId
-} from "./chunk-PNIGAVY6.js";
+} from "./chunk-DTVQSSNM.js";
 import {
   normalizeSessionIdForLookup,
   parseCallerSuppliedSessionId
@@ -149,33 +154,43 @@ import {
   buildPermissionSettings,
   normalizePermissionRules,
   readPermissionRuleSet
-} from "./chunk-JPKTAQS3.js";
+} from "./chunk-I5N4EAS6.js";
 import {
   MAX_AUDIO_BYTES,
   sanitizeVoiceErrorMessage,
   transcribeVoiceAudio
-} from "./chunk-YNG7XAJU.js";
+} from "./chunk-LEPCWS5A.js";
 import {
   readVoiceModel
-} from "./chunk-BE5FGT5Z.js";
+} from "./chunk-BA4WJC4L.js";
 import "./chunk-QAK5475D.js";
-import "./chunk-6YXNJXQW.js";
-import "./chunk-AN3KFCNH.js";
+import "./chunk-RN3YGDCA.js";
+import "./chunk-3JQZVCBI.js";
 import "./chunk-JS73NNWF.js";
 import {
   SCHEDULED_TASK_RUN_SOURCE_TYPE
-} from "./chunk-RLSPPTWH.js";
+} from "./chunk-DSX7KQPM.js";
 import "./chunk-7U5G6JXI.js";
 import "./chunk-WCCLLK7X.js";
 import "./chunk-OCPBI7J5.js";
 import {
+  ndJsonStream
+} from "./chunk-4HVH57J3.js";
+import {
+  PERSIST_REASONING_SELECTION_META_KEY,
   REASONING_EFFORT_DEFAULT,
   REASONING_EFFORT_NAMES,
   REASONING_EFFORT_NONE,
+  REASONING_SELECTION_PERSISTED_META_KEY,
+  applyReasoningSelection,
   buildModelReasoningConfigOption,
   buildModelReasoningConfigPreview,
-  getModelConfiguration
-} from "./chunk-T4EFG2P5.js";
+  clearReasoningRequestOverrides,
+  getModelConfiguration,
+  isReasoningSelectionSupported,
+  parseReasoningSelection,
+  resolvePersistedReasoningConfigState
+} from "./chunk-ZJ2LM2SI.js";
 import {
   ACP_ROUTE_ID_PREFIX,
   buildAcpModelOptions,
@@ -184,36 +199,34 @@ import {
   parseAcpModelOption,
   resolveAcpModelOption,
   sanitizeProviderBaseUrl
-} from "./chunk-W7KWB6AH.js";
+} from "./chunk-6A2D4QSO.js";
 import {
   mapSkillConfigToStatus
 } from "./chunk-BHTYRHJF.js";
+import {
+  ACP_PREFLIGHT_KINDS,
+  IDLE_HOOK_EVENTS,
+  SERVE_CONTROL_EXT_METHODS,
+  SERVE_STATUS_EXT_METHODS,
+  STATUS_SCHEMA_VERSION,
+  mapDomainErrorToErrorKind
+} from "./chunk-64QH2UC6.js";
 import {
   resolveSkillSettings
 } from "./chunk-HWVUSYSN.js";
 import "./chunk-DMEUXLSS.js";
-import "./chunk-OE5AQVNB.js";
-import "./chunk-H2A2GJGL.js";
+import "./chunk-F7NF2IOE.js";
+import "./chunk-AZJLY2XZ.js";
 import "./chunk-57OAHC2Y.js";
-import "./chunk-V4HN35IF.js";
-import "./chunk-CAZADEU7.js";
-import "./chunk-GN422P4J.js";
+import "./chunk-PCRBLMIN.js";
+import "./chunk-NXKOVOM5.js";
+import "./chunk-TSZSGQ3N.js";
 import "./chunk-V6WHFGST.js";
 import {
   createLoadedSettingsAdapter
-} from "./chunk-HDMKCJHI.js";
-import {
-  ndJsonStream
-} from "./chunk-JMRE4WJQ.js";
-import {
-  ACP_PREFLIGHT_KINDS,
-  IDLE_HOOK_EVENTS,
-  SERVE_CONTROL_EXT_METHODS,
-  SERVE_STATUS_EXT_METHODS,
-  STATUS_SCHEMA_VERSION,
-  mapDomainErrorToErrorKind
-} from "./chunk-J4Y3QJHF.js";
-import "./chunk-SMRDCANI.js";
+} from "./chunk-32LU3APX.js";
+import "./chunk-S6H3ELPG.js";
+import "./chunk-7XL4WRXM.js";
 import {
   ACTIVE_WORK_CLOSE_IF_UNHELD_PARAM,
   ACTIVE_WORK_HEARTBEAT_META_KEY,
@@ -255,12 +268,12 @@ import {
 import {
   NOT_CURRENTLY_GENERATING_CANCEL_MESSAGE,
   isNotCurrentlyGeneratingCancelError
-} from "./chunk-YPISTYEI.js";
+} from "./chunk-F47DITLZ.js";
 import "./chunk-6PLDPT2C.js";
 import "./chunk-FYJ7W2PI.js";
 import "./chunk-STUJ7IMZ.js";
 import "./chunk-GYTKQYDB.js";
-import "./chunk-3EGEBDTW.js";
+import "./chunk-M4KFODIP.js";
 import "./chunk-ALMR3E6Q.js";
 import "./chunk-RKFGE7JH.js";
 import "./chunk-UDG5EZJI.js";
@@ -274,32 +287,35 @@ import {
   isValidExternalToolGuardDenialReason
 } from "./chunk-3VUENPWF.js";
 import "./chunk-M5GB774H.js";
-import "./chunk-ZVP4PWBU.js";
 import {
   ACP_EVENT_LOOP_STALL_RESTART_MS,
   CHANNEL_PROMPT_META_KEY
-} from "./chunk-IXEZHTDR.js";
+} from "./chunk-U4DJ5XB3.js";
 import {
   AgentSideConnection,
   PROTOCOL_VERSION,
   RequestError
 } from "./chunk-IW6RQPQB.js";
+import "./chunk-ZVP4PWBU.js";
 import {
   assembleMcpServers,
   loadMcpApprovals
-} from "./chunk-ND7TQQPE.js";
+} from "./chunk-C2VWOXHS.js";
 import {
+  deleteNestedPropertySafe,
   getOutputLanguageFilePath,
   getPersistScopeForModelSelection,
   getUserSettingsPath,
+  getWritableScopes,
   loadSettings,
   resolveOutputLanguageOrPreserveAuto,
+  settingExistsInScope,
   updateOutputLanguageFile,
   writeOutputLanguageAndRegisterPath
-} from "./chunk-AAX236AR.js";
-import "./chunk-NT5XIL5H.js";
+} from "./chunk-VWTSRH6C.js";
+import "./chunk-NQ4L2CMD.js";
 import "./chunk-RKUWKYED.js";
-import "./chunk-GOXKNSDZ.js";
+import "./chunk-O5CD7T4T.js";
 import {
   getSystemDefaultsPath,
   getSystemSettingsPath
@@ -307,7 +323,7 @@ import {
 import {
   getCurrentLanguage,
   setLanguageAsync
-} from "./chunk-EU2B4P3D.js";
+} from "./chunk-I4NRYS6A.js";
 import {
   SUPPORTED_LANGUAGES
 } from "./chunk-5EJZE3FP.js";
@@ -315,19 +331,19 @@ import {
   findEnvFiles,
   preResolveHomeEnvOverrides,
   reloadEnvironment
-} from "./chunk-T4RMUTTT.js";
+} from "./chunk-C4TIXFDZ.js";
 import {
   ENV_ACP_REPEATED_TOOL_FAILURE_GUARD,
   QWEN_CODE_SERVE_ENV
-} from "./chunk-3452WXOK.js";
-import "./chunk-7XL4WRXM.js";
-import "./chunk-ZYPJ7HVZ.js";
+} from "./chunk-2M3EWQNG.js";
+import "./chunk-2EAZ43JQ.js";
+import "./chunk-NF5J2WFA.js";
+import "./chunk-VBWD6C27.js";
 import "./chunk-W3N5XAZ6.js";
 import {
-  isFolderTrustEnabled,
   isWorkspaceTrusted,
   loadTrustedFolders
-} from "./chunk-I75VKFCJ.js";
+} from "./chunk-65HWLGA7.js";
 import "./chunk-NPQ5ZKRP.js";
 import "./chunk-MR3PXB6E.js";
 import {
@@ -357,42 +373,44 @@ import {
   resolveBaseUrl,
   runManagedRememberByAgent,
   subagentGenerator
-} from "./chunk-NT7LXVV5.js";
+} from "./chunk-JUARRUMA.js";
 import {
   MAX_RETAINED_SNAPSHOTS,
   deleteWorkflowSnapshot,
   listSavedWorkflows,
   listWorkflowSnapshots,
   toSnapshot
-} from "./chunk-DBTMP3P4.js";
+} from "./chunk-I2TMJPCV.js";
 import "./chunk-XFSFZCM5.js";
-import "./chunk-2EAZ43JQ.js";
-import "./chunk-NF5J2WFA.js";
 import {
   CreateSubSessionTool
-} from "./chunk-ERHAMGAA.js";
+} from "./chunk-JR42V4UY.js";
 import "./chunk-LJZSMWOH.js";
-import "./chunk-6NWPR2EB.js";
-import "./chunk-GCUR24KK.js";
-import "./chunk-W4BDHLRT.js";
 import {
   restoreWorktreeContext
-} from "./chunk-ED7DD7MV.js";
-import "./chunk-AYYKUUKP.js";
-import "./chunk-PWR2NQBS.js";
+} from "./chunk-RAFQIHN2.js";
+import "./chunk-L26ONV2Y.js";
+import "./chunk-47RYEQW5.js";
+import "./chunk-IG4W5SJR.js";
+import "./chunk-ZPJWUGCS.js";
+import "./chunk-4UANMABT.js";
+import "./chunk-ZKFTS3OV.js";
 import "./chunk-ENYUKMFK.js";
 import "./chunk-UKYXYWI2.js";
-import "./chunk-ZPJWUGCS.js";
 import {
   clearCachedCredentialFile,
   qwenOAuth2Events
 } from "./chunk-3AKCBZVW.js";
-import "./chunk-JDIO45X7.js";
+import "./chunk-SULZPKTA.js";
+import "./chunk-VNOVK4I7.js";
 import {
   APPROVAL_MODE_INFO,
   BranchPointInvalidError,
   ExtensionManager,
   GLOBAL_DUPLICATE_THRESHOLD,
+  GoalConflictError,
+  GoalInvalidTransitionError,
+  GoalPersistenceUnavailableError,
   InvalidMcpConfigError,
   InvalidSessionTranscriptCursorError,
   MAX_TRANSCRIPT_MESSAGES,
@@ -438,6 +456,7 @@ import {
   decoratePlanModeShellConfirmation,
   dedupeToolCallsById,
   didWriteProjectContextFile,
+  emptyGoalSnapshot,
   encodeSessionTranscriptCursor,
   evaluateAutoMode,
   evaluatePermissionFlow,
@@ -465,6 +484,7 @@ import {
   getStopHookContinuationReason,
   getToolCallRepeatKey,
   getWorkflowTaskMutationKey,
+  goalTurnContext,
   ideContextStore,
   injectPermissionRulesIfMissing,
   isApproveOutcome,
@@ -482,6 +502,9 @@ import {
   normalizeDerivedBranchTitle,
   normalizeTurnResultError,
   observeToolResultBoundary,
+  parseGoalControlRequest,
+  parseGoalSnapshotV2,
+  parseGoalStateCause,
   persistPermissionOutcome,
   recordAllow,
   recordFallbackApprove,
@@ -504,7 +527,7 @@ import {
   updateSetting,
   validatePlanModeShellApproval,
   validatePlanModeShellContext
-} from "./chunk-ZBDYI7VM.js";
+} from "./chunk-4F7GQGXB.js";
 import "./chunk-GOFAQQZA.js";
 import "./chunk-5M6IDOMF.js";
 import "./chunk-6HUXPLB5.js";
@@ -512,9 +535,10 @@ import "./chunk-TWPJO254.js";
 import {
   external_exports
 } from "./chunk-CQ35AJ4Z.js";
-import "./chunk-SMJYTKTB.js";
+import "./chunk-NSUKQ4DN.js";
+import "./chunk-DQCKVAF5.js";
 import "./chunk-AI35S34R.js";
-import "./chunk-FIWZOMBF.js";
+import "./chunk-KM3XVTMO.js";
 import {
   parsePositiveIntegerEnv
 } from "./chunk-6PVPNMXU.js";
@@ -524,11 +548,13 @@ import {
 import {
   SESSION_ARTIFACT_PERSISTENCE_VERSION,
   normalizeEventPayload,
-  normalizeSnapshotPayload
-} from "./chunk-DJBQCO2E.js";
+  normalizeSnapshotPayload,
+  wrapUserPromptSubmitContext
+} from "./chunk-EFTPIZIC.js";
 import "./chunk-IRH27ZC2.js";
 import "./chunk-QHWCP53L.js";
 import "./chunk-UJ4DUYIH.js";
+import "./chunk-QJNDUTOL.js";
 import {
   promptIdContext,
   todoWorkChainContext
@@ -538,9 +564,9 @@ import {
   getOutputStyleTurnReminder,
   getPlanModeSystemReminder,
   resolveMainSessionOutputStyle
-} from "./chunk-YDQ4OCDK.js";
-import "./chunk-SDCHI64N.js";
-import "./chunk-B2RIIK3K.js";
+} from "./chunk-OSSTATJF.js";
+import "./chunk-ZHO2CW6D.js";
+import "./chunk-CVX63TFJ.js";
 import "./chunk-373DQUVA.js";
 import {
   AgentOutputMessageCapture,
@@ -549,64 +575,47 @@ import {
   addToolCallResultAttributes,
   registerAcpEventLoopLagGauge,
   startEventLoopLagMonitor
-} from "./chunk-OSTQZIOY.js";
+} from "./chunk-H43PSPYS.js";
 import {
   HookEventName,
   createHookOutput
 } from "./chunk-U6D2PPMN.js";
-import "./chunk-PDXYZBBQ.js";
-import "./chunk-QJNDUTOL.js";
-import "./chunk-ZHO2CW6D.js";
-import "./chunk-AF3QB6OL.js";
+import "./chunk-VYIUNFEA.js";
+import "./chunk-KGV55H53.js";
 import "./chunk-7TBU7PU2.js";
 import "./chunk-E4JNFXNI.js";
-import {
-  GoalConflictError,
-  GoalInvalidTransitionError,
-  GoalPersistenceUnavailableError,
-  emptyGoalSnapshot,
-  goalTurnContext,
-  parseGoalControlRequest,
-  parseGoalSnapshotV2,
-  parseGoalStateCause
-} from "./chunk-4P7PPAHN.js";
-import {
-  wrapUserPromptSubmitContext
-} from "./chunk-7J6OTNGO.js";
 import {
   escapeJsonTagCharacters
 } from "./chunk-CHEIIBT3.js";
-import "./chunk-VYSZUQGU.js";
+import "./chunk-TJYRTS4S.js";
 import {
   APPROVAL_MODES
 } from "./chunk-JX6XHPTX.js";
 import "./chunk-MLXTMF7H.js";
-import "./chunk-NAVJD2PQ.js";
-import "./chunk-KFN2IZYR.js";
-import "./chunk-GB4UKWY5.js";
-import "./chunk-QHMLYMMS.js";
-import {
-  addDaemonRequestAttribute,
-  extractDaemonTraceContext,
-  withDaemonSpan
-} from "./chunk-UXEW7TQS.js";
-import "./chunk-VNOVK4I7.js";
 import "./chunk-PQEISIKS.js";
-import "./chunk-RT4QNQ5P.js";
+import "./chunk-FD5SJOWT.js";
 import {
   runWithRuntimeContentGenerator
-} from "./chunk-26SIKQIC.js";
+} from "./chunk-4LIFGNI4.js";
 import "./chunk-S6LOFUVP.js";
+import "./chunk-NAVJD2PQ.js";
+import "./chunk-KFN2IZYR.js";
+import "./chunk-GB4UKWY5.js";
+import "./chunk-QHMLYMMS.js";
 import {
   getToolCallPreparations
 } from "./chunk-CFKIH3D3.js";
 import {
-  REASONING_EFFORT_TIERS,
-  applyReasoningEffort
+  REASONING_EFFORT_TIERS
 } from "./chunk-2LD5U7Q3.js";
 import "./chunk-DJ2GSRLV.js";
 import "./chunk-S2T7H5MI.js";
 import "./chunk-LKODFJRD.js";
+import {
+  addDaemonRequestAttribute,
+  extractDaemonTraceContext,
+  withDaemonSpan
+} from "./chunk-LB3WQQJK.js";
 import {
   ConversationFinishedEvent,
   DiscoveredMCPTool,
@@ -632,25 +641,23 @@ import {
   logUserPrompt,
   normalizeParts,
   parseInvocationContext,
+  runSideQuery,
   runVisionBridge,
   runWithInvocationContext,
   shouldRunVisionBridge,
   splitImageParts,
   uiTelemetryService
-} from "./chunk-FXUSWLBF.js";
+} from "./chunk-GH2S4GD5.js";
 import "./chunk-XBVNNDPK.js";
 import "./chunk-VGC4I5JJ.js";
 import {
   getAllMemoryFilenames,
   getSpecificMimeType
-} from "./chunk-67AY5D3M.js";
+} from "./chunk-DYTW3QVG.js";
 import {
   getAutoMemoryRoot,
   getUserAutoMemoryRoot
 } from "./chunk-HT5S5TRQ.js";
-import {
-  runSideQuery
-} from "./chunk-LMMHS3RS.js";
 import "./chunk-WZAD4ZNJ.js";
 import {
   DEFAULT_TOKEN_LIMIT,
@@ -660,8 +667,7 @@ import "./chunk-EIJT2PQ6.js";
 import {
   hasVertexProjectConfigured,
   preloadContentGenerator
-} from "./chunk-H5GPPDGY.js";
-import "./chunk-XZA32HII.js";
+} from "./chunk-BFY33IB4.js";
 import "./chunk-KHP66DFN.js";
 import {
   AuthType
@@ -677,16 +683,16 @@ import {
   startToolExecutionSpan,
   startToolSpan,
   withInteractionSpan
-} from "./chunk-TBJ3SNS3.js";
+} from "./chunk-QKDNS6FU.js";
 import "./chunk-74TONY4F.js";
-import "./chunk-IXHV5MIC.js";
+import "./chunk-ZDFQGHZH.js";
 import {
   FORK_SUBAGENT_TYPE,
   getStartupContextLength,
   isSystemReminderContent,
   wrapSystemReminder
-} from "./chunk-D7D3HSYQ.js";
-import "./chunk-YKADANK6.js";
+} from "./chunk-G7HBEEX7.js";
+import "./chunk-QQD2GART.js";
 import "./chunk-AQ37AY7B.js";
 import "./chunk-ODZF64DM.js";
 import {
@@ -696,7 +702,7 @@ import {
   ToolNames,
   canonicalToolName,
   isShellProgressData
-} from "./chunk-LYSZVCCD.js";
+} from "./chunk-7JMGTOH7.js";
 import {
   Storage,
   createDebugLogger,
@@ -705,11 +711,11 @@ import {
   isSubpath,
   sessionIdContext
 } from "./chunk-EAHOJF6V.js";
-import "./chunk-FHPYRXRH.js";
-import "./chunk-WLEYH7CD.js";
+import "./chunk-QJGYU5PG.js";
+import "./chunk-HRPFBHW7.js";
 import {
   runExitCleanup
-} from "./chunk-TV7BJ7TX.js";
+} from "./chunk-RJUVTJEZ.js";
 import {
   writeStderrLine,
   writeStderrLineSafe
@@ -4049,6 +4055,10 @@ var Session = class {
     this.slashCommandPolicy = this.requiresManagedConversationBinding ? STANDALONE_SLASH_COMMAND_POLICY : void 0;
     this.runtimeBaseDir = config.storage.getRuntimeBaseDir();
     const todoStopGuardEnabled = this.settings.merged.experimental?.todoStopGuard === true && !this.config.getBareMode() && !this.config.isSafeMode();
+    const sessionWorkflowEnabledFromSettings = this.settings.merged.experimental?.sessionWorkflow === true;
+    this.config.setSessionWorkflowEnabledProvider?.(
+      () => sessionWorkflowEnabledFromSettings
+    );
     this.todoStopGuard = new DaemonTodoStopGuard(todoStopGuardEnabled);
     const configuredGuardMode = process.env[ENV_ACP_REPEATED_TOOL_FAILURE_GUARD];
     const parsedGuardMode = parseRepeatedToolFailureGuardMode(configuredGuardMode);
@@ -4217,6 +4227,8 @@ var Session = class {
   #shellStatusChangeCallback;
   workflowApprovalAbortController = new AbortController();
   activeTodoPlanRevision;
+  activeTodoPlanStructure;
+  todoPlanRevisionGeneration = 0;
   // Modular components
   historyReplayer;
   toolCallEmitter;
@@ -4262,6 +4274,7 @@ var Session = class {
   restoredAskUserQuestionSkipPersistence = false;
   // Implement SessionContext interface
   sessionId;
+  sessionReasoningSelection;
   #bindGoalRuntime() {
     try {
       const runtime = this.config.getGoalRuntime();
@@ -4781,7 +4794,10 @@ var Session = class {
     this.#clearTodoStopGuardTrustAndDrainAutomaticQueues();
   }
   clearActiveTodoPlanRevision() {
+    this.todoPlanRevisionGeneration++;
     this.activeTodoPlanRevision = void 0;
+    this.activeTodoPlanStructure = void 0;
+    this.config.clearSessionWorkflowPlanRevision?.();
   }
   hardSuspendTodoStopGuard() {
     this.#clearTodoStopGuardQueuedPromptWait();
@@ -5683,6 +5699,7 @@ var Session = class {
   dispose() {
     this.disposed = true;
     this.closing = true;
+    this.clearActiveTodoPlanRevision();
     this.pendingPrompt?.abort(SESSION_DISPOSE_ABORT_REASON);
     this.pendingPrompt = null;
     this.resolveCloseGate?.();
@@ -5733,6 +5750,7 @@ var Session = class {
       this.#workflowStatusChangeCallback = void 0;
     }
     this.config.getChatRecordingService()?.setTitleRecordedCallback(void 0);
+    this.config.getSessionService().setSessionPrBoundCallback(void 0);
     this.unsubscribeChatRecordingFailure?.();
     this.unsubscribeChatRecordingFailure = void 0;
     this.config.setSubSessionSpawner(void 0);
@@ -5789,7 +5807,7 @@ var Session = class {
         ...options
       });
     } finally {
-      this.activeTodoPlanRevision = void 0;
+      this.clearActiveTodoPlanRevision();
     }
   }
   rewindToTurn(targetTurnIndex, opts) {
@@ -5819,7 +5837,7 @@ var Session = class {
     }
     chat.truncateHistory(apiTruncateIndex);
     chat.stripThoughtsFromHistory();
-    this.activeTodoPlanRevision = void 0;
+    this.clearActiveTodoPlanRevision();
     const preserveQueuedPromptPriority = this.todoStopGuardQueuedPromptPriority;
     const shouldDrainAutomaticQueues = (this.todoStopGuard.blocksUnrelatedAutomaticTurns || this.todoStopGuard.hasCommittedContinuation) && !preserveQueuedPromptPriority;
     this.todoStopGuard.blockUntilOrdinaryPromptStarts();
@@ -5864,7 +5882,7 @@ var Session = class {
       );
     }
     this.config.getLlmClient().getChat().setHistory(structuredClone(history));
-    this.activeTodoPlanRevision = void 0;
+    this.clearActiveTodoPlanRevision();
     this.#clearTodoStopGuardTrustAndDrainAutomaticQueues();
   }
   #computeApiTruncationIndexForUserTurn(apiHistory, targetTurnIndex) {
@@ -7984,21 +8002,80 @@ ${this.pendingRecoveredAgentsNotice}
       sessionId: this.sessionId,
       update: projectedUpdate
     };
-    if (update.sessionUpdate === "plan") {
-      this.activeTodoPlanRevision = void 0;
+    const canUpdateTodoPlanRevision = update.sessionUpdate === "plan" && this.config.getApprovalMode() === "plan" /* PLAN */;
+    const todoPlanRevision = canUpdateTodoPlanRevision ? this.#readTodoPlanRevision(update) : void 0;
+    const preservesPendingRevision = todoPlanRevision !== void 0 && todoPlanRevision.structure === this.activeTodoPlanStructure;
+    const previousActiveTodoPlanRevision = this.activeTodoPlanRevision;
+    const previousActiveTodoPlanStructure = this.activeTodoPlanStructure;
+    const previousWorkflowRevision = this.config.getSessionWorkflowPlanRevision?.();
+    if (canUpdateTodoPlanRevision && !preservesPendingRevision) {
+      this.clearActiveTodoPlanRevision();
+    }
+    try {
+      await this.client.sessionUpdate(params);
+    } catch (error) {
+      if (canUpdateTodoPlanRevision && !preservesPendingRevision && this.config.getApprovalMode() === "plan" /* PLAN */) {
+        this.activeTodoPlanRevision = previousActiveTodoPlanRevision;
+        this.activeTodoPlanStructure = previousActiveTodoPlanStructure;
+        this.config.setSessionWorkflowPlanRevision?.(previousWorkflowRevision);
+      }
+      throw error;
     }
-    await this.client.sessionUpdate(params);
-    if (update.sessionUpdate === "plan") {
-      this.#captureTodoPlanRevision(update);
+    if (canUpdateTodoPlanRevision && this.config.getApprovalMode() === "plan" /* PLAN */ && todoPlanRevision?.allPending) {
+      if (this.activeTodoPlanRevision?.planId !== todoPlanRevision.planId || this.activeTodoPlanRevision?.sourceCallId !== todoPlanRevision.sourceCallId) {
+        this.todoPlanRevisionGeneration++;
+      }
+      this.activeTodoPlanRevision = {
+        planId: todoPlanRevision.planId,
+        sourceCallId: todoPlanRevision.sourceCallId
+      };
+      this.activeTodoPlanStructure = todoPlanRevision.structure;
+      this.config.setSessionWorkflowPlanRevision?.({
+        planId: todoPlanRevision.planId,
+        sourceCallId: todoPlanRevision.sourceCallId,
+        todoIds: todoPlanRevision.todoIds
+      });
     }
   }
-  #captureTodoPlanRevision(update) {
+  #readTodoPlanRevision(update) {
     const meta = isRecord2(update["_meta"]) ? update["_meta"] : void 0;
     const plan = isRecord2(meta?.["qwenTodoPlan"]) ? meta["qwenTodoPlan"] : void 0;
     const transcript = isRecord2(meta?.["qwenTranscript"]) ? meta["qwenTranscript"] : void 0;
     const planId = plan?.["id"];
     const sourceCallId = transcript?.["planToolCallId"];
-    this.activeTodoPlanRevision = typeof planId === "string" && typeof sourceCallId === "string" && update.entries.length > 0 ? { planId, sourceCallId } : void 0;
+    const workflowPlan = meta?.["qwenSessionWorkflow"] === true;
+    const hasValidIdentity = typeof planId === "string" && planId.trim() !== "" && typeof sourceCallId === "string" && sourceCallId.trim() !== "" && update.entries.length > 0;
+    const workflowEnabled = this.config.isSessionWorkflowEnabled?.() === true;
+    if (!workflowEnabled || !workflowPlan || !hasValidIdentity)
+      return void 0;
+    const todos = update.entries.flatMap((entry) => {
+      const entryRecord = entry;
+      const entryMeta = isRecord2(entryRecord["_meta"]) ? entryRecord["_meta"] : void 0;
+      const todo = isRecord2(entryMeta?.["qwenTodo"]) ? entryMeta["qwenTodo"] : void 0;
+      const todoId = todo?.["id"];
+      const blockedBy = todo?.["blockedBy"];
+      if (typeof todoId !== "string" || todoId.trim() === "" || blockedBy !== void 0 && (!Array.isArray(blockedBy) || !blockedBy.every((dependency) => typeof dependency === "string"))) {
+        return [];
+      }
+      return [
+        {
+          id: todoId,
+          content: entry.content,
+          priority: entry.priority,
+          blockedBy: blockedBy ?? []
+        }
+      ];
+    });
+    const todoIds = todos.map((todo) => todo.id);
+    if (todos.length !== update.entries.length || new Set(todoIds).size !== todoIds.length)
+      return void 0;
+    return {
+      planId,
+      sourceCallId,
+      todoIds,
+      structure: JSON.stringify([planId, todos]),
+      allPending: update.entries.every((entry) => entry.status === "pending")
+    };
   }
   #scheduleChannelDelivery(params) {
     const timer = setTimeout(() => {
@@ -8583,7 +8660,10 @@ ${this.pendingRecoveredAgentsNotice}
       const isTimeout = error instanceof MidTurnDrainTimeoutError;
       if (isTimeout) {
         this.midTurnDrainTimeoutStrikes += 1;
-        if (drainPromise) void this.#recoverLateDrain(drainPromise);
+        if (drainPromise) {
+          void this.#recoverLateDrain(drainPromise).catch(() => {
+          });
+        }
       }
       const isPermanentError = errorCode === -32601 || /method not found/i.test(errorMessage) || isTimeout && this.midTurnDrainTimeoutStrikes >= MID_TURN_QUEUE_DRAIN_MAX_TIMEOUT_STRIKES;
       if (isPermanentError) {
@@ -9422,6 +9502,14 @@ ${this.pendingRecoveredAgentsNotice}
       }).catch(() => {
       });
     });
+    this.config.getSessionService().setSessionPrBoundCallback((sessionId, pr) => {
+      void this.client.extNotification("qwen/notify/session/pr-binding", {
+        v: 1,
+        sessionId,
+        pr: { number: pr.number, url: pr.url }
+      }).catch(() => {
+      });
+    });
     if (typeof this.config.onChatRecordingFailure === "function") {
       this.unsubscribeChatRecordingFailure = this.config.onChatRecordingFailure(
         (event) => this.client.extNotification(
@@ -10043,10 +10131,10 @@ ${this.pendingRecoveredAgentsNotice}
     }
     const previousApprovalMode = this.config.getApprovalMode();
     this.config.setApprovalMode(approvalMode);
+    if (previousApprovalMode !== approvalMode && (previousApprovalMode === "plan" /* PLAN */ || approvalMode === "plan" /* PLAN */)) {
+      this.clearActiveTodoPlanRevision();
+    }
     if (approvalMode === "plan" /* PLAN */) {
-      if (previousApprovalMode !== "plan" /* PLAN */) {
-        this.activeTodoPlanRevision = void 0;
-      }
       this.clearTodoStopGuardTrust();
     }
     void this.client.extNotification("qwen/notify/session/mode-update", {
@@ -10099,6 +10187,10 @@ ${this.pendingRecoveredAgentsNotice}
     const effectiveAuthType = after?.authType ?? selectedAuthType;
     const effectiveModelId = after?.model ?? parsed.modelId;
     const isRuntime = resolvedRoute?.isRuntime ?? rawModelId.startsWith(RUNTIME_SNAPSHOT_PREFIX);
+    const persistDefault = !this.requiresManagedConversationBinding && (options.persistDefault ?? true);
+    this.reconcileReasoningSelection(effectiveModelId, {
+      persist: persistDefault
+    });
     void recordDaemonSessionModel(this.config, {
       modelId: isRuntime ? resolvedRoute?.modelId ?? parsed.modelId : effectiveModelId,
       authType: effectiveAuthType,
@@ -10119,7 +10211,6 @@ ${this.pendingRecoveredAgentsNotice}
     }).catch((error) => {
       debugLogger6.debug("model-update extNotification failed", error);
     });
-    const persistDefault = !this.requiresManagedConversationBinding && (options.persistDefault ?? true);
     if (persistDefault) {
       const persistScope = getPersistScopeForModelSelection(this.settings);
       this.settings.setValue(
@@ -10150,6 +10241,115 @@ ${this.pendingRecoveredAgentsNotice}
       }
     };
   }
+  getDefaultReasoningConfig() {
+    const authType = this.config.getAuthType?.();
+    const model = authType && !this.config.getActiveRuntimeModelSnapshot?.() ? this.config.getResolvedModelConfig?.(
+      authType,
+      this.config.getModel(),
+      this.config.getCurrentModelRegistryBaseUrl?.() ?? void 0
+    ) : void 0;
+    if (model) return model.generationConfig.reasoning;
+    return this.settings.merged.model?.generationConfig?.reasoning;
+  }
+  reloadReasoningSelection() {
+    this.settings.reloadScopeFromDisk("User" /* User */);
+    this.settings.reloadScopeFromDisk("Workspace" /* Workspace */);
+    this.reconcileReasoningSelection(this.config.getModel(), {
+      persist: !this.requiresManagedConversationBinding
+    });
+  }
+  setSessionReasoningSelection(selection) {
+    this.sessionReasoningSelection = selection;
+  }
+  getSessionReasoningSelection() {
+    return this.sessionReasoningSelection;
+  }
+  persistReasoningSelection(selection) {
+    if (this.requiresManagedConversationBinding) {
+      throw RequestError.invalidParams(
+        void 0,
+        "Reasoning selection cannot be persisted for this session"
+      );
+    }
+    const key = "model.reasoningEffort";
+    const persistScope = getPersistScopeForModelSelection(this.settings);
+    const clears = getWritableScopes(this.settings).filter(
+      (scope) => (selection === REASONING_EFFORT_DEFAULT || scope !== persistScope) && settingExistsInScope(key, this.settings.forScope(scope).settings)
+    ).map((scope) => ({ scope, value: void 0 }));
+    const writes = selection === REASONING_EFFORT_DEFAULT ? clears : [{ scope: persistScope, value: selection }, ...clears];
+    const committed = [];
+    for (const write of writes) {
+      const previous = this.settings.forScope(write.scope).settings.model?.reasoningEffort;
+      try {
+        this.writeReasoningSelection(write.scope, write.value);
+      } catch (error) {
+        this.settings.reloadScopeFromDisk(write.scope);
+        for (const previousWrite of committed.reverse()) {
+          try {
+            this.writeReasoningSelection(
+              previousWrite.scope,
+              previousWrite.value
+            );
+          } catch (rollbackError) {
+            this.settings.reloadScopeFromDisk(previousWrite.scope);
+            debugLogger6.warn(
+              `Failed to roll back reasoning preference: ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`
+            );
+          }
+        }
+        throw error;
+      }
+      committed.push({ scope: write.scope, value: previous });
+    }
+  }
+  reconcileReasoningSelection(modelId, options) {
+    const rawSelection = this.settings.merged.model?.reasoningEffort;
+    let hasSessionSelection = this.sessionReasoningSelection !== void 0;
+    if (!hasSessionSelection && rawSelection === void 0) return;
+    let selection = hasSessionSelection ? this.sessionReasoningSelection : parseReasoningSelection(rawSelection);
+    const generation = this.config.getContentGeneratorConfig?.();
+    const thinkingMandatory = generation?.thinkingMandatory === true;
+    let supported = selection !== void 0 && selection !== REASONING_EFFORT_DEFAULT && isReasoningSelectionSupported(modelId, selection, thinkingMandatory);
+    const appliesSessionDefault = hasSessionSelection && selection === REASONING_EFFORT_DEFAULT;
+    if (hasSessionSelection && !supported && !appliesSessionDefault) {
+      this.sessionReasoningSelection = void 0;
+      hasSessionSelection = false;
+      selection = parseReasoningSelection(rawSelection);
+      supported = selection !== void 0 && selection !== REASONING_EFFORT_DEFAULT && isReasoningSelectionSupported(modelId, selection, thinkingMandatory);
+    }
+    if (!hasSessionSelection && rawSelection !== void 0 && !supported && options.persist) {
+      try {
+        this.persistReasoningSelection(REASONING_EFFORT_DEFAULT);
+      } catch (error) {
+        debugLogger6.warn(
+          `Failed to clear incompatible reasoning preference: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    const modelReasoning = getModelConfiguration(modelId)?.reasoning;
+    if (supported && generation && modelReasoning && !modelReasoning.toggleOnly) {
+      clearReasoningRequestOverrides(generation);
+    }
+    const effectiveSelection = (supported || appliesSessionDefault) && selection !== void 0 ? selection : REASONING_EFFORT_DEFAULT;
+    applyReasoningSelection(
+      this.config,
+      effectiveSelection,
+      this.getDefaultReasoningConfig()
+    );
+  }
+  writeReasoningSelection(scope, value) {
+    const key = "model.reasoningEffort";
+    this.settings.setValue(scope, key, value, void 0, {
+      throwOnWriteFailure: true
+    });
+    if (value !== void 0) return;
+    const file = this.settings.forScope(scope);
+    for (const settings of [file.settings, file.originalSettings]) {
+      if (settings)
+        deleteNestedPropertySafe(settings, key);
+    }
+    this.settings.recomputeMerged();
+  }
   /**
    * Sends a current_mode_update notification to the client.
    * Called after the agent switches modes (e.g., from exit_plan_mode tool).
@@ -10810,6 +11010,8 @@ ${this.pendingRecoveredAgentsNotice}
     let nestedPermissionCancelled = false;
     let agentToolAbortController;
     let removeAgentToolAbortPropagation;
+    let todoPlanApprovalGeneration;
+    let todoPlanApprovalRevision;
     let subAgentCleanupFunctions = [];
     const cleanupAgentToolResources = /* @__PURE__ */ __name(() => {
       subAgentCleanupFunctions.forEach((cleanup) => cleanup());
@@ -11261,8 +11463,10 @@ ${this.pendingRecoveredAgentsNotice}
                   }
                 );
               case "fallback":
-                wasAutoModeManualFallback = isDenialFallbackReason(outcome.reason) || outcome.reason === "classifier_unavailable";
-                autoModeFallbackMessage = outcome.message;
+                wasAutoModeManualFallback = isDenialFallbackReason(outcome.reason) || outcome.reason === "classifier_unavailable" || outcome.reason === "external_write";
+                if (outcome.reason === "classifier_unavailable" || outcome.reason === "external_write") {
+                  autoModeFallbackMessage = outcome.message;
+                }
                 if (wasAutoModeManualFallback) {
                   debugLogger6.warn(
                     `Auto mode fallback to manual approval (${outcome.reason}): ` + formatDenialStateLog(denialState)
@@ -11277,6 +11481,34 @@ ${this.pendingRecoveredAgentsNotice}
           }
           let didRequestPermission = false;
           let confirmationDetails;
+          const cancelStaleTodoPlanApproval = /* @__PURE__ */ __name(async () => {
+            const configRevision = this.config.getSessionWorkflowPlanRevision?.();
+            if (todoPlanApprovalGeneration === void 0 || !todoPlanApprovalRevision || todoPlanApprovalGeneration === this.todoPlanRevisionGeneration && this.activeTodoPlanRevision?.planId === todoPlanApprovalRevision.planId && this.activeTodoPlanRevision?.sourceCallId === todoPlanApprovalRevision.sourceCallId && configRevision?.planId === todoPlanApprovalRevision.planId && configRevision?.sourceCallId === todoPlanApprovalRevision.sourceCallId) {
+              return void 0;
+            }
+            try {
+              await confirmationDetails?.onConfirm(
+                "cancel" /* Cancel */
+              );
+            } catch (error) {
+              debugLogger6.warn(
+                `Failed to cancel stale plan approval: ${this.#formatError(error)}`
+              );
+            }
+            onStopAfterPermissionCancel?.();
+            return earlyErrorResponse(
+              new Error(
+                "Plan approval is stale because its Session Workflow revision changed. No action was taken."
+              ),
+              toolName,
+              {
+                status: "cancelled",
+                errorType: void 0,
+                executionStatus: "not_started",
+                stopAfterPermissionCancel: true
+              }
+            );
+          }, "cancelStaleTodoPlanApproval");
           const recordAutoModeFallbackResolution = /* @__PURE__ */ __name((outcome) => {
             if (approvalMode === "auto" /* AUTO */ && wasAutoModeManualFallback && isApproveOutcome(outcome)) {
               const before = this.config.getAutoModeDenialState();
@@ -11509,6 +11741,12 @@ ${this.pendingRecoveredAgentsNotice}
               const offeredPermissionOptions = permissionOptions.map(
                 (option) => ({ ...option })
               );
+              const workflowPlanRevision = isExitPlanModeTool ? this.config.getSessionWorkflowPlanRevision?.() : void 0;
+              const qwenTodoApproval = isExitPlanModeTool && this.activeTodoPlanRevision && workflowPlanRevision?.planId === this.activeTodoPlanRevision.planId && workflowPlanRevision.sourceCallId === this.activeTodoPlanRevision.sourceCallId ? this.activeTodoPlanRevision : void 0;
+              if (qwenTodoApproval) {
+                todoPlanApprovalGeneration = this.todoPlanRevisionGeneration;
+                todoPlanApprovalRevision = qwenTodoApproval;
+              }
               const params = {
                 sessionId: this.sessionId,
                 options: permissionOptions,
@@ -11527,9 +11765,7 @@ ${this.pendingRecoveredAgentsNotice}
                   _meta: {
                     toolName,
                     ...interactionMetaFields(confirmationDetails),
-                    ...isExitPlanModeTool && this.activeTodoPlanRevision ? {
-                      qwenTodoApproval: this.activeTodoPlanRevision
-                    } : {}
+                    ...qwenTodoApproval ? { qwenTodoApproval } : {}
                   }
                 }
               };
@@ -11560,6 +11796,8 @@ ${this.pendingRecoveredAgentsNotice}
                 if (permissionRequestCancellation) {
                   return permissionRequestCancellation;
                 }
+                const staleTodoPlanApproval2 = await cancelStaleTodoPlanApproval();
+                if (staleTodoPlanApproval2) return staleTodoPlanApproval2;
                 outcome = resolvePermissionOutcome(
                   output,
                   offeredPermissionOptions
@@ -11816,6 +12054,8 @@ ${this.pendingRecoveredAgentsNotice}
           if (executionBoundaryCancellation) {
             return executionBoundaryCancellation;
           }
+          const staleTodoPlanApproval = await cancelStaleTodoPlanApproval();
+          if (staleTodoPlanApproval) return staleTodoPlanApproval;
           const continuedAgentId = toolName === ToolNames.SEND_MESSAGE && typeof args["task_id"] === "string" && args["task_id"].length > 0 ? args["task_id"] : void 0;
           const provisionalRelatedAgent = continuedAgentId !== void 0 && !this.relatedAgentIds.has(continuedAgentId);
           if (provisionalRelatedAgent) {
@@ -11977,7 +12217,7 @@ ${this.pendingRecoveredAgentsNotice}
           if ((isEnterPlanModeTool || isExitPlanModeTool) && !toolResult.error && this.config.getApprovalMode() !== approvalMode) {
             await this.sendCurrentModeUpdateNotification();
             if (this.config.getApprovalMode() === "plan" /* PLAN */) {
-              this.activeTodoPlanRevision = void 0;
+              this.clearActiveTodoPlanRevision();
               this.#clearTodoStopGuardTrustAndDrainAutomaticQueues();
             }
           }
@@ -12326,12 +12566,18 @@ ${this.pendingRecoveredAgentsNotice}
     this.refreshContextFilesOnWrite = result.type === "submit_prompt" && Boolean(result.refreshContextFilesOnWrite);
     const recorder = shouldRecordResult ? this.config.getChatRecordingService() : void 0;
     switch (result.type) {
-      case "submit_prompt":
+      case "submit_prompt": {
+        const expandedPrompt = normalizePartList(result.content);
+        const attachmentBlocks = result.resolvedCommand?.kind === "built-in" /* BUILT_IN */ ? [] : originalPrompt.filter((block) => block.type !== "text");
+        const attachmentParts = attachmentBlocks.length === 0 ? [] : await this.#resolvePrompt(attachmentBlocks, abortSignal, {
+          deferBridgeConversions: true
+        });
         return this.#applyBridgeConversionsIfNeeded(
-          normalizePartList(result.content),
+          [...attachmentParts, ...expandedPrompt],
           abortSignal,
           onFullTurnModel
         );
+      }
       case "message": {
         if (result.messageType === "error") {
           throw new Error(result.content || "Slash command failed.");
@@ -15067,6 +15313,23 @@ function readCoreSettingValues(source) {
   return values;
 }
 __name(readCoreSettingValues, "readCoreSettingValues");
+function foldReloadApprovalMode(raw) {
+  if (!raw) {
+    return "auto" /* AUTO */;
+  }
+  if (typeof raw === "string") {
+    try {
+      return parseApprovalModeValue(raw);
+    } catch {
+    }
+  }
+  return void 0;
+}
+__name(foldReloadApprovalMode, "foldReloadApprovalMode");
+function isRestrictedApprovalModeConfig(config) {
+  return config.isSafeMode?.() === true || config.getBareMode?.() === true;
+}
+__name(isRestrictedApprovalModeConfig, "isRestrictedApprovalModeConfig");
 function normalizeCoreSettingValue(key, value) {
   const definition = QWEN_CORE_SETTING_DEFINITIONS[key];
   switch (definition.type) {
@@ -16256,6 +16519,26 @@ var QwenAgent = class _QwenAgent {
   transcriptReplayConfigCache = /* @__PURE__ */ new Map();
   pendingConfigCleanup = /* @__PURE__ */ new Map();
   initializingConfigs = /* @__PURE__ */ new Set();
+  sessionWorkflowEnabledOverride;
+  /**
+   * The last file-derived approval mode each live session actually
+   * converged on, seeded with the session's boot-derived mode at
+   * publication. `workspaceReload` compares the reloaded disk value against
+   * this — not against each session's live mode — because approval mode has
+   * runtime-only writers (`ExitPlanModeTool` approved plan exits, ACP
+   * `session/set_mode`, the `sessionApprovalMode` ext) that never persist,
+   * so a live session legitimately diverges from the file mid-workflow and
+   * an unchanged file must not clobber those transitions. The record lives
+   * on the daemon so it survives a `this.settings` cache swap, and per
+   * session because one daemon-wide baseline cannot represent a partially
+   * applied convergence: while a session skipped mid-flip still waits for
+   * its value, the file can round-trip back to the old baseline and strand
+   * the already-flipped sessions on the intermediate mode. An entry advances
+   * only when that session successfully converges, so skipped sessions and
+   * failed applies retry on the next reload, and an unparseable file value
+   * (undefined fold) is never recorded.
+   */
+  sessionApprovalModeConverged = /* @__PURE__ */ new Map();
   managedShuttingDown = false;
   clientCapabilities;
   /** Set once the daemon negotiates active-work reporting; one per channel. */
@@ -16648,6 +16931,10 @@ var QwenAgent = class _QwenAgent {
           config.setAllowedMcpServers(gating.allowed);
           config.setPendingMcpServers(gating.pending);
           await config.reinitializeMcpServers(mcpServers);
+          const llmClient = config.getLlmClient?.();
+          if (llmClient?.isInitialized?.()) {
+            await llmClient.setTools?.();
+          }
         } catch (error) {
           syncErrors.push(error);
         }
@@ -16770,6 +17057,7 @@ var QwenAgent = class _QwenAgent {
       cleanupErrors.push(error);
     }
     this.sessions.delete(sessionId);
+    this.sessionApprovalModeConverged.delete(sessionId);
     try {
       this.pruneDrainedWorkflowRegistries();
       const registry = session.getConfig().getWorkflowRunRegistry?.();
@@ -17121,7 +17409,7 @@ var QwenAgent = class _QwenAgent {
     }
     this.clientCapabilities = args.clientCapabilities;
     const authMethods = buildAuthMethods();
-    const version = "0.22.3-nightly.20260831.3a0c4c6108";
+    const version = "0.23.0";
     const response = {
       protocolVersion: PROTOCOL_VERSION,
       agentInfo: {
@@ -17214,7 +17502,11 @@ var QwenAgent = class _QwenAgent {
     }
     await clearCachedCredentialFile();
     try {
-      await this.config.refreshAuth(method);
+      await this.refreshAuthWithPersistedReasoning(
+        this.config,
+        this.settings,
+        method
+      );
       this.settings.setValue(
         "User" /* User */,
         "security.auth.selectedType",
@@ -17341,7 +17633,7 @@ var QwenAgent = class _QwenAgent {
             if (!provisionalStandalone) {
               await profiler.time(
                 "auth",
-                () => this.ensureAuthenticated(config)
+                () => this.ensureAuthenticated(config, settings)
               );
               initializationDeadline?.signal.throwIfAborted();
               profiler.timeSync(
@@ -17578,7 +17870,10 @@ var QwenAgent = class _QwenAgent {
             () => restoreSessionModelThenAuthenticate(
               config,
               projection,
-              () => profiler.time("auth", () => this.ensureAuthenticated(config))
+              () => profiler.time(
+                "auth",
+                () => this.ensureAuthenticated(config, settings)
+              )
             )
           );
           profiler.timeSync(
@@ -17599,7 +17894,7 @@ var QwenAgent = class _QwenAgent {
                   projection,
                   () => profiler.time(
                     "auth",
-                    () => this.ensureAuthenticated(config)
+                    () => this.ensureAuthenticated(config, settings)
                   )
                 )
               ), "beforeDeferredWorkspaceActivation")
@@ -17886,7 +18181,10 @@ var QwenAgent = class _QwenAgent {
             () => restoreSessionModelThenAuthenticate(
               config,
               projection,
-              () => profiler.time("auth", () => this.ensureAuthenticated(config))
+              () => profiler.time(
+                "auth",
+                () => this.ensureAuthenticated(config, settings)
+              )
             )
           );
           profiler.timeSync(
@@ -17907,7 +18205,7 @@ var QwenAgent = class _QwenAgent {
                   projection,
                   () => profiler.time(
                     "auth",
-                    () => this.ensureAuthenticated(config)
+                    () => this.ensureAuthenticated(config, settings)
                   )
                 )
               ), "beforeDeferredWorkspaceActivation")
@@ -18073,62 +18371,81 @@ var QwenAgent = class _QwenAgent {
           break;
         }
         case "reasoning_effort": {
-          const generation = session.getConfig().getContentGeneratorConfig();
-          const thinkingMandatory = generation.thinkingMandatory === true;
-          const modelReasoning = this.getModelReasoningConfiguration(
-            session.getConfig()
-          );
-          if (modelReasoning) {
-            const effortValues = modelReasoning.toggleOnly ? void 0 : modelReasoning.efforts;
-            const selected = value === REASONING_EFFORT_NONE && !thinkingMandatory ? REASONING_EFFORT_NONE : modelReasoning.toggleOnly ? value === REASONING_EFFORT_DEFAULT ? REASONING_EFFORT_DEFAULT : void 0 : effortValues?.find((effort2) => effort2 === value);
-            if (!selected) {
-              const choices = [
-                ...thinkingMandatory ? [] : [REASONING_EFFORT_NONE],
-                ...effortValues ?? [REASONING_EFFORT_DEFAULT]
-              ];
-              throw RequestError.invalidParams(
-                void 0,
-                `Unknown reasoning effort: ${value}. Choose one of: ${choices.join(", ")}`
-              );
-            }
-            if (!modelReasoning.toggleOnly) {
-              for (const source of ["extra_body", "samplingParams"]) {
-                const layer = generation[source];
-                if (!layer) continue;
-                const next = { ...layer };
-                delete next["enable_thinking"];
-                delete next["reasoning_effort"];
-                delete next["thinking_budget"];
-                generation[source] = next;
-              }
-            }
-            if (selected === REASONING_EFFORT_NONE) {
-              generation.reasoning = false;
-            } else if (selected === REASONING_EFFORT_DEFAULT) {
-              generation.reasoning = void 0;
-            } else {
-              const current = generation.reasoning;
-              generation.reasoning = {
-                ...current || {},
-                effort: selected
-              };
-            }
-            break;
-          }
-          const effort = value === REASONING_EFFORT_DEFAULT ? void 0 : REASONING_EFFORT_TIERS.find((tier) => tier === value);
-          if (value !== REASONING_EFFORT_DEFAULT && effort === void 0) {
+          const config = session.getConfig();
+          const generation = config.getContentGeneratorConfig();
+          const option = this.buildConfigOptions(config).find(
+            (candidate) => candidate.id === "reasoning_effort"
+          );
+          const modelReasoning = this.getModelReasoningConfiguration(config);
+          const selected = parseReasoningSelection(value);
+          const choices = option?.options.flatMap(
+            (choice) => "value" in choice ? [choice.value] : choice.options.map((nested) => nested.value)
+          ) ?? [];
+          if (!option || !selected || selected !== REASONING_EFFORT_DEFAULT && !choices.includes(selected)) {
+            const allowedChoices = modelReasoning ? choices : [
+              REASONING_EFFORT_DEFAULT,
+              ...choices.filter(
+                (choice) => choice !== REASONING_EFFORT_DEFAULT
+              )
+            ];
             throw RequestError.invalidParams(
               void 0,
-              `Unknown reasoning effort: ${value}. Choose one of: ${REASONING_EFFORT_DEFAULT}, ${REASONING_EFFORT_TIERS.join(", ")}`
+              option ? `Unknown reasoning effort: ${String(value)}. Choose one of: ${allowedChoices.join(", ")}` : "Reasoning is not supported by the current model"
             );
           }
-          if (!applyReasoningEffort(session.getConfig(), effort)) {
+          const persist = params._meta?.[PERSIST_REASONING_SELECTION_META_KEY] === true;
+          const tierSelected = selected !== REASONING_EFFORT_NONE && selected !== REASONING_EFFORT_DEFAULT;
+          if (!modelReasoning && tierSelected && generation.reasoning === false) {
             throw RequestError.invalidParams(
               void 0,
               "Reasoning effort cannot be applied while thinking is disabled"
             );
           }
-          break;
+          const defaultReasoning = session.getDefaultReasoningConfig();
+          const previous = {
+            reasoning: generation.reasoning,
+            extra_body: generation.extra_body,
+            samplingParams: generation.samplingParams
+          };
+          const rebuildable = config.getModelsConfig?.()?.getGenerationConfig?.();
+          const previousRebuildableReasoning = rebuildable?.reasoning;
+          try {
+            if (modelReasoning && !modelReasoning.toggleOnly) {
+              clearReasoningRequestOverrides(generation);
+            }
+            applyReasoningSelection(config, selected, defaultReasoning);
+            if (!modelReasoning && selected !== REASONING_EFFORT_NONE) {
+              config.setReasoningEffort?.(
+                selected === REASONING_EFFORT_DEFAULT ? defaultReasoning ? defaultReasoning.effort : void 0 : selected
+              );
+            }
+            const configOptions = this.buildConfigOptions(config);
+            const confirmedValue = configOptions.find(
+              (candidate) => candidate.id === "reasoning_effort"
+            )?.currentValue;
+            const confirmed = selected === REASONING_EFFORT_DEFAULT ? confirmedValue !== void 0 : confirmedValue === selected;
+            if (!confirmed) {
+              throw RequestError.invalidParams(
+                void 0,
+                modelReasoning ? `Reasoning selection was not applied: ${selected}` : "Reasoning effort cannot be applied while thinking is disabled"
+              );
+            }
+            if (persist) {
+              session.persistReasoningSelection(selected);
+            }
+            session.setSessionReasoningSelection(
+              persist ? void 0 : selected
+            );
+            return {
+              configOptions,
+              ...persist ? { _meta: { [REASONING_SELECTION_PERSISTED_META_KEY]: true } } : {}
+            };
+          } catch (error) {
+            Object.assign(generation, previous);
+            if (rebuildable)
+              rebuildable.reasoning = previousRebuildableReasoning;
+            throw error;
+          }
         }
         default:
           throw RequestError.invalidParams(
@@ -18512,7 +18829,12 @@ var QwenAgent = class _QwenAgent {
               hasOAuthTokens = credentials !== null;
             } catch {
             }
-            const rawStatus = this.getMcpServerStatus(config, name);
+            const poolRow = poolByName[name];
+            const rawStatus = poolRow ? poolRow.entrySummary.some(
+              (entry) => entry.status === "connected" /* CONNECTED */
+            ) ? "connected" /* CONNECTED */ : poolRow.entrySummary.some(
+              (entry) => entry.status === "connecting" /* CONNECTING */
+            ) ? "connecting" /* CONNECTING */ : "disconnected" /* DISCONNECTED */ : this.getMcpServerStatus(config, name);
             const requiresAuth = rawStatus !== "connected" /* CONNECTED */ && (mcpServerRequiresOAuth.get(name) === true || server.oauth?.enabled === true && !hasOAuthTokens);
             const refusedByBudget = refusedSet.has(name);
             const effectivelyRefused = refusedByBudget && !disabled;
@@ -18602,7 +18924,6 @@ var QwenAgent = class _QwenAgent {
                 out.config = serverConfig;
               }
             }
-            const poolRow = poolByName[name];
             if (poolRow) {
               out.entryCount = poolRow.entryCount;
               out.entrySummary = poolRow.entrySummary.map((e) => ({
@@ -19055,13 +19376,18 @@ var QwenAgent = class _QwenAgent {
           providers.set(authType, provider);
         }
         const isCurrent = currentAuth === model.authType && currentAcpModelId === modelId;
-        const configOptions = model.isRuntimeModel || modelId.startsWith(ACP_ROUTE_ID_PREFIX) ? void 0 : buildModelReasoningConfigPreview(model.id, {
-          thinkingMandatory: config.getResolvedModelConfig?.(
-            model.authType,
+        const configOptions = model.isRuntimeModel || modelId.startsWith(ACP_ROUTE_ID_PREFIX) ? void 0 : buildModelReasoningConfigPreview(
+          model.id,
+          resolvePersistedReasoningConfigState(
             model.id,
-            model.registryBaseUrl ?? model.baseUrl
-          )?.generationConfig.thinkingMandatory === true
-        });
+            this.settings.merged.model?.reasoningEffort,
+            config.getResolvedModelConfig?.(
+              model.authType,
+              model.id,
+              model.registryBaseUrl ?? model.baseUrl
+            )?.generationConfig.thinkingMandatory === true
+          )
+        );
         const providerModel = {
           modelId,
           baseModelId: parseAcpBaseModelId(effectiveModelId),
@@ -20020,7 +20346,11 @@ var QwenAgent = class _QwenAgent {
           settings: adapter,
           reloadModelProviders: /* @__PURE__ */ __name((modelProviders) => this.config.reloadModelProvidersConfig(modelProviders), "reloadModelProviders"),
           syncAuthState: /* @__PURE__ */ __name((authType, modelId, baseUrl) => this.config.getModelsConfig().syncAfterAuthRefresh(authType, modelId, baseUrl), "syncAuthState"),
-          refreshAuth: /* @__PURE__ */ __name((authType) => this.config.refreshAuth(authType), "refreshAuth")
+          refreshAuth: /* @__PURE__ */ __name((authType) => this.refreshAuthWithPersistedReasoning(
+            this.config,
+            this.settings,
+            authType
+          ), "refreshAuth")
         });
         const effectiveModelId = adapter.getValue("model.name") ?? plan.modelSelection?.modelId;
         const effectiveBaseUrl = adapter.getValue("model.baseUrl") ?? plan.modelSelection?.baseUrl;
@@ -21740,7 +22070,19 @@ var QwenAgent = class _QwenAgent {
         const previousCwd = config.getTargetDir();
         let trustValidated = false;
         const validateTrust = /* @__PURE__ */ __name(() => {
-          if (managedTrustAllowed || !isFolderTrustEnabled(this.settings.merged)) {
+          if (managedTrustAllowed || // Folder-trust enablement is bound to the workspace this session
+          // was admitted under: `config.getFolderTrust()` is
+          // `security.folderTrust.enabled` from that workspace, set once at
+          // construction and never moved by `relocateWorkingDirectory`.
+          // Deliberately NOT the process-wide `this.settings` cache (holds
+          // another workspace's value in a multi-workspace daemon — the bug
+          // this fixes), and deliberately NOT a live re-read keyed on the
+          // current cwd: a cd moves `targetDir` into a subdirectory that
+          // carries no `.qwen/settings.json`, so a cwd-keyed read resolves
+          // disabled after the first cd and disarms the gate for the rest of
+          // the session. `security.folderTrust.enabled` is `requiresRestart`,
+          // so binding it at admission matches its declared semantics.
+          !config.getFolderTrust()) {
             trustValidated = true;
             return;
           }
@@ -21901,9 +22243,25 @@ var QwenAgent = class _QwenAgent {
             session.clearActiveTodoPlanRevision();
           }
           session.clearTodoStopGuardTrust();
+        } else if (previous === "plan") {
+          session.clearActiveTodoPlanRevision();
         }
         return { previous, current };
       }
+      case SERVE_CONTROL_EXT_METHODS.workspaceSessionWorkflow: {
+        const enabled = params["enabled"];
+        if (typeof enabled !== "boolean") {
+          throw RequestError.invalidParams(
+            void 0,
+            "Invalid or missing Session Workflow setting"
+          );
+        }
+        if (this.sessionWorkflowEnabledOverride === enabled) {
+          return { enabled, sessionsUpdated: 0 };
+        }
+        const sessionsUpdated = this.applySessionWorkflowOverrideToLiveSessions(enabled);
+        return { enabled, sessionsUpdated };
+      }
       case SERVE_CONTROL_EXT_METHODS.sessionLanguage: {
         const sessionId = params["sessionId"];
         const language = params["language"];
@@ -22009,6 +22367,51 @@ var QwenAgent = class _QwenAgent {
         }
         return { language: resolvedLanguage, outputLanguage, refreshed };
       }
+      case SERVE_CONTROL_EXT_METHODS.userLanguage: {
+        const language = params["language"];
+        const syncOutputLanguage = params["syncOutputLanguage"] === true;
+        const allowedLanguages = [
+          ...SUPPORTED_LANGUAGES.map((l) => l.code),
+          "auto"
+        ];
+        if (typeof language !== "string" || !allowedLanguages.includes(language)) {
+          throw RequestError.invalidParams(
+            void 0,
+            `Invalid language; must be one of: ${allowedLanguages.join(", ")}`
+          );
+        }
+        try {
+          await setLanguageAsync(language);
+        } catch (err) {
+          debugLogger9.warn("setLanguageAsync failed:", err);
+          throw new RequestError(
+            -32603,
+            `Failed to switch UI language: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+        const resolvedLanguage = getCurrentLanguage();
+        this.settings.reloadScopeFromDisk("User" /* User */);
+        let sessions = 0;
+        let failed = 0;
+        if (syncOutputLanguage) {
+          const allSessions = [...this.sessions.values()];
+          const results = await Promise.allSettled(
+            allSessions.map(async (s) => {
+              const cfg = s.getConfig();
+              await cfg.refreshHierarchicalMemory();
+              await cfg.getLlmClient()?.refreshSystemInstruction();
+            })
+          );
+          sessions = results.length;
+          failed = results.filter((r) => r.status === "rejected").length;
+          if (failed > 0) {
+            debugLogger9.warn(
+              `User language refresh failed for ${failed}/${results.length} session(s)`
+            );
+          }
+        }
+        return { language: resolvedLanguage, sessions, failed };
+      }
       case SERVE_CONTROL_EXT_METHODS.sessionRecap: {
         const sessionId = params["sessionId"];
         if (typeof sessionId !== "string" || sessionId.length === 0) {
@@ -23511,6 +23914,19 @@ ${outputText}
         if (providersChanged) {
           this.modelProviderReloadRevision += 1;
         }
+        const readSessionWorkflow = /* @__PURE__ */ __name((merged) => merged.experimental?.sessionWorkflow === true, "readSessionWorkflow");
+        const reloadedSessionWorkflow = readSessionWorkflow(newMerged);
+        this.applySessionWorkflowOverrideToLiveSessions(
+          reloadedSessionWorkflow
+        );
+        const reloadedApprovalMode = foldReloadApprovalMode(
+          newMerged.tools?.approvalMode
+        );
+        if (reloadedApprovalMode === void 0) {
+          debugLogger9.warn(
+            "reload: tools.approvalMode holds a value boot would reject; live sessions keep their current modes until the file is corrected"
+          );
+        }
         const sessions = [...this.sessions.entries()];
         const refreshed = [];
         const skipped = [];
@@ -23538,6 +23954,7 @@ ${outputText}
             if (changed.has("model") && newModelName && newModelName !== config.getModel() && authType) {
               try {
                 await config.switchModel(authType, newModelName);
+                session.reloadReasoningSelection();
               } catch (err) {
                 debugLogger9.warn(
                   `reload: switchModel failed for session ${id}: ${err}`
@@ -23545,44 +23962,65 @@ ${outputText}
               }
             } else if ((providersChanged || envChanged) && authType) {
               try {
-                await config.refreshAuth(authType);
+                await this.refreshAuthWithPersistedReasoning(
+                  config,
+                  this.settings,
+                  authType,
+                  void 0,
+                  session.getSessionReasoningSelection()
+                );
+                session.reloadReasoningSelection();
               } catch (err) {
                 debugLogger9.warn(
                   `reload: refreshAuth failed for session ${id}: ${err}`
                 );
               }
+            } else if (changed.has("model")) {
+              session.reloadReasoningSelection();
             }
             if (changed.has("tools")) {
               const disabled = normalizeDisabledToolList(
                 newMerged.tools?.disabled
               );
               config.setDisabledTools(new Set(disabled));
-              const workflowsWereEnabled = config.isWorkflowsEnabled();
-              config.setWorkflowsEnabled(
-                newMerged.tools?.workflowsEnabled === true
-              );
-              if (config.isWorkflowsEnabled() !== workflowsWereEnabled) {
-                try {
-                  await session.sendAvailableCommandsUpdate();
-                } catch (err) {
-                  debugLogger9.warn(
-                    `reload: sendAvailableCommandsUpdate failed for session ${id}: ${err}`
-                  );
-                }
+            }
+            const workflowsWereEnabled = config.isWorkflowsEnabled();
+            config.setWorkflowsEnabled(
+              newMerged.tools?.workflowsEnabled === true
+            );
+            if (config.isWorkflowsEnabled() !== workflowsWereEnabled) {
+              try {
+                await session.sendAvailableCommandsUpdate();
+              } catch (err) {
+                debugLogger9.warn(
+                  `reload: sendAvailableCommandsUpdate failed for session ${id}: ${err}`
+                );
               }
-              const newMode = newMerged.tools?.approvalMode;
-              if (newMode && APPROVAL_MODES.includes(newMode) && newMode !== config.getApprovalMode()) {
+            }
+            const reloadedSessionMode = isRestrictedApprovalModeConfig(config) ? "default" /* DEFAULT */ : reloadedApprovalMode;
+            const previousMode = config.getApprovalMode();
+            const convergedMode = this.sessionApprovalModeConverged.get(id);
+            if (reloadedSessionMode !== void 0 && reloadedSessionMode !== convergedMode) {
+              if (reloadedSessionMode !== previousMode) {
                 try {
-                  config.setApprovalMode(newMode);
-                  if (newMode === "plan") {
+                  config.setApprovalMode(reloadedSessionMode);
+                  if (reloadedSessionMode === "plan") {
                     session.clearActiveTodoPlanRevision();
                     session.clearTodoStopGuardTrust();
+                  } else if (previousMode === "plan") {
+                    session.clearActiveTodoPlanRevision();
                   }
+                  this.sessionApprovalModeConverged.set(
+                    id,
+                    reloadedSessionMode
+                  );
                 } catch (err) {
                   debugLogger9.warn(
                     `reload: setApprovalMode failed for session ${id}: ${err}`
                   );
                 }
+              } else {
+                this.sessionApprovalModeConverged.set(id, reloadedSessionMode);
               }
             }
             try {
@@ -24051,7 +24489,30 @@ ${outputText}
       );
     }
   }
-  async ensureAuthenticated(config) {
+  async refreshAuthWithPersistedReasoning(config, settings, authType, isInitialAuth, sessionSelection) {
+    await config.refreshAuth(authType, isInitialAuth);
+    const selection = sessionSelection ?? parseReasoningSelection(settings.merged.model?.reasoningEffort);
+    if (!selection || selection === REASONING_EFFORT_DEFAULT) {
+      return;
+    }
+    const generation = config.getContentGeneratorConfig?.();
+    const modelId = generation?.model ?? config.getModel();
+    if (!isReasoningSelectionSupported(
+      modelId,
+      selection,
+      generation?.thinkingMandatory === true
+    )) {
+      return;
+    }
+    const modelReasoning = this.getModelReasoningConfiguration(config);
+    if (generation && modelReasoning && !modelReasoning.toggleOnly) {
+      clearReasoningRequestOverrides(generation);
+    }
+    if (selection === REASONING_EFFORT_NONE) {
+      applyReasoningSelection(config, REASONING_EFFORT_NONE);
+    }
+  }
+  async ensureAuthenticated(config, settings) {
     const selectedType = config.getModelsConfig().getCurrentAuthType();
     if (!selectedType) {
       throw RequestError.authRequired(
@@ -24060,7 +24521,12 @@ ${outputText}
       );
     }
     try {
-      await config.refreshAuth(selectedType, true);
+      await this.refreshAuthWithPersistedReasoning(
+        config,
+        settings,
+        selectedType,
+        true
+      );
     } catch (e) {
       debugLogger9.error(`Authentication failed: ${e}`);
       throw RequestError.authRequired(
@@ -24071,6 +24537,37 @@ ${outputText}
       );
     }
   }
+  /**
+   * Pins the workflow gate of every live Session whose effective gate
+   * actually changes to `enabled`, dropping the bound plan revision on those
+   * sessions, then records `enabled` as the daemon-held override. The no-op
+   * decision is per-session because neither caller's own state can answer it:
+   * on a first UI write the override is still `undefined` although sessions
+   * already derive the pushed value from settings (a shadowed workspace
+   * write), and a reload diff can fire against a stale settings view that the
+   * UI write path never updated. Each session's live value is read BEFORE the
+   * field reassignment below so a pinned provider cannot report the new value
+   * as its "before" state. The provider reads the field rather than capturing
+   * a value so a later re-derivation (a settings-file reload) reaches
+   * sessions that were pinned earlier. Returns the number of sessions whose
+   * gate changed.
+   */
+  applySessionWorkflowOverrideToLiveSessions(enabled) {
+    let sessionsUpdated = 0;
+    for (const session of this.sessions.values()) {
+      const config = session.getConfig();
+      if (config.isSessionWorkflowEnabled?.() === enabled) {
+        continue;
+      }
+      config.setSessionWorkflowEnabledProvider?.(
+        () => this.sessionWorkflowEnabledOverride === true
+      );
+      session.clearActiveTodoPlanRevision();
+      sessionsUpdated++;
+    }
+    this.sessionWorkflowEnabledOverride = enabled;
+    return sessionsUpdated;
+  }
   setupFileSystem(config) {
     if (!this.clientCapabilities?.fs) return;
     const acpFileSystemService = new AcpFileSystemService(
@@ -24225,7 +24722,7 @@ ${outputText}
           if (options.beforeDeferredWorkspaceActivation) {
             await options.beforeDeferredWorkspaceActivation();
           } else {
-            await this.ensureAuthenticated(config);
+            await this.ensureAuthenticated(config, settings);
           }
           this.assertManagedSessionAdmission();
           await config.activateProvisionalWorkspace();
@@ -24286,7 +24783,7 @@ ${outputText}
             settings.merged.providerProtocol
           );
           if (forceAuthenticationRefresh || providerSettingsChanged || envReload.updatedKeys.length > 0 || envReload.removedKeys.length > 0) {
-            await this.ensureAuthenticated(config);
+            await this.ensureAuthenticated(config, settings);
           }
         }
         if (providerReloadRevision === this.modelProviderReloadRevision) break;
@@ -24297,7 +24794,16 @@ ${outputText}
       if (options.deferWorkspaceActivation !== true) {
         config.hydrateSessionRestoreFileHistory?.();
       }
+      if (this.sessionWorkflowEnabledOverride !== void 0) {
+        config.setSessionWorkflowEnabledProvider?.(
+          () => this.sessionWorkflowEnabledOverride === true
+        );
+      }
       this.sessions.set(sessionId, session);
+      this.sessionApprovalModeConverged.set(
+        sessionId,
+        config.getApprovalMode()
+      );
       published = true;
       this.activeWorkReporter?.notifyChanged();
       this.initializingConfigs.delete(config);
@@ -24429,7 +24935,16 @@ ${outputText}
       currentValue: currentModelId,
       options: configModelOptions
     };
-    const generation = config.getContentGeneratorConfig();
+    if (activeRuntimeSnapshot || currentModelId.startsWith(ACP_ROUTE_ID_PREFIX) || !isReasoningSelectionSupported(
+      rawCurrentModelId,
+      REASONING_EFFORT_DEFAULT
+    )) {
+      return [modeConfigOption, modelConfigOption];
+    }
+    const generation = config.getContentGeneratorConfig?.();
+    if (!generation) {
+      return [modeConfigOption, modelConfigOption];
+    }
     const modelReasoning = this.getModelReasoningConfiguration(
       config,
       currentModelId
@@ -24448,6 +24963,7 @@ ${outputText}
       (effort) => effort === normalizedOverrideEffort
     ) ?? modelReasoning.defaultEffort : currentModelEffort : currentModelEffort;
     const reasoningEnabled = generation.reasoning !== false && (!reasoningOverride || !overrideDisablesReasoning);
+    const canDisableReasoning = generation.thinkingMandatory !== true;
     const reasoningEffortConfigOption = (modelReasoning ? buildModelReasoningConfigOption(rawCurrentModelId, {
       enabled: reasoningEnabled,
       effort: effectiveModelEffort,
@@ -24458,8 +24974,15 @@ ${outputText}
       description: "How hard reasoning-capable models should think",
       category: "thought_level",
       type: "select",
-      currentValue: currentModelEffort ?? REASONING_EFFORT_DEFAULT,
+      currentValue: generation.reasoning === false && canDisableReasoning ? REASONING_EFFORT_NONE : currentModelEffort ?? REASONING_EFFORT_DEFAULT,
       options: [
+        ...canDisableReasoning ? [
+          {
+            value: REASONING_EFFORT_NONE,
+            name: "Thinking off",
+            description: "Disable thinking for this session"
+          }
+        ] : [],
         {
           value: REASONING_EFFORT_DEFAULT,
           name: "Default",