@qwen-code/qwen-code 0.22.3 → 0.23.0

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

@@ -1,12 +1,14 @@
 // Force strict mode and setup for ESM
 "use strict";
 import {
-  recomputeMcpGating
-} from "./chunk-2HYKTO7V.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,10 +16,9 @@ import {
   extractAtPathCommands,
   matchExtensionByRef,
   matchMcpServerByRef,
-  normalizePartList,
   parseExtensionRef,
   parseMcpServerRef
-} from "./chunk-PADPMMYM.js";
+} from "./chunk-LOBDDFYK.js";
 import {
   getAvailableCommands,
   getSlashCommandFirstToken,
@@ -26,53 +27,59 @@ import {
   isSlashCommand,
   recordDaemonSessionModel,
   restoreSessionModelThenAuthenticate
-} from "./chunk-DJEZ55D4.js";
+} from "./chunk-NVVJTUSL.js";
+import {
+  recomputeMcpGating
+} from "./chunk-UUASLXHW.js";
 import {
   SessionIdConflictError,
   appEvents,
   buildDisabledSkillNamesProvider,
+  buildEnabledSkillNamesProvider,
   cleanupReviewWorktreeLeases,
   loadCliConfig,
-  normalizeDisabledToolList
-} from "./chunk-DJPASAUV.js";
-import "./chunk-NYX53SV4.js";
-import {
-  collectContextData,
-  formatContextUsageText
-} from "./chunk-6X7EU5TI.js";
+  normalizeDisabledToolList,
+  parseApprovalModeValue
+} from "./chunk-MP6YZ4RK.js";
 import {
   getCommandSubcommandNames
-} from "./chunk-4TT3IVGA.js";
+} from "./chunk-EIY7SUPZ.js";
 import {
   getEffectiveSupportedModes
-} from "./chunk-WGY3AVGM.js";
-import "./chunk-CFJY4DGX.js";
-import "./chunk-4WGODMVR.js";
+} from "./chunk-5RTTI4GE.js";
 import "./chunk-3SH53ANB.js";
+import "./chunk-NYX53SV4.js";
+import "./chunk-M4LBBSVP.js";
+import {
+  collectContextData,
+  formatContextUsageText
+} from "./chunk-SX2QIMJV.js";
+import "./chunk-4WGODMVR.js";
+import {
+  startNonInteractiveOpenAILogHousekeeping
+} from "./chunk-GXUTFQXK.js";
+import "./chunk-KW7NOTN6.js";
+import "./chunk-JHN7UIDW.js";
+import "./chunk-5EIOJGCR.js";
+import "./chunk-37JFWFCD.js";
 import {
   isGoalStatusKind
 } from "./chunk-EKTCKZV5.js";
-import "./chunk-ZYMLPEZQ.js";
+import "./chunk-UM2FFKXN.js";
 import "./chunk-YAF2MQZ6.js";
-import "./chunk-QFCDF5PL.js";
 import {
-  startNonInteractiveOpenAILogHousekeeping
-} from "./chunk-LHBUKJG2.js";
-import "./chunk-KW7NOTN6.js";
-import "./chunk-4VPCTGH6.js";
+  computeCpuPercent
+} from "./chunk-LBOVL47Y.js";
+import "./chunk-24FVUD5P.js";
+import "./chunk-EWRW2WQC.js";
 import "./chunk-6H67XLET.js";
 import {
   beginAcpBootstrapConfigProfiling,
   buildAndFreezeAcpStartupProfile,
   endAcpBootstrapConfigProfiling,
   markAcpStartup
-} from "./chunk-5JTIYALA.js";
-import "./chunk-HP5LR5HL.js";
-import "./chunk-MPNBVAEU.js";
-import "./chunk-MSBO7X2W.js";
-import {
-  computeCpuPercent
-} from "./chunk-LBOVL47Y.js";
+} from "./chunk-JZWOCUZ3.js";
+import "./chunk-VNAYZAFX.js";
 import {
   GENERATION_MAX_PROMPT_BYTES,
   GENERATION_TIMEOUT_MS,
@@ -93,7 +100,7 @@ import {
   shouldSuppressRememberErrorDetails,
   workspaceMemoryFailureCode,
   workspaceMemoryFailureDiagnostics
-} from "./chunk-EQSBPBZ3.js";
+} from "./chunk-WP4AX3XD.js";
 import {
   BaseEmitter,
   HistoryReplayer,
@@ -104,33 +111,39 @@ import {
   hasFullSessionContext,
   observeAcpToolResultProjection,
   observeAcpToolResultWire
-} from "./chunk-ST5MDGH3.js";
-import "./chunk-BFPESSTR.js";
-import "./chunk-E7REAOTN.js";
-import "./chunk-ZZUKP7HV.js";
+} from "./chunk-QI27MKNQ.js";
+import "./chunk-XEAAO654.js";
+import "./chunk-NRL5CUZT.js";
+import "./chunk-47ECGEJC.js";
 import "./chunk-2MIN6GRR.js";
 import "./chunk-QHTIBUWB.js";
 import "./chunk-TXASDT2M.js";
+import {
+  buildToolWriteOriginMeta
+} from "./chunk-VGHZT6JR.js";
+import {
+  getConversationDirectoryName,
+  hasVerifiableInode,
+  isSameConversationPath,
+  isSameDirectoryIdentity
+} from "./chunk-PB7JBAHF.js";
+import "./chunk-UXEO7E3V.js";
 import {
   isCompatibleLiveSessionSource
-} from "./chunk-36LGBEM6.js";
+} from "./chunk-OHU2H5CS.js";
 import "./chunk-4VQBQLIZ.js";
 import {
   DAEMON_OWNED_STANDALONE_CREATION_KEY,
   SESSION_SOURCE_META_KEY,
   isReservedStandaloneSessionSourceType,
   parseSessionSource
-} from "./chunk-2TNL5KPM.js";
+} from "./chunk-N4QWUPDM.js";
 import {
-  buildToolWriteOriginMeta,
-  getConversationDirectoryName,
-  isSameConversationPath
-} from "./chunk-U54AYGEC.js";
-import "./chunk-RXFQM6FQ.js";
-import "./chunk-UXEO7E3V.js";
-import {
-  normalizeChannelDeliveryText
-} from "./chunk-4CMJKUND.js";
+  buildScheduledTaskRunPrompt,
+  normalizeChannelDeliveryText,
+  scheduledTaskRunSessionName,
+  scheduledTaskRunSourceId
+} from "./chunk-DTVQSSNM.js";
 import {
   normalizeSessionIdForLookup,
   parseCallerSuppliedSessionId
@@ -141,29 +154,43 @@ import {
   buildPermissionSettings,
   normalizePermissionRules,
   readPermissionRuleSet
-} from "./chunk-V7EESTJV.js";
+} from "./chunk-I5N4EAS6.js";
 import {
   MAX_AUDIO_BYTES,
   sanitizeVoiceErrorMessage,
   transcribeVoiceAudio
-} from "./chunk-URE3QBBB.js";
+} from "./chunk-LEPCWS5A.js";
 import {
   readVoiceModel
-} from "./chunk-A3LWD5MK.js";
-import "./chunk-YTDVNSUQ.js";
-import "./chunk-VGIFXISB.js";
-import "./chunk-TVC6HQ2U.js";
-import "./chunk-SS4MRMKE.js";
+} from "./chunk-BA4WJC4L.js";
+import "./chunk-QAK5475D.js";
+import "./chunk-RN3YGDCA.js";
+import "./chunk-3JQZVCBI.js";
+import "./chunk-JS73NNWF.js";
+import {
+  SCHEDULED_TASK_RUN_SOURCE_TYPE
+} 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,
@@ -172,26 +199,10 @@ import {
   parseAcpModelOption,
   resolveAcpModelOption,
   sanitizeProviderBaseUrl
-} from "./chunk-OU5APVWO.js";
+} from "./chunk-6A2D4QSO.js";
 import {
   mapSkillConfigToStatus
-} from "./chunk-N4X7G4J2.js";
-import {
-  resolveSkillSettings
-} from "./chunk-HCOBAG2L.js";
-import "./chunk-73RM4POK.js";
-import "./chunk-6ZPDLGHN.js";
-import "./chunk-57OAHC2Y.js";
-import "./chunk-Y5S7LBOZ.js";
-import "./chunk-3XKLXHGK.js";
-import "./chunk-HVC3PNVC.js";
-import "./chunk-V6WHFGST.js";
-import {
-  createLoadedSettingsAdapter
-} from "./chunk-7T52W4SW.js";
-import {
-  ndJsonStream
-} from "./chunk-H72BQNM3.js";
+} from "./chunk-BHTYRHJF.js";
 import {
   ACP_PREFLIGHT_KINDS,
   IDLE_HOOK_EVENTS,
@@ -199,8 +210,23 @@ import {
   SERVE_STATUS_EXT_METHODS,
   STATUS_SCHEMA_VERSION,
   mapDomainErrorToErrorKind
-} from "./chunk-KID24ZFN.js";
-import "./chunk-FTF2YIZ5.js";
+} from "./chunk-64QH2UC6.js";
+import {
+  resolveSkillSettings
+} from "./chunk-HWVUSYSN.js";
+import "./chunk-DMEUXLSS.js";
+import "./chunk-F7NF2IOE.js";
+import "./chunk-AZJLY2XZ.js";
+import "./chunk-57OAHC2Y.js";
+import "./chunk-PCRBLMIN.js";
+import "./chunk-NXKOVOM5.js";
+import "./chunk-TSZSGQ3N.js";
+import "./chunk-V6WHFGST.js";
+import {
+  createLoadedSettingsAdapter
+} from "./chunk-32LU3APX.js";
+import "./chunk-S6H3ELPG.js";
+import "./chunk-7XL4WRXM.js";
 import {
   ACTIVE_WORK_CLOSE_IF_UNHELD_PARAM,
   ACTIVE_WORK_HEARTBEAT_META_KEY,
@@ -231,21 +257,23 @@ import {
   MID_TURN_QUEUE_DRAIN_METHOD,
   PROMPT_CANCEL_METHOD,
   REQUESTED_SESSION_ID_META_KEY,
+  SESSION_INITIALIZATION_DEADLINE_META_KEY,
+  SESSION_INITIALIZATION_TIMEOUT_ERROR_KIND,
   TODO_STOP_GUARD_CONTINUATION_CLAIM_METHOD,
   TODO_STOP_GUARD_QUEUE_RELEASE_METHOD,
   WORKTREE_MCP_DEFER_META_KEY,
   clampActiveWorkIntervalMs,
   isValidTrustedModelPrompt
-} from "./chunk-OZ6KS6KW.js";
+} from "./chunk-ZGCKTAL5.js";
 import {
   NOT_CURRENTLY_GENERATING_CANCEL_MESSAGE,
   isNotCurrentlyGeneratingCancelError
-} from "./chunk-ERFDKH32.js";
+} from "./chunk-F47DITLZ.js";
 import "./chunk-6PLDPT2C.js";
 import "./chunk-FYJ7W2PI.js";
 import "./chunk-STUJ7IMZ.js";
 import "./chunk-GYTKQYDB.js";
-import "./chunk-RFIDDFAL.js";
+import "./chunk-M4KFODIP.js";
 import "./chunk-ALMR3E6Q.js";
 import "./chunk-RKFGE7JH.js";
 import "./chunk-UDG5EZJI.js";
@@ -259,32 +287,35 @@ import {
   isValidExternalToolGuardDenialReason
 } from "./chunk-3VUENPWF.js";
 import "./chunk-M5GB774H.js";
-import "./chunk-7EQQR46F.js";
 import {
   ACP_EVENT_LOOP_STALL_RESTART_MS,
   CHANNEL_PROMPT_META_KEY
-} from "./chunk-ICURCKIU.js";
+} from "./chunk-U4DJ5XB3.js";
 import {
   AgentSideConnection,
   PROTOCOL_VERSION,
   RequestError
 } from "./chunk-IW6RQPQB.js";
+import "./chunk-ZVP4PWBU.js";
 import {
   assembleMcpServers,
   loadMcpApprovals
-} from "./chunk-7VMIMAVB.js";
+} from "./chunk-C2VWOXHS.js";
 import {
+  deleteNestedPropertySafe,
   getOutputLanguageFilePath,
   getPersistScopeForModelSelection,
   getUserSettingsPath,
+  getWritableScopes,
   loadSettings,
   resolveOutputLanguageOrPreserveAuto,
+  settingExistsInScope,
   updateOutputLanguageFile,
   writeOutputLanguageAndRegisterPath
-} from "./chunk-AIAOIFY4.js";
+} from "./chunk-VWTSRH6C.js";
+import "./chunk-NQ4L2CMD.js";
 import "./chunk-RKUWKYED.js";
-import "./chunk-ZEYFMJQA.js";
-import "./chunk-GOXKNSDZ.js";
+import "./chunk-O5CD7T4T.js";
 import {
   getSystemDefaultsPath,
   getSystemSettingsPath
@@ -292,7 +323,7 @@ import {
 import {
   getCurrentLanguage,
   setLanguageAsync
-} from "./chunk-CLWO3B77.js";
+} from "./chunk-I4NRYS6A.js";
 import {
   SUPPORTED_LANGUAGES
 } from "./chunk-5EJZE3FP.js";
@@ -300,19 +331,19 @@ import {
   findEnvFiles,
   preResolveHomeEnvOverrides,
   reloadEnvironment
-} from "./chunk-XHF7WQ6B.js";
+} from "./chunk-C4TIXFDZ.js";
 import {
   ENV_ACP_REPEATED_TOOL_FAILURE_GUARD,
   QWEN_CODE_SERVE_ENV
-} from "./chunk-MZCJWS5Y.js";
-import "./chunk-V2NDP3I4.js";
-import "./chunk-Q2MSPKIJ.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-MF7HCQWZ.js";
+} from "./chunk-65HWLGA7.js";
 import "./chunk-NPQ5ZKRP.js";
 import "./chunk-MR3PXB6E.js";
 import {
@@ -342,35 +373,44 @@ import {
   resolveBaseUrl,
   runManagedRememberByAgent,
   subagentGenerator
-} from "./chunk-NV55WWD6.js";
-import "./chunk-2OUD5T67.js";
+} from "./chunk-JUARRUMA.js";
+import {
+  MAX_RETAINED_SNAPSHOTS,
+  deleteWorkflowSnapshot,
+  listSavedWorkflows,
+  listWorkflowSnapshots,
+  toSnapshot
+} from "./chunk-I2TMJPCV.js";
 import "./chunk-XFSFZCM5.js";
-import "./chunk-2EAZ43JQ.js";
-import "./chunk-NF5J2WFA.js";
 import {
   CreateSubSessionTool
-} from "./chunk-CQH5KTKC.js";
+} from "./chunk-JR42V4UY.js";
 import "./chunk-LJZSMWOH.js";
-import "./chunk-NMOD2FXQ.js";
-import "./chunk-WNPDGUJO.js";
-import "./chunk-K5KXUXWC.js";
 import {
   restoreWorktreeContext
-} from "./chunk-62GQFYID.js";
-import "./chunk-AYFA7MZV.js";
-import "./chunk-XQFT3QUF.js";
-import "./chunk-VTHREBQM.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 {
   clearCachedCredentialFile,
   qwenOAuth2Events
