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

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

@@ -2,7 +2,7 @@
 "use strict";
 import {
   recomputeMcpGating
-} from "./chunk-P5GGM4KS.js";
+} from "./chunk-RAEEQEC5.js";
 import {
   classifyApiError,
   fireSessionDeleteHook
@@ -17,7 +17,10 @@ import {
   normalizePartList,
   parseExtensionRef,
   parseMcpServerRef
-} from "./chunk-OIP7C4FE.js";
+} from "./chunk-AKNQMSL2.js";
+import {
+  getCommandSubcommandNames
+} from "./chunk-QE7DTCLX.js";
 import {
   getAvailableCommands,
   getSlashCommandFirstToken,
@@ -26,53 +29,52 @@ import {
   isSlashCommand,
   recordDaemonSessionModel,
   restoreSessionModelThenAuthenticate
-} from "./chunk-F5SZP77N.js";
+} from "./chunk-BBYTY46C.js";
 import {
   SessionIdConflictError,
   appEvents,
   buildDisabledSkillNamesProvider,
+  buildEnabledSkillNamesProvider,
   cleanupReviewWorktreeLeases,
   loadCliConfig,
   normalizeDisabledToolList
-} from "./chunk-BAJKAAOY.js";
+} from "./chunk-YOMKOM7E.js";
+import {
+  getEffectiveSupportedModes
+} from "./chunk-3NQCZMUB.js";
 import "./chunk-NYX53SV4.js";
+import "./chunk-JLSZT354.js";
 import {
   collectContextData,
   formatContextUsageText
-} from "./chunk-AGR5UROZ.js";
-import {
-  getCommandSubcommandNames
-} from "./chunk-IJKTMLBE.js";
-import {
-  getEffectiveSupportedModes
-} from "./chunk-K2NQPH5D.js";
-import "./chunk-FDY5RMGH.js";
+} from "./chunk-KUDI54QQ.js";
 import "./chunk-4WGODMVR.js";
+import {
+  startNonInteractiveOpenAILogHousekeeping
+} from "./chunk-XPDKSOVW.js";
+import "./chunk-KW7NOTN6.js";
 import "./chunk-3SH53ANB.js";
+import "./chunk-BSJOBW4U.js";
 import {
   isGoalStatusKind
 } from "./chunk-EKTCKZV5.js";
-import "./chunk-QP4C6WCE.js";
+import "./chunk-NGKLMNWN.js";
 import "./chunk-YAF2MQZ6.js";
-import "./chunk-QFCDF5PL.js";
+import "./chunk-JHN7UIDW.js";
 import {
-  startNonInteractiveOpenAILogHousekeeping
-} from "./chunk-JSHHYW6T.js";
-import "./chunk-KW7NOTN6.js";
-import "./chunk-C6K43ZDE.js";
+  computeCpuPercent
+} from "./chunk-LBOVL47Y.js";
+import "./chunk-24FVUD5P.js";
+import "./chunk-QTMPM6RC.js";
 import "./chunk-6H67XLET.js";
 import {
   beginAcpBootstrapConfigProfiling,
   buildAndFreezeAcpStartupProfile,
   endAcpBootstrapConfigProfiling,
   markAcpStartup
-} from "./chunk-5JTIYALA.js";
-import "./chunk-A7YP63XN.js";
-import "./chunk-L6YT5H34.js";
-import "./chunk-CSMI4FP5.js";
-import {
-  computeCpuPercent
-} from "./chunk-LBOVL47Y.js";
+} from "./chunk-JZWOCUZ3.js";
+import "./chunk-UKB2TZAO.js";
+import "./chunk-MJBHSZEJ.js";
 import {
   GENERATION_MAX_PROMPT_BYTES,
   GENERATION_TIMEOUT_MS,
@@ -85,7 +87,6 @@ import {
   createWorkspaceMemoryExtractionErrorLogger,
   executeGeneration,
   formatWorkspaceMemoryForgetSummary,
-  isCompatibleLiveSessionSource,
   isValidServerName,
   projectAcpToolResultUpdate,
   redactMcpServerSecrets,
@@ -94,7 +95,7 @@ import {
   shouldSuppressRememberErrorDetails,
   workspaceMemoryFailureCode,
   workspaceMemoryFailureDiagnostics
-} from "./chunk-4MQEPP3Y.js";
+} from "./chunk-BY24DZ4J.js";
 import {
   BaseEmitter,
   HistoryReplayer,
@@ -105,29 +106,39 @@ import {
   hasFullSessionContext,
   observeAcpToolResultProjection,
   observeAcpToolResultWire
-} from "./chunk-3SGB2UHX.js";
-import "./chunk-BFPESSTR.js";
-import "./chunk-E7REAOTN.js";
-import "./chunk-XDLEZ5HX.js";
+} from "./chunk-L2OKAIUK.js";
+import "./chunk-XEAAO654.js";
+import "./chunk-47ECGEJC.js";
+import "./chunk-OQYXJK2V.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-OHU2H5CS.js";
+import "./chunk-4VQBQLIZ.js";
 import {
   DAEMON_OWNED_STANDALONE_CREATION_KEY,
   SESSION_SOURCE_META_KEY,
   isReservedStandaloneSessionSourceType,
   parseSessionSource
-} from "./chunk-2TNL5KPM.js";
-import {
-  buildToolWriteOriginMeta,
-  getConversationDirectoryName,
-  isSameConversationPath
-} from "./chunk-T3WXYEZ4.js";
-import "./chunk-UXEO7E3V.js";
-import "./chunk-RXFQM6FQ.js";
+} from "./chunk-N4QWUPDM.js";
 import {
-  normalizeChannelDeliveryText
-} from "./chunk-4CMJKUND.js";
+  buildScheduledTaskRunPrompt,
+  normalizeChannelDeliveryText,
+  scheduledTaskRunSessionName,
+  scheduledTaskRunSourceId
+} from "./chunk-PNIGAVY6.js";
 import {
   normalizeSessionIdForLookup,
   parseCallerSuppliedSessionId
@@ -138,21 +149,25 @@ import {
   buildPermissionSettings,
   normalizePermissionRules,
   readPermissionRuleSet
-} from "./chunk-KEKZFOL6.js";
+} from "./chunk-JPKTAQS3.js";
 import {
   MAX_AUDIO_BYTES,
   sanitizeVoiceErrorMessage,
   transcribeVoiceAudio
-} from "./chunk-JCQD3INC.js";
+} from "./chunk-YNG7XAJU.js";
 import {
   readVoiceModel
-} from "./chunk-XRSOI3DL.js";
-import "./chunk-YTDVNSUQ.js";
-import "./chunk-RJC5EIKY.js";
-import "./chunk-6CGL7E7G.js";
-import "./chunk-ZGXYO7DY.js";
+} from "./chunk-BE5FGT5Z.js";
+import "./chunk-QAK5475D.js";
+import "./chunk-6YXNJXQW.js";
+import "./chunk-AN3KFCNH.js";
+import "./chunk-JS73NNWF.js";
+import {
+  SCHEDULED_TASK_RUN_SOURCE_TYPE
+} from "./chunk-RLSPPTWH.js";
 import "./chunk-7U5G6JXI.js";
 import "./chunk-WCCLLK7X.js";
+import "./chunk-OCPBI7J5.js";
 import {
   REASONING_EFFORT_DEFAULT,
   REASONING_EFFORT_NAMES,
@@ -160,7 +175,7 @@ import {
   buildModelReasoningConfigOption,
   buildModelReasoningConfigPreview,
   getModelConfiguration
-} from "./chunk-4K7NQDCG.js";
+} from "./chunk-T4EFG2P5.js";
 import {
   ACP_ROUTE_ID_PREFIX,
   buildAcpModelOptions,
@@ -169,26 +184,27 @@ import {
   parseAcpModelOption,
   resolveAcpModelOption,
   sanitizeProviderBaseUrl
-} from "./chunk-Q26AYA62.js";
+} from "./chunk-W7KWB6AH.js";
 import {
   mapSkillConfigToStatus
-} from "./chunk-BGXZBI5B.js";
+} from "./chunk-BHTYRHJF.js";
 import {
   resolveSkillSettings
-} from "./chunk-Z4X5MTRT.js";
-import "./chunk-FBSSIAAQ.js";
-import "./chunk-PFCQ62V4.js";
+} from "./chunk-HWVUSYSN.js";
+import "./chunk-DMEUXLSS.js";
+import "./chunk-OE5AQVNB.js";
+import "./chunk-H2A2GJGL.js";
 import "./chunk-57OAHC2Y.js";
