@qwen-code/qwen-code 0.22.1 → 0.22.2-nightly.20260828.7357136dd1

package/chunks/{acpAgent-GY53MJIW.js → acpAgent-EYZ6EEHD.js}

@@ -1,5 +1,8 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  recomputeMcpGating
+} from "./chunk-3OOXT6CR.js";
 import {
   classifyApiError,
   fireSessionDeleteHook
@@ -14,7 +17,7 @@ import {
   normalizePartList,
   parseExtensionRef,
   parseMcpServerRef
-} from "./chunk-EEQYTWGU.js";
+} from "./chunk-M4ORUPYI.js";
 import {
   getAvailableCommands,
   getSlashCommandFirstToken,
@@ -23,14 +26,7 @@ import {
   isSlashCommand,
   recordDaemonSessionModel,
   restoreSessionModelThenAuthenticate
-} from "./chunk-2YEZNBSD.js";
-import {
-  collectContextData,
-  formatContextUsageText
-} from "./chunk-KCOXDRQL.js";
-import {
-  recomputeMcpGating
-} from "./chunk-43C2II2G.js";
+} from "./chunk-FMFBLTLY.js";
 import {
   SessionIdConflictError,
   appEvents,
@@ -38,41 +34,45 @@ import {
   cleanupReviewWorktreeLeases,
   loadCliConfig,
   normalizeDisabledToolList
-} from "./chunk-ZXDM7DYV.js";
+} from "./chunk-TQHGJYR3.js";
+import "./chunk-NYX53SV4.js";
+import {
+  collectContextData,
+  formatContextUsageText
+} from "./chunk-UY3PBNY3.js";
 import {
   getCommandSubcommandNames
-} from "./chunk-6E4WHQJV.js";
+} from "./chunk-ZTP35P4B.js";
 import {
   getEffectiveSupportedModes
-} from "./chunk-OT26ITEY.js";
-import "./chunk-2FN2HNTI.js";
+} from "./chunk-RVXDXY6I.js";
+import "./chunk-CFJY4DGX.js";
 import "./chunk-4WGODMVR.js";
 import "./chunk-3SH53ANB.js";
-import "./chunk-NYX53SV4.js";
 import {
   isGoalStatusKind
 } from "./chunk-EKTCKZV5.js";
-import "./chunk-TKO4TLT6.js";
-import "./chunk-WEGXPP5E.js";
+import "./chunk-SUX7HDNA.js";
+import "./chunk-YAF2MQZ6.js";
+import "./chunk-QFCDF5PL.js";
 import {
   startNonInteractiveOpenAILogHousekeeping
-} from "./chunk-2NCVUT3C.js";
+} from "./chunk-TLHUNMO7.js";
 import "./chunk-KW7NOTN6.js";
+import "./chunk-LVPZO674.js";
+import "./chunk-6H67XLET.js";
 import {
   beginAcpBootstrapConfigProfiling,
   buildAndFreezeAcpStartupProfile,
   endAcpBootstrapConfigProfiling,
   markAcpStartup
 } from "./chunk-5JTIYALA.js";
-import "./chunk-5CI4AXDD.js";
-import "./chunk-C4WBKZJT.js";
-import "./chunk-NVK4HJYQ.js";
-import "./chunk-YAF2MQZ6.js";
+import "./chunk-LNETQKBE.js";
+import "./chunk-JN4IWWMN.js";
+import "./chunk-YRZX2PHA.js";
 import {
   computeCpuPercent
 } from "./chunk-LBOVL47Y.js";
-import "./chunk-62PXFOK4.js";
-import "./chunk-6H67XLET.js";
 import {
   GENERATION_MAX_PROMPT_BYTES,
   GENERATION_TIMEOUT_MS,
@@ -85,9 +85,7 @@ import {
   createWorkspaceMemoryExtractionErrorLogger,
   executeGeneration,
   formatWorkspaceMemoryForgetSummary,
-  isCompatibleLiveSessionSource,
   isValidServerName,
-  normalizeChannelDeliveryText,
   projectAcpToolResultUpdate,
   redactMcpServerSecrets,
   replayTranscriptRecordPage,
@@ -95,7 +93,7 @@ import {
   shouldSuppressRememberErrorDetails,
   workspaceMemoryFailureCode,
   workspaceMemoryFailureDiagnostics
-} from "./chunk-KWFP3WV6.js";
+} from "./chunk-YWQ237GX.js";
 import {
   BaseEmitter,
   HistoryReplayer,
@@ -106,48 +104,57 @@ import {
   hasFullSessionContext,
   observeAcpToolResultProjection,
   observeAcpToolResultWire
-} from "./chunk-HJOWQUE2.js";
-import "./chunk-4TPAG3O7.js";
+} from "./chunk-AU3MMVJF.js";
+import "./chunk-BFPESSTR.js";
 import "./chunk-E7REAOTN.js";
-import "./chunk-L436XFLJ.js";
+import "./chunk-7VD6IPQM.js";
 import "./chunk-2MIN6GRR.js";
 import "./chunk-QHTIBUWB.js";
 import "./chunk-TXASDT2M.js";
 import {
-  buildToolWriteOriginMeta
-} from "./chunk-VGHZT6JR.js";
+  isCompatibleLiveSessionSource
+} from "./chunk-36LGBEM6.js";
+import {
+  DAEMON_OWNED_STANDALONE_CREATION_KEY,
+  SESSION_SOURCE_META_KEY,
+  isReservedStandaloneSessionSourceType,
+  parseSessionSource
+} from "./chunk-2TNL5KPM.js";
+import {
+  buildToolWriteOriginMeta,
+  getConversationDirectoryName,
+  isSameConversationPath
+} from "./chunk-U54AYGEC.js";
+import "./chunk-RXFQM6FQ.js";
+import "./chunk-UXEO7E3V.js";
+import {
+  normalizeChannelDeliveryText
+} from "./chunk-4CMJKUND.js";
 import {
   normalizeSessionIdForLookup,
   parseCallerSuppliedSessionId
 } from "./chunk-ZEZKIS2K.js";
-import "./chunk-RXFQM6FQ.js";
-import "./chunk-UXEO7E3V.js";
 import {
   PERMISSION_RULE_TYPES,
   PermissionRulesValidationError,
   buildPermissionSettings,
   normalizePermissionRules,
   readPermissionRuleSet
-} from "./chunk-I32QCIK7.js";
+} from "./chunk-AXC26UCQ.js";
 import {
   MAX_AUDIO_BYTES,
   sanitizeVoiceErrorMessage,
   transcribeVoiceAudio
-} from "./chunk-76WGY6LW.js";
+} from "./chunk-SVNO44PF.js";
 import {
   readVoiceModel
-} from "./chunk-2MHGD7EE.js";
-import "./chunk-2SERYG4T.js";
-import "./chunk-JS73NNWF.js";
-import "./chunk-4DCP3362.js";
-import "./chunk-DCSAVGDJ.js";
-import {
-  SESSION_SOURCE_META_KEY,
-  parseSessionSource
-} from "./chunk-I6YW3T3W.js";
+} from "./chunk-HYDJDQGJ.js";
+import "./chunk-YTDVNSUQ.js";
+import "./chunk-7GWQW5ID.js";
+import "./chunk-HOCJDUFY.js";
+import "./chunk-EW5VVLJT.js";
 import "./chunk-7U5G6JXI.js";
 import "./chunk-WCCLLK7X.js";
-import "./chunk-OCPBI7J5.js";
 import {
   REASONING_EFFORT_DEFAULT,
   REASONING_EFFORT_NAMES,
@@ -155,7 +162,7 @@ import {
   buildModelReasoningConfigOption,
   buildModelReasoningConfigPreview,
   getModelConfiguration
-} from "./chunk-4K7NQDCG.js";
+} from "./chunk-T4EFG2P5.js";
 import {
   ACP_ROUTE_ID_PREFIX,
   buildAcpModelOptions,
@@ -164,26 +171,26 @@ import {
   parseAcpModelOption,
   resolveAcpModelOption,
   sanitizeProviderBaseUrl
-} from "./chunk-GNRVKN76.js";
+} from "./chunk-EKNBU2X7.js";
 import {
   mapSkillConfigToStatus
-} from "./chunk-BGXZBI5B.js";
+} from "./chunk-N4X7G4J2.js";
 import {
   resolveSkillSettings
 } from "./chunk-Z4X5MTRT.js";
-import "./chunk-SM7ZVKTF.js";
-import "./chunk-A7X32SCT.js";
+import "./chunk-MTJN7FOT.js";
+import "./chunk-6ZZBRRKQ.js";
 import "./chunk-57OAHC2Y.js";
-import "./chunk-EAV3TENS.js";
-import "./chunk-7JPW6IYH.js";
-import "./chunk-IKN3IUJP.js";
+import "./chunk-QPTRRPZU.js";
+import "./chunk-Y4TPOUEV.js";
+import "./chunk-HVC3PNVC.js";
 import "./chunk-V6WHFGST.js";
 import {
   createLoadedSettingsAdapter
-} from "./chunk-7AS7QX72.js";
+} from "./chunk-AY3BNYEQ.js";
 import {
   ndJsonStream
-} from "./chunk-GZJUCMH4.js";
+} from "./chunk-H72BQNM3.js";
 import {
   ACP_PREFLIGHT_KINDS,
   IDLE_HOOK_EVENTS,
@@ -191,8 +198,8 @@ import {
   SERVE_STATUS_EXT_METHODS,
   STATUS_SCHEMA_VERSION,
   mapDomainErrorToErrorKind
-} from "./chunk-CITGRGCM.js";
-import "./chunk-MZS7GEC7.js";
+} from "./chunk-7TUBJBBJ.js";
+import "./chunk-FTF2YIZ5.js";
 import {
   ACTIVE_WORK_CLOSE_IF_UNHELD_PARAM,
   ACTIVE_WORK_HEARTBEAT_META_KEY,
@@ -232,15 +239,15 @@ import {
 import {
   NOT_CURRENTLY_GENERATING_CANCEL_MESSAGE,
   isNotCurrentlyGeneratingCancelError
-} from "./chunk-624NHDGB.js";
+} from "./chunk-ERFDKH32.js";
 import "./chunk-6PLDPT2C.js";
 import "./chunk-FYJ7W2PI.js";
-import "./chunk-7CWEZQ6T.js";
-import "./chunk-JVPFTDBK.js";
+import "./chunk-STUJ7IMZ.js";
 import "./chunk-GYTKQYDB.js";
+import "./chunk-RFIDDFAL.js";
 import "./chunk-ALMR3E6Q.js";
+import "./chunk-RKFGE7JH.js";
 import "./chunk-UDG5EZJI.js";
-import "./chunk-M5GB774H.js";
 import {
   EXTERNAL_TOOL_GUARD_READY_META_KEY,
   EXTERNAL_TOOL_GUARD_REQUIRED_VALUE,
@@ -250,11 +257,12 @@ import {
   SHELL_EXECUTING_TOOL_NAMES,
   isValidExternalToolGuardDenialReason
 } from "./chunk-3VUENPWF.js";
-import "./chunk-ELY4QVIB.js";
+import "./chunk-M5GB774H.js";
+import "./chunk-7EQQR46F.js";
 import {
   ACP_EVENT_LOOP_STALL_RESTART_MS,
   CHANNEL_PROMPT_META_KEY
-} from "./chunk-E55H6BZ7.js";
+} from "./chunk-ICURCKIU.js";
 import {
   AgentSideConnection,
   PROTOCOL_VERSION,
@@ -263,7 +271,7 @@ import {
 import {
   assembleMcpServers,
   loadMcpApprovals
-} from "./chunk-MW5AHWOZ.js";
+} from "./chunk-PWIGAMA4.js";
 import {
   getOutputLanguageFilePath,
   getPersistScopeForModelSelection,
@@ -272,9 +280,9 @@ import {
   resolveOutputLanguageOrPreserveAuto,
   updateOutputLanguageFile,
   writeOutputLanguageAndRegisterPath
-} from "./chunk-MDZO5V2O.js";
+} from "./chunk-HPXV655A.js";
 import "./chunk-RKUWKYED.js";
-import "./chunk-BDHLBR46.js";
+import "./chunk-IB7FQJRY.js";
 import "./chunk-GOXKNSDZ.js";
 import {
   getSystemDefaultsPath,
@@ -283,7 +291,7 @@ import {
 import {
   getCurrentLanguage,
   setLanguageAsync
-} from "./chunk-W2WRNJKX.js";
+} from "./chunk-RWZB422L.js";
 import {
   SUPPORTED_LANGUAGES
 } from "./chunk-5EJZE3FP.js";
@@ -291,19 +299,19 @@ import {
   findEnvFiles,
   preResolveHomeEnvOverrides,
   reloadEnvironment
-} from "./chunk-2CRNTW2B.js";
+} from "./chunk-DP4MWIM3.js";
 import {
   ENV_ACP_REPEATED_TOOL_FAILURE_GUARD,
   QWEN_CODE_SERVE_ENV
 } from "./chunk-5PA6UEYA.js";
-import "./chunk-7DPKPBOQ.js";
-import "./chunk-6KS24S3X.js";
+import "./chunk-V2NDP3I4.js";
+import "./chunk-GGNE3JAW.js";
 import "./chunk-W3N5XAZ6.js";
 import {
   isFolderTrustEnabled,
   isWorkspaceTrusted,
   loadTrustedFolders
-} from "./chunk-XNXWEGKB.js";
+} from "./chunk-CYAUBK46.js";
 import "./chunk-NPQ5ZKRP.js";
 import "./chunk-MR3PXB6E.js";
 import {
@@ -333,30 +341,30 @@ import {
   resolveBaseUrl,
   runManagedRememberByAgent,
   subagentGenerator
-} from "./chunk-VMDURMFY.js";
-import "./chunk-J7MLXFC5.js";
+} from "./chunk-W6DUQ5GA.js";
+import "./chunk-CRKKHXTI.js";
 import "./chunk-XFSFZCM5.js";
 import "./chunk-2EAZ43JQ.js";
 import "./chunk-NF5J2WFA.js";
 import {
   CreateSubSessionTool
-} from "./chunk-LRKMQPMD.js";
+} from "./chunk-CQH5KTKC.js";
 import "./chunk-LJZSMWOH.js";