-} from "./chunk-3JXM2CVW.js";
-import "./chunk-ST5V3ZOC.js";
+} from "./chunk-3AKCBZVW.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,
@@ -416,6 +456,7 @@ import {
   decoratePlanModeShellConfirmation,
   dedupeToolCallsById,
   didWriteProjectContextFile,
+  emptyGoalSnapshot,
   encodeSessionTranscriptCursor,
   evaluateAutoMode,
   evaluatePermissionFlow,
@@ -434,23 +475,25 @@ import {
   formatStopHookBlockingCapWarning,
   generateToolUseId,
   getActiveGoal,
-  getArenaSystemReminder,
   getAutoModePermissionDeniedReason,
   getEffectivePermissionForConfirmation,
   getFunctionCallFingerprint,
   getMCPDiscoveryState,
-  getPlanModeSystemReminder,
   getProviderToolCallId,
   getScopedEnvContents,
   getStopHookContinuationReason,
   getToolCallRepeatKey,
+  getWorkflowTaskMutationKey,
+  goalTurnContext,
   ideContextStore,
   injectPermissionRulesIfMissing,
   isApproveOutcome,
+  isCompressionFailureStatus,
   isDenialFallbackReason,
   isGatedMcpScope,
   isPlanModeBlocked,
   isReplayOfHandledToolCall,
+  isTerminalWorkflowStatus,
   isTurnResultRecordPayload,
   markDuplicateProviderToolCallResponseSent,
   matchesAnyServerPattern,
@@ -459,6 +502,9 @@ import {
   normalizeDerivedBranchTitle,
   normalizeTurnResultError,
   observeToolResultBoundary,
+  parseGoalControlRequest,
+  parseGoalSnapshotV2,
+  parseGoalStateCause,
   persistPermissionOutcome,
   recordAllow,
   recordFallbackApprove,
@@ -477,41 +523,51 @@ import {
   toolResultBoundaryArtifact,
   toolResultPartDiagnosticValues,
   truncateNotificationLabel,
+  tryWithWorkflowTaskMutation,
   updateSetting,
   validatePlanModeShellApproval,
   validatePlanModeShellContext
-} from "./chunk-PZ66FRIC.js";
+} from "./chunk-4F7GQGXB.js";
 import "./chunk-GOFAQQZA.js";
 import "./chunk-5M6IDOMF.js";
+import "./chunk-6HUXPLB5.js";
 import "./chunk-TWPJO254.js";
 import {
   external_exports
 } from "./chunk-CQ35AJ4Z.js";
-import "./chunk-EKSCLBBF.js";
-import "./chunk-LUEHOUHM.js";
-import "./chunk-WXEA74YB.js";
-import "./chunk-42IDLQWS.js";
+import "./chunk-NSUKQ4DN.js";
+import "./chunk-DQCKVAF5.js";
+import "./chunk-AI35S34R.js";
+import "./chunk-KM3XVTMO.js";
 import {
   parsePositiveIntegerEnv
 } from "./chunk-6PVPNMXU.js";
 import {
   RUNTIME_SNAPSHOT_PREFIX
-} from "./chunk-JB4JIVTJ.js";
+} from "./chunk-OKTNXDVO.js";
 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-D5LUXLUH.js";
+import "./chunk-UJ4DUYIH.js";
+import "./chunk-QJNDUTOL.js";
 import {
   promptIdContext,
   todoWorkChainContext
 } from "./chunk-O6GEWCJA.js";
-import "./chunk-T26EAKDL.js";
-import "./chunk-2SXSLSQE.js";
-import "./chunk-CPBF7KYF.js";
+import {
+  getArenaSystemReminder,
+  getOutputStyleTurnReminder,
+  getPlanModeSystemReminder,
+  resolveMainSessionOutputStyle
+} from "./chunk-OSSTATJF.js";
+import "./chunk-ZHO2CW6D.js";
+import "./chunk-CVX63TFJ.js";
+import "./chunk-373DQUVA.js";
 import {
   AgentOutputMessageCapture,
   addAgentInputMessageAttributes,
@@ -519,59 +575,47 @@ import {
   addToolCallResultAttributes,
   registerAcpEventLoopLagGauge,
   startEventLoopLagMonitor
-} from "./chunk-KJO2LBUK.js";
+} from "./chunk-H43PSPYS.js";
 import {
   HookEventName,
   createHookOutput
-} from "./chunk-TTX2JUE6.js";
-import "./chunk-4K7KNVWH.js";
-import "./chunk-SMPR7SPO.js";
-import "./chunk-JWALNCLT.js";
-import "./chunk-NIFYWDYN.js";
-import "./chunk-C2X7KY45.js";
-import {
-  GoalConflictError,
-  GoalInvalidTransitionError,
-  GoalPersistenceUnavailableError,
-  emptyGoalSnapshot,
-  goalTurnContext,
-  parseGoalControlRequest,
-  parseGoalSnapshotV2,
-  parseGoalStateCause
-} from "./chunk-JHYH6PYQ.js";
+} from "./chunk-U6D2PPMN.js";
+import "./chunk-VYIUNFEA.js";
+import "./chunk-KGV55H53.js";
+import "./chunk-7TBU7PU2.js";
+import "./chunk-E4JNFXNI.js";
 import {
-  wrapUserPromptSubmitContext
-} from "./chunk-7J6OTNGO.js";
+  escapeJsonTagCharacters
+} from "./chunk-CHEIIBT3.js";
+import "./chunk-TJYRTS4S.js";
 import {
   APPROVAL_MODES
-} from "./chunk-V5J4J5TP.js";
+} from "./chunk-JX6XHPTX.js";
 import "./chunk-MLXTMF7H.js";
-import "./chunk-NAVJD2PQ.js";
-import "./chunk-B466ZSHZ.js";
-import "./chunk-4QHPPXK2.js";
-import "./chunk-QHMLYMMS.js";
-import {
-  addDaemonRequestAttribute,
-  extractDaemonTraceContext,
-  withDaemonSpan
-} from "./chunk-3WK3QDNV.js";
-import "./chunk-VNOVK4I7.js";
 import "./chunk-PQEISIKS.js";
-import "./chunk-EB6QRGHM.js";
+import "./chunk-FD5SJOWT.js";
 import {
   runWithRuntimeContentGenerator
-} from "./chunk-CMHFCLBU.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-DYXFD5RO.js";
-import "./chunk-V4264FEG.js";
+import "./chunk-S2T7H5MI.js";
+import "./chunk-LKODFJRD.js";
+import {
+  addDaemonRequestAttribute,
+  extractDaemonTraceContext,
+  withDaemonSpan
+} from "./chunk-LB3WQQJK.js";
 import {
   ConversationFinishedEvent,
   DiscoveredMCPTool,
@@ -597,40 +641,37 @@ import {
   logUserPrompt,
   normalizeParts,
   parseInvocationContext,
+  runSideQuery,
   runVisionBridge,
   runWithInvocationContext,
   shouldRunVisionBridge,
   splitImageParts,
   uiTelemetryService
-} from "./chunk-QYMAKPY5.js";
+} from "./chunk-GH2S4GD5.js";
 import "./chunk-XBVNNDPK.js";
 import "./chunk-VGC4I5JJ.js";
 import {
   getAllMemoryFilenames,
   getSpecificMimeType
-} from "./chunk-BKWNKLZB.js";
+} from "./chunk-DYTW3QVG.js";
 import {
   getAutoMemoryRoot,
   getUserAutoMemoryRoot
-} from "./chunk-6PJOTWAN.js";
-import {
-  runSideQuery
-} from "./chunk-BWORX6FA.js";
+} from "./chunk-HT5S5TRQ.js";
 import "./chunk-WZAD4ZNJ.js";
 import {
   DEFAULT_TOKEN_LIMIT,
   tokenLimit
 } from "./chunk-FPGTNKCP.js";
-import "./chunk-6DIGWMGT.js";
+import "./chunk-EIJT2PQ6.js";
 import {
   hasVertexProjectConfigured,
   preloadContentGenerator
-} from "./chunk-W3JH33JE.js";
-import "./chunk-XZA32HII.js";
-import "./chunk-23RFD54N.js";
+} from "./chunk-BFY33IB4.js";
+import "./chunk-KHP66DFN.js";
 import {
   AuthType
-} from "./chunk-PPKZ7JOE.js";
+} from "./chunk-22UH7VTP.js";
 import "./chunk-HHJLM3WQ.js";
 import {
   endToolExecutionSpan,
@@ -642,17 +683,18 @@ import {
   startToolExecutionSpan,
   startToolSpan,
   withInteractionSpan
-} from "./chunk-B5PHIJGI.js";
+} from "./chunk-QKDNS6FU.js";
 import "./chunk-74TONY4F.js";
-import "./chunk-XF63PKEN.js";
+import "./chunk-ZDFQGHZH.js";
 import {
   FORK_SUBAGENT_TYPE,
   getStartupContextLength,
-  isSystemReminderContent
-} from "./chunk-CAJTKR6W.js";
-import "./chunk-ZU4UDIWX.js";
+  isSystemReminderContent,
+  wrapSystemReminder
+} from "./chunk-G7HBEEX7.js";
+import "./chunk-QQD2GART.js";
 import "./chunk-AQ37AY7B.js";