-import "./chunk-HVQ3B7FF.js";
-import "./chunk-7JPW6IYH.js";
-import "./chunk-5XBFCMWD.js";
+import "./chunk-V4HN35IF.js";
+import "./chunk-CAZADEU7.js";
+import "./chunk-GN422P4J.js";
 import "./chunk-V6WHFGST.js";
 import {
   createLoadedSettingsAdapter
-} from "./chunk-CPGJJJLU.js";
+} from "./chunk-HDMKCJHI.js";
 import {
   ndJsonStream
-} from "./chunk-H72BQNM3.js";
+} from "./chunk-JMRE4WJQ.js";
 import {
   ACP_PREFLIGHT_KINDS,
   IDLE_HOOK_EVENTS,
@@ -196,8 +212,8 @@ import {
   SERVE_STATUS_EXT_METHODS,
   STATUS_SCHEMA_VERSION,
   mapDomainErrorToErrorKind
-} from "./chunk-JHS74YAB.js";
-import "./chunk-MZS7GEC7.js";
+} from "./chunk-J4Y3QJHF.js";
+import "./chunk-SMRDCANI.js";
 import {
   ACTIVE_WORK_CLOSE_IF_UNHELD_PARAM,
   ACTIVE_WORK_HEARTBEAT_META_KEY,
@@ -228,22 +244,24 @@ 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-YPISTYEI.js";
 import "./chunk-6PLDPT2C.js";
 import "./chunk-FYJ7W2PI.js";
 import "./chunk-STUJ7IMZ.js";
-import "./chunk-JVPFTDBK.js";
-import "./chunk-ALMR3E6Q.js";
 import "./chunk-GYTKQYDB.js";
+import "./chunk-3EGEBDTW.js";
+import "./chunk-ALMR3E6Q.js";
 import "./chunk-RKFGE7JH.js";
 import "./chunk-UDG5EZJI.js";
 import {
@@ -256,11 +274,11 @@ import {
   isValidExternalToolGuardDenialReason
 } from "./chunk-3VUENPWF.js";
 import "./chunk-M5GB774H.js";
-import "./chunk-7EQQR46F.js";
+import "./chunk-ZVP4PWBU.js";
 import {
   ACP_EVENT_LOOP_STALL_RESTART_MS,
   CHANNEL_PROMPT_META_KEY
-} from "./chunk-E55H6BZ7.js";
+} from "./chunk-IXEZHTDR.js";
 import {
   AgentSideConnection,
   PROTOCOL_VERSION,
@@ -269,7 +287,7 @@ import {
 import {
   assembleMcpServers,
   loadMcpApprovals
-} from "./chunk-5O72BNDD.js";
+} from "./chunk-ND7TQQPE.js";
 import {
   getOutputLanguageFilePath,
   getPersistScopeForModelSelection,
@@ -278,9 +296,9 @@ import {
   resolveOutputLanguageOrPreserveAuto,
   updateOutputLanguageFile,
   writeOutputLanguageAndRegisterPath
-} from "./chunk-F7TNAPZ4.js";
+} from "./chunk-AAX236AR.js";
+import "./chunk-NT5XIL5H.js";
 import "./chunk-RKUWKYED.js";
-import "./chunk-JSC3H3TD.js";
 import "./chunk-GOXKNSDZ.js";
 import {
   getSystemDefaultsPath,
@@ -289,7 +307,7 @@ import {
 import {
   getCurrentLanguage,
   setLanguageAsync
-} from "./chunk-LDP5OD6N.js";
+} from "./chunk-EU2B4P3D.js";
 import {
   SUPPORTED_LANGUAGES
 } from "./chunk-5EJZE3FP.js";
@@ -297,19 +315,19 @@ import {
   findEnvFiles,
   preResolveHomeEnvOverrides,
   reloadEnvironment
-} from "./chunk-IK5BW3CS.js";
+} from "./chunk-T4RMUTTT.js";
 import {
   ENV_ACP_REPEATED_TOOL_FAILURE_GUARD,
   QWEN_CODE_SERVE_ENV
-} from "./chunk-5PA6UEYA.js";
-import "./chunk-V2NDP3I4.js";
-import "./chunk-7UYV53BC.js";
+} from "./chunk-3452WXOK.js";
+import "./chunk-7XL4WRXM.js";
+import "./chunk-ZYPJ7HVZ.js";
 import "./chunk-W3N5XAZ6.js";
 import {
   isFolderTrustEnabled,
   isWorkspaceTrusted,
   loadTrustedFolders
-} from "./chunk-V4QXXQJ2.js";
+} from "./chunk-I75VKFCJ.js";
 import "./chunk-NPQ5ZKRP.js";
 import "./chunk-MR3PXB6E.js";
 import {
@@ -339,30 +357,37 @@ import {
   resolveBaseUrl,
   runManagedRememberByAgent,
   subagentGenerator
-} from "./chunk-KUX5D6DK.js";
-import "./chunk-3DXFGHAJ.js";
+} from "./chunk-NT7LXVV5.js";
+import {
+  MAX_RETAINED_SNAPSHOTS,
+  deleteWorkflowSnapshot,
+  listSavedWorkflows,
+  listWorkflowSnapshots,
+  toSnapshot
+} from "./chunk-DBTMP3P4.js";
 import "./chunk-XFSFZCM5.js";
 import "./chunk-2EAZ43JQ.js";
 import "./chunk-NF5J2WFA.js";
 import {
   CreateSubSessionTool
-} from "./chunk-CQH5KTKC.js";
+} from "./chunk-ERHAMGAA.js";
 import "./chunk-LJZSMWOH.js";
