@qwen-code/qwen-code 0.21.0 → 0.21.1-nightly.20260731.702932cc7

package/chunks/{acpAgent-6J2U72PQ.js → acpAgent-ERFA6HWV.js}

@@ -12,48 +12,47 @@ import {
   matchMcpServerByRef,
   parseExtensionRef,
   parseMcpServerRef
-} from "./chunk-VULLI6WQ.js";
+} from "./chunk-QIERF2GQ.js";
 import {
   getAvailableCommands,
   handleSlashCommand,
   insertAfterFunctionResponses,
   isSlashCommand,
   normalizePartList
-} from "./chunk-LB6DUZ26.js";
+} from "./chunk-BTWSGZCT.js";
 import {
   collectContextData,
   formatContextUsageText
-} from "./chunk-R5AFZNQW.js";
+} from "./chunk-VAVHTGU4.js";
 import {
   recomputeMcpGating
-} from "./chunk-OFDOK3VM.js";
+} from "./chunk-RX7NJOPE.js";
 import {
   appEvents,
   buildDisabledSkillNamesProvider,
+  cleanupReviewWorktreeLeases,
   loadCliConfig,
   normalizeDisabledToolList
-} from "./chunk-TPRQ7RZH.js";
+} from "./chunk-76E5Y3UZ.js";
 import {
   getCommandSubcommandNames
-} from "./chunk-RZIX2G32.js";
+} from "./chunk-THPORXSI.js";
 import {
   getEffectiveSupportedModes
-} from "./chunk-U7M2DMGW.js";
-import "./chunk-J56UI34H.js";
+} from "./chunk-M4MSAE7U.js";
 import "./chunk-4WGODMVR.js";
 import "./chunk-PQNHRFJC.js";
-import "./chunk-M4FMGVY4.js";
-import "./chunk-L5UHQJTJ.js";
-import "./chunk-GSN55ZRI.js";
-import "./chunk-6H67XLET.js";
+import "./chunk-NBD76HUW.js";
+import "./chunk-IGTHU3T4.js";
 import {
   beginAcpBootstrapConfigProfiling,
   buildAndFreezeAcpStartupProfile,
   endAcpBootstrapConfigProfiling,
   markAcpStartup
-} from "./chunk-HIJQF5B5.js";
-import "./chunk-7MVVZO4N.js";
-import "./chunk-IKYJHJNF.js";
+} from "./chunk-YGE3IXJP.js";
+import "./chunk-6ZRWX46I.js";
+import "./chunk-VOMQ2P6B.js";
+import "./chunk-WQP7BKWA.js";
 import "./chunk-YAF2MQZ6.js";
 import {
   GENERATION_MAX_PROMPT_BYTES,
@@ -74,7 +73,7 @@ import {
   shouldSuppressRememberErrorDetails,
   workspaceMemoryFailureCode,
   workspaceMemoryFailureDiagnostics
-} from "./chunk-RIBKPMRP.js";
+} from "./chunk-23F4XGWO.js";
 import {
   HistoryReplayer,
   MessageEmitter,
@@ -84,71 +83,57 @@ import {
   goalTerminalEventToHistoryItem,
   recordGoalStatusItem,
   restoreGoalFromHistory
-} from "./chunk-EBJQ6AXW.js";
-import "./chunk-RHLZR4E5.js";
-import "./chunk-IPUUTYMV.js";
-import "./chunk-WCXCRJYB.js";
+} from "./chunk-ANDVK2JN.js";
+import "./chunk-675H6PLP.js";
+import "./chunk-YDLJGZHL.js";
+import "./chunk-Z3YLHKB7.js";
 import "./chunk-2MIN6GRR.js";
 import "./chunk-QHTIBUWB.js";
 import {
   isTerminalGoalStatusKind
 } from "./chunk-QTERJVPZ.js";
 import "./chunk-3Z43GZUQ.js";
+import {
+  computeCpuPercent
+} from "./chunk-HGT6JR3U.js";
+import "./chunk-RXFQM6FQ.js";
+import "./chunk-ID3O7PRB.js";
+import "./chunk-6H67XLET.js";
+import {
+  mapSkillConfigToStatus
+} from "./chunk-L55JWS76.js";
 import {
   PERMISSION_RULE_TYPES,
   PermissionRulesValidationError,
   buildPermissionSettings,
   normalizePermissionRules,
   readPermissionRuleSet
-} from "./chunk-VRYUBFMC.js";
+} from "./chunk-GRUAVQQR.js";
 import {
   MAX_AUDIO_BYTES,
   sanitizeVoiceErrorMessage,
   transcribeVoiceAudio
-} from "./chunk-H4SBPHSA.js";
+} from "./chunk-NNL7WPPK.js";
 import {
   readVoiceModel
-} from "./chunk-YBL3QUDD.js";
-import "./chunk-ZD6UTE4A.js";
-import {
-  computeCpuPercent
-} from "./chunk-HGT6JR3U.js";
-import "./chunk-RXFQM6FQ.js";
-import "./chunk-PSOO6YXD.js";
-import "./chunk-PC6JANNU.js";
-import "./chunk-57OAHC2Y.js";
+} from "./chunk-NQCXWP5D.js";
+import "./chunk-CNTR4GR6.js";
 import {
   createLoadedSettingsAdapter
-} from "./chunk-IO3IX5Q4.js";
-import "./chunk-LXXMOYPL.js";
-import "./chunk-MVSUYZDT.js";
+} from "./chunk-4YJQD2IO.js";
+import "./chunk-VXZBKKQR.js";
+import "./chunk-GWV7DI3S.js";
 import "./chunk-E5Z2AVNV.js";
 import {
+  SESSION_SOURCE_META_KEY,
   parseSessionSource
-} from "./chunk-KIM5GUMA.js";
+} from "./chunk-OE6F6ZWQ.js";
 import "./chunk-GLWP3FDB.js";
-import {
-  NOT_CURRENTLY_GENERATING_CANCEL_MESSAGE,
-  isNotCurrentlyGeneratingCancelError
-} from "./chunk-UH3WSE5L.js";
-import "./chunk-COH43MRJ.js";
-import {
-  CHANNEL_STARTUP_PROFILE_META_KEY,
-  CHANNEL_STARTUP_PROFILE_VERSION,
-  CLIENT_MCP_OVER_WS_CONFIG_FLAG,
-  DAEMON_CHANNEL_DELIVERY_META_KEY,
-  LOAD_REPLAY_BULK_MODE,
-  LOAD_REPLAY_META_KEY,
-  LOAD_REPLAY_MODE_META_KEY,
-  LOAD_REPLAY_PAGE_SIZE_META_KEY,
-  LOAD_REPLAY_VERSION,
-  MID_TURN_QUEUE_DRAIN_METHOD,
-  PROMPT_CANCEL_METHOD,
-  TODO_STOP_GUARD_QUEUE_RELEASE_METHOD
-} from "./chunk-3SJ43L4W.js";
+import "./chunk-XCGIMOLN.js";
+import "./chunk-OCPBI7J5.js";
 import {
   ndJsonStream
-} from "./chunk-7JURR4JT.js";
+} from "./chunk-2OQUICDM.js";
 import {
   ACP_ROUTE_ID_PREFIX,
   buildAcpModelOptions,
@@ -157,10 +142,7 @@ import {
   parseAcpModelOption,
   resolveAcpModelOption,
   sanitizeProviderBaseUrl
-} from "./chunk-KMQ33DO4.js";
-import {
-  mapSkillConfigToStatus
-} from "./chunk-2W3OOD4W.js";
+} from "./chunk-EDB7A72S.js";
 import {
   ACP_PREFLIGHT_KINDS,
   IDLE_HOOK_EVENTS,
@@ -168,28 +150,57 @@ import {
   SERVE_STATUS_EXT_METHODS,
   STATUS_SCHEMA_VERSION,
   mapDomainErrorToErrorKind
-} from "./chunk-VIA5XA4U.js";
-import "./chunk-X5XDDSSH.js";
-import "./chunk-4WIZGAH3.js";
-import "./chunk-7ZCNENPP.js";
+} from "./chunk-A5UODYG3.js";
+import {
+  resolveSkillSettings
+} from "./chunk-Z4X5MTRT.js";
+import "./chunk-6NUWQ3R7.js";
+import "./chunk-HKRVXYDN.js";
+import "./chunk-57OAHC2Y.js";
+import "./chunk-I5BT7ADR.js";
+import "./chunk-FANRZEAJ.js";
+import "./chunk-KWHKHSIS.js";
 import "./chunk-V6WHFGST.js";
 import {
-  assembleMcpServers,
-  loadMcpApprovals
-} from "./chunk-JVPM2ULZ.js";
-import "./chunk-ZNAUOR2I.js";
+  CHANNEL_STARTUP_PROFILE_META_KEY,
+  CHANNEL_STARTUP_PROFILE_VERSION,
+  CLIENT_MCP_OVER_WS_CONFIG_FLAG,
+  DAEMON_CHANNEL_DELIVERY_META_KEY,
+  LOAD_REPLAY_BULK_MODE,
+  LOAD_REPLAY_HIDE_INHERITED_META_KEY,
+  LOAD_REPLAY_META_KEY,
+  LOAD_REPLAY_MODE_META_KEY,
+  LOAD_REPLAY_PAGE_SIZE_META_KEY,
+  LOAD_REPLAY_VERSION,
+  MID_TURN_QUEUE_DRAIN_METHOD,
+  PROMPT_CANCEL_METHOD,
+  TODO_STOP_GUARD_CONTINUATION_CLAIM_METHOD,
+  TODO_STOP_GUARD_QUEUE_RELEASE_METHOD,
+  WORKTREE_MCP_DEFER_META_KEY
+} from "./chunk-CPZAH673.js";
+import {
+  NOT_CURRENTLY_GENERATING_CANCEL_MESSAGE,
+  isNotCurrentlyGeneratingCancelError
+} from "./chunk-B4AJNNOL.js";
 import "./chunk-2RFKHEXL.js";
-import "./chunk-LK7CHLVP.js";
-import "./chunk-JLU636DO.js";
+import "./chunk-FYJ7W2PI.js";
+import "./chunk-U4VTUMMK.js";
+import "./chunk-6MPDY6ZG.js";
+import "./chunk-ALMR3E6Q.js";
 import "./chunk-BK2UNYWD.js";
 import "./chunk-M5GB774H.js";
-import "./chunk-RWTEFFPU.js";
+import "./chunk-IIUGIWWY.js";
+import "./chunk-ZPZ7ZJEE.js";
+import "./chunk-JCJ7LKNA.js";
 import {
   AgentSideConnection,
   PROTOCOL_VERSION,
   RequestError
 } from "./chunk-UDXSXLER.js";
-import "./chunk-BIQWWWJN.js";
+import {
+  assembleMcpServers,
+  loadMcpApprovals
+} from "./chunk-3XZ5SSNR.js";
 import {
   getOutputLanguageFilePath,
   getPersistScopeForModelSelection,
@@ -198,7 +209,7 @@ import {
   resolveOutputLanguageOrPreserveAuto,
   updateOutputLanguageFile,
   writeOutputLanguageAndRegisterPath
-} from "./chunk-TEHGS6UP.js";
+} from "./chunk-A5T5W7PR.js";
 import "./chunk-RKUWKYED.js";
 import "./chunk-GOXKNSDZ.js";
 import {
@@ -209,27 +220,28 @@ import {
   SUPPORTED_LANGUAGES,
   getCurrentLanguage,
   setLanguageAsync
-} from "./chunk-LKEJ26GS.js";
+} from "./chunk-B3TA3IF5.js";
 import {
   findEnvFiles,
   preResolveHomeEnvOverrides,
   reloadEnvironment
-} from "./chunk-LH2BYDQ5.js";
+} from "./chunk-X2E5TFJ5.js";
 import "./chunk-6PEXNQTX.js";
-import "./chunk-YX324OPW.js";
-import "./chunk-VJNBRRZG.js";
+import "./chunk-BZBPT52P.js";
 import {
   isFolderTrustEnabled,
   isWorkspaceTrusted,
   loadTrustedFolders
-} from "./chunk-Z2BC6UJ5.js";
+} from "./chunk-UU2B5YG6.js";
 import "./chunk-ALGGS7UH.js";
 import "./chunk-MR3PXB6E.js";
+import "./chunk-XFSFZCM5.js";
+import "./chunk-XDS22O52.js";
+import "./chunk-VJNBRRZG.js";
 import {
   writeStderrLine,
   writeStderrLineSafe
 } from "./chunk-OWAK7LMW.js";
-import "./chunk-XFSFZCM5.js";
 import {
   ALL_PROVIDERS,
   APPROVAL_MODE_INFO,
@@ -269,6 +281,7 @@ import {
   applyAutoModeDecision,
   applyProviderInstallPlan,
   approxBase64Bytes,
+  bridgeToolResultImages,
   buildBackgroundEntryLabel,
   buildBtwCacheSafeParams,
   buildBtwPrompt,
@@ -351,69 +364,80 @@ import {
   unregisterGoalHook,
   updateSetting,
   validatePlanModeShellApproval,
-  validatePlanModeShellContext
-} from "./chunk-PHOF65IG.js";
+  validatePlanModeShellContext,
+  wrapUserPromptSubmitContext
+} from "./chunk-FRXG4ARO.js";
 import "./chunk-5M6IDOMF.js";
 import "./chunk-TWPJO254.js";
 import {
   external_exports
 } from "./chunk-H6XPXXMH.js";
-import "./chunk-K4XWPEWB.js";
-import "./chunk-TOFQCPDC.js";
-import "./chunk-IRH27ZC2.js";
-import "./chunk-VDDGDZMA.js";
-import "./chunk-FNQ6T3CV.js";
-import "./chunk-ZOIFNCKL.js";
-import "./chunk-PWTZEM3C.js";
+import "./chunk-AOHY3QJ3.js";
+import "./chunk-5NNHICSA.js";
+import "./chunk-SHN4KHDK.js";
+import "./chunk-JXVC2PL3.js";
 import "./chunk-KRXPRVGL.js";
 import {
   parsePositiveIntegerEnv
 } from "./chunk-6PVPNMXU.js";
-import "./chunk-MZAXJAUM.js";
-import "./chunk-SZRN75WQ.js";
-import "./chunk-HTO4JFDZ.js";
+import "./chunk-26JK4RPD.js";
+import "./chunk-IRH27ZC2.js";
+import "./chunk-QHWCP53L.js";
+import "./chunk-TEGJSJDF.js";
+import "./chunk-TIRRPCFS.js";
+import {
+  promptIdContext,
+  todoWorkChainContext
+} from "./chunk-O6GEWCJA.js";
+import "./chunk-T26EAKDL.js";
 import "./chunk-CPBF7KYF.js";
+import "./chunk-4KP2F2TE.js";
+import {
+  HookEventName,
+  createHookOutput
+} from "./chunk-3APUUXRF.js";
+import "./chunk-THVU3RNH.js";
+import "./chunk-LHKCY7DY.js";
+import "./chunk-6FMJLI5M.js";
 import {
   APPROVAL_MODES,
   FORK_SUBAGENT_TYPE,
   getStartupContextLength,
   isSystemReminderContent,
   runWithRuntimeContentGenerator
-} from "./chunk-L26JL52R.js";
-import "./chunk-6AM5D4ME.js";
-import "./chunk-JZA3JUDJ.js";
-import {
-  HookEventName,
-  createHookOutput
-} from "./chunk-3QMGYBFN.js";
-import "./chunk-JCW2R7WC.js";
-import "./chunk-M5JM7OSF.js";
-import "./chunk-OHNBB4XR.js";
-import "./chunk-E5TUC6CA.js";
+} from "./chunk-CBBP4BMC.js";
+import "./chunk-S6LOFUVP.js";
+import "./chunk-K623ENWT.js";
+import "./chunk-AQ37AY7B.js";
+import "./chunk-N4ACHWNH.js";
+import "./chunk-ZPJWUGCS.js";
 import {
   clearCachedCredentialFile,
   qwenOAuth2Events
-} from "./chunk-EPDRMGT4.js";
-import "./chunk-JESCGQM3.js";
-import "./chunk-NH6KE4JX.js";
-import "./chunk-USTWD7QV.js";
-import "./chunk-XVNQMZ2I.js";
-import "./chunk-FODK6UMO.js";
+} from "./chunk-D4HTUMGX.js";
+import "./chunk-NAVJD2PQ.js";
+import "./chunk-LOY7RWQG.js";
+import "./chunk-E6CJ2SMM.js";
+import "./chunk-DGEIYUC3.js";
+import "./chunk-MPHPFVKK.js";
 import "./chunk-GLNBDYUX.js";
 import "./chunk-DJ2GSRLV.js";
-import "./chunk-ZJHVAS7M.js";
+import "./chunk-2YCYFWYZ.js";
 import {
+  addToolArgumentsAttributes,
+  addToolCallResultAttributes,
   extractDaemonTraceContext,
   registerAcpEventLoopLagGauge,
   startEventLoopLagMonitor,
   withDaemonSpan
-} from "./chunk-NIBLUX3Y.js";
-import "./chunk-BPJSQIJX.js";
+} from "./chunk-Z3S5EMOW.js";
+import "./chunk-2J3OJGTL.js";
 import "./chunk-P3QQPMQA.js";
-import "./chunk-6FGBXPWM.js";
+import "./chunk-XQK4XXTN.js";
 import {
   getToolCallPreparations
-} from "./chunk-LS77BEZP.js";
+} from "./chunk-GLCZKT5V.js";
+import "./chunk-QDK4F2N5.js";
 import {
   ConversationFinishedEvent,
   DiscoveredMCPTool,
@@ -427,6 +451,7 @@ import {
   formatVisionBridgeNotice,
   getAllGeminiMdFilenames,
   getFullTurnVisionModelSelector,
+  getInvocationContext,
   getMCPServerStatus,
   getSpecificMimeType,
   hasImageParts,
@@ -443,25 +468,30 @@ import {
   shouldRunVisionBridge,
   splitImageParts,
   uiTelemetryService
-} from "./chunk-CIKQ7KKO.js";
+} from "./chunk-NVFSGPIF.js";
 import "./chunk-VGC4I5JJ.js";
 import {
   getAutoMemoryRoot,
   getUserAutoMemoryRoot
-} from "./chunk-MUP3T3AD.js";
+} from "./chunk-3I6DUGQD.js";
+import "./chunk-7ULQIS27.js";
 import {
-  AuthType
-} from "./chunk-IKCX4CCL.js";
+  ToolConfirmationOutcome,
+  ToolNames,
+  isShellProgressData
+} from "./chunk-MM7TH7ZM.js";
+import {
+  AuthType,
+  preloadContentGenerator
+} from "./chunk-DKPJUF5F.js";
 import "./chunk-46UV252V.js";