-import "./chunk-PDQGMSZK.js";
+import "./chunk-ODZF64DM.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
@@ -660,7 +702,7 @@ import {
   ToolNames,
   canonicalToolName,
   isShellProgressData
-} from "./chunk-UTLCH2FK.js";
+} from "./chunk-7JMGTOH7.js";
 import {
   Storage,
   createDebugLogger,
@@ -668,11 +710,12 @@ import {
   getErrorStatus,
   isSubpath,
   sessionIdContext
-} from "./chunk-UHQFIS7N.js";
-import "./chunk-MK2GIB46.js";
+} from "./chunk-EAHOJF6V.js";
+import "./chunk-QJGYU5PG.js";
+import "./chunk-HRPFBHW7.js";
 import {
   runExitCleanup
-} from "./chunk-MO3FC2WT.js";
+} from "./chunk-RJUVTJEZ.js";
 import {
   writeStderrLine,
   writeStderrLineSafe
@@ -693,6 +736,7 @@ import {
 init_esbuild_shims();
 import { randomUUID as randomUUID2, timingSafeEqual } from "node:crypto";
 import { performance } from "node:perf_hooks";
+import { isDeepStrictEqual } from "node:util";
 
 // packages/cli/src/acp-integration/authMethods.ts
 init_esbuild_shims();
@@ -1075,7 +1119,7 @@ import * as path3 from "node:path";
 // packages/cli/src/acp-integration/live/capture-screen-context.ts
 init_esbuild_shims();
 import { constants } from "node:fs";
-import { open, unlink } from "node:fs/promises";
+import { lstat, open, unlink } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { dirname, join, resolve as resolve2 } from "node:path";
 var MAX_SCREENSHOT_BYTES = 8 * 1024 * 1024;
@@ -1100,6 +1144,9 @@ function resolvePrivatePngPath(path7, captureDirectory) {
 }
 __name(resolvePrivatePngPath, "resolvePrivatePngPath");
 async function readPrivatePng(path7) {
+  if ((await lstat(path7)).isSymbolicLink()) {
+    throw new Error("Host returned a symbolic link screenshot path.");
+  }
   const handle = await open(path7, constants.O_RDONLY | constants.O_NOFOLLOW);
   try {
     const stat2 = await handle.stat();
@@ -1152,11 +1199,13 @@ var CaptureScreenContextInvocation = class extends BaseToolInvocation {
       signal.throwIfAborted();
       const screenshot = await readPrivatePng(screenshotPath);
       signal.throwIfAborted();
-      const serializedContext = JSON.stringify({
-        appName: result.appName,
-        ...result.windowTitle ? { windowTitle: result.windowTitle } : {},
-        accessibilityText: result.accessibilityText
-      }).replace(/</gu, "\\u003c");
+      const serializedContext = escapeJsonTagCharacters(
+        JSON.stringify({
+          appName: result.appName,
+          ...result.windowTitle ? { windowTitle: result.windowTitle } : {},
+          accessibilityText: result.accessibilityText
+        })
+      );
       return {
         llmContent: [
           {
@@ -3158,6 +3207,7 @@ __name(reduceRepeatedToolFailureGuard, "reduceRepeatedToolFailureGuard");
 // packages/cli/src/acp-integration/session/Session.ts
 var debugLogger6 = createDebugLogger("SESSION");
 var permissionRequestTails = /* @__PURE__ */ new WeakMap();
+var MAX_RETAINED_SESSION_ROUTE_COUNTS = 8;
 var USER_CANCEL_ABORT_REASON = "qwen:user-cancel";
 var NEW_PROMPT_ABORT_REASON = "qwen:new-prompt";
 var SESSION_DISPOSE_ABORT_REASON = "qwen:session-dispose";
@@ -3205,10 +3255,6 @@ function isTodoStopGuardPromptText(text) {
   return remainder === body || remainder === body + TODO_STOP_GUARD_FINAL_PROMPT_SUFFIX;
 }
 __name(isTodoStopGuardPromptText, "isTodoStopGuardPromptText");
-function isCompressionFailureStatus(status) {
-  return status === 2 /* COMPRESSION_FAILED_INFLATED_TOKEN_COUNT */ || status === 3 /* COMPRESSION_FAILED_TOKEN_COUNT_ERROR */ || status === 4 /* COMPRESSION_FAILED_EMPTY_SUMMARY */ || status === 6 /* COMPRESSION_FAILED_OUTPUT_TRUNCATED */;
-}
-__name(isCompressionFailureStatus, "isCompressionFailureStatus");
 async function finalizeToolCallPreparations(tracker, includeResolved, streamName) {
   try {
     await tracker.discard(includeResolved);
@@ -3910,11 +3956,9 @@ async function buildAvailableCommandsSnapshot(config, abortSignal = AbortSignal.
     settings,
     executionPolicy
   );
-  const disabledSkillNames = config.getDisabledSkillNames();
   const inactiveSkillRefs = inactiveExtensionSkillRefs(config);
   const visibleSlashCommands = slashCommands.filter((cmd) => {
     if (cmd.kind !== "skill" /* SKILL */ || !cmd.skillDetail) return true;
-    const skillName = cmd.skillDetail.name.toLowerCase();
     const isInactiveExtensionCommand = cmd.skillDetail.level === "extension" && isInactiveExtensionSkill(
       {
         name: cmd.skillDetail.name,
@@ -3923,7 +3967,7 @@ async function buildAvailableCommandsSnapshot(config, abortSignal = AbortSignal.
       },
       inactiveSkillRefs
     );
-    return !disabledSkillNames.has(skillName) && !isInactiveExtensionCommand;
+    return config.isSkillEnabled(cmd.skillDetail) && !isInactiveExtensionCommand;
   });
   const availableCommands = visibleSlashCommands.map(
     (cmd) => {
@@ -3954,7 +3998,7 @@ async function buildAvailableCommandsSnapshot(config, abortSignal = AbortSignal.
     const skillManager = config.getSkillManager();
     if (skillManager) {
       const skills = (await skillManager.listSkills()).filter(
-        (skill) => !disabledSkillNames.has(skill.name.toLowerCase()) && !isInactiveExtensionSkill(skill, inactiveSkillRefs)
+        (skill) => config.isSkillEnabled(skill) && !isInactiveExtensionSkill(skill, inactiveSkillRefs)
       );
       availableSkills = skills.map((skill) => skill.name);
       for (const skill of skills) {
@@ -3995,13 +4039,15 @@ async function buildAvailableCommandsSnapshot(config, abortSignal = AbortSignal.
 }
 __name(buildAvailableCommandsSnapshot, "buildAvailableCommandsSnapshot");
 var Session = class {
-  constructor(id, config, client, settings, runExclusiveAutomaticHistoryMutation = (operation) => operation(), onActiveWorkChanged) {
+  constructor(id, config, client, settings, runExclusiveAutomaticHistoryMutation = (operation) => operation(), onActiveWorkChanged, workflowHistory = [], isWorkflowRunLiveInSiblingSession = () => false) {
     this.config = config;
     this.client = client;
     this.settings = settings;
     this.runExclusiveAutomaticHistoryMutation = runExclusiveAutomaticHistoryMutation;
     this.onActiveWorkChanged = onActiveWorkChanged;
+    this.isWorkflowRunLiveInSiblingSession = isWorkflowRunLiveInSiblingSession;
     this.sessionId = id;
+    this.workflowHistory = [...workflowHistory];
     this.requiresManagedConversationBinding = isReservedStandaloneSessionSourceType(
       this.config.getSessionSourceType?.()
     );
@@ -4009,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);
@@ -4081,6 +4131,14 @@ var Session = class {
   cronDisabledByTokenLimit = false;
   lastPromptTokenCount = 0;
   lastPromptTokenCountChat = null;
+  // Private ACP fallback cache, bounded like LlmChat without exposing a
+  // cross-package route resolver just for this closeout.
+  lastPromptTokenCountsByRouteKey = /* @__PURE__ */ new Map();
+  // The model route that produced `lastPromptTokenCount` (Config
+  // .getModelRouteIdentity). ACP model switches keep the same LlmChat, so
+  // the chat-instance check alone never invalidates the count on a route
+  // change (#9529, follow-up to #9454/#9506).
+  lastPromptTokenCountRouteKey = void 0;
   midTurnDrainUnavailable = false;
   midTurnDrainTimeoutStrikes = 0;
   // ACP can continue one logical conversation through prompt, cron, and
@@ -4109,10 +4167,11 @@ var Session = class {
   notificationAbortController = null;
   notificationCompletion = null;
   currentAgentNotificationTaskId = null;
+  currentWorkflowNotificationTaskId = null;
   currentShellNotificationActive = false;
   persistedBackgroundNotificationTaskIds = /* @__PURE__ */ new Set();
   backgroundNotificationAcceptances = /* @__PURE__ */ new Map();
-  activeAgentNotificationAcceptances = /* @__PURE__ */ new Set();
+  activeNotificationAcceptances = /* @__PURE__ */ new Set();
   goalQueue = [];
   goalProcessing = false;
   activeGoalTurn;
@@ -4138,9 +4197,38 @@ var Session = class {
   /** The exact status-change callback this Session installed, so dispose can
    *  retract its own and nobody else's. */
   #statusChangeCallback;
+  #workflowStatusChangeCallback;
+  workflowHistory;
+  /**
+   * R7-5: runIds whose snapshot write this session has observed. Latches
+   * `#rememberWorkflowHistory` off so a post-persistence status emission
+   * cannot resurrect a sibling-deleted run. See that method.
+   */
+  persistedWorkflowRunIds = /* @__PURE__ */ new Set();
+  /**
+   * R7-4: every runId the last `refreshWorkflowHistory` merged, BEFORE the
+   * MAX_RETAINED_SNAPSHOTS cap. `workflowHistory` is the display window;
+   * this is what deletion tests membership against.
+   */
+  mergedWorkflowRunIds = /* @__PURE__ */ new Set();
+  unpersistedWorkflowHistory = /* @__PURE__ */ new Map();
+  /**
+   * Deletion order, so a refresh can tell which runs were deleted AFTER
+   * its disk read began. `refreshWorkflowHistory` reads the directory
+   * and then merges without holding a claim, while deletion holds one —
+   * a delete that lands between the read and the merge would otherwise
+   * be overwritten by the stale listing and the run would reappear
+   * until the next refresh. Keyed by runId so a later re-run of the same
+   * id (a retry reuses it) is not suppressed: its sequence predates that
+   * refresh's mark.
+   */
+  workflowDeletionSeq = 0;
+  workflowDeletionSeqByRunId = /* @__PURE__ */ new Map();
   #shellStatusChangeCallback;
   workflowApprovalAbortController = new AbortController();
   activeTodoPlanRevision;
+  activeTodoPlanStructure;
+  todoPlanRevisionGeneration = 0;
   // Modular components
   historyReplayer;
   toolCallEmitter;
@@ -4186,6 +4274,7 @@ var Session = class {
   restoredAskUserQuestionSkipPersistence = false;
   // Implement SessionContext interface
   sessionId;
+  sessionReasoningSelection;
   #bindGoalRuntime() {
     try {
       const runtime = this.config.getGoalRuntime();
@@ -4705,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();
@@ -4797,6 +4889,7 @@ var Session = class {
     const agents = this.config.getBackgroundTaskRegistry?.()?.getAll?.() ?? [];
     const shells = this.config.getBackgroundShellRegistry?.()?.getAll?.() ?? [];
     const monitors = this.config.getMonitorRegistry?.()?.getAll?.() ?? [];
+    const workflows = this.config.getWorkflowRunRegistry?.()?.list?.() ?? [];
     const wakeups = this.config.isCronEnabled?.() ? (this.config.getCronScheduler?.()?.list?.() ?? []).filter(
       (job) => job.cronExpr === "@wakeup"
     ) : [];
@@ -4813,6 +4906,7 @@ var Session = class {
         ...monitors.map((task) => task.id),
         ...this.notificationQueue.filter((item) => item.kind === "monitor").map((item) => item.taskId)
       ]),
+      workflows: new Set(workflows),
       wakeups: /* @__PURE__ */ new Set([
         ...wakeups.map((job) => job.id),
         ...this.cronQueue.flatMap(
@@ -4882,6 +4976,12 @@ var Session = class {
     )) {
       return true;
     }
+    const workflows = this.config.getWorkflowRunRegistry?.()?.list?.() ?? [];
+    if (workflows.some(
+      (task) => !baseline.workflows.has(task) && !isTerminalWorkflowStatus(task.status)
+    )) {
+      return true;
+    }
     if (!this.config.isCronEnabled?.()) return false;
     const wakeups = this.config.getCronScheduler?.()?.list?.() ?? [];
     return wakeups.some(
@@ -5147,6 +5247,131 @@ var Session = class {
   getConfig() {
     return this.config;
   }
+  getWorkflowHistory() {
+    return this.workflowHistory;
+  }
+  async refreshWorkflowHistory() {
+    const deletionMark = this.workflowDeletionSeq;
+    const persisted = await listWorkflowSnapshots(this.config);
+    const byRunId = new Map(
+      persisted.map((snapshot) => [snapshot.runId, snapshot])
+    );
+    for (const [runId, seq] of this.workflowDeletionSeqByRunId) {
+      if (seq > deletionMark) byRunId.delete(runId);
+    }
+    for (const [runId, snapshot] of this.unpersistedWorkflowHistory) {
+      const stored = byRunId.get(runId);
+      if (stored === void 0) {
+        byRunId.set(runId, snapshot);
+      } else {
+        this.unpersistedWorkflowHistory.delete(runId);
+      }
+    }
+    this.mergedWorkflowRunIds = new Set(byRunId.keys());
+    this.workflowHistory = [...byRunId.values()].sort((a, b) => b.startTime - a.startTime).slice(0, MAX_RETAINED_SNAPSHOTS);
+    this.#pruneUnpersistedWorkflowHistory();
+    return this.workflowHistory;
+  }
+  async deleteWorkflowHistory(runId) {
+    const attempt = await tryWithWorkflowTaskMutation(
+      getWorkflowTaskMutationKey(this.config, runId),
+      () => this.#deleteWorkflowHistoryClaimed(runId)
+    );
+    return attempt.acquired ? attempt.value : false;
+  }
+  async #deleteWorkflowHistoryClaimed(runId) {
+    const registry = this.config.getWorkflowRunRegistry();
+    const isDeletable = /* @__PURE__ */ __name(() => {
+      if (this.isWorkflowRunLiveInSiblingSession(runId)) return false;
+      if (registry.isStarting?.(runId)) return false;
+      const current = registry.get(runId);
+      return !current || isTerminalWorkflowStatus(current.status);
+    }, "isDeletable");
+    if (!isDeletable()) return false;
+    const handle = registry.getHandle(runId);
+    if (handle) {
+      await handle.completion;
+      if (!isDeletable()) return false;
+    }
+    await this.refreshWorkflowHistory();
+    if (!isDeletable()) return false;
+    if (!this.mergedWorkflowRunIds.has(runId) && registry.get(runId) === void 0 && !this.unpersistedWorkflowHistory.has(runId)) {
+      return false;
+    }
+    if (registry.get(runId) !== void 0 && !registry.removeTerminal(runId)) {
+      return false;
+    }
+    if (!await deleteWorkflowSnapshot(this.config, runId)) return false;
+    this.workflowDeletionSeqByRunId.set(runId, ++this.workflowDeletionSeq);
+    this.unpersistedWorkflowHistory.delete(runId);
+    this.mergedWorkflowRunIds.delete(runId);
+    this.persistedWorkflowRunIds.delete(runId);
+    this.workflowHistory = this.workflowHistory.filter(
+      (item) => item.runId !== runId
+    );
+    this.#activeWorkChanged();
+    return true;
+  }
+  /**
+   * A sibling session deleted `runId` from the shared store. The
+   * deletion-sequence marker is per-Session — it records deletions THIS
+   * session issued — while the store and the delete entrance are
+   * process-wide, so without this a refresh of ours that began reading
+   * the directory before the sibling's delete landed would merge the
+   * stale listing and republish the run the sibling's client was just
+   * told was gone. Called under the sibling's task-mutation claim,
+   * symmetric to the registry `removeTerminal` sweep.
+   *
+   * The R7-5 persisted latch is deliberately kept: a late terminal
+   * emission for the deleted run must still not re-insert it.
+   */
+  noteExternalWorkflowDeletion(runId) {
+    this.workflowDeletionSeqByRunId.set(runId, ++this.workflowDeletionSeq);
+    this.unpersistedWorkflowHistory.delete(runId);
+    this.mergedWorkflowRunIds.delete(runId);
+    const retained = this.workflowHistory.filter(
+      (item) => item.runId !== runId
+    );
+    if (retained.length === this.workflowHistory.length) return;
+    this.workflowHistory = retained;
+    this.#activeWorkChanged();
+  }
+  #rememberWorkflowHistory(entry) {
+    if (!isTerminalWorkflowStatus(entry.status)) {
+      this.persistedWorkflowRunIds.delete(entry.runId);
+      return;
+    }
+    if (this.persistedWorkflowRunIds.has(entry.runId)) return;
+    const snapshot = toSnapshot(entry);
+    this.unpersistedWorkflowHistory.set(snapshot.runId, snapshot);
+    this.workflowHistory = [
+      snapshot,
+      ...this.workflowHistory.filter((item) => item.runId !== entry.runId)
+    ].sort((a, b) => b.startTime - a.startTime).slice(0, MAX_RETAINED_SNAPSHOTS);
+    this.#pruneUnpersistedWorkflowHistory();
+  }
+  #pruneUnpersistedWorkflowHistory() {
+    const retainedRunIds = new Set(
+      this.workflowHistory.map((item) => item.runId)
+    );
+    for (const runId of this.unpersistedWorkflowHistory.keys()) {
+      if (!retainedRunIds.has(runId)) {
+        this.unpersistedWorkflowHistory.delete(runId);
+      }
+    }
+  }
+  reloadModelProvidersFromDisk() {
+    if (!this.settings.reloadScopesFromDiskAtomically([
+      "User" /* User */,
+      "Workspace" /* Workspace */
+    ])) {
+      throw new Error("Unable to reload model-provider settings from disk.");
+    }
+    this.config.reloadModelProvidersConfig(
+      this.settings.merged.modelProviders,
+      this.settings.merged.providerProtocol ?? {}
+    );
+  }
   installPendingManagedConversationBinding(expectation, assertIdentity) {
     if (!this.requiresManagedConversationBinding || expectation.canonicalSessionId !== this.sessionId) {
       throw managedConversationBindingError();
@@ -5331,14 +5556,19 @@ var Session = class {
     }
     const notificationIds = /* @__PURE__ */ new Set();
     for (const item of this.notificationQueue) {
-      if (item.kind === "agent") notificationIds.add(item.taskId);
+      if (item.kind === "agent" || item.kind === "workflow") {
+        notificationIds.add(item.taskId);
+      }
     }
-    for (const taskId of this.activeAgentNotificationAcceptances) {
+    for (const taskId of this.activeNotificationAcceptances) {
       notificationIds.add(taskId);
     }
     if (this.currentAgentNotificationTaskId !== null) {
       notificationIds.add(this.currentAgentNotificationTaskId);
     }
+    if (this.currentWorkflowNotificationTaskId !== null) {
+      notificationIds.add(this.currentWorkflowNotificationTaskId);
+    }
     for (const taskId of notificationIds) {
       holds.push({ category: "notification", id: taskId });
     }
@@ -5346,6 +5576,15 @@ var Session = class {
     if (shellActive) {
       holds.push({ category: "shell", id: "background-shells" });
     }
+    const workflowRegistry = this.config.getWorkflowRunRegistry();
+    for (const runId of workflowRegistry.listStartingRunIds?.() ?? []) {
+      holds.push({ category: "workflow", id: runId });
+    }
+    for (const task of workflowRegistry.list()) {
+      if (task.status === "running" || task.status === "pausing") {
+        holds.push({ category: "workflow", id: task.runId });
+      }
+    }
     return holds;
   }
   hasStandaloneRelocationBlockers() {
@@ -5460,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?.();
@@ -5502,7 +5742,15 @@ var Session = class {
       shellRegistry.clearStatusChangeCallback(this.#shellStatusChangeCallback);
       this.#shellStatusChangeCallback = void 0;
     }
+    this.config.getWorkflowRunRegistry().abortAll();
+    this.config.getWorkflowRunRegistry().setCompletionCallback(void 0);
+    this.config.getWorkflowRunRegistry().setSnapshotPersistedCallback(void 0);
+    if (this.#workflowStatusChangeCallback) {
+      this.config.getWorkflowRunRegistry().clearStatusChangeCallback(this.#workflowStatusChangeCallback);
+      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);
@@ -5559,7 +5807,7 @@ var Session = class {
         ...options
       });
     } finally {
-      this.activeTodoPlanRevision = void 0;
+      this.clearActiveTodoPlanRevision();
     }
   }
   rewindToTurn(targetTurnIndex, opts) {
@@ -5589,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();
@@ -5634,7 +5882,7 @@ var Session = class {
       );
     }
     this.config.getLlmClient().getChat().setHistory(structuredClone(history));
-    this.activeTodoPlanRevision = void 0;
+    this.clearActiveTodoPlanRevision();
     this.#clearTodoStopGuardTrustAndDrainAutomaticQueues();
   }
   #computeApiTruncationIndexForUserTurn(apiHistory, targetTurnIndex) {
@@ -6649,6 +6897,7 @@ ${this.pendingRecoveredAgentsNotice}
                 );
                 let channelDeliveryResponseBlock;
                 let channelDeliveryCheckpoint = 0;
+                let requestRouteKey = "";
                 try {
                   if (goalTurn) {
                     goalTurn.modelStarted = true;
@@ -6677,6 +6926,7 @@ ${this.pendingRecoveredAgentsNotice}
                   if (restorePostAnswerNoticesAttached) {
                     this.#clearPendingRestoreNotices();
                   }
+                  requestRouteKey = sendResult.requestRouteKey;
                   const responseStream = sendResult.responseStream;
                   nextMessage = null;
                   channelDeliveryResponseBlock = beginChannelDeliveryResponseBlock(responseCapture);
@@ -6739,6 +6989,12 @@ ${this.pendingRecoveredAgentsNotice}
                         );
                         functionCalls.length = 0;
                       }
+                      if (resp.type === "compressed" /* COMPRESSED */) {
+                        this.#recordCompressionTokenCount(
+                          resp.info,
+                          requestRouteKey
+                        );
+                      }
                     }
                   } catch (error) {
                     streamFailed = true;
@@ -6792,7 +7048,7 @@ ${this.pendingRecoveredAgentsNotice}
                   functionCalls.length > 0
                 );
                 if (usageMetadata) {
-                  this.#recordPromptTokenCount(usageMetadata);
+                  this.#recordPromptTokenCount(usageMetadata, requestRouteKey);
                   if (this.messageRewriter) {
                     this.messageRewriter.flushTurn(pendingSend.signal);
                   }
@@ -7242,6 +7498,7 @@ ${this.pendingRecoveredAgentsNotice}
       let channelDeliveryCheckpoint = 0;
       let providerSendChat;
       let userContentPushCountBeforeSend = 0;
+      let requestRouteKey = "";
       try {
         const sendResult = await this.#sendMessageStreamWithAutoCompression(
           promptIdForSend,
@@ -7467,6 +7724,7 @@ ${this.pendingRecoveredAgentsNotice}
             ...supersededAutomaticContinuation ? { supersededAutomaticContinuation: true } : {}
           };
         }
+        requestRouteKey = sendResult.requestRouteKey;
         const responseStream = sendResult.responseStream;
         nextMessage = null;
         channelDeliveryResponseBlock = beginChannelDeliveryResponseBlock(
@@ -7543,6 +7801,9 @@ ${this.pendingRecoveredAgentsNotice}
             );
             functionCalls.length = 0;
           }
+          if (response.type === "compressed" /* COMPRESSED */) {
+            this.#recordCompressionTokenCount(response.info, requestRouteKey);
+          }
         }
       } catch (error) {
         streamFailed = true;
@@ -7598,7 +7859,7 @@ ${this.pendingRecoveredAgentsNotice}
         functionCalls.length > 0
       );
       if (usageMetadata) {
-        this.#recordPromptTokenCount(usageMetadata);
+        this.#recordPromptTokenCount(usageMetadata, requestRouteKey);
         const durationMs = Date.now() - streamStartTime;
         await this.messageEmitter.emitUsageMetadata(
           usageMetadata,
@@ -7741,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(() => {
@@ -7882,7 +8202,6 @@ ${this.pendingRecoveredAgentsNotice}
           abortSignal
         );
         compressionInfo = compressed;
-        this.#recordCompressionTokenCount(compressed);
         compressionFailed = isCompressionFailureStatus(
           compressed.compressionStatus
         );
@@ -7912,15 +8231,28 @@ ${this.pendingRecoveredAgentsNotice}
       debugLogger6.debug(`Auto-compression aborted for prompt ${promptId}`);
       return { responseStream: null, stopReason: "cancelled" };
     }
-    if (!compressionInfo) {
-      this.#syncPromptTokenCountWithCurrentChat();
+    const model = options.getModelOverride?.() ?? options.modelOverride ?? this.config.getModel();
+    const requestRouteKey = await this.#requestRouteKeyForModel(model);
+    if (abortSignal.aborted) {
+      debugLogger6.debug(
+        `Send aborted after request route key resolution for prompt ${promptId}`
+      );
+      return { responseStream: null, stopReason: "cancelled" };
+    }
+    if (compressionInfo) {
+      this.#recordCompressionTokenCount(compressionInfo, requestRouteKey);
+    } else {
+      this.#syncPromptTokenCountWithCurrentChat(requestRouteKey);
     }
     const sessionTokenLimit = this.config.getSessionTokenLimit();
     if (sessionTokenLimit > 0) {
-      const lastPromptTokenCount = this.#getPostCompressionTokenCount(compressionInfo);
+      const lastPromptTokenCount = this.#getPostCompressionTokenCount(
+        compressionInfo,
+        requestRouteKey
+      );
       if (lastPromptTokenCount > sessionTokenLimit) {
         debugLogger6.warn(
-          `Session token limit exceeded for prompt ${promptId}: ${lastPromptTokenCount} > ${sessionTokenLimit}. Send dropped.`
+          `Session token limit exceeded for prompt ${promptId}: ${lastPromptTokenCount} > ${sessionTokenLimit}. requestRoute=${requestRouteKey}, activeModel=${this.config.getModel()}. Send dropped.`
         );
         await this.#emitAgentDiagnosticMessageSafely(
           `Session token limit exceeded: ${lastPromptTokenCount} tokens > ${sessionTokenLimit} limit. Please start a new session or increase the sessionTokenLimit in your settings.json.`,
@@ -7963,7 +8295,6 @@ ${this.pendingRecoveredAgentsNotice}
       }
     }
     const chat = this.#getCurrentChat();
-    const model = options.getModelOverride?.() ?? options.modelOverride ?? this.config.getModel();
     const request = {
       message,
       config: {
@@ -7972,7 +8303,7 @@ ${this.pendingRecoveredAgentsNotice}
     };
     const goalPermit = goalTurnContext.getStore();
     const responseStream = goalPermit ? await chat.sendMessageStream(model, request, promptId, goalPermit) : await chat.sendMessageStream(model, request, promptId);
-    return { responseStream };
+    return { responseStream, requestRouteKey };
   }
   #clearPendingRestoreNotices() {
     this.pendingWorktreeNotice = null;
@@ -8130,25 +8461,58 @@ ${this.pendingRecoveredAgentsNotice}
       hadMidTurnUserInput
     };
   }
-  #recordCompressionTokenCount(info) {
-    this.#syncPromptTokenCountWithCurrentChat();
+  #recordCompressionTokenCount(info, requestRouteKey) {
+    if (info.compressionStatus === 1 /* COMPRESSED */) {
+      this.#invalidateRouteTokenCountsForCompression(info, requestRouteKey);
+      return;
+    }
+    this.#syncPromptTokenCountWithCurrentChat(requestRouteKey);
+    const tokenCount = this.#extractCompressionTokenCount(info);
+    if (tokenCount !== null && tokenCount > 0) {
+      this.#setLastPromptTokenCount(requestRouteKey, tokenCount);
+    }
+  }
+  /**
+   * Compression rewrote the shared history, so EVERY retained route-keyed
+   * count is stale — not just the request route's. Drop them all and
+   * re-record the fresh post-compression count under the request route,
+   * retaining it under the active route too when the two differ (the
+   * compressed history is shared, so the count anchors both routes' next
+   * gate reads). Mirrors LlmChat clearing its keyed counts in the
+   * COMPRESSED branch of tryCompress; without this, in-send compressions
+   * (LlmChat.sendMessageStream's hard-tier rescue and reactive-overflow
+   * paths, surfaced as StreamEventType.COMPRESSED) would leave this cache
+   * holding pre-compression sizes and the gate would drop a returning
+   * route's send that fits the compressed history (#9529).
+   */
+  #invalidateRouteTokenCountsForCompression(info, requestRouteKey) {
+    this.lastPromptTokenCountsByRouteKey.clear();
     const tokenCount = this.#extractCompressionTokenCount(info);
     if (tokenCount !== null && tokenCount > 0) {
-      this.lastPromptTokenCount = tokenCount;
+      this.#setLastPromptTokenCount(requestRouteKey, tokenCount);
+      const activeRouteKey = this.#currentRouteKey();
+      if (activeRouteKey !== requestRouteKey) {
+        this.lastPromptTokenCountsByRouteKey.set(activeRouteKey, tokenCount);
+      }
+    } else {
+      this.lastPromptTokenCount = 0;
+      this.lastPromptTokenCountRouteKey = requestRouteKey;
     }
+    this.lastPromptTokenCountChat = this.#getCurrentChat();
   }
-  #recordPromptTokenCount(usageMetadata) {
-    this.#syncPromptTokenCountWithCurrentChat();
+  #recordPromptTokenCount(usageMetadata, routeKey = this.#currentRouteKey()) {
+    this.#syncPromptTokenCountWithCurrentChat(routeKey);
     const tokenCount = usageMetadata.promptTokenCount ?? usageMetadata.totalTokenCount;
     if (tokenCount !== void 0 && tokenCount > 0) {
-      this.lastPromptTokenCount = tokenCount;
+      this.#setLastPromptTokenCount(routeKey, tokenCount);
     }
   }
-  #getPostCompressionTokenCount(info) {
+  #getPostCompressionTokenCount(info, routeKey = this.#currentRouteKey()) {
     const tokenCount = this.#extractCompressionTokenCount(info);
     if (tokenCount !== null) {
       return tokenCount;
     }
+    this.#syncPromptTokenCountWithCurrentChat(routeKey);
     return this.lastPromptTokenCount;
   }
   #extractCompressionTokenCount(info) {
@@ -8164,12 +8528,50 @@ ${this.pendingRecoveredAgentsNotice}
     }
     return tokenCount;
   }
-  #syncPromptTokenCountWithCurrentChat() {
+  #currentRouteKey() {
+    return this.config.getModelRouteIdentity?.() ?? "";
+  }
+  async #requestRouteKeyForModel(model) {
+    if (!this.config.getModelRouteIdentity) {
+      return "";
+    }
+    if (!model.endsWith("\0")) {
+      return this.config.getModelRouteIdentity(model);
+    }
+    const runtimeView = await this.config.getBaseLlmClient().resolveForModel(model.slice(0, -1), { failClosed: true });
+    return this.config.getModelRouteIdentity(
+      runtimeView.model,
+      runtimeView.contentGeneratorConfig
+    );
+  }
+  #setLastPromptTokenCount(routeKey, tokenCount) {
+    this.lastPromptTokenCount = tokenCount;
+    this.lastPromptTokenCountRouteKey = routeKey;
+    if (!this.lastPromptTokenCountsByRouteKey.has(routeKey) && this.lastPromptTokenCountsByRouteKey.size >= MAX_RETAINED_SESSION_ROUTE_COUNTS) {
+      const oldestKey = this.lastPromptTokenCountsByRouteKey.keys().next().value;
+      if (oldestKey !== void 0) {
+        this.lastPromptTokenCountsByRouteKey.delete(oldestKey);
+      }
+    }
+    this.lastPromptTokenCountsByRouteKey.set(routeKey, tokenCount);
+  }
+  #syncPromptTokenCountWithCurrentChat(routeKey = this.#currentRouteKey()) {
     const chat = this.#getCurrentChat();
-    if (this.lastPromptTokenCountChat && this.lastPromptTokenCountChat !== chat) {
+    const chatChanged = this.lastPromptTokenCountChat && this.lastPromptTokenCountChat !== chat;
+    if (chatChanged) {
+      this.lastPromptTokenCountsByRouteKey.clear();
       this.lastPromptTokenCount = 0;
+    } else if (this.lastPromptTokenCountRouteKey !== routeKey) {
+      if (this.lastPromptTokenCountRouteKey !== void 0 && this.lastPromptTokenCount > 0) {
+        this.lastPromptTokenCountsByRouteKey.set(
+          this.lastPromptTokenCountRouteKey,
+          this.lastPromptTokenCount
+        );
+      }
+      this.lastPromptTokenCount = this.lastPromptTokenCountsByRouteKey.get(routeKey) ?? 0;
     }
     this.lastPromptTokenCountChat = chat;
+    this.lastPromptTokenCountRouteKey = routeKey;
   }
   #isAbortError(error) {
     return error instanceof Error && error.name === "AbortError" || typeof DOMException !== "undefined" && error instanceof DOMException && error.name === "AbortError" || typeof error === "object" && error !== null && "name" in error && error.name === "AbortError";
@@ -8258,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) {
@@ -8415,6 +8820,10 @@ ${this.pendingRecoveredAgentsNotice}
     scheduler.start((job) => {
       if (this.cronDisabledByTokenLimit) return;
       if (job.missed && detectAutonomousSentinel(job.prompt)) return;
+      if (!job.missed && job.sessionMode === "per_run" && job.cronExpr !== "@wakeup" && !job.delivery && !detectAutonomousSentinel(job.prompt)) {
+        void this.#dispatchCronToFreshSession(job);
+        return;
+      }
       this.#enqueueCronPrompt({
         prompt: job.prompt,
         source: job.cronExpr === "@wakeup" ? "loop" : "cron",
@@ -8426,6 +8835,77 @@ ${this.pendingRecoveredAgentsNotice}
       void this.#drainCronQueue();
     });
   }
+  /**
+   * Runs a per-run scheduled fire in a fresh child session created through the
+   * daemon. The scheduler has already booked the run; this attributes it to the
+   * child that accepted it. If the daemon cannot create the child, the fire
+   * falls back to this (persistent) session so it is not lost — a consumed
+   * one-shot has no scheduled retry — and the run record keeps the failure
+   * marker alongside the session it actually ran in.
+   */
+  async #dispatchCronToFreshSession(job) {
+    const scheduler = this.config.getCronScheduler();
+    const taskId = job.id ?? "unknown";
+    const firedAt = job.lastFiredAt;
+    const triggeredAt = firedAt ?? Date.now();
+    const record = /* @__PURE__ */ __name(async (outcome) => {
+      if (!job.id || firedAt === void 0) return;
+      await scheduler.annotateRunSession(job.id, firedAt, outcome).catch((error) => {
+        debugLogger6.warn(
+          `Scheduled task ${taskId} could not record its run session: ${error instanceof Error ? error.message : String(error)}`
+        );
+      });
+    }, "record");
+    let sessionId;
+    try {
+      const response = await this.client.extMethod(
+        SERVE_CONTROL_EXT_METHODS.createSubSession,
+        {
+          prompt: buildScheduledTaskRunPrompt({
+            id: taskId,
+            name: job.name,
+            cron: job.cronExpr ?? "",
+            prompt: job.prompt,
+            triggeredAt,
+            trigger: "scheduled"
+          }),
+          completion: "sent",
+          // Title the child from the task and its trigger time — never from
+          // the built prompt, whose first line is the execution-context
+          // header. Same shape the manual-run route gives its children.
+          name: scheduledTaskRunSessionName(
+            job.name ?? job.prompt,
+            triggeredAt
+          ),
+          ...job.id ? {
+            sourceType: SCHEDULED_TASK_RUN_SOURCE_TYPE,
+            sourceId: scheduledTaskRunSourceId(job.id)
+          } : {},
+          callerSessionId: this.sessionId
+        }
+      );
+      const responseSessionId = response["sessionId"];
+      if (typeof responseSessionId !== "string" || responseSessionId.length === 0) {
+        throw new Error("bridge returned a missing session id");
+      }
+      sessionId = responseSessionId;
+    } catch (error) {
+      debugLogger6.warn(
+        `Scheduled task ${taskId} could not create a fresh session, running it in the task session instead: ${error instanceof Error ? error.message : String(error)}`
+      );
+      await record({ sessionId: this.sessionId, dispatchFailed: true });
+      this.#enqueueCronPrompt({
+        prompt: job.prompt,
+        source: "cron",
+        ...job.id ? { taskId: job.id } : {},
+        ...job.lastFiredAt !== void 0 ? { firedAt: job.lastFiredAt } : {}
+      });
+      void this.#drainCronQueue();
+      return;
+    }
+    this.relatedAgentIds.add(sessionId);
+    await record({ sessionId });
+  }
   #startCronSchedulerInRuntime() {
     return Storage.runWithRuntimeBaseDir(
       this.runtimeBaseDir,
@@ -8713,6 +9193,7 @@ ${this.pendingRecoveredAgentsNotice}
                   return;
                 }
                 const responseStream = sendResult.responseStream;
+                const requestRouteKey = sendResult.requestRouteKey;
                 const channelDeliveryResponseBlock = beginChannelDeliveryResponseBlock(responseCapture);
                 const channelDeliveryCheckpoint = channelDeliveryResponseBlock?.parts.length ?? 0;
                 if (loopTick && turnCount === 1) {
@@ -8778,6 +9259,12 @@ ${this.pendingRecoveredAgentsNotice}
                       );
                       functionCalls.length = 0;
                     }
+                    if (resp.type === "compressed" /* COMPRESSED */) {
+                      this.#recordCompressionTokenCount(
+                        resp.info,
+                        requestRouteKey
+                      );
+                    }
                   }
                 } catch (error) {
                   streamFailed = true;
@@ -8799,7 +9286,7 @@ ${this.pendingRecoveredAgentsNotice}
                   functionCalls.length > 0
                 );
                 if (usageMetadata) {
-                  this.#recordPromptTokenCount(usageMetadata);
+                  this.#recordPromptTokenCount(usageMetadata, requestRouteKey);
                   if (this.messageRewriter) {
                     this.messageRewriter.flushTurn(ac.signal);
                   }
@@ -8982,6 +9469,30 @@ ${this.pendingRecoveredAgentsNotice}
         structured: entry ? { commandLabel: truncateNotificationLabel(entry.description) } : void 0
       });
     });
