@qwen-code/qwen-code 0.22.2-preview.1 → 0.22.2

package/chunks/{acpAgent-4DCKLA32.js → acpAgent-MXEAN54C.js}

@@ -1,5 +1,8 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  recomputeMcpGating
+} from "./chunk-P5GGM4KS.js";
 import {
   classifyApiError,
   fireSessionDeleteHook
@@ -14,7 +17,7 @@ import {
   normalizePartList,
   parseExtensionRef,
   parseMcpServerRef
-} from "./chunk-5SM2AK65.js";
+} from "./chunk-OIP7C4FE.js";
 import {
   getAvailableCommands,
   getSlashCommandFirstToken,
@@ -23,14 +26,7 @@ import {
   isSlashCommand,
   recordDaemonSessionModel,
   restoreSessionModelThenAuthenticate
-} from "./chunk-GTUZ3R6I.js";
-import {
-  collectContextData,
-  formatContextUsageText
-} from "./chunk-WZ3QKPMQ.js";
-import {
-  recomputeMcpGating
-} from "./chunk-JLU3FPQR.js";
+} from "./chunk-F5SZP77N.js";
 import {
   SessionIdConflictError,
   appEvents,
@@ -38,41 +34,45 @@ import {
   cleanupReviewWorktreeLeases,
   loadCliConfig,
   normalizeDisabledToolList
-} from "./chunk-HPECDZ6X.js";
+} from "./chunk-BAJKAAOY.js";
+import "./chunk-NYX53SV4.js";
+import {
+  collectContextData,
+  formatContextUsageText
+} from "./chunk-AGR5UROZ.js";
 import {
   getCommandSubcommandNames
-} from "./chunk-VBF4KZRQ.js";
+} from "./chunk-IJKTMLBE.js";
 import {
   getEffectiveSupportedModes
-} from "./chunk-CDUN63IN.js";
-import "./chunk-2FN2HNTI.js";
+} from "./chunk-K2NQPH5D.js";
+import "./chunk-FDY5RMGH.js";
 import "./chunk-4WGODMVR.js";
 import "./chunk-3SH53ANB.js";
-import "./chunk-NYX53SV4.js";
 import {
   isGoalStatusKind
 } from "./chunk-EKTCKZV5.js";
-import "./chunk-R3T33BG5.js";
-import "./chunk-WEGXPP5E.js";
+import "./chunk-QP4C6WCE.js";
+import "./chunk-YAF2MQZ6.js";
+import "./chunk-QFCDF5PL.js";
 import {
   startNonInteractiveOpenAILogHousekeeping
-} from "./chunk-CZFQ62RM.js";
+} from "./chunk-JSHHYW6T.js";
 import "./chunk-KW7NOTN6.js";
+import "./chunk-C6K43ZDE.js";
+import "./chunk-6H67XLET.js";
 import {
   beginAcpBootstrapConfigProfiling,
   buildAndFreezeAcpStartupProfile,
   endAcpBootstrapConfigProfiling,
   markAcpStartup
 } from "./chunk-5JTIYALA.js";
-import "./chunk-FCSWZAS3.js";
-import "./chunk-TR7G7XFQ.js";
-import "./chunk-3WBMPR3S.js";
-import "./chunk-YAF2MQZ6.js";
+import "./chunk-A7YP63XN.js";
+import "./chunk-L6YT5H34.js";
+import "./chunk-CSMI4FP5.js";
 import {
   computeCpuPercent
 } from "./chunk-LBOVL47Y.js";
