@qwen-code/qwen-code 0.18.2 → 0.18.3-nightly.20260618.bc3e0b405

package/cli.js

@@ -92,7 +92,7 @@ import {
   updateOutputLanguageFile,
   validateCustomTheme,
   writeOutputLanguageAndRegisterPath
-} from "./chunks/chunk-QFJ67S5R.js";
+} from "./chunks/chunk-XFUQS3BO.js";
 import {
   AgentSideConnection,
   PROTOCOL_VERSION,
@@ -105,7 +105,7 @@ import {
   formatContextUsageText,
   isTerminalGoalStatusKind,
   require_react
-} from "./chunks/chunk-JZEKEWO5.js";
+} from "./chunks/chunk-753BG2JJ.js";
 import {
   SUPPORTED_LANGUAGES,
   clearScreen,
@@ -118,7 +118,7 @@ import {
   ta,
   writeStderrLine,
   writeStdoutLine
-} from "./chunks/chunk-M7OBURJM.js";
+} from "./chunks/chunk-SWMGBYC2.js";
 import {
   noteInteraction
 } from "./chunks/chunk-MRO43B25.js";
@@ -342,7 +342,7 @@ import {
   writeRuntimeStatus,
   writeWorktreeSession,
   writeWorktreeSessionMarker
-} from "./chunks/chunk-EQ5NHJBY.js";
+} from "./chunks/chunk-RMFCNRER.js";
 import {
   external_exports
 } from "./chunks/chunk-K5PGHDBN.js";
@@ -418,7 +418,7 @@ import {
   stripRuntimeSnapshotPrefix,
   uiTelemetryService,
   withInteractionSpan
-} from "./chunks/chunk-25FFAMED.js";
+} from "./chunks/chunk-BPJAFPPD.js";
 import "./chunks/chunk-3PJXIDKI.js";
 import "./chunks/chunk-UWCTAVOD.js";
 import {
@@ -59189,7 +59189,7 @@ var serveCommand = {
         process.exit(1);
       }
     }
