@qwen-code/qwen-code 0.21.4 → 0.21.5-nightly.20260805.32e274157

package/chunks/{acpAgent-MVEFZSBS.js → acpAgent-J474KXVM.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   recomputeMcpGating
-} from "./chunk-M6RNMBUO.js";
+} from "./chunk-NQZ5IVLH.js";
 import {
   classifyApiError,
   fireSessionDeleteHook
@@ -16,14 +16,14 @@ import {
   matchMcpServerByRef,
   parseExtensionRef,
   parseMcpServerRef
-} from "./chunk-PQ5JFCNL.js";
+} from "./chunk-762UTZQZ.js";
 import {
   getAvailableCommands,
   handleSlashCommand,
   insertAfterFunctionResponses,
   isSlashCommand,
   normalizePartList
-} from "./chunk-WDLQGFWP.js";
+} from "./chunk-TYWI5NXY.js";
 import {
   SessionIdConflictError,
   appEvents,
@@ -31,23 +31,27 @@ import {
   cleanupReviewWorktreeLeases,
   loadCliConfig,
   normalizeDisabledToolList
-} from "./chunk-2T3RYG4L.js";
+} from "./chunk-5KDLX7ER.js";
 import "./chunk-NYX53SV4.js";
 import {
   collectContextData,
   formatContextUsageText
-} from "./chunk-C5YFS6VR.js";
+} from "./chunk-EL4W7MGQ.js";
 import {
   getCommandSubcommandNames
-} from "./chunk-QZQ72YF6.js";
+} from "./chunk-Z26UXKZE.js";
 import {
   getEffectiveSupportedModes
-} from "./chunk-DJA7YBLJ.js";
+} from "./chunk-56MC5OM7.js";
 import "./chunk-3LGZEYOF.js";
 import "./chunk-4WGODMVR.js";
-import "./chunk-THLV7YGY.js";
+import "./chunk-XIKKANF4.js";
+import "./chunk-YAF2MQZ6.js";
 import "./chunk-KKN2IE7Q.js";
-import "./chunk-2ON2O4MD.js";
+import {
+  computeCpuPercent
+} from "./chunk-LBOVL47Y.js";
+import "./chunk-FV2JYSWS.js";
 import "./chunk-6H67XLET.js";
 import {
   beginAcpBootstrapConfigProfiling,
@@ -55,9 +59,8 @@ import {
   endAcpBootstrapConfigProfiling,
   markAcpStartup
 } from "./chunk-M744OFVE.js";
-import "./chunk-P5UJMCVS.js";
-import "./chunk-EJXATV5R.js";
-import "./chunk-YAF2MQZ6.js";
+import "./chunk-XIDYVC4P.js";
+import "./chunk-PWFDZA5A.js";
 import {
   GENERATION_MAX_PROMPT_BYTES,
   GENERATION_TIMEOUT_MS,
@@ -78,7 +81,7 @@ import {
   shouldSuppressRememberErrorDetails,
   workspaceMemoryFailureCode,
   workspaceMemoryFailureDiagnostics
-} from "./chunk-I32URQI7.js";
+} from "./chunk-EA2CKB6L.js";
 import {
   HistoryReplayer,
   MessageEmitter,
@@ -88,19 +91,16 @@ import {
   goalTerminalEventToHistoryItem,
   recordGoalStatusItem,
   restoreGoalFromHistory
-} from "./chunk-DHNFB7NC.js";
+} from "./chunk-2QOLRESU.js";
 import "./chunk-DYA25Y7U.js";
 import "./chunk-4NFY2S7N.js";
-import "./chunk-AFJSRJTO.js";
+import "./chunk-2B6FBVWE.js";
 import "./chunk-2MIN6GRR.js";
 import "./chunk-QHTIBUWB.js";
 import {
   isTerminalGoalStatusKind
 } from "./chunk-EKTCKZV5.js";
 import "./chunk-3Z43GZUQ.js";
-import {
-  computeCpuPercent
-} from "./chunk-LBOVL47Y.js";
 import "./chunk-RXFQM6FQ.js";
 import "./chunk-HGCQ5SE7.js";
 import {
@@ -112,38 +112,38 @@ import {
   buildPermissionSettings,
   normalizePermissionRules,
   readPermissionRuleSet
-} from "./chunk-RL2NPV5E.js";
+} from "./chunk-N5QPOGRQ.js";
 import {
   MAX_AUDIO_BYTES,
   sanitizeVoiceErrorMessage,
   transcribeVoiceAudio
-} from "./chunk-G6KI6B5L.js";
+} from "./chunk-VF6WPN4R.js";
 import {
   readVoiceModel
-} from "./chunk-FPPVCCAH.js";
+} from "./chunk-DNPP267F.js";
 import "./chunk-JELIWHXD.js";
 import {
   resolveSkillSettings
 } from "./chunk-Z4X5MTRT.js";
-import "./chunk-5XGI4IPK.js";
-import "./chunk-O4IWFYUW.js";
+import "./chunk-JEVHOCCA.js";
+import "./chunk-VY4TEQQ6.js";
 import "./chunk-57OAHC2Y.js";
 import {
   createLoadedSettingsAdapter
-} from "./chunk-C6FU76AA.js";
+} from "./chunk-V3BNVUFI.js";
 import "./chunk-VXZBKKQR.js";
-import "./chunk-XPAY4EMH.js";
+import "./chunk-2OSE7Q5O.js";
 import "./chunk-3SH53ANB.js";
 import {
   SESSION_SOURCE_META_KEY,
   parseSessionSource
-} from "./chunk-B3EBXISV.js";
+} from "./chunk-5DVP76WL.js";
 import "./chunk-GLWP3FDB.js";
 import "./chunk-XCGIMOLN.js";
 import "./chunk-OCPBI7J5.js";
 import {
   ndJsonStream
-} from "./chunk-UWSXFI6E.js";
+} from "./chunk-2U7GPHA6.js";
 import {
   ACP_ROUTE_ID_PREFIX,
   buildAcpModelOptions,
@@ -152,7 +152,7 @@ import {
   parseAcpModelOption,
   resolveAcpModelOption,
   sanitizeProviderBaseUrl
-} from "./chunk-IMGNGOGC.js";
+} from "./chunk-PQ2J56BJ.js";
 import {
   ACP_PREFLIGHT_KINDS,
   IDLE_HOOK_EVENTS,
@@ -160,10 +160,10 @@ import {
   SERVE_STATUS_EXT_METHODS,
   STATUS_SCHEMA_VERSION,
   mapDomainErrorToErrorKind
-} from "./chunk-PDDYAXL2.js";
-import "./chunk-LEZFUYPM.js";
-import "./chunk-DTAPI453.js";
+} from "./chunk-WIRAPZ62.js";
+import "./chunk-7GYP5COR.js";
 import "./chunk-VWOVHOTT.js";
+import "./chunk-DTAPI453.js";
 import "./chunk-V6WHFGST.js";
 import {
   CHANNEL_STARTUP_PROFILE_META_KEY,
@@ -193,6 +193,13 @@ import "./chunk-QONSRAEV.js";
 import "./chunk-24ER7UV4.js";
 import "./chunk-ALMR3E6Q.js";
 import "./chunk-BK2UNYWD.js";
+import {
+  EXTERNAL_TOOL_GUARD_READY_META_KEY,
+  EXTERNAL_TOOL_GUARD_REQUIRED_VALUE,
+  EXTERNAL_TOOL_GUARD_TOKEN_ENV,
+  PRIVATE_EXTERNAL_TOOL_GUARD_ENV,
+  isValidExternalToolGuardDenialReason
+} from "./chunk-BKHCW2BI.js";
 import "./chunk-M5GB774H.js";
 import "./chunk-XC2VAFVZ.js";
 import "./chunk-WUC6ZFXO.js";
@@ -207,7 +214,7 @@ import {
 import {
   assembleMcpServers,
   loadMcpApprovals
-} from "./chunk-6ME3PVMM.js";
+} from "./chunk-JNFWMBG6.js";
 import {
   getOutputLanguageFilePath,
   getPersistScopeForModelSelection,
@@ -215,7 +222,7 @@ import {
   resolveOutputLanguageOrPreserveAuto,
   updateOutputLanguageFile,
   writeOutputLanguageAndRegisterPath
-} from "./chunk-KB6VSG2U.js";
+} from "./chunk-GXP44JOS.js";
 import "./chunk-RKUWKYED.js";
 import "./chunk-GOXKNSDZ.js";
 import "./chunk-IDS7MSUP.js";
@@ -223,19 +230,19 @@ import {
   SUPPORTED_LANGUAGES,
   getCurrentLanguage,
   setLanguageAsync
-} from "./chunk-FV4TUUDE.js";
+} from "./chunk-O4WOWHMZ.js";
 import {
   reloadEnvironment
-} from "./chunk-4PZ7SPD5.js";
+} from "./chunk-7FKLLD4X.js";
 import "./chunk-6PEXNQTX.js";
-import "./chunk-RNKGMZEW.js";
-import "./chunk-HBCKZF2A.js";
+import "./chunk-MFTOMYE2.js";
+import "./chunk-7EW7CYLA.js";
 import "./chunk-VJNBRRZG.js";
 import {
   isFolderTrustEnabled,
   isWorkspaceTrusted,
   loadTrustedFolders
-} from "./chunk-URVJ4AZC.js";
+} from "./chunk-MKMUBBEX.js";
 import "./chunk-ALGGS7UH.js";
 import "./chunk-MR3PXB6E.js";
 import "./chunk-XFSFZCM5.js";
@@ -363,25 +370,25 @@ import {
   validatePlanModeShellApproval,
   validatePlanModeShellContext,
   wrapUserPromptSubmitContext
-} from "./chunk-E2SYUEIA.js";
+} from "./chunk-5OAMVWFL.js";
 import "./chunk-GOFAQQZA.js";
 import "./chunk-5M6IDOMF.js";
 import "./chunk-TWPJO254.js";
 import {
   external_exports
 } from "./chunk-H6XPXXMH.js";
-import "./chunk-VA5NLVPT.js";
+import "./chunk-Z7JILXGX.js";
 import "./chunk-I7JDGNG6.js";
 import "./chunk-A6SX5TAH.js";
 import "./chunk-33FNCQSY.js";
 import {
   parsePositiveIntegerEnv
 } from "./chunk-6PVPNMXU.js";
-import "./chunk-DZPOYHBT.js";
+import "./chunk-D6FISK43.js";
 import "./chunk-IRH27ZC2.js";
 import "./chunk-QHWCP53L.js";
 import "./chunk-MOHAWIAW.js";
