@qwen-code/qwen-code 0.20.0 → 0.20.1-nightly.20260724.7d17c44a3

package/chunks/{acpAgent-YUR43TLG.js → acpAgent-5D7P4BB5.js}

@@ -12,40 +12,46 @@ import {
   matchMcpServerByRef,
   parseExtensionRef,
   parseMcpServerRef
-} from "./chunk-IVPSS6EL.js";
+} from "./chunk-F5MBYZSU.js";
 import {
   getAvailableCommands,
   handleSlashCommand,
   insertAfterFunctionResponses,
   isSlashCommand,
   normalizePartList
-} from "./chunk-PBWEWI4N.js";
+} from "./chunk-BW5Z5NOG.js";
+import {
+  collectContextData,
+  formatContextUsageText
+} from "./chunk-BJBUDCM3.js";
 import {
   recomputeMcpGating
-} from "./chunk-333CXMNJ.js";
+} from "./chunk-QXZTZJLX.js";
 import {
   appEvents,
   buildDisabledSkillNamesProvider,
   loadCliConfig,
   normalizeDisabledToolList
-} from "./chunk-4XNLIGVA.js";
+} from "./chunk-JKCALGYN.js";
 import {
   getCommandSubcommandNames
-} from "./chunk-HZPN55E5.js";
+} from "./chunk-SJEDL7DI.js";
 import {
   getEffectiveSupportedModes
-} from "./chunk-2LL7TXB4.js";
-import "./chunk-5DTTYNB7.js";
-import "./chunk-QKYTTBYW.js";
-import {
-  collectContextData,
-  formatContextUsageText
-} from "./chunk-A5LYNIW7.js";
+} from "./chunk-UH7242DI.js";
 import "./chunk-4WGODMVR.js";
-import "./chunk-AYCDXHZB.js";
-import "./chunk-KDC6GNQR.js";
-import "./chunk-KG3XV6FH.js";
-import "./chunk-S2W2LVDU.js";
+import "./chunk-PQNHRFJC.js";
+import "./chunk-4LVZNIDO.js";
+import "./chunk-7Z6JQEL6.js";
+import {
+  beginAcpBootstrapConfigProfiling,
+  buildAndFreezeAcpStartupProfile,
+  endAcpBootstrapConfigProfiling,
+  markAcpStartup
+} from "./chunk-HIJQF5B5.js";
+import "./chunk-LEEWLFHW.js";
+import "./chunk-JYUSL2V4.js";
+import "./chunk-WHFK6G6U.js";
 import "./chunk-YAF2MQZ6.js";
 import {
   GENERATION_MAX_PROMPT_BYTES,
@@ -59,13 +65,14 @@ import {
   executeGeneration,
   formatWorkspaceMemoryForgetSummary,
   isValidServerName,
+  normalizeChannelDeliveryText,
   redactMcpServerSecrets,
   replayTranscriptRecordPage,
   restoreRedactedMcpSecrets,
   shouldSuppressRememberErrorDetails,
   workspaceMemoryFailureCode,
   workspaceMemoryFailureDiagnostics
-} from "./chunk-5JBR5XIK.js";
+} from "./chunk-G7EFBBVF.js";
 import {
   HistoryReplayer,
   MessageEmitter,
@@ -75,83 +82,81 @@ import {
   goalTerminalEventToHistoryItem,
   recordGoalStatusItem,
   restoreGoalFromHistory
-} from "./chunk-PGEPSDJI.js";
-import "./chunk-KTUQMDEP.js";
-import "./chunk-D22SX43D.js";
-import "./chunk-RS7MT2QG.js";
-import "./chunk-H2XVO6NE.js";
+} from "./chunk-FWNZ7CVN.js";
+import "./chunk-4K7VDKAD.js";
+import "./chunk-IPUUTYMV.js";
+import "./chunk-DWNZ6PVQ.js";
+import "./chunk-2MIN6GRR.js";
 import "./chunk-QHTIBUWB.js";
 import {
   isTerminalGoalStatusKind
 } from "./chunk-QTERJVPZ.js";
-import "./chunk-L573Z2QZ.js";
-import {
-  computeCpuPercent
-} from "./chunk-HGT6JR3U.js";
-import "./chunk-RXFQM6FQ.js";
-import "./chunk-KOR3XKCA.js";
-import "./chunk-6H67XLET.js";
-import {
-  beginAcpBootstrapConfigProfiling,
-  buildAndFreezeAcpStartupProfile,
-  endAcpBootstrapConfigProfiling,
-  markAcpStartup
-} from "./chunk-TDKQP3M6.js";
-import "./chunk-VEXFOTEO.js";
-import "./chunk-LXXMOYPL.js";
-import "./chunk-NDMQLV4Y.js";
-import "./chunk-E5Z2AVNV.js";
-import {
-  ACP_ROUTE_ID_PREFIX,
-  buildAcpModelOptions,
-  getCurrentAcpModelId,
-  parseAcpBaseModelId,
-  parseAcpModelOption,
-  resolveAcpModelOption,
-  sanitizeProviderBaseUrl
-} from "./chunk-NGFEPAE6.js";
-import {
-  mapSkillConfigToStatus
-} from "./chunk-2W3OOD4W.js";
+import "./chunk-3Z43GZUQ.js";
 import {
   PERMISSION_RULE_TYPES,
   PermissionRulesValidationError,
   buildPermissionSettings,
   normalizePermissionRules,
   readPermissionRuleSet
-} from "./chunk-S2XVRHDN.js";
+} from "./chunk-JDFBBGRD.js";
 import {
   MAX_AUDIO_BYTES,
   sanitizeVoiceErrorMessage,
   transcribeVoiceAudio
-} from "./chunk-IR46U7RB.js";
+} from "./chunk-3FB2Y2OE.js";
 import {
   readVoiceModel
-} from "./chunk-S2PD3EZD.js";
-import "./chunk-BVLROR2T.js";
+} from "./chunk-KJEMJWNH.js";
+import "./chunk-QLJUC7TG.js";
+import {
+  computeCpuPercent
+} from "./chunk-HGT6JR3U.js";
+import "./chunk-RXFQM6FQ.js";
+import "./chunk-PBII2NFX.js";
+import "./chunk-6H67XLET.js";
+import {
+  createLoadedSettingsAdapter
+} from "./chunk-LA5H3LM5.js";
+import "./chunk-LXXMOYPL.js";
+import "./chunk-LBAO2XRA.js";
+import "./chunk-E5Z2AVNV.js";
 import {
   parseSessionSource
-} from "./chunk-AKX4WPPP.js";
-import "./chunk-6RLROE6G.js";
-import "./chunk-COH43MRJ.js";
+} from "./chunk-SWBJRDYC.js";
+import {
+  NOT_CURRENTLY_GENERATING_CANCEL_MESSAGE
+} from "./chunk-UH3WSE5L.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-QR6U5QPP.js";
+} from "./chunk-3SJ43L4W.js";
+import "./chunk-BLFVGB7D.js";
+import "./chunk-COH43MRJ.js";
 import {
   ndJsonStream
-} from "./chunk-CV63PP6U.js";
+} from "./chunk-YCIM6O3I.js";
 import {
-  NOT_CURRENTLY_GENERATING_CANCEL_MESSAGE
-} from "./chunk-X6YQWCIJ.js";
+  ACP_ROUTE_ID_PREFIX,
+  buildAcpModelOptions,
+  getCurrentAcpModelId,
+  parseAcpBaseModelId,
+  parseAcpModelOption,
+  resolveAcpModelOption,
+  sanitizeProviderBaseUrl
+} from "./chunk-WLEFWSSC.js";
+import {
+  mapSkillConfigToStatus
+} from "./chunk-2W3OOD4W.js";
 import {
   ACP_PREFLIGHT_KINDS,
   IDLE_HOOK_EVENTS,
@@ -159,23 +164,22 @@ import {
   SERVE_STATUS_EXT_METHODS,
   STATUS_SCHEMA_VERSION,
   mapDomainErrorToErrorKind
-} from "./chunk-VDWBQ5AW.js";
-import "./chunk-CB2HFGRV.js";
-import "./chunk-MJ6S23WZ.js";
+} from "./chunk-CUPAVLRY.js";
+import "./chunk-PFSUKTZH.js";
+import "./chunk-UJV643E2.js";
+import "./chunk-HZEWYOVI.js";
 import "./chunk-57OAHC2Y.js";
-import "./chunk-YWEW33JY.js";
-import "./chunk-4ODB7WIB.js";
+import "./chunk-HVO55LUD.js";
+import "./chunk-QAFKR7WR.js";
 import "./chunk-V6WHFGST.js";
-import {
-  createLoadedSettingsAdapter
-} from "./chunk-CZF3E5GF.js";
-import "./chunk-W7FJ3N32.js";
-import "./chunk-Y2ENGUD6.js";
-import "./chunk-TJTKSVIV.js";
+import "./chunk-BSNWBC33.js";
+import "./chunk-2RFKHEXL.js";
+import "./chunk-UPF7PTBI.js";
+import "./chunk-JLU636DO.js";
+import "./chunk-BK2UNYWD.js";
 import "./chunk-M5GB774H.js";
-import "./chunk-RFIAR4YL.js";
-import "./chunk-2HOVDT7W.js";
-import "./chunk-NIJEXGV6.js";
+import "./chunk-RV4C2ZFG.js";
+import "./chunk-ZXYUQXY5.js";
 import {
   AgentSideConnection,
   PROTOCOL_VERSION,
@@ -184,7 +188,7 @@ import {
 import {
   assembleMcpServers,
   loadMcpApprovals
-} from "./chunk-7SXZC7ID.js";
+} from "./chunk-2WTVWAKT.js";
 import {
   getOutputLanguageFilePath,
   getPersistScopeForModelSelection,
@@ -193,7 +197,7 @@ import {
   resolveOutputLanguageOrPreserveAuto,
   updateOutputLanguageFile,
   writeOutputLanguageAndRegisterPath
-} from "./chunk-33XUAINQ.js";
+} from "./chunk-J5UKQEFG.js";
 import "./chunk-RKUWKYED.js";
 import "./chunk-GOXKNSDZ.js";
 import {
@@ -204,20 +208,20 @@ import {
   SUPPORTED_LANGUAGES,
   getCurrentLanguage,
   setLanguageAsync
-} from "./chunk-TKLLK6XQ.js";
+} from "./chunk-ZT4POVWC.js";
 import {
   findEnvFiles,
   preResolveHomeEnvOverrides,
   reloadEnvironment
-} from "./chunk-TIH2ZTOC.js";
+} from "./chunk-32A4PI3E.js";
 import "./chunk-QRUIS3DN.js";
-import "./chunk-OWCALFEG.js";
+import "./chunk-54R2CV2G.js";
 import "./chunk-VJNBRRZG.js";
 import {
   isFolderTrustEnabled,
   isWorkspaceTrusted,
   loadTrustedFolders
-} from "./chunk-I2PYAYFM.js";
+} from "./chunk-CXUFILV3.js";
 import "./chunk-ALGGS7UH.js";
 import "./chunk-MR3PXB6E.js";
 import {
@@ -243,16 +247,20 @@ import {
   McpServerSpawnFailedError,
   McpTransportPool,
   MessageDisplayDispatcher,
+  PLAN_MODE_ENTRY_SIBLING_SKIP_MESSAGE,
   POOLED_TRANSPORTS_DEFAULT,
   SESSION_ARTIFACT_PERSISTENCE_VERSION,
   SESSION_TITLE_MAX_LENGTH,
   SESSION_TRANSCRIPT_MAX_LIMIT,
   SESSION_TRANSCRIPT_MAX_PAGE_BYTES,
+  SESSION_WRITER_RPC_CODES,
   SessionService,
   SessionTranscriptPageTooLargeError,
   SessionTranscriptReader,
   SessionTranscriptSnapshotUnavailableError,
   SessionTranscriptTooLargeError,
+  SessionWriterError,
+  SessionWriterUnavailableError,
   TURN_INTERRUPTION_HISTORY_TAIL_COUNT,
   WorkspaceMcpBudget,
   abortGoalForStopHookCap,
@@ -272,13 +280,18 @@ import {
   convertToFunctionErrorResponse,
   convertToFunctionResponse,
   createDuplicateProviderToolCallResponse,
+  decorateClassifierUnavailableConfirmation,
+  decoratePlanModeShellConfirmation,
   dedupeToolCallsById,
   detectAutonomousSentinel,
   detectLoopSentinel,
   encodeSessionTranscriptCursor,
   evaluateAutoMode,
   evaluatePermissionFlow,
+  evaluatePlanModeShellPolicy,
+  finalizeToolResponses,
   findExistingProviderModels,
+  findPlanModeEntryBatchBoundaryIndex,
   findProviderById,
   findRepeatedDuplicateProviderToolCall,
   fireNotificationHook,
@@ -301,21 +314,19 @@ import {
   getPlanModeSystemReminder,
   getProviderToolCallId,
   getScopedEnvContents,
-  getStartupContextLength,
+  getStopHookContinuationReason,
   ideContextStore,
   injectPermissionRulesIfMissing,
   isApproveOutcome,
   isDenialFallbackReason,
   isGatedMcpScope,
   isPlanModeBlocked,
-  isSystemReminderContent,
   markDuplicateProviderToolCallResponseSent,
   matchesAnyServerPattern,
   mcpServerRequiresOAuth,
   needsConfirmation,
   normalizeEventPayload,
   normalizeSnapshotPayload,
-  parsePositiveIntegerEnv,
   persistPermissionOutcome,
   readManyFiles,
   recordAllow,
@@ -337,53 +348,79 @@ import {
   shouldRunAutoModeForCall,
   subagentGenerator,
   unregisterGoalHook,
-  updateSetting
-} from "./chunk-KX6UK4VJ.js";
+  updateSetting,
+  validatePlanModeShellApproval,
+  validatePlanModeShellContext
+} from "./chunk-LI4I37W4.js";
 import "./chunk-5M6IDOMF.js";
-import "./chunk-T4TZQJ7W.js";
+import "./chunk-TWPJO254.js";
 import {
   external_exports
 } from "./chunk-H6XPXXMH.js";
-import "./chunk-EAUYY7SS.js";
-import "./chunk-FSL5W5TI.js";
-import "./chunk-OONJNQ42.js";
-import "./chunk-D2VIDMVM.js";
-import "./chunk-E2UVIFI2.js";
-import "./chunk-XU457J4V.js";
+import "./chunk-NOAAFNTJ.js";
+import "./chunk-AFFGGOF6.js";
+import "./chunk-RGG6M2WF.js";
+import "./chunk-X6N25LXS.js";
+import "./chunk-KRXPRVGL.js";
+import {
+  parsePositiveIntegerEnv
+} from "./chunk-6PVPNMXU.js";
+import "./chunk-UO7DCGEV.js";
+import "./chunk-IRH27ZC2.js";
 import "./chunk-VDDGDZMA.js";
-import "./chunk-EIAK6Q2B.js";
+import "./chunk-C3VHAXP2.js";
 import "./chunk-SZRN75WQ.js";
 import "./chunk-HTO4JFDZ.js";
 import "./chunk-CPBF7KYF.js";
 import {
   APPROVAL_MODES,
   FORK_SUBAGENT_TYPE,
+  getStartupContextLength,
+  isSystemReminderContent,
   runWithRuntimeContentGenerator
-} from "./chunk-CPCVCKKF.js";
+} from "./chunk-XAWJ2526.js";
 import "./chunk-6AM5D4ME.js";
-import "./chunk-G45X5TRN.js";
+import "./chunk-NABLFI57.js";
 import {
   HookEventName,
   createHookOutput
-} from "./chunk-PBATSWUQ.js";
-import "./chunk-ZEOZL37W.js";
-import "./chunk-OOCI5VVU.js";
+} from "./chunk-QBUDF33N.js";
+import "./chunk-JCW2R7WC.js";
+import "./chunk-57FIIFJN.js";
+import "./chunk-LIZRAKPB.js";
 import {
   clearCachedCredentialFile,
   qwenOAuth2Events
-} from "./chunk-BRRF37CO.js";
-import "./chunk-BMWMT5Y2.js";
+} from "./chunk-LYTBLSSW.js";
+import "./chunk-WI3KCKZ5.js";
+import "./chunk-DP5GT2MW.js";
 import "./chunk-JESCGQM3.js";
+import "./chunk-XVNQMZ2I.js";
+import "./chunk-FODK6UMO.js";
+import "./chunk-GLNBDYUX.js";
+import "./chunk-DJ2GSRLV.js";
+import "./chunk-R6D2CTQR.js";
+import {
+  extractDaemonTraceContext,
+  registerAcpEventLoopLagGauge,
+  startEventLoopLagMonitor,
+  withDaemonSpan
+} from "./chunk-AXUW635Q.js";
+import "./chunk-BPJSQIJX.js";
+import "./chunk-P3QQPMQA.js";
+import "./chunk-6QHAUJUE.js";
+import {
+  getToolCallPreparations
+} from "./chunk-LS77BEZP.js";
 import {
-  AuthType,
   ConversationFinishedEvent,
   DiscoveredMCPTool,
+  INVOCATION_CONTEXT_META_KEY,
   LoopDetectedEvent,
+  PRIVATE_ACP_CAPABILITY_ENV,
+  PRIVATE_PARENT_CAPABILITY_META_KEY,
   PromptSuggestionEvent,
   UserPromptEvent,
-  endToolExecutionSpan,
-  endToolSpan,
-  extractDaemonTraceContext,
   formatFullTurnVisionNotice,
   formatVisionBridgeNotice,
   getAllGeminiMdFilenames,
@@ -397,63 +434,66 @@ import {
   logToolCall,
   logUserPrompt,
   normalizeParts,
-  registerAcpEventLoopLagGauge,
-  runInToolSpanContext,
+  parseInvocationContext,
   runSideQuery,
   runVisionBridge,
+  runWithInvocationContext,
   shouldRunVisionBridge,
   splitImageParts,
-  startEventLoopLagMonitor,
-  startToolExecutionSpan,
-  startToolSpan,
-  uiTelemetryService,
-  withDaemonSpan,
-  withInteractionSpan
-} from "./chunk-ZFKNWQGQ.js";
-import "./chunk-4WKAA4KS.js";
-import "./chunk-CR3C7WXL.js";
+  uiTelemetryService
+} from "./chunk-IFG6TYJ2.js";
 import "./chunk-VGC4I5JJ.js";
 import {
   getAutoMemoryRoot,
   getUserAutoMemoryRoot
-} from "./chunk-JD3MKVKL.js";
-import "./chunk-UEY4AYUL.js";
-import "./chunk-BDBMYST4.js";
-import "./chunk-EZVDJFZ7.js";
+} from "./chunk-4K56OJFJ.js";
 import {
-  ToolConfirmationOutcome,
-  ToolNames,
-  isShellProgressData
-} from "./chunk-OP4MOGXF.js";
-import "./chunk-XVNQMZ2I.js";
-import "./chunk-FEOZBUMT.js";
-import "./chunk-DJ2GSRLV.js";
-import "./chunk-6EFTQYW7.js";
+  AuthType
+} from "./chunk-36HSVBBU.js";
+import "./chunk-46UV252V.js";
+import "./chunk-A4UCTEB5.js";
+import "./chunk-XWRJCPHC.js";
 import {
   DEFAULT_TOKEN_LIMIT,
-  getToolCallPreparations,
   tokenLimit
-} from "./chunk-MAQQGNQ5.js";
-import "./chunk-A4UCTEB5.js";
-import "./chunk-XWRJCPHC.js";
-import "./chunk-TYQMGACW.js";
-import "./chunk-TYAMGABM.js";
-import "./chunk-FCMNKVXT.js";
+} from "./chunk-UW5EOVUN.js";
+import "./chunk-NBQDBANR.js";
+import "./chunk-QNLNLENL.js";
+import "./chunk-6X4GWOPW.js";
+import {
+  endToolExecutionSpan,
+  endToolSpan,
+  initializeTelemetry,
+  runInToolSpanContext,
+  startToolExecutionSpan,
+  startToolSpan,
+  withInteractionSpan
+} from "./chunk-PKL3HGNZ.js";
+import "./chunk-HTR4WV6U.js";
+import "./chunk-BULDBTYC.js";
+import "./chunk-U7ZFW55U.js";
+import "./chunk-ERLGR7GI.js";
+import {
+  ToolConfirmationOutcome,
+  ToolNames,
+  isShellProgressData
+} from "./chunk-P5RRUHL7.js";
 import {
   Storage,
   createDebugLogger,
   getErrorMessage,
   getErrorStatus,
   isSubpath
-} from "./chunk-C27BYUX6.js";
-import "./chunk-VZQUV7VK.js";
+} from "./chunk-OQB4EXO4.js";
+import "./chunk-CKTMY3EP.js";
 import {
   runExitCleanup
-} from "./chunk-DP5GXXNZ.js";
+} from "./chunk-EL2IQ2S5.js";
 import "./chunk-75DOP5OR.js";
 import "./chunk-DMTGGOSA.js";
 import "./chunk-YQ3U5MUC.js";