-import "./chunk-47SIHHPL.js";
-import "./chunk-JLGFGPZJ.js";
-import "./chunk-SKNVVYIJ.js";
+import "./chunk-V2QDDC5J.js";
+import "./chunk-OI4NY7RA.js";
+import "./chunk-K5KXUXWC.js";
 import {
   restoreWorktreeContext
-} from "./chunk-UCSV2IZW.js";
-import "./chunk-T2HMXHYA.js";
-import "./chunk-3FSBMAYD.js";
-import "./chunk-XJS54K4A.js";
+} from "./chunk-62GQFYID.js";
+import "./chunk-C3KURPP7.js";
+import "./chunk-XQFT3QUF.js";
+import "./chunk-VTHREBQM.js";
 import "./chunk-ZPJWUGCS.js";
 import {
   clearCachedCredentialFile,
   qwenOAuth2Events
-} from "./chunk-ZWKGZB2K.js";
-import "./chunk-OX44MOAN.js";
+} from "./chunk-3JXM2CVW.js";
+import "./chunk-TW3E6YNO.js";
 import {
   APPROVAL_MODE_INFO,
   BranchPointInvalidError,
@@ -374,7 +382,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,
@@ -391,6 +398,7 @@ import {
   TURN_RESULT_TEXT_MAX_CHARS,
   abortGoalForStopHookCap,
   acquireSleepInhibitor,
+  ambientGoalToolResultProvenance,
   applyAutoModeDecision,
   approxBase64Bytes,
   bridgeToolResultImages,
@@ -448,8 +456,6 @@ import {
   mcpServerRequiresOAuth,
   needsConfirmation,
   normalizeDerivedBranchTitle,
-  normalizeEventPayload,
-  normalizeSnapshotPayload,
   normalizeTurnResultError,
   observeToolResultBoundary,
   persistPermissionOutcome,
@@ -473,43 +479,55 @@ import {
   updateSetting,
   validatePlanModeShellApproval,
   validatePlanModeShellContext
-} from "./chunk-XYX474JQ.js";
+} from "./chunk-EWIQ3NAE.js";
 import "./chunk-GOFAQQZA.js";
 import "./chunk-5M6IDOMF.js";
 import "./chunk-TWPJO254.js";
 import {
   external_exports
 } from "./chunk-CQ35AJ4Z.js";
-import "./chunk-3UZCLCXR.js";
-import "./chunk-TOF4UZHH.js";
-import "./chunk-O3BUXIPM.js";
-import "./chunk-ZLTEQYNC.js";
+import "./chunk-EKSCLBBF.js";
+import "./chunk-LUEHOUHM.js";
+import "./chunk-WXEA74YB.js";
+import "./chunk-42IDLQWS.js";
 import {
   parsePositiveIntegerEnv
 } from "./chunk-6PVPNMXU.js";
 import {
   RUNTIME_SNAPSHOT_PREFIX
-} from "./chunk-AYVIGUUK.js";
+} from "./chunk-JB4JIVTJ.js";
+import {
+  SESSION_ARTIFACT_PERSISTENCE_VERSION,
+  normalizeEventPayload,
+  normalizeSnapshotPayload
+} from "./chunk-DJBQCO2E.js";
 import "./chunk-IRH27ZC2.js";
 import "./chunk-QHWCP53L.js";
-import "./chunk-JECO75XD.js";
+import "./chunk-D5LUXLUH.js";
 import {
   promptIdContext,
   todoWorkChainContext
 } from "./chunk-O6GEWCJA.js";
 import "./chunk-T26EAKDL.js";
-import "./chunk-LJP2BBMK.js";
+import "./chunk-2SXSLSQE.js";
 import "./chunk-CPBF7KYF.js";
-import "./chunk-5Y2JCJAH.js";
+import {
+  AgentOutputMessageCapture,
+  addAgentInputMessageAttributes,
+  addToolArgumentsAttributes,
+  addToolCallResultAttributes,
+  registerAcpEventLoopLagGauge,
+  startEventLoopLagMonitor
+} from "./chunk-6W2IK5KC.js";
 import {
   HookEventName,
   createHookOutput
-} from "./chunk-T2CRBIDJ.js";
-import "./chunk-77TOMRBG.js";
-import "./chunk-DEYPMJPD.js";
-import "./chunk-T6OODF2U.js";
-import "./chunk-27ONXAFY.js";
-import "./chunk-ZEADBZLO.js";
+} from "./chunk-TTX2JUE6.js";
+import "./chunk-4K7KNVWH.js";
+import "./chunk-SMPR7SPO.js";
+import "./chunk-JWALNCLT.js";
+import "./chunk-NIFYWDYN.js";
+import "./chunk-C2X7KY45.js";
 import {
   GoalConflictError,
   GoalInvalidTransitionError,
@@ -518,50 +536,41 @@ import {
   goalTurnContext,
   parseGoalControlRequest,
   parseGoalSnapshotV2,
-  parseGoalStateCause,
+  parseGoalStateCause
+} from "./chunk-XLLQJRAH.js";
+import {
   wrapUserPromptSubmitContext
-} from "./chunk-FN5C6C7G.js";
+} from "./chunk-7J6OTNGO.js";
 import {
   APPROVAL_MODES
-} from "./chunk-BVE5EMIG.js";
+} from "./chunk-V5J4J5TP.js";
 import "./chunk-MLXTMF7H.js";
 import "./chunk-NAVJD2PQ.js";
-import "./chunk-FVDQ5E67.js";
-import "./chunk-V3GINY6K.js";
+import "./chunk-B466ZSHZ.js";
+import "./chunk-4QHPPXK2.js";
 import "./chunk-QHMLYMMS.js";
-import {
-  AgentOutputMessageCapture,
-  addAgentInputMessageAttributes,
-  addToolArgumentsAttributes,
-  addToolCallResultAttributes,
-  registerAcpEventLoopLagGauge,
-  startEventLoopLagMonitor
-} from "./chunk-SDVF6A42.js";
-import "./chunk-P3QQPMQA.js";
 import {
   addDaemonRequestAttribute,
   extractDaemonTraceContext,
   withDaemonSpan
-} from "./chunk-ILPXSKGQ.js";
+} from "./chunk-3WK3QDNV.js";
 import "./chunk-VNOVK4I7.js";
-import "./chunk-SAH4BD2J.js";
-import "./chunk-ZKAZP2ZG.js";
+import "./chunk-PQEISIKS.js";
+import "./chunk-EB6QRGHM.js";
 import {
   runWithRuntimeContentGenerator
-} from "./chunk-DP7LABIB.js";
+} from "./chunk-CMHFCLBU.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-I6VVOZDK.js";
-import "./chunk-K2OJUPOE.js";
-import {
-  getToolCallPreparations
-} from "./chunk-CFKIH3D3.js";
-import "./chunk-EB4VDXNI.js";
-import "./chunk-FJWICLG7.js";
+import "./chunk-DYXFD5RO.js";
+import "./chunk-Y3QL45LS.js";
 import {
   ConversationFinishedEvent,
   DiscoveredMCPTool,
@@ -592,35 +601,35 @@ import {
   shouldRunVisionBridge,
   splitImageParts,
   uiTelemetryService
-} from "./chunk-UX3IFLJM.js";
-import "./chunk-YRLW2MSX.js";
+} from "./chunk-SZLBBZH4.js";
+import "./chunk-XBVNNDPK.js";
 import "./chunk-VGC4I5JJ.js";
 import {
-  getAllGeminiMdFilenames,
+  getAllMemoryFilenames,
   getSpecificMimeType
-} from "./chunk-WBT3STGU.js";
+} from "./chunk-BKWNKLZB.js";
 import {
   getAutoMemoryRoot,
   getUserAutoMemoryRoot
-} from "./chunk-PVBT5QPD.js";
+} from "./chunk-6PJOTWAN.js";
 import {
   runSideQuery
-} from "./chunk-IPQA4SR5.js";
+} from "./chunk-BWORX6FA.js";
 import "./chunk-WZAD4ZNJ.js";
 import {
   DEFAULT_TOKEN_LIMIT,
   tokenLimit
 } from "./chunk-FPGTNKCP.js";
-import "./chunk-SLEWBQWM.js";
+import "./chunk-6DIGWMGT.js";
 import {
   hasVertexProjectConfigured,
   preloadContentGenerator
-} from "./chunk-ICWGPK23.js";
+} from "./chunk-3K6TUZHS.js";
 import "./chunk-XZA32HII.js";
-import "./chunk-7QGEJI7M.js";
+import "./chunk-23RFD54N.js";
 import {
   AuthType
-} from "./chunk-GTUKW3I6.js";
+} from "./chunk-PPKZ7JOE.js";
 import "./chunk-HHJLM3WQ.js";
 import {
   endToolExecutionSpan,
@@ -632,17 +641,17 @@ import {
   startToolExecutionSpan,
   startToolSpan,
   withInteractionSpan
-} from "./chunk-6US7BF3G.js";
+} from "./chunk-B5PHIJGI.js";
 import "./chunk-74TONY4F.js";
-import "./chunk-VL4YX3FH.js";
+import "./chunk-XF63PKEN.js";
 import {
   FORK_SUBAGENT_TYPE,
   getStartupContextLength,
   isSystemReminderContent
-} from "./chunk-JUIJ3FXC.js";
-import "./chunk-E6FGMDFQ.js";
+} from "./chunk-CAJTKR6W.js";
+import "./chunk-ZU4UDIWX.js";
 import "./chunk-AQ37AY7B.js";
-import "./chunk-RRKNX553.js";
+import "./chunk-PDQGMSZK.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
@@ -650,7 +659,7 @@ import {
   ToolNames,
   canonicalToolName,
   isShellProgressData
-} from "./chunk-KOJ6MHD5.js";
+} from "./chunk-UTLCH2FK.js";
 import {
   Storage,
   createDebugLogger,
@@ -658,11 +667,11 @@ import {
   getErrorStatus,
   isSubpath,
   sessionIdContext
-} from "./chunk-2NNTE2ED.js";
-import "./chunk-NER3H7PI.js";
+} from "./chunk-UHQFIS7N.js";
+import "./chunk-X3ZRTCJD.js";
 import {
   runExitCleanup
-} from "./chunk-EKP3M4RF.js";
+} from "./chunk-SJ5ERAW3.js";
 import {
   writeStderrLine,
   writeStderrLineSafe
@@ -1044,9 +1053,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;
@@ -1952,6 +1958,19 @@ var basicPermissionOptions = [
     kind: "reject_once"
   }
 ];