-import "./chunk-X6QNZOTC.js";
+import "./chunk-3PRJYMXC.js";
 import {
   promptIdContext,
   todoWorkChainContext
@@ -397,21 +404,21 @@ import {
 } from "./chunk-A5YZ3FA2.js";
 import "./chunk-YAVY33G4.js";
 import "./chunk-2UISUFHQ.js";
-import "./chunk-HFVW54NL.js";
+import "./chunk-MBEMTXQT.js";
 import {
   APPROVAL_MODES,
   runWithRuntimeContentGenerator
-} from "./chunk-LLMGP5IC.js";
+} from "./chunk-6WBWIPBF.js";
 import "./chunk-S6LOFUVP.js";
 import {
   FORK_SUBAGENT_TYPE,
   getStartupContextLength,
   isSystemReminderContent
-} from "./chunk-7UXI6P72.js";
+} from "./chunk-WVAESIM6.js";
 import "./chunk-K623ENWT.js";
 import "./chunk-AQ37AY7B.js";
 import "./chunk-432XCUHF.js";
-import "./chunk-YXEVDA66.js";
+import "./chunk-HU5TUALO.js";
 import {
   clearCachedCredentialFile,
   qwenOAuth2Events
@@ -423,7 +430,7 @@ import "./chunk-DGEIYUC3.js";
 import "./chunk-MPHPFVKK.js";
 import "./chunk-GLNBDYUX.js";
 import "./chunk-DJ2GSRLV.js";
-import "./chunk-SBBHZ3YT.js";
+import "./chunk-QKWPXGW4.js";
 import {
   addToolArgumentsAttributes,
   addToolCallResultAttributes,
@@ -431,7 +438,7 @@ import {
   registerAcpEventLoopLagGauge,
   startEventLoopLagMonitor,
   withDaemonSpan
-} from "./chunk-RPYYTL7E.js";
+} from "./chunk-MGSSJT27.js";
 import "./chunk-2J3OJGTL.js";
 import "./chunk-P3QQPMQA.js";
 import "./chunk-6O5DVH27.js";
@@ -469,22 +476,23 @@ import {
   shouldRunVisionBridge,
   splitImageParts,
   uiTelemetryService
-} from "./chunk-JDJ7SC4E.js";
+} from "./chunk-NMBDPO63.js";
+import "./chunk-WOJZWRAZ.js";
 import "./chunk-VGC4I5JJ.js";
 import {
   getAutoMemoryRoot,
   getUserAutoMemoryRoot
 } from "./chunk-E4WHKETF.js";
-import "./chunk-UEJESCS7.js";
+import "./chunk-ZPPP6VCL.js";
 import {
   ToolConfirmationOutcome,
   ToolNames,
   isShellProgressData
-} from "./chunk-CFDR3GNL.js";
+} from "./chunk-D7D7RXIJ.js";
 import {
   AuthType,
   preloadContentGenerator
-} from "./chunk-TXZDRD36.js";
+} from "./chunk-LCCBAGRT.js";
 import "./chunk-46UV252V.js";
 import {
   DEFAULT_TOKEN_LIMIT,
@@ -501,9 +509,9 @@ import {
   startToolExecutionSpan,
   startToolSpan,
   withInteractionSpan
-} from "./chunk-O2ZYHG33.js";
+} from "./chunk-5L6CQ4ZU.js";
 import "./chunk-W4RQUHY3.js";
-import "./chunk-G7XXKQYS.js";
+import "./chunk-LKRMNRSN.js";
 import {
   Storage,
   createDebugLogger,
@@ -512,10 +520,10 @@ import {
   isSubpath
 } from "./chunk-3RXUYQJI.js";
 import "./chunk-VOQXFAY5.js";
-import "./chunk-KHSJSMFS.js";
+import "./chunk-6I6WUVYI.js";
 import {
   runExitCleanup
-} from "./chunk-SV5X2EUV.js";
+} from "./chunk-FMU2QVA5.js";
 import {
   writeStderrLine,
   writeStderrLineSafe
@@ -1242,6 +1250,11 @@ var SubAgentTracker = class {
         callId: event.callId,
         args: event.args,
         subagentMeta: this.subagentMeta
+      }).catch((error) => {
+        debugLogger2.debug(
+          `Failed to emit subagent tool start for ${event.name}:`,
+          error
+        );
       });
     };
   }
@@ -1261,6 +1274,11 @@ var SubAgentTracker = class {
         resultDisplay: event.resultDisplay,
         args: state?.args,
         subagentMeta: this.subagentMeta
+      }).catch((error) => {
+        debugLogger2.debug(
+          `Failed to emit subagent tool result for ${event.name}:`,
+          error
+        );
       });
       this.toolStates.delete(event.callId);
     };
