@opencow-ai/opencow-agent-sdk 0.4.18 → 0.4.20

package/dist/client.js

@@ -31323,7 +31323,7 @@ function isFsInaccessible(e) {
   const code = getErrnoCode(e);
   return code === "ENOENT" || code === "EACCES" || code === "EPERM" || code === "ENOTDIR" || code === "ELOOP";
 }
-var ClaudeError, MalformedCommandError, AbortError, ConfigParseError, ShellError, TelemetrySafeError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS;
+var ClaudeError, MalformedCommandError, AbortError, ToolContinuationStopError, ConfigParseError, ShellError, TelemetrySafeError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS;
 var init_errors5 = __esm(() => {
   init_canonical();
   ClaudeError = class ClaudeError extends Error {
@@ -31340,6 +31340,12 @@ var init_errors5 = __esm(() => {
       this.name = "AbortError";
     }
   };
+  ToolContinuationStopError = class ToolContinuationStopError extends Error {
+    constructor(message, options) {
+      super(message, options);
+      this.name = "ToolContinuationStopError";
+    }
+  };
   ConfigParseError = class ConfigParseError extends Error {
     filePath;
     defaultConfig;
@@ -46083,6 +46089,21 @@ var init_which = __esm(() => {
 // src/capabilities/git.ts
 import { readFileSync as readFileSync5, realpathSync as realpathSync2, statSync as statSync4 } from "fs";
 import { basename as basename3, dirname as dirname7, join as join12, resolve as resolve6, sep as sep4 } from "path";
+function hasValidGitMarker(gitPath) {
+  const markerStat = statSync4(gitPath);
+  if (markerStat.isDirectory()) {
+    return statSync4(join12(gitPath, "HEAD")).isFile();
+  }
+  if (!markerStat.isFile()) {
+    return false;
+  }
+  const marker = readFileSync5(gitPath, "utf-8").trim();
+  if (!marker.startsWith("gitdir:")) {
+    return false;
+  }
+  const gitDir = resolve6(dirname7(gitPath), marker.slice("gitdir:".length).trim());
+  return statSync4(join12(gitDir, "HEAD")).isFile();
+}
 function createFindGitRoot() {
   function wrapper(startPath) {
     const result = findGitRootImpl(startPath);
@@ -46167,8 +46188,7 @@ var init_git = __esm(() => {
       try {
         const gitPath = join12(current, ".git");
         statCount++;
-        const stat4 = statSync4(gitPath);
-        if (stat4.isDirectory() || stat4.isFile()) {
+        if (hasValidGitMarker(gitPath)) {
           logForDiagnosticsNoPII("info", "find_git_root_completed", {
             duration_ms: Date.now() - startTime,
             stat_count: statCount,
@@ -46186,8 +46206,7 @@ var init_git = __esm(() => {
     try {
       const gitPath = join12(root2, ".git");
       statCount++;
-      const stat4 = statSync4(gitPath);
-      if (stat4.isDirectory() || stat4.isFile()) {
+      if (hasValidGitMarker(gitPath)) {
         logForDiagnosticsNoPII("info", "find_git_root_completed", {
           duration_ms: Date.now() - startTime,
           stat_count: statCount,
@@ -234734,18 +234753,74 @@ var init_registerFrontmatterHooks = __esm(() => {
 });
 
 // src/session/backgroundAbortRegistry.ts
-function registerBackgroundAgentAbort(agentId, controller) {
-  runs.set(agentId, { controller, stopFired: false });
+function registerBackgroundAgentAbort(agentId, actions) {
+  if (runs.has(agentId)) {
+    throw new Error(`Background agent '${agentId}' is already registered`);
+  }
+  let resolveSettled = () => {};
+  const settled = new Promise((resolve15) => {
+    resolveSettled = resolve15;
+  });
+  runs.set(agentId, {
+    ...actions,
+    stopFired: false,
+    stopPromise: undefined,
+    settled,
+    resolveSettled,
+    shellsStopped: false
+  });
 }
 function unregisterBackgroundAgentAbort(agentId) {
+  const run = runs.get(agentId);
+  if (!run)
+    return;
   runs.delete(agentId);
+  run.resolveSettled();
 }
 function abortBackgroundAgentById(agentId) {
   const run = runs.get(agentId);
   if (!run)
-    return false;
-  run.controller.abort();
-  return true;
+    return Promise.resolve();
+  if (!run.stopPromise) {
+    run.stopPromise = (async () => {
+      const errors4 = [];
+      let abortFailed = false;
+      try {
+        run.abort();
+      } catch (error41) {
+        abortFailed = true;
+        errors4.push(error41);
+      }
+      try {
+        stopBackgroundAgentShells(run);
+      } catch (error41) {
+        errors4.push(error41);
+      }
+      if (abortFailed) {
+        throw new AggregateError(errors4, `Failed to stop background agent '${agentId}'`);
+      }
+      await run.settled;
+      if (errors4.length > 0) {
+        throw new AggregateError(errors4, `Failed to stop background agent '${agentId}'`);
+      }
+    })();
+  }
+  return run.stopPromise;
+}
+function hasBackgroundAgent(agentId) {
+  return runs.has(agentId);
+}
+function stopBackgroundAgentShellsById(agentId) {
+  const run = runs.get(agentId);
+  if (run) {
+    stopBackgroundAgentShells(run);
+  }
+}
+function stopBackgroundAgentShells(run) {
+  if (run.shellsStopped)
+    return;
+  run.shellsStopped = true;
+  run.stopShells();
 }
 function markSubagentStopFired(agentId) {
   const run = runs.get(agentId);
@@ -235703,6 +235778,23 @@ var init_formatting = __esm(() => {
   init_xml();
 });
 
+// src/capabilities/tools/AgentTool/agentLifecycleFinalizer.ts
+function createAgentLifecycleFinalizer(onCleanupError) {
+  let finalization;
+  return (cleanups) => {
+    finalization ??= (async () => {
+      for (const cleanup of cleanups) {
+        try {
+          await cleanup();
+        } catch (error41) {
+          onCleanupError(error41);
+        }
+      }
+    })();
+    return finalization;
+  };
+}
+
 // src/capabilities/tools/AgentTool/runAgent.ts
 import { randomUUID as randomUUID6 } from "crypto";
 async function initializeAgentMcpServers(agentDefinition, parentClients) {
@@ -235725,44 +235817,6 @@ async function initializeAgentMcpServers(agentDefinition, parentClients) {
   const agentClients = [];
   const newlyCreatedClients = [];
   const agentTools = [];
-  for (const spec of agentDefinition.mcpServers) {
-    let config2 = null;
-    let name;
-    let isNewlyCreated = false;
-    if (typeof spec === "string") {
-      name = spec;
-      config2 = getMcpConfigByName(spec);
-      if (!config2) {
-        logForDebugging(`[Agent: ${agentDefinition.agentType}] MCP server not found: ${spec}`, { level: "warn" });
-        continue;
-      }
-    } else {
-      const entries = Object.entries(spec);
-      if (entries.length !== 1) {
-        logForDebugging(`[Agent: ${agentDefinition.agentType}] Invalid MCP server spec: expected exactly one key`, { level: "warn" });
-        continue;
-      }
-      const [serverName, serverConfig] = entries[0];
-      name = serverName;
-      config2 = {
-        ...serverConfig,
-        scope: "dynamic"
-      };
-      isNewlyCreated = true;
-    }
-    const client = await connectToServer(name, config2);
-    agentClients.push(client);
-    if (isNewlyCreated) {
-      newlyCreatedClients.push(client);
-    }
-    if (client.type === "connected") {
-      const tools = await fetchToolsForClient(client);
-      agentTools.push(...tools);
-      logForDebugging(`[Agent: ${agentDefinition.agentType}] Connected to MCP server '${name}' with ${tools.length} tools`);
-    } else {
-      logForDebugging(`[Agent: ${agentDefinition.agentType}] Failed to connect to MCP server '${name}': ${client.type}`, { level: "warn" });
-    }
-  }
   const cleanup = async () => {
     for (const client of newlyCreatedClients) {
       if (client.type === "connected") {
@@ -235774,6 +235828,49 @@ async function initializeAgentMcpServers(agentDefinition, parentClients) {
       }
     }
   };
+  try {
+    for (const spec of agentDefinition.mcpServers) {
+      let config2 = null;
+      let name;
+      let isNewlyCreated = false;
+      if (typeof spec === "string") {
+        name = spec;
+        config2 = getMcpConfigByName(spec);
+        if (!config2) {
+          logForDebugging(`[Agent: ${agentDefinition.agentType}] MCP server not found: ${spec}`, { level: "warn" });
+          continue;
+        }
+      } else {
+        const entries = Object.entries(spec);
+        if (entries.length !== 1) {
+          logForDebugging(`[Agent: ${agentDefinition.agentType}] Invalid MCP server spec: expected exactly one key`, { level: "warn" });
+          continue;
+        }
+        const [serverName, serverConfig] = entries[0];
+        name = serverName;
+        config2 = {
+          ...serverConfig,
+          scope: "dynamic"
+        };
+        isNewlyCreated = true;
+      }
+      const client = await connectToServer(name, config2);
+      agentClients.push(client);
+      if (isNewlyCreated) {
+        newlyCreatedClients.push(client);
+      }
+      if (client.type === "connected") {
+        const tools = await fetchToolsForClient(client);
+        agentTools.push(...tools);
+        logForDebugging(`[Agent: ${agentDefinition.agentType}] Connected to MCP server '${name}' with ${tools.length} tools`);
+      } else {
+        logForDebugging(`[Agent: ${agentDefinition.agentType}] Failed to connect to MCP server '${name}': ${client.type}`, { level: "warn" });
+      }
+    }
+  } catch (error41) {
+    await cleanup();
+    throw error41;
+  }
   return {
     clients: [...parentClients, ...agentClients],
     tools: agentTools,
@@ -235926,121 +236023,140 @@ async function* runAgent({
   const additionalWorkingDirectories = Array.from(appState.toolPermissionContext.additionalWorkingDirectories.keys());
   const agentSystemPrompt = override?.systemPrompt ? override.systemPrompt : asSystemPrompt(await getAgentSystemPrompt(agentDefinition, toolUseContext, resolvedAgentModel, additionalWorkingDirectories, resolvedTools));
   const agentAbortController = override?.abortController ? override.abortController : isAsync2 ? new AbortController : toolUseContext.abortController;
+  const stopOwnedShells = () => {
+    killShellTasksForAgent(agentId, toolUseContext.getAppState, rootSetAppState);
+  };
   if (isAsync2) {
-    registerBackgroundAgentAbort(agentId, agentAbortController);
-  }
-  const additionalContexts = [];
-  for await (const hookResult of executeSubagentStartHooks(agentId, agentDefinition.agentType, agentAbortController.signal, undefined, toolUseContext.toolUseId, isAsync2)) {
-    if (hookResult.additionalContexts && hookResult.additionalContexts.length > 0) {
-      additionalContexts.push(...hookResult.additionalContexts);
-    }
+    registerBackgroundAgentAbort(agentId, {
+      abort: () => {
+        killAsyncAgent(agentId, rootSetAppState);
+        if (!agentAbortController.signal.aborted) {
+          agentAbortController.abort();
+        }
+      },
+      stopShells: stopOwnedShells
+    });
   }
-  if (additionalContexts.length > 0) {
-    const contextMessage = createAttachmentMessage({
-      type: "hook_additional_context",
-      content: additionalContexts,
-      hookName: "SubagentStart",
-      toolUseID: randomUUID6(),
-      hookEvent: "SubagentStart"
+  let agentToolRuntimeContext;
+  let mcpCleanup = async () => {};
+  let lastAssistantForFallback = null;
+  let agentRunError;
+  const finalizeLifecycle = createAgentLifecycleFinalizer((error41) => {
+    logForDebugging(`Agent ${agentId} cleanup failed: ${error41}`, {
+      level: "warn"
     });
-    initialMessages.push(contextMessage);
-  }
-  const hooksAllowedForThisAgent = !isRestrictedToPluginOnly("hooks") || isSourceAdminTrusted(agentDefinition.source);
-  if (agentDefinition.hooks && hooksAllowedForThisAgent) {
-    registerFrontmatterHooks(rootSetAppState, agentId, agentDefinition.hooks, `agent '${agentDefinition.agentType}'`, true);
-  }
-  const skillsToPreload = agentDefinition.skills ?? [];
-  if (skillsToPreload.length > 0) {
-    const allSkills = await getSkillToolCommands(getProjectRoot());
-    const validSkills = [];
-    for (const skillName of skillsToPreload) {
-      const resolvedName = resolveSkillName(skillName, allSkills, agentDefinition);
-      if (!resolvedName) {
-        logForDebugging(`[Agent: ${agentDefinition.agentType}] Warning: Skill '${skillName}' specified in frontmatter was not found`, { level: "warn" });
-        continue;
-      }
-      const skill = getCommand(resolvedName, allSkills);
-      if (skill.type !== "prompt") {
-        logForDebugging(`[Agent: ${agentDefinition.agentType}] Warning: Skill '${skillName}' is not a prompt-based skill`, { level: "warn" });
-        continue;
+  });
+  try {
+    const additionalContexts = [];
+    for await (const hookResult of executeSubagentStartHooks(agentId, agentDefinition.agentType, agentAbortController.signal, undefined, toolUseContext.toolUseId, isAsync2)) {
+      if (hookResult.additionalContexts && hookResult.additionalContexts.length > 0) {
+        additionalContexts.push(...hookResult.additionalContexts);
       }
-      validSkills.push({ skillName, skill });
     }
-    const loaded = await Promise.all(validSkills.map(async ({ skillName, skill }) => ({
-      skillName,
-      skill,
-      content: await skill.getPromptForCommand("", toolUseContext)
-    })));
-    for (const { skillName, skill, content } of loaded) {
-      logForDebugging(`[Agent: ${agentDefinition.agentType}] Preloaded skill '${skillName}'`);
-      const metadata = formatSkillLoadingMetadata(skillName, skill.progressMessage);
-      initialMessages.push(createUserMessage({
-        content: [{ type: "text", text: metadata }, ...content],
-        isMeta: true
-      }));
+    if (additionalContexts.length > 0) {
+      const contextMessage = createAttachmentMessage({
+        type: "hook_additional_context",
+        content: additionalContexts,
+        hookName: "SubagentStart",
+        toolUseID: randomUUID6(),
+        hookEvent: "SubagentStart"
+      });
+      initialMessages.push(contextMessage);
+    }
+    const hooksAllowedForThisAgent = !isRestrictedToPluginOnly("hooks") || isSourceAdminTrusted(agentDefinition.source);
+    if (agentDefinition.hooks && hooksAllowedForThisAgent) {
+      registerFrontmatterHooks(rootSetAppState, agentId, agentDefinition.hooks, `agent '${agentDefinition.agentType}'`, true);
+    }
+    const skillsToPreload = agentDefinition.skills ?? [];
+    if (skillsToPreload.length > 0) {
+      const allSkills = await getSkillToolCommands(getProjectRoot());
+      const validSkills = [];
+      for (const skillName of skillsToPreload) {
+        const resolvedName = resolveSkillName(skillName, allSkills, agentDefinition);
+        if (!resolvedName) {
+          logForDebugging(`[Agent: ${agentDefinition.agentType}] Warning: Skill '${skillName}' specified in frontmatter was not found`, { level: "warn" });
+          continue;
+        }
+        const skill = getCommand(resolvedName, allSkills);
+        if (skill.type !== "prompt") {
+          logForDebugging(`[Agent: ${agentDefinition.agentType}] Warning: Skill '${skillName}' is not a prompt-based skill`, { level: "warn" });
+          continue;
+        }
+        validSkills.push({ skillName, skill });
+      }
+      const loaded = await Promise.all(validSkills.map(async ({ skillName, skill }) => ({
+        skillName,
+        skill,
+        content: await skill.getPromptForCommand("", toolUseContext)
+      })));
+      for (const { skillName, skill, content } of loaded) {
+        logForDebugging(`[Agent: ${agentDefinition.agentType}] Preloaded skill '${skillName}'`);
+        const metadata = formatSkillLoadingMetadata(skillName, skill.progressMessage);
+        initialMessages.push(createUserMessage({
+          content: [{ type: "text", text: metadata }, ...content],
+          isMeta: true
+        }));
+      }
     }
-  }
-  const {
-    clients: mergedMcpClients,
-    tools: agentMcpTools,
-    cleanup: mcpCleanup
-  } = await initializeAgentMcpServers(agentDefinition, toolUseContext.options.mcpClients);
-  const allTools = agentMcpTools.length > 0 ? uniqBy_default([...resolvedTools, ...agentMcpTools], "name") : resolvedTools;
-  const agentOptions = {
-    isNonInteractiveSession: useExactTools ? toolUseContext.options.isNonInteractiveSession : isAsync2 ? true : toolUseContext.options.isNonInteractiveSession ?? false,
-    appendSystemPrompt: toolUseContext.options.appendSystemPrompt,
-    tools: allTools,
-    commands: [],
-    debug: toolUseContext.options.debug,
-    verbose: toolUseContext.options.verbose,
-    mainLoopModel: effectiveModel,
-    providerOverride: providerOverride ?? undefined,
-    thinkingConfig: toolUseContext.options.thinkingConfig,
-    mcpClients: mergedMcpClients,
-    mcpResources: toolUseContext.options.mcpResources,
-    agentDefinitions: toolUseContext.options.agentDefinitions,
-    subagentDisallowedTools: toolUseContext.options.subagentDisallowedTools,
-    ...useExactTools && { querySource }
-  };
-  const agentToolRuntimeContext = createSubagentContext(toolUseContext, {
-    options: agentOptions,
-    agentId,
-    agentType: agentDefinition.agentType,
-    messages: initialMessages,
-    readFileState: agentReadFileState,
-    abortController: agentAbortController,
-    getAppState: agentGetAppState,
-    shareSetAppState: !isAsync2,
-    shareSetResponseLength: true,
-    criticalSystemReminder_EXPERIMENTAL: agentDefinition.criticalSystemReminder_EXPERIMENTAL,
-    contentReplacementState
-  });
-  if (preserveToolUseResults) {
-    agentToolRuntimeContext.preserveToolUseResults = true;
-  }
-  if (onCacheSafeParams) {
-    onCacheSafeParams({
-      systemPrompt: agentSystemPrompt,
-      userContext: resolvedUserContext,
-      systemContext: resolvedSystemContext,
-      toolUseContext: agentToolRuntimeContext,
-      forkContextMessages: initialMessages
+    const mcp = await initializeAgentMcpServers(agentDefinition, toolUseContext.options.mcpClients);
+    const {
+      clients: mergedMcpClients,
+      tools: agentMcpTools
+    } = mcp;
+    mcpCleanup = mcp.cleanup;
+    const allTools = agentMcpTools.length > 0 ? uniqBy_default([...resolvedTools, ...agentMcpTools], "name") : resolvedTools;
+    const agentOptions = {
+      isNonInteractiveSession: useExactTools ? toolUseContext.options.isNonInteractiveSession : isAsync2 ? true : toolUseContext.options.isNonInteractiveSession ?? false,
+      appendSystemPrompt: toolUseContext.options.appendSystemPrompt,
+      tools: allTools,
+      commands: [],
+      debug: toolUseContext.options.debug,
+      verbose: toolUseContext.options.verbose,
+      mainLoopModel: effectiveModel,
+      providerOverride: providerOverride ?? undefined,
+      thinkingConfig: toolUseContext.options.thinkingConfig,
+      mcpClients: mergedMcpClients,
+      mcpResources: toolUseContext.options.mcpResources,
+      agentDefinitions: toolUseContext.options.agentDefinitions,
+      subagentDisallowedTools: toolUseContext.options.subagentDisallowedTools,
+      ...useExactTools && { querySource }
+    };
+    agentToolRuntimeContext = createSubagentContext(toolUseContext, {
+      options: agentOptions,
+      agentId,
+      agentType: agentDefinition.agentType,
+      messages: initialMessages,
+      readFileState: agentReadFileState,
+      abortController: agentAbortController,
+      getAppState: agentGetAppState,
+      shareSetAppState: !isAsync2,
+      shareSetResponseLength: true,
+      criticalSystemReminder_EXPERIMENTAL: agentDefinition.criticalSystemReminder_EXPERIMENTAL,
+      contentReplacementState
     });
-  }
-  recordSidechainTranscript(initialMessages, agentId).catch((_err) => logForDebugging(`Failed to record sidechain transcript: ${_err}`));
-  writeAgentMetadata(agentId, {
-    agentType: agentDefinition.agentType,
-    ...worktreePath && { worktreePath },
-    ...description && { description }
-  }).catch((_err) => logForDebugging(`Failed to write agent metadata: ${_err}`));
-  let lastRecordedUuid = initialMessages.at(-1)?.uuid ?? null;
-  let partialBaseMessage = null;
-  const partialTextByIndex = new Map;
-  const PARTIAL_PROGRESS_HOOK_INTERVAL_MS = 100;
-  let lastPartialProgressHookAt = 0;
-  let lastAssistantForFallback = null;
-  let agentRunError;
-  try {
+    if (preserveToolUseResults) {
+      agentToolRuntimeContext.preserveToolUseResults = true;
+    }
+    if (onCacheSafeParams) {
+      onCacheSafeParams({
+        systemPrompt: agentSystemPrompt,
+        userContext: resolvedUserContext,
+        systemContext: resolvedSystemContext,
+        toolUseContext: agentToolRuntimeContext,
+        forkContextMessages: initialMessages
+      });
+    }
+    recordSidechainTranscript(initialMessages, agentId).catch((_err) => logForDebugging(`Failed to record sidechain transcript: ${_err}`));
+    writeAgentMetadata(agentId, {
+      agentType: agentDefinition.agentType,
+      ...worktreePath && { worktreePath },
+      ...description && { description }
+    }).catch((_err) => logForDebugging(`Failed to write agent metadata: ${_err}`));
+    let lastRecordedUuid = initialMessages.at(-1)?.uuid ?? null;
+    let partialBaseMessage = null;
+    const partialTextByIndex = new Map;
+    const PARTIAL_PROGRESS_HOOK_INTERVAL_MS = 100;
+    let lastPartialProgressHookAt = 0;
     for await (const message of query({
       messages: initialMessages,
       systemPrompt: agentSystemPrompt,
@@ -236130,43 +236246,65 @@ async function* runAgent({
     agentRunError = err2;
     throw err2;
   } finally {
-    const naturalStopAlreadyFired = isAsync2 && hasSubagentStopFired(agentId);
-    if (isAsync2) {
-      unregisterBackgroundAgentAbort(agentId);
-    }
-    if (isAsync2 && agentRunError !== undefined) {
-      logForDebugging(`Background agent ${agentId} crashed: ${errorMessage(agentRunError)}
+    await finalizeLifecycle([
+      async () => {
+        const naturalStopAlreadyFired = isAsync2 && hasSubagentStopFired(agentId);
+        if (isAsync2 && agentRunError !== undefined) {
+          logForDebugging(`Background agent ${agentId} crashed: ${errorMessage(agentRunError)}
 ${agentRunError instanceof Error ? agentRunError.stack ?? "" : ""}`, { level: "error" });
-    }
-    if (isAsync2 && !naturalStopAlreadyFired) {
-      try {
-        const fallbackAppState = agentToolRuntimeContext.getAppState();
-        const terminal = agentAbortController.signal.aborted ? { status: "stopped" } : agentRunError !== undefined ? { status: "failed", errorMessage: errorMessage(agentRunError) } : { status: "completed" };
-        const fallbackStop = executeStopHooks(fallbackAppState.toolPermissionContext.mode, undefined, undefined, false, agentId, agentToolRuntimeContext, lastAssistantForFallback ? [lastAssistantForFallback] : undefined, agentDefinition.agentType, undefined, terminal);
-        for await (const evt of fallbackStop) {}
-      } catch (err2) {
-        logForDebugging(`Fallback SubagentStop failed for ${agentId}: ${err2}`, {
-          level: "warn"
+        }
+        if (isAsync2 && !naturalStopAlreadyFired) {
+          try {
+            const terminalContext = agentToolRuntimeContext ?? toolUseContext;
+            const fallbackAppState = terminalContext.getAppState();
+            const terminal = agentAbortController.signal.aborted ? { status: "stopped" } : agentRunError !== undefined ? { status: "failed", errorMessage: errorMessage(agentRunError) } : { status: "completed" };
+            const fallbackStop = executeStopHooks(fallbackAppState.toolPermissionContext.mode, undefined, undefined, false, agentId, terminalContext, lastAssistantForFallback ? [lastAssistantForFallback] : undefined, agentDefinition.agentType, undefined, terminal);
+            for await (const evt of fallbackStop) {}
+          } catch (err2) {
+            logForDebugging(`Fallback SubagentStop failed for ${agentId}: ${err2}`, {
+              level: "warn"
+            });
+          }
+        }
+      },
+      mcpCleanup,
+      () => {
+        if (agentDefinition.hooks) {
+          clearSessionHooks(rootSetAppState, agentId);
+        }
+      },
+      () => {
+        if (false) {}
+      },
+      () => agentToolRuntimeContext?.readFileState.clear(),
+      () => {
+        initialMessages.length = 0;
+      },
+      () => unregisterAgent(agentId),
+      () => clearAgentTranscriptSubdir(agentId),
+      () => {
+        rootSetAppState((prev) => {
+          if (!(agentId in prev.todos))
+            return prev;
+          const { [agentId]: _removed, ...todos } = prev.todos;
+          return { ...prev, todos };
         });
+      },
+      () => {
+        if (isAsync2) {
+          stopBackgroundAgentShellsById(agentId);
+        } else {
+          stopOwnedShells();
+        }
+      },
+      () => {
+        if (false) {}
+      },
+      () => {
+        if (isAsync2)
+          unregisterBackgroundAgentAbort(agentId);
       }
-    }
-    await mcpCleanup();
-    if (agentDefinition.hooks) {
-      clearSessionHooks(rootSetAppState, agentId);
-    }
-    if (false) {}
-    agentToolRuntimeContext.readFileState.clear();
-    initialMessages.length = 0;
-    unregisterAgent(agentId);
-    clearAgentTranscriptSubdir(agentId);
-    rootSetAppState((prev) => {
-      if (!(agentId in prev.todos))
-        return prev;
-      const { [agentId]: _removed, ...todos } = prev.todos;
-      return { ...prev, todos };
-    });
-    killShellTasksForAgent(agentId, toolUseContext.getAppState, rootSetAppState);
-    if (false) {}
+    ]);
   }
 }
 function filterIncompleteToolCalls(messages) {
@@ -236238,6 +236376,7 @@ var init_runAgent = __esm(() => {
   init_config5();
   init_permissions2();
   init_killShellTasks();
+  init_LocalAgentTask();
   init_attachments();
   init_errors5();
   init_file();
@@ -238037,6 +238176,21 @@ var init_RemoteAgentTask = __esm(() => {
   };
 });
 
+// src/lib/zodToJsonSchema.ts
+function zodToJsonSchema3(schema) {
+  const hit = cache2.get(schema);
+  if (hit)
+    return hit;
+  const result = toJSONSchema(schema);
+  cache2.set(schema, result);
+  return result;
+}
+var cache2;
+var init_zodToJsonSchema2 = __esm(() => {
+  init_v4();
+  cache2 = new WeakMap;
+});
+
 // src/session/systemPrompt.ts
 function buildEffectiveSystemPrompt({
   mainThreadAgentDefinition,
@@ -238080,6 +238234,67 @@ function getTeleportLauncher() {
 }
 var _launcher = null;
 
+// src/capabilities/worktreeAvailability.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { resolve as resolve15 } from "path";
+function resolveGitWorktreeAvailability(cwd, gitExecutable = "git") {
+  try {
+    const rootResult = spawnSync2(gitExecutable, ["rev-parse", "--show-toplevel"], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      windowsHide: true
+    });
+    if (rootResult.error) {
+      return { available: false, reason: "git_unavailable" };
+    }
+    const gitRoot = rootResult.stdout.trim();
+    if (rootResult.status !== 0 || !gitRoot) {
+      return { available: false, reason: "not_git_repository" };
+    }
+    const headResult = spawnSync2(gitExecutable, ["rev-parse", "--verify", "HEAD^{commit}"], {
+      cwd: gitRoot,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      windowsHide: true
+    });
+    if (headResult.error) {
+      return { available: false, reason: "git_unavailable" };
+    }
+    const headCommit = headResult.stdout.trim();
+    if (headResult.status !== 0 || !headCommit) {
+      return { available: false, reason: "unborn_head" };
+    }
+    return {
+      available: true,
+      gitRoot: resolve15(gitRoot).normalize("NFC"),
+      headCommit
+    };
+  } catch {
+    return { available: false, reason: "git_unavailable" };
+  }
+}
+function isGitWorktreeIsolationAvailable(cwd, gitExecutable = "git", cache3) {
+  const cacheKey = `${resolve15(cwd).normalize("NFC")}\x00${gitExecutable}`;
+  const cached2 = cache3?.get(cacheKey);
+  if (cached2 !== undefined)
+    return cached2;
+  const available = resolveGitWorktreeAvailability(cwd, gitExecutable).available;
+  cache3?.set(cacheKey, available);
+  return available;
+}
+var WorktreeUnavailableError;
+var init_worktreeAvailability = __esm(() => {
+  WorktreeUnavailableError = class WorktreeUnavailableError extends Error {
+    reason;
+    constructor(reason) {
+      super(`Agent worktree is unavailable (${reason})`);
+      this.reason = reason;
+      this.name = "WorktreeUnavailableError";
+    }
+  };
+});
+
 // src/session/agentId.ts
 function formatAgentId(agentName, teamName) {
   return `${agentName}@${teamName}`;
@@ -244727,13 +244942,13 @@ var init_sedValidation = __esm(() => {
 
 // src/capabilities/tools/BashTool/pathValidation.ts
 import { homedir as homedir16 } from "os";
-import { isAbsolute as isAbsolute10, resolve as resolve15 } from "path";
+import { isAbsolute as isAbsolute10, resolve as resolve16 } from "path";
 function checkDangerousRemovalPaths(command, args, cwd) {
   const extractor = PATH_EXTRACTORS[command];
   const paths2 = extractor(args);
   for (const path10 of paths2) {
     const cleanPath = expandTilde(path10.replace(/^['"]|['"]$/g, ""));
-    const absolutePath = isAbsolute10(cleanPath) ? cleanPath : resolve15(cwd, cleanPath);
+    const absolutePath = isAbsolute10(cleanPath) ? cleanPath : resolve16(cwd, cleanPath);
     if (isDangerousRemovalPath(absolutePath)) {
       return {
         behavior: "ask",
@@ -248174,7 +248389,7 @@ function createInProcessCanUseTool(identity4, abortController, onPermissionWaitM
     }
     const setToolUseConfirmQueue = getLeaderToolUseConfirmQueue();
     if (setToolUseConfirmQueue) {
-      return new Promise((resolve16) => {
+      return new Promise((resolve17) => {
         let decisionMade = false;
         const permissionStartMs = Date.now();
         const reportPermissionWait = () => {
@@ -248185,7 +248400,7 @@ function createInProcessCanUseTool(identity4, abortController, onPermissionWaitM
             return;
           decisionMade = true;
           reportPermissionWait();
-          resolve16({ behavior: "ask", message: SUBAGENT_REJECT_MESSAGE });
+          resolve17({ behavior: "ask", message: SUBAGENT_REJECT_MESSAGE });
           setToolUseConfirmQueue((queue3) => queue3.filter((item) => item.toolUseID !== toolUseID));
         };
         abortController.signal.addEventListener("abort", onAbortListener, {
@@ -248210,7 +248425,7 @@ function createInProcessCanUseTool(identity4, abortController, onPermissionWaitM
               decisionMade = true;
               abortController.signal.removeEventListener("abort", onAbortListener);
               reportPermissionWait();
-              resolve16({ behavior: "ask", message: SUBAGENT_REJECT_MESSAGE });
+              resolve17({ behavior: "ask", message: SUBAGENT_REJECT_MESSAGE });
             },
             async onAllow(updatedInput, permissionUpdates, feedback, contentBlocks) {
               if (decisionMade)
@@ -248230,7 +248445,7 @@ function createInProcessCanUseTool(identity4, abortController, onPermissionWaitM
                 }
               }
               const trimmedFeedback = feedback?.trim();
-              resolve16({
+              resolve17({
                 behavior: "allow",
                 updatedInput,
                 userModified: false,
@@ -248245,7 +248460,7 @@ function createInProcessCanUseTool(identity4, abortController, onPermissionWaitM
               abortController.signal.removeEventListener("abort", onAbortListener);
               reportPermissionWait();
               const message = feedback ? `${SUBAGENT_REJECT_MESSAGE_WITH_REASON_PREFIX}${feedback}` : SUBAGENT_REJECT_MESSAGE;
-              resolve16({ behavior: "ask", message, contentBlocks });
+              resolve17({ behavior: "ask", message, contentBlocks });
             },
             async recheckPermission() {
               if (decisionMade)
@@ -248256,7 +248471,7 @@ function createInProcessCanUseTool(identity4, abortController, onPermissionWaitM
                 abortController.signal.removeEventListener("abort", onAbortListener);
                 reportPermissionWait();
                 setToolUseConfirmQueue((queue4) => queue4.filter((item) => item.toolUseID !== toolUseID));
-                resolve16({
+                resolve17({
                   ...freshResult,
                   updatedInput: input,
                   userModified: false
@@ -248267,7 +248482,7 @@ function createInProcessCanUseTool(identity4, abortController, onPermissionWaitM
         ]);
       });
     }
-    return new Promise((resolve16) => {
+    return new Promise((resolve17) => {
       const request = createPermissionRequest({
         toolName: tool.name,
         toolUseId: toolUseID,
@@ -248286,7 +248501,7 @@ function createInProcessCanUseTool(identity4, abortController, onPermissionWaitM
           cleanup();
           persistPermissionUpdates(permissionUpdates);
           const finalInput = updatedInput && Object.keys(updatedInput).length > 0 ? updatedInput : input;
-          resolve16({
+          resolve17({
             behavior: "allow",
             updatedInput: finalInput,
             userModified: false,
@@ -248296,14 +248511,14 @@ function createInProcessCanUseTool(identity4, abortController, onPermissionWaitM
         onReject(feedback, contentBlocks) {
           cleanup();
           const message = feedback ? `${SUBAGENT_REJECT_MESSAGE_WITH_REASON_PREFIX}${feedback}` : SUBAGENT_REJECT_MESSAGE;
-          resolve16({ behavior: "ask", message, contentBlocks });
+          resolve17({ behavior: "ask", message, contentBlocks });
         }
       });
       sendPermissionRequestViaMailbox(request);
-      const pollInterval = setInterval(async (abortController2, cleanup2, resolve17, identity5, request2) => {
+      const pollInterval = setInterval(async (abortController2, cleanup2, resolve18, identity5, request2) => {
         if (abortController2.signal.aborted) {
           cleanup2();
-          resolve17({ behavior: "ask", message: SUBAGENT_REJECT_MESSAGE });
+          resolve18({ behavior: "ask", message: SUBAGENT_REJECT_MESSAGE });
           return;
         }
         const allMessages = await readMailbox(identity5.agentName, identity5.teamName);
@@ -248331,10 +248546,10 @@ function createInProcessCanUseTool(identity4, abortController, onPermissionWaitM
             }
           }
         }
-      }, PERMISSION_POLL_INTERVAL_MS, abortController, cleanup, resolve16, identity4, request);
+      }, PERMISSION_POLL_INTERVAL_MS, abortController, cleanup, resolve17, identity4, request);
       const onAbortListener = () => {
         cleanup();
-        resolve16({ behavior: "ask", message: SUBAGENT_REJECT_MESSAGE });
+        resolve17({ behavior: "ask", message: SUBAGENT_REJECT_MESSAGE });
       };
       abortController.signal.addEventListener("abort", onAbortListener, {
         once: true
@@ -249074,8 +249289,8 @@ function waitForPaneShellReady() {
 }
 function acquirePaneCreationLock() {
   let release;
-  const newLock = new Promise((resolve16) => {
-    release = resolve16;
+  const newLock = new Promise((resolve17) => {
+    release = resolve17;
   });
   const previousLock = paneCreationLock;
   paneCreationLock = newLock;
@@ -249522,8 +249737,8 @@ __export(exports_ITermBackend, {
 });
 function acquirePaneCreationLock2() {
   let release;
-  const newLock = new Promise((resolve16) => {
-    release = resolve16;
+  const newLock = new Promise((resolve17) => {
+    release = resolve17;
   });
   const previousLock = paneCreationLock2;
   paneCreationLock2 = newLock;
@@ -250504,6 +250719,96 @@ var init_spawnMultiAgent = __esm(() => {
   init_loadAgentsDir();
 });
 
+// src/capabilities/tools/AgentTool/agentInvocationDedupe.ts
+import { isDeepStrictEqual } from "node:util";
+function isToolUseBlock(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const block2 = value;
+  return block2.type === "tool_use" && typeof block2.id === "string" && typeof block2.name === "string";
+}
+function isAgentToolUseBlock(block2) {
+  return block2.name === AGENT_TOOL_NAME2 || block2.name === LEGACY_AGENT_TOOL_NAME;
+}
+function findEarlierDuplicateAgentToolUse(assistantMessage, currentToolUseId) {
+  if (!currentToolUseId || !Array.isArray(assistantMessage?.message?.content)) {
+    return;
+  }
+  const earlierAgentToolUses = [];
+  for (const block2 of assistantMessage.message.content) {
+    if (!isToolUseBlock(block2))
+      continue;
+    if (block2.id === currentToolUseId) {
+      if (!isAgentToolUseBlock(block2))
+        return;
+      return earlierAgentToolUses.find((candidate) => isDeepStrictEqual(candidate.input, block2.input))?.id;
+    }
+    if (isAgentToolUseBlock(block2))
+      earlierAgentToolUses.push(block2);
+  }
+  return;
+}
+var init_agentInvocationDedupe = __esm(() => {
+  init_constants4();
+});
+
+// src/capabilities/tools/AgentTool/worktreeIsolation.ts
+function getWorktreeIsolationUnavailableMessage(reason) {
+  switch (reason) {
+    case "not_git_repository":
+      return "Worktree isolation is unavailable: the current directory is not a Git repository and no WorktreeCreate hook is configured. This model continuation has been stopped. Run the Agent task again without `isolation` only if using the current directory is safe; otherwise select a Git repository or configure a WorktreeCreate hook.";
+    case "unborn_head":
+      return "Worktree isolation is unavailable: the Git repository has no resolvable HEAD commit. This model continuation has been stopped. Run the Agent task again without `isolation` only if using the current directory is safe; otherwise create the initial commit.";
+    case "git_unavailable":
+      return "Worktree isolation is unavailable because Git could not be inspected. This model continuation has been stopped. Check that Git is installed and accessible, or run the Agent task again without `isolation` only if using the current directory is safe.";
+    default: {
+      const exhaustive = reason;
+      return exhaustive;
+    }
+  }
+}
+var WORKTREE_ISOLATION_SCHEMA_DESCRIPTION = 'Isolation mode. Set "worktree" only when the user explicitly requests worktree isolation. It requires a Git repository with a resolvable HEAD commit or a configured WorktreeCreate hook; omit it for ordinary tasks, including read-only research.', WORKTREE_ISOLATION_USAGE_GUIDANCE = 'Only set `isolation: "worktree"` when the user explicitly requests worktree isolation. Omit it for ordinary tasks, including read-only research. Worktree isolation requires a Git repository with a resolvable HEAD commit or a configured WorktreeCreate hook.';
+
+// src/capabilities/tools/AgentTool/inputSchema.ts
+function buildAgentInputSchema(options2) {
+  const capabilityAwareSchema = options2.worktreeIsolationAvailable ? fullInputSchema() : inputSchemaWithoutWorktreeIsolation();
+  const schema = options2.includeCwd ? capabilityAwareSchema : capabilityAwareSchema.omit({
+    cwd: true
+  });
+  return options2.includeRunInBackground ? schema : schema.omit({
+    run_in_background: true
+  });
+}
+var baseInputSchema, fullInputSchema, inputSchemaWithoutWorktreeIsolation;
+var init_inputSchema = __esm(() => {
+  init_v4();
+  init_PermissionMode();
+  baseInputSchema = lazySchema(() => exports_external2.object({
+    description: exports_external2.string().describe("A short (3-5 word) description of the task"),
+    prompt: exports_external2.string().describe("The task for the agent to perform"),
+    subagent_type: exports_external2.string().optional().describe("The type of specialized agent to use for this task"),
+    model: exports_external2.enum(["sonnet", "opus", "haiku"]).optional().describe("Optional model override for this agent. Takes precedence over the agent definition's model frontmatter. If omitted, uses the agent definition's model, or inherits from the parent."),
+    run_in_background: exports_external2.boolean().optional().describe("Set to true to run this agent in the background. You will be notified when it completes.")
+  }));
+  fullInputSchema = lazySchema(() => {
+    const multiAgentInputSchema = exports_external2.object({
+      name: exports_external2.string().optional().describe("Name for the spawned agent. Makes it addressable via SendMessage({to: name}) while running."),
+      team_name: exports_external2.string().optional().describe("Team name for spawning. Uses current team context if omitted."),
+      mode: permissionModeSchema().optional().describe('Permission mode for spawned teammate (e.g., "plan" to require plan approval).')
+    });
+    const isolationInputSchema = exports_external2.object({
+      isolation: exports_external2.enum(["worktree"]).optional().describe(WORKTREE_ISOLATION_SCHEMA_DESCRIPTION)
+    });
+    return baseInputSchema().merge(multiAgentInputSchema).extend({
+      cwd: exports_external2.string().optional().describe('Absolute path to run the agent in. Overrides the working directory for all filesystem and shell operations within this agent. Mutually exclusive with isolation: "worktree".')
+    }).merge(isolationInputSchema);
+  });
+  inputSchemaWithoutWorktreeIsolation = lazySchema(() => {
+    const schema = fullInputSchema().omit({ isolation: true });
+    return schema;
+  });
+});
+
 // src/capabilities/tools/AgentTool/forkSubagent.ts
 import { randomUUID as randomUUID7 } from "crypto";
 function isForkSubagentEnabled() {
@@ -250749,7 +251054,11 @@ The ${AGENT_TOOL_NAME2} tool launches specialized agents (subprocesses) that aut
 
 ${agentListSection}
 
-${forkEnabled ? `When using the ${AGENT_TOOL_NAME2} tool, specify a subagent_type to use a specialized agent, or omit it to fork yourself — a fork inherits your full conversation context. Only use subagent_type values that appear in the available agent types; never invent an agent type from an example.` : `When using the ${AGENT_TOOL_NAME2} tool, specify a subagent_type parameter to select which agent type to use. If omitted, the general-purpose agent is used. Only use subagent_type values that appear in the available agent types; never invent an agent type from an example.`}`;
+${forkEnabled ? `When using the ${AGENT_TOOL_NAME2} tool, specify a subagent_type to use a specialized agent, or omit it to fork yourself — a fork inherits your full conversation context. Only use subagent_type values that appear in the available agent types; never invent an agent type from an example.` : `When using the ${AGENT_TOOL_NAME2} tool, specify a subagent_type parameter to select which agent type to use. If omitted, the general-purpose agent is used. Only use subagent_type values that appear in the available agent types; never invent an agent type from an example.`}
+
+Do not launch multiple Agent calls with exactly the same input.
+
+${WORKTREE_ISOLATION_USAGE_GUIDANCE}`;
   if (isCoordinator) {
     return shared2;
   }
@@ -250764,7 +251073,7 @@ When NOT to use the ${AGENT_TOOL_NAME2} tool:
 - Other tasks that are not related to the agent descriptions above
 `;
   const concurrencyNote = !listViaAttachment && getSubscriptionType() !== "pro" ? `
-- Launch multiple agents concurrently whenever possible, to maximize performance; to do that, use a single message with multiple tool uses` : "";
+- Launch multiple agents concurrently for independent, non-overlapping tasks; to do that, use a single message with multiple tool uses` : "";
   return `${shared2}
 ${whenNotToUseSection}
 
@@ -250778,7 +251087,7 @@ Usage notes:
 - Clearly tell the agent whether you expect it to write code or just to do research (search, file reads, web fetches, etc.)${forkEnabled ? "" : ", since it is not aware of the user's intent"}
 - If the agent description mentions that it should be used proactively, then you should try your best to use it without the user having to ask for it first. Use your judgement.
 - If the user specifies that they want you to run agents "in parallel", you MUST send a single message with multiple ${AGENT_TOOL_NAME2} tool use content blocks. Each call must either omit subagent_type or use an exact type from the available agent list.
-- 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.${process.env.USER_TYPE === "ant" ? `
+${process.env.USER_TYPE === "ant" ? `
 - You can set \`isolation: "remote"\` to run the agent in a remote CCR environment. This is always a background task; you'll be notified when it completes. Use for long-running tasks that need a fresh sandbox.` : ""}${isInProcessTeammate() ? `
 - The run_in_background, name, team_name, and mode parameters are not available in this context. Only synchronous subagents are supported.` : isTeammate() ? `
 - The name, team_name, and mode parameters are not available in this context — teammates cannot spawn other teammates. Omit them to spawn a subagent.` : ""}${whenToForkSection}${writingThePromptSection}
@@ -250804,12 +251113,57 @@ function getAutoBackgroundMs() {
   }
   return 0;
 }
+function buildConfiguredAgentInputSchema(worktreeIsolationAvailable) {
+  const options2 = {
+    worktreeIsolationAvailable,
+    includeRunInBackground: !isBackgroundTasksDisabled && !isForkSubagentEnabled()
+  };
+  return buildAgentInputSchema({
+    ...options2,
+    includeCwd: false
+  });
+}
+function getAdvertisedWorktreeAvailabilityCache() {
+  try {
+    const queryContext = getQueryContext();
+    const now = Date.now();
+    let cache3 = advertisedWorktreeAvailabilityByQuery.get(queryContext);
+    if (!cache3 || cache3.expiresAt <= now || cache3.totalToolDuration !== queryContext.cost.totalToolDuration) {
+      cache3 = {
+        expiresAt: now + WORKTREE_AVAILABILITY_CACHE_TTL_MS,
+        totalToolDuration: queryContext.cost.totalToolDuration,
+        values: new Map
+      };
+      advertisedWorktreeAvailabilityByQuery.set(queryContext, cache3);
+    }
+    return cache3.values;
+  } catch {
+    return;
+  }
+}
+function getAdvertisedAgentInputJSONSchema() {
+  const worktreeIsolationAvailable = isAgentWorktreeIsolationAvailable({
+    gitAvailabilityCache: getAdvertisedWorktreeAvailabilityCache()
+  });
+  const schemaVariant = "standard";
+  const includeRunInBackground = !isBackgroundTasksDisabled && !isForkSubagentEnabled();
+  const cacheKey = `${worktreeIsolationAvailable}:${schemaVariant}:${includeRunInBackground}`;
+  const cached2 = advertisedInputJSONSchemaCache.get(cacheKey);
+  if (cached2)
+    return cached2;
+  const schema = {
+    ...zodToJsonSchema3(buildConfiguredAgentInputSchema(worktreeIsolationAvailable)),
+    type: "object"
+  };
+  advertisedInputJSONSchemaCache.set(cacheKey, schema);
+  return schema;
+}
 function resolveTeamName(input, appState) {
   if (!isAgentSwarmsEnabled())
     return;
   return input.team_name || appState.teamContext?.teamName;
 }
-var getBackgroundHintJSX, renderGroupedAgentToolUse, renderToolResultMessage3, renderToolUseErrorMessage, renderToolUseMessage3, renderToolUseProgressMessage2, renderToolUseRejectedMessage, renderToolUseTag, userFacingName, userFacingNameBackgroundColor, proactiveModule = null, PROGRESS_THRESHOLD_MS = 2000, isBackgroundTasksDisabled, baseInputSchema, fullInputSchema, inputSchema6, outputSchema5, AgentTool;
+var getBackgroundHintJSX, renderGroupedAgentToolUse, renderToolResultMessage3, renderToolUseErrorMessage, renderToolUseMessage3, renderToolUseProgressMessage2, renderToolUseRejectedMessage, renderToolUseTag, userFacingName, userFacingNameBackgroundColor, proactiveModule = null, PROGRESS_THRESHOLD_MS = 2000, isBackgroundTasksDisabled, inputSchema6 = () => buildConfiguredAgentInputSchema(true), outputSchema5, advertisedInputJSONSchemaCache, WORKTREE_AVAILABILITY_CACHE_TTL_MS = 30000, advertisedWorktreeAvailabilityByQuery, agentToolRuntime, AgentTool;
 var init_AgentTool = __esm(() => {
   init_toolRuntime();
   init_promptCategory();
@@ -250828,9 +251182,9 @@ var init_AgentTool = __esm(() => {
   init_debug();
   init_envUtils();
   init_errors5();
+  init_zodToJsonSchema2();
   init_messages4();
   init_agent();
-  init_PermissionMode();
   init_permissions2();
   init_sdkEventQueue();
   init_sessionStorage();
@@ -250841,11 +251195,14 @@ var init_AgentTool = __esm(() => {
   init_tokens();
   init_uuid();
   init_worktree();
+  init_worktreeAvailability();
   init_toolUIRegistry();
   init_prompt2();
   init_spawnMultiAgent();
   init_agentColorManager();
+  init_agentInvocationDedupe();
   init_agentToolUtils();
+  init_inputSchema();
   init_generalPurposeAgent();
   init_constants4();
   init_forkSubagent();
@@ -250866,32 +251223,6 @@ var init_AgentTool = __esm(() => {
     userFacingNameBackgroundColor
   } = lazyUI("Agent"));
   isBackgroundTasksDisabled = isEnvTruthy(resolveEnvVar("DISABLE_BACKGROUND_TASKS"));
-  baseInputSchema = lazySchema(() => exports_external2.object({
-    description: exports_external2.string().describe("A short (3-5 word) description of the task"),
-    prompt: exports_external2.string().describe("The task for the agent to perform"),
-    subagent_type: exports_external2.string().optional().describe("The type of specialized agent to use for this task"),
-    model: exports_external2.enum(["sonnet", "opus", "haiku"]).optional().describe("Optional model override for this agent. Takes precedence over the agent definition's model frontmatter. If omitted, uses the agent definition's model, or inherits from the parent."),
-    run_in_background: exports_external2.boolean().optional().describe("Set to true to run this agent in the background. You will be notified when it completes.")
-  }));
-  fullInputSchema = lazySchema(() => {
-    const multiAgentInputSchema = exports_external2.object({
-      name: exports_external2.string().optional().describe("Name for the spawned agent. Makes it addressable via SendMessage({to: name}) while running."),
-      team_name: exports_external2.string().optional().describe("Team name for spawning. Uses current team context if omitted."),
-      mode: permissionModeSchema().optional().describe('Permission mode for spawned teammate (e.g., "plan" to require plan approval).')
-    });
-    return baseInputSchema().merge(multiAgentInputSchema).extend({
-      isolation: exports_external2.enum(["worktree"]).optional().describe('Isolation mode. "worktree" creates a temporary git worktree so the agent works on an isolated copy of the repo.'),
-      cwd: exports_external2.string().optional().describe('Absolute path to run the agent in. Overrides the working directory for all filesystem and shell operations within this agent. Mutually exclusive with isolation: "worktree".')
-    });
-  });
-  inputSchema6 = lazySchema(() => {
-    const schema = fullInputSchema().omit({
-      cwd: true
-    });
-    return isBackgroundTasksDisabled || isForkSubagentEnabled() ? schema.omit({
-      run_in_background: true
-    }) : schema;
-  });
   outputSchema5 = lazySchema(() => {
     const syncOutputSchema = agentToolResultSchema().extend({
       status: exports_external2.literal("completed"),
@@ -250907,7 +251238,9 @@ var init_AgentTool = __esm(() => {
     });
     return exports_external2.union([syncOutputSchema, asyncOutputSchema]);
   });
-  AgentTool = buildToolRuntime({
+  advertisedInputJSONSchemaCache = new Map;
+  advertisedWorktreeAvailabilityByQuery = new WeakMap;
+  agentToolRuntime = buildToolRuntime({
     async prompt({
       agents,
       tools,
@@ -250937,9 +251270,7 @@ var init_AgentTool = __esm(() => {
     async description() {
       return "Launch a new agent";
     },
-    get inputSchema() {
-      return inputSchema6();
-    },
+    inputSchema: inputSchema6(),
     get outputSchema() {
       return outputSchema5();
     },
@@ -250955,6 +251286,10 @@ var init_AgentTool = __esm(() => {
       isolation,
       cwd
     }, toolUseContext, canUseTool, assistantMessage, onProgress) {
+      const earlierDuplicateId = findEarlierDuplicateAgentToolUse(assistantMessage, toolUseContext.toolUseId);
+      if (earlierDuplicateId) {
+        throw new Error(`Duplicate Agent call skipped: this input duplicates earlier call ${earlierDuplicateId}. Do not retry it; wait for the earlier Agent result.`);
+      }
       const startTime = Date.now();
       const model = isCoordinatorMode() ? undefined : modelParam;
       const appState = toolUseContext.getAppState();
@@ -251191,15 +251526,16 @@ ${reasons}`);
         try {
           worktreeInfo = await createAgentWorktree(slug);
         } catch (error41) {
-          const message = error41 instanceof Error ? error41.message : String(error41);
-          if (message.includes("Cannot create agent worktree: not in a git repository")) {
-            if (isolation === "worktree") {
-              throw error41;
-            }
-            logForDebugging("Agent worktree isolation unavailable outside a git repository; falling back to the current working directory.");
-          } else {
+          if (!(error41 instanceof WorktreeUnavailableError)) {
             throw error41;
           }
+          const unavailableMessage = getWorktreeIsolationUnavailableMessage(error41.reason);
+          if (isolation === "worktree") {
+            throw new ToolContinuationStopError(unavailableMessage, {
+              cause: error41
+            });
+          }
+          logForDebugging(`${unavailableMessage} Falling back to the current working directory.`);
         }
       }
       if (isForkPath && worktreeInfo) {
@@ -251792,6 +252128,15 @@ duration_ms: ${data.totalDurationMs}</usage>`
     renderToolUseErrorMessage,
     renderGroupedToolUse: renderGroupedAgentToolUse
   });
+  AgentTool = {
+    ...agentToolRuntime,
+    get inputSchema() {
+      return inputSchema6();
+    },
+    get inputJSONSchema() {
+      return getAdvertisedAgentInputJSONSchema();
+    }
+  };
 });
 
 // node_modules/.bun/lodash-es@4.18.0/node_modules/lodash-es/_baseSlice.js
@@ -251938,7 +252283,7 @@ var init_idePathConversion = () => {};
 
 // src/capabilities/ide.ts
 import { createConnection } from "net";
-import { basename as basename11, join as join49, sep as pathSeparator, resolve as resolve16 } from "path";
+import { basename as basename11, join as join49, sep as pathSeparator, resolve as resolve17 } from "path";
 function isVSCodeIde(ide) {
   if (!ide)
     return false;
@@ -251953,7 +252298,7 @@ function isJetBrainsIde(ide) {
 }
 async function checkIdeConnection(host, port, timeout = 500) {
   try {
-    return new Promise((resolve17) => {
+    return new Promise((resolve18) => {
       const socket = createConnection({
         host,
         port,
@@ -251961,14 +252306,14 @@ async function checkIdeConnection(host, port, timeout = 500) {
       });
       socket.on("connect", () => {
         socket.destroy();
-        resolve17(true);
+        resolve18(true);
       });
       socket.on("error", () => {
-        resolve17(false);
+        resolve18(false);
       });
       socket.on("timeout", () => {
         socket.destroy();
-        resolve17(false);
+        resolve18(false);
       });
     });
   } catch (_) {
@@ -255654,7 +255999,7 @@ async function getSnapshotScript(shellPath, snapshotFilePath, configFileExists)
 var LITERAL_BACKSLASH = "\\", SNAPSHOT_CREATION_TIMEOUT = 1e4, VCS_DIRECTORIES_TO_EXCLUDE2, createAndSaveSnapshot = async (binShell) => {
   const shellType = binShell.includes("zsh") ? "zsh" : binShell.includes("bash") ? "bash" : "sh";
   logForDebugging(`Creating shell snapshot for ${shellType} (${binShell})`);
-  return new Promise(async (resolve17) => {
+  return new Promise(async (resolve18) => {
     try {
       const configFile = getConfigFile(binShell);
       logForDebugging(`Looking for shell config file: ${configFile}`);
@@ -255715,7 +256060,7 @@ ${stdout}`);
             error_signal_number: signalNumber,
             error_killed: execError?.killed
           });
-          resolve17(undefined);
+          resolve18(undefined);
         } else {
           let snapshotSize;
           try {
@@ -255731,7 +256076,7 @@ ${stdout}`);
                 logForDebugging(`Error cleaning up session snapshot: ${error42}`);
               }
             });
-            resolve17(shellSnapshotPath);
+            resolve18(shellSnapshotPath);
           } else {
             logForDebugging(`Shell snapshot file not found after creation: ${shellSnapshotPath}`);
             logForDebugging(`Checking if parent directory still exists: ${snapshotsDir}`);
@@ -255742,7 +256087,7 @@ ${stdout}`);
               logForDebugging(`Parent directory does not exist or is not accessible: ${snapshotsDir}`);
             }
             logEvent("tengu_shell_unknown_error", {});
-            resolve17(undefined);
+            resolve18(undefined);
           }
         }
       });
@@ -255753,7 +256098,7 @@ ${stdout}`);
       }
       logError(error41);
       logEvent("tengu_shell_snapshot_error", {});
-      resolve17(undefined);
+      resolve18(undefined);
     }
   });
 };
@@ -256158,7 +256503,7 @@ var init_bashProvider = __esm(() => {
 import { spawn as spawn5 } from "child_process";
 import { constants as fsConstants4, readFileSync as readFileSync6, unlinkSync as unlinkSync2 } from "fs";
 import { mkdir as mkdir4, open as open4, realpath as realpath4 } from "fs/promises";
-import { isAbsolute as isAbsolute16, resolve as resolve17 } from "path";
+import { isAbsolute as isAbsolute16, resolve as resolve18 } from "path";
 import { join as posixJoin3 } from "path/posix";
 async function findSuitableShell() {
   return (await requireShellCapability("bash")).path;
@@ -256299,7 +256644,7 @@ async function exec2(command, abortSignal, shellType, options2) {
   }
 }
 function setCwd(path10, relativeTo) {
-  const resolved = isAbsolute16(path10) ? path10 : resolve17(relativeTo || getFsImplementation().cwd(), path10);
+  const resolved = isAbsolute16(path10) ? path10 : resolve18(relativeTo || getFsImplementation().cwd(), path10);
   let physicalPath;
   try {
     physicalPath = getFsImplementation().realpathSync(resolved);
@@ -256652,7 +256997,7 @@ var init_notebook = __esm(() => {
 var DESCRIPTION6 = "Replace the contents of a specific cell in a Jupyter notebook.", PROMPT4 = `Completely replaces the contents of a specific cell in a Jupyter notebook (.ipynb file) with new source. Jupyter notebooks are interactive documents that combine code, text, and visualizations, commonly used for data analysis and scientific computing. The notebook_path parameter must be an absolute path, not a relative path. The cell_number is 0-indexed. Use edit_mode=insert to add a new cell at the index specified by cell_number. Use edit_mode=delete to delete the cell at the index specified by cell_number.`;
 
 // src/capabilities/tools/NotebookEditTool/NotebookEditTool.ts
-import { extname as extname5, isAbsolute as isAbsolute17, resolve as resolve18 } from "path";
+import { extname as extname5, isAbsolute as isAbsolute17, resolve as resolve19 } from "path";
 var getToolUseSummary5, renderToolResultMessage8, renderToolUseErrorMessage6, renderToolUseMessage8, renderToolUseRejectedMessage4, inputSchema11, outputSchema10, NotebookEditTool;
 var init_NotebookEditTool = __esm(() => {
   init_fileHistory();
@@ -256767,7 +257112,7 @@ var init_NotebookEditTool = __esm(() => {
     renderToolUseErrorMessage: renderToolUseErrorMessage6,
     renderToolResultMessage: renderToolResultMessage8,
     async validateInput({ notebook_path, cell_type, cell_id, edit_mode = "replace" }, toolUseContext) {
-      const fullPath = isAbsolute17(notebook_path) ? notebook_path : resolve18(getCwd3(), notebook_path);
+      const fullPath = isAbsolute17(notebook_path) ? notebook_path : resolve19(getCwd3(), notebook_path);
       if (fullPath.startsWith("\\\\") || fullPath.startsWith("//")) {
         return { result: true };
       }
@@ -256866,7 +257211,7 @@ var init_NotebookEditTool = __esm(() => {
       cell_type,
       edit_mode: originalEditMode
     }, { readFileState, updateFileHistoryState }, _, parentMessage) {
-      const fullPath = isAbsolute17(notebook_path) ? notebook_path : resolve18(getCwd3(), notebook_path);
+      const fullPath = isAbsolute17(notebook_path) ? notebook_path : resolve19(getCwd3(), notebook_path);
       if (fileHistoryEnabled()) {
         await fileHistoryTrackEdit(updateFileHistoryState, fullPath, parentMessage.uuid);
       }
@@ -257126,7 +257471,7 @@ var init_gitOperationTracking = __esm(() => {
 });
 
 // src/session/fullscreen.ts
-import { spawnSync as spawnSync2 } from "child_process";
+import { spawnSync as spawnSync3 } from "child_process";
 function isTmuxControlModeEnvHeuristic() {
   if (!process.env.TMUX)
     return false;
@@ -257145,7 +257490,7 @@ function probeTmuxControlModeSync() {
     return;
   let result;
   try {
-    result = spawnSync2("tmux", ["display-message", "-p", "#{client_control_mode}"], { encoding: "utf8", timeout: 2000 });
+    result = spawnSync3("tmux", ["display-message", "-p", "#{client_control_mode}"], { encoding: "utf8", timeout: 2000 });
   } catch {
     return;
   }
@@ -257638,8 +257983,8 @@ function registerAgentForeground({
     diskLoaded: false
   };
   let resolveBackgroundSignal;
-  const backgroundSignal = new Promise((resolve19) => {
-    resolveBackgroundSignal = resolve19;
+  const backgroundSignal = new Promise((resolve20) => {
+    resolveBackgroundSignal = resolve20;
   });
   backgroundSignalResolvers.set(agentId, resolveBackgroundSignal);
   registerTask(taskState, setAppState);
@@ -257722,6 +258067,75 @@ var init_LocalAgentTask = __esm(() => {
   backgroundSignalResolvers = new Map;
 });
 
+// src/session/backgroundTaskScope.ts
+class BackgroundTaskScope {
+  tasks = new Set;
+  stopPromise;
+  stopped = false;
+  register(task) {
+    let registered = true;
+    const unregister = () => {
+      if (!registered)
+        return;
+      registered = false;
+      this.tasks.delete(task);
+    };
+    this.tasks.add(task);
+    task.settled.then(unregister, unregister);
+    if (this.stopped) {
+      this.stopTask(task).finally(unregister).catch(() => {});
+    }
+    return unregister;
+  }
+  stop() {
+    if (!this.stopPromise) {
+      this.stopPromise = this.drain().finally(() => {
+        this.stopped = true;
+      });
+    }
+    return this.stopPromise;
+  }
+  async drain() {
+    const failures = [];
+    while (this.tasks.size > 0) {
+      const tasks = [...this.tasks];
+      const results = await Promise.allSettled(tasks.map((task) => this.stopTask(task)));
+      for (const result of results) {
+        if (result.status === "rejected")
+          failures.push(result.reason);
+      }
+      for (const task of tasks) {
+        this.tasks.delete(task);
+      }
+    }
+    if (failures.length > 0) {
+      throw new AggregateError(failures, "BackgroundTaskScope cleanup failed");
+    }
+  }
+  async stopTask(task) {
+    try {
+      await task.stop();
+    } finally {
+      await task.settled;
+    }
+  }
+}
+function bindBackgroundTaskScope(setAppState, scope) {
+  scopesBySetAppState.set(setAppState, scope);
+  return () => {
+    if (scopesBySetAppState.get(setAppState) === scope) {
+      scopesBySetAppState.delete(setAppState);
+    }
+  };
+}
+function getBackgroundTaskScope(setAppState) {
+  return scopesBySetAppState.get(setAppState);
+}
+var scopesBySetAppState;
+var init_backgroundTaskScope = __esm(() => {
+  scopesBySetAppState = new WeakMap;
+});
+
 // src/tasks/LocalShellTask/LocalShellTask.ts
 function looksLikePrompt(tail) {
   const lastLine = tail.trimEnd().split(`
@@ -257850,26 +258264,9 @@ async function spawnShellTask(input, context3) {
     taskOutput
   } = shellCommand;
   const taskId = taskOutput.taskId;
-  const unregisterCleanup = registerCleanup(async () => {
-    killTask(taskId, setAppState);
-  });
-  const taskState = {
-    ...createTaskStateBase(taskId, "local_bash", description, toolUseId),
-    type: "local_bash",
-    status: "running",
-    command,
-    completionStatusSentInAttachment: false,
-    shellCommand,
-    unregisterCleanup,
-    lastReportedTotalLines: 0,
-    isBackgrounded: true,
-    agentId,
-    kind
-  };
-  registerTask(taskState, setAppState);
-  shellCommand.background(taskId);
-  const cancelStallWatchdog = startStallWatchdog(taskId, description, kind, toolUseId, agentId);
-  shellCommand.result.then(async (result) => {
+  let unregisterCleanup = () => {};
+  let cancelStallWatchdog = () => {};
+  const settled = shellCommand.result.then(async (result) => {
     cancelStallWatchdog();
     await flushAndCleanup(shellCommand);
     let wasKilled = false;
@@ -257892,12 +258289,43 @@ async function spawnShellTask(input, context3) {
     });
     enqueueShellNotification(taskId, description, wasKilled ? "killed" : result.code === 0 ? "completed" : "failed", result.code, setAppState, toolUseId, kind, agentId);
     evictTaskOutput(taskId);
+  }).catch((error41) => {
+    cancelStallWatchdog();
+    logError(error41);
+  }).finally(() => {
+    unregisterCleanup();
   });
+  const stopAndSettle = async () => {
+    killTask(taskId, setAppState);
+    await settled;
+  };
+  const cleanupRegistration = () => {
+    unregisterCleanup();
+  };
+  const taskState = {
+    ...createTaskStateBase(taskId, "local_bash", description, toolUseId),
+    type: "local_bash",
+    status: "running",
+    command,
+    completionStatusSentInAttachment: false,
+    shellCommand,
+    unregisterCleanup: cleanupRegistration,
+    lastReportedTotalLines: 0,
+    isBackgrounded: true,
+    agentId,
+    kind
+  };
+  registerTask(taskState, setAppState);
+  const owner = getBackgroundTaskScope(setAppState);
+  unregisterCleanup = owner ? owner.register({
+    stop: stopAndSettle,
+    settled
+  }) : registerCleanup(stopAndSettle);
+  shellCommand.background(taskId);
+  cancelStallWatchdog = startStallWatchdog(taskId, description, kind, toolUseId, agentId);
   return {
     taskId,
-    cleanup: () => {
-      unregisterCleanup();
-    }
+    cleanup: cleanupRegistration
   };
 }
 function registerForeground(input, setAppState, toolUseId) {
@@ -258026,6 +258454,7 @@ var init_LocalShellTask = __esm(() => {
   init_LocalAgentTask();
   init_killShellTasks();
   init_fsOperations();
+  init_backgroundTaskScope();
   PROMPT_PATTERNS = [
     /\(y\/n\)/i,
     /\[y\/n\]/i,
@@ -258984,8 +259413,8 @@ async function* runShellCommand({
   let assistantAutoBackgrounded = false;
   let resolveProgress = null;
   function createProgressSignal() {
-    return new Promise((resolve19) => {
-      resolveProgress = () => resolve19(null);
+    return new Promise((resolve20) => {
+      resolveProgress = () => resolve20(null);
     });
   }
   const shouldAutoBackground = !isBackgroundTasksDisabled2 && isAutobackgroundingAllowed(command);
@@ -258996,10 +259425,10 @@ async function* runShellCommand({
       fullOutput = allLines;
       lastTotalLines = totalLines;
       lastTotalBytes = isIncomplete ? totalBytes : 0;
-      const resolve19 = resolveProgress;
-      if (resolve19) {
+      const resolve20 = resolveProgress;
+      if (resolve20) {
         resolveProgress = null;
-        resolve19();
+        resolve20();
       }
     },
     preventCwdChanges,
@@ -259037,10 +259466,10 @@ async function* runShellCommand({
     }
     spawnBackgroundTask().then((shellId) => {
       backgroundShellId = shellId;
-      const resolve19 = resolveProgress;
-      if (resolve19) {
+      const resolve20 = resolveProgress;
+      if (resolve20) {
         resolveProgress = null;
-        resolve19();
+        resolve20();
       }
       logEvent(eventName, {
         command_type: getCommandTypeForLogging(command)
@@ -259072,8 +259501,8 @@ async function* runShellCommand({
   const startTime = Date.now();
   let foregroundTaskId = undefined;
   {
-    const initialResult = await Promise.race([resultPromise, new Promise((resolve19) => {
-      const t = setTimeout((r) => r(null), PROGRESS_THRESHOLD_MS2, resolve19);
+    const initialResult = await Promise.race([resultPromise, new Promise((resolve20) => {
+      const t = setTimeout((r) => r(null), PROGRESS_THRESHOLD_MS2, resolve20);
       t.unref();
     })]);
     if (initialResult !== null) {
@@ -260596,7 +261025,7 @@ var init_parser5 = __esm(() => {
 });
 
 // src/capabilities/tools/PowerShellTool/gitSafety.ts
-import { basename as basename13, posix as posix5, resolve as resolve19, sep as sep17 } from "path";
+import { basename as basename13, posix as posix5, resolve as resolve20, sep as sep17 } from "path";
 function resolveCwdReentry(normalized) {
   if (!normalized.startsWith("../../../tools"))
     return normalized;
@@ -260644,7 +261073,7 @@ function normalizeGitPathArg(arg) {
 }
 function resolveEscapingPathToCwdRelative(n2) {
   const cwd = getCwd3();
-  const abs = resolve19(cwd, n2);
+  const abs = resolve20(cwd, n2);
   const cwdWithSep = cwd.endsWith(sep17) ? cwd : cwd + sep17;
   const absLower = abs.toLowerCase();
   const cwdLower = cwd.toLowerCase();
@@ -261917,7 +262346,7 @@ var init_modeValidation2 = __esm(() => {
 
 // src/capabilities/tools/PowerShellTool/pathValidation.ts
 import { homedir as homedir18 } from "os";
-import { isAbsolute as isAbsolute18, resolve as resolve20 } from "path";
+import { isAbsolute as isAbsolute18, resolve as resolve21 } from "path";
 function matchesParam(paramLower, paramList) {
   for (const p of paramList) {
     if (p === paramLower || paramLower.length > 1 && p.startsWith(paramLower)) {
@@ -262025,7 +262454,7 @@ function checkDenyRuleForGuessedPath(strippedPath, cwd, toolPermissionContext, o
   if (!strippedPath || strippedPath.includes("\x00"))
     return null;
   const tildeExpanded = expandTilde2(strippedPath);
-  const abs = isAbsolute18(tildeExpanded) ? tildeExpanded : resolve20(cwd, tildeExpanded);
+  const abs = isAbsolute18(tildeExpanded) ? tildeExpanded : resolve21(cwd, tildeExpanded);
   const { resolvedPath } = safeResolvePath(getFsImplementation(), abs);
   const permissionType = operationType === "read" ? "read" : "edit";
   const denyRule = matchingRuleForInput(resolvedPath, toolPermissionContext, permissionType, "deny");
@@ -262115,7 +262544,7 @@ function validatePath2(filePath, cwd, toolPermissionContext, operationType) {
       };
     }
     if (containsPathTraversal(normalizedPath)) {
-      const absolutePath2 = isAbsolute18(normalizedPath) ? normalizedPath : resolve20(cwd, normalizedPath);
+      const absolutePath2 = isAbsolute18(normalizedPath) ? normalizedPath : resolve21(cwd, normalizedPath);
       const { resolvedPath: resolvedPath3, isCanonical: isCanonical2 } = safeResolvePath(getFsImplementation(), absolutePath2);
       const result2 = isPathAllowed2(resolvedPath3, toolPermissionContext, operationType, isCanonical2 ? [resolvedPath3] : undefined);
       return {
@@ -262125,7 +262554,7 @@ function validatePath2(filePath, cwd, toolPermissionContext, operationType) {
       };
     }
     const basePath = getGlobBaseDirectory2(normalizedPath);
-    const absoluteBasePath = isAbsolute18(basePath) ? basePath : resolve20(cwd, basePath);
+    const absoluteBasePath = isAbsolute18(basePath) ? basePath : resolve21(cwd, basePath);
     const { resolvedPath: resolvedPath2 } = safeResolvePath(getFsImplementation(), absoluteBasePath);
     const permissionType = operationType === "read" ? "read" : "edit";
     const denyRule = matchingRuleForInput(resolvedPath2, toolPermissionContext, permissionType, "deny");
@@ -262145,7 +262574,7 @@ function validatePath2(filePath, cwd, toolPermissionContext, operationType) {
       }
     };
   }
-  const absolutePath = isAbsolute18(normalizedPath) ? normalizedPath : resolve20(cwd, normalizedPath);
+  const absolutePath = isAbsolute18(normalizedPath) ? normalizedPath : resolve21(cwd, normalizedPath);
   const { resolvedPath, isCanonical } = safeResolvePath(getFsImplementation(), absolutePath);
   const result = isPathAllowed2(resolvedPath, toolPermissionContext, operationType, isCanonical ? [resolvedPath] : undefined);
   return {
@@ -264075,7 +264504,7 @@ var init_powershellSecurity = __esm(() => {
 var POWERSHELL_TOOL_NAME3 = "PowerShell";
 
 // src/capabilities/tools/PowerShellTool/powershellPermissions.ts
-import { resolve as resolve21 } from "path";
+import { resolve as resolve22 } from "path";
 async function extractCommandName(command) {
   const trimmed = command.trim();
   if (!trimmed) {
@@ -264688,7 +265117,7 @@ async function powershellToolHasPermission(input, context3) {
     const canonical = resolveToCanonical(element.name);
     if (canonical === "set-location" && element.args.length > 0) {
       const target = element.args.find((a2) => a2.length === 0 || !PS_TOKENIZER_DASH_CHARS.has(a2[0]));
-      if (target && resolve21(getCwd3(), target) === getCwd3()) {
+      if (target && resolve22(getCwd3(), target) === getCwd3()) {
         return false;
       }
     }
@@ -265084,8 +265513,8 @@ async function* runPowerShellCommand({
   let assistantAutoBackgrounded = false;
   let resolveProgress = null;
   function createProgressSignal() {
-    return new Promise((resolve22) => {
-      resolveProgress = () => resolve22(null);
+    return new Promise((resolve23) => {
+      resolveProgress = () => resolve23(null);
     });
   }
   const shouldAutoBackground = !isBackgroundTasksDisabled3 && isAutobackgroundingAllowed2(command);
@@ -265155,10 +265584,10 @@ async function* runPowerShellCommand({
     }
     spawnBackgroundTask().then((shellId) => {
       backgroundShellId = shellId;
-      const resolve22 = resolveProgress;
-      if (resolve22) {
+      const resolve23 = resolveProgress;
+      if (resolve23) {
         resolveProgress = null;
-        resolve22();
+        resolve23();
       }
       logEvent(eventName, {
         command_type: getCommandTypeForLogging2(command)
@@ -265196,7 +265625,7 @@ async function* runPowerShellCommand({
       const now = Date.now();
       const timeUntilNextProgress = Math.max(0, nextProgressTime - now);
       const progressSignal = createProgressSignal();
-      const result = await Promise.race([resultPromise, new Promise((resolve22) => setTimeout((r) => r(null), timeUntilNextProgress, resolve22).unref()), progressSignal]);
+      const result = await Promise.race([resultPromise, new Promise((resolve23) => setTimeout((r) => r(null), timeUntilNextProgress, resolve23).unref()), progressSignal]);
       if (result !== null) {
         if (result.backgroundTaskId !== undefined) {
           markTaskNotified2(result.backgroundTaskId, setAppState);
@@ -267794,7 +268223,7 @@ var init_officialMarketplaceGcs = __esm(() => {
 });
 
 // src/capabilities/plugins/marketplaceManager.ts
-import { basename as basename18, dirname as dirname31, isAbsolute as isAbsolute20, join as join59, resolve as resolve22, sep as sep18 } from "path";
+import { basename as basename18, dirname as dirname31, isAbsolute as isAbsolute20, join as join59, resolve as resolve23, sep as sep18 } from "path";
 function getKnownMarketplacesFile() {
   return join59(getPluginsDirectory(), "known_marketplaces.json");
 }
@@ -268360,14 +268789,14 @@ async function loadAndCacheMarketplace(source, onProgress) {
         throw new Error("NPM marketplace sources not yet implemented");
       }
       case "file": {
-        const absPath = resolve22(source.path);
+        const absPath = resolve23(source.path);
         marketplacePath = absPath;
         temporaryCachePath = dirname31(dirname31(absPath));
         cleanupNeeded = false;
         break;
       }
       case "directory": {
-        const absPath = resolve22(source.path);
+        const absPath = resolve23(source.path);
         marketplacePath = join59(absPath, ".claude-plugin", "marketplace.json");
         temporaryCachePath = absPath;
         cleanupNeeded = false;
@@ -268399,8 +268828,8 @@ async function loadAndCacheMarketplace(source, onProgress) {
       throw new Error(`Failed to parse marketplace file at ${marketplacePath}: ${errorMessage(e)}`);
     }
     const finalCachePath = join59(cacheDir, marketplace.name);
-    const resolvedFinal = resolve22(finalCachePath);
-    const resolvedCacheDir = resolve22(cacheDir);
+    const resolvedFinal = resolve23(finalCachePath);
+    const resolvedCacheDir = resolve23(cacheDir);
     if (!resolvedFinal.startsWith(resolvedCacheDir + sep18)) {
       throw new Error(`Marketplace name '${marketplace.name}' resolves to a path outside the cache directory`);
     }
@@ -268761,11 +269190,11 @@ var init_pluginVersioning = __esm(() => {
 });
 
 // src/capabilities/plugins/pluginInstallationHelpers.ts
-import { dirname as dirname33, join as join61, resolve as resolve23, sep as sep19 } from "path";
+import { dirname as dirname33, join as join61, resolve as resolve24, sep as sep19 } from "path";
 function validatePathWithinBase(basePath, relativePath2) {
-  const resolvedPath = resolve23(basePath, relativePath2);
-  const normalizedBase = resolve23(basePath) + sep19;
-  if (!resolvedPath.startsWith(normalizedBase) && resolvedPath !== resolve23(basePath)) {
+  const resolvedPath = resolve24(basePath, relativePath2);
+  const normalizedBase = resolve24(basePath) + sep19;
+  if (!resolvedPath.startsWith(normalizedBase) && resolvedPath !== resolve24(basePath)) {
     throw new Error(`Path traversal detected: "${relativePath2}" would escape the base directory`);
   }
   return resolvedPath;
@@ -268791,7 +269220,7 @@ var init_pluginInstallationHelpers = __esm(() => {
 });
 
 // src/capabilities/plugins/pluginLoader.ts
-import { basename as basename19, dirname as dirname34, join as join62, relative as relative11, resolve as resolve24, sep as sep20 } from "path";
+import { basename as basename19, dirname as dirname34, join as join62, relative as relative11, resolve as resolve25, sep as sep20 } from "path";
 function getPluginCachePath() {
   return join62(getPluginsDirectory(), "cache");
 }
@@ -270145,7 +270574,7 @@ async function loadSessionOnlyPlugins(sessionPluginPaths) {
   const errors4 = [];
   for (const [index, pluginPath] of sessionPluginPaths.entries()) {
     try {
-      const resolvedPath = resolve24(pluginPath);
+      const resolvedPath = resolve25(pluginPath);
       if (!await pathExists(resolvedPath)) {
         logForDebugging(`Plugin path does not exist: ${resolvedPath}, skipping`, { level: "warn" });
         errors4.push({
@@ -271512,14 +271941,14 @@ function waitForCallback(port, expectedState, abortSignal, onListening) {
       abortHandler = null;
     }
   };
-  return new Promise((resolve25, reject2) => {
+  return new Promise((resolve26, reject2) => {
     let resolved = false;
     const resolveOnce = (v) => {
       if (resolved)
         return;
       resolved = true;
       cleanup();
-      resolve25(v);
+      resolve26(v);
     };
     const rejectOnce = (e) => {
       if (resolved)
@@ -271990,13 +272419,13 @@ async function performMCPOAuthFlow(serverName, serverConfig, onAuthorizationUrl,
       }
       logMCPDebug(serverName, `MCP OAuth server cleaned up`);
     };
-    const authorizationCode = await new Promise((resolve25, reject2) => {
+    const authorizationCode = await new Promise((resolve26, reject2) => {
       let resolved = false;
       const resolveOnce = (code) => {
         if (resolved)
           return;
         resolved = true;
-        resolve25(code);
+        resolve26(code);
       };
       const rejectOnce = (error41) => {
         if (resolved)
@@ -272916,8 +273345,8 @@ function createMcpAuthTool(serverName, config2) {
       }
       const sseOrHttpConfig = config2;
       let resolveAuthUrl;
-      const authUrlPromise = new Promise((resolve25) => {
-        resolveAuthUrl = resolve25;
+      const authUrlPromise = new Promise((resolve26) => {
+        resolveAuthUrl = resolve26;
       });
       const controller = new AbortController;
       const { setAppState } = context3;
@@ -273399,15 +273828,15 @@ class WebSocketTransport {
   isBun = typeof Bun !== "undefined";
   constructor(ws) {
     this.ws = ws;
-    this.opened = new Promise((resolve25, reject2) => {
+    this.opened = new Promise((resolve26, reject2) => {
       if (this.ws.readyState === WS_OPEN) {
-        resolve25();
+        resolve26();
       } else if (this.isBun) {
         const nws = this.ws;
         const onOpen = () => {
           nws.removeEventListener("open", onOpen);
           nws.removeEventListener("error", onError);
-          resolve25();
+          resolve26();
         };
         const onError = (event) => {
           nws.removeEventListener("open", onOpen);
@@ -273420,7 +273849,7 @@ class WebSocketTransport {
       } else {
         const nws = this.ws;
         nws.on("open", () => {
-          resolve25();
+          resolve26();
         });
         nws.on("error", (error41) => {
           logForDiagnosticsNoPII("error", "mcp_websocket_connect_fail");
@@ -273519,12 +273948,12 @@ class WebSocketTransport {
       if (this.isBun) {
         this.ws.send(json2);
       } else {
-        await new Promise((resolve25, reject2) => {
+        await new Promise((resolve26, reject2) => {
           this.ws.send(json2, (error41) => {
             if (error41) {
               reject2(error41);
             } else {
-              resolve25();
+              resolve26();
             }
           });
         });
@@ -277439,12 +277868,12 @@ class StdioServerTransport {
     this.onclose?.();
   }
   send(message) {
-    return new Promise((resolve25) => {
+    return new Promise((resolve26) => {
       const json2 = serializeMessage(message);
       if (this._stdout.write(json2)) {
-        resolve25();
+        resolve26();
       } else {
-        this._stdout.once("drain", resolve25);
+        this._stdout.once("drain", resolve26);
       }
     });
   }
@@ -277769,8 +278198,8 @@ function getMcpAuthCache() {
   return authCachePromise;
 }
 async function isMcpAuthCached(serverId) {
-  const cache2 = await getMcpAuthCache();
-  const entry = cache2[serverId];
+  const cache3 = await getMcpAuthCache();
+  const entry = cache3[serverId];
   if (!entry) {
     return false;
   }
@@ -277778,11 +278207,11 @@ async function isMcpAuthCached(serverId) {
 }
 function setMcpAuthCacheEntry(serverId) {
   writeChain = writeChain.then(async () => {
-    const cache2 = await getMcpAuthCache();
-    cache2[serverId] = { timestamp: Date.now() };
+    const cache3 = await getMcpAuthCache();
+    cache3[serverId] = { timestamp: Date.now() };
     const cachePath = getMcpAuthCachePath();
     await getFsImplementation().mkdir(dirname36(cachePath), { recursive: true });
-    await getFsImplementation().writeFile(cachePath, jsonStringify(cache2));
+    await getFsImplementation().writeFile(cachePath, jsonStringify(cache3));
     authCachePromise = null;
   }).catch(() => {});
 }
@@ -278266,9 +278695,9 @@ async function callMCPToolWithUrlElicitationRetry({
             actionLabel: "Retry now",
             showCancel: true
           };
-          userResult = await new Promise((resolve25) => {
+          userResult = await new Promise((resolve26) => {
             const onAbort = () => {
-              resolve25({ action: "cancel" });
+              resolve26({ action: "cancel" });
             };
             if (signal.aborted) {
               onAbort();
@@ -278291,14 +278720,14 @@ async function callMCPToolWithUrlElicitationRetry({
                         return;
                       }
                       signal.removeEventListener("abort", onAbort);
-                      resolve25(result);
+                      resolve26(result);
                     },
                     onWaitingDismiss: (action) => {
                       signal.removeEventListener("abort", onAbort);
                       if (action === "retry") {
-                        resolve25({ action: "accept" });
+                        resolve26({ action: "accept" });
                       } else {
-                        resolve25({ action: "cancel" });
+                        resolve26({ action: "cancel" });
                       }
                     }
                   }
@@ -278996,7 +279425,7 @@ var init_client5 = __esm(() => {
                 logMCPDebug(name, `Error sending SIGINT: ${error41}`);
                 return;
               }
-              await new Promise(async (resolve25) => {
+              await new Promise(async (resolve26) => {
                 let resolved = false;
                 const checkInterval = setInterval(() => {
                   try {
@@ -279007,7 +279436,7 @@ var init_client5 = __esm(() => {
                       clearInterval(checkInterval);
                       clearTimeout(failsafeTimeout);
                       logMCPDebug(name, "MCP server process exited cleanly");
-                      resolve25();
+                      resolve26();
                     }
                   }
                 }, 50);
@@ -279016,7 +279445,7 @@ var init_client5 = __esm(() => {
                     resolved = true;
                     clearInterval(checkInterval);
                     logMCPDebug(name, "Cleanup timeout reached, stopping process monitoring");
-                    resolve25();
+                    resolve26();
                   }
                 }, 600);
                 try {
@@ -279032,14 +279461,14 @@ var init_client5 = __esm(() => {
                         resolved = true;
                         clearInterval(checkInterval);
                         clearTimeout(failsafeTimeout);
-                        resolve25();
+                        resolve26();
                         return;
                       }
                     } catch {
                       resolved = true;
                       clearInterval(checkInterval);
                       clearTimeout(failsafeTimeout);
-                      resolve25();
+                      resolve26();
                       return;
                     }
                     await sleep2(400);
@@ -279056,7 +279485,7 @@ var init_client5 = __esm(() => {
                         resolved = true;
                         clearInterval(checkInterval);
                         clearTimeout(failsafeTimeout);
-                        resolve25();
+                        resolve26();
                       }
                     }
                   }
@@ -279064,14 +279493,14 @@ var init_client5 = __esm(() => {
                     resolved = true;
                     clearInterval(checkInterval);
                     clearTimeout(failsafeTimeout);
-                    resolve25();
+                    resolve26();
                   }
                 } catch {
                   if (!resolved) {
                     resolved = true;
                     clearInterval(checkInterval);
                     clearTimeout(failsafeTimeout);
-                    resolve25();
+                    resolve26();
                   }
                 }
               });
@@ -280341,6 +280770,9 @@ async function checkPermissionsAndCallTool(tool, toolUseID, input, toolUseContex
       logError(hookError);
     }
   }
+  if (toolUseContext.abortController.signal.aborted) {
+    throw new AbortError;
+  }
   try {
     const result = await tool.call(callInput, {
       ...toolUseContext,
@@ -280641,19 +281073,24 @@ async function checkPermissionsAndCallTool(tool, toolUseID, input, toolUseContex
     }
     return [
       {
-        message: createUserMessage({
-          content: [
-            {
-              type: "tool_result",
-              content,
-              is_error: true,
-              tool_use_id: toolUseID
-            }
-          ],
-          toolUseResult: `Error: ${content}`,
-          mcpMeta: toolUseContext.agentId ? undefined : error41 instanceof McpToolCallError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS ? error41.mcpMeta : undefined,
-          sourceToolAssistantUUID: assistantMessage.uuid
-        })
+        message: {
+          ...createUserMessage({
+            content: [
+              {
+                type: "tool_result",
+                content,
+                is_error: true,
+                tool_use_id: toolUseID
+              }
+            ],
+            toolUseResult: `Error: ${content}`,
+            mcpMeta: toolUseContext.agentId ? undefined : error41 instanceof McpToolCallError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS ? error41.mcpMeta : undefined,
+            sourceToolAssistantUUID: assistantMessage.uuid
+          }),
+          ...error41 instanceof ToolContinuationStopError && {
+            preventContinuation: true
+          }
+        }
       },
       ...hookMessages
     ];
@@ -280960,8 +281397,8 @@ class StreamingToolExecutor {
       }
       if (this.hasExecutingTools() && !this.hasCompletedResults() && !this.hasPendingProgress()) {
         const executingPromises = this.tools.filter((t) => t.status === "executing" && t.promise).map((t) => t.promise);
-        const progressPromise = new Promise((resolve25) => {
-          this.progressAvailableResolve = resolve25;
+        const progressPromise = new Promise((resolve26) => {
+          this.progressAvailableResolve = resolve26;
         });
         if (executingPromises.length > 0) {
           await Promise.race([...executingPromises, progressPromise]);
@@ -281203,7 +281640,7 @@ function streamOnEnd() {
   });
 }
 function readFileInRangeStreaming(filePath, offset, maxLines, maxBytes, truncateOnByteLimit, signal) {
-  return new Promise((resolve25, reject2) => {
+  return new Promise((resolve26, reject2) => {
     const state3 = {
       stream: createReadStream2(filePath, {
         encoding: "utf8",
@@ -281214,7 +281651,7 @@ function readFileInRangeStreaming(filePath, offset, maxLines, maxBytes, truncate
       endLine: maxLines !== undefined ? offset + maxLines : Infinity,
       maxBytes,
       truncateOnByteLimit,
-      resolve: resolve25,
+      resolve: resolve26,
       totalBytesRead: 0,
       selectedBytes: 0,
       truncatedByBytes: false,
@@ -281712,6 +282149,9 @@ function* yieldMissingToolResultBlocks(assistantMessages, errorMessage2) {
 function isWithheldMaxOutputTokens(msg) {
   return msg?.type === "assistant" && msg.apiError === "max_output_tokens";
 }
+function messagePreventsContinuation(message) {
+  return message.type === "user" && message.preventContinuation === true || message.type === "attachment" && message.attachment.type === "hook_stopped_continuation";
+}
 async function* query(params) {
   const consumedCommandUuids = [];
   const terminal2 = yield* queryLoop(params, consumedCommandUuids);
@@ -281879,6 +282319,7 @@ async function* queryLoop(params, consumedCommandUuids) {
       const toolResults = [];
       const toolUseBlocks = [];
       let needsFollowUp = false;
+      let shouldPreventContinuation = false;
       queryCheckpoint("query_setup_start");
       const useStreamingToolExecution = config2.gates.streamingToolExecution;
       let streamingToolExecutor = useStreamingToolExecution ? new StreamingToolExecutor(toolUseContext.options.tools, canUseTool, toolUseContext) : null;
@@ -281976,6 +282417,7 @@ async function* queryLoop(params, consumedCommandUuids) {
                 toolResults.length = 0;
                 toolUseBlocks.length = 0;
                 needsFollowUp = false;
+                shouldPreventContinuation = false;
                 if (streamingToolExecutor) {
                   streamingToolExecutor.discard();
                   streamingToolExecutor = new StreamingToolExecutor(toolUseContext.options.tools, canUseTool, toolUseContext);
@@ -282038,6 +282480,9 @@ async function* queryLoop(params, consumedCommandUuids) {
                 for (const result of streamingToolExecutor.getCompletedResults()) {
                   if (result.message) {
                     yield result.message;
+                    if (messagePreventsContinuation(result.message)) {
+                      shouldPreventContinuation = true;
+                    }
                     toolResults.push(...normalizeMessagesForAPI([result.message], toolUseContext.options.tools).filter((_) => _.type === "user"));
                   }
                 }
@@ -282054,6 +282499,7 @@ async function* queryLoop(params, consumedCommandUuids) {
               toolResults.length = 0;
               toolUseBlocks.length = 0;
               needsFollowUp = false;
+              shouldPreventContinuation = false;
               if (streamingToolExecutor) {
                 streamingToolExecutor.discard();
                 streamingToolExecutor = new StreamingToolExecutor(toolUseContext.options.tools, canUseTool, toolUseContext);
@@ -282251,7 +282697,6 @@ async function* queryLoop(params, consumedCommandUuids) {
         if (false) {}
         return { reason: "completed" };
       }
-      let shouldPreventContinuation = false;
       let updatedToolRuntimeContext = toolUseContext;
       queryCheckpoint("query_tool_execution_start");
       if (streamingToolExecutor) {
@@ -282271,7 +282716,7 @@ async function* queryLoop(params, consumedCommandUuids) {
       for await (const update of toolUpdates) {
         if (update.message) {
           yield update.message;
-          if (update.message.type === "attachment" && update.message.attachment.type === "hook_stopped_continuation") {
+          if (messagePreventsContinuation(update.message)) {
             shouldPreventContinuation = true;
           }
           toolResults.push(...normalizeMessagesForAPI([update.message], toolUseContext.options.tools).filter((_) => _.type === "user"));
@@ -282285,7 +282730,7 @@ async function* queryLoop(params, consumedCommandUuids) {
       }
       queryCheckpoint("query_tool_execution_end");
       let nextPendingToolUseSummary;
-      if (config2.gates.emitToolUseSummaries && toolUseBlocks.length > 0 && !toolUseContext.abortController.signal.aborted && !toolUseContext.agentId) {
+      if (!shouldPreventContinuation && config2.gates.emitToolUseSummaries && toolUseBlocks.length > 0 && !toolUseContext.abortController.signal.aborted && !toolUseContext.agentId) {
         const lastAssistantMessage = assistantMessages.at(-1);
         let lastAssistantText;
         if (lastAssistantMessage) {
@@ -282618,7 +283063,7 @@ function getAnthropicEnvMetadata() {
 function getBuildAgeMinutes() {
   if (false)
     ;
-  const buildTime = new Date("2026-07-16T03:27:09.740Z").getTime();
+  const buildTime = new Date("2026-07-21T10:56:17.312Z").getTime();
   if (isNaN(buildTime))
     return;
   return Math.floor((Date.now() - buildTime) / 60000);
@@ -284416,10 +284861,10 @@ function DANGEROUS_uncachedSystemPromptSection(name, compute, _reason) {
   return { name, compute, cacheBreak: true };
 }
 async function resolveSystemPromptSections(sections) {
-  const cache2 = getSystemPromptSectionCache();
+  const cache3 = getSystemPromptSectionCache();
   return Promise.all(sections.map(async (s) => {
-    if (!s.cacheBreak && cache2.has(s.name)) {
-      return cache2.get(s.name) ?? null;
+    if (!s.cacheBreak && cache3.has(s.name)) {
+      return cache3.get(s.name) ?? null;
     }
     const value = await s.compute();
     setSystemPromptSectionCacheEntry(s.name, value);
@@ -285134,21 +285579,6 @@ var init_analyzeContext = __esm(() => {
   init_state2();
 });
 
-// src/lib/zodToJsonSchema.ts
-function zodToJsonSchema3(schema) {
-  const hit = cache2.get(schema);
-  if (hit)
-    return hit;
-  const result = toJSONSchema(schema);
-  cache2.set(schema, result);
-  return result;
-}
-var cache2;
-var init_zodToJsonSchema2 = __esm(() => {
-  init_v4();
-  cache2 = new WeakMap;
-});
-
 // src/controller/toolSearch.ts
 function parseAutoPercentage(value) {
   if (!value.startsWith("auto:"))
@@ -285263,7 +285693,8 @@ async function calculateDeferredToolDescriptionChars(tools, getToolPermissionCon
       tools,
       agents
     });
-    const inputSchema16 = tool.inputJSONSchema ? jsonStringify(tool.inputJSONSchema) : tool.inputSchema ? jsonStringify(zodToJsonSchema3(tool.inputSchema)) : "";
+    const inputJSONSchema = tool.inputJSONSchema;
+    const inputSchema16 = inputJSONSchema ? jsonStringify(inputJSONSchema) : tool.inputSchema ? jsonStringify(zodToJsonSchema3(tool.inputSchema)) : "";
     return tool.name.length + description.length + inputSchema16.length;
   }));
   return sizes.reduce((total, size) => total + size, 0);
@@ -286822,7 +287253,7 @@ var init_findRelevantMemories = __esm(() => {
 });
 
 // src/session/attachments.ts
-import { dirname as dirname37, parse as parse12, relative as relative12, resolve as resolve25 } from "path";
+import { dirname as dirname37, parse as parse12, relative as relative12, resolve as resolve26 } from "path";
 import { randomUUID as randomUUID13 } from "crypto";
 async function getAttachments(input, toolUseContext, ideSelection, queuedCommands, messages, querySource, options2) {
   if (isEnvTruthy(resolveEnvVar("DISABLE_ATTACHMENTS")) || isEnvTruthy(resolveEnvVar("SIMPLE"))) {
@@ -287200,7 +287631,7 @@ async function getSelectedLinesFromIDE(ideSelection, toolUseContext) {
   ];
 }
 function getDirectoriesToProcess(targetPath, originalCwd) {
-  const targetDir = dirname37(resolve25(targetPath));
+  const targetDir = dirname37(resolve26(targetPath));
   const nestedDirs = [];
   let currentDir = targetDir;
   while (currentDir !== originalCwd && currentDir !== parse12(currentDir).root) {
@@ -287656,7 +288087,7 @@ async function getDynamicSkillAttachments(toolUseContext) {
         const candidates = entries.filter((e) => e.isDirectory() || e.isSymbolicLink()).map((e) => e.name);
         const checked = await Promise.all(candidates.map(async (name) => {
           try {
-            await getFsImplementation().stat(resolve25(skillDir, name, "SKILL.md"));
+            await getFsImplementation().stat(resolve26(skillDir, name, "SKILL.md"));
             return name;
           } catch {
             return null;
@@ -289278,7 +289709,7 @@ function executeInBackground({
 }) {
   if (asyncRewake) {
     shellCommand.result.then(async (result) => {
-      await new Promise((resolve26) => setImmediate(resolve26));
+      await new Promise((resolve27) => setImmediate(resolve27));
       const stdout = await shellCommand.taskOutput.getStdout();
       const stderr = shellCommand.taskOutput.getStderr();
       shellCommand.cleanup();
@@ -289721,8 +290152,8 @@ async function execCommandHook(hook, hookEvent, hookName, jsonInput, signal, hoo
   child.stderr.setEncoding("utf8");
   let initialResponseChecked = false;
   let asyncResolve = null;
-  const childIsAsyncPromise = new Promise((resolve26) => {
-    asyncResolve = resolve26;
+  const childIsAsyncPromise = new Promise((resolve27) => {
+    asyncResolve = resolve27;
   });
   const processedPromptLines = new Set;
   let promptChain = Promise.resolve();
@@ -289813,13 +290244,13 @@ async function execCommandHook(hook, hookEvent, hookName, jsonInput, signal, hoo
     hookEvent,
     getOutput: async () => ({ stdout, stderr, output })
   });
-  const stdoutEndPromise = new Promise((resolve26) => {
-    child.stdout.on("end", () => resolve26());
+  const stdoutEndPromise = new Promise((resolve27) => {
+    child.stdout.on("end", () => resolve27());
   });
-  const stderrEndPromise = new Promise((resolve26) => {
-    child.stderr.on("end", () => resolve26());
+  const stderrEndPromise = new Promise((resolve27) => {
+    child.stderr.on("end", () => resolve27());
   });
-  const stdinWritePromise = stdinWritten ? Promise.resolve() : new Promise((resolve26, reject2) => {
+  const stdinWritePromise = stdinWritten ? Promise.resolve() : new Promise((resolve27, reject2) => {
     child.stdin.on("error", (err2) => {
       if (!requestPrompt) {
         reject2(err2);
@@ -289832,12 +290263,12 @@ async function execCommandHook(hook, hookEvent, hookName, jsonInput, signal, hoo
     if (!requestPrompt) {
       child.stdin.end();
     }
-    resolve26();
+    resolve27();
   });
   const childErrorPromise = new Promise((_, reject2) => {
     child.on("error", reject2);
   });
-  const childClosePromise = new Promise((resolve26) => {
+  const childClosePromise = new Promise((resolve27) => {
     let exitCode = null;
     child.on("close", (code) => {
       exitCode = code ?? 1;
@@ -289845,7 +290276,7 @@ async function execCommandHook(hook, hookEvent, hookName, jsonInput, signal, hoo
         const finalStdout = processedPromptLines.size === 0 ? stdout : stdout.split(`
 `).filter((line) => !processedPromptLines.has(line.trim())).join(`
 `);
-        resolve26({
+        resolve27({
           stdout: finalStdout,
           stderr,
           output,
@@ -291900,12 +292331,12 @@ async function executeFunctionHook({
         hook
       };
     }
-    const passed = await new Promise((resolve26, reject2) => {
+    const passed = await new Promise((resolve27, reject2) => {
       const onAbort = () => reject2(new Error("Function hook cancelled"));
       abortSignal.addEventListener("abort", onAbort);
       Promise.resolve(hook.callback(messages, abortSignal)).then((result) => {
         abortSignal.removeEventListener("abort", onAbort);
-        resolve26(result);
+        resolve27(result);
       }).catch((error41) => {
         abortSignal.removeEventListener("abort", onAbort);
         reject2(error41);
@@ -292362,10 +292793,11 @@ async function createAgentWorktree(slug) {
     logForDebugging(`Created hook-based agent worktree at: ${hookResult.worktreePath}`);
     return { worktreePath: hookResult.worktreePath, hookBased: true };
   }
-  const gitRoot = findCanonicalGitRoot(getCwd3());
-  if (!gitRoot) {
-    throw new Error("Cannot create agent worktree: not in a git repository and no WorktreeCreate hooks are configured. " + "Configure WorktreeCreate/WorktreeRemove hooks in settings.json to use worktree isolation with other VCS systems.");
+  const availability = resolveGitWorktreeAvailability(getCwd3(), gitExe());
+  if (!availability.available) {
+    throw new WorktreeUnavailableError(availability.reason);
   }
+  const gitRoot = findCanonicalGitRoot(availability.gitRoot) ?? availability.gitRoot;
   const { worktreePath, worktreeBranch, headCommit, existed } = await getOrCreateWorktree(gitRoot, slug);
   if (!existed) {
     logForDebugging(`Created agent worktree at: ${worktreePath} on branch: ${worktreeBranch}`);
@@ -292377,6 +292809,16 @@ async function createAgentWorktree(slug) {
   }
   return { worktreePath, worktreeBranch, headCommit, gitRoot };
 }
+function isAgentWorktreeIsolationAvailable(options2 = {}) {
+  try {
+    if (options2.hasCreateHook ?? hasWorktreeCreateHook()) {
+      return true;
+    }
+    return isGitWorktreeIsolationAvailable(options2.cwd ?? getCwd3(), gitExe(), options2.gitAvailabilityCache);
+  } catch {
+    return false;
+  }
+}
 async function removeAgentWorktree(worktreePath, worktreeBranch, gitRoot, hookBased) {
   if (hookBased) {
     const hookRan = await executeWorktreeRemoveHook(worktreePath);
@@ -292448,6 +292890,7 @@ var init_worktree = __esm(() => {
   init_settings2();
   init_detection();
   init_fsOperations();
+  init_worktreeAvailability();
   import_ignore4 = __toESM(require_ignore(), 1);
   VALID_WORKTREE_SLUG_SEGMENT = /^[a-zA-Z0-9._-]+$/;
   GIT_NO_PROMPT_ENV2 = {
@@ -292939,12 +293382,13 @@ function filterSwarmFieldsFromSchema(toolName, schema) {
   return filtered;
 }
 async function toolToAPISchema(tool, options2) {
-  const cacheKey = "inputJSONSchema" in tool && tool.inputJSONSchema ? `${tool.name}:${jsonStringify(tool.inputJSONSchema)}` : tool.name;
+  const inputJSONSchema = tool.inputJSONSchema;
+  const cacheKey = inputJSONSchema ? `${tool.name}:${jsonStringify(inputJSONSchema)}` : tool.name;
   const cache3 = getToolSchemaCache();
   let base2 = cache3.get(cacheKey);
   if (!base2) {
     const strictToolsEnabled = checkStatsigFeatureGate_CACHED_MAY_BE_STALE("tengu_tool_pear");
-    let input_schema = "inputJSONSchema" in tool && tool.inputJSONSchema ? tool.inputJSONSchema : zodToJsonSchema3(tool.inputSchema);
+    let input_schema = inputJSONSchema ?? zodToJsonSchema3(tool.inputSchema);
     if (!isAgentSwarmsEnabled()) {
       input_schema = filterSwarmFieldsFromSchema(tool.name, input_schema);
     }
@@ -296032,7 +296476,7 @@ var init_permissionSetup = __esm(() => {
 
 // src/capabilities/markdownConfigLoader.ts
 import { homedir as homedir20 } from "os";
-import { dirname as dirname39, join as join74, resolve as resolve26, sep as sep21 } from "path";
+import { dirname as dirname39, join as join74, resolve as resolve27, sep as sep21 } from "path";
 function extractDescriptionFromMarkdown(content, defaultDescription = "Custom item") {
   const lines = content.split(`
 `);
@@ -296114,9 +296558,9 @@ function resolveStopBoundary(cwd) {
   return cwdGitRoot;
 }
 function getProjectDirsUpToHome(subdir, cwd) {
-  const home = resolve26(homedir20()).normalize("NFC");
+  const home = resolve27(homedir20()).normalize("NFC");
   const gitRoot = resolveStopBoundary(cwd);
-  let current = resolve26(cwd);
+  let current = resolve27(cwd);
   const dirs = [];
   while (true) {
     if (normalizePathForComparison(current) === normalizePathForComparison(home)) {
@@ -317753,7 +318197,7 @@ var HttpClient = class {
           } else if (extractStatus.status === "failed" || extractStatus.status === "cancelled") {
             throw new FirecrawlError(`Extract job ${extractStatus.status}. Error: ${extractStatus.error}`, statusResponse.status);
           }
-          await new Promise((resolve27) => setTimeout(resolve27, 1000));
+          await new Promise((resolve28) => setTimeout(resolve28, 1000));
         } while (extractStatus.status !== "completed");
       } else {
         this.handleError(response, "extract");
@@ -317852,7 +318296,7 @@ var HttpClient = class {
             }
           } else if (["active", "paused", "pending", "queued", "waiting", "scraping"].includes(statusData.status)) {
             checkInterval = Math.max(checkInterval, 2);
-            await new Promise((resolve27) => setTimeout(resolve27, checkInterval * 1000));
+            await new Promise((resolve28) => setTimeout(resolve28, checkInterval * 1000));
           } else {
             throw new FirecrawlError(`Crawl job failed or was stopped. Status: ${statusData.status}`, 500);
           }
@@ -317866,7 +318310,7 @@ var HttpClient = class {
         if (this.isRetryableError(error41) && networkRetries < maxNetworkRetries) {
           networkRetries++;
           const backoffDelay = Math.min(1000 * Math.pow(2, networkRetries - 1), 1e4);
-          await new Promise((resolve27) => setTimeout(resolve27, backoffDelay));
+          await new Promise((resolve28) => setTimeout(resolve28, backoffDelay));
           continue;
         }
         throw new FirecrawlError(error41, 500);
@@ -317949,7 +318393,7 @@ var HttpClient = class {
         if (researchStatus.status !== "processing") {
           break;
         }
-        await new Promise((resolve27) => setTimeout(resolve27, 2000));
+        await new Promise((resolve28) => setTimeout(resolve28, 2000));
       }
       return { success: false, error: "Research job terminated unexpectedly" };
     } catch (error41) {
@@ -318037,7 +318481,7 @@ var HttpClient = class {
         if (researchStatus.status !== "processing") {
           break;
         }
-        await new Promise((resolve27) => setTimeout(resolve27, 2000));
+        await new Promise((resolve28) => setTimeout(resolve28, 2000));
       }
       return { success: false, error: "Research job terminated unexpectedly" };
     } catch (error41) {
@@ -318108,7 +318552,7 @@ var HttpClient = class {
         if (generationStatus.status !== "processing") {
           break;
         }
-        await new Promise((resolve27) => setTimeout(resolve27, 2000));
+        await new Promise((resolve28) => setTimeout(resolve28, 2000));
       }
       return { success: false, error: "LLMs.txt generation job terminated unexpectedly" };
     } catch (error41) {
@@ -324945,9 +325389,9 @@ var require_needle = __commonJS((exports, module) => {
         verb = args.shift();
       if (verb.match(/get|head/i) && args.length == 2)
         args.splice(1, 0, null);
-      return new Promise(function(resolve27, reject2) {
+      return new Promise(function(resolve28, reject2) {
         module.exports.request(verb, args[0], args[1], args[2], function(err2, resp) {
-          return err2 ? reject2(err2) : resolve27(resp);
+          return err2 ? reject2(err2) : resolve28(resp);
         });
       });
     };
@@ -329467,8 +329911,9 @@ function registerSdkInlineSkillHandler() {
 }
 
 // src/session/sdkRuntime.ts
-init_LocalAgentTask();
 init_backgroundAbortRegistry();
+init_backgroundTaskScope();
+init_sessionStorage();
 init_hooks2();
 init_debug();
 init_errors5();
@@ -331711,7 +332156,8 @@ async function stopTask(taskId, context4) {
   const appState = getAppState();
   const task = appState.tasks?.[taskId];
   if (!task) {
-    if (abortBackgroundAgentById(taskId)) {
+    if (hasBackgroundAgent(taskId)) {
+      await abortBackgroundAgentById(taskId);
       return { taskId, taskType: "local_agent", command: undefined };
     }
     throw new StopTaskError(`No task found with ID: ${taskId}`, "not_found");
@@ -331723,7 +332169,11 @@ async function stopTask(taskId, context4) {
   if (!taskImpl) {
     throw new StopTaskError(`Unsupported task type: ${task.type}`, "unsupported_type");
   }
-  await taskImpl.kill(taskId, setAppState);
+  if (task.type === "local_agent" && hasBackgroundAgent(taskId)) {
+    await abortBackgroundAgentById(taskId);
+  } else {
+    await taskImpl.kill(taskId, setAppState);
+  }
   if (isLocalShellTask(task)) {
     let suppressed = false;
     setAppState((prev) => {
@@ -331765,6 +332215,7 @@ var DESCRIPTION10 = `
 
 // src/capabilities/tools/TaskStopTool/TaskStopTool.ts
 init_toolUIRegistry();
+init_backgroundAbortRegistry();
 var {
   renderToolResultMessage: renderToolResultMessage17,
   renderToolUseMessage: renderToolUseMessage17
@@ -331810,6 +332261,9 @@ var TaskStopTool = buildToolRuntime({
     const appState = getAppState();
     const task = appState.tasks?.[id];
     if (!task) {
+      if (hasBackgroundAgent(id)) {
+        return { result: true };
+      }
       return {
         result: false,
         message: `No task found with ID: ${id}`,
@@ -334757,34 +335211,63 @@ function optionsWithProviderRoutingEnv(options2) {
   }
   return { ...options2, env: mergedEnv };
 }
-function createQueryLike(generator, runtimeState, onClose) {
+function createQueryLike(generator, runtimeState, finalize) {
+  let finalizePromise;
+  let closePromise;
+  const finalizeOnce = () => {
+    finalizePromise ??= finalize();
+    return finalizePromise;
+  };
+  const stream4 = async function* () {
+    try {
+      yield* generator;
+    } finally {
+      await finalizeOnce();
+    }
+  }();
   return {
     [Symbol.asyncIterator]() {
-      return generator;
+      return stream4;
     },
     async interrupt() {
       runtimeState.abortController.abort();
       runtimeState.abortController = createAbortController();
     },
     killAgent(agentId) {
-      abortBackgroundAgentById(agentId);
-      killAsyncAgent(agentId, runtimeState.setAppState);
+      return abortBackgroundAgentById(agentId);
     },
-    async close() {
-      if (runtimeState.closed)
-        return;
-      runtimeState.closed = true;
-      runtimeState.abortController.abort();
-      try {
-        await generator.return(undefined);
-      } finally {
-        if (onClose) {
-          await onClose();
-        }
+    close() {
+      if (!closePromise) {
+        runtimeState.closed = true;
+        runtimeState.abortController.abort();
+        closePromise = (async () => {
+          try {
+            await stream4.return(undefined);
+          } finally {
+            await finalizeOnce();
+          }
+        })();
       }
+      return closePromise;
     }
   };
 }
+function trackProjectContextId(ownership, sessionId) {
+  ownership.projectContextIds.add(sessionId);
+  if (ownership.kind === "session") {
+    ownership.trackProjectContextId(sessionId);
+  }
+}
+async function closeOwnedQueryResources(scope, projectContextIds) {
+  try {
+    await scope.stop();
+  } finally {
+    for (const sessionId of projectContextIds) {
+      clearProjectForSession(sessionId);
+    }
+    projectContextIds.clear();
+  }
+}
 async function* mergeAskWithStatus(askIterable, statusStream) {
   const askIter = askIterable[Symbol.asyncIterator]();
   let askNext = askIter.next();
@@ -334817,6 +335300,15 @@ function runSdkQueryRuntime(params) {
   const cwd = typeof options2.cwd === "string" && options2.cwd.trim().length > 0 ? options2.cwd : process.cwd();
   const optionsWithProviderRouting = optionsWithProviderRoutingEnv(options2);
   const queryContext = buildQueryContextFromSdk(optionsWithProviderRouting);
+  const ownership = params.resourceOwner ? {
+    ...params.resourceOwner,
+    projectContextIds: new Set
+  } : {
+    kind: "standalone",
+    backgroundTaskScope: new BackgroundTaskScope,
+    projectContextIds: new Set
+  };
+  trackProjectContextId(ownership, queryContext.identity.sessionId);
   const runtimeState = {
     closed: false,
     runningTurn: false,
@@ -334824,6 +335316,7 @@ function runSdkQueryRuntime(params) {
   };
   const fileCheckpointingOnChange = options2.fileCheckpointing?.onFileHistoryChange;
   const appStateStore = buildAppStateStore(applyFileCheckpointingInitialState(applyDisallowedTools(applyPermissionMode(getDefaultAppState(), options2.permissionMode), options2.disallowedTools), options2.fileCheckpointing?.initialState), fileCheckpointingOnChange);
+  const releaseBackgroundTaskScope = bindBackgroundTaskScope(appStateStore.setAppState, ownership.backgroundTaskScope);
   const initialMessagesForReplay = options2.resume ? loadAndRestampHistoricalMessages(options2.resume, queryContext.identity.sessionId, options2.initialMessages) : options2.initialMessages;
   let mutableMessages = normalizeInitialMessages(initialMessagesForReplay);
   let readFileCache = createFileStateCacheWithSizeLimit(DEFAULT_READ_FILE_CACHE_SIZE);
@@ -335066,7 +335559,17 @@ function runSdkQueryRuntime(params) {
     }
   }();
   const generator = bindAsyncGeneratorToScope(rawGenerator, queryContext);
-  return createQueryLike(generator, runtimeState);
+  return createQueryLike(generator, runtimeState, async () => {
+    trackProjectContextId(ownership, queryContext.identity.sessionId);
+    releaseBackgroundTaskScope();
+    try {
+      params.onStreamSettled?.();
+    } finally {
+      if (ownership.kind === "standalone") {
+        await closeOwnedQueryResources(ownership.backgroundTaskScope, ownership.projectContextIds);
+      }
+    }
+  });
 }
 
 // src/session/runtime.ts
@@ -335078,6 +335581,8 @@ init_hooks2();
 init_AppStateStore();
 init_debug();
 init_errors5();
+init_backgroundTaskScope();
+init_sessionStorage();
 function mergeTurnOptions(sessionOptions, turnOptions) {
   if (!turnOptions)
     return sessionOptions;
@@ -335094,6 +335599,10 @@ function mergeTurnOptions(sessionOptions, turnOptions) {
 class SessionRuntime {
   baseOptions;
   closed = false;
+  closePromise;
+  backgroundTaskScope = new BackgroundTaskScope;
+  projectContextIds = new Set;
+  activeQueries = new Set;
   accumulatedFileHistory;
   constructor(options2) {
     this.baseOptions = options2;
@@ -335117,13 +335626,34 @@ class SessionRuntime {
         }
       }
     } : undefined;
-    return runSdkQueryRuntime({
+    let query2;
+    query2 = runSdkQueryRuntime({
       prompt: params.prompt,
       options: {
         ...merged,
         ...fileCheckpointing ? { fileCheckpointing } : {}
+      },
+      resourceOwner: {
+        kind: "session",
+        backgroundTaskScope: this.backgroundTaskScope,
+        trackProjectContextId: (sessionId) => {
+          this.projectContextIds.add(sessionId);
+        }
+      },
+      onStreamSettled: () => {
+        this.activeQueries.delete(query2);
       }
     });
+    this.activeQueries.add(query2);
+    const closeQuery = query2.close.bind(query2);
+    query2.close = async () => {
+      try {
+        await closeQuery();
+      } finally {
+        this.activeQueries.delete(query2);
+      }
+    };
+    return query2;
   }
   async prompt(message, options2) {
     const q = this.query({ prompt: message, options: options2 });
@@ -335138,32 +335668,66 @@ class SessionRuntime {
   async getInfo() {
     return;
   }
-  async close(reason = "normal") {
-    if (this.closed)
-      return;
-    this.closed = true;
-    const ctx = buildRewindQueryContext(this.baseOptions);
-    await runWithQueryContext(ctx, async () => {
-      if (this.baseOptions.hooks) {
-        try {
-          registerHookCallbacks2(this.baseOptions.hooks);
-        } catch (err2) {
-          logForDebugging(`SessionRuntime.close: registerHookCallbacks threw: ${errorMessage(err2)}`, { level: "warn" });
-        }
+  close(reason = "normal") {
+    if (!this.closePromise) {
+      this.closed = true;
+      this.closePromise = this.closeResources(reason);
+    }
+    return this.closePromise;
+  }
+  async closeResources(reason) {
+    const failures = [];
+    try {
+      const activeQueries = [...this.activeQueries];
+      const queryResults = await Promise.allSettled(activeQueries.map(async (query2) => {
+        await query2.close();
+      }));
+      for (const result of queryResults) {
+        if (result.status === "rejected")
+          failures.push(result.reason);
       }
-      let state3 = getDefaultAppState();
+      this.activeQueries.clear();
       try {
-        await executeSessionEndHooks(reason, {
-          getAppState: () => state3,
-          setAppState: (updater) => {
-            state3 = updater(state3);
-          },
-          timeoutMs: getSessionEndHookTimeoutMs()
+        await this.backgroundTaskScope.stop();
+      } catch (err2) {
+        failures.push(err2);
+      }
+      try {
+        const ctx = buildRewindQueryContext(this.baseOptions);
+        this.projectContextIds.add(ctx.identity.sessionId);
+        await runWithQueryContext(ctx, async () => {
+          if (this.baseOptions.hooks) {
+            try {
+              registerHookCallbacks2(this.baseOptions.hooks);
+            } catch (err2) {
+              logForDebugging(`SessionRuntime.close: registerHookCallbacks threw: ${errorMessage(err2)}`, { level: "warn" });
+            }
+          }
+          let state3 = getDefaultAppState();
+          try {
+            await executeSessionEndHooks(reason, {
+              getAppState: () => state3,
+              setAppState: (updater) => {
+                state3 = updater(state3);
+              },
+              timeoutMs: getSessionEndHookTimeoutMs()
+            });
+          } catch (err2) {
+            logForDebugging(`SessionRuntime.close: SessionEnd hooks errored: ${errorMessage(err2)}`, { level: "warn" });
+          }
         });
       } catch (err2) {
-        logForDebugging(`SessionRuntime.close: SessionEnd hooks errored: ${errorMessage(err2)}`, { level: "warn" });
+        logForDebugging(`SessionRuntime.close: SessionEnd context errored: ${errorMessage(err2)}`, { level: "warn" });
       }
-    });
+    } finally {
+      for (const sessionId of this.projectContextIds) {
+        clearProjectForSession(sessionId);
+      }
+      this.projectContextIds.clear();
+    }
+    if (failures.length > 0) {
+      throw new AggregateError(failures, "SessionRuntime cleanup failed");
+    }
   }
   canRewindFiles(state3, messageUuid) {
     const effective = this.accumulatedFileHistory ?? state3;
@@ -335478,14 +336042,14 @@ class AuthCodeListener {
     this.callbackPath = callbackPath;
   }
   async start(port) {
-    return new Promise((resolve27, reject2) => {
+    return new Promise((resolve28, reject2) => {
       this.localServer.once("error", (err2) => {
         reject2(new Error(`Failed to start OAuth callback server: ${err2.message}`));
       });
       this.localServer.listen({ port: port ?? 0, host: "::", ipv6Only: false }, () => {
         const address = this.localServer.address();
         this.port = address.port;
-        resolve27(this.port);
+        resolve28(this.port);
       });
     });
   }
@@ -335496,8 +336060,8 @@ class AuthCodeListener {
     return this.pendingResponse !== null;
   }
   async waitForAuthorization(state3, onReady) {
-    return new Promise((resolve27, reject2) => {
-      this.promiseResolver = resolve27;
+    return new Promise((resolve28, reject2) => {
+      this.promiseResolver = resolve28;
       this.promiseRejecter = reject2;
       this.expectedState = state3;
       this.startLocalListener(onReady);
@@ -335663,11 +336227,11 @@ class OAuthService {
     }
   }
   async waitForAuthorizationCode(state3, onReady) {
-    return new Promise((resolve27, reject2) => {
-      this.manualAuthCodeResolver = resolve27;
+    return new Promise((resolve28, reject2) => {
+      this.manualAuthCodeResolver = resolve28;
       this.authCodeListener?.waitForAuthorization(state3, onReady).then((authorizationCode) => {
         this.manualAuthCodeResolver = null;
-        resolve27(authorizationCode);
+        resolve28(authorizationCode);
       }).catch((error41) => {
         this.manualAuthCodeResolver = null;
         reject2(error41);
@@ -336140,4 +336704,4 @@ export {
   AbortError2 as AbortError
 };
 
-//# debugId=AE8C8840D6E2407264756E2164756E21
+//# debugId=802EF03F664786CA64756E2164756E21