-import "./chunk-IOGKXPL3.js";
-import "./chunk-6H67XLET.js";
 import {
   GENERATION_MAX_PROMPT_BYTES,
   GENERATION_TIMEOUT_MS,
@@ -87,7 +87,6 @@ import {
   formatWorkspaceMemoryForgetSummary,
   isCompatibleLiveSessionSource,
   isValidServerName,
-  normalizeChannelDeliveryText,
   projectAcpToolResultUpdate,
   redactMcpServerSecrets,
   replayTranscriptRecordPage,
@@ -95,7 +94,7 @@ import {
   shouldSuppressRememberErrorDetails,
   workspaceMemoryFailureCode,
   workspaceMemoryFailureDiagnostics
-} from "./chunk-ALTQLFEG.js";
+} from "./chunk-4MQEPP3Y.js";
 import {
   BaseEmitter,
   HistoryReplayer,
@@ -106,48 +105,54 @@ import {
   hasFullSessionContext,
   observeAcpToolResultProjection,
   observeAcpToolResultWire
-} from "./chunk-J3CBIEDS.js";
-import "./chunk-4TPAG3O7.js";
+} from "./chunk-3SGB2UHX.js";
+import "./chunk-BFPESSTR.js";
 import "./chunk-E7REAOTN.js";
-import "./chunk-L436XFLJ.js";
+import "./chunk-XDLEZ5HX.js";
 import "./chunk-2MIN6GRR.js";
 import "./chunk-QHTIBUWB.js";
 import "./chunk-TXASDT2M.js";
 import {
-  buildToolWriteOriginMeta
-} from "./chunk-VGHZT6JR.js";
+  DAEMON_OWNED_STANDALONE_CREATION_KEY,
+  SESSION_SOURCE_META_KEY,
+  isReservedStandaloneSessionSourceType,
+  parseSessionSource
+} from "./chunk-2TNL5KPM.js";
+import {
+  buildToolWriteOriginMeta,
+  getConversationDirectoryName,
+  isSameConversationPath
+} from "./chunk-T3WXYEZ4.js";
+import "./chunk-UXEO7E3V.js";
+import "./chunk-RXFQM6FQ.js";
+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-7UJTY5V3.js";
+} from "./chunk-KEKZFOL6.js";
 import {
   MAX_AUDIO_BYTES,
   sanitizeVoiceErrorMessage,
   transcribeVoiceAudio
-} from "./chunk-76WGY6LW.js";
+} from "./chunk-JCQD3INC.js";
 import {
   readVoiceModel
-} from "./chunk-2MHGD7EE.js";
-import "./chunk-2SERYG4T.js";
-import "./chunk-JS73NNWF.js";
-import "./chunk-ATLGYSYH.js";
-import "./chunk-VOEMVOM4.js";
-import {
-  SESSION_SOURCE_META_KEY,
-  parseSessionSource
-} from "./chunk-AKQA3WCH.js";
+} from "./chunk-XRSOI3DL.js";
+import "./chunk-YTDVNSUQ.js";
+import "./chunk-RJC5EIKY.js";
+import "./chunk-6CGL7E7G.js";
+import "./chunk-ZGXYO7DY.js";
 import "./chunk-7U5G6JXI.js";
 import "./chunk-WCCLLK7X.js";
-import "./chunk-OCPBI7J5.js";
 import {
   REASONING_EFFORT_DEFAULT,
   REASONING_EFFORT_NAMES,
@@ -164,26 +169,26 @@ import {
   parseAcpModelOption,
   resolveAcpModelOption,
   sanitizeProviderBaseUrl
-} from "./chunk-HABT2Z7R.js";
+} from "./chunk-Q26AYA62.js";
 import {
   mapSkillConfigToStatus
 } from "./chunk-BGXZBI5B.js";
 import {
   resolveSkillSettings
 } from "./chunk-Z4X5MTRT.js";
-import "./chunk-F7M6ZFGU.js";
-import "./chunk-KQYW2GB5.js";
+import "./chunk-FBSSIAAQ.js";
+import "./chunk-PFCQ62V4.js";
 import "./chunk-57OAHC2Y.js";
-import "./chunk-5JCZ3UKB.js";
+import "./chunk-HVQ3B7FF.js";
 import "./chunk-7JPW6IYH.js";
