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

package/chunks/{chunk-E2SYUEIA.js → chunk-5OAMVWFL.js}

@@ -40,7 +40,7 @@ import {
   CronScheduler,
   DEFAULT_RECURRING_MAX_AGE_DAYS,
   normalizeRecurringMaxAge
-} from "./chunk-VA5NLVPT.js";
+} from "./chunk-Z7JILXGX.js";
 import {
   consumeUnread,
   forwardApproval,
@@ -71,13 +71,13 @@ import {
   RUNTIME_SNAPSHOT_PREFIX,
   buildModelIdContext,
   resolveModelId
-} from "./chunk-DZPOYHBT.js";
+} from "./chunk-D6FISK43.js";
 import {
   ARTIFACT_TITLE_MAX_LENGTH,
   ARTIFACT_WORKSPACE_PATH_MAX_LENGTH,
   hasControlCharacter,
   hasUnsafeDisplayPayload
-} from "./chunk-X6QNZOTC.js";
+} from "./chunk-3PRJYMXC.js";
 import {
   promptIdContext,
   todoWorkChainContext
@@ -139,7 +139,7 @@ import {
   goalRequiresExactPermit,
   goalTurnContext,
   parseGoalStateRecordPayloadV2
-} from "./chunk-HFVW54NL.js";
+} from "./chunk-MBEMTXQT.js";
 import {
   APPROVAL_MODES,
   SUBAGENT_PLAN_LIFECYCLE_TOOLS,
@@ -163,7 +163,7 @@ import {
   runWithRuntimeContentGenerator,
   shouldUsePlanOnlyReminderInSubagentContext,
   spawnBlockReason
-} from "./chunk-LLMGP5IC.js";
+} from "./chunk-6WBWIPBF.js";
 import {
   getTeammateContext,
   isTeammate,
@@ -202,7 +202,7 @@ import {
   selectForkHistory,
   stripSystemReminderBlocks,
   validateForkToolList
-} from "./chunk-7UXI6P72.js";
+} from "./chunk-WVAESIM6.js";
 import {
   collectAvailableSkillEntries,
   renderAvailableSkillsBlock
@@ -223,7 +223,7 @@ import {
 } from "./chunk-432XCUHF.js";
 import {
   DashScopeOpenAICompatibleProvider
-} from "./chunk-YXEVDA66.js";
+} from "./chunk-HU5TUALO.js";
 import {
   openBrowserSecurely,
   shouldAttemptBrowserLaunch
@@ -248,7 +248,7 @@ import {
   addToolArgumentsAttributes,
   addToolCallResultAttributes,
   addUserPromptAttributes
-} from "./chunk-RPYYTL7E.js";
+} from "./chunk-MGSSJT27.js";
 import {
   InvalidStreamError,
   getThoughtSummary
@@ -302,7 +302,6 @@ import {
   _recoverObjectsFromLine,
   addMCPStatusChangeListener,
   collectText,
-  defaultModalities,
   detectFileType,
   exists,
   fileExists,
@@ -383,7 +382,10 @@ import {
   updateMCPServerStatus,
   writeLine,
   writeLineSync
-} from "./chunk-JDJ7SC4E.js";
+} from "./chunk-NMBDPO63.js";
+import {
+  defaultModalities
+} from "./chunk-WOJZWRAZ.js";
 import {
   E_TIMEOUT,
   Mutex,
@@ -411,13 +413,14 @@ import {
 } from "./chunk-E4WHKETF.js";
 import {
   STRUCTURED_OUTPUT_REDACTED_ARGS
-} from "./chunk-UEJESCS7.js";
+} from "./chunk-ZPPP6VCL.js";
 import {
   AgentStatistics,
   BaseDeclarativeTool,
   BaseToolInvocation,
   CONCURRENCY_SAFE_KINDS,
   SchemaValidator,
+  StructuredToolError,
   ToolDisplayNames,
   ToolDisplayNamesMigration,
   ToolNames,
@@ -428,7 +431,7 @@ import {
   require_dist,
   require_fast_deep_equal,
   require_fast_uri
-} from "./chunk-CFDR3GNL.js";
+} from "./chunk-D7D7RXIJ.js";
 import {
   AUTH_ENV_MAPPINGS,
   AuthType,
@@ -442,7 +445,7 @@ import {
   createContentGenerator,
   resetPreloadedContentGenerator,
   resolveContentGeneratorConfigWithSources
-} from "./chunk-TXZDRD36.js";
+} from "./chunk-LCCBAGRT.js";
 import {
   normalizeMcpToolName,
   sanitizeToolNameForProvider
@@ -494,15 +497,28 @@ import {
   startToolExecutionSpan,
   startToolSpan,
   truncateSpanError
-} from "./chunk-O2ZYHG33.js";
+} from "./chunk-5L6CQ4ZU.js";
 import {
   safeJsonStringify
 } from "./chunk-W4RQUHY3.js";
 import {
   DEFAULT_SENSITIVE_SPAN_ATTRIBUTE_MAX_LENGTH,
   SENSITIVE_SPAN_ATTRIBUTE_MAX_LENGTH_LIMIT,
+  TOOL_FAILURE_KIND_ATTRIBUTE,
+  TOOL_FAILURE_KIND_BACKGROUND_AGENT_DENIED,
+  TOOL_FAILURE_KIND_CANCELLED,
+  TOOL_FAILURE_KIND_INVOCATION_GUARD_DENIED,
+  TOOL_FAILURE_KIND_NON_INTERACTIVE_DENIED,
+  TOOL_FAILURE_KIND_PERMISSION_DENIED,
+  TOOL_FAILURE_KIND_PERMISSION_HOOK_DENIED,
+  TOOL_FAILURE_KIND_PLAN_MODE_BLOCKED,
+  TOOL_FAILURE_KIND_POST_HOOK_STOPPED,
+  TOOL_FAILURE_KIND_PRE_HOOK_BLOCKED,
+  TOOL_FAILURE_KIND_TIMEOUT,
+  TOOL_FAILURE_KIND_TOOL_ERROR,
+  TOOL_FAILURE_KIND_TOOL_EXCEPTION,
   isValidSensitiveSpanAttributeMaxLength
-} from "./chunk-G7XXKQYS.js";
+} from "./chunk-LKRMNRSN.js";
 import {
   FatalConfigError,
   PATH_ARG_KEYS,
@@ -20571,6 +20587,9 @@ function buildKeptFilePaths(history, refs, keepRefs, callIdToFilePath) {
     if (!keepRefs.has(refKey(ref))) continue;
     const part = getPart(history, ref);
     if (!part || isErrorResponse(part) || isAlreadyCleared(part)) continue;
+    if (part.functionResponse?.name !== ToolNames.WRITE_FILE) {
+      continue;
+    }
     const paths = getFilePathsForResponse(part, callIdToFilePath);
     if (paths?.length === 1) {
       kept.add(paths[0]);
@@ -20584,6 +20603,7 @@ function planSizeBasedClearing(history, settings, keepRecent, pendingContent, pr
   if (!Number.isFinite(threshold) || threshold < 0) {
     return null;
   }
+  const lowWatermark = Math.floor(threshold / 2);
   const pending = normalizePendingContent(pendingContent);
   const virtualHistory = pending.length > 0 ? [...history, ...pending] : history;
   const { tool } = collectCompactablePartRefs(virtualHistory);
@@ -20606,11 +20626,16 @@ function planSizeBasedClearing(history, settings, keepRecent, pendingContent, pr
   const compactableToolRefs = tool.filter(
     (ref) => !preservedToolRefs.has(refKey(ref))
   );
-  const keepToolRefs = buildKeepRefs(compactableToolRefs, keepRecent);
+  const keepToolRefs = buildKeepRefs(
+    compactableToolRefs.filter(
+      (ref) => ref.contentIndex < history.length && charsByRef.has(refKey(ref))
+    ),
+    keepRecent
+  );
   const clearRefs = [];
   let remainingChars = totalChars;
   for (const ref of compactableToolRefs) {
-    if (remainingChars <= threshold) break;
+    if (remainingChars <= lowWatermark) break;
     const key = refKey(ref);
     const chars = charsByRef.get(key) ?? 0;
     if (chars <= 0 || ref.contentIndex >= history.length || keepToolRefs.has(key)) {
@@ -20626,7 +20651,8 @@ function planSizeBasedClearing(history, settings, keepRecent, pendingContent, pr
     toolResultCharsBefore: totalChars,
     toolResultCharsAfter: remainingChars - pendingChars,
     pendingToolResultChars: pendingChars,
-    toolResultsTotalCharsThreshold: threshold
+    toolResultsTotalCharsThreshold: threshold,
+    toolResultsLowWatermark: lowWatermark
   };
 }
 __name(planSizeBasedClearing, "planSizeBasedClearing");
@@ -20646,6 +20672,7 @@ function microcompactHistory(history, lastApiCompletionTimestamp, settings, opts
   let toolResultCharsAfter;
   let pendingToolResultChars;
   let toolResultsTotalCharsThreshold;
+  let toolResultsLowWatermark;
   let keptPathHistory = history;
   let keptPathRefs = [];
   if (opts?.force) {
@@ -20665,13 +20692,28 @@ function microcompactHistory(history, lastApiCompletionTimestamp, settings, opts
       history,
       opts?.preserveReadFileResult
     ));
+    const keepToolRefs = buildKeepRefs(
+      tool.filter((ref) => {
+        const part = getPart(history, ref);
+        return getToolOutputChars(part) > 0 || !!part && hasNestedMedia(part);
+      }),
+      keepRecent
+    );
     keepRefs = /* @__PURE__ */ new Set([
-      ...tool.slice(-keepRecent).map(refKey),
+      ...keepToolRefs,
       ...media.slice(-keepRecent).map(refKey),
       ...nestedMedia.slice(-keepRecent).map(refKey)
     ]);
     const allRefs = [...tool, ...media, ...nestedMedia];
-    clearRefs = allRefs.filter((r) => !keepRefs.has(refKey(r)));
+    const toolKeys = new Set(tool.map(refKey));
+    clearRefs = allRefs.filter((r) => {
+      if (keepRefs.has(refKey(r))) return false;
+      const part = getPart(history, r);
+      if (toolKeys.has(refKey(r)) && getToolOutputChars(part) === 0 && !(part && hasNestedMedia(part))) {
+        return false;
+      }
+      return true;
+    });
     keptPathRefs = tool;
   } else {
     const pending = normalizePendingContent(opts?.pendingContent);
@@ -20695,6 +20737,7 @@ function microcompactHistory(history, lastApiCompletionTimestamp, settings, opts
     toolResultCharsAfter = sizePlan.toolResultCharsAfter;
     pendingToolResultChars = sizePlan.pendingToolResultChars;
     toolResultsTotalCharsThreshold = sizePlan.toolResultsTotalCharsThreshold;
+    toolResultsLowWatermark = sizePlan.toolResultsLowWatermark;
   }
   if (clearRefs.length === 0 && triggerReason !== "size") {
     return { history };
@@ -20784,6 +20827,7 @@ function microcompactHistory(history, lastApiCompletionTimestamp, settings, opts
       toolResultCharsAfter,
       pendingToolResultChars,
       toolResultsTotalCharsThreshold,
+      toolResultsLowWatermark,
       toolsCleared,
       mediaCleared,
       toolsKept,
@@ -22441,6 +22485,9 @@ Okay, I can write those tests. First, I'll read someFile.ts to understand its fu
 Now I'll look for existing or related test files to understand current testing conventions and dependencies.
 [tool_call: ${ToolNames.READ_FILE} for file_path '/path/to/existingTest.test.ts']
 (After reviewing existing tests and the file content)
+I'll check whether the intended test file already exists.
+[tool_call: ${ToolNames.READ_FILE} for file_path '/path/to/someFile.test.ts']
+(After read_file reports that /path/to/someFile.test.ts does not exist)
 [tool_call: ${ToolNames.WRITE_FILE} for file_path '/path/to/someFile.test.ts' with content '(test code content)']
 I've written the tests. Now I'll run the project's test command to verify them.
 [tool_call: ${ToolNames.SHELL} for 'npm run test']
@@ -22580,6 +22627,15 @@ Now I'll look for existing or related test files to understand current testing c
 </function>
 </tool_call>
 (After reviewing existing tests and the file content)
+I'll check whether the intended test file already exists.
+<tool_call>
+<function=${ToolNames.READ_FILE}>
+<parameter=file_path>
+/path/to/someFile.test.ts
+</parameter>
+</function>
+</tool_call>
+(After read_file reports that /path/to/someFile.test.ts does not exist)
 <tool_call>
 <function=${ToolNames.WRITE_FILE}>
 <parameter=file_path>
@@ -22693,6 +22749,11 @@ Now I'll look for existing or related test files to understand current testing c
 {"name": "${ToolNames.READ_FILE}", "arguments": {"file_path": "/path/to/existingTest.test.ts"}}
 </tool_call>
 (After reviewing existing tests and the file content)
+I'll check whether the intended test file already exists.
+<tool_call>
+{"name": "${ToolNames.READ_FILE}", "arguments": {"file_path": "/path/to/someFile.test.ts"}}
+</tool_call>
+(After read_file reports that /path/to/someFile.test.ts does not exist)
 <tool_call>
 {"name": "${ToolNames.WRITE_FILE}", "arguments": {"file_path": "/path/to/someFile.test.ts", "content": "(test code content)"}}
 </tool_call>
@@ -22774,6 +22835,9 @@ Okay, I can write those tests. First, I'll read someFile.ts to understand its fu
 Now I'll look for existing or related test files to understand current testing conventions and dependencies.
 <|tool_call>call:${ToolNames.READ_FILE}{file_path:<|"|>/path/to/existingTest.test.ts<|"|>}<tool_call|>
 (After reviewing existing tests and the file content)
+I'll check whether the intended test file already exists.
+<|tool_call>call:${ToolNames.READ_FILE}{file_path:<|"|>/path/to/someFile.test.ts<|"|>}<tool_call|>
+(After read_file reports that /path/to/someFile.test.ts does not exist)
 <|tool_call>call:${ToolNames.WRITE_FILE}{file_path:<|"|>/path/to/someFile.test.ts<|"|>,content:<|"|>(test code content)<|"|>}<tool_call|>
 I've written the tests. Now I'll run the project's test command to verify them.
 <|tool_call>call:${ToolNames.SHELL}{command:<|"|>npm run test<|"|>}<tool_call|>
@@ -35090,7 +35154,8 @@ function createDuplicateProviderToolCallResponse(request) {
     ],
     resultDisplay: message,
     error: new Error(message),
-    errorType: "execution_failed" /* EXECUTION_FAILED */
+    errorType: "execution_failed" /* EXECUTION_FAILED */,
+    executionStatus: "not_started"
   };
 }
 __name(createDuplicateProviderToolCallResponse, "createDuplicateProviderToolCallResponse");
@@ -35702,6 +35767,7 @@ __name(composePostCompactHistory, "composePostCompactHistory");
 // packages/core/src/services/chatCompressionService.ts
 var debugLogger20 = createDebugLogger("COMPRESSION");
 var COMPACT_MAX_OUTPUT_TOKENS = 2e4;
+var COMPRESSION_REQUEST_DIRECTIVE = "First, reason in your <analysis> block. Then, produce the <state_snapshot> XML.";
 var DEFAULT_PCT = 0.85;
 var SUMMARY_RESERVE = COMPACT_MAX_OUTPUT_TOKENS;
 var AUTOCOMPACT_BUFFER = 13e3;
@@ -35809,6 +35875,8 @@ var ChatCompressionService = class {
     const chatCompressionSettings = config.getChatCompression();
     const slimmingConfig = resolveSlimmingConfig(chatCompressionSettings);
     const tuning = resolveCompactionTuning(chatCompressionSettings);
+    const contentGeneratorConfig = config.getContentGeneratorConfig();
+    const contextLimit = contentGeneratorConfig.contextWindowSize ?? DEFAULT_TOKEN_LIMIT;
     if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES && !force) {
       return {
         newHistory: null,
@@ -35820,7 +35888,6 @@ var ChatCompressionService = class {
       };
     }
     if (!force) {
-      const contextLimit = config.getContentGeneratorConfig()?.contextWindowSize ?? DEFAULT_TOKEN_LIMIT;
       const { auto } = computeThresholds(
         contextLimit,
         config.getAutoCompactThreshold()
@@ -35901,12 +35968,11 @@ var ChatCompressionService = class {
       [opts.pendingUserMessage],
       slimmingConfig.imageTokenEstimate
     ) : 0;
-    const slim = slimCompactionInput(sideQueryHistory);
-    if (slim.stats.imagesStripped > 0 || slim.stats.documentsStripped > 0) {
-      config.getDebugLogger().debug(
-        `[chat-compression] slimmed ${slim.stats.imagesStripped} image(s) and ${slim.stats.documentsStripped} document(s) from side-query payload`
-      );
-    }
+    let coldInput;
+    const getColdInput = /* @__PURE__ */ __name(() => {
+      coldInput ??= slimCompactionInput(sideQueryHistory);
+      return coldInput;
+    }, "getColdInput");
     const systemInstruction = buildCompressionSystemPrompt(
       opts.customInstructions,
       hookExtraInstructions
@@ -35920,7 +35986,7 @@ var ChatCompressionService = class {
         const entry = models.find((m2) => m2.id === resolved.modelId);
         const window2 = entry?.contextWindowSize;
         const slimmedTokenEstimate = estimateContentTokens(
-          slim.slimmedHistory,
+          getColdInput().slimmedHistory,
           slimmingConfig.imageTokenEstimate
         ) + Math.ceil(systemInstruction.length / CHARS_PER_TOKEN) + COMPACT_MAX_OUTPUT_TOKENS;
         if (window2 && window2 > 0 && slimmedTokenEstimate > window2) {
@@ -35932,49 +35998,72 @@ var ChatCompressionService = class {
     }
     const abortSignal = signal ?? new AbortController().signal;
     abortSignal.throwIfAborted();
-    const runColdCompression = /* @__PURE__ */ __name(() => runSideQuery(config, {
-      purpose: "chat-compression",
-      skipOutputLanguagePreference: true,
-      model: effectiveCompactionModel,
-      // Compression uses the compaction model (config.getCompactionModel?.()) to reduce cost.
-      // Falls back to the main model if not set or if the payload exceeds the
-      // compaction model's context window.
-      // See https://github.com/QwenLM/qwen-code/issues/5956
-      // Stream so a slow compression inference keeps the HTTP connection alive.
-      // Non-streaming returns no bytes until the whole summary is generated, so
-      // behind a BFF gateway with a short `proxy_read_timeout` a long inference
-      // is killed with a 504 (surfaced as a 422) mid-compression, breaking the
-      // session. See https://github.com/QwenLM/qwen-code/issues/5861.
-      stream: true,
-      // Best-effort: failures fall back to NOOP and the next turn re-triggers
-      // compression anyway, so don't burn 7 retries blocking the user mid-turn.
-      maxAttempts: 1,
-      systemInstruction,
-      contents: [
-        ...slim.slimmedHistory,
-        {
-          role: "user",
-          parts: [
-            {
-              text: "First, reason in your <analysis> block. Then, produce the <state_snapshot> XML."
-            }
-          ]
-        }
-      ],
-      // Compression output is bounded by maxOutputTokens to guarantee a predictable
-      // reserve across providers (see docs/design/auto-compaction-threshold-redesign.md).
-      // Thinking is disabled because per-provider thinking-budget semantics are
-      // inconsistent (Anthropic/OpenAI count it separately, Gemini varies by model).
-      config: {
-        thinkingConfig: { includeThoughts: false },
-        maxOutputTokens: COMPACT_MAX_OUTPUT_TOKENS
-      },
-      abortSignal,
-      promptId
-    }), "runColdCompression");
+    const runColdCompression = /* @__PURE__ */ __name(() => {
+      const slim = getColdInput();
+      if (slim.stats.imagesStripped > 0 || slim.stats.documentsStripped > 0) {
+        config.getDebugLogger().debug(
+          `[chat-compression] slimmed ${slim.stats.imagesStripped} image(s) and ${slim.stats.documentsStripped} document(s) from side-query payload`
+        );
+      }
+      return runSideQuery(config, {
+        purpose: "chat-compression",
+        skipOutputLanguagePreference: true,
+        model: effectiveCompactionModel,
+        // Compression uses the compaction model (config.getCompactionModel?.()) to reduce cost.
+        // Falls back to the main model if not set or if the payload exceeds the
+        // compaction model's context window.
+        // See https://github.com/QwenLM/qwen-code/issues/5956
+        // Stream so a slow compression inference keeps the HTTP connection alive.
+        // Non-streaming returns no bytes until the whole summary is generated, so
+        // behind a BFF gateway with a short `proxy_read_timeout` a long inference
+        // is killed with a 504 (surfaced as a 422) mid-compression, breaking the
+        // session. See https://github.com/QwenLM/qwen-code/issues/5861.
+        stream: true,
+        // Best-effort: failures fall back to NOOP and the next turn re-triggers
+        // compression anyway, so don't burn 7 retries blocking the user mid-turn.
+        maxAttempts: 1,
+        systemInstruction,
+        contents: [
+          ...slim.slimmedHistory,
+          {
+            role: "user",
+            parts: [
+              {
+                text: COMPRESSION_REQUEST_DIRECTIVE
+              }
+            ]
+          }
+        ],
+        // Compression output is bounded by maxOutputTokens to guarantee a predictable
+        // reserve across providers (see docs/design/auto-compaction-threshold-redesign.md).
+        // Thinking is disabled because per-provider thinking-budget semantics are
+        // inconsistent (Anthropic/OpenAI count it separately, Gemini varies by model).
+        config: {
+          thinkingConfig: { includeThoughts: false },
+          maxOutputTokens: COMPACT_MAX_OUTPUT_TOKENS
+        },
+        abortSignal,
+        promptId
+      });
+    }, "runColdCompression");
     let summaryResult;
     let usedCacheSharing = false;
-    const canShareCache = effectiveCompactionModel === config.getModel() && slim.stats.imagesStripped === 0 && slim.stats.documentsStripped === 0 && supportsCompressionCacheSharing(config);
+    const sharedRequestText = `${systemInstruction}
+
+Do not call tools; tool execution is disabled for this request. ` + COMPRESSION_REQUEST_DIRECTIVE;
+    const sharedPromptTokenCount = opts.precomputedEffectiveTokens ?? originalTokenCount + (chat.getLastOutputTokenCount?.() ?? 0);
+    const sharedDirectiveTokenCount = Math.ceil(
+      sharedRequestText.length / CHARS_PER_TOKEN
+    );
+    const usesMainModel = effectiveCompactionModel === config.getModel();
+    const providerSupportsCacheSharing = supportsCompressionCacheSharing(config);
+    const hasProviderTokenCount = (chat.getLastPromptTokenCount?.() ?? 0) > 0;
+    const sharedRequestFits = sharedPromptTokenCount + sharedDirectiveTokenCount + COMPACT_MAX_OUTPUT_TOKENS <= contextLimit;
+    const canShareCache = usesMainModel && providerSupportsCacheSharing && hasProviderTokenCount && sharedRequestFits;
+    if (!canShareCache) {
+      const reason = !usesMainModel ? "distinct compaction model" : !providerSupportsCacheSharing ? "provider does not support cache sharing" : !hasProviderTokenCount ? "no provider token-count anchor" : `shared request exceeds context window: prompt=${sharedPromptTokenCount}, directive=${sharedDirectiveTokenCount}, reserve=${COMPACT_MAX_OUTPUT_TOKENS}, window=${contextLimit}`;
+      debugLogger20.debug(`[compaction] skipping cache sharing: ${reason}`);
+    }
     if (canShareCache) {
       try {
         const generationConfig = {
@@ -35991,9 +36080,7 @@ var ChatCompressionService = class {
               role: "user",
               parts: [
                 {
-                  text: `${systemInstruction}
-
-Do not call tools; tool execution is disabled for this request. First, reason in your <analysis> block. Then, produce the <state_snapshot> XML.`
+                  text: sharedRequestText
                 }
               ]
             }
@@ -36002,7 +36089,7 @@ Do not call tools; tool execution is disabled for this request. First, reason in
           systemInstruction: mainSystemInstruction,
           config: {
             ...generationConfig,
-            ...config.getContentGeneratorConfig().authType === "anthropic" /* USE_ANTHROPIC */ ? {
+            ...contentGeneratorConfig.authType === "anthropic" /* USE_ANTHROPIC */ ? {
               thinkingConfig: {
                 ...generationConfig.thinkingConfig,
                 // Manual Anthropic thinking requires budget_tokens to be
@@ -37723,6 +37810,10 @@ var GeminiChat = class {
   getLastPromptTokenCount() {
     return this.lastPromptTokenCount;
   }
+  /** Previous model-response tokens used by the next prompt estimate. */
+  getLastOutputTokenCount() {
+    return this.lastOutputTokenCount;
+  }
   /**
    * Builds request contents for the content generator without deep-cloning the
    * whole chat history. This is an internal hot path: long sessions can make a
@@ -38434,6 +38525,7 @@ var GeminiChat = class {
                     params.config?.abortSignal,
                     {
                       originalTokenCountOverride: reactiveOriginalTokenCount,
+                      precomputedEffectiveTokens: reactiveOriginalTokenCount,
                       requestGenerationConfig: params.config,
                       trigger: "auto"
                     }
@@ -52240,7 +52332,12 @@ async function evaluateToolInvocationGuard(guard, context2) {
     });
     const decision = await guard({
       ...context2,
-      args: structuredClone(context2.args)
+      args: structuredClone(context2.args),
+      ...context2.invocationContext ? {
+        invocationContext: Object.freeze({
+          ...context2.invocationContext
+        })
+      } : {}
     });
     if (context2.signal.aborted) {
       return { allowed: false, reason: FAILED_MESSAGE };
@@ -74585,16 +74682,6 @@ __name(toReadTextFileResponse, "toReadTextFileResponse");
 // packages/core/src/tools/priorReadEnforcement.ts
 init_esbuild_shims();
 import * as fs26 from "node:fs";
-var StructuredToolError = class extends Error {
-  constructor(message, errorType) {
-    super(message);
-    this.errorType = errorType;
-  }
-  static {
-    __name(this, "StructuredToolError");
-  }
-  name = "StructuredToolError";
-};
 async function checkPriorRead(cache, filePath, verb, options2 = {}) {
   let stats;
   try {
@@ -75120,7 +75207,7 @@ var WriteFileTool = class _WriteFileTool extends BaseDeclarativeTool {
     super(
       _WriteFileTool.Name,
       ToolDisplayNames.WRITE_FILE,
-      `Writes content to a specified file in the local filesystem. The file_path argument MUST be an absolute path. Always construct it by combining the project root with the file's relative path (e.g. project root '/path/to/project/' + relative 'foo/bar.txt' = '/path/to/project/foo/bar.txt'). If the user provides a relative path, resolve it against the project root first.
+      `Writes content to a specified file in the local filesystem. A request to create or generate a file does not establish that the target path is new. Unless the target's absence or current text contents have already been established in this session, you MUST use the ${ToolNames.READ_FILE} tool first; if the file does not exist, then create it. With prior-read enforcement enabled, blind overwrites are rejected. The file_path argument MUST be an absolute path. Always construct it by combining the project root with the file's relative path (e.g. project root '/path/to/project/' + relative 'foo/bar.txt' = '/path/to/project/foo/bar.txt'). If the user provides a relative path, resolve it against the project root first.
 
 The user has the ability to modify \`content\`. If modified, this will be stated in the response.`,
       "edit" /* Edit */,
@@ -114599,13 +114686,15 @@ async function runSpeculativeLoop(config, state, cacheSafe, modelOverride) {
           const invocation = tool.build(args);
           const toolInvocationGuard = config.getToolInvocationGuard?.();
           if (toolInvocationGuard) {
+            const invocationContext = getInvocationContext();
             const guardDecision = await evaluateToolInvocationGuard(
               toolInvocationGuard,
               {
                 callId: persistenceCallId,
                 toolName: canonicalToolName2(name),
                 args: invocation.params,
-                signal: state.abortController.signal
+                signal: state.abortController.signal,
+                ...invocationContext ? { invocationContext } : {}
               }
             );
             if (state.abortController.signal.aborted) {
@@ -130612,18 +130701,6 @@ function extractTextFromPartListUnion(c) {
   return "";
 }
 __name(extractTextFromPartListUnion, "extractTextFromPartListUnion");
-var TOOL_FAILURE_KIND_ATTRIBUTE = "tool.failure_kind";
-var TOOL_FAILURE_KIND_PRE_HOOK_BLOCKED = "pre_hook_blocked";
-var TOOL_FAILURE_KIND_INVOCATION_GUARD_DENIED = "invocation_guard_denied";
-var TOOL_FAILURE_KIND_POST_HOOK_STOPPED = "post_hook_stopped";
-var TOOL_FAILURE_KIND_TOOL_ERROR = "tool_error";
-var TOOL_FAILURE_KIND_TOOL_EXCEPTION = "tool_exception";
-var TOOL_FAILURE_KIND_CANCELLED = "cancelled";
-var TOOL_FAILURE_KIND_PERMISSION_DENIED = "permission_denied";
-var TOOL_FAILURE_KIND_PERMISSION_HOOK_DENIED = "permission_hook_denied";
-var TOOL_FAILURE_KIND_PLAN_MODE_BLOCKED = "plan_mode_blocked";
-var TOOL_FAILURE_KIND_NON_INTERACTIVE_DENIED = "non_interactive_denied";
-var TOOL_FAILURE_KIND_BACKGROUND_AGENT_DENIED = "background_agent_denied";
 var TOOL_SPAN_STATUS_PRE_HOOK_BLOCKED = "Tool execution blocked by hook";
 var TOOL_SPAN_STATUS_INVOCATION_GUARD_DENIED = "Tool execution blocked by host policy";
 var TOOL_SPAN_STATUS_POST_HOOK_STOPPED = "Tool execution stopped by hook";
@@ -130635,8 +130712,9 @@ var TOOL_SPAN_STATUS_BACKGROUND_AGENT_DENIED = "Background agent cannot prompt f
 var TOOL_SPAN_STATUS_TOOL_ERROR = "Tool execution failed";
 var TOOL_SPAN_STATUS_TOOL_EXCEPTION = "Tool execution failed with exception";
 var TOOL_SPAN_STATUS_TOOL_CANCELLED = "Tool execution cancelled by user";
-var TOOL_FAILURE_KIND_TIMEOUT = "timeout";
 var TOOL_SPAN_STATUS_TOOL_TIMEOUT = "Tool execution timed out";
+var TOOL_CANCELLED_BEFORE_COMPLETION_MESSAGE = "User cancelled tool execution.";
+var TOOL_CANCELLED_AFTER_COMPLETION_MESSAGE = "The tool had already completed; its output was discarded.";
 function createToolTimeoutResult(timeoutMs) {
   const display = timeoutMs >= 1e3 ? `${Math.round(timeoutMs / 1e3)}s` : `${timeoutMs}ms`;
   const message = `Tool execution timed out after ${display}. The tool may be stuck or operating on too large a scope.`;
@@ -130914,7 +130992,7 @@ __name(toParts2, "toParts");
 var VALIDATION_RETRY_LOOP_THRESHOLD = 3;
 var RETRY_LOOP_STOP_DIRECTIVE = "\n\n\u26A0 RETRY LOOP DETECTED: This tool call has failed validation multiple times with the same error. STOP retrying the same approach. Re-examine the tool schema and parameter requirements, then try a fundamentally different approach. If you cannot resolve the validation error, explain the issue to the user instead of retrying.";
 var TRUNCATION_RETRY_LOOP_DIRECTIVE = "\n\n\u26A0 RETRY LOOP DETECTED: The same truncated file write has been rejected multiple times. STOP resending the same large content. Either split it into smaller write_file + incremental edit calls, or explain to the user that the content is too large to write safely in one call.";
-var createErrorResponse = /* @__PURE__ */ __name((request, error, errorType, artifacts, resultDisplay) => ({
+var createErrorResponse = /* @__PURE__ */ __name((request, error, errorType, executionStatus, artifacts, resultDisplay) => ({
   callId: request.callId,
   error,
   responseParts: [
@@ -130928,10 +131006,11 @@ var createErrorResponse = /* @__PURE__ */ __name((request, error, errorType, art
   ],
   resultDisplay: resultDisplay ?? error.message,
   errorType,
+  executionStatus,
   contentLength: error.message.length,
   ...artifacts && artifacts.length > 0 ? { artifacts } : {}
 }), "createErrorResponse");
-var createCancelledResponse = /* @__PURE__ */ __name((request, reason, artifacts) => {
+var createCancelledResponse = /* @__PURE__ */ __name((request, reason, executionStatus, artifacts, persistedOutputFiles, visionBridgeNotice) => {
   const errorMessage = `[Operation Cancelled] Reason: ${reason}`;
   return {
     callId: request.callId,
@@ -130947,8 +131026,11 @@ var createCancelledResponse = /* @__PURE__ */ __name((request, reason, artifacts
     resultDisplay: void 0,
     error: void 0,
     errorType: void 0,
+    executionStatus,
     contentLength: errorMessage.length,
-    ...artifacts && artifacts.length > 0 ? { artifacts } : {}
+    ...artifacts && artifacts.length > 0 ? { artifacts } : {},
+    ...persistedOutputFiles !== void 0 ? { persistedOutputFiles } : {},
+    ...visionBridgeNotice !== void 0 ? { visionBridgeNotice } : {}
   };
 }, "createCancelledResponse");
 function isToolCallResponseInfo(value) {
@@ -130965,6 +131047,7 @@ function serializeToolResponse(response) {
     result_display: response.resultDisplay,
     error: response.error?.message,
     error_type: response.errorType,
+    execution_status: response.executionStatus,
     content_length: response.contentLength,
     ...response.visionBridgeNotice !== void 0 ? { vision_bridge_notice: response.visionBridgeNotice } : {}
   };
@@ -131097,15 +131180,19 @@ function withPostToolBatchStop(completedCalls, stopReason) {
   }
   const calls = [...completedCalls];
   const lastCall = calls[calls.length - 1];
+  const executionStatus = lastCall.response.executionStatus;
+  const { executionStatus: _es, ...baseResponse } = createErrorResponse(
+    lastCall.request,
+    new Error(stopReason),
+    "execution_denied" /* EXECUTION_DENIED */,
+    executionStatus ?? "not_started"
+  );
+  const response = executionStatus !== void 0 ? { ...baseResponse, executionStatus } : baseResponse;
   calls[calls.length - 1] = {
     status: "error",
     request: lastCall.request,
     tool: lastCall.tool,
-    response: createErrorResponse(
-      lastCall.request,
-      new Error(stopReason),
-      "execution_denied" /* EXECUTION_DENIED */
-    ),
+    response,
     durationMs: lastCall.durationMs,
     outcome: void 0
   };
@@ -131167,6 +131254,9 @@ var CoreToolScheduler = class {
   chatRecordingService;
   onToolResultFullTurnModel;
   isFinalizingToolCalls = false;
+  postToolBatchEnabledForBatch = false;
+  postToolBatchSpanCallId;
+  postToolBatchConfigWarned = false;
   isScheduling = false;
   validationRetryCounts = /* @__PURE__ */ new Map();
   autoModeFallbackCallIds = /* @__PURE__ */ new Set();
@@ -131249,7 +131339,7 @@ var CoreToolScheduler = class {
       ...notices.length > 0 ? { visionBridgeNotice: notices.join("\n") } : {}
     };
   }
-  setStatusInternal(targetCallId, newStatus, auxiliaryData) {
+  setStatusInternal(targetCallId, newStatus, auxiliaryData, executionStatus) {
     this.toolCalls = this.toolCalls.map((currentCall) => {
       if (currentCall.request.callId !== targetCallId || currentCall.status === "success" || currentCall.status === "error" || currentCall.status === "cancelled") {
         return currentCall;
@@ -131330,8 +131420,11 @@ var CoreToolScheduler = class {
           }
           const preservedResultDisplay = this.compactResultDisplayForInteractiveHistory(resultDisplay);
           const errorMessage = `[Operation Cancelled] Reason: ${auxiliaryData}`;
-          const response = isToolCallResponseInfo(auxiliaryData) ? {
+          const response = isToolCallResponseInfo(
+            auxiliaryData
+          ) ? {
             ...auxiliaryData,
+            executionStatus: auxiliaryData.executionStatus ?? executionStatus ?? "not_started",
             resultDisplay: auxiliaryData.resultDisplay ?? preservedResultDisplay
           } : {
             callId: currentCall.request.callId,
@@ -131349,6 +131442,7 @@ var CoreToolScheduler = class {
             resultDisplay: preservedResultDisplay,
             error: void 0,
             errorType: void 0,
+            executionStatus: executionStatus ?? "not_started",
             contentLength: errorMessage.length
           };
           return {
@@ -131394,8 +131488,10 @@ var CoreToolScheduler = class {
     });
   }
   setArgsInternal(targetCallId, args) {
+    let invocationError;
+    let argsUpdated = false;
     this.toolCalls = this.toolCalls.map((call) => {
-      if (call.request.callId !== targetCallId || call.status === "error") {
+      if (call.request.callId !== targetCallId || call.status === "success" || call.status === "error" || call.status === "cancelled") {
         return call;
       }
       const invocationOrError = runInRequestGoalContext(
@@ -131408,10 +131504,12 @@ var CoreToolScheduler = class {
         )
       );
       if (invocationOrError instanceof Error) {
+        invocationError = invocationOrError;
         const response = createErrorResponse(
           call.request,
           invocationOrError,
-          "invalid_tool_params" /* INVALID_TOOL_PARAMS */
+          "invalid_tool_params" /* INVALID_TOOL_PARAMS */,
+          "not_started"
         );
         return {
           request: { ...call.request, args },
@@ -131420,18 +131518,54 @@ var CoreToolScheduler = class {
           response
         };
       }
+      argsUpdated = true;
       return {
         ...call,
         request: { ...call.request, args },
         invocation: invocationOrError
       };
     });
+    if (invocationError) {
+      this.finalizeBlockedSpan(targetCallId, "error", "system");
+      const toolSpan = this.toolSpans.get(targetCallId);
+      if (toolSpan) {
+        setToolSpanFailure(
+          toolSpan,
+          TOOL_FAILURE_KIND_TOOL_EXCEPTION,
+          invocationError.message
+        );
+      }
+      this.finalizeToolSpan(targetCallId);
+      this.notifyToolCallsUpdate();
+      void this.checkAndNotifyCompletion().catch((error) => {
+        debugLogger122.warn(
+          `setArgsInternal completion notification failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      });
+      return false;
+    }
+    return argsUpdated;
   }
   isRunning() {
     return this.isFinalizingToolCalls || this.toolCalls.some(
       (call) => call.status === "executing" || call.status === "awaiting_approval"
     );
   }
+  cancelPreExecutionIfAborted(callId, signal, toolSpan = this.toolSpans.get(callId)) {
+    if (!signal.aborted) return false;
+    this.setStatusInternal(
+      callId,
+      "cancelled",
+      "Tool call cancelled by user.",
+      "not_started"
+    );
+    this.finalizeBlockedSpan(callId, "aborted", "system");
+    if (toolSpan) {
+      setToolSpanCancelled(toolSpan);
+    }
+    this.finalizeToolSpan(callId);
+    return true;
+  }
   /**
    * End the tool span for `callId` (if any) and remove it from the map.
    * Centralizes terminal-state cleanup so every cancel/error/success path
@@ -131441,10 +131575,12 @@ var CoreToolScheduler = class {
    * No `metadata` parameter: every caller pre-sets span status via
    * `setToolSpan{Failure,Cancelled,Ok}` before this call (#4321 review).
    */
-  finalizeToolSpan(callId) {
+  finalizeToolSpan(callId, force = false) {
     this.bouncedAwaitingApproval.delete(callId);
     this.bouncedToolUseId.delete(callId);
+    this.autoModeFallbackCallIds.delete(callId);
     this.runtimeContentGeneratorViews.delete(callId);
+    if (callId === this.postToolBatchSpanCallId && !force) return;
     const span = this.toolSpans.get(callId);
     if (!span) return;
     this.toolSpans.delete(callId);
@@ -131521,7 +131657,8 @@ var CoreToolScheduler = class {
           this.setStatusInternal(
             callId,
             "cancelled",
-            "Tool call cancelled by user."
+            "Tool call cancelled by user.",
+            "not_started"
           );
           if (this.blockedSpans.has(callId)) {
             this.finalizeBlockedSpan(callId, "aborted", "system");
@@ -131529,7 +131666,7 @@ var CoreToolScheduler = class {
           const span = this.toolSpans.get(callId);
           if (span) {
             setToolSpanCancelled(span);
-            this.finalizeToolSpan(callId);
+            this.finalizeToolSpan(callId, true);
           }
           this.callIdToPostToolBatchSignal.delete(callId);
           this.autoModeFallbackCallIds.delete(callId);
@@ -131729,6 +131866,13 @@ var CoreToolScheduler = class {
     }
     return this._schedule(request, signal, runtimeView);
   }
+  drainRequestQueueIfIdle() {
+    if (this.requestQueue.length === 0 || this.isScheduling || this.isRunning()) {
+      return;
+    }
+    const next = this.requestQueue.shift();
+    this._schedule(next.request, next.signal, next.runtimeView).then(next.resolve).catch(next.reject);
+  }
   /**
    * Removes all validation retry counters for the given tool. Keys are
    * "<toolName>:<errorMessage>", so a plain `Map.delete(toolName)` would not
@@ -131820,147 +131964,220 @@ var CoreToolScheduler = class {
         return count;
       }, "recordBatchRetryableToolError");
       for (const [requestIndex, reqInfo] of requestsToProcess.entries()) {
-        if (planModeEntryBoundaryIndex !== void 0 && requestIndex !== planModeEntryBoundaryIndex) {
+        let resolvedTool;
+        let resolvedInvocation;
+        const recordPrevalidationCancellation = /* @__PURE__ */ __name(() => {
+          if (!signal.aborted) return false;
           newToolCalls.push({
-            status: "error",
-            request: reqInfo,
-            response: createErrorResponse(
-              reqInfo,
-              new Error(PLAN_MODE_ENTRY_SIBLING_SKIP_MESSAGE),
-              "execution_denied" /* EXECUTION_DENIED */
-            ),
-            durationMs: 0
-          });
-          continue;
-        }
-        const canonicalName = canonicalToolName2(reqInfo.name);
-        const pm = this.config.getPermissionManager?.();
-        if (pm && !await pm.isToolEnabled(canonicalName)) {
-          const matchingRule = pm.findMatchingDenyRule({
-            toolName: canonicalName
-          });
-          const ruleInfo = matchingRule ? ` Matching deny rule: "${matchingRule}".` : "";
-          const permissionErrorMessage = `Qwen Code requires permission to use "${reqInfo.name}", but that permission was declined.${ruleInfo}`;
-          newToolCalls.push({
-            status: "error",
+            status: "cancelled",
             request: reqInfo,
-            response: createErrorResponse(
+            response: createCancelledResponse(
               reqInfo,
-              new Error(permissionErrorMessage),
-              "execution_denied" /* EXECUTION_DENIED */
+              "Tool call cancelled before execution.",
+              "not_started"
             ),
+            ...resolvedTool ? { tool: resolvedTool } : {},
+            ...resolvedInvocation ? { invocation: resolvedInvocation } : {},
             durationMs: 0
           });
-          continue;
-        }
-        if (!pm) {
-          const excludeTools = this.config.getPermissionsDeny?.() ?? void 0;
-          if (excludeTools && excludeTools.length > 0) {
-            const normalizedToolName = canonicalName.toLowerCase().trim();
-            const excludedMatch = excludeTools.find(
-              (excludedTool) => excludedTool.toLowerCase().trim() === normalizedToolName
-            );
-            if (excludedMatch) {
-              const permissionErrorMessage = `Qwen Code requires permission to use ${excludedMatch}, but that permission was declined.`;
-              newToolCalls.push({
-                status: "error",
-                request: reqInfo,
-                response: createErrorResponse(
-                  reqInfo,
-                  new Error(permissionErrorMessage),
-                  "execution_denied" /* EXECUTION_DENIED */
-                ),
-                durationMs: 0
-              });
-              continue;
+          return true;
+        }, "recordPrevalidationCancellation");
+        try {
+          if (recordPrevalidationCancellation()) continue;
+          if (planModeEntryBoundaryIndex !== void 0 && requestIndex !== planModeEntryBoundaryIndex) {
+            newToolCalls.push({
+              status: "error",
+              request: reqInfo,
+              response: createErrorResponse(
+                reqInfo,
+                new Error(PLAN_MODE_ENTRY_SIBLING_SKIP_MESSAGE),
+                "execution_denied" /* EXECUTION_DENIED */,
+                "not_started"
+              ),
+              durationMs: 0
+            });
+            continue;
+          }
+          const canonicalName = canonicalToolName2(reqInfo.name);
+          const pm = this.config.getPermissionManager?.();
+          const permissionEnabled = pm ? await pm.isToolEnabled(canonicalName) : true;
+          if (recordPrevalidationCancellation()) continue;
+          if (pm && !permissionEnabled) {
+            const matchingRule = pm.findMatchingDenyRule({
+              toolName: canonicalName
+            });
+            const ruleInfo = matchingRule ? ` Matching deny rule: "${matchingRule}".` : "";
+            const permissionErrorMessage = `Qwen Code requires permission to use "${reqInfo.name}", but that permission was declined.${ruleInfo}`;
+            newToolCalls.push({
+              status: "error",
+              request: reqInfo,
+              response: createErrorResponse(
+                reqInfo,
+                new Error(permissionErrorMessage),
+                "execution_denied" /* EXECUTION_DENIED */,
+                "not_started"
+              ),
+              durationMs: 0
+            });
+            continue;
+          }
+          if (!pm) {
+            const excludeTools = this.config.getPermissionsDeny?.() ?? void 0;
+            if (excludeTools && excludeTools.length > 0) {
+              const normalizedToolName = canonicalName.toLowerCase().trim();
+              const excludedMatch = excludeTools.find(
+                (excludedTool) => excludedTool.toLowerCase().trim() === normalizedToolName
+              );
+              if (excludedMatch) {
+                const permissionErrorMessage = `Qwen Code requires permission to use ${excludedMatch}, but that permission was declined.`;
+                newToolCalls.push({
+                  status: "error",
+                  request: reqInfo,
+                  response: createErrorResponse(
+                    reqInfo,
+                    new Error(permissionErrorMessage),
+                    "execution_denied" /* EXECUTION_DENIED */,
+                    "not_started"
+                  ),
+                  durationMs: 0
+                });
+                continue;
+              }
             }
           }
-        }
-        const toolInstance = await runInRequestGoalContext(
-          reqInfo,
-          () => this.toolRegistry.ensureTool(canonicalName)
-        );
-        if (!toolInstance) {
-          const errorMessage = await runInRequestGoalContext(
+          const toolInstance = await runInRequestGoalContext(
             reqInfo,
-            () => this.getToolNotFoundMessage(reqInfo.name)
+            () => this.toolRegistry.ensureTool(canonicalName)
           );
-          newToolCalls.push({
-            status: "error",
-            request: reqInfo,
-            response: createErrorResponse(
+          resolvedTool = toolInstance;
+          if (recordPrevalidationCancellation()) continue;
+          if (!toolInstance) {
+            const errorMessage = await runInRequestGoalContext(
               reqInfo,
-              new Error(errorMessage),
-              "tool_not_registered" /* TOOL_NOT_REGISTERED */
-            ),
-            durationMs: 0
-          });
-          continue;
-        }
-        if (reqInfo.wasOutputTruncated && toolInstance.kind === "edit" /* Edit */) {
-          const count = recordBatchRetryableToolError(
-            reqInfo.name,
-            TRUNCATION_EDIT_REJECTION
-          );
-          const truncationError = new Error(
-            count >= VALIDATION_RETRY_LOOP_THRESHOLD ? `${TRUNCATION_EDIT_REJECTION}${TRUNCATION_RETRY_LOOP_DIRECTIVE}` : TRUNCATION_EDIT_REJECTION
+              () => this.getToolNotFoundMessage(reqInfo.name)
+            );
+            if (recordPrevalidationCancellation()) continue;
+            newToolCalls.push({
+              status: "error",
+              request: reqInfo,
+              response: createErrorResponse(
+                reqInfo,
+                new Error(errorMessage),
+                "tool_not_registered" /* TOOL_NOT_REGISTERED */,
+                "not_started"
+              ),
+              durationMs: 0
+            });
+            continue;
+          }
+          if (reqInfo.wasOutputTruncated && toolInstance.kind === "edit" /* Edit */) {
+            const count = recordBatchRetryableToolError(
+              reqInfo.name,
+              TRUNCATION_EDIT_REJECTION
+            );
+            const truncationError = new Error(
+              count >= VALIDATION_RETRY_LOOP_THRESHOLD ? `${TRUNCATION_EDIT_REJECTION}${TRUNCATION_RETRY_LOOP_DIRECTIVE}` : TRUNCATION_EDIT_REJECTION
+            );
+            newToolCalls.push({
+              status: "error",
+              request: reqInfo,
+              tool: toolInstance,
+              response: createErrorResponse(
+                reqInfo,
+                truncationError,
+                "output_truncated" /* OUTPUT_TRUNCATED */,
+                "not_started"
+              ),
+              durationMs: 0
+            });
+            continue;
+          }
+          const invocationOrError = runInRequestGoalContext(
+            reqInfo,
+            () => this.buildInvocation(
+              toolInstance,
+              reqInfo.args,
+              reqInfo.callId,
+              reqInfo.prompt_id
+            )
           );
+          if (recordPrevalidationCancellation()) continue;
+          if (invocationOrError instanceof Error) {
+            const displayError = reqInfo.wasOutputTruncated ? new Error(
+              `${invocationOrError.message} ${TRUNCATION_PARAM_GUIDANCE}`
+            ) : invocationOrError;
+            const count = recordBatchRetryableToolError(
+              reqInfo.name,
+              invocationOrError.message
+            );
+            const finalError = count >= VALIDATION_RETRY_LOOP_THRESHOLD ? new Error(
+              `${invocationOrError.message}${RETRY_LOOP_STOP_DIRECTIVE}`
+            ) : displayError;
+            newToolCalls.push({
+              status: "error",
+              request: reqInfo,
+              tool: toolInstance,
+              response: createErrorResponse(
+                reqInfo,
+                finalError,
+                "invalid_tool_params" /* INVALID_TOOL_PARAMS */,
+                "not_started"
+              ),
+              durationMs: 0
+            });
+            continue;
+          }
+          resolvedInvocation = invocationOrError;
+          this.clearRetryCountsForTool(reqInfo.name);
           newToolCalls.push({
-            status: "error",
+            status: "validating",
             request: reqInfo,
             tool: toolInstance,
-            response: createErrorResponse(
-              reqInfo,
-              truncationError,
-              "output_truncated" /* OUTPUT_TRUNCATED */
-            ),
-            durationMs: 0
+            invocation: invocationOrError,
+            startTime: Date.now()
           });
-          continue;
-        }
-        const invocationOrError = runInRequestGoalContext(
-          reqInfo,
-          () => this.buildInvocation(
-            toolInstance,
-            reqInfo.args,
-            reqInfo.callId,
-            reqInfo.prompt_id
-          )
-        );
-        if (invocationOrError instanceof Error) {
-          const displayError = reqInfo.wasOutputTruncated ? new Error(
-            `${invocationOrError.message} ${TRUNCATION_PARAM_GUIDANCE}`
-          ) : invocationOrError;
-          const count = recordBatchRetryableToolError(
-            reqInfo.name,
-            invocationOrError.message
-          );
-          const finalError = count >= VALIDATION_RETRY_LOOP_THRESHOLD ? new Error(
-            `${invocationOrError.message}${RETRY_LOOP_STOP_DIRECTIVE}`
-          ) : displayError;
+        } catch (error) {
+          if (recordPrevalidationCancellation()) continue;
+          const normalizedError = error instanceof Error ? error : new Error(String(error));
           newToolCalls.push({
             status: "error",
             request: reqInfo,
-            tool: toolInstance,
             response: createErrorResponse(
               reqInfo,
-              finalError,
-              "invalid_tool_params" /* INVALID_TOOL_PARAMS */
+              normalizedError,
+              error?.errorType ?? "unhandled_exception" /* UNHANDLED_EXCEPTION */,
+              "not_started"
             ),
+            ...resolvedTool ? { tool: resolvedTool } : {},
             durationMs: 0
           });
-          continue;
         }
-        this.clearRetryCountsForTool(reqInfo.name);
-        newToolCalls.push({
-          status: "validating",
-          request: reqInfo,
-          tool: toolInstance,
-          invocation: invocationOrError,
-          startTime: Date.now()
-        });
       }
       this.toolCalls = this.toolCalls.concat(newToolCalls);
+      for (const toolCall of newToolCalls) {
+        this.callIdToPostToolBatchSignal.set(toolCall.request.callId, signal);
+      }
+      const postToolBatchParentCallId = newToolCalls.findLast(
+        (toolCall) => toolCall.status === "validating"
+      )?.request.callId;
+      this.postToolBatchEnabledForBatch = false;
+      this.postToolBatchSpanCallId = void 0;
+      try {
+        this.postToolBatchEnabledForBatch = !this.config.getDisableAllHooks() && (this.config.hasHooksForEvent?.("PostToolBatch") ?? false);
+        if (this.postToolBatchEnabledForBatch) {
+          this.postToolBatchSpanCallId = postToolBatchParentCallId;
+        }
+      } catch (configError) {
+        this.postToolBatchEnabledForBatch = true;
+        this.postToolBatchSpanCallId = postToolBatchParentCallId;
+        if (!this.postToolBatchConfigWarned) {
+          this.postToolBatchConfigWarned = true;
+          debugLogger122.warn(
+            "PostToolBatch hook detection failed; deferring span as a precaution:",
+            configError
+          );
+        }
+      }
       this.notifyToolCallsUpdate();
       const batchState = {
         signal,
@@ -131988,16 +132205,8 @@ var CoreToolScheduler = class {
         this.toolSpans.set(reqInfo.callId, toolSpan);
         batchState.callIds.add(reqInfo.callId);
         this.callIdToBatch.set(reqInfo.callId, batchState);
-        this.callIdToPostToolBatchSignal.set(reqInfo.callId, signal);
         try {
-          if (signal.aborted) {
-            this.setStatusInternal(
-              reqInfo.callId,
-              "cancelled",
-              "Tool call cancelled by user."
-            );
-            setToolSpanCancelled(toolSpan);
-            this.finalizeToolSpan(reqInfo.callId);
+          if (this.cancelPreExecutionIfAborted(reqInfo.callId, signal, toolSpan)) {
             continue;
           }
           let toolParams = invocation.params;
@@ -132010,6 +132219,9 @@ var CoreToolScheduler = class {
               toolParams
             )
           );
+          if (this.cancelPreExecutionIfAborted(reqInfo.callId, signal, toolSpan)) {
+            continue;
+          }
           const {
             defaultPermission,
             finalPermission,
@@ -132054,7 +132266,8 @@ var CoreToolScheduler = class {
               createErrorResponse(
                 reqInfo,
                 new Error(message),
-                "execution_denied" /* EXECUTION_DENIED */
+                "execution_denied" /* EXECUTION_DENIED */,
+                "not_started"
               )
             );
             setToolSpanFailure(
@@ -132072,7 +132285,8 @@ var CoreToolScheduler = class {
               createErrorResponse(
                 reqInfo,
                 new Error(denyMessage ?? `Tool "${reqInfo.name}" is denied.`),
-                "execution_denied" /* EXECUTION_DENIED */
+                "execution_denied" /* EXECUTION_DENIED */,
+                "not_started"
               )
             );
             setToolSpanFailure(
@@ -132105,12 +132319,16 @@ var CoreToolScheduler = class {
               signal
             })
           ) : { classification: "not-applicable" };
+          if (this.cancelPreExecutionIfAborted(reqInfo.callId, signal, toolSpan)) {
+            continue;
+          }
           const rejectPlanShell = /* @__PURE__ */ __name((message) => {
             this.setStatusInternal(reqInfo.callId, "error", {
               ...createErrorResponse(
                 reqInfo,
                 new Error(message),
-                "execution_denied" /* EXECUTION_DENIED */
+                "execution_denied" /* EXECUTION_DENIED */,
+                "not_started"
               ),
               resultDisplay: message
             });
@@ -132132,6 +132350,9 @@ var CoreToolScheduler = class {
                 signal
               })
             );
+            if (this.cancelPreExecutionIfAborted(reqInfo.callId, signal, toolSpan)) {
+              continue;
+            }
             if (initialPlanShellError) {
               rejectPlanShell(initialPlanShellError);
               continue;
@@ -132172,6 +132393,9 @@ var CoreToolScheduler = class {
                 skipClassifierReason: fallback.fallback ? fallback.reason : void 0
               })
             );
+            if (this.cancelPreExecutionIfAborted(reqInfo.callId, signal, toolSpan)) {
+              continue;
+            }
             const outcome = applyAutoModeDecision(
               decision,
               this.config,
@@ -132196,6 +132420,9 @@ var CoreToolScheduler = class {
                 );
               }
             }
+            if (this.cancelPreExecutionIfAborted(reqInfo.callId, signal, toolSpan)) {
+              continue;
+            }
             switch (outcome.kind) {
               case "approved":
                 this.setToolCallOutcome(
@@ -132214,9 +132441,16 @@ var CoreToolScheduler = class {
                   createErrorResponse(
                     reqInfo,
                     new Error(outcome.errorMessage),
-                    "execution_denied" /* EXECUTION_DENIED */
+                    "execution_denied" /* EXECUTION_DENIED */,
+                    "not_started"
                   )
                 );
+                setToolSpanFailure(
+                  toolSpan,
+                  TOOL_FAILURE_KIND_PERMISSION_DENIED,
+                  outcome.errorMessage
+                );
+                this.finalizeToolSpan(reqInfo.callId);
                 continue;
               case "fallback":
                 if (isDenialFallbackReason(outcome.reason) || outcome.reason === "classifier_unavailable") {
@@ -132251,6 +132485,9 @@ var CoreToolScheduler = class {
               reqInfo,
               () => invocation.getConfirmationDetails(signal)
             );
+            if (this.cancelPreExecutionIfAborted(reqInfo.callId, signal, toolSpan)) {
+              continue;
+            }
             if (autoModeFallbackMessage) {
               confirmationDetails = decorateClassifierUnavailableConfirmation(
                 confirmationDetails,
@@ -132268,6 +132505,13 @@ var CoreToolScheduler = class {
                   signal
                 })
               );
+              if (this.cancelPreExecutionIfAborted(
+                reqInfo.callId,
+                signal,
+                toolSpan
+              )) {
+                continue;
+              }
               if (preDisplayPlanShellError) {
                 rejectPlanShell(preDisplayPlanShellError);
                 continue;
@@ -132301,7 +132545,8 @@ var CoreToolScheduler = class {
                 ...createErrorResponse(
                   reqInfo,
                   planModeError,
-                  "execution_denied" /* EXECUTION_DENIED */
+                  "execution_denied" /* EXECUTION_DENIED */,
+                  "not_started"
                 ),
                 resultDisplay: "Plan mode blocked a non-read-only tool call."
               });
@@ -132334,7 +132579,8 @@ var CoreToolScheduler = class {
                 createErrorResponse(
                   reqInfo,
                   new Error(errorMessage),
-                  "execution_denied" /* EXECUTION_DENIED */
+                  "execution_denied" /* EXECUTION_DENIED */,
+                  "not_started"
                 )
               );
               setToolSpanFailure(
@@ -132361,6 +132607,13 @@ var CoreToolScheduler = class {
                   signal
                 )
               );
+              if (this.cancelPreExecutionIfAborted(
+                reqInfo.callId,
+                signal,
+                toolSpan
+              )) {
+                continue;
+              }
               if (hookResult.hasDecision && (!hookResult.shouldAllow || !requiresUserInteraction)) {
                 if (hookResult.shouldAllow) {
                   if (planShellDecision.classification !== "not-applicable") {
@@ -132376,6 +132629,13 @@ var CoreToolScheduler = class {
                         payload: hookResult.updatedInput ? { updatedInput: hookResult.updatedInput } : void 0
                       })
                     );
+                    if (this.cancelPreExecutionIfAborted(
+                      reqInfo.callId,
+                      signal,
+                      toolSpan
+                    )) {
+                      continue;
+                    }
                     if (approval.outcome === "cancel" /* Cancel */) {
                       await runInRequestGoalContext(
                         reqInfo,
@@ -132384,6 +132644,13 @@ var CoreToolScheduler = class {
                           approval.payload
                         )
                       );
+                      if (this.cancelPreExecutionIfAborted(
+                        reqInfo.callId,
+                        signal,
+                        toolSpan
+                      )) {
+                        continue;
+                      }
                       rejectPlanShell(
                         approval.payload?.cancelMessage ?? planShellDecision.noApprovalMessage
                       );
@@ -132396,6 +132663,13 @@ var CoreToolScheduler = class {
                         approval.payload
                       )
                     );
+                    if (this.cancelPreExecutionIfAborted(
+                      reqInfo.callId,
+                      signal,
+                      toolSpan
+                    )) {
+                      continue;
+                    }
                     this.recordAutoModeFallbackResolution(
                       reqInfo.callId,
                       approval.outcome
@@ -132405,10 +132679,12 @@ var CoreToolScheduler = class {
                     continue;
                   }
                   if (hookResult.updatedInput && typeof reqInfo.args === "object") {
-                    this.setArgsInternal(
+                    if (!this.setArgsInternal(
                       reqInfo.callId,
                       hookResult.updatedInput
-                    );
+                    )) {
+                      continue;
+                    }
                   }
                   await runInRequestGoalContext(
                     reqInfo,
@@ -132416,6 +132692,13 @@ var CoreToolScheduler = class {
                       "proceed_once" /* ProceedOnce */
                     )
                   );
+                  if (this.cancelPreExecutionIfAborted(
+                    reqInfo.callId,
+                    signal,
+                    toolSpan
+                  )) {
+                    continue;
+                  }
                   this.recordAutoModeFallbackResolution(
                     reqInfo.callId,
                     "proceed_once" /* ProceedOnce */
@@ -132434,6 +132717,13 @@ var CoreToolScheduler = class {
                       cancelPayload
                     )
                   );
+                  if (this.cancelPreExecutionIfAborted(
+                    reqInfo.callId,
+                    signal,
+                    toolSpan
+                  )) {
+                    continue;
+                  }
                   this.recordAutoModeFallbackResolution(
                     reqInfo.callId,
                     "cancel" /* Cancel */
@@ -132450,7 +132740,8 @@ var CoreToolScheduler = class {
                       new Error(
                         hookResult.denyMessage || `Permission denied by hook for "${reqInfo.name}"`
                       ),
-                      "execution_denied" /* EXECUTION_DENIED */
+                      "execution_denied" /* EXECUTION_DENIED */,
+                      "not_started"
                     )
                   );
                   setToolSpanFailure(
@@ -132475,7 +132766,8 @@ var CoreToolScheduler = class {
                 createErrorResponse(
                   reqInfo,
                   new Error(errorMessage),
-                  "execution_denied" /* EXECUTION_DENIED */
+                  "execution_denied" /* EXECUTION_DENIED */,
+                  "not_started"
                 )
               );
               setToolSpanFailure(
@@ -132486,14 +132778,7 @@ var CoreToolScheduler = class {
               this.finalizeToolSpan(reqInfo.callId);
               continue;
             }
-            if (signal.aborted) {
-              this.setStatusInternal(
-                reqInfo.callId,
-                "cancelled",
-                "Tool call cancelled by user."
-              );
-              setToolSpanCancelled(toolSpan);
-              this.finalizeToolSpan(reqInfo.callId);
+            if (this.cancelPreExecutionIfAborted(reqInfo.callId, signal, toolSpan)) {
               continue;
             }
             if (planShellDecision.classification !== "not-applicable") {
@@ -132507,6 +132792,13 @@ var CoreToolScheduler = class {
                   signal
                 })
               );
+              if (this.cancelPreExecutionIfAborted(
+                reqInfo.callId,
+                signal,
+                toolSpan
+              )) {
+                continue;
+              }
               if (finalPreDisplayPlanShellError) {
                 rejectPlanShell(finalPreDisplayPlanShellError);
                 continue;
@@ -132593,7 +132885,8 @@ var CoreToolScheduler = class {
             this.setStatusInternal(
               reqInfo.callId,
               "cancelled",
-              "Tool call cancelled by user."
+              "Tool call cancelled by user.",
+              "not_started"
             );
             this.finalizeBlockedSpan(reqInfo.callId, "aborted", "system");
             setToolSpanCancelled(toolSpan);
@@ -132607,7 +132900,8 @@ var CoreToolScheduler = class {
             createErrorResponse(
               reqInfo,
               error instanceof Error ? error : new Error(String(error)),
-              explicitErrorType ?? "unhandled_exception" /* UNHANDLED_EXCEPTION */
+              explicitErrorType ?? "unhandled_exception" /* UNHANDLED_EXCEPTION */,
+              "not_started"
             )
           );
           this.finalizeBlockedSpan(reqInfo.callId, "error", "system");
@@ -132630,6 +132924,7 @@ var CoreToolScheduler = class {
       }
     } finally {
       this.isScheduling = false;
+      this.drainRequestQueueIfIdle();
     }
   }
   async handleConfirmationResponse(callId, originalOnConfirm, outcome, signal, payload) {
@@ -132673,6 +132968,25 @@ var CoreToolScheduler = class {
       );
     } catch (error) {
       const aborted = signal.aborted;
+      if (aborted) {
+        this.setStatusInternal(
+          callId,
+          "cancelled",
+          "Tool call cancelled by user.",
+          "not_started"
+        );
+      } else {
+        this.setStatusInternal(
+          callId,
+          "error",
+          createErrorResponse(
+            toolCall.request,
+            error instanceof Error ? error : new Error(String(error)),
+            "unhandled_exception" /* UNHANDLED_EXCEPTION */,
+            "not_started"
+          )
+        );
+      }
       this.finalizeBlockedSpan(callId, aborted ? "aborted" : "error", "system");
       const toolSpan = this.toolSpans.get(callId);
       if (toolSpan) {
@@ -132716,7 +133030,7 @@ var CoreToolScheduler = class {
     this.recordAutoModeFallbackResolution(callId, outcome);
     if (outcome === "cancel" /* Cancel */ || signal.aborted) {
       const cancelMessage = payload?.cancelMessage || "User did not allow tool call";
-      this.setStatusInternal(callId, "cancelled", cancelMessage);
+      this.setStatusInternal(callId, "cancelled", cancelMessage, "not_started");
       const toolSpan = this.toolSpans.get(callId);
       if (toolSpan) {
         setToolSpanCancelled(toolSpan);
@@ -132771,7 +133085,7 @@ var CoreToolScheduler = class {
           signal,
           this.onEditorClose
         );
-        this.setArgsInternal(callId, updatedParams);
+        if (!this.setArgsInternal(callId, updatedParams)) return;
         this.setStatusInternal(callId, "awaiting_approval", {
           ...waitingToolCall.confirmationDetails,
           fileDiff: updatedDiff,
@@ -132780,11 +133094,13 @@ var CoreToolScheduler = class {
       }
     } else {
       if (payload?.newContent && toolCall) {
-        await this._applyInlineModify(
+        if (!await this._applyInlineModify(
           toolCall,
           payload,
           signal
-        );
+        )) {
+          return;
+        }
       }
       this.setStatusInternal(callId, "scheduled");
       const decision = outcome === "proceed_once" /* ProceedOnce */ ? "proceed_once" : "proceed_always";
@@ -132868,7 +133184,7 @@ var CoreToolScheduler = class {
   async _applyInlineModify(toolCall, payload, signal) {
     const confirmDetails = toolCall.confirmationDetails;
     if (confirmDetails.type !== "edit" || !isModifiableDeclarativeTool(toolCall.tool) || !payload.newContent) {
-      return;
+      return true;
     }
     const currentContent = confirmDetails.originalContent ?? "";
     const modifyContext = toolCall.tool.getModifyContext(signal);
@@ -132884,11 +133200,14 @@ var CoreToolScheduler = class {
       "Current",
       "Proposed"
     );
-    this.setArgsInternal(toolCall.request.callId, updatedParams);
+    if (!this.setArgsInternal(toolCall.request.callId, updatedParams)) {
+      return false;
+    }
     this.setStatusInternal(toolCall.request.callId, "awaiting_approval", {
       ...confirmDetails,
       fileDiff: updatedDiff
     });
+    return true;
   }
   async attemptExecutionOfScheduledCalls(signal) {
     while (true) {
@@ -133002,10 +133321,10 @@ var CoreToolScheduler = class {
         createErrorResponse(
           scheduledCall.request,
           error instanceof Error ? error : new Error(errorMessage),
-          "unhandled_exception" /* UNHANDLED_EXCEPTION */
+          "unhandled_exception" /* UNHANDLED_EXCEPTION */,
+          this.toolCalls.find((call) => call.request.callId === callId)?.status === "executing" ? "error" : "not_started"
         )
       );
-      throw error;
     } finally {
       if (!this.bouncedAwaitingApproval.has(callId)) {
         this.finalizeToolSpan(callId);
@@ -133145,7 +133464,7 @@ var CoreToolScheduler = class {
           hasAdditionalContext: !!r.additionalContext
         }
       );
-      if (!preHookResult.shouldProceed) {
+      if (!signal.aborted && !preHookResult.shouldProceed) {
         if (preHookResult.blockType === "ask" && !signal.aborted && this.canPromptForAskBounce()) {
           this.bouncedToolUseId.set(callId, toolUseId);
           this.bounceToAwaitingApprovalForAsk(
@@ -133160,7 +133479,8 @@ var CoreToolScheduler = class {
         const errorResponse = createErrorResponse(
           scheduledCall.request,
           new Error(blockMessage),
-          "execution_denied" /* EXECUTION_DENIED */
+          "execution_denied" /* EXECUTION_DENIED */,
+          "not_started"
         );
         this.setStatusInternal(callId, "error", errorResponse);
         setToolSpanFailure(
@@ -133173,29 +133493,38 @@ var CoreToolScheduler = class {
     }
     const toolInvocationGuard = this.config.getToolInvocationGuard?.();
     if (toolInvocationGuard) {
+      const invocationContext = getInvocationContext();
       const guardDecision = await evaluateToolInvocationGuard(
         toolInvocationGuard,
         {
           callId,
           toolName: canonicalName,
           args: invocation.params,
-          signal
+          signal,
+          ...invocationContext ? { invocationContext } : {}
         }
       );
       if (signal.aborted) {
         this.setStatusInternal(
           callId,
           "cancelled",
-          "Tool call cancelled by user."
+          createCancelledResponse(
+            scheduledCall.request,
+            "Tool call cancelled before execution.",
+            "not_started"
+          )
         );
-        setToolSpanCancelled(span);
+        if (this.toolSpans.has(callId)) {
+          setToolSpanCancelled(span);
+        }
         return;
       }
       if (!guardDecision.allowed) {
         const errorResponse = createErrorResponse(
           scheduledCall.request,
           new Error(guardDecision.reason),
-          "execution_denied" /* EXECUTION_DENIED */
+          "execution_denied" /* EXECUTION_DENIED */,
+          "not_started"
         );
         this.setStatusInternal(callId, "error", errorResponse);
         setToolSpanFailure(
@@ -133206,7 +133535,26 @@ var CoreToolScheduler = class {
         return;
       }
     }
-    this.setStatusInternal(callId, "executing");
+    if (signal.aborted) {
+      const currentCall = this.toolCalls.find(
+        (call) => call.request.callId === callId
+      );
+      if (currentCall && currentCall.status !== "success" && currentCall.status !== "error" && currentCall.status !== "cancelled") {
+        this.setStatusInternal(
+          callId,
+          "cancelled",
+          createCancelledResponse(
+            scheduledCall.request,
+            "Tool call cancelled before execution.",
+            "not_started"
+          )
+        );
+        if (this.toolSpans.has(callId)) {
+          setToolSpanCancelled(span);
+        }
+      }
+      return;
+    }
     const liveOutputCallback = scheduledCall.tool.canUpdateOutput ? (outputChunk) => {
       if (isShellProgressData(outputChunk)) {
         if (this.outputUpdateHandler) {
@@ -133224,12 +133572,14 @@ var CoreToolScheduler = class {
       this.notifyToolCallsUpdate();
     } : void 0;
     const shellExecutionConfig = this.config.getShellExecutionConfig();
-    const execSpan = startToolExecutionSpan();
     const sleepInhibitorHandle = acquireSleepInhibitor(
       this.config,
       `Qwen Code is executing tool ${canonicalName}`
     );
     let removeParentAbortForward;
+    let executionStatus = "not_started";
+    let executionSettled = false;
+    let execSpan;
     try {
       let promise;
       const toolExecutionTimeoutMs = Math.min(
@@ -133280,30 +133630,40 @@ var CoreToolScheduler = class {
         this.safelyAddToolArgumentsAttributes(span, invocation.params);
         promise = todoWorkChainContext.run(
           todoWorkChainId,
-          () => promptIdContext.run(
-            scheduledCall.request.prompt_id,
-            () => invocation.execute(
+          () => promptIdContext.run(scheduledCall.request.prompt_id, () => {
+            this.setStatusInternal(callId, "executing");
+            execSpan = startToolExecutionSpan({
+              toolName: canonicalName,
+              callId
+            });
+            executionStatus = "error";
+            return invocation.execute(
               execSignal,
               liveOutputCallback,
               shellExecutionConfig,
               setPidCallback,
               setPromoteAbortControllerCallback,
               canPromoteForegroundShell
-            )
-          )
+            );
+          })
         );
       } else {
         this.safelyAddToolArgumentsAttributes(span, invocation.params);
         promise = todoWorkChainContext.run(
           todoWorkChainId,
-          () => promptIdContext.run(
-            scheduledCall.request.prompt_id,
-            () => invocation.execute(
+          () => promptIdContext.run(scheduledCall.request.prompt_id, () => {
+            this.setStatusInternal(callId, "executing");
+            execSpan = startToolExecutionSpan({
+              toolName: canonicalName,
+              callId
+            });
+            executionStatus = "error";
+            return invocation.execute(
               execSignal,
               liveOutputCallback,
               shellExecutionConfig
-            )
-          )
+            );
+          })
         );
       }
       let toolResult;
@@ -133338,14 +133698,24 @@ var CoreToolScheduler = class {
         toolResult = await promise;
       }
       const isTimeout = toolResult.error?.type === "execution_timeout" /* EXECUTION_TIMEOUT */ && (!schedulerTimeoutResultSelected || schedulerTimeoutWon);
-      const aborted = signal.aborted && !isTimeout;
-      endToolExecutionSpan(execSpan, {
-        success: toolResult.error === void 0 && !aborted,
-        error: aborted ? TOOL_SPAN_STATUS_TOOL_CANCELLED : isTimeout ? TOOL_SPAN_STATUS_TOOL_TIMEOUT : toolResult.error ? TOOL_SPAN_STATUS_TOOL_ERROR : void 0,
-        cancelled: aborted
-      });
+      const parentAbortedAtExecutionSettle = signal.aborted;
+      const aborted = parentAbortedAtExecutionSettle && !isTimeout;
+      const executionErrorType = toolResult.error ? toolResult.error.type ?? (scheduledCall.tool instanceof DiscoveredMCPTool ? "mcp_tool_error" /* MCP_TOOL_ERROR */ : "unknown" /* UNKNOWN */) : void 0;
+      executionStatus = aborted ? "cancelled" : toolResult.error ? "error" : "success";
+      executionSettled = true;
+      if (execSpan) {
+        const completedExecSpan = execSpan;
+        execSpan = void 0;
+        endToolExecutionSpan(completedExecSpan, {
+          success: executionStatus === "success",
+          error: aborted ? TOOL_SPAN_STATUS_TOOL_CANCELLED : isTimeout ? TOOL_SPAN_STATUS_TOOL_TIMEOUT : toolResult.error ? TOOL_SPAN_STATUS_TOOL_ERROR : void 0,
+          cancelled: aborted,
+          executionStatus,
+          errorType: executionErrorType
+        });
+      }
       if (aborted) {
-        let cancelMessage = "User cancelled tool execution.";
+        let cancelMessage = TOOL_CANCELLED_AFTER_COMPLETION_MESSAGE;
         let failureHookArtifacts;
         if (hooksEnabled && messageBus) {
           const failureHookResult = await this.withHookSpan(
@@ -133377,15 +133747,37 @@ ${failureHookResult.additionalContext}`;
         this.setStatusInternal(
           callId,
           "cancelled",
-          failureHookArtifacts && failureHookArtifacts.length > 0 ? createCancelledResponse(
+          createCancelledResponse(
             scheduledCall.request,
             cancelMessage,
-            failureHookArtifacts
-          ) : cancelMessage
+            executionStatus,
+            failureHookArtifacts,
+            toolResult.persistedOutputFiles
+          )
         );
         setToolSpanCancelled(span);
         return;
       }
+      const cancelAfterPostProcessing = /* @__PURE__ */ __name((artifacts, preserved) => {
+        if (!signal.aborted || isTimeout && parentAbortedAtExecutionSettle) {
+          return false;
+        }
+        this.setStatusInternal(
+          callId,
+          "cancelled",
+          createCancelledResponse(
+            scheduledCall.request,
+            // Reached only after `execute()` settled with a result.
+            TOOL_CANCELLED_AFTER_COMPLETION_MESSAGE,
+            executionStatus,
+            artifacts,
+            preserved?.persistedOutputFiles,
+            preserved?.visionBridgeNotice
+          )
+        );
+        setToolSpanCancelled(span);
+        return true;
+      }, "cancelAfterPostProcessing");
       if (toolResult.error === void 0) {
         let content = toolResult.llmContent ?? "";
         let persistedOutputFiles = toolResult.persistedOutputFiles ? [...toolResult.persistedOutputFiles] : toolResult.persistedOutputFiles;
@@ -133442,12 +133834,21 @@ ${failureHookResult.additionalContext}`;
             postToolUseArtifacts = postHookResult.artifacts;
           }
           if (postHookResult.shouldStop) {
+            if (cancelAfterPostProcessing(postHookResult.artifacts, {
+              persistedOutputFiles
+            })) {
+              return;
+            }
             const stopMessage = postHookResult.stopReason || "Execution stopped by hook";
             const errorResponse = createErrorResponse(
               scheduledCall.request,
               new Error(stopMessage),
-              "execution_denied" /* EXECUTION_DENIED */
+              "execution_denied" /* EXECUTION_DENIED */,
+              executionStatus
             );
+            if (persistedOutputFiles !== void 0) {
+              errorResponse.persistedOutputFiles = persistedOutputFiles;
+            }
             this.setStatusInternal(callId, "error", errorResponse);
             setToolSpanFailure(
               span,
@@ -133613,6 +134014,7 @@ ${body}
           ),
           error: void 0,
           errorType: void 0,
+          executionStatus,
           contentLength,
           ...persistedOutputFiles !== void 0 ? { persistedOutputFiles } : {},
           // Propagate modelOverride from skill tools. Use `in` to distinguish
@@ -133644,6 +134046,12 @@ ${body}
             );
           }
         }
+        if (cancelAfterPostProcessing(artifacts, {
+          persistedOutputFiles: successResponse.persistedOutputFiles,
+          visionBridgeNotice: successResponse.visionBridgeNotice
+        })) {
+          return;
+        }
         this.setStatusInternal(callId, "success", successResponse);
         safeSetStatus(span, { code: SpanStatusCode.OK });
         try {
@@ -133732,6 +134140,12 @@ ${failureHookResult.additionalContext}`;
               ...timeoutContent.persistedOutputFiles ?? []
             ])
           );
+          if (cancelAfterPostProcessing(artifacts, {
+            persistedOutputFiles: timeoutPersistedOutputFiles,
+            visionBridgeNotice: processedImages.visionBridgeNotice
+          })) {
+            return;
+          }
           this.setStatusInternal(callId, "error", {
             callId,
             responseParts,
@@ -133740,6 +134154,7 @@ ${failureHookResult.additionalContext}`;
             ),
             error: new Error(operationalErrorMessage),
             errorType: "execution_timeout" /* EXECUTION_TIMEOUT */,
+            executionStatus,
             contentLength,
             ...timeoutPersistedOutputFiles !== void 0 ? { persistedOutputFiles: timeoutPersistedOutputFiles } : {},
             ...processedImages.modelOverride !== void 0 ? { modelOverride: processedImages.modelOverride } : {},
@@ -133773,7 +134188,8 @@ ${failureHookResult.additionalContext}`;
         let errorResponse = createErrorResponse(
           scheduledCall.request,
           error,
-          toolResult.error.type ?? "unknown" /* UNKNOWN */,
+          executionErrorType ?? "unknown" /* UNKNOWN */,
+          executionStatus,
           failureHookArtifacts,
           typeof toolResult.returnDisplay === "string" ? void 0 : this.compactResultDisplayForInteractiveHistory(
             toolResult.returnDisplay
@@ -133821,6 +134237,15 @@ ${failureHookResult.additionalContext}`;
             };
           }
         }
+        if (cancelAfterPostProcessing(
+          [...toolResult.artifacts ?? [], ...failureHookArtifacts ?? []],
+          {
+            persistedOutputFiles: errorResponse.persistedOutputFiles,
+            visionBridgeNotice: errorResponse.visionBridgeNotice
+          }
+        )) {
+          return;
+        }
         this.setStatusInternal(callId, "error", errorResponse);
         setToolSpanFailure(
           span,
@@ -133830,14 +134255,28 @@ ${failureHookResult.additionalContext}`;
       }
     } catch (executionError) {
       const errorMessage = executionError instanceof Error ? executionError.message : String(executionError);
-      const aborted = signal.aborted;
-      endToolExecutionSpan(execSpan, {
-        success: false,
-        error: aborted ? TOOL_SPAN_STATUS_TOOL_CANCELLED : TOOL_SPAN_STATUS_TOOL_EXCEPTION,
-        cancelled: aborted
-      });
+      const executionThrew = !executionSettled && executionStatus !== "not_started";
+      const explicitErrorType = executionError?.errorType;
+      const executionTimedOut = executionThrew && explicitErrorType === "execution_timeout" /* EXECUTION_TIMEOUT */;
+      const aborted = signal.aborted && !executionTimedOut;
+      if (executionThrew) {
+        executionStatus = aborted ? "cancelled" : "error";
+        executionSettled = true;
+      }
+      const exceptionErrorType = explicitErrorType ?? (executionThrew && scheduledCall.tool instanceof DiscoveredMCPTool ? "mcp_tool_error" /* MCP_TOOL_ERROR */ : "unhandled_exception" /* UNHANDLED_EXCEPTION */);
+      if (execSpan) {
+        const failedExecSpan = execSpan;
+        execSpan = void 0;
+        endToolExecutionSpan(failedExecSpan, {
+          success: false,
+          error: aborted ? TOOL_SPAN_STATUS_TOOL_CANCELLED : executionTimedOut ? TOOL_SPAN_STATUS_TOOL_TIMEOUT : TOOL_SPAN_STATUS_TOOL_EXCEPTION,
+          cancelled: aborted,
+          executionStatus,
+          errorType: executionStatus === "error" ? exceptionErrorType : void 0
+        });
+      }
       if (aborted) {
-        let cancelMessage = "User cancelled tool execution.";
+        let cancelMessage = executionThrew ? TOOL_CANCELLED_BEFORE_COMPLETION_MESSAGE : TOOL_CANCELLED_AFTER_COMPLETION_MESSAGE;
         let failureHookArtifacts;
         if (hooksEnabled && messageBus) {
           const failureHookResult = await this.withHookSpan(
@@ -133869,11 +134308,12 @@ ${failureHookResult.additionalContext}`;
         this.setStatusInternal(
           callId,
           "cancelled",
-          failureHookArtifacts && failureHookArtifacts.length > 0 ? createCancelledResponse(
+          createCancelledResponse(
             scheduledCall.request,
             cancelMessage,
+            executionStatus,
             failureHookArtifacts
-          ) : cancelMessage
+          )
         );
         setToolSpanCancelled(span);
         return;
@@ -133907,13 +134347,30 @@ ${failureHookResult.additionalContext}`;
           }
           failureHookArtifacts = failureHookResult.artifacts;
         }
+        if (signal.aborted && !executionTimedOut) {
+          this.setStatusInternal(
+            callId,
+            "cancelled",
+            createCancelledResponse(
+              scheduledCall.request,
+              // The abort landed while the failure hook was running; the
+              // tool's own outcome is still what `executionThrew` says.
+              executionThrew ? TOOL_CANCELLED_BEFORE_COMPLETION_MESSAGE : TOOL_CANCELLED_AFTER_COMPLETION_MESSAGE,
+              executionStatus,
+              failureHookArtifacts
+            )
+          );
+          setToolSpanCancelled(span);
+          return;
+        }
         this.setStatusInternal(
           callId,
           "error",
           createErrorResponse(
             scheduledCall.request,
             executionError instanceof Error ? new Error(exceptionErrorMessage) : new Error(String(executionError)),
-            "unhandled_exception" /* UNHANDLED_EXCEPTION */,
+            exceptionErrorType,
+            executionStatus,
             failureHookArtifacts
           )
         );
@@ -133944,8 +134401,7 @@ ${failureHookResult.additionalContext}`;
       }
       let messageBus;
       try {
-        const shouldFirePostToolBatch = !this.config.getDisableAllHooks() && (this.config.hasHooksForEvent?.("PostToolBatch") ?? false);
-        messageBus = shouldFirePostToolBatch ? this.config.getMessageBus() : void 0;
+        messageBus = this.postToolBatchEnabledForBatch ? this.config.getMessageBus() : void 0;
       } catch (error) {
         debugLogger122.warn(
           `PostToolBatch hook setup failed: ${error instanceof Error ? error.message : String(error)}`
@@ -133959,7 +134415,7 @@ ${failureHookResult.additionalContext}`;
         if (messageBus) {
           const batchToolCalls = completedCalls.map(toPostToolBatchToolCall);
           const permissionMode = this.config.getApprovalMode();
-          const batchHookResult = await this.withHookSpan(
+          const fireBatchHook = /* @__PURE__ */ __name(() => this.withHookSpan(
             { hookEvent: "PostToolBatch", toolName: "batch" },
             () => firePostToolBatchHook(
               messageBus,
@@ -133981,15 +134437,28 @@ ${failureHookResult.additionalContext}`;
               postBatchStop: r.shouldStop,
               postBatchStopReason: r.shouldStop ? r.stopReason || "no reason given" : void 0
             }
-          );
+          ), "fireBatchHook");
+          const batchParentSpan = this.postToolBatchSpanCallId ? this.toolSpans.get(this.postToolBatchSpanCallId) : void 0;
+          const batchHookResult = await (batchParentSpan ? runInToolSpanContext(batchParentSpan, fireBatchHook) : fireBatchHook());
           if (batchHookResult.shouldStop) {
+            const stopMessage = batchHookResult.stopReason || "Execution stopped by PostToolBatch hook";
             debugLogger122.info(
               `PostToolBatch hook stopped batch (${completedCalls.length} calls): ${batchHookResult.stopReason || "no reason given"}`
             );
-            completedCalls = withPostToolBatchStop(
-              completedCalls,
-              batchHookResult.stopReason || "Execution stopped by PostToolBatch hook"
-            );
+            completedCalls = withPostToolBatchStop(completedCalls, stopMessage);
+            const stoppedCall = completedCalls.at(-1);
+            const stoppedSpan = stoppedCall ? this.toolSpans.get(stoppedCall.request.callId) : void 0;
+            if (stoppedSpan) {
+              setToolSpanFailure(
+                stoppedSpan,
+                TOOL_FAILURE_KIND_POST_HOOK_STOPPED,
+                stopMessage
+              );
+            } else {
+              debugLogger122.debug(
+                `PostToolBatch stop: no tool span for stopped call ${stoppedCall?.request.callId}; post_hook_stopped not recorded`
+              );
+            }
           }
           completedCalls = withPostToolBatchAdditionalContext(
             completedCalls,
@@ -134001,6 +134470,9 @@ ${failureHookResult.additionalContext}`;
           );
         }
         completedCalls = await this.applyBatchOutputBudget(completedCalls);
+        for (const call of completedCalls) {
+          this.finalizeToolSpan(call.request.callId, true);
+        }
         for (const call of completedCalls) {
           this.runtimeContentGeneratorViews.delete(call.request.callId);
           logToolCall(this.config, new ToolCallEvent(call));
@@ -134011,13 +134483,15 @@ ${failureHookResult.additionalContext}`;
         }
       } finally {
         try {
+          for (const call of completedCalls) {
+            this.finalizeToolSpan(call.request.callId, true);
+          }
+          this.postToolBatchEnabledForBatch = false;
+          this.postToolBatchSpanCallId = void 0;
           this.notifyToolCallsUpdate();
         } finally {
           this.isFinalizingToolCalls = false;
-          if (this.requestQueue.length > 0) {
-            const next = this.requestQueue.shift();
-            this._schedule(next.request, next.signal, next.runtimeView).then(next.resolve).catch(next.reject);
-          }
+          this.drainRequestQueueIfIdle();
         }
       }
     }
@@ -134082,6 +134556,7 @@ ${failureHookResult.additionalContext}`;
       const result = {
         callId: call.request.callId,
         status: call.status,
+        executionStatus: call.response.executionStatus,
         resultDisplay: call.response.resultDisplay,
         ...call.response.visionBridgeNotice !== void 0 ? { visionBridgeNotice: call.response.visionBridgeNotice } : {},
         error: call.response.error,
@@ -134109,8 +134584,15 @@ ${failureHookResult.additionalContext}`;
     }
   }
   notifyToolCallsUpdate() {
-    if (this.onToolCallsUpdate) {
+    if (!this.onToolCallsUpdate) {
+      return;
+    }
+    try {
       this.onToolCallsUpdate([...this.toolCalls]);
+    } catch (error) {
+      debugLogger122.error(
+        `Tool call update observer failed: ${error instanceof Error ? error.message : String(error)}`
+      );
     }
   }
   setToolCallOutcome(callId, outcome) {
@@ -134133,6 +134615,9 @@ ${failureHookResult.additionalContext}`;
     );
     for (const pendingTool of pendingTools) {
       try {
+        if (this.cancelPreExecutionIfAborted(pendingTool.request.callId, signal)) {
+          continue;
+        }
         const toolParams = pendingTool.invocation.params;
         const flowResult = await runInRequestGoalContext(
           pendingTool.request,
@@ -134143,6 +134628,9 @@ ${failureHookResult.additionalContext}`;
             toolParams
           )
         );
+        if (this.cancelPreExecutionIfAborted(pendingTool.request.callId, signal)) {
+          continue;
+        }
         const { finalPermission, pmForcedAsk, pmCtx, requiresUserInteraction } = flowResult;
         if (requiresUserInteraction) {
           continue;
@@ -134170,6 +134658,9 @@ ${failureHookResult.additionalContext}`;
               skipClassifierReason: fallback.fallback ? fallback.reason : void 0
             })
           );
+          if (this.cancelPreExecutionIfAborted(pendingTool.request.callId, signal)) {
+            continue;
+          }
           const outcome = applyAutoModeDecision(
             decision,
             this.config,
@@ -134194,6 +134685,9 @@ ${failureHookResult.additionalContext}`;
               );
             }
           }
+          if (this.cancelPreExecutionIfAborted(pendingTool.request.callId, signal)) {
+            continue;
+          }
           switch (outcome.kind) {
             case "approved":
               this.setToolCallOutcome(
@@ -134214,7 +134708,8 @@ ${failureHookResult.additionalContext}`;
                 createErrorResponse(
                   pendingTool.request,
                   new Error(outcome.errorMessage),
-                  "execution_denied" /* EXECUTION_DENIED */
+                  "execution_denied" /* EXECUTION_DENIED */,
+                  "not_started"
                 )
               );
               this.finalizeBlockedSpan(
@@ -134273,6 +134768,9 @@ ${failureHookResult.additionalContext}`;
           );
         }
       } catch (error) {
+        if (this.cancelPreExecutionIfAborted(pendingTool.request.callId, signal)) {
+          continue;
+        }
         debugLogger122.error(
           `Error checking confirmation for tool ${pendingTool.request.callId}:`,
           error
@@ -142730,8 +143228,10 @@ var GeminiClient = class _GeminiClient {
       }
       if (m2.triggerReason === "size") {
         const pendingNote = m2.pendingToolResultChars && m2.pendingToolResultChars > 0 ? ` (+${m2.pendingToolResultChars} pending)` : "";
+        const virtualAfter = (m2.toolResultCharsAfter ?? 0) + (m2.pendingToolResultChars ?? 0);
+        const targetNote = m2.toolResultsLowWatermark !== void 0 ? `, target ${m2.toolResultsLowWatermark}` + (virtualAfter > m2.toolResultsLowWatermark ? " (soft-exceeded)" : "") : "";
         debugLogger132.info(
-          `[TOOL-RESULT MC] tool result chars ${m2.toolResultCharsBefore} > ${m2.toolResultsTotalCharsThreshold}, cleared ${m2.toolsCleared} tool result(s) (~${m2.tokensSaved} tokens), history now ${m2.toolResultCharsAfter}${pendingNote}, kept ${m2.toolsKept} tool result(s)`
+          `[TOOL-RESULT MC] tool result chars ${m2.toolResultCharsBefore} > ${m2.toolResultsTotalCharsThreshold}, cleared ${m2.toolsCleared} tool result(s) (~${m2.tokensSaved} tokens), history now ${m2.toolResultCharsAfter}${pendingNote}${targetNote}, kept ${m2.toolsKept} tool result(s)`
         );
       } else {
         debugLogger132.info(
@@ -150331,7 +150831,7 @@ var Config = class _Config {
     }
     if (!enabled) return;
     registry.registerFactory(ToolNames.IMAGE_GEN, async () => {
-      const { ImageGenTool } = await import("./image-gen-2ZWPS42A.js");
+      const { ImageGenTool } = await import("./image-gen-KNKDTUEN.js");
       return new ImageGenTool(this);
     });
   }
@@ -150361,36 +150861,36 @@ var Config = class _Config {
       if (options2?.forSubAgent) return;
       const schema = this.jsonSchema;
       await registerLazy(ToolNames.STRUCTURED_OUTPUT, async () => {
-        const { SyntheticOutputTool } = await import("./syntheticOutput-EYL7DWO7.js");
+        const { SyntheticOutputTool } = await import("./syntheticOutput-BN7E626U.js");
         return new SyntheticOutputTool(schema);
       });
     }, "registerStructuredOutputIfRequested");
     const registerGoalWorkerTools = /* @__PURE__ */ __name(async () => {
       if (options2?.forSubAgent) return;
       await registerLazy(ToolNames.GET_GOAL, async () => {
-        const { GetGoalTool } = await import("./goal-tools-SPQ5M6D3.js");
+        const { GetGoalTool } = await import("./goal-tools-3AZKX5WQ.js");
         return new GetGoalTool(this);
       });
       await registerLazy(ToolNames.UPDATE_GOAL, async () => {
-        const { UpdateGoalTool } = await import("./goal-tools-SPQ5M6D3.js");
+        const { UpdateGoalTool } = await import("./goal-tools-3AZKX5WQ.js");
         return new UpdateGoalTool(this);
       });
     }, "registerGoalWorkerTools");
     if (this.getBareMode()) {
       await registerLazy(ToolNames.READ_FILE, async () => {
-        const { ReadFileTool } = await import("./read-file-2T54FYZV.js");
+        const { ReadFileTool } = await import("./read-file-6PSNROKB.js");
         return new ReadFileTool(this);
       });
       await registerLazy(ToolNames.EDIT, async () => {
-        const { EditTool } = await import("./edit-YK3UP6D2.js");
+        const { EditTool } = await import("./edit-E2WNOITJ.js");
         return new EditTool(this);
       });
       await registerLazy(ToolNames.NOTEBOOK_EDIT, async () => {
-        const { NotebookEditTool } = await import("./notebook-edit-373IQQLE.js");
+        const { NotebookEditTool } = await import("./notebook-edit-WKZUONWV.js");
         return new NotebookEditTool(this);
       });
       await registerLazy(ToolNames.SHELL, async () => {
-        const { ShellTool: ShellTool2 } = await import("./shell-RT5DBH6B.js");
+        const { ShellTool: ShellTool2 } = await import("./shell-6SUYJURL.js");
         return new ShellTool2(this);
       });
       await registerGoalWorkerTools();
@@ -150402,43 +150902,43 @@ var Config = class _Config {
     }
     await registerGoalWorkerTools();
     await registerLazy(ToolNames.TOOL_SEARCH, async () => {
-      const { ToolSearchTool } = await import("./tool-search-2AOU77H4.js");
+      const { ToolSearchTool } = await import("./tool-search-HJN53LCN.js");
       return new ToolSearchTool(this);
     });
     await registerLazy(ToolNames.READ_MCP_RESOURCE, async () => {
-      const { ReadMcpResourceTool } = await import("./read-mcp-resource-DRZSI3HE.js");
+      const { ReadMcpResourceTool } = await import("./read-mcp-resource-RTSSEER5.js");
       return new ReadMcpResourceTool(this);
     });
     await registerLazy(ToolNames.AGENT, async () => {
-      const { AgentTool: AgentTool2 } = await import("./agent-RB6LCRZX.js");
+      const { AgentTool: AgentTool2 } = await import("./agent-SC23IV5L.js");
       return new AgentTool2(this);
     });
     await registerLazy(ToolNames.LIST_AGENTS, async () => {
-      const { ListAgentsTool } = await import("./list-agents-TWEGRJWO.js");
+      const { ListAgentsTool } = await import("./list-agents-GC4BRET7.js");
       return new ListAgentsTool(this);
     });
     await registerLazy(ToolNames.TASK_STOP, async () => {
-      const { TaskStopTool } = await import("./task-stop-Y5ZTFVRX.js");
+      const { TaskStopTool } = await import("./task-stop-TNXRNAL2.js");
       return new TaskStopTool(this);
     });
     await registerLazy(ToolNames.SEND_MESSAGE, async () => {
-      const { SendMessageTool } = await import("./send-message-LHJLVWFD.js");
+      const { SendMessageTool } = await import("./send-message-TL6FIMMN.js");
       return new SendMessageTool(this);
     });
     await registerLazy(ToolNames.SKILL, async () => {
-      const { SkillTool } = await import("./skill-LVGA3ATZ.js");
+      const { SkillTool } = await import("./skill-ZIQFS6YD.js");
       return new SkillTool(this);
     });
     await registerLazy(ToolNames.LS, async () => {
-      const { LSTool } = await import("./ls-H5WX22VK.js");
+      const { LSTool } = await import("./ls-63CC3NNX.js");
       return new LSTool(this);
     });
     await registerLazy(ToolNames.READ_FILE, async () => {
-      const { ReadFileTool } = await import("./read-file-2T54FYZV.js");
+      const { ReadFileTool } = await import("./read-file-6PSNROKB.js");
       return new ReadFileTool(this);
     });
     await registerLazy(ToolNames.ZOOM_IMAGE, async () => {
-      const { ZoomImageTool } = await import("./zoom-image-E3VHRCFU.js");
+      const { ZoomImageTool } = await import("./zoom-image-4Y6Y6DAX.js");
       return new ZoomImageTool(this);
     });
     if (this.getUseRipgrep()) {
@@ -150453,7 +150953,7 @@ var Config = class _Config {
       recordStartupEvent("config_initialize_ripgrep_probe_end");
       if (useRipgrep) {
         await registerLazy(ToolNames.GREP, async () => {
-          const { RipGrepTool: RipGrepTool2 } = await import("./ripGrep-3H72KY7S.js");
+          const { RipGrepTool: RipGrepTool2 } = await import("./ripGrep-4WZJEOGB.js");
           return new RipGrepTool2(this);
         });
       } else {
@@ -150466,7 +150966,7 @@ var Config = class _Config {
           )
         );
         await registerLazy(ToolNames.GREP, async () => {
-          const { GrepTool } = await import("./grep-SQ7RD7SV.js");
+          const { GrepTool } = await import("./grep-SJ2NYUCD.js");
           return new GrepTool(this);
         });
       }
@@ -150474,77 +150974,77 @@ var Config = class _Config {
       recordStartupEvent("config_initialize_ripgrep_probe_start");
       recordStartupEvent("config_initialize_ripgrep_probe_end");
       await registerLazy(ToolNames.GREP, async () => {
-        const { GrepTool } = await import("./grep-SQ7RD7SV.js");
+        const { GrepTool } = await import("./grep-SJ2NYUCD.js");
         return new GrepTool(this);
       });
     }
     await registerLazy(ToolNames.GLOB, async () => {
-      const { GlobTool } = await import("./glob-SKUYGTF2.js");
+      const { GlobTool } = await import("./glob-IGTV723M.js");
       return new GlobTool(this);
     });
     await registerLazy(ToolNames.EDIT, async () => {
-      const { EditTool } = await import("./edit-YK3UP6D2.js");
+      const { EditTool } = await import("./edit-E2WNOITJ.js");
       return new EditTool(this);
     });
     await registerLazy(ToolNames.NOTEBOOK_EDIT, async () => {
-      const { NotebookEditTool } = await import("./notebook-edit-373IQQLE.js");
+      const { NotebookEditTool } = await import("./notebook-edit-WKZUONWV.js");
       return new NotebookEditTool(this);
     });
     await registerLazy(ToolNames.WRITE_FILE, async () => {
-      const { WriteFileTool: WriteFileTool2 } = await import("./write-file-MOM4JDHG.js");
+      const { WriteFileTool: WriteFileTool2 } = await import("./write-file-NK4C3GFC.js");
       return new WriteFileTool2(this);
     });
     await registerLazy(ToolNames.SHELL, async () => {
-      const { ShellTool: ShellTool2 } = await import("./shell-RT5DBH6B.js");
+      const { ShellTool: ShellTool2 } = await import("./shell-6SUYJURL.js");
       return new ShellTool2(this);
     });
     await registerLazy(ToolNames.TODO_WRITE, async () => {
-      const { TodoWriteTool } = await import("./todoWrite-FTZWQRZH.js");
+      const { TodoWriteTool } = await import("./todoWrite-MHWHO5UO.js");
       return new TodoWriteTool(this);
     });
     const supportsUserInteraction = resolveInteractionMode(this) !== "headless";
     if (supportsUserInteraction) {
       await registerLazy(ToolNames.ASK_USER_QUESTION, async () => {
-        const { AskUserQuestionTool } = await import("./askUserQuestion-23Y5WZFJ.js");
+        const { AskUserQuestionTool } = await import("./askUserQuestion-2EPPBPUZ.js");
         return new AskUserQuestionTool(this);
       });
     }
     if (!this.sdkMode && (supportsUserInteraction || options2?.forSubAgent)) {
       await registerLazy(ToolNames.EXIT_PLAN_MODE, async () => {
-        const { ExitPlanModeTool: ExitPlanModeTool2 } = await import("./exitPlanMode-K5Y3REU2.js");
+        const { ExitPlanModeTool: ExitPlanModeTool2 } = await import("./exitPlanMode-V75Y36HJ.js");
         return new ExitPlanModeTool2(this);
       });
     }
     if (!this.sdkMode && supportsUserInteraction) {
       await registerLazy(ToolNames.ENTER_PLAN_MODE, async () => {
-        const { EnterPlanModeTool } = await import("./enterPlanMode-TZAYQ5MP.js");
+        const { EnterPlanModeTool } = await import("./enterPlanMode-GISFJA3O.js");
         return new EnterPlanModeTool(this);
       });
     }
     await registerLazy(ToolNames.ENTER_WORKTREE, async () => {
-      const { EnterWorktreeTool } = await import("./enter-worktree-QMVQW7UG.js");
+      const { EnterWorktreeTool } = await import("./enter-worktree-RMCBAAA2.js");
       return new EnterWorktreeTool(this);
     });
     await registerLazy(ToolNames.EXIT_WORKTREE, async () => {
-      const { ExitWorktreeTool } = await import("./exit-worktree-4EC7LBBC.js");
+      const { ExitWorktreeTool } = await import("./exit-worktree-HORS3V7Z.js");
       return new ExitWorktreeTool(this);
     });
     await registerLazy(ToolNames.WEB_FETCH, async () => {
-      const { WebFetchTool } = await import("./web-fetch-ZRXSV5AN.js");
+      const { WebFetchTool } = await import("./web-fetch-MXA6HQ42.js");
       return new WebFetchTool(this);
     });
     if (resolveInteractionMode(this) === "interactive" && !this.sdkMode && !this.getScreenReader() && !options2?.forSubAgent) {
       await registerLazy(ToolNames.DISPLAY_IMAGE, async () => {
-        const { DisplayImageTool } = await import("./display-image-2WOG27DY.js");
+        const { DisplayImageTool } = await import("./display-image-GUJA352B.js");
         return new DisplayImageTool(this);
       });
     }
     if (this.webSearchSettings?.enabled) {
-      const { evaluateWebSearchGate } = await import("./web-search-WOLV3L6T.js");
+      const { evaluateWebSearchGate } = await import("./web-search-YENHOBMC.js");
       const gate = evaluateWebSearchGate(this);
       if (gate.ok) {
         await registerLazy(ToolNames.WEB_SEARCH, async () => {
-          const { WebSearchTool } = await import("./web-search-WOLV3L6T.js");
+          const { WebSearchTool } = await import("./web-search-YENHOBMC.js");
           return new WebSearchTool(this);
         });
       } else if (!this.webSearchNoticeEmitted && !options2?.forSubAgent) {
@@ -150555,83 +151055,83 @@ var Config = class _Config {
     await this.registerImageGenerationTool(registry);
     if (this.isArtifactEnabled()) {
       await registerLazy(ToolNames.ARTIFACT, async () => {
-        const { ArtifactTool } = await import("./artifact-tool-TBOYEKTY.js");
+        const { ArtifactTool } = await import("./artifact-tool-RROCCJDA.js");
         return new ArtifactTool(this);
       });
     }
     if (this.isRecordArtifactEnabled()) {
       await registerLazy(ToolNames.RECORD_ARTIFACT, async () => {
-        const { RecordArtifactTool } = await import("./record-artifact-IPIRWMFY.js");
+        const { RecordArtifactTool } = await import("./record-artifact-E6AWQU2Z.js");
         return new RecordArtifactTool();
       });
     }
     if (this.isLspEnabled() && this.getLspClient()) {
       await registerLazy(ToolNames.LSP, async () => {
-        const { LspTool } = await import("./lsp-G6FXYEIS.js");
+        const { LspTool } = await import("./lsp-P6NVJVNT.js");
         return new LspTool(this);
       });
     }
     await registerStructuredOutputIfRequested();
     if (this.isCronEnabled()) {
       await registerLazy(ToolNames.CRON_CREATE, async () => {
-        const { CronCreateTool } = await import("./cron-create-HMFSHIAR.js");
+        const { CronCreateTool } = await import("./cron-create-CCRIULJE.js");
         return new CronCreateTool(this);
       });
       await registerLazy(ToolNames.CRON_LIST, async () => {
-        const { CronListTool } = await import("./cron-list-ZEX2NBMN.js");
+        const { CronListTool } = await import("./cron-list-QDBVCHRF.js");
         return new CronListTool(this);
       });
       await registerLazy(ToolNames.CRON_DELETE, async () => {
-        const { CronDeleteTool } = await import("./cron-delete-ZJFHOX57.js");
+        const { CronDeleteTool } = await import("./cron-delete-FCFW6BGP.js");
         return new CronDeleteTool(this);
       });
       await registerLazy(ToolNames.LOOP_WAKEUP, async () => {
-        const { LoopWakeupTool } = await import("./loop-wakeup-6LLEOQYV.js");
+        const { LoopWakeupTool } = await import("./loop-wakeup-SQQSBMEY.js");
         return new LoopWakeupTool(this);
       });
     }
     await registerLazy(ToolNames.CREATE_SUB_SESSION, async () => {
-      const { CreateSubSessionTool } = await import("./create-sub-session-J32WC64U.js");
+      const { CreateSubSessionTool } = await import("./create-sub-session-6EWLAZD5.js");
       return new CreateSubSessionTool(this);
     });
     if (this.isAgentTeamEnabled()) {
       await registerLazy(ToolNames.TEAM_CREATE, async () => {
-        const { TeamCreateTool } = await import("./team-create-ZVPQIXCP.js");
+        const { TeamCreateTool } = await import("./team-create-CMF2RRF2.js");
         return new TeamCreateTool(this);
       });
       await registerLazy(ToolNames.TEAM_DELETE, async () => {
-        const { TeamDeleteTool } = await import("./team-delete-CE7DC53R.js");
+        const { TeamDeleteTool } = await import("./team-delete-D2VMSDOT.js");
         return new TeamDeleteTool(this);
       });
       await registerLazy(ToolNames.TEAM_PLAN_APPROVAL, async () => {
-        const { TeamPlanApprovalTool } = await import("./team-plan-approval-5UHUBY3W.js");
+        const { TeamPlanApprovalTool } = await import("./team-plan-approval-5EET4S3I.js");
         return new TeamPlanApprovalTool(this);
       });
       await registerLazy(ToolNames.TASK_CREATE, async () => {
-        const { TaskCreateTool } = await import("./task-create-4ALZMGP5.js");
+        const { TaskCreateTool } = await import("./task-create-2X4UP4F3.js");
         return new TaskCreateTool(this);
       });
       await registerLazy(ToolNames.TASK_UPDATE, async () => {
-        const { TaskUpdateTool } = await import("./task-update-IKCEEWJ6.js");
+        const { TaskUpdateTool } = await import("./task-update-VDUSN36E.js");
         return new TaskUpdateTool(this);
       });
       await registerLazy(ToolNames.TASK_LIST, async () => {
-        const { TaskListTool } = await import("./task-list-6CVQPORX.js");
+        const { TaskListTool } = await import("./task-list-WOLJPZ64.js");
         return new TaskListTool(this);
       });
     }
     if (this.isWorkflowsEnabled()) {
       await registerLazy(ToolNames.WORKFLOW, async () => {
-        const { WorkflowTool } = await import("./workflow-F63ES3OB.js");
+        const { WorkflowTool } = await import("./workflow-RYEVBM4L.js");
         return new WorkflowTool(this);
       });
     }
     if (this.isComputerUseEnabled()) {
-      const { registerComputerUseTools } = await import("./computer-use-MDOMIVTL.js");
+      const { registerComputerUseTools } = await import("./computer-use-ENYMKQAI.js");
       await registerComputerUseTools(registerLazy, this);
     }
     await registerLazy(ToolNames.MONITOR, async () => {
-      const { MonitorTool } = await import("./monitor-6Y3NDMTI.js");
+      const { MonitorTool } = await import("./monitor-I43P3MNV.js");
       return new MonitorTool(this);
     });
     if (this.pendingMcpBudgetCallback) {
@@ -151071,7 +151571,6 @@ export {
   findPlanModeEntryBatchBoundaryIndex,
   finalizeToolResponses,
   parseAndFormatApiError,
-  StructuredToolError,
   checkPriorRead,
   PLAN_EXIT_APPROVED_LLM_CONTENT_PREFIXES,
   ExitPlanModeTool,