@@ -1314,7 +1332,7 @@ var SubAgentTracker = class {
         await event.respond(outcome, {
           answers: "answers" in output ? output.answers : void 0
         });
-        if (outcome === "cancel" /* Cancel */) {
+        if (outcome === "cancel" /* Cancel */ && !abortSignal.aborted) {
           this.onPermissionCancel?.();
         }
       } catch (error) {
@@ -1322,7 +1340,9 @@ var SubAgentTracker = class {
           `Permission request failed for subagent tool ${event.name}:`,
           error
         );
-        this.onPermissionCancel?.();
+        if (!abortSignal.aborted) {
+          this.onPermissionCancel?.();
+        }
         try {
           await event.respond("cancel" /* Cancel */);
         } catch (respondError) {
@@ -1341,12 +1361,9 @@ var SubAgentTracker = class {
     return (...args) => {
       const event = args[0];
       if (abortSignal.aborted) return;
-      this.messageEmitter.emitUsageMetadata(
-        event.usage,
-        "",
-        event.durationMs,
-        this.subagentMeta
-      );
+      void this.messageEmitter.emitUsageMetadata(event.usage, "", event.durationMs, this.subagentMeta).catch((error) => {
+        debugLogger2.debug("Failed to emit subagent usage metadata:", error);
+      });
     };
   }
   /**
@@ -1363,7 +1380,9 @@ var SubAgentTracker = class {
         event.thought ?? false,
         void 0,
         this.subagentMeta
-      );
+      ).catch((error) => {
+        debugLogger2.debug("Failed to emit subagent stream text:", error);
+      });
     };
   }
 };
@@ -1912,6 +1931,8 @@ 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.";
 var LOOP_DETECTED_CONTEXT_MESSAGE = "System: this turn was terminated because the model exceeded tool-call safety limits. Try a different approach on the next turn.";
+var TOOL_EXECUTION_CANCELLED_MESSAGE = "Tool execution was cancelled.";
+var TOOL_POST_EXECUTION_CANCELLED_MESSAGE = "The tool had already completed; its output was discarded.";
 function createDaemonToolLoopState() {
   return {
     totalToolCalls: 0,
@@ -1924,7 +1945,14 @@ function recordDaemonLoopDetected(config, promptId, loopType, message, loopState
   if (!loopState.loopDetected) {
     loopState.loopDetected = true;
     debugLogger5.warn(message);
-    logLoopDetected(config, new LoopDetectedEvent(loopType, promptId));
+    try {
+      logLoopDetected(config, new LoopDetectedEvent(loopType, promptId));
+    } catch (error) {
+      debugLogger5.debug(
+        "[Session] Failed to record loop detection telemetry",
+        error
+      );
+    }
   }
   return true;
 }
@@ -2525,6 +2553,7 @@ var Session = class {
   resolveCloseGate = null;
   unsubscribeChatRecordingFailure;
   workflowApprovalAbortController = new AbortController();
+  activeTodoPlanRevision;
   // Modular components
   historyReplayer;
   toolCallEmitter;
@@ -2747,6 +2776,9 @@ var Session = class {
   clearTodoStopGuardTrust() {
     this.#clearTodoStopGuardTrustAndDrainAutomaticQueues();
   }
+  clearActiveTodoPlanRevision() {
+    this.activeTodoPlanRevision = void 0;
+  }
   hardSuspendTodoStopGuard() {
     this.#clearTodoStopGuardQueuedPromptWait();
     this.todoStopGuardDrainAutomaticQueuesWhenIdle = false;
@@ -3187,7 +3219,11 @@ var Session = class {
   }
   async replayHistory(records, gaps) {
     this.primeTurnFromHistory(records);
-    await this.historyReplayer.replay(records, gaps);
+    try {
+      await this.historyReplayer.replay(records, gaps);
+    } finally {
+      this.activeTodoPlanRevision = void 0;
+    }
   }
   rewindToTurn(targetTurnIndex, opts) {
     if (!Number.isInteger(targetTurnIndex) || targetTurnIndex < 0) {
@@ -3216,6 +3252,7 @@ var Session = class {
     }
     chat.truncateHistory(apiTruncateIndex);
     chat.stripThoughtsFromHistory();
+    this.activeTodoPlanRevision = void 0;
     const preserveQueuedPromptPriority = this.todoStopGuardQueuedPromptPriority;
     const shouldDrainAutomaticQueues = (this.todoStopGuard.blocksUnrelatedAutomaticTurns || this.todoStopGuard.hasCommittedContinuation) && !preserveQueuedPromptPriority;
     this.todoStopGuard.blockUntilOrdinaryPromptStarts();
@@ -3260,6 +3297,7 @@ var Session = class {
       );
     }
     this.config.getGeminiClient().getChat().setHistory(structuredClone(history));
+    this.activeTodoPlanRevision = void 0;
     this.#clearTodoStopGuardTrustAndDrainAutomaticQueues();
   }
   #computeApiTruncationIndexForUserTurn(apiHistory, targetTurnIndex) {
@@ -3961,7 +3999,7 @@ ${this.pendingRecoveredAgentsNotice}
                       onFullTurnModel
                     )
                   );
-                  if (toolRun.stopAfterPermissionCancel) {
+                  if (toolRun.stopAfterPermissionCancel || pendingSend.signal.aborted) {
                     this.todoStopGuard.suspend();
                     await this.#preserveStoppedToolRun(
                       toolRun,
@@ -4700,7 +4738,7 @@ ${this.pendingRecoveredAgentsNotice}
             options.onFullTurnModel
           )
         );
-        if (toolRun.stopAfterPermissionCancel || toolRun.loopDetected) {
+        if (toolRun.stopAfterPermissionCancel || toolRun.loopDetected || pendingSend.signal.aborted) {
           this.todoStopGuard.suspend();
           await this.#preserveStoppedToolRun(toolRun, pendingSend.signal);
           return {
@@ -4799,7 +4837,21 @@ ${this.pendingRecoveredAgentsNotice}
       sessionId: this.sessionId,
       update
     };
+    if (update.sessionUpdate === "plan") {
+      this.activeTodoPlanRevision = void 0;
+    }
     await this.client.sessionUpdate(params);
+    if (update.sessionUpdate === "plan") {
+      this.#captureTodoPlanRevision(update);
+    }
+  }
+  #captureTodoPlanRevision(update) {
+    const meta = isRecord2(update["_meta"]) ? update["_meta"] : void 0;
+    const plan = isRecord2(meta?.["qwenTodoPlan"]) ? meta["qwenTodoPlan"] : void 0;
+    const transcript = isRecord2(meta?.["qwenTranscript"]) ? meta["qwenTranscript"] : void 0;
+    const planId = plan?.["id"];
+    const sourceCallId = transcript?.["planToolCallId"];
+    this.activeTodoPlanRevision = typeof planId === "string" && typeof sourceCallId === "string" && update.entries.length > 0 ? { planId, sourceCallId } : void 0;
   }
   #scheduleChannelDelivery(params) {
     const timer = setTimeout(() => {
@@ -5661,7 +5713,7 @@ ${this.pendingRecoveredAgentsNotice}
                     functionCalls,
                     toolLoopState
                   );
-                  if (toolRun.stopAfterPermissionCancel) {
+                  if (toolRun.stopAfterPermissionCancel || ac.signal.aborted) {
                     this.todoStopGuard.suspend();
                     await this.#preserveStoppedToolRun(toolRun, ac.signal);
                     return;
@@ -6067,7 +6119,7 @@ ${this.pendingRecoveredAgentsNotice}
                 functionCalls,
                 toolLoopState
               );
-              if (toolRun.stopAfterPermissionCancel) {
+              if (toolRun.stopAfterPermissionCancel || ac.signal.aborted) {
                 this.todoStopGuard.suspend();
                 await this.#preserveStoppedToolRun(toolRun, ac.signal);
                 await this.#emitBackgroundNotificationEndTurn(
@@ -6294,8 +6346,12 @@ ${this.pendingRecoveredAgentsNotice}
         `Unknown approval mode: ${params.modeId}`
       );
     }
+    const previousApprovalMode = this.config.getApprovalMode();
     this.config.setApprovalMode(approvalMode);
     if (approvalMode === "plan" /* PLAN */) {
+      if (previousApprovalMode !== "plan" /* PLAN */) {
+        this.activeTodoPlanRevision = void 0;
+      }
       this.clearTodoStopGuardTrust();
     }
     void this.client.extNotification("qwen/notify/session/mode-update", {
@@ -6493,9 +6549,10 @@ ${this.pendingRecoveredAgentsNotice}
           metadata: {
             callId,
             status: "error",
+            executionStatus: "not_started",
             resultDisplay: void 0,
             error,
-            errorType
+            errorType: errorType ?? "execution_denied" /* EXECUTION_DENIED */
           }
         });
         if (emitStart) {
@@ -6521,7 +6578,12 @@ ${this.pendingRecoveredAgentsNotice}
       return await finalizeRunToolResult({
         parts: await Promise.all(
           dedupedFunctionCalls.map(
-            (fc) => recordSkippedToolCall(fc, LOOP_DETECTED_SKIP_MESSAGE, false)
+            (fc) => recordSkippedToolCall(
+              fc,
+              LOOP_DETECTED_SKIP_MESSAGE,
+              false,
+              "unknown" /* UNKNOWN */
+            )
           )
         ),
         stopAfterPermissionCancel: false,
@@ -6563,38 +6625,47 @@ ${this.pendingRecoveredAgentsNotice}
     }, "pushDuplicateBatch");
     const emitDuplicateBatch = /* @__PURE__ */ __name(async (batch) => {
       const { request, response } = batch;
-      if (request.name === ToolNames.TODO_WRITE) {
-        const provenance = ToolCallEmitter.resolveToolProvenance(request.name);
-        await this.sendUpdate({
-          sessionUpdate: "tool_call_update",
-          toolCallId: response.callId,
-          status: "failed",
-          content: [
-            {
-              type: "content",
-              content: {
-                type: "text",
-                text: response.error?.message ?? String(response.resultDisplay)
+      try {
+        if (request.name === ToolNames.TODO_WRITE) {
+          const provenance = ToolCallEmitter.resolveToolProvenance(
+            request.name
+          );
+          await this.sendUpdate({
+            sessionUpdate: "tool_call_update",
+            toolCallId: response.callId,
+            status: "failed",
+            content: [
+              {
+                type: "content",
+                content: {
+                  type: "text",
+                  text: response.error?.message ?? String(response.resultDisplay)
+                }
               }
+            ],
+            rawOutput: response.resultDisplay,
+            _meta: {
+              toolName: request.name,
+              provenance: provenance.provenance,
+              ...provenance.serverId ? { serverId: provenance.serverId } : {}
             }
-          ],
-          rawOutput: response.resultDisplay,
-          _meta: {
+          });
+        } else {
+          await this.toolCallEmitter.emitResult({
+            callId: response.callId,
             toolName: request.name,
-            provenance: provenance.provenance,
-            ...provenance.serverId ? { serverId: provenance.serverId } : {}
-          }
-        });
-      } else {
-        await this.toolCallEmitter.emitResult({
-          callId: response.callId,
-          toolName: request.name,
-          args: request.args,
-          message: response.responseParts,
-          resultDisplay: response.resultDisplay,
-          error: response.error,
-          success: false
-        });
+            args: request.args,
+            message: response.responseParts,
+            resultDisplay: response.resultDisplay,
+            error: response.error,
+            success: false
+          });
+        }
+      } catch (emitError) {
+        debugLogger5.debug(
+          "[Session.runToolCalls] Failed to emit duplicate tool update",
+          emitError
+        );
       }
       queueToolResultRecord(batch.fc, {
         callId: response.callId,
@@ -6604,6 +6675,7 @@ ${this.pendingRecoveredAgentsNotice}
         metadata: {
           callId: response.callId,
           status: "error",
+          executionStatus: response.executionStatus ?? "not_started",
           resultDisplay: response.resultDisplay,
           error: response.error,
           errorType: response.errorType
@@ -6642,10 +6714,12 @@ ${this.pendingRecoveredAgentsNotice}
       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 appendSkippedAfter = /* @__PURE__ */ __name(async (parts2, fc, message = PERMISSION_CANCEL_SKIP_MESSAGE, errorType) => {
       const startIndex = dedupedFunctionCalls.indexOf(fc) + 1;
       for (const remainingCall of dedupedFunctionCalls.slice(startIndex)) {
-        parts2.push(await recordSkippedToolCall(remainingCall, message));
+        parts2.push(
+          await recordSkippedToolCall(remainingCall, message, true, errorType)
+        );
       }
     }, "appendSkippedAfter");
     const memoryWriteCandidates = [];
@@ -6675,7 +6749,12 @@ ${this.pendingRecoveredAgentsNotice}
           if (results[i]) continue;
           results[i] = {
             parts: [
-              await recordSkippedToolCall(calls[i], LOOP_DETECTED_SKIP_MESSAGE)
+              await recordSkippedToolCall(
+                calls[i],
+                LOOP_DETECTED_SKIP_MESSAGE,
+                true,
+                "unknown" /* UNKNOWN */
+              )
             ],
             stopAfterPermissionCancel: false,
             loopDetected: true
@@ -6839,7 +6918,8 @@ ${this.pendingRecoveredAgentsNotice}
             await appendSkippedAfter(
               parts,
               batch.calls[batch.calls.length - 1],
-              LOOP_DETECTED_SKIP_MESSAGE
+              LOOP_DETECTED_SKIP_MESSAGE,
+              "unknown" /* UNKNOWN */
             );
             return await finalizeRunToolResult({
               parts,
@@ -6876,7 +6956,12 @@ ${this.pendingRecoveredAgentsNotice}
             parts.push(...r.parts);
             collectMemoryWriteCandidates(r);
             if (r.loopDetected) {
-              await appendSkippedAfter(parts, fc, LOOP_DETECTED_SKIP_MESSAGE);
+              await appendSkippedAfter(
+                parts,
+                fc,
+                LOOP_DETECTED_SKIP_MESSAGE,
+                "unknown" /* UNKNOWN */
+              );
               return await finalizeRunToolResult({
                 parts,
                 stopAfterPermissionCancel: false,
@@ -6939,10 +7024,21 @@ ${this.pendingRecoveredAgentsNotice}
   async runTool(abortSignal, promptId, fc, onStopAfterPermissionCancel, toolLoopState, recordSkippedToolCall, queueToolResultRecord, generatedCallId, onFullTurnModel) {
     const callId = fc.id ?? generatedCallId ?? `${fc.name}-${Date.now()}`;
     let args = fc.args ?? {};
+    let executionStatus = "not_started";
+    let executionErrorType;
+    let executeReturned = false;
+    let terminalStatus;
+    let toolType = "native";
+    let mcpServerName = void 0;
     if (toolLoopState?.loopDetected) {
       return {
         parts: [
-          recordSkippedToolCall ? await recordSkippedToolCall(fc, LOOP_DETECTED_SKIP_MESSAGE, false) : {
+          recordSkippedToolCall ? await recordSkippedToolCall(
+            fc,
+            LOOP_DETECTED_SKIP_MESSAGE,
+            false,
+            "unknown" /* UNKNOWN */
+          ) : {
             functionResponse: {
               id: callId,
               name: fc.name ?? "unknown_tool",
@@ -6967,51 +7063,80 @@ ${this.pendingRecoveredAgentsNotice}
       removeAgentToolAbortPropagation?.();
       removeAgentToolAbortPropagation = void 0;
     }, "cleanupAgentToolResources");
-    const errorResponse = /* @__PURE__ */ __name((error) => {
+    const errorResponse = /* @__PURE__ */ __name((error, toolName2, status, errorType) => {
       const durationMs = Date.now() - startTime;
-      logToolCall(this.config, {
-        "event.name": "tool_call",
-        "event.timestamp": (/* @__PURE__ */ new Date()).toISOString(),
-        prompt_id: promptId,
-        function_name: fc.name ?? "",
-        function_args: args,
-        duration_ms: durationMs,
-        // An aborted signal means the call was cancelled, not a genuine error.
-        status: activeToolAbortSignal.aborted ? "cancelled" : "error",
-        success: false,
-        error: error.message,
-        tool_type: typeof tool !== "undefined" && tool instanceof DiscoveredMCPTool ? "mcp" : "native"
-      });
+      try {
+        logToolCall(this.config, {
+          "event.name": "tool_call",
+          "event.timestamp": (/* @__PURE__ */ new Date()).toISOString(),
+          call_id: callId,
+          prompt_id: promptId,
+          function_name: toolName2,
+          function_args: args,
+          duration_ms: durationMs,
+          status,
+          execution_status: executionStatus,
+          success: false,
+          ...status === "error" ? {
+            error: error.message,
+            error_type: errorType
+          } : {},
+          tool_type: toolType,
+          mcp_server_name: mcpServerName
+        });
+      } catch (telemetryError) {
+        debugLogger5.debug(
+          "[Session.runTool] Failed to record terminal tool telemetry",
+          telemetryError
+        );
+      }
       return [
         {
           functionResponse: {
             id: callId,
-            name: fc.name ?? "",
+            name: toolName2,
             response: { error: error.message }
           }
         }
       ];
     }, "errorResponse");
     const earlyErrorResponse = /* @__PURE__ */ __name(async (error, toolName2 = fc.name ?? "unknown_tool", opts) => {
-      spanError = error.message;
+      executionStatus = opts.executionStatus;
+      terminalStatus = opts.status;
+      spanError = opts.status === "error" ? error.message : void 0;
       cleanupAgentToolResources();
       if (toolName2 !== ToolNames.TODO_WRITE) {
-        await this.toolCallEmitter.emitError(callId, toolName2, error);
+        try {
+          await this.toolCallEmitter.emitError(callId, toolName2, error);
+        } catch (emitError) {
+          debugLogger5.debug(
+            "[Session.runTool] Failed to emit terminal tool update",
+            emitError
+          );
+        }
       }
-      const errorParts = errorResponse(error);
+      const errorParts = errorResponse(
+        error,
+        toolName2,
+        opts.status,
+        opts.errorType
+      );
       queueToolResultRecord?.(fc, {
         callId,
         toolName: toolName2,
         responseParts: errorParts,
         metadata: {
           callId,
-          status: opts?.status ?? "error",
+          status: opts.status,
+          executionStatus,
           resultDisplay: void 0,
-          error,
-          errorType: opts?.errorType
+          error: opts.status === "error" ? error : void 0,
+          errorType: opts.status === "error" ? opts.errorType : void 0
         }
       });
-      const loopDetected = opts?.recordInvalidToolParams === true && !activeToolAbortSignal.aborted && !opts?.stopAfterPermissionCancel && recordDaemonInvalidToolParams(
+      const loopDetected = opts.recordInvalidToolParams === true && !activeToolAbortSignal.aborted && // A permission cancellation is the user declining, not the model
+      // re-sending invalid params, so it must not feed loop detection.
+      !opts.stopAfterPermissionCancel && recordDaemonInvalidToolParams(
         this.config,
         promptId,
         toolLoopState,
@@ -7020,14 +7145,32 @@ ${this.pendingRecoveredAgentsNotice}
       );
       return {
         parts: errorParts,
-        stopAfterPermissionCancel: opts?.stopAfterPermissionCancel ?? false,
+        stopAfterPermissionCancel: opts.stopAfterPermissionCancel ?? false,
         loopDetected
       };
     }, "earlyErrorResponse");
+    const cancelBeforeExecutionIfAborted = /* @__PURE__ */ __name((toolName2 = fc.name ?? "unknown_tool") => activeToolAbortSignal.aborted ? earlyErrorResponse(
+      new Error("Tool call was cancelled before execution."),
+      toolName2,
+      {
+        status: "cancelled",
+        errorType: void 0,
+        executionStatus: "not_started"
+      }
+    ) : void 0, "cancelBeforeExecutionIfAborted");
+    const initialCancellation = cancelBeforeExecutionIfAborted();
+    if (initialCancellation) return initialCancellation;
     if (!fc.name) {
-      return earlyErrorResponse(new Error("Missing function name"), void 0, {
-        recordInvalidToolParams: true
-      });
+      return earlyErrorResponse(
+        new Error("Missing function name"),
+        "unknown_tool",
+        {
+          status: "error",
+          errorType: "invalid_tool_params" /* INVALID_TOOL_PARAMS */,
+          executionStatus: "not_started",
+          recordInvalidToolParams: true
+        }
+      );
     }
     const toolName = fc.name;
     const toolRegistry = this.config.getToolRegistry();
@@ -7036,9 +7179,16 @@ ${this.pendingRecoveredAgentsNotice}
       return earlyErrorResponse(
         new Error(`Tool "${toolName}" not found in registry.`),
         toolName,
-        { recordInvalidToolParams: true }
+        {
+          status: "error",
+          errorType: "tool_not_registered" /* TOOL_NOT_REGISTERED */,
+          executionStatus: "not_started",
+          recordInvalidToolParams: true
+        }
       );
     }
+    toolType = tool instanceof DiscoveredMCPTool ? "mcp" : "native";
+    mcpServerName = tool instanceof DiscoveredMCPTool ? tool.serverName : void 0;
     const policyToolName = tool.name;
     const originalPolicyRequestArgs = policyToolName === ToolNames.SHELL || policyToolName === ToolNames.MONITOR ? structuredClone(args) : args;
     const toolSpan = startToolSpan(
@@ -7055,14 +7205,23 @@ ${this.pendingRecoveredAgentsNotice}
       tool.description,
       promptId
     );
-    let spanSuccess = false;
     try {
       return await runInToolSpanContext(toolSpan, async () => {
+        const entryCancellation = cancelBeforeExecutionIfAborted(toolName);
+        if (entryCancellation) return entryCancellation;
         const pm = this.config.getPermissionManager?.();
-        if (pm && !await pm.isToolEnabled(policyToolName)) {
+        const toolEnabled = pm ? await pm.isToolEnabled(policyToolName) : true;
+        const enablementCancellation = cancelBeforeExecutionIfAborted(toolName);
+        if (enablementCancellation) return enablementCancellation;
+        if (pm && !toolEnabled) {
           return earlyErrorResponse(
             new Error(`Tool "${toolName}" is disabled.`),
-            toolName
+            toolName,
+            {
+              status: "error",
+              errorType: "execution_denied" /* EXECUTION_DENIED */,
+              executionStatus: "not_started"
+            }
           );
         }
         const isTodoWriteTool = tool.name === ToolNames.TODO_WRITE;
@@ -7124,6 +7283,8 @@ ${this.pendingRecoveredAgentsNotice}
             policyToolName,
             toolParams
           );
+          const permissionFlowCancellation = cancelBeforeExecutionIfAborted(toolName);
+          if (permissionFlowCancellation) return permissionFlowCancellation;
           const {
             finalPermission,
             pmForcedAsk,
@@ -7137,7 +7298,12 @@ ${this.pendingRecoveredAgentsNotice}
           if (finalPermission === "deny") {
             return earlyErrorResponse(
               new Error(denyMessage ?? `Tool "${toolName}" is denied.`),
-              toolName
+              toolName,
+              {
+                status: "error",
+                errorType: "execution_denied" /* EXECUTION_DENIED */,
+                executionStatus: "not_started"
+              }
             );
           }
           let planShellAmbientWorkingDirectory;
@@ -7159,6 +7325,8 @@ ${this.pendingRecoveredAgentsNotice}
             ambientWorkingDirectory: planShellAmbientWorkingDirectory,
             signal: activeToolAbortSignal
           }) : { classification: "not-applicable" };
+          const planPolicyCancellation = cancelBeforeExecutionIfAborted(toolName);
+          if (planPolicyCancellation) return planPolicyCancellation;
           if (planShellDecision.classification !== "not-applicable") {
             const initialPlanShellError = await validatePlanModeShellContext({
               config: this.config,
@@ -7167,17 +7335,31 @@ ${this.pendingRecoveredAgentsNotice}
               invocationParams: invocation.params,
               signal: activeToolAbortSignal
             });
+            const initialPlanValidationCancellation = cancelBeforeExecutionIfAborted(toolName);
+            if (initialPlanValidationCancellation) {
+              return initialPlanValidationCancellation;
+            }
             if (initialPlanShellError) {
               return earlyErrorResponse(
                 new Error(initialPlanShellError),
-                toolName
+                toolName,
+                {
+                  status: "error",
+                  errorType: "execution_denied" /* EXECUTION_DENIED */,
+                  executionStatus: "not_started"
+                }
               );
             }
           }
           if (planShellDecision.classification === "write") {
             return earlyErrorResponse(
               new Error(planShellDecision.writeBlockMessage),
-              toolName
+              toolName,
+              {
+                status: "error",
+                errorType: "execution_denied" /* EXECUTION_DENIED */,
+                executionStatus: "not_started"
+              }
             );
           }
           const planShellRequiresConfirmation = planShellDecision.classification === "unknown";
@@ -7212,6 +7394,8 @@ ${this.pendingRecoveredAgentsNotice}
               signal: abortSignal,
               skipClassifierReason: fallback.fallback ? fallback.reason : void 0
             });
+            const autoModeCancellation = cancelBeforeExecutionIfAborted(toolName);
+            if (autoModeCancellation) return autoModeCancellation;
             const outcome = applyAutoModeDecision(
               decision,
               this.config,
@@ -7226,6 +7410,10 @@ ${this.pendingRecoveredAgentsNotice}
               callId,
               abortSignal
             );
+            const permissionDeniedHookCancellation = cancelBeforeExecutionIfAborted(toolName);
+            if (permissionDeniedHookCancellation) {
+              return permissionDeniedHookCancellation;
+            }
             switch (outcome.kind) {
               case "approved":
                 autoModeAllowed = true;
@@ -7236,7 +7424,12 @@ ${this.pendingRecoveredAgentsNotice}
                 );
                 return earlyErrorResponse(
                   new Error(outcome.errorMessage),
-                  toolName
+                  toolName,
+                  {
+                    status: "error",
+                    errorType: "execution_denied" /* EXECUTION_DENIED */,
+                    executionStatus: "not_started"
+                  }
                 );
               case "fallback":
                 wasAutoModeManualFallback = isDenialFallbackReason(outcome.reason) || outcome.reason === "classifier_unavailable";
@@ -7280,6 +7473,10 @@ ${this.pendingRecoveredAgentsNotice}
             confirmationDetails = await invocation.getConfirmationDetails(
               activeToolAbortSignal
             );
+            const confirmationDetailsCancellation = cancelBeforeExecutionIfAborted(toolName);
+            if (confirmationDetailsCancellation) {
+              return confirmationDetailsCancellation;
+            }
             if (autoModeFallbackMessage) {
               confirmationDetails = decorateClassifierUnavailableConfirmation(
                 confirmationDetails,
@@ -7294,10 +7491,19 @@ ${this.pendingRecoveredAgentsNotice}
                 invocationParams: invocation.params,
                 signal: activeToolAbortSignal
               });
+              const preDisplayValidationCancellation = cancelBeforeExecutionIfAborted(toolName);
+              if (preDisplayValidationCancellation) {
+                return preDisplayValidationCancellation;
+              }
               if (preDisplayPlanShellError) {
                 return earlyErrorResponse(
                   new Error(preDisplayPlanShellError),
-                  toolName
+                  toolName,
+                  {
+                    status: "error",
+                    errorType: "execution_denied" /* EXECUTION_DENIED */,
+                    executionStatus: "not_started"
+                  }
                 );
               }
             }
@@ -7310,7 +7516,12 @@ ${this.pendingRecoveredAgentsNotice}
               if (planShellDecision.classification === "unknown") {
                 return earlyErrorResponse(
                   new Error(planShellDecision.noApprovalMessage),
-                  toolName
+                  toolName,
+                  {
+                    status: "error",
+                    errorType: "execution_denied" /* EXECUTION_DENIED */,
+                    executionStatus: "not_started"
+                  }
                 );
               }
               throw new Error("Unable to prepare shell confirmation.");
@@ -7327,7 +7538,12 @@ ${this.pendingRecoveredAgentsNotice}
                 new Error(
                   `Plan mode is active. The tool "${toolName}" cannot be executed because it modifies the system. Please use the exit_plan_mode tool to present your plan and exit plan mode before making changes.`
                 ),
-                toolName
+                toolName,
+                {
+                  status: "error",
+                  errorType: "execution_denied" /* EXECUTION_DENIED */,
+                  executionStatus: "not_started"
+                }
               );
             }
             const messageBus = this.config.getMessageBus?.();
@@ -7342,6 +7558,10 @@ ${this.pendingRecoveredAgentsNotice}
                 void 0,
                 activeToolAbortSignal
               );
+              const permissionHookCancellation = cancelBeforeExecutionIfAborted(toolName);
+              if (permissionHookCancellation) {
+                return permissionHookCancellation;
+              }
               if (hookResult.hasDecision && (!hookResult.shouldAllow || !requiresUserInteraction)) {
                 hookHandled = true;
                 if (hookResult.shouldAllow) {
@@ -7355,16 +7575,29 @@ ${this.pendingRecoveredAgentsNotice}
                       outcome: "proceed_once" /* ProceedOnce */,
                       payload: hookResult.updatedInput ? { updatedInput: hookResult.updatedInput } : void 0
                     });
+                    const hookPlanApprovalCancellation = cancelBeforeExecutionIfAborted(toolName);
+                    if (hookPlanApprovalCancellation) {
+                      return hookPlanApprovalCancellation;
+                    }
                     await confirmationDetails.onConfirm(
                       approval.outcome,
                       approval.payload
                     );
+                    const hookPlanConfirmationCancellation = cancelBeforeExecutionIfAborted(toolName);
+                    if (hookPlanConfirmationCancellation) {
+                      return hookPlanConfirmationCancellation;
+                    }
                     if (approval.outcome === "cancel" /* Cancel */) {
                       return earlyErrorResponse(
                         new Error(
                           approval.payload?.cancelMessage ?? planShellDecision.noApprovalMessage
                         ),
-                        toolName
+                        toolName,
+                        {
+                          status: "error",
+                          errorType: "execution_denied" /* EXECUTION_DENIED */,
+                          executionStatus: "not_started"
+                        }
                       );
                     }
                     recordAutoModeFallbackResolution(approval.outcome);
@@ -7376,6 +7609,10 @@ ${this.pendingRecoveredAgentsNotice}
                     await confirmationDetails.onConfirm(
                       "proceed_once" /* ProceedOnce */
                     );
+                    const hookConfirmationCancellation = cancelBeforeExecutionIfAborted(toolName);
+                    if (hookConfirmationCancellation) {
+                      return hookConfirmationCancellation;
+                    }
                     recordAutoModeFallbackResolution(
                       "proceed_once" /* ProceedOnce */
                     );
@@ -7385,7 +7622,12 @@ ${this.pendingRecoveredAgentsNotice}
                     new Error(
                       hookResult.denyMessage || `Permission denied by hook for "${toolName}"`
                     ),
-                    toolName
+                    toolName,
+                    {
+                      status: "error",
+                      errorType: "execution_denied" /* EXECUTION_DENIED */,
+                      executionStatus: "not_started"
+                    }
                   );
                 }
               }
@@ -7400,10 +7642,19 @@ ${this.pendingRecoveredAgentsNotice}
                   invocationParams: invocation.params,
                   signal: activeToolAbortSignal
                 });
+                const finalPlanValidationCancellation = cancelBeforeExecutionIfAborted(toolName);
+                if (finalPlanValidationCancellation) {
+                  return finalPlanValidationCancellation;
+                }
                 if (finalPreDisplayPlanShellError) {
                   return earlyErrorResponse(
                     new Error(finalPreDisplayPlanShellError),
-                    toolName
+                    toolName,
+                    {
+                      status: "error",
+                      errorType: "execution_denied" /* EXECUTION_DENIED */,
+                      executionStatus: "not_started"
+                    }
                   );
                 }
               }
@@ -7445,7 +7696,10 @@ ${this.pendingRecoveredAgentsNotice}
                   // frame already ships _meta.toolName; mirror it here.
                   _meta: {
                     toolName,
-                    ...interactionMetaFields(confirmationDetails)
+                    ...interactionMetaFields(confirmationDetails),
+                    ...isExitPlanModeTool && this.activeTodoPlanRevision ? {
+                      qwenTodoApproval: this.activeTodoPlanRevision
+                    } : {}
                   }
                 }
               };
@@ -7456,7 +7710,12 @@ ${this.pendingRecoveredAgentsNotice}
                     message ?? `Tool "${toolName}" was canceled by the user.`
                   ),
                   toolName,
-                  { stopAfterPermissionCancel: true }
+                  {
+                    status: "cancelled",
+                    errorType: void 0,
+                    executionStatus: "not_started",
+                    stopAfterPermissionCancel: true
+                  }
                 );
               }, "stopAfterPermissionCancel");
               let output;
@@ -7466,6 +7725,10 @@ ${this.pendingRecoveredAgentsNotice}
                   params,
                   activeToolAbortSignal
                 );
+                const permissionRequestCancellation = cancelBeforeExecutionIfAborted(toolName);
+                if (permissionRequestCancellation) {
+                  return permissionRequestCancellation;
+                }
                 outcome = resolvePermissionOutcome(
                   output,
                   offeredPermissionOptions
@@ -7485,16 +7748,26 @@ ${this.pendingRecoveredAgentsNotice}
                     confirmError
                   );
                 }
-                onStopAfterPermissionCancel?.();
+                const wasAborted = activeToolAbortSignal.aborted;
+                if (!wasAborted) {
+                  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." : 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(
-                  new Error(permissionFailureMessage),
+                  new Error(
+                    wasAborted ? "Tool call was cancelled before execution." : permissionFailureMessage
+                  ),
                   toolName,
-                  { stopAfterPermissionCancel: true }
+                  {
+                    status: wasAborted ? "cancelled" : "error",
+                    errorType: wasAborted ? void 0 : "unhandled_exception" /* UNHANDLED_EXCEPTION */,
+                    executionStatus: "not_started",
+                    stopAfterPermissionCancel: !wasAborted
+                  }
                 );
               }
               let confirmationPayload = {
@@ -7510,6 +7783,10 @@ ${this.pendingRecoveredAgentsNotice}
                   outcome,
                   payload: confirmationPayload
                 });
+                const planApprovalCancellation = cancelBeforeExecutionIfAborted(toolName);
+                if (planApprovalCancellation) {
+                  return planApprovalCancellation;
+                }
                 outcome = approval.outcome;
                 confirmationPayload = approval.payload;
               }
@@ -7523,6 +7800,10 @@ ${this.pendingRecoveredAgentsNotice}
                   outcome,
                   confirmationPayload
                 );
+                const confirmationCancellation = cancelBeforeExecutionIfAborted(toolName);
+                if (confirmationCancellation) {
+                  return confirmationCancellation;
+                }
               } catch (error) {
                 if (outcome !== "cancel" /* Cancel */) {
                   throw error;
@@ -7536,6 +7817,8 @@ ${this.pendingRecoveredAgentsNotice}
               if (shouldSwitchToDefault) {
                 this.config.setApprovalMode("default" /* DEFAULT */);
                 await this.sendCurrentModeUpdateNotification();
+                const modeUpdateCancellation = cancelBeforeExecutionIfAborted(toolName);
+                if (modeUpdateCancellation) return modeUpdateCancellation;
               }
               if (outcome === "proceed_always" /* ProceedAlways */ || outcome === "proceed_always_project" /* ProceedAlwaysProject */ || outcome === "proceed_always_user" /* ProceedAlwaysUser */) {
                 await persistPermissionOutcome(
@@ -7545,9 +7828,17 @@ ${this.pendingRecoveredAgentsNotice}
                   this.config.getPermissionManager?.(),
                   confirmationPayload
                 );
+                const permissionPersistenceCancellation = cancelBeforeExecutionIfAborted(toolName);
+                if (permissionPersistenceCancellation) {
+                  return permissionPersistenceCancellation;
+                }
               }
               if (confirmationDetails.type === "edit" && outcome === "proceed_always" /* ProceedAlways */) {
                 await this.sendCurrentModeUpdateNotification();
+                const editModeUpdateCancellation = cancelBeforeExecutionIfAborted(toolName);
+                if (editModeUpdateCancellation) {
+                  return editModeUpdateCancellation;
+                }
               }
               switch (outcome) {
                 case "proceed_once_and_switch_to_default" /* ProceedOnceAndSwitchToDefault */:
@@ -7581,7 +7872,16 @@ ${this.pendingRecoveredAgentsNotice}
               args,
               status: "in_progress"
             };
-            await this.toolCallEmitter.emitStart(startParams);
+            try {
+              await this.toolCallEmitter.emitStart(startParams);
+            } catch (emitError) {
+              debugLogger5.debug(
+                "[Session.runTool] Failed to emit tool start update",
+                emitError
+              );
+            }
+            const startEmissionCancellation = cancelBeforeExecutionIfAborted(toolName);
+            if (startEmissionCancellation) return startEmissionCancellation;
           }
           const hooksEnabledForTool = !this.config.getDisableAllHooks?.();
           const messageBusForTool = this.config.getMessageBus?.();
@@ -7596,12 +7896,27 @@ ${this.pendingRecoveredAgentsNotice}
               activeToolAbortSignal,
               callId
             );
+            const preHookCancellation = cancelBeforeExecutionIfAborted(toolName);
+            if (preHookCancellation) return preHookCancellation;
             if (!preHookResult.shouldProceed) {
               const blockReason = preHookResult.blockReason || "Blocked by PreToolUse hook";
-              await this.messageEmitter.emitAgentMessage(
-                `\u2717 **PreToolUse blocked**: ${toolName} - ${blockReason}`
-              );
-              return earlyErrorResponse(new Error(blockReason), toolName);
+              try {
+                await this.messageEmitter.emitAgentMessage(
+                  `\u2717 **PreToolUse blocked**: ${toolName} - ${blockReason}`
+                );
+              } catch (emitError) {
+                debugLogger5.debug(
+                  "[Session.runTool] Failed to emit PreToolUse block message",
+                  emitError
+                );
+              }
+              const blockMessageCancellation = cancelBeforeExecutionIfAborted(toolName);
+              if (blockMessageCancellation) return blockMessageCancellation;
+              return earlyErrorResponse(new Error(blockReason), toolName, {
+                status: "error",
+                errorType: "execution_denied" /* EXECUTION_DENIED */,
+                executionStatus: "not_started"
+              });
             }
             if (preHookResult.additionalContext) {
               debugLogger5.debug(
@@ -7611,30 +7926,44 @@ ${this.pendingRecoveredAgentsNotice}
           }
           const toolInvocationGuard = this.config.getToolInvocationGuard?.();
           if (toolInvocationGuard) {
+            const invocationContext = getInvocationContext();
             const guardDecision = await evaluateToolInvocationGuard(
               toolInvocationGuard,
               {
                 callId,
                 toolName: policyToolName,
                 args: invocation.params,
-                signal: activeToolAbortSignal
+                signal: activeToolAbortSignal,
+                ...invocationContext ? { invocationContext } : {}
               }
             );
             if (activeToolAbortSignal.aborted) {
               return earlyErrorResponse(
                 new Error("Tool invocation was cancelled"),
                 toolName,
-                { status: "cancelled" }
+                {
+                  status: "cancelled",
+                  errorType: void 0,
+                  executionStatus: "not_started"
+                }
               );
             }
             if (!guardDecision.allowed) {
               return earlyErrorResponse(
                 new Error(guardDecision.reason),
                 toolName,
-                { errorType: "execution_denied" /* EXECUTION_DENIED */ }
+                {
+                  status: "error",
+                  errorType: "execution_denied" /* EXECUTION_DENIED */,
+                  executionStatus: "not_started"
+                }
               );
             }
           }
+          const executionBoundaryCancellation = cancelBeforeExecutionIfAborted(toolName);
+          if (executionBoundaryCancellation) {
+            return executionBoundaryCancellation;
+          }
           const continuedAgentId = toolName === ToolNames.SEND_MESSAGE && typeof args["task_id"] === "string" && args["task_id"].length > 0 ? args["task_id"] : void 0;
           const provisionalRelatedAgent = continuedAgentId !== void 0 && !this.relatedAgentIds.has(continuedAgentId);
           if (provisionalRelatedAgent) {
@@ -7662,9 +7991,9 @@ ${this.pendingRecoveredAgentsNotice}
               this.relatedAgentIds.add(continuedAgentId);
             }
           }, "settleRelatedAgent");
