@qwen-code/qwen-code 0.21.4 → 0.21.5

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

@@ -2,7 +2,7 @@
 "use strict";
 import {
   recomputeMcpGating
-} from "./chunk-M6RNMBUO.js";
+} from "./chunk-YMUZQ3MQ.js";
 import {
   classifyApiError,
   fireSessionDeleteHook
@@ -16,14 +16,14 @@ import {
   matchMcpServerByRef,
   parseExtensionRef,
   parseMcpServerRef
-} from "./chunk-PQ5JFCNL.js";
+} from "./chunk-JDNWIXHJ.js";
 import {
   getAvailableCommands,
   handleSlashCommand,
   insertAfterFunctionResponses,
   isSlashCommand,
   normalizePartList
-} from "./chunk-WDLQGFWP.js";
+} from "./chunk-IWYXZAGT.js";
 import {
   SessionIdConflictError,
   appEvents,
@@ -31,23 +31,23 @@ import {
   cleanupReviewWorktreeLeases,
   loadCliConfig,
   normalizeDisabledToolList
-} from "./chunk-2T3RYG4L.js";
+} from "./chunk-GP4IMBX5.js";
 import "./chunk-NYX53SV4.js";
 import {
   collectContextData,
   formatContextUsageText
-} from "./chunk-C5YFS6VR.js";
+} from "./chunk-4NNR24EP.js";
 import {
   getCommandSubcommandNames
-} from "./chunk-QZQ72YF6.js";
+} from "./chunk-G2UXFO2B.js";
 import {
   getEffectiveSupportedModes
-} from "./chunk-DJA7YBLJ.js";
+} from "./chunk-C6ARWPCG.js";
 import "./chunk-3LGZEYOF.js";
 import "./chunk-4WGODMVR.js";
-import "./chunk-THLV7YGY.js";
+import "./chunk-EXHQZBVJ.js";
 import "./chunk-KKN2IE7Q.js";
-import "./chunk-2ON2O4MD.js";
+import "./chunk-SVIEVA3L.js";
 import "./chunk-6H67XLET.js";
 import {
   beginAcpBootstrapConfigProfiling,
@@ -55,8 +55,8 @@ import {
   endAcpBootstrapConfigProfiling,
   markAcpStartup
 } from "./chunk-M744OFVE.js";
-import "./chunk-P5UJMCVS.js";
-import "./chunk-EJXATV5R.js";
+import "./chunk-ZLGPHA34.js";
+import "./chunk-VJPF6GF2.js";
 import "./chunk-YAF2MQZ6.js";
 import {
   GENERATION_MAX_PROMPT_BYTES,
@@ -78,7 +78,7 @@ import {
   shouldSuppressRememberErrorDetails,
   workspaceMemoryFailureCode,
   workspaceMemoryFailureDiagnostics
-} from "./chunk-I32URQI7.js";
+} from "./chunk-IWGMDSC3.js";
 import {
   HistoryReplayer,
   MessageEmitter,
@@ -88,10 +88,10 @@ import {
   goalTerminalEventToHistoryItem,
   recordGoalStatusItem,
   restoreGoalFromHistory
-} from "./chunk-DHNFB7NC.js";
+} from "./chunk-YO4JI7B4.js";
 import "./chunk-DYA25Y7U.js";
 import "./chunk-4NFY2S7N.js";
-import "./chunk-AFJSRJTO.js";
+import "./chunk-5HWAJ4BK.js";
 import "./chunk-2MIN6GRR.js";
 import "./chunk-QHTIBUWB.js";
 import {
@@ -112,32 +112,32 @@ import {
   buildPermissionSettings,
   normalizePermissionRules,
   readPermissionRuleSet
-} from "./chunk-RL2NPV5E.js";
+} from "./chunk-4O6HLCOF.js";
 import {
   MAX_AUDIO_BYTES,
   sanitizeVoiceErrorMessage,
   transcribeVoiceAudio
-} from "./chunk-G6KI6B5L.js";
+} from "./chunk-LMNM37OE.js";
 import {
   readVoiceModel
-} from "./chunk-FPPVCCAH.js";
+} from "./chunk-TCOJPG2P.js";
 import "./chunk-JELIWHXD.js";
 import {
   resolveSkillSettings
 } from "./chunk-Z4X5MTRT.js";
-import "./chunk-5XGI4IPK.js";
-import "./chunk-O4IWFYUW.js";
+import "./chunk-VOA2UPZM.js";
+import "./chunk-3GOCVBYR.js";
 import "./chunk-57OAHC2Y.js";
 import {
   createLoadedSettingsAdapter
-} from "./chunk-C6FU76AA.js";
+} from "./chunk-K6VEL5KP.js";
 import "./chunk-VXZBKKQR.js";