-import "./chunk-TB6UDU4T.js";
+import "./chunk-AMDSOFFV.js";
+import "./chunk-THJNPLI4.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -463,7 +503,7 @@ import {
 
 // packages/cli/src/acp-integration/acpAgent.ts
 init_esbuild_shims();
-import { randomUUID } from "node:crypto";
+import { randomUUID as randomUUID2, timingSafeEqual } from "node:crypto";
 import { performance } from "node:perf_hooks";
 
 // packages/cli/src/acp-integration/authMethods.ts
@@ -841,6 +881,7 @@ __name(isInactiveExtensionSkill, "isInactiveExtensionSkill");
 // packages/cli/src/acp-integration/session/Session.ts
 init_esbuild_shims();
 import { Buffer as Buffer2 } from "node:buffer";
+import { randomUUID } from "node:crypto";
 import { existsSync as existsSync2, statSync as statSync2 } from "node:fs";
 import * as os2 from "node:os";
 import * as path3 from "node:path";
@@ -965,8 +1006,23 @@ function supportsHideAlwaysAllow(confirmation) {
 }
 __name(supportsHideAlwaysAllow, "supportsHideAlwaysAllow");
 function filterAlwaysAllowOptions(confirmation, options, forceHideAlwaysAllow = false) {
-  const hideAlwaysAllow = forceHideAlwaysAllow || supportsHideAlwaysAllow(confirmation) && confirmation.hideAlwaysAllow === true;
-  return hideAlwaysAllow ? options.filter((option) => option.kind !== "allow_always") : options;
+  const hideAlwaysAllow = forceHideAlwaysAllow || confirmation.autoModeFallback !== void 0 || supportsHideAlwaysAllow(confirmation) && confirmation.hideAlwaysAllow === true;
+  const visibleOptions = hideAlwaysAllow ? options.filter((option) => option.kind !== "allow_always") : options;
+  if (!confirmation.autoModeFallback) return visibleOptions;
+  const switchOption = {
+    optionId: "proceed_once_and_switch_to_default" /* ProceedOnceAndSwitchToDefault */,
+    name: "Switch to Default Mode and allow once (recommended)",
+    kind: "allow_once"
+  };
+  const rejectIndex = visibleOptions.findIndex(
+    (option) => option.kind === "reject_once"
+  );
+  if (rejectIndex === -1) return [...visibleOptions, switchOption];
+  return [
+    ...visibleOptions.slice(0, rejectIndex),
+    switchOption,
+    ...visibleOptions.slice(rejectIndex)
+  ];
 }
 __name(filterAlwaysAllowOptions, "filterAlwaysAllowOptions");
 function formatExecPermissionScopeLabel(confirmation) {
@@ -994,6 +1050,22 @@ function interactionMetaFields(confirmation) {
 __name(interactionMetaFields, "interactionMetaFields");
 function buildPermissionRequestContent(confirmation) {
   const content = [];
+  if (confirmation.autoModeFallback) {
+    content.push({
+      type: "content",
+      content: {
+        type: "text",
+        text: confirmation.autoModeFallback.message
+      }
+    });
+  }
+  const warnings = confirmation.type === "exec" || confirmation.type === "edit" ? confirmation.warnings ?? [] : [];
+  for (const warning of warnings) {
+    content.push({
+      type: "content",
+      content: { type: "text", text: warning }
+    });
+  }
   if (confirmation.type === "edit") {
     content.push({
       type: "diff",
@@ -1014,6 +1086,56 @@ function buildPermissionRequestContent(confirmation) {
   return content;
 }
 __name(buildPermissionRequestContent, "buildPermissionRequestContent");
+function permissionAbortError(signal) {
+  return signal.reason instanceof Error ? signal.reason : new Error("Permission request was aborted.");
+}
+__name(permissionAbortError, "permissionAbortError");
+function requestPermissionWithAbort(client, params, signal) {
+  if (signal.aborted) {
+    return Promise.reject(permissionAbortError(signal));
+  }
+  return new Promise((resolve5, reject) => {
+    let settled = false;
+    const finish = /* @__PURE__ */ __name((callback) => {
+      if (settled) return;
+      settled = true;
+      signal.removeEventListener("abort", onAbort);
+      callback();
+    }, "finish");
+    const onAbort = /* @__PURE__ */ __name(() => finish(() => reject(permissionAbortError(signal))), "onAbort");
+    signal.addEventListener("abort", onAbort, { once: true });
+    let request;
+    try {
+      request = client.requestPermission(params);
+    } catch (error) {
+      finish(() => reject(error));
+      return;
+    }
+    request.then(
+      (response) => finish(() => resolve5(response)),
+      (error) => finish(() => reject(error))
+    );
+  });
+}
+__name(requestPermissionWithAbort, "requestPermissionWithAbort");
+function resolvePermissionOutcome(response, offeredOptions) {
+  if (response.outcome.outcome === "cancelled") {
+    return "cancel" /* Cancel */;
+  }
+  const optionId = response.outcome.optionId;
+  if (!offeredOptions.some((option) => option.optionId === optionId)) {
+    throw new Error(
+      `Permission response selected unoffered option: ${optionId}`
+    );
+  }
+  if (!Object.values(ToolConfirmationOutcome).includes(
+    optionId
+  )) {
+    throw new Error(`Permission response selected invalid option: ${optionId}`);
+  }
+  return optionId;
+}
+__name(resolvePermissionOutcome, "resolvePermissionOutcome");
 function toPermissionOptions(confirmation, forceHideAlwaysAllow = false) {
   switch (confirmation.type) {
     case "edit":
@@ -1240,9 +1362,13 @@ var SubAgentTracker = class {
         }, "onConfirm")
       };
       const { title, locations, kind } = this.toolCallEmitter.resolveToolMetadata(event.name, state?.args);
+      const permissionOptions = toPermissionOptions(fullConfirmationDetails);
+      const offeredPermissionOptions = permissionOptions.map((option) => ({
+        ...option
+      }));
       const params = {
         sessionId: this.ctx.sessionId,
-        options: toPermissionOptions(fullConfirmationDetails),
+        options: permissionOptions,
         toolCall: {
           toolCallId: event.callId,
           status: "pending",
@@ -1263,8 +1389,15 @@ var SubAgentTracker = class {
         }
       };
       try {
-        const output = await this.client.requestPermission(params);
-        const outcome = output.outcome.outcome === "cancelled" ? "cancel" /* Cancel */ : external_exports.nativeEnum(ToolConfirmationOutcome).parse(output.outcome.optionId);
+        const output = await requestPermissionWithAbort(
+          this.client,
+          params,
+          abortSignal
+        );
+        const outcome = resolvePermissionOutcome(
+          output,
+          offeredPermissionOptions
+        );
         await event.respond(outcome, {
           answers: "answers" in output ? output.answers : void 0
         });
@@ -1856,6 +1989,10 @@ function maskApiKeyForDisplay(apiKey) {
   return `${trimmed.slice(0, 3)}...${trimmed.slice(-4)}`;
 }
 __name(maskApiKeyForDisplay, "maskApiKeyForDisplay");
+function getAbortAwareEndTurnStopReason(signal) {
+  return signal.aborted ? "cancelled" : "end_turn";
+}
+__name(getAbortAwareEndTurnStopReason, "getAbortAwareEndTurnStopReason");
 var DAEMON_INVALID_TOOL_PARAMS_THRESHOLD = 3;
 var PERMISSION_CANCEL_SKIP_MESSAGE = "Skipped because a permission request was cancelled before the user answered; user input is required before continuing.";
 var LOOP_DETECTED_SKIP_MESSAGE = "Skipped because loop detection stopped the current turn before this tool call could run.";
@@ -2091,6 +2228,43 @@ var MidTurnDrainTimeoutError = class extends Error {
     );
   }
 };
+function beginChannelDeliveryResponseBlock(capture) {
+  if (!capture) return void 0;
+  capture.finalText = "";
+  return [];
+}
+__name(beginChannelDeliveryResponseBlock, "beginChannelDeliveryResponseBlock");
+function commitChannelDeliveryResponseBlock(capture, responseBlock, hasFunctionCalls) {
+  if (capture && responseBlock && !hasFunctionCalls) {
+    capture.finalText = responseBlock.join("");
+  }
+}
+__name(commitChannelDeliveryResponseBlock, "commitChannelDeliveryResponseBlock");
+function parsePromptChannelDelivery(params) {
+  const meta = params._meta;
+  const value = meta?.[DAEMON_CHANNEL_DELIVERY_META_KEY];
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return void 0;
+  }
+  const delivery = value;
+  const target = delivery["target"];
+  if (typeof delivery["deliveryId"] !== "string" || delivery["deliveryId"].length === 0 || typeof target !== "object" || target === null || Array.isArray(target)) {
+    return void 0;
+  }
+  const targetRecord = target;
+  if (typeof targetRecord["channelName"] !== "string" || targetRecord["channelName"].length === 0 || targetRecord["type"] !== "user" && targetRecord["type"] !== "chat" || typeof targetRecord["id"] !== "string" || targetRecord["id"].length === 0) {
+    return void 0;
+  }
+  return {
+    deliveryId: delivery["deliveryId"],
+    target: {
+      channelName: targetRecord["channelName"],
+      type: targetRecord["type"],
+      id: targetRecord["id"]
+    }
+  };
+}
+__name(parsePromptChannelDelivery, "parsePromptChannelDelivery");
 var MAX_NOTIFICATION_QUEUE = 20;
 var MAX_DEFERRED_UNRELATED_CRON_QUEUE = 20;
 function isExistingFile(resolved, fileExists = existsSync2, statFile = statSync2) {
@@ -2307,7 +2481,7 @@ var Session = class {
     this.client = client;
     this.settings = settings;
     this.sessionId = id;
-    this.runtimeBaseDir = Storage.getRuntimeBaseDir();
+    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() : {
@@ -2338,6 +2512,7 @@ var Session = class {
    * process termination is slow.
    */
   pendingPromptCompletion = null;
+  automaticDrainRetry = null;
   /**
    * Per-turn AbortController for the fire-and-forget follow-up suggestion
    * generation. Aborted on the top of the next `prompt()` and on
@@ -2400,6 +2575,9 @@ var Session = class {
   // or session reload), which would otherwise execute orphaned cron prompts
   // on a session whose registries are already unregistered.
   disposed = false;
+  closing = false;
+  closeGateCompletion = null;
+  resolveCloseGate = null;
   unsubscribeChatRecordingFailure;
   // Modular components
   historyReplayer;
@@ -2422,6 +2600,8 @@ var Session = class {
    * that produces this string.
    */
   pendingWorktreeNotice = null;
+  /** One-shot model notice for background agents restored with the session. */
+  pendingRecoveredAgentsNotice = null;
   // Implement SessionContext interface
   sessionId;
   #prepareTodoStopGuardForPrompt(params) {
@@ -2634,7 +2814,7 @@ var Session = class {
    * mount.
    */
   startCronScheduler() {
-    this.#startCronSchedulerIfNeeded().catch((error) => {
+    this.#startCronSchedulerInRuntime().catch((error) => {
       debugLogger6.warn(
         `Cron scheduler startup failed [session ${this.sessionId}]: ${error}`
       );
@@ -2643,8 +2823,95 @@ var Session = class {
   getConfig() {
     return this.config;
   }
+  async assertCanStartTurn() {
+    if (this.closing) {
+      throw RequestError.invalidParams(void 0, "Session is closing");
+    }
+    try {
+      await this.config.assertCanStartTurn();
+    } catch (error) {
+      if (error instanceof SessionWriterError) {
+        throw new RequestError(error.rpcCode, error.message, {
+          errorKind: error.errorKind
+        });
+      }
+      throw error;
+    }
+    if (this.closing) {
+      throw RequestError.invalidParams(void 0, "Session is closing");
+    }
+  }
   isIdle() {
-    return !this.pendingPrompt && !this.pendingPromptCompletion && !this.cronProcessing && !this.cronAbortController && !this.notificationProcessing && !this.notificationAbortController;
+    return !this.closing && !this.#hasActiveTurn();
+  }
+  #hasActiveTurn() {
+    return Boolean(
+      this.pendingPrompt || this.pendingPromptCompletion || this.cronProcessing || this.cronAbortController || this.cronCompletion || this.notificationProcessing || this.notificationAbortController || this.notificationCompletion
+    );
+  }
+  beginClose() {
+    if (this.closing) {
+      throw RequestError.invalidParams(
+        void 0,
+        "Session close is already in progress"
+      );
+    }
+    this.closing = true;
+    let resolveGate;
+    const completion = new Promise((resolve5) => {
+      resolveGate = resolve5;
+    });
+    this.closeGateCompletion = completion;
+    this.resolveCloseGate = resolveGate;
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      if (this.closeGateCompletion === completion) {
+        this.closeGateCompletion = null;
+        this.resolveCloseGate = null;
+      }
+      resolveGate();
+      if (this.disposed) return;
+      this.closing = false;
+      void this.#drainCronQueue();
+      void this.#drainNotificationQueue();
+    };
+  }
+  beginCloseIfAvailable() {
+    if (this.disposed) {
+      throw RequestError.invalidParams(void 0, "Session has been disposed");
+    }
+    return this.closing ? null : this.beginClose();
+  }
+  waitForCloseGateToRelease() {
+    return this.closeGateCompletion ?? Promise.resolve();
+  }
+  async waitForActiveTurnsToSettle() {
+    const pending = [
+      this.pendingPromptCompletion,
+      this.cronCompletion,
+      this.notificationCompletion
+    ].filter((completion) => completion !== null);
+    await Promise.allSettled(pending);
+  }
+  #deferAutomaticQueueDrainUntilTurnsSettle() {
+    const completions = [
+      this.pendingPromptCompletion,
+      this.cronCompletion,
+      this.notificationCompletion
+    ].filter((completion) => completion !== null);
+    if (completions.length === 0) return false;
+    if (this.automaticDrainRetry) return true;
+    const retry = Promise.allSettled(completions).then(() => {
+      if (this.automaticDrainRetry !== retry) return;
+      this.automaticDrainRetry = null;
+      if (this.disposed) return;
+      void this.#drainCronQueue();
+      void this.#drainNotificationQueue();
+    });
+    this.automaticDrainRetry = retry;
+    return true;
   }
   getTurnCount() {
     return this.turn;
@@ -2654,6 +2921,10 @@ var Session = class {
   }
   dispose() {
     this.disposed = true;
+    this.closing = true;
+    this.resolveCloseGate?.();
+    this.resolveCloseGate = null;
+    this.closeGateCompletion = null;
     this.todoStopGuardQueuedPromptPriority = false;
     this.todoStopGuardDrainAutomaticQueuesWhenIdle = false;
     this.todoStopGuard.clearTrust();
@@ -2670,8 +2941,9 @@ var Session = class {
     this.cronProcessing = false;
     this.cronCompletion = null;
     if (this.config.isCronEnabled()) {
-      this.config.getCronScheduler().stop();
+      this.#stopCronSchedulerInRuntime();
     }
+    this.config.getBackgroundTaskRegistry().abortAll({ notify: false });
     this.config.getBackgroundTaskRegistry().setNotificationCallback(void 0);
     this.config.getMonitorRegistry().setNotificationCallback(void 0);
     this.config.getBackgroundShellRegistry().setNotificationCallback(void 0);
@@ -2754,7 +3026,7 @@ var Session = class {
         "targetTurnIndex must be a non-negative integer"
       );
     }
-    if (this.pendingPrompt || this.cronProcessing || this.cronAbortController || this.notificationProcessing || this.notificationAbortController) {
+    if (this.closing || this.#hasActiveTurn()) {
       throw RequestError.invalidParams(
         void 0,
         "Cannot rewind while a prompt is running"
@@ -2811,7 +3083,7 @@ var Session = class {
     return count;
   }
   restoreHistory(history) {
-    if (this.pendingPrompt || this.cronProcessing || this.cronAbortController || this.notificationProcessing || this.notificationAbortController) {
+    if (this.closing || this.#hasActiveTurn()) {
       throw RequestError.invalidParams(
         void 0,
         "Cannot restore history while a prompt is running"
@@ -2885,17 +3157,37 @@ var Session = class {
     const scheduler = this.config.isCronEnabled() ? this.config.getCronScheduler() : null;
     if (scheduler) {
       const summary = scheduler.getExitSummary();
-      scheduler.stop();
+      this.#stopCronSchedulerInRuntime();
       if (summary) {
         await this.messageEmitter.emitAgentMessage(summary);
       }
     }
   }
-  async prompt(params) {
+  async prompt(params, invocationContext, admissionCancellation) {
+    if (this.closing) {
+      throw RequestError.invalidParams(void 0, "Session is closing");
+    }
+    await this.assertCanStartTurn();
+    if (admissionCancellation?.aborted) {
+      return { stopReason: "cancelled" };
+    }
     const todoStopGuardPreparation = this.#prepareTodoStopGuardForPrompt(params);
     this.pendingPrompt?.abort();
     const pendingSend = new AbortController();
+    const cancelPendingSend = /* @__PURE__ */ __name(() => pendingSend.abort(USER_CANCEL_ABORT_REASON), "cancelPendingSend");
+    if (admissionCancellation) {
+      admissionCancellation.addEventListener("abort", cancelPendingSend, {
+        once: true
+      });
+      if (admissionCancellation.aborted) cancelPendingSend();
+    }
     this.pendingPrompt = pendingSend;
+    const releasePendingSend = /* @__PURE__ */ __name(() => {
+      admissionCancellation?.removeEventListener("abort", cancelPendingSend);
+      if (this.pendingPrompt === pendingSend) {
+        this.pendingPrompt = null;
+      }
+    }, "releasePendingSend");
     if (this.followupAbort) {
       this.followupAbort.abort();
       this.followupAbort = null;
@@ -2932,6 +3224,8 @@ var Session = class {
       }
     }
     if (pendingSend.signal.aborted) {
+      releasePendingSend();
+      this.todoStopGuard.suspend();
       return { stopReason: "cancelled" };
     }
     if (todoStopGuardPreparation.startsWorkChain) {
@@ -2940,26 +3234,52 @@ var Session = class {
       this.todoStopGuardBackgroundBaseline = this.#captureTodoStopGuardBackgroundBaseline();
     }
     this.duplicateProviderToolCallResponseIds.clear();
+    const channelDelivery = parsePromptChannelDelivery(params);
+    const channelDeliveryCapture = channelDelivery ? { finalText: "" } : void 0;
     let resolveCompletion;
     this.pendingPromptCompletion = new Promise((resolve5) => {
       resolveCompletion = resolve5;
     });
     try {
-      const result = await this.#executePrompt(params, pendingSend);
-      this.pendingPrompt = null;
+      const result = await this.#executePrompt(
+        params,
+        pendingSend,
+        channelDeliveryCapture,
+        invocationContext
+      );
+      releasePendingSend();
       void this.#drainCronQueue();
       void this.#drainNotificationQueue();
       this.#maybeEmitFollowupSuggestion(result);
+      if (channelDelivery && result.stopReason === "end_turn") {
+        this.#scheduleChannelDelivery({
+          sessionId: this.sessionId,
+          deliveryId: channelDelivery.deliveryId,
+          source: "prompt",
+          target: channelDelivery.target,
+          text: normalizeChannelDeliveryText(
+            channelDeliveryCapture?.finalText ?? ""
+          ),
+          promptId: channelDelivery.deliveryId
+        });
+      }
       return result;
+    } catch (error) {
+      if (error instanceof SessionWriterError) {
+        throw new RequestError(error.rpcCode, error.message, {
+          errorKind: error.errorKind
+        });
+      }
+      throw error;
     } finally {
-      this.pendingPrompt = null;
+      releasePendingSend();
       const shouldDrainAutomaticQueues = todoStopGuardPreparation.drainSupersededAutomaticQueues || this.todoStopGuardDrainAutomaticQueuesWhenIdle || this.todoStopGuard.blocksUnrelatedAutomaticTurns || this.todoStopGuard.hasCommittedContinuation || this.todoStopGuardQueuedPromptPriority;
       this.todoStopGuardDrainAutomaticQueuesWhenIdle = false;
       if (shouldDrainAutomaticQueues) {
         void this.#drainCronQueue();
         void this.#drainNotificationQueue();
       }
-      void this.#startCronSchedulerIfNeeded();
+      void this.#startCronSchedulerInRuntime();
       resolveCompletion();
       this.pendingPromptCompletion = null;
     }
@@ -3082,17 +3402,31 @@ var Session = class {
       }
     })();
   }
-  async #executePrompt(params, pendingSend) {
-    return sessionIdContext.run(
-      this.config.getSessionId(),
-      () => this.#executePromptInner(params, pendingSend)
+  async #executePrompt(params, pendingSend, channelDeliveryCapture, invocationContext) {
+    const sessionId = this.config.getSessionId();
+    if (invocationContext !== void 0 && invocationContext.sessionId !== sessionId) {
+      throw RequestError.invalidParams(
+        void 0,
+        "Invocation context session does not match the active session"
+      );
+    }
+    return runWithInvocationContext(
+      invocationContext,
+      () => sessionIdContext.run(
+        sessionId,
+        () => this.#executePromptInner(params, pendingSend, channelDeliveryCapture)
+      )
     );
   }
-  async #executePromptInner(params, pendingSend) {
+  async #executePromptInner(params, pendingSend, channelDeliveryCapture) {
     return Storage.runWithRuntimeBaseDir(
       this.runtimeBaseDir,
       this.config.getWorkingDir(),
       async () => {
+        await this.assertCanStartTurn();
+        if (pendingSend.signal.aborted) {
+          return { stopReason: "cancelled" };
+        }
         this.turn += 1;
         const promptId = this.config.getSessionId() + "########" + this.turn;
         const parentContext = extractDaemonTraceContext(params);
@@ -3156,6 +3490,7 @@ var Session = class {
               (block) => block.type === "text"
             );
             const inputText = firstTextBlock?.text || "";
+            const isSlashInput = !isContinue && isSlashCommand(inputText);
             let parts;
             let fullTurnModelOverride;
             const onFullTurnModel = /* @__PURE__ */ __name((model) => {
@@ -3167,7 +3502,7 @@ var Session = class {
             }, "onFullTurnModel");
             if (isContinue) {
               parts = continuationParts;
-            } else if (isSlashCommand(inputText)) {
+            } else if (isSlashInput) {
               const slashCommandResult = await handleSlashCommand(
                 inputText,
                 pendingSend,
@@ -3251,6 +3586,17 @@ ${this.pendingWorktreeNotice}
               parts = insertAfterFunctionResponses(parts, [noticePart]);
               this.pendingWorktreeNotice = null;
             }
+            if (this.pendingRecoveredAgentsNotice && !isContinue && !isSlashInput) {
+              const noticePart = {
+                text: `<system-reminder>
+${this.pendingRecoveredAgentsNotice}
+</system-reminder>
+
+`
+              };
+              parts = insertAfterFunctionResponses(parts, [noticePart]);
+              this.pendingRecoveredAgentsNotice = null;
+            }
             let nextMessage = { role: "user", parts };
             let turnCount = 0;
             const toolLoopState = createDaemonToolLoopState();
@@ -3271,6 +3617,7 @@ ${this.pendingWorktreeNotice}
                 const messageDisplay = this.#createMessageDisplayDispatcher(
                   pendingSend.signal
                 );
+                let channelDeliveryResponseBlock;
                 try {
                   const sendResult = await this.#sendMessageStreamWithAutoCompression(
                     promptId,
@@ -3288,6 +3635,8 @@ ${this.pendingWorktreeNotice}
                   }
                   const responseStream = sendResult.responseStream;
                   nextMessage = null;
+                  channelDeliveryResponseBlock = beginChannelDeliveryResponseBlock(channelDeliveryCapture);
+                  const channelDeliveryCheckpoint = channelDeliveryResponseBlock?.length ?? 0;
                   let streamFailed = false;
                   try {
                     for await (const resp of responseStream) {
@@ -3307,6 +3656,7 @@ ${this.pendingWorktreeNotice}
                             part.thought
                           );
                           if (!part.thought) {
+                            channelDeliveryResponseBlock?.push(part.text);
                             messageDisplay?.addChunk(part.text);
                           }
                         }
@@ -3322,6 +3672,11 @@ ${this.pendingWorktreeNotice}
                         }
                       }
                       if (resp.type === "retry" /* RETRY */ || resp.type === "model_fallback" /* MODEL_FALLBACK */) {
+                        if (resp.type === "model_fallback" /* MODEL_FALLBACK */ || !resp.isContinuation) {
+                          if (channelDeliveryResponseBlock) {
+                            channelDeliveryResponseBlock.length = channelDeliveryCheckpoint;
+                          }
+                        }
                         await finalizeToolCallPreparations(
                           preparationTracker,
                           true,
@@ -3375,6 +3730,11 @@ ${this.pendingWorktreeNotice}
                 } finally {
                   await messageDisplay?.finish();
                 }
+                commitChannelDeliveryResponseBlock(
+                  channelDeliveryCapture,
+                  channelDeliveryResponseBlock,
+                  functionCalls.length > 0
+                );
                 if (usageMetadata) {
                   this.#recordPromptTokenCount(usageMetadata);
                   if (this.messageRewriter) {
@@ -3403,7 +3763,11 @@ ${this.pendingWorktreeNotice}
                       toolRun,
                       pendingSend.signal
                     );
-                    return { stopReason: "end_turn" };
+                    return {
+                      stopReason: getAbortAwareEndTurnStopReason(
+                        pendingSend.signal
+                      )
+                    };
                   }
                   const nextAfterTools = await this.#buildNextMessageAfterToolRun(
                     toolRun,
@@ -3417,7 +3781,11 @@ ${this.pendingWorktreeNotice}
                       toolRun,
                       pendingSend.signal
                     );
-                    return { stopReason: "end_turn" };
+                    return {
+                      stopReason: getAbortAwareEndTurnStopReason(
+                        pendingSend.signal
+                      )
+                    };
                   }
                 }
               }
@@ -3430,7 +3798,8 @@ ${this.pendingWorktreeNotice}
                 hooksEnabled,
                 messageBus,
                 true,
-                fullTurnModelOverride
+                fullTurnModelOverride,
+                channelDeliveryCapture
               );
             } finally {
               logConversationFinishedEvent(
@@ -3447,7 +3816,7 @@ ${this.pendingWorktreeNotice}
       }
     );
   }
-  async #handleStopHookLoop(pendingSend, promptId, hooksEnabled, messageBus, allowExternalHooks = true, modelOverride) {
+  async #handleStopHookLoop(pendingSend, promptId, hooksEnabled, messageBus, allowExternalHooks = true, modelOverride, channelDeliveryCapture) {
     const stopHookBlockingCap = this.config.getStopHookBlockingCap();
     let stopHookIterationCount = 0;
     let stopHookReasons = [];
@@ -3462,7 +3831,7 @@ ${this.pendingWorktreeNotice}
     while (true) {
       if (pendingSend.signal.aborted) {
         this.todoStopGuard.suspend();
-        return { stopReason: "end_turn" };
+        return { stopReason: "cancelled" };
       }
       if (this.config.getApprovalMode() === "plan" /* PLAN */) {
         this.#clearTodoStopGuardTrustAndDrainAutomaticQueues();
@@ -3489,7 +3858,8 @@ ${this.pendingWorktreeNotice}
             false,
             {
               onFullTurnModel,
-              getModelOverride: /* @__PURE__ */ __name(() => modelOverride, "getModelOverride")
+              getModelOverride: /* @__PURE__ */ __name(() => modelOverride, "getModelOverride"),
+              channelDeliveryCapture
             }
           );
           if (continuation2.kind === "terminal") {
@@ -3551,7 +3921,8 @@ ${this.pendingWorktreeNotice}
               false,
               {
                 onFullTurnModel,
-                getModelOverride: /* @__PURE__ */ __name(() => modelOverride, "getModelOverride")
+                getModelOverride: /* @__PURE__ */ __name(() => modelOverride, "getModelOverride"),
+                channelDeliveryCapture
               }
             );
             if (continuation2.kind === "terminal") {
@@ -3565,7 +3936,7 @@ ${this.pendingWorktreeNotice}
           await this.messageEmitter.emitAgentMessage(stopOutput.systemMessage);
         }
         if (stopOutput?.isBlockingDecision() || stopOutput?.shouldStopExecution()) {
-          externalReason = stopOutput.getEffectiveReason();
+          externalReason = getStopHookContinuationReason(stopOutput);
           stopHookIterationCount++;
           stopHookReasons = [...stopHookReasons, externalReason];
           stopHookCount = response.stopHookCount ?? 1;
@@ -3632,7 +4003,8 @@ ${this.pendingWorktreeNotice}
             ), "onAutomaticContinuationValidated")
           } : {},
           onFullTurnModel,
-          getModelOverride: /* @__PURE__ */ __name(() => modelOverride, "getModelOverride")
+          getModelOverride: /* @__PURE__ */ __name(() => modelOverride, "getModelOverride"),
+          channelDeliveryCapture
         }
       );
       if (continuation.supersededAutomaticContinuation && externalReason) {
@@ -3675,6 +4047,7 @@ ${this.pendingWorktreeNotice}
       const messageDisplay = this.#createMessageDisplayDispatcher(
         pendingSend.signal
       );
+      let channelDeliveryResponseBlock;
       try {
         const sendResult = await this.#sendMessageStreamWithAutoCompression(
           promptIdForSend,
@@ -3806,6 +4179,10 @@ ${this.pendingWorktreeNotice}
         }
         const responseStream = sendResult.responseStream;
         nextMessage = null;
+        channelDeliveryResponseBlock = beginChannelDeliveryResponseBlock(
+          options.channelDeliveryCapture
+        );
+        const channelDeliveryCheckpoint = channelDeliveryResponseBlock?.length ?? 0;
         initialSend = false;
         if (guardForThisSend) {
           const guardCommitted = this.todoStopGuard.commitContinuation(
@@ -3836,7 +4213,10 @@ ${this.pendingWorktreeNotice}
                 "assistant",
                 part.thought
               );
-              if (!part.thought) messageDisplay?.addChunk(part.text);
+              if (!part.thought) {
+                channelDeliveryResponseBlock?.push(part.text);
+                messageDisplay?.addChunk(part.text);
+              }
             }
           }
           if (response.type === "chunk" /* CHUNK */ && response.value.usageMetadata) {
@@ -3850,6 +4230,11 @@ ${this.pendingWorktreeNotice}
             }
           }
           if (response.type === "retry" /* RETRY */ || response.type === "model_fallback" /* MODEL_FALLBACK */) {
+            if (response.type === "model_fallback" /* MODEL_FALLBACK */ || !response.isContinuation) {
+              if (channelDeliveryResponseBlock) {
+                channelDeliveryResponseBlock.length = channelDeliveryCheckpoint;
+              }
+            }
             await finalizeToolCallPreparations(
               preparationTracker,
               true,
@@ -3888,6 +4273,11 @@ ${this.pendingWorktreeNotice}
           await messageDisplay?.finish();
         }
       }
+      commitChannelDeliveryResponseBlock(
+        options.channelDeliveryCapture,
+        channelDeliveryResponseBlock,
+        functionCalls.length > 0
+      );
       if (usageMetadata) {
         this.#recordPromptTokenCount(usageMetadata);
         const durationMs = Date.now() - streamStartTime;
@@ -3912,7 +4302,7 @@ ${this.pendingWorktreeNotice}
           await this.#preserveStoppedToolRun(toolRun, pendingSend.signal);
           return {
             kind: "terminal",
-            stopReason: "end_turn",
+            stopReason: getAbortAwareEndTurnStopReason(pendingSend.signal),
             ...supersededAutomaticContinuation ? { supersededAutomaticContinuation: true } : {}
           };
         }
@@ -4007,6 +4397,19 @@ ${this.pendingWorktreeNotice}
     };
     await this.client.sessionUpdate(params);
   }
+  #scheduleChannelDelivery(params) {
+    const timer = setTimeout(() => {
+      void this.client.extMethod(SERVE_CONTROL_EXT_METHODS.channelDelivery, params).catch((error) => {
+        try {
+          debugLogger6.warn(
+            `Channel delivery submission failed: ${error instanceof Error ? error.message : String(error)}`
+          );
+        } catch {
+        }
+      });
+    }, 0);
+    timer.unref();
+  }
   #getCurrentChat() {
     return this.config.getGeminiClient().getChat();
   }
@@ -4161,13 +4564,18 @@ ${this.pendingWorktreeNotice}
     }
   }
   async #preserveStoppedToolRun(toolRun, abortSignal) {