-          const execSpan = startToolExecutionSpan();
           let toolResult;
           let isExecutionTimeout = false;
+          let parentAbortedAtExecutionSettle = false;
           let aborted = false;
           let toolSettled = false;
           let heartbeatCount = 0;
@@ -7694,58 +8023,81 @@ ${this.pendingRecoveredAgentsNotice}
               }
             }
           } : void 0, "heartbeatSpanAttributes");
+          const sleepInhibitorHandle = acquireSleepInhibitor(
+            this.config,
+            `Qwen Code is executing tool ${toolName}`
+          );
           try {
-            const sleepInhibitorHandle = acquireSleepInhibitor(
-              this.config,
-              `Qwen Code is executing tool ${toolName}`
-            );
             try {
-              try {
-                addToolArgumentsAttributes(
-                  this.config,
-                  toolSpan,
-                  invocation.params
-                );
-              } catch {
-                debugLogger5.debug(
-                  "[Session.runTool] Failed to record tool arguments telemetry"
-                );
-              }
+              addToolArgumentsAttributes(
+                this.config,
+                toolSpan,
+                invocation.params
+              );
+            } catch {
+              debugLogger5.debug(
+                "[Session.runTool] Failed to record tool arguments telemetry"
+              );
+            }
+            const execSpan = startToolExecutionSpan({
+              toolName: policyToolName,
+              callId
+            });
+            executionStatus = "error";
+            try {
               toolResult = await invocation.execute(
                 activeToolAbortSignal,
                 onToolProgress
               );
-            } finally {
-              toolSettled = true;
-              sleepInhibitorHandle.release();
+              executeReturned = true;
+              parentAbortedAtExecutionSettle = activeToolAbortSignal.aborted;
+              isExecutionTimeout = toolResult.error?.type === "execution_timeout" /* EXECUTION_TIMEOUT */;
+              aborted = parentAbortedAtExecutionSettle && !isExecutionTimeout;
+              executionStatus = aborted ? "cancelled" : toolResult.error ? "error" : "success";
+              executionErrorType = toolResult.error ? toolResult.error.type ?? (toolType === "mcp" ? "mcp_tool_error" /* MCP_TOOL_ERROR */ : "unknown" /* UNKNOWN */) : void 0;
+              settleRelatedAgent(executionStatus === "success");
+              endToolExecutionSpan(execSpan, {
+                success: executionStatus === "success",
+                error: aborted ? "tool_cancelled" : isExecutionTimeout ? "tool_timeout" : toolResult.error ? "tool_error" : void 0,
+                cancelled: aborted,
+                executionStatus,
+                errorType: executionErrorType,
+                ...heartbeatSpanAttributes()
+              });
+            } catch (execError) {
+              const explicitErrorType = execError?.errorType;
+              const executionTimedOut = explicitErrorType === "execution_timeout" /* EXECUTION_TIMEOUT */;
+              executionStatus = activeToolAbortSignal.aborted && !executionTimedOut ? "cancelled" : "error";
+              executionErrorType = executionStatus === "error" ? explicitErrorType ?? (toolType === "mcp" ? "mcp_tool_error" /* MCP_TOOL_ERROR */ : "unhandled_exception" /* UNHANDLED_EXCEPTION */) : void 0;
+              settleRelatedAgent(false);
+              endToolExecutionSpan(execSpan, {
+                success: false,
+                error: executionStatus === "cancelled" ? "tool_cancelled" : executionTimedOut ? "tool_timeout" : "tool_exception",
+                cancelled: executionStatus === "cancelled",
+                executionStatus,
+                errorType: executionErrorType,
+                ...heartbeatSpanAttributes()
+              });
+              throw execError;
             }
-            isExecutionTimeout = toolResult.error?.type === "execution_timeout" /* EXECUTION_TIMEOUT */;
-            aborted = activeToolAbortSignal.aborted && !isExecutionTimeout;
-            settleRelatedAgent(!toolResult.error && !aborted);
-            endToolExecutionSpan(execSpan, {
-              success: !toolResult.error && !aborted,
-              error: aborted ? "tool_cancelled" : isExecutionTimeout ? "tool_timeout" : toolResult.error ? "tool_error" : void 0,
-              cancelled: aborted,
-              ...heartbeatSpanAttributes()
-            });
-          } catch (execError) {
-            settleRelatedAgent(false);
-            endToolExecutionSpan(execSpan, {
-              success: false,
-              error: activeToolAbortSignal.aborted ? "tool_cancelled" : "tool_exception",
-              cancelled: activeToolAbortSignal.aborted,
-              ...heartbeatSpanAttributes()
-            });
-            throw execError;
+          } finally {
+            toolSettled = true;
+            sleepInhibitorHandle.release();
           }
           cleanupAgentToolResources();
           if ((isEnterPlanModeTool || isExitPlanModeTool) && !toolResult.error && this.config.getApprovalMode() !== approvalMode) {
             await this.sendCurrentModeUpdateNotification();
             if (this.config.getApprovalMode() === "plan" /* PLAN */) {
+              this.activeTodoPlanRevision = void 0;
               this.#clearTodoStopGuardTrustAndDrainAutomaticQueues();
             }
           }