+function filterPermissionPersistenceOptions(options, policy) {
+  if (!policy) return options;
+  return options.filter((option) => {
+    if (option.optionId === "proceed_always_project" /* ProceedAlwaysProject */ && !policy.allowProjectPersistence) {
+      return false;
+    }
+    if (option.optionId === "proceed_always_user" /* ProceedAlwaysUser */ && !policy.allowUserPersistence) {
+      return false;
+    }
+    return true;
+  });
+}
+__name(filterPermissionPersistenceOptions, "filterPermissionPersistenceOptions");
 function supportsHideAlwaysAllow(confirmation) {
   return confirmation.type !== "ask_user_question";
 }
@@ -2087,7 +2106,7 @@ function resolvePermissionOutcome(response, offeredOptions) {
   return optionId;
 }
 __name(resolvePermissionOutcome, "resolvePermissionOutcome");
-function toPermissionOptions(confirmation, forceHideAlwaysAllow = false) {
+function toPermissionOptions(confirmation, forceHideAlwaysAllow = false, persistencePolicy) {
   switch (confirmation.type) {
     case "edit":
       return filterAlwaysAllowOptions(
@@ -2106,56 +2125,65 @@ function toPermissionOptions(confirmation, forceHideAlwaysAllow = false) {
       const label = formatExecPermissionScopeLabel(confirmation);
       return filterAlwaysAllowOptions(
         confirmation,
-        [
-          {
-            optionId: "proceed_always_project" /* ProceedAlwaysProject */,
-            name: `Always Allow in project: ${label}`,
-            kind: "allow_always"
-          },
-          {
-            optionId: "proceed_always_user" /* ProceedAlwaysUser */,
-            name: `Always Allow for user: ${label}`,
-            kind: "allow_always"
-          },
-          ...basicPermissionOptions
-        ],
+        filterPermissionPersistenceOptions(
+          [
+            {
+              optionId: "proceed_always_project" /* ProceedAlwaysProject */,
+              name: `Always Allow in project: ${label}`,
+              kind: "allow_always"
+            },
+            {
+              optionId: "proceed_always_user" /* ProceedAlwaysUser */,
+              name: `Always Allow for user: ${label}`,
+              kind: "allow_always"
+            },
+            ...basicPermissionOptions
+          ],
+          persistencePolicy
+        ),
         forceHideAlwaysAllow
       );
     }
     case "mcp":
       return filterAlwaysAllowOptions(
         confirmation,
-        [
-          {
-            optionId: "proceed_always_project" /* ProceedAlwaysProject */,
-            name: `Always Allow in project: ${confirmation.toolName}`,
-            kind: "allow_always"
-          },
-          {
-            optionId: "proceed_always_user" /* ProceedAlwaysUser */,
-            name: `Always Allow for user: ${confirmation.toolName}`,
-            kind: "allow_always"
-          },
-          ...basicPermissionOptions
-        ],
+        filterPermissionPersistenceOptions(
+          [
+            {
+              optionId: "proceed_always_project" /* ProceedAlwaysProject */,
+              name: `Always Allow in project: ${confirmation.toolName}`,
+              kind: "allow_always"
+            },
+            {
+              optionId: "proceed_always_user" /* ProceedAlwaysUser */,
+              name: `Always Allow for user: ${confirmation.toolName}`,
+              kind: "allow_always"
+            },
+            ...basicPermissionOptions
+          ],
+          persistencePolicy
+        ),
         forceHideAlwaysAllow
       );
     case "info":
       return filterAlwaysAllowOptions(
         confirmation,
-        [
-          {
-            optionId: "proceed_always_project" /* ProceedAlwaysProject */,
-            name: "Always Allow in project",
-            kind: "allow_always"
-          },
-          {
-            optionId: "proceed_always_user" /* ProceedAlwaysUser */,
-            name: "Always Allow for user",
-            kind: "allow_always"
-          },
-          ...basicPermissionOptions
-        ],
+        filterPermissionPersistenceOptions(
+          [
+            {
+              optionId: "proceed_always_project" /* ProceedAlwaysProject */,
+              name: "Always Allow in project",
+              kind: "allow_always"
+            },
+            {
+              optionId: "proceed_always_user" /* ProceedAlwaysUser */,
+              name: "Always Allow for user",
+              kind: "allow_always"
+            },
+            ...basicPermissionOptions
+          ],
+          persistencePolicy
+        ),
         forceHideAlwaysAllow
       );
     case "plan":
@@ -2205,11 +2233,12 @@ __name(toPermissionOptions, "toPermissionOptions");
 // packages/cli/src/acp-integration/session/SubAgentTracker.ts
 var debugLogger3 = createDebugLogger("ACP_SUBAGENT_TRACKER");
 var SubAgentTracker = class {
-  constructor(ctx, client, parentToolCallId, subagentType, onPermissionCancel, permissionRequester = (params, signal) => requestPermissionWithAbort(this.client, params, signal)) {
+  constructor(ctx, client, parentToolCallId, subagentType, onPermissionCancel, permissionRequester = (params, signal) => requestPermissionWithAbort(this.client, params, signal), permissionPersistencePolicy) {
     this.ctx = ctx;
     this.client = client;
     this.onPermissionCancel = onPermissionCancel;
     this.permissionRequester = permissionRequester;
+    this.permissionPersistencePolicy = permissionPersistencePolicy;
     this.toolCallEmitter = new ToolCallEmitter(ctx);
     this.messageEmitter = new MessageEmitter(ctx);
     this.subagentMeta = { parentToolCallId, subagentType };
@@ -2325,7 +2354,11 @@ var SubAgentTracker = class {
         }, "onConfirm")
       };
       const { title, locations, kind } = this.toolCallEmitter.resolveToolMetadata(event.name, state?.args);
-      const permissionOptions = toPermissionOptions(fullConfirmationDetails);
+      const permissionOptions = toPermissionOptions(
+        fullConfirmationDetails,
+        false,
+        this.permissionPersistencePolicy
+      );
       const offeredPermissionOptions = permissionOptions.map((option) => ({
         ...option
       }));
@@ -3248,6 +3281,18 @@ var LOOP_DETECTED_CONTEXT_MESSAGE = "System: this turn was terminated because th
 var LOOP_DETECTED_TURN_ERROR_MESSAGE = "Tool-call loop protection stopped this turn. The session is still available; send a more specific instruction to continue.";
 var TOOL_EXECUTION_CANCELLED_MESSAGE = "Tool execution was cancelled.";
 var TOOL_POST_EXECUTION_CANCELLED_MESSAGE = "The tool had already completed; its output was discarded.";
+function sameManagedConversationExpectation(left, right) {
+  return left.canonicalSessionId === right.canonicalSessionId && left.root.canonicalPath === right.root.canonicalPath && left.root.device === right.root.device && left.root.inode === right.root.inode && left.child.name === right.child.name && left.child.canonicalPath === right.child.canonicalPath && left.child.device === right.child.device && left.child.inode === right.child.inode;
+}
+__name(sameManagedConversationExpectation, "sameManagedConversationExpectation");
+function managedConversationBindingError() {
+  return new RequestError(
+    -32004,
+    "The standalone working directory is missing.",
+    { errorKind: "working_directory_missing" }
+  );
+}
+__name(managedConversationBindingError, "managedConversationBindingError");
 function createDaemonToolLoopState(repeatedToolFailureMode) {
   return {
     totalToolCalls: 0,
@@ -3814,22 +3859,55 @@ async function registerCreateSubSessionTool(config) {
     return;
   }
   const permissionManager = config.getPermissionManager();
-  if (permissionManager && !await permissionManager.isToolEnabled(ToolNames.CREATE_SUB_SESSION)) {
+  const registrationStatus = permissionManager ? await permissionManager.getToolRegistrationStatus(
+    ToolNames.CREATE_SUB_SESSION
+  ) : "registered";
+  if (registrationStatus === "disabled") {
     return;
   }
   const toolRegistry = config.getToolRegistry();
+  if (registrationStatus === "deferred") {
+    toolRegistry.registerPermissionDeferredFactory(
+      ToolNames.CREATE_SUB_SESSION,
+      async () => new CreateSubSessionTool(config)
+    );
+    await config.getGeminiClient().setTools();
+    return;
+  }
   toolRegistry.registerTool(new CreateSubSessionTool(config));
   toolRegistry.revealDeferredTool(ToolNames.CREATE_SUB_SESSION);
   toolRegistry.pinDeferredToolReveal(ToolNames.CREATE_SUB_SESSION);
   await config.getGeminiClient().setTools();
 }
 __name(registerCreateSubSessionTool, "registerCreateSubSessionTool");
-async function buildAvailableCommandsSnapshot(config, abortSignal = AbortSignal.timeout(1e4), settings) {
+var STANDALONE_SLASH_COMMAND_POLICY = Object.freeze({
+  allowSessionReset: false,
+  allowWorkspaceSettingsWrite: false,
+  persistModelSelection: false,
+  blockedBuiltinCommandNames: Object.freeze([
+    "cd",
+    "clear",
+    "directory",
+    "diff",
+    "dream",
+    "export",
+    "learn",
+    "curator",
+    "workflows"
+  ])
+});
+var STANDALONE_PERMISSION_PERSISTENCE_POLICY = Object.freeze({
+  allowProjectPersistence: false,
+  allowUserPersistence: true
+});
+var STANDALONE_WORKTREE_ACTION_ERROR = "Standalone sessions cannot change or override their working directory.";
+async function buildAvailableCommandsSnapshot(config, abortSignal = AbortSignal.timeout(1e4), settings, executionPolicy) {
   const slashCommands = await getAvailableCommands(
     config,
     abortSignal,
     "acp",
-    settings
+    settings,
+    executionPolicy
   );
   const disabledSkillNames = config.getDisabledSkillNames();
   const inactiveSkillRefs = inactiveExtensionSkillRefs(config);
@@ -3923,6 +4001,11 @@ var Session = class {
     this.runExclusiveAutomaticHistoryMutation = runExclusiveAutomaticHistoryMutation;
     this.onActiveWorkChanged = onActiveWorkChanged;
     this.sessionId = id;
+    this.requiresManagedConversationBinding = isReservedStandaloneSessionSourceType(
+      this.config.getSessionSourceType?.()
+    );
+    this.requiresManagedConversationActivation = this.requiresManagedConversationBinding && this.config.isProvisionalWorkspace?.() === true;
+    this.slashCommandPolicy = this.requiresManagedConversationBinding ? STANDALONE_SLASH_COMMAND_POLICY : void 0;
     this.runtimeBaseDir = config.storage.getRuntimeBaseDir();
     const todoStopGuardEnabled = this.settings.merged.experimental?.todoStopGuard === true && !this.config.getBareMode() && !this.config.isSafeMode();
     this.todoStopGuard = new DaemonTodoStopGuard(todoStopGuardEnabled);
@@ -3942,6 +4025,7 @@ var Session = class {
     this.#bindGoalRuntime();
     this.#registerBackgroundNotificationCallbacks();
     this.#registerSubSessionSpawner();
+    this.#registerCurrentSessionScheduledTaskCreator();
     this.config.getWorkflowRunRegistry?.().setApprovalRequestCallback(
       (entry, approval, rawArgs, signal) => this.#requestWorkflowApproval(entry.runId, approval, rawArgs, signal)
     );
@@ -4066,6 +4150,11 @@ var Session = class {
   liveSpeakToUserTool;
   liveConversationActive;
   liveEndInstructionPending = false;
+  requiresManagedConversationBinding;
+  requiresManagedConversationActivation;
+  slashCommandPolicy;
+  managedConversationBinding;
+  managedConversationActivation;
   // Message rewrite middleware (optional, installed after history replay)
   messageRewriter;
   /**
@@ -4122,6 +4211,8 @@ 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
           });
@@ -4278,13 +4369,14 @@ var Session = class {
     return publication;
   }
   async #drainGoalQueue() {
+    if (this.#isAutomaticWorkHeld()) return;
     if (this.goalQueue.length === 0) return;
     await this.runExclusiveAutomaticHistoryMutation(
       () => this.#drainGoalQueueExclusive()
     );
   }
   async #drainGoalQueueExclusive() {
-    if (this.disposed || this.closing || this.goalProcessing || this.pendingPrompt || this.pendingPromptCompletion || this.cronProcessing || this.cronAbortController || this.notificationProcessing || this.notificationAbortController) {
+    if (this.disposed || this.closing || this.goalProcessing || this.pendingPrompt || this.pendingPromptCompletion || this.cronProcessing || this.cronAbortController || this.notificationProcessing || this.notificationAbortController || this.#isAutomaticWorkHeld()) {
       return;
     }
     const turn = this.goalQueue.shift();
@@ -4322,6 +4414,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();
@@ -4826,6 +4936,48 @@ var Session = class {
       };
     });
   }
+  #registerCurrentSessionScheduledTaskCreator() {
+    if (process.env[QWEN_CODE_SERVE_ENV] !== "1") {
+      return;
+    }
+    this.config.setCurrentSessionScheduledTaskCreator(async (req) => {
+      let resp;
+      try {
+        resp = await this.client.extMethod(
+          SERVE_CONTROL_EXT_METHODS.createCurrentSessionScheduledTask,
+          {
+            callerSessionId: this.sessionId,
+            promptId: getInvocationContext()?.promptId ?? req.promptId,
+            cron: req.cron,
+            prompt: req.prompt,
+            recurring: req.recurring
+          }
+        );
+      } catch (error) {
+        const code = error && typeof error === "object" && "code" in error ? error.code : void 0;
+        if (code === -32601) {
+          throw new Error(
+            "current_session_scheduling_unavailable: The daemon does not support current-session scheduling."
+          );
+        }
+        const data = isRecord2(error) && isRecord2(error["data"]) ? error["data"] : void 0;
+        const errorKind = data?.["errorKind"];
+        if (typeof errorKind === "string") {
+          const hint = data?.["hint"];
+          throw new Error(
+            `${errorKind}: ${typeof hint === "string" && hint.length > 0 ? hint : "Current-session scheduled task creation was rejected."}`
+          );
+        }
+        throw error;
+      }
+      if (typeof resp["id"] !== "string" || resp["id"].length === 0 || typeof resp["cron"] !== "string" || resp["cron"].length === 0) {
+        throw new Error(
+          "cron_create: bridge returned an invalid scheduled-task result"
+        );
+      }
+      return { id: resp["id"], cron: resp["cron"] };
+    });
+  }
   async enableLiveScreenContext() {
     const registry = this.config.getToolRegistry();
     const existing = registry.getTool(CAPTURE_SCREEN_CONTEXT_TOOL_NAME);
@@ -4984,6 +5136,7 @@ var Session = class {
    * mount.
    */
   startCronScheduler() {
+    if (this.#isAutomaticWorkHeld()) return;
     this.#startCronSchedulerInRuntime().catch((error) => {
       debugLogger6.warn(
         `Cron scheduler startup failed [session ${this.sessionId}]: ${error}`
@@ -4993,6 +5146,113 @@ var Session = class {
   getConfig() {
     return this.config;
   }
+  installPendingManagedConversationBinding(expectation, assertIdentity) {
+    if (!this.requiresManagedConversationBinding || expectation.canonicalSessionId !== this.sessionId) {
+      throw managedConversationBindingError();
+    }
+    if (this.managedConversationBinding && this.managedConversationBinding.state !== "released" && !sameManagedConversationExpectation(
+      this.managedConversationBinding.expectation,
+      expectation
+    )) {
+      throw managedConversationBindingError();
+    }
+    this.managedConversationBinding = {
+      expectation,
+      assertIdentity,
+      state: "pending"
+    };
+  }
+  installManagedConversationActivation(run, onRelease) {
+    if (!this.requiresManagedConversationActivation || this.managedConversationActivation) {
+      throw managedConversationBindingError();
+    }
+    this.managedConversationActivation = {
+      run,
+      ...onRelease ? { onRelease } : {},
+      releaseScheduled: false,
+      state: "pending"
+    };
+  }
+  async activateManagedConversation() {
+    if (!this.requiresManagedConversationActivation) return;
+    const activation = this.managedConversationActivation;
+    if (!activation) throw managedConversationBindingError();
+    if (activation.state === "ready") return;
+    if (activation.state === "poisoned") throw activation.error;
+    if (activation.promise) return activation.promise;
+    activation.state = "activating";
+    const promise = activation.run().then(() => {
+      activation.state = "ready";
+    }).catch((error) => {
+      activation.state = "poisoned";
+      activation.error = error;
+      throw error;
+    });
+    activation.promise = promise;
+    return promise;
+  }
+  async commitManagedConversationBinding(expectation) {
+    const binding = this.managedConversationBinding;
+    if (!this.requiresManagedConversationBinding || !binding || !sameManagedConversationExpectation(binding.expectation, expectation)) {
+      throw managedConversationBindingError();
+    }
+    if (binding.state === "committed" || binding.state === "released") return;
+    if (!isSameConversationPath(
+      this.config.getTargetDir(),
+      binding.expectation.child.canonicalPath
+    )) {
+      throw managedConversationBindingError();
+    }
+    await binding.assertIdentity();
+    await this.activateManagedConversation();
+    await binding.assertIdentity();
+    binding.state = "committed";
+  }
+  async releaseManagedConversationBinding(expectation) {
+    const binding = this.managedConversationBinding;
+    if (!this.requiresManagedConversationBinding || !binding || binding.state === "pending" || !sameManagedConversationExpectation(binding.expectation, expectation)) {
+      throw managedConversationBindingError();
+    }
+    if (binding.state === "released") return;
+    if (!isSameConversationPath(
+      this.config.getTargetDir(),
+      binding.expectation.child.canonicalPath
+    )) {
+      throw managedConversationBindingError();
+    }
+    await binding.assertIdentity();
+    binding.state = "released";
+    const activation = this.managedConversationActivation;
+    if (activation && !activation.releaseScheduled) {
+      activation.releaseScheduled = true;
+      try {
+        activation.onRelease?.();
+      } catch (error) {
+        debugLogger6.warn(
+          `Managed conversation release callback failed [session ${this.sessionId}]: ${error}`
+        );
+      }
+    }
+    this.startCronScheduler();
+    void this.sendAvailableCommandsUpdate();
+    void this.#drainGoalQueue();
+    void this.#drainCronQueue();
+    void this.#drainNotificationQueue();
+  }
+  async assertManagedConversationBindingReady() {
+    if (!this.requiresManagedConversationBinding) return;
+    const binding = this.managedConversationBinding;
+    if (binding?.state !== "released" || !isSameConversationPath(
+      this.config.getTargetDir(),
+      binding.expectation.child.canonicalPath
+    )) {
+      throw managedConversationBindingError();
+    }
+    await binding.assertIdentity();
+  }
+  #isAutomaticWorkHeld() {
+    return this.requiresManagedConversationBinding && this.managedConversationBinding?.state !== "released";
+  }
   shouldHintAskUserQuestionRestore() {
     if (this.config.getRestoreAskUserQuestion?.() !== true) return false;
     if (this.pendingPrompt && !this.pendingPrompt.signal.aborted) return false;
@@ -5010,6 +5270,9 @@ var Session = class {
         "Session history mutation is in progress"
       );
     }
+    if (this.requiresManagedConversationBinding) {
+      await this.assertManagedConversationBindingReady();
+    }
     try {
       await this.config.assertCanStartTurn();
     } catch (error) {
@@ -5020,6 +5283,9 @@ var Session = class {
       }
       throw error;
     }
+    if (this.requiresManagedConversationBinding) {
+      await this.assertManagedConversationBindingReady();
+    }
     if (this.closing) {
       throw RequestError.invalidParams(void 0, "Session is closing");
     }
@@ -5081,6 +5347,9 @@ var Session = class {
     }
     return holds;
   }
+  hasStandaloneRelocationBlockers() {
+    return this.collectActiveWorkHolds().length > 0 || this.config.getMonitorRegistry().getAll().some((monitor) => monitor.status === "running");
+  }
   #activeWorkChanged() {
     this.onActiveWorkChanged?.();
   }
@@ -5236,6 +5505,7 @@ var Session = class {
     this.unsubscribeChatRecordingFailure?.();
     this.unsubscribeChatRecordingFailure = void 0;
     this.config.setSubSessionSpawner(void 0);
+    this.config.setCurrentSessionScheduledTaskCreator(void 0);
     this.config.getWorkflowRunRegistry?.().setApprovalRequestCallback(void 0);
     this.workflowApprovalAbortController.abort(SESSION_DISPOSE_ABORT_REASON);
   }
@@ -5926,6 +6196,7 @@ var Session = class {
     return goalTurn ? goalTurnContext.run(goalTurn.permit, execute) : goalTurnContext.exit(execute);
   }
   async #executePromptInner(params, pendingSend, responseCapture, modelPrompt, rejectOnLoopDetected = false, goalTurn, channelTurn = false) {
+    let managedMemoryRecallStarted = false;
     return Storage.runWithRuntimeBaseDir(
       this.runtimeBaseDir,
       this.config.getWorkingDir(),
@@ -6071,7 +6342,8 @@ var Session = class {
                   // long-lived Session; without this the goal-state
                   // subscription stays on the disposed instance.
                   startNewSession: /* @__PURE__ */ __name(() => this.rebindGoalRuntimeForNewSession(), "startNewSession")
-                }
+                },
+                this.slashCommandPolicy
               );
               if (slashCommandName === "advisor" && pendingSend.signal.aborted && slashCommandResult.type === "message") {
                 this.todoStopGuard.suspend();
@@ -6137,6 +6409,7 @@ var Session = class {
             const hooksEnabled = !this.config.getDisableAllHooks?.();
             const messageBus = this.config.getMessageBus?.();
             const isRuntimeContinuation = goalTurn?.origin === "runtime";
+            const isFreshUserTurn = !isRetry && !isContinue && !isRestoreAskUserQuestion && !isRuntimeContinuation;
             if (!isContinue && !isRestoreAskUserQuestion && !isRuntimeContinuation && hooksEnabled && messageBus && this.config.hasHooksForEvent?.("UserPromptSubmit")) {
               const response = await messageBus.request(
                 {
@@ -6165,6 +6438,10 @@ var Session = class {
                 ];
               }
             }
+            if (isFreshUserTurn) {
+              managedMemoryRecallStarted = true;
+              this.config.getGeminiClient().beginManagedAutoMemoryRecall(promptText, pendingSend.signal);
+            }
             if (!continuesCurrentWorkChain && !this.todoStopGuard.enabled) {
               this.#resetTodoStopGuardBackgroundLineage();
             }
@@ -6190,6 +6467,12 @@ var Session = class {
               }
             }
             const systemReminders = await this.#buildInitialSystemReminders();
+            if (isFreshUserTurn) {
+              const memory = await this.config.getGeminiClient().consumeManagedAutoMemoryRecall("initial");
+              if (memory?.prompt) {
+                systemReminders.unshift({ text: memory.prompt });
+              }
+            }
             if (systemReminders.length > 0 && !isRestoreAskUserQuestion) {
               const alreadyHasReminder = isContinue && parts.some(
                 (part) => isSystemReminderContent({ role: "user", parts: [part] })
@@ -6366,7 +6649,12 @@ ${this.pendingRecoveredAgentsNotice}
                 let channelDeliveryResponseBlock;
                 let channelDeliveryCheckpoint = 0;
                 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 ?? [],
@@ -6587,7 +6875,32 @@ ${this.pendingRecoveredAgentsNotice}
                   getActiveInteractionSpan()
                 );
               }
-              return result;
+              if (isFreshUserTurn && result.stopReason === "end_turn" && !result.loopProtectionStopped && this.config.getManagedAutoMemoryEnabled()) {
+                const memoryManager = this.config.getMemoryManager();
+                const history = this.#getCurrentChat().getHistoryShallow();
+                void memoryManager.scheduleExtract({
+                  projectRoot: this.config.getProjectRoot(),
+                  sessionId: this.config.getSessionId(),
+                  history,
+                  config: this.config
+                }).catch((error) => {
+                  debugLogger6.warn(
+                    "Failed to schedule ACP managed auto-memory extraction.",
+                    error
+                  );
+                });
+                void memoryManager.scheduleDream({
+                  projectRoot: this.config.getProjectRoot(),
+                  sessionId: this.config.getSessionId(),
+                  config: this.config
+                }).catch((error) => {
+                  debugLogger6.warn(
+                    "Failed to schedule ACP managed auto-memory dream.",
+                    error
+                  );
+                });
+              }
+              return { stopReason: result.stopReason };
             } finally {
               logConversationFinishedEvent(
                 this.config,
@@ -6606,7 +6919,11 @@ ${this.pendingRecoveredAgentsNotice}
           (result) => result.stopReason === "cancelled" ? "cancelled" : "ok"
         );
       }
-    );
+    ).finally(() => {
+      if (managedMemoryRecallStarted) {
+        this.config.getGeminiClient().finishManagedAutoMemoryRecall();
+      }
+    });
   }
   async #handleStopHookLoop(pendingSend, promptId, hooksEnabled, messageBus, allowExternalHooks = true, modelOverride, responseCapture, rejectOnLoopDetected = false) {
     const stopHookBlockingCap = this.config.getStopHookBlockingCap();
@@ -6673,7 +6990,7 @@ ${this.pendingRecoveredAgentsNotice}
             }
           );
           if (continuation2.kind === "terminal") {
-            return { stopReason: continuation2.stopReason };
+            return continuation2;
           }
           continue;
         }
@@ -6758,7 +7075,7 @@ ${this.pendingRecoveredAgentsNotice}
               }
             );
             if (continuation2.kind === "terminal") {
-              return { stopReason: continuation2.stopReason };
+              return continuation2;
             }
             continue;
           }
@@ -6862,7 +7179,7 @@ ${this.pendingRecoveredAgentsNotice}
         stopHookReasons = stopHookReasons.slice(0, -1);
       }
       if (continuation.kind === "terminal") {
-        return { stopReason: continuation.stopReason };
+        return continuation;
       }
     }
   }
@@ -7317,6 +7634,7 @@ ${this.pendingRecoveredAgentsNotice}
             // and background-notification turns keep the graceful end-turn
             // handling they had before loop stops became rejections.
             stopReason: options.rejectOnLoopDetected ? cancelledOrThrowLoopDetected(pendingSend.signal, toolLoopState) : getAbortAwareEndTurnStopReason(pendingSend.signal),
+            loopProtectionStopped: true,
             ...supersededAutomaticContinuation ? { supersededAutomaticContinuation: true } : {}
           };
         }