-    const { runQwenServe } = await import("./chunks/serve-VF4ZNUJP.js");
+    const { runQwenServe } = await import("./chunks/serve-SYMKDBDG.js");
     try {
       await runQwenServe({
         port: argv.port,
@@ -72034,7 +72034,7 @@ async function extractMetadata(conversation, config) {
   const gitBranch = firstRecord?.gitBranch;
   let gitRepo;
   if (cwd5) {
-    const { getGitRepoName } = await import("./chunks/src-XV5MLRND.js");
+    const { getGitRepoName } = await import("./chunks/src-YBSBZZEL.js");
     gitRepo = getGitRepoName(cwd5);
   }
   let model;
@@ -84233,7 +84233,7 @@ var SystemController = class extends BaseController {
       throw new Error("Request aborted");
     }
     try {
-      const mod = await import("./chunks/contextCommand-HI2X2Y7I.js");
+      const mod = await import("./chunks/contextCommand-4AF56TE5.js");
       if (signal.aborted) {
         throw new Error("Request aborted");
       }
@@ -84759,11 +84759,13 @@ var PermissionController = class extends BaseController {
             label: "Deny",
             description: "Block this file edit"
           },
-          {
-            type: "modify",
-            label: "Review Changes",
-            description: "Review the proposed changes before applying"
-          }
+          ...details["hideModify"] === true ? [] : [
+            {
+              type: "modify",
+              label: "Review Changes",
+              description: "Review the proposed changes before applying"
+            }
+          ]
         ];
       case "plan":
         return [
@@ -96892,7 +96894,7 @@ var ToolConfirmationMessage = /* @__PURE__ */ __name(({
         key: "Yes, allow always"
       });
     }
-    if ((!config.getIdeMode() || !isDiffingEnabled) && preferredEditor) {
+    if (!confirmationDetails.hideModify && (!config.getIdeMode() || !isDiffingEnabled) && preferredEditor) {
       options.push({
         label: t("Modify with external editor"),
         value: "modify_with_editor" /* ModifyWithEditor */,
@@ -122011,6 +122013,10 @@ var PrepareLabel = import_react152.default.memo(_PrepareLabel);
 // packages/cli/src/ui/components/SuggestionsDisplay.tsx
 var import_jsx_runtime150 = __toESM(require_jsx_runtime(), 1);
 var MAX_SUGGESTIONS_TO_SHOW = 8;
+function normalizeDescription(description) {
+  return description.replace(/\s+/g, " ").trim();
+}
+__name(normalizeDescription, "normalizeDescription");
 function SuggestionsDisplay({
   suggestions,
   activeIndex,
@@ -122087,7 +122093,7 @@ function SuggestionsDisplay({
             flexGrow: 1,
             flexShrink: 1,
             paddingLeft: 2,
-            children: /* @__PURE__ */ (0, import_jsx_runtime150.jsx)(Text, { color: textColor, wrap: "wrap", children: suggestion.description })
+            children: /* @__PURE__ */ (0, import_jsx_runtime150.jsx)(Text, { color: textColor, wrap: "truncate-end", children: normalizeDescription(suggestion.description) })
           }
         ),
         isActive && isLong && /* @__PURE__ */ (0, import_jsx_runtime150.jsx)(Box_default, { children: /* @__PURE__ */ (0, import_jsx_runtime150.jsx)(Text, { color: Colors.Gray, children: isExpanded ? " \u2190 " : " \u2192 " }) })
@@ -143744,9 +143750,10 @@ __name(toPermissionOptions, "toPermissionOptions");
 // packages/cli/src/acp-integration/session/SubAgentTracker.ts
 var debugLogger75 = createDebugLogger("ACP_SUBAGENT_TRACKER");
 var SubAgentTracker = class {
-  constructor(ctx, client, parentToolCallId, subagentType) {
+  constructor(ctx, client, parentToolCallId, subagentType, onAskUserQuestionCancel) {
     this.ctx = ctx;
     this.client = client;
+    this.onAskUserQuestionCancel = onAskUserQuestionCancel;
     this.toolCallEmitter = new ToolCallEmitter(ctx);
     this.messageEmitter = new MessageEmitter(ctx);
     this.subagentMeta = { parentToolCallId, subagentType };
@@ -143876,12 +143883,25 @@ var SubAgentTracker = class {
         await event.respond(outcome, {
           answers: "answers" in output ? output.answers : void 0
         });
+        if (outcome === "cancel" /* Cancel */ && event.name === ToolNames.ASK_USER_QUESTION) {
+          this.onAskUserQuestionCancel?.();
+        }
       } catch (error) {
         debugLogger75.error(
           `Permission request failed for subagent tool ${event.name}:`,
           error
         );
-        await event.respond("cancel" /* Cancel */);
+        if (event.name === ToolNames.ASK_USER_QUESTION) {
+          this.onAskUserQuestionCancel?.();
+        }
+        try {
+          await event.respond("cancel" /* Cancel */);
+        } catch (respondError) {
+          debugLogger75.error(
+            `Failed to cancel subagent tool ${event.name} after permission request failure:`,
+            respondError
+          );
+        }
       }
     };
   }
@@ -144247,6 +144267,7 @@ function maskApiKeyForDisplay(apiKey) {
   return `${trimmed.slice(0, 3)}...${trimmed.slice(-4)}`;
 }
 __name(maskApiKeyForDisplay, "maskApiKeyForDisplay");
+var ASK_USER_QUESTION_CANCEL_SKIP_MESSAGE = "Skipped because ask_user_question was cancelled before the user answered; user input is required before continuing.";
 var MID_TURN_QUEUE_DRAIN_TIMEOUT_MS = 2e3;
 var MID_TURN_QUEUE_DRAIN_MAX_TIMEOUT_STRIKES = 3;
 var MidTurnDrainTimeoutError = class extends Error {
@@ -145045,15 +145066,21 @@ ${this.pendingWorktreeNotice}
                   );
                 }
                 if (functionCalls.length > 0) {
-                  const toolResponseParts = await this.runToolCalls(
+                  const toolRun = await this.runToolCalls(
                     pendingSend.signal,
                     promptId,
                     functionCalls
                   );
+                  if (toolRun.stopAfterUserQuestionCancel) {
+                    await this.#preserveCancelledAskUserQuestionToolRun(
+                      toolRun
+                    );
+                    return { stopReason: "end_turn" };
+                  }
                   nextMessage = {
                     role: "user",
                     parts: [
-                      ...toolResponseParts,
+                      ...toolRun.parts,
                       ...await this.#drainMidTurnUserMessages()
                     ]
                   };
@@ -145231,15 +145258,19 @@ ${this.pendingWorktreeNotice}
             );
           }
           if (functionCalls.length > 0) {
-            const toolResponseParts = await this.runToolCalls(
+            const toolRun = await this.runToolCalls(
               pendingSend.signal,
               promptId,
               functionCalls
             );
+            if (toolRun.stopAfterUserQuestionCancel) {
+              await this.#preserveCancelledAskUserQuestionToolRun(toolRun);
+              return { stopReason: "end_turn" };
+            }
             nextMessage = {
               role: "user",
               parts: [
-                ...toolResponseParts,
+                ...toolRun.parts,
                 ...await this.#drainMidTurnUserMessages()
               ]
             };
@@ -145363,6 +145394,16 @@ ${this.pendingWorktreeNotice}
       });
     }
   }
+  async #preserveCancelledAskUserQuestionToolRun(toolRun) {
+    this.#preserveUnsentMessageHistory(
+      {
+        role: "user",
+        parts: [...toolRun.parts, ...await this.#drainMidTurnUserMessages()]
+      },
+      true
+    );
+    await this.messageRewriter?.waitForPendingRewrites();
+  }
   #recordCompressionTokenCount(info) {
     this.#syncPromptTokenCountWithCurrentChat();
     const tokenCount = this.#extractCompressionTokenCount(info);
@@ -145642,15 +145683,21 @@ ${this.pendingWorktreeNotice}
                   );
                 }
                 if (functionCalls.length > 0) {
-                  const toolResponseParts = await this.runToolCalls(
+                  const toolRun = await this.runToolCalls(
                     ac.signal,
                     promptId,
                     functionCalls
                   );
+                  if (toolRun.stopAfterUserQuestionCancel) {
+                    await this.#preserveCancelledAskUserQuestionToolRun(
+                      toolRun
+                    );
+                    return;
+                  }
                   nextMessage = {
                     role: "user",
                     parts: [
-                      ...toolResponseParts,
+                      ...toolRun.parts,
                       ...await this.#drainMidTurnUserMessages()
                     ]
                   };
@@ -145871,15 +145918,20 @@ ${this.pendingWorktreeNotice}
               );
             }
             if (functionCalls.length > 0) {
-              const toolResponseParts = await this.runToolCalls(
+              const toolRun = await this.runToolCalls(
                 ac.signal,
                 promptId,
                 functionCalls
               );
+              if (toolRun.stopAfterUserQuestionCancel) {
+                await this.#preserveCancelledAskUserQuestionToolRun(toolRun);
+                await this.#emitBackgroundNotificationEndTurn("end_turn");
+                return;
+              }
               nextMessage = {
                 role: "user",
                 parts: [
-                  ...toolResponseParts,
+                  ...toolRun.parts,
                   ...await this.#drainMidTurnUserMessages()
                 ]
               };
@@ -146116,8 +146168,9 @@ ${this.pendingWorktreeNotice}
    * on. Response-part ordering matches the original `functionCalls` order.
    */
   async runToolCalls(abortSignal, promptId, functionCalls) {
+    const dedupedFunctionCalls = dedupeToolCallsById(functionCalls);
     const batches = [];
-    for (const fc of dedupeToolCallsById(functionCalls)) {
+    for (const fc of dedupedFunctionCalls) {
       const isAgent = fc.name === ToolNames.AGENT;
       const last = batches[batches.length - 1];
       if (isAgent && last?.concurrent) {
@@ -146126,7 +146179,45 @@ ${this.pendingWorktreeNotice}
         batches.push({ concurrent: isAgent, calls: [fc] });
       }
     }
-    const runBounded = /* @__PURE__ */ __name(async (calls) => {
+    let skippedToolCallCounter = 0;
+    const recordSkippedToolCall = /* @__PURE__ */ __name(async (fc) => {
+      const toolName = fc.name ?? "unknown_tool";
+      const callId = fc.id ?? `${toolName}-skip-${++skippedToolCallCounter}`;
+      const part = {
+        functionResponse: {
+          id: callId,
+          name: toolName,
+          response: { error: ASK_USER_QUESTION_CANCEL_SKIP_MESSAGE }
+        }
+      };
+      const error = new Error(ASK_USER_QUESTION_CANCEL_SKIP_MESSAGE);
+      try {
+        this.config.getChatRecordingService()?.recordToolResult([part], {
+          callId,
+          status: "error",
+          resultDisplay: void 0,
+          error,
+          errorType: void 0
+        });
+        await this.toolCallEmitter.emitStart({
+          callId,
+          toolName,
+          args: fc.args ?? {},
+          status: "pending"
+        });
+        await this.toolCallEmitter.emitError(callId, toolName, error);
+      } catch (recordError) {
+        debugLogger78.error("Failed to record skipped tool call:", recordError);
+      }
+      return part;
+    }, "recordSkippedToolCall");
+    const appendSkippedAfter = /* @__PURE__ */ __name(async (parts2, fc) => {
+      const startIndex = dedupedFunctionCalls.indexOf(fc) + 1;
+      for (const remainingCall of dedupedFunctionCalls.slice(startIndex)) {
+        parts2.push(await recordSkippedToolCall(remainingCall));
+      }
+    }, "appendSkippedAfter");
+    const runBounded = /* @__PURE__ */ __name(async (calls, runAbortSignal, onStopAfterUserQuestionCancel, shouldSkipUnstarted) => {
       const parsed = parseInt(
         process.env["QWEN_CODE_MAX_TOOL_CONCURRENCY"] || "",
         10
@@ -146136,7 +146227,19 @@ ${this.pendingWorktreeNotice}
       const executing = /* @__PURE__ */ new Set();
       for (let i = 0; i < calls.length; i++) {
         const idx = i;
-        const p = this.runTool(abortSignal, promptId, calls[idx]).then((r) => {
+        if (runAbortSignal.aborted && shouldSkipUnstarted?.()) {
+          results[idx] = {
+            parts: [await recordSkippedToolCall(calls[idx])],
+            stopAfterUserQuestionCancel: false
+          };
+          continue;
+        }
+        const p = this.runTool(
+          runAbortSignal,
+          promptId,
+          calls[idx],
+          onStopAfterUserQuestionCancel
+        ).then((r) => {
           results[idx] = r;
         }).finally(() => {
           executing.delete(p);
@@ -146152,16 +146255,54 @@ ${this.pendingWorktreeNotice}
     const parts = [];
     for (const batch of batches) {
       if (batch.concurrent && batch.calls.length > 1) {
-        const results = await runBounded(batch.calls);
-        for (const r of results) parts.push(...r);
+        const batchAbortController = new AbortController();
+        let batchStopAfterUserQuestionCancel = false;
+        const propagateAbort = /* @__PURE__ */ __name(() => {
+          batchAbortController.abort(abortSignal.reason);
+        }, "propagateAbort");
+        if (abortSignal.aborted) {
+          propagateAbort();
+        } else {
+          abortSignal.addEventListener("abort", propagateAbort, {
+            once: true
+          });
+        }
+        const stopBatchAfterUserQuestionCancel = /* @__PURE__ */ __name(() => {
+          batchStopAfterUserQuestionCancel = true;
+          batchAbortController.abort(USER_CANCEL_ABORT_REASON);
+        }, "stopBatchAfterUserQuestionCancel");
+        let results;
+        try {
+          results = await runBounded(
+            batch.calls,
+            batchAbortController.signal,
+            stopBatchAfterUserQuestionCancel,
+            () => batchStopAfterUserQuestionCancel
+          );
+        } finally {
+          abortSignal.removeEventListener("abort", propagateAbort);
+        }
+        let shouldStop = false;
+        for (const r of results) {
+          parts.push(...r.parts);
+          shouldStop ||= r.stopAfterUserQuestionCancel;
+        }
+        if (shouldStop) {
+          await appendSkippedAfter(parts, batch.calls[batch.calls.length - 1]);
+          return { parts, stopAfterUserQuestionCancel: true };
+        }
       } else {
         for (const fc of batch.calls) {
           const r = await this.runTool(abortSignal, promptId, fc);
-          parts.push(...r);
+          parts.push(...r.parts);
+          if (r.stopAfterUserQuestionCancel) {
+            await appendSkippedAfter(parts, fc);
+            return { parts, stopAfterUserQuestionCancel: true };
+          }
         }
       }
     }
-    return parts;
+    return { parts, stopAfterUserQuestionCancel: false };
   }
   /**
    * Assemble the per-turn system reminders the model needs to see at the
@@ -146193,11 +146334,15 @@ ${this.pendingWorktreeNotice}
     }
     return reminders;
   }
-  async runTool(abortSignal, promptId, fc) {
+  async runTool(abortSignal, promptId, fc, onStopAfterUserQuestionCancel) {
     const callId = fc.id ?? `${fc.name}-${Date.now()}`;
     let args = fc.args ?? {};
     const startTime = Date.now();
     let spanError;
+    let activeToolAbortSignal = abortSignal;
+    let nestedAskUserQuestionCancelled = false;
+    let agentToolAbortController;
+    let removeAgentToolAbortPropagation;
     const errorResponse = /* @__PURE__ */ __name((error) => {
       const durationMs = Date.now() - startTime;
       logToolCall(this.config, {
@@ -146208,7 +146353,7 @@ ${this.pendingWorktreeNotice}
         function_args: args,
         duration_ms: durationMs,
         // An aborted signal means the call was cancelled, not a genuine error.
-        status: abortSignal.aborted ? "cancelled" : "error",
+        status: activeToolAbortSignal.aborted ? "cancelled" : "error",
         success: false,
         error: error.message,
         tool_type: typeof tool !== "undefined" && tool instanceof DiscoveredMCPTool ? "mcp" : "native"
@@ -146223,8 +146368,9 @@ ${this.pendingWorktreeNotice}
         }
       ];
     }, "errorResponse");
-    const earlyErrorResponse = /* @__PURE__ */ __name(async (error, toolName2 = fc.name ?? "unknown_tool") => {
+    const earlyErrorResponse = /* @__PURE__ */ __name(async (error, toolName2 = fc.name ?? "unknown_tool", opts) => {
       spanError = error.message;
+      removeAgentToolAbortPropagation?.();
       if (toolName2 !== ToolNames.TODO_WRITE) {
         await this.toolCallEmitter.emitError(callId, toolName2, error);
       }
@@ -146236,7 +146382,10 @@ ${this.pendingWorktreeNotice}
         error,
         errorType: void 0
       });
-      return errorParts;
+      return {
+        parts: errorParts,
+        stopAfterUserQuestionCancel: opts?.stopAfterUserQuestionCancel ?? false
+      };
     }, "earlyErrorResponse");
     if (!fc.name) {
       return earlyErrorResponse(new Error("Missing function name"));
@@ -146271,6 +146420,23 @@ ${this.pendingWorktreeNotice}
         const isAgentTool = tool.name === ToolNames.AGENT;
         const isExitPlanModeTool = tool.name === ToolNames.EXIT_PLAN_MODE;
         const isEnterPlanModeTool = tool.name === ToolNames.ENTER_PLAN_MODE;
+        if (isAgentTool) {
+          agentToolAbortController = new AbortController();
+          activeToolAbortSignal = agentToolAbortController.signal;
+          const propagateAbort = /* @__PURE__ */ __name(() => {
+            agentToolAbortController?.abort(abortSignal.reason);
+          }, "propagateAbort");
+          if (abortSignal.aborted) {
+            propagateAbort();
+          } else {
+            abortSignal.addEventListener("abort", propagateAbort, {
+              once: true
+            });
+            removeAgentToolAbortPropagation = /* @__PURE__ */ __name(() => {
+              abortSignal.removeEventListener("abort", propagateAbort);
+            }, "removeAgentToolAbortPropagation");
+          }
+        }
         let subAgentCleanupFunctions = [];
         const toolUseId = generateToolUseId();
         const approvalMode = this.config.getApprovalMode();
@@ -146284,11 +146450,16 @@ ${this.pendingWorktreeNotice}
               this,
               this.client,
               parentToolCallId,
-              subagentType
+              subagentType,
+              () => {
+                nestedAskUserQuestionCancelled = true;
+                agentToolAbortController?.abort(USER_CANCEL_ABORT_REASON);
+                onStopAfterUserQuestionCancel?.();
+              }
             );
             subAgentCleanupFunctions = subSubAgentTracker.setup(
               taskEventEmitter,
-              abortSignal
+              activeToolAbortSignal
             );
           }
           const isAskUserQuestionTool = toolName === ToolNames.ASK_USER_QUESTION;
@@ -146506,9 +146677,15 @@ ${this.pendingWorktreeNotice}
               }
               switch (outcome) {
                 case "cancel" /* Cancel */:
+                  if (toolName === ToolNames.ASK_USER_QUESTION) {
+                    onStopAfterUserQuestionCancel?.();
+                  }
                   return earlyErrorResponse(
                     new Error(`Tool "${toolName}" was canceled by the user.`),
-                    toolName
+                    toolName,
+                    {
+                      stopAfterUserQuestionCancel: toolName === ToolNames.ASK_USER_QUESTION
+                    }
                   );
                 case "proceed_once" /* ProceedOnce */:
                 case "proceed_always" /* ProceedAlways */:
@@ -146545,7 +146722,7 @@ ${this.pendingWorktreeNotice}
               args,
               toolUseId,
               permissionMode,
-              abortSignal
+              activeToolAbortSignal
             );
             if (!preHookResult.shouldProceed) {
               const blockReason = preHookResult.blockReason || "Blocked by PreToolUse hook";
@@ -146568,11 +146745,11 @@ ${this.pendingWorktreeNotice}
               `Qwen Code is executing tool ${toolName}`
             );
             try {
-              toolResult = await invocation.execute(abortSignal);
+              toolResult = await invocation.execute(activeToolAbortSignal);
             } finally {
               sleepInhibitorHandle.release();
             }
-            const aborted2 = abortSignal.aborted;
+            const aborted2 = activeToolAbortSignal.aborted;
             endToolExecutionSpan(execSpan, {
               success: !toolResult.error && !aborted2,
               error: aborted2 ? "tool_cancelled" : toolResult.error ? "tool_error" : void 0,
@@ -146581,12 +146758,13 @@ ${this.pendingWorktreeNotice}
           } catch (execError) {
             endToolExecutionSpan(execSpan, {
               success: false,
-              error: abortSignal.aborted ? "tool_cancelled" : "tool_exception",
-              cancelled: abortSignal.aborted
+              error: activeToolAbortSignal.aborted ? "tool_cancelled" : "tool_exception",
+              cancelled: activeToolAbortSignal.aborted
             });
             throw execError;
           }
           subAgentCleanupFunctions.forEach((cleanup) => cleanup());
+          removeAgentToolAbortPropagation?.();
           if ((isEnterPlanModeTool || isExitPlanModeTool) && !didRequestPermission && !toolResult.error && this.config.getApprovalMode() !== approvalMode) {
             await this.sendUpdate({
               sessionUpdate: "current_mode_update",
@@ -146598,7 +146776,10 @@ ${this.pendingWorktreeNotice}
             callId,
             toolResult.llmContent
           );
-          if (hooksEnabledForTool && messageBusForTool && !toolResult.error) {
+          const aborted = activeToolAbortSignal.aborted;
+          const status = aborted ? "cancelled" : toolResult.error ? "error" : "success";
+          const succeeded = status === "success";
+          if (hooksEnabledForTool && messageBusForTool && !toolResult.error && !aborted && !nestedAskUserQuestionCancelled) {
             const toolResponse = {
               llmContent: toolResult.llmContent,
               returnDisplay: toolResult.returnDisplay
@@ -146610,7 +146791,7 @@ ${this.pendingWorktreeNotice}
               toolResponse,
               toolUseId,
               permissionMode,
-              abortSignal
+              activeToolAbortSignal
             );
             if (postHookResult.shouldStop) {
               const stopMessage = postHookResult.stopReason || "Execution stopped by PostToolUse hook";
@@ -146623,17 +146804,17 @@ ${this.pendingWorktreeNotice}
               const contextPart = { text: postHookResult.additionalContext };
               responseParts.push(contextPart);
             }
-          } else if (hooksEnabledForTool && messageBusForTool && toolResult.error) {
+          } else if (hooksEnabledForTool && messageBusForTool && (toolResult.error || aborted)) {
+            const isInterrupt = aborted;
             const failureHookResult = await firePostToolUseFailureHook(
               messageBusForTool,
               toolUseId,
               toolName,
               args,
-              toolResult.error.message,
-              false,
-              // not an interrupt
+              toolResult.error?.message ?? "Tool execution was cancelled",
+              isInterrupt,
               permissionMode,
-              abortSignal
+              activeToolAbortSignal
             );
             if (failureHookResult.additionalContext) {
               debugLogger78.debug(
@@ -146641,9 +146822,6 @@ ${this.pendingWorktreeNotice}
               );
             }
           }
-          const aborted = abortSignal.aborted;
-          const status = aborted ? "cancelled" : toolResult.error ? "error" : "success";
-          const succeeded = status === "success";
           if (isTodoWriteTool) {
             const todos = this.planEmitter.extractTodos(
               toolResult.returnDisplay,
@@ -146691,14 +146869,18 @@ ${this.pendingWorktreeNotice}
           } else if (aborted) {
             spanError = "Tool execution was cancelled";
           }
-          return responseParts;
+          return {
+            parts: responseParts,
+            stopAfterUserQuestionCancel: nestedAskUserQuestionCancelled
+          };
         } catch (e) {
           subAgentCleanupFunctions.forEach((cleanup) => cleanup());
+          removeAgentToolAbortPropagation?.();
           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 = abortSignal.aborted;
+          const isInterrupt = activeToolAbortSignal.aborted;
           if (hooksEnabledForError && messageBusForError) {
             const failureHookResult = await firePostToolUseFailureHook(
               messageBusForError,
@@ -146708,7 +146890,7 @@ ${this.pendingWorktreeNotice}
               error.message,
               isInterrupt,
               String(approvalMode),
-              abortSignal
+              activeToolAbortSignal
             );
             if (failureHookResult.additionalContext) {
               debugLogger78.debug(
@@ -146730,12 +146912,15 @@ ${this.pendingWorktreeNotice}
             callId,
             // A throw caused by abort (e.g. AbortError) is a cancellation, not
             // a genuine tool error — keep it consistent with the success path.
-            status: abortSignal.aborted ? "cancelled" : "error",
+            status: activeToolAbortSignal.aborted ? "cancelled" : "error",
             resultDisplay: void 0,
             error,
             errorType: void 0
           });
-          return errorResponse(error);
+          return {
+            parts: errorResponse(error),
+            stopAfterUserQuestionCancel: nestedAskUserQuestionCancelled
+          };
         }
       });
     } finally {
@@ -148782,7 +148967,7 @@ var QwenAgent = class {
   async initialize(args) {
     this.clientCapabilities = args.clientCapabilities;
     const authMethods = buildAuthMethods();
-    const version = "0.18.2";
+    const version = "0.18.3-nightly.20260618.bc3e0b405";
     return {
       protocolVersion: PROTOCOL_VERSION,
       agentInfo: {
@@ -152870,7 +153055,7 @@ ${finalArgs[promptIndex + 1]}`;
       process.exit(0);
     }
     if (config.isInteractive()) {
-      void import("./chunks/scheduler-J3OUGTTS.js").then((m) => m.startBackgroundHousekeeping(config, settings)).catch((err) => {
+      void import("./chunks/scheduler-2GZTWP5S.js").then((m) => m.startBackgroundHousekeeping(config, settings)).catch((err) => {
         debugLogger80.warn("failed to start background housekeeping:", err);
       });
     }