-import "./chunk-A4UCTEB5.js";
-import "./chunk-XWRJCPHC.js";
 import {
   DEFAULT_TOKEN_LIMIT,
   tokenLimit
-} from "./chunk-UW5EOVUN.js";
-import "./chunk-2JZBVYTU.js";
-import "./chunk-5I2IWRSH.js";
-import "./chunk-A5L3JMUA.js";
+} from "./chunk-ZBVS26BY.js";
+import "./chunk-Q3T5KA2V.js";
+import "./chunk-R2XWGR75.js";
+import "./chunk-HC45LTEN.js";
 import {
   endToolExecutionSpan,
   endToolSpan,
@@ -470,32 +500,26 @@ import {
   startToolExecutionSpan,
   startToolSpan,
   withInteractionSpan
-} from "./chunk-MB4MZHMJ.js";
-import "./chunk-HTR4WV6U.js";
-import "./chunk-BULDBTYC.js";
-import "./chunk-U7ZFW55U.js";
-import "./chunk-UUUTRMI2.js";
-import {
-  ToolConfirmationOutcome,
-  ToolNames,
-  isShellProgressData
-} from "./chunk-PR75REBZ.js";
+} from "./chunk-QARJNL2V.js";
+import "./chunk-W4RQUHY3.js";
+import "./chunk-G7XXKQYS.js";
 import {
   Storage,
   createDebugLogger,
   getErrorMessage,
   getErrorStatus,
   isSubpath
-} from "./chunk-NL7LTRLR.js";
-import "./chunk-QAF7NMK7.js";
+} from "./chunk-E2BHWIDT.js";
+import "./chunk-VOQXFAY5.js";
+import "./chunk-D7CQTWRS.js";
 import {
   runExitCleanup
-} from "./chunk-PWVFN2LF.js";
+} from "./chunk-BP2H5K25.js";
 import "./chunk-75DOP5OR.js";
 import "./chunk-DMTGGOSA.js";
 import "./chunk-YQ3U5MUC.js";
 import "./chunk-AMDSOFFV.js";
-import "./chunk-TARRHLLG.js";
+import "./chunk-QUGAUQGJ.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -1949,6 +1973,7 @@ var DaemonTodoStopGuard = class {
 // packages/cli/src/acp-integration/session/Session.ts
 var debugLogger6 = createDebugLogger("SESSION");
 var USER_CANCEL_ABORT_REASON = "qwen:user-cancel";
+var SESSION_DISPOSE_ABORT_REASON = "qwen:session-dispose";
 var DAEMON_RETRY_META_KEY = "qwen.daemon.retry";
 var DAEMON_CONTINUE_META_KEY = "qwen.daemon.continueLastTurn";
 var TODO_STOP_GUARD_PROMPT_PREFIX = "[Todo Stop Guard] ";
@@ -2220,6 +2245,20 @@ function parseMidTurnDrainResponse(response) {
   ).map((message) => ({ kind: "text", message }));
 }
 __name(parseMidTurnDrainResponse, "parseMidTurnDrainResponse");
+function isValidMidTurnDrainResponse(response, requireQueuedPromptState) {
+  if (!isRecord2(response) || requireQueuedPromptState && typeof response["hasQueuedPrompt"] !== "boolean") {
+    return false;
+  }
+  if (Array.isArray(response["items"])) {
+    return response["items"].every(
+      (item) => isRecord2(item) && Array.isArray(item["content"]) && item["content"].length > 0 && item["content"].every(isContentBlock)
+    );
+  }
+  return Array.isArray(response["messages"]) && response["messages"].every(
+    (message) => typeof message === "string" && message.trim().length > 0
+  );
+}
+__name(isValidMidTurnDrainResponse, "isValidMidTurnDrainResponse");
 var MidTurnDrainTimeoutError = class extends Error {
   static {
     __name(this, "MidTurnDrainTimeoutError");
@@ -2230,6 +2269,16 @@ var MidTurnDrainTimeoutError = class extends Error {
     );
   }
 };
+var TodoStopGuardClaimTimeoutError = class extends Error {
+  static {
+    __name(this, "TodoStopGuardClaimTimeoutError");
+  }
+  constructor() {
+    super(
+      `Todo Stop Guard continuation claim got no response within ${MID_TURN_QUEUE_DRAIN_TIMEOUT_MS}ms`
+    );
+  }
+};
 function beginChannelDeliveryResponseBlock(capture) {
   if (!capture) return void 0;
   capture.finalText = "";
@@ -2486,12 +2535,7 @@ var Session = class {
     this.runtimeBaseDir = config.storage.getRuntimeBaseDir();
     const todoStopGuardEnabled = this.settings.merged.experimental?.todoStopGuard === true && !this.config.getBareMode() && !this.config.isSafeMode();
     this.todoStopGuard = new DaemonTodoStopGuard(todoStopGuardEnabled);
-    this.todoStopGuardBackgroundBaseline = todoStopGuardEnabled ? this.#captureTodoStopGuardBackgroundBaseline() : {
-      agents: /* @__PURE__ */ new Set(),
-      shells: /* @__PURE__ */ new Set(),
-      monitors: /* @__PURE__ */ new Set(),
-      wakeups: /* @__PURE__ */ new Set()
-    };
+    this.todoStopGuardBackgroundBaseline = this.#captureTodoStopGuardBackgroundBaseline();
     this.toolCallEmitter = new ToolCallEmitter(this);
     this.planEmitter = new PlanEmitter(this);
     this.historyReplayer = new HistoryReplayer(this, {
@@ -2523,6 +2567,7 @@ var Session = class {
    */
   followupAbort = null;
   turn = 0;
+  activeTodoWorkChainPromptId;
   createdAt = Date.now();
   /**
    * Running cumulative usage for this session, snapshotted onto each todo/plan
@@ -2563,7 +2608,12 @@ var Session = class {
   midTurnRecoveredMessages = [];
   todoStopGuard;
   todoStopGuardBackgroundBaseline;
+  relatedAgentIds = /* @__PURE__ */ new Set();
+  provisionalRelatedAgentCounts = /* @__PURE__ */ new Map();
   todoStopGuardQueuedPromptPriority = false;
+  todoStopGuardQueuedPromptOwnerPromptId;
+  todoStopGuardClaimOwnerCounts = /* @__PURE__ */ new Map();
+  todoStopGuardReleasedDuringClaim = /* @__PURE__ */ new Set();
   todoStopGuardDrainAutomaticQueuesWhenIdle = false;
   // Background notification drain state. ACP does not have the TUI's idle
   // hook, so the session serializes registry callbacks through this queue.
@@ -2615,7 +2665,7 @@ var Session = class {
     }
     const drainSupersededAutomaticQueues = this.todoStopGuard.blocksUnrelatedAutomaticTurns || this.todoStopGuard.hasCommittedContinuation || this.todoStopGuardQueuedPromptPriority;
     if (this.config.getApprovalMode() === "plan" /* PLAN */) {
-      this.todoStopGuardQueuedPromptPriority = false;
+      this.#clearTodoStopGuardQueuedPromptWait();
       this.todoStopGuard.blockUntilOrdinaryPromptStarts();
       return {
         startsWorkChain: false,
@@ -2626,7 +2676,7 @@ var Session = class {
     const isRetry = params.retry === true || metadata?.[DAEMON_RETRY_META_KEY] === true;
     const isContinue = metadata?.[DAEMON_CONTINUE_META_KEY] === true;
     if (isRetry || isContinue) {
-      this.todoStopGuardQueuedPromptPriority = false;
+      this.#clearTodoStopGuardQueuedPromptWait();
       if (this.todoStopGuard.hasTrustedUnfinishedState) {
         this.todoStopGuard.resumeTrustedPrompt();
         return {
@@ -2640,7 +2690,7 @@ var Session = class {
         drainSupersededAutomaticQueues
       };
     }
-    this.todoStopGuardQueuedPromptPriority = false;
+    this.#clearTodoStopGuardQueuedPromptWait();
     this.todoStopGuard.blockUntilOrdinaryPromptStarts();
     return {
       startsWorkChain: true,
@@ -2653,7 +2703,7 @@ var Session = class {
       this.todoStopGuard.blockUntilOrdinaryPromptStarts();
       return;
     }
-    if (continuesCurrentWorkChain && this.todoStopGuard.isHardSuspended) {
+    if (this.todoStopGuard.isHardSuspended) {
       return;
     }
     if (continuesCurrentWorkChain && this.todoStopGuard.hasTrustedUnfinishedState) {
@@ -2661,7 +2711,7 @@ var Session = class {
       return;
     }
     this.todoStopGuard.clearTrust();
-    this.todoStopGuardBackgroundBaseline = this.#captureTodoStopGuardBackgroundBaseline();
+    this.#resetTodoStopGuardBackgroundLineage();
   }
   #clearTodoStopGuardTrustAndDrainAutomaticQueues() {
     const preserveQueuedPromptPriority = this.todoStopGuardQueuedPromptPriority;
@@ -2675,35 +2725,116 @@ var Session = class {
     void this.#drainCronQueue();
     void this.#drainNotificationQueue();
   }
-  releaseTodoStopGuardQueuedPromptWait() {
-    if (!this.todoStopGuardQueuedPromptPriority) return false;
-    this.todoStopGuardQueuedPromptPriority = false;
+  releaseTodoStopGuardQueuedPromptWait(promptId) {
+    const matchesCurrentWait = this.todoStopGuardQueuedPromptPriority && this.todoStopGuardQueuedPromptOwnerPromptId === promptId;
+    if (!matchesCurrentWait) {
+      if ((this.todoStopGuardClaimOwnerCounts.get(promptId) ?? 0) === 0) {
+        return false;
+      }
+      this.todoStopGuardReleasedDuringClaim.add(promptId);
+      if (!this.todoStopGuardQueuedPromptPriority) {
+        this.#finishTodoStopGuardQueuedPromptRelease();
+      }
+      return true;
+    }
+    this.#clearTodoStopGuardQueuedPromptWait(promptId);
+    this.#finishTodoStopGuardQueuedPromptRelease();
+    return true;
+  }
+  #finishTodoStopGuardQueuedPromptRelease() {
     this.todoStopGuard.blockUntilOrdinaryPromptStarts();
     if (this.pendingPrompt) {
       this.todoStopGuardDrainAutomaticQueuesWhenIdle = true;
-      return true;
+      return;
     }
     void this.#drainCronQueue();
     void this.#drainNotificationQueue();
-    return true;
   }
   clearTodoStopGuardTrust() {
     this.#clearTodoStopGuardTrustAndDrainAutomaticQueues();
   }
-  #beginTodoStopGuardQueuedPromptCheck() {
-    this.todoStopGuardQueuedPromptPriority = this.todoStopGuard.awaitQueuedPrompt();
+  hardSuspendTodoStopGuard() {
+    this.#clearTodoStopGuardQueuedPromptWait();
+    this.todoStopGuardDrainAutomaticQueuesWhenIdle = false;
+    this.todoStopGuard.blockUntilOrdinaryPromptStarts();
   }
-  #finishTodoStopGuardQueuedPromptCheck(hasQueuedPrompt) {
-    const shouldWait = hasQueuedPrompt && this.todoStopGuardQueuedPromptPriority;
-    this.todoStopGuardQueuedPromptPriority = shouldWait;
-    if (!shouldWait) this.todoStopGuard.resumeTrustedPrompt();
-    return shouldWait;
+  #clearTodoStopGuardQueuedPromptWait(expectedOwner) {
+    if (expectedOwner !== void 0 && this.todoStopGuardQueuedPromptOwnerPromptId !== expectedOwner) {
+      return;
+    }
+    this.todoStopGuardQueuedPromptPriority = false;
+    this.todoStopGuardQueuedPromptOwnerPromptId = void 0;
+  }
+  #awaitTodoStopGuardQueuedPrompt(promptId) {
+    this.todoStopGuard.awaitQueuedPrompt();
+    this.todoStopGuardQueuedPromptPriority = true;
+    this.todoStopGuardQueuedPromptOwnerPromptId = promptId;
+  }
+  async #claimTodoStopGuardContinuation(abortSignal) {
+    const context = getInvocationContext();
+    const ownerPromptId = context?.sessionId === this.sessionId ? context.promptId : void 0;
+    if (ownerPromptId) {
+      this.todoStopGuardClaimOwnerCounts.set(
+        ownerPromptId,
+        (this.todoStopGuardClaimOwnerCounts.get(ownerPromptId) ?? 0) + 1
+      );
+    }
+    let timeoutHandle;
+    try {
+      const claimPromise = this.client.extMethod(
+        TODO_STOP_GUARD_CONTINUATION_CLAIM_METHOD,
+        {
+          sessionId: this.sessionId,
+          ...ownerPromptId ? { promptId: ownerPromptId } : {}
+        }
+      );
+      const timeoutPromise = new Promise((_, reject) => {
+        timeoutHandle = setTimeout(
+          () => reject(new TodoStopGuardClaimTimeoutError()),
+          MID_TURN_QUEUE_DRAIN_TIMEOUT_MS
+        );
+      });
+      const response = await Promise.race([claimPromise, timeoutPromise]);
+      if (abortSignal.aborted || !isRecord2(response)) {
+        return "unavailable";
+      }
+      if (ownerPromptId && response["claimed"] === false && response["hasQueuedPrompt"] === true) {
+        if (this.closing || this.disposed) return "unavailable";
+        if (this.todoStopGuardReleasedDuringClaim.has(ownerPromptId)) {
+          return "unavailable";
+        }
+        this.#awaitTodoStopGuardQueuedPrompt(ownerPromptId);
+        return "queued";
+      }
+      if (this.todoStopGuard.isHardSuspended) return "unavailable";
+      if (response["claimed"] === true && response["hasQueuedPrompt"] === false) {
+        if (ownerPromptId) {
+          this.#clearTodoStopGuardQueuedPromptWait(ownerPromptId);
+        }
+        this.todoStopGuard.resumeTrustedPrompt();
+        return "claimed";
+      }
+      return "unavailable";
+    } catch (error) {
+      debugLogger6.warn(
+        `Todo Stop Guard continuation claim unavailable [session ${this.sessionId}]: ${this.#formatError(error)}`
+      );
+      return "unavailable";
+    } finally {
+      clearTimeout(timeoutHandle);
+      if (ownerPromptId) {
+        const remaining = (this.todoStopGuardClaimOwnerCounts.get(ownerPromptId) ?? 1) - 1;
+        if (remaining > 0) {
+          this.todoStopGuardClaimOwnerCounts.set(ownerPromptId, remaining);
+        } else {
+          this.todoStopGuardClaimOwnerCounts.delete(ownerPromptId);
+          this.todoStopGuardReleasedDuringClaim.delete(ownerPromptId);
+        }
+      }
+    }
   }
   #notificationContinuesTodoStopGuardWorkChain(item) {
-    const baseline = this.todoStopGuardBackgroundBaseline;
-    if (item.kind === "agent") return !baseline.agents.has(item.taskId);
-    if (item.kind === "shell") return !baseline.shells.has(item.taskId);
-    return !baseline.monitors.has(item.taskId);
+    return item.continuesTodoStopGuardWorkChain;
   }
   #cronContinuesTodoStopGuardWorkChain(item) {
     return item.source === "loop" && item.taskId !== void 0 && !this.todoStopGuardBackgroundBaseline.wakeups.has(item.taskId);
@@ -2736,6 +2867,37 @@ var Session = class {
       ])
     };
   }
+  #resetTodoStopGuardBackgroundLineage() {
+    this.relatedAgentIds.clear();
+    this.provisionalRelatedAgentCounts.clear();
+    this.todoStopGuardBackgroundBaseline = this.#captureTodoStopGuardBackgroundBaseline();
+    for (const item of this.notificationQueue) {
+      item.continuesTodoStopGuardWorkChain = false;
+    }
+  }
+  #agentContinuesTodoStopGuardWorkChain(taskId, visiting = /* @__PURE__ */ new Set()) {
+    if (this.relatedAgentIds.has(taskId) || (this.provisionalRelatedAgentCounts.get(taskId) ?? 0) > 0) {
+      return true;
+    }
+    if (this.todoStopGuardBackgroundBaseline.agents.has(taskId)) return false;
+    if (visiting.has(taskId)) return false;
+    const task = this.config.getBackgroundTaskRegistry?.()?.get?.(taskId);
+    if (!task) return false;
+    if (!task.parentAgentId) return true;
+    visiting.add(taskId);
+    const related = this.#agentContinuesTodoStopGuardWorkChain(
+      task.parentAgentId,
+      visiting
+    );
+    visiting.delete(taskId);
+    return related;
+  }
+  #monitorContinuesTodoStopGuardWorkChain(monitorId, ownerAgentId) {
+    if (ownerAgentId) {
+      return this.#agentContinuesTodoStopGuardWorkChain(ownerAgentId);
+    }
+    return !this.todoStopGuardBackgroundBaseline.monitors.has(monitorId);
+  }
   #hasRelevantTodoStopGuardBackgroundInput() {
     if (this.notificationQueue.some(
       (item) => this.#notificationContinuesTodoStopGuardWorkChain(item)
@@ -2747,7 +2909,7 @@ var Session = class {
     const baseline = this.todoStopGuardBackgroundBaseline;
     const agents = this.config.getBackgroundTaskRegistry?.()?.getAll?.() ?? [];
     if (agents.some(
-      (task) => !baseline.agents.has(task.id) && task.isBackgrounded && (task.status === "running" || task.status === "paused" || task.status === "cancelled" && !task.notified)
+      (task) => this.#agentContinuesTodoStopGuardWorkChain(task.id) && task.isBackgrounded && (task.status === "running" || task.status === "paused" || task.status === "cancelled" && !task.notified)
     )) {
       return true;
     }
@@ -2759,7 +2921,10 @@ var Session = class {
     }
     const monitors = this.config.getMonitorRegistry?.()?.getAll?.() ?? [];
     if (monitors.some(
-      (task) => !baseline.monitors.has(task.id) && task.status === "running"
+      (task) => this.#monitorContinuesTodoStopGuardWorkChain(
+        task.id,
+        task.ownerAgentId
+      ) && task.status === "running"
     )) {
       return true;
     }
@@ -2890,12 +3055,19 @@ var Session = class {
     return this.closeGateCompletion ?? Promise.resolve();
   }
   async waitForActiveTurnsToSettle() {
-    const pending = [
-      this.pendingPromptCompletion,
-      this.cronCompletion,
-      this.notificationCompletion
-    ].filter((completion) => completion !== null);
-    await Promise.allSettled(pending);
+    while (this.#hasActiveTurn()) {
+      const pending = [
+        this.pendingPromptCompletion,
+        this.cronCompletion,
+        this.notificationCompletion
+      ].filter(
+        (completion) => completion !== null
+      );
+      if (pending.length > 0) {
+        await Promise.allSettled(pending);
+      }
+      await new Promise((resolve5) => setImmediate(resolve5));
+    }
   }
   #deferAutomaticQueueDrainUntilTurnsSettle() {
     const completions = [
@@ -2924,12 +3096,12 @@ var Session = class {
   dispose() {
     this.disposed = true;
     this.closing = true;
+    this.pendingPrompt?.abort(SESSION_DISPOSE_ABORT_REASON);
+    this.pendingPrompt = null;
     this.resolveCloseGate?.();
     this.resolveCloseGate = null;
     this.closeGateCompletion = null;
-    this.todoStopGuardQueuedPromptPriority = false;
-    this.todoStopGuardDrainAutomaticQueuesWhenIdle = false;
-    this.todoStopGuard.clearTrust();
+    this.hardSuspendTodoStopGuard();
     this.notificationQueue = [];
     this.cronQueue = [];
     this.notificationAbortController?.abort();
@@ -3170,6 +3342,9 @@ var Session = class {
       throw RequestError.invalidParams(void 0, "Session is closing");
     }
     await this.assertCanStartTurn();
+    if (this.closing) {
+      throw RequestError.invalidParams(void 0, "Session is closing");
+    }
     if (admissionCancellation?.aborted) {
       return { stopReason: "cancelled" };
     }
@@ -3231,9 +3406,9 @@ var Session = class {
       return { stopReason: "cancelled" };
     }
     if (todoStopGuardPreparation.startsWorkChain) {
-      this.todoStopGuardQueuedPromptPriority = false;
+      this.#clearTodoStopGuardQueuedPromptWait();
       this.todoStopGuard.startOrdinaryPrompt();
-      this.todoStopGuardBackgroundBaseline = this.#captureTodoStopGuardBackgroundBaseline();
+      this.#resetTodoStopGuardBackgroundLineage();
     }
     this.duplicateProviderToolCallResponseIds.clear();
     const channelDelivery = parsePromptChannelDelivery(params);
@@ -3274,9 +3449,12 @@ var Session = class {
       }
       throw error;
     } finally {
+      const stillOwnsPendingPrompt = this.pendingPrompt === pendingSend;
       releasePendingSend();
       const shouldDrainAutomaticQueues = todoStopGuardPreparation.drainSupersededAutomaticQueues || this.todoStopGuardDrainAutomaticQueuesWhenIdle || this.todoStopGuard.blocksUnrelatedAutomaticTurns || this.todoStopGuard.hasCommittedContinuation || this.todoStopGuardQueuedPromptPriority;
-      this.todoStopGuardDrainAutomaticQueuesWhenIdle = false;
+      if (stillOwnsPendingPrompt) {
+        this.todoStopGuardDrainAutomaticQueuesWhenIdle = false;
+      }
       if (shouldDrainAutomaticQueues) {
         void this.#drainCronQueue();
         void this.#drainNotificationQueue();
@@ -3431,6 +3609,9 @@ var Session = class {
         }
         this.turn += 1;
         const promptId = this.config.getSessionId() + "########" + this.turn;
+        const promptMetadata = params._meta;
+        const continuesCurrentWorkChain = params.retry === true || promptMetadata?.[DAEMON_RETRY_META_KEY] === true || promptMetadata?.[DAEMON_CONTINUE_META_KEY] === true;
+        promptIdContext.enterWith(promptId);
         const parentContext = extractDaemonTraceContext(params);
         return await withInteractionSpan(
           this.config,
@@ -3496,6 +3677,9 @@ var Session = class {
             let parts;
             let fullTurnModelOverride;
             const onFullTurnModel = /* @__PURE__ */ __name((model) => {
+              if (fullTurnModelOverride === model) {
+                return true;
+              }
               if (fullTurnModelOverride) {
                 return false;
               }
@@ -3551,9 +3735,20 @@ var Session = class {
               }
               const additionalContext = hookOutput?.getAdditionalContext();
               if (additionalContext) {
-                parts = [...parts, { text: additionalContext }];
+                parts = [
+                  ...parts,
+                  { text: wrapUserPromptSubmitContext(additionalContext) }
+                ];
               }
             }
+            if (!continuesCurrentWorkChain && !this.todoStopGuard.enabled) {
+              this.#resetTodoStopGuardBackgroundLineage();
+            }
+            this.config.startActiveTodoWorkChain(
+              promptId,
+              continuesCurrentWorkChain ? this.activeTodoWorkChainPromptId : void 0
+            );
+            this.activeTodoWorkChainPromptId = promptId;
             try {
               const fileHistoryService = this.config.getFileHistoryService();
               await fileHistoryService.makeSnapshot(promptId);
@@ -3599,6 +3794,15 @@ ${this.pendingRecoveredAgentsNotice}
               parts = insertAfterFunctionResponses(parts, [noticePart]);
               this.pendingRecoveredAgentsNotice = null;
             }
+            const activeTodoReminder = this.config.takeActiveTodoReminder(
+              promptId,
+              true
+            );
+            if (activeTodoReminder && !parts.some((part) => part.text === activeTodoReminder)) {
+              parts = insertAfterFunctionResponses(parts, [
+                { text: activeTodoReminder }
+              ]);
+            }
             let nextMessage = { role: "user", parts };
             let turnCount = 0;
             const toolLoopState = createDaemonToolLoopState();
@@ -3704,7 +3908,8 @@ ${this.pendingRecoveredAgentsNotice}
                     }
                     strippedOrphanEntries = null;
                   }
-                  if (pendingSend.signal.aborted && pendingSend.signal.reason === USER_CANCEL_ABORT_REASON && this.#isAbortError(error)) {
+                  const isControlledCancellation = pendingSend.signal.aborted && (pendingSend.signal.reason === USER_CANCEL_ABORT_REASON || pendingSend.signal.reason === SESSION_DISPOSE_ABORT_REASON);
+                  if (isControlledCancellation) {
                     this.todoStopGuard.suspend();
                     return { stopReason: "cancelled" };
                   }
@@ -3756,7 +3961,8 @@ ${this.pendingRecoveredAgentsNotice}
                       pendingSend.signal,
                       promptId,
                       functionCalls,
-                      toolLoopState
+                      toolLoopState,
+                      onFullTurnModel
                     )
                   );
                   if (toolRun.stopAfterPermissionCancel) {
@@ -3774,6 +3980,7 @@ ${this.pendingRecoveredAgentsNotice}
                   const nextAfterTools = await this.#buildNextMessageAfterToolRun(
                     toolRun,
                     pendingSend.signal,
+                    promptId,
                     onFullTurnModel
                   );
                   nextMessage = nextAfterTools.message;
@@ -3811,6 +4018,11 @@ ${this.pendingRecoveredAgentsNotice}
                   turnCount
                 )
               );
+              cleanupReviewWorktreeLeases({
+                sessionId: this.config.getSessionId(),
+                promptId,
+                repositoryRoot: this.config.getProjectRoot()
+              });
             }
           },
           (result) => result.stopReason === "cancelled" ? "cancelled" : "ok"
@@ -3823,6 +4035,9 @@ ${this.pendingRecoveredAgentsNotice}
     let stopHookIterationCount = 0;
     let stopHookReasons = [];
     const onFullTurnModel = /* @__PURE__ */ __name((model) => {
+      if (modelOverride === model) {
+        return true;
+      }
       if (modelOverride) {
         return false;
       }
@@ -3831,6 +4046,9 @@ ${this.pendingRecoveredAgentsNotice}
     }, "onFullTurnModel");
     let midTurnContinuationCount = 0;
     while (true) {
+      if (this.pendingPrompt && this.pendingPrompt !== pendingSend) {
+        return { stopReason: "cancelled" };
+      }
       if (pendingSend.signal.aborted) {
         this.todoStopGuard.suspend();
         return { stopReason: "cancelled" };
@@ -3842,15 +4060,26 @@ ${this.pendingRecoveredAgentsNotice}
         return { stopReason: "end_turn" };
       }
       if (this.todoStopGuard.needsStopInspection) {
-        this.#beginTodoStopGuardQueuedPromptCheck();
         const drained = await this.#drainMidTurnInput(pendingSend.signal, {
           watchQueuedPromptForTodoStopGuard: true,
           onFullTurnModel
         });
-        const waitsForQueuedPrompt = this.#finishTodoStopGuardQueuedPromptCheck(
-          drained.hasQueuedPrompt
-        );
         if (drained.parts.length > 0) {
+          if (drained.hasQueuedPrompt) {
+            const claim = await this.#claimTodoStopGuardContinuation(
+              pendingSend.signal
+            );
+            if (claim === "queued") {
+              this.#preserveUnsentMessageHistory(
+                { role: "user", parts: drained.parts },
+                true
+              );
+              return { stopReason: "end_turn" };
+            }
+            if (claim === "unavailable") {
+              this.todoStopGuard.blockUntilOrdinaryPromptStarts();
+            }
+          }
           this.todoStopGuard.acceptMidTurnUserInput();
           const continuation2 = await this.#runStopContinuation(
             pendingSend,