+    const workflowRegistry = this.config.getWorkflowRunRegistry();
+    this.#workflowStatusChangeCallback = (entry) => {
+      this.#activeWorkChanged();
+      if (entry) this.#rememberWorkflowHistory(entry);
+    };
+    workflowRegistry.setStatusChangeCallback(
+      this.#workflowStatusChangeCallback
+    );
+    workflowRegistry.setSnapshotPersistedCallback((runId) => {
+      this.persistedWorkflowRunIds.add(runId);
+      this.unpersistedWorkflowHistory.delete(runId);
+    });
+    workflowRegistry.setCompletionCallback((displayText, modelText, meta) => {
+      const entry = workflowRegistry.get(meta.runId);
+      this.#enqueueBackgroundNotification({
+        displayText,
+        modelText,
+        taskId: meta.runId,
+        status: meta.status,
+        kind: "workflow",
+        continuesTodoStopGuardWorkChain: !entry || !this.todoStopGuardBackgroundBaseline.workflows.has(entry),
+        todoWorkChainId: meta.todoWorkChainId
+      });
+    });
     this.config.getChatRecordingService()?.setTitleRecordedCallback((customTitle, titleSource, sessionId) => {
       void this.client.extNotification("qwen/notify/session/title-update", {
         v: 1,
@@ -8991,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(
@@ -9042,8 +9561,8 @@ ${this.pendingRecoveredAgentsNotice}
     if (existing) return { accepted: await existing };
     const acceptance = this.#persistDaemonBackgroundNotification(item);
     this.backgroundNotificationAcceptances.set(item.taskId, acceptance);
-    if (item.kind === "agent") {
-      this.activeAgentNotificationAcceptances.add(item.taskId);
+    if (item.kind === "agent" || item.kind === "workflow") {
+      this.activeNotificationAcceptances.add(item.taskId);
       this.#activeWorkChanged();
     }
     try {
@@ -9051,8 +9570,8 @@ ${this.pendingRecoveredAgentsNotice}
     } finally {
       if (this.backgroundNotificationAcceptances.get(item.taskId) === acceptance) {
         this.backgroundNotificationAcceptances.delete(item.taskId);
-        if (item.kind === "agent") {
-          this.activeAgentNotificationAcceptances.delete(item.taskId);
+        if (item.kind === "agent" || item.kind === "workflow") {
+          this.activeNotificationAcceptances.delete(item.taskId);
           this.#activeWorkChanged();
         }
       }
@@ -9141,6 +9660,7 @@ ${this.pendingRecoveredAgentsNotice}
         const [item] = this.notificationQueue.splice(nextIndex, 1);
         if (!item) break;
         this.currentAgentNotificationTaskId = item.kind === "agent" ? item.taskId : null;
+        this.currentWorkflowNotificationTaskId = item.kind === "workflow" ? item.taskId : null;
         this.currentShellNotificationActive = item.kind === "shell";
         this.#activeWorkChanged();
         try {
@@ -9155,6 +9675,7 @@ ${this.pendingRecoveredAgentsNotice}
           );
         } finally {
           this.currentAgentNotificationTaskId = null;
+          this.currentWorkflowNotificationTaskId = null;
           this.currentShellNotificationActive = false;
           this.#activeWorkChanged();
         }
@@ -9251,6 +9772,7 @@ ${this.pendingRecoveredAgentsNotice}
               return;
             }
             const responseStream = sendResult.responseStream;
+            const requestRouteKey = sendResult.requestRouteKey;
             nextMessage = null;
             const messageDisplay = this.#createMessageDisplayDispatcher(
               ac.signal
@@ -9297,6 +9819,9 @@ ${this.pendingRecoveredAgentsNotice}
                   );
                   functionCalls.length = 0;
                 }
+                if (resp.type === "compressed" /* COMPRESSED */) {
+                  this.#recordCompressionTokenCount(resp.info, requestRouteKey);
+                }
               }
             } catch (error) {
               streamFailed = true;
@@ -9323,7 +9848,7 @@ ${this.pendingRecoveredAgentsNotice}
               await this.messageRewriter.flushTurn(ac.signal);
             }
             if (usageMetadata) {
-              this.#recordPromptTokenCount(usageMetadata);
+              this.#recordPromptTokenCount(usageMetadata, requestRouteKey);
               const durationMs = Date.now() - streamStartTime;
               await this.messageEmitter.emitUsageMetadata(
                 usageMetadata,
@@ -9606,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", {
@@ -9662,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,
@@ -9682,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(
@@ -9713,10 +10241,119 @@ ${this.pendingRecoveredAgentsNotice}
       }
     };
   }
-  /**
-   * Sends a current_mode_update notification to the client.
-   * Called after the agent switches modes (e.g., from exit_plan_mode tool).
-   */
+  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).
+   */
   async sendCurrentModeUpdateNotification() {
     const newModeId = this.config.getApprovalMode();
     const update = {
@@ -10325,6 +10962,14 @@ ${this.pendingRecoveredAgentsNotice}
       } catch {
       }
     }
+    if (this.config.getOutputStyle?.()) {
+      const outputStyle = resolveMainSessionOutputStyle(this.config);
+      if (outputStyle) {
+        reminders.push({
+          text: wrapSystemReminder(getOutputStyleTurnReminder(outputStyle))
+        });
+      }
+    }
     return reminders;
   }
   async runTool(abortSignal, promptId, fc, onStopAfterPermissionCancel, toolLoopState, recordSkippedToolCall, queueToolResultRecord, generatedCallId, onFullTurnModel) {
@@ -10365,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());
@@ -10816,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)
@@ -10832,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();
@@ -11064,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,
@@ -11082,9 +11765,7 @@ ${this.pendingRecoveredAgentsNotice}
                   _meta: {
                     toolName,
                     ...interactionMetaFields(confirmationDetails),
-                    ...isExitPlanModeTool && this.activeTodoPlanRevision ? {
-                      qwenTodoApproval: this.activeTodoPlanRevision
-                    } : {}
+                    ...qwenTodoApproval ? { qwenTodoApproval } : {}
                   }
                 }
               };