-import "./chunk-6LFTG244.js";
-import "./chunk-PKAYJDB3.js";
-import "./chunk-6IUNAPLR.js";
+import "./chunk-6NWPR2EB.js";
+import "./chunk-GCUR24KK.js";
+import "./chunk-W4BDHLRT.js";
 import {
   restoreWorktreeContext
-} from "./chunk-OIVXBW3W.js";
-import "./chunk-4CDSK5AZ.js";
-import "./chunk-XQFT3QUF.js";
-import "./chunk-VTHREBQM.js";
+} from "./chunk-ED7DD7MV.js";
+import "./chunk-AYYKUUKP.js";
+import "./chunk-PWR2NQBS.js";
+import "./chunk-ENYUKMFK.js";
+import "./chunk-UKYXYWI2.js";
 import "./chunk-ZPJWUGCS.js";
 import {
   clearCachedCredentialFile,
   qwenOAuth2Events
-} from "./chunk-H2WDGQ6D.js";
-import "./chunk-MIIVI25Q.js";
+} from "./chunk-3AKCBZVW.js";
+import "./chunk-JDIO45X7.js";
 import {
   APPROVAL_MODE_INFO,
   BranchPointInvalidError,
@@ -380,7 +405,6 @@ import {
   MessageDisplayDispatcher,
   PLAN_MODE_ENTRY_SIBLING_SKIP_MESSAGE,
   POOLED_TRANSPORTS_DEFAULT,
-  SESSION_ARTIFACT_PERSISTENCE_VERSION,
   SESSION_TITLE_MAX_LENGTH,
   SESSION_TRANSCRIPT_MAX_LIMIT,
   SESSION_TRANSCRIPT_MAX_PAGE_BYTES,
@@ -397,6 +421,7 @@ import {
   TURN_RESULT_TEXT_MAX_CHARS,
   abortGoalForStopHookCap,
   acquireSleepInhibitor,
+  ambientGoalToolResultProvenance,
   applyAutoModeDecision,
   approxBase64Bytes,
   bridgeToolResultImages,
@@ -431,31 +456,30 @@ import {
   formatStopHookBlockingCapWarning,
   generateToolUseId,
   getActiveGoal,
-  getArenaSystemReminder,
   getAutoModePermissionDeniedReason,
   getEffectivePermissionForConfirmation,
   getFunctionCallFingerprint,
   getMCPDiscoveryState,
-  getPlanModeSystemReminder,
   getProviderToolCallId,
   getScopedEnvContents,
   getStopHookContinuationReason,
   getToolCallRepeatKey,
+  getWorkflowTaskMutationKey,
   ideContextStore,
   injectPermissionRulesIfMissing,
   isApproveOutcome,
+  isCompressionFailureStatus,
   isDenialFallbackReason,
   isGatedMcpScope,
   isPlanModeBlocked,
   isReplayOfHandledToolCall,
+  isTerminalWorkflowStatus,
   isTurnResultRecordPayload,
   markDuplicateProviderToolCallResponseSent,
   matchesAnyServerPattern,
   mcpServerRequiresOAuth,
   needsConfirmation,
   normalizeDerivedBranchTitle,
-  normalizeEventPayload,
-  normalizeSnapshotPayload,
   normalizeTurnResultError,
   observeToolResultBoundary,
   persistPermissionOutcome,
@@ -476,46 +500,66 @@ import {
   toolResultBoundaryArtifact,
   toolResultPartDiagnosticValues,
   truncateNotificationLabel,
+  tryWithWorkflowTaskMutation,
   updateSetting,
   validatePlanModeShellApproval,
   validatePlanModeShellContext
-} from "./chunk-TGWAQ5RB.js";
+} from "./chunk-ZBDYI7VM.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-P2SU6ZTI.js";
-import "./chunk-IZIVM7LZ.js";
-import "./chunk-SFPGAQUL.js";
+import "./chunk-SMJYTKTB.js";
+import "./chunk-AI35S34R.js";
+import "./chunk-FIWZOMBF.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";
 import "./chunk-IRH27ZC2.js";
 import "./chunk-QHWCP53L.js";
-import "./chunk-D5LUXLUH.js";
+import "./chunk-UJ4DUYIH.js";
 import {
   promptIdContext,
   todoWorkChainContext
 } from "./chunk-O6GEWCJA.js";
-import "./chunk-T26EAKDL.js";
-import "./chunk-EOGELB3H.js";
-import "./chunk-CPBF7KYF.js";
-import "./chunk-EFUM7RVY.js";
+import {
+  getArenaSystemReminder,
+  getOutputStyleTurnReminder,
+  getPlanModeSystemReminder,
+  resolveMainSessionOutputStyle
+} from "./chunk-YDQ4OCDK.js";
+import "./chunk-SDCHI64N.js";
+import "./chunk-B2RIIK3K.js";
+import "./chunk-373DQUVA.js";
+import {
+  AgentOutputMessageCapture,
+  addAgentInputMessageAttributes,
+  addToolArgumentsAttributes,
+  addToolCallResultAttributes,
+  registerAcpEventLoopLagGauge,
+  startEventLoopLagMonitor
+} from "./chunk-OSTQZIOY.js";
 import {
   HookEventName,
   createHookOutput
-} from "./chunk-TTX2JUE6.js";
-import "./chunk-43GGFFLY.js";
-import "./chunk-SMPR7SPO.js";
-import "./chunk-JWALNCLT.js";
-import "./chunk-NIFYWDYN.js";
-import "./chunk-3AFMQUTI.js";
+} from "./chunk-U6D2PPMN.js";
+import "./chunk-PDXYZBBQ.js";
+import "./chunk-QJNDUTOL.js";
+import "./chunk-ZHO2CW6D.js";
+import "./chunk-AF3QB6OL.js";
+import "./chunk-7TBU7PU2.js";
+import "./chunk-E4JNFXNI.js";
 import {
   GoalConflictError,
   GoalInvalidTransitionError,
@@ -524,50 +568,45 @@ import {
   goalTurnContext,
   parseGoalControlRequest,
   parseGoalSnapshotV2,
-  parseGoalStateCause,
+  parseGoalStateCause
+} from "./chunk-4P7PPAHN.js";
+import {
   wrapUserPromptSubmitContext
-} from "./chunk-WKK5BQNP.js";
+} from "./chunk-7J6OTNGO.js";
+import {
+  escapeJsonTagCharacters
+} from "./chunk-CHEIIBT3.js";
+import "./chunk-VYSZUQGU.js";
 import {
   APPROVAL_MODES
-} from "./chunk-V5J4J5TP.js";
+} from "./chunk-JX6XHPTX.js";
 import "./chunk-MLXTMF7H.js";
 import "./chunk-NAVJD2PQ.js";
-import "./chunk-3JGZSIDA.js";
-import "./chunk-VVW4ZNFY.js";
+import "./chunk-KFN2IZYR.js";
+import "./chunk-GB4UKWY5.js";
 import "./chunk-QHMLYMMS.js";
-import {
-  AgentOutputMessageCapture,
-  addAgentInputMessageAttributes,
-  addToolArgumentsAttributes,
-  addToolCallResultAttributes,
-  registerAcpEventLoopLagGauge,
-  startEventLoopLagMonitor
-} from "./chunk-7DJCPZE3.js";
-import "./chunk-P3QQPMQA.js";
 import {
   addDaemonRequestAttribute,
   extractDaemonTraceContext,
   withDaemonSpan
-} from "./chunk-HVEYF6VT.js";
+} from "./chunk-UXEW7TQS.js";
 import "./chunk-VNOVK4I7.js";
-import "./chunk-SAH4BD2J.js";
-import "./chunk-PDMJ3KGS.js";
+import "./chunk-PQEISIKS.js";
+import "./chunk-RT4QNQ5P.js";
 import {
   runWithRuntimeContentGenerator
-} from "./chunk-CMHFCLBU.js";
+} from "./chunk-26SIKQIC.js";
 import "./chunk-S6LOFUVP.js";
+import {
+  getToolCallPreparations
+} from "./chunk-CFKIH3D3.js";
 import {
   REASONING_EFFORT_TIERS,
   applyReasoningEffort
 } from "./chunk-2LD5U7Q3.js";
 import "./chunk-DJ2GSRLV.js";
-import "./chunk-J2OSJFP3.js";
-import "./chunk-K2OJUPOE.js";
-import {
-  getToolCallPreparations
-} from "./chunk-CFKIH3D3.js";
-import "./chunk-4FTKQNWJ.js";
-import "./chunk-Y3QL45LS.js";
+import "./chunk-S2T7H5MI.js";
+import "./chunk-LKODFJRD.js";
 import {
   ConversationFinishedEvent,
   DiscoveredMCPTool,
@@ -598,35 +637,35 @@ import {
   shouldRunVisionBridge,
   splitImageParts,
   uiTelemetryService
-} from "./chunk-L2M46FP5.js";
-import "./chunk-YRLW2MSX.js";
+} from "./chunk-FXUSWLBF.js";
+import "./chunk-XBVNNDPK.js";
 import "./chunk-VGC4I5JJ.js";
 import {
-  getAllGeminiMdFilenames,
+  getAllMemoryFilenames,
   getSpecificMimeType
-} from "./chunk-3I6UTTDX.js";
+} from "./chunk-67AY5D3M.js";
 import {
   getAutoMemoryRoot,
   getUserAutoMemoryRoot
-} from "./chunk-6PJOTWAN.js";
+} from "./chunk-HT5S5TRQ.js";
 import {
   runSideQuery
-} from "./chunk-BWORX6FA.js";
+} from "./chunk-LMMHS3RS.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-Z7FLBQPR.js";
+} from "./chunk-H5GPPDGY.js";
 import "./chunk-XZA32HII.js";
-import "./chunk-23RFD54N.js";
+import "./chunk-KHP66DFN.js";
 import {
   AuthType
-} from "./chunk-PPKZ7JOE.js";
+} from "./chunk-22UH7VTP.js";
 import "./chunk-HHJLM3WQ.js";
 import {
   endToolExecutionSpan,
@@ -638,17 +677,18 @@ import {
   startToolExecutionSpan,
   startToolSpan,
   withInteractionSpan
-} from "./chunk-L6BZRIUL.js";
+} from "./chunk-TBJ3SNS3.js";
 import "./chunk-74TONY4F.js";
