@qwen-code/qwen-code 0.17.0-preview.0 → 0.17.1-nightly.20260604.16dd99fa3

package/chunks/{chunk-7JHNICSJ.js → chunk-JR346RJ5.js}

@@ -24,7 +24,7 @@ import {
   isInitializedNotification,
   isJSONRPCRequest,
   isJSONRPCResultResponse
-} from "./chunk-TI4GXJKO.js";
+} from "./chunk-7TQVELRB.js";
 import {
   NEVER2 as NEVER,
   ZodIssueCode2 as ZodIssueCode,
@@ -41,7 +41,7 @@ import {
 } from "./chunk-AKBFRR6J.js";
 import {
   runSideQuery
-} from "./chunk-FEENTAB2.js";
+} from "./chunk-6O244QKR.js";
 import {
   escapeSystemReminderTags,
   escapeXml
@@ -51,13 +51,14 @@ import {
   HOOKS_CONFIG_FIELDS,
   HookEventName,
   PermissionRequestHookOutput,
+  PostToolBatchHookOutput,
   PostToolUseFailureHookOutput,
   PostToolUseHookOutput,
   PreToolUseHookOutput,
   StopHookOutput,
   createHookOutput,
   getHookKey
-} from "./chunk-HAQCNXSG.js";
+} from "./chunk-RQW7WUJR.js";
 import {
   DEFAULT_FILE_FILTERING_OPTIONS
 } from "./chunk-77WXWU44.js";
@@ -101,6 +102,7 @@ import {
   addToolInputAttributes,
   addToolResultAttributes,
   addUserPromptAttributes,
+  clearDetailedSpanState,
   createContentGenerator,
   defaultModalities,
   endHookSpan,
@@ -165,7 +167,7 @@ import {
   truncateSpanError,
   truncateToolOutput,
   uiTelemetryService
-} from "./chunk-OXXOAIGT.js";
+} from "./chunk-YVGIQ2CS.js";
 import {
   safeJsonStringify
 } from "./chunk-W57YDFU5.js";