-import "./chunk-IKN3IUJP.js";
+import "./chunk-5XBFCMWD.js";
 import "./chunk-V6WHFGST.js";
 import {
   createLoadedSettingsAdapter
-} from "./chunk-AWFZDYSD.js";
+} from "./chunk-CPGJJJLU.js";
 import {
   ndJsonStream
-} from "./chunk-VYWCFWI5.js";
+} from "./chunk-H72BQNM3.js";
 import {
   ACP_PREFLIGHT_KINDS,
   IDLE_HOOK_EVENTS,
@@ -191,7 +196,7 @@ import {
   SERVE_STATUS_EXT_METHODS,
   STATUS_SCHEMA_VERSION,
   mapDomainErrorToErrorKind
-} from "./chunk-XUX6O2ZT.js";
+} from "./chunk-JHS74YAB.js";
 import "./chunk-MZS7GEC7.js";
 import {
   ACTIVE_WORK_CLOSE_IF_UNHELD_PARAM,
@@ -232,15 +237,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-STUJ7IMZ.js";
 import "./chunk-JVPFTDBK.js";
-import "./chunk-GYTKQYDB.js";
 import "./chunk-ALMR3E6Q.js";
+import "./chunk-GYTKQYDB.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,7 +255,8 @@ 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
@@ -263,7 +269,7 @@ import {
 import {
   assembleMcpServers,
   loadMcpApprovals
-} from "./chunk-3JKUX4PB.js";
+} from "./chunk-5O72BNDD.js";
 import {
   getOutputLanguageFilePath,
   getPersistScopeForModelSelection,
@@ -272,9 +278,9 @@ import {
   resolveOutputLanguageOrPreserveAuto,
   updateOutputLanguageFile,
   writeOutputLanguageAndRegisterPath
-} from "./chunk-TDQBVEPK.js";
+} from "./chunk-F7TNAPZ4.js";
 import "./chunk-RKUWKYED.js";
-import "./chunk-KPF2K55D.js";
+import "./chunk-JSC3H3TD.js";
 import "./chunk-GOXKNSDZ.js";
 import {
   getSystemDefaultsPath,
@@ -283,7 +289,7 @@ import {
 import {
   getCurrentLanguage,
   setLanguageAsync
-} from "./chunk-W2WRNJKX.js";
+} from "./chunk-LDP5OD6N.js";
 import {
   SUPPORTED_LANGUAGES
 } from "./chunk-5EJZE3FP.js";
@@ -291,19 +297,19 @@ import {
   findEnvFiles,
   preResolveHomeEnvOverrides,
   reloadEnvironment
-} from "./chunk-R7G7GKOX.js";
+} from "./chunk-IK5BW3CS.js";
 import {
   ENV_ACP_REPEATED_TOOL_FAILURE_GUARD,
   QWEN_CODE_SERVE_ENV
 } from "./chunk-5PA6UEYA.js";
-import "./chunk-7DPKPBOQ.js";
-import "./chunk-H3HZ4AWW.js";
+import "./chunk-V2NDP3I4.js";
+import "./chunk-7UYV53BC.js";
 import "./chunk-W3N5XAZ6.js";
 import {
   isFolderTrustEnabled,
   isWorkspaceTrusted,
   loadTrustedFolders
-} from "./chunk-ZGWDHSUM.js";
+} from "./chunk-V4QXXQJ2.js";
 import "./chunk-NPQ5ZKRP.js";
 import "./chunk-MR3PXB6E.js";
 import {
@@ -333,30 +339,30 @@ import {
   resolveBaseUrl,
   runManagedRememberByAgent,
   subagentGenerator
-} from "./chunk-5URK47RN.js";
-import "./chunk-JSY43GMI.js";
+} from "./chunk-KUX5D6DK.js";
+import "./chunk-3DXFGHAJ.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-AP7WZONS.js";
-import "./chunk-JLGFGPZJ.js";
-import "./chunk-SKNVVYIJ.js";
+import "./chunk-6LFTG244.js";
+import "./chunk-PKAYJDB3.js";
+import "./chunk-6IUNAPLR.js";
 import {
   restoreWorktreeContext
-} from "./chunk-UCSV2IZW.js";
-import "./chunk-NEZZHGEI.js";
-import "./chunk-3FSBMAYD.js";
-import "./chunk-XJS54K4A.js";
+} from "./chunk-OIVXBW3W.js";
+import "./chunk-4CDSK5AZ.js";
+import "./chunk-XQFT3QUF.js";
+import "./chunk-VTHREBQM.js";
 import "./chunk-ZPJWUGCS.js";
 import {
   clearCachedCredentialFile,
   qwenOAuth2Events
-} from "./chunk-ZWKGZB2K.js";
-import "./chunk-J5352S3S.js";
+} from "./chunk-H2WDGQ6D.js";
+import "./chunk-MIIVI25Q.js";
 import {
   APPROVAL_MODE_INFO,
   BranchPointInvalidError,
@@ -473,43 +479,43 @@ import {
   updateSetting,
   validatePlanModeShellApproval,
   validatePlanModeShellContext
-} from "./chunk-XIRDDFRS.js";
+} from "./chunk-TGWAQ5RB.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-P2SU6ZTI.js";
+import "./chunk-IZIVM7LZ.js";
+import "./chunk-SFPGAQUL.js";
 import {
   parsePositiveIntegerEnv
 } from "./chunk-6PVPNMXU.js";
 import {
   RUNTIME_SNAPSHOT_PREFIX
-} from "./chunk-AYVIGUUK.js";
+} from "./chunk-JB4JIVTJ.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-EOGELB3H.js";
 import "./chunk-CPBF7KYF.js";