@@ -3869,13 +4098,22 @@ ${this.pendingRecoveredAgentsNotice}
           }
           continue;
         }
-        if (waitsForQueuedPrompt) {
-          return { stopReason: "end_turn" };
+        if (!drained.reliable) {
+          this.todoStopGuard.blockUntilOrdinaryPromptStarts();
+        } else if (drained.hasQueuedPrompt) {
+          const claim = await this.#claimTodoStopGuardContinuation(
+            pendingSend.signal
+          );
+          if (claim === "queued") {
+            return { stopReason: "end_turn" };
+          }
+          if (claim === "unavailable") {
+            this.todoStopGuard.blockUntilOrdinaryPromptStarts();
+          }
         }
       }
       let externalReason = null;
       let stopHookCount = 1;
-      let queuedPromptArrivedDuringStopHook = false;
       if (allowExternalHooks && hooksEnabled && messageBus && stopHookIterationCount < stopHookBlockingCap && this.config.hasHooksForEvent?.("Stop")) {
         const responseText = this.#getCurrentChat().getLastModelMessageText?.() || "[no response text]";
         const contextUsage = buildContextUsage(
@@ -3906,14 +4144,26 @@ ${this.pendingRecoveredAgentsNotice}
           return { stopReason: "cancelled" };
         }
         if (this.todoStopGuard.needsStopInspection) {
-          this.#beginTodoStopGuardQueuedPromptCheck();
           const drained = await this.#drainMidTurnInput(pendingSend.signal, {
             watchQueuedPromptForTodoStopGuard: true,
             onFullTurnModel
           });
-          const waitsForQueuedPrompt = this.#finishTodoStopGuardQueuedPromptCheck(drained.hasQueuedPrompt);
-          queuedPromptArrivedDuringStopHook = waitsForQueuedPrompt;
           if (drained.parts.length > 0) {
+            if (drained.hasQueuedPrompt) {
+              const claim = await this.#claimTodoStopGuardContinuation(
+                pendingSend.signal
+              );
+              if (claim === "queued") {
+                this.#preserveUnsentMessageHistory(
+                  { role: "user", parts: drained.parts },
+                  true
+                );
+                return { stopReason: "end_turn" };
+              }
+              if (claim === "unavailable") {
+                this.todoStopGuard.blockUntilOrdinaryPromptStarts();
+              }
+            }
             this.todoStopGuard.acceptMidTurnUserInput();
             const continuation2 = await this.#runStopContinuation(
               pendingSend,
@@ -3930,6 +4180,20 @@ ${this.pendingRecoveredAgentsNotice}
             if (continuation2.kind === "terminal") {
               return { stopReason: continuation2.stopReason };
             }
+            continue;
+          }
+          if (!drained.reliable) {
+            this.todoStopGuard.blockUntilOrdinaryPromptStarts();
+          } else if (drained.hasQueuedPrompt) {
+            const claim = await this.#claimTodoStopGuardContinuation(
+              pendingSend.signal
+            );
+            if (claim === "queued") {
+              return { stopReason: "end_turn" };
+            }
+            if (claim === "unavailable") {
+              this.todoStopGuard.blockUntilOrdinaryPromptStarts();
+            }
           }
         }
         const hookOutput = response.output ? createHookOutput("Stop", response.output) : void 0;
@@ -3942,9 +4206,13 @@ ${this.pendingRecoveredAgentsNotice}
           stopHookIterationCount++;
           stopHookReasons = [...stopHookReasons, externalReason];
           stopHookCount = response.stopHookCount ?? 1;
+        } else {
+          stopHookIterationCount = 0;
+          stopHookReasons = [];
+          stopHookCount = 1;
         }
       }
-      const guardDecision = queuedPromptArrivedDuringStopHook ? null : this.todoStopGuard.decide(
+      const guardDecision = this.todoStopGuard.decide(
         this.todoStopGuard.needsStopInspection ? this.#hasRelevantTodoStopGuardBackgroundInput() : false
       );
       const guardContinuation = guardDecision?.kind === "continue" ? guardDecision : null;
@@ -3967,9 +4235,6 @@ ${this.pendingRecoveredAgentsNotice}
         debugLogger6.warn(warning);
         return { stopReason: "end_turn" };
       }
-      if (queuedPromptArrivedDuringStopHook) {
-        return { stopReason: "end_turn" };
-      }
       if (!externalReason && !guardContinuation) {
         return { stopReason: "end_turn" };
       }
@@ -4025,8 +4290,27 @@ ${this.pendingRecoveredAgentsNotice}
     let initialSend = true;
     let automaticContinuationValidated = false;
     let supersededAutomaticContinuation = false;