@@ -184,7 +186,7 @@ import {
 } from "./chunk-NQ3E7YLD.js";
 import {
   STRUCTURED_OUTPUT_REDACTED_ARGS
-} from "./chunk-UQRYJQBE.js";
+} from "./chunk-SOGUPKP6.js";
 import {
   ToolDisplayNames,
   ToolDisplayNamesMigration,
@@ -199,7 +201,7 @@ import {
   SchemaValidator,
   hasCycleInSchema,
   isTool
-} from "./chunk-R2B65CAN.js";
+} from "./chunk-JKUAX6UT.js";
 import {
   atomicWriteFile,
   atomicWriteFileSync,
@@ -207,7 +209,7 @@ import {
 } from "./chunk-HX3JRTWL.js";
 import {
   require_undici
-} from "./chunk-U2K6HDUJ.js";
+} from "./chunk-QVJ33ZBG.js";
 import {
   DEFAULT_TOKEN_LIMIT,
   ESCALATED_MAX_TOKENS,
@@ -219,7 +221,7 @@ import {
   createUserContent,
   mcpToTool,
   require_src as require_src2
-} from "./chunk-HCSJIOLR.js";
+} from "./chunk-BNESGOSJ.js";
 import {
   PATH_ARG_KEYS,
   QWEN_DIR,
@@ -33548,12 +33550,11 @@ You are Qwen Code, an interactive CLI agent developed by Alibaba Group, speciali
 - **Style & Structure:** Mimic the style (formatting, naming), structure, framework choices, typing, and architectural patterns of existing code in the project.
 - **Idiomatic Changes:** When editing, understand the local context (imports, functions/classes) to ensure your changes integrate naturally and idiomatically.
 - **Comments:** Default to none. Only add a comment when the _why_ cannot be conveyed through naming or code structure \u2014 a hidden constraint, a subtle invariant, or a workaround for a specific bug. Do not narrate what the code does. Do not edit comments that are separate from the code you are changing. *NEVER* talk to the user or describe your changes through comments.
-- **Proactiveness:** Fulfill the user's request thoroughly. When adding features or fixing bugs, this includes adding tests to ensure quality. Consider all created files, especially tests, to be permanent artifacts unless the user says otherwise.
+- **Proactiveness:** Fulfill the user's request thoroughly. When the task involves code modifications, add tests to verify the change works. Consider all created files, especially tests, to be permanent artifacts unless the user says otherwise.
 - **Confirm Ambiguity/Expansion:** Do not take significant actions beyond the clear scope of the request without confirming with the user. If asked *how* to do something, explain first, don't just do it.
-- **Explaining Changes:** After completing a code modification or file operation *do not* provide summaries unless asked.
-- **Path Construction:** Before using any file system tool (e.g., ${ToolNames.READ_FILE}' or '${ToolNames.WRITE_FILE}'), you must construct the full absolute path for the file_path argument. Always combine the absolute path of the project's root directory with the file's path relative to the root. For example, if the project root is /path/to/project/ and the file is foo/bar/baz.txt, the final path you must use is /path/to/project/foo/bar/baz.txt. If the user provides a relative path, you must resolve it against the root directory to create an absolute path.
 - **Do Not revert changes:** Do not revert changes to the codebase unless asked to do so by the user. Only revert changes made by you if they have resulted in an error or if the user has explicitly asked you to revert the changes.
 
+
 # Task Management
 You have access to the ${ToolNames.TODO_WRITE} tool to help you manage and plan tasks. Use these tools VERY frequently to ensure that you are tracking your tasks and giving the user visibility into your progress.
 These tools are also EXTREMELY helpful for planning tasks, and for breaking down larger complex tasks into smaller steps. If you do not use this tool when planning, you may forget to do important tasks - and that is unacceptable.
@@ -33601,37 +33602,38 @@ I've found some existing telemetry code. Let me mark the first todo as in_progre
 [Assistant continues implementing the feature step by step, marking todos as in_progress and completed as they go]
 </example>
 
-# Asking questions as you work
-
-You have access to the ${ToolNames.ASK_USER_QUESTION} tool to ask the user questions when you need clarification, want to validate assumptions, or need to make a decision you're unsure about. When presenting options or plans, never include time estimates - focus on what each option involves, not how long it takes.
-
 # Primary Workflows
 
 ## Software Engineering Tasks
 When requested to perform tasks like fixing bugs, adding features, refactoring, or explaining code, follow this iterative approach:
 - **Plan:** After understanding the user's request, create an initial plan based on your existing knowledge and any immediately obvious context. Use the '${ToolNames.TODO_WRITE}' tool to capture this rough plan for complex or multi-step work. Don't wait for complete understanding - start with what you know.
-- **Implement:** Begin implementing the plan while gathering additional context as needed. Use '${ToolNames.GREP}', '${ToolNames.GLOB}', and '${ToolNames.READ_FILE}' tools strategically when you encounter specific unknowns during implementation. Use the available tools (e.g., '${ToolNames.EDIT}', '${ToolNames.WRITE_FILE}' '${ToolNames.SHELL}' ...) to act on the plan, strictly adhering to the project's established conventions (detailed under 'Core Mandates').
-- **Adapt:** As you discover new information or encounter obstacles, update your plan and todos accordingly. Mark todos as in_progress when starting and completed when finishing each task. Add new todos if the scope expands. Refine your approach based on what you learn.
-- **Verify (Tests):** If applicable and feasible, verify the changes using the project's testing procedures. Identify the correct test commands and frameworks by examining 'README' files, build/package configuration (e.g., 'package.json'), or existing test execution patterns. NEVER assume standard test commands.
-- **Verify (Standards):** VERY IMPORTANT: After making code changes, execute the project-specific build, linting and type-checking commands (e.g., 'tsc', 'npm run lint', 'ruff check .') that you have identified for this project (or obtained from the user). This ensures code quality and adherence to standards. If unsure about these commands, you can ask the user if they'd like you to run them and if so how to.
+- **Implement:** Begin implementing while gathering context as needed. Use available search and editing tools strategically, adhering to project conventions (see 'Core Mandates'). Do not add features, refactor code, or make "improvements" beyond what was asked. Don't add error handling, fallbacks, or validation for scenarios that can't happen\u2014only validate at system boundaries (user input, external APIs). Don't create helpers, utilities, or abstractions for one-time operations. Three similar lines of code is better than a premature abstraction. Prefer editing existing files over creating new ones.
+- **Adapt:** As you discover new information or encounter obstacles, update your plan and todos accordingly. Mark todos as in_progress when starting and completed when finishing each task. Add new todos if the scope expands. Refine your approach based on what you learn. If an approach fails, diagnose why before switching tactics\u2014read the error, check your assumptions, try a focused fix. Don't retry blindly, but don't abandon a viable approach after a single failure.
+- **Verify (Tests):** If applicable and feasible, verify the changes using the project's testing procedures. Identify the correct test commands and frameworks by examining 'README' files, build/package configuration (e.g., 'package.json'), or existing test execution patterns. NEVER assume standard test commands. Before reporting a task complete, verify it actually works. If you can't verify (no test exists, can't run the code), say so explicitly rather than claiming success.
+- **Verify (Standards):** When your task involves a code or system change, execute the project-specific build, linting and type-checking commands (e.g., 'tsc', 'npm run lint', 'ruff check .') that you have identified for this project (or obtained from the user). This ensures code quality and adherence to standards. Read-only or explanatory turns do not require verification.
+- **Report outcomes faithfully:** If tests fail, say so with the relevant output. If you did not run a verification step, say that rather than implying it succeeded. Never claim "all tests pass" when output shows failures, never suppress failing checks to manufacture a green result, and never characterize incomplete or broken work as done.
 
 **Key Principle:** Start with a reasonable plan based on available information, then adapt as you learn. Users prefer seeing progress quickly rather than waiting for perfect understanding.
 
 - Tool results and user messages may include <system-reminder> tags. <system-reminder> tags contain useful information and reminders. They are NOT part of the user's provided input or the tool result.
 
-IMPORTANT: Always use the ${ToolNames.TODO_WRITE} tool to plan and track tasks throughout the conversation.
-
 ## New Applications
 
 When a user wants to create a new application, project, website, game, or library from scratch, use the '${ToolNames.SKILL}' tool with skill="new-app" to load the detailed workflow and tech-stack guidance.
 
 # Operational Guidelines
 
+## Communicating With the User
+
+Before your first tool call, briefly state what you're about to do. While working, give short updates at key moments: when you find something load-bearing (a bug, a root cause), when changing direction, or when you've made progress without an update.
+
+End-of-turn summary: one or two sentences. What changed and what's next. Nothing else.
+
 ## Tone and Style (CLI Interaction)
 - **Concise & Direct:** Adopt a professional, direct, and concise tone suitable for a CLI environment.
 - **Minimal Output:** Aim for fewer than 3 lines of text output (excluding tool use/code generation) per response whenever practical. Focus strictly on the user's query.
 - **Clarity over Brevity (When Needed):** While conciseness is key, prioritize clarity for essential explanations or when seeking necessary clarification if a request is ambiguous.
-- **No Chitchat:** Avoid conversational filler, preambles ("Okay, I will now..."), or postambles ("I have finished the changes..."). Get straight to the action or answer.
+- **No Chitchat:** Avoid conversational filler and chitchat. Get straight to the action or answer.
 - **Formatting:** Use GitHub-flavored Markdown. Responses will be rendered in monospace.
 - **Tools vs. Text:** Use tools for actions, text output *only* for communication. Do not add explanatory comments within tool calls or code blocks unless specifically part of the required code/command itself.
 - **Handling Inability:** If unable/unwilling to fulfill a request, state so briefly (1-2 sentences) without excessive justification. Offer alternatives if appropriate.
@@ -33640,16 +33642,22 @@ When a user wants to create a new application, project, website, game, or librar
 - **Explain Critical Commands:** Before executing commands with '${ToolNames.SHELL}' that modify the file system, codebase, or system state, you *must* provide a brief explanation of the command's purpose and potential impact. Prioritize user understanding and safety. You should not ask permission to use the tool; the user will be presented with a confirmation dialogue upon use (you do not need to tell them this).
 - **Security First:** Always apply security best practices. Never introduce code that exposes, logs, or commits secrets, API keys, or other sensitive information.
 
-## Tool Usage
+## Using Your Tools
+- **Prefer Dedicated Tools:** Do NOT use the '${ToolNames.SHELL}' to run commands when a relevant dedicated tool is provided. Using dedicated tools allows the user to better understand and review your work. This is CRITICAL to assisting the user:
+  - To read files use '${ToolNames.READ_FILE}' instead of cat, head, tail, or sed
+  - To edit files use '${ToolNames.EDIT}' instead of sed or awk
+  - To create files use '${ToolNames.WRITE_FILE}' instead of cat with heredoc or echo redirection
+  - To search for files use '${ToolNames.GLOB}' instead of find or ls
+  - To search the content of files, use '${ToolNames.GREP}' instead of grep or rg
+  - Reserve using the '${ToolNames.SHELL}' exclusively for system commands and terminal operations that require shell execution. If you are unsure and there is a relevant dedicated tool, default to using the dedicated tool and only fallback on using the '${ToolNames.SHELL}' tool for these if it is absolutely necessary.
+- **Task Management:** Break down and manage your work with the '${ToolNames.TODO_WRITE}' tool. These tools are helpful for planning your work and helping the user track your progress. Mark each task as completed as soon as you are done with the task. Do not batch up multiple tasks before marking them as completed.
+- **Parallel Tool Calls:** You can call multiple tools in a single response. If you intend to call multiple tools and there are no dependencies between them, make all independent tool calls in parallel. Maximize use of parallel tool calls where possible to increase efficiency. However, if some tool calls depend on previous calls to inform dependent values, do NOT call these tools in parallel and instead call them sequentially. For instance, if one operation must complete before another starts, run these operations sequentially instead.
 - **File Paths:** Always use absolute paths when referring to files with tools like '${ToolNames.READ_FILE}' or '${ToolNames.WRITE_FILE}'. Relative paths are not supported. You must provide an absolute path.
-- **Parallelism:** Execute multiple independent tool calls in parallel when feasible (i.e. searching the codebase).
-- **Command Execution:** Use the '${ToolNames.SHELL}' tool for running shell commands, remembering the safety rule to explain modifying commands first.
 - **Background Processes:** Use background execution with \`is_background: true\` for commands that are unlikely to stop on their own, e.g. \`node server.js\`. Do not append a trailing \`&\` when using the shell tool's managed background mode. If unsure, ask the user.
 - **Interactive Commands:** Try to avoid shell commands that are likely to require user interaction (e.g. \`git rebase -i\`). Use non-interactive versions of commands (e.g. \`npm init -y\` instead of \`npm init\`) when available, and otherwise remind the user that interactive shell commands are not supported and may cause hangs until canceled by the user.
-- **Task Management:** Use the '${ToolNames.TODO_WRITE}' tool proactively for complex, multi-step tasks to track progress and provide visibility to users. This tool helps organize work systematically and ensures no requirements are missed.
+- **Questions:** Use '${ToolNames.ASK_USER_QUESTION}' when you need clarification or want to validate assumptions. Never include time estimates in options.
 - **Subagent Delegation:** Use the '${ToolNames.AGENT}' tool with specialized agents when the task at hand matches the agent's description. Subagents are valuable for parallelizing independent queries or for protecting the main context window from excessive results, but they should not be used excessively when not needed. Importantly, avoid duplicating work that subagents are already doing - if you delegate research to a subagent, do not also perform the same searches yourself.
-- For simple, directed codebase searches (e.g. for a specific file/class/function) use the '${ToolNames.GREP}' or '${ToolNames.GLOB}' tools directly.
-- For broader codebase exploration and deep research, use the '${ToolNames.AGENT}' tool with subagent_type=Explore. This is slower than using '${ToolNames.GREP}' or '${ToolNames.GLOB}' directly, so use this only when a simple, directed search proves to be insufficient or when your task will clearly require more than 3 queries.
+- **Codebase Search:** For simple, directed codebase searches (e.g. for a specific file/class/function) use the '${ToolNames.GREP}' or '${ToolNames.GLOB}' tools directly. For broader codebase exploration and deep research, use the '${ToolNames.AGENT}' tool with subagent_type=Explore. This is slower than using '${ToolNames.GREP}' or '${ToolNames.GLOB}' directly, so use this only when a simple, directed search proves to be insufficient or when your task will clearly require more than 3 queries.
 - **Respect User Confirmations:** Most tool calls (also denoted as 'function calls') will first require confirmation from the user, where they will either approve or cancel the function call. If a user cancels a function call, respect their choice and do _not_ try to make the function call again. It is okay to request the tool call again _only_ if the user requests that same tool call on a subsequent prompt. When a user cancels a function call, assume best intentions from the user and consider inquiring if they prefer any alternative paths forward.
 
 ## Interaction Details
@@ -34174,15 +34182,43 @@ function getToolCallExamples(model) {
   return generalToolCallExamples;
 }
 __name(getToolCallExamples, "getToolCallExamples");
-function getSubagentSystemReminder(agentTypes) {
-  return `<system-reminder>You have powerful specialized agents at your disposal, available agent types are: ${agentTypes.join(", ")}. PROACTIVELY use the ${ToolNames.AGENT} tool to delegate user's task to appropriate agent when user's task matches agent capabilities. Ignore this message if user's task is not relevant to any agent. This message is for internal use only. Do not mention this to user in your response.</system-reminder>`;
-}
-__name(getSubagentSystemReminder, "getSubagentSystemReminder");
 function getPlanModeSystemReminder(planOnly = false) {
   return `<system-reminder>
-Plan mode is active. The user indicated that they do not want you to execute yet -- you MUST NOT make any edits, run any non-readonly tools (including changing configs or making commits), or otherwise make any changes to the system. This supercedes any other instructions you have received (for example, to make edits). Instead, you should:
-1. Answer the user's query comprehensively
-2. When you're done researching, present your plan ${planOnly ? "directly" : `by calling the ${ToolNames.EXIT_PLAN_MODE} tool, which will prompt the user to confirm the plan`}. Do NOT make any file changes or run any tools that modify the system state in any way until the user has confirmed the plan. Use ${ToolNames.ASK_USER_QUESTION} if you need to clarify approaches.
+Plan mode is active. The user indicated that they do not want you to execute yet -- you MUST NOT make any edits, run any non-readonly tools (including changing configs or making commits), or otherwise make any changes to the system. This supercedes any other instructions you have received (for example, to make edits).
+
+## Iterative Planning Workflow
+
+You are pair-planning with the user. Explore the code to build context, ask the user questions when you hit decisions you cannot make alone, and refine your plan incrementally.
+
+### The Loop
+
+Repeat this cycle until the plan is complete:
+
+1. **Explore** \u2014 Use read-only tools (${ToolNames.READ_FILE}, ${ToolNames.GREP}, ${ToolNames.GLOB}) to read code. Look for existing functions, utilities, and patterns to reuse. For broader or ambiguous tasks, use multiple parallel exploration passes (directly or via agents when appropriate) to understand different parts of the codebase.
+2. **Capture findings** \u2014 After each discovery, immediately integrate what you learned into your evolving mental model. Do not wait until the end to synthesize.
+3. **Ask the user** \u2014 When you hit an ambiguity or decision you cannot resolve from code alone, use ${ToolNames.ASK_USER_QUESTION}. Then go back to step 1.
+
+### First Turn
+
+Start by quickly scanning a few key files to form an initial understanding of the task scope. Then ask the user your first round of questions if any exist. Do not explore exhaustively before engaging the user.
+
+### Asking Good Questions
+
+- Never ask what you could find out by reading the code
+- Batch related questions together (use multi-question ${ToolNames.ASK_USER_QUESTION} calls)
+- Focus on things only the user can answer: requirements, preferences, tradeoffs, edge case priorities
+- Scale depth to the task \u2014 a vague feature request needs many rounds; a focused bug fix may need one or none
+
+### Planning Principles
+
+- Build a global understanding of how the relevant pieces fit together before deciding on local edits. Do not jump from the first relevant file straight into a plan when the task likely spans multiple files or behaviors.
+- Design an implementation approach that fits the existing codebase rather than inventing a parallel pattern.
+- Reference existing functions and utilities you found that should be reused, with their file paths.
+- Include a verification section describing how to test the changes end-to-end.
+
+### When to Converge
+
+Your plan is ready when you have addressed all ambiguities and it covers: what to change, which files to modify, what existing code to reuse (with file paths), and how to verify the changes. Present your plan ${planOnly ? "directly" : `by calling the ${ToolNames.EXIT_PLAN_MODE} tool, which will prompt the user to confirm the plan`}. Do NOT make any file changes or run any tools that modify the system state in any way until the user has confirmed the plan.
 </system-reminder>`;
 }
 __name(getPlanModeSystemReminder, "getPlanModeSystemReminder");
@@ -34677,12 +34713,59 @@ function safeRealpath(p) {
   }
 }
 __name(safeRealpath, "safeRealpath");
+var PLAN_MODE_REMINDER_TEXT = `<plan-mode-active>
+You are currently in PLAN mode. You may research, read files, and propose plans, but you may not execute modification tools (${ToolNames.WRITE_FILE}, ${ToolNames.EDIT}, ${ToolNames.SHELL}, etc.) until the user exits plan mode. The summary above may not reflect this constraint \u2014 honor plan mode regardless.
+</plan-mode-active>`;
+var MAX_SUBAGENT_DESC_CHARS = 200;
+var MAX_SUBAGENT_SNAPSHOT_COUNT = 30;
+function buildPlanModeReminderPart() {
+  return { text: PLAN_MODE_REMINDER_TEXT };
+}
+__name(buildPlanModeReminderPart, "buildPlanModeReminderPart");
+function flattenWhitespaceForBullet(text) {
+  return text.replace(/[\r\n\t]+/g, " ");
+}
+__name(flattenWhitespaceForBullet, "flattenWhitespaceForBullet");
+function buildSubagentSnapshotPart(snaps) {
+  if (snaps.length === 0) return null;
+  const sorted2 = [...snaps].sort((a, b) => a.startTime - b.startTime);
+  const overflow = Math.max(0, sorted2.length - MAX_SUBAGENT_SNAPSHOT_COUNT);
+  const shown = overflow > 0 ? sorted2.slice(overflow) : sorted2;
+  const lines = shown.map((s) => {
+    const flattened = flattenWhitespaceForBullet(s.description);
+    const truncated = flattened.length > MAX_SUBAGENT_DESC_CHARS ? flattened.slice(0, MAX_SUBAGENT_DESC_CHARS) + "\u2026" : flattened;
+    return `- [${escapeXml(s.status)}] ${escapeXml(s.id)}: ${escapeXml(truncated)}`;
+  });
+  if (overflow > 0) {
+    lines.push(
+      `- (\u2026 and ${overflow} older task${overflow === 1 ? "" : "s"} not shown)`
+    );
+  }
+  return {
+    text: "<background-tasks>\nThe following background subagent tasks were active at compaction. The summary above does not include their per-task state. Use `task_stop` / `send_message` to interact; do not assume they completed.\n" + lines.join("\n") + "\n</background-tasks>"
+  };
+}
+__name(buildSubagentSnapshotPart, "buildSubagentSnapshotPart");
+function buildStateReminderParts(options2) {
+  const parts2 = [];
+  if (options2.planModeActive) {
+    parts2.push(buildPlanModeReminderPart());
+  }
+  if (options2.runningSubagents && options2.runningSubagents.length > 0) {
+    const snap = buildSubagentSnapshotPart(options2.runningSubagents);
+    if (snap) parts2.push(snap);
+  }
+  return parts2;
+}
+__name(buildStateReminderParts, "buildStateReminderParts");
 async function composePostCompactHistory(history, summary, options2 = {}) {
   const {
     workspaceRoot,
     signal,
     maxFiles = POST_COMPACT_MAX_FILES_TO_RESTORE,
-    maxImages = POST_COMPACT_MAX_IMAGES_TO_RESTORE
+    maxImages = POST_COMPACT_MAX_IMAGES_TO_RESTORE,
+    planModeActive,
+    runningSubagents
   } = options2;
   const filePaths = extractRecentFilePaths(history, maxFiles).filter(
     (p) => isInsideWorkspace(p, workspaceRoot)
@@ -34690,7 +34773,9 @@ async function composePostCompactHistory(history, summary, options2 = {}) {
   const fileBlocks = await buildFileRestorationBlocks(filePaths, signal);
   const images = extractRecentImages(history, maxImages);
   const imageBlock = buildImageRestorationBlock(images);
-  const postAckParts = [];
+  const postAckParts = [
+    ...buildStateReminderParts({ planModeActive, runningSubagents })
+  ];
   for (const block2 of fileBlocks) {
     for (const part of block2.parts ?? []) postAckParts.push(part);
   }
@@ -34727,6 +34812,7 @@ var AUTOCOMPACT_BUFFER = 13e3;
 var WARN_BUFFER = 2e4;
 var HARD_BUFFER = 3e3;
 var MAX_CONSECUTIVE_FAILURES = 3;
+var MAX_HOOK_INSTRUCTIONS_CHARS = 4e3;
 function computeThresholds(window2) {
   const effectiveWindow = Math.max(0, window2 - SUMMARY_RESERVE);
   const absAuto = effectiveWindow - AUTOCOMPACT_BUFFER;
@@ -34738,6 +34824,41 @@ function computeThresholds(window2) {
   return { warn, auto, hard, effectiveWindow };
 }
 __name(computeThresholds, "computeThresholds");
+function collectActiveSubagents(config) {
+  const registry = config.getBackgroundTaskRegistry?.();
+  if (!registry) return [];
+  return registry.getAll().filter(
+    (t) => t.kind === "agent" && // Only TRUE background subagents belong in a `<background-tasks>`
+    // block. Foreground entries (`isBackgrounded: false`) are the
+    // parent's synchronously-awaited tool call — their pending
+    // functionCall is still in history and resolves through the normal
+    // tool-result channel, so a reminder would mislabel them. Mirrors
+    // the `getRunningBackgroundCount` filter in background-tasks.ts.
+    t.isBackgrounded && (t.status === "running" || t.status === "paused")
+  ).map((t) => ({
+    id: t.id,
+    description: t.description,
+    status: t.status,
+    startTime: t.startTime
+  }));
+}
+__name(collectActiveSubagents, "collectActiveSubagents");
+function buildCompressionSystemPrompt(userInstructions, hookInstructions) {
+  const base = getCompressionPrompt();
+  const parts2 = [];
+  if (userInstructions && userInstructions.trim().length > 0) {
+    parts2.push(userInstructions.trim());
+  }
+  if (hookInstructions.length > 0) {
+    parts2.push(hookInstructions);
+  }
+  if (parts2.length === 0) return base;
+  return `${base}
+
+Additional Instructions:
+${parts2.join("\n\n")}`;
+}
+__name(buildCompressionSystemPrompt, "buildCompressionSystemPrompt");
 var ChatCompressionService = class {
   static {
     __name(this, "ChatCompressionService");
@@ -34804,15 +34925,6 @@ var ChatCompressionService = class {
         }
       };
     }
-    const hookSystem = config.getHookSystem();
-    if (hookSystem) {
-      const preCompactTrigger = compactTrigger === "manual" ? "manual" /* Manual */ : "auto" /* Auto */;
-      try {
-        await hookSystem.firePreCompactEvent(preCompactTrigger, "", signal);
-      } catch (err2) {
-        config.getDebugLogger().warn(`PreCompact hook failed: ${err2}`);
-      }
-    }
     if (curatedHistory.length < 2) {
       return {
         newHistory: null,
@@ -34823,6 +34935,24 @@ var ChatCompressionService = class {
         }
       };
     }
+    let hookExtraInstructions = "";
+    const hookSystem = config.getHookSystem();
+    if (hookSystem) {
+      const preCompactTrigger = compactTrigger === "manual" ? "manual" /* Manual */ : "auto" /* Auto */;
+      try {
+        const result = await hookSystem.firePreCompactEvent(
+          preCompactTrigger,
+          opts.customInstructions ?? "",
+          signal
+        );
+        const merged = result?.getAdditionalContext();
+        if (merged && merged.trim().length > 0) {
+          hookExtraInstructions = merged.trim().slice(0, MAX_HOOK_INSTRUCTIONS_CHARS);
+        }
+      } catch (err2) {
+        config.getDebugLogger().warn(`PreCompact hook failed: ${err2}`);
+      }
+    }
     const slim = slimCompactionInput(curatedHistory);
     if (slim.stats.imagesStripped > 0 || slim.stats.documentsStripped > 0) {
       config.getDebugLogger().debug(
@@ -34835,7 +34965,10 @@ var ChatCompressionService = class {
       // Best-effort: failures fall back to NOOP and the next turn re-triggers
       // compression anyway, so don't burn 7 retries blocking the user mid-turn.
       maxAttempts: 1,
-      systemInstruction: getCompressionPrompt(),
+      systemInstruction: buildCompressionSystemPrompt(
+        opts.customInstructions,
+        hookExtraInstructions
+      ),
       contents: [
         ...slim.slimmedHistory,
         {
@@ -34901,15 +35034,28 @@ var ChatCompressionService = class {
             workspaceRoot: config.getTargetDir(),
             signal,
             maxFiles: tuning.maxRecentFiles,
-            maxImages: tuning.maxRecentImages
+            maxImages: tuning.maxRecentImages,
+            // Restore plan-mode reminder + running-subagent snapshot so the
+            // post-compact agent does not lose either piece of mid-session
+            // state. Both reduce to no-ops when the corresponding source is
+            // empty.
+            planModeActive: config.getApprovalMode?.() === "plan" /* PLAN */,
+            runningSubagents: collectActiveSubagents(config)
           }
         );
       } catch (err2) {
         config.getDebugLogger().warn(`[chat-compression] composePostCompactHistory failed: ${err2}`);
         const trailingFc = historyForCompose[historyForCompose.length - 1];
         const fcParts = trailingFc?.role === "model" ? (trailingFc.parts ?? []).filter((p) => !!p.functionCall) : [];
+        const reminderParts = buildStateReminderParts({
+          planModeActive: config.getApprovalMode?.() === "plan" /* PLAN */,
+          runningSubagents: collectActiveSubagents(config)
+        });
         extraHistory = [
-          { role: "user", parts: [{ text: postProcessSummary(summary) }] },
+          {
+            role: "user",
+            parts: [{ text: postProcessSummary(summary) }, ...reminderParts]
+          },
           {
             role: "model",
             parts: [
@@ -35830,6 +35976,7 @@ var GeminiChat = class {
       pendingUserMessage: options2?.pendingUserMessage,
       precomputedEffectiveTokens: options2?.precomputedEffectiveTokens,
       trigger: options2?.trigger,
+      customInstructions: options2?.customInstructions,
       signal
     });
     if (info2.compressionStatus === 1 /* COMPRESSED */ && newHistory) {
@@ -35842,6 +35989,7 @@ var GeminiChat = class {
       this.setHistory(newHistory);
       debugLogger15.debug("[FILE_READ_CACHE] clear after auto tryCompress");
       this.config.getFileReadCache().clear();
+      clearDetailedSpanState();
       this.lastPromptTokenCount = info2.newTokenCount;
       this.telemetryService?.setLastPromptTokenCount(info2.newTokenCount);
       this.consecutiveFailures = 0;
@@ -37392,6 +37540,7 @@ var MessageBusType = /* @__PURE__ */ ((MessageBusType2) => {
 
 // packages/core/src/core/toolHookTriggers.ts
 var debugLogger16 = createDebugLogger("TOOL_HOOKS");
+var POST_TOOL_BATCH_HOOK_TIMEOUT_MS = 15e3;
 function generateToolUseId() {
   return `toolu_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
 }
@@ -37544,6 +37693,44 @@ async function firePostToolUseFailureHook(messageBus, toolUseId, toolName, toolI
   }
 }
 __name(firePostToolUseFailureHook, "firePostToolUseFailureHook");
+async function firePostToolBatchHook(messageBus, toolCalls, permissionMode = "default", signal) {
+  if (!messageBus) {
+    return { shouldStop: false };
+  }
+  try {
+    const response = await messageBus.request(
+      {
+        type: "hook-execution-request" /* HOOK_EXECUTION_REQUEST */,
+        eventName: "PostToolBatch",
+        input: {
+          permission_mode: permissionMode,
+          tool_calls: toolCalls
+        },
+        signal
+      },
+      "hook-execution-response" /* HOOK_EXECUTION_RESPONSE */,
+      POST_TOOL_BATCH_HOOK_TIMEOUT_MS,
+      signal
+    );
+    if (!response.success || !response.output) {
+      const message = response.error?.message || `hook runner returned ${response.success ? "no output" : "success: false"} without error detail`;
+      debugLogger16.warn(`PostToolBatch hook returned failure: ${message}`);
+      return { shouldStop: false, hookError: message };
+    }
+    const batchOutput = createHookOutput("PostToolBatch", response.output);
+    const shouldStop = batchOutput.shouldStopExecution();
+    return {
+      shouldStop,
+      stopReason: shouldStop ? batchOutput.getEffectiveReason() : void 0,
+      additionalContext: batchOutput.getAdditionalContext()
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    debugLogger16.warn(`PostToolBatch hook error: ${message}`);
+    return { shouldStop: false, hookError: message };
+  }
+}
+__name(firePostToolBatchHook, "firePostToolBatchHook");
 async function fireNotificationHook(messageBus, message, notificationType, title, signal) {
   if (!messageBus) {
     return {};
@@ -40866,10 +41053,10 @@ async function getIdeProcessInfo() {
 }
 __name(getIdeProcessInfo, "getIdeProcessInfo");
 
-// packages/core/node_modules/@modelcontextprotocol/sdk/dist/esm/client/streamableHttp.js
+// node_modules/@modelcontextprotocol/sdk/dist/esm/client/streamableHttp.js
 init_esbuild_shims();
 
-// packages/core/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/transport.js
+// node_modules/@modelcontextprotocol/sdk/dist/esm/shared/transport.js
 init_esbuild_shims();
 function normalizeHeaders(headers) {
   if (!headers)
@@ -40899,7 +41086,7 @@ function createFetchWithInit(baseFetch = fetch, baseInit) {
 }
 __name(createFetchWithInit, "createFetchWithInit");
 
-// packages/core/node_modules/@modelcontextprotocol/sdk/dist/esm/client/auth.js
+// node_modules/@modelcontextprotocol/sdk/dist/esm/client/auth.js
 init_esbuild_shims();
 
 // node_modules/pkce-challenge/dist/index.node.js
@@ -40947,7 +41134,7 @@ async function pkceChallenge(length) {
 }
 __name(pkceChallenge, "pkceChallenge");
 
-// packages/core/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/auth.js
+// node_modules/@modelcontextprotocol/sdk/dist/esm/shared/auth.js
 init_esbuild_shims();
 var SafeUrlSchema = url().superRefine((val, ctx) => {
   if (!URL.canParse(val)) {
@@ -41092,7 +41279,7 @@ var OAuthTokenRevocationRequestSchema = object({
   token_type_hint: string().optional()
 }).strip();
 
-// packages/core/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/auth-utils.js
+// node_modules/@modelcontextprotocol/sdk/dist/esm/shared/auth-utils.js
 init_esbuild_shims();
 function resourceUrlFromServerUrl(url2) {
   const resourceURL = typeof url2 === "string" ? new URL(url2) : new URL(url2.href);
@@ -41115,7 +41302,7 @@ function checkResourceAllowed({ requestedResource, configuredResource }) {
 }
 __name(checkResourceAllowed, "checkResourceAllowed");
 
-// packages/core/node_modules/@modelcontextprotocol/sdk/dist/esm/server/auth/errors.js
+// node_modules/@modelcontextprotocol/sdk/dist/esm/server/auth/errors.js
 init_esbuild_shims();
 var OAuthError = class extends Error {
   static {
@@ -41265,7 +41452,7 @@ var OAUTH_ERRORS = {
   [InvalidTargetError.errorCode]: InvalidTargetError
 };
 
-// packages/core/node_modules/@modelcontextprotocol/sdk/dist/esm/client/auth.js
+// node_modules/@modelcontextprotocol/sdk/dist/esm/client/auth.js
 var UnauthorizedError2 = class extends Error {
   static {
     __name(this, "UnauthorizedError");
@@ -41282,12 +41469,12 @@ var AUTHORIZATION_CODE_RESPONSE_TYPE = "code";
 var AUTHORIZATION_CODE_CHALLENGE_METHOD = "S256";
 function selectClientAuthMethod(clientInformation, supportedMethods) {
   const hasClientSecret = clientInformation.client_secret !== void 0;
-  if (supportedMethods.length === 0) {
-    return hasClientSecret ? "client_secret_post" : "none";
-  }
-  if ("token_endpoint_auth_method" in clientInformation && clientInformation.token_endpoint_auth_method && isClientAuthMethod(clientInformation.token_endpoint_auth_method) && supportedMethods.includes(clientInformation.token_endpoint_auth_method)) {
+  if ("token_endpoint_auth_method" in clientInformation && clientInformation.token_endpoint_auth_method && isClientAuthMethod(clientInformation.token_endpoint_auth_method) && (supportedMethods.length === 0 || supportedMethods.includes(clientInformation.token_endpoint_auth_method))) {
     return clientInformation.token_endpoint_auth_method;
   }
+  if (supportedMethods.length === 0) {
+    return hasClientSecret ? "client_secret_basic" : "none";
+  }
   if (hasClientSecret && supportedMethods.includes("client_secret_basic")) {
     return "client_secret_basic";
   }
@@ -41366,22 +41553,46 @@ async function auth(provider, options2) {
 }
 __name(auth, "auth");
 async function authInternal(provider, { serverUrl, authorizationCode, scope, resourceMetadataUrl, fetchFn }) {
+  const cachedState = await provider.discoveryState?.();
   let resourceMetadata;
   let authorizationServerUrl;
-  try {
-    resourceMetadata = await discoverOAuthProtectedResourceMetadata(serverUrl, { resourceMetadataUrl }, fetchFn);
-    if (resourceMetadata.authorization_servers && resourceMetadata.authorization_servers.length > 0) {
-      authorizationServerUrl = resourceMetadata.authorization_servers[0];
+  let metadata2;
+  let effectiveResourceMetadataUrl = resourceMetadataUrl;
+  if (!effectiveResourceMetadataUrl && cachedState?.resourceMetadataUrl) {
+    effectiveResourceMetadataUrl = new URL(cachedState.resourceMetadataUrl);
+  }
+  if (cachedState?.authorizationServerUrl) {
+    authorizationServerUrl = cachedState.authorizationServerUrl;
+    resourceMetadata = cachedState.resourceMetadata;
+    metadata2 = cachedState.authorizationServerMetadata ?? await discoverAuthorizationServerMetadata(authorizationServerUrl, { fetchFn });
+    if (!resourceMetadata) {
+      try {
+        resourceMetadata = await discoverOAuthProtectedResourceMetadata(serverUrl, { resourceMetadataUrl: effectiveResourceMetadataUrl }, fetchFn);
+      } catch {
+      }
     }
-  } catch {
-  }
-  if (!authorizationServerUrl) {
-    authorizationServerUrl = new URL("/", serverUrl);
+    if (metadata2 !== cachedState.authorizationServerMetadata || resourceMetadata !== cachedState.resourceMetadata) {
+      await provider.saveDiscoveryState?.({
+        authorizationServerUrl: String(authorizationServerUrl),
+        resourceMetadataUrl: effectiveResourceMetadataUrl?.toString(),
+        resourceMetadata,
+        authorizationServerMetadata: metadata2
+      });
+    }
+  } else {
+    const serverInfo = await discoverOAuthServerInfo(serverUrl, { resourceMetadataUrl: effectiveResourceMetadataUrl, fetchFn });
+    authorizationServerUrl = serverInfo.authorizationServerUrl;
+    metadata2 = serverInfo.authorizationServerMetadata;
+    resourceMetadata = serverInfo.resourceMetadata;
+    await provider.saveDiscoveryState?.({
+      authorizationServerUrl: String(authorizationServerUrl),
+      resourceMetadataUrl: effectiveResourceMetadataUrl?.toString(),
+      resourceMetadata,
+      authorizationServerMetadata: metadata2
+    });
   }
   const resource = await selectResourceURL(serverUrl, provider, resourceMetadata);
-  const metadata2 = await discoverAuthorizationServerMetadata(authorizationServerUrl, {
-    fetchFn
-  });
+  const resolvedScope = scope || resourceMetadata?.scopes_supported?.join(" ") || provider.clientMetadata.scope;
   let clientInformation = await Promise.resolve(provider.clientInformation());
   if (!clientInformation) {
     if (authorizationCode !== void 0) {
@@ -41405,6 +41616,7 @@ async function authInternal(provider, { serverUrl, authorizationCode, scope, res
       const fullInformation = await registerClient(authorizationServerUrl, {
         metadata: metadata2,
         clientMetadata: provider.clientMetadata,
+        scope: resolvedScope,
         fetchFn
       });
       await provider.saveClientInformation(fullInformation);
@@ -41448,7 +41660,7 @@ async function authInternal(provider, { serverUrl, authorizationCode, scope, res
     clientInformation,
     state,
     redirectUrl: provider.redirectUrl,
-    scope: scope || resourceMetadata?.scopes_supported?.join(" ") || provider.clientMetadata.scope,
+    scope: resolvedScope,
     resource
   });
   await provider.saveCodeVerifier(codeVerifier);
@@ -41649,6 +41861,27 @@ async function discoverAuthorizationServerMetadata(authorizationServerUrl, { fet
   return void 0;
 }
 __name(discoverAuthorizationServerMetadata, "discoverAuthorizationServerMetadata");
+async function discoverOAuthServerInfo(serverUrl, opts) {
+  let resourceMetadata;
+  let authorizationServerUrl;
+  try {
+    resourceMetadata = await discoverOAuthProtectedResourceMetadata(serverUrl, { resourceMetadataUrl: opts?.resourceMetadataUrl }, opts?.fetchFn);
+    if (resourceMetadata.authorization_servers && resourceMetadata.authorization_servers.length > 0) {
+      authorizationServerUrl = resourceMetadata.authorization_servers[0];
+    }
+  } catch {
+  }
+  if (!authorizationServerUrl) {
+    authorizationServerUrl = String(new URL("/", serverUrl));
+  }
+  const authorizationServerMetadata = await discoverAuthorizationServerMetadata(authorizationServerUrl, { fetchFn: opts?.fetchFn });
+  return {
+    authorizationServerUrl,
+    authorizationServerMetadata,
+    resourceMetadata
+  };
+}
+__name(discoverOAuthServerInfo, "discoverOAuthServerInfo");
 async function startAuthorization(authorizationServerUrl, { metadata: metadata2, clientInformation, redirectUrl, scope, state, resource }) {
   let authorizationUrl;
   if (metadata2) {
@@ -41764,7 +41997,7 @@ async function fetchToken(provider, authorizationServerUrl, { metadata: metadata
   });
 }
 __name(fetchToken, "fetchToken");
-async function registerClient(authorizationServerUrl, { metadata: metadata2, clientMetadata, fetchFn }) {
+async function registerClient(authorizationServerUrl, { metadata: metadata2, clientMetadata, scope, fetchFn }) {
   let registrationUrl;
   if (metadata2) {
     if (!metadata2.registration_endpoint) {
@@ -41779,7 +42012,10 @@ async function registerClient(authorizationServerUrl, { metadata: metadata2, cli
     headers: {
       "Content-Type": "application/json"
     },
-    body: JSON.stringify(clientMetadata)
+    body: JSON.stringify({
+      ...clientMetadata,
+      ...scope !== void 0 ? { scope } : {}
+    })
   });
   if (!response.ok) {
     throw await parseErrorResponse(response);
@@ -41933,7 +42169,7 @@ var EventSourceParserStream = class extends TransformStream {
   }
 };
 
-// packages/core/node_modules/@modelcontextprotocol/sdk/dist/esm/client/streamableHttp.js
+// node_modules/@modelcontextprotocol/sdk/dist/esm/client/streamableHttp.js
 var DEFAULT_STREAMABLE_HTTP_RECONNECTION_OPTIONS = {
   initialReconnectionDelay: 1e3,
   maxReconnectionDelay: 3e4,
@@ -43449,6 +43685,132 @@ var createErrorResponse = /* @__PURE__ */ __name((request, error, errorType) =>
   errorType,
   contentLength: error.message.length
 }), "createErrorResponse");
+function serializeToolResponse(response) {
+  return {
+    response_parts: response.responseParts.map(summarizeBatchResponsePart),
+    result_display: response.resultDisplay,
+    error: response.error?.message,
+    error_type: response.errorType,
+    content_length: response.contentLength
+  };
+}
+__name(serializeToolResponse, "serializeToolResponse");
+function summarizeBatchResponsePart(part) {
+  const summarized = part.inlineData ? {
+    ...part,
+    inlineData: {
+      mimeType: part.inlineData.mimeType,
+      data: "<binary omitted>"
+    }
+  } : part;
+  if (!summarized.functionResponse?.parts) {
+    return summarized;
+  }
+  return {
+    ...summarized,
+    functionResponse: {
+      ...summarized.functionResponse,
+      parts: summarized.functionResponse.parts.map(summarizeBatchResponsePart)
+    }
+  };
+}
+__name(summarizeBatchResponsePart, "summarizeBatchResponsePart");
+function toPostToolBatchToolCall(call) {
+  return {
+    tool_name: call.request.name,
+    tool_input: call.request.args,
+    tool_use_id: call.request.callId,
+    status: call.status,
+    tool_response: serializeToolResponse(call.response)
+  };
+}
+__name(toPostToolBatchToolCall, "toPostToolBatchToolCall");
+function appendContextToResponsePart(part, additionalContext) {
+  if (!part.functionResponse) {
+    debugLogger22.warn(
+      "appendContextToResponsePart: no functionResponse on part, additionalContext dropped"
+    );
+    return part;
+  }
+  const response = part.functionResponse.response ?? {};
+  const output = response["output"];
+  const error = response["error"];
+  const hasOutput = Object.prototype.hasOwnProperty.call(response, "output");
+  const useOutputKey = typeof output === "string" || hasOutput && typeof error !== "string";
+  const key = useOutputKey ? "output" : "error";
+  const currentText = useOutputKey ? typeof output === "string" ? output : JSON.stringify(output) : typeof error === "string" ? error : JSON.stringify(response);
+  return {
+    ...part,
+    functionResponse: {
+      ...part.functionResponse,
+      response: {
+        ...response,
+        [key]: `${currentText}
+
+${additionalContext}`
+      }
+    }
+  };
+}
+__name(appendContextToResponsePart, "appendContextToResponsePart");
+function appendContextToToolResponse(response, additionalContext) {
+  if (!additionalContext || response.responseParts.length === 0) {
+    return response;
+  }
+  const responseParts = [...response.responseParts];
+  const lastIndex = responseParts.length - 1;
+  const appendedPart = appendContextToResponsePart(
+    responseParts[lastIndex],
+    additionalContext
+  );
+  if (appendedPart === responseParts[lastIndex]) {
+    return response;
+  }
+  responseParts[lastIndex] = appendedPart;
+  return {
+    ...response,
+    responseParts,
+    contentLength: response.contentLength !== void 0 ? response.contentLength + additionalContext.length + 2 : void 0
+  };
+}
+__name(appendContextToToolResponse, "appendContextToToolResponse");
+function withPostToolBatchAdditionalContext(completedCalls, additionalContext) {
+  if (!additionalContext || completedCalls.length === 0) {
+    return completedCalls;
+  }
+  const calls = [...completedCalls];
+  const lastIndex = calls.length - 1;
+  calls[lastIndex] = {
+    ...calls[lastIndex],
+    response: appendContextToToolResponse(
+      calls[lastIndex].response,
+      additionalContext
+    )
+  };
+  return calls;
+}
+__name(withPostToolBatchAdditionalContext, "withPostToolBatchAdditionalContext");
+function withPostToolBatchStop(completedCalls, stopReason) {
+  if (completedCalls.length === 0) {
+    return completedCalls;
+  }
+  const calls = [...completedCalls];
+  const lastCall = calls[calls.length - 1];
+  calls[calls.length - 1] = {
+    status: "error",
+    request: lastCall.request,
+    tool: lastCall.tool,
+    response: createErrorResponse(
+      lastCall.request,
+      new Error(stopReason),
+      "execution_denied" /* EXECUTION_DENIED */
+    ),
+    durationMs: lastCall.durationMs,
+    outcome: void 0
+  };
+  return calls;
+}
+__name(withPostToolBatchStop, "withPostToolBatchStop");
 function isConcurrencySafe(call) {
   if (canonicalToolName(call.request.name) === ToolNames.AGENT) return true;
   if (call.tool.kind === "execute" /* Execute */) {
@@ -43515,6 +43877,10 @@ var CoreToolScheduler = class {
   // sessions reusing the same AbortSignal don't accumulate listeners
   // and trip Node's MaxListenersExceededWarning (#4321 review-3).
   callIdToBatch = /* @__PURE__ */ new Map();
+  // Keep the scheduling signal until the all-calls-complete hook fires.
+  // callIdToBatch is drained earlier when spans end, so it cannot be used
+  // to recover the PostToolBatch AbortSignal reliably.
+  callIdToPostToolBatchSignal = /* @__PURE__ */ new Map();
   requestQueue = [];
   constructor(options2) {
     this.config = options2.config;
@@ -43662,7 +44028,11 @@ var CoreToolScheduler = class {
       }
     });
     this.notifyToolCallsUpdate();
-    this.checkAndNotifyCompletion();
+    void this.checkAndNotifyCompletion().catch((error) => {
+      debugLogger22.warn(
+        `setStatusInternal completion notification failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    });
   }
   setArgsInternal(targetCallId, args2) {
     this.toolCalls = this.toolCalls.map((call) => {
@@ -43787,6 +44157,7 @@ var CoreToolScheduler = class {
             setToolSpanCancelled(span);
             this.finalizeToolSpan(callId);
           }
+          this.callIdToPostToolBatchSignal.delete(callId);
         } catch (e) {
           debugLogger22.warn(
             `drainSpansForBatch: failed to drain ${callId}: ${e instanceof Error ? e.message : String(e)}`
@@ -44104,6 +44475,7 @@ 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(
@@ -44453,7 +44825,11 @@ var CoreToolScheduler = class {
         }
       }
       await this.attemptExecutionOfScheduledCalls(signal);
-      void this.checkAndNotifyCompletion();
+      void this.checkAndNotifyCompletion().catch((error) => {
+        debugLogger22.warn(
+          `_schedule completion notification failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      });
       if (batchState.callIds.size === 0) {
         signal.removeEventListener("abort", batchState.onAbort);
       }
@@ -45194,21 +45570,78 @@ ${failureHookResult.additionalContext}`;
       (call) => call.status === "success" || call.status === "error" || call.status === "cancelled"
     );
     if (this.toolCalls.length > 0 && allCallsAreTerminal) {
-      const completedCalls = [...this.toolCalls];
+      let completedCalls = [...this.toolCalls];
       this.toolCalls = [];
+      this.isFinalizingToolCalls = true;
+      const batchSignal = completedCalls.map(
+        (call) => this.callIdToPostToolBatchSignal.get(call.request.callId)
+      ).find((candidate) => !!candidate);
       for (const call of completedCalls) {
-        logToolCall(this.config, new ToolCallEvent(call));
+        this.callIdToPostToolBatchSignal.delete(call.request.callId);
       }
-      this.recordToolResults(completedCalls);
-      if (this.onAllToolCallsComplete) {
-        this.isFinalizingToolCalls = true;
-        await this.onAllToolCallsComplete(completedCalls);
-        this.isFinalizingToolCalls = false;
+      let messageBus;
+      try {
+        const shouldFirePostToolBatch = !this.config.getDisableAllHooks() && (this.config.hasHooksForEvent?.("PostToolBatch") ?? false);
+        messageBus = shouldFirePostToolBatch ? this.config.getMessageBus() : void 0;
+      } catch (error) {
+        debugLogger22.warn(
+          `PostToolBatch hook setup failed: ${error instanceof Error ? error.message : String(error)}`
+        );
       }
-      this.notifyToolCallsUpdate();
-      if (this.requestQueue.length > 0) {
-        const next = this.requestQueue.shift();
-        this._schedule(next.request, next.signal).then(next.resolve).catch(next.reject);
+      try {
+        if (messageBus) {
+          const batchToolCalls = completedCalls.map(toPostToolBatchToolCall);
+          const permissionMode = this.config.getApprovalMode();
+          const batchHookResult = await this.withHookSpan(
+            { hookEvent: "PostToolBatch", toolName: "batch" },
+            () => firePostToolBatchHook(
+              messageBus,
+              batchToolCalls,
+              permissionMode,
+              batchSignal
+            ),
+            (r) => r.hookError ? {
+              success: false,
+              error: r.hookError,
+              shouldStop: false,
+              postBatchStop: false
+            } : {
+              success: true,
+              shouldStop: r.shouldStop,
+              hasAdditionalContext: !!r.additionalContext,
+              blockType: r.shouldStop ? "stop" : void 0,
+              postBatchStop: r.shouldStop,
+              postBatchStopReason: r.shouldStop ? r.stopReason || "no reason given" : void 0
+            }
+          );
+          if (batchHookResult.shouldStop) {
+            debugLogger22.info(
+              `PostToolBatch hook stopped batch (${completedCalls.length} calls): ${batchHookResult.stopReason || "no reason given"}`
+            );
+            completedCalls = withPostToolBatchStop(
+              completedCalls,
+              batchHookResult.stopReason || "Execution stopped by PostToolBatch hook"
+            );
+          }
+          completedCalls = withPostToolBatchAdditionalContext(
+            completedCalls,
+            batchHookResult.additionalContext
+          );
+        }
+        for (const call of completedCalls) {
+          logToolCall(this.config, new ToolCallEvent(call));
+        }
+        this.recordToolResults(completedCalls);
+        if (this.onAllToolCallsComplete) {
+          await this.onAllToolCallsComplete(completedCalls);
+        }
+        this.notifyToolCallsUpdate();
+      } finally {
+        this.isFinalizingToolCalls = false;
+        if (this.requestQueue.length > 0) {
+          const next = this.requestQueue.shift();
+          this._schedule(next.request, next.signal).then(next.resolve).catch(next.reject);
+        }
       }
     }
   }
@@ -46946,6 +47379,10 @@ ${userMemory.trim()}`;
 init_esbuild_shims();
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
 var FORK_SUBAGENT_TYPE = "fork";
+function isForkSubagentEnabled(config) {
+  return config.isForkSubagentEnabled() && config.isInteractive();
+}
+__name(isForkSubagentEnabled, "isForkSubagentEnabled");
 var FORK_BOILERPLATE_TAG = "fork-boilerplate";
 var FORK_DIRECTIVE_PREFIX = "Directive: ";
 var FORK_AGENT = {
@@ -54552,7 +54989,7 @@ The Agent tool launches specialized agents (subprocesses) that autonomously hand
 Available agent types and the tools they have access to:
 ${subagentDescriptions}
 
-When using the Agent tool, specify a subagent_type parameter to select which agent type to use.
+${isForkSubagentEnabled(this.config) ? `When using the Agent tool, specify a subagent_type to use a specialized agent, or omit it to fork yourself \u2014 a fork inherits your full conversation context.` : `When using the Agent tool, specify a subagent_type parameter to select which agent type to use. If omitted, the general-purpose agent is used.`}
 
 When NOT to use the Agent tool:
 - If you want to read a specific file path, use the ${ToolNames.READ_FILE} tool or the ${ToolNames.GLOB} tool instead of the ${ToolNames.AGENT} tool, to find the match more quickly
@@ -54572,6 +55009,35 @@ Usage notes:
 - If the user specifies that they want you to run agents "in parallel", you MUST send a single message with multiple Agent tool use content blocks. For example, if you need to launch both a build-validator agent and a test-runner agent in parallel, send a single message with both tool calls.
 - You can optionally set \`run_in_background: true\` to run the agent in the background. You will be notified when it completes. Use this when you have genuinely independent work to do in parallel and don't need the agent's results before you can proceed.
 - You can optionally set \`isolation: "worktree"\` to run the agent in a temporary git worktree, giving it an isolated copy of the repository. The worktree is automatically cleaned up if the agent makes no changes; if changes are made, the worktree path and branch are returned in the result so you can review or merge them.
+${isForkSubagentEnabled(this.config) ? `
+## When to fork
+
+Fork yourself (omit \`subagent_type\`) when the intermediate tool output isn't worth keeping in your context. The criterion is qualitative \u2014 "will I need this output again" \u2014 not task size.
+- **Research**: fork open-ended questions. If research can be broken into independent questions, launch parallel forks in one message. A fork beats a fresh subagent for this \u2014 it inherits context and shares your cache.
+- **Implementation**: prefer to fork implementation work that requires more than a couple of edits. Do research before jumping to implementation.
+
+Forks are cheap because they share your prompt cache. Don't set \`model\` on a fork \u2014 a different model can't reuse the parent's cache. Pass a short \`name\` (one or two words, lowercase) so the user can track the fork.
+
+**Don't peek.** The tool result includes an output \u2014 do not read or tail it unless the user explicitly asks for a progress check. You get a completion notification; trust it. Reading the transcript mid-flight pulls the fork's tool noise into your context, which defeats the point of forking.
+
+**Don't race.** After launching, you know nothing about what the fork found. Never fabricate or predict fork results in any format \u2014 not as prose, summary, or structured output. The notification arrives as a user-role message in a later turn; it is never something you write yourself. If the user asks a follow-up before the notification lands, tell them the fork is still running \u2014 give status, not a guess.
+
+**Writing a fork prompt.** Since the fork inherits your context, the prompt is a *directive* \u2014 what to do, not what the situation is. Be specific about scope: what's in, what's out, what another agent is handling. Don't re-explain background.
+` : ""}
+## Writing the prompt
+
+${isForkSubagentEnabled(this.config) ? "When spawning a fresh agent (with a `subagent_type`), it starts with zero context. " : ""}Brief the agent like a smart colleague who just walked into the room \u2014 it has not seen this conversation, does not know what you've tried, and does not understand why this task matters.
+- Explain what you're trying to accomplish and why.
+- Describe what you've already learned or ruled out.
+- Give enough context about the surrounding problem that the agent can make judgment calls rather than just following a narrow instruction.
+- If you need a short response, say so explicitly.
+- For lookups, provide the exact target. For investigations, provide the actual question rather than an over-prescribed sequence of steps.
+
+${isForkSubagentEnabled(this.config) ? "For fresh agents, terse" : "Terse"} command-style prompts produce shallow, generic work.
+
+**Never delegate understanding.** Do not write prompts like "based on your findings, fix the bug" or "based on the research, implement it." Those phrases push synthesis onto the agent instead of doing it yourself. Write prompts that prove you understood the task: include relevant file paths, constraints, what specifically needs to be learned or changed, and what is out of scope.
+
+After launching an agent, do not fabricate or predict what it found before it returns. If the user asks a follow-up before the result arrives, provide status rather than guessing.
 
 Example usage:
 
@@ -55147,7 +55613,8 @@ var AgentToolInvocation = class extends BaseToolInvocation {
     let restoreParentPM = /* @__PURE__ */ __name(() => {
     }, "restoreParentPM");
     try {
-      const isFork = !this.params.subagent_type;
+      const isFork = !this.params.subagent_type && isForkSubagentEnabled(this.config);
+      const effectiveSubagentType = this.params.subagent_type ?? (isFork ? void 0 : DEFAULT_BUILTIN_SUBAGENT_TYPE);
       let subagentConfig;
       if (isFork) {
         subagentConfig = FORK_AGENT;
@@ -55166,18 +55633,18 @@ var AgentToolInvocation = class extends BaseToolInvocation {
         }
       } else {
         const loadedConfig = await this.subagentManager.loadSubagent(
-          this.params.subagent_type
+          effectiveSubagentType
         );
         if (!loadedConfig) {
           return {
-            llmContent: `Subagent "${this.params.subagent_type}" not found`,
+            llmContent: `Subagent "${effectiveSubagentType}" not found`,
             returnDisplay: {
               type: "task_execution",
-              subagentName: this.params.subagent_type,
+              subagentName: effectiveSubagentType,
               taskDescription: this.params.description,
               taskPrompt: this.params.prompt,
               status: "failed",
-              terminateReason: `Subagent "${this.params.subagent_type}" not found`
+              terminateReason: `Subagent "${effectiveSubagentType}" not found`
             }
           };
         }
@@ -65569,11 +66036,6 @@ var GeminiClient = class {
       }
       if (messageType === "userQuery" /* UserQuery */ || messageType === "cron" /* Cron */) {
         const systemReminders = [];
-        const hasAgentTool = await this.config.getToolRegistry().ensureTool(ToolNames.AGENT);
-        const subagents = (await this.config.getSubagentManager().listSubagents()).filter((subagent) => subagent.level !== "builtin").map((subagent) => subagent.name);
-        if (hasAgentTool && subagents.length > 0) {
-          systemReminders.push(getSubagentSystemReminder(subagents));
-        }
         if (this.config.getApprovalMode() === "plan" /* PLAN */) {
           systemReminders.push(
             getPlanModeSystemReminder(this.config.getSdkMode())
@@ -65937,14 +66399,15 @@ var GeminiClient = class {
    * startup context after successful compaction and flips the IDE full-context
    * flag for the next regular message.
    */
-  async tryCompressChat(prompt_id, force = false, signal) {
+  async tryCompressChat(prompt_id, force = false, signal, customInstructions) {
     const previousSessionStartContext = this.lastSessionStartContext;
     const previousSessionStartSource = this.lastSessionStartSource;
     const info2 = await this.getChat().tryCompress(
       prompt_id,
       this.config.getModel(),
       force,
-      signal
+      signal,
+      customInstructions ? { customInstructions } : void 0
     );
     if (info2.compressionStatus === 1 /* COMPRESSED */) {
       const chat = this.getChat();
@@ -75191,7 +75654,7 @@ __name(assertNever, "assertNever");
 // packages/core/src/tools/mcp-client.ts
 init_esbuild_shims();
 
-// packages/core/node_modules/@modelcontextprotocol/sdk/dist/esm/client/sse.js
+// node_modules/@modelcontextprotocol/sdk/dist/esm/client/sse.js
 init_esbuild_shims();
 
 // node_modules/eventsource/dist/index.js
@@ -75502,7 +75965,7 @@ function getBaseURL() {
 }
 __name(getBaseURL, "getBaseURL");
 
-// packages/core/node_modules/@modelcontextprotocol/sdk/dist/esm/client/sse.js
+// node_modules/@modelcontextprotocol/sdk/dist/esm/client/sse.js
 var SseError = class extends Error {
   static {
     __name(this, "SseError");
@@ -98173,6 +98636,7 @@ var HookAggregator = class {
       case "PreToolUse" /* PreToolUse */:
       case "PostToolUse" /* PostToolUse */:
       case "PostToolUseFailure" /* PostToolUseFailure */:
+      case "PostToolBatch" /* PostToolBatch */:
       case "Stop" /* Stop */:
       case "UserPromptSubmit" /* UserPromptSubmit */:
       case "SubagentStop" /* SubagentStop */:
@@ -98361,6 +98825,8 @@ var HookAggregator = class {
         return new PostToolUseHookOutput(output);
       case "PostToolUseFailure" /* PostToolUseFailure */:
         return new PostToolUseFailureHookOutput(output);
+      case "PostToolBatch" /* PostToolBatch */:
+        return new PostToolBatchHookOutput(output);
       case "Stop" /* Stop */:
       case "SubagentStop" /* SubagentStop */:
         return new StopHookOutput(output);
@@ -98413,6 +98879,7 @@ function getHookMatcherTarget(eventName, context) {
       };
     case "UserPromptSubmit" /* UserPromptSubmit */:
     case "Stop" /* Stop */:
+    case "PostToolBatch" /* PostToolBatch */:
     case "TodoCreated" /* TodoCreated */:
     case "TodoCompleted" /* TodoCompleted */:
       return void 0;
@@ -98756,6 +99223,23 @@ var HookEventHandler = class {
       signal
     );
   }
+  /**
+   * Fire a PostToolBatch event
+   * Called once after every tool call in a batch has resolved
+   */
+  async firePostToolBatchEvent(toolCalls, permissionMode = "default" /* Default */, signal) {
+    const input = {
+      ...this.createBaseInput("PostToolBatch" /* PostToolBatch */),
+      permission_mode: permissionMode,
+      tool_calls: toolCalls
+    };
+    return this.executeHooks(
+      "PostToolBatch" /* PostToolBatch */,
+      input,
+      void 0,
+      signal
+    );
+  }
   /**
    * Fire a Notification event
    */
@@ -99565,6 +100049,17 @@ var HookSystem = class {
     );
     return result.finalOutput ? createHookOutput("PostToolUseFailure", result.finalOutput) : void 0;
   }
+  /**
+   * Fire a PostToolBatch event - called once after a tool-call batch resolves
+   */
+  async firePostToolBatchEvent(toolCalls, permissionMode = "default" /* Default */, signal) {
+    const result = await this.hookEventHandler.firePostToolBatchEvent(
+      toolCalls,
+      permissionMode,
+      signal
+    );
+    return result.finalOutput ? createHookOutput("PostToolBatch", result.finalOutput) : void 0;
+  }
   /**
    * Fire a PreCompact event - called before conversation compaction
    */
@@ -103544,6 +104039,7 @@ var Config = class {
   runtimeStatusEnabled = false;
   experimentalZedIntegration = false;
   cronEnabled = false;
+  forkSubagentEnabled = false;
   computerUseEnabled = true;
   emitToolUseSummaries = true;
   chatRecordingEnabled;
@@ -103704,6 +104200,7 @@ var Config = class {
     this.sessionTokenLimit = params.sessionTokenLimit ?? -1;
     this.experimentalZedIntegration = params.experimentalZedIntegration ?? false;
     this.cronEnabled = params.cronEnabled ?? false;
+    this.forkSubagentEnabled = params.forkSubagentEnabled ?? false;
     this.computerUseEnabled = params.computerUseEnabled ?? true;
     this.emitToolUseSummaries = params.emitToolUseSummaries ?? true;
     this.listExtensions = params.listExtensions ?? false;
@@ -103898,6 +104395,13 @@ var Config = class {
                   signal
                 );
                 break;
+              case "PostToolBatch":
+                result = await hookSystem.firePostToolBatchEvent(
+                  input["tool_calls"] || [],
+                  input["permission_mode"] || "default",
+                  signal
+                );
+                break;
               case "Notification":
                 result = await hookSystem.fireNotificationEvent(
                   input["message"] || "",
@@ -105166,6 +105670,10 @@ var Config = class {
     if (process5.env["QWEN_CODE_ENABLE_CRON"] === "1") return true;
     return this.cronEnabled;
   }
+  isForkSubagentEnabled() {
+    if (process5.env["QWEN_CODE_ENABLE_FORK_SUBAGENT"] === "1") return true;
+    return this.forkSubagentEnabled;
+  }
   isComputerUseEnabled() {
     return this.computerUseEnabled;
   }
@@ -105740,25 +106248,25 @@ var Config = class {
       if (options2?.forSubAgent) return;
       const schema = this.jsonSchema;
       await registerLazy(ToolNames.STRUCTURED_OUTPUT, async () => {
-        const { SyntheticOutputTool } = await import("./syntheticOutput-U3YJ3GOO.js");
+        const { SyntheticOutputTool } = await import("./syntheticOutput-DM43O6TY.js");
         return new SyntheticOutputTool(schema);
       });
     }, "registerStructuredOutputIfRequested");
     if (this.getBareMode()) {
       await registerLazy(ToolNames.READ_FILE, async () => {
-        const { ReadFileTool } = await import("./read-file-N2YTOQ2U.js");
+        const { ReadFileTool } = await import("./read-file-MXUW3RUF.js");
         return new ReadFileTool(this);
       });
       await registerLazy(ToolNames.EDIT, async () => {
-        const { EditTool } = await import("./edit-UQFK25NR.js");
+        const { EditTool } = await import("./edit-YP22XCVA.js");
         return new EditTool(this);
       });
       await registerLazy(ToolNames.NOTEBOOK_EDIT, async () => {
-        const { NotebookEditTool } = await import("./notebook-edit-I2MBTWI6.js");
+        const { NotebookEditTool } = await import("./notebook-edit-AFRICVUX.js");
         return new NotebookEditTool(this);
       });
       await registerLazy(ToolNames.SHELL, async () => {
-        const { ShellTool: ShellTool2 } = await import("./shell-V7PVS7O7.js");
+        const { ShellTool: ShellTool2 } = await import("./shell-JOXQ5PPL.js");
         return new ShellTool2(this);
       });
       await registerStructuredOutputIfRequested();
@@ -105768,31 +106276,31 @@ var Config = class {
       return registry;
     }
     await registerLazy(ToolNames.TOOL_SEARCH, async () => {
-      const { ToolSearchTool } = await import("./tool-search-6CRPUSUB.js");
+      const { ToolSearchTool } = await import("./tool-search-DRMR34WX.js");
       return new ToolSearchTool(this);
     });
     await registerLazy(ToolNames.AGENT, async () => {
-      const { AgentTool: AgentTool2 } = await import("./agent-Z7O3I6MY.js");
+      const { AgentTool: AgentTool2 } = await import("./agent-GNHB6UIW.js");
       return new AgentTool2(this);
     });
     await registerLazy(ToolNames.TASK_STOP, async () => {
-      const { TaskStopTool } = await import("./task-stop-NPUI3YBA.js");
+      const { TaskStopTool } = await import("./task-stop-WKP5OB3V.js");
       return new TaskStopTool(this);
     });
     await registerLazy(ToolNames.SEND_MESSAGE, async () => {
-      const { SendMessageTool } = await import("./send-message-ZL7CDM7K.js");
+      const { SendMessageTool } = await import("./send-message-GFYV7WLL.js");
       return new SendMessageTool(this);
     });
     await registerLazy(ToolNames.SKILL, async () => {
-      const { SkillTool } = await import("./skill-6LP5ANRL.js");
+      const { SkillTool } = await import("./skill-73RYGDJQ.js");
       return new SkillTool(this);
     });
     await registerLazy(ToolNames.LS, async () => {
-      const { LSTool } = await import("./ls-7FYQHPWF.js");
+      const { LSTool } = await import("./ls-T4SVZWR6.js");
       return new LSTool(this);
     });
     await registerLazy(ToolNames.READ_FILE, async () => {
-      const { ReadFileTool } = await import("./read-file-N2YTOQ2U.js");
+      const { ReadFileTool } = await import("./read-file-MXUW3RUF.js");
       return new ReadFileTool(this);
     });
     if (this.getUseRipgrep()) {
@@ -105805,7 +106313,7 @@ var Config = class {
       }
       if (useRipgrep) {
         await registerLazy(ToolNames.GREP, async () => {
-          const { RipGrepTool: RipGrepTool2 } = await import("./ripGrep-NBWBOVPW.js");
+          const { RipGrepTool: RipGrepTool2 } = await import("./ripGrep-AHBINNF3.js");
           return new RipGrepTool2(this);
         });
       } else {
@@ -105818,89 +106326,89 @@ var Config = class {
           )
         );
         await registerLazy(ToolNames.GREP, async () => {
-          const { GrepTool } = await import("./grep-4RXPZUYZ.js");
+          const { GrepTool } = await import("./grep-RFEZDGI4.js");
           return new GrepTool(this);
         });
       }
     } else {
       await registerLazy(ToolNames.GREP, async () => {
-        const { GrepTool } = await import("./grep-4RXPZUYZ.js");
+        const { GrepTool } = await import("./grep-RFEZDGI4.js");
         return new GrepTool(this);
       });
     }
     await registerLazy(ToolNames.GLOB, async () => {
-      const { GlobTool } = await import("./glob-34CPYA2M.js");
+      const { GlobTool } = await import("./glob-NZWP66L5.js");
       return new GlobTool(this);
     });
     await registerLazy(ToolNames.EDIT, async () => {
-      const { EditTool } = await import("./edit-UQFK25NR.js");
+      const { EditTool } = await import("./edit-YP22XCVA.js");
       return new EditTool(this);
     });
     await registerLazy(ToolNames.NOTEBOOK_EDIT, async () => {
-      const { NotebookEditTool } = await import("./notebook-edit-I2MBTWI6.js");
+      const { NotebookEditTool } = await import("./notebook-edit-AFRICVUX.js");
       return new NotebookEditTool(this);
     });
     await registerLazy(ToolNames.WRITE_FILE, async () => {
-      const { WriteFileTool } = await import("./write-file-CCMVL5Q7.js");
+      const { WriteFileTool } = await import("./write-file-B45ZAKUJ.js");
       return new WriteFileTool(this);
     });
     await registerLazy(ToolNames.SHELL, async () => {
-      const { ShellTool: ShellTool2 } = await import("./shell-V7PVS7O7.js");
+      const { ShellTool: ShellTool2 } = await import("./shell-JOXQ5PPL.js");
       return new ShellTool2(this);
     });
     await registerLazy(ToolNames.TODO_WRITE, async () => {
-      const { TodoWriteTool } = await import("./todoWrite-USWGQJ53.js");
+      const { TodoWriteTool } = await import("./todoWrite-GHL6DCLP.js");
       return new TodoWriteTool(this);
     });
     await registerLazy(ToolNames.ASK_USER_QUESTION, async () => {
-      const { AskUserQuestionTool } = await import("./askUserQuestion-DC6OWQIL.js");
+      const { AskUserQuestionTool } = await import("./askUserQuestion-TGRD7FNQ.js");
       return new AskUserQuestionTool(this);
     });
     if (!this.sdkMode) {
       await registerLazy(ToolNames.EXIT_PLAN_MODE, async () => {
-        const { ExitPlanModeTool } = await import("./exitPlanMode-SFNBASAU.js");
+        const { ExitPlanModeTool } = await import("./exitPlanMode-2D6EGF76.js");
         return new ExitPlanModeTool(this);
       });
     }
     await registerLazy(ToolNames.ENTER_WORKTREE, async () => {
-      const { EnterWorktreeTool } = await import("./enter-worktree-VZT6JX45.js");
+      const { EnterWorktreeTool } = await import("./enter-worktree-BD7UFMUZ.js");
       return new EnterWorktreeTool(this);
     });
     await registerLazy(ToolNames.EXIT_WORKTREE, async () => {
-      const { ExitWorktreeTool } = await import("./exit-worktree-JETQQ26R.js");
+      const { ExitWorktreeTool } = await import("./exit-worktree-AVWBCQWY.js");
       return new ExitWorktreeTool(this);
     });
     await registerLazy(ToolNames.WEB_FETCH, async () => {
-      const { WebFetchTool } = await import("./web-fetch-LGLGFGGT.js");
+      const { WebFetchTool } = await import("./web-fetch-SZIV74ZX.js");
       return new WebFetchTool(this);
     });
     if (this.isLspEnabled() && this.getLspClient()) {
       await registerLazy(ToolNames.LSP, async () => {
-        const { LspTool } = await import("./lsp-DKG34USR.js");
+        const { LspTool } = await import("./lsp-U4ZQLNIS.js");
         return new LspTool(this);
       });
     }
     await registerStructuredOutputIfRequested();
     if (this.isCronEnabled()) {
       await registerLazy(ToolNames.CRON_CREATE, async () => {
-        const { CronCreateTool } = await import("./cron-create-FXRORK2U.js");
+        const { CronCreateTool } = await import("./cron-create-V3UK2SJN.js");
         return new CronCreateTool(this);
       });
       await registerLazy(ToolNames.CRON_LIST, async () => {
-        const { CronListTool } = await import("./cron-list-SMOX26SL.js");
+        const { CronListTool } = await import("./cron-list-UDIYK3B3.js");
         return new CronListTool(this);
       });
       await registerLazy(ToolNames.CRON_DELETE, async () => {
-        const { CronDeleteTool } = await import("./cron-delete-D24IN6CA.js");
+        const { CronDeleteTool } = await import("./cron-delete-MANALPCP.js");
         return new CronDeleteTool(this);
       });
     }
     if (this.isComputerUseEnabled()) {
-      const { registerComputerUseTools } = await import("./computer-use-2J5ZXEER.js");
+      const { registerComputerUseTools } = await import("./computer-use-NAHQPV2L.js");
       await registerComputerUseTools(registerLazy);
     }
     await registerLazy(ToolNames.MONITOR, async () => {
-      const { MonitorTool } = await import("./monitor-QCNAUO75.js");
+      const { MonitorTool } = await import("./monitor-OHKCQLFQ.js");
       return new MonitorTool(this);
     });
     if (this.pendingMcpBudgetCallback) {
@@ -121159,7 +121667,6 @@ export {
   getCoreSystemPrompt,
   getCompressionPrompt,
   getProjectSummaryPrompt,
-  getSubagentSystemReminder,
   getPlanModeSystemReminder,
   getArenaSystemReminder,
   getInsightPrompt,