+    const midTurnParts = abortSignal.aborted ? await this.#buildMidTurnParts(
+      this.#takeRecoveredMidTurnMessages(),
+      abortSignal,
+      { preserveFallbackOnAbort: true }
+    ) : await this.#drainMidTurnUserMessages(abortSignal);
     this.#preserveUnsentMessageHistory(
       {
         role: "user",
         parts: [
           ...toolRun.parts,
           ...toolRun.loopDetected ? [{ text: LOOP_DETECTED_CONTEXT_MESSAGE }] : [],
-          ...await this.#drainMidTurnUserMessages(abortSignal)
+          ...midTurnParts
         ]
       },
       true
@@ -4282,11 +4690,7 @@ ${this.pendingWorktreeNotice}
     const recovered = this.#takeRecoveredMidTurnMessages();
     if (this.midTurnDrainUnavailable) {
       return {
-        parts: await this.#buildMidTurnParts(
-          recovered,
-          abortSignal,
-          options.onFullTurnModel
-        ),
+        parts: await this.#buildMidTurnParts(recovered, abortSignal, options),
         hasQueuedPrompt: false
       };
     }
@@ -4314,7 +4718,7 @@ ${this.pendingWorktreeNotice}
         parts: await this.#buildMidTurnParts(
           [...recovered, ...parseMidTurnDrainResponse(response)],
           abortSignal,
-          options.onFullTurnModel
+          options
         ),
         hasQueuedPrompt: isRecord2(response) && response["hasQueuedPrompt"] === true
       };
@@ -4334,11 +4738,7 @@ ${this.pendingWorktreeNotice}
         `Mid-turn queue drain ${isPermanentError ? "permanently " : ""}unavailable [session ${this.sessionId}]: ${errorMessage}`
       );
       return {
-        parts: await this.#buildMidTurnParts(
-          recovered,
-          abortSignal,
-          options.onFullTurnModel
-        ),
+        parts: await this.#buildMidTurnParts(recovered, abortSignal, options),
         hasQueuedPrompt: false
       };
     }
@@ -4398,7 +4798,7 @@ ${this.pendingWorktreeNotice}
    * happens on injection (here), so a message recovered from an earlier
    * timed-out drain is still recorded exactly once.
    */
-  async #buildMidTurnParts(messages, abortSignal, onFullTurnModel) {
+  async #buildMidTurnParts(messages, abortSignal, options = {}) {
     const parts = [];
     for (const message of messages) {
       const displayText = message.kind === "text" ? message.message : message.displayText;
@@ -4408,13 +4808,19 @@ ${this.pendingWorktreeNotice}
           abortSignal,
           MID_TURN_QUEUE_RESOLVE_TIMEOUT_MS,
           (signal) => this.#resolvePrompt(message.content, signal, {
-            onFullTurnModel
+            onFullTurnModel: options.onFullTurnModel
           })
         );
       } catch (messageError) {
-        if (abortSignal.aborted) return parts;
-        const errorMessage = this.#formatError(messageError);
-        debugLogger6.warn(`Failed to resolve mid-turn message: ${errorMessage}`);
+        if (abortSignal.aborted && !options.preserveFallbackOnAbort) {
+          return parts;
+        }
+        if (!abortSignal.aborted) {
+          const errorMessage = this.#formatError(messageError);
+          debugLogger6.warn(
+            `Failed to resolve mid-turn message: ${errorMessage}`
+          );
+        }
         rawParts = [{ text: displayText }];
         if (message.kind === "structured" && hasInlineMediaContentBlock(message.content)) {
           rawParts.push({ text: MID_TURN_ATTACHMENT_PROCESSING_FAILURE_TEXT });
@@ -4451,11 +4857,27 @@ ${this.pendingWorktreeNotice}
       this.#enqueueCronPrompt({
         prompt: job.prompt,
         source: job.cronExpr === "@wakeup" ? "loop" : "cron",
-        ...job.id ? { taskId: job.id } : {}
+        ...job.id ? { taskId: job.id } : {},
+        ...job.lastFiredAt !== void 0 ? { firedAt: job.lastFiredAt } : {},
+        ...job.delivery ? { delivery: job.delivery } : {}
       });
       void this.#drainCronQueue();
     });
   }