-import "./chunk-I6DY753S.js";
+import "./chunk-EFUM7RVY.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-43GGFFLY.js";
+import "./chunk-SMPR7SPO.js";
+import "./chunk-JWALNCLT.js";
+import "./chunk-NIFYWDYN.js";
+import "./chunk-3AFMQUTI.js";
 import {
   GoalConflictError,
   GoalInvalidTransitionError,
@@ -520,14 +526,14 @@ import {
   parseGoalSnapshotV2,
   parseGoalStateCause,
   wrapUserPromptSubmitContext
-} from "./chunk-FN5C6C7G.js";
+} from "./chunk-WKK5BQNP.js";
 import {
   APPROVAL_MODES
-} from "./chunk-XR7OIAQF.js";
+} from "./chunk-V5J4J5TP.js";
 import "./chunk-MLXTMF7H.js";
 import "./chunk-NAVJD2PQ.js";
-import "./chunk-FVDQ5E67.js";
-import "./chunk-V3GINY6K.js";
+import "./chunk-3JGZSIDA.js";
+import "./chunk-VVW4ZNFY.js";
 import "./chunk-QHMLYMMS.js";
 import {
   AgentOutputMessageCapture,
@@ -536,32 +542,32 @@ import {
   addToolCallResultAttributes,
   registerAcpEventLoopLagGauge,
   startEventLoopLagMonitor
-} from "./chunk-SDVF6A42.js";
+} from "./chunk-7DJCPZE3.js";
 import "./chunk-P3QQPMQA.js";
 import {
   addDaemonRequestAttribute,
   extractDaemonTraceContext,
   withDaemonSpan
-} from "./chunk-ILPXSKGQ.js";
+} from "./chunk-HVEYF6VT.js";
 import "./chunk-VNOVK4I7.js";
 import "./chunk-SAH4BD2J.js";
-import "./chunk-ZKAZP2ZG.js";
+import "./chunk-PDMJ3KGS.js";
 import {
   runWithRuntimeContentGenerator
-} from "./chunk-U45D46O5.js";
+} from "./chunk-CMHFCLBU.js";
 import "./chunk-S6LOFUVP.js";
 import {
   REASONING_EFFORT_TIERS,
   applyReasoningEffort
 } from "./chunk-2LD5U7Q3.js";
 import "./chunk-DJ2GSRLV.js";