-          let responseParts = toolResult.error ? convertToFunctionErrorResponse(
+          let responseParts = aborted ? convertToFunctionErrorResponse(
+            toolName,
+            callId,
+            TOOL_EXECUTION_CANCELLED_MESSAGE,
+            TOOL_EXECUTION_CANCELLED_MESSAGE
+          ) : toolResult.error ? convertToFunctionErrorResponse(
             toolName,
             callId,
             toolResult.llmContent,
@@ -7755,9 +8107,7 @@ ${this.pendingRecoveredAgentsNotice}
             callId,
             toolResult.llmContent
           );
-          const status = aborted ? "cancelled" : toolResult.error ? "error" : "success";
-          const succeeded = status === "success";
-          const responseError = toolResult.error ? new Error(toolResult.error.message) : aborted ? new Error("Tool execution was cancelled") : void 0;
+          let status = aborted ? "cancelled" : toolResult.error ? "error" : "success";
           if (isTrustedTodoWriteTool && !toolResult.error) {
             this.todoStopGuard.observeTodoWrite(
               toolResult.returnDisplay,
@@ -7780,13 +8130,28 @@ ${this.pendingRecoveredAgentsNotice}
               activeToolAbortSignal,
               callId
             );
+            if (activeToolAbortSignal.aborted) {
+              return earlyErrorResponse(
+                new Error(TOOL_POST_EXECUTION_CANCELLED_MESSAGE),
+                toolName,
+                {
+                  status: "cancelled",
+                  errorType: void 0,
+                  executionStatus
+                }
+              );
+            }
             if (postHookResult.shouldStop) {
               const stopMessage = postHookResult.stopReason || "Execution stopped by PostToolUse hook";
               debugLogger5.info(
                 `PostToolUse hook requested stop for ${toolName}: ${stopMessage}`
               );
               this.todoStopGuard.suspend();
-              return earlyErrorResponse(new Error(stopMessage), toolName);
+              return earlyErrorResponse(new Error(stopMessage), toolName, {
+                status: "error",
+                errorType: "execution_denied" /* EXECUTION_DENIED */,
+                executionStatus
+              });
             }
             if (postHookResult.additionalContext) {
               const contextPart = { text: postHookResult.additionalContext };
@@ -7800,28 +8165,35 @@ ${this.pendingRecoveredAgentsNotice}
             });
           } else if (hooksEnabledForTool && messageBusForTool && (toolResult.error || aborted)) {
             const isInterrupt = aborted;
-            const failureHookResult = await firePostToolUseFailureHook(
-              messageBusForTool,
-              toolUseId,
-              policyToolName,
-              args,
-              toolResult.error?.message ?? "Tool execution was cancelled",
-              isInterrupt,
-              permissionMode,
-              activeToolAbortSignal,
-              callId
-            );
-            if (failureHookResult.additionalContext) {
+            try {
+              const failureHookResult = await firePostToolUseFailureHook(
+                messageBusForTool,
+                toolUseId,
+                policyToolName,
+                args,
+                toolResult.error?.message ?? TOOL_EXECUTION_CANCELLED_MESSAGE,
+                isInterrupt,
+                permissionMode,
+                activeToolAbortSignal,
+                callId
+              );
+              if (failureHookResult.additionalContext) {
+                debugLogger5.debug(
+                  `PostToolUseFailure hook additional context for ${toolName}: ${failureHookResult.additionalContext}`
+                );
+              }
+              await this.emitHookArtifactsNotification({
+                hookEventName: "PostToolUseFailure",
+                toolName,
+                toolCallId: callId,
+                artifacts: failureHookResult.artifacts
+              });
+            } catch (hookError) {
               debugLogger5.debug(
-                `PostToolUseFailure hook additional context for ${toolName}: ${failureHookResult.additionalContext}`
+                "[Session.runTool] PostToolUseFailure hook failed",
+                hookError
               );
             }
-            await this.emitHookArtifactsNotification({
-              hookEventName: "PostToolUseFailure",
-              toolName,
-              toolCallId: callId,
-              artifacts: failureHookResult.artifacts
-            });
           }
           const visionBridgeNotices = [];
           responseParts = await bridgeToolResultImages({
@@ -7833,7 +8205,29 @@ ${this.pendingRecoveredAgentsNotice}
           });
           const visionBridgeNotice = visionBridgeNotices.length > 0 ? visionBridgeNotices.join("\n") : void 0;
           if (visionBridgeNotice) {
-            await this.messageEmitter.emitAgentMessage(visionBridgeNotice);
+            try {
+              await this.messageEmitter.emitAgentMessage(visionBridgeNotice);
+            } catch (emitError) {
+              debugLogger5.debug(
+                "[Session.runTool] Failed to emit vision bridge notice",
+                emitError
+              );
+            }
+          }
+          if (activeToolAbortSignal.aborted && !(isExecutionTimeout && parentAbortedAtExecutionSettle)) {
+            status = "cancelled";
+            responseParts = convertToFunctionErrorResponse(
+              toolName,
+              callId,
+              TOOL_POST_EXECUTION_CANCELLED_MESSAGE,
+              TOOL_POST_EXECUTION_CANCELLED_MESSAGE
+            );
+          }
+          terminalStatus = status;
+          const succeeded = status === "success";
+          const responseError = status === "error" && toolResult.error ? new Error(toolResult.error.message) : status === "cancelled" ? new Error(TOOL_POST_EXECUTION_CANCELLED_MESSAGE) : void 0;
+          if (isTrustedTodoWriteTool && status === "cancelled") {
+            this.todoStopGuard.suspend();
           }
           if (isTodoWriteTool) {
             const plan = this.planEmitter.extractPlan(
@@ -7841,34 +8235,60 @@ ${this.pendingRecoveredAgentsNotice}
               succeeded ? args : void 0
             );
             if (plan && (plan.todos.length > 0 || Array.isArray(args["todos"]))) {
-              await this.planEmitter.emitPlan(plan, callId);
+              try {
+                await this.planEmitter.emitPlan(plan, callId);
+              } catch (emitError) {
+                debugLogger5.debug(
+                  "[Session.runTool] Failed to emit plan update",
+                  emitError
+                );
+              }
             }
           } else if (!isTodoWriteTool) {
-            await this.toolCallEmitter.emitResult({
-              callId,
-              toolName,
-              args,
-              message: responseParts,
-              resultDisplay: toolResult.returnDisplay,
-              error: responseError,
+            try {
+              await this.toolCallEmitter.emitResult({
+                callId,
+                toolName,
+                args,
+                message: responseParts,
+                resultDisplay: toolResult.returnDisplay,
+                error: responseError,
+                success: succeeded,
+                artifacts: toolResult.artifacts
+              });
+            } catch (emitError) {
+              debugLogger5.debug(
+                "[Session.runTool] Failed to emit terminal tool update",
+                emitError
+              );
+            }
+          }
+          const durationMs = Date.now() - startTime;
+          try {
+            logToolCall(this.config, {
+              "event.name": "tool_call",
+              "event.timestamp": (/* @__PURE__ */ new Date()).toISOString(),
+              call_id: callId,
+              function_name: toolName,
+              function_args: args,
+              duration_ms: durationMs,
+              status,
+              execution_status: executionStatus,
               success: succeeded,
-              artifacts: toolResult.artifacts
+              ...status === "error" ? {
+                error: toolResult.error?.message,
+                error_type: executionErrorType
+              } : {},
+              prompt_id: promptId,
+              tool_type: toolType,
+              mcp_server_name: mcpServerName
             });
+          } catch (telemetryError) {
+            debugLogger5.debug(
+              "[Session.runTool] Failed to record terminal tool telemetry",
+              telemetryError
+            );
           }
-          const durationMs = Date.now() - startTime;
-          logToolCall(this.config, {
-            "event.name": "tool_call",
-            "event.timestamp": (/* @__PURE__ */ new Date()).toISOString(),
-            function_name: toolName,
-            function_args: args,
-            duration_ms: durationMs,
-            status,
-            success: succeeded,
-            error: toolResult.error?.message,
-            error_type: toolResult.error?.type,
-            prompt_id: promptId,
-            tool_type: typeof tool !== "undefined" && tool instanceof DiscoveredMCPTool ? "mcp" : "native"
-          });
           queueToolResultRecord?.(fc, {
             callId,
             toolName,
@@ -7877,13 +8297,13 @@ ${this.pendingRecoveredAgentsNotice}
             metadata: {
               callId,
               status,
+              executionStatus,
               resultDisplay: toolResult.returnDisplay,
               ...visionBridgeNotice !== void 0 ? { visionBridgeNotice } : {},
-              error: toolResult.error ? new Error(toolResult.error.message) : void 0,
-              errorType: toolResult.error?.type
+              error: status === "error" && toolResult.error ? new Error(toolResult.error.message) : void 0,
+              errorType: status === "error" ? executionErrorType : void 0
             }
           });
-          spanSuccess = succeeded;
           if (succeeded && !nestedPermissionCancelled) {
             const result = responseParts.find(
               (part) => part.functionResponse !== void 0
@@ -7898,10 +8318,8 @@ ${this.pendingRecoveredAgentsNotice}
               }
             }
           }
-          if (toolResult.error) {
+          if (status === "error" && toolResult.error) {
             spanError = toolResult.error.message;
-          } else if (aborted) {
-            spanError = "Tool execution was cancelled";
           }
           return {
             parts: responseParts,
@@ -7915,66 +8333,74 @@ ${this.pendingRecoveredAgentsNotice}
             ] : void 0
           };
         } catch (e) {
-          cleanupAgentToolResources();
           const error = e instanceof Error ? e : new Error(String(e));
-          spanError = error.message;
           const hooksEnabledForError = !this.config.getDisableAllHooks?.();
           const messageBusForError = this.config.getMessageBus?.();
-          const isInterrupt = activeToolAbortSignal.aborted;
+          const executionTimeoutException = !executeReturned && executionErrorType === "execution_timeout" /* EXECUTION_TIMEOUT */;
+          let status = executionStatus === "cancelled" || activeToolAbortSignal.aborted && !executionTimeoutException ? "cancelled" : "error";
+          const isInterrupt = status === "cancelled";
           if (hooksEnabledForError && messageBusForError) {
-            const failureHookResult = await firePostToolUseFailureHook(
-              messageBusForError,
-              toolUseId,
-              policyToolName,
-              args,
-              error.message,
-              isInterrupt,
-              String(approvalMode),
-              activeToolAbortSignal,
-              callId
-            );
-            if (failureHookResult.additionalContext) {
+            try {
+              const failureHookResult = await firePostToolUseFailureHook(
+                messageBusForError,
+                toolUseId,
+                policyToolName,
+                args,
+                error.message,
+                isInterrupt,
+                String(approvalMode),
+                activeToolAbortSignal,
+                callId
+              );
+              if (failureHookResult.additionalContext) {
+                debugLogger5.debug(
+                  `PostToolUseFailure hook additional context for ${toolName}: ${failureHookResult.additionalContext}`
+                );
+              }
+              await this.emitHookArtifactsNotification({
+                hookEventName: "PostToolUseFailure",
+                toolName,
+                toolCallId: callId,
+                artifacts: failureHookResult.artifacts
+              });
+            } catch (hookError) {
               debugLogger5.debug(
-                `PostToolUseFailure hook additional context for ${toolName}: ${failureHookResult.additionalContext}`
+                "[Session.runTool] PostToolUseFailure hook failed",
+                hookError
               );
             }
-            await this.emitHookArtifactsNotification({
-              hookEventName: "PostToolUseFailure",
-              toolName,
-              toolCallId: callId,
-              artifacts: failureHookResult.artifacts
-            });
           }
-          await this.toolCallEmitter.emitError(callId, toolName, error);
-          const loopDetected = !activeToolAbortSignal.aborted && !toolBuildSucceeded && recordDaemonInvalidToolParams(
-            this.config,
-            promptId,
-            toolLoopState,
-            toolName,
-            error
-          );
-          const responseParts = errorResponse(error);
-          queueToolResultRecord?.(fc, {
-            callId,
-            toolName,
-            responseParts,
-            metadata: {
-              callId,
-              status: activeToolAbortSignal.aborted ? "cancelled" : "error",
-              resultDisplay: void 0,
-              error,
-              errorType: void 0
-            }
+          if (activeToolAbortSignal.aborted && !executionTimeoutException) {
+            status = "cancelled";
+          }
+          const explicitErrorType = e?.errorType;
+          const errorType = status === "cancelled" ? void 0 : explicitErrorType ?? (executeReturned ? "unhandled_exception" /* UNHANDLED_EXCEPTION */ : executionErrorType ?? (!toolBuildSucceeded ? "invalid_tool_params" /* INVALID_TOOL_PARAMS */ : "unhandled_exception" /* UNHANDLED_EXCEPTION */));
+          return earlyErrorResponse(error, toolName, {
+            status,
+            errorType,
+            executionStatus,
+            recordInvalidToolParams: !toolBuildSucceeded,
+            stopAfterPermissionCancel: nestedPermissionCancelled
           });
-          return {
-            parts: responseParts,
-            stopAfterPermissionCancel: nestedPermissionCancelled,
-            loopDetected
-          };
         }
       });
+    } catch (e) {
+      const error = e instanceof Error ? e : new Error(String(e));
+      const status = activeToolAbortSignal.aborted ? "cancelled" : "error";
+      return await earlyErrorResponse(error, toolName, {
+        status,
+        errorType: status === "error" ? "unhandled_exception" /* UNHANDLED_EXCEPTION */ : void 0,
+        executionStatus
+      });
     } finally {
-      endToolSpan(toolSpan, { success: spanSuccess, error: spanError });
+      if (terminalStatus === "cancelled") {
+        endToolSpan(toolSpan, { success: false, cancelled: true });
+      } else {
+        endToolSpan(toolSpan, {
+          success: terminalStatus === "success",
+          error: spanError
+        });
+      }
     }
   }
   #emitGoalStatusItems(result) {