+  #startCronSchedulerInRuntime() {
+    return Storage.runWithRuntimeBaseDir(
+      this.runtimeBaseDir,
+      this.config.getWorkingDir(),
+      () => this.#startCronSchedulerIfNeeded()
+    );
+  }
+  #stopCronSchedulerInRuntime() {
+    Storage.runWithRuntimeBaseDir(
+      this.runtimeBaseDir,
+      this.config.getWorkingDir(),
+      () => this.config.getCronScheduler().stop()
+    );
+  }
   #enqueueCronPrompt(item) {
     if ((this.todoStopGuard.blocksUnrelatedAutomaticTurns || this.todoStopGuardQueuedPromptPriority) && !this.#cronContinuesTodoStopGuardWorkChain(item)) {
       if (item.taskId) {
@@ -4486,17 +4908,31 @@ ${this.pendingWorktreeNotice}
    */
   async #drainCronQueue() {
     if (this.disposed) return;
+    if (this.closing) return;
     if (this.cronProcessing) return;
     if (this.pendingPrompt) return;
     if (this.notificationProcessing) return;
+    if (this.#deferAutomaticQueueDrainUntilTurnsSettle()) return;
     if (this.#nextCronQueueIndex() < 0) return;
-    this.cronProcessing = true;
-    let resolveCompletion;
-    this.cronCompletion = new Promise((resolve5) => {
-      resolveCompletion = resolve5;
-    });
     try {
-      while (this.cronQueue.length > 0) {
+      await this.assertCanStartTurn();
+    } catch (error) {
+      debugLogger6.warn(
+        `Cron turn rejected [session ${this.sessionId}]: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return;
+    }
+    if (this.disposed || this.closing || this.cronProcessing || this.pendingPrompt || this.notificationProcessing || this.#nextCronQueueIndex() < 0) {
+      return;
+    }
+    if (this.#deferAutomaticQueueDrainUntilTurnsSettle()) return;
+    this.cronProcessing = true;
+    let resolveCompletion;
+    this.cronCompletion = new Promise((resolve5) => {
+      resolveCompletion = resolve5;
+    });
+    try {
+      while (this.cronQueue.length > 0) {
         const nextIndex = this.#nextCronQueueIndex();
         if (nextIndex < 0) break;
         const [item] = this.cronQueue.splice(nextIndex, 1);
@@ -4511,7 +4947,7 @@ ${this.pendingWorktreeNotice}
       if (this.config.isCronEnabled()) {
         const scheduler = this.config.getCronScheduler();
         if (!scheduler.hasPendingWork) {
-          scheduler.stop();
+          this.#stopCronSchedulerInRuntime();
         }
       }
     }
@@ -4550,9 +4986,12 @@ ${this.pendingWorktreeNotice}
    * `_meta.source='cron'`, streams the model response, and handles tool calls.
    */
   async #executeCronPrompt(item) {
-    return sessionIdContext.run(
-      this.config.getSessionId(),
-      () => this.#executeCronPromptInner(item)
+    return runWithInvocationContext(
+      void 0,
+      () => sessionIdContext.run(
+        this.config.getSessionId(),
+        () => this.#executeCronPromptInner(item)
+      )
     );
   }
   async #executeCronPromptInner(item) {
@@ -4568,6 +5007,8 @@ ${this.pendingWorktreeNotice}
         );
         const promptId = this.config.getSessionId() + "########cron" + Date.now();
         let cronHadError = false;
+        let cronCompleted = false;
+        const channelDeliveryCapture = item.delivery ? { finalText: "" } : void 0;
         await withInteractionSpan(
           this.config,
           {
@@ -4578,6 +5019,8 @@ ${this.pendingWorktreeNotice}
           async () => {
             let turnCount = 0;
             try {
+              await this.assertCanStartTurn();
+              if (ac.signal.aborted) return;
               const loopMode = detectLoopSentinel(prompt);
               const autonomousMode = loopMode ? null : detectAutonomousSentinel(prompt);
               let loopTick = null;
@@ -4666,6 +5109,8 @@ ${this.pendingWorktreeNotice}
                   return;
                 }
                 const responseStream = sendResult.responseStream;
+                const channelDeliveryResponseBlock = beginChannelDeliveryResponseBlock(channelDeliveryCapture);
+                const channelDeliveryCheckpoint = channelDeliveryResponseBlock?.length ?? 0;
                 if (loopTick && turnCount === 1) {
                   this.loopTickResolver?.markDelivered();
                 }
@@ -4690,6 +5135,7 @@ ${this.pendingWorktreeNotice}
                           part.thought
                         );
                         if (!part.thought) {
+                          channelDeliveryResponseBlock?.push(part.text);
                           messageDisplay?.addChunk(part.text);
                         }
                       }
@@ -4705,6 +5151,11 @@ ${this.pendingWorktreeNotice}
                       }
                     }
                     if (resp.type === "retry" /* RETRY */ || resp.type === "model_fallback" /* MODEL_FALLBACK */) {
+                      if (resp.type === "model_fallback" /* MODEL_FALLBACK */ || !resp.isContinuation) {
+                        if (channelDeliveryResponseBlock) {
+                          channelDeliveryResponseBlock.length = channelDeliveryCheckpoint;
+                        }
+                      }
                       await finalizeToolCallPreparations(
                         preparationTracker,
                         true,
@@ -4727,6 +5178,11 @@ ${this.pendingWorktreeNotice}
                     await messageDisplay?.finish();
                   }
                 }
+                commitChannelDeliveryResponseBlock(
+                  channelDeliveryCapture,
+                  channelDeliveryResponseBlock,
+                  functionCalls.length > 0
+                );
                 if (usageMetadata) {
                   this.#recordPromptTokenCount(usageMetadata);
                   if (this.messageRewriter) {
@@ -4763,18 +5219,23 @@ ${this.pendingWorktreeNotice}
                   }
                 }
               }
+              let stopReason = "end_turn";
               if (this.todoStopGuard.needsStopInspection) {
                 const guardStop = await this.#handleStopHookLoop(
                   ac,
                   promptId,
                   false,
                   void 0,
-                  false
+                  false,
+                  void 0,
+                  channelDeliveryCapture
                 );
+                stopReason = guardStop.stopReason;
                 if (guardStop.stopReason === "max_tokens") {
                   this.#stopCronAfterTokenLimit();
                 }
               }
+              cronCompleted = stopReason === "end_turn" && !ac.signal.aborted;
             } catch (error) {
               if (ac.signal.aborted) {
                 this.todoStopGuard.suspend();
@@ -4802,6 +5263,19 @@ ${this.pendingWorktreeNotice}
           },
           () => ac.signal.aborted ? "cancelled" : cronHadError ? "error" : "ok"
         );
+        if (cronCompleted && item.delivery && item.taskId && item.firedAt !== void 0) {
+          this.#scheduleChannelDelivery({
+            sessionId: this.sessionId,
+            deliveryId: `${item.taskId}:${item.firedAt}`,
+            source: "scheduled",
+            target: item.delivery.target,
+            text: normalizeChannelDeliveryText(
+              channelDeliveryCapture?.finalText ?? ""
+            ),
+            taskId: item.taskId,
+            firedAt: item.firedAt
+          });
+        }
       }
     );
   }
@@ -4907,12 +5381,26 @@ ${this.pendingWorktreeNotice}
   }
   async #drainNotificationQueue() {
     if (this.disposed) return;
+    if (this.closing) return;
     if (this.notificationProcessing) return;
     if (this.pendingPrompt || this.cronProcessing || this.cronAbortController) {
       return;
     }
+    if (this.#deferAutomaticQueueDrainUntilTurnsSettle()) return;
     if (this.notificationQueue.length === 0) return;
     if (this.#nextNotificationQueueIndex() < 0) return;
+    try {
+      await this.assertCanStartTurn();
+    } catch (error) {
+      debugLogger6.warn(
+        `Notification turn rejected [session ${this.sessionId}]: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return;
+    }
+    if (this.disposed || this.closing || this.notificationProcessing || this.pendingPrompt || this.cronProcessing || this.cronAbortController || this.#nextNotificationQueueIndex() < 0) {
+      return;
+    }
+    if (this.#deferAutomaticQueueDrainUntilTurnsSettle()) return;
     this.notificationProcessing = true;
     let resolveCompletion;
     this.notificationCompletion = new Promise((resolve5) => {
@@ -4927,9 +5415,12 @@ ${this.pendingWorktreeNotice}
         if (nextIndex < 0) break;
         const [item] = this.notificationQueue.splice(nextIndex, 1);
         if (!item) break;
-        await sessionIdContext.run(
-          this.config.getSessionId(),
-          () => this.#executeBackgroundNotificationPromptInner(item)
+        await runWithInvocationContext(
+          void 0,
+          () => sessionIdContext.run(
+            this.config.getSessionId(),
+            () => this.#executeBackgroundNotificationPromptInner(item)
+          )
         );
       }
     } finally {
@@ -4962,6 +5453,8 @@ ${this.pendingWorktreeNotice}
         );
         const promptId = this.config.getSessionId() + "########notification" + Date.now();
         try {
+          await this.assertCanStartTurn();
+          if (ac.signal.aborted) return;
           await this.#emitBackgroundNotificationDisplay(item);
           const notificationParts = [{ text: item.modelText }];
           this.config.getChatRecordingService()?.recordNotification(notificationParts, item.displayText);
@@ -5091,7 +5584,9 @@ ${this.pendingWorktreeNotice}
               if (toolRun.stopAfterPermissionCancel) {
                 this.todoStopGuard.suspend();
                 await this.#preserveStoppedToolRun(toolRun, ac.signal);
-                await this.#emitBackgroundNotificationEndTurn("end_turn");
+                await this.#emitBackgroundNotificationEndTurn(
+                  getAbortAwareEndTurnStopReason(ac.signal)
+                );
                 return;
               }
               const nextAfterTools = await this.#buildNextMessageAfterToolRun(
@@ -5102,7 +5597,9 @@ ${this.pendingWorktreeNotice}
               if (toolRun.loopDetected) {
                 this.todoStopGuard.suspend();
                 await this.#preserveStoppedToolRun(toolRun, ac.signal);
-                await this.#emitBackgroundNotificationEndTurn("end_turn");
+                await this.#emitBackgroundNotificationEndTurn(
+                  getAbortAwareEndTurnStopReason(ac.signal)
+                );
                 return;
               }
             }
@@ -5120,7 +5617,9 @@ ${this.pendingWorktreeNotice}
               false
             )).stopReason;
           }
-          await this.#emitBackgroundNotificationEndTurn(stopReason);
+          await this.#emitBackgroundNotificationEndTurn(
+            ac.signal.aborted ? "cancelled" : stopReason
+          );
         } catch (error) {
           if (ac.signal.aborted) {
             this.todoStopGuard.suspend();
@@ -5413,8 +5912,46 @@ ${this.pendingWorktreeNotice}
    */
   async runToolCalls(abortSignal, promptId, functionCalls, toolLoopState) {
     const dedupedFunctionCalls = dedupeToolCallsById(functionCalls);
+    const generatedCallIdBase = randomUUID();
+    const executionCallIds = new Map(
+      dedupedFunctionCalls.map((functionCall, index) => [
+        functionCall,
+        functionCall.id ?? `${functionCall.name ?? "tool"}-${generatedCallIdBase}-${index}`
+      ])
+    );
+    const pendingToolResultRecords = [];
+    let toolResultRecordSequence = 0;
+    const queueToolResultRecord = /* @__PURE__ */ __name((fc, record) => {
+      pendingToolResultRecords.push({
+        ...record,
+        ordinal: dedupedFunctionCalls.indexOf(fc),
+        sequence: toolResultRecordSequence++
+      });
+    }, "queueToolResultRecord");
+    const finalizeRunToolResult = /* @__PURE__ */ __name(async (result) => {
+      if (pendingToolResultRecords.length === 0) return result;
+      const orderedRecords = [...pendingToolResultRecords].sort(
+        (left, right) => left.ordinal - right.ordinal || left.sequence - right.sequence
+      );
+      const finalized = await finalizeToolResponses(
+        this.config,
+        orderedRecords.map((record) => ({
+          callId: record.callId,
+          toolName: record.toolName,
+          responseParts: record.responseParts,
+          persistedOutputFiles: record.persistedOutputFiles
+        }))
+      );
+      orderedRecords.forEach((record, index) => {
+        this.config.getChatRecordingService()?.recordToolResult(finalized[index].responseParts, record.metadata);
+      });
+      return {
+        ...result,
+        parts: finalized.flatMap((entry) => entry.responseParts)
+      };
+    }, "finalizeRunToolResult");
     let skippedToolCallCounter = 0;
-    const recordSkippedToolCall = /* @__PURE__ */ __name(async (fc, message = PERMISSION_CANCEL_SKIP_MESSAGE, emitStart = true) => {
+    const recordSkippedToolCall = /* @__PURE__ */ __name(async (fc, message = PERMISSION_CANCEL_SKIP_MESSAGE, emitStart = true, errorType) => {
       const toolName = fc.name ?? "unknown_tool";
       const callId = fc.id ?? `${toolName}-skip-${++skippedToolCallCounter}`;
       const part = {
@@ -5426,12 +5963,17 @@ ${this.pendingWorktreeNotice}
       };
       const error = new Error(message);
       try {
-        this.config.getChatRecordingService()?.recordToolResult([part], {
+        queueToolResultRecord(fc, {
           callId,
-          status: "error",
-          resultDisplay: void 0,
-          error,
-          errorType: void 0
+          toolName,
+          responseParts: [part],
+          metadata: {
+            callId,
+            status: "error",
+            resultDisplay: void 0,
+            error,
+            errorType
+          }
         });
         if (emitStart) {
           await this.toolCallEmitter.emitStart({
@@ -5453,7 +5995,7 @@ ${this.pendingWorktreeNotice}
       toolLoopState,
       dedupedFunctionCalls.length
     )) {
-      return {
+      return await finalizeRunToolResult({
         parts: await Promise.all(
           dedupedFunctionCalls.map(
             (fc) => recordSkippedToolCall(fc, LOOP_DETECTED_SKIP_MESSAGE, false)
@@ -5461,7 +6003,7 @@ ${this.pendingWorktreeNotice}
         ),
         stopAfterPermissionCancel: false,
         loopDetected: true
-      };
+      });
     }
     const batches = [];
     const handledProviderToolCallIds = new Set(
@@ -5478,13 +6020,13 @@ ${this.pendingWorktreeNotice}
       debugLogger6.debug(
         `[Session.runToolCalls] Dropping batch after repeated duplicate provider tool-call id: ${providerCallId} (tool: ${repeatedDuplicateCall.name ?? "unknown_tool"})`
       );
-      return {
+      return await finalizeRunToolResult({
         parts: [],
         stopAfterPermissionCancel: false,
         repeatedDuplicateProviderToolCall: true
-      };
+      });
     }
-    const pushDuplicateBatch = /* @__PURE__ */ __name((request) => {
+    const pushDuplicateBatch = /* @__PURE__ */ __name((fc, request) => {
       const providerCallId = request.providerCallId ?? request.callId;
       markDuplicateProviderToolCallResponseSent(
         providerCallId,
@@ -5494,7 +6036,7 @@ ${this.pendingWorktreeNotice}
       debugLogger6.debug(
         `[Session.runToolCalls] Suppressing duplicate provider tool-call id: ${providerCallId} (tool: ${request.name})`
       );
-      batches.push({ kind: "duplicate", request, response });
+      batches.push({ kind: "duplicate", fc, request, response });
     }, "pushDuplicateBatch");
     const emitDuplicateBatch = /* @__PURE__ */ __name(async (batch) => {
       const { request, response } = batch;
@@ -5531,20 +6073,26 @@ ${this.pendingWorktreeNotice}
           success: false
         });
       }
-      this.config.getChatRecordingService()?.recordToolResult(response.responseParts, {
+      queueToolResultRecord(batch.fc, {
         callId: response.callId,
-        status: "error",
-        resultDisplay: response.resultDisplay,
-        error: response.error,
-        errorType: response.errorType
+        toolName: request.name,
+        responseParts: response.responseParts,
+        persistedOutputFiles: response.persistedOutputFiles,
+        metadata: {
+          callId: response.callId,
+          status: "error",
+          resultDisplay: response.resultDisplay,
+          error: response.error,
+          errorType: response.errorType
+        }
       });
     }, "emitDuplicateBatch");
     for (const fc of dedupedFunctionCalls) {
       const providerCallId = getProviderToolCallId(fc) ?? fc.id;
       if (providerCallId) {
         if (handledProviderToolCallIds.has(providerCallId)) {
-          const callId = fc.id ?? `${fc.name}-${Date.now()}`;
-          pushDuplicateBatch({
+          const callId = executionCallIds.get(fc);
+          pushDuplicateBatch(fc, {
             callId,
             providerCallId,
             name: fc.name ?? "unknown_tool",
@@ -5564,6 +6112,13 @@ ${this.pendingWorktreeNotice}
         batches.push({ kind: "execute", concurrent: isAgent, calls: [fc] });
       }
     }
+    const executableCalls = batches.flatMap(
+      (batch) => batch.kind === "execute" ? batch.calls : []
+    );
+    const planModeEntryBoundaryIndex = findPlanModeEntryBatchBoundaryIndex(
+      executableCalls.map((call) => call.name)
+    );
+    const planModeEntryBoundary = planModeEntryBoundaryIndex === void 0 ? void 0 : executableCalls[planModeEntryBoundaryIndex];
     const appendSkippedAfter = /* @__PURE__ */ __name(async (parts2, fc, message = PERMISSION_CANCEL_SKIP_MESSAGE) => {
       const startIndex = dedupedFunctionCalls.indexOf(fc) + 1;
       for (const remainingCall of dedupedFunctionCalls.slice(startIndex)) {
@@ -5630,7 +6185,9 @@ ${this.pendingWorktreeNotice}
             calls[i],
             onStopAfterPermissionCancel,
             toolLoopState,
-            recordSkippedToolCall
+            recordSkippedToolCall,
+            queueToolResultRecord,
+            executionCallIds.get(calls[i])
           );
           results[i] = r;
           if (r.loopDetected) {
@@ -5662,7 +6219,9 @@ ${this.pendingWorktreeNotice}
           calls[idx],
           onStopAfterPermissionCancel,
           toolLoopState,
-          recordSkippedToolCall
+          recordSkippedToolCall,
+          queueToolResultRecord,
+          executionCallIds.get(calls[idx])
         ).then((r) => {
           results[idx] = r;
         }).finally(() => {
@@ -5701,6 +6260,19 @@ ${this.pendingWorktreeNotice}
           parts.push(...batch.response.responseParts);
           continue;
         }
+        if (planModeEntryBoundary && !batch.calls.includes(planModeEntryBoundary)) {
+          for (const fc of batch.calls) {
+            parts.push(
+              await recordSkippedToolCall(
+                fc,
+                PLAN_MODE_ENTRY_SIBLING_SKIP_MESSAGE,
+                true,
+                "execution_denied" /* EXECUTION_DENIED */
+              )
+            );
+          }
+          continue;
+        }
         if (batch.concurrent && batch.calls.length > 1) {
           const batchAbortController = new AbortController();
           let batchStopAfterPermissionCancel = false;
@@ -5744,24 +6316,24 @@ ${this.pendingWorktreeNotice}
               batch.calls[batch.calls.length - 1],
               LOOP_DETECTED_SKIP_MESSAGE
             );
-            return {
+            return await finalizeRunToolResult({
               parts,
               stopAfterPermissionCancel: false,
               loopDetected: true,
               memoryWriteCandidates
-            };
+            });
           }
           if (shouldStop) {
             await appendSkippedAfter(
               parts,
               batch.calls[batch.calls.length - 1]
             );
-            return {
+            return await finalizeRunToolResult({
               parts,
               stopAfterPermissionCancel: true,
               repeatedDuplicateProviderToolCall: false,
               memoryWriteCandidates
-            };
+            });
           }
         } else {
           for (const fc of batch.calls) {
@@ -5771,37 +6343,39 @@ ${this.pendingWorktreeNotice}
               fc,
               void 0,
               toolLoopState,
-              recordSkippedToolCall
+              recordSkippedToolCall,
+              queueToolResultRecord,
+              executionCallIds.get(fc)
             );
             parts.push(...r.parts);
             collectMemoryWriteCandidates(r);
             if (r.loopDetected) {
               await appendSkippedAfter(parts, fc, LOOP_DETECTED_SKIP_MESSAGE);
-              return {
+              return await finalizeRunToolResult({
                 parts,
                 stopAfterPermissionCancel: false,
                 loopDetected: true,
                 memoryWriteCandidates
-              };
+              });
             }
             if (r.stopAfterPermissionCancel) {
               await appendSkippedAfter(parts, fc);
-              return {
+              return await finalizeRunToolResult({
                 parts,
                 stopAfterPermissionCancel: true,
                 repeatedDuplicateProviderToolCall: false,
                 memoryWriteCandidates
-              };
+              });
             }
           }
         }
       }
-      return {
+      return await finalizeRunToolResult({
         parts,
         stopAfterPermissionCancel: false,
         repeatedDuplicateProviderToolCall: false,
         memoryWriteCandidates
-      };
+      });
     } finally {
       await refreshMemoryIfNeeded();
     }
@@ -5836,8 +6410,8 @@ ${this.pendingWorktreeNotice}
     }
     return reminders;
   }
-  async runTool(abortSignal, promptId, fc, onStopAfterPermissionCancel, toolLoopState, recordSkippedToolCall) {
-    const callId = fc.id ?? `${fc.name}-${Date.now()}`;
+  async runTool(abortSignal, promptId, fc, onStopAfterPermissionCancel, toolLoopState, recordSkippedToolCall, queueToolResultRecord, generatedCallId) {
+    const callId = fc.id ?? generatedCallId ?? `${fc.name}-${Date.now()}`;
     let args = fc.args ?? {};
     if (toolLoopState?.loopDetected) {
       return {
@@ -5899,12 +6473,17 @@ ${this.pendingWorktreeNotice}
         await this.toolCallEmitter.emitError(callId, toolName2, error);
       }
       const errorParts = errorResponse(error);
-      this.config.getChatRecordingService()?.recordToolResult(errorParts, {
+      queueToolResultRecord?.(fc, {
         callId,
-        status: "error",
-        resultDisplay: void 0,
-        error,
-        errorType: void 0
+        toolName: toolName2,
+        responseParts: errorParts,
+        metadata: {
+          callId,
+          status: "error",
+          resultDisplay: void 0,
+          error,
+          errorType: void 0
+        }
       });
       const loopDetected = opts?.recordInvalidToolParams === true && !activeToolAbortSignal.aborted && !opts?.stopAfterPermissionCancel && recordDaemonInvalidToolParams(
         this.config,
@@ -5934,19 +6513,22 @@ ${this.pendingWorktreeNotice}
         { recordInvalidToolParams: true }
       );
     }
-    const toolSpan = startToolSpan(toolName, {
+    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: toolName
+      tool_name: policyToolName
     });
     let spanSuccess = false;
     try {
       return await runInToolSpanContext(toolSpan, async () => {
         const pm = this.config.getPermissionManager?.();
-        if (pm && !await pm.isToolEnabled(toolName)) {
+        if (pm && !await pm.isToolEnabled(policyToolName)) {
           return earlyErrorResponse(
             new Error(`Tool "${toolName}" is disabled.`),
             toolName
@@ -5975,7 +6557,7 @@ ${this.pendingWorktreeNotice}
           }
         }
         const toolUseId = generateToolUseId();
-        const approvalMode = this.config.getApprovalMode();
+        let approvalMode = this.config.getApprovalMode();
         let toolBuildSucceeded = false;
         try {
           const invocation = tool.build(args);
@@ -6000,12 +6582,12 @@ ${this.pendingWorktreeNotice}
               activeToolAbortSignal
             );
           }
-          const isAskUserQuestionTool = toolName === ToolNames.ASK_USER_QUESTION;
-          const toolParams = invocation.params;
+          const isAskUserQuestionTool = policyToolName === ToolNames.ASK_USER_QUESTION;
+          let toolParams = invocation.params;
           const flowResult = await evaluatePermissionFlow(
             this.config,
             invocation,
-            toolName,
+            policyToolName,
             toolParams
           );
           const {
@@ -6015,31 +6597,75 @@ ${this.pendingWorktreeNotice}
             denyMessage,
             requiresUserInteraction
           } = flowResult;
+          approvalMode = this.config.getApprovalMode();
           const isPlanMode = approvalMode === "plan" /* PLAN */;
+          const isPlanShellCall = isPlanMode && (policyToolName === ToolNames.SHELL || policyToolName === ToolNames.MONITOR);
           if (finalPermission === "deny") {
             return earlyErrorResponse(
               new Error(denyMessage ?? `Tool "${toolName}" is denied.`),
               toolName
             );
           }
-          const forceAutoReviewForAllow = approvalMode === "auto" /* AUTO */ && (shouldForceAutoModeReviewForAllow(pmCtx, this.config.getCwd()) || shouldClassifyAllShellForAutoMode(toolName, this.config));
+          let planShellAmbientWorkingDirectory;
+          if (isPlanShellCall) {
+            const directory = toolParams["directory"];
+            planShellAmbientWorkingDirectory = typeof directory === "string" && directory.length > 0 ? void 0 : this.config.getTargetDir();
+            invocation.params = {
+              ...structuredClone(invocation.params),
+              directory: typeof directory === "string" && directory.length > 0 ? directory : planShellAmbientWorkingDirectory
+            };
+            toolParams = invocation.params;
+          }
+          const planShellDecision = isPlanShellCall ? await evaluatePlanModeShellPolicy({
+            config: this.config,
+            toolName: policyToolName,
+            requestArgs: originalPolicyRequestArgs,
+            invocationParams: toolParams,
+            permissionContext: pmCtx,
+            ambientWorkingDirectory: planShellAmbientWorkingDirectory,
+            signal: activeToolAbortSignal
+          }) : { classification: "not-applicable" };
+          if (planShellDecision.classification !== "not-applicable") {
+            const initialPlanShellError = await validatePlanModeShellContext({
+              config: this.config,
+              decision: planShellDecision,
+              requestArgs: args,
+              invocationParams: invocation.params,
+              signal: activeToolAbortSignal
+            });
+            if (initialPlanShellError) {
+              return earlyErrorResponse(
+                new Error(initialPlanShellError),
+                toolName
+              );
+            }
+          }
+          if (planShellDecision.classification === "write") {
+            return earlyErrorResponse(
+              new Error(planShellDecision.writeBlockMessage),
+              toolName
+            );
+          }
+          const planShellRequiresConfirmation = planShellDecision.classification === "unknown";
+          const forceAutoReviewForAllow = approvalMode === "auto" /* AUTO */ && (shouldForceAutoModeReviewForAllow(pmCtx, this.config.getCwd()) || shouldClassifyAllShellForAutoMode(policyToolName, this.config));
           const confirmationPermission = getEffectivePermissionForConfirmation(
             finalPermission,
             forceAutoReviewForAllow
           );
           if (finalPermission === "allow" && forceAutoReviewForAllow) {
             debugLogger6.info(
-              `Auto mode: L4 allow overridden by protected-write guard for ${toolName}`
+              `Auto mode: L4 allow overridden by protected-write guard for ${policyToolName}`
             );
           }
-          let autoModeAllowed = finalPermission === "allow" && !forceAutoReviewForAllow;
+          let autoModeAllowed = finalPermission === "allow" && !forceAutoReviewForAllow && !planShellRequiresConfirmation;
           if (autoModeAllowed && approvalMode === "auto" /* AUTO */) {
             this.config.setAutoModeDenialState(
               recordAllow(this.config.getAutoModeDenialState())
             );
           }
-          let wasAutoModeDenialFallback = false;
-          if (!autoModeAllowed && !requiresUserInteraction && shouldRunAutoModeForCall(approvalMode, toolName)) {
+          let wasAutoModeManualFallback = false;
+          let autoModeFallbackMessage;
+          if (!autoModeAllowed && !requiresUserInteraction && shouldRunAutoModeForCall(approvalMode, policyToolName)) {
             const denialState = this.config.getAutoModeDenialState();
             const fallback = shouldFallback(denialState);
             const messages = this.config.getGeminiClient?.()?.getHistoryTail(MAX_TRANSCRIPT_MESSAGES, false) ?? [];
@@ -6061,7 +6687,7 @@ ${this.pendingWorktreeNotice}
               this.config,
               decision,
               outcome,
-              toolName,
+              policyToolName,
               toolParams,
               callId,
               abortSignal
@@ -6072,17 +6698,16 @@ ${this.pendingWorktreeNotice}
                 break;
               case "blocked":
                 debugLogger6.warn(
-                  `Auto mode blocked (${outcome.reason}): tool=${toolName}, ` + formatDenialStateLog(denialState)
+                  `Auto mode blocked (${outcome.reason}): tool=${policyToolName}, ` + formatDenialStateLog(denialState)
                 );
                 return earlyErrorResponse(
                   new Error(outcome.errorMessage),
                   toolName
                 );
               case "fallback":
-                wasAutoModeDenialFallback = isDenialFallbackReason(
-                  outcome.reason
-                );
-                if (wasAutoModeDenialFallback) {
+                wasAutoModeManualFallback = isDenialFallbackReason(outcome.reason) || outcome.reason === "classifier_unavailable";
+                autoModeFallbackMessage = outcome.message;
+                if (wasAutoModeManualFallback) {
                   debugLogger6.warn(
                     `Auto mode fallback to manual approval (${outcome.reason}): ` + formatDenialStateLog(denialState)
                   );
@@ -6097,7 +6722,7 @@ ${this.pendingWorktreeNotice}
           let didRequestPermission = false;
           let confirmationDetails;
           const recordAutoModeFallbackResolution = /* @__PURE__ */ __name((outcome) => {
-            if (approvalMode === "auto" /* AUTO */ && wasAutoModeDenialFallback && isApproveOutcome(outcome)) {
+            if (approvalMode === "auto" /* AUTO */ && wasAutoModeManualFallback && isApproveOutcome(outcome)) {
               const before = this.config.getAutoModeDenialState();
               const after = recordFallbackApprove(before);
               if (after === before) {
@@ -6113,14 +6738,51 @@ ${this.pendingWorktreeNotice}
             }
           }, "recordAutoModeFallbackResolution");
           if (!autoModeAllowed && needsConfirmation(
-            confirmationPermission,
+            planShellRequiresConfirmation ? "ask" : confirmationPermission,
             approvalMode,
-            toolName,
+            policyToolName,
             requiresUserInteraction
           )) {
-            confirmationDetails = await invocation.getConfirmationDetails(abortSignal);
+            confirmationDetails = await invocation.getConfirmationDetails(
+              activeToolAbortSignal
+            );
+            if (autoModeFallbackMessage) {
+              confirmationDetails = decorateClassifierUnavailableConfirmation(
+                confirmationDetails,
+                autoModeFallbackMessage
+              );
+            }
+            if (planShellDecision.classification !== "not-applicable") {
+              const preDisplayPlanShellError = await validatePlanModeShellContext({
+                config: this.config,
+                decision: planShellDecision,
+                requestArgs: args,
+                invocationParams: invocation.params,
+                signal: activeToolAbortSignal
+              });
+              if (preDisplayPlanShellError) {
+                return earlyErrorResponse(
+                  new Error(preDisplayPlanShellError),
+                  toolName
+                );
+              }
+            }
+            try {
+              confirmationDetails = decoratePlanModeShellConfirmation(
+                planShellDecision,
+                confirmationDetails
+              );
+            } catch {
+              if (planShellDecision.classification === "unknown") {
+                return earlyErrorResponse(
+                  new Error(planShellDecision.noApprovalMessage),
+                  toolName
+                );
+              }
+              throw new Error("Unable to prepare shell confirmation.");
+            }
             injectPermissionRulesIfMissing(confirmationDetails, pmCtx);
-            if (isPlanModeBlocked(
+            if (planShellDecision.classification === "not-applicable" && isPlanModeBlocked(
               isPlanMode,
               isExitPlanModeTool,
               isAskUserQuestionTool,
@@ -6140,23 +6802,50 @@ ${this.pendingWorktreeNotice}
             if (hooksEnabled && messageBus) {
               const hookResult = await firePermissionRequestHook(
                 messageBus,
-                toolName,
+                policyToolName,
                 args,
-                String(approvalMode)
+                String(approvalMode),
+                void 0,
+                activeToolAbortSignal
               );
               if (hookResult.hasDecision && (!hookResult.shouldAllow || !requiresUserInteraction)) {
                 hookHandled = true;
                 if (hookResult.shouldAllow) {
-                  if (hookResult.updatedInput) {
-                    args = hookResult.updatedInput;
-                    invocation.params = hookResult.updatedInput;
+                  if (planShellDecision.classification !== "not-applicable") {
+                    const approval = await validatePlanModeShellApproval({
+                      config: this.config,
+                      decision: planShellDecision,
+                      requestArgs: args,
+                      invocationParams: invocation.params,
+                      signal: activeToolAbortSignal,
+                      outcome: "proceed_once" /* ProceedOnce */,
+                      payload: hookResult.updatedInput ? { updatedInput: hookResult.updatedInput } : void 0
+                    });
+                    await confirmationDetails.onConfirm(
+                      approval.outcome,
+                      approval.payload
+                    );
+                    if (approval.outcome === "cancel" /* Cancel */) {
+                      return earlyErrorResponse(
+                        new Error(
+                          approval.payload?.cancelMessage ?? planShellDecision.noApprovalMessage
+                        ),
+                        toolName
+                      );
+                    }
+                    recordAutoModeFallbackResolution(approval.outcome);
+                  } else {
+                    if (hookResult.updatedInput) {
+                      args = hookResult.updatedInput;
+                      invocation.params = hookResult.updatedInput;
+                    }
+                    await confirmationDetails.onConfirm(
+                      "proceed_once" /* ProceedOnce */
+                    );
+                    recordAutoModeFallbackResolution(
+                      "proceed_once" /* ProceedOnce */
+                    );
                   }
-                  await confirmationDetails.onConfirm(
-                    "proceed_once" /* ProceedOnce */
-                  );
-                  recordAutoModeFallbackResolution(
-                    "proceed_once" /* ProceedOnce */
-                  );
                 } else {
                   return earlyErrorResponse(
                     new Error(
@@ -6169,11 +6858,26 @@ ${this.pendingWorktreeNotice}
             }
             if (!requiresUserInteraction && approvalMode === "auto-edit" /* AUTO_EDIT */ && (confirmationDetails.type === "edit" || confirmationDetails.type === "info")) {
             } else if (!hookHandled) {
+              if (planShellDecision.classification !== "not-applicable") {
+                const finalPreDisplayPlanShellError = await validatePlanModeShellContext({
+                  config: this.config,
+                  decision: planShellDecision,
+                  requestArgs: args,
+                  invocationParams: invocation.params,
+                  signal: activeToolAbortSignal
+                });
+                if (finalPreDisplayPlanShellError) {
+                  return earlyErrorResponse(
+                    new Error(finalPreDisplayPlanShellError),
+                    toolName
+                  );
+                }
+              }
               didRequestPermission = true;
               const content = buildPermissionRequestContent(confirmationDetails);
               const mappedKind = this.toolCallEmitter.mapToolKind(
                 tool.kind,
-                toolName
+                policyToolName
               );
               if (hooksEnabled && messageBus) {
                 this.fireNotificationHookWithTerminalSequence(
@@ -6183,9 +6887,16 @@ ${this.pendingWorktreeNotice}
                   "Permission needed"
                 );
               }
+              const permissionOptions = toPermissionOptions(
+                confirmationDetails,
+                pmForcedAsk
+              );
+              const offeredPermissionOptions = permissionOptions.map(
+                (option) => ({ ...option })
+              );
               const params = {
                 sessionId: this.sessionId,
-                options: toPermissionOptions(confirmationDetails, pmForcedAsk),
+                options: permissionOptions,
                 toolCall: {
                   toolCallId: callId,
                   status: "pending",
@@ -6204,10 +6915,12 @@ ${this.pendingWorktreeNotice}
                   }
                 }
               };
-              const stopAfterPermissionCancel = /* @__PURE__ */ __name(() => {
+              const stopAfterPermissionCancel = /* @__PURE__ */ __name((message) => {
                 onStopAfterPermissionCancel?.();
                 return earlyErrorResponse(
-                  new Error(`Tool "${toolName}" was canceled by the user.`),
+                  new Error(
+                    message ?? `Tool "${toolName}" was canceled by the user.`
+                  ),
                   toolName,
                   { stopAfterPermissionCancel: true }
                 );
@@ -6215,10 +6928,15 @@ ${this.pendingWorktreeNotice}
               let output;
               let outcome;
               try {
-                output = await this.client.requestPermission(
-                  params
+                output = await requestPermissionWithAbort(
+                  this.client,
+                  params,
+                  activeToolAbortSignal
+                );
+                outcome = resolvePermissionOutcome(
+                  output,
+                  offeredPermissionOptions
                 );
-                outcome = output.outcome.outcome === "cancelled" ? "cancel" /* Cancel */ : external_exports.nativeEnum(ToolConfirmationOutcome).parse(output.outcome.optionId);
               } catch (error) {
                 debugLogger6.error(
                   `Permission request failed for tool ${toolName}:`,
@@ -6235,7 +6953,9 @@ ${this.pendingWorktreeNotice}
                   );
                 }
                 onStopAfterPermissionCancel?.();
-                const permissionFailureMessage = isExitPlanModeTool ? "The host could not present plan-exit approval. Plan mode remains active; use the host mode selector or /plan exit to leave plan mode." : `Permission request failed for "${toolName}": ${this.#formatError(
+                const permissionFailureMessage = isExitPlanModeTool ? "The host could not present plan-exit approval. Plan mode remains active; use the host mode selector or /plan exit to leave plan mode." : planShellDecision.classification === "unknown" ? `Plan mode could not complete approval for this shell command: ${this.#formatError(
+                  error
+                )}. The command was not run; Plan mode remains active.` : `Permission request failed for "${toolName}": ${this.#formatError(
                   error
                 )}`;
                 return earlyErrorResponse(
@@ -6244,11 +6964,32 @@ ${this.pendingWorktreeNotice}
                   { stopAfterPermissionCancel: true }
                 );
               }
+              let confirmationPayload = {
+                answers: output.answers
+              };
+              if (planShellDecision.classification !== "not-applicable") {
+                const approval = await validatePlanModeShellApproval({
+                  config: this.config,
+                  decision: planShellDecision,
+                  requestArgs: args,
+                  invocationParams: invocation.params,
+                  signal: activeToolAbortSignal,
+                  outcome,
+                  payload: confirmationPayload
+                });
+                outcome = approval.outcome;
+                confirmationPayload = approval.payload;
+              }
+              const shouldSwitchToDefault = outcome === "proceed_once_and_switch_to_default" /* ProceedOnceAndSwitchToDefault */;
+              if (shouldSwitchToDefault) {
+                outcome = "proceed_once" /* ProceedOnce */;
+              }
               recordAutoModeFallbackResolution(outcome);
               try {
-                await confirmationDetails.onConfirm(outcome, {
-                  answers: output.answers
-                });
+                await confirmationDetails.onConfirm(
+                  outcome,
+                  confirmationPayload
+                );
               } catch (error) {
                 if (outcome !== "cancel" /* Cancel */) {
                   throw error;
@@ -6259,21 +7000,31 @@ ${this.pendingWorktreeNotice}
                 );
                 return stopAfterPermissionCancel();
               }
+              if (shouldSwitchToDefault) {
+                this.config.setApprovalMode("default" /* DEFAULT */);
+                await this.sendCurrentModeUpdateNotification();
+              }
               if (outcome === "proceed_always" /* ProceedAlways */ || outcome === "proceed_always_project" /* ProceedAlwaysProject */ || outcome === "proceed_always_user" /* ProceedAlwaysUser */) {
                 await persistPermissionOutcome(
                   outcome,
                   confirmationDetails,
                   this.config.getOnPersistPermissionRule?.(),
                   this.config.getPermissionManager?.(),
-                  { answers: output.answers }
+                  confirmationPayload
                 );
               }
               if (confirmationDetails.type === "edit" && outcome === "proceed_always" /* ProceedAlways */) {
                 await this.sendCurrentModeUpdateNotification();
               }
               switch (outcome) {
+                case "proceed_once_and_switch_to_default" /* ProceedOnceAndSwitchToDefault */:
+                  throw new Error(
+                    "Switch-to-Default outcome must be normalized before execution."
+                  );
                 case "cancel" /* Cancel */:
-                  return stopAfterPermissionCancel();
+                  return stopAfterPermissionCancel(
+                    confirmationPayload?.cancelMessage
+                  );
                 case "proceed_once" /* ProceedOnce */:
                 case "proceed_always" /* ProceedAlways */:
                 case "proceed_always_project" /* ProceedAlwaysProject */:
@@ -6305,7 +7056,7 @@ ${this.pendingWorktreeNotice}
           if (hooksEnabledForTool && messageBusForTool) {
             const preHookResult = await firePreToolUseHook(
               messageBusForTool,
-              toolName,
+              policyToolName,
               args,
               toolUseId,
               permissionMode,
@@ -6422,7 +7173,7 @@ ${this.pendingWorktreeNotice}
             };
             const postHookResult = await firePostToolUseHook(
               messageBusForTool,
-              toolName,
+              policyToolName,
               args,
               toolResponse,
               toolUseId,
@@ -6453,7 +7204,7 @@ ${this.pendingWorktreeNotice}
             const failureHookResult = await firePostToolUseFailureHook(
               messageBusForTool,
               toolUseId,
-              toolName,
+              policyToolName,
               args,
               toolResult.error?.message ?? "Tool execution was cancelled",
               isInterrupt,
@@ -6507,12 +7258,18 @@ ${this.pendingWorktreeNotice}
             prompt_id: promptId,
             tool_type: typeof tool !== "undefined" && tool instanceof DiscoveredMCPTool ? "mcp" : "native"
           });
-          this.config.getChatRecordingService()?.recordToolResult(responseParts, {
+          queueToolResultRecord?.(fc, {
             callId,
-            status,
-            resultDisplay: toolResult.returnDisplay,
-            error: toolResult.error ? new Error(toolResult.error.message) : void 0,
-            errorType: toolResult.error?.type
+            toolName,
+            responseParts,
+            persistedOutputFiles: toolResult.persistedOutputFiles,
+            metadata: {
+              callId,
+              status,
+              resultDisplay: toolResult.returnDisplay,
+              error: toolResult.error ? new Error(toolResult.error.message) : void 0,
+              errorType: toolResult.error?.type
+            }
           });
           spanSuccess = succeeded;
           if (toolResult.error) {
@@ -6542,7 +7299,7 @@ ${this.pendingWorktreeNotice}
             const failureHookResult = await firePostToolUseFailureHook(
               messageBusForError,
               toolUseId,
-              toolName,
+              policyToolName,
               args,
               error.message,
               isInterrupt,
@@ -6563,24 +7320,6 @@ ${this.pendingWorktreeNotice}
             });
           }
           await this.toolCallEmitter.emitError(callId, toolName, error);
-          const errorParts = [
-            {
-              functionResponse: {
-                id: callId,
-                name: toolName,
-                response: { error: error.message }
-              }
-            }
-          ];
-          this.config.getChatRecordingService()?.recordToolResult(errorParts, {
-            callId,
-            // A throw caused by abort (e.g. AbortError) is a cancellation, not
-            // a genuine tool error — keep it consistent with the success path.
-            status: activeToolAbortSignal.aborted ? "cancelled" : "error",
-            resultDisplay: void 0,
-            error,
-            errorType: void 0
-          });
           const loopDetected = !activeToolAbortSignal.aborted && !toolBuildSucceeded && recordDaemonInvalidToolParams(
             this.config,
             promptId,
@@ -6589,6 +7328,18 @@ ${this.pendingWorktreeNotice}
             error
           );
           const responseParts = errorResponse(error);
+          queueToolResultRecord?.(fc, {
+            callId,
+            toolName,
+            responseParts,
+            metadata: {
+              callId,
+              status: activeToolAbortSignal.aborted ? "cancelled" : "error",
+              resultDisplay: void 0,
+              error,
+              errorType: void 0
+            }
+          });
           return {
             parts: responseParts,
             stopAfterPermissionCancel: nestedPermissionCancelled,
@@ -7149,7 +7900,8 @@ function serializeAgentTask(entry, now) {
         at: a.at
       }))
     } : {},
-    ...optionalField("prompt", entry.prompt)
+    ...optionalField("prompt", entry.prompt),
+    ...optionalField("toolUseId", entry.toolUseId)
   };
 }
 __name(serializeAgentTask, "serializeAgentTask");
@@ -7225,6 +7977,7 @@ var QWEN_ACP_LOCAL_READ_ROOTS_ENV = "QWEN_ACP_LOCAL_READ_ROOTS";
 var POSIX_TMP_LOCAL_READ_ROOT = "/tmp";
 var BTW_CHILD_TIMEOUT_MS = 55e3;
 var MCP_OAUTH_START_TIMEOUT_MS = 3e4;
+var SESSION_DRAIN_TIMEOUT_MS = 3e4;
 var WORKSPACE_MEMORY_REMEMBER_CHILD_TIMEOUT_MS = 295e3;
 function createAcpSessionStartProfiler(span) {
   let failedStage;
@@ -7283,6 +8036,77 @@ function workspaceMemoryErrorData(code, diagnostics) {
   };
 }
 __name(workspaceMemoryErrorData, "workspaceMemoryErrorData");
+var SESSION_WRITER_MESSAGES = {
+  session_writer_conflict: "This session is already open in another Qwen process.",
+  session_writer_lost: "Write ownership for this session was lost.",
+  session_transcript_changed: "The session transcript changed outside its active writer.",
+  session_writer_unavailable: "Session write ownership could not be verified."
+};
+function getSessionWriterError(error) {
+  if (!error || typeof error !== "object") return void 0;
+  const candidate = error;
+  const errorKind = candidate["errorKind"];
+  if (typeof errorKind !== "string" || !(errorKind in SESSION_WRITER_RPC_CODES)) {
+    return void 0;
+  }
+  const typedKind = errorKind;
+  if (candidate["rpcCode"] !== SESSION_WRITER_RPC_CODES[typedKind]) {
+    return void 0;
+  }
+  return {
+    rpcCode: SESSION_WRITER_RPC_CODES[typedKind],
+    errorKind: typedKind,
+    message: SESSION_WRITER_MESSAGES[typedKind]
+  };
+}
+__name(getSessionWriterError, "getSessionWriterError");
+function mapSessionWriterRequestError(error) {
+  const writerError = getSessionWriterError(error);
+  return writerError ? new RequestError(writerError.rpcCode, writerError.message, {
+    errorKind: writerError.errorKind
+  }) : error;
+}
+__name(mapSessionWriterRequestError, "mapSessionWriterRequestError");
+async function shutdownSessionConfig(config) {
+  await config.shutdown({ shutdownTelemetry: false });
+  if (config.hasSessionWriteOwnership()) {
+    throw new SessionWriterUnavailableError();
+  }
+}
+__name(shutdownSessionConfig, "shutdownSessionConfig");
+async function waitForSessionDrain(operation, timeoutMs, kind) {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(
+      () => reject(new Error(`Session ${kind} timed out after ${timeoutMs}ms`)),
+      timeoutMs
+    );
+    timer.unref();
+  });
+  try {
+    await Promise.race([operation, timeout]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+__name(waitForSessionDrain, "waitForSessionDrain");
+async function beginSessionCloseAfterCurrentGate(session, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (true) {
+    const releaseGate = session.beginCloseIfAvailable();
+    if (releaseGate) return releaseGate;
+    const remainingMs = deadline - Date.now();
+    if (remainingMs <= 0) {
+      throw new Error(`Session close timed out after ${timeoutMs}ms`);
+    }
+    await waitForSessionDrain(
+      session.waitForCloseGateToRelease(),
+      remainingMs,
+      "close"
+    );
+  }
+}
+__name(beginSessionCloseAfterCurrentGate, "beginSessionCloseAfterCurrentGate");
 var logWorkspaceMemoryExtractionError = createWorkspaceMemoryExtractionErrorLogger(debugLogger7);
 function parseAcpLocalReadRootsEnv(raw = process.env[QWEN_ACP_LOCAL_READ_ROOTS_ENV]) {
   if (!raw) return [];
@@ -7300,7 +8124,7 @@ function buildAcpLocalReadRoots(config) {
     // local read fallback, not read_file's default permission.
     config.storage.getProjectTempDir(),
     path4.join(config.storage.getProjectDir(), "subagents"),
-    Storage.getGlobalTempDir(),
+    path4.join(config.getSessionRuntimeBaseDir(), "tmp"),
     getAutoMemoryRoot(config.getTargetDir()),
     getUserAutoMemoryRoot(),
     ...config.storage.getUserSkillsDirs(),
@@ -8785,7 +9609,9 @@ async function deliverClientMcpMessage(connection, serverName, message, sessionI
   return payload;
 }
 __name(deliverClientMcpMessage, "deliverClientMcpMessage");
-async function runAcpAgent(config, settings, argv) {
+async function runAcpAgent(config, settings, argv, options) {
+  const privateParentCapability = options === void 0 ? process.env[PRIVATE_ACP_CAPABILITY_ENV] : options.privateParentCapability;
+  delete process.env[PRIVATE_ACP_CAPABILITY_ENV];
   let acpConnection;
   const bootstrapClientMcpSender = /* @__PURE__ */ __name((serverName, message) => deliverClientMcpMessage(acpConnection, serverName, message), "bootstrapClientMcpSender");
   beginAcpBootstrapConfigProfiling();
@@ -8803,6 +9629,11 @@ async function runAcpAgent(config, settings, argv) {
   } finally {
     endAcpBootstrapConfigProfiling();
   }
+  const startupWarnings = typeof config.getWarnings === "function" ? config.getWarnings() : [];
+  for (const warning of startupWarnings) {
+    process.stderr.write(`${warning}
+`);
+  }
   const eventLoopMonitor = startEventLoopLagMonitor({
     onNewMaxStall: /* @__PURE__ */ __name((maxMs) => {
       console.error(`[perf] acp agent event loop stall: max=${maxMs}ms`);
@@ -8817,10 +9648,33 @@ async function runAcpAgent(config, settings, argv) {
     console.log = console.error;
     console.info = console.error;
     console.debug = console.error;
-    const stream = ndJsonStream(stdout, stdin);
+    let initializeRequestId;
+    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;
+          return;
+        }
+        if (direction !== "sent" || initializeRequestId === void 0 || !("id" in message) || "method" in message || message.id !== initializeRequestId) {
+          return;
+        }
+        initializeRequestId = void 0;
+        if ("result" in message) {
+          void initializeTelemetry(config).then(() => {
+            registerAcpEventLoopLagGauge(() => eventLoopMonitor.snapshot());
+          });
+        }
+      }, "onMessageObserved")
+    });
     connection = new AgentSideConnection((conn) => {
       acpConnection = conn;
-      agentInstance = new QwenAgent(config, settings, argv, conn);
+      agentInstance = new QwenAgent(
+        config,
+        settings,
+        argv,
+        conn,
+        privateParentCapability
+      );
       return agentInstance;
     }, stream);
     markAcpStartup("transportSetupEnd");
@@ -8828,7 +9682,6 @@ async function runAcpAgent(config, settings, argv) {
     eventLoopMonitor.dispose();
     throw err;
   }
-  registerAcpEventLoopLagGauge(() => eventLoopMonitor.snapshot());
   const drainPoolBeforeExit = /* @__PURE__ */ __name(async (label) => {
     if (!agentInstance) return;
     try {
@@ -8873,7 +9726,7 @@ async function runAcpAgent(config, settings, argv) {
     debugLogger7.debug("[ACP] Shutdown signal received, closing streams");
     try {
       await fireSessionEndOnce("other" /* Other */);
-      agentInstance?.disposeSessions();
+      await agentInstance?.disposeSessions();
       try {
         process.stdin.destroy();
       } catch {
@@ -8900,7 +9753,7 @@ async function runAcpAgent(config, settings, argv) {
     await connection.closed;
     await fireSessionEndOnce("prompt_input_exit" /* PromptInputExit */);
     await drainPoolBeforeExit("ide_close");
-    agentInstance?.disposeSessions();
+    await agentInstance?.disposeSessions();
   } finally {
     process.off("SIGTERM", shutdownHandler);
     process.off("SIGINT", shutdownHandler);
@@ -9017,11 +9870,12 @@ function parseAcpSessionListCursor(value) {
 }
 __name(parseAcpSessionListCursor, "parseAcpSessionListCursor");
 var QwenAgent = class {
-  constructor(config, settings, argv, connection) {
+  constructor(config, settings, argv, connection, expectedPrivateParentCapability) {
     this.config = config;
     this.settings = settings;
     this.argv = argv;
     this.connection = connection;
+    this.expectedPrivateParentCapability = expectedPrivateParentCapability;
     if (process.env["QWEN_SERVE_NO_MCP_POOL"] === "1") {
       this.mcpPool = void 0;
       this.workspaceMcpBudget = void 0;
@@ -9052,14 +9906,18 @@ var QwenAgent = class {
     __name(this, "QwenAgent");
   }
   sessions = /* @__PURE__ */ new Map();
+  activePromptCalls = /* @__PURE__ */ new Map();
   workspaceMcpDiscoveryConfig;
   workspaceMcpDiscoveryPromise;
   workspaceMcpDiscoveryError;
   pendingMcpAuthentications = /* @__PURE__ */ new Map();
   mcpAuthenticationResults = /* @__PURE__ */ new Map();
   generationControllers = /* @__PURE__ */ new Map();
+  workspaceGenerationControllers = /* @__PURE__ */ new Map();
   transcriptReplayConfigCache = /* @__PURE__ */ new Map();
+  pendingConfigCleanup = /* @__PURE__ */ new Map();
   clientCapabilities;
+  privateParentState = "uninitialized";
   // CPU-usage delta baseline for the daemon's `workspaceResource` extMethod
   // (Daemon Status child-resource chart). The daemon polls this at a fixed
   // cadence, so successive calls form a clean delta window independent of tool
@@ -9161,21 +10019,26 @@ var QwenAgent = class {
   async createWorkspaceMcpDiscoveryConfig(settings) {
     if (this.workspaceMcpDiscoveryConfig) return;
     const cwd = this.config.getTargetDir();
-    const config = await loadCliConfig(
-      settings.merged,
-      {
-        ...this.argv,
-        sessionId: "workspace-mcp-discovery",
-        resume: void 0,
-        continue: false
-      },
+    const config = await this.runWithPinnedRuntimeBaseDir(
+      settings,
       cwd,
-      void 0,
-      {
-        userHooks: settings.getUserHooks(),
-        projectHooks: settings.getProjectHooks()
-      },
-      buildDisabledSkillNamesProvider(settings)
+      () => loadCliConfig(
+        settings.merged,
+        {
+          ...this.argv,
+          sessionId: "workspace-mcp-discovery",
+          resume: void 0,
+          continue: false,
+          chatRecording: false
+        },
+        cwd,
+        void 0,
+        {
+          userHooks: settings.getUserHooks(),
+          projectHooks: settings.getProjectHooks()
+        },
+        buildDisabledSkillNamesProvider(settings)
+      )
     );
     config.setMcpTransportPool(this.mcpPool);
     try {
@@ -9215,7 +10078,7 @@ var QwenAgent = class {
       await this.createWorkspaceMcpDiscoveryConfig(settings);
     });
   }
-  reloadWorkspaceMcpDiscovery() {
+  reloadWorkspaceMcpDiscovery(options = {}) {
     return this.enqueueWorkspaceMcpDiscovery("reload", async () => {
       const settings = loadSettings(this.config.getTargetDir());
       const discoveryConfig = this.workspaceMcpDiscoveryConfig;
@@ -9261,8 +10124,62 @@ var QwenAgent = class {
           "Failed to synchronize MCP settings with live sessions"
         );
       }
+      if (options.forceReconnectAll === true || options.forceReconnectWhich !== void 0) {
+        await this.forceReconnectWorkspaceMcp(options.forceReconnectWhich);
+      }
     });
   }
+  async forceReconnectWorkspaceMcp(requestedServerNames) {
+    const serverNames = /* @__PURE__ */ new Set();
+    for (const config of [
+      this.workspaceMcpDiscoveryConfig,
+      this.config,
+      ...this.getActiveSessions().map((session) => session.getConfig())
+    ]) {
+      for (const name of Object.keys(config?.getMcpServers() ?? {})) {
+        serverNames.add(name);
+      }
+    }
+    const selectedServerNames = requestedServerNames ? [...new Set(requestedServerNames)].filter(
+      (name) => serverNames.has(name)
+    ) : [...serverNames];
+    const errors = [];
+    for (const serverName of selectedServerNames) {
+      try {
+        const poolHasEntries = (this.mcpPool?.getSnapshot().byName[serverName]?.entryCount ?? 0) > 0;
+        if (this.mcpPool && poolHasEntries) {
+          const results = await this.mcpPool.restartByName(serverName);
+          const failed = results.find((result) => !result.restarted);
+          if (failed) {
+            throw new Error(
+              `MCP server ${JSON.stringify(serverName)} failed to reconnect: ${failed.reason ?? "unknown error"}`
+            );
+          }
+          await Promise.all(
+            this.getLiveMcpConfigs(serverName).map(async (config) => {
+              const geminiClient = config.getGeminiClient?.();
+              if (geminiClient?.isInitialized?.()) {
+                await geminiClient.setTools?.();
+              }
+            })
+          );
+        } else {
+          await this.reconcileMcpServerAcrossLiveConfigs(
+            serverName,
+            "discover"
+          );
+        }
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+    if (errors.length > 0) {
+      throw new AggregateError(
+        errors,
+        "Failed to force reconnect one or more MCP servers"
+      );
+    }
+  }
   /**
    * Drain the workspace MCP transport pool. Called on shutdown so all
    * pool entries get a coordinated SIGTERM before process.exit. No-op
@@ -9283,100 +10200,229 @@ var QwenAgent = class {
       );
     }
   }
-  async closeStoredSession(sessionId, opts) {
-    for (const [requestId, generation] of this.generationControllers) {
-      if (generation.sessionId !== sessionId) continue;
-      generation.controller.abort();
-      this.generationControllers.delete(requestId);
-    }
-    const session = this.sessions.get(sessionId);
-    if (!session) {
-      this.mcpPool?.releaseSession(sessionId);
-      return;
+  async removeStoredSessionEntry(sessionId, session, cleanupErrors = [], options = {}) {
+    if (this.sessions.get(sessionId) !== session) return;
+    try {
+      session.dispose();
+    } catch (error) {
+      cleanupErrors.push(error);
     }
-    const requireFlush = opts?.requireFlush === true;
-    const flushRecording = /* @__PURE__ */ __name(async () => {
+    if (options.shutdownConfig !== false) {
       try {
-        await session.getConfig().getChatRecordingService()?.flush();
-        return void 0;
-      } catch (err) {
-        debugLogger7.debug(
-          `Session ${sessionId} chat recording flush during close failed: ${err instanceof Error ? err.message : String(err)}`
-        );
-        return err;
-      }
-    }, "flushRecording");
-    if (requireFlush) {
-      const preCancelFlushError = await flushRecording();
-      if (preCancelFlushError !== void 0) {
-        throw preCancelFlushError;
+        await session.getConfig().shutdown({ shutdownTelemetry: false });
+      } catch (error) {
+        cleanupErrors.push(error);
       }
     }
     try {
-      await session.cancelPendingPrompt();
-    } catch (err) {
-      debugLogger7.debug(
-        `Session ${sessionId} cancel during close failed: ${err instanceof Error ? err.message : String(err)}`
-      );
+      unregisterGoalHook(session.getConfig(), sessionId);
+    } catch (error) {
+      cleanupErrors.push(error);
     }
-    const flushError = await flushRecording();
-    if (flushError !== void 0 && requireFlush) {
-      throw flushError;
+    try {
+      this.mcpPool?.releaseSession(sessionId);
+    } catch (error) {
+      cleanupErrors.push(error);
     }
     try {
-      await session.getConfig().getToolRegistry()?.stop();
-    } catch (err) {
-      debugLogger7.debug(
-        `Session ${sessionId} tool registry stop during close failed: ${err instanceof Error ? err.message : String(err)}`
-      );
+      uiTelemetryService.removeSession(sessionId);
+    } catch (error) {
+      cleanupErrors.push(error);
     }
-    unregisterGoalHook(session.getConfig(), sessionId);
-    this.mcpPool?.releaseSession(sessionId);
-    uiTelemetryService.removeSession(sessionId);
     this.sessions.delete(sessionId);
-  }
-  discardStoredSessionIfCurrent(sessionId, session) {
-    if (this.sessions.get(sessionId) !== session) {
-      return;
-    }
-    const logCleanupFailure = /* @__PURE__ */ __name((action, err) => {
-      debugLogger7.debug(
-        `Session ${sessionId} ${action} during failed restore cleanup failed: ${err instanceof Error ? err.message : String(err)}`
+    if (cleanupErrors.length > 0) {
+      debugLogger7.warn(
+        `Session ${sessionId} closed after ${cleanupErrors.length} cleanup failure(s): ${cleanupErrors.map(
+          (error) => error instanceof Error ? error.message : String(error)
+        ).join("; ")}`
       );
-    }, "logCleanupFailure");
+    }
+  }
+  async withLiveSessionRestore(sessionId, session, operation) {
+    await session.assertCanStartTurn();
+    const config = session.getConfig();
+    const releaseGate = session.beginClose();
     try {
-      session.dispose();
-    } catch (err) {
-      logCleanupFailure("dispose", err);
+      await waitForSessionDrain(
+        session.waitForActiveTurnsToSettle(),
+        SESSION_DRAIN_TIMEOUT_MS,
+        "restore"
+      );
+      const recorder = config.getChatRecordingService();
+      const loadAuthoritative = /* @__PURE__ */ __name(() => config.getSessionService().loadSession(sessionId), "loadAuthoritative");
+      const data = recorder ? await recorder.runWithWriteBarrier(loadAuthoritative) : await loadAuthoritative();
+      if (!data) throw new SessionWriterUnavailableError();
+      return await operation(config, data);
+    } catch (error) {
+      throw mapSessionWriterRequestError(error);
+    } finally {
+      releaseGate();
     }
+  }
+  async cleanupUnstoredConfig(config) {
+    const sessionId = config.getSessionId();
+    const cleanupKey = this.pendingConfigCleanupKey(
+      config.getSessionRuntimeBaseDir(),
+      sessionId
+    );
     try {
-      unregisterGoalHook(session.getConfig(), sessionId);
-    } catch (err) {
-      logCleanupFailure("goal hook unregister", err);
+      await shutdownSessionConfig(config);
+    } catch (error) {
+      const pending2 = this.pendingConfigCleanup.get(cleanupKey) ?? /* @__PURE__ */ new Set();
+      pending2.add(config);
+      this.pendingConfigCleanup.set(cleanupKey, pending2);
+      throw mapSessionWriterRequestError(error);
+    }
+    const pending = this.pendingConfigCleanup.get(cleanupKey);
+    pending?.delete(config);
+    if (pending?.size === 0) {
+      this.pendingConfigCleanup.delete(cleanupKey);
     }
+  }
+  async cleanupAfterRequestFailure(error, cleanup) {
     try {
+      await cleanup();
+    } catch (cleanupError) {
+      debugLogger7.warn(
+        `Session cleanup failed while preserving the original request error: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`
+      );
+    }
+    throw error;
+  }
+  pendingConfigCleanupKey(runtimeBaseDir, sessionId) {
+    return `${path4.resolve(runtimeBaseDir)}\0${sessionId}`;
+  }
+  async retryPendingConfigCleanup(runtimeBaseDir, requiredSessionId) {
+    const resolvedRuntimeBaseDir = path4.resolve(runtimeBaseDir);
+    const configs = /* @__PURE__ */ new Set();
+    for (const pending of this.pendingConfigCleanup.values()) {
+      for (const config of pending) {
+        if (path4.resolve(config.getSessionRuntimeBaseDir()) === resolvedRuntimeBaseDir) {
+          configs.add(config);
+        }
+      }
+    }
+    for (const config of configs) {
+      try {
+        await this.cleanupUnstoredConfig(config);
+      } catch (error) {
+        if (config.getSessionId() === requiredSessionId) throw error;
+        debugLogger7.warn(
+          `Deferred Config cleanup retry failed for session ${config.getSessionId()}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  }
+  async closeStoredSession(sessionId, opts) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
       this.mcpPool?.releaseSession(sessionId);
-    } catch (err) {
-      logCleanupFailure("MCP pool release", err);
+      return;
+    }
+    const recorder = session.getConfig().getChatRecordingService();
+    const requireFlush = opts?.requireFlush === true;
+    if (requireFlush) {
+      await recorder?.flush();
+    }
+    const drainTimeoutMs = opts?.drainTimeoutMs ?? SESSION_DRAIN_TIMEOUT_MS;
+    const cancelClose = opts?.waitForCloseGate ? await beginSessionCloseAfterCurrentGate(session, drainTimeoutMs) : session.beginClose();
+    for (const [requestId, generation] of this.generationControllers) {
+      if (generation.sessionId !== sessionId) continue;
+      generation.controller.abort();
+      this.generationControllers.delete(requestId);
     }
+    let removedFromStore = false;
     try {
-      uiTelemetryService.removeSession(sessionId);
-    } catch (err) {
-      logCleanupFailure("telemetry removal", err);
+      await waitForSessionDrain(
+        (async () => {
+          try {
+            await session.cancelPendingPrompt();
+          } catch (err) {
+            debugLogger7.debug(
+              `Session ${sessionId} cancel during close failed: ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
+          await session.waitForActiveTurnsToSettle();
+        })(),
+        drainTimeoutMs,
+        "close"
+      );
+      recorder?.finalize();
+      let flushError;
+      try {
+        await recorder?.flush();
+      } catch (error) {
+        flushError = error;
+      }
+      if (flushError !== void 0 && requireFlush) {
+        throw flushError;
+      }
+      let closeError;
+      try {
+        await recorder?.close();
+      } catch (error) {
+        closeError = error;
+      }
+      if (recorder?.hasWriteOwnership()) {
+        throw closeError ?? new SessionWriterUnavailableError();
+      }
+      const cleanupErrors = [];
+      if (flushError !== void 0) cleanupErrors.push(flushError);
+      if (closeError !== void 0) cleanupErrors.push(closeError);
+      await this.removeStoredSessionEntry(sessionId, session, cleanupErrors, {
+        shutdownConfig: opts?.shutdownConfig
+      });
+      removedFromStore = true;
+    } finally {
+      if (!removedFromStore) cancelClose();
     }
-    this.sessions.delete(sessionId);
   }
-  disposeSessions() {
+  async discardStoredSessionIfCurrent(sessionId, session, opts) {
+    if (this.sessions.get(sessionId) !== session) {
+      return;
+    }
+    await this.closeStoredSession(sessionId, opts);
+  }
+  async disposeSessions() {
     for (const generation of this.generationControllers.values()) {
       generation.controller.abort();
     }
     this.generationControllers.clear();
-    for (const session of this.sessions.values()) {
-      session.dispose();
-    }
-    this.sessions.clear();
+    for (const controller of this.workspaceGenerationControllers.values()) {
+      controller.abort();
+    }
+    this.workspaceGenerationControllers.clear();
+    await Promise.allSettled(
+      [...this.sessions.entries()].map(
+        ([sessionId, session]) => this.discardStoredSessionIfCurrent(sessionId, session, {
+          waitForCloseGate: true
+        })
+      )
+    );
+    await Promise.allSettled(
+      [...this.pendingConfigCleanup.values()].flatMap((configs) => [...configs]).map((config) => this.cleanupUnstoredConfig(config))
+    );
     this.disposeTranscriptReplayConfigs();
   }
+  runWithPinnedRuntimeBaseDir(settings, cwd, operation) {
+    return runWithAcpRuntimeOutputDir(settings, cwd, operation);
+  }
+  async assertLiveSessionScope(config, settings, cwd) {
+    if (path4.resolve(config.storage.getProjectRoot()) !== path4.resolve(cwd)) {
+      throw RequestError.invalidParams(
+        void 0,
+        "The live session belongs to another workspace."
+      );
+    }
+    const requestedRuntimeBaseDir = await this.runWithPinnedRuntimeBaseDir(
+      settings,
+      cwd,
+      () => Storage.getRuntimeBaseDir()
+    );
+    if (path4.resolve(config.getSessionRuntimeBaseDir()) !== path4.resolve(requestedRuntimeBaseDir)) {
+      throw mapSessionWriterRequestError(new SessionWriterUnavailableError());
+    }
+  }
   /** Expose the pool's workspace-scoped budget controller for snapshot builders. */
   getWorkspaceMcpBudget() {
     return this.workspaceMcpBudget;
@@ -9404,9 +10450,34 @@ var QwenAgent = class {
   }
   async initialize(args) {
     markAcpStartup("initializeHandlerStart");
+    if (this.privateParentState === "rejected") {
+      throw RequestError.invalidParams(
+        void 0,
+        "Invalid private ACP parent capability"
+      );
+    }
+    if (this.privateParentState === "uninitialized") {
+      const expectedCapability = this.expectedPrivateParentCapability;
+      if (expectedCapability === void 0) {
+        this.privateParentState = "untrusted";
+      } else {
+        const suppliedCapability = args._meta?.[PRIVATE_PARENT_CAPABILITY_META_KEY];
+        const suppliedBuffer = typeof suppliedCapability === "string" ? Buffer.from(suppliedCapability) : void 0;
+        const expectedBuffer = Buffer.from(expectedCapability);
+        if (suppliedBuffer !== void 0 && suppliedBuffer.length === expectedBuffer.length && timingSafeEqual(suppliedBuffer, expectedBuffer)) {
+          this.privateParentState = "trusted";
+        } else {
+          this.privateParentState = "rejected";
+          throw RequestError.invalidParams(
+            void 0,
+            "Invalid private ACP parent capability"
+          );
+        }
+      }
+    }
     this.clientCapabilities = args.clientCapabilities;
     const authMethods = buildAuthMethods();
-    const version = "0.20.0";
+    const version = "0.20.1-nightly.20260724.7d17c44a3";
     const response = {
       protocolVersion: PROTOCOL_VERSION,
       agentInfo: {
@@ -9495,15 +10566,24 @@ var QwenAgent = class {
           "config_setup",
           () => this.newSessionConfig(cwd, mcpServers, settings)
         );
-        await profiler.time("auth", () => this.ensureAuthenticated(config));
-        profiler.timeSync(
-          "file_system_setup",
-          () => this.setupFileSystem(config)
-        );
-        const session = await profiler.time(
-          "session_register",
-          () => this.createAndStoreSession(config, settings)
-        );
+        let session;
+        try {
+          await profiler.time("auth", () => this.ensureAuthenticated(config));
+          profiler.timeSync(
+            "file_system_setup",
+            () => this.setupFileSystem(config)
+          );
+          session = await profiler.time(
+            "session_register",
+            () => this.createAndStoreSession(config, settings)
+          );
+        } catch (error) {
+          return this.cleanupAfterRequestFailure(error, async () => {
+            if (this.sessions.get(config.getSessionId())?.getConfig() !== config) {
+              await this.cleanupUnstoredConfig(config);
+            }
+          });
+        }
         profiler.setSessionId(session.getId());
         return profiler.timeSync("response_build", () => ({
           sessionId: session.getId(),
@@ -9517,7 +10597,56 @@ var QwenAgent = class {
   }
   async loadSession(params) {
     const settings = loadSettingsCached(params.cwd);
-    const exists = await runWithAcpRuntimeOutputDir(
+    const liveSession = this.sessions.get(params.sessionId);
+    if (liveSession) {
+      const liveConfig = liveSession.getConfig();
+      await this.assertLiveSessionScope(liveConfig, settings, params.cwd);
+      return this.withLiveSessionRestore(
+        params.sessionId,
+        liveSession,
+        async (config2, sessionData2) => {
+          const response2 = {
+            modes: this.buildModesData(config2),
+            models: this.buildAvailableModels(config2),
+            configOptions: this.buildConfigOptions(config2),
+            ...sessionData2.artifactSnapshot ? { artifactSnapshot: sessionData2.artifactSnapshot } : {}
+          };
+          const records = sessionData2.conversation.messages;
+          if (records.length === 0) return response2;
+          const bulkReplay2 = isBulkLoadReplayRequest(params);
+          const replayPage = bulkReplay2 ? selectRecentHistoryRecords(records, getLoadReplayPageSize(params)) : { records, hasMore: false };
+          const replay = await collectHistoryReplayUpdates({
+            sessionId: params.sessionId,
+            config: config2,
+            records: replayPage.records,
+            gaps: sessionData2.historyGaps,
+            cumulativeUsage: createReplayCumulativeUsage(),
+            logger: debugLogger7
+          });
+          if (!bulkReplay2) {
+            for (const update of replay.updates) {
+              await liveSession.sendUpdate(update);
+            }
+            if (replay.replayError !== void 0) {
+              throw RequestError.internalError(void 0, replay.replayError);
+            }
+            return response2;
+          }
+          return {
+            ...response2,
+            _meta: {
+              [LOAD_REPLAY_META_KEY]: {
+                v: LOAD_REPLAY_VERSION,
+                updates: replay.updates,
+                ...replay.replayError !== void 0 ? { partial: true, replayError: replay.replayError } : {},
+                ...replayPage.hasMore ? { hasMore: true } : {}
+              }
+            }
+          };
+        }
+      );
+    }
+    const exists = await this.runWithPinnedRuntimeBaseDir(
       settings,
       params.cwd,
       async () => {
@@ -9540,17 +10669,26 @@ var QwenAgent = class {
       params.sessionId,
       true
     );
-    await this.ensureAuthenticated(config);
-    this.setupFileSystem(config);
     const sessionData = config.getResumedSessionData();
     const bulkReplay = isBulkLoadReplayRequest(params);
     const replayPageSize = bulkReplay ? getLoadReplayPageSize(params) : void 0;
-    const session = await this.createAndStoreSession(
-      config,
-      settings,
-      sessionData,
-      bulkReplay ? { replayHistory: false, startPostReplayServices: false } : {}
-    );
+    let session;
+    try {
+      await this.ensureAuthenticated(config);
+      this.setupFileSystem(config);
+      session = await this.createAndStoreSession(
+        config,
+        settings,
+        sessionData,
+        bulkReplay ? { replayHistory: false, startPostReplayServices: false } : {}
+      );
+    } catch (error) {
+      return this.cleanupAfterRequestFailure(error, async () => {
+        if (this.sessions.get(config.getSessionId())?.getConfig() !== config) {
+          await this.cleanupUnstoredConfig(config);
+        }
+      });
+    }
     let replayEnvelope;
     if (bulkReplay) {
       try {
@@ -9597,11 +10735,25 @@ var QwenAgent = class {
         session.installRewriter();
         session.startCronScheduler();
       } catch (err) {
-        this.discardStoredSessionIfCurrent(params.sessionId, session);
-        throw 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);
@@ -9624,7 +10776,22 @@ var QwenAgent = class {
   }
   async unstable_resumeSession(params) {
     const settings = loadSettingsCached(params.cwd);
-    const exists = await runWithAcpRuntimeOutputDir(
+    const liveSession = this.sessions.get(params.sessionId);
+    if (liveSession) {
+      const liveConfig = liveSession.getConfig();
+      await this.assertLiveSessionScope(liveConfig, settings, params.cwd);
+      return this.withLiveSessionRestore(
+        params.sessionId,
+        liveSession,
+        async (config2, sessionData2) => ({
+          modes: this.buildModesData(config2),
+          models: this.buildAvailableModels(config2),
+          configOptions: this.buildConfigOptions(config2),
+          ...sessionData2.artifactSnapshot ? { artifactSnapshot: sessionData2.artifactSnapshot } : {}
+        })
+      );
+    }
+    const exists = await this.runWithPinnedRuntimeBaseDir(
       settings,
       params.cwd,
       async () => {
@@ -9643,15 +10810,25 @@ var QwenAgent = class {
       params.sessionId,
       true
     );
-    await this.ensureAuthenticated(config);
-    this.setupFileSystem(config);
-    const session = await this.createAndStoreSession(
-      config,
-      settings,
-      config.getResumedSessionData(),
-      { replayHistory: false }
-    );
+    let session;
+    try {
+      await this.ensureAuthenticated(config);
+      this.setupFileSystem(config);
+      session = await this.createAndStoreSession(
+        config,
+        settings,
+        config.getResumedSessionData(),
+        { replayHistory: false }
+      );
+    } catch (error) {
+      return this.cleanupAfterRequestFailure(error, async () => {
+        if (this.sessions.get(config.getSessionId())?.getConfig() !== config) {
+          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);
@@ -9681,6 +10858,10 @@ var QwenAgent = class {
       debugLogger7.warn(`ACP worktree restore failed: ${error}`);
     }
   }
+  async #restoreBackgroundAgentsOnResume(config, session) {
+    await config.loadPausedBackgroundAgents(config.getSessionId());
+    session.pendingRecoveredAgentsNotice = config.consumePendingRecoveredAgentsNotice();
+  }
   /**
    * Re-registers the `/goal` Stop hook when a resumed transcript ends on an
    * unsatisfied goal — the daemon counterpart of the TUI's resume restore.
@@ -9814,7 +10995,50 @@ var QwenAgent = class {
     if (!session) {
       throw new Error(`Session not found: ${params.sessionId}`);
     }
-    return session.prompt(params);
+    const sanitizedParams = { ...params };
+    const meta = params._meta && typeof params._meta === "object" ? { ...params._meta } : {};
+    const suppliedContext = meta[INVOCATION_CONTEXT_META_KEY];
+    delete meta[INVOCATION_CONTEXT_META_KEY];
+    delete meta[PRIVATE_PARENT_CAPABILITY_META_KEY];
+    if (Object.keys(meta).length > 0) {
+      sanitizedParams._meta = meta;
+    } else {
+      delete sanitizedParams._meta;
+    }
+    const invocationContext = this.privateParentState === "trusted" && suppliedContext !== void 0 ? parseInvocationContext(suppliedContext) : void 0;
+    if (this.privateParentState === "trusted" && suppliedContext !== void 0 && invocationContext === void 0) {
+      throw RequestError.invalidParams(
+        void 0,
+        "Invalid trusted ACP invocation context"
+      );
+    }
+    let settleCall = /* @__PURE__ */ __name(() => {
+    }, "settleCall");
+    const call = {
+      controller: new AbortController(),
+      settled: new Promise((resolve5) => {
+        settleCall = resolve5;
+      })
+    };
+    let calls = this.activePromptCalls.get(params.sessionId);
+    if (!calls) {
+      calls = /* @__PURE__ */ new Set();
+      this.activePromptCalls.set(params.sessionId, calls);
+    }
+    calls.add(call);
+    try {
+      return await session.prompt(
+        sanitizedParams,
+        invocationContext,
+        call.controller.signal
+      );
+    } finally {
+      calls.delete(call);
+      if (calls.size === 0) {
+        this.activePromptCalls.delete(params.sessionId);
+      }
+      settleCall();
+    }
   }
   async cancel(params) {
     const session = this.sessions.get(params.sessionId);
@@ -11564,10 +12788,48 @@ var QwenAgent = class {
     };
   }
   async extMethod(method, params) {
+    try {
+      return await this.extMethodInternal(method, params);
+    } catch (error) {
+      const writerError = getSessionWriterError(error);
+      if (writerError) {
+        throw new RequestError(writerError.rpcCode, writerError.message, {
+          errorKind: writerError.errorKind
+        });
+      }
+      throw error;
+    }
+  }
+  async extMethodInternal(method, params) {
     const requestedCwd = typeof params["cwd"] === "string" ? params["cwd"] : void 0;
     const cwd = requestedCwd || process.cwd();
     const SESSION_ID_RE = /^[0-9a-fA-F-]{32,36}$/;
     switch (method) {
+      case PROMPT_CANCEL_METHOD: {
+        const sessionId = params["sessionId"];
+        if (typeof sessionId !== "string" || sessionId.length === 0) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Invalid or missing sessionId"
+          );
+        }
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+          throw RequestError.invalidParams(
+            void 0,
+            `Session not found for id: ${sessionId}`
+          );
+        }
+        const targetedCalls = new Set(
+          this.activePromptCalls.get(sessionId) ?? []
+        );
+        if (targetedCalls.size === 0) {
+          return { cancelled: false };
+        }
+        targetedCalls.forEach((call) => call.controller.abort());
+        await Promise.all(Array.from(targetedCalls, (call) => call.settled));
+        return { cancelled: true };
+      }
       case TODO_STOP_GUARD_QUEUE_RELEASE_METHOD: {
         const sessionId = params["sessionId"];
         if (typeof sessionId !== "string" || sessionId.length === 0) {
@@ -11837,6 +13099,25 @@ var QwenAgent = class {
             "Transcript cursor and record boundary are mutually exclusive"
           );
         }
+        const rawDirection = params["direction"];
+        if (rawDirection !== void 0 && rawDirection !== "backward") {
+          throw RequestError.invalidParams(
+            void 0,
+            "Invalid transcript direction"
+          );
+        }
+        if (rawCursor !== void 0 && rawDirection !== void 0) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Transcript cursor and direction are mutually exclusive"
+          );
+        }
+        if (rawBeforeRecordId !== void 0 && rawDirection !== void 0) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Transcript record boundary and direction are mutually exclusive"
+          );
+        }
         const rawLimit = params["limit"];
         if (rawLimit !== void 0 && (!Number.isSafeInteger(rawLimit) || rawLimit < 1 || rawLimit > SESSION_TRANSCRIPT_MAX_LIMIT)) {
           throw RequestError.invalidParams(
@@ -11847,10 +13128,14 @@ var QwenAgent = class {
         try {
           const settings = loadSettingsCached(cwd);
           return await runWithAcpRuntimeOutputDir(settings, cwd, async () => {
+            if (rawDirection === "backward") {
+              await this.sessions.get(sessionId)?.getConfig().getChatRecordingService()?.flush();
+            }
             const reader = new SessionTranscriptReader(cwd);
             const page = await reader.readPage(sessionId, {
               ...typeof rawCursor === "string" ? { cursor: rawCursor } : {},
               ...typeof rawBeforeRecordId === "string" ? { beforeRecordId: rawBeforeRecordId } : {},
+              ...rawDirection === "backward" ? { direction: rawDirection } : {},
               ...typeof rawLimit === "number" ? { limit: rawLimit } : {},
               maxBytes: SESSION_TRANSCRIPT_MAX_PAGE_BYTES
             });
@@ -12396,8 +13681,34 @@ var QwenAgent = class {
       }
       case SERVE_CONTROL_EXT_METHODS.workspaceMcpInitialize:
         return this.initializeWorkspaceMcpDiscovery();
-      case SERVE_CONTROL_EXT_METHODS.workspaceMcpReload:
-        return this.reloadWorkspaceMcpDiscovery();
+      case SERVE_CONTROL_EXT_METHODS.workspaceMcpReload: {
+        const forceReconnectAll = params["forceReconnectAll"];
+        const forceReconnectWhich = params["forceReconnectWhich"];
+        if (forceReconnectAll !== void 0 && typeof forceReconnectAll !== "boolean") {
+          throw RequestError.invalidParams(
+            void 0,
+            "forceReconnectAll must be a boolean"
+          );
+        }
+        if (forceReconnectWhich !== void 0 && (!Array.isArray(forceReconnectWhich) || forceReconnectWhich.some(
+          (serverName) => typeof serverName !== "string" || serverName.length === 0
+        ))) {
+          throw RequestError.invalidParams(
+            void 0,
+            "forceReconnectWhich must be an array of server names"
+          );
+        }
+        if (forceReconnectAll === true && forceReconnectWhich !== void 0) {
+          throw RequestError.invalidParams(
+            void 0,
+            "forceReconnectAll and forceReconnectWhich cannot be used together"
+          );
+        }
+        return this.reloadWorkspaceMcpDiscovery({
+          forceReconnectAll: forceReconnectAll === true,
+          forceReconnectWhich
+        });
+      }
       case SERVE_CONTROL_EXT_METHODS.workspaceMcpManage: {
         const serverName = params["serverName"];
         const action = params["action"];
@@ -12649,6 +13960,52 @@ var QwenAgent = class {
           authUrl
         };
       }
+      case SERVE_CONTROL_EXT_METHODS.workspaceGenerationStart: {
+        const requestId = params["requestId"];
+        const prompt = params["prompt"];
+        if (typeof requestId !== "string" || requestId.length === 0) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Invalid or missing requestId"
+          );
+        }
+        if (typeof prompt !== "string" || !prompt.trim() || Buffer.byteLength(prompt, "utf8") > GENERATION_MAX_PROMPT_BYTES || params["purpose"] !== "text") {
+          throw RequestError.invalidParams(
+            void 0,
+            "Invalid workspace generation request"
+          );
+        }
+        if (this.workspaceGenerationControllers.has(requestId)) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Duplicate workspace generation requestId"
+          );
+        }
+        const controller = new AbortController();
+        this.workspaceGenerationControllers.set(requestId, controller);
+        const signal = AbortSignal.any([
+          controller.signal,
+          AbortSignal.timeout(GENERATION_TIMEOUT_MS)
+        ]);
+        try {
+          const emit = /* @__PURE__ */ __name(async (event) => {
+            await this.connection.extNotification(
+              "qwen/notify/workspace/generation/event",
+              { v: 1, requestId, event }
+            );
+          }, "emit");
+          const result = await executeGeneration(
+            this.config,
+            requestId,
+            prompt.trim(),
+            signal,
+            emit
+          );
+          return { requestId, ...result };
+        } finally {
+          this.workspaceGenerationControllers.delete(requestId);
+        }
+      }
       case SERVE_CONTROL_EXT_METHODS.workspaceAgentGenerate: {
         const description = params["description"];
         if (typeof description !== "string" || !description.trim() || description.length > 4096) {
@@ -12663,6 +14020,22 @@ var QwenAgent = class {
           AbortSignal.timeout(5 * 6e4)
         );
       }
+      case SERVE_CONTROL_EXT_METHODS.workspaceGenerationCancel: {
+        const requestId = params["requestId"];
+        if (typeof requestId !== "string" || requestId.length === 0) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Invalid or missing requestId"
+          );
+        }
+        const controller = this.workspaceGenerationControllers.get(requestId);
+        const cancelled = controller !== void 0;
+        if (cancelled) {
+          controller.abort();
+          this.workspaceGenerationControllers.delete(requestId);
+        }
+        return { requestId, cancelled };
+      }
       case SERVE_CONTROL_EXT_METHODS.sessionArtifactsPersist: {
         const sessionId = params["sessionId"];
         if (typeof sessionId !== "string" || sessionId.length === 0) {
@@ -12704,6 +14077,34 @@ var QwenAgent = class {
         }
         return { sessionId, persisted: true, kind };
       }
+      case "qwen/session/recordTextElements": {
+        const sessionId = params["sessionId"];
+        const content = params["content"];
+        const textElements = params["textElements"];
+        if (typeof sessionId !== "string" || sessionId.length === 0) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Invalid or missing sessionId"
+          );
+        }
+        if (typeof content !== "string" || !Array.isArray(textElements)) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Invalid user text elements payload"
+          );
+        }
+        const session = this.sessionOrThrow(sessionId);
+        await session.assertCanStartTurn();
+        const recording = session.getConfig().getChatRecordingService();
+        if (!recording) {
+          throw RequestError.internalError(
+            void 0,
+            "Chat recording service unavailable"
+          );
+        }
+        await recording.recordUserTextElements({ content, textElements });
+        return { sessionId, persisted: true };
+      }
       case SERVE_CONTROL_EXT_METHODS.sessionTitle: {
         const sessionId = params["sessionId"];
         const displayName = params["displayName"];
@@ -12799,8 +14200,16 @@ var QwenAgent = class {
             "Invalid or missing sessionId"
           );
         }
+        const rawDrainTimeoutMs = params["drainTimeoutMs"];
+        if (rawDrainTimeoutMs !== void 0 && (typeof rawDrainTimeoutMs !== "number" || !Number.isSafeInteger(rawDrainTimeoutMs) || rawDrainTimeoutMs < 1 || rawDrainTimeoutMs > 2147483647)) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Invalid session close drain timeout"
+          );
+        }
         await this.closeStoredSession(sessionId, {
-          requireFlush: params["requireFlush"] === true
+          requireFlush: params["requireFlush"] === true,
+          ...typeof rawDrainTimeoutMs === "number" ? { drainTimeoutMs: rawDrainTimeoutMs } : {}
         });
         return { sessionId, closed: true };
       }
@@ -12842,6 +14251,21 @@ var QwenAgent = class {
           });
         }
         const canonicalPath = await fs2.realpath(targetPath);
+        const allowedRoots = params["allowedRoots"];
+        if (Array.isArray(allowedRoots) && allowedRoots.length > 0) {
+          const contained = allowedRoots.some((root) => {
+            if (typeof root !== "string") return false;
+            const rel = path4.relative(root, canonicalPath);
+            return !rel.startsWith("..") && !path4.isAbsolute(rel);
+          });
+          if (!contained) {
+            throw new RequestError(
+              -32004,
+              `Path outside allowed roots: ${canonicalPath}`,
+              { errorKind: "containment_violation", path: canonicalPath }
+            );
+          }
+        }
         const previousCwd = config.getTargetDir();
         if (canonicalPath === previousCwd) {
           return { previousCwd, newCwd: canonicalPath, warnings: [] };
@@ -13723,16 +15147,11 @@ ${outputText}
         let artifactSnapshot;
         let artifactSnapshotUnavailable;
         try {
-          await session.getConfig().getChatRecordingService()?.flush();
-          const cwd2 = session.getConfig().getProjectRoot();
-          const sessionData = await runWithAcpRuntimeOutputDir(
-            this.settings,
-            cwd2,
-            async () => {
-              const sessionService = new SessionService(cwd2);
-              return sessionService.loadSession(sessionId);
-            }
-          );
+          const config = session.getConfig();
+          const recording = config.getChatRecordingService();
+          await recording?.flush();
+          const loadAuthoritative = /* @__PURE__ */ __name(() => config.getSessionService().loadSession(sessionId), "loadAuthoritative");
+          const sessionData = recording ? await recording.runWithWriteBarrier(loadAuthoritative) : await loadAuthoritative();
           if (sessionData === void 0) {
             artifactSnapshotUnavailable = "session data unavailable after rewind";
           } else if (sessionData.artifactSnapshot) {
@@ -13773,20 +15192,37 @@ ${outputText}
             "Invalid or missing sessionId"
           );
         }
-        const sessionData = await runWithAcpRuntimeOutputDir(
-          this.settings,
-          cwd,
-          async () => {
-            const sessionService = new SessionService(cwd);
-            return sessionService.loadSession(sessionId);
-          }
-        );
+        const liveSession = this.sessions.get(sessionId);
+        let replayConfig = this.config;
+        let sessionData;
+        if (liveSession) {
+          const config = liveSession.getConfig();
+          await this.assertLiveSessionScope(
+            config,
+            loadSettingsCached(cwd),
+            cwd
+          );
+          const recording = config.getChatRecordingService();
+          const loadAuthoritative = /* @__PURE__ */ __name(() => config.getSessionService().loadSession(sessionId), "loadAuthoritative");
+          sessionData = recording ? await recording.runWithWriteBarrier(loadAuthoritative) : await loadAuthoritative();
+          replayConfig = config;
+        } else {
+          const settings = loadSettingsCached(cwd);
+          sessionData = await this.runWithPinnedRuntimeBaseDir(
+            settings,
+            cwd,
+            async () => {
+              const sessionService = new SessionService(cwd);
+              return sessionService.loadSession(sessionId);
+            }
+          );
+        }
         if (!sessionData?.conversation) {
           return { updates: [] };
         }
         const replay = await collectHistoryReplayUpdates({
           sessionId,
-          config: this.config,
+          config: replayConfig,
           records: sessionData.conversation.messages,
           gaps: sessionData.historyGaps,
           cumulativeUsage: createReplayCumulativeUsage(),
@@ -13854,56 +15290,51 @@ ${outputText}
             sessionId
           });
         }
-        const recording = sourceSession.getConfig().getChatRecordingService();
+        const sourceConfig = sourceSession.getConfig();
+        const recording = sourceConfig.getChatRecordingService();
         if (recording) {
           await recording.flush();
         }
-        const newSessionId = randomUUID();
-        return await runWithAcpRuntimeOutputDir(
-          this.settings,
-          cwd,
-          async () => {
-            const sessionService = new SessionService(cwd);
-            await sessionService.forkSession(sessionId, newSessionId);
-            let title;
-            try {
-              let baseName;
-              if (typeof name === "string" && name.trim().length > 0) {
-                baseName = name.trim();
-              } else {
-                const existingTitle = recording?.getCurrentCustomTitle();
-                const stripped = existingTitle?.replace(/\s*\(Branch(?:\s+\d+)?\)\s*$/, "").trim();
-                if (stripped && stripped.length > 0) {
-                  baseName = stripped;
-                } else {
-                  baseName = sessionId.slice(0, 8);
-                }
-              }
-              title = await computeUniqueBranchTitle(baseName, sessionService);
-              const renamed = await sessionService.renameSession(
-                newSessionId,
-                title,
-                "manual"
-              );
-              if (!renamed) {
-                throw new RequestError(
-                  -32603,
-                  `Failed to set title on forked session ${newSessionId}`,
-                  { errorKind: "internal", sessionId: newSessionId }
-                );
-              }
-            } catch (err) {
-              sessionService.removeSession(newSessionId).catch((rmErr) => {
-                process.stderr.write(
-                  `qwen serve: failed to clean up orphan session ${newSessionId}: ${rmErr instanceof Error ? rmErr.message : rmErr}
-`
-                );
-              });
-              throw err;
+        const newSessionId = randomUUID2();
+        const sessionService = sourceConfig.getSessionService();
+        await sessionService.forkSession(sessionId, newSessionId);
+        let title;
+        try {
+          let baseName;
+          if (typeof name === "string" && name.trim().length > 0) {
+            baseName = name.trim();
+          } else {
+            const existingTitle = recording?.getCurrentCustomTitle();
+            const stripped = existingTitle?.replace(/\s*\(Branch(?:\s+\d+)?\)\s*$/, "").trim();
+            if (stripped && stripped.length > 0) {
+              baseName = stripped;
+            } else {
+              baseName = sessionId.slice(0, 8);
             }
-            return { newSessionId, title, displayName: title };
           }
-        );
+          title = await computeUniqueBranchTitle(baseName, sessionService);
+          const renamed = await sessionService.renameSession(
+            newSessionId,
+            title,
+            "manual"
+          );
+          if (!renamed) {
+            throw new RequestError(
+              -32603,
+              `Failed to set title on forked session ${newSessionId}`,
+              { errorKind: "internal", sessionId: newSessionId }
+            );
+          }
+        } catch (err) {
+          sessionService.removeSession(newSessionId).catch((rmErr) => {
+            process.stderr.write(
+              `qwen serve: failed to clean up orphan session ${newSessionId}: ${rmErr instanceof Error ? rmErr.message : rmErr}
+`
+            );
+          });
+          throw err;
+        }
+        return { newSessionId, title, displayName: title };
       }
       case "qwen/settings/getCore": {
         const settings = loadSettings(cwd);
@@ -14292,17 +15723,25 @@ ${outputText}
       this.disposeTranscriptReplayConfig(cached.config);
     }
     const entry = { settings };
-    const pending = this.newSessionConfig(cwd, [], settings, void 0, false, {
-      skipMcpDiscovery: true,
-      skipHooks: true,
-      skipSkillManager: true,
-      skipFileCheckpointing: true,
-      // Read-only replay: tolerate tools that cannot construct without the
-      // subsystems skipped above (e.g. SkillTool needs the SkillManager). The
-      // registry is only consulted for optional tool_call metadata during
-      // replay, and ToolCallEmitter falls back to the recorded tool name.
-      lenientToolWarmup: true
-    });
+    const pending = this.newSessionConfig(
+      cwd,
+      [],
+      settings,
+      void 0,
+      false,
+      {
+        skipMcpDiscovery: true,
+        skipHooks: true,
+        skipSkillManager: true,
+        skipFileCheckpointing: true,
+        // Read-only replay: tolerate tools that cannot construct without the
+        // subsystems skipped above (e.g. SkillTool needs the SkillManager). The
+        // registry is only consulted for optional tool_call metadata during
+        // replay, and ToolCallEmitter falls back to the recorded tool name.
+        lenientToolWarmup: true
+      },
+      false
+    );
     entry.pending = pending;
     this.transcriptReplayConfigCache.set(key, entry);
     try {
@@ -14330,7 +15769,34 @@ ${outputText}
       throw error;
     }
   }
-  async newSessionConfig(cwd, mcpServers, settings, sessionId, resume, initializeOptions = {}) {
+  async newSessionConfig(cwd, mcpServers, settings, sessionId, resume, initializeOptions = {}, chatRecording) {
+    try {
+      return await this.runWithPinnedRuntimeBaseDir(settings, cwd, async () => {
+        await this.retryPendingConfigCleanup(
+          Storage.getRuntimeBaseDir(),
+          sessionId
+        );
+        return this.newSessionConfigInRuntimeContext(
+          cwd,
+          mcpServers,
+          settings,
+          sessionId,
+          resume,
+          initializeOptions,
+          chatRecording
+        );
+      });
+    } catch (error) {
+      const writerError = getSessionWriterError(error);
+      if (writerError) {
+        throw new RequestError(writerError.rpcCode, writerError.message, {
+          errorKind: writerError.errorKind
+        });
+      }
+      throw error;
+    }
+  }
+  async newSessionConfigInRuntimeContext(cwd, mcpServers, settings, sessionId, resume, initializeOptions = {}, chatRecording) {
     const sessionMcpServers = {};
     for (const server of mcpServers) {
       const stdioServer = toStdioServer(server);
@@ -14386,8 +15852,14 @@ ${outputText}
     const sessionArg = resume === true ? { resume: sessionId, sessionId: void 0 } : { sessionId, resume: void 0 };
     const argvForSession = {
       ...this.argv,
+      // Docker sandbox relaunch injects a fixed --sandbox-session-id into
+      // the ACP process argv. Without clearing it, every newSession()
+      // inherits the same ID and the second session collides with the
+      // first's writer lease (#7435).
+      sandboxSessionId: void 0,
       ...sessionArg,
-      continue: false
+      continue: false,
+      ...chatRecording !== void 0 ? { chatRecording } : {}
     };
     const config = await loadCliConfig(
       mergedSettings,
@@ -14441,15 +15913,22 @@ ${outputText}
         });
       });
     }
-    await config.initialize({
-      ...initializeOptions,
-      // Reverse tool channel (issue #5626, Phase 2): bind the session
-      // manager's SDK MCP callback to the `client_mcp/message` ext-method so a
-      // client-hosted (extension) MCP server added at runtime reaches the
-      // daemon WS. Servers that aren't client-hosted never use this callback
-      // (the daemon only adds SDK-type runtime servers for client MCP).
-      sendSdkMcpMessage: this.buildClientMcpSender(wiredSessionId)
-    });
+    try {
+      await config.initialize({
+        ...initializeOptions,
+        // Reverse tool channel (issue #5626, Phase 2): bind the session
+        // manager's SDK MCP callback to the `client_mcp/message` ext-method so a
+        // client-hosted (extension) MCP server added at runtime reaches the
+        // daemon WS. Servers that aren't client-hosted never use this callback
+        // (the daemon only adds SDK-type runtime servers for client MCP).
+        sendSdkMcpMessage: this.buildClientMcpSender(wiredSessionId)
+      });
+    } catch (error) {
+      return this.cleanupAfterRequestFailure(
+        error,
+        () => this.cleanupUnstoredConfig(config)
+      );
+    }
     void this.surfaceMcpFailuresWhenReady(config);
     return config;
   }
@@ -14510,34 +15989,52 @@ ${outputText}
     if (needsInitialize) {
       await geminiClient.initialize();
     }
-    this.sessions.get(sessionId)?.dispose();
+    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);
-    setTimeout(async () => {
-      await session.sendAvailableCommandsUpdate();
-    }, 0);
-    if (sessionData?.fileHistorySnapshots?.length) {
-      config.getFileHistoryService().restoreFromSnapshots(sessionData.fileHistorySnapshots);
-    }
-    if (sessionData?.conversation.messages) {
-      config.getChatRecordingService()?.rebuildTurnBoundaries(sessionData.conversation.messages);
-    }
-    if (options.replayHistory !== false && sessionData?.conversation.messages) {
-      await session.replayHistory(
-        sessionData.conversation.messages,
-        sessionData.historyGaps
-      );
-    }
-    if (options.startPostReplayServices !== false) {
-      session.installRewriter();
-      session.startCronScheduler();
+    try {
+      if (sessionData?.fileHistorySnapshots?.length) {
+        config.getFileHistoryService().restoreFromSnapshots(sessionData.fileHistorySnapshots);
+      }
+      if (sessionData?.conversation.messages) {
+        config.getChatRecordingService()?.rebuildTurnBoundaries(sessionData.conversation.messages);
+      }
+      if (options.replayHistory !== false && sessionData?.conversation.messages) {
+        await session.replayHistory(
+          sessionData.conversation.messages,
+          sessionData.historyGaps
+        );
+      }
+      if (options.startPostReplayServices !== false) {
+        session.installRewriter();
+        session.startCronScheduler();
+      }
+      setTimeout(() => {
+        void session.sendAvailableCommandsUpdate();
+      }, 0);
+      return session;
+    } catch (error) {
+      try {
+        await this.discardStoredSessionIfCurrent(sessionId, session, {
+          shutdownConfig: false
+        });
+      } catch (cleanupError) {
+        await this.removeStoredSessionEntry(
+          sessionId,
+          session,
+          [cleanupError],
+          { shutdownConfig: false }
+        );
+      }
+      throw error;
     }
-    return session;
   }
   buildAvailableModels(config) {
     const rawCurrentModelId = (config.getModel() || this.config.getModel() || "").trim();
     const currentAuthType = config.getAuthType();
-    const modelOptions = buildAcpModelOptions(config.getAllConfiguredModels());
+    const modelOptions = this.buildSelectableModelOptions(config);
     const activeRuntimeSnapshot = config.getActiveRuntimeModelSnapshot?.();
     const currentModelId = getCurrentAcpModelId(
       modelOptions,
@@ -14572,7 +16069,7 @@ ${outputText}
   }
   buildConfigOptions(config) {
     const currentApprovalMode = config.getApprovalMode();
-    const modelOptions = buildAcpModelOptions(config.getAllConfiguredModels());
+    const modelOptions = this.buildSelectableModelOptions(config);
     const rawCurrentModelId = (config.getModel() || "").trim();
     const currentAuthType = config.getAuthType?.();
     const activeRuntimeSnapshot = config.getActiveRuntimeModelSnapshot?.();
@@ -14612,6 +16109,14 @@ ${outputText}
     };
     return [modeConfigOption, modelConfigOption];
   }
+  buildSelectableModelOptions(config) {
+    const currentAuthType = config.getAuthType();
+    return buildAcpModelOptions(
+      config.getAllConfiguredModels().filter(
+        (model) => model.authType !== "qwen-oauth" /* QWEN_OAUTH */ || currentAuthType === "qwen-oauth" /* QWEN_OAUTH */
+      )
+    );
+  }
 };
 function diffSettingsKeys(oldMerged, newMerged) {
   const changed = /* @__PURE__ */ new Set();