-import "./chunk-XF63PKEN.js";
+import "./chunk-IXHV5MIC.js";
 import {
   FORK_SUBAGENT_TYPE,
   getStartupContextLength,
-  isSystemReminderContent
-} from "./chunk-CAJTKR6W.js";
-import "./chunk-ZU4UDIWX.js";
+  isSystemReminderContent,
+  wrapSystemReminder
+} from "./chunk-D7D3HSYQ.js";
+import "./chunk-YKADANK6.js";
 import "./chunk-AQ37AY7B.js";
-import "./chunk-PDQGMSZK.js";
+import "./chunk-ODZF64DM.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
@@ -656,7 +696,7 @@ import {
   ToolNames,
   canonicalToolName,
   isShellProgressData
-} from "./chunk-UTLCH2FK.js";
+} from "./chunk-LYSZVCCD.js";
 import {
   Storage,
   createDebugLogger,
@@ -664,15 +704,16 @@ import {
   getErrorStatus,
   isSubpath,
   sessionIdContext
-} from "./chunk-UHQFIS7N.js";
-import "./chunk-W5MJJ2V7.js";
+} from "./chunk-EAHOJF6V.js";
+import "./chunk-FHPYRXRH.js";
+import "./chunk-WLEYH7CD.js";
 import {
   runExitCleanup
-} from "./chunk-Y6LSMB6J.js";
+} from "./chunk-TV7BJ7TX.js";
 import {
   writeStderrLine,
   writeStderrLineSafe
-} from "./chunk-KGJGEEVR.js";
+} from "./chunk-7FA2II6K.js";
 import "./chunk-75DOP5OR.js";
 import "./chunk-DMTGGOSA.js";
 import "./chunk-YQ3U5MUC.js";
@@ -689,6 +730,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();
@@ -1050,9 +1092,6 @@ function inactiveExtensionSkillRefs(config) {
     if (extension.isActive) continue;
     for (const skill of extension.skills ?? []) {
       refs.add(extensionSkillRef(extension.name, skill.name));
-      if (extension.displayName) {
-        refs.add(extensionSkillRef(extension.displayName, skill.name));
-      }
     }
   }
   return refs;
@@ -1074,7 +1113,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;
@@ -1099,6 +1138,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();
@@ -1151,11 +1193,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: [
           {
@@ -3157,6 +3201,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";
@@ -3204,10 +3249,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);
@@ -3871,13 +3912,13 @@ async function registerCreateSubSessionTool(config) {
       ToolNames.CREATE_SUB_SESSION,
       async () => new CreateSubSessionTool(config)
     );
-    await config.getGeminiClient().setTools();
+    await config.getLlmClient().setTools();
     return;
   }
   toolRegistry.registerTool(new CreateSubSessionTool(config));
   toolRegistry.revealDeferredTool(ToolNames.CREATE_SUB_SESSION);
   toolRegistry.pinDeferredToolReveal(ToolNames.CREATE_SUB_SESSION);
