@qwen-code/qwen-code 0.24.1-preview.2 → 0.24.1

package/chunks/{chunk-7S2BGPWN.js → chunk-J6QWYIXU.js}

@@ -155,7 +155,7 @@ import {
   stringify,
   validateGoalProposalReason,
   validateSkillName
-} from "./chunk-ZPLLLCRC.js";
+} from "./chunk-MQD3FY7L.js";
 import {
   canUseRipgrep
 } from "./chunk-KMPZCA4L.js";
@@ -265,7 +265,7 @@ import {
 } from "./chunk-6C3D7BKK.js";
 import {
   isOmniDeliveryActive
-} from "./chunk-YM7MHAIC.js";
+} from "./chunk-QZECTXG4.js";
 import {
   MediaResourceRegistry,
   evaluateMediaPolicyToolCall,
@@ -286,7 +286,7 @@ import {
   resolveEffectiveOutputStyle,
   resolveInteractionMode,
   resolveMainSessionOutputStyle
-} from "./chunk-I4EFTUMC.js";
+} from "./chunk-KNTOORZV.js";
 import {
   NO_EXEC_CONFIG,
   findGitRoot,
@@ -333,7 +333,7 @@ import {
 import {
   DashScopeOpenAICompatibleProvider,
   selectDashScopeThinkingKnob
-} from "./chunk-3WTPIIX3.js";
+} from "./chunk-HISXBKXU.js";
 import {
   InvalidStreamError,
   getToolCallPreparations,
@@ -437,7 +437,7 @@ import {
   resolveReasoningForModel,
   stripRuntimeSnapshotPrefix,
   validateReasoningCapabilities
-} from "./chunk-EUEDQORS.js";
+} from "./chunk-FUZESLZQ.js";
 import {
   openBrowserSecurely,
   shouldAttemptBrowserLaunch
@@ -563,7 +563,7 @@ import {
   updateMCPServerStatus,
   writeLine,
   writeLineSync
-} from "./chunk-KQW7W6WZ.js";
+} from "./chunk-3UOPPEN5.js";
 import {
   getInvocationContext,
   runWithInvocationContext
@@ -667,7 +667,7 @@ import {
   resolveContentGeneratorConfigWithSources,
   setGeneratorReasoningEffort,
   tokenLimit
-} from "./chunk-UQ4WDEGV.js";
+} from "./chunk-CBJBLKDH.js";
 import {
   DEFAULT_QWEN_MODEL
 } from "./chunk-XZA32HII.js";
@@ -34324,6 +34324,15 @@ function findRunningLegacyGoalCard(records) {
   return running;
 }
 __name(findRunningLegacyGoalCard, "findRunningLegacyGoalCard");
+var GOAL_CARD_KINDS = /* @__PURE__ */ new Set([
+  "set",
+  "achieved",
+  "cleared",
+  "failed",
+  "aborted",
+  "paused",
+  "checking"
+]);
 function isRunningKind(kind) {
   return kind === "set" || kind === "checking";
 }
@@ -34345,7 +34354,9 @@ function legacyGoalCards(record4) {
     if (raw["type"] !== "goal_status") continue;
     const kind = raw["kind"];
     const condition = raw["condition"];
-    if (typeof kind !== "string" || typeof condition !== "string") continue;
+    if (typeof kind !== "string" || !GOAL_CARD_KINDS.has(kind) || typeof condition !== "string") {
+      continue;
+    }
     const iterations = finiteNumber(raw["iterations"]);
     const setAt = finiteNumber(raw["setAt"]);
     cards.push({
@@ -43925,7 +43936,7 @@ var LlmChat = class {
                 const degradeAttempt = omniMediaDegradeAttempts++;
                 let degradeOutcome;
                 try {
-                  const { degradeOmniMediaAfterServerReject } = await import("./reactive-degrade-SJQJUSWE.js");
+                  const { degradeOmniMediaAfterServerReject } = await import("./reactive-degrade-N2GKSQDU.js");
                   degradeOutcome = await degradeOmniMediaAfterServerReject(
                     self2.config,
                     self2.history,
@@ -68217,7 +68228,7 @@ var CoreToolScheduler = class _CoreToolScheduler {
     const notices = [];
     let omniProcessed = responseParts;
     if (this.config.isOmniEnabled?.()) {
-      const { processToolResultOmniMedia } = await import("./tool-result-media-GQOZVVL2.js");
+      const { processToolResultOmniMedia } = await import("./tool-result-media-LWY3EMBX.js");
       omniProcessed = await processToolResultOmniMedia(
         responseParts,
         this.config,
@@ -71254,7 +71265,7 @@ ${body}
           artifacts: toolResult.artifacts
         } : void 0;
         if (policyArtifacts && policyArtifacts.executionOrigin.kind !== "fixed_policy" && scheduledCall.tool.mediaPolicyDescriptor) {
-          const { collectModelPolicyCall } = await import("./model-call-collection-TON6MSCF.js");
+          const { collectModelPolicyCall } = await import("./model-call-collection-NNN4RJL2.js");
           await collectModelPolicyCall({
             config: this.config,
             batch: policyArtifacts,
@@ -90234,7 +90245,8 @@ function getMainSessionBaseSystemPrompt(config3) {
     // section, and a session must not be reminded of one it lacks.
     resolveMainSessionOutputStyle(config3),
     config3.isTodoWriteEnabled(),
-    config3.getCodeModeOnly()
+    config3.getCodeModeOnly(),
+    { declaredTools: config3.getPromptToolSnapshot?.() }
   );
 }
 __name(getMainSessionBaseSystemPrompt, "getMainSessionBaseSystemPrompt");
@@ -91683,6 +91695,11 @@ var LlmClient = class _LlmClient {
       profiler.timeSync("deferred_tool_preload", () => {
         this.preloadDeferredToolsWithinBudget();
       });
+      this.config.setPromptToolSnapshot?.(
+        new Set(
+          toolRegistry.getFunctionDeclarations().map((declaration) => declaration.name).filter((name) => Boolean(name))
+        )
+      );
       const deferredTools = profiler.timeSync("deferred_reminder_setup", () => {
         const resolved = this.resolveDeferredToolsForReminder(deferredSummary);
         this.rememberAnnouncedDeferredTools(resolved);
@@ -152188,6 +152205,49 @@ var ExtensionManager = class _ExtensionManager {
     }
     return snapshot;
   }
+  /**
+   * Loads the extension catalog — identity fields only (id, name, version,
+   * install metadata, activation policy) — and returns it with the store's
+   * snapshot. Skills, commands, agents, hooks, and context files are NOT
+   * loaded, so this costs one manifest read per extension instead of a full
+   * subresource scan. The inclusion set matches the full load exactly: the
+   * manifest head rejects the same manifests the full load's catch rejects.
+   *
+   * Unlike `refreshCacheWithSnapshot`, this touches no manager state: no
+   * `extensionCache` write (the entries carry no subresources, so caching
+   * them would poison a shared manager) and no fingerprint baseline commit
+   * (which would make a later `refreshCacheIfSourcesChanged` on a shared
+   * manager report "unchanged" over a manifest-only cache). That also keeps
+   * the per-request cost down — no fingerprint walk on this path.
+   *
+   * The fingerprint still governs invalidation for full refreshes and is
+   * unaffected by this method: it covers only install metadata and manifests
+   * — never skill files — so a skill-only edit does not change the catalog's
+   * inputs either, which is exactly the desired behavior.
+   */
+  async refreshCatalogSnapshot(options2) {
+    const requestedNames = options2?.names?.filter(Boolean) ?? [];
+    const { value: extensions, snapshot } = await this.extensionStore.readConsistent(async () => {
+      const loadedAll = await this.loadExtensionsFromExtensionsDir(
+        this.configDir,
+        this.workspaceDir,
+        { manifestOnly: true }
+      );
+      const loaded = requestedNames.length > 0 ? loadedAll.filter(
+        (extension) => requestedNames.some(
+          (name) => name.toLowerCase() === extension.name.toLowerCase()
+        )
+      ) : loadedAll;
+      return {
+        value: loaded,
+        extensions: loaded.map((extension) => ({
+          id: extension.id,
+          name: extension.name
+        }))
+      };
+    });
+    return { snapshot, extensions };
+  }
   static stampPath(target, followSymlinks = true) {
     try {
       const stats = followSymlinks ? fs73.statSync(target) : fs73.lstatSync(target);
@@ -152342,7 +152402,7 @@ var ExtensionManager = class _ExtensionManager {
       dir
     );
   }
-  async loadExtensionsFromExtensionsDir(extensionsDir, workspaceDir) {
+  async loadExtensionsFromExtensionsDir(extensionsDir, workspaceDir, options2 = {}) {
     let subdirs;
     try {
       subdirs = fs73.readdirSync(extensionsDir);
@@ -152352,70 +152412,114 @@ var ExtensionManager = class _ExtensionManager {
     const extensions = [];
     for (const subdir of subdirs) {
       const extensionDir = path72.join(extensionsDir, subdir);
-      const extension = await this.loadExtension({
-        extensionDir,
-        workspaceDir
-      });
+      const extension = await this.loadExtension(
+        { extensionDir, workspaceDir },
+        { manifestOnly: options2.manifestOnly }
+      );
       if (extension != null) {
         extensions.push(extension);
       }
     }
     return extensions;
   }
-  async loadExtension(context2, options2 = {}) {
-    const { extensionDir, workspaceDir } = context2;
-    if (!fs73.statSync(extensionDir).isDirectory()) {
-      return null;
-    }
+  /**
+   * Loads everything an extension's manifest itself provides: install
+   * metadata, the parsed (and env-resolved) config, the extension id, and the
+   * base `Extension` object. Everything sourced from subresource directories
+   * (skills, commands, agents, hooks, context files) is left to the caller.
+   *
+   * The agent-plugins-v1 MCP load always runs here because its throws are
+   * part of this head's rejection set — skipping it would change which
+   * extensions a caller sees. With `createDataDir` (the default) a
+   * successful load also mkdirs the plugin data root; catalog-style callers
+   * pass `false` so a read-only refresh performs no write.
+   */
+  async loadExtensionManifestHead(context2, options2 = {}) {
+    const { extensionDir } = context2;
     const installMetadata = this.loadInstallMetadata(extensionDir);
     let effectiveExtensionPath = extensionDir;
     if (installMetadata?.type === "link" && typeof installMetadata.source === "string" && installMetadata.source.length > 0) {
       effectiveExtensionPath = installMetadata.source;
     }
     try {
-      const loadedManifest = this.loadExtensionManifest({
-        extensionDir: effectiveExtensionPath,
-        workspaceDir
-      });
-      let config3 = loadedManifest.config;
-      if (loadedManifest.format === "qwen") {
-        config3 = resolveEnvVarsInObject(config3);
-      }
-      const extensionId = getExtensionId(config3, installMetadata);
-      if (loadedManifest.format === "agent-plugins-v1") {
-        config3 = {
-          ...config3,
-          mcpServers: await loadAgentPluginMcpServers(
-            effectiveExtensionPath,
-            this.extensionStore.agentPluginDataRoot(extensionId),
-            { createDataDir: true }
-          )
-        };
-      }
-      const extension = {
-        id: extensionId,
-        name: config3.name,
-        displayName: config3.displayName,
-        version: config3.version || installMetadata?.marketplaceConfig?.metadata?.version || "1.0.0",
-        path: effectiveExtensionPath,
-        format: loadedManifest.format,
+      return await this.loadExtensionManifestHeadResolved(
+        context2,
         installMetadata,
-        isActive: this.isEnabled(config3.name, this.workspaceDir),
-        config: config3,
-        settings: config3.settings,
-        contextFiles: []
-      };
-      if (config3.mcpServers) {
-        extension.mcpServers = Object.fromEntries(
-          Object.entries(config3.mcpServers).map(([key, value]) => [
-            key,
-            filterMcpConfig(value)
-          ])
-        );
+        effectiveExtensionPath,
+        options2
+      );
+    } catch (error3) {
+      const withManifestPath = error3;
+      if (!withManifestPath.manifestPath) {
+        withManifestPath.manifestPath = effectiveExtensionPath;
       }
-      if (loadedManifest.format === "qwen" && config3.channels) {
-        extension.channels = config3.channels;
+      throw error3;
+    }
+  }
+  async loadExtensionManifestHeadResolved(context2, installMetadata, effectiveExtensionPath, options2) {
+    const { workspaceDir } = context2;
+    const loadedManifest = this.loadExtensionManifest({
+      extensionDir: effectiveExtensionPath,
+      workspaceDir
+    });
+    let config3 = loadedManifest.config;
+    if (loadedManifest.format === "qwen") {
+      config3 = resolveEnvVarsInObject(config3);
+    }
+    const extensionId = getExtensionId(config3, installMetadata);
+    if (loadedManifest.format === "agent-plugins-v1") {
+      config3 = {
+        ...config3,
+        mcpServers: await loadAgentPluginMcpServers(
+          effectiveExtensionPath,
+          this.extensionStore.agentPluginDataRoot(extensionId),
+          { createDataDir: options2.createDataDir !== false }
+        )
+      };
+    }
+    const extension = {
+      id: extensionId,
+      name: config3.name,
+      displayName: config3.displayName,
+      version: config3.version || installMetadata?.marketplaceConfig?.metadata?.version || "1.0.0",
+      path: effectiveExtensionPath,
+      format: loadedManifest.format,
+      installMetadata,
+      isActive: this.isEnabled(config3.name, this.workspaceDir),
+      config: config3,
+      settings: config3.settings,
+      contextFiles: []
+    };
+    if (config3.mcpServers) {
+      extension.mcpServers = Object.fromEntries(
+        Object.entries(config3.mcpServers).map(([key, value]) => [
+          key,
+          filterMcpConfig(value)
+        ])
+      );
+    }
+    if (loadedManifest.format === "qwen" && config3.channels) {
+      extension.channels = config3.channels;
+    }
+    return { extension, loadedManifest };
+  }
+  async loadExtension(context2, options2 = {}) {
+    const { extensionDir } = context2;
+    if (!fs73.statSync(extensionDir).isDirectory()) {
+      return null;
+    }
+    let extension;
+    try {
+      const head = await this.loadExtensionManifestHead(context2, {
+        createDataDir: !options2.manifestOnly
+      });
+      extension = head.extension;
+      if (options2.manifestOnly) {
+        return extension;
       }
+      const { loadedManifest } = head;
+      const config3 = extension.config;
+      const effectiveExtensionPath = extension.path;
       if (loadedManifest.format === "agent-plugins-v1") {
         extension.commands = [];
         extension.skills = await loadAgentPluginSkills(effectiveExtensionPath);
@@ -152479,7 +152583,7 @@ var ExtensionManager = class _ExtensionManager {
     } catch (e) {
       if (options2.throwOnError) throw e;
       debugLogger105.warn(
-        `Warning: Skipping extension in ${effectiveExtensionPath}: ${getErrorMessage(
+        `Warning: Skipping extension in ${e.manifestPath ?? extension?.path ?? extensionDir}: ${getErrorMessage(
           e
         )}`
       );
@@ -163882,6 +163986,11 @@ var Config = class _Config {
    * single-block layout when it doesn't match the request's system text.
    */
   staticSystemPrefix;
+  /**
+   * Tool names declared to the model when this session's system prompt was
+   * built. See {@link getPromptToolSnapshot}.
+   */
+  promptToolSnapshot;
   /**
    * Volatile system-prompt layer: the managed auto-memory section
    * (instructions + MEMORY.md indexes). Kept separate from `userMemory`
@@ -164677,7 +164786,7 @@ var Config = class _Config {
     await this.proxyDispatcherReady;
     options2?.signal?.throwIfAborted();
     if (this.isOmniEnabled()) {
-      const { normalizeDedicatedOmniUploadConfig } = await import("./upload-config-JNZAPCF6.js");
+      const { normalizeDedicatedOmniUploadConfig } = await import("./upload-config-PE3LJBUR.js");
       this.omniUploadConfig = normalizeDedicatedOmniUploadConfig({
         baseUrl: this.omniUploadBaseUrl,
         apiKeyEnv: this.omniUploadApiKeyEnv,
@@ -167765,6 +167874,23 @@ var Config = class _Config {
   setStaticSystemPrefix(prefix) {
     this.staticSystemPrefix = prefix;
   }
+  /**
+   * The tool names declared to the model when this session's system prompt was
+   * built. The prompt gates its tool-specific text on this set (#12032), and
+   * `/context` reads the same set so its system-prompt row describes the text
+   * the request actually carries rather than what the registry holds now — the
+   * two genuinely diverge after a mid-session ToolSearch reveal, because a
+   * reveal rewrites the declarations without rebuilding the prompt.
+   *
+   * `undefined` until `startChat` records it, which the prompt builder reads as
+   * "every tool is declared" and renders exactly as it did before gating.
+   */
+  getPromptToolSnapshot() {
+    return this.promptToolSnapshot;
+  }
+  setPromptToolSnapshot(names) {
+    this.promptToolSnapshot = names;
+  }
   /**
    * The managed auto-memory section of the system prompt (volatile layer).
    * Empty when managed memory is unavailable. Callers assembling a system
@@ -168550,7 +168676,7 @@ var Config = class _Config {
     return this.omniPolicyTools;
   }
   async loadOmniMediaReader() {
-    return import("./omni-32DW7DAU.js");
+    return import("./omni-J44KEAF2.js");
   }
   /** Normalized `omni.processing` view. Undefined until tool warmup
    * completes (or when omni is disabled). */
@@ -170083,7 +170209,7 @@ var Config = class _Config {
   async registerWorkflowTool(registry3) {
     if (registry3.getAllToolNames().includes(ToolNames.WORKFLOW)) return true;
     await this.registerLazyTool(registry3, ToolNames.WORKFLOW, async () => {
-      const { WorkflowTool } = await import("./workflow-ZLOBJFVU.js");
+      const { WorkflowTool } = await import("./workflow-AQ74SHPL.js");
       return new WorkflowTool(this);
     });
     return registry3.getAllToolNames().includes(ToolNames.WORKFLOW);
@@ -170159,8 +170285,8 @@ var Config = class _Config {
         );
       }
       const [{ createExecutionTools }, { wrapExecutionTool }] = await Promise.all([
-        import("./local-execution-environment-JLIO4YKC.js"),
-        import("./execution-tool-GSOYRE7M.js")
+        import("./local-execution-environment-JIXYT7RU.js"),
+        import("./execution-tool-LGCWZ5JC.js")
       ]);
       for (const [name, tool] of createExecutionTools(this)) {
         if (name === ToolNames.LS && !this.isLsToolEnabled()) continue;
@@ -170170,7 +170296,7 @@ var Config = class _Config {
         );
       }
       await registerLazy(ToolNames.TOOL_SEARCH, async () => {
-        const { ToolSearchTool } = await import("./tool-search-ZF4TSSBS.js");
+        const { ToolSearchTool } = await import("./tool-search-5RPYPGFG.js");
         return new ToolSearchTool(this);
       });
       return registry3;
@@ -170187,16 +170313,16 @@ var Config = class _Config {
     const registerGoalWorkerTools = /* @__PURE__ */ __name(async () => {
       if (options2?.forSubAgent) return;
       await registerLazy(ToolNames.GET_GOAL, async () => {
-        const { GetGoalTool: GetGoalTool2 } = await import("./goal-tools-D523PJR5.js");
+        const { GetGoalTool: GetGoalTool2 } = await import("./goal-tools-52S6IYSS.js");
         return new GetGoalTool2(this);
       });
       await registerLazy(ToolNames.UPDATE_GOAL, async () => {
-        const { UpdateGoalTool: UpdateGoalTool2 } = await import("./goal-tools-D523PJR5.js");
+        const { UpdateGoalTool: UpdateGoalTool2 } = await import("./goal-tools-52S6IYSS.js");
         return new UpdateGoalTool2(this);
       });
       if (this.getModelProposedGoals() !== "disabled" && (resolveInteractionMode(this) === "interactive" || this.goalProposalHostSupported)) {
         await registerLazy(ToolNames.PROPOSE_GOAL, async () => {
-          const { ProposeGoalTool: ProposeGoalTool2 } = await import("./goal-tools-D523PJR5.js");
+          const { ProposeGoalTool: ProposeGoalTool2 } = await import("./goal-tools-52S6IYSS.js");
           return new ProposeGoalTool2(this);
         });
       }
@@ -170210,19 +170336,19 @@ var Config = class _Config {
     }, "registerExecIfEnabled");
     if (this.getBareMode()) {
       await registerLazy(ToolNames.READ_FILE, async () => {
-        const { ReadFileTool } = await import("./read-file-FSGLCFTS.js");
+        const { ReadFileTool } = await import("./read-file-MGTENCNH.js");
         return new ReadFileTool(this);
       });
       await registerLazy(ToolNames.EDIT, async () => {
-        const { EditTool } = await import("./edit-FJFHUIY4.js");
+        const { EditTool } = await import("./edit-XY623A63.js");
         return new EditTool(this);
       });
       await registerLazy(ToolNames.NOTEBOOK_EDIT, async () => {
-        const { NotebookEditTool } = await import("./notebook-edit-QH7FXG4T.js");
+        const { NotebookEditTool } = await import("./notebook-edit-VZ3HDVGJ.js");
         return new NotebookEditTool(this);
       });
       await registerLazy(ToolNames.SHELL, async () => {
-        const { ShellTool: ShellTool2 } = await import("./shell-BRLSIRIJ.js");
+        const { ShellTool: ShellTool2 } = await import("./shell-OHI4FUG7.js");
         return new ShellTool2(this);
       });
       await registerGoalWorkerTools();
@@ -170236,7 +170362,7 @@ var Config = class _Config {
     await registerExecIfEnabled();
     await registerGoalWorkerTools();
     await registerLazy(ToolNames.TOOL_SEARCH, async () => {
-      const { ToolSearchTool } = await import("./tool-search-ZF4TSSBS.js");
+      const { ToolSearchTool } = await import("./tool-search-5RPYPGFG.js");
       return new ToolSearchTool(this);
     });
     await registerLazy(ToolNames.READ_MCP_RESOURCE, async () => {
@@ -170244,7 +170370,7 @@ var Config = class _Config {
       return new ReadMcpResourceTool(this);
     });
     await registerLazy(ToolNames.AGENT, async () => {
-      const { AgentTool: AgentTool2 } = await import("./agent-6SYYNHSZ.js");
+      const { AgentTool: AgentTool2 } = await import("./agent-WINHBR34.js");
       return new AgentTool2(this);
     });
     await registerLazy(ToolNames.LIST_AGENTS, async () => {
@@ -170260,7 +170386,7 @@ var Config = class _Config {
       return new SendMessageTool(this);
     });
     await registerLazy(ToolNames.SKILL, async () => {
-      const { SkillTool } = await import("./skill-ANJV3QCO.js");
+      const { SkillTool } = await import("./skill-3VAIVEQN.js");
       return new SkillTool(this);
     });
     if (this.isLsToolEnabled()) {
@@ -170270,11 +170396,11 @@ var Config = class _Config {
       });
     }
     await registerLazy(ToolNames.READ_FILE, async () => {
-      const { ReadFileTool } = await import("./read-file-FSGLCFTS.js");
+      const { ReadFileTool } = await import("./read-file-MGTENCNH.js");
       return new ReadFileTool(this);
     });
     await registerLazy(ToolNames.ZOOM_IMAGE, async () => {
-      const { ZoomImageTool } = await import("./zoom-image-MRU6WPE6.js");
+      const { ZoomImageTool } = await import("./zoom-image-7INIHGVL.js");
       return new ZoomImageTool(this);
     });
     if (this.getUseRipgrep()) {
@@ -170289,7 +170415,7 @@ var Config = class _Config {
       recordStartupEvent("config_initialize_ripgrep_probe_end");
       if (useRipgrep) {
         await registerLazy(ToolNames.GREP, async () => {
-          const { RipGrepTool } = await import("./ripGrep-YVM3DMMW.js");
+          const { RipGrepTool } = await import("./ripGrep-GY3USA7L.js");
           return new RipGrepTool(this);
         });
       } else {
@@ -170315,23 +170441,23 @@ var Config = class _Config {
       });
     }
     await registerLazy(ToolNames.GLOB, async () => {
-      const { GlobTool } = await import("./glob-M2TXMH5Q.js");
+      const { GlobTool } = await import("./glob-KMXCAZRN.js");
       return new GlobTool(this);
     });
     await registerLazy(ToolNames.EDIT, async () => {
-      const { EditTool } = await import("./edit-FJFHUIY4.js");
+      const { EditTool } = await import("./edit-XY623A63.js");
       return new EditTool(this);
     });
     await registerLazy(ToolNames.NOTEBOOK_EDIT, async () => {
-      const { NotebookEditTool } = await import("./notebook-edit-QH7FXG4T.js");
+      const { NotebookEditTool } = await import("./notebook-edit-VZ3HDVGJ.js");
       return new NotebookEditTool(this);
     });
     await registerLazy(ToolNames.WRITE_FILE, async () => {
-      const { WriteFileTool } = await import("./write-file-Z35R7HTD.js");
+      const { WriteFileTool } = await import("./write-file-BJ5NTPQB.js");
       return new WriteFileTool(this);
     });
     await registerLazy(ToolNames.SHELL, async () => {
-      const { ShellTool: ShellTool2 } = await import("./shell-BRLSIRIJ.js");
+      const { ShellTool: ShellTool2 } = await import("./shell-OHI4FUG7.js");
       return new ShellTool2(this);
     });
     if (this.isTodoWriteEnabled()) {
@@ -170347,19 +170473,19 @@ var Config = class _Config {
     const supportsUserInteraction = resolveInteractionMode(this) !== "headless";
     if (supportsUserInteraction) {
       await registerLazy(ToolNames.ASK_USER_QUESTION, async () => {
-        const { AskUserQuestionTool: AskUserQuestionTool2 } = await import("./askUserQuestion-RYGNEYFC.js");
+        const { AskUserQuestionTool: AskUserQuestionTool2 } = await import("./askUserQuestion-C2GAWACN.js");
         return new AskUserQuestionTool2(this);
       });
     }
     if (!this.sdkMode && (supportsUserInteraction || options2?.forSubAgent)) {
       await registerLazy(ToolNames.EXIT_PLAN_MODE, async () => {
-        const { ExitPlanModeTool: ExitPlanModeTool2 } = await import("./exitPlanMode-3GA5VWWB.js");
+        const { ExitPlanModeTool: ExitPlanModeTool2 } = await import("./exitPlanMode-AGRSXL5M.js");
         return new ExitPlanModeTool2(this);
       });
     }
     if (!this.sdkMode && supportsUserInteraction) {
       await registerLazy(ToolNames.ENTER_PLAN_MODE, async () => {
-        const { EnterPlanModeTool } = await import("./enterPlanMode-WGDUBIGO.js");
+        const { EnterPlanModeTool } = await import("./enterPlanMode-VGKHLQVD.js");
         return new EnterPlanModeTool(this);
       });
     }
@@ -170372,7 +170498,7 @@ var Config = class _Config {
       return new ExitWorktreeTool(this);
     });
     await registerLazy(ToolNames.WEB_FETCH, async () => {
-      const { WebFetchTool } = await import("./web-fetch-6IQOTXM2.js");
+      const { WebFetchTool } = await import("./web-fetch-WVJPQMBM.js");
       return new WebFetchTool(this);
     });
     if (resolveInteractionMode(this) === "interactive" && !this.sdkMode && !this.getScreenReader() && !options2?.forSubAgent) {
@@ -170383,11 +170509,11 @@ var Config = class _Config {
     }
     const hasExplicitWebSearchBackend = !!this.webSearchSettings?.model?.trim() || !!this.webSearchSettings?.baseUrl;
     if (!this.getBareMode() && !this.isSafeMode() && this.webSearchSettings?.enabled !== false && (this.webSearchSettings?.enabled === true || !hasExplicitWebSearchBackend)) {
-      const { evaluateWebSearchGate } = await import("./web-search-TY4ODCXK.js");
+      const { evaluateWebSearchGate } = await import("./web-search-MLYZQUGL.js");
       const gate = evaluateWebSearchGate(this);
       if (gate.ok) {
         await registerLazy(ToolNames.WEB_SEARCH, async () => {
-          const { WebSearchTool } = await import("./web-search-TY4ODCXK.js");
+          const { WebSearchTool } = await import("./web-search-MLYZQUGL.js");
           return new WebSearchTool(this);
         });
       } else if (!gate.silent && !this.webSearchNoticeEmitted && !options2?.forSubAgent) {
@@ -170444,7 +170570,7 @@ var Config = class _Config {
     }
     if (this.isAgentTeamEnabled()) {
       await registerLazy(ToolNames.TEAM_CREATE, async () => {
-        const { TeamCreateTool } = await import("./team-create-KWEJO6TE.js");
+        const { TeamCreateTool } = await import("./team-create-ED6VAG37.js");
         return new TeamCreateTool(this);
       });
       await registerLazy(ToolNames.TEAM_DELETE, async () => {
@@ -170452,7 +170578,7 @@ var Config = class _Config {
         return new TeamDeleteTool(this);
       });
       await registerLazy(ToolNames.TEAM_PLAN_APPROVAL, async () => {
-        const { TeamPlanApprovalTool } = await import("./team-plan-approval-VXHTSKHR.js");
+        const { TeamPlanApprovalTool } = await import("./team-plan-approval-LDAEETXQ.js");
         return new TeamPlanApprovalTool(this);
       });
       if (!options2?.forSubAgent) {
@@ -170548,7 +170674,7 @@ var Config = class _Config {
       }
     }
     await registerLazy(ToolNames.MONITOR, async () => {
-      const { MonitorTool } = await import("./monitor-VXQ7KYEJ.js");
+      const { MonitorTool } = await import("./monitor-AMX4GGO4.js");
       return new MonitorTool(this);
     });
     if (this.pendingMcpBudgetCallback) {