-import "./chunk-I6VVOZDK.js";
+import "./chunk-J2OSJFP3.js";
 import "./chunk-K2OJUPOE.js";
 import {
   getToolCallPreparations
 } from "./chunk-CFKIH3D3.js";
-import "./chunk-EB4VDXNI.js";
-import "./chunk-FJWICLG7.js";
+import "./chunk-4FTKQNWJ.js";
+import "./chunk-Y3QL45LS.js";
 import {
   ConversationFinishedEvent,
   DiscoveredMCPTool,
@@ -592,35 +598,35 @@ import {
   shouldRunVisionBridge,
   splitImageParts,
   uiTelemetryService
-} from "./chunk-OF2DPXUS.js";
+} from "./chunk-L2M46FP5.js";
 import "./chunk-YRLW2MSX.js";
 import "./chunk-VGC4I5JJ.js";
 import {
   getAllGeminiMdFilenames,
   getSpecificMimeType
-} from "./chunk-WBT3STGU.js";
+} from "./chunk-3I6UTTDX.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-AA7VBRBG.js";
+} from "./chunk-Z7FLBQPR.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 +638,17 @@ import {
   startToolExecutionSpan,
   startToolSpan,
   withInteractionSpan
-} from "./chunk-6US7BF3G.js";
+} from "./chunk-L6BZRIUL.js";
 import "./chunk-74TONY4F.js";
-import "./chunk-VL4YX3FH.js";
+import "./chunk-XF63PKEN.js";
 import {
   FORK_SUBAGENT_TYPE,
   getStartupContextLength,
   isSystemReminderContent
-} from "./chunk-7OBH4AM2.js";
-import "./chunk-OT4YKUUV.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 +656,7 @@ import {
   ToolNames,
   canonicalToolName,
   isShellProgressData
-} from "./chunk-KOJ6MHD5.js";
+} from "./chunk-UTLCH2FK.js";
 import {
   Storage,
   createDebugLogger,
@@ -658,11 +664,11 @@ import {
   getErrorStatus,
   isSubpath,
   sessionIdContext
-} from "./chunk-2NNTE2ED.js";
-import "./chunk-66GIFJ63.js";
+} from "./chunk-UHQFIS7N.js";
+import "./chunk-W5MJJ2V7.js";
 import {
   runExitCleanup
-} from "./chunk-TFV4RXPU.js";
+} from "./chunk-Y6LSMB6J.js";
 import {
   writeStderrLine,
   writeStderrLineSafe
@@ -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,7 @@ var Session = class {
             controller: new AbortController(),
             origin: "runtime",
             continuationContext: input.continuationContext,
+            ...input.windDown ? { windDown: true } : {},
             ...input.verifierFeedback ? { verifierFeedback: input.verifierFeedback } : {},
             modelStarted: false
           });
@@ -4278,13 +4368,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();
@@ -4826,6 +4917,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 +5117,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 +5127,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 +5251,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 +5264,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 +5328,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 +5486,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 +6177,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 +6323,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 +6390,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 +6419,10 @@ var Session = class {
                 ];
               }
             }
+            if (isFreshUserTurn) {
+              managedMemoryRecallStarted = true;
+              this.config.getGeminiClient().beginManagedAutoMemoryRecall(promptText, pendingSend.signal);
+            }
             if (!continuesCurrentWorkChain && !this.todoStopGuard.enabled) {
               this.#resetTodoStopGuardBackgroundLineage();
             }
@@ -6190,6 +6448,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] })
@@ -6587,7 +6851,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 +6895,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 +6966,7 @@ ${this.pendingRecoveredAgentsNotice}
             }
           );
           if (continuation2.kind === "terminal") {
-            return { stopReason: continuation2.stopReason };
+            return continuation2;
           }
           continue;
         }