-import "./chunk-XPAY4EMH.js";
+import "./chunk-IK3RYLAD.js";
 import "./chunk-3SH53ANB.js";
 import {
   SESSION_SOURCE_META_KEY,
   parseSessionSource
-} from "./chunk-B3EBXISV.js";
+} from "./chunk-KH2BIJ4H.js";
 import "./chunk-GLWP3FDB.js";
 import "./chunk-XCGIMOLN.js";
 import "./chunk-OCPBI7J5.js";
@@ -152,7 +152,7 @@ import {
   parseAcpModelOption,
   resolveAcpModelOption,
   sanitizeProviderBaseUrl
-} from "./chunk-IMGNGOGC.js";
+} from "./chunk-WU5NBSLD.js";
 import {
   ACP_PREFLIGHT_KINDS,
   IDLE_HOOK_EVENTS,
@@ -207,7 +207,7 @@ import {
 import {
   assembleMcpServers,
   loadMcpApprovals
-} from "./chunk-6ME3PVMM.js";
+} from "./chunk-SJMCYCUQ.js";
 import {
   getOutputLanguageFilePath,
   getPersistScopeForModelSelection,
@@ -215,7 +215,7 @@ import {
   resolveOutputLanguageOrPreserveAuto,
   updateOutputLanguageFile,
   writeOutputLanguageAndRegisterPath
-} from "./chunk-KB6VSG2U.js";
+} from "./chunk-RM3F46UT.js";
 import "./chunk-RKUWKYED.js";
 import "./chunk-GOXKNSDZ.js";
 import "./chunk-IDS7MSUP.js";
@@ -223,19 +223,19 @@ import {
   SUPPORTED_LANGUAGES,
   getCurrentLanguage,
   setLanguageAsync
-} from "./chunk-FV4TUUDE.js";
+} from "./chunk-K64OI7S7.js";
 import {
   reloadEnvironment
-} from "./chunk-4PZ7SPD5.js";
+} from "./chunk-LYPXNRBX.js";
 import "./chunk-6PEXNQTX.js";
-import "./chunk-RNKGMZEW.js";
-import "./chunk-HBCKZF2A.js";
+import "./chunk-CAX76R46.js";
+import "./chunk-IZ2CMEYO.js";
 import "./chunk-VJNBRRZG.js";
 import {
   isFolderTrustEnabled,
   isWorkspaceTrusted,
   loadTrustedFolders
-} from "./chunk-URVJ4AZC.js";
+} from "./chunk-B3EBIZUY.js";
 import "./chunk-ALGGS7UH.js";
 import "./chunk-MR3PXB6E.js";
 import "./chunk-XFSFZCM5.js";
@@ -363,25 +363,25 @@ import {
   validatePlanModeShellApproval,
   validatePlanModeShellContext,
   wrapUserPromptSubmitContext
-} from "./chunk-E2SYUEIA.js";
+} from "./chunk-YLL3SC5S.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-7W5KOBYU.js";
 import "./chunk-IRH27ZC2.js";
 import "./chunk-QHWCP53L.js";
 import "./chunk-MOHAWIAW.js";
-import "./chunk-X6QNZOTC.js";
+import "./chunk-7MFQLOHZ.js";
 import {
   promptIdContext,
   todoWorkChainContext
@@ -397,21 +397,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-4LLUH3A7.js";
 import {
   clearCachedCredentialFile,
   qwenOAuth2Events
@@ -423,7 +423,7 @@ import "./chunk-DGEIYUC3.js";
 import "./chunk-MPHPFVKK.js";
 import "./chunk-GLNBDYUX.js";
 import "./chunk-DJ2GSRLV.js";
-import "./chunk-SBBHZ3YT.js";
+import "./chunk-AEWOKOJY.js";
 import {
   addToolArgumentsAttributes,
   addToolCallResultAttributes,
@@ -431,7 +431,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 +469,22 @@ import {
   shouldRunVisionBridge,
   splitImageParts,
   uiTelemetryService
-} from "./chunk-JDJ7SC4E.js";
+} from "./chunk-ZPGMDT4S.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-XD2PNH3K.js";
 import "./chunk-46UV252V.js";
 import {
   DEFAULT_TOKEN_LIMIT,
@@ -501,9 +501,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 +512,10 @@ import {
   isSubpath
 } from "./chunk-3RXUYQJI.js";
 import "./chunk-VOQXFAY5.js";
-import "./chunk-KHSJSMFS.js";
+import "./chunk-K2ETEWG6.js";
 import {
   runExitCleanup
-} from "./chunk-SV5X2EUV.js";
+} from "./chunk-LSYVASZS.js";
 import {
   writeStderrLine,
   writeStderrLineSafe
@@ -1242,6 +1242,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 +1266,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 +1324,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 +1332,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 +1353,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 +1372,9 @@ var SubAgentTracker = class {
         event.thought ?? false,
         void 0,
         this.subagentMeta
-      );
+      ).catch((error) => {
+        debugLogger2.debug("Failed to emit subagent stream text:", error);
+      });
     };
   }
 };
@@ -1912,6 +1923,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 +1937,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;
 }