@@ -11115,6 +11796,8 @@ ${this.pendingRecoveredAgentsNotice}
                 if (permissionRequestCancellation) {
                   return permissionRequestCancellation;
                 }
+                const staleTodoPlanApproval2 = await cancelStaleTodoPlanApproval();
+                if (staleTodoPlanApproval2) return staleTodoPlanApproval2;
                 outcome = resolvePermissionOutcome(
                   output,
                   offeredPermissionOptions
@@ -11371,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) {
@@ -11532,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();
             }
           }
@@ -11881,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.");
@@ -13115,11 +13806,21 @@ function validateSkillSlug(slug) {
   }
 }
 __name(validateSkillSlug, "validateSkillSlug");
+function rejectInstallArtifactSlug(slug) {
+  if (/\.(backup|installing)-\d+-\d+$/.test(slug)) {
+    throw RequestError.invalidParams(
+      void 0,
+      "Invalid skill.slug: name ends with a reserved install-artifact suffix"
+    );
+  }
+}
+__name(rejectInstallArtifactSlug, "rejectInstallArtifactSlug");
 function readSkillInstallRequest(params) {
   const skillParams = toRecord2(params["skill"]);
   const input = Object.keys(skillParams).length > 0 ? skillParams : params;
   const slug = readRequiredString2(input["slug"], "skill.slug");
   validateSkillSlug(slug);
+  rejectInstallArtifactSlug(slug);
   const scope = readOptionalString2(input["scope"], "skill.scope") ?? "global";
   if (scope !== "global") {
     throw RequestError.invalidParams(
@@ -13286,8 +13987,29 @@ async function installSkillFromUrl(config, request) {
       await fs2.mkdir(path5.dirname(targetPath), { recursive: true });
       await fs2.writeFile(targetPath, file.content);
     }
-    await fs2.rm(skillDir, { recursive: true, force: true });
-    await fs2.rename(stagingDir, skillDir);
+    const backupDir = `${skillDir}.backup-${process.pid}-${Date.now()}`;
+    let backedUp = false;
+    try {
+      try {
+        await fs2.rename(skillDir, backupDir);
+        backedUp = true;
+      } catch (err) {
+        if (err.code !== "ENOENT") throw err;
+      }
+      await fs2.rename(stagingDir, skillDir);
+    } catch (error) {
+      if (backedUp) {
+        await fs2.rename(backupDir, skillDir).catch(() => {
+        });
+      }
+      await fs2.rm(stagingDir, { recursive: true, force: true }).catch(() => {
+      });
+      throw error;
+    }
+    if (backedUp) {
+      await fs2.rm(backupDir, { recursive: true, force: true }).catch(() => {
+      });
+    }
   } catch (error) {
     await fs2.rm(stagingDir, { recursive: true, force: true }).catch(() => {
     });
@@ -13536,11 +14258,91 @@ function serializeMonitorTask(entry, now) {
   };
 }
 __name(serializeMonitorTask, "serializeMonitorTask");
-function buildSessionTasksStatus(sessionId, config, now = Date.now()) {
+function serializeWorkflowTask(entry, now) {
+  return {
+    kind: "workflow",
+    id: entry.runId,
+    ...optionalField("toolUseId", entry.toolUseId),
+    ...optionalField("sourceRunId", entry.sourceRunId),
+    ...optionalField("startMode", entry.startMode),
+    label: entry.meta?.name ?? entry.description ?? entry.runId,
+    description: entry.meta?.description ?? entry.description,
+    status: entry.status,
+    startTime: entry.startTime,
+    runtimeMs: runtimeMs(entry, now),
+    outputFile: entry.outputFile,
+    ...optionalField("endTime", entry.endTime),
+    isBackgrounded: entry.isBackgrounded === true,
+    currentPhase: entry.currentPhase,
+    phaseVisits: entry.phaseVisits.map((visit) => ({ ...visit })),
+    dispatches: entry.dispatches.map((dispatch) => ({
+      ...dispatch,
+      dependsOn: [...dispatch.dependsOn]
+    })),
+    agentsDispatched: entry.agentsDispatched,
+    agentsCompleted: entry.agentsCompleted,
+    tokensSpent: entry.tokensSpent,
+    tokenBudgetTotal: entry.tokenBudgetTotal,
+    recentLogs: [...entry.recentLogs],
+    events: entry.events.map((event) => ({ ...event })),
+    pendingApprovalCount: entry.pendingApprovals.length,
+    pendingApprovals: entry.pendingApprovals.map((approval) => ({
+      approvalId: approval.approvalId,
+      subagentId: approval.subagentId,
+      name: approval.name,
+      description: approval.description,
+      at: approval.at
+    })),
+    ...optionalField("error", entry.error)
+  };
+}
+__name(serializeWorkflowTask, "serializeWorkflowTask");
+function serializeWorkflowSnapshot(snapshot) {
+  return {
+    kind: "workflow",
+    id: snapshot.runId,
+    isHistorical: true,
+    ...optionalField("sourceRunId", snapshot.sourceRunId),
+    ...optionalField("startMode", snapshot.startMode),
+    label: snapshot.meta?.name ?? snapshot.description ?? snapshot.runId,
+    description: snapshot.meta?.description ?? snapshot.description ?? snapshot.runId,
+    status: snapshot.status,
+    startTime: snapshot.startTime,
+    ...optionalField("endTime", snapshot.endTime),
+    runtimeMs: runtimeMs(snapshot, snapshot.endTime ?? snapshot.startTime),
+    isBackgrounded: false,
+    currentPhase: snapshot.phases.at(-1) ?? null,
+    phaseVisits: (snapshot.phaseVisits ?? []).map((visit) => ({ ...visit })),
+    dispatches: (snapshot.dispatches ?? []).map((dispatch) => ({
+      ...dispatch,
+      dependsOn: [...dispatch.dependsOn]
+    })),
+    agentsDispatched: snapshot.agentsDispatched,
+    agentsCompleted: snapshot.agentsCompleted,
+    tokensSpent: snapshot.tokensSpent,
+    tokenBudgetTotal: snapshot.tokenBudgetTotal,
+    recentLogs: [...snapshot.recentLogs],
+    ...optionalField(
+      "events",
+      snapshot.events?.map((event) => ({ ...event }))
+    ),
+    pendingApprovalCount: 0,
+    ...optionalField("error", snapshot.error)
+  };
+}
+__name(serializeWorkflowSnapshot, "serializeWorkflowSnapshot");
+function buildSessionTasksStatus(sessionId, config, now = Date.now(), workflowHistory = [], options = {}) {
+  const includeWorkflows = options.includeWorkflows === true;
+  const workflowTasks = includeWorkflows ? config.getWorkflowRunRegistry().list() : [];
+  const inMemoryWorkflowIds = new Set(
+    workflowTasks.map((entry) => entry.runId)
+  );
   const tasks = [
     ...config.getBackgroundTaskRegistry().getAll().map((entry) => serializeAgentTask(entry, now)),
     ...config.getBackgroundShellRegistry().getAll().map((entry) => serializeShellTask(entry, now)),
-    ...config.getMonitorRegistry().getAll().map((entry) => serializeMonitorTask(entry, now))
+    ...config.getMonitorRegistry().getAll().map((entry) => serializeMonitorTask(entry, now)),
+    ...includeWorkflows ? workflowTasks.map((entry) => serializeWorkflowTask(entry, now)) : [],
+    ...includeWorkflows ? workflowHistory.filter((snapshot) => !inMemoryWorkflowIds.has(snapshot.runId)).map(serializeWorkflowSnapshot) : []
   ].sort((a, b) => a.startTime - b.startTime);
   return {
     v: STATUS_SCHEMA_VERSION,
@@ -13582,12 +14384,17 @@ var ACP_ERROR_CODES = {
 };
 
 // packages/cli/src/acp-integration/acpAgent.ts
+function isSessionOwnedWorkflowTool(value) {
+  return typeof value === "object" && value !== null && "buildSessionOwnedBackground" in value && typeof value.buildSessionOwnedBackground === "function";
+}
+__name(isSessionOwnedWorkflowTool, "isSessionOwnedWorkflowTool");
 var debugLogger9 = createDebugLogger("ACP_AGENT");
 var QWEN_ACP_LOCAL_READ_ROOTS_ENV = "QWEN_ACP_LOCAL_READ_ROOTS";
 var POSIX_TMP_LOCAL_READ_ROOT = "/tmp";
 var BTW_CHILD_TIMEOUT_MS = 55e3;
 var MCP_OAUTH_START_TIMEOUT_MS = 3e4;
 var SESSION_DRAIN_TIMEOUT_MS = 3e4;
+var SESSION_ID_RE = /^[0-9a-fA-F-]{32,36}$/;
 var WORKSPACE_MEMORY_REMEMBER_CHILD_TIMEOUT_MS = 295e3;
 function currentGoalSnapshot(config, runtime) {
   try {
@@ -14506,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) {
@@ -15534,6 +16358,11 @@ function isOwnerOnlyDirectory(stats) {
   return (stats.mode & 63) === 0;
 }
 __name(isOwnerOnlyDirectory, "isOwnerOnlyDirectory");
+function hasExpectedManagedDirectoryIdentity(stats, expected) {
+  const inodeVerifiable = hasVerifiableInode(stats.ino);
+  return stats.dev === expected.device && inodeVerifiable === (expected.inode !== 0) && (!inodeVerifiable || stats.ino === expected.inode);
+}
+__name(hasExpectedManagedDirectoryIdentity, "hasExpectedManagedDirectoryIdentity");
 function hasOnlyKeys(value, keys) {
   const actual = Object.keys(value).sort();
   const expected = [...keys].sort();
@@ -15608,7 +16437,7 @@ async function assertManagedConversationDirectoryIdentity(expectation) {
       error.code === "ENOENT"
     );
   }
-  if (!isOwnerOnlyDirectory(rootBefore) || !isOwnerOnlyDirectory(rootAfter) || !isSameConversationPath(canonicalRoot, expectation.root.canonicalPath) || rootBefore.dev !== expectation.root.device || rootBefore.ino !== expectation.root.inode || rootAfter.dev !== expectation.root.device || rootAfter.ino !== expectation.root.inode) {
+  if (!isOwnerOnlyDirectory(rootBefore) || !isOwnerOnlyDirectory(rootAfter) || !isSameConversationPath(canonicalRoot, expectation.root.canonicalPath) || !hasExpectedManagedDirectoryIdentity(rootBefore, expectation.root) || !hasExpectedManagedDirectoryIdentity(rootAfter, expectation.root)) {
     throw managedConversationDirectoryError(false);
   }
   let childBefore;
@@ -15623,12 +16452,12 @@ async function assertManagedConversationDirectoryIdentity(expectation) {
       error.code === "ENOENT"
     );
   }
-  if (!isOwnerOnlyDirectory(childBefore) || !isOwnerOnlyDirectory(childAfter) || !isSameConversationPath(canonicalChild, expectation.child.canonicalPath) || childBefore.dev !== expectation.child.device || childBefore.ino !== expectation.child.inode || childAfter.dev !== expectation.child.device || childAfter.ino !== expectation.child.inode) {
+  if (!isOwnerOnlyDirectory(childBefore) || !isOwnerOnlyDirectory(childAfter) || !isSameConversationPath(canonicalChild, expectation.child.canonicalPath) || !hasExpectedManagedDirectoryIdentity(childBefore, expectation.child) || !hasExpectedManagedDirectoryIdentity(childAfter, expectation.child)) {
     throw managedConversationDirectoryError(false);
   }
 }
 __name(assertManagedConversationDirectoryIdentity, "assertManagedConversationDirectoryIdentity");
-var QwenAgent = class {
+var QwenAgent = class _QwenAgent {
   constructor(config, settings, argv, connection, expectedPrivateParentCapability, sessionWriterLeaseEnabledAtStartup = false, managedToolInvocationGuard, externalToolGuardProviderAttached = false) {
     this.config = config;
     this.settings = settings;
@@ -15668,13 +16497,21 @@ var QwenAgent = class {
     __name(this, "QwenAgent");
   }
   sessions = /* @__PURE__ */ new Map();
+  modelProviderReloadRevision = 0;
   historyMutationTails = /* @__PURE__ */ new Map();
   startingSessionIds = /* @__PURE__ */ new Set();
+  /**
+   * R7-10: workflow registries of sessions already removed from
+   * `this.sessions` whose runs have not finished settling. Consulted by
+   * `isWorkflowRunLiveOutsideSession` so a delete-history cannot delete
+   * an orphaned live run out from under itself. Pruned as they drain.
+   */
+  detachedWorkflowRegistries = /* @__PURE__ */ new Set();
   activePromptCalls = /* @__PURE__ */ new Map();
   workspaceMcpDiscoveryConfig;
   workspaceMcpDiscoveryPromise;
   workspaceMcpDiscoveryError;
-  workspaceExtensionStatusRefreshPromise;
+  workspaceExtensionStatusRefreshes = /* @__PURE__ */ new Map();
   pendingMcpAuthentications = /* @__PURE__ */ new Map();
   mcpAuthenticationResults = /* @__PURE__ */ new Map();
   generationControllers = /* @__PURE__ */ new Map();
@@ -15682,6 +16519,26 @@ var QwenAgent = class {
   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. */
@@ -15874,19 +16731,25 @@ var QwenAgent = class {
     }
     return this.workspaceMcpDiscoveryConfig ?? this.config;
   }
-  refreshBootstrapExtensionStatus() {
-    if (this.workspaceExtensionStatusRefreshPromise) {
-      return this.workspaceExtensionStatusRefreshPromise;
-    }
+  refreshBootstrapExtensionStatus(skillsOnly = false) {
+    const inFlight = this.workspaceExtensionStatusRefreshes.get(skillsOnly);
+    if (inFlight) return inFlight;
     const promise = (async () => {
       const errors = [];
+      if (skillsOnly) {
+        try {
+          this.settings.reloadScopeFromDisk("Workspace" /* Workspace */);
+        } catch (error) {
+          errors.push(error);
+        }
+      }
       try {
         await this.config.getExtensionManager().refreshCache();
       } catch (error) {
         errors.push(error);
       }
       try {
-        await this.config.getSkillManager()?.refreshCache();
+        await this.config.getSkillManager()?.refreshCache(skillsOnly ? { throwOnError: true } : void 0);
       } catch (error) {
         errors.push(error);
       }
@@ -15898,10 +16761,10 @@ var QwenAgent = class {
         );
       }
     })();
-    this.workspaceExtensionStatusRefreshPromise = promise;
+    this.workspaceExtensionStatusRefreshes.set(skillsOnly, promise);
     const clear = /* @__PURE__ */ __name(() => {
-      if (this.workspaceExtensionStatusRefreshPromise === promise) {
-        this.workspaceExtensionStatusRefreshPromise = void 0;
+      if (this.workspaceExtensionStatusRefreshes.get(skillsOnly) === promise) {
+        this.workspaceExtensionStatusRefreshes.delete(skillsOnly);
       }
     }, "clear");
     void promise.then(clear, clear);
@@ -15970,56 +16833,63 @@ var QwenAgent = class {
   }
   async createWorkspaceMcpDiscoveryConfig(settings) {
     if (this.workspaceMcpDiscoveryConfig) return;
-    const cwd = this.config.getTargetDir();
-    const config = await this.runWithPinnedRuntimeBaseDir(
-      settings,
-      cwd,
-      () => loadCliConfig(
-        settings.merged,
-        {
-          ...this.argv,
-          sessionId: "workspace-mcp-discovery",
-          resume: void 0,
-          continue: false,
-          chatRecording: false
-        },
+    return sessionIdContext.run("workspace-mcp-discovery", async () => {
+      const cwd = this.config.getTargetDir();
+      const config = await this.runWithPinnedRuntimeBaseDir(
+        settings,
         cwd,
-        void 0,
-        {
-          userHooks: settings.getUserHooks(),
-          projectHooks: settings.getProjectHooks()
-        },
-        buildDisabledSkillNamesProvider(settings)
-      )
-    );
-    config.setMcpTransportPool(this.mcpPool);
-    try {
-      await config.initialize({
-        skipLlmInitialization: true,
-        skipFileCheckpointing: true,
-        skipHooks: true,
-        skipSkillManager: true,
-        skipMcpDiscovery: true,
-        lenientToolWarmup: true
-      });
-      const manager = config.getToolRegistry()?.getMcpClientManager();
-      if (!manager) {
-        throw new Error("MCP client manager is unavailable");
-      }
-      await manager.discoverAllMcpToolsIncremental(config);
-      if (manager.getDiscoveryState() === "not_started" /* NOT_STARTED */) {
-        throw new Error(
-          "MCP discovery did not start. The workspace may not be trusted."
-        );
-      }
-      this.workspaceMcpDiscoveryConfig = config;
-    } catch (error) {
+        () => loadCliConfig(
+          settings.merged,
+          {
+            ...this.argv,
+            sessionId: "workspace-mcp-discovery",
+            resume: void 0,
+            continue: false,
+            chatRecording: false
+          },
+          cwd,
+          void 0,
+          {
+            userHooks: settings.getUserHooks(),
+            projectHooks: settings.getProjectHooks()
+          },
+          buildDisabledSkillNamesProvider(settings),
+          void 0,
+          void 0,
+          void 0,
+          void 0,
+          buildEnabledSkillNamesProvider(settings)
+        )
+      );
+      config.setMcpTransportPool(this.mcpPool);
       try {
-        await config.getToolRegistry()?.stop();
-      } catch {
+        await config.initialize({
+          skipLlmInitialization: true,
+          skipFileCheckpointing: true,
+          skipHooks: true,
+          skipSkillManager: true,
+          skipMcpDiscovery: true,
+          lenientToolWarmup: true
+        });
+        const manager = config.getToolRegistry()?.getMcpClientManager();
+        if (!manager) {
+          throw new Error("MCP client manager is unavailable");
+        }
+        await manager.discoverAllMcpToolsIncremental(config);
+        if (manager.getDiscoveryState() === "not_started" /* NOT_STARTED */) {
+          throw new Error(
+            "MCP discovery did not start. The workspace may not be trusted."
+          );
+        }
+        this.workspaceMcpDiscoveryConfig = config;
+      } catch (error) {
+        try {
+          await config.getToolRegistry()?.stop();
+        } catch {
+        }
+        throw error;
       }
-      throw error;
-    }
+    });
   }
   initializeWorkspaceMcpDiscovery() {
     if (this.workspaceMcpDiscoveryConfig || this.workspaceMcpDiscoveryPromise) {
@@ -16061,6 +16931,10 @@ var QwenAgent = class {
           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);
         }
@@ -16183,6 +17057,19 @@ var QwenAgent = class {
       cleanupErrors.push(error);
     }
     this.sessions.delete(sessionId);
+    this.sessionApprovalModeConverged.delete(sessionId);
+    try {
+      this.pruneDrainedWorkflowRegistries();
+      const registry = session.getConfig().getWorkflowRunRegistry?.();
+      if (registry && _QwenAgent.isWorkflowRegistryDraining(registry)) {
+        this.detachedWorkflowRegistries.add(registry);
+      }
+    } catch (error) {
+      debugLogger9.warn(
+        `Session ${sessionId}: could not retain its workflow registry for liveness checks:`,
+        error
+      );
+    }
     this.activeWorkReporter?.notifyChanged();
     if (cleanupErrors.length > 0) {
       debugLogger9.warn(
@@ -16522,7 +17409,7 @@ var QwenAgent = class {
     }
     this.clientCapabilities = args.clientCapabilities;
     const authMethods = buildAuthMethods();
-    const version = "0.22.3";
+    const version = "0.23.0";
     const response = {
       protocolVersion: PROTOCOL_VERSION,
       agentInfo: {
@@ -16615,7 +17502,11 @@ var QwenAgent = class {
     }
     await clearCachedCredentialFile();
     try {
-      await this.config.refreshAuth(method);
+      await this.refreshAuthWithPersistedReasoning(
+        this.config,
+        this.settings,
+        method
+      );
       this.settings.setValue(
         "User" /* User */,
         "security.auth.selectedType",
@@ -16643,6 +17534,41 @@ var QwenAgent = class {
       this.startingSessionIds.delete(sessionId);
     };
   }
+  createSessionInitializationDeadline(raw) {
+    if (raw === void 0 || !this.isTrustedManagedParent()) return void 0;
+    if (typeof raw !== "number" || !Number.isSafeInteger(raw) || raw <= 0) {
+      throw RequestError.invalidParams(
+        { errorKind: "invalid_session_initialization_deadline" },
+        `\`_meta["${SESSION_INITIALIZATION_DEADLINE_META_KEY}"]\` must be a positive safe integer`
+      );
+    }
+    const remainingMs = raw - Date.now();
+    if (remainingMs > 2147483647) {
+      throw RequestError.invalidParams(
+        { errorKind: "invalid_session_initialization_deadline" },
+        `\`_meta["${SESSION_INITIALIZATION_DEADLINE_META_KEY}"]\` exceeds the supported timer range`
+      );
+    }
+    const controller = new AbortController();
+    const timeoutError = new RequestError(
+      ACP_ERROR_CODES.INTERNAL_ERROR,
+      "Session initialization deadline exceeded",
+      { errorKind: SESSION_INITIALIZATION_TIMEOUT_ERROR_KIND }
+    );
+    let timer;
+    if (remainingMs <= 0) {
+      controller.abort(timeoutError);
+    } else {
+      timer = setTimeout(() => controller.abort(timeoutError), remainingMs);
+      timer.unref();
+    }
+    return {
+      signal: controller.signal,
+      dispose: /* @__PURE__ */ __name(() => {
+        if (timer) clearTimeout(timer);
+      }, "dispose")
+    };
+  }
   async newSession(params) {
     const { cwd, mcpServers } = params;
     const parsedSessionId = parseCallerSuppliedSessionId(
@@ -16657,7 +17583,12 @@ var QwenAgent = class {
     }
     const requestedSessionId = parsedSessionId.kind === "valid" ? parsedSessionId.sessionId : void 0;
     const releaseStartingSessionId = requestedSessionId ? this.reserveStartingSessionId(requestedSessionId) : void 0;
+    let initializationDeadline;
     try {
+      initializationDeadline = this.createSessionInitializationDeadline(
+        params._meta?.[SESSION_INITIALIZATION_DEADLINE_META_KEY]
+      );
+      initializationDeadline?.signal.throwIfAborted();
       const sessionSource = getSessionSource(params);
       const provisionalStandalone = isReservedStandaloneSessionSourceType(
         sessionSource?.sourceType
@@ -16679,6 +17610,8 @@ var QwenAgent = class {
             () => loadSettingsCached(cwd)
           );
           this.settings = settings;
+          const deferMcpDiscovery = shouldDeferMcpDiscovery(params);
+          const configProviderRevision = this.modelProviderReloadRevision;
           const config = await profiler.time(
             "config_setup",
             () => this.newSessionConfig(
@@ -16688,16 +17621,21 @@ var QwenAgent = class {
               sessionSource,
               requestedSessionId,
               void 0,
-              shouldDeferMcpDiscovery(params) ? { skipMcpDiscovery: true } : void 0
+              initializationDeadline || deferMcpDiscovery ? {
+                ...initializationDeadline ? { signal: initializationDeadline.signal } : {},
+                ...deferMcpDiscovery ? { skipMcpDiscovery: true } : {}
+              } : void 0
             )
           );
           let session;
           try {
+            initializationDeadline?.signal.throwIfAborted();
             if (!provisionalStandalone) {
               await profiler.time(
                 "auth",
-                () => this.ensureAuthenticated(config)
+                () => this.ensureAuthenticated(config, settings)
               );
+              initializationDeadline?.signal.throwIfAborted();
               profiler.timeSync(
                 "file_system_setup",
                 () => this.setupFileSystem(config)
@@ -16706,7 +17644,9 @@ var QwenAgent = class {
             session = await profiler.time(
               "session_register",
               () => this.createAndStoreSession(config, settings, void 0, {
-                deferWorkspaceActivation: provisionalStandalone
+                deferWorkspaceActivation: provisionalStandalone,
+                ...initializationDeadline ? { signal: initializationDeadline.signal } : {},
+                configProviderRevision
               })
             );
           } catch (error) {
@@ -16727,6 +17667,7 @@ var QwenAgent = class {
         parentContext ? { parentContext } : {}
       );
     } finally {
+      initializationDeadline?.dispose();
       releaseStartingSessionId?.();
     }
   }
@@ -16880,6 +17821,7 @@ var QwenAgent = class {
       sessionId = persistedSessionId;
       profiler.setSessionId(sessionId);
       this.settings = settings;
+      const configProviderRevision = this.modelProviderReloadRevision;
       const config = await profiler.time(
         "config_setup",
         () => this.newSessionConfig(
@@ -16928,7 +17870,10 @@ var QwenAgent = class {
             () => restoreSessionModelThenAuthenticate(
               config,
               projection,
-              () => profiler.time("auth", () => this.ensureAuthenticated(config))
+              () => profiler.time(
+                "auth",
+                () => this.ensureAuthenticated(config, settings)
+              )
             )
           );
           profiler.timeSync(
@@ -16940,6 +17885,7 @@ var QwenAgent = class {
           "session_register",
           () => this.createAndStoreSession(config, settings, void 0, {
             deferWorkspaceActivation: provisionalStandalone,
+            configProviderRevision,
             ...provisionalStandalone ? {
               beforeDeferredWorkspaceActivation: /* @__PURE__ */ __name(() => profiler.time(
                 "restore_session_model",
@@ -16948,7 +17894,7 @@ var QwenAgent = class {
                   projection,
                   () => profiler.time(
                     "auth",
-                    () => this.ensureAuthenticated(config)
+                    () => this.ensureAuthenticated(config, settings)
                   )
                 )
               ), "beforeDeferredWorkspaceActivation")
@@ -17038,9 +17984,9 @@ var QwenAgent = class {
                 );
               }
             }, "prepareBeforeSessionCreate"),
-            beforeSessionCreate: /* @__PURE__ */ __name(() => {
+            beforeSessionPublish: /* @__PURE__ */ __name(() => {
               response = buildResponse();
-            }, "beforeSessionCreate"),
+            }, "beforeSessionPublish"),
             primeSession: /* @__PURE__ */ __name((createdSession) => {
               profiler.timeSync("runtime_initialize", () => {
                 if (!projection) return;
@@ -17208,6 +18154,7 @@ var QwenAgent = class {
       sessionId = persistedSessionId;
       profiler.setSessionId(sessionId);
       this.settings = settings;
+      const configProviderRevision = this.modelProviderReloadRevision;
       const config = await profiler.time(
         "config_setup",
         () => this.newSessionConfig(
@@ -17234,7 +18181,10 @@ var QwenAgent = class {
             () => restoreSessionModelThenAuthenticate(
               config,
               projection,
-              () => profiler.time("auth", () => this.ensureAuthenticated(config))
+              () => profiler.time(
+                "auth",
+                () => this.ensureAuthenticated(config, settings)
+              )
             )
           );
           profiler.timeSync(
@@ -17246,6 +18196,7 @@ var QwenAgent = class {
           "session_register",
           () => this.createAndStoreSession(config, settings, void 0, {
             deferWorkspaceActivation: provisionalStandalone,
+            configProviderRevision,
             ...provisionalStandalone ? {
               beforeDeferredWorkspaceActivation: /* @__PURE__ */ __name(() => profiler.time(
                 "restore_session_model",
@@ -17254,7 +18205,7 @@ var QwenAgent = class {
                   projection,
                   () => profiler.time(
                     "auth",
-                    () => this.ensureAuthenticated(config)
+                    () => this.ensureAuthenticated(config, settings)
                   )
                 )
               ), "beforeDeferredWorkspaceActivation")
@@ -17263,14 +18214,14 @@ var QwenAgent = class {
               sessionSource ?? {}
             ),
             replayHistory: false,
-            beforeSessionCreate: /* @__PURE__ */ __name(() => {
+            beforeSessionPublish: /* @__PURE__ */ __name(() => {
               response = profiler.timeSync("response_build", () => ({
                 modes: this.buildModesData(config),
                 models: this.buildAvailableModels(config),
                 configOptions: this.buildConfigOptions(config),
                 ...projection?.runtime.artifactSnapshot ? { artifactSnapshot: projection.runtime.artifactSnapshot } : {}
               }));
-            }, "beforeSessionCreate"),
+            }, "beforeSessionPublish"),
             primeSession: /* @__PURE__ */ __name((createdSession) => {
               profiler.timeSync("runtime_initialize", () => {
                 if (!projection) return;
@@ -17420,62 +18371,81 @@ var QwenAgent = class {
           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(
@@ -17859,7 +18829,12 @@ var QwenAgent = class {
               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;
@@ -17949,7 +18924,6 @@ var QwenAgent = class {
                 out.config = serverConfig;
               }
             }
-            const poolRow = poolByName[name];
             if (poolRow) {
               out.entryCount = poolRow.entryCount;
               out.entrySummary = poolRow.entrySummary.map((e) => ({
@@ -18325,7 +19299,8 @@ var QwenAgent = class {
         skills.map((skill) => [
           `${skill.level}:${skill.extensionName ?? ""}:${skill.name}`,
           mapSkillConfigToStatus(skill, disablements, {
-            disabled: isInactiveExtensionSkill(skill, inactiveSkillRefs)
+            disabled: isInactiveExtensionSkill(skill, inactiveSkillRefs),
+            enabled: config.isSkillEnabled(skill)
           })
         ])
       );
@@ -18401,13 +19376,18 @@ var QwenAgent = class {
           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),
@@ -18862,17 +19842,34 @@ var QwenAgent = class {
   }
   async buildSessionSupportedCommandsStatus(sessionId) {
     const session = this.sessionOrThrow(sessionId);
+    const config = session.getConfig();
     const { availableCommands, availableSkills } = await session.buildAvailableCommandsSnapshot();
+    const workflowsEnabled = this.canUseWorkflowControls(config);
+    const savedWorkflows = workflowsEnabled ? (await listSavedWorkflows(config)).map(({ name, source }) => ({
+      name,
+      source
+    })) : [];
     return {
       v: STATUS_SCHEMA_VERSION,
       sessionId,
-      availableCommands,
-      availableSkills: availableSkills ?? []
+      availableCommands: workflowsEnabled || !config.isWorkflowsEnabled() ? availableCommands : availableCommands.filter((command) => command.name !== "workflows"),
+      availableSkills: availableSkills ?? [],
+      workflowsEnabled,
+      savedWorkflows
     };
   }
-  buildSessionTasksStatus(sessionId) {
+  canUseWorkflowControls(config) {
+    return config.isWorkflowsEnabled() && !config.getBareMode() && (!config.getFolderTrustFeature() || config.getFolderTrust());
+  }
+  async buildSessionTasksStatus(sessionId, includeWorkflows = false) {
     const session = this.sessionOrThrow(sessionId);
-    return buildSessionTasksStatus(sessionId, session.getConfig());
+    return buildSessionTasksStatus(
+      sessionId,
+      session.getConfig(),
+      Date.now(),
+      includeWorkflows ? await session.refreshWorkflowHistory() : [],
+      { includeWorkflows }
+    );
   }
   buildSessionLspStatus(sessionId) {
     const session = this.sessionOrThrow(sessionId);
@@ -19228,9 +20225,9 @@ var QwenAgent = class {
       }
       const sessionId = normalizedParams["sessionId"];
       const session = typeof sessionId === "string" && sessionId.length > 0 ? this.sessions.get(sessionId) : void 0;
-      if (session && this.isSessionScopedExtMethod(method)) {
-        return await this.runInSessionContext(
-          session,
+      if (typeof sessionId === "string" && sessionId.length > 0 && this.isSessionScopedExtMethod(method) && (session !== void 0 || SESSION_ID_RE.test(sessionId))) {
+        return await sessionIdContext.run(
+          session?.getConfig().getSessionId() ?? sessionId,
           () => this.extMethodInternal(method, normalizedParams)
         );
       }
@@ -19248,7 +20245,6 @@ var QwenAgent = class {
   async extMethodInternal(method, params) {
     const requestedCwd = typeof params["cwd"] === "string" ? params["cwd"] : void 0;
     const cwd = requestedCwd || process.cwd();
-    const SESSION_ID_RE = /^[0-9a-fA-F-]{32,36}$/;
     switch (method) {
       case SERVE_STATUS_EXT_METHODS.channelPing: {
         const nonce = params["nonce"];
@@ -19350,7 +20346,11 @@ var QwenAgent = class {
           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;
@@ -19520,7 +20520,11 @@ var QwenAgent = class {
             "Invalid or missing sessionId"
           );
         }
-        return this.buildSessionTasksStatus(sessionId);
+        const session = this.sessionOrThrow(sessionId);
+        return await this.buildSessionTasksStatus(
+          sessionId,
+          params["includeWorkflows"] === true && this.canUseWorkflowControls(session.getConfig())
+        );
       }
       case SERVE_STATUS_EXT_METHODS.sessionLspStatus: {
         const sessionId = params["sessionId"];
@@ -19763,6 +20767,10 @@ var QwenAgent = class {
           throw RequestError.invalidParams(void 0, "Invalid contextMode");
         }
         const contextMode = rawContextMode;
+        const rawScope = params["scope"];
+        if (rawScope !== void 0 && rawScope !== "project" && rawScope !== "user") {
+          throw RequestError.invalidParams(void 0, "Invalid scope");
+        }
         if (!this.config.isManagedMemoryAvailable()) {
           throw new RequestError(
             -32009,
@@ -19781,6 +20789,7 @@ var QwenAgent = class {
             projectRoot,
             content: content.trim(),
             contextMode,
+            ...rawScope ? { scope: rawScope } : {},
             abortSignal: childSignal
           });
           if (result.filesTouched.length > 0) {
@@ -19851,6 +20860,10 @@ var QwenAgent = class {
             "Query exceeds maximum size"
           );
         }
+        const rawScope = params["scope"];
+        if (rawScope !== void 0 && rawScope !== "project" && rawScope !== "user") {
+          throw RequestError.invalidParams(void 0, "Invalid scope");
+        }
         if (!this.config.isManagedMemoryAvailable()) {
           throw new RequestError(
             -32009,
@@ -19867,7 +20880,8 @@ var QwenAgent = class {
           const hiddenConfig = createHiddenWorkspaceMemoryConfig(this.config);
           const result = await this.config.getMemoryManager().forget(projectRoot, trimmedQuery, {
             config: hiddenConfig,
-            abortSignal: childSignal
+            abortSignal: childSignal,
+            ...rawScope ? { scope: rawScope } : {}
           });
           return {
             summary: result.systemMessage ?? formatWorkspaceMemoryForgetSummary(result.removedEntries.length),
@@ -20957,10 +21971,13 @@ var QwenAgent = class {
               { errorKind: "containment_violation", path: rootPath }
             );
           }
-          if (!isOwnerOnlyDirectory(rootBefore) || !isOwnerOnlyDirectory(rootAfter) || rootBefore.dev !== rootAfter.dev || rootBefore.ino !== rootAfter.ino || conversationDirectoryExpectation !== void 0 && (!isSameConversationPath(
+          if (!isOwnerOnlyDirectory(rootBefore) || !isOwnerOnlyDirectory(rootAfter) || !isSameDirectoryIdentity(rootBefore, rootAfter) || conversationDirectoryExpectation !== void 0 && (!isSameConversationPath(
             canonicalRoot,
             conversationDirectoryExpectation.root.canonicalPath
-          ) || rootAfter.dev !== conversationDirectoryExpectation.root.device || rootAfter.ino !== conversationDirectoryExpectation.root.inode)) {
+          ) || !hasExpectedManagedDirectoryIdentity(
+            rootAfter,
+            conversationDirectoryExpectation.root
+          ))) {
             if (conversationDirectoryExpectation !== void 0) {
               throw managedConversationDirectoryError(false);
             }
@@ -20988,10 +22005,13 @@ var QwenAgent = class {
             );
           }
           const relativeTarget = path6.relative(canonicalRoot, canonicalPath);
-          if (!isOwnerOnlyDirectory(targetBefore) || !isOwnerOnlyDirectory(targetAfter) || targetBefore.dev !== targetAfter.dev || targetBefore.ino !== targetAfter.ino || conversationDirectoryExpectation !== void 0 && (!isSameConversationPath(
+          if (!isOwnerOnlyDirectory(targetBefore) || !isOwnerOnlyDirectory(targetAfter) || !isSameDirectoryIdentity(targetBefore, targetAfter) || conversationDirectoryExpectation !== void 0 && (!isSameConversationPath(
             canonicalPath,
             conversationDirectoryExpectation.child.canonicalPath
-          ) || targetAfter.dev !== conversationDirectoryExpectation.child.device || targetAfter.ino !== conversationDirectoryExpectation.child.inode) || relativeTarget.length === 0 || relativeTarget.startsWith("..") || path6.isAbsolute(relativeTarget) || relativeTarget.includes(path6.sep)) {
+          ) || !hasExpectedManagedDirectoryIdentity(
+            targetAfter,
+            conversationDirectoryExpectation.child
+          )) || relativeTarget.length === 0 || relativeTarget.startsWith("..") || path6.isAbsolute(relativeTarget) || relativeTarget.includes(path6.sep)) {
             if (conversationDirectoryExpectation !== void 0) {
               throw managedConversationDirectoryError(false);
             }
@@ -21014,7 +22034,10 @@ var QwenAgent = class {
               { errorKind: "containment_violation", path: canonicalRoot }
             );
           }
-          if (!isOwnerOnlyDirectory(rootFinal) || rootFinal.dev !== rootAfter.dev || rootFinal.ino !== rootAfter.ino || conversationDirectoryExpectation !== void 0 && (rootFinal.dev !== conversationDirectoryExpectation.root.device || rootFinal.ino !== conversationDirectoryExpectation.root.inode)) {
+          if (!isOwnerOnlyDirectory(rootFinal) || !isSameDirectoryIdentity(rootFinal, rootAfter) || conversationDirectoryExpectation !== void 0 && !hasExpectedManagedDirectoryIdentity(
+            rootFinal,
+            conversationDirectoryExpectation.root
+          )) {
             if (conversationDirectoryExpectation !== void 0) {
               throw managedConversationDirectoryError(false);
             }
@@ -21047,7 +22070,19 @@ var QwenAgent = class {
         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;
           }
@@ -21208,9 +22243,25 @@ var QwenAgent = class {
             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"];
@@ -21316,6 +22367,51 @@ var QwenAgent = class {
         }
         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) {
@@ -21566,10 +22662,10 @@ ${outputText}
           );
         }
         const taskKind = params["taskKind"];
-        if (taskKind !== "agent" && taskKind !== "shell" && taskKind !== "monitor") {
+        if (taskKind !== "agent" && taskKind !== "shell" && taskKind !== "monitor" && taskKind !== "workflow") {
           throw RequestError.invalidParams(
             void 0,
-            'taskKind must be "agent", "shell", or "monitor"'
+            'taskKind must be "agent", "shell", "monitor", or "workflow"'
           );
         }
         debugLogger9.info(
@@ -21627,12 +22723,169 @@ ${outputText}
             );
             return { cancelled: true, status: task.status };
           }
+          case "workflow": {
+            if (!this.canUseWorkflowControls(config)) {
+              return { cancelled: false, reason: "disabled" };
+            }
+            const registry = config.getWorkflowRunRegistry();
+            const task = registry.get(taskId);
+            if ((!task || isTerminalWorkflowStatus(task.status)) && registry.isStarting?.(taskId)) {
+              registry.cancelStarting(taskId);
+              debugLogger9.info(
+                `sessionTaskCancel completed sessionId=${sessionId} taskId=${taskId} taskKind=${taskKind} status=starting`
+              );
+              return { cancelled: true, status: "cancelled" };
+            }
+            if (!task || task.status !== "running" && task.status !== "pausing" && task.status !== "paused") {
+              const reason = task ? "not_running" : "not_found";
+              debugLogger9.info(
+                `sessionTaskCancel skipped sessionId=${sessionId} taskId=${taskId} taskKind=${taskKind} reason=${reason} status=${task?.status ?? "missing"}`
+              );
+              return { cancelled: false, reason, status: task?.status };
+            }
+            const handle = registry.getHandle(taskId);
+            registry.cancel(taskId, Date.now());
+            if (handle) await handle.completion;
+            debugLogger9.info(
+              `sessionTaskCancel completed sessionId=${sessionId} taskId=${taskId} taskKind=${taskKind} status=${task.status}`
+            );
+            return { cancelled: true, status: task.status };
+          }
           default: {
             const exhaustive = taskKind;
             throw new Error(`Unhandled task kind: ${exhaustive}`);
           }
         }
       }
+      case SERVE_CONTROL_EXT_METHODS.sessionWorkflowTaskAction: {
+        const sessionId = params["sessionId"];
+        if (typeof sessionId !== "string" || sessionId.length === 0) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Invalid or missing sessionId"
+          );
+        }
+        const taskId = params["taskId"];
+        if (typeof taskId !== "string" || taskId.length === 0) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Invalid or missing taskId"
+          );
+        }
+        const action = params["action"];
+        if (action !== "pause" && action !== "resume" && action !== "retry" && action !== "rerun" && action !== "delete-history" && action !== "run-saved") {
+          throw RequestError.invalidParams(
+            void 0,
+            'action must be "pause", "resume", "retry", "rerun", "delete-history", or "run-saved"'
+          );
+        }
+        const session = this.sessionOrThrow(sessionId);
+        const config = session.getConfig();
+        if (!this.canUseWorkflowControls(config)) {
+          return { changed: false };
+        }
+        const mutationClaim = action === "run-saved" ? getWorkflowTaskMutationKey(config, taskId, "saved") : getWorkflowTaskMutationKey(config, taskId);
+        if (action === "delete-history") {
+          const attempt = await tryWithWorkflowTaskMutation(
+            mutationClaim,
+            async () => {
+              const changed2 = await session.deleteWorkflowHistory(taskId);
+              if (changed2) {
+                for (const [siblingId, sibling] of this.sessions) {
+                  if (siblingId === sessionId) continue;
+                  sibling.getConfig().getWorkflowRunRegistry().removeTerminal(taskId);
+                  sibling.noteExternalWorkflowDeletion(taskId);
+                }
+              }
+              return { changed: changed2 };
+            }
+          );
+          if (!attempt.acquired) {
+            return { changed: false };
+          }
+          return attempt.value;
+        }
+        const registry = config.getWorkflowRunRegistry();
+        if (action === "run-saved") {
+          const attempt = await tryWithWorkflowTaskMutation(
+            mutationClaim,
+            async () => {
+              const savedWorkflow = (await listSavedWorkflows(config)).find(
+                (entry) => entry.name === taskId
+              );
+              if (!savedWorkflow) return { changed: false };
+              const workflowTool = config.getToolRegistry().getTool(ToolNames.WORKFLOW);
+              if (!isSessionOwnedWorkflowTool(workflowTool)) {
+                throw RequestError.invalidParams(
+                  void 0,
+                  "The workflow tool is unavailable; cannot run this saved workflow."
+                );
+              }
+              const result = await workflowTool.buildSessionOwnedBackground({
+                scriptPath: savedWorkflow.scriptPath
+              }).execute(new AbortController().signal);
+              const startedTask = result.workflowRunId ? registry.get(result.workflowRunId) : void 0;
+              return startedTask ? {
+                changed: true,
+                status: startedTask.status,
+                taskId: startedTask.runId
+              } : { changed: false };
+            }
+          );
+          if (!attempt.acquired) {
+            return { changed: false };
+          }
+          return attempt.value;
+        }
+        const task = registry.get(taskId);
+        if (!task) return { changed: false };
+        if (action === "retry" || action === "rerun") {
+          const liveElsewhere = action === "retry" && (registry.isStarting?.(taskId) === true || this.isWorkflowRunLiveOutsideSession(sessionId, taskId));
+          const canStart = action === "retry" ? task.status === "failed" && !registry.getHandle(taskId) && !liveElsewhere : task.status === "completed" || task.status === "failed" || task.status === "cancelled";
+          if (!canStart || !task.script) {
+            return { changed: false, status: task.status };
+          }
+          const attempt = await tryWithWorkflowTaskMutation(
+            mutationClaim,
+            async () => {
+              const workflowTool = config.getToolRegistry().getTool(ToolNames.WORKFLOW);
+              if (!isSessionOwnedWorkflowTool(workflowTool)) {
+                throw RequestError.invalidParams(
+                  void 0,
+                  `The workflow tool is unavailable; cannot ${action} this run.`
+                );
+              }
+              const startParams = {
+                script: task.script,
+                args: task.args,
+                ...action === "retry" ? { resumeFromRunId: task.runId } : {}
+              };
+              const result = await workflowTool.buildSessionOwnedBackground(startParams).execute(new AbortController().signal);
+              if (action === "rerun") {
+                const rerunTask = result.workflowRunId ? registry.get(result.workflowRunId) : void 0;
+                if (rerunTask) {
+                  registry.setLineage(rerunTask.runId, task.runId, "rerun");
+                }
+                return rerunTask ? {
+                  changed: true,
+                  status: rerunTask.status,
+                  taskId: rerunTask.runId
+                } : { changed: false, status: task.status };
+              }
+              return result.workflowRunId ? {
+                changed: true,
+                status: registry.get(result.workflowRunId)?.status
+              } : { changed: false, status: task.status };
+            }
+          );
+          if (!attempt.acquired) {
+            return { changed: false, status: task.status };
+          }
+          return attempt.value;
+        }
+        const changed = action === "pause" ? registry.pause(taskId) : registry.resume(taskId);
+        return { changed, status: task.status };
+      }
       case SERVE_CONTROL_EXT_METHODS.sessionGoalClear: {
         const sessionId = params["sessionId"];
         if (typeof sessionId !== "string" || sessionId.length === 0) {
@@ -21902,6 +23155,14 @@ ${outputText}
       case SERVE_CONTROL_EXT_METHODS.workspaceExtensionsRefresh: {
         const sessionId = params["sessionId"];
         const rawRefreshBootstrap = params["refreshBootstrap"];
+        const rawSkillsOnly = params["skillsOnly"];
+        if (rawSkillsOnly !== void 0 && typeof rawSkillsOnly !== "boolean") {
+          throw RequestError.invalidParams(
+            void 0,
+            "skillsOnly must be a boolean"
+          );
+        }
+        const skillsOnly = rawSkillsOnly === true;
         if (rawRefreshBootstrap !== void 0 && typeof rawRefreshBootstrap !== "boolean") {
           throw RequestError.invalidParams(
             void 0,
@@ -21919,16 +23180,25 @@ ${outputText}
             errors.push(error);
           }
         }, "runRefresh");
+        if (skillsOnly) {
+          await runRefresh(async () => session.reloadSkillSettings());
+        }
         await runRefresh(async () => await extensionManager.refreshCache());
-        await runRefresh(async () => await extensionManager.refreshTools());
+        if (skillsOnly) {
+          await runRefresh(
+            async () => await config.getSkillManager()?.refreshCache({ throwOnError: true })
+          );
+        } else {
+          await runRefresh(async () => await extensionManager.refreshTools());
+        }
         const bootstrapConfig = this.config;
         if (rawRefreshBootstrap !== false && bootstrapConfig !== config) {
           await runRefresh(
-            async () => await this.refreshBootstrapExtensionStatus()
+            async () => await this.refreshBootstrapExtensionStatus(skillsOnly)
           );
         }
         const discoveryConfig = this.workspaceMcpDiscoveryConfig;
-        if (discoveryConfig && discoveryConfig !== config) {
+        if (!skillsOnly && discoveryConfig && discoveryConfig !== config) {
           const discoveryExtensionManager = discoveryConfig.getExtensionManager();
           await runRefresh(
             async () => await discoveryExtensionManager.refreshCache()
@@ -21941,7 +23211,10 @@ ${outputText}
           async () => await config.getLlmClient()?.refreshSystemInstruction()
         );
         await runRefresh(
-          async () => await session.sendAvailableCommandsUpdate()
+          async () => skillsOnly ? await session.refreshSkillsFromSettings({
+            reloadSettings: false,
+            notifyConfigChanged: false
+          }) : await session.sendAvailableCommandsUpdate()
         );
         if (errors.length > 0) {
           const details = errors.map(
@@ -22583,6 +23856,52 @@ ${outputText}
         this.syncLivePermissionManagers(before, after);
         return buildPermissionSettings(settings);
       }
+      case SERVE_CONTROL_EXT_METHODS.workspaceModelProvidersReload: {
+        if (!this.settings.reloadScopesFromDiskAtomically([
+          "User" /* User */,
+          "Workspace" /* Workspace */
+        ])) {
+          debugLogger9.warn("Model-provider settings reload failed");
+          return { configsRefreshed: 0, configsFailed: 1 };
+        }
+        this.modelProviderReloadRevision += 1;
+        const merged = this.settings.merged;
+        reloadEnvironment(merged, cwd);
+        const providerProtocol = merged.providerProtocol ?? {};
+        let configsRefreshed = 0;
+        let configsFailed = 0;
+        const reloadConfig = /* @__PURE__ */ __name((config, id) => {
+          try {
+            config.reloadModelProvidersConfig(
+              merged.modelProviders,
+              providerProtocol
+            );
+            configsRefreshed += 1;
+          } catch {
+            configsFailed += 1;
+            debugLogger9.warn(`Model-provider reload failed for ${id}`);
+          }
+        }, "reloadConfig");
+        reloadConfig(this.config, "bootstrap");
+        for (const config of this.initializingConfigs) {
+          if (config !== this.config) {
+            reloadConfig(config, `initializing:${config.getSessionId()}`);
+          }
+        }
+        for (const [id, session] of this.sessions) {
+          try {
+            session.reloadModelProvidersFromDisk();
+            configsRefreshed += 1;
+          } catch {
+            configsFailed += 1;
+            debugLogger9.warn(`Model-provider reload failed for session ${id}`);
+          }
+        }
+        return {
+          configsRefreshed,
+          configsFailed
+        };
+      }
       case SERVE_CONTROL_EXT_METHODS.workspaceReload: {
         const oldMerged = structuredClone(this.settings.merged);
         this.settings.reloadScopeFromDisk("User" /* User */);
@@ -22591,6 +23910,23 @@ ${outputText}
         const envResult = reloadEnvironment(newMerged, cwd);
         const changed = diffSettingsKeys(oldMerged, newMerged);
         const envChanged = envResult.updatedKeys.length > 0 || envResult.removedKeys.length > 0;
+        const providersChanged = changed.has("modelProviders") || changed.has("providerProtocol");
+        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 = [];
@@ -22602,7 +23938,6 @@ ${outputText}
             }
             const config = session.getConfig();
             const authType = config.getAuthType();
-            const providersChanged = changed.has("modelProviders") || changed.has("providerProtocol");
             if (providersChanged) {
               try {
                 config.reloadModelProvidersConfig(
@@ -22619,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}`
@@ -22626,31 +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 newMode = newMerged.tools?.approvalMode;
-              if (newMode && APPROVAL_MODES.includes(newMode) && newMode !== config.getApprovalMode()) {
+            }
+            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 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 {
@@ -22861,25 +24231,34 @@ ${outputText}
     }
   }
   async newSessionConfig(cwd, mcpServers, settings, sessionSource, sessionId, resume, initializeOptions = {}, chatRecording, restoreOptions) {
+    const preserveIdlessSession = sessionId === void 0 && chatRecording === false;
+    const inheritedSessionId = preserveIdlessSession ? sessionIdContext.getStore() : void 0;
+    const sessionIdGenerated = sessionId === void 0 && !preserveIdlessSession;
+    const effectiveSessionId = sessionId ?? (sessionIdGenerated ? randomUUID2() : void 0);
+    const debugSessionId = effectiveSessionId ?? inheritedSessionId ?? "transcript-replay";
     try {
       this.assertManagedSessionAdmission();
-      return await this.runWithPinnedRuntimeBaseDir(settings, cwd, async () => {
-        await this.retryPendingConfigCleanup(
-          Storage.getRuntimeBaseDir(),
-          sessionId
-        );
-        return this.newSessionConfigInRuntimeContext(
-          cwd,
-          mcpServers,
-          settings,
-          sessionSource,
-          sessionId,
-          resume,
-          initializeOptions,
-          chatRecording,
-          restoreOptions
-        );
-      });
+      return await sessionIdContext.run(
+        debugSessionId,
+        () => this.runWithPinnedRuntimeBaseDir(settings, cwd, async () => {
+          await this.retryPendingConfigCleanup(
+            Storage.getRuntimeBaseDir(),
+            effectiveSessionId
+          );
+          return this.newSessionConfigInRuntimeContext(
+            cwd,
+            mcpServers,
+            settings,
+            sessionSource,
+            effectiveSessionId,
+            resume,
+            initializeOptions,
+            chatRecording,
+            restoreOptions,
+            sessionIdGenerated
+          );
+        })
+      );
     } catch (error) {
       if (error instanceof SessionIdConflictError) {
         throw new RequestError(ACP_ERROR_CODES.INVALID_PARAMS, error.message, {
@@ -22896,7 +24275,7 @@ ${outputText}
       throw sessionId && restoreOptions ? mapSessionRestoreRequestError(error, sessionId) : error;
     }
   }
-  async newSessionConfigInRuntimeContext(cwd, mcpServers, settings, sessionSource, sessionId, resume, initializeOptions = {}, chatRecording, restoreOptions) {
+  async newSessionConfigInRuntimeContext(cwd, mcpServers, settings, sessionSource, sessionId, resume, initializeOptions = {}, chatRecording, restoreOptions, sessionIdGenerated) {
     const provisionalWorkspace = isReservedStandaloneSessionSourceType(
       sessionSource?.sourceType
     );
@@ -22958,7 +24337,11 @@ ${outputText}
         ...sessionSource?.sourceType === "channel" ? { cron: false } : {}
       }
     };
-    const sessionArg = resume === true ? { resume: sessionId, sessionId: void 0 } : { sessionId, resume: void 0 };
+    const sessionArg = resume === true ? { resume: sessionId, sessionId: void 0 } : {
+      sessionId,
+      sessionIdGenerated: sessionIdGenerated === true || void 0,
+      resume: void 0
+    };
     const argvForSession = {
       ...this.argv,
       ...provisionalWorkspace ? { experimentalLsp: false } : {},
@@ -23011,7 +24394,8 @@ ${outputText}
             ), "projectionSource")
           }
         } : {}
-      } : void 0
+      } : void 0,
+      buildEnabledSkillNamesProvider(settings)
     );
     if (sessionSource) {
       config.setSessionSource(sessionSource.sourceType, sessionSource.sourceId);
@@ -23048,16 +24432,18 @@ ${outputText}
     const wiredSessionId = typeof config.getSessionId === "function" ? config.getSessionId() : void 0;
     const skipPerSessionBudgetCallback = this.workspaceMcpBudget !== void 0;
     if (!skipPerSessionBudgetCallback && typeof config.setMcpBudgetEventCallback === "function" && wiredSessionId !== void 0) {
-      const sid = wiredSessionId;
+      const acpSessionId = wiredSessionId;
       config.setMcpBudgetEventCallback((event) => {
-        void this.connection.extNotification("qwen/notify/session/mcp-budget-event", {
-          v: 1,
-          sessionId: sid,
-          ...event
-        }).catch((err) => {
-          debugLogger9.debug(
-            `MCP budget extNotification dropped (session=${sid}, kind=${event.kind}): ${err instanceof Error ? err.message : String(err)}`
-          );
+        sessionIdContext.run(config.getSessionId(), () => {
+          void this.connection.extNotification("qwen/notify/session/mcp-budget-event", {
+            v: 1,
+            sessionId: acpSessionId,
+            ...event
+          }).catch((err) => {
+            debugLogger9.debug(
+              `MCP budget extNotification dropped (session=${acpSessionId}, kind=${event.kind}): ${err instanceof Error ? err.message : String(err)}`
+            );
+          });
         });
       });
     }
@@ -23103,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(
@@ -23112,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(
@@ -23123,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(
@@ -23136,14 +24581,82 @@ ${outputText}
     );
     config.setFileSystemService(acpFileSystemService);
   }
+  /**
+   * All sessions in this child share one workflow snapshot store but each
+   * keeps a private run registry, so one session's history deletion must
+   * see every sibling registry — or it can delete a run another session
+   * is still executing or settling. A handle outlives the terminal
+   * transition until the snapshot write lands, so it blocks too.
+   *
+   * R7-10: iterating `this.sessions` alone left a blind spot the width of
+   * a whole run. A workflow can outlive its owning session's removal —
+   * explicit close/kill/shutdown use force semantics, and a background
+   * run owns a detached controller — so once `removeStoredSessionEntry`
+   * deleted the session, a still-settling run became invisible here and
+   * unreachable by the delete handler's sibling `removeTerminal` loop. A
+   * sibling `delete-history` then passed every check, removed the LIVE
+   * run's journal directory and snapshot, and answered `{changed: true}`;
+   * the orphan kept going and its settlement `writeWorkflowSnapshot`
+   * recreated the file — resurrection, plus a run whose journal was rm'd
+   * under it.
+   *
+   * The repair has two halves. `Session.dispose()` now aborts its
+   * workflow registry the way it already aborts the agent registry, so an
+   * orphan settles instead of running on; and the registry of a removed
+   * session stays reachable here until its runs drain, so the gate keeps
+   * answering for the settlement window that abort cannot compress to
+   * zero (the handle is released only after the snapshot write lands).
+   */
+  isWorkflowRunLiveOutsideSession(excludeSessionId, runId) {
+    for (const [sessionId, session] of this.sessions) {
+      if (sessionId === excludeSessionId) continue;
+      if (_QwenAgent.isWorkflowRunLiveInRegistry(
+        session.getConfig().getWorkflowRunRegistry(),
+        runId
+      )) {
+        return true;
+      }
+    }
+    this.pruneDrainedWorkflowRegistries();
+    for (const registry of this.detachedWorkflowRegistries) {
+      if (_QwenAgent.isWorkflowRunLiveInRegistry(registry, runId)) return true;
+    }
+    return false;
+  }
+  static isWorkflowRunLiveInRegistry(registry, runId) {
+    if (registry.isStarting?.(runId)) return true;
+    const entry = registry.get(runId);
+    if (entry && !isTerminalWorkflowStatus(entry.status)) return true;
+    return registry.getHandle(runId) !== void 0;
+  }
+  /**
+   * Registries of removed sessions are retained only while they still
+   * hold work — an aborted run keeps its handle until settlement releases
+   * it. Dropping drained ones keeps this from becoming a leak that grows
+   * with every closed session.
+   */
+  pruneDrainedWorkflowRegistries() {
+    for (const registry of this.detachedWorkflowRegistries) {
+      if (!_QwenAgent.isWorkflowRegistryDraining(registry)) {
+        this.detachedWorkflowRegistries.delete(registry);
+      }
+    }
+  }
+  /** Still holding work: an active entry, or a handle awaiting settlement. */
+  static isWorkflowRegistryDraining(registry) {
+    if (registry.hasRunningEntries?.()) return true;
+    return registry.list?.().some((entry) => registry.getHandle(entry.runId)) ?? false;
+  }
   async createAndStoreSession(config, settings, sessionData, options = {}) {
+    options.signal?.throwIfAborted();
     this.assertManagedSessionAdmission();
     const sessionId = normalizeSessionIdForLookup(config.getSessionId());
     const llmClient = config.getLlmClient();
     const needsInitialize = !llmClient.isInitialized();
     if (needsInitialize && options.deferWorkspaceActivation !== true) {
-      await llmClient.initialize();
+      await llmClient.initialize(void 0, options.signal);
     }
+    options.signal?.throwIfAborted();
     this.assertManagedSessionAdmission();
     if (this.sessions.has(sessionId)) {
       throw new RequestError(
@@ -23153,6 +24666,7 @@ ${outputText}
       );
     }
     await options.prepareBeforeSessionCreate?.();
+    options.signal?.throwIfAborted();
     this.assertManagedSessionAdmission();
     if (this.sessions.has(sessionId)) {
       throw new RequestError(
@@ -23161,14 +24675,16 @@ ${outputText}
         { errorKind: "session_id_conflict", sessionId }
       );
     }
-    options.beforeSessionCreate?.();
+    const workflowHistory = await listWorkflowSnapshots(config);
     const session = new Session(
       sessionId,
       config,
       this.connection,
       settings,
       (operation) => this.runExclusiveHistoryMutation(sessionId, operation),
-      () => this.activeWorkReporter?.notifyChanged()
+      () => this.activeWorkReporter?.notifyChanged(),
+      workflowHistory,
+      (runId) => this.isWorkflowRunLiveOutsideSession(sessionId, runId)
     );
     const replaySessionHistory = /* @__PURE__ */ __name(async () => {
       if (options.replayHistory === false || !sessionData?.conversation.messages) {
@@ -23192,10 +24708,21 @@ ${outputText}
       session.installManagedConversationActivation(
         async () => {
           this.assertManagedSessionAdmission();
+          const settingsReloaded = settings.reloadScopesFromDiskAtomically?.([
+            "User" /* User */,
+            "Workspace" /* Workspace */
+          ]) !== false;
+          if (settingsReloaded) {
+            reloadEnvironment(settings.merged, config.getTargetDir());
+          } else {
+            debugLogger9.warn(
+              "Deferred session settings reload failed; keeping current environment"
+            );
+          }
           if (options.beforeDeferredWorkspaceActivation) {
             await options.beforeDeferredWorkspaceActivation();
           } else {
-            await this.ensureAuthenticated(config);
+            await this.ensureAuthenticated(config, settings);
           }
           this.assertManagedSessionAdmission();
           await config.activateProvisionalWorkspace();
@@ -23219,11 +24746,64 @@ ${outputText}
     let published = false;
     try {
       await registerCreateSubSessionTool(config);
+      options.signal?.throwIfAborted();
+      let forceAuthenticationRefresh = options.deferWorkspaceActivation !== true && options.configProviderRevision !== this.modelProviderReloadRevision;
+      while (true) {
+        const providerReloadRevision = this.modelProviderReloadRevision;
+        const previousModelProviders = settings.merged.modelProviders;
+        const previousProviderProtocol = settings.merged.providerProtocol;
+        const settingsReloaded = settings.reloadScopesFromDiskAtomically?.([
+          "User" /* User */,
+          "Workspace" /* Workspace */
+        ]) !== false;
+        if (!settingsReloaded) {
+          if (providerReloadRevision !== options.configProviderRevision) {
+            throw new Error(
+              "Unable to reload model-provider settings from disk."
+            );
+          }
+          debugLogger9.warn(
+            "Final model-provider settings reload failed; keeping current settings"
+          );
+        }
+        config.reloadModelProvidersConfig?.(
+          settings.merged.modelProviders,
+          settings.merged.providerProtocol ?? {}
+        );
+        if (options.deferWorkspaceActivation !== true) {
+          const envReload = reloadEnvironment(
+            settings.merged,
+            config.getTargetDir()
+          );
+          const providerSettingsChanged = !isDeepStrictEqual(
+            previousModelProviders,
+            settings.merged.modelProviders
+          ) || !isDeepStrictEqual(
+            previousProviderProtocol,
+            settings.merged.providerProtocol
+          );
+          if (forceAuthenticationRefresh || providerSettingsChanged || envReload.updatedKeys.length > 0 || envReload.removedKeys.length > 0) {
+            await this.ensureAuthenticated(config, settings);
+          }
+        }
+        if (providerReloadRevision === this.modelProviderReloadRevision) break;
+        forceAuthenticationRefresh = true;
+      }
+      options.beforeSessionPublish?.();
       options.primeSession?.(session);
       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);
@@ -23355,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
@@ -23374,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,
@@ -23384,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",