+    const preservePendingMessage = /* @__PURE__ */ __name((message) => {
+      if (initialSend) return;
+      const preservedParts = (message.parts ?? []).filter(
+        (part) => !("text" in part && isTodoStopGuardPromptText(part.text))
+      );
+      this.#preserveUnsentMessageHistory(
+        preservedParts.length > 0 ? { ...message, parts: preservedParts } : null,
+        true
+      );
+    }, "preservePendingMessage");
     while (nextMessage !== null) {
+      if (this.pendingPrompt && this.pendingPrompt !== pendingSend) {
+        preservePendingMessage(nextMessage);
+        return {
+          kind: "terminal",
+          stopReason: "cancelled",
+          ...supersededAutomaticContinuation ? { supersededAutomaticContinuation: true } : {}
+        };
+      }
       if (pendingSend.signal.aborted) {
+        preservePendingMessage(nextMessage);
         this.todoStopGuard.suspend();
         return {
           kind: "terminal",
@@ -4044,12 +4328,18 @@ ${this.pendingRecoveredAgentsNotice}
       let guardForThisSend = nextGuardContinuation;
       let preserveGuardOnSkippedSend = false;
       let messageForPreservation = nextMessage;
+      let preparedMessage = nextMessage.parts ?? [];
+      let preservePreparedMessageOnSkippedSend = !guardForThisSend && preparedMessage.some(
+        (part) => !("text" in part && isTodoStopGuardPromptText(part.text))
+      );
       const externalParts = initialSend ? options.externalParts : void 0;
       const promptIdForSend = guardForThisSend && guardForThisSend.attempt !== options.guardContinuation?.attempt ? toolPromptId + "_todo_stop_guard_" + guardForThisSend.attempt : streamPromptId;
       const messageDisplay = this.#createMessageDisplayDispatcher(
         pendingSend.signal
       );
       let channelDeliveryResponseBlock;
+      let providerSendChat;
+      let userContentPushCountBeforeSend = 0;
       try {
         const sendResult = await this.#sendMessageStreamWithAutoCompression(
           promptIdForSend,
@@ -4058,44 +4348,134 @@ ${this.pendingRecoveredAgentsNotice}
           {
             skipCompression: skipCompression || (guardForThisSend?.attempt ?? 0) > 1,
             getModelOverride: options.getModelOverride,
-            beforeSend: guardForThisSend || !automaticContinuationValidated && options.onAutomaticContinuationValidated ? async ({ compressionFailed }) => {
-              const inspectGuardPriority = guardForThisSend !== void 0;
-              const guardCompressionFailed = inspectGuardPriority && compressionFailed;
-              if (inspectGuardPriority) {
-                this.#beginTodoStopGuardQueuedPromptCheck();
-                const drained = await this.#drainMidTurnInput(
-                  pendingSend.signal,
-                  {
-                    watchQueuedPromptForTodoStopGuard: true,
-                    onFullTurnModel: options.onFullTurnModel
+            prepareBeforeCompression: guardForThisSend ? async () => {
+              const drained = await this.#drainMidTurnInput(
+                pendingSend.signal,
+                {
+                  watchQueuedPromptForTodoStopGuard: true,
+                  onFullTurnModel: options.onFullTurnModel
+                }
+              );
+              if (drained.parts.length > 0) {
+                if (drained.hasQueuedPrompt) {
+                  const claim = await this.#claimTodoStopGuardContinuation(
+                    pendingSend.signal
+                  );
+                  if (claim === "queued") {
+                    guardForThisSend = void 0;
+                    nextGuardContinuation = void 0;
+                    preserveGuardOnSkippedSend = true;
+                    preservePreparedMessageOnSkippedSend = true;
+                    messageForPreservation = {
+                      role: "user",
+                      parts: drained.parts
+                    };
+                    if (initialSend) {
+                      supersededAutomaticContinuation = true;
+                    }
+                    return { kind: "stop", stopReason: "end_turn" };
                   }
+                  if (claim === "unavailable") {
+                    this.todoStopGuard.blockUntilOrdinaryPromptStarts();
+                  }
+                }
+                preservePreparedMessageOnSkippedSend = true;
+                this.todoStopGuard.acceptMidTurnUserInput();
+                guardForThisSend = void 0;
+                nextGuardContinuation = void 0;
+                if (initialSend) {
+                  supersededAutomaticContinuation = true;
+                }
+                preparedMessage = initialSend ? drained.parts : [
+                  ...(nextMessage?.parts ?? []).filter(
+                    (part) => !("text" in part && isTodoStopGuardPromptText(part.text))
+                  ),
+                  ...drained.parts
+                ];
+                messageForPreservation = {
+                  role: "user",
+                  parts: preparedMessage
+                };
+                return { kind: "send", message: preparedMessage };
+              }
+              if (!drained.reliable) {
+                this.todoStopGuard.blockUntilOrdinaryPromptStarts();
+                guardForThisSend = void 0;
+                nextGuardContinuation = void 0;
+                if (!options.externalParts) {
+                  preserveGuardOnSkippedSend = true;
+                  return { kind: "stop", stopReason: "end_turn" };
+                }
+                if (!initialSend && nextMessage) {
+                  nextMessage = {
+                    ...nextMessage,
+                    parts: (nextMessage.parts ?? []).filter(
+                      (part) => !("text" in part && isTodoStopGuardPromptText(part.text))
+                    )
+                  };
+                }
+              } else if (drained.hasQueuedPrompt) {
+                const probe = await this.#claimTodoStopGuardContinuation(
+                  pendingSend.signal
                 );
-                const waitsForQueuedPrompt = this.#finishTodoStopGuardQueuedPromptCheck(
-                  drained.hasQueuedPrompt
-                );
-                if (drained.parts.length > 0) {
-                  this.todoStopGuard.acceptMidTurnUserInput();
+                if (probe === "queued") {
                   guardForThisSend = void 0;
                   nextGuardContinuation = void 0;
+                  preserveGuardOnSkippedSend = true;
                   if (initialSend) {
                     supersededAutomaticContinuation = true;
                   }
-                  const replacementMessage = initialSend ? drained.parts : [
-                    ...(nextMessage?.parts ?? []).filter(
-                      (part) => !("text" in part && isTodoStopGuardPromptText(part.text))
-                    ),
-                    ...drained.parts
-                  ];
-                  messageForPreservation = {
-                    role: "user",
-                    parts: replacementMessage
-                  };
-                  return {
-                    kind: "send",
-                    message: replacementMessage
-                  };
+                  return { kind: "stop", stopReason: "end_turn" };
                 }
-                if (waitsForQueuedPrompt) {
+                if (probe === "unavailable") {
+                  this.todoStopGuard.blockUntilOrdinaryPromptStarts();
+                  guardForThisSend = void 0;
+                  nextGuardContinuation = void 0;
+                  if (!options.externalParts) {
+                    preserveGuardOnSkippedSend = true;
+                    return { kind: "stop", stopReason: "end_turn" };
+                  }
+                  if (!initialSend && nextMessage) {
+                    nextMessage = {
+                      ...nextMessage,
+                      parts: (nextMessage.parts ?? []).filter(
+                        (part) => !("text" in part && isTodoStopGuardPromptText(part.text))
+                      )
+                    };
+                  }
+                }
+              }
+              if (guardForThisSend && this.config.getApprovalMode() === "plan" /* PLAN */) {
+                this.#clearTodoStopGuardTrustAndDrainAutomaticQueues();
+              }
+              if (guardForThisSend) {
+                const hasRelevantBackgroundInput = this.#hasRelevantTodoStopGuardBackgroundInput();
+                const refreshedDecision = guardForThisSend.toolClosure ? this.todoStopGuard.decideToolClosure(
+                  guardForThisSend.attempt - 1,
+                  hasRelevantBackgroundInput
+                ) : this.todoStopGuard.decide(hasRelevantBackgroundInput);
+                if (refreshedDecision.kind !== "continue" || refreshedDecision.attempt !== guardForThisSend.attempt) {
+                  guardForThisSend = void 0;
+                  nextGuardContinuation = void 0;
+                  if (!options.externalParts) {
+                    preserveGuardOnSkippedSend = true;
+                    return { kind: "stop", stopReason: "end_turn" };
+                  }
+                  if (!initialSend && nextMessage) {
+                    nextMessage = {
+                      ...nextMessage,
+                      parts: (nextMessage.parts ?? []).filter(
+                        (part) => !("text" in part && isTodoStopGuardPromptText(part.text))
+                      )
+                    };
+                  }
+                }
+              }
+              if (guardForThisSend) {
+                const claim = await this.#claimTodoStopGuardContinuation(
+                  pendingSend.signal
+                );
+                if (claim === "queued") {
                   guardForThisSend = void 0;
                   nextGuardContinuation = void 0;
                   preserveGuardOnSkippedSend = true;
@@ -4104,41 +4484,21 @@ ${this.pendingRecoveredAgentsNotice}
                   }
                   return { kind: "stop", stopReason: "end_turn" };
                 }
-                if (guardCompressionFailed) {
-                  this.todoStopGuard.suspend();
+                if (claim === "unavailable") {
+                  this.todoStopGuard.blockUntilOrdinaryPromptStarts();
                   guardForThisSend = void 0;
                   nextGuardContinuation = void 0;
-                  if (!externalParts || externalParts.length === 0) {
+                  if (!options.externalParts) {
                     preserveGuardOnSkippedSend = true;
                     return { kind: "stop", stopReason: "end_turn" };
                   }
-                }
-                if (guardForThisSend && this.config.getApprovalMode() === "plan" /* PLAN */) {
-                  this.#clearTodoStopGuardTrustAndDrainAutomaticQueues();
-                }
-                if (guardForThisSend) {
-                  const hasRelevantBackgroundInput = this.#hasRelevantTodoStopGuardBackgroundInput();
-                  const refreshedDecision = guardForThisSend.toolClosure ? this.todoStopGuard.decideToolClosure(
-                    guardForThisSend.attempt - 1,
-                    hasRelevantBackgroundInput
-                  ) : this.todoStopGuard.decide(
-                    hasRelevantBackgroundInput
-                  );
-                  if (refreshedDecision.kind !== "continue" || refreshedDecision.attempt !== guardForThisSend.attempt) {
-                    guardForThisSend = void 0;
-                    nextGuardContinuation = void 0;
-                    if (!options.externalParts) {
-                      preserveGuardOnSkippedSend = true;
-                      return { kind: "stop", stopReason: "end_turn" };
-                    }
-                    if (!initialSend && nextMessage) {
-                      nextMessage = {
-                        ...nextMessage,
-                        parts: (nextMessage.parts ?? []).filter(
-                          (part) => !("text" in part && isTodoStopGuardPromptText(part.text))
-                        )
-                      };
-                    }
+                  if (!initialSend && nextMessage) {
+                    nextMessage = {
+                      ...nextMessage,
+                      parts: (nextMessage.parts ?? []).filter(
+                        (part) => !("text" in part && isTodoStopGuardPromptText(part.text))
+                      )
+                    };
                   }
                 }
               }
@@ -4146,16 +4506,42 @@ ${this.pendingRecoveredAgentsNotice}
                 await options.onAutomaticContinuationValidated();
                 automaticContinuationValidated = true;
               }
-              const selectedMessage = guardForThisSend || !externalParts ? nextMessage?.parts ?? [] : externalParts;
+              preparedMessage = guardForThisSend || !externalParts ? nextMessage?.parts ?? [] : externalParts;
               messageForPreservation = {
                 role: "user",
-                parts: selectedMessage
+                parts: preparedMessage
               };
-              return {
-                kind: "send",
-                message: selectedMessage
+              preservePreparedMessageOnSkippedSend = preparedMessage.some(
+                (part) => !("text" in part && isTodoStopGuardPromptText(part.text))
+              );
+              return { kind: "send", message: preparedMessage };
+            } : void 0,
+            beforeSend: /* @__PURE__ */ __name(async ({ compressionFailed }) => {
+              if (guardForThisSend && compressionFailed) {
+                this.todoStopGuard.suspend();
+                guardForThisSend = void 0;
+                nextGuardContinuation = void 0;
+                if (!options.externalParts) {
+                  preserveGuardOnSkippedSend = true;
+                  return { kind: "stop", stopReason: "end_turn" };
+                }
+                preparedMessage = initialSend && externalParts ? externalParts : preparedMessage.filter(
+                  (part) => !("text" in part && isTodoStopGuardPromptText(part.text))
+                );
+                preservePreparedMessageOnSkippedSend = true;
+              }
+              if (!automaticContinuationValidated && options.onAutomaticContinuationValidated) {
+                await options.onAutomaticContinuationValidated();
+                automaticContinuationValidated = true;
+              }
+              messageForPreservation = {
+                role: "user",
+                parts: preparedMessage
               };
-            } : void 0
+              providerSendChat = this.#getCurrentChat();
+              userContentPushCountBeforeSend = providerSendChat.getUserContentPushCount?.() ?? 0;
+              return { kind: "send", message: preparedMessage };
+            }, "beforeSend")
           }
         );
         if (!sendResult.responseStream) {
@@ -4171,7 +4557,7 @@ ${this.pendingRecoveredAgentsNotice}
           );
           this.#preserveUnsentMessageHistory(
             preservedParts.length > 0 ? { ...messageForPreservation, parts: preservedParts } : null,
-            sendResult.stopReason === "cancelled"
+            sendResult.stopReason === "cancelled" || preservePreparedMessageOnSkippedSend
           );
           return {
             kind: "terminal",
@@ -4193,7 +4579,7 @@ ${this.pendingRecoveredAgentsNotice}
           if (guardCommitted) {
             await this.#emitTodoStopGuardContinuation(guardForThisSend);
           }
-          if (!guardCommitted && externalParts) {
+          if (!guardCommitted && options.externalParts) {
             guardForThisSend = void 0;
           }
         }
@@ -4247,6 +4633,24 @@ ${this.pendingRecoveredAgentsNotice}
         }
       } catch (error) {
         streamFailed = true;
+        const preservedParts = (messageForPreservation.parts ?? []).filter(
+          (part) => !("text" in part && isTodoStopGuardPromptText(part.text))
+        );
+        if (preservedParts.length > 0 && (!providerSendChat || (providerSendChat.getUserContentPushCount?.() ?? 0) <= userContentPushCountBeforeSend)) {
+          this.#preserveUnsentMessageHistory(
+            { ...messageForPreservation, parts: preservedParts },
+            true
+          );
+        }
+        const isControlledCancellation = pendingSend.signal.aborted && (pendingSend.signal.reason === USER_CANCEL_ABORT_REASON || pendingSend.signal.reason === SESSION_DISPOSE_ABORT_REASON);
+        if (isControlledCancellation) {
+          this.todoStopGuard.suspend();
+          return {
+            kind: "terminal",
+            stopReason: "cancelled",
+            ...supersededAutomaticContinuation ? { supersededAutomaticContinuation: true } : {}
+          };
+        }
         this.todoStopGuard.pauseForTrustedRetry();
         const errorStatus = getErrorStatus(error);
         const errorMessage = error instanceof Error ? error.message : String(error);
@@ -4296,7 +4700,8 @@ ${this.pendingRecoveredAgentsNotice}
             pendingSend.signal,
             toolPromptId,
             functionCalls,
-            toolLoopState
+            toolLoopState,
+            options.onFullTurnModel
           )
         );
         if (toolRun.stopAfterPermissionCancel || toolRun.loopDetected) {
@@ -4311,6 +4716,7 @@ ${this.pendingRecoveredAgentsNotice}
         const nextAfterTools = await this.#buildNextMessageAfterToolRun(
           toolRun,
           pendingSend.signal,
+          toolPromptId,
           options.onFullTurnModel
         );
         nextMessage = nextAfterTools.message;
@@ -4454,6 +4860,19 @@ ${this.pendingRecoveredAgentsNotice}
    */
   async #sendMessageStreamWithAutoCompression(promptId, message, abortSignal, options = {}) {
     const geminiClient = this.config.getGeminiClient();
+    if (options.prepareBeforeCompression) {
+      const decision = await options.prepareBeforeCompression();
+      if (decision.kind === "stop") {
+        return { responseStream: null, stopReason: decision.stopReason };
+      }
+      message = decision.message;
+    }
+    if (abortSignal.aborted) {
+      debugLogger6.debug(
+        `Send aborted after pre-compression preparation for prompt ${promptId}`
+      );
+      return { responseStream: null, stopReason: "cancelled" };
+    }
     let compressionDiagnostic = null;
     let compressionInfo = null;
     let compressionFailed = false;
@@ -4475,10 +4894,13 @@ ${this.pendingRecoveredAgentsNotice}
           compressionDiagnostic = `IMPORTANT: This conversation ${reasonClause}. A compressed context will be sent for future messages (compressed from: ${compressed.originalTokenCount ?? "unknown"} to ${compressed.newTokenCount ?? "unknown"} tokens).`;
         }
       } catch (compressionError) {
-        if (abortSignal.aborted || this.#isAbortError(compressionError)) {
+        if (abortSignal.aborted) {
           debugLogger6.debug(`Auto-compression aborted for prompt ${promptId}`);
           return { responseStream: null, stopReason: "cancelled" };
         }
+        if (this.#isAbortError(compressionError)) {
+          throw compressionError;
+        }
         debugLogger6.warn(
           `Auto-compression failed for prompt ${promptId}; proceeding without compression: ` + this.#formatError(compressionError)
         );
@@ -4584,7 +5006,7 @@ ${this.pendingRecoveredAgentsNotice}
     );
     await this.messageRewriter?.waitForPendingRewrites();
   }
-  async #buildNextMessageAfterToolRun(toolRun, abortSignal, onFullTurnModel) {
+  async #buildNextMessageAfterToolRun(toolRun, abortSignal, promptId, onFullTurnModel) {
     if (toolRun.loopDetected) {
       debugLogger6.debug("Stopping ACP turn after daemon loop detection.");
       return { message: null, hadMidTurnUserInput: false };
@@ -4603,7 +5025,12 @@ ${this.pendingRecoveredAgentsNotice}
     if (hadMidTurnUserInput) {
       this.todoStopGuard.acceptMidTurnUserInput();
     }
-    const parts = [...toolRun.parts, ...drained.parts];
+    const activeTodoReminder = this.config.takeActiveTodoReminder(promptId);
+    const parts = [
+      ...toolRun.parts,
+      ...activeTodoReminder ? [{ text: activeTodoReminder }] : [],
+      ...drained.parts
+    ];
     return {
       message: { role: "user", parts },
       hadMidTurnUserInput
@@ -4693,7 +5120,8 @@ ${this.pendingRecoveredAgentsNotice}
     if (this.midTurnDrainUnavailable) {
       return {
         parts: await this.#buildMidTurnParts(recovered, abortSignal, options),
-        hasQueuedPrompt: false
+        hasQueuedPrompt: false,
+        reliable: false
       };
     }
     let drainPromise;
@@ -4716,13 +5144,18 @@ ${this.pendingRecoveredAgentsNotice}
         clearTimeout(timeoutHandle);
       }
       this.midTurnDrainTimeoutStrikes = 0;
+      const reliable = isValidMidTurnDrainResponse(
+        response,
+        options.watchQueuedPromptForTodoStopGuard === true
+      );
       return {
         parts: await this.#buildMidTurnParts(
           [...recovered, ...parseMidTurnDrainResponse(response)],
           abortSignal,
           options
         ),
-        hasQueuedPrompt: isRecord2(response) && response["hasQueuedPrompt"] === true
+        hasQueuedPrompt: isRecord2(response) && response["hasQueuedPrompt"] === true,
+        reliable
       };
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : error && typeof error === "object" && "message" in error ? String(error.message) : String(error);
@@ -4741,7 +5174,8 @@ ${this.pendingRecoveredAgentsNotice}
       );
       return {
         parts: await this.#buildMidTurnParts(recovered, abortSignal, options),
-        hasQueuedPrompt: false
+        hasQueuedPrompt: false,
+        reliable: false
       };
     }
   }
@@ -4861,7 +5295,8 @@ ${this.pendingRecoveredAgentsNotice}
         source: job.cronExpr === "@wakeup" ? "loop" : "cron",
         ...job.id ? { taskId: job.id } : {},
         ...job.lastFiredAt !== void 0 ? { firedAt: job.lastFiredAt } : {},
-        ...job.delivery ? { delivery: job.delivery } : {}
+        ...job.delivery ? { delivery: job.delivery } : {},
+        ...job.todoWorkChainId ? { todoWorkChainId: job.todoWorkChainId } : {}
       });
       void this.#drainCronQueue();
     });
@@ -4881,26 +5316,39 @@ ${this.pendingRecoveredAgentsNotice}
     );
   }
   #enqueueCronPrompt(item) {
-    if ((this.todoStopGuard.blocksUnrelatedAutomaticTurns || this.todoStopGuardQueuedPromptPriority) && !this.#cronContinuesTodoStopGuardWorkChain(item)) {
-      if (item.taskId) {
+    const automaticWorkDeferred = this.todoStopGuard.blocksUnrelatedAutomaticTurns || this.todoStopGuardQueuedPromptPriority;
+    if (automaticWorkDeferred) {
+      const incomingIsRelated = this.#cronContinuesTodoStopGuardWorkChain(item);
+      let shouldAppend = true;
+      if (!incomingIsRelated && item.taskId) {
         const duplicateIndex = this.cronQueue.findIndex(
           (queued) => queued.taskId === item.taskId && !this.#cronContinuesTodoStopGuardWorkChain(queued)
         );
         if (duplicateIndex >= 0) {
           this.cronQueue[duplicateIndex] = item;
-          return;
+          shouldAppend = false;
         }
       }
-      const unrelatedIndices = this.cronQueue.map(
-        (queued, index) => this.#cronContinuesTodoStopGuardWorkChain(queued) ? -1 : index
-      ).filter((index) => index >= 0);
-      if (unrelatedIndices.length >= MAX_DEFERRED_UNRELATED_CRON_QUEUE) {
-        const evictedIndex = unrelatedIndices[0];
+      const maxBeforeAppend = MAX_DEFERRED_UNRELATED_CRON_QUEUE - (shouldAppend && !incomingIsRelated ? 1 : 0);
+      let unrelatedCount = this.cronQueue.filter(
+        (queued) => !this.#cronContinuesTodoStopGuardWorkChain(queued)
+      ).length;
+      const evictedTaskIds = [];
+      while (unrelatedCount > maxBeforeAppend) {
+        const evictedIndex = this.cronQueue.findIndex(
+          (queued) => !this.#cronContinuesTodoStopGuardWorkChain(queued)
+        );
+        if (evictedIndex < 0) break;
         const [evicted] = this.cronQueue.splice(evictedIndex, 1);
+        evictedTaskIds.push(evicted?.taskId ?? "unknown");
+        unrelatedCount--;
+      }
+      if (evictedTaskIds.length > 0) {
         debugLogger6.warn(
-          `Cron queue overflow while automatic work is deferred: evicting task=${evicted?.taskId ?? "unknown"}`
+          `Cron queue overflow while automatic work is deferred: evicted ${evictedTaskIds.length} unrelated task(s): ${evictedTaskIds.join(", ")}`
         );
       }
+      if (!shouldAppend) return;
     }
     this.cronQueue.push(item);
   }
@@ -5004,9 +5452,8 @@ ${this.pendingRecoveredAgentsNotice}
       async () => {
         const ac = new AbortController();
         this.cronAbortController = ac;
-        this.#prepareTodoStopGuardForAutomaticTurn(
-          this.#cronContinuesTodoStopGuardWorkChain(item)
-        );
+        const continuesCurrentWorkChain = this.#cronContinuesTodoStopGuardWorkChain(item);
+        this.#prepareTodoStopGuardForAutomaticTurn(continuesCurrentWorkChain);
         const promptId = this.config.getSessionId() + "########cron" + Date.now();
         let cronHadError = false;
         let cronCompleted = false;
@@ -5023,6 +5470,10 @@ ${this.pendingRecoveredAgentsNotice}
             try {
               await this.assertCanStartTurn();
               if (ac.signal.aborted) return;
+              this.config.startAutomaticActiveTodoWorkChain(
+                promptId,
+                item.todoWorkChainId
+              );
               const loopMode = detectLoopSentinel(prompt);
               const autonomousMode = loopMode ? null : detectAutonomousSentinel(prompt);
               let loopTick = null;
@@ -5077,9 +5528,17 @@ ${this.pendingRecoveredAgentsNotice}
                 _meta: { source: item.source }
               });
               const cronReminders = await this.#buildInitialSystemReminders();
+              const activeTodoReminder = this.config.takeActiveTodoReminder(
+                promptId,
+                true
+              );
               let nextMessage = {
                 role: "user",
-                parts: [...cronReminders, { text: modelText }]
+                parts: [
+                  ...cronReminders,
+                  ...activeTodoReminder ? [{ text: activeTodoReminder }] : [],
+                  { text: modelText }
+                ]
               };
               const toolLoopState = createDaemonToolLoopState();
               while (nextMessage !== null) {
@@ -5211,7 +5670,8 @@ ${this.pendingRecoveredAgentsNotice}
                   }
                   const nextAfterTools = await this.#buildNextMessageAfterToolRun(
                     toolRun,
-                    ac.signal
+                    ac.signal,
+                    promptId
                   );
                   nextMessage = nextAfterTools.message;
                   if (toolRun.loopDetected) {
@@ -5251,6 +5711,7 @@ ${this.pendingRecoveredAgentsNotice}
                 `[${item.source} error] ${msg}`
               );
             } finally {
+              this.config.endAutomaticActiveTodoWorkChain(promptId);
               if (this.cronAbortController === ac) {
                 this.cronAbortController = null;
               }
@@ -5302,7 +5763,9 @@ ${this.pendingRecoveredAgentsNotice}
           taskId: meta.agentId,
           status: meta.status,
           kind: "agent",
-          toolUseId: meta.toolUseId
+          continuesTodoStopGuardWorkChain: this.#agentContinuesTodoStopGuardWorkChain(meta.agentId),
+          toolUseId: meta.toolUseId,
+          todoWorkChainId: meta.todoWorkChainId
         });
       }
     );