@@ -7329,6 +7647,14 @@ ${this.pendingRecoveredAgentsNotice}
           options.rejectOnLoopDetected ?? false
         );
         nextMessage = nextAfterTools.message;
+        if (nextAfterTools.stoppedByRepeatedToolFailure) {
+          return {
+            kind: "terminal",
+            stopReason: options.rejectOnLoopDetected ? cancelledOrThrowLoopDetected(pendingSend.signal, toolLoopState) : getAbortAwareEndTurnStopReason(pendingSend.signal),
+            loopProtectionStopped: true,
+            ...supersededAutomaticContinuation ? { supersededAutomaticContinuation: true } : {}
+          };
+        }
         if (nextAfterTools.hadMidTurnUserInput) {
           nextGuardContinuation = void 0;
           continue;
@@ -7627,6 +7953,14 @@ ${this.pendingRecoveredAgentsNotice}
       );
       return { responseStream: null, stopReason: "cancelled" };
     }
+    if (message[0]?.functionResponse) {
+      const memory = await geminiClient.consumeManagedAutoMemoryRecall("tool_result");
+      if (memory?.prompt) {
+        message = insertAfterFunctionResponses(message, [
+          { text: memory.prompt }
+        ]);
+      }
+    }
     const chat = this.#getCurrentChat();
     const model = options.getModelOverride?.() ?? options.modelOverride ?? this.config.getModel();
     const request = {
@@ -8000,13 +8334,23 @@ ${this.pendingRecoveredAgentsNotice}
       const displayText = message.kind === "text" ? message.message : message.displayText;
       let rawParts;
       try {
-        rawParts = message.kind === "text" ? [{ text: message.message }] : await withTimeoutSignal(
-          abortSignal,
-          MID_TURN_QUEUE_RESOLVE_TIMEOUT_MS,
-          (signal) => this.#resolvePrompt(message.content, signal, {
-            onFullTurnModel: options.onFullTurnModel
-          })
-        );
+        if (message.kind === "text") {
+          rawParts = [{ text: message.message }];
+        } else {
+          rawParts = await withTimeoutSignal(
+            abortSignal,
+            MID_TURN_QUEUE_RESOLVE_TIMEOUT_MS,
+            (signal) => this.#resolvePrompt(message.content, signal, {
+              deferBridgeConversions: true
+            })
+          );
+          rawParts = await this.#applyBridgeConversionsIfNeeded(
+            rawParts,
+            abortSignal,
+            options.onFullTurnModel
+          );
+          abortSignal.throwIfAborted();
+        }
       } catch (messageError) {
         if (abortSignal.aborted && !options.preserveFallbackOnAbort) {
           return parts;
@@ -8052,15 +8396,18 @@ ${this.pendingRecoveredAgentsNotice}
    */
   async #startCronSchedulerIfNeeded() {
     if (this.disposed) return;
+    if (this.#isAutomaticWorkHeld()) return;
     if (!this.config.isCronEnabled()) return;
     if (this.cronDisabledByTokenLimit) return;
     const scheduler = this.config.getCronScheduler();
-    try {
-      await scheduler.enableDurable(this.sessionId);
-    } catch (err) {
-      debugLogger6.warn(
-        `Durable cron init failed \u2014 persistent tasks will not fire in this session: ${err}`
-      );
+    if (!this.requiresManagedConversationBinding) {
+      try {
+        await scheduler.enableDurable(this.sessionId);
+      } catch (err) {
+        debugLogger6.warn(
+          `Durable cron init failed \u2014 persistent tasks will not fire in this session: ${err}`
+        );
+      }
     }
     if (this.disposed) return;
     if (!scheduler.hasPendingWork) return;
@@ -8136,6 +8483,7 @@ ${this.pendingRecoveredAgentsNotice}
   async #drainCronQueue() {
     if (this.disposed) return;
     if (this.closing) return;
+    if (this.#isAutomaticWorkHeld()) return;
     if (this.cronProcessing) return;
     if (this.pendingPrompt) return;
     if (this.goalProcessing) return;
@@ -8148,6 +8496,7 @@ ${this.pendingRecoveredAgentsNotice}
   }
   async #drainCronQueueExclusive() {
     if (this.disposed || this.closing || this.cronProcessing) return;
+    if (this.#isAutomaticWorkHeld()) return;
     if (this.pendingPrompt || this.notificationProcessing) return;
     if (this.#deferAutomaticQueueDrainUntilTurnsSettle()) return;
     if (this.#nextCronQueueIndex() < 0) return;
@@ -8224,11 +8573,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)
+        )
       )
     );
   }
@@ -8741,6 +9092,7 @@ ${this.pendingRecoveredAgentsNotice}
   async #drainNotificationQueue() {
     if (this.disposed) return;
     if (this.closing) return;
+    if (this.#isAutomaticWorkHeld()) return;
     if (this.notificationProcessing) return;
     if (this.pendingPrompt || this.goalProcessing || this.cronProcessing || this.cronAbortController) {
       return;
@@ -8754,6 +9106,7 @@ ${this.pendingRecoveredAgentsNotice}
   }
   async #drainNotificationQueueExclusive() {
     if (this.disposed || this.closing || this.notificationProcessing) return;
+    if (this.#isAutomaticWorkHeld()) return;
     if (this.pendingPrompt || this.cronProcessing || this.cronAbortController) {
       return;
     }
@@ -8790,11 +9143,13 @@ ${this.pendingRecoveredAgentsNotice}
         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 {
@@ -9173,12 +9528,17 @@ ${this.pendingRecoveredAgentsNotice}
   reloadSkillSettings() {
     this.settings.reloadScopeFromDisk("Workspace" /* Workspace */);
   }
-  async sendAvailableCommandsUpdateOrThrow() {
-    const { availableCommands, availableSkills, availableSkillDetails } = await buildAvailableCommandsSnapshot(
+  buildAvailableCommandsSnapshot() {
+    return buildAvailableCommandsSnapshot(
       this.config,
       void 0,
-      this.settings
+      this.settings,
+      this.slashCommandPolicy
     );
+  }
+  async sendAvailableCommandsUpdateOrThrow() {
+    if (this.#isAutomaticWorkHeld()) return;
+    const { availableCommands, availableSkills, availableSkillDetails } = await this.buildAvailableCommandsSnapshot();
     const update = {
       sessionUpdate: "available_commands_update",
       availableCommands,
@@ -9321,7 +9681,8 @@ ${this.pendingRecoveredAgentsNotice}
     }).catch((error) => {
       debugLogger6.debug("model-update extNotification failed", error);
     });
-    if (options.persistDefault ?? true) {
+    const persistDefault = !this.requiresManagedConversationBinding && (options.persistDefault ?? true);
+    if (persistDefault) {
       const persistScope = getPersistScopeForModelSelection(this.settings);
       this.settings.setValue(
         persistScope,
@@ -9445,11 +9806,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,
@@ -9936,11 +10302,6 @@ ${this.pendingRecoveredAgentsNotice}
    * branches in `GeminiClient.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 `GeminiClient`, and porting it into the ACP path is tracked
-   * separately as part of the broader middleware-alignment work.
    */
   async #buildInitialSystemReminders() {
     const reminders = [];
@@ -10221,6 +10582,18 @@ ${this.pendingRecoveredAgentsNotice}
         const isAgentTool = tool.name === ToolNames.AGENT;
         const isExitPlanModeTool = tool.name === ToolNames.EXIT_PLAN_MODE;
         const isEnterPlanModeTool = tool.name === ToolNames.ENTER_PLAN_MODE;
+        const requestsAgentWorkingDirectory = isAgentTool && (args["isolation"] === "worktree" || typeof args["working_dir"] === "string" && args["working_dir"].trim().length > 0);
+        if (this.requiresManagedConversationBinding && (requestsAgentWorkingDirectory || tool.name === ToolNames.ENTER_WORKTREE || tool.name === ToolNames.EXIT_WORKTREE)) {
+          return earlyErrorResponse(
+            new Error(STANDALONE_WORKTREE_ACTION_ERROR),
+            toolName,
+            {
+              status: "error",
+              errorType: "execution_denied" /* EXECUTION_DENIED */,
+              executionStatus: "not_started"
+            }
+          );
+        }
         if (isAgentTool) {
           agentToolAbortController = new AbortController();
           activeToolAbortSignal = agentToolAbortController.signal;
@@ -10260,7 +10633,8 @@ ${this.pendingRecoveredAgentsNotice}
                 agentToolAbortController?.abort(USER_CANCEL_ABORT_REASON);
                 onStopAfterPermissionCancel?.();
               },
-              (params, signal) => this.#requestPermissionQueued(params, signal)
+              (params, signal) => this.#requestPermissionQueued(params, signal),
+              this.requiresManagedConversationBinding ? STANDALONE_PERMISSION_PERSISTENCE_POLICY : void 0
             );
             subAgentCleanupFunctions = subSubAgentTracker.setup(
               taskEventEmitter,
@@ -10678,7 +11052,8 @@ ${this.pendingRecoveredAgentsNotice}
               }
               const permissionOptions = toPermissionOptions(
                 confirmationDetails,
-                pmForcedAsk
+                pmForcedAsk,
+                this.requiresManagedConversationBinding ? STANDALONE_PERMISSION_PERSISTENCE_POLICY : void 0
               );
               const offeredPermissionOptions = permissionOptions.map(
                 (option) => ({ ...option })
@@ -10831,7 +11206,7 @@ ${this.pendingRecoveredAgentsNotice}
                 const modeUpdateCancellation = cancelBeforeExecutionIfAborted(toolName);
                 if (modeUpdateCancellation) return modeUpdateCancellation;
               }
-              if (outcome === "proceed_always" /* ProceedAlways */ || outcome === "proceed_always_project" /* ProceedAlwaysProject */ || outcome === "proceed_always_user" /* ProceedAlwaysUser */) {
+              if (outcome === "proceed_always_project" /* ProceedAlwaysProject */ || outcome === "proceed_always_user" /* ProceedAlwaysUser */) {
                 await persistPermissionOutcome(
                   outcome,
                   confirmationDetails,
@@ -11469,6 +11844,9 @@ ${this.pendingRecoveredAgentsNotice}
         executionStatus
       });
     } finally {
+      if (terminalStatus && terminalStatus !== "cancelled") {
+        this.config.getGeminiClient().recordCompletedToolCall(toolName, args);
+      }
       if (terminalStatus === "cancelled") {
         endToolSpan(toolSpan, { success: false, cancelled: true });
       } else {
@@ -11541,6 +11919,13 @@ ${this.pendingRecoveredAgentsNotice}
         return null;
       }
       case "unsupported": {
+        if (result.originalType === "unsupported_action") {
+          throw new RequestError(
+            -32004,
+            "This action is not supported in this standalone session.",
+            { errorKind: "unsupported_action" }
+          );
+        }
         const unsupportedError = `Slash command not supported in ACP integration: ${result.reason}`;
         throw new Error(unsupportedError);
       }
@@ -11575,6 +11960,11 @@ ${this.pendingRecoveredAgentsNotice}
     const preserveUnsupportedImageForBridge = shouldRunVisionBridge(
       this.config
     );
+    const finish = /* @__PURE__ */ __name((parts2) => options.deferBridgeConversions ? parts2 : this.#applyBridgeConversionsIfNeeded(
+      parts2,
+      abortSignal,
+      options.onFullTurnModel
+    ), "finish");
     const parts = message.map((part) => {
       switch (part.type) {
         case "text":
@@ -11680,18 +12070,10 @@ ${this.pendingRecoveredAgentsNotice}
       (part) => !("fileData" in part) || acceptedFileUris.has(part.fileData.fileUri)
     );
     if (pathSpecsToRead.length === 0 && embeddedContext.length === 0 && extensionParts.length === 0 && mcpServerParts.length === 0) {
-      return this.#applyBridgeConversionsIfNeeded(
-        partsToSend,
-        abortSignal,
-        options.onFullTurnModel
-      );
+      return finish(partsToSend);
     }
     if (pathSpecsToRead.length === 0 && embeddedContext.length === 0) {
-      return this.#applyBridgeConversionsIfNeeded(
-        [...partsToSend, ...extensionParts, ...mcpServerParts],
-        abortSignal,
-        options.onFullTurnModel
-      );
+      return finish([...partsToSend, ...extensionParts, ...mcpServerParts]);
     }
     let initialQueryText = "";
     for (let i = 0; i < partsToSend.length; i++) {
@@ -11752,11 +12134,7 @@ ${contextPart.text}`
     const promptText = pathSpecsToRead.length > 0 ? initialQueryText : initialQueryText.trim();
     const promptPart = { text: promptText };
     const processedQueryParts = options.promptLast ? [...referenceParts, promptPart] : [promptPart, ...referenceParts];
-    return this.#applyBridgeConversionsIfNeeded(
-      processedQueryParts,
-      abortSignal,
-      options.onFullTurnModel
-    );
+    return finish(processedQueryParts);
   }
   async #applyBridgeConversionsIfNeeded(originalParts, abortSignal, onFullTurnModel) {
     const parts = await this.#applyVoiceBridgeIfNeeded(
@@ -13703,7 +14081,8 @@ function getSessionSource(params) {
   }
   return {
     sourceType: value["sourceType"],
-    ...typeof value["sourceId"] === "string" ? { sourceId: value["sourceId"] } : {}
+    ...typeof value["sourceId"] === "string" ? { sourceId: value["sourceId"] } : {},
+    ...value[DAEMON_OWNED_STANDALONE_CREATION_KEY] === true ? { daemonOwnedStandaloneCreation: true } : {}
   };
 }
 __name(getSessionSource, "getSessionSource");
@@ -14521,7 +14900,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);
@@ -14533,7 +14912,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
@@ -15149,6 +15528,100 @@ function isOwnerOnlyDirectory(stats) {
   return (stats.mode & 63) === 0;
 }
 __name(isOwnerOnlyDirectory, "isOwnerOnlyDirectory");
+function hasOnlyKeys(value, keys) {
+  const actual = Object.keys(value).sort();
+  const expected = [...keys].sort();
+  return actual.length === expected.length && actual.every((key, index) => key === expected[index]);
+}
+__name(hasOnlyKeys, "hasOnlyKeys");
+function isManagedConversationPath(value) {
+  return typeof value === "string" && value.length > 0 && !value.includes("\0") && path6.isAbsolute(value);
+}
+__name(isManagedConversationPath, "isManagedConversationPath");
+function isManagedConversationIdentityNumber(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+__name(isManagedConversationIdentityNumber, "isManagedConversationIdentityNumber");
+function parseConversationDirectoryExpectation(value) {
+  if (value === void 0) return void 0;
+  if (!isObjectRecord(value) || !hasOnlyKeys(value, ["canonicalSessionId", "root", "child"])) {
+    throw RequestError.invalidParams(
+      void 0,
+      "Invalid managed conversation directory expectation"
+    );
+  }
+  const canonicalSessionId = value["canonicalSessionId"];
+  const root = value["root"];
+  const child = value["child"];
+  const parsedSessionId = parseCallerSuppliedSessionId(canonicalSessionId);
+  if (parsedSessionId.kind !== "valid" || parsedSessionId.sessionId !== canonicalSessionId || !isObjectRecord(root) || !hasOnlyKeys(root, ["canonicalPath", "device", "inode"]) || !isManagedConversationPath(root["canonicalPath"]) || !isManagedConversationIdentityNumber(root["device"]) || !isManagedConversationIdentityNumber(root["inode"]) || !isObjectRecord(child) || !hasOnlyKeys(child, ["name", "canonicalPath", "device", "inode"]) || typeof child["name"] !== "string" || child["name"] !== getConversationDirectoryName(canonicalSessionId) || !isManagedConversationPath(child["canonicalPath"]) || !isManagedConversationIdentityNumber(child["device"]) || !isManagedConversationIdentityNumber(child["inode"]) || !isSameConversationPath(
+    path6.dirname(child["canonicalPath"]),
+    root["canonicalPath"]
+  ) || path6.basename(child["canonicalPath"]) !== child["name"]) {
+    throw RequestError.invalidParams(
+      void 0,
+      "Invalid managed conversation directory expectation"
+    );
+  }
+  return {
+    canonicalSessionId,
+    root: {
+      canonicalPath: root["canonicalPath"],
+      device: root["device"],
+      inode: root["inode"]
+    },
+    child: {
+      name: child["name"],
+      canonicalPath: child["canonicalPath"],
+      device: child["device"],
+      inode: child["inode"]
+    }
+  };
+}
+__name(parseConversationDirectoryExpectation, "parseConversationDirectoryExpectation");
+function managedConversationDirectoryError(missing) {
+  return new RequestError(
+    -32004,
+    missing ? "The standalone working directory is missing." : "The standalone working directory identity is compromised.",
+    {
+      errorKind: missing ? "working_directory_missing" : "working_directory_compromised"
+    }
+  );
+}
+__name(managedConversationDirectoryError, "managedConversationDirectoryError");
+async function assertManagedConversationDirectoryIdentity(expectation) {
+  let rootBefore;
+  let canonicalRoot;
+  let rootAfter;
+  try {
+    rootBefore = await fs3.lstat(expectation.root.canonicalPath);
+    canonicalRoot = await fs3.realpath(expectation.root.canonicalPath);
+    rootAfter = await fs3.lstat(canonicalRoot);
+  } catch (error) {
+    throw managedConversationDirectoryError(
+      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) {
+    throw managedConversationDirectoryError(false);
+  }
+  let childBefore;
+  let canonicalChild;
+  let childAfter;
+  try {
+    childBefore = await fs3.lstat(expectation.child.canonicalPath);
+    canonicalChild = await fs3.realpath(expectation.child.canonicalPath);
+    childAfter = await fs3.lstat(canonicalChild);
+  } catch (error) {
+    throw managedConversationDirectoryError(
+      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) {
+    throw managedConversationDirectoryError(false);
+  }
+}
+__name(assertManagedConversationDirectoryIdentity, "assertManagedConversationDirectoryIdentity");
 var QwenAgent = class {
   constructor(config, settings, argv, connection, expectedPrivateParentCapability, sessionWriterLeaseEnabledAtStartup = false, managedToolInvocationGuard, externalToolGuardProviderAttached = false) {
     this.config = config;
@@ -16043,7 +16516,7 @@ var QwenAgent = class {
     }
     this.clientCapabilities = args.clientCapabilities;
     const authMethods = buildAuthMethods();
-    const version = "0.22.1";
+    const version = "0.22.2-nightly.20260828.7357136dd1";
     const response = {
       protocolVersion: PROTOCOL_VERSION,
       agentInfo: {
@@ -16180,6 +16653,15 @@ var QwenAgent = class {
     const releaseStartingSessionId = requestedSessionId ? this.reserveStartingSessionId(requestedSessionId) : void 0;
     try {
       const sessionSource = getSessionSource(params);
+      const provisionalStandalone = isReservedStandaloneSessionSourceType(
+        sessionSource?.sourceType
+      );
+      if (sessionSource && isReservedStandaloneSessionSourceType(sessionSource.sourceType) && (sessionSource.daemonOwnedStandaloneCreation !== true || !this.isTrustedManagedParent())) {
+        throw RequestError.invalidParams(
+          void 0,
+          "`standalone` is reserved for daemon-owned session creation"
+        );
+      }
       const parentContext = extractDaemonTraceContext(params);
       return await withDaemonSpan(
         "qwen-code.daemon.session_start",
@@ -16205,14 +16687,21 @@ var QwenAgent = class {
           );
           let session;
           try {
-            await profiler.time("auth", () => this.ensureAuthenticated(config));
-            profiler.timeSync(
-              "file_system_setup",
-              () => this.setupFileSystem(config)
-            );
+            if (!provisionalStandalone) {
+              await profiler.time(
+                "auth",
+                () => this.ensureAuthenticated(config)
+              );
+              profiler.timeSync(
+                "file_system_setup",
+                () => this.setupFileSystem(config)
+              );
+            }
             session = await profiler.time(
               "session_register",
-              () => this.createAndStoreSession(config, settings)
+              () => this.createAndStoreSession(config, settings, void 0, {
+                deferWorkspaceActivation: provisionalStandalone
+              })
             );
           } catch (error) {
             return this.cleanupAfterRequestFailure(error, async () => {
@@ -16256,6 +16745,15 @@ var QwenAgent = class {
   async loadSessionWithProfiler(params, initialSessionId, profiler) {
     let sessionId = initialSessionId;
     const sessionSource = getSessionSource(params);
+    const provisionalStandalone = isReservedStandaloneSessionSourceType(
+      sessionSource?.sourceType
+    );
+    if (provisionalStandalone && (sessionSource?.daemonOwnedStandaloneCreation !== true || !this.isTrustedManagedParent())) {
+      throw RequestError.invalidParams(
+        void 0,
+        "`standalone` is reserved for daemon-owned session restore"
+      );
+    }
     const restoreOptions = loadRestoreOptions(params);
     const suppressRestoreAskUserQuestion = params._meta?.[DAEMON_SUPPRESS_RESTORE_ASK_USER_QUESTION_META_KEY] === true;
     const withRestoreHint = /* @__PURE__ */ __name((session, response) => suppressRestoreAskUserQuestion ? response : this.withAskUserQuestionRestoreHint(session, response), "withRestoreHint");
@@ -16418,21 +16916,37 @@ var QwenAgent = class {
         } : {}
       })), "buildResponse");
       try {
-        await profiler.time(
-          "restore_session_model",
-          () => restoreSessionModelThenAuthenticate(
-            config,
-            projection,
-            () => profiler.time("auth", () => this.ensureAuthenticated(config))
-          )
-        );
-        profiler.timeSync(
-          "file_system_setup",
-          () => this.setupFileSystem(config)
-        );
+        if (!provisionalStandalone) {
+          await profiler.time(
+            "restore_session_model",
+            () => restoreSessionModelThenAuthenticate(
+              config,
+              projection,
+              () => profiler.time("auth", () => this.ensureAuthenticated(config))
+            )
+          );
+          profiler.timeSync(
+            "file_system_setup",
+            () => this.setupFileSystem(config)
+          );
+        }
         await profiler.time(
           "session_register",
           () => this.createAndStoreSession(config, settings, void 0, {
+            deferWorkspaceActivation: provisionalStandalone,
+            ...provisionalStandalone ? {
+              beforeDeferredWorkspaceActivation: /* @__PURE__ */ __name(() => profiler.time(
+                "restore_session_model",
+                () => restoreSessionModelThenAuthenticate(
+                  config,
+                  projection,
+                  () => profiler.time(
+                    "auth",
+                    () => this.ensureAuthenticated(config)
+                  )
+                )
+              ), "beforeDeferredWorkspaceActivation")
+            } : {},
             enableLiveScreenContext: isCompatibleLiveSessionSource(
               sessionSource ?? {}
             ),
@@ -16578,7 +17092,9 @@ var QwenAgent = class {
                 }
               }
               await profiler.time("post_replay_services", async () => {
-                await this.#restoreWorktreeOnResume(config, createdSession);
+                if (!provisionalStandalone) {
+                  await this.#restoreWorktreeOnResume(config, createdSession);
+                }
                 await this.#restoreBackgroundAgentsOnResume(
                   config,
                   createdSession
@@ -16627,6 +17143,15 @@ var QwenAgent = class {
   async resumeSessionWithProfiler(params, initialSessionId, profiler) {
     let sessionId = initialSessionId;
     const sessionSource = getSessionSource(params);
+    const provisionalStandalone = isReservedStandaloneSessionSourceType(
+      sessionSource?.sourceType
+    );
+    if (provisionalStandalone && (sessionSource?.daemonOwnedStandaloneCreation !== true || !this.isTrustedManagedParent())) {
+      throw RequestError.invalidParams(
+        void 0,
+        "`standalone` is reserved for daemon-owned session restore"
+      );
+    }
     const suppressRestoreAskUserQuestion = params._meta?.[DAEMON_SUPPRESS_RESTORE_ASK_USER_QUESTION_META_KEY] === true;
     const withRestoreHint = /* @__PURE__ */ __name((session, response) => suppressRestoreAskUserQuestion ? response : this.withAskUserQuestionRestoreHint(session, response), "withRestoreHint");
     const liveSession = this.sessions.get(sessionId);
@@ -16697,21 +17222,37 @@ var QwenAgent = class {
       const projection = config.consumeSessionRestoreProjection?.();
       let response;
       try {
-        await profiler.time(
-          "restore_session_model",
-          () => restoreSessionModelThenAuthenticate(
-            config,
-            projection,
-            () => profiler.time("auth", () => this.ensureAuthenticated(config))
-          )
-        );
-        profiler.timeSync(
-          "file_system_setup",
-          () => this.setupFileSystem(config)
-        );
+        if (!provisionalStandalone) {
+          await profiler.time(
+            "restore_session_model",
+            () => restoreSessionModelThenAuthenticate(
+              config,
+              projection,
+              () => profiler.time("auth", () => this.ensureAuthenticated(config))
+            )
+          );
+          profiler.timeSync(
+            "file_system_setup",
+            () => this.setupFileSystem(config)
+          );
+        }
         await profiler.time(
           "session_register",
           () => this.createAndStoreSession(config, settings, void 0, {
+            deferWorkspaceActivation: provisionalStandalone,
+            ...provisionalStandalone ? {
+              beforeDeferredWorkspaceActivation: /* @__PURE__ */ __name(() => profiler.time(
+                "restore_session_model",
+                () => restoreSessionModelThenAuthenticate(
+                  config,
+                  projection,
+                  () => profiler.time(
+                    "auth",
+                    () => this.ensureAuthenticated(config)
+                  )
+                )
+              ), "beforeDeferredWorkspaceActivation")
+            } : {},
             enableLiveScreenContext: isCompatibleLiveSessionSource(
               sessionSource ?? {}
             ),
@@ -16735,7 +17276,9 @@ var QwenAgent = class {
             }, "primeSession"),
             beforeStartPostReplayServices: /* @__PURE__ */ __name(async (createdSession) => {
               await profiler.time("post_replay_services", async () => {
-                await this.#restoreWorktreeOnResume(config, createdSession);
+                if (!provisionalStandalone) {
+                  await this.#restoreWorktreeOnResume(config, createdSession);
+                }
                 await this.#restoreBackgroundAgentsOnResume(
                   config,
                   createdSession
@@ -16871,15 +17414,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(
@@ -16887,7 +17432,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) {
@@ -17771,18 +18326,17 @@ var QwenAgent = class {
       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 }
@@ -17841,7 +18395,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),
@@ -18296,7 +18856,7 @@ var QwenAgent = class {
   }
   async buildSessionSupportedCommandsStatus(sessionId) {
     const session = this.sessionOrThrow(sessionId);
-    const { availableCommands, availableSkills } = await buildAvailableCommandsSnapshot(session.getConfig());
+    const { availableCommands, availableSkills } = await session.buildAvailableCommandsSnapshot();
     return {
       v: STATUS_SCHEMA_VERSION,
       sessionId,
@@ -18341,12 +18901,26 @@ var QwenAgent = class {
     const now = Date.now();
     const createdAt = session.getCreatedAt();
     const models = {};
-    for (const [name, m] of Object.entries(metrics.models)) {
+    for (const [name, rawMetrics] of Object.entries(metrics.models)) {
+      const m = metrics.statsModels?.[name] ?? rawMetrics;
       models[name] = {
         api: { ...m.api },
         tokens: { ...m.tokens }
       };
     }
+    const sources = [];
+    for (const [id, source] of Object.entries(metrics.sourceMetrics ?? {})) {
+      const meta = metrics.sourceMeta?.[id];
+      sources.push({
+        id,
+        type: meta?.type ?? "",
+        name: meta?.name ?? id,
+        tokens: { ...source.tokens }
+      });
+    }
+    sources.sort(
+      (a, b) => b.tokens.total - a.tokens.total || a.id.localeCompare(b.id)
+    );
     const byName = {};
     for (const [name, t] of Object.entries(metrics.tools.byName)) {
       byName[name] = {
@@ -18389,6 +18963,7 @@ var QwenAgent = class {
       durationMs: now - createdAt,
       promptCount: session.getTurnCount(),
       models,
+      sources,
       tools: {
         totalCalls: metrics.tools.totalCalls,
         totalSuccess: metrics.tools.totalSuccess,
@@ -20064,6 +20639,17 @@ var QwenAgent = class {
             "error" in source ? source.error : "Invalid or missing sourceType"
           );
         }
+        if (isReservedStandaloneSessionSourceType(source.sourceType)) {
+          const standaloneSession = this.sessionOrThrow(sessionId);
+          if (params[DAEMON_OWNED_STANDALONE_CREATION_KEY] !== true || this.privateParentState !== "trusted" || !isReservedStandaloneSessionSourceType(
+            standaloneSession.getConfig().getSessionSourceType()
+          )) {
+            throw RequestError.invalidParams(
+              void 0,
+              "`standalone` is reserved for daemon-owned session creation"
+            );
+          }
+        }
         const session = this.sessionOrThrow(sessionId);
         if (isCompatibleLiveSessionSource(source)) {
           await session.enableLiveScreenContext();
@@ -20260,9 +20846,41 @@ var QwenAgent = class {
             "Invalid managed relocation capability"
           );
         }
+        const conversationDirectoryExpectation = parseConversationDirectoryExpectation(
+          params["conversationDirectoryExpectation"]
+        );
+        if (conversationDirectoryExpectation !== void 0 && managedRelocation !== "live-conversation") {
+          throw RequestError.invalidParams(
+            void 0,
+            "Managed conversation directory expectation requires managed relocation"
+          );
+        }
         const allowedRoots = params["allowedRoots"];
         const session = this.sessionOrThrow(sessionId);
         const config = session.getConfig();
+        const standalone = isReservedStandaloneSessionSourceType(
+          config.getSessionSourceType()
+        );
+        if (standalone && (managedRelocation !== "live-conversation" || conversationDirectoryExpectation === void 0)) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Standalone relocation requires an exact managed directory expectation"
+          );
+        }
+        if (conversationDirectoryExpectation !== void 0) {
+          if (this.privateParentState !== "trusted" || conversationDirectoryExpectation.canonicalSessionId !== normalizeSessionIdForLookup(sessionId) || !Array.isArray(allowedRoots) || allowedRoots.length !== 1 || typeof allowedRoots[0] !== "string" || !isSameConversationPath(
+            allowedRoots[0],
+            conversationDirectoryExpectation.root.canonicalPath
+          ) || !isSameConversationPath(
+            targetPath,
+            conversationDirectoryExpectation.child.canonicalPath
+          )) {
+            throw managedConversationDirectoryError(false);
+          }
+          await assertManagedConversationDirectoryIdentity(
+            conversationDirectoryExpectation
+          );
+        }
         if (config.isRestrictiveSandbox()) {
           throw new RequestError(-32003, "Restrictive sandbox mode active", {
             errorKind: "restrictive_sandbox"
@@ -20272,18 +20890,34 @@ var QwenAgent = class {
         try {
           stats = await fs3.stat(targetPath);
         } catch {
+          if (conversationDirectoryExpectation !== void 0) {
+            throw managedConversationDirectoryError(true);
+          }
           throw new RequestError(-32002, `Directory not found: ${targetPath}`, {
             errorKind: "directory_not_found",
             path: targetPath
           });
         }
         if (!stats.isDirectory()) {
+          if (conversationDirectoryExpectation !== void 0) {
+            throw managedConversationDirectoryError(false);
+          }
           throw new RequestError(-32002, `Not a directory: ${targetPath}`, {
             errorKind: "directory_not_found",
             path: targetPath
           });
         }
-        const canonicalPath = await fs3.realpath(targetPath);
+        let canonicalPath;
+        try {
+          canonicalPath = await fs3.realpath(targetPath);
+        } catch (error) {
+          if (conversationDirectoryExpectation !== void 0) {
+            throw managedConversationDirectoryError(
+              error.code === "ENOENT"
+            );
+          }
+          throw error;
+        }
         let containmentRoots = allowedRoots;
         let managedTrustAllowed = false;
         if (managedRelocation === "live-conversation") {
@@ -20308,13 +20942,22 @@ var QwenAgent = class {
             canonicalRoot = await fs3.realpath(rootPath);
             rootAfter = await fs3.lstat(canonicalRoot);
           } catch {
+            if (conversationDirectoryExpectation !== void 0) {
+              throw managedConversationDirectoryError(false);
+            }
             throw new RequestError(
               -32004,
               "Live managed relocation requires an owner-only allowed root",
               { errorKind: "containment_violation", path: rootPath }
             );
           }
-          if (!isOwnerOnlyDirectory(rootBefore) || !isOwnerOnlyDirectory(rootAfter) || rootBefore.dev !== rootAfter.dev || rootBefore.ino !== rootAfter.ino) {
+          if (!isOwnerOnlyDirectory(rootBefore) || !isOwnerOnlyDirectory(rootAfter) || rootBefore.dev !== rootAfter.dev || rootBefore.ino !== rootAfter.ino || conversationDirectoryExpectation !== void 0 && (!isSameConversationPath(
+            canonicalRoot,
+            conversationDirectoryExpectation.root.canonicalPath
+          ) || rootAfter.dev !== conversationDirectoryExpectation.root.device || rootAfter.ino !== conversationDirectoryExpectation.root.inode)) {
+            if (conversationDirectoryExpectation !== void 0) {
+              throw managedConversationDirectoryError(false);
+            }
             throw new RequestError(
               -32004,
               "Live managed relocation requires an owner-only allowed root",
@@ -20326,7 +20969,12 @@ var QwenAgent = class {
           try {
             targetBefore = await fs3.lstat(targetPath);
             targetAfter = await fs3.lstat(canonicalPath);
-          } catch {
+          } catch (error) {
+            if (conversationDirectoryExpectation !== void 0) {
+              throw managedConversationDirectoryError(
+                error.code === "ENOENT"
+              );
+            }
             throw new RequestError(
               -32004,
               "Live managed relocation requires an owner-only direct child",
@@ -20334,7 +20982,13 @@ var QwenAgent = class {
             );
           }
           const relativeTarget = path6.relative(canonicalRoot, canonicalPath);
-          if (!isOwnerOnlyDirectory(targetBefore) || !isOwnerOnlyDirectory(targetAfter) || targetBefore.dev !== targetAfter.dev || targetBefore.ino !== targetAfter.ino || relativeTarget.length === 0 || relativeTarget.startsWith("..") || path6.isAbsolute(relativeTarget) || relativeTarget.includes(path6.sep)) {
+          if (!isOwnerOnlyDirectory(targetBefore) || !isOwnerOnlyDirectory(targetAfter) || targetBefore.dev !== targetAfter.dev || targetBefore.ino !== targetAfter.ino || 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)) {
+            if (conversationDirectoryExpectation !== void 0) {
+              throw managedConversationDirectoryError(false);
+            }
             throw new RequestError(
               -32004,
               "Live managed relocation requires an owner-only direct child",
@@ -20345,13 +20999,19 @@ var QwenAgent = class {
           try {
             rootFinal = await fs3.lstat(canonicalRoot);
           } catch {
+            if (conversationDirectoryExpectation !== void 0) {
+              throw managedConversationDirectoryError(false);
+            }
             throw new RequestError(
               -32004,
               "Live managed relocation allowed root changed during validation",
               { errorKind: "containment_violation", path: canonicalRoot }
             );
           }
-          if (!isOwnerOnlyDirectory(rootFinal) || rootFinal.dev !== rootAfter.dev || rootFinal.ino !== rootAfter.ino) {
+          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 (conversationDirectoryExpectation !== void 0) {
+              throw managedConversationDirectoryError(false);
+            }
             throw new RequestError(
               -32004,
               "Live managed relocation allowed root changed during validation",
@@ -20368,6 +21028,9 @@ var QwenAgent = class {
             return !rel.startsWith("..") && !path6.isAbsolute(rel);
           });
           if (!contained) {
+            if (conversationDirectoryExpectation !== void 0) {
+              throw managedConversationDirectoryError(false);
+            }
             throw new RequestError(
               -32004,
               `Path outside allowed roots: ${canonicalPath}`,
@@ -20401,7 +21064,7 @@ var QwenAgent = class {
         );
         try {
           const settledPreviousCwd = config.getTargetDir();
-          if (canonicalPath === settledPreviousCwd) {
+          if (canonicalPath === settledPreviousCwd && conversationDirectoryExpectation === void 0) {
             return {
               previousCwd: settledPreviousCwd,
               newCwd: canonicalPath,
@@ -20417,12 +21080,30 @@ var QwenAgent = class {
             SESSION_DRAIN_TIMEOUT_MS,
             "close"
           );
+          if (conversationDirectoryExpectation !== void 0 && session.hasStandaloneRelocationBlockers()) {
+            throw new RequestError(
+              -32602,
+              "Cannot relocate while standalone background work is active",
+              { errorKind: "session_busy" }
+            );
+          }
           const warnings = [];
           const relocation = await config.relocateWorkingDirectory(
             canonicalPath,
             canonicalPath,
             { skipProcessChdir: true, skipArtifactMigration: true }
           );
+          if (conversationDirectoryExpectation !== void 0) {
+            await assertManagedConversationDirectoryIdentity(
+              conversationDirectoryExpectation
+            );
+            session.installPendingManagedConversationBinding(
+              conversationDirectoryExpectation,
+              () => assertManagedConversationDirectoryIdentity(
+                conversationDirectoryExpectation
+              )
+            );
+          }
           if (relocation.memoryRefreshError) {
             warnings.push(
               `Memory refresh failed: ${relocation.memoryRefreshError instanceof Error ? relocation.memoryRefreshError.message : String(relocation.memoryRefreshError)}`
@@ -20452,6 +21133,41 @@ var QwenAgent = class {
           releaseGate();
         }
       }
+      case SERVE_CONTROL_EXT_METHODS.sessionManagedConversationBindingCommit:
+      case SERVE_CONTROL_EXT_METHODS.sessionManagedConversationBindingRelease: {
+        const sessionId = params["sessionId"];
+        if (typeof sessionId !== "string" || sessionId.length === 0) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Invalid or missing sessionId"
+          );
+        }
+        if (this.privateParentState !== "trusted") {
+          throw RequestError.invalidParams(
+            void 0,
+            "Managed conversation binding requires a trusted private ACP parent"
+          );
+        }
+        const expectation = parseConversationDirectoryExpectation(
+          params["conversationDirectoryExpectation"]
+        );
+        if (expectation === void 0 || expectation.canonicalSessionId !== normalizeSessionIdForLookup(sessionId)) {
+          throw managedConversationDirectoryError(false);
+        }
+        const session = this.sessionOrThrow(sessionId);
+        if (!isReservedStandaloneSessionSourceType(
+          session.getConfig().getSessionSourceType()
+        )) {
+          throw managedConversationDirectoryError(false);
+        }
+        await assertManagedConversationDirectoryIdentity(expectation);
+        if (method === SERVE_CONTROL_EXT_METHODS.sessionManagedConversationBindingCommit) {
+          await session.commitManagedConversationBinding(expectation);
+          return { sessionId, committed: true };
+        }
+        await session.releaseManagedConversationBinding(expectation);
+        return { sessionId, released: true };
+      }
       case SERVE_CONTROL_EXT_METHODS.sessionApprovalMode: {
         const sessionId = params["sessionId"];
         const mode = params["mode"];
@@ -22175,6 +22891,9 @@ ${outputText}
     }
   }
   async newSessionConfigInRuntimeContext(cwd, mcpServers, settings, sessionSource, sessionId, resume, initializeOptions = {}, chatRecording, restoreOptions) {
+    const provisionalWorkspace = isReservedStandaloneSessionSourceType(
+      sessionSource?.sourceType
+    );
     const sessionMcpServers = {};
     for (const server of mcpServers) {
       const stdioServer = toStdioServer(server);
@@ -22236,6 +22955,7 @@ ${outputText}
     const sessionArg = resume === true ? { resume: sessionId, sessionId: void 0 } : { sessionId, resume: void 0 };
     const argvForSession = {
       ...this.argv,
+      ...provisionalWorkspace ? { experimentalLsp: false } : {},
       // Docker sandbox relaunch injects a fixed --sandbox-session-id into
       // the ACP process argv. Without clearing it, every newSession()
       // inherits the same ID and the second session collides with the
@@ -22272,7 +22992,8 @@ ${outputText}
       // not process.exit(1) the shared ACP child and every session on its
       // channel. newSessionConfig maps the throw to a RequestError.
       true,
-      this.managedToolInvocationGuard || restoreOptions ? {
+      this.managedToolInvocationGuard || restoreOptions || provisionalWorkspace ? {
+        ...provisionalWorkspace ? { provisionalWorkspace: true } : {},
         ...this.managedToolInvocationGuard ? { toolInvocationGuard: this.managedToolInvocationGuard } : {},
         ...restoreOptions && sessionId ? {
           sessionRestore: {
@@ -22351,8 +23072,12 @@ ${outputText}
         () => this.cleanupUnstoredConfig(config)
       );
     }
-    startNonInteractiveOpenAILogHousekeeping(config, settings);
-    void this.surfaceMcpFailuresWhenReady(config);
+    if (!provisionalWorkspace) {
+      startNonInteractiveOpenAILogHousekeeping(config, settings);
+    }
+    if (!provisionalWorkspace) {
+      void this.surfaceMcpFailuresWhenReady(config);
+    }
     return config;
   }
   async surfaceMcpFailuresWhenReady(config) {
@@ -22410,7 +23135,7 @@ ${outputText}
     const sessionId = normalizeSessionIdForLookup(config.getSessionId());
     const geminiClient = config.getGeminiClient();
     const needsInitialize = !geminiClient.isInitialized();
-    if (needsInitialize) {
+    if (needsInitialize && options.deferWorkspaceActivation !== true) {
       await geminiClient.initialize();
     }
     this.assertManagedSessionAdmission();
@@ -22439,11 +23164,59 @@ ${outputText}
       (operation) => this.runExclusiveHistoryMutation(sessionId, operation),
       () => this.activeWorkReporter?.notifyChanged()
     );
+    const replaySessionHistory = /* @__PURE__ */ __name(async () => {
+      if (options.replayHistory === false || !sessionData?.conversation.messages) {
+        return;
+      }
+      await session.replayHistory(
+        sessionData.conversation.messages,
+        sessionData.historyGaps
+      );
+      try {
+        await session.publishRecoveredGoalState(
+          sessionData.conversation.messages
+        );
+      } catch (error) {
+        debugLogger9.debug(
+          `Failed to publish recovered Goal state: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }, "replaySessionHistory");
+    if (options.deferWorkspaceActivation === true) {
+      session.installManagedConversationActivation(
+        async () => {
+          this.assertManagedSessionAdmission();
+          if (options.beforeDeferredWorkspaceActivation) {
+            await options.beforeDeferredWorkspaceActivation();
+          } else {
+            await this.ensureAuthenticated(config);
+          }
+          this.assertManagedSessionAdmission();
+          await config.activateProvisionalWorkspace();
+          this.assertManagedSessionAdmission();
+          this.setupFileSystem(config);
+          config.hydrateSessionRestoreFileHistory?.();
+          if (sessionData?.fileHistorySnapshots?.length) {
+            config.getFileHistoryService().restoreFromSnapshots(sessionData.fileHistorySnapshots);
+          }
+          await replaySessionHistory();
+          await options.beforeStartPostReplayServices?.(session);
+          session.installRewriter();
+          config.finalizeSessionRestore?.();
+          startNonInteractiveOpenAILogHousekeeping(config, settings);
+        },
+        () => {
+          void this.surfaceMcpFailuresWhenReady(config);
+        }
+      );
+    }
     let published = false;
     try {
       await registerCreateSubSessionTool(config);
       options.primeSession?.(session);
-      config.hydrateSessionRestoreFileHistory?.();
+      if (options.deferWorkspaceActivation !== true) {
+        config.hydrateSessionRestoreFileHistory?.();
+      }
       this.sessions.set(sessionId, session);
       published = true;
       this.activeWorkReporter?.notifyChanged();
@@ -22451,30 +23224,24 @@ ${outputText}
       if (options.enableLiveScreenContext) {
         await session.enableLiveScreenContext();
       }
-      if (sessionData?.fileHistorySnapshots?.length) {
+      if (options.deferWorkspaceActivation !== true && sessionData?.fileHistorySnapshots?.length) {
         config.getFileHistoryService().restoreFromSnapshots(sessionData.fileHistorySnapshots);
       }
       if (sessionData?.conversation.messages) {
         config.getChatRecordingService()?.rebuildTurnBoundaries(sessionData.conversation.messages);
       }
-      if (options.replayHistory !== false && sessionData?.conversation.messages) {
-        await session.replayHistory(
-          sessionData.conversation.messages,
-          sessionData.historyGaps
-        );
-        try {
-          await session.publishRecoveredGoalState(
-            sessionData.conversation.messages
-          );
-        } catch (error) {
-          debugLogger9.debug(
-            `Failed to publish recovered Goal state: ${error instanceof Error ? error.message : String(error)}`
-          );
-        }
+      if (options.deferWorkspaceActivation !== true) {
+        await replaySessionHistory();
+      }
+      if (options.deferWorkspaceActivation !== true) {
+        await options.beforeStartPostReplayServices?.(session);
+      }
+      if (options.deferWorkspaceActivation !== true) {
+        session.installRewriter();
+      }
+      if (options.deferWorkspaceActivation !== true) {
+        config.finalizeSessionRestore?.();
       }
-      await options.beforeStartPostReplayServices?.(session);
-      session.installRewriter();
-      config.finalizeSessionRestore?.();
       session.startCronScheduler();
       setTimeout(() => {
         void session.sendAvailableCommandsUpdate();
@@ -22582,11 +23349,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",
@@ -22609,13 +23394,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();