-  await config.getGeminiClient().setTools();
+  await config.getLlmClient().setTools();
 }
 __name(registerCreateSubSessionTool, "registerCreateSubSessionTool");
 var STANDALONE_SLASH_COMMAND_POLICY = Object.freeze({
@@ -3909,11 +3950,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,
@@ -3922,7 +3961,7 @@ async function buildAvailableCommandsSnapshot(config, abortSignal = AbortSignal.
       },
       inactiveSkillRefs
     );
-    return !disabledSkillNames.has(skillName) && !isInactiveExtensionCommand;
+    return config.isSkillEnabled(cmd.skillDetail) && !isInactiveExtensionCommand;
   });
   const availableCommands = visibleSlashCommands.map(
     (cmd) => {
@@ -3953,7 +3992,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) {
@@ -3994,13 +4033,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?.()
     );
@@ -4080,6 +4121,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
@@ -4108,10 +4157,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;
@@ -4137,6 +4187,33 @@ 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;
@@ -4211,6 +4288,7 @@ var Session = class {
             controller: new AbortController(),
             origin: "runtime",
             continuationContext: input.continuationContext,
+            ...input.objectiveUpdated ? { objectiveUpdated: input.objectiveUpdated } : {},
             ...input.windDown ? { windDown: true } : {},
             ...input.verifierFeedback ? { verifierFeedback: input.verifierFeedback } : {},
             modelStarted: false
@@ -4413,6 +4491,24 @@ var Session = class {
       void this.#drainGoalQueue();
     }
   }
+  /**
+   * Confirms the continuation's prompt reached the model.
+   *
+   * `startGoalTurn` resolves at enqueue time, so the runtime cannot tell a
+   * delivered turn from a queued one when it settles; `#settleGoalTurn`'s
+   * degraded-persistence fallback settles a model-started turn through
+   * `releaseTurn`, and only this confirmation keeps that turn's objective
+   * announcement from rolling back and re-firing on the next continuation.
+   */
+  #markGoalTurnDelivered(turnKey) {
+    try {
+      this.config.getGoalRuntime().markTurnDelivered(turnKey);
+    } catch (error) {
+      debugLogger6.debug(
+        `Failed to confirm ACP Goal turn delivery: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
   async #settleGoalTurn(turn, result, failed) {
     try {
       const runtime = await this.config.getGoalRuntimeReady();
@@ -4777,6 +4873,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"
     ) : [];
@@ -4793,6 +4890,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(
@@ -4862,6 +4960,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(
@@ -5044,11 +5148,11 @@ var Session = class {
     await this.#syncLiveToolDeclarations();
   }
   async #syncLiveToolDeclarations() {
-    const geminiClient = this.config.getGeminiClient();
-    if (!geminiClient) {
+    const llmClient = this.config.getLlmClient();
+    if (!llmClient) {
       throw new Error("The Live backend model client is unavailable.");
     }
-    await geminiClient.setTools();
+    await llmClient.setTools();
   }
   async setLiveConversationActive(active) {
     if (this.liveConversationActive === active) return;
@@ -5065,7 +5169,7 @@ var Session = class {
       this.liveEndInstructionPending = true;
       this.config.setLiveAppendSystemPrompt(LIVE_BACKEND_END_INSTRUCTIONS);
     }
-    await this.config.getGeminiClient()?.refreshSystemInstruction();
+    await this.config.getLlmClient()?.refreshSystemInstruction();
   }
   async appendLiveConversationTranscript(entries, model) {
     if (this.liveConversationActive !== true) {
@@ -5103,7 +5207,7 @@ var Session = class {
     if (this.liveConversationActive || !this.liveEndInstructionPending) return;
     this.liveEndInstructionPending = false;
     this.config.setLiveAppendSystemPrompt(void 0);
-    await this.config.getGeminiClient()?.refreshSystemInstruction();
+    await this.config.getLlmClient()?.refreshSystemInstruction();
   }
   getId() {
     return this.sessionId;
@@ -5127,6 +5231,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();
@@ -5311,14 +5540,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 });
     }
@@ -5326,6 +5560,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() {
@@ -5482,6 +5725,13 @@ 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.unsubscribeChatRecordingFailure?.();
     this.unsubscribeChatRecordingFailure = void 0;
@@ -5555,7 +5805,7 @@ var Session = class {
         "Cannot rewind while a prompt is running"
       );
     }
-    const chat = this.config.getGeminiClient().getChat();
+    const chat = this.config.getLlmClient().getChat();
     const apiHistory = chat.getHistoryShallow();
     const apiTruncateIndex = this.#computeApiTruncationIndexForUserTurn(
       apiHistory,
@@ -5591,7 +5841,7 @@ var Session = class {
     return { targetTurnIndex, apiTruncateIndex };
   }
   captureHistorySnapshot() {
-    return this.config.getGeminiClient().getChat().getHistoryShallow();
+    return this.config.getLlmClient().getChat().getHistoryShallow();
   }
   getRewindableUserTurnCount() {
     const apiHistory = this.captureHistorySnapshot();
@@ -5613,7 +5863,7 @@ var Session = class {
         "Cannot restore history while a prompt is running"
       );
     }
-    this.config.getGeminiClient().getChat().setHistory(structuredClone(history));
+    this.config.getLlmClient().getChat().setHistory(structuredClone(history));
     this.activeTodoPlanRevision = void 0;
     this.#clearTodoStopGuardTrustAndDrainAutomaticQueues();
   }
@@ -6040,8 +6290,8 @@ var Session = class {
    * authoritatively. Powers `qwen/control/session/continue`.
    */
   async continueLastTurn() {
-    const geminiClient = this.config.getGeminiClient();
-    if (!geminiClient || !geminiClient.isInitialized()) {
+    const llmClient = this.config.getLlmClient();
+    if (!llmClient || !llmClient.isInitialized()) {
       return { accepted: false, interruption: "none" };
     }
     const chat = this.#getCurrentChat();
@@ -6090,7 +6340,7 @@ var Session = class {
     }
     if (this.settings.merged.ui?.enableFollowupSuggestions === false) return;
     if (this.config.getApprovalMode() === "plan" /* PLAN */) return;
-    const chat = this.config.getGeminiClient()?.getChat();
+    const chat = this.config.getLlmClient()?.getChat();
     if (!chat) return;
     const ac = new AbortController();
     this.followupAbort = ac;
@@ -6421,7 +6671,7 @@ var Session = class {
             }
             if (isFreshUserTurn) {
               managedMemoryRecallStarted = true;
-              this.config.getGeminiClient().beginManagedAutoMemoryRecall(promptText, pendingSend.signal);
+              this.config.getLlmClient().beginManagedAutoMemoryRecall(promptText, pendingSend.signal);
             }
             if (!continuesCurrentWorkChain && !this.todoStopGuard.enabled) {
               this.#resetTodoStopGuardBackgroundLineage();
@@ -6449,7 +6699,7 @@ var Session = class {
             }
             const systemReminders = await this.#buildInitialSystemReminders();
             if (isFreshUserTurn) {
-              const memory = await this.config.getGeminiClient().consumeManagedAutoMemoryRecall("initial");
+              const memory = await this.config.getLlmClient().consumeManagedAutoMemoryRecall("initial");
               if (memory?.prompt) {
                 systemReminders.unshift({ text: memory.prompt });
               }
@@ -6629,8 +6879,14 @@ ${this.pendingRecoveredAgentsNotice}
                 );
                 let channelDeliveryResponseBlock;
                 let channelDeliveryCheckpoint = 0;
+                let requestRouteKey = "";
                 try {
-                  if (goalTurn) goalTurn.modelStarted = true;
+                  if (goalTurn) {
+                    goalTurn.modelStarted = true;
+                    if (goalTurn.origin === "runtime") {
+                      this.#markGoalTurnDelivered(goalTurn.turnKey);
+                    }
+                  }
                   const sendResult = await this.#sendMessageStreamWithAutoCompression(
                     promptId,
                     nextMessage?.parts ?? [],
@@ -6652,6 +6908,7 @@ ${this.pendingRecoveredAgentsNotice}
                   if (restorePostAnswerNoticesAttached) {
                     this.#clearPendingRestoreNotices();
                   }
+                  requestRouteKey = sendResult.requestRouteKey;
                   const responseStream = sendResult.responseStream;
                   nextMessage = null;
                   channelDeliveryResponseBlock = beginChannelDeliveryResponseBlock(responseCapture);
@@ -6714,6 +6971,12 @@ ${this.pendingRecoveredAgentsNotice}
                         );
                         functionCalls.length = 0;
                       }
+                      if (resp.type === "compressed" /* COMPRESSED */) {
+                        this.#recordCompressionTokenCount(
+                          resp.info,
+                          requestRouteKey
+                        );
+                      }
                     }
                   } catch (error) {
                     streamFailed = true;
@@ -6767,7 +7030,7 @@ ${this.pendingRecoveredAgentsNotice}
                   functionCalls.length > 0
                 );
                 if (usageMetadata) {
-                  this.#recordPromptTokenCount(usageMetadata);
+                  this.#recordPromptTokenCount(usageMetadata, requestRouteKey);
                   if (this.messageRewriter) {
                     this.messageRewriter.flushTurn(pendingSend.signal);
                   }
@@ -6897,7 +7160,7 @@ ${this.pendingRecoveredAgentsNotice}
       }
     ).finally(() => {
       if (managedMemoryRecallStarted) {
-        this.config.getGeminiClient().finishManagedAutoMemoryRecall();
+        this.config.getLlmClient().finishManagedAutoMemoryRecall();
       }
     });
   }
@@ -7217,6 +7480,7 @@ ${this.pendingRecoveredAgentsNotice}
       let channelDeliveryCheckpoint = 0;
       let providerSendChat;
       let userContentPushCountBeforeSend = 0;
+      let requestRouteKey = "";
       try {
         const sendResult = await this.#sendMessageStreamWithAutoCompression(
           promptIdForSend,
@@ -7442,6 +7706,7 @@ ${this.pendingRecoveredAgentsNotice}
             ...supersededAutomaticContinuation ? { supersededAutomaticContinuation: true } : {}
           };
         }
+        requestRouteKey = sendResult.requestRouteKey;
         const responseStream = sendResult.responseStream;
         nextMessage = null;
         channelDeliveryResponseBlock = beginChannelDeliveryResponseBlock(
@@ -7518,6 +7783,9 @@ ${this.pendingRecoveredAgentsNotice}
             );
             functionCalls.length = 0;
           }
+          if (response.type === "compressed" /* COMPRESSED */) {
+            this.#recordCompressionTokenCount(response.info, requestRouteKey);
+          }
         }
       } catch (error) {
         streamFailed = true;
@@ -7573,7 +7841,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,
@@ -7792,7 +8060,7 @@ ${this.pendingRecoveredAgentsNotice}
     }
   }
   #getCurrentChat() {
-    return this.config.getGeminiClient().getChat();
+    return this.config.getLlmClient().getChat();
   }
   async #runWithFullTurnModel(modelOverride, fn) {
     if (!modelOverride?.endsWith("\0")) {
@@ -7804,9 +8072,9 @@ ${this.pendingRecoveredAgentsNotice}
   /**
    * Create the MessageDisplay hook dispatcher for one model call's streamed
    * reply, or null when the hook isn't registered (the common case — keeps
-   * the streaming loops zero-cost). The ACP surface consumes GeminiChat's
+   * the streaming loops zero-cost). The ACP surface consumes LlmChat's
    * raw stream directly rather than going through
-   * GeminiClient.sendMessageStream, so it has to fire this hook itself —
+   * LlmClient.sendMessageStream, so it has to fire this hook itself —
    * with the same contract as the terminal UI path in client.ts: debounced
    * cumulative text, one message_id per model call, and an is_final firing
    * on every non-aborted exit (delivered by awaiting `finish()` in a
@@ -7832,7 +8100,7 @@ ${this.pendingRecoveredAgentsNotice}
    * was cancelled or the session token limit was exceeded.
    */
   async #sendMessageStreamWithAutoCompression(promptId, message, abortSignal, options = {}) {
-    const geminiClient = this.config.getGeminiClient();
+    const llmClient = this.config.getLlmClient();
     if (options.prepareBeforeCompression) {
       const decision = await options.prepareBeforeCompression();
       if (decision.kind === "stop") {
@@ -7851,13 +8119,12 @@ ${this.pendingRecoveredAgentsNotice}
     let compressionFailed = false;
     if (!options.skipCompression && !(options.getModelOverride?.() ?? options.modelOverride)) {
       try {
-        const compressed = await geminiClient.tryCompressChat(
+        const compressed = await llmClient.tryCompressChat(
           promptId,
           false,
           abortSignal
         );
         compressionInfo = compressed;
-        this.#recordCompressionTokenCount(compressed);
         compressionFailed = isCompressionFailureStatus(
           compressed.compressionStatus
         );
@@ -7887,15 +8154,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.`,
@@ -7930,7 +8210,7 @@ ${this.pendingRecoveredAgentsNotice}
       return { responseStream: null, stopReason: "cancelled" };
     }
     if (message[0]?.functionResponse) {
-      const memory = await geminiClient.consumeManagedAutoMemoryRecall("tool_result");
+      const memory = await llmClient.consumeManagedAutoMemoryRecall("tool_result");
       if (memory?.prompt) {
         message = insertAfterFunctionResponses(message, [
           { text: memory.prompt }
@@ -7938,7 +8218,6 @@ ${this.pendingRecoveredAgentsNotice}
       }
     }
     const chat = this.#getCurrentChat();
-    const model = options.getModelOverride?.() ?? options.modelOverride ?? this.config.getModel();
     const request = {
       message,
       config: {
@@ -7947,7 +8226,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;
@@ -8105,25 +8384,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) {
@@ -8139,12 +8451,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";
@@ -8390,6 +8740,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",
@@ -8401,6 +8755,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,
@@ -8549,11 +8974,13 @@ ${this.pendingRecoveredAgentsNotice}
    * `_meta.source='cron'`, streams the model response, and handles tool calls.
    */
   async #executeCronPrompt(item) {
-    return runWithInvocationContext(
-      void 0,
-      () => sessionIdContext.run(
-        this.config.getSessionId(),
-        () => this.#executeCronPromptInner(item)
+    return goalTurnContext.exit(
+      () => runWithInvocationContext(
+        void 0,
+        () => sessionIdContext.run(
+          this.config.getSessionId(),
+          () => this.#executeCronPromptInner(item)
+        )
       )
     );
   }
@@ -8686,6 +9113,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) {
@@ -8751,6 +9179,12 @@ ${this.pendingRecoveredAgentsNotice}
                       );
                       functionCalls.length = 0;
                     }
+                    if (resp.type === "compressed" /* COMPRESSED */) {
+                      this.#recordCompressionTokenCount(
+                        resp.info,
+                        requestRouteKey
+                      );
+                    }
                   }
                 } catch (error) {
                   streamFailed = true;
@@ -8772,7 +9206,7 @@ ${this.pendingRecoveredAgentsNotice}
                   functionCalls.length > 0
                 );
                 if (usageMetadata) {
-                  this.#recordPromptTokenCount(usageMetadata);
+                  this.#recordPromptTokenCount(usageMetadata, requestRouteKey);
                   if (this.messageRewriter) {
                     this.messageRewriter.flushTurn(ac.signal);
                   }
@@ -8955,6 +9389,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,
@@ -9015,8 +9473,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 {
@@ -9024,8 +9482,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();
         }
       }
@@ -9114,18 +9572,22 @@ ${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 {
-          await runWithInvocationContext(
-            void 0,
-            () => sessionIdContext.run(
-              this.config.getSessionId(),
-              () => this.#executeBackgroundNotificationPromptInner(item)
+          await goalTurnContext.exit(
+            () => runWithInvocationContext(
+              void 0,
+              () => sessionIdContext.run(
+                this.config.getSessionId(),
+                () => this.#executeBackgroundNotificationPromptInner(item)
+              )
             )
           );
         } finally {
           this.currentAgentNotificationTaskId = null;
+          this.currentWorkflowNotificationTaskId = null;
           this.currentShellNotificationActive = false;
           this.#activeWorkChanged();
         }
@@ -9222,6 +9684,7 @@ ${this.pendingRecoveredAgentsNotice}
               return;
             }
             const responseStream = sendResult.responseStream;
+            const requestRouteKey = sendResult.requestRouteKey;
             nextMessage = null;
             const messageDisplay = this.#createMessageDisplayDispatcher(
               ac.signal
@@ -9268,6 +9731,9 @@ ${this.pendingRecoveredAgentsNotice}
                   );
                   functionCalls.length = 0;
                 }
+                if (resp.type === "compressed" /* COMPRESSED */) {
+                  this.#recordCompressionTokenCount(resp.info, requestRouteKey);
+                }
               }
             } catch (error) {
               streamFailed = true;
@@ -9294,7 +9760,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,
@@ -9778,11 +10244,16 @@ ${this.pendingRecoveredAgentsNotice}
         if (record.skipPersistence === true || this.#shouldSkipRestoredAskUserQuestionPersistence(record.callId)) {
           return;
         }
-        this.config.getChatRecordingService()?.recordToolResult(finalized[index].responseParts, {
-          ...record.metadata,
-          persistedOutputFiles: finalized[index].persistedOutputFiles,
-          artifacts: finalized[index].artifacts
-        });
+        const goalProvenance = ambientGoalToolResultProvenance(record.toolName);
+        this.config.getChatRecordingService()?.recordToolResult(
+          finalized[index].responseParts,
+          {
+            ...record.metadata,
+            persistedOutputFiles: finalized[index].persistedOutputFiles,
+            artifacts: finalized[index].artifacts
+          },
+          ...goalProvenance ? [goalProvenance] : []
+        );
       });
       return {
         ...result,
@@ -10266,9 +10737,14 @@ ${this.pendingRecoveredAgentsNotice}
   /**
    * Assemble the per-turn system reminders the model needs to see at the
    * start of a user query or cron fire. Mirrors the subagent/plan/arena
-   * branches in `GeminiClient.sendMessageStream` (`client.ts:848-878`) —
+   * branches in `LlmClient.sendMessageStream` (`client.ts:848-878`) —
    * the ACP path bypasses that code, so without this helper plan mode is
    * silently inert and subagent/arena sessions lose context.
+   *
+   * Scope note: the `relevantAutoMemory` reminder is intentionally NOT
+   * included here. Managed auto-memory requires a prefetch pipeline that
+   * lives in `LlmClient`, and porting it into the ACP path is tracked
+   * separately as part of the broader middleware-alignment work.
    */
   async #buildInitialSystemReminders() {
     const reminders = [];
@@ -10286,6 +10762,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) {
@@ -10729,7 +11213,7 @@ ${this.pendingRecoveredAgentsNotice}
           if (!autoModeAllowed && !requiresUserInteraction && shouldRunAutoModeForCall(approvalMode, policyToolName)) {
             const denialState = this.config.getAutoModeDenialState();
             const fallback = shouldFallback(denialState);
-            const messages = this.config.getGeminiClient?.()?.getHistoryTail(MAX_TRANSCRIPT_MESSAGES, false) ?? [];
+            const messages = this.config.getLlmClient?.()?.getHistoryTail(MAX_TRANSCRIPT_MESSAGES, false) ?? [];
             const decision = await evaluateAutoMode({
               ctx: pmCtx,
               pmForcedAsk,
@@ -11812,7 +12296,7 @@ ${this.pendingRecoveredAgentsNotice}
       });
     } finally {
       if (terminalStatus && terminalStatus !== "cancelled") {
-        this.config.getGeminiClient().recordCompletedToolCall(toolName, args);
+        this.config.getLlmClient().recordCompletedToolCall(toolName, args);
       }
       if (terminalStatus === "cancelled") {
         endToolSpan(toolSpan, { success: false, cancelled: true });
@@ -13076,11 +13560,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(
@@ -13247,8 +13741,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(() => {
     });
@@ -13497,11 +14012,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,
@@ -13543,12 +14138,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 {
@@ -14867,7 +15467,7 @@ function readScopeSettings(settings, scope) {
 }
 __name(readScopeSettings, "readScopeSettings");
 async function resolvePreferredMemoryFile(dir, fallbackFilename) {
-  for (const filename of getAllGeminiMdFilenames()) {
+  for (const filename of getAllMemoryFilenames()) {
     const filePath = path6.join(dir, filename);
     try {
       await fs3.access(filePath);
@@ -14879,7 +15479,7 @@ async function resolvePreferredMemoryFile(dir, fallbackFilename) {
 }
 __name(resolvePreferredMemoryFile, "resolvePreferredMemoryFile");
 async function resolveQwenMemoryPaths(params) {
-  const fallbackFilename = getAllGeminiMdFilenames()[0] ?? "QWEN.md";
+  const fallbackFilename = getAllMemoryFilenames()[0] ?? "QWEN.md";
   const userMemoryFile = await resolvePreferredMemoryFile(
     Storage.getGlobalQwenDir(),
     fallbackFilename
@@ -15103,7 +15703,7 @@ async function runAcpAgent(config, settings, argv, options) {
   beginAcpBootstrapConfigProfiling();
   try {
     await config.initialize({
-      skipGeminiInitialization: true,
+      skipLlmInitialization: true,
       // Bootstrap skips MCP discovery — each session runs its own
       // pool-routed discovery, so bootstrap-level spawns would be
       // redundant subprocess leaks (W119).
@@ -15495,6 +16095,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();
@@ -15569,7 +16174,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;
@@ -15584,12 +16189,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;
@@ -15629,13 +16234,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();
@@ -15835,19 +16448,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 = [];
-      try {
-        await this.config.getExtensionManager().refreshCache();
+      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);
       }
@@ -15859,10 +16478,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);
@@ -15884,9 +16503,9 @@ var QwenAgent = class {
         const registry = config.getToolRegistry();
         if (operation === "discover") {
           await registry?.discoverToolsForServer(serverName);
-          const geminiClient = config.getGeminiClient?.();
-          if (geminiClient?.isInitialized?.()) {
-            await geminiClient.setTools?.();
+          const llmClient = config.getLlmClient?.();
+          if (llmClient?.isInitialized?.()) {
+            await llmClient.setTools?.();
           }
         } else if (operation === "disable") {
           await registry?.disableMcpServer(serverName);
@@ -15931,56 +16550,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({
-        skipGeminiInitialization: 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) {
@@ -16072,9 +16698,9 @@ var QwenAgent = class {
           }
           await Promise.all(
             this.getLiveMcpConfigs(serverName).map(async (config) => {
-              const geminiClient = config.getGeminiClient?.();
-              if (geminiClient?.isInitialized?.()) {
-                await geminiClient.setTools?.();
+              const llmClient = config.getLlmClient?.();
+              if (llmClient?.isInitialized?.()) {
+                await llmClient.setTools?.();
               }
             })
           );
@@ -16144,6 +16770,18 @@ var QwenAgent = class {
       cleanupErrors.push(error);
     }
     this.sessions.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(
@@ -16483,7 +17121,7 @@ var QwenAgent = class {
     }
     this.clientCapabilities = args.clientCapabilities;
     const authMethods = buildAuthMethods();
-    const version = "0.22.2";
+    const version = "0.22.3-nightly.20260831.3a0c4c6108";
     const response = {
       protocolVersion: PROTOCOL_VERSION,
       agentInfo: {
@@ -16604,6 +17242,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(
@@ -16618,7 +17291,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
@@ -16640,6 +17318,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(
@@ -16649,16 +17329,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)
               );
+              initializationDeadline?.signal.throwIfAborted();
               profiler.timeSync(
                 "file_system_setup",
                 () => this.setupFileSystem(config)
@@ -16667,7 +17352,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) {
@@ -16688,6 +17375,7 @@ var QwenAgent = class {
         parentContext ? { parentContext } : {}
       );
     } finally {
+      initializationDeadline?.dispose();
       releaseStartingSessionId?.();
     }
   }
@@ -16841,6 +17529,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(
@@ -16901,6 +17590,7 @@ var QwenAgent = class {
           "session_register",
           () => this.createAndStoreSession(config, settings, void 0, {
             deferWorkspaceActivation: provisionalStandalone,
+            configProviderRevision,
             ...provisionalStandalone ? {
               beforeDeferredWorkspaceActivation: /* @__PURE__ */ __name(() => profiler.time(
                 "restore_session_model",
@@ -16999,9 +17689,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;
@@ -17169,6 +17859,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(
@@ -17207,6 +17898,7 @@ var QwenAgent = class {
           "session_register",
           () => this.createAndStoreSession(config, settings, void 0, {
             deferWorkspaceActivation: provisionalStandalone,
+            configProviderRevision,
             ...provisionalStandalone ? {
               beforeDeferredWorkspaceActivation: /* @__PURE__ */ __name(() => profiler.time(
                 "restore_session_model",
@@ -17224,14 +17916,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;
@@ -17381,15 +18073,17 @@ 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 ? REASONING_EFFORT_NONE : modelReasoning.toggleOnly ? value === REASONING_EFFORT_DEFAULT ? REASONING_EFFORT_DEFAULT : void 0 : effortValues?.find((effort2) => effort2 === value);
+            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 = [
-                REASONING_EFFORT_NONE,
+                ...thinkingMandatory ? [] : [REASONING_EFFORT_NONE],
                 ...effortValues ?? [REASONING_EFFORT_DEFAULT]
               ];
               throw RequestError.invalidParams(
@@ -17397,7 +18091,17 @@ var QwenAgent = class {
                 `Unknown reasoning effort: ${value}. Choose one of: ${choices.join(", ")}`
               );
             }
-            const generation = session.getConfig().getContentGeneratorConfig();
+            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) {
@@ -18274,25 +18978,25 @@ 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)
           })
         ])
       );
       for (const extension of config.getExtensions()) {
         if (extension.isActive) continue;
         for (const skill of extension.skills ?? []) {
-          const extensionName = extension.displayName ?? extension.name;
+          const extensionName = extension.name;
           const key = `extension:${extensionName}:${skill.name}`;
-          if (skillsByKey.has(`extension:${extension.name}:${skill.name}`) || skillsByKey.has(key)) {
-            continue;
-          }
+          if (skillsByKey.has(key)) continue;
           skillsByKey.set(
             key,
             mapSkillConfigToStatus(
               {
                 ...skill,
                 level: "extension",
-                extensionName
+                extensionName,
+                extensionDisplayName: extension.displayName
               },
               disablements,
               { disabled: true }
@@ -18351,7 +19055,13 @@ 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);
+        const configOptions = model.isRuntimeModel || modelId.startsWith(ACP_ROUTE_ID_PREFIX) ? void 0 : buildModelReasoningConfigPreview(model.id, {
+          thinkingMandatory: config.getResolvedModelConfig?.(
+            model.authType,
+            model.id,
+            model.registryBaseUrl ?? model.baseUrl
+          )?.generationConfig.thinkingMandatory === true
+        });
         const providerModel = {
           modelId,
           baseModelId: parseAcpBaseModelId(effectiveModelId),
@@ -18806,17 +19516,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);
@@ -19172,9 +19899,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)
         );
       }
@@ -19192,7 +19919,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"];
@@ -19464,7 +20190,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"];
@@ -19707,6 +20437,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,
@@ -19725,6 +20459,7 @@ var QwenAgent = class {
             projectRoot,
             content: content.trim(),
             contextMode,
+            ...rawScope ? { scope: rawScope } : {},
             abortSignal: childSignal
           });
           if (result.filesTouched.length > 0) {
@@ -19795,6 +20530,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,
@@ -19811,7 +20550,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),
@@ -20049,9 +20789,9 @@ var QwenAgent = class {
           });
           await Promise.all(
             this.getLiveMcpConfigs(serverName).map(async (liveConfig) => {
-              const geminiClient = liveConfig.getGeminiClient?.();
-              if (geminiClient?.isInitialized?.()) {
-                await geminiClient.setTools?.();
+              const llmClient = liveConfig.getLlmClient?.();
+              if (llmClient?.isInitialized?.()) {
+                await llmClient.setTools?.();
               }
             })
           );
@@ -20901,10 +21641,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);
             }
@@ -20932,10 +21675,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);
             }
@@ -20958,7 +21704,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);
             }
@@ -21065,7 +21814,7 @@ var QwenAgent = class {
             );
           }
           try {
-            await config.getGeminiClient()?.addWorkingDirectoryChangedContext(
+            await config.getLlmClient()?.addWorkingDirectoryChangedContext(
               settledPreviousCwd,
               canonicalPath
             );
@@ -21243,7 +21992,7 @@ var QwenAgent = class {
                   );
                 }
                 await cfg.refreshHierarchicalMemory();
-                await cfg.getGeminiClient()?.refreshSystemInstruction();
+                await cfg.getLlmClient()?.refreshSystemInstruction();
               })
             );
             const failedCount = results.filter(
@@ -21409,7 +22158,7 @@ var QwenAgent = class {
         }
         let hasHistory = false;
         try {
-          hasHistory = (config.getGeminiClient().getHistoryShallow() ?? []).length > 0;
+          hasHistory = (config.getLlmClient().getHistoryShallow() ?? []).length > 0;
         } catch (error) {
           debugLogger9.debug("Failed to read history before /fork:", error);
         }
@@ -21442,7 +22191,7 @@ var QwenAgent = class {
           );
         }
         try {
-          config.getGeminiClient().addHistory({
+          config.getLlmClient().addHistory({
             role: "user",
             parts: [
               {
@@ -21474,9 +22223,9 @@ var QwenAgent = class {
         }
         const session = this.sessionOrThrow(sessionId);
         const config = session.getConfig();
-        const geminiClient = config.getGeminiClient();
+        const llmClient = config.getLlmClient();
         const outputText = typeof params["output"] === "string" ? params["output"] : "";
-        geminiClient.addHistory({
+        llmClient.addHistory({
           role: "user",
           parts: [
             {
@@ -21510,10 +22259,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(
@@ -21571,12 +22320,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) {
@@ -21846,6 +22752,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,
@@ -21863,16 +22777,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()
@@ -21882,10 +22805,13 @@ ${outputText}
           );
         }
         await runRefresh(
-          async () => await config.getGeminiClient()?.refreshSystemInstruction()
+          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(
@@ -22527,6 +23453,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 */);
@@ -22535,6 +23507,10 @@ ${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 sessions = [...this.sessions.entries()];
         const refreshed = [];
         const skipped = [];
@@ -22546,7 +23522,6 @@ ${outputText}
             }
             const config = session.getConfig();
             const authType = config.getAuthType();
-            const providersChanged = changed.has("modelProviders") || changed.has("providerProtocol");
             if (providersChanged) {
               try {
                 config.reloadModelProvidersConfig(
@@ -22582,6 +23557,19 @@ ${outputText}
                 newMerged.tools?.disabled
               );
               config.setDisabledTools(new Set(disabled));
+              const workflowsWereEnabled = config.isWorkflowsEnabled();
+              config.setWorkflowsEnabled(
+                newMerged.tools?.workflowsEnabled === true
+              );
+              if (config.isWorkflowsEnabled() !== workflowsWereEnabled) {
+                try {
+                  await session.sendAvailableCommandsUpdate();
+                } catch (err) {
+                  debugLogger9.warn(
+                    `reload: sendAvailableCommandsUpdate failed for session ${id}: ${err}`
+                  );
+                }
+              }
               const newMode = newMerged.tools?.approvalMode;
               if (newMode && APPROVAL_MODES.includes(newMode) && newMode !== config.getApprovalMode()) {
                 try {
@@ -22605,7 +23593,7 @@ ${outputText}
               );
             }
             try {
-              await config.getGeminiClient()?.refreshSystemInstruction();
+              await config.getLlmClient()?.refreshSystemInstruction();
             } catch (err) {
               debugLogger9.warn(
                 `reload: refreshSystemInstruction failed for session ${id}: ${err}`
@@ -22805,25 +23793,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, {
@@ -22840,7 +23837,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
     );
@@ -22902,7 +23899,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 } : {},
@@ -22955,7 +23956,8 @@ ${outputText}
             ), "projectionSource")
           }
         } : {}
-      } : void 0
+      } : void 0,
+      buildEnabledSkillNamesProvider(settings)
     );
     if (sessionSource) {
       config.setSessionSource(sessionSource.sourceType, sessionSource.sourceId);
@@ -22992,16 +23994,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)}`
+            );
+          });
         });
       });
     }
@@ -23080,14 +24084,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 geminiClient = config.getGeminiClient();
-    const needsInitialize = !geminiClient.isInitialized();
+    const llmClient = config.getLlmClient();
+    const needsInitialize = !llmClient.isInitialized();
     if (needsInitialize && options.deferWorkspaceActivation !== true) {
-      await geminiClient.initialize();
+      await llmClient.initialize(void 0, options.signal);
     }
+    options.signal?.throwIfAborted();
     this.assertManagedSessionAdmission();
     if (this.sessions.has(sessionId)) {
       throw new RequestError(
@@ -23097,6 +24169,7 @@ ${outputText}
       );
     }
     await options.prepareBeforeSessionCreate?.();
+    options.signal?.throwIfAborted();
     this.assertManagedSessionAdmission();
     if (this.sessions.has(sessionId)) {
       throw new RequestError(
@@ -23105,14 +24178,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) {
@@ -23136,6 +24211,17 @@ ${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 {
@@ -23163,6 +24249,50 @@ ${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);
+          }
+        }
+        if (providerReloadRevision === this.modelProviderReloadRevision) break;
+        forceAuthenticationRefresh = true;
+      }
+      options.beforeSessionPublish?.();
       options.primeSession?.(session);
       if (options.deferWorkspaceActivation !== true) {
         config.hydrateSessionRestoreFileHistory?.();
@@ -23299,11 +24429,29 @@ ${outputText}
       currentValue: currentModelId,
       options: configModelOptions
     };
-    const modelReasoning = this.getModelReasoningConfiguration(config);
+    const generation = config.getContentGeneratorConfig();
+    const modelReasoning = this.getModelReasoningConfiguration(
+      config,
+      currentModelId
+    );
     const currentModelEffort = config.getReasoningEffort?.();
+    const reasoningOverride = config.getReasoningEffortOverride?.();
+    const reasoningOverrideValue = reasoningOverride ? generation[reasoningOverride.source]?.[reasoningOverride.field] : void 0;
+    const normalizedEffortOverride = reasoningOverride?.field === "reasoning_effort" && typeof reasoningOverrideValue === "string" ? reasoningOverrideValue === "minimal" ? "low" : REASONING_EFFORT_TIERS.find(
+      (effort) => effort === reasoningOverrideValue
+    ) : void 0;
+    const normalizedBudgetOverride = reasoningOverride?.field === "thinking_budget" && typeof reasoningOverrideValue === "number" && Number.isFinite(reasoningOverrideValue) && reasoningOverrideValue >= 0 && reasoningOverrideValue <= 262144 ? reasoningOverrideValue <= 4096 ? "low" : reasoningOverrideValue <= 16384 ? "medium" : "xhigh" : void 0;
+    const normalizedOverrideEffort = normalizedEffortOverride ?? normalizedBudgetOverride;
+    const overrideDisablesReasoning = reasoningOverride?.field === "enable_thinking" && reasoningOverrideValue === false || reasoningOverride?.field === "reasoning_effort" && reasoningOverrideValue === REASONING_EFFORT_NONE;
+    const mandatoryUsesDefaultEffort = generation.thinkingMandatory === true && (overrideDisablesReasoning || generation.reasoning === false && reasoningOverride?.field === "reasoning_effort");
+    const effectiveModelEffort = modelReasoning && !modelReasoning.toggleOnly ? mandatoryUsesDefaultEffort ? modelReasoning.defaultEffort : normalizedOverrideEffort ? modelReasoning.efforts.find(
+      (effort) => effort === normalizedOverrideEffort
+    ) ?? modelReasoning.defaultEffort : currentModelEffort : currentModelEffort;
+    const reasoningEnabled = generation.reasoning !== false && (!reasoningOverride || !overrideDisablesReasoning);
     const reasoningEffortConfigOption = (modelReasoning ? buildModelReasoningConfigOption(rawCurrentModelId, {
-      enabled: config.getContentGeneratorConfig().reasoning !== false,
-      effort: currentModelEffort
+      enabled: reasoningEnabled,
+      effort: effectiveModelEffort,
+      thinkingMandatory: generation.thinkingMandatory === true
     }) : void 0) ?? {
       id: "reasoning_effort",
       name: "Reasoning effort",
@@ -23326,13 +24474,21 @@ ${outputText}
     };
     return [modeConfigOption, modelConfigOption, reasoningEffortConfigOption];
   }
-  getModelReasoningConfiguration(config) {
-    if (config.getActiveRuntimeModelSnapshot?.() || config.getReasoningEffortOverride?.() || config.getContentGeneratorConfig().thinkingMandatory === true) {
+  getModelReasoningConfiguration(config, currentAcpModelId) {
+    if (config.getActiveRuntimeModelSnapshot?.()) {
+      return void 0;
+    }
+    const completeModelId = currentAcpModelId ?? getCurrentAcpModelId(
+      this.buildSelectableModelOptions(config),
+      (config.getModel() || "").trim(),
+      config.getAuthType?.(),
+      config.getCurrentModelRegistryBaseUrl?.()
+    );
+    if (completeModelId.startsWith(ACP_ROUTE_ID_PREFIX)) {
       return void 0;
     }
     const reasoning = getModelConfiguration(config.getModel())?.reasoning;
-    const currentEffort = config.getReasoningEffort?.();
-    return reasoning?.thinking && (reasoning.toggleOnly || !currentEffort || reasoning.efforts.includes(currentEffort)) ? reasoning : void 0;
+    return reasoning?.thinking ? reasoning : void 0;
   }
   buildSelectableModelOptions(config) {
     const currentAuthType = config.getAuthType();