@@ -5317,7 +5780,12 @@ ${this.pendingRecoveredAgentsNotice}
         taskId: meta.monitorId,
         status: meta.status,
         kind: "monitor",
-        toolUseId: meta.toolUseId
+        continuesTodoStopGuardWorkChain: this.#monitorContinuesTodoStopGuardWorkChain(
+          meta.monitorId,
+          meta.ownerAgentId
+        ),
+        toolUseId: meta.toolUseId,
+        todoWorkChainId: meta.todoWorkChainId
       });
     });
     const shellRegistry = this.config.getBackgroundShellRegistry();
@@ -5327,7 +5795,9 @@ ${this.pendingRecoveredAgentsNotice}
         modelText,
         taskId: meta.shellId,
         status: meta.status,
-        kind: "shell"
+        kind: "shell",
+        continuesTodoStopGuardWorkChain: !this.todoStopGuardBackgroundBaseline.shells.has(meta.shellId),
+        todoWorkChainId: meta.todoWorkChainId
       });
     });
     this.config.getChatRecordingService()?.setTitleRecordedCallback((customTitle, titleSource, sessionId) => {
@@ -5450,20 +5920,36 @@ ${this.pendingRecoveredAgentsNotice}
       async () => {
         const ac = new AbortController();
         this.notificationAbortController = ac;
-        this.#prepareTodoStopGuardForAutomaticTurn(
-          this.#notificationContinuesTodoStopGuardWorkChain(item)
-        );
+        const continuesCurrentWorkChain = this.#notificationContinuesTodoStopGuardWorkChain(item);
+        this.#prepareTodoStopGuardForAutomaticTurn(continuesCurrentWorkChain);
         const promptId = this.config.getSessionId() + "########notification" + Date.now();
         try {
           await this.assertCanStartTurn();
           if (ac.signal.aborted) return;
+          this.config.startAutomaticActiveTodoWorkChain(
+            promptId,
+            item.todoWorkChainId
+          );
           await this.#emitBackgroundNotificationDisplay(item);
           const notificationParts = [{ text: item.modelText }];
-          this.config.getChatRecordingService()?.recordNotification(notificationParts, item.displayText);
+          this.config.getChatRecordingService()?.recordNotification(notificationParts, item.displayText, {
+            taskId: item.taskId,
+            status: item.status,
+            kind: item.kind,
+            toolUseId: item.toolUseId
+          });
           const notificationReminders = await this.#buildInitialSystemReminders();
+          const activeTodoReminder = this.config.takeActiveTodoReminder(
+            promptId,
+            true
+          );
           let nextMessage = {
             role: "user",
-            parts: [...notificationReminders, ...notificationParts]
+            parts: [
+              ...notificationReminders,
+              ...activeTodoReminder ? [{ text: activeTodoReminder }] : [],
+              ...notificationParts
+            ]
           };
           const toolLoopState = createDaemonToolLoopState();
           while (nextMessage !== null) {
@@ -5593,7 +6079,8 @@ ${this.pendingRecoveredAgentsNotice}
               }
               const nextAfterTools = await this.#buildNextMessageAfterToolRun(
                 toolRun,
-                ac.signal
+                ac.signal,
+                promptId
               );
               nextMessage = nextAfterTools.message;
               if (toolRun.loopDetected) {
@@ -5644,6 +6131,7 @@ ${this.pendingRecoveredAgentsNotice}
             await this.#emitBackgroundNotificationEndTurn("end_turn");
           }
         } finally {
+          this.config.endAutomaticActiveTodoWorkChain(promptId);
           if (this.notificationAbortController === ac) {
             this.notificationAbortController = null;
           }
@@ -5708,8 +6196,10 @@ ${this.pendingRecoveredAgentsNotice}
       debugLogger6.error("Error sending available commands update:", error);
     }
   }
