@qwen-code/qwen-code 0.21.3 → 0.21.4-nightly.20260804.d6f55a1c9

package/chunks/{chunk-UQDFEU47.js → chunk-7E5BCHGR.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-XUMAD5IT.js";
+} from "./chunk-PMMWMPWV.js";
 import {
   ARTIFACT_TITLE_MAX_LENGTH,
   ARTIFACT_WORKSPACE_PATH_MAX_LENGTH,
   hasControlCharacter,
   hasUnsafeDisplayPayload
-} from "./chunk-X6QNZOTC.js";
+} from "./chunk-7MFQLOHZ.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-TZTBZ25J.js";
+} from "./chunk-6WBWIPBF.js";
 import {
   getTeammateContext,
   isTeammate,
@@ -202,7 +202,7 @@ import {
   selectForkHistory,
   stripSystemReminderBlocks,
   validateForkToolList
-} from "./chunk-SRY26X4H.js";
+} from "./chunk-WVAESIM6.js";
 import {
   collectAvailableSkillEntries,
   renderAvailableSkillsBlock
@@ -221,6 +221,9 @@ import {
   isPathWithinRoot,
   require_ignore
 } from "./chunk-432XCUHF.js";
+import {
+  DashScopeOpenAICompatibleProvider
+} from "./chunk-4LLUH3A7.js";
 import {
   openBrowserSecurely,
   shouldAttemptBrowserLaunch
@@ -245,7 +248,7 @@ import {
   addToolArgumentsAttributes,
   addToolCallResultAttributes,
   addUserPromptAttributes
-} from "./chunk-RPYYTL7E.js";
+} from "./chunk-MGSSJT27.js";
 import {
   InvalidStreamError,
   getThoughtSummary
@@ -380,7 +383,7 @@ import {
   updateMCPServerStatus,
   writeLine,
   writeLineSync
-} from "./chunk-4K3RV3OA.js";
+} from "./chunk-36Q4BOUL.js";
 import {
   E_TIMEOUT,
   Mutex,
@@ -408,13 +411,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,
@@ -425,7 +429,7 @@ import {
   require_dist,
   require_fast_deep_equal,
   require_fast_uri
-} from "./chunk-CFDR3GNL.js";
+} from "./chunk-D7D7RXIJ.js";
 import {
   AUTH_ENV_MAPPINGS,
   AuthType,
@@ -439,7 +443,7 @@ import {
   createContentGenerator,
   resetPreloadedContentGenerator,
   resolveContentGeneratorConfigWithSources
-} from "./chunk-H35Q5CEG.js";
+} from "./chunk-MMWH7ERH.js";
 import {
   normalizeMcpToolName,
   sanitizeToolNameForProvider
@@ -491,15 +495,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,
@@ -19962,13 +19979,15 @@ var BaseLlmClient = class {
         );
         let text = "";
         let usage;
+        let hadToolCall = false;
         for await (const chunk of responseStream) {
           text += getResponseText(chunk) ?? "";
+          hadToolCall ||= (getFunctionCalls(chunk)?.length ?? 0) > 0;
           if (chunk.usageMetadata) {
             usage = chunk.usageMetadata;
           }
         }
-        return { text, usage };
+        return { text, usage, hadToolCall };
       } : async () => {
         const result2 = await contentGenerator.generateContent(
           request,
@@ -19976,7 +19995,8 @@ var BaseLlmClient = class {
         );
         return {
           text: getResponseText(result2) ?? "",
-          usage: result2.usageMetadata
+          usage: result2.usageMetadata,
+          hadToolCall: (getFunctionCalls(result2)?.length ?? 0) > 0
         };
       };
       const result = await retryWithBackoff(apiCall, {
@@ -20008,7 +20028,8 @@ var BaseLlmClient = class {
       });
       return {
         text: result.text.trim(),
-        usage: result.usage
+        usage: result.usage,
+        hadToolCall: result.hadToolCall
       };
     } catch (error) {
       if (abortSignal.aborted) {
@@ -22132,7 +22153,7 @@ You have access to the ${ToolNames.TODO_WRITE} tool to keep user-visible progres
 
 When you create a todo list:
 - Keep it short and outcome-oriented. Use a few meaningful, logically ordered, verifiable steps rather than one item per error, file, command, or minor edit.
-- For complex work delegated through top-level Agent calls, create the relevant todo first and pass its ID as \`todo_id\` so the execution can be associated with the plan node.
+- When an active Todo plan covers work delegated through top-level Agent calls, pass the matching Todo ID as \`todo_id\` so the execution can be associated with that plan node. Do not create a Todo solely to wrap a delegation that does not otherwise need task tracking.
 - Keep at most one item in_progress. Keep the list current, mark finished work completed, and revise it when the scope or approach changes. When work completes together, update multiple statuses in one tool call rather than making bookkeeping-only calls.
 - Do not repeat the full todo list in prose after calling the tool; briefly communicate only important context or the next step.
 
@@ -22434,6 +22455,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']
@@ -22573,6 +22597,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>
@@ -22686,6 +22719,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>
@@ -22767,6 +22805,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|>
@@ -29318,17 +29359,14 @@ function recordSegmentBytes(index, uuid) {
   return entry?.segments.reduce((total, segment) => total + segment.length, 0) ?? 0;
 }
 __name(recordSegmentBytes, "recordSegmentBytes");
-function selectPageUuids(index, sessionId, position, limit, maxBytes) {
+function selectPageUuids(index, position, limit, maxBytes) {
   const candidates = index.activeUuids.slice(position, position + limit);
   if (maxBytes === void 0) return candidates;
   const selected = [];
   let selectedBytes = 0;
   for (const uuid of candidates) {
     const bytes = recordSegmentBytes(index, uuid);
-    if (selected.length === 0 && bytes > maxBytes) {
-      throw new SessionTranscriptPageTooLargeError(sessionId, bytes, maxBytes);
-    }
-    if (selectedBytes + bytes > maxBytes) break;
+    if (selected.length > 0 && selectedBytes + bytes > maxBytes) break;
     selected.push(uuid);
     selectedBytes += bytes;
   }
@@ -29340,7 +29378,7 @@ function isReplayTurnStart(index, uuid) {
   return entry?.type === "user" && entry.subtype !== "mid_turn_user_message";
 }
 __name(isReplayTurnStart, "isReplayTurnStart");
-function selectBackwardPageUuids(index, sessionId, position, limit, maxBytes) {
+function selectBackwardPageUuids(index, position, limit, maxBytes) {
   let start = Math.max(0, position - limit);
   for (let i = start; i < position; i++) {
     if (isReplayTurnStart(index, index.activeUuids[i])) {
@@ -29356,10 +29394,9 @@ function selectBackwardPageUuids(index, sessionId, position, limit, maxBytes) {
   for (let i = position - 1; i >= start; i--) {
     const uuid = index.activeUuids[i];
     const bytes = recordSegmentBytes(index, uuid);
-    if (selectedStart === position && maxBytes !== void 0 && bytes > maxBytes) {
-      throw new SessionTranscriptPageTooLargeError(sessionId, bytes, maxBytes);
+    if (selectedStart < position && maxBytes !== void 0 && selectedBytes + bytes > maxBytes) {
+      break;
     }
-    if (maxBytes !== void 0 && selectedBytes + bytes > maxBytes) break;
     selectedStart = i;
     selectedBytes += bytes;
   }
@@ -29371,7 +29408,6 @@ function selectBackwardPageUuids(index, sessionId, position, limit, maxBytes) {
       break;
     }
   }
-  let expandedSelection = false;
   if (alignedToReplayBoundary && selectedStart > 0) {
     let previousTurnStart = selectedStart - 1;
     while (previousTurnStart >= 0 && !isReplayTurnStart(index, index.activeUuids[previousTurnStart])) {
@@ -29379,23 +29415,11 @@ function selectBackwardPageUuids(index, sessionId, position, limit, maxBytes) {
     }
     if (previousTurnStart < 0) {
       selectedStart = 0;
-      expandedSelection = true;
     }
   } else if (!alignedToReplayBoundary) {
     while (selectedStart > 0 && !isReplayTurnStart(index, index.activeUuids[selectedStart])) {
       selectedStart--;
     }
-    expandedSelection = true;
-  }
-  if (expandedSelection && maxBytes !== void 0) {
-    const alignedBytes = index.activeUuids.slice(selectedStart, position).reduce((total, uuid) => total + recordSegmentBytes(index, uuid), 0);
-    if (alignedBytes > maxBytes) {
-      throw new SessionTranscriptPageTooLargeError(
-        sessionId,
-        alignedBytes,
-        maxBytes
-      );
-    }
   }
   return {
     uuids: index.activeUuids.slice(selectedStart, position),
@@ -29825,8 +29849,8 @@ var SessionTranscriptReader = class {
       );
       throw new InvalidSessionTranscriptCursorError();
     }
-    const backwardPage = direction === "backward" ? selectBackwardPageUuids(index, sessionId, position, limit, maxBytes) : void 0;
-    const pageUuids = backwardPage?.uuids ?? selectPageUuids(index, sessionId, position, limit, maxBytes);
+    const backwardPage = direction === "backward" ? selectBackwardPageUuids(index, position, limit, maxBytes) : void 0;
+    const pageUuids = backwardPage?.uuids ?? selectPageUuids(index, position, limit, maxBytes);
     const nextPosition = backwardPage?.nextPosition ?? position + pageUuids.length;
     const records = await readAggregatedRecords(index, pageUuids);
     const backwardGoalState = direction === "backward" ? await readGoalStateBeforePosition(index, nextPosition) : void 0;
@@ -35100,7 +35124,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");
@@ -35318,6 +35343,15 @@ function getCitations(resp) {
 }
 __name(getCitations, "getCitations");
 
+// packages/core/src/core/openaiContentGenerator/prefix-caching.ts
+init_esbuild_shims();
+function supportsOpenAIPrefixCaching(contentGeneratorConfig) {
+  return DashScopeOpenAICompatibleProvider.isDashScopeProvider(
+    contentGeneratorConfig
+  );
+}
+__name(supportsOpenAIPrefixCaching, "supportsOpenAIPrefixCaching");
+
 // packages/core/src/services/postCompactAttachments.ts
 init_esbuild_shims();
 import { readFile as readFile7, stat as stat4 } from "node:fs/promises";
@@ -35776,6 +35810,21 @@ Additional Instructions:
 ${parts.join("\n\n")}`;
 }
 __name(buildCompressionSystemPrompt, "buildCompressionSystemPrompt");
+function supportsCompressionCacheSharing(config) {
+  const provider = config.getContentGeneratorConfig();
+  if (provider.enableCacheControl === false) return false;
+  if (provider.authType === "anthropic" /* USE_ANTHROPIC */) return true;
+  return (provider.authType === "qwen-oauth" /* QWEN_OAUTH */ || provider.authType === "openai" /* USE_OPENAI */) && supportsOpenAIPrefixCaching(provider);
+}
+__name(supportsCompressionCacheSharing, "supportsCompressionCacheSharing");
+function hasStateSnapshot(summary) {
+  const stripped = stripAnalysisBlock(summary);
+  const startTag = "<state_snapshot>";
+  const start = stripped.indexOf(startTag);
+  const end = stripped.indexOf("</state_snapshot>", start + startTag.length);
+  return start >= 0 && end > start + startTag.length && stripped.slice(start + startTag.length, end).trim().length > 0;
+}
+__name(hasStateSnapshot, "hasStateSnapshot");
 var ChatCompressionService = class {
   static {
     __name(this, "ChatCompressionService");
@@ -35916,7 +35965,9 @@ var ChatCompressionService = class {
         }
       }
     }
-    const summaryResult = await runSideQuery(config, {
+    const abortSignal = signal ?? new AbortController().signal;
+    abortSignal.throwIfAborted();
+    const runColdCompression = /* @__PURE__ */ __name(() => runSideQuery(config, {
       purpose: "chat-compression",
       skipOutputLanguagePreference: true,
       model: effectiveCompactionModel,
@@ -35953,9 +36004,77 @@ var ChatCompressionService = class {
         thinkingConfig: { includeThoughts: false },
         maxOutputTokens: COMPACT_MAX_OUTPUT_TOKENS
       },
-      abortSignal: signal ?? new AbortController().signal,
+      abortSignal,
       promptId
-    });
+    }), "runColdCompression");
+    let summaryResult;
+    let usedCacheSharing = false;
+    const canShareCache = effectiveCompactionModel === config.getModel() && slim.stats.imagesStripped === 0 && slim.stats.documentsStripped === 0 && supportsCompressionCacheSharing(config);
+    if (canShareCache) {
+      try {
+        const generationConfig = {
+          ...chat.getGenerationConfig(),
+          ...opts.requestGenerationConfig
+        };
+        const mainSystemInstruction = generationConfig.systemInstruction;
+        delete generationConfig.systemInstruction;
+        delete generationConfig.abortSignal;
+        const sharedResult = await config.getBaseLlmClient().generateText({
+          contents: [
+            ...sideQueryHistory,
+            {
+              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.`
+                }
+              ]
+            }
+          ],
+          model: effectiveCompactionModel,
+          systemInstruction: mainSystemInstruction,
+          config: {
+            ...generationConfig,
+            ...config.getContentGeneratorConfig().authType === "anthropic" /* USE_ANTHROPIC */ ? {
+              thinkingConfig: {
+                ...generationConfig.thinkingConfig,
+                // Manual Anthropic thinking requires budget_tokens to be
+                // strictly below max_tokens. Preserve thinking for cache
+                // compatibility while keeping this bounded request valid.
+                thinkingBudget: COMPACT_MAX_OUTPUT_TOKENS - 1
+              }
+            } : {},
+            maxOutputTokens: COMPACT_MAX_OUTPUT_TOKENS
+          },
+          abortSignal,
+          promptId,
+          stream: true,
+          maxAttempts: 1
+        });
+        if (!sharedResult.hadToolCall && hasStateSnapshot(sharedResult.text)) {
+          summaryResult = sharedResult;
+          usedCacheSharing = true;
+          config.getDebugLogger().debug(
+            `[chat-compression] cache-sharing request succeeded; cachedContentTokenCount=${sharedResult.usage?.cachedContentTokenCount ?? 0}`
+          );
+        } else {
+          config.getDebugLogger().warn(
+            `[chat-compression] cache-sharing response was unusable (${sharedResult.hadToolCall ? "tool call" : "invalid state snapshot"}); falling back to the dedicated summarizer.`
+          );
+        }
+      } catch (error) {
+        if (abortSignal.aborted) throw error;
+        config.getDebugLogger().warn(
+          `[chat-compression] cache-sharing request failed; falling back to the dedicated summarizer: ${String(error)}`
+        );
+      }
+    }
+    if (!summaryResult) {
+      abortSignal.throwIfAborted();
+      summaryResult = await runColdCompression();
+    }
     const summary = summaryResult.text;
     const isSummaryEmpty = !summary || stripAnalysisBlock(summary).trim().length === 0;
     const compressionUsageMetadata = summaryResult.usage;
@@ -35976,7 +36095,7 @@ var ChatCompressionService = class {
         `[chat-compression] compression side-query omitted usage metadata; using local estimate for summary output token count (${compressionOutputTokenCount}).`
       );
     }
-    if (!isSummaryEmpty && typeof compressionOutputTokenCount === "number" && compressionOutputTokenCount >= COMPACT_MAX_OUTPUT_TOKENS) {
+    if (!usedCacheSharing && !isSummaryEmpty && typeof compressionOutputTokenCount === "number" && compressionOutputTokenCount >= COMPACT_MAX_OUTPUT_TOKENS) {
       config.getDebugLogger().warn(
         `[chat-compression] summary output reached the COMPACT_MAX_OUTPUT_TOKENS cap (${COMPACT_MAX_OUTPUT_TOKENS}); dropping potentially-truncated result. This counts as a compression failure for the per-chat circuit breaker.`
       );
@@ -36039,7 +36158,7 @@ var ChatCompressionService = class {
           }
         ];
       }
-      if (typeof compressionInputTokenCount === "number" && compressionInputTokenCount > 0 && typeof compressionOutputTokenCount === "number" && compressionOutputTokenCount > 0) {
+      if (!usedCacheSharing && typeof compressionInputTokenCount === "number" && compressionInputTokenCount > 0 && typeof compressionOutputTokenCount === "number" && compressionOutputTokenCount > 0) {
         canCalculateNewTokenCount = true;
         const compressedHistoryTokenCount = Math.max(
           0,
@@ -36071,7 +36190,7 @@ var ChatCompressionService = class {
           newTokenCount = estimatedNonVisibleTokenCount + estimatedNewVisibleTokenCount;
           canCalculateNewTokenCount = true;
           config.getDebugLogger().debug(
-            `[chat-compression] usage metadata missing; estimated post-compression token count by preserving the API-reported non-visible remainder (${estimatedNonVisibleTokenCount}) and replacing the visible-history estimate (${estimatedOriginalVisibleTokenCount} -> ${estimatedNewVisibleTokenCount}).`
+            `[chat-compression] ${usedCacheSharing ? "cache-sharing token accounting" : "usage metadata missing"}; estimated post-compression token count by preserving the API-reported non-visible remainder (${estimatedNonVisibleTokenCount}) and replacing the visible-history estimate (${estimatedOriginalVisibleTokenCount} -> ${estimatedNewVisibleTokenCount}).`
           );
         }
       }
@@ -36082,7 +36201,9 @@ var ChatCompressionService = class {
         tokens_before: originalTokenCount,
         tokens_after: newTokenCount,
         compression_input_token_count: compressionInputTokenCount,
-        compression_output_token_count: compressionOutputTokenCount
+        compression_output_token_count: compressionOutputTokenCount,
+        cache_sharing_attempted: canShareCache,
+        cache_sharing_used: usedCacheSharing
       })
     );
     if (isSummaryEmpty) {
@@ -36787,14 +36908,14 @@ var RETRYABLE_STREAM_TRANSPORT_CODES = /* @__PURE__ */ new Set([
 // packages/core/src/core/geminiChat.ts
 var debugLogger22 = createDebugLogger("QWEN_CODE_CHAT");
 var GEMINI_EMPTY_CONTENT_PLACEHOLDER = "(empty content)";
-function isToolCallPreparationOnly(response) {
-  if (getToolCallPreparations(response).length === 0) return false;
-  const hasCandidateOutput = response.candidates?.some(
-    (candidate) => Boolean(candidate.finishReason) || (candidate.content?.parts?.length ?? 0) > 0
+function hasCandidateOutput(response) {
+  return Boolean(
+    response.candidates?.some(
+      (candidate) => Boolean(candidate.finishReason) || (candidate.content?.parts?.length ?? 0) > 0
+    )
   );
-  return !hasCandidateOutput && !response.usageMetadata;
 }
-__name(isToolCallPreparationOnly, "isToolCallPreparationOnly");
+__name(hasCandidateOutput, "hasCandidateOutput");
 function hasNonThoughtCandidateParts(response) {
   return Boolean(
     response.candidates?.some(
@@ -36927,11 +37048,24 @@ var INVALID_STREAM_RETRY_CONFIG = {
 };
 var TRANSPORT_STREAM_RETRY_CONFIG = {
   maxRetries: 2,
-  initialDelayMs: 1e3
+  initialDelayMs: 1e3,
+  /**
+   * Budget for *continuation* recovery after a socket-level cut that already
+   * delivered output (issue #7832). This is a different mechanism from the
+   * `maxRetries` replay above and therefore has its own budget: a replay
+   * re-sends the request from scratch and is only legal before any chunk
+   * reached callers, while a continuation keeps the delivered output and asks
+   * the model to resume from it. A single long generation can be cut more than
+   * once by the same gateway idle timeout, so this is sized like
+   * {@link MAX_OUTPUT_RECOVERY_ATTEMPTS} rather than like the replay budget.
+   */
+  maxContinuationRetries: 3
 };
 var FIRST_SEND_CLAMP_OVERHEAD_PAD = 2e4;
 var MAX_OUTPUT_RECOVERY_ATTEMPTS = 3;
-var OUTPUT_RECOVERY_MESSAGE = "Output token limit hit. Resume directly \u2014 no apology, no recap of what you were doing. Pick up mid-thought if that is where the cut happened. Break remaining work into smaller pieces.";
+var RECOVERY_RESUME_INSTRUCTION = "Resume directly \u2014 no apology, no recap of what you were doing. Pick up mid-thought if that is where the cut happened. Break remaining work into smaller pieces.";
+var OUTPUT_RECOVERY_MESSAGE = `Output token limit hit. ${RECOVERY_RESUME_INSTRUCTION}`;
+var TRANSPORT_CONTINUATION_MESSAGE = `The connection dropped mid-response. ${RECOVERY_RESUME_INSTRUCTION}`;
 var OUTPUT_RECOVERY_TAIL_CHARS = 1200;
 var RECOVERY_OVERLAP_MAX_SCAN_CHARS = 4e3;
 var RECOVERY_OVERLAP_MIN_BYTES = 6;
@@ -37046,20 +37180,26 @@ function sanitizeRecoverySuffixTail(tail) {
   return tail.replace(/<\/previous_response_suffix>/g, "<\u200B/previous_response_suffix>").replace(/<previous_response_suffix>/g, "<\u200Bprevious_response_suffix>");
 }
 __name(sanitizeRecoverySuffixTail, "sanitizeRecoverySuffixTail");
-function buildOutputRecoveryMessage(previousModelTurn) {
-  const previousText = previousModelTurn?.role === "model" ? getPlainTextFromParts(previousModelTurn.parts) : "";
+function buildRecoveryMessageFromText(lead, previousText) {
   if (previousText.trim().length === 0) {
-    return OUTPUT_RECOVERY_MESSAGE;
+    return lead;
   }
   const rawTail = previousText.length > OUTPUT_RECOVERY_TAIL_CHARS ? previousText.slice(-OUTPUT_RECOVERY_TAIL_CHARS) : previousText;
   const tail = sanitizeRecoverySuffixTail(rawTail);
-  return `${OUTPUT_RECOVERY_MESSAGE}
+  return `${lead}
 
 The previous assistant response ended with this exact suffix. Do not repeat any line, table row, code line, or prose that already appears in it; output only text that comes after this suffix:
 
 <previous_response_suffix>
 ` + tail + "\n</previous_response_suffix>";
 }
+__name(buildRecoveryMessageFromText, "buildRecoveryMessageFromText");
+function buildOutputRecoveryMessage(previousModelTurn) {
+  return buildRecoveryMessageFromText(
+    OUTPUT_RECOVERY_MESSAGE,
+    previousModelTurn?.role === "model" ? getPlainTextFromParts(previousModelTurn.parts) : ""
+  );
+}
 __name(buildOutputRecoveryMessage, "buildOutputRecoveryMessage");
 function appendRecoveryContinuationParts(previousParts, continuationParts) {
   const mergedParts = [...previousParts ?? []];
@@ -37247,6 +37387,26 @@ var PROTOCOL_TAG_PREFIXES = [
   "<summary",
   "</summary"
 ];
+var LEAKED_TOOL_CALL_TAGS = /[}\]]\s*<\/parameter>\s*<\/function>/iy;
+function hasLeakedToolCallTags(text) {
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < text.length; i++) {
+    const char = text[i];
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (char === "\\") escaped = true;
+      else if (char === '"') inString = false;
+    } else if (char === '"') {
+      inString = true;
+    } else if (char === "}" || char === "]") {
+      LEAKED_TOOL_CALL_TAGS.lastIndex = i;
+      if (LEAKED_TOOL_CALL_TAGS.test(text)) return true;
+    }
+  }
+  return false;
+}
+__name(hasLeakedToolCallTags, "hasLeakedToolCallTags");
 var LeadingProtocolTagLeakDetector = class {
   static {
     __name(this, "LeadingProtocolTagLeakDetector");
@@ -37257,6 +37417,7 @@ var LeadingProtocolTagLeakDetector = class {
     if (this.state === "clean") return text;
     if (this.state === "leaked") return "";
     this.buffer += text;
+    if (this.state === "json") return "";
     const candidate = this.buffer.trimStart().toLowerCase();
     if (!candidate) return "";
     if (PROTOCOL_TAG_PREFIXES.some((prefix) => prefix.startsWith(candidate))) {
@@ -37269,12 +37430,29 @@ var LeadingProtocolTagLeakDetector = class {
         return "";
       }
     }
-    this.state = "clean";
-    const output = this.buffer;
-    this.buffer = "";
-    return output;
+    if (candidate.startsWith("{")) {
+      this.state = "json";
+      return "";
+    }
+    if (candidate.startsWith("[")) {
+      const normalized2 = candidate.replace(/\s/g, "");
+      if (normalized2 === "[") return "";
+      if (normalized2.startsWith("[{")) {
+        this.state = "json";
+        return "";
+      }
+    }
+    return this.release();
   }
   finish() {
+    if (this.state === "json") {
+      if (hasLeakedToolCallTags(this.buffer)) {
+        this.state = "leaked";
+        this.buffer = "";
+        return "";
+      }
+      return this.release();
+    }
     if (this.state !== "detecting") return "";
     const candidate = this.buffer.trimStart().toLowerCase();
     if (candidate && PROTOCOL_TAG_PREFIXES.some((prefix) => prefix.startsWith(candidate))) {
@@ -37282,8 +37460,11 @@ var LeadingProtocolTagLeakDetector = class {
       this.buffer = "";
       return "";
     }
-    this.state = "clean";
+    return this.release();
+  }
+  release() {
     const output = this.buffer;
+    this.state = "clean";
     this.buffer = "";
     return output;
   }
@@ -37664,6 +37845,7 @@ var GeminiChat = class {
       originalTokenCount: options2?.originalTokenCountOverride ?? this.lastPromptTokenCount,
       pendingUserMessage: options2?.pendingUserMessage,
       precomputedEffectiveTokens: options2?.precomputedEffectiveTokens,
+      requestGenerationConfig: options2?.requestGenerationConfig,
       trigger: options2?.trigger,
       customInstructions: options2?.customInstructions,
       signal
@@ -37893,6 +38075,7 @@ var GeminiChat = class {
           {
             pendingUserMessage: userContent,
             precomputedEffectiveTokens: effectiveTokens,
+            requestGenerationConfig: params.config,
             deferChatCompressionRecord: shouldForceFromHard,
             // Hard-rescue is force=true to bypass the cheap-gate breaker
             // but it remains a semantically AUTOMATIC trigger. Tag the
@@ -38033,6 +38216,10 @@ var GeminiChat = class {
         let protocolTagLeakRetryCount = 0;
         const totalInvalidStreamRetryCount = /* @__PURE__ */ __name(() => transientInvalidStreamRetryCount + protocolTagLeakRetryCount, "totalInvalidStreamRetryCount");
         let transportStreamRetryCount = 0;
+        let transportContinuationCount = 0;
+        let transportContinuationText = "";
+        let transportAttemptText = "";
+        let transportContinuationPrefix = "";
         let reactiveCompressionAttempted = false;
         let suppressNextRetryEvent = false;
         let streamYieldedAnyChunk = false;
@@ -38059,18 +38246,49 @@ var GeminiChat = class {
         );
         const shouldEscalateMaxOutputTokens = effectiveInitialMaxOutputTokens < escalatedLimit;
         let lastFinishReason;
+        const buildAttemptContents = /* @__PURE__ */ __name(() => transportContinuationPrefix.length > 0 ? [
+          ...requestContents,
+          {
+            role: "model",
+            parts: [{ text: transportContinuationPrefix }]
+          },
+          createUserContent([
+            {
+              text: buildRecoveryMessageFromText(
+                TRANSPORT_CONTINUATION_MESSAGE,
+                transportContinuationPrefix
+              )
+            }
+          ])
+        ] : requestContents, "buildAttemptContents");
+        const resetTransportContinuation = /* @__PURE__ */ __name(() => {
+          transportContinuationCount = 0;
+          transportContinuationText = "";
+          transportAttemptText = "";
+          transportContinuationPrefix = "";
+        }, "resetTransportContinuation");
+        const foldTransportAttemptText = /* @__PURE__ */ __name(() => {
+          transportContinuationText += getRecoveryContinuationSuffix(
+            transportContinuationText,
+            transportAttemptText
+          );
+          transportAttemptText = "";
+        }, "foldTransportAttemptText");
         for (; ; ) {
+          transportAttemptText = "";
           let streamYieldedChunk = false;
           let streamYieldedContentChunk = false;
+          let streamYieldedFunctionCall = false;
           try {
             if (suppressNextRetryEvent) {
               suppressNextRetryEvent = false;
-            } else if (rateLimitRetryCount > 0 || totalInvalidStreamRetryCount() > 0 || transportStreamRetryCount > 0) {
+            } else if (rateLimitRetryCount > 0 || totalInvalidStreamRetryCount() > 0 || transportStreamRetryCount > 0 || transportContinuationCount > 0) {
+              resetTransportContinuation();
               yield { type: "retry" /* RETRY */ };
             }
             const stream2 = await self2.makeApiCallAndProcessStream(
               model,
-              requestContents,
+              buildAttemptContents(),
               params,
               prompt_id,
               requestOverrides,
@@ -38078,21 +38296,31 @@ var GeminiChat = class {
             );
             lastFinishReason = void 0;
             for await (const chunk of stream2) {
-              if (!isToolCallPreparationOnly(chunk)) {
+              if (hasCandidateOutput(chunk)) {
                 streamYieldedChunk = true;
                 streamYieldedAnyChunk = true;
               }
               if (hasNonThoughtCandidateParts(chunk)) {
                 streamYieldedContentChunk = true;
               }
+              const chunkParts = chunk.candidates?.[0]?.content?.parts;
+              transportAttemptText += getPlainTextFromParts(chunkParts);
+              if (chunkParts?.some((part) => part.functionCall)) {
+                streamYieldedFunctionCall = true;
+              }
               const fr2 = chunk.candidates?.[0]?.finishReason;
               if (fr2) lastFinishReason = fr2;
               yield { type: "chunk" /* CHUNK */, value: chunk };
             }
             lastError = null;
+            if (transportContinuationPrefix.length > 0) {
+              self2.prependTextToLastModelTurn(transportContinuationPrefix);
+              transportContinuationPrefix = "";
+            }
             break;
           } catch (error) {
             lastError = error;
+            foldTransportAttemptText();
             const classification = classifyRetryError(error, {
               authType: cgConfig?.authType,
               extraRetryErrorCodes
@@ -38165,7 +38393,15 @@ var GeminiChat = class {
             const isRetryableStreamTransportError = classification.kind === "transport" && classification.transportCode !== void 0 && RETRYABLE_STREAM_TRANSPORT_CODES.has(
               classification.transportCode
             );
-            if (isRetryableStreamTransportError && !streamYieldedContentChunk && transportStreamRetryCount < TRANSPORT_STREAM_RETRY_CONFIG.maxRetries) {
+            if (isRetryableStreamTransportError && !streamYieldedContentChunk && // `streamYieldedContentChunk` is per-attempt, so on its own it
+            // cannot tell "nothing has been delivered" from "this attempt
+            // was cut while thinking, after earlier attempts already put
+            // text on screen". Only the first is replayable; replaying the
+            // second discards output the caller is watching. The
+            // accumulated buffer is what distinguishes them, and it must be
+            // consulted here because this branch is checked before the
+            // continuation one below.
+            transportContinuationText.trim().length === 0 && transportStreamRetryCount < TRANSPORT_STREAM_RETRY_CONFIG.maxRetries) {
               self2.popPendingPartialAssistantTurn();
               transportStreamRetryCount++;
               const delayMs = TRANSPORT_STREAM_RETRY_CONFIG.initialDelayMs * transportStreamRetryCount;
@@ -38180,6 +38416,28 @@ var GeminiChat = class {
                 transportCode: classification.transportCode
               });
               yield { type: "retry" /* RETRY */ };
+              resetTransportContinuation();
+              suppressNextRetryEvent = true;
+              await delay2(delayMs, params.config?.abortSignal).promise;
+              continue;
+            }
+            const canContinueAfterTransportCut = isRetryableStreamTransportError && !streamYieldedFunctionCall && transportContinuationText.trim().length > 0 && transportContinuationCount < TRANSPORT_STREAM_RETRY_CONFIG.maxContinuationRetries;
+            if (canContinueAfterTransportCut) {
+              self2.popPendingPartialAssistantTurn();
+              transportContinuationCount++;
+              transportContinuationPrefix = transportContinuationText;
+              const delayMs = TRANSPORT_STREAM_RETRY_CONFIG.initialDelayMs * transportContinuationCount;
+              debugLogger22.warn("Transport stream continuation scheduled", {
+                retryPath: "stream",
+                retryDecision: "continue",
+                attempt: transportContinuationCount,
+                maxRetries: TRANSPORT_STREAM_RETRY_CONFIG.maxContinuationRetries,
+                retryDelayMs: delayMs,
+                errorKind: classification.kind,
+                transportCode: classification.transportCode,
+                deliveredChars: transportContinuationText.length
+              });
+              yield { type: "retry" /* RETRY */, isContinuation: true };
               suppressNextRetryEvent = true;
               await delay2(delayMs, params.config?.abortSignal).promise;
               continue;
@@ -38190,6 +38448,8 @@ var GeminiChat = class {
                 retryDecision: streamYieldedContentChunk ? "skipped_after_content" : "exhausted",
                 attempts: transportStreamRetryCount,
                 maxRetries: TRANSPORT_STREAM_RETRY_CONFIG.maxRetries,
+                continuationAttempts: transportContinuationCount,
+                maxContinuationRetries: TRANSPORT_STREAM_RETRY_CONFIG.maxContinuationRetries,
                 errorKind: classification.kind,
                 transportCode: classification.transportCode
               });
@@ -38209,6 +38469,7 @@ var GeminiChat = class {
                     params.config?.abortSignal,
                     {
                       originalTokenCountOverride: reactiveOriginalTokenCount,
+                      requestGenerationConfig: params.config,
                       trigger: "auto"
                     }
                   );
@@ -38244,6 +38505,7 @@ var GeminiChat = class {
                       info: reactiveInfo
                     };
                     yield { type: "retry" /* RETRY */ };
+                    resetTransportContinuation();
                     suppressNextRetryEvent = true;
                     continue;
                   }
@@ -38612,7 +38874,7 @@ var GeminiChat = class {
                     fallbackRetryErrorCodes,
                     turnGoalContext
                   )) {
-                    const emittedUserVisibleOutput = event.type !== "chunk" /* CHUNK */ || !isToolCallPreparationOnly(event.value);
+                    const emittedUserVisibleOutput = event.type !== "chunk" /* CHUNK */ || hasCandidateOutput(event.value);
                     if (emittedUserVisibleOutput) {
                       currentFallbackYieldedAnyChunk = true;
                       fallbackStreamYieldedAnyChunk = true;
@@ -39096,6 +39358,21 @@ This error was probably caused by cyclic schema references in one of the followi
     let hasToolCall = false;
     let hasFinishReason = false;
     const protocolTagDetector = new LeadingProtocolTagLeakDetector();
+    let pendingProtocolParts = [];
+    const takePendingProtocolParts = /* @__PURE__ */ __name(() => {
+      const parts = pendingProtocolParts;
+      pendingProtocolParts = [];
+      const released = [];
+      for (const part of parts) {
+        const previous = released.at(-1);
+        if (previous && isValidNonThoughtTextPart(previous) && isValidNonThoughtTextPart(part)) {
+          previous.text += part.text;
+        } else {
+          released.push(isValidNonThoughtTextPart(part) ? { ...part } : part);
+        }
+      }
+      return released;
+    }, "takePendingProtocolParts");
     let protocolTextWasSuppressed = false;
     const currentUserTurn = this.history[this.history.length - 1];
     const isToolResultContinuation = currentUserTurn?.role === "user" && currentUserTurn.parts?.some((part) => part.functionResponse) === true;
@@ -39120,22 +39397,57 @@ This error was probably caused by cyclic schema references in one of the followi
         hasFinishReason ||= chunk?.candidates?.some((candidate) => candidate.finishReason) ?? false;
         if (isValidResponse(chunk)) {
           const candidate = chunk.candidates?.[0];
-          const content = candidate?.content;
+          let content = candidate?.content;
+          if (candidate?.finishReason && !content?.parts) {
+            protocolTagDetector.finish();
+            if (protocolTagDetector.leaked) {
+              pendingProtocolParts = [];
+            } else {
+              const parts = takePendingProtocolParts();
+              if (parts.length > 0) {
+                content = {
+                  ...content,
+                  role: content?.role ?? "model",
+                  parts
+                };
+                candidate.content = content;
+              }
+            }
+          }
           if (content?.parts) {
-            content.parts = content.parts.flatMap((part) => {
+            const outputParts = [];
+            for (const part of content.parts) {
               if (isToolResultContinuation && !part.thought && part.text?.trim() === GEMINI_EMPTY_CONTENT_PLACEHOLDER) {
-                return [];
+                continue;
+              }
+              if (typeof part.text !== "string" || part.thought) {
+                if (pendingProtocolParts.length > 0 || protocolTagDetector.leaked) {
+                  pendingProtocolParts.push(part);
+                } else {
+                  outputParts.push(part);
+                }
+                continue;
               }
-              if (typeof part.text !== "string" || part.thought) return [part];
               const text = protocolTagDetector.accept(part.text);
-              if (text) return [{ ...part, text }];
+              if (text) {
+                if (pendingProtocolParts.length > 0) {
+                  outputParts.push(...takePendingProtocolParts(), part);
+                } else {
+                  outputParts.push({ ...part, text });
+                }
+                continue;
+              }
+              pendingProtocolParts.push(...outputParts.splice(0), part);
               protocolTextWasSuppressed ||= part.text.length > 0;
-              const { text: _text, ...rest } = part;
-              return Object.values(rest).some((value) => value !== void 0) ? [rest] : [];
-            });
+            }
+            content.parts = outputParts;
             if (candidate?.finishReason) {
-              const text = protocolTagDetector.finish();
-              if (text) content.parts.push({ text });
+              protocolTagDetector.finish();
+              if (protocolTagDetector.leaked) {
+                pendingProtocolParts = [];
+              } else {
+                content.parts.push(...takePendingProtocolParts());
+              }
             }
             content.parts = normalizeModelToolCallIds(
               content.parts,
@@ -39208,13 +39520,33 @@ This error was probably caused by cyclic schema references in one of the followi
             }
           }
         }
-        if (!protocolTextWasSuppressed || !protocolTagDetector.blockingOutput) {
+        if (!chunk.candidates?.length || preparations.length > 0 || !protocolTextWasSuppressed || !protocolTagDetector.blockingOutput) {
           yield chunk;
         }
       }
     } catch (e) {
       streamError = e;
     }
+    if (streamError === null && pendingProtocolParts.length > 0 && (hasToolCall || pendingProtocolParts.some((part) => part.functionCall !== void 0))) {
+      protocolTagDetector.finish();
+      if (protocolTagDetector.leaked) {
+        pendingProtocolParts = [];
+      } else {
+        const parts = normalizeModelToolCallIds(
+          takePendingProtocolParts(),
+          usedToolCallIds,
+          rawToolCallIdsInCurrentTurn,
+          reservedToolCallIds
+        );
+        const chunk = {
+          candidates: [{ content: { role: "model", parts } }]
+        };
+        syncFunctionCallsField(chunk, parts);
+        hasToolCall ||= parts.some((part) => part.functionCall);
+        allModelParts.push(...parts);
+        yield chunk;
+      }
+    }
     let thoughtContentPart;
     const thoughtText = allModelParts.filter((part) => part.thought).map((part) => part.text).join("").trim();
     if (thoughtText !== "") {
@@ -39283,7 +39615,7 @@ This error was probably caused by cyclic schema references in one of the followi
         );
       }
     }
-    if (streamError === null && protocolTagDetector.leaked) {
+    if (streamError === null && protocolTagDetector.leaked && !hasToolCall) {
       throw new InvalidStreamError(
         "Model response started with leaked protocol tags.",
         "PROTOCOL_TAG_LEAK"
@@ -39364,6 +39696,49 @@ This error was probably caused by cyclic schema references in one of the followi
       };
     }
   }
+  /**
+   * Prepend already-delivered text to the trailing model turn.
+   *
+   * Used by the transport-continuation path (issue #7832): after a socket cut
+   * mid-response, the caller has seen text that `processStreamResponse`
+   * deliberately did not persist, and the continuation attempt's own turn
+   * carries only the resumed remainder. Without this, durable history would
+   * hold an answer that starts mid-sentence — visibly wrong on `/compress`,
+   * `--resume`, and every later turn's context.
+   *
+   * The delivered text is merged into the turn's first plain-text part (kept
+   * after any leading thought part, matching the
+   * `[thoughtPart?, ...text]` shape `processStreamResponse` produces), or
+   * inserted as a new part when the continuation returned no text of its own.
+   * Overlap is deduped by the same helper the output-recovery merge uses, so a
+   * model that replays part of its previous tail does not double it.
+   */
+  prependTextToLastModelTurn(deliveredText) {
+    if (deliveredText.length === 0) return;
+    const lastEntry = this.history.at(-1);
+    if (lastEntry?.role !== "model") {
+      debugLogger22.warn(
+        "[TRANSPORT_CONTINUATION] Trailing entry is not a model turn; dropping the delivered-text merge.",
+        { role: lastEntry?.role ?? "undefined" }
+      );
+      return;
+    }
+    const parts = [...lastEntry.parts ?? []];
+    const textIndex = parts.findIndex(isPlainTextPart);
+    if (textIndex < 0) {
+      const insertAt = parts.findIndex((part) => !part.thought);
+      parts.splice(insertAt < 0 ? parts.length : insertAt, 0, {
+        text: deliveredText
+      });
+    } else {
+      const continuationPart = parts[textIndex];
+      parts[textIndex] = {
+        ...continuationPart,
+        text: deliveredText + getRecoveryContinuationSuffix(deliveredText, continuationPart.text)
+      };
+    }
+    lastEntry.parts = parts;
+  }
   /**
    * Merge `pairCount` trailing (user_recovery, model_continuation) pairs back
    * into the model turn that precedes them. Used after the output-token
@@ -74245,16 +74620,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 {
@@ -74780,7 +75145,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 */,
@@ -84989,7 +85354,7 @@ async function runManagedRememberByAgent(params) {
       wrapUserContent: true
     }),
     systemPrompt: buildRememberSystemPrompt(memoryPrompt),
-    maxTurns: 6,
+    maxTurns: params.config.getMemoryAgentMaxTurns() ?? 6,
     maxTimeMinutes: params.config.getMemoryAgentTimeoutMinutes() ?? 5,
     extraHistory: params.contextMode === "clean" ? [] : void 0,
     preserveEmptyExtraHistory: params.contextMode === "clean",
@@ -85235,7 +85600,7 @@ async function planManagedAutoMemoryDreamByAgent(config, projectRoot, abortSigna
     config: scopedConfig,
     taskPrompt: buildConsolidationTaskPrompt(memoryRoot, transcriptDir),
     systemPrompt: DREAM_AGENT_SYSTEM_PROMPT,
-    maxTurns: MAX_TURNS,
+    maxTurns: config.getMemoryAgentMaxTurns() ?? MAX_TURNS,
     maxTimeMinutes: config.getMemoryAgentTimeoutMinutes() ?? MAX_TIME_MINUTES,
     tools: [
       ToolNames.READ_FILE,
@@ -85616,7 +85981,7 @@ async function runSkillReviewByAgent(params) {
     config: scopedConfig,
     taskPrompt: await buildTaskPrompt(params.projectRoot),
     systemPrompt: SKILL_REVIEW_SYSTEM_PROMPT,
-    maxTurns: params.maxTurns ?? DEFAULT_AUTO_SKILL_MAX_TURNS,
+    maxTurns: params.maxTurns ?? params.config.getMemoryAgentMaxTurns() ?? DEFAULT_AUTO_SKILL_MAX_TURNS,
     maxTimeMinutes: params.timeoutMs !== void 0 ? params.timeoutMs / 6e4 : params.config.getMemoryAgentTimeoutMinutes() ?? DEFAULT_AUTO_SKILL_TIMEOUT_MS / 6e4,
     tools: [
       ToolNames.READ_FILE,
@@ -130272,18 +130637,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";
@@ -130295,8 +130648,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.`;
@@ -130574,7 +130928,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: [
@@ -130588,10 +130942,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,
@@ -130607,8 +130962,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) {
@@ -130625,6 +130983,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 } : {}
   };
@@ -130757,15 +131116,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
   };
@@ -130827,6 +131190,9 @@ var CoreToolScheduler = class {
   chatRecordingService;
   onToolResultFullTurnModel;
   isFinalizingToolCalls = false;
+  postToolBatchEnabledForBatch = false;
+  postToolBatchSpanCallId;
+  postToolBatchConfigWarned = false;
   isScheduling = false;
   validationRetryCounts = /* @__PURE__ */ new Map();
   autoModeFallbackCallIds = /* @__PURE__ */ new Set();
@@ -130909,7 +131275,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;
@@ -130990,8 +131356,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,
@@ -131009,6 +131378,7 @@ var CoreToolScheduler = class {
             resultDisplay: preservedResultDisplay,
             error: void 0,
             errorType: void 0,
+            executionStatus: executionStatus ?? "not_started",
             contentLength: errorMessage.length
           };
           return {
@@ -131054,8 +131424,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(
@@ -131068,10 +131440,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 },
@@ -131080,18 +131454,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
@@ -131101,10 +131511,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);
@@ -131181,7 +131593,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");
@@ -131189,7 +131602,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);
@@ -131389,6 +131802,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
@@ -131480,147 +131900,220 @@ var CoreToolScheduler = class {
         return count;
       }, "recordBatchRetryableToolError");
       for (const [requestIndex, reqInfo] of requestsToProcess.entries()) {
-        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 */
-            ),
-            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}`;
+        let resolvedTool;
+        let resolvedInvocation;
+        const recordPrevalidationCancellation = /* @__PURE__ */ __name(() => {
+          if (!signal.aborted) return false;
           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,
@@ -131648,16 +132141,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;
@@ -131670,6 +132155,9 @@ var CoreToolScheduler = class {
               toolParams
             )
           );
+          if (this.cancelPreExecutionIfAborted(reqInfo.callId, signal, toolSpan)) {
+            continue;
+          }
           const {
             defaultPermission,
             finalPermission,
@@ -131714,7 +132202,8 @@ var CoreToolScheduler = class {
               createErrorResponse(
                 reqInfo,
                 new Error(message),
-                "execution_denied" /* EXECUTION_DENIED */
+                "execution_denied" /* EXECUTION_DENIED */,
+                "not_started"
               )
             );
             setToolSpanFailure(
@@ -131732,7 +132221,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(
@@ -131765,12 +132255,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
             });
@@ -131792,6 +132286,9 @@ var CoreToolScheduler = class {
                 signal
               })
             );
+            if (this.cancelPreExecutionIfAborted(reqInfo.callId, signal, toolSpan)) {
+              continue;
+            }
             if (initialPlanShellError) {
               rejectPlanShell(initialPlanShellError);
               continue;
@@ -131832,6 +132329,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,
@@ -131856,6 +132356,9 @@ var CoreToolScheduler = class {
                 );
               }
             }
+            if (this.cancelPreExecutionIfAborted(reqInfo.callId, signal, toolSpan)) {
+              continue;
+            }
             switch (outcome.kind) {
               case "approved":
                 this.setToolCallOutcome(
@@ -131874,9 +132377,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") {
@@ -131911,6 +132421,9 @@ var CoreToolScheduler = class {
               reqInfo,
               () => invocation.getConfirmationDetails(signal)
             );
+            if (this.cancelPreExecutionIfAborted(reqInfo.callId, signal, toolSpan)) {
+              continue;
+            }
             if (autoModeFallbackMessage) {
               confirmationDetails = decorateClassifierUnavailableConfirmation(
                 confirmationDetails,
@@ -131928,6 +132441,13 @@ var CoreToolScheduler = class {
                   signal
                 })
               );
+              if (this.cancelPreExecutionIfAborted(
+                reqInfo.callId,
+                signal,
+                toolSpan
+              )) {
+                continue;
+              }
               if (preDisplayPlanShellError) {
                 rejectPlanShell(preDisplayPlanShellError);
                 continue;
@@ -131961,7 +132481,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."
               });
@@ -131994,7 +132515,8 @@ var CoreToolScheduler = class {
                 createErrorResponse(
                   reqInfo,
                   new Error(errorMessage),
-                  "execution_denied" /* EXECUTION_DENIED */
+                  "execution_denied" /* EXECUTION_DENIED */,
+                  "not_started"
                 )
               );
               setToolSpanFailure(
@@ -132021,6 +132543,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") {
@@ -132036,6 +132565,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,
@@ -132044,6 +132580,13 @@ var CoreToolScheduler = class {
                           approval.payload
                         )
                       );
+                      if (this.cancelPreExecutionIfAborted(
+                        reqInfo.callId,
+                        signal,
+                        toolSpan
+                      )) {
+                        continue;
+                      }
                       rejectPlanShell(
                         approval.payload?.cancelMessage ?? planShellDecision.noApprovalMessage
                       );
@@ -132056,6 +132599,13 @@ var CoreToolScheduler = class {
                         approval.payload
                       )
                     );
+                    if (this.cancelPreExecutionIfAborted(
+                      reqInfo.callId,
+                      signal,
+                      toolSpan
+                    )) {
+                      continue;
+                    }
                     this.recordAutoModeFallbackResolution(
                       reqInfo.callId,
                       approval.outcome
@@ -132065,10 +132615,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,
@@ -132076,6 +132628,13 @@ var CoreToolScheduler = class {
                       "proceed_once" /* ProceedOnce */
                     )
                   );
+                  if (this.cancelPreExecutionIfAborted(
+                    reqInfo.callId,
+                    signal,
+                    toolSpan
+                  )) {
+                    continue;
+                  }
                   this.recordAutoModeFallbackResolution(
                     reqInfo.callId,
                     "proceed_once" /* ProceedOnce */
@@ -132094,6 +132653,13 @@ var CoreToolScheduler = class {
                       cancelPayload
                     )
                   );
+                  if (this.cancelPreExecutionIfAborted(
+                    reqInfo.callId,
+                    signal,
+                    toolSpan
+                  )) {
+                    continue;
+                  }
                   this.recordAutoModeFallbackResolution(
                     reqInfo.callId,
                     "cancel" /* Cancel */
@@ -132110,7 +132676,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(
@@ -132135,7 +132702,8 @@ var CoreToolScheduler = class {
                 createErrorResponse(
                   reqInfo,
                   new Error(errorMessage),
-                  "execution_denied" /* EXECUTION_DENIED */
+                  "execution_denied" /* EXECUTION_DENIED */,
+                  "not_started"
                 )
               );
               setToolSpanFailure(
@@ -132146,14 +132714,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") {
@@ -132167,6 +132728,13 @@ var CoreToolScheduler = class {
                   signal
                 })
               );
+              if (this.cancelPreExecutionIfAborted(
+                reqInfo.callId,
+                signal,
+                toolSpan
+              )) {
+                continue;
+              }
               if (finalPreDisplayPlanShellError) {
                 rejectPlanShell(finalPreDisplayPlanShellError);
                 continue;
@@ -132253,7 +132821,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);
@@ -132267,7 +132836,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");
@@ -132290,6 +132860,7 @@ var CoreToolScheduler = class {
       }
     } finally {
       this.isScheduling = false;
+      this.drainRequestQueueIfIdle();
     }
   }
   async handleConfirmationResponse(callId, originalOnConfirm, outcome, signal, payload) {
@@ -132333,6 +132904,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) {
@@ -132376,7 +132966,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);
@@ -132431,7 +133021,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,
@@ -132440,11 +133030,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";
@@ -132528,7 +133120,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);
@@ -132544,11 +133136,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) {
@@ -132662,10 +133257,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);
@@ -132805,7 +133400,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(
@@ -132820,7 +133415,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(
@@ -132846,16 +133442,23 @@ var CoreToolScheduler = class {
         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(
@@ -132866,7 +133469,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) {
@@ -132884,12 +133506,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(
@@ -132940,30 +133564,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;
@@ -132998,14 +133632,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(
@@ -133037,15 +133681,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;
@@ -133102,12 +133768,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,
@@ -133273,6 +133948,7 @@ ${body}
           ),
           error: void 0,
           errorType: void 0,
+          executionStatus,
           contentLength,
           ...persistedOutputFiles !== void 0 ? { persistedOutputFiles } : {},
           // Propagate modelOverride from skill tools. Use `in` to distinguish
@@ -133304,6 +133980,12 @@ ${body}
             );
           }
         }
+        if (cancelAfterPostProcessing(artifacts, {
+          persistedOutputFiles: successResponse.persistedOutputFiles,
+          visionBridgeNotice: successResponse.visionBridgeNotice
+        })) {
+          return;
+        }
         this.setStatusInternal(callId, "success", successResponse);
         safeSetStatus(span, { code: SpanStatusCode.OK });
         try {
@@ -133392,6 +134074,12 @@ ${failureHookResult.additionalContext}`;
               ...timeoutContent.persistedOutputFiles ?? []
             ])
           );
+          if (cancelAfterPostProcessing(artifacts, {
+            persistedOutputFiles: timeoutPersistedOutputFiles,
+            visionBridgeNotice: processedImages.visionBridgeNotice
+          })) {
+            return;
+          }
           this.setStatusInternal(callId, "error", {
             callId,
             responseParts,
@@ -133400,6 +134088,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 } : {},
@@ -133433,7 +134122,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
@@ -133481,6 +134171,15 @@ ${failureHookResult.additionalContext}`;
             };
           }
         }
+        if (cancelAfterPostProcessing(
+          [...toolResult.artifacts ?? [], ...failureHookArtifacts ?? []],
+          {
+            persistedOutputFiles: errorResponse.persistedOutputFiles,
+            visionBridgeNotice: errorResponse.visionBridgeNotice
+          }
+        )) {
+          return;
+        }
         this.setStatusInternal(callId, "error", errorResponse);
         setToolSpanFailure(
           span,
@@ -133490,14 +134189,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(
@@ -133529,11 +134242,12 @@ ${failureHookResult.additionalContext}`;
         this.setStatusInternal(
           callId,
           "cancelled",
-          failureHookArtifacts && failureHookArtifacts.length > 0 ? createCancelledResponse(
+          createCancelledResponse(
             scheduledCall.request,
             cancelMessage,
+            executionStatus,
             failureHookArtifacts
-          ) : cancelMessage
+          )
         );
         setToolSpanCancelled(span);
         return;
@@ -133567,13 +134281,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
           )
         );
@@ -133604,8 +134335,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)}`
@@ -133619,7 +134349,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,
@@ -133641,15 +134371,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,
@@ -133661,6 +134404,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));
@@ -133671,13 +134417,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();
         }
       }
     }
@@ -133742,6 +134490,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,
@@ -133769,8 +134518,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) {
@@ -133793,6 +134549,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,
@@ -133803,6 +134562,9 @@ ${failureHookResult.additionalContext}`;
             toolParams
           )
         );
+        if (this.cancelPreExecutionIfAborted(pendingTool.request.callId, signal)) {
+          continue;
+        }
         const { finalPermission, pmForcedAsk, pmCtx, requiresUserInteraction } = flowResult;
         if (requiresUserInteraction) {
           continue;
@@ -133830,6 +134592,9 @@ ${failureHookResult.additionalContext}`;
               skipClassifierReason: fallback.fallback ? fallback.reason : void 0
             })
           );
+          if (this.cancelPreExecutionIfAborted(pendingTool.request.callId, signal)) {
+            continue;
+          }
           const outcome = applyAutoModeDecision(
             decision,
             this.config,
@@ -133854,6 +134619,9 @@ ${failureHookResult.additionalContext}`;
               );
             }
           }
+          if (this.cancelPreExecutionIfAborted(pendingTool.request.callId, signal)) {
+            continue;
+          }
           switch (outcome.kind) {
             case "approved":
               this.setToolCallOutcome(
@@ -133874,7 +134642,8 @@ ${failureHookResult.additionalContext}`;
                 createErrorResponse(
                   pendingTool.request,
                   new Error(outcome.errorMessage),
-                  "execution_denied" /* EXECUTION_DENIED */
+                  "execution_denied" /* EXECUTION_DENIED */,
+                  "not_started"
                 )
               );
               this.finalizeBlockedSpan(
@@ -133933,6 +134702,9 @@ ${failureHookResult.additionalContext}`;
           );
         }
       } catch (error) {
+        if (this.cancelPreExecutionIfAborted(pendingTool.request.callId, signal)) {
+          continue;
+        }
         debugLogger122.error(
           `Error checking confirmation for tool ${pendingTool.request.callId}:`,
           error
@@ -138860,7 +139632,7 @@ async function runAutoMemoryExtractionByAgent(config, projectRoot) {
       topicSummaries
     ),
     systemPrompt: EXTRACTION_AGENT_SYSTEM_PROMPT,
-    maxTurns: 5,
+    maxTurns: config.getMemoryAgentMaxTurns() ?? 5,
     maxTimeMinutes: config.getMemoryAgentTimeoutMinutes() ?? 2,
     tools: [
       ToolNames.READ_FILE,
@@ -142242,7 +143014,6 @@ var GeminiClient = class _GeminiClient {
           skillsModified: this.skillsModifiedInSession,
           enabled: autoSkillEnabled,
           threshold: AUTO_SKILL_THRESHOLD,
-          maxTurns: DEFAULT_AUTO_SKILL_MAX_TURNS,
           confirmBeforePersist: this.config.getAutoSkillConfirmEnabled()
         });
         if (skillReviewResult.status === "scheduled") {
@@ -145613,6 +146384,7 @@ var Config = class _Config {
   enableAutoSkill;
   autoSkillConfirm;
   memoryAgentTimeoutMinutes;
+  memoryAgentMaxTurns;
   fastModel;
   webSearchSettings;
   webSearchNoticeEmitted = false;
@@ -145928,6 +146700,7 @@ var Config = class _Config {
     this.enableAutoSkill = params.enableAutoSkill ?? false;
     this.autoSkillConfirm = params.autoSkillConfirm ?? true;
     this.memoryAgentTimeoutMinutes = params.memoryAgentTimeoutMinutes !== void 0 && params.memoryAgentTimeoutMinutes >= 0 ? params.memoryAgentTimeoutMinutes : void 0;
+    this.memoryAgentMaxTurns = params.memoryAgentMaxTurns !== void 0 && Number.isInteger(params.memoryAgentMaxTurns) && params.memoryAgentMaxTurns >= 0 ? params.memoryAgentMaxTurns : void 0;
     this.fastModel = params.fastModel || void 0;
     this.webSearchSettings = params.webSearch;
     this.visionModel = params.visionModel || void 0;
@@ -149243,6 +150016,14 @@ var Config = class _Config {
   getMemoryAgentTimeoutMinutes() {
     return this.memoryAgentTimeoutMinutes;
   }
+  /**
+   * Max turns for background memory agents. Resolves the
+   * `memory.agentMaxTurns` setting. Unset means each agent's built-in default;
+   * 0 disables the turn limit.
+   */
+  getMemoryAgentMaxTurns() {
+    return this.memoryAgentMaxTurns;
+  }
   getPreventSystemSleepEnabled() {
     return this.preventSystemSleep && !this.isSafeMode();
   }
@@ -149982,7 +150763,7 @@ var Config = class _Config {
     }
     if (!enabled) return;
     registry.registerFactory(ToolNames.IMAGE_GEN, async () => {
-      const { ImageGenTool } = await import("./image-gen-UC7XVHI7.js");
+      const { ImageGenTool } = await import("./image-gen-XLFJRDFA.js");
       return new ImageGenTool(this);
     });
   }
@@ -150012,36 +150793,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-HXJXHBI6.js");
+        const { ReadFileTool } = await import("./read-file-IHXKC6D3.js");
         return new ReadFileTool(this);
       });
       await registerLazy(ToolNames.EDIT, async () => {
-        const { EditTool } = await import("./edit-J7SW6UP6.js");
+        const { EditTool } = await import("./edit-QSTJ353U.js");
         return new EditTool(this);
       });
       await registerLazy(ToolNames.NOTEBOOK_EDIT, async () => {
-        const { NotebookEditTool } = await import("./notebook-edit-EZISE7IC.js");
+        const { NotebookEditTool } = await import("./notebook-edit-MALKVMST.js");
         return new NotebookEditTool(this);
       });
       await registerLazy(ToolNames.SHELL, async () => {
-        const { ShellTool: ShellTool2 } = await import("./shell-GLC6OP3C.js");
+        const { ShellTool: ShellTool2 } = await import("./shell-FQLEHJKT.js");
         return new ShellTool2(this);
       });
       await registerGoalWorkerTools();
@@ -150053,43 +150834,43 @@ var Config = class _Config {
     }
     await registerGoalWorkerTools();
     await registerLazy(ToolNames.TOOL_SEARCH, async () => {
-      const { ToolSearchTool } = await import("./tool-search-DEAS54VG.js");
+      const { ToolSearchTool } = await import("./tool-search-MFTNRTFA.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-PE37ARLM.js");
+      const { AgentTool: AgentTool2 } = await import("./agent-W6IG55Q7.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-HGCVVDTZ.js");
+      const { SendMessageTool } = await import("./send-message-TL6FIMMN.js");
       return new SendMessageTool(this);
     });
     await registerLazy(ToolNames.SKILL, async () => {
-      const { SkillTool } = await import("./skill-C7W6M4GO.js");
+      const { SkillTool } = await import("./skill-QAXTGG6F.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-HXJXHBI6.js");
+      const { ReadFileTool } = await import("./read-file-IHXKC6D3.js");
       return new ReadFileTool(this);
     });
     await registerLazy(ToolNames.ZOOM_IMAGE, async () => {
-      const { ZoomImageTool } = await import("./zoom-image-O5YCB7WN.js");
+      const { ZoomImageTool } = await import("./zoom-image-WLSVNK2C.js");
       return new ZoomImageTool(this);
     });
     if (this.getUseRipgrep()) {
@@ -150104,7 +150885,7 @@ var Config = class _Config {
       recordStartupEvent("config_initialize_ripgrep_probe_end");
       if (useRipgrep) {
         await registerLazy(ToolNames.GREP, async () => {
-          const { RipGrepTool: RipGrepTool2 } = await import("./ripGrep-MCETPF2E.js");
+          const { RipGrepTool: RipGrepTool2 } = await import("./ripGrep-7ASLNF5O.js");
           return new RipGrepTool2(this);
         });
       } else {
@@ -150117,7 +150898,7 @@ var Config = class _Config {
           )
         );
         await registerLazy(ToolNames.GREP, async () => {
-          const { GrepTool } = await import("./grep-UJMPVZER.js");
+          const { GrepTool } = await import("./grep-XFBSAUJW.js");
           return new GrepTool(this);
         });
       }
@@ -150125,77 +150906,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-UJMPVZER.js");
+        const { GrepTool } = await import("./grep-XFBSAUJW.js");
         return new GrepTool(this);
       });
     }
     await registerLazy(ToolNames.GLOB, async () => {
-      const { GlobTool } = await import("./glob-F3EAUDAX.js");
+      const { GlobTool } = await import("./glob-4MLY2HOS.js");
       return new GlobTool(this);
     });
     await registerLazy(ToolNames.EDIT, async () => {
-      const { EditTool } = await import("./edit-J7SW6UP6.js");
+      const { EditTool } = await import("./edit-QSTJ353U.js");
       return new EditTool(this);
     });
     await registerLazy(ToolNames.NOTEBOOK_EDIT, async () => {
-      const { NotebookEditTool } = await import("./notebook-edit-EZISE7IC.js");
+      const { NotebookEditTool } = await import("./notebook-edit-MALKVMST.js");
       return new NotebookEditTool(this);
     });
     await registerLazy(ToolNames.WRITE_FILE, async () => {
-      const { WriteFileTool: WriteFileTool2 } = await import("./write-file-RQ4DG5RY.js");
+      const { WriteFileTool: WriteFileTool2 } = await import("./write-file-OHTP7KKV.js");
       return new WriteFileTool2(this);
     });
     await registerLazy(ToolNames.SHELL, async () => {
-      const { ShellTool: ShellTool2 } = await import("./shell-GLC6OP3C.js");
+      const { ShellTool: ShellTool2 } = await import("./shell-FQLEHJKT.js");
       return new ShellTool2(this);
     });
     await registerLazy(ToolNames.TODO_WRITE, async () => {
-      const { TodoWriteTool } = await import("./todoWrite-YKAA57W2.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-4ZFY7KUH.js");
+        const { ExitPlanModeTool: ExitPlanModeTool2 } = await import("./exitPlanMode-GCRUFTNX.js");
         return new ExitPlanModeTool2(this);
       });
     }
     if (!this.sdkMode && supportsUserInteraction) {
       await registerLazy(ToolNames.ENTER_PLAN_MODE, async () => {
-        const { EnterPlanModeTool } = await import("./enterPlanMode-GDSTEFSM.js");
+        const { EnterPlanModeTool } = await import("./enterPlanMode-OWFAGX5J.js");
         return new EnterPlanModeTool(this);
       });
     }
     await registerLazy(ToolNames.ENTER_WORKTREE, async () => {
-      const { EnterWorktreeTool } = await import("./enter-worktree-NRLOHRB6.js");
+      const { EnterWorktreeTool } = await import("./enter-worktree-R73VWVFF.js");
       return new EnterWorktreeTool(this);
     });
     await registerLazy(ToolNames.EXIT_WORKTREE, async () => {
-      const { ExitWorktreeTool } = await import("./exit-worktree-ARVID7DF.js");
+      const { ExitWorktreeTool } = await import("./exit-worktree-6O2324LA.js");
       return new ExitWorktreeTool(this);
     });
     await registerLazy(ToolNames.WEB_FETCH, async () => {
-      const { WebFetchTool } = await import("./web-fetch-Y5QQMPKA.js");
+      const { WebFetchTool } = await import("./web-fetch-Y6VEJMFN.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-VS3TXYQH.js");
+        const { DisplayImageTool } = await import("./display-image-GUJA352B.js");
         return new DisplayImageTool(this);
       });
     }
     if (this.webSearchSettings?.enabled) {
-      const { evaluateWebSearchGate } = await import("./web-search-QKKEU723.js");
+      const { evaluateWebSearchGate } = await import("./web-search-BTKVYWOR.js");
       const gate = evaluateWebSearchGate(this);
       if (gate.ok) {
         await registerLazy(ToolNames.WEB_SEARCH, async () => {
-          const { WebSearchTool } = await import("./web-search-QKKEU723.js");
+          const { WebSearchTool } = await import("./web-search-BTKVYWOR.js");
           return new WebSearchTool(this);
         });
       } else if (!this.webSearchNoticeEmitted && !options2?.forSubAgent) {
@@ -150206,83 +150987,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-L3BAHQFN.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-HBIJ7NHT.js");
+        const { TeamCreateTool } = await import("./team-create-7B5NKWA2.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-IBJOKS4J.js");
+        const { TeamPlanApprovalTool } = await import("./team-plan-approval-J6TURTZC.js");
         return new TeamPlanApprovalTool(this);
       });
       await registerLazy(ToolNames.TASK_CREATE, async () => {
-        const { TaskCreateTool } = await import("./task-create-CSCEG4SM.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-C52LNFU5.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-PWIU6Q2M.js");
+        const { WorkflowTool } = await import("./workflow-LWFOBFN3.js");
         return new WorkflowTool(this);
       });
     }
     if (this.isComputerUseEnabled()) {
-      const { registerComputerUseTools } = await import("./computer-use-UJMK6JQU.js");
+      const { registerComputerUseTools } = await import("./computer-use-NFBEZ73C.js");
       await registerComputerUseTools(registerLazy, this);
     }
     await registerLazy(ToolNames.MONITOR, async () => {
-      const { MonitorTool } = await import("./monitor-TGSVSAZZ.js");
+      const { MonitorTool } = await import("./monitor-Y7YAHCA6.js");
       return new MonitorTool(this);
     });
     if (this.pendingMcpBudgetCallback) {
@@ -150722,7 +151503,6 @@ export {
   findPlanModeEntryBatchBoundaryIndex,
   finalizeToolResponses,
   parseAndFormatApiError,
-  StructuredToolError,
   checkPriorRead,
   PLAN_EXIT_APPROVED_LLM_CONTENT_PREFIXES,
   ExitPlanModeTool,