@@ -6758,7 +7051,7 @@ ${this.pendingRecoveredAgentsNotice}
               }
             );
             if (continuation2.kind === "terminal") {
-              return { stopReason: continuation2.stopReason };
+              return continuation2;
             }
             continue;
           }
@@ -6862,7 +7155,7 @@ ${this.pendingRecoveredAgentsNotice}
         stopHookReasons = stopHookReasons.slice(0, -1);
       }
       if (continuation.kind === "terminal") {
-        return { stopReason: continuation.stopReason };
+        return continuation;
       }
     }
   }
@@ -7317,6 +7610,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 +7623,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 +7929,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 = {
@@ -8062,15 +8372,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;
@@ -8146,6 +8459,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;
@@ -8158,6 +8472,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;
@@ -8751,6 +9066,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;
@@ -8764,6 +9080,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;
     }
@@ -9183,12 +9500,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,
@@ -9331,7 +9653,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,
@@ -9946,11 +10269,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 = [];
@@ -10231,6 +10549,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;
@@ -10270,7 +10600,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,
@@ -10688,7 +11019,8 @@ ${this.pendingRecoveredAgentsNotice}
               }
               const permissionOptions = toPermissionOptions(
                 confirmationDetails,
-                pmForcedAsk
+                pmForcedAsk,
+                this.requiresManagedConversationBinding ? STANDALONE_PERMISSION_PERSISTENCE_POLICY : void 0
               );
               const offeredPermissionOptions = permissionOptions.map(
                 (option) => ({ ...option })
@@ -10841,7 +11173,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,
@@ -11479,6 +11811,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 {
@@ -11551,6 +11886,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);
       }
@@ -13706,7 +14048,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");
@@ -15152,6 +15495,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;
@@ -16046,7 +16483,7 @@ var QwenAgent = class {
     }
     this.clientCapabilities = args.clientCapabilities;
     const authMethods = buildAuthMethods();
-    const version = "0.22.2-preview.1";
+    const version = "0.22.2";
     const response = {
       protocolVersion: PROTOCOL_VERSION,
       agentInfo: {
@@ -16183,6 +16620,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",
@@ -16208,14 +16654,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 () => {
@@ -16259,6 +16712,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");
@@ -16421,21 +16883,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 ?? {}
             ),
@@ -16581,7 +17059,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
@@ -16630,6 +17110,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);
@@ -16700,21 +17189,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 ?? {}
             ),
@@ -16738,7 +17243,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
@@ -18299,7 +18806,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,
@@ -18344,12 +18851,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] = {
@@ -18392,6 +18913,7 @@ var QwenAgent = class {
       durationMs: now - createdAt,
       promptCount: session.getTurnCount(),
       models,
+      sources,
       tools: {
         totalCalls: metrics.tools.totalCalls,
         totalSuccess: metrics.tools.totalSuccess,
@@ -20067,6 +20589,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();
@@ -20263,9 +20796,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"
@@ -20275,18 +20840,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") {
@@ -20311,13 +20892,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",
@@ -20329,7 +20919,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",
@@ -20337,7 +20932,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",
@@ -20348,13 +20949,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",
@@ -20371,6 +20978,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}`,
@@ -20404,7 +21014,7 @@ var QwenAgent = class {
         );
         try {
           const settledPreviousCwd = config.getTargetDir();
-          if (canonicalPath === settledPreviousCwd) {
+          if (canonicalPath === settledPreviousCwd && conversationDirectoryExpectation === void 0) {
             return {
               previousCwd: settledPreviousCwd,
               newCwd: canonicalPath,
@@ -20420,12 +21030,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)}`
@@ -20455,6 +21083,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"];
@@ -22178,6 +22841,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);
@@ -22239,6 +22905,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
@@ -22275,7 +22942,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: {
@@ -22354,8 +23022,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) {
@@ -22413,7 +23085,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();
@@ -22442,11 +23114,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();
@@ -22454,30 +23174,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();