-  async refreshSkillsFromSettings() {
-    this.settings.reloadScopeFromDisk("Workspace" /* Workspace */);
+  async refreshSkillsFromSettings(options = {}) {
+    if (options.reloadSettings ?? true) {
+      this.reloadSkillSettings();
+    }
     const skillManager = this.config.getSkillManager();
     let updateFailed = false;
     let updateError;
@@ -5719,7 +6209,7 @@ ${this.pendingRecoveredAgentsNotice}
       updateFailed = true;
       updateError = error;
     }
-    if (skillManager) {
+    if (skillManager && (options.notifyConfigChanged ?? true)) {
       try {
         skillManager.suppressNextSlashReload();
         await skillManager.notifyConfigChanged();
@@ -5733,6 +6223,9 @@ ${this.pendingRecoveredAgentsNotice}
     }
     if (updateFailed) throw updateError;
   }
+  reloadSkillSettings() {
+    this.settings.reloadScopeFromDisk("Workspace" /* Workspace */);
+  }
   async sendAvailableCommandsUpdateOrThrow() {
     const { availableCommands, availableSkills, availableSkillDetails } = await buildAvailableCommandsSnapshot(
       this.config,
@@ -5912,7 +6405,11 @@ ${this.pendingRecoveredAgentsNotice}
    * sequential batch to preserve the implicit ordering the model may rely
    * on. Response-part ordering matches the original `functionCalls` order.
    */
-  async runToolCalls(abortSignal, promptId, functionCalls, toolLoopState) {
+  async runToolCalls(abortSignal, promptId, functionCalls, toolLoopState, onFullTurnModel) {
+    promptIdContext.enterWith(promptId);
+    todoWorkChainContext.enterWith(
+      this.config.getActiveTodoWorkChainOwner(promptId)
+    );
     const dedupedFunctionCalls = dedupeToolCallsById(functionCalls);
     const generatedCallIdBase = randomUUID();
     const executionCallIds = new Map(
@@ -6189,7 +6686,8 @@ ${this.pendingRecoveredAgentsNotice}
             toolLoopState,
             recordSkippedToolCall,
             queueToolResultRecord,
-            executionCallIds.get(calls[i])
+            executionCallIds.get(calls[i]),
+            onFullTurnModel
           );
           results[i] = r;
           if (r.loopDetected) {
@@ -6223,7 +6721,8 @@ ${this.pendingRecoveredAgentsNotice}
           toolLoopState,
           recordSkippedToolCall,
           queueToolResultRecord,
-          executionCallIds.get(calls[idx])
+          executionCallIds.get(calls[idx]),
+          onFullTurnModel
         ).then((r) => {
           results[idx] = r;
         }).finally(() => {
@@ -6347,7 +6846,8 @@ ${this.pendingRecoveredAgentsNotice}
               toolLoopState,
               recordSkippedToolCall,
               queueToolResultRecord,
-              executionCallIds.get(fc)
+              executionCallIds.get(fc),
+              onFullTurnModel
             );
             parts.push(...r.parts);
             collectMemoryWriteCandidates(r);
@@ -6412,7 +6912,7 @@ ${this.pendingRecoveredAgentsNotice}
     }
     return reminders;
   }
-  async runTool(abortSignal, promptId, fc, onStopAfterPermissionCancel, toolLoopState, recordSkippedToolCall, queueToolResultRecord, generatedCallId) {
+  async runTool(abortSignal, promptId, fc, onStopAfterPermissionCancel, toolLoopState, recordSkippedToolCall, queueToolResultRecord, generatedCallId, onFullTurnModel) {
     const callId = fc.id ?? generatedCallId ?? `${fc.name}-${Date.now()}`;
     let args = fc.args ?? {};
     if (toolLoopState?.loopDetected) {
@@ -6517,15 +7017,20 @@ ${this.pendingRecoveredAgentsNotice}
     }
     const policyToolName = tool.name;
     const originalPolicyRequestArgs = policyToolName === ToolNames.SHELL || policyToolName === ToolNames.MONITOR ? structuredClone(args) : args;
-    const toolSpan = startToolSpan(policyToolName, {
-      "tool.call_id": callId,
-      "gen_ai.tool.call.id": getProviderToolCallId(fc) ?? callId,
-      // Dual-emit the legacy call_id/tool_name aliases like CoreToolScheduler
-      // (coreToolScheduler.ts) so pre-Phase-2 dashboards keyed off call_id keep
-      // matching daemon/ACP tool spans during the migration window.
-      call_id: callId,
-      tool_name: policyToolName
-    });
+    const toolSpan = startToolSpan(
+      policyToolName,
+      {
+        "tool.call_id": callId,
+        "gen_ai.tool.call.id": getProviderToolCallId(fc) ?? callId,
+        // Dual-emit the legacy call_id/tool_name aliases like CoreToolScheduler
+        // (coreToolScheduler.ts) so pre-Phase-2 dashboards keyed off call_id keep
+        // matching daemon/ACP tool spans during the migration window.
+        call_id: callId,
+        tool_name: policyToolName
+      },
+      tool.description,
+      promptId
+    );
     let spanSuccess = false;
     try {
       return await runInToolSpanContext(toolSpan, async () => {
@@ -6563,6 +7068,10 @@ ${this.pendingRecoveredAgentsNotice}
         let toolBuildSucceeded = false;
         try {
           const invocation = tool.build(args);
+          if (policyToolName === ToolNames.MONITOR) {
+            const callIdAware = invocation;
+            callIdAware.setCallId?.(callId);
+          }
           toolBuildSucceeded = true;
           const taskEventEmitter = invocation.eventEmitter;
           if (isAgentTool && taskEventEmitter) {
@@ -7078,6 +7587,33 @@ ${this.pendingRecoveredAgentsNotice}
               );
             }
           }
+          const continuedAgentId = toolName === ToolNames.SEND_MESSAGE && typeof args["task_id"] === "string" && args["task_id"].length > 0 ? args["task_id"] : void 0;
+          const provisionalRelatedAgent = continuedAgentId !== void 0 && !this.relatedAgentIds.has(continuedAgentId);
+          if (provisionalRelatedAgent) {
+            this.provisionalRelatedAgentCounts.set(
+              continuedAgentId,
+              (this.provisionalRelatedAgentCounts.get(continuedAgentId) ?? 0) + 1
+            );
+          }
+          let relatedAgentSettled = false;
+          const settleRelatedAgent = /* @__PURE__ */ __name((succeeded2) => {
+            if (relatedAgentSettled || !provisionalRelatedAgent || !continuedAgentId) {
+              return;
+            }
+            relatedAgentSettled = true;
+            const remaining = (this.provisionalRelatedAgentCounts.get(continuedAgentId) ?? 1) - 1;
+            if (remaining > 0) {
+              this.provisionalRelatedAgentCounts.set(
+                continuedAgentId,
+                remaining
+              );
+            } else {
+              this.provisionalRelatedAgentCounts.delete(continuedAgentId);
+            }
+            if (succeeded2) {
+              this.relatedAgentIds.add(continuedAgentId);
+            }
+          }, "settleRelatedAgent");
           const execSpan = startToolExecutionSpan();
           let toolResult;
           let isExecutionTimeout = false;
@@ -7116,6 +7652,17 @@ ${this.pendingRecoveredAgentsNotice}
               `Qwen Code is executing tool ${toolName}`
             );
             try {
+              try {
+                addToolArgumentsAttributes(
+                  this.config,
+                  toolSpan,
+                  invocation.params
+                );
+              } catch {
+                debugLogger6.debug(
+                  "[Session.runTool] Failed to record tool arguments telemetry"
+                );
+              }
               toolResult = await invocation.execute(
                 activeToolAbortSignal,
                 onToolProgress
@@ -7126,6 +7673,7 @@ ${this.pendingRecoveredAgentsNotice}
             }
             isExecutionTimeout = toolResult.error?.type === "execution_timeout" /* EXECUTION_TIMEOUT */;
             aborted = activeToolAbortSignal.aborted && !isExecutionTimeout;
+            settleRelatedAgent(!toolResult.error && !aborted);
             endToolExecutionSpan(execSpan, {
               success: !toolResult.error && !aborted,
               error: aborted ? "tool_cancelled" : isExecutionTimeout ? "tool_timeout" : toolResult.error ? "tool_error" : void 0,
@@ -7133,6 +7681,7 @@ ${this.pendingRecoveredAgentsNotice}
               ...heartbeatSpanAttributes()
             });
           } catch (execError) {
+            settleRelatedAgent(false);
             endToolExecutionSpan(execSpan, {
               success: false,
               error: activeToolAbortSignal.aborted ? "tool_cancelled" : "tool_exception",
@@ -7148,7 +7697,7 @@ ${this.pendingRecoveredAgentsNotice}
               this.#clearTodoStopGuardTrustAndDrainAutomaticQueues();
             }
           }
-          const responseParts = toolResult.error ? convertToFunctionErrorResponse(
+          let responseParts = toolResult.error ? convertToFunctionErrorResponse(
             toolName,
             callId,
             toolResult.llmContent,
@@ -7226,6 +7775,18 @@ ${this.pendingRecoveredAgentsNotice}
               artifacts: failureHookResult.artifacts
             });
           }
+          const visionBridgeNotices = [];
+          responseParts = await bridgeToolResultImages({
+            config: this.config,
+            responseParts,
+            signal: activeToolAbortSignal,
+            onFullTurnModel,
+            onVisionBridgeNotice: /* @__PURE__ */ __name((notice) => visionBridgeNotices.push(notice), "onVisionBridgeNotice")
+          });
+          const visionBridgeNotice = visionBridgeNotices.length > 0 ? visionBridgeNotices.join("\n") : void 0;
+          if (visionBridgeNotice) {
+            await this.messageEmitter.emitAgentMessage(visionBridgeNotice);
+          }
           if (isTodoWriteTool) {
             const todos = this.planEmitter.extractTodos(
               toolResult.returnDisplay,
@@ -7269,11 +7830,26 @@ ${this.pendingRecoveredAgentsNotice}
               callId,
               status,
               resultDisplay: toolResult.returnDisplay,
+              ...visionBridgeNotice !== void 0 ? { visionBridgeNotice } : {},
               error: toolResult.error ? new Error(toolResult.error.message) : void 0,
               errorType: toolResult.error?.type
             }
           });
           spanSuccess = succeeded;
+          if (succeeded && !nestedPermissionCancelled) {
+            const result = responseParts.find(
+              (part) => part.functionResponse !== void 0
+            )?.functionResponse?.response;
+            if (result !== void 0) {
+              try {
+                addToolCallResultAttributes(this.config, toolSpan, result);
+              } catch {
+                debugLogger6.debug(
+                  "[Session.runTool] Failed to record tool result telemetry"
+                );
+              }
+            }
+          }
           if (toolResult.error) {
             spanError = toolResult.error.message;
           } else if (aborted) {
@@ -7943,7 +8519,8 @@ function serializeMonitorTask(entry, now) {
     ...optionalField("pid", entry.pid),
     ...optionalField("exitCode", entry.exitCode),
     ...optionalField("error", entry.error),
-    ...optionalField("ownerAgentId", entry.ownerAgentId)
+    ...optionalField("ownerAgentId", entry.ownerAgentId),
+    ...optionalField("toolUseId", entry.toolUseId)
   };
 }
 __name(serializeMonitorTask, "serializeMonitorTask");
@@ -8131,6 +8708,9 @@ function buildAcpLocalReadRoots(config) {
     getUserAutoMemoryRoot(),
     ...config.storage.getUserSkillsDirs(),
     Storage.getUserExtensionsDir(),
+    // Saved plan files (see ReadFileTool.getDefaultPermission for why the
+    // plans dir must be readable without a confirmation prompt).
+    config.getPlansDir(),
     ...defaultAcpOnlyLocalReadRoots(),
     ...parseAcpLocalReadRootsEnv()
   ];
@@ -8182,6 +8762,32 @@ function isBulkLoadReplayRequest(params) {
   return meta?.[LOAD_REPLAY_MODE_META_KEY] === LOAD_REPLAY_BULK_MODE;
 }
 __name(isBulkLoadReplayRequest, "isBulkLoadReplayRequest");
+function shouldHideInheritedHistory(params) {
+  const meta = isObjectRecord(params._meta) ? params._meta : void 0;
+  return meta?.[LOAD_REPLAY_HIDE_INHERITED_META_KEY] === true;
+}
+__name(shouldHideInheritedHistory, "shouldHideInheritedHistory");
+function selectVisibleHistoryRecords(records, hideInheritedHistory) {
+  const sourceBoundary = records.findIndex(
+    (record) => record.type === "system" && record.subtype === "session_source" && isObjectRecord(record.systemPayload) && record.systemPayload["sourceType"] === "side_task"
+  );
+  if (sourceBoundary >= 0) {
+    return records.slice(sourceBoundary).filter((record) => record.forkedFrom === void 0);
+  }
+  return hideInheritedHistory ? records.filter((record) => record.forkedFrom === void 0) : records;
+}
+__name(selectVisibleHistoryRecords, "selectVisibleHistoryRecords");
+function isChannelSessionRequest(params) {
+  const meta = isObjectRecord(params._meta) ? params._meta : void 0;
+  const value = meta?.[SESSION_SOURCE_META_KEY];
+  return isObjectRecord(value) && value["sourceType"] === "channel";
+}
+__name(isChannelSessionRequest, "isChannelSessionRequest");
+function shouldDeferMcpDiscovery(params) {
+  const meta = isObjectRecord(params._meta) ? params._meta : void 0;
+  return meta?.[WORKTREE_MCP_DEFER_META_KEY] === true;
+}
+__name(shouldDeferMcpDiscovery, "shouldDeferMcpDiscovery");
 function getLoadReplayPageSize(params) {
   const meta = isObjectRecord(params._meta) ? params._meta : void 0;
   const value = meta?.[LOAD_REPLAY_PAGE_SIZE_META_KEY];
@@ -9611,7 +10217,97 @@ async function deliverClientMcpMessage(connection, serverName, message, sessionI
   return payload;
 }
 __name(deliverClientMcpMessage, "deliverClientMcpMessage");
+function readRuntimeMcpRequest(params) {
+  const name = params["name"];
+  if (typeof name !== "string" || name.length === 0) {
+    throw RequestError.invalidParams(void 0, "Invalid or missing name");
+  }
+  if (!isValidServerName(name)) {
+    throw RequestError.invalidParams(
+      void 0,
+      "Server name must be \u2264256 chars, alphanumeric + underscore/hyphen, and not a reserved JS property name"
+    );
+  }
+  const originatorClientId = params["originatorClientId"];
+  return {
+    name,
+    runtimeClientId: typeof originatorClientId === "string" && originatorClientId.length > 0 ? originatorClientId : "daemon"
+  };
+}
+__name(readRuntimeMcpRequest, "readRuntimeMcpRequest");
+function readRuntimeMcpAddRequest(params) {
+  const request = readRuntimeMcpRequest(params);
+  const config = params["config"];
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    throw RequestError.invalidParams(void 0, "Invalid or missing config");
+  }
+  const {
+    trust: _trust,
+    authProviderType: _auth,
+    includeTools: _inc,
+    excludeTools: _exc,
+    cwd: _cwd,
+    env: _env,
+    oauth: _oauth,
+    headers: _headers,
+    type: _type,
+    [CLIENT_MCP_OVER_WS_CONFIG_FLAG]: clientMcpOverWs,
+    ...safeConfig
+  } = config;
+  if (clientMcpOverWs === true) {
+    safeConfig["type"] = "sdk";
+  }
+  return {
+    ...request,
+    config: safeConfig
+  };
+}
+__name(readRuntimeMcpAddRequest, "readRuntimeMcpAddRequest");
+function getRuntimeMcpManager(config) {
+  const manager = config.getToolRegistry()?.getMcpClientManager();
+  if (!manager) {
+    throw RequestError.internalError(
+      void 0,
+      "McpClientManager unavailable on this Config"
+    );
+  }
+  return manager;
+}
+__name(getRuntimeMcpManager, "getRuntimeMcpManager");
+async function addRuntimeMcpServer(manager, request) {
+  try {
+    return await manager.addRuntimeMcpServer(
+      request.name,
+      request.config,
+      request.runtimeClientId
+    );
+  } catch (err) {
+    if (err instanceof McpBudgetWouldExceedError) {
+      throw new RequestError(-32099, err.message, {
+        errorKind: err.code,
+        serverName: err.serverName
+      });
+    }
+    if (err instanceof McpServerSpawnFailedError) {
+      throw new RequestError(-32099, err.message, {
+        errorKind: err.code,
+        serverName: err.serverName,
+        ...err.details
+      });
+    }
+    if (err instanceof InvalidMcpConfigError) {
+      throw new RequestError(-32099, err.message, {
+        errorKind: err.code,
+        serverName: err.serverName,
+        reason: err.reason
+      });
+    }
+    throw err;
+  }
+}
+__name(addRuntimeMcpServer, "addRuntimeMcpServer");
 async function runAcpAgent(config, settings, argv, options) {
+  const sessionWriterLeaseEnabledAtStartup = typeof config.isSessionWriterLeaseEnabled === "function" ? config.isSessionWriterLeaseEnabled() : settings.merged.experimental?.sessionWriterLease === true;
   const privateParentCapability = options === void 0 ? process.env[PRIVATE_ACP_CAPABILITY_ENV] : options.privateParentCapability;
   delete process.env[PRIVATE_ACP_CAPABILITY_ENV];
   let acpConnection;
@@ -9651,12 +10347,31 @@ async function runAcpAgent(config, settings, argv, options) {
     console.info = console.error;
     console.debug = console.error;
     let initializeRequestId;
+    const pendingNewSessionRequestIds = /* @__PURE__ */ new Set();
     const stream = ndJsonStream(stdout, stdin, {
       onMessageObserved: /* @__PURE__ */ __name(({ direction, message }) => {
-        if (direction === "received" && "id" in message && "method" in message && message.method === "initialize") {
-          initializeRequestId = message.id;
+        if (direction === "received" && "id" in message && "method" in message) {
+          if (message.method === "session/new") {
+            pendingNewSessionRequestIds.add(message.id);
+          } else if (message.method === "initialize") {
+            initializeRequestId = message.id;
+          }
           return;
         }
+        if (direction === "sent" && "id" in message && !("method" in message) && pendingNewSessionRequestIds.delete(message.id) && "result" in message && typeof message.result === "object" && message.result !== null && "sessionId" in message.result && typeof message.result.sessionId === "string") {
+          const sessionId = message.result.sessionId;
+          setImmediate(() => {
+            const session = agentInstance?.getActiveSessions().find((candidate) => candidate.getId() === sessionId);
+            if (!session) return;
+            void preloadContentGenerator(
+              session.getConfig().getContentGenerator()
+            ).catch((error) => {
+              debugLogger7.debug(
+                `[ACP] Session provider preload failed for ${sessionId}: ${error instanceof Error ? error.message : String(error)}`
+              );
+            });
+          }).unref();
+        }
         if (direction !== "sent" || initializeRequestId === void 0 || !("id" in message) || "method" in message || message.id !== initializeRequestId) {
           return;
         }
@@ -9675,7 +10390,8 @@ async function runAcpAgent(config, settings, argv, options) {
         settings,
         argv,
         conn,
-        privateParentCapability
+        privateParentCapability,
+        sessionWriterLeaseEnabledAtStartup
       );
       return agentInstance;
     }, stream);
@@ -9684,29 +10400,34 @@ async function runAcpAgent(config, settings, argv, options) {
     eventLoopMonitor.dispose();
     throw err;
   }
-  const drainPoolBeforeExit = /* @__PURE__ */ __name(async (label) => {
+  const drainPoolBeforeExit = /* @__PURE__ */ __name(async (label, strict = false) => {
     if (!agentInstance) return;
     try {
       await agentInstance.shutdownMcpPool(8e3);
     } catch (err) {
       debugLogger7.error(`[ACP] MCP pool drain (${label}) error:`, err);
+      if (strict) throw err;
     }
   }, "drainPoolBeforeExit");
   let shuttingDown = false;
+  let managedShutdownPromise;
   let sessionEndFired = false;
-  const fireSessionEndOnce = /* @__PURE__ */ __name(async (reason) => {
+  const fireSessionEndOnce = /* @__PURE__ */ __name(async (reason, managedConfigs) => {
     if (sessionEndFired) return;
     sessionEndFired = true;
-    const configs = /* @__PURE__ */ new Set([config]);
-    const sessions = agentInstance?.getActiveSessions();
-    if (sessions) {
-      for (const session of sessions) {
-        const sessionConfig = session.getConfig?.();
-        if (sessionConfig) {
-          configs.add(sessionConfig);
+    const configs = new Set(managedConfigs ?? [config]);
+    if (!managedConfigs) {
+      const sessions = agentInstance?.getActiveSessions();
+      if (sessions) {
+        for (const session of sessions) {
+          const sessionConfig = session.getConfig?.();
+          if (sessionConfig) {
+            configs.add(sessionConfig);
+          }
         }
       }
     }
+    const failures = [];
     for (const cfg of configs) {
       const hookSystem = cfg.getHookSystem?.();
       const hooksEnabled = !cfg.getDisableAllHooks?.();
@@ -9716,16 +10437,99 @@ async function runAcpAgent(config, settings, argv, options) {
       try {
         await hookSystem.fireSessionEndEvent(reason);
       } catch (err) {
+        if (managedConfigs) failures.push(err);
         debugLogger7.warn(
           `SessionEnd hook failed: ${err instanceof Error ? err.message : String(err)}`
         );
       }
     }
+    if (failures.length > 0) {
+      throw new AggregateError(failures, "SessionEnd hook shutdown failed");
+    }
   }, "fireSessionEndOnce");
+  const shutdownManagedAgent = /* @__PURE__ */ __name((reason, label) => {
+    if (managedShutdownPromise) return managedShutdownPromise;
+    const agent = agentInstance;
+    if (!agent?.isTrustedManagedParent()) {
+      return Promise.reject(
+        new Error("Managed shutdown requires a trusted private parent")
+      );
+    }
+    const terminal = agent.beginManagedShutdown();
+    managedShutdownPromise = (async () => {
+      const failures = [];
+      try {
+        await terminal.writerShutdown;
+      } catch (error) {
+        failures.push(error);
+        debugLogger7.error("[ACP] Managed writer shutdown error:", error);
+        const retainedLockPaths = terminal.configs.flatMap((config2) => {
+          if (typeof config2.getSessionRuntimeBaseDir !== "function" || typeof config2.getSessionId !== "function") {
+            return [];
+          }
+          return [
+            path4.join(
+              config2.getSessionRuntimeBaseDir(),
+              "tmp",
+              "session-writer-locks",
+              `${encodeURIComponent(config2.getSessionId())}.lock`
+            )
+          ];
+        });
+        writeStderrLineSafe(
+          "qwen --acp: managed session writer shutdown failed; a writer lock may be retained for safety. Verify that no previous writer is running before manual cleanup." + (retainedLockPaths.length > 0 ? ` Candidate lock paths: ${retainedLockPaths.join(", ")}` : "")
+        );
+      }
+      try {
+        await fireSessionEndOnce(reason, terminal.configs);
+      } catch (error) {
+        failures.push(error);
+      }
+      try {
+        await agent.finishManagedShutdown(terminal.configs);
+      } catch (error) {
+        failures.push(error);
+        debugLogger7.error("[ACP] Managed resource shutdown error:", error);
+      }
+      try {
+        await drainPoolBeforeExit(label, true);
+      } catch (error) {
+        failures.push(error);
+      }
+      try {
+        await runExitCleanup();
+      } catch (error) {
+        failures.push(error);
+        debugLogger7.error("[ACP] Cleanup error:", error);
+      }
+      if (failures.length > 0) {
+        throw new AggregateError(failures, "Managed ACP shutdown failed");
+      }
+    })();
+    return managedShutdownPromise;
+  }, "shutdownManagedAgent");
   const shutdownHandler = /* @__PURE__ */ __name(async () => {
     if (shuttingDown) return;
     shuttingDown = true;
     debugLogger7.debug("[ACP] Shutdown signal received, closing streams");
+    if (agentInstance?.isTrustedManagedParent()) {
+      let exitCode = 0;
+      try {
+        await shutdownManagedAgent("other" /* Other */, "signal");
+      } catch (err) {
+        exitCode = 1;
+        debugLogger7.error("[ACP] Managed shutdown error:", err);
+      } finally {
+        eventLoopMonitor.dispose();
+      }
+      try {
+        process.stdin.destroy();
+        process.stdout.destroy();
+      } catch {
+      }
+      process.exit(exitCode);
+      return;
+    }
     try {
       await fireSessionEndOnce("other" /* Other */);
       await agentInstance?.disposeSessions();
@@ -9753,9 +10557,21 @@ async function runAcpAgent(config, settings, argv, options) {
   process.on("SIGINT", shutdownHandler);
   try {
     await connection.closed;
-    await fireSessionEndOnce("prompt_input_exit" /* PromptInputExit */);
-    await drainPoolBeforeExit("ide_close");
-    await agentInstance?.disposeSessions();
+    if (agentInstance?.isTrustedManagedParent()) {
+      try {
+        await shutdownManagedAgent(
+          "prompt_input_exit" /* PromptInputExit */,
+          "ide_close"
+        );
+      } catch (error) {
+        process.exitCode = 1;
+        throw error;
+      }
+    } else {
+      await fireSessionEndOnce("prompt_input_exit" /* PromptInputExit */);
+      await drainPoolBeforeExit("ide_close");
+      await agentInstance?.disposeSessions();
+    }
   } finally {
     process.off("SIGTERM", shutdownHandler);
     process.off("SIGINT", shutdownHandler);
@@ -9872,12 +10688,13 @@ function parseAcpSessionListCursor(value) {
 }
 __name(parseAcpSessionListCursor, "parseAcpSessionListCursor");
 var QwenAgent = class {
-  constructor(config, settings, argv, connection, expectedPrivateParentCapability) {
+  constructor(config, settings, argv, connection, expectedPrivateParentCapability, sessionWriterLeaseEnabledAtStartup = false) {
     this.config = config;
     this.settings = settings;
     this.argv = argv;
     this.connection = connection;
     this.expectedPrivateParentCapability = expectedPrivateParentCapability;
+    this.sessionWriterLeaseEnabledAtStartup = sessionWriterLeaseEnabledAtStartup;
     if (process.env["QWEN_SERVE_NO_MCP_POOL"] === "1") {
       this.mcpPool = void 0;
       this.workspaceMcpBudget = void 0;
@@ -9912,12 +10729,15 @@ var QwenAgent = class {
   workspaceMcpDiscoveryConfig;
   workspaceMcpDiscoveryPromise;
   workspaceMcpDiscoveryError;
+  workspaceExtensionStatusRefreshPromise;
   pendingMcpAuthentications = /* @__PURE__ */ new Map();
   mcpAuthenticationResults = /* @__PURE__ */ new Map();
   generationControllers = /* @__PURE__ */ new Map();
   workspaceGenerationControllers = /* @__PURE__ */ new Map();
   transcriptReplayConfigCache = /* @__PURE__ */ new Map();
   pendingConfigCleanup = /* @__PURE__ */ new Map();
+  initializingConfigs = /* @__PURE__ */ new Set();
+  managedShuttingDown = false;
   clientCapabilities;
   privateParentState = "uninitialized";
   // CPU-usage delta baseline for the daemon's `workspaceResource` extMethod
@@ -9951,12 +10771,141 @@ var QwenAgent = class {
   getActiveSessions() {
     return [...this.sessions.values()];
   }
+  isTrustedManagedParent() {
+    return this.privateParentState === "trusted";
+  }
+  assertManagedSessionAdmission() {
+    if (this.expectedPrivateParentCapability !== void 0 && !this.isTrustedManagedParent()) {
+      throw RequestError.invalidParams(
+        void 0,
+        "Private ACP parent is not initialized"
+      );
+    }
+    if (this.managedShuttingDown) {
+      throw new SessionWriterUnavailableError();
+    }
+  }
+  beginManagedShutdown() {
+    if (!this.isTrustedManagedParent()) {
+      throw new Error("Managed shutdown requires a trusted private parent");
+    }
+    this.managedShuttingDown = true;
+    for (const generation of this.generationControllers.values()) {
+      generation.controller.abort();
+    }
+    this.generationControllers.clear();
+    for (const controller of this.workspaceGenerationControllers.values()) {
+      controller.abort();
+    }
+    this.workspaceGenerationControllers.clear();
+    const configs = /* @__PURE__ */ new Set([this.config, ...this.initializingConfigs]);
+    for (const session of this.sessions.values()) {
+      try {
+        session.beginCloseIfAvailable();
+      } catch (error) {
+        debugLogger7.debug(
+          `Session ${session.getId()} admission close during managed shutdown failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+      void session.cancelPendingPrompt().catch((error) => {
+        debugLogger7.debug(
+          `Session ${session.getId()} cancel during managed shutdown failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      });
+      configs.add(session.getConfig());
+    }
+    for (const pending of this.pendingConfigCleanup.values()) {
+      for (const config of pending) configs.add(config);
+    }
+    const configList = [...configs];
+    const writerTerminals = [];
+    for (const config of configList) {
+      try {
+        writerTerminals.push(config.closeSessionWriter({ handoff: true }));
+      } catch (error) {
+        writerTerminals.push(Promise.reject(error));
+      }
+    }
+    const writerShutdown = Promise.allSettled(writerTerminals).then(
+      (results) => {
+        const failures = results.flatMap(
+          (result) => result.status === "rejected" ? [result.reason] : []
+        );
+        if (failures.length > 0) {
+          throw new AggregateError(
+            failures,
+            "Managed session writer shutdown failed"
+          );
+        }
+      }
+    );
+    return { configs: configList, writerShutdown };
+  }
+  async finishManagedShutdown(configs) {
+    const failures = [];
+    for (const [sessionId, session] of [...this.sessions]) {
+      await this.removeStoredSessionEntry(sessionId, session, failures, {
+        shutdownConfig: false
+      });
+    }
+    const results = await Promise.allSettled(
+      configs.map(
+        (config) => config.shutdown({
+          shutdownTelemetry: false,
+          skipSessionWriter: true,
+          strictResourceCleanup: true
+        })
+      )
+    );
+    for (const result of results) {
+      if (result.status === "rejected") failures.push(result.reason);
+    }
+    this.initializingConfigs.clear();
+    this.pendingConfigCleanup.clear();
+    this.disposeTranscriptReplayConfigs();
+    if (failures.length > 0) {
+      throw new AggregateError(failures, "Managed session cleanup failed");
+    }
+  }
   getWorkspaceMcpConfig(serverName) {
     if (serverName && this.config.getRuntimeMcpServers?.()[serverName] !== void 0) {
       return this.config;
     }
     return this.workspaceMcpDiscoveryConfig ?? this.config;
   }
+  refreshBootstrapExtensionStatus() {
+    if (this.workspaceExtensionStatusRefreshPromise) {
+      return this.workspaceExtensionStatusRefreshPromise;
+    }
+    const promise = (async () => {
+      const errors = [];
+      try {
+        await this.config.getExtensionManager().refreshCache();
+      } catch (error) {
+        errors.push(error);
+      }
+      try {
+        await this.config.getSkillManager()?.refreshCache();
+      } catch (error) {
+        errors.push(error);
+      }
+      if (errors.length === 1) throw errors[0];
+      if (errors.length > 1) {
+        throw new AggregateError(
+          errors,
+          "Bootstrap extension status refresh failed"
+        );
+      }
+    })();
+    this.workspaceExtensionStatusRefreshPromise = promise;
+    const clear = /* @__PURE__ */ __name(() => {
+      if (this.workspaceExtensionStatusRefreshPromise === promise) {
+        this.workspaceExtensionStatusRefreshPromise = void 0;
+      }
+    }, "clear");
+    void promise.then(clear, clear);
+    return promise;
+  }
   getLiveMcpConfigs(serverName) {
     return [
       .../* @__PURE__ */ new Set([
@@ -10093,16 +11042,18 @@ var QwenAgent = class {
       for (const config of liveConfigs) {
         try {
           const cwd = config.getTargetDir();
-          const mcpServers = assembleMcpServers(
+          const isBareOrSafe = config.getBareMode() || config.isSafeMode();
+          const mcpServers = isBareOrSafe ? { ...config.getTopTierMcpServers() } : assembleMcpServers(
             settings.merged.mcpServers,
             cwd,
             config.getTopTierMcpServers()
           );
-          const gating = recomputeMcpGating(
+          const bootAllowed = config.getCliAllowedMcpServerNames();
+          const gating = isBareOrSafe ? { allowed: bootAllowed ? [...bootAllowed] : void 0 } : recomputeMcpGating(
             settings,
             mcpServers,
             cwd,
-            config.getCliAllowedMcpServerNames(),
+            bootAllowed,
             config.getApprovalMode() === "yolo" /* YOLO */
           );
           config.setExcludedMcpServers(gating.excluded ?? []);
@@ -10195,11 +11146,15 @@ var QwenAgent = class {
         debugLogger7.warn(
           `MCP pool drain: ${result.drained} clean, ${result.forced} timed out, ${result.errors.length} errors`
         );
+        throw new Error(
+          `MCP pool drain incomplete: ${result.forced} forced, ${result.errors.length} errors`
+        );
       }
     } catch (err) {
       debugLogger7.error(
         `MCP pool drainAll failed: ${err instanceof Error ? err.message : String(err)}`
       );
+      throw err;
     }
   }
   async removeStoredSessionEntry(sessionId, session, cleanupErrors = [], options = {}) {
@@ -10270,11 +11225,13 @@ var QwenAgent = class {
     try {
       await shutdownSessionConfig(config);
     } catch (error) {
+      this.initializingConfigs.delete(config);
       const pending2 = this.pendingConfigCleanup.get(cleanupKey) ?? /* @__PURE__ */ new Set();
       pending2.add(config);
       this.pendingConfigCleanup.set(cleanupKey, pending2);
       throw mapSessionWriterRequestError(error);
     }
+    this.initializingConfigs.delete(config);
     const pending = this.pendingConfigCleanup.get(cleanupKey);
     pending?.delete(config);
     if (pending?.size === 0) {
@@ -10289,7 +11246,7 @@ var QwenAgent = class {
         `Session cleanup failed while preserving the original request error: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`
       );
     }
-    throw error;
+    throw mapSessionWriterRequestError(error);
   }
   pendingConfigCleanupKey(runtimeBaseDir, sessionId) {
     return `${path4.resolve(runtimeBaseDir)}\0${sessionId}`;
@@ -10479,7 +11436,7 @@ var QwenAgent = class {
     }
     this.clientCapabilities = args.clientCapabilities;
     const authMethods = buildAuthMethods();
-    const version = "0.21.0";
+    const version = "0.21.1-nightly.20260731.702932cc7";
     const response = {
       protocolVersion: PROTOCOL_VERSION,
       agentInfo: {
@@ -10553,6 +11510,7 @@ var QwenAgent = class {
   }
   async newSession(params) {
     const { cwd, mcpServers } = params;
+    const isChannelSession = isChannelSessionRequest(params);
     const parentContext = extractDaemonTraceContext(params);
     return await withDaemonSpan(
       "qwen-code.daemon.session_start",
@@ -10566,7 +11524,15 @@ var QwenAgent = class {
         this.settings = settings;
         const config = await profiler.time(
           "config_setup",
-          () => this.newSessionConfig(cwd, mcpServers, settings)
+          () => this.newSessionConfig(
+            cwd,
+            mcpServers,
+            settings,
+            isChannelSession,
+            void 0,
+            void 0,
+            shouldDeferMcpDiscovery(params) ? { skipMcpDiscovery: true } : void 0
+          )
         );
         let session;
         try {
@@ -10598,6 +11564,7 @@ var QwenAgent = class {
     );
   }
   async loadSession(params) {
+    const isChannelSession = isChannelSessionRequest(params);
     const settings = loadSettingsCached(params.cwd);
     const liveSession = this.sessions.get(params.sessionId);
     if (liveSession) {
@@ -10614,9 +11581,16 @@ var QwenAgent = class {
             ...sessionData2.artifactSnapshot ? { artifactSnapshot: sessionData2.artifactSnapshot } : {}
           };
           const records = sessionData2.conversation.messages;
-          if (records.length === 0) return response2;
+          const visibleRecords = selectVisibleHistoryRecords(
+            records,
+            shouldHideInheritedHistory(params)
+          );
+          if (visibleRecords.length === 0) return response2;
           const bulkReplay2 = isBulkLoadReplayRequest(params);
-          const replayPage = bulkReplay2 ? selectRecentHistoryRecords(records, getLoadReplayPageSize(params)) : { records, hasMore: false };
+          const replayPage = bulkReplay2 ? selectRecentHistoryRecords(
+            visibleRecords,
+            getLoadReplayPageSize(params)
+          ) : { records: visibleRecords, hasMore: false };
           const replay = await collectHistoryReplayUpdates({
             sessionId: params.sessionId,
             config: config2,
@@ -10668,22 +11642,70 @@ var QwenAgent = class {
       // a `null`/`undefined` would otherwise throw `TypeError`.
       params.mcpServers ?? [],
       settings,
+      isChannelSession,
       params.sessionId,
       true
     );
     const sessionData = config.getResumedSessionData();
     const bulkReplay = isBulkLoadReplayRequest(params);
     const replayPageSize = bulkReplay ? getLoadReplayPageSize(params) : void 0;
-    let session;
+    let replayEnvelope;
     try {
       await this.ensureAuthenticated(config);
       this.setupFileSystem(config);
-      session = await this.createAndStoreSession(
-        config,
-        settings,
-        sessionData,
-        bulkReplay ? { replayHistory: false, startPostReplayServices: false } : {}
-      );
+      await this.createAndStoreSession(config, settings, sessionData, {
+        ...bulkReplay ? { replayHistory: false } : {},
+        beforeStartPostReplayServices: /* @__PURE__ */ __name(async (createdSession) => {
+          if (bulkReplay) {
+            const records = sessionData?.conversation.messages;
+            let replayUpdates = [];
+            if (records) {
+              createdSession.primeTurnFromHistory(records);
+              const visibleRecords = selectVisibleHistoryRecords(
+                records,
+                shouldHideInheritedHistory(params)
+              );
+              const replayPage = selectRecentHistoryRecords(
+                visibleRecords,
+                replayPageSize
+              );
+              const replayUsage = createReplayCumulativeUsage();
+              const replay = await collectHistoryReplayUpdates({
+                sessionId: params.sessionId,
+                config,
+                records: replayPage.records,
+                gaps: sessionData?.historyGaps,
+                cumulativeUsage: replayUsage,
+                supersedeUnrestorableGoal: true,
+                logger: debugLogger7
+              });
+              replayUpdates = replay.updates;
+              copyCumulativeUsage(createdSession.cumulativeUsage, replayUsage);
+              if (replay.replayError !== void 0) {
+                replayEnvelope = {
+                  v: LOAD_REPLAY_VERSION,
+                  updates: replayUpdates,
+                  partial: true,
+                  replayError: replay.replayError,
+                  ...replayPage.hasMore ? { hasMore: true } : {}
+                };
+              }
+              replayEnvelope ??= {
+                v: LOAD_REPLAY_VERSION,
+                updates: replayUpdates,
+                ...replayPage.hasMore ? { hasMore: true } : {}
+              };
+            }
+            replayEnvelope ??= {
+              v: LOAD_REPLAY_VERSION,
+              updates: replayUpdates
+            };
+          }
+          await this.#restoreWorktreeOnResume(config, createdSession);
+          await this.#restoreBackgroundAgentsOnResume(config, createdSession);
+          this.#restoreGoalOnResume(config, createdSession);
+        }, "beforeStartPostReplayServices")
+      });
     } catch (error) {
       return this.cleanupAfterRequestFailure(error, async () => {
         if (this.sessions.get(config.getSessionId())?.getConfig() !== config) {
@@ -10691,72 +11713,6 @@ var QwenAgent = class {
         }
       });
     }
-    let replayEnvelope;
-    if (bulkReplay) {
-      try {
-        const records = sessionData?.conversation.messages;
-        let replayUpdates = [];
-        if (records) {
-          session.primeTurnFromHistory(records);
-          const replayPage = selectRecentHistoryRecords(
-            records,
-            replayPageSize
-          );
-          const replayUsage = createReplayCumulativeUsage();
-          const replay = await collectHistoryReplayUpdates({
-            sessionId: params.sessionId,
-            config,
-            records: replayPage.records,
-            gaps: sessionData?.historyGaps,
-            cumulativeUsage: replayUsage,
-            // A resume: the goal restore runs right after this.
-            supersedeUnrestorableGoal: true,
-            logger: debugLogger7
-          });
-          replayUpdates = replay.updates;
-          copyCumulativeUsage(session.cumulativeUsage, replayUsage);
-          if (replay.replayError !== void 0) {
-            replayEnvelope = {
-              v: LOAD_REPLAY_VERSION,
-              updates: replayUpdates,
-              partial: true,
-              replayError: replay.replayError,
-              ...replayPage.hasMore ? { hasMore: true } : {}
-            };
-          }
-          replayEnvelope ??= {
-            v: LOAD_REPLAY_VERSION,
-            updates: replayUpdates,
-            ...replayPage.hasMore ? { hasMore: true } : {}
-          };
-        }
-        replayEnvelope ??= {
-          v: LOAD_REPLAY_VERSION,
-          updates: replayUpdates
-        };
-        session.installRewriter();
-        session.startCronScheduler();
-      } catch (err) {
-        return this.cleanupAfterRequestFailure(err, async () => {
-          try {
-            await this.discardStoredSessionIfCurrent(params.sessionId, session);
-          } catch (cleanupError) {
-            await this.removeStoredSessionEntry(
-              params.sessionId,
-              session,
-              [cleanupError],
-              {
-                shutdownConfig: false
-              }
-            );
-            await this.cleanupUnstoredConfig(config);
-          }
-        });
-      }
-    }
-    await this.#restoreWorktreeOnResume(config, session);
-    await this.#restoreBackgroundAgentsOnResume(config, session);
-    this.#restoreGoalOnResume(config, session);
     const modesData = this.buildModesData(config);
     const availableModels = this.buildAvailableModels(config);
     const configOptions = this.buildConfigOptions(config);
@@ -10777,6 +11733,7 @@ var QwenAgent = class {
     };
   }
   async unstable_resumeSession(params) {
+    const isChannelSession = isChannelSessionRequest(params);
     const settings = loadSettingsCached(params.cwd);
     const liveSession = this.sessions.get(params.sessionId);
     if (liveSession) {
@@ -10809,18 +11766,25 @@ var QwenAgent = class {
       params.cwd,
       params.mcpServers ?? [],
       settings,
+      isChannelSession,
       params.sessionId,
       true
     );
-    let session;
     try {
       await this.ensureAuthenticated(config);
       this.setupFileSystem(config);
-      session = await this.createAndStoreSession(
+      await this.createAndStoreSession(
         config,
         settings,
         config.getResumedSessionData(),
-        { replayHistory: false }
+        {
+          replayHistory: false,
+          beforeStartPostReplayServices: /* @__PURE__ */ __name(async (createdSession) => {
+            await this.#restoreWorktreeOnResume(config, createdSession);
+            await this.#restoreBackgroundAgentsOnResume(config, createdSession);
+            this.#restoreGoalOnResume(config, createdSession);
+          }, "beforeStartPostReplayServices")
+        }
       );
     } catch (error) {
       return this.cleanupAfterRequestFailure(error, async () => {
@@ -10829,9 +11793,6 @@ var QwenAgent = class {
         }
       });
     }
-    await this.#restoreWorktreeOnResume(config, session);
-    await this.#restoreBackgroundAgentsOnResume(config, session);
-    this.#restoreGoalOnResume(config, session);
     const modesData = this.buildModesData(config);
     const availableModels = this.buildAvailableModels(config);
     const configOptions = this.buildConfigOptions(config);
@@ -11732,34 +12693,70 @@ var QwenAgent = class {
       ...inferred ? { errorKind: inferred } : {}
     };
   }
+  /**
+   * Keeps the extension-derived half of the skill snapshot self-healing.
+   *
+   * Skills have a watcher (`SkillManager.startWatching`); extensions do not, so
+   * without this the child would never notice an extension installed, removed,
+   * enabled, or disabled outside the daemon — and extension-level skills are
+   * derived from that set, so a skill-watcher tick alone cannot recover it.
+   *
+   * The check is one `readdir` plus a bounded number of `stat`s, and refreshes
+   * only when the sources actually moved, so a steady-state read still parses
+   * no manifest and no `SKILL.md`. Failures are logged and swallowed: a status
+   * read must not fail because revalidation could not run.
+   *
+   * Skipped in safe and bare mode. Those modes deliberately never populate the
+   * extension cache (`Config.initialize` omits the refresh), and the snapshot
+   * derives extension skills from `getExtensions()` — so revalidating here
+   * would load the extensions those modes exist to exclude.
+   */
+  async revalidateExtensionSources(config) {
+    try {
+      if (config.isSafeMode() || config.getBareMode()) return;
+      const changed = await config.getExtensionManager().refreshCacheIfSourcesChanged();
+      if (!changed) return;
+      await config.getSkillManager()?.refreshCache();
+    } catch (error) {
+      debugLogger7.warn("Extension source revalidation failed:", error);
+    }
+  }
   async buildWorkspaceSkillsStatus(config) {
     const skillManager = config.getSkillManager();
     if (!skillManager) {
       return {
         v: STATUS_SCHEMA_VERSION,
         workspaceCwd: this.workspaceCwd(config),
-        initialized: true,
+        initialized: false,
         skills: []
       };
     }
+    await this.revalidateExtensionSources(config);
     try {
-      const disabled = config.getDisabledSkillNames();
-      try {
-        await config.getExtensionManager().refreshCache();
-      } catch (error) {
-        debugLogger7.warn("Extension cache refresh failed:", error);
-      }
-      try {
-        await skillManager.refreshCache();
-      } catch (error) {
-        debugLogger7.warn("Skill cache refresh failed:", error);
+      const skills = skillManager.getCachedSkills();
+      if (skills === null) {
+        return {
+          v: STATUS_SCHEMA_VERSION,
+          workspaceCwd: this.workspaceCwd(config),
+          initialized: false,
+          skills: []
+        };
       }
-      const skills = await skillManager.listSkills();
+      const resolved = resolveSkillSettings(this.settings);
+      const disablements = new Map(
+        Array.from(config.getDisabledSkillNames(), (name) => {
+          const normalizedName = name.trim().toLowerCase();
+          return [
+            normalizedName,
+            resolved.disablements.get(normalizedName) ?? { reason: "hard" }
+          ];
+        })
+      );
       const inactiveSkillRefs = inactiveExtensionSkillRefs(config);
       const skillsByKey = new Map(
         skills.map((skill) => [
           `${skill.level}:${skill.extensionName ?? ""}:${skill.name}`,
-          mapSkillConfigToStatus(skill, disabled, {
+          mapSkillConfigToStatus(skill, disablements, {
             disabled: isInactiveExtensionSkill(skill, inactiveSkillRefs)
           })
         ])
@@ -11780,7 +12777,7 @@ var QwenAgent = class {
                 level: "extension",
                 extensionName
               },
-              disabled,
+              disablements,
               { disabled: true }
             )
           );
@@ -12840,12 +13837,19 @@ var QwenAgent = class {
       }
       case TODO_STOP_GUARD_QUEUE_RELEASE_METHOD: {
         const sessionId = params["sessionId"];
+        const promptId = params["promptId"];
         if (typeof sessionId !== "string" || sessionId.length === 0) {
           throw RequestError.invalidParams(
             void 0,
             "Invalid or missing sessionId"
           );
         }
+        if (typeof promptId !== "string" || promptId.length === 0) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Invalid or missing promptId"
+          );
+        }
         const session = this.sessions.get(sessionId);
         if (!session) {
           throw RequestError.invalidParams(
@@ -12854,7 +13858,7 @@ var QwenAgent = class {
           );
         }
         return {
-          released: session.releaseTodoStopGuardQueuedPromptWait()
+          released: session.releaseTodoStopGuardQueuedPromptWait(promptId)
         };
       }
       case "qwen/providers/list": {
@@ -14275,10 +15279,12 @@ var QwenAgent = class {
           }
         }
         const previousCwd = config.getTargetDir();
-        if (canonicalPath === previousCwd) {
-          return { previousCwd, newCwd: canonicalPath, warnings: [] };
-        }
-        if (isFolderTrustEnabled(this.settings.merged)) {
+        let trustValidated = false;
+        const validateTrust = /* @__PURE__ */ __name(() => {
+          if (!isFolderTrustEnabled(this.settings.merged)) {
+            trustValidated = true;
+            return;
+          }
           const trustedFolders = loadTrustedFolders();
           if (trustedFolders.isPathTrusted(canonicalPath) !== true) {
             throw new RequestError(
@@ -14287,27 +15293,67 @@ var QwenAgent = class {
               { errorKind: "directory_not_trusted", path: canonicalPath }
             );
           }
+          trustValidated = true;
+        }, "validateTrust");
+        if (canonicalPath !== previousCwd) {
+          validateTrust();
         }
-        const warnings = [];
-        const relocation = await config.relocateWorkingDirectory(
-          canonicalPath,
-          canonicalPath,
-          { skipProcessChdir: true, skipArtifactMigration: true }
+        const releaseGate = await beginSessionCloseAfterCurrentGate(
+          session,
+          SESSION_DRAIN_TIMEOUT_MS
         );
-        if (relocation.memoryRefreshError) {
-          warnings.push(
-            `Memory refresh failed: ${relocation.memoryRefreshError instanceof Error ? relocation.memoryRefreshError.message : String(relocation.memoryRefreshError)}`
-          );
-        }
         try {
-          await config.getGeminiClient()?.addWorkingDirectoryChangedContext(previousCwd, canonicalPath);
-        } catch (error) {
-          warnings.push(
-            `Model context refresh failed: ${error instanceof Error ? error.message : String(error)}`
+          const settledPreviousCwd = config.getTargetDir();
+          if (canonicalPath === settledPreviousCwd) {
+            return {
+              previousCwd: settledPreviousCwd,
+              newCwd: canonicalPath,
+              warnings: []
+            };
+          }
+          if (!trustValidated) {
+            validateTrust();
+          }
+          session.hardSuspendTodoStopGuard();
+          await waitForSessionDrain(
+            session.waitForActiveTurnsToSettle(),
+            SESSION_DRAIN_TIMEOUT_MS,
+            "close"
+          );
+          const warnings = [];
+          const relocation = await config.relocateWorkingDirectory(
+            canonicalPath,
+            canonicalPath,
+            { skipProcessChdir: true, skipArtifactMigration: true }
           );
+          if (relocation.memoryRefreshError) {
+            warnings.push(
+              `Memory refresh failed: ${relocation.memoryRefreshError instanceof Error ? relocation.memoryRefreshError.message : String(relocation.memoryRefreshError)}`
+            );
+          }
+          if (relocation.mcpRefreshError) {
+            warnings.push(
+              `MCP refresh failed: ${relocation.mcpRefreshError instanceof Error ? relocation.mcpRefreshError.message : String(relocation.mcpRefreshError)}`
+            );
+          }
+          try {
+            await config.getGeminiClient()?.addWorkingDirectoryChangedContext(
+              settledPreviousCwd,
+              canonicalPath
+            );
+          } catch (error) {
+            warnings.push(
+              `Model context refresh failed: ${error instanceof Error ? error.message : String(error)}`
+            );
+          }
+          return {
+            previousCwd: settledPreviousCwd,
+            newCwd: canonicalPath,
+            warnings
+          };
+        } finally {
+          releaseGate();
         }
-        session.clearTodoStopGuardTrust();
-        return { previousCwd, newCwd: canonicalPath, warnings };
       }
       case SERVE_CONTROL_EXT_METHODS.sessionApprovalMode: {
         const sessionId = params["sessionId"];
@@ -14823,149 +15869,91 @@ ${outputText}
         return result;
       }
       case SERVE_CONTROL_EXT_METHODS.workspaceMcpRuntimeAdd: {
-        const name = params["name"];
-        const config = params["config"];
-        const originatorClientId = params["originatorClientId"];
-        if (typeof name !== "string" || name.length === 0) {
-          throw RequestError.invalidParams(
-            void 0,
-            "Invalid or missing name"
-          );
-        }
-        if (!isValidServerName(name)) {
-          throw RequestError.invalidParams(
-            void 0,
-            "Server name must be \u2264256 chars, alphanumeric + underscore/hyphen, and not a reserved JS property name"
-          );
-        }
-        if (!config || typeof config !== "object" || Array.isArray(config)) {
-          throw RequestError.invalidParams(
-            void 0,
-            "Invalid or missing config"
-          );
-        }
-        const runtimeClientId = typeof originatorClientId === "string" && originatorClientId.length > 0 ? originatorClientId : "daemon";
-        const manager = this.config.getToolRegistry()?.getMcpClientManager();
-        if (!manager) {
-          throw RequestError.internalError(
-            void 0,
-            "McpClientManager unavailable on this Config"
-          );
-        }
-        try {
-          const {
-            trust: _trust,
-            authProviderType: _auth,
-            includeTools: _inc,
-            excludeTools: _exc,
-            cwd: _cwd,
-            env: _env,
-            oauth: _oauth,
-            headers: _headers,
-            type: _type,
-            // Reverse tool channel marker (issue #5626, Phase 2). The parent
-            // serve process stamps this on a client-hosted (extension) MCP
-            // server's runtime config; it never reaches the transport itself.
-            [CLIENT_MCP_OVER_WS_CONFIG_FLAG]: clientMcpOverWs,
-            ...safeConfig
-          } = config;
-          if (clientMcpOverWs === true) {
-            safeConfig["type"] = "sdk";
-          }
-          const result = await manager.addRuntimeMcpServer(
-            name,
-            safeConfig,
-            runtimeClientId
-          );
-          await Promise.all(
-            this.getActiveSessions().map(async (session) => {
-              const sessionManager = session.getConfig().getToolRegistry()?.getMcpClientManager();
-              if (!sessionManager) return;
-              try {
-                await sessionManager.addRuntimeMcpServer(
-                  name,
-                  safeConfig,
-                  runtimeClientId
-                );
-              } catch (sessionErr) {
-                debugLogger7.warn(
-                  `workspaceMcpRuntimeAdd: failed to add runtime MCP server '${name}' to active session ${session.getConfig().getSessionId()}: ${sessionErr instanceof Error ? sessionErr.message : String(sessionErr)}`
-                );
-              }
-            })
-          );
-          return result;
-        } catch (err) {
-          if (err instanceof McpBudgetWouldExceedError) {
-            throw new RequestError(-32099, err.message, {
-              errorKind: err.code,
-              serverName: err.serverName
-            });
-          }
-          if (err instanceof McpServerSpawnFailedError) {
-            throw new RequestError(-32099, err.message, {
-              errorKind: err.code,
-              serverName: err.serverName,
-              ...err.details
-            });
-          }
-          if (err instanceof InvalidMcpConfigError) {
-            throw new RequestError(-32099, err.message, {
-              errorKind: err.code,
-              serverName: err.serverName,
-              reason: err.reason
-            });
-          }
-          throw err;
-        }
+        const request = readRuntimeMcpAddRequest(params);
+        const result = await addRuntimeMcpServer(
+          getRuntimeMcpManager(this.config),
+          request
+        );
+        await Promise.all(
+          this.getActiveSessions().map(async (session) => {
+            const sessionManager = session.getConfig().getToolRegistry()?.getMcpClientManager();
+            if (!sessionManager) return;
+            try {
+              await sessionManager.addRuntimeMcpServer(
+                request.name,
+                request.config,
+                request.runtimeClientId
+              );
+            } catch (sessionErr) {
+              debugLogger7.warn(
+                `workspaceMcpRuntimeAdd: failed to add runtime MCP server '${request.name}' to active session ${session.getConfig().getSessionId()}: ${sessionErr instanceof Error ? sessionErr.message : String(sessionErr)}`
+              );
+            }
+          })
+        );
+        return result;
       }
       case SERVE_CONTROL_EXT_METHODS.workspaceMcpRuntimeRemove: {
-        const name = params["name"];
-        const originatorClientId = params["originatorClientId"];
-        if (typeof name !== "string" || name.length === 0) {
-          throw RequestError.invalidParams(
-            void 0,
-            "Invalid or missing name"
-          );
-        }
-        if (!isValidServerName(name)) {
-          throw RequestError.invalidParams(
-            void 0,
-            "Server name must be \u2264256 chars, alphanumeric + underscore/hyphen, and not a reserved JS property name"
-          );
-        }
-        const runtimeClientId = typeof originatorClientId === "string" && originatorClientId.length > 0 ? originatorClientId : "daemon";
-        const manager = this.config.getToolRegistry()?.getMcpClientManager();
-        if (!manager) {
-          throw RequestError.internalError(
-            void 0,
-            "McpClientManager unavailable on this Config"
-          );
-        }
-        const result = await manager.removeRuntimeMcpServer(
-          name,
-          runtimeClientId
-        );
+        const request = readRuntimeMcpRequest(params);
+        const result = await getRuntimeMcpManager(
+          this.config
+        ).removeRuntimeMcpServer(request.name, request.runtimeClientId);
         await Promise.all(
           this.getActiveSessions().map(async (session) => {
             const sessionManager = session.getConfig().getToolRegistry()?.getMcpClientManager();
             if (!sessionManager) return;
             try {
               await sessionManager.removeRuntimeMcpServer(
-                name,
-                runtimeClientId
+                request.name,
+                request.runtimeClientId
               );
             } catch (sessionErr) {
               debugLogger7.warn(
-                `workspaceMcpRuntimeRemove: failed to remove runtime MCP server '${name}' from active session ${session.getConfig().getSessionId()}: ${sessionErr instanceof Error ? sessionErr.message : String(sessionErr)}`
+                `workspaceMcpRuntimeRemove: failed to remove runtime MCP server '${request.name}' from active session ${session.getConfig().getSessionId()}: ${sessionErr instanceof Error ? sessionErr.message : String(sessionErr)}`
               );
             }
           })
         );
         return result;
       }
+      case SERVE_CONTROL_EXT_METHODS.sessionMcpRuntimeAdd: {
+        const sessionId = params["sessionId"];
+        if (typeof sessionId !== "string" || sessionId.length === 0) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Invalid or missing sessionId"
+          );
+        }
+        const session = this.sessionOrThrow(sessionId);
+        return addRuntimeMcpServer(
+          getRuntimeMcpManager(session.getConfig()),
+          readRuntimeMcpAddRequest(params)
+        );
+      }
+      case SERVE_CONTROL_EXT_METHODS.sessionMcpRuntimeRemove: {
+        const sessionId = params["sessionId"];
+        if (typeof sessionId !== "string" || sessionId.length === 0) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Invalid or missing sessionId"
+          );
+        }
+        const session = this.sessionOrThrow(sessionId);
+        const request = readRuntimeMcpRequest(params);
+        const result = await getRuntimeMcpManager(
+          session.getConfig()
+        ).removeRuntimeMcpServer(request.name, request.runtimeClientId);
+        return result;
+      }
       case SERVE_CONTROL_EXT_METHODS.workspaceExtensionsRefresh: {
         const sessionId = params["sessionId"];
+        const rawRefreshBootstrap = params["refreshBootstrap"];
+        if (rawRefreshBootstrap !== void 0 && typeof rawRefreshBootstrap !== "boolean") {
+          throw RequestError.invalidParams(
+            void 0,
+            "refreshBootstrap must be a boolean"
+          );
+        }
         const session = this.sessionOrThrow(sessionId);
         const config = session.getConfig();
         const extensionManager = config.getExtensionManager();
@@ -14979,6 +15967,12 @@ ${outputText}
         }, "runRefresh");
         await runRefresh(async () => await extensionManager.refreshCache());
         await runRefresh(async () => await extensionManager.refreshTools());
+        const bootstrapConfig = this.config;
+        if (rawRefreshBootstrap !== false && bootstrapConfig !== config) {
+          await runRefresh(
+            async () => await this.refreshBootstrapExtensionStatus()
+          );
+        }
         const discoveryConfig = this.workspaceMcpDiscoveryConfig;
         if (discoveryConfig && discoveryConfig !== config) {
           const discoveryExtensionManager = discoveryConfig.getExtensionManager();
@@ -15282,7 +16276,9 @@ ${outputText}
           apiKeyEnvKey: cfg?.apiKeyEnvKey ?? null
         };
       }
-      case SERVE_CONTROL_EXT_METHODS.sessionBranch: {
+      case SERVE_CONTROL_EXT_METHODS.sessionBranch:
+      case SERVE_CONTROL_EXT_METHODS.sessionSideTask: {
+        const isSideTask = method === SERVE_CONTROL_EXT_METHODS.sessionSideTask;
         const sessionId = params["sessionId"];
         if (typeof sessionId !== "string" || !SESSION_ID_RE.test(sessionId)) {
           throw RequestError.invalidParams(
@@ -15305,7 +16301,17 @@ ${outputText}
         }
         const newSessionId = randomUUID2();
         const sessionService = sourceConfig.getSessionService();
-        await sessionService.forkSession(sessionId, newSessionId);
+        const fork = /* @__PURE__ */ __name(() => isSideTask ? sessionService.forkSession(sessionId, newSessionId, {
+          source: {
+            sourceType: "side_task",
+            sourceId: sessionId
+          }
+        }) : sessionService.forkSession(sessionId, newSessionId), "fork");
+        if (isSideTask && recording) {
+          await recording.runWithWriteBarrier(fork);
+        } else {
+          await fork();
+        }
         let title;
         try {
           let baseName;
@@ -15320,7 +16326,7 @@ ${outputText}
               baseName = sessionId.slice(0, 8);
             }
           }
-          title = await computeUniqueBranchTitle(baseName, sessionService);
+          title = isSideTask ? baseName : await computeUniqueBranchTitle(baseName, sessionService);
           const renamed = await sessionService.renameSession(
             newSessionId,
             title,
@@ -15654,16 +16660,58 @@ ${outputText}
         };
       }
       case SERVE_CONTROL_EXT_METHODS.workspaceSkillsRefresh: {
-        this.settings.reloadScopeFromDisk("Workspace" /* Workspace */);
+        const rawReason = params["reason"];
+        if (rawReason !== void 0 && rawReason !== "settings" && rawReason !== "content" && rawReason !== "all") {
+          throw RequestError.invalidParams(
+            void 0,
+            "reason must be settings, content, or all"
+          );
+        }
+        const reason = rawReason ?? "all";
+        const refreshSettings = reason !== "content";
+        const refreshContent = reason !== "settings";
+        if (refreshSettings) {
+          this.settings.reloadScopeFromDisk("Workspace" /* Workspace */);
+        }
         const sessions = this.getActiveSessions();
+        const settingsReloadResults = refreshSettings ? await Promise.allSettled(
+          sessions.map(
+            (session) => Promise.resolve().then(() => session.reloadSkillSettings())
+          )
+        ) : void 0;
+        let configResults = [];
+        if (refreshContent) {
+          const skillManagers = new Set(
+            [this.config, ...sessions.map((session) => session.getConfig())].map((config) => config.getSkillManager()).filter(
+              (manager) => manager !== void 0
+            )
+          );
+          configResults = await Promise.allSettled(
+            [...skillManagers].map((manager) => manager.refreshCache())
+          );
+          for (const result of configResults) {
+            if (result.status === "rejected") {
+              debugLogger7.warn(`Skill config refresh failed: ${result.reason}`);
+            }
+          }
+        }
         const results = await Promise.allSettled(
-          sessions.map((session) => session.refreshSkillsFromSettings())
+          sessions.map((session, index) => {
+            const settingsReload = settingsReloadResults?.[index];
+            if (settingsReload?.status === "rejected") {
+              return Promise.reject(settingsReload.reason);
+            }
+            return session.refreshSkillsFromSettings({
+              reloadSettings: false,
+              notifyConfigChanged: !refreshContent
+            });
+          })
         );
         for (let i = 0; i < results.length; i++) {
           if (results[i].status === "rejected") {
-            const reason = results[i].reason;
+            const reason2 = results[i].reason;
             debugLogger7.warn(
-              `Session ${sessions[i].getId()} skill refresh failed: ${reason}`
+              `Session ${sessions[i].getId()} skill refresh failed: ${reason2}`
             );
           }
         }
@@ -15673,7 +16721,14 @@ ${outputText}
           ).length,
           sessionsFailed: results.filter(
             (result) => result.status === "rejected"
-          ).length
+          ).length,
+          configsRefreshed: configResults.filter(
+            (result) => result.status === "fulfilled"
+          ).length,
+          configsFailed: configResults.filter(
+            (result) => result.status === "rejected"
+          ).length,
+          reason
         };
       }
       default:
@@ -15736,6 +16791,7 @@ ${outputText}
       [],
       settings,
       void 0,
+      void 0,
       false,
       {
         skipMcpDiscovery: true,
@@ -15777,8 +16833,9 @@ ${outputText}
       throw error;
     }
   }
-  async newSessionConfig(cwd, mcpServers, settings, sessionId, resume, initializeOptions = {}, chatRecording) {
+  async newSessionConfig(cwd, mcpServers, settings, isChannelSession, sessionId, resume, initializeOptions = {}, chatRecording) {
     try {
+      this.assertManagedSessionAdmission();
       return await this.runWithPinnedRuntimeBaseDir(settings, cwd, async () => {
         await this.retryPendingConfigCleanup(
           Storage.getRuntimeBaseDir(),
@@ -15788,6 +16845,7 @@ ${outputText}
           cwd,
           mcpServers,
           settings,
+          isChannelSession,
           sessionId,
           resume,
           initializeOptions,
@@ -15804,7 +16862,7 @@ ${outputText}
       throw error;
     }
   }
-  async newSessionConfigInRuntimeContext(cwd, mcpServers, settings, sessionId, resume, initializeOptions = {}, chatRecording) {
+  async newSessionConfigInRuntimeContext(cwd, mcpServers, settings, isChannelSession, sessionId, resume, initializeOptions = {}, chatRecording) {
     const sessionMcpServers = {};
     for (const server of mcpServers) {
       const stdioServer = toStdioServer(server);
@@ -15816,8 +16874,7 @@ ${outputText}
         sessionMcpServers[stdioServer.name] = new MCPServerConfig(
           stdioServer.command,
           stdioServer.args,
-          env,
-          cwd
+          env
         );
         continue;
       }
@@ -15856,7 +16913,14 @@ ${outputText}
         continue;
       }
     }
-    const mergedSettings = settings.merged;
+    const mergedSettings = {
+      ...settings.merged,
+      experimental: {
+        ...settings.merged.experimental,
+        sessionWriterLease: this.sessionWriterLeaseEnabledAtStartup,
+        ...isChannelSession ? { cron: false } : {}
+      }
+    };
     const sessionArg = resume === true ? { resume: sessionId, sessionId: void 0 } : { sessionId, resume: void 0 };
     const argvForSession = {
       ...this.argv,
@@ -15891,6 +16955,21 @@ ${outputText}
       buildDisabledSkillNamesProvider(settings),
       sessionMcpServers
     );
+    if (chatRecording !== false) {
+      this.initializingConfigs.add(config);
+    }
+    try {
+      this.assertManagedSessionAdmission();
+      if (this.isTrustedManagedParent()) {
+        config.setSessionWriterReclaimPolicy("never");
+        config.setSessionWriterTakeoverPolicy("certified");
+      }
+    } catch (error) {
+      return this.cleanupAfterRequestFailure(
+        error,
+        () => this.cleanupUnstoredConfig(config)
+      );
+    }
     if (!initializeOptions.skipFileCheckpointing && typeof config.enableFileCheckpointing === "function") {
       config.enableFileCheckpointing();
     }
@@ -15931,6 +17010,7 @@ ${outputText}
         // (the daemon only adds SDK-type runtime servers for client MCP).
         sendSdkMcpMessage: this.buildClientMcpSender(wiredSessionId)
       });
+      this.assertManagedSessionAdmission();
     } catch (error) {
       return this.cleanupAfterRequestFailure(
         error,
@@ -15991,17 +17071,20 @@ ${outputText}
     config.setFileSystemService(acpFileSystemService);
   }
   async createAndStoreSession(config, settings, sessionData, options = {}) {
+    this.assertManagedSessionAdmission();
     const sessionId = config.getSessionId();
     const geminiClient = config.getGeminiClient();
     const needsInitialize = !geminiClient.isInitialized();
     if (needsInitialize) {
       await geminiClient.initialize();
     }
+    this.assertManagedSessionAdmission();
     if (this.sessions.has(sessionId)) {
       throw new Error(`Session ${sessionId} is already active.`);
     }
     const session = new Session(sessionId, config, this.connection, settings);
     this.sessions.set(sessionId, session);
+    this.initializingConfigs.delete(config);
     try {
       if (sessionData?.fileHistorySnapshots?.length) {
         config.getFileHistoryService().restoreFromSnapshots(sessionData.fileHistorySnapshots);
@@ -16015,10 +17098,9 @@ ${outputText}
           sessionData.historyGaps
         );
       }
-      if (options.startPostReplayServices !== false) {
-        session.installRewriter();
-        session.startCronScheduler();
-      }
+      await options.beforeStartPostReplayServices?.(session);
+      session.installRewriter();
+      session.startCronScheduler();
       setTimeout(() => {
         void session.sendAvailableCommandsUpdate();
       }, 0);
@@ -16149,6 +17231,7 @@ export {
   fetchAllowedGitHub,
   normalizeCoreSettingValue,
   runAcpAgent,
+  selectVisibleHistoryRecords,
   toHttpServer,
   toSseServer,
   toStdioServer