@@ -3961,7 +3981,7 @@ ${this.pendingRecoveredAgentsNotice}
                       onFullTurnModel
                     )
                   );
-                  if (toolRun.stopAfterPermissionCancel) {
+                  if (toolRun.stopAfterPermissionCancel || pendingSend.signal.aborted) {
                     this.todoStopGuard.suspend();
                     await this.#preserveStoppedToolRun(
                       toolRun,
@@ -4700,7 +4720,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 {
@@ -5661,7 +5681,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 +6087,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(
@@ -6493,9 +6513,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 +6542,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 +6589,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 +6639,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 +6678,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 +6713,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 +6882,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 +6920,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 +6988,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 +7027,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 +7109,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 +7143,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 +7169,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 +7247,8 @@ ${this.pendingRecoveredAgentsNotice}
             policyToolName,
             toolParams
           );
+          const permissionFlowCancellation = cancelBeforeExecutionIfAborted(toolName);
+          if (permissionFlowCancellation) return permissionFlowCancellation;
           const {
             finalPermission,
             pmForcedAsk,
@@ -7137,7 +7262,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 +7289,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 +7299,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 +7358,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 +7374,10 @@ ${this.pendingRecoveredAgentsNotice}
               callId,
               abortSignal
             );
+            const permissionDeniedHookCancellation = cancelBeforeExecutionIfAborted(toolName);
+            if (permissionDeniedHookCancellation) {
+              return permissionDeniedHookCancellation;
+            }
             switch (outcome.kind) {
               case "approved":
                 autoModeAllowed = true;
@@ -7236,7 +7388,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 +7437,10 @@ ${this.pendingRecoveredAgentsNotice}
             confirmationDetails = await invocation.getConfirmationDetails(
               activeToolAbortSignal
             );
+            const confirmationDetailsCancellation = cancelBeforeExecutionIfAborted(toolName);
+            if (confirmationDetailsCancellation) {
+              return confirmationDetailsCancellation;
+            }
             if (autoModeFallbackMessage) {
               confirmationDetails = decorateClassifierUnavailableConfirmation(
                 confirmationDetails,
@@ -7294,10 +7455,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 +7480,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 +7502,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 +7522,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 +7539,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 +7573,10 @@ ${this.pendingRecoveredAgentsNotice}
                     await confirmationDetails.onConfirm(
                       "proceed_once" /* ProceedOnce */
                     );
+                    const hookConfirmationCancellation = cancelBeforeExecutionIfAborted(toolName);
+                    if (hookConfirmationCancellation) {
+                      return hookConfirmationCancellation;
+                    }
                     recordAutoModeFallbackResolution(
                       "proceed_once" /* ProceedOnce */
                     );
@@ -7385,7 +7586,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 +7606,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"
+                    }
                   );
                 }
               }
@@ -7456,7 +7671,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 +7686,10 @@ ${this.pendingRecoveredAgentsNotice}
                   params,
                   activeToolAbortSignal
                 );
+                const permissionRequestCancellation = cancelBeforeExecutionIfAborted(toolName);
+                if (permissionRequestCancellation) {
+                  return permissionRequestCancellation;
+                }
                 outcome = resolvePermissionOutcome(
                   output,
                   offeredPermissionOptions
@@ -7485,16 +7709,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 +7744,10 @@ ${this.pendingRecoveredAgentsNotice}
                   outcome,
                   payload: confirmationPayload
                 });
+                const planApprovalCancellation = cancelBeforeExecutionIfAborted(toolName);
+                if (planApprovalCancellation) {
+                  return planApprovalCancellation;
+                }
                 outcome = approval.outcome;
                 confirmationPayload = approval.payload;
               }
@@ -7523,6 +7761,10 @@ ${this.pendingRecoveredAgentsNotice}
                   outcome,
                   confirmationPayload
                 );
+                const confirmationCancellation = cancelBeforeExecutionIfAborted(toolName);
+                if (confirmationCancellation) {
+                  return confirmationCancellation;
+                }
               } catch (error) {
                 if (outcome !== "cancel" /* Cancel */) {
                   throw error;
@@ -7536,6 +7778,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 +7789,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 +7833,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 +7857,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(
@@ -7624,17 +7900,29 @@ ${this.pendingRecoveredAgentsNotice}
               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 +7950,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,49 +7982,66 @@ ${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) {
@@ -7745,7 +8050,12 @@ ${this.pendingRecoveredAgentsNotice}
               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 +8065,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 +8088,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 +8123,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 +8163,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 +8193,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 +8255,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 +8276,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 +8291,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) {
@@ -11528,7 +11912,7 @@ var QwenAgent = class {
     }
     this.clientCapabilities = args.clientCapabilities;
     const authMethods = buildAuthMethods();
-    const version = "0.21.4";
+    const version = "0.21.5";
     const response = {
       protocolVersion: PROTOCOL_VERSION,
       agentInfo: {