@@ -10308,6 +10734,74 @@ async function deliverClientMcpMessage(connection, serverName, message, sessionI
   return payload;
 }
 __name(deliverClientMcpMessage, "deliverClientMcpMessage");
+function createManagedExternalToolGuard(connection) {
+  return async (context) => {
+    const invocation = context.invocationContext;
+    if (!invocation) {
+      throw new Error(
+        "Managed external tool guard requires a runtime invocation context."
+      );
+    }
+    if (context.signal.aborted) {
+      throw new DOMException("Tool invocation aborted", "AbortError");
+    }
+    if (context.toolName === ToolNames.AGENT || context.toolName === ToolNames.WORKFLOW || context.toolName === ToolNames.CREATE_SUB_SESSION || context.toolName === ToolNames.SEND_MESSAGE) {
+      return {
+        allowed: false,
+        reason: "Managed external tool guard v1 does not support nested or delegated agent execution."
+      };
+    }
+    let rejectOnAbort;
+    const aborted = new Promise((_resolve, reject) => {
+      rejectOnAbort = reject;
+    });
+    const onAbort = /* @__PURE__ */ __name(() => rejectOnAbort?.(
+      new DOMException("Tool invocation aborted", "AbortError")
+    ), "onAbort");
+    context.signal.addEventListener("abort", onAbort, { once: true });
+    if (context.signal.aborted) onAbort();
+    try {
+      const response = await Promise.race([
+        connection.extMethod(
+          SERVE_CONTROL_EXT_METHODS.externalToolGuardPrepare,
+          {
+            sessionId: invocation.sessionId,
+            promptId: invocation.promptId,
+            toolCallId: context.callId,
+            toolName: context.toolName,
+            arguments: context.args
+          }
+        ),
+        aborted
+      ]);
+      const keys = Object.keys(response);
+      if (typeof response["allowed"] !== "boolean" || keys.some((key) => key !== "allowed" && key !== "reason")) {
+        throw new Error(
+          "Managed external tool guard returned an invalid reply."
+        );
+      }
+      if (response["allowed"]) {
+        if (Object.hasOwn(response, "reason")) {
+          throw new Error(
+            "Managed external tool guard allow reply contains a reason."
+          );
+        }
+        return { allowed: true };
+      }
+      const reason = response["reason"];
+      if (reason === void 0) return { allowed: false };
+      if (!isValidExternalToolGuardDenialReason(reason)) {
+        throw new Error(
+          "Managed external tool guard denial reason is invalid."
+        );
+      }
+      return { allowed: false, reason };
+    } finally {
+      context.signal.removeEventListener("abort", onAbort);
+    }
+  };
+}
+__name(createManagedExternalToolGuard, "createManagedExternalToolGuard");
 function readRuntimeMcpRequest(params) {
   const name = params["name"];
   if (typeof name !== "string" || name.length === 0) {
@@ -10401,6 +10895,14 @@ async function runAcpAgent(config, settings, argv, options) {
   const sessionWriterLeaseEnabledAtStartup = typeof config.isSessionWriterLeaseEnabled === "function" ? config.isSessionWriterLeaseEnabled() : settings.merged.experimental?.sessionWriterLease === true;
   const privateParentCapability = options === void 0 ? process.env[PRIVATE_ACP_CAPABILITY_ENV] : options.privateParentCapability;
   delete process.env[PRIVATE_ACP_CAPABILITY_ENV];
+  delete process.env[PRIVATE_EXTERNAL_TOOL_GUARD_ENV];
+  delete process.env[EXTERNAL_TOOL_GUARD_TOKEN_ENV];
+  const externalToolGuardRequired = options?.externalToolGuardRequired === true;
+  if (externalToolGuardRequired && privateParentCapability === void 0) {
+    throw new Error(
+      "Required external tool guard is available only to a private managed ACP parent."
+    );
+  }
   let acpConnection;
   const bootstrapClientMcpSender = /* @__PURE__ */ __name((serverName, message) => deliverClientMcpMessage(acpConnection, serverName, message), "bootstrapClientMcpSender");
   beginAcpBootstrapConfigProfiling();
@@ -10477,13 +10979,15 @@ async function runAcpAgent(config, settings, argv, options) {
     });
     connection = new AgentSideConnection((conn) => {
       acpConnection = conn;
+      const managedToolInvocationGuard = externalToolGuardRequired ? createManagedExternalToolGuard(conn) : void 0;
       agentInstance = new QwenAgent(
         config,
         settings,
         argv,
         conn,
         privateParentCapability,
-        sessionWriterLeaseEnabledAtStartup
+        sessionWriterLeaseEnabledAtStartup,
+        managedToolInvocationGuard
       );
       return agentInstance;
     }, stream);
@@ -10780,13 +11284,14 @@ function parseAcpSessionListCursor(value) {
 }
 __name(parseAcpSessionListCursor, "parseAcpSessionListCursor");
 var QwenAgent = class {
-  constructor(config, settings, argv, connection, expectedPrivateParentCapability, sessionWriterLeaseEnabledAtStartup = false) {
+  constructor(config, settings, argv, connection, expectedPrivateParentCapability, sessionWriterLeaseEnabledAtStartup = false, managedToolInvocationGuard) {
     this.config = config;
     this.settings = settings;
     this.argv = argv;
     this.connection = connection;
     this.expectedPrivateParentCapability = expectedPrivateParentCapability;
     this.sessionWriterLeaseEnabledAtStartup = sessionWriterLeaseEnabledAtStartup;
+    this.managedToolInvocationGuard = managedToolInvocationGuard;
     if (process.env["QWEN_SERVE_NO_MCP_POOL"] === "1") {
       this.mcpPool = void 0;
       this.workspaceMcpBudget = void 0;
@@ -10877,6 +11382,14 @@ var QwenAgent = class {
       throw new SessionWriterUnavailableError();
     }
   }
+  rejectUnsupportedGuardedHiddenAgent(operation) {
+    if (this.managedToolInvocationGuard) {
+      throw RequestError.invalidParams(
+        void 0,
+        `Managed external tool guard v1 does not support ${operation}.`
+      );
+    }
+  }
   beginManagedShutdown() {
     if (!this.isTrustedManagedParent()) {
       throw new Error("Managed shutdown requires a trusted private parent");
@@ -11528,7 +12041,7 @@ var QwenAgent = class {
     }
     this.clientCapabilities = args.clientCapabilities;
     const authMethods = buildAuthMethods();
-    const version = "0.21.4";
+    const version = "0.21.5-nightly.20260805.32e274157";
     const response = {
       protocolVersion: PROTOCOL_VERSION,
       agentInfo: {
@@ -11567,12 +12080,13 @@ var QwenAgent = class {
     }
     const requestedProfile = args._meta?.[CHANNEL_STARTUP_PROFILE_META_KEY];
     const profileRequested = requestedProfile !== null && typeof requestedProfile === "object" && !Array.isArray(requestedProfile) && requestedProfile["v"] === CHANNEL_STARTUP_PROFILE_VERSION;
-    return profileRequested && startupProfile ? {
-      ...response,
-      _meta: {
-        [CHANNEL_STARTUP_PROFILE_META_KEY]: startupProfile
-      }
-    } : response;
+    const responseMeta = {
+      ...this.managedToolInvocationGuard ? {
+        [EXTERNAL_TOOL_GUARD_READY_META_KEY]: EXTERNAL_TOOL_GUARD_REQUIRED_VALUE
+      } : {},
+      ...profileRequested && startupProfile ? { [CHANNEL_STARTUP_PROFILE_META_KEY]: startupProfile } : {}
+    };
+    return Object.keys(responseMeta).length > 0 ? { ...response, _meta: responseMeta } : response;
   }
   async authenticate({ methodId }) {
     const method = external_exports.nativeEnum(AuthType).parse(methodId);
@@ -11693,8 +12207,12 @@ var QwenAgent = class {
             logger: debugLogger6
           });
           if (!bulkReplay2) {
-            for (const update of replay.updates) {
-              await liveSession.sendUpdate(update);
+            try {
+              for (const update of replay.updates) {
+                await liveSession.sendUpdate(update);
+              }
+            } finally {
+              liveSession.clearActiveTodoPlanRevision();
             }
             if (replay.replayError !== void 0) {
               throw RequestError.internalError(void 0, replay.replayError);
@@ -14381,9 +14899,12 @@ var QwenAgent = class {
         );
       case SERVE_CONTROL_EXT_METHODS.workspaceMemoryRememberAvailability:
         return {
-          available: this.config.isManagedMemoryAvailable()
+          available: !this.managedToolInvocationGuard && this.config.isManagedMemoryAvailable()
         };
       case SERVE_CONTROL_EXT_METHODS.workspaceMemoryRemember: {
+        this.rejectUnsupportedGuardedHiddenAgent(
+          "agent-backed workspace memory remember"
+        );
         const content = params["content"];
         if (typeof content !== "string" || !content.trim()) {
           throw RequestError.invalidParams(
@@ -14562,6 +15083,9 @@ var QwenAgent = class {
         }
       }
       case SERVE_CONTROL_EXT_METHODS.workspaceMemoryDream: {
+        this.rejectUnsupportedGuardedHiddenAgent(
+          "agent-backed workspace memory dream"
+        );
         if (!this.config.isManagedMemoryAvailable()) {
           throw new RequestError(
             -32009,
@@ -15478,6 +16002,9 @@ var QwenAgent = class {
         }
         const current = config.getApprovalMode();
         if (current === "plan") {
+          if (previous !== "plan") {
+            session.clearActiveTodoPlanRevision();
+          }
           session.clearTodoStopGuardTrust();
         }
         return { previous, current };
@@ -15708,6 +16235,12 @@ var QwenAgent = class {
         return { sessionId, answer: result.text || null };
       }
       case SERVE_CONTROL_EXT_METHODS.sessionForkAgent: {
+        if (this.managedToolInvocationGuard) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Managed external tool guard v1 does not support /fork."
+          );
+        }
         const sessionId = params["sessionId"];
         if (typeof sessionId !== "string" || sessionId.length === 0) {
           throw RequestError.invalidParams(
@@ -16713,6 +17246,7 @@ ${outputText}
                 try {
                   config.setApprovalMode(newMode);
                   if (newMode === "plan") {
+                    session.clearActiveTodoPlanRevision();
                     session.clearTodoStopGuardTrust();
                   }
                 } catch (err) {
@@ -17058,7 +17592,8 @@ ${outputText}
       // A duplicate caller-supplied session id must fail this one request,
       // not process.exit(1) the shared ACP child and every session on its
       // channel. newSessionConfig maps the throw to a RequestError.
-      true
+      true,
+      this.managedToolInvocationGuard ? { toolInvocationGuard: this.managedToolInvocationGuard } : void 0
     );
     if (sessionSource) {
       config.setSessionSource(sessionSource.sourceType, sessionSource.sourceId);
@@ -17333,6 +17868,7 @@ __name(diffSettingsKeys, "diffSettingsKeys");
 export {
   AUTH_PREFLIGHT_ENV_KEYS,
   AUTH_PREFLIGHT_WAIVED_AUTH_TYPES,
+  createManagedExternalToolGuard,
   createWorkspaceMcpBudget,
   deliverClientMcpMessage,
   extractFilesFromTarGz,