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

package/dist/cli.mjs

@@ -5556,7 +5556,7 @@ function classifyAxiosError(e) {
   }
   return { kind: "http", status, message };
 }
-var ClaudeError, MalformedCommandError, AbortError, ConfigParseError, ShellError, TeleportOperationError, TelemetrySafeError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS;
+var ClaudeError, MalformedCommandError, AbortError, ToolContinuationStopError, ConfigParseError, ShellError, TeleportOperationError, TelemetrySafeError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS;
 var init_errors2 = __esm(() => {
   init_canonical();
   ClaudeError = class ClaudeError extends Error {
@@ -5573,6 +5573,12 @@ var init_errors2 = __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;
@@ -32091,6 +32097,21 @@ import { createHash } from "crypto";
 import { readFileSync as readFileSync5, realpathSync as realpathSync2, statSync as statSync4 } from "fs";
 import { open as open2, readFile as readFile3, realpath as realpath3, stat as stat4 } from "fs/promises";
 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);
@@ -32512,8 +32533,7 @@ var init_git = __esm(() => {
       try {
         const gitPath = join12(current, ".git");
         statCount++;
-        const stat5 = statSync4(gitPath);
-        if (stat5.isDirectory() || stat5.isFile()) {
+        if (hasValidGitMarker(gitPath)) {
           logForDiagnosticsNoPII("info", "find_git_root_completed", {
             duration_ms: Date.now() - startTime,
             stat_count: statCount,
@@ -32531,8 +32551,7 @@ var init_git = __esm(() => {
     try {
       const gitPath = join12(root2, ".git");
       statCount++;
-      const stat5 = statSync4(gitPath);
-      if (stat5.isDirectory() || stat5.isFile()) {
+      if (hasValidGitMarker(gitPath)) {
         logForDiagnosticsNoPII("info", "find_git_root_completed", {
           duration_ms: Date.now() - startTime,
           stat_count: statCount,
@@ -94620,7 +94639,7 @@ function printStartupScreen() {
   const sLen = ` ● ${sL}    Ready — type /help to begin`.length;
   out.push(boxRow(sRow, W2, sLen));
   out.push(`${rgb(...BORDER)}╚${"═".repeat(W2 - 2)}╝${RESET}`);
-  out.push(`  ${DIM}${rgb(...DIMCOL)}opencow ${RESET}${rgb(...ACCENT)}v${"0.4.18"}${RESET}`);
+  out.push(`  ${DIM}${rgb(...DIMCOL)}opencow ${RESET}${rgb(...ACCENT)}v${"0.4.20"}${RESET}`);
   out.push("");
   process.stdout.write(out.join(`
 `) + `
@@ -241530,6 +241549,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,
@@ -241830,19 +241852,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
     ];
@@ -243670,6 +243697,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 terminal = yield* queryLoop(params, consumedCommandUuids);
@@ -243837,6 +243867,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;
@@ -243934,6 +243965,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);
@@ -243996,6 +244028,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"));
                   }
                 }
@@ -244012,6 +244047,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);
@@ -244209,7 +244245,6 @@ async function* queryLoop(params, consumedCommandUuids) {
         if (false) {}
         return { reason: "completed" };
       }
-      let shouldPreventContinuation = false;
       let updatedToolRuntimeContext = toolUseContext;
       queryCheckpoint("query_tool_execution_start");
       if (streamingToolExecutor) {
@@ -244229,7 +244264,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"));
@@ -244243,7 +244278,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) {
@@ -244610,7 +244645,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);
@@ -247203,18 +247238,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((resolve18) => {
+    resolveSettled = resolve18;
+  });
+  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);
@@ -248069,6 +248160,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 randomUUID10 } from "crypto";
 async function initializeAgentMcpServers(agentDefinition, parentClients) {
@@ -248091,44 +248199,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) {
-        logForDebugging2(`[Agent: ${agentDefinition.agentType}] MCP server not found: ${spec}`, { level: "warn" });
-        continue;
-      }
-    } else {
-      const entries = Object.entries(spec);
-      if (entries.length !== 1) {
-        logForDebugging2(`[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);
-      logForDebugging2(`[Agent: ${agentDefinition.agentType}] Connected to MCP server '${name}' with ${tools.length} tools`);
-    } else {
-      logForDebugging2(`[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") {
@@ -248140,6 +248210,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) {
+          logForDebugging2(`[Agent: ${agentDefinition.agentType}] MCP server not found: ${spec}`, { level: "warn" });
+          continue;
+        }
+      } else {
+        const entries = Object.entries(spec);
+        if (entries.length !== 1) {
+          logForDebugging2(`[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);
+        logForDebugging2(`[Agent: ${agentDefinition.agentType}] Connected to MCP server '${name}' with ${tools.length} tools`);
+      } else {
+        logForDebugging2(`[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,
@@ -248292,121 +248405,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);
+    registerBackgroundAgentAbort(agentId, {
+      abort: () => {
+        killAsyncAgent(agentId, rootSetAppState);
+        if (!agentAbortController.signal.aborted) {
+          agentAbortController.abort();
+        }
+      },
+      stopShells: stopOwnedShells
+    });
   }
-  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);
+  let agentToolRuntimeContext;
+  let mcpCleanup = async () => {};
+  let lastAssistantForFallback = null;
+  let agentRunError;
+  const finalizeLifecycle = createAgentLifecycleFinalizer((error41) => {
+    logForDebugging2(`Agent ${agentId} cleanup failed: ${error41}`, {
+      level: "warn"
+    });
+  });
+  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);
+      }
     }
-  }
-  if (additionalContexts.length > 0) {
-    const contextMessage = createAttachmentMessage({
-      type: "hook_additional_context",
-      content: additionalContexts,
-      hookName: "SubagentStart",
-      toolUseID: randomUUID10(),
-      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) {
-        logForDebugging2(`[Agent: ${agentDefinition.agentType}] Warning: Skill '${skillName}' specified in frontmatter was not found`, { level: "warn" });
-        continue;
+    if (additionalContexts.length > 0) {
+      const contextMessage = createAttachmentMessage({
+        type: "hook_additional_context",
+        content: additionalContexts,
+        hookName: "SubagentStart",
+        toolUseID: randomUUID10(),
+        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) {
+          logForDebugging2(`[Agent: ${agentDefinition.agentType}] Warning: Skill '${skillName}' specified in frontmatter was not found`, { level: "warn" });
+          continue;
+        }
+        const skill = getCommand2(resolvedName, allSkills);
+        if (skill.type !== "prompt") {
+          logForDebugging2(`[Agent: ${agentDefinition.agentType}] Warning: Skill '${skillName}' is not a prompt-based skill`, { level: "warn" });
+          continue;
+        }
+        validSkills.push({ skillName, skill });
       }
-      const skill = getCommand2(resolvedName, allSkills);
-      if (skill.type !== "prompt") {
-        logForDebugging2(`[Agent: ${agentDefinition.agentType}] Warning: Skill '${skillName}' is not a prompt-based skill`, { level: "warn" });
-        continue;
+      const loaded = await Promise.all(validSkills.map(async ({ skillName, skill }) => ({
+        skillName,
+        skill,
+        content: await skill.getPromptForCommand("", toolUseContext)
+      })));
+      for (const { skillName, skill, content } of loaded) {
+        logForDebugging2(`[Agent: ${agentDefinition.agentType}] Preloaded skill '${skillName}'`);
+        const metadata = formatSkillLoadingMetadata(skillName, skill.progressMessage);
+        initialMessages.push(createUserMessage({
+          content: [{ type: "text", text: metadata }, ...content],
+          isMeta: true
+        }));
       }
-      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) {
-      logForDebugging2(`[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
-    });
-  }
-  recordSidechainTranscript(initialMessages, agentId).catch((_err) => logForDebugging2(`Failed to record sidechain transcript: ${_err}`));
-  writeAgentMetadata(agentId, {
-    agentType: agentDefinition.agentType,
-    ...worktreePath && { worktreePath },
-    ...description && { description }
-  }).catch((_err) => logForDebugging2(`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 {
+    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
+    });
+    if (preserveToolUseResults) {
+      agentToolRuntimeContext.preserveToolUseResults = true;
+    }
+    if (onCacheSafeParams) {
+      onCacheSafeParams({
+        systemPrompt: agentSystemPrompt,
+        userContext: resolvedUserContext,
+        systemContext: resolvedSystemContext,
+        toolUseContext: agentToolRuntimeContext,
+        forkContextMessages: initialMessages
+      });
+    }
+    recordSidechainTranscript(initialMessages, agentId).catch((_err) => logForDebugging2(`Failed to record sidechain transcript: ${_err}`));
+    writeAgentMetadata(agentId, {
+      agentType: agentDefinition.agentType,
+      ...worktreePath && { worktreePath },
+      ...description && { description }
+    }).catch((_err) => logForDebugging2(`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,
@@ -248496,43 +248628,65 @@ async function* runAgent({
     agentRunError = err2;
     throw err2;
   } finally {
-    const naturalStopAlreadyFired = isAsync2 && hasSubagentStopFired(agentId);
-    if (isAsync2) {
-      unregisterBackgroundAgentAbort(agentId);
-    }
-    if (isAsync2 && agentRunError !== undefined) {
-      logForDebugging2(`Background agent ${agentId} crashed: ${errorMessage(agentRunError)}
+    await finalizeLifecycle([
+      async () => {
+        const naturalStopAlreadyFired = isAsync2 && hasSubagentStopFired(agentId);
+        if (isAsync2 && agentRunError !== undefined) {
+          logForDebugging2(`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) {
-        logForDebugging2(`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) {
+            logForDebugging2(`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) {
@@ -248604,6 +248758,7 @@ var init_runAgent = __esm(() => {
   init_config7();
   init_permissions2();
   init_killShellTasks();
+  init_LocalAgentTask();
   init_attachments();
   init_errors2();
   init_file();
@@ -250468,6 +250623,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,
@@ -250511,6 +250681,67 @@ function getTeleportLauncher() {
 }
 var _launcher = null;
 
+// src/capabilities/worktreeAvailability.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { resolve as resolve18 } 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: resolve18(gitRoot).normalize("NFC"),
+      headCommit
+    };
+  } catch {
+    return { available: false, reason: "git_unavailable" };
+  }
+}
+function isGitWorktreeIsolationAvailable(cwd, gitExecutable = "git", cache3) {
+  const cacheKey = `${resolve18(cwd).normalize("NFC")}\x00${gitExecutable}`;
+  const cached3 = cache3?.get(cacheKey);
+  if (cached3 !== undefined)
+    return cached3;
+  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}`;
@@ -257885,13 +258116,13 @@ var init_sedValidation = __esm(() => {
 
 // src/capabilities/tools/BashTool/pathValidation.ts
 import { homedir as homedir18 } from "os";
-import { isAbsolute as isAbsolute13, resolve as resolve18 } from "path";
+import { isAbsolute as isAbsolute13, resolve as resolve19 } from "path";
 function checkDangerousRemovalPaths(command, args, cwd) {
   const extractor = PATH_EXTRACTORS[command];
   const paths2 = extractor(args);
   for (const path11 of paths2) {
     const cleanPath = expandTilde(path11.replace(/^['"]|['"]$/g, ""));
-    const absolutePath = isAbsolute13(cleanPath) ? cleanPath : resolve18(cwd, cleanPath);
+    const absolutePath = isAbsolute13(cleanPath) ? cleanPath : resolve19(cwd, cleanPath);
     if (isDangerousRemovalPath(absolutePath)) {
       return {
         behavior: "ask",
@@ -261619,7 +261850,7 @@ function createInProcessCanUseTool(identity4, abortController, onPermissionWaitM
     }
     const setToolUseConfirmQueue = getLeaderToolUseConfirmQueue();
     if (setToolUseConfirmQueue) {
-      return new Promise((resolve19) => {
+      return new Promise((resolve20) => {
         let decisionMade = false;
         const permissionStartMs = Date.now();
         const reportPermissionWait = () => {
@@ -261630,7 +261861,7 @@ function createInProcessCanUseTool(identity4, abortController, onPermissionWaitM
             return;
           decisionMade = true;
           reportPermissionWait();
-          resolve19({ behavior: "ask", message: SUBAGENT_REJECT_MESSAGE });
+          resolve20({ behavior: "ask", message: SUBAGENT_REJECT_MESSAGE });
           setToolUseConfirmQueue((queue3) => queue3.filter((item) => item.toolUseID !== toolUseID));
         };
         abortController.signal.addEventListener("abort", onAbortListener, {
@@ -261655,7 +261886,7 @@ function createInProcessCanUseTool(identity4, abortController, onPermissionWaitM
               decisionMade = true;
               abortController.signal.removeEventListener("abort", onAbortListener);
               reportPermissionWait();
-              resolve19({ behavior: "ask", message: SUBAGENT_REJECT_MESSAGE });
+              resolve20({ behavior: "ask", message: SUBAGENT_REJECT_MESSAGE });
             },
             async onAllow(updatedInput, permissionUpdates, feedback, contentBlocks) {
               if (decisionMade)
@@ -261675,7 +261906,7 @@ function createInProcessCanUseTool(identity4, abortController, onPermissionWaitM
                 }
               }
               const trimmedFeedback = feedback?.trim();
-              resolve19({
+              resolve20({
                 behavior: "allow",
                 updatedInput,
                 userModified: false,
@@ -261690,7 +261921,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;
-              resolve19({ behavior: "ask", message, contentBlocks });
+              resolve20({ behavior: "ask", message, contentBlocks });
             },
             async recheckPermission() {
               if (decisionMade)
@@ -261701,7 +261932,7 @@ function createInProcessCanUseTool(identity4, abortController, onPermissionWaitM
                 abortController.signal.removeEventListener("abort", onAbortListener);
                 reportPermissionWait();
                 setToolUseConfirmQueue((queue4) => queue4.filter((item) => item.toolUseID !== toolUseID));
-                resolve19({
+                resolve20({
                   ...freshResult,
                   updatedInput: input,
                   userModified: false
@@ -261712,7 +261943,7 @@ function createInProcessCanUseTool(identity4, abortController, onPermissionWaitM
         ]);
       });
     }
-    return new Promise((resolve19) => {
+    return new Promise((resolve20) => {
       const request = createPermissionRequest({
         toolName: tool.name,
         toolUseId: toolUseID,
@@ -261731,7 +261962,7 @@ function createInProcessCanUseTool(identity4, abortController, onPermissionWaitM
           cleanup();
           persistPermissionUpdates(permissionUpdates);
           const finalInput = updatedInput && Object.keys(updatedInput).length > 0 ? updatedInput : input;
-          resolve19({
+          resolve20({
             behavior: "allow",
             updatedInput: finalInput,
             userModified: false,
@@ -261741,14 +261972,14 @@ function createInProcessCanUseTool(identity4, abortController, onPermissionWaitM
         onReject(feedback, contentBlocks) {
           cleanup();
           const message = feedback ? `${SUBAGENT_REJECT_MESSAGE_WITH_REASON_PREFIX}${feedback}` : SUBAGENT_REJECT_MESSAGE;
-          resolve19({ behavior: "ask", message, contentBlocks });
+          resolve20({ behavior: "ask", message, contentBlocks });
         }
       });
       sendPermissionRequestViaMailbox(request);
-      const pollInterval = setInterval(async (abortController2, cleanup2, resolve20, identity5, request2) => {
+      const pollInterval = setInterval(async (abortController2, cleanup2, resolve21, identity5, request2) => {
         if (abortController2.signal.aborted) {
           cleanup2();
-          resolve20({ behavior: "ask", message: SUBAGENT_REJECT_MESSAGE });
+          resolve21({ behavior: "ask", message: SUBAGENT_REJECT_MESSAGE });
           return;
         }
         const allMessages = await readMailbox(identity5.agentName, identity5.teamName);
@@ -261776,10 +262007,10 @@ function createInProcessCanUseTool(identity4, abortController, onPermissionWaitM
             }
           }
         }
-      }, PERMISSION_POLL_INTERVAL_MS, abortController, cleanup, resolve19, identity4, request);
+      }, PERMISSION_POLL_INTERVAL_MS, abortController, cleanup, resolve20, identity4, request);
       const onAbortListener = () => {
         cleanup();
-        resolve19({ behavior: "ask", message: SUBAGENT_REJECT_MESSAGE });
+        resolve20({ behavior: "ask", message: SUBAGENT_REJECT_MESSAGE });
       };
       abortController.signal.addEventListener("abort", onAbortListener, {
         once: true
@@ -263001,8 +263232,8 @@ function waitForPaneShellReady() {
 }
 function acquirePaneCreationLock() {
   let release;
-  const newLock = new Promise((resolve19) => {
-    release = resolve19;
+  const newLock = new Promise((resolve20) => {
+    release = resolve20;
   });
   const previousLock = paneCreationLock;
   paneCreationLock = newLock;
@@ -263449,8 +263680,8 @@ __export(exports_ITermBackend, {
 });
 function acquirePaneCreationLock2() {
   let release;
-  const newLock = new Promise((resolve19) => {
-    release = resolve19;
+  const newLock = new Promise((resolve20) => {
+    release = resolve20;
   });
   const previousLock = paneCreationLock2;
   paneCreationLock2 = newLock;
@@ -264481,6 +264712,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_NAME2;
+}
+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_external.object({
+    description: exports_external.string().describe("A short (3-5 word) description of the task"),
+    prompt: exports_external.string().describe("The task for the agent to perform"),
+    subagent_type: exports_external.string().optional().describe("The type of specialized agent to use for this task"),
+    model: exports_external.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_external.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_external.object({
+      name: exports_external.string().optional().describe("Name for the spawned agent. Makes it addressable via SendMessage({to: name}) while running."),
+      team_name: exports_external.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_external.object({
+      isolation: exports_external.enum(["worktree"]).optional().describe(WORKTREE_ISOLATION_SCHEMA_DESCRIPTION)
+    });
+    return baseInputSchema().merge(multiAgentInputSchema).extend({
+      cwd: exports_external.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 randomUUID12 } from "crypto";
 function isForkSubagentEnabled() {
@@ -264726,7 +265047,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;
   }
@@ -264741,7 +265066,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}
 
@@ -264755,7 +265080,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}
@@ -264781,12 +265106,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 cached3 = advertisedInputJSONSchemaCache.get(cacheKey);
+  if (cached3)
+    return cached3;
+  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, renderToolResultMessage4, renderToolUseErrorMessage2, renderToolUseMessage4, renderToolUseProgressMessage2, renderToolUseRejectedMessage, renderToolUseTag2, userFacingName2, userFacingNameBackgroundColor, proactiveModule = null, PROGRESS_THRESHOLD_MS = 2000, isBackgroundTasksDisabled, baseInputSchema, fullInputSchema, inputSchema7, outputSchema6, AgentTool;
+var getBackgroundHintJSX, renderGroupedAgentToolUse, renderToolResultMessage4, renderToolUseErrorMessage2, renderToolUseMessage4, renderToolUseProgressMessage2, renderToolUseRejectedMessage, renderToolUseTag2, userFacingName2, userFacingNameBackgroundColor, proactiveModule = null, PROGRESS_THRESHOLD_MS = 2000, isBackgroundTasksDisabled, inputSchema7 = () => buildConfiguredAgentInputSchema(true), outputSchema6, advertisedInputJSONSchemaCache, WORKTREE_AVAILABILITY_CACHE_TTL_MS = 30000, advertisedWorktreeAvailabilityByQuery, agentToolRuntime, AgentTool;
 var init_AgentTool = __esm(() => {
   init_toolRuntime();
   init_promptCategory();
@@ -264805,9 +265175,9 @@ var init_AgentTool = __esm(() => {
   init_debug();
   init_envUtils();
   init_errors2();
+  init_zodToJsonSchema2();
   init_messages4();
   init_agent();
-  init_PermissionMode();
   init_permissions2();
   init_sdkEventQueue();
   init_sessionStorage();
@@ -264818,11 +265188,14 @@ var init_AgentTool = __esm(() => {
   init_tokens();
   init_uuid();
   init_worktree();
+  init_worktreeAvailability();
   init_toolUIRegistry();
   init_prompt();
   init_spawnMultiAgent();
   init_agentColorManager();
+  init_agentInvocationDedupe();
   init_agentToolUtils();
+  init_inputSchema();
   init_generalPurposeAgent();
   init_constants4();
   init_forkSubagent();
@@ -264843,32 +265216,6 @@ var init_AgentTool = __esm(() => {
     userFacingNameBackgroundColor
   } = lazyUI("Agent"));
   isBackgroundTasksDisabled = isEnvTruthy(resolveEnvVar("DISABLE_BACKGROUND_TASKS"));
-  baseInputSchema = lazySchema(() => exports_external.object({
-    description: exports_external.string().describe("A short (3-5 word) description of the task"),
-    prompt: exports_external.string().describe("The task for the agent to perform"),
-    subagent_type: exports_external.string().optional().describe("The type of specialized agent to use for this task"),
-    model: exports_external.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_external.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_external.object({
-      name: exports_external.string().optional().describe("Name for the spawned agent. Makes it addressable via SendMessage({to: name}) while running."),
-      team_name: exports_external.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_external.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_external.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".')
-    });
-  });
-  inputSchema7 = lazySchema(() => {
-    const schema = fullInputSchema().omit({
-      cwd: true
-    });
-    return isBackgroundTasksDisabled || isForkSubagentEnabled() ? schema.omit({
-      run_in_background: true
-    }) : schema;
-  });
   outputSchema6 = lazySchema(() => {
     const syncOutputSchema = agentToolResultSchema().extend({
       status: exports_external.literal("completed"),
@@ -264884,7 +265231,9 @@ var init_AgentTool = __esm(() => {
     });
     return exports_external.union([syncOutputSchema, asyncOutputSchema]);
   });
-  AgentTool = buildToolRuntime({
+  advertisedInputJSONSchemaCache = new Map;
+  advertisedWorktreeAvailabilityByQuery = new WeakMap;
+  agentToolRuntime = buildToolRuntime({
     async prompt({
       agents,
       tools,
@@ -264914,9 +265263,7 @@ var init_AgentTool = __esm(() => {
     async description() {
       return "Launch a new agent";
     },
-    get inputSchema() {
-      return inputSchema7();
-    },
+    inputSchema: inputSchema7(),
     get outputSchema() {
       return outputSchema6();
     },
@@ -264932,6 +265279,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();
@@ -265168,15 +265519,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;
-            }
-            logForDebugging2("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
+            });
+          }
+          logForDebugging2(`${unavailableMessage} Falling back to the current working directory.`);
         }
       }
       if (isForkPath && worktreeInfo) {
@@ -265769,6 +266121,15 @@ duration_ms: ${data.totalDurationMs}</usage>`
     renderToolUseErrorMessage: renderToolUseErrorMessage2,
     renderGroupedToolUse: renderGroupedAgentToolUse
   });
+  AgentTool = {
+    ...agentToolRuntime,
+    get inputSchema() {
+      return inputSchema7();
+    },
+    get inputJSONSchema() {
+      return getAdvertisedAgentInputJSONSchema();
+    }
+  };
 });
 
 // src/capabilities/diagnostics.ts
@@ -266147,12 +266508,12 @@ var init_LSPDiagnosticRegistry = __esm(() => {
 });
 
 // src/capabilities/plugins/lspPluginIntegration.ts
-import { join as join57, relative as relative7, resolve as resolve19 } from "path";
+import { join as join57, relative as relative7, resolve as resolve20 } from "path";
 function validatePathWithinPlugin(pluginPath, relativePath) {
-  const resolvedPluginPath = resolve19(pluginPath);
-  const resolvedFilePath = resolve19(pluginPath, relativePath);
+  const resolvedPluginPath = resolve20(pluginPath);
+  const resolvedFilePath = resolve20(pluginPath, relativePath);
   const rel = relative7(resolvedPluginPath, resolvedFilePath);
-  if (rel.startsWith("..") || resolve19(rel) === rel) {
+  if (rel.startsWith("..") || resolve20(rel) === rel) {
     return null;
   }
   return resolvedFilePath;
@@ -267386,8 +267747,8 @@ var require_semaphore = __commonJS((exports) => {
       this._waiting = [];
     }
     lock(thunk) {
-      return new Promise((resolve20, reject2) => {
-        this._waiting.push({ thunk, resolve: resolve20, reject: reject2 });
+      return new Promise((resolve21, reject2) => {
+        this._waiting.push({ thunk, resolve: resolve21, reject: reject2 });
         this.runNext();
       });
     }
@@ -268878,9 +269239,9 @@ ${JSON.stringify(message, null, 4)}`);
         if (typeof cancellationStrategy.sender.enableCancellation === "function") {
           cancellationStrategy.sender.enableCancellation(requestMessage);
         }
-        return new Promise(async (resolve20, reject2) => {
+        return new Promise(async (resolve21, reject2) => {
           const resolveWithCleanup = (r) => {
-            resolve20(r);
+            resolve21(r);
             cancellationStrategy.sender.cleanup(id);
             disposable?.dispose();
           };
@@ -269289,10 +269650,10 @@ var require_ril = __commonJS((exports) => {
       return api_1.Disposable.create(() => this.stream.off("end", listener2));
     }
     write(data, encoding) {
-      return new Promise((resolve20, reject2) => {
+      return new Promise((resolve21, reject2) => {
         const callback = (error41) => {
           if (error41 === undefined || error41 === null) {
-            resolve20();
+            resolve21();
           } else {
             reject2(error41);
           }
@@ -269551,10 +269912,10 @@ var require_main = __commonJS((exports) => {
   exports.generateRandomPipeName = generateRandomPipeName;
   function createClientPipeTransport(pipeName, encoding = "utf-8") {
     let connectResolve;
-    const connected = new Promise((resolve20, _reject) => {
-      connectResolve = resolve20;
+    const connected = new Promise((resolve21, _reject) => {
+      connectResolve = resolve21;
     });
-    return new Promise((resolve20, reject2) => {
+    return new Promise((resolve21, reject2) => {
       let server = (0, net_1.createServer)((socket) => {
         server.close();
         connectResolve([
@@ -269565,7 +269926,7 @@ var require_main = __commonJS((exports) => {
       server.on("error", reject2);
       server.listen(pipeName, () => {
         server.removeListener("error", reject2);
-        resolve20({
+        resolve21({
           onConnected: () => {
             return connected;
           }
@@ -269584,10 +269945,10 @@ var require_main = __commonJS((exports) => {
   exports.createServerPipeTransport = createServerPipeTransport;
   function createClientSocketTransport(port, encoding = "utf-8") {
     let connectResolve;
-    const connected = new Promise((resolve20, _reject) => {
-      connectResolve = resolve20;
+    const connected = new Promise((resolve21, _reject) => {
+      connectResolve = resolve21;
     });
-    return new Promise((resolve20, reject2) => {
+    return new Promise((resolve21, reject2) => {
       const server = (0, net_1.createServer)((socket) => {
         server.close();
         connectResolve([
@@ -269598,7 +269959,7 @@ var require_main = __commonJS((exports) => {
       server.on("error", reject2);
       server.listen(port, "127.0.0.1", () => {
         server.removeListener("error", reject2);
-        resolve20({
+        resolve21({
           onConnected: () => {
             return connected;
           }
@@ -269677,10 +270038,10 @@ function createLSPClient(serverName, onCrash) {
           throw new Error("LSP server process stdio not available");
         }
         const spawnedProcess = process14;
-        await new Promise((resolve20, reject2) => {
+        await new Promise((resolve21, reject2) => {
           const onSpawn = () => {
             cleanup();
-            resolve20();
+            resolve21();
           };
           const onError = (error41) => {
             cleanup();
@@ -273545,7 +273906,7 @@ ${filenames.join(`
 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 extname7, isAbsolute as isAbsolute18, resolve as resolve21 } from "path";
+import { extname as extname7, isAbsolute as isAbsolute18, resolve as resolve22 } from "path";
 var getToolUseSummary6, renderToolResultMessage9, renderToolUseErrorMessage7, renderToolUseMessage9, renderToolUseRejectedMessage4, inputSchema12, outputSchema11, NotebookEditTool;
 var init_NotebookEditTool = __esm(() => {
   init_fileHistory();
@@ -273660,7 +274021,7 @@ var init_NotebookEditTool = __esm(() => {
     renderToolUseErrorMessage: renderToolUseErrorMessage7,
     renderToolResultMessage: renderToolResultMessage9,
     async validateInput({ notebook_path, cell_type, cell_id, edit_mode = "replace" }, toolUseContext) {
-      const fullPath = isAbsolute18(notebook_path) ? notebook_path : resolve21(getCwd3(), notebook_path);
+      const fullPath = isAbsolute18(notebook_path) ? notebook_path : resolve22(getCwd3(), notebook_path);
       if (fullPath.startsWith("\\\\") || fullPath.startsWith("//")) {
         return { result: true };
       }
@@ -273759,7 +274120,7 @@ var init_NotebookEditTool = __esm(() => {
       cell_type,
       edit_mode: originalEditMode
     }, { readFileState, updateFileHistoryState }, _, parentMessage) {
-      const fullPath = isAbsolute18(notebook_path) ? notebook_path : resolve21(getCwd3(), notebook_path);
+      const fullPath = isAbsolute18(notebook_path) ? notebook_path : resolve22(getCwd3(), notebook_path);
       if (fileHistoryEnabled()) {
         await fileHistoryTrackEdit(updateFileHistoryState, fullPath, parentMessage.uuid);
       }
@@ -274090,7 +274451,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;
@@ -274109,7 +274470,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;
   }
@@ -275066,8 +275427,8 @@ function registerAgentForeground({
     diskLoaded: false
   };
   let resolveBackgroundSignal;
-  const backgroundSignal = new Promise((resolve22) => {
-    resolveBackgroundSignal = resolve22;
+  const backgroundSignal = new Promise((resolve23) => {
+    resolveBackgroundSignal = resolve23;
   });
   backgroundSignalResolvers.set(agentId, resolveBackgroundSignal);
   registerTask(taskState, setAppState);
@@ -275179,6 +275540,67 @@ 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 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(`
@@ -275307,26 +275729,9 @@ async function spawnShellTask(input, context4) {
     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;
@@ -275349,12 +275754,43 @@ async function spawnShellTask(input, context4) {
     });
     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) {
@@ -275578,6 +276014,7 @@ var init_LocalShellTask = __esm(() => {
   init_LocalAgentTask();
   init_killShellTasks();
   init_fsOperations();
+  init_backgroundTaskScope();
   PROMPT_PATTERNS = [
     /\(y\/n\)/i,
     /\[y\/n\]/i,
@@ -276647,8 +277084,8 @@ async function* runShellCommand({
   let assistantAutoBackgrounded = false;
   let resolveProgress = null;
   function createProgressSignal() {
-    return new Promise((resolve22) => {
-      resolveProgress = () => resolve22(null);
+    return new Promise((resolve23) => {
+      resolveProgress = () => resolve23(null);
     });
   }
   const shouldAutoBackground = !isBackgroundTasksDisabled2 && isAutobackgroundingAllowed(command);
@@ -276659,10 +277096,10 @@ async function* runShellCommand({
       fullOutput = allLines;
       lastTotalLines = totalLines;
       lastTotalBytes = isIncomplete ? totalBytes : 0;
-      const resolve22 = resolveProgress;
-      if (resolve22) {
+      const resolve23 = resolveProgress;
+      if (resolve23) {
         resolveProgress = null;
-        resolve22();
+        resolve23();
       }
     },
     preventCwdChanges,
@@ -276700,10 +277137,10 @@ async function* runShellCommand({
     }
     spawnBackgroundTask().then((shellId) => {
       backgroundShellId = shellId;
-      const resolve22 = resolveProgress;
-      if (resolve22) {
+      const resolve23 = resolveProgress;
+      if (resolve23) {
         resolveProgress = null;
-        resolve22();
+        resolve23();
       }
       logEvent(eventName, {
         command_type: getCommandTypeForLogging(command)
@@ -276735,8 +277172,8 @@ async function* runShellCommand({
   const startTime = Date.now();
   let foregroundTaskId = undefined;
   {
-    const initialResult = await Promise.race([resultPromise, new Promise((resolve22) => {
-      const t = setTimeout((r) => r(null), PROGRESS_THRESHOLD_MS2, resolve22);
+    const initialResult = await Promise.race([resultPromise, new Promise((resolve23) => {
+      const t = setTimeout((r) => r(null), PROGRESS_THRESHOLD_MS2, resolve23);
       t.unref();
     })]);
     if (initialResult !== null) {
@@ -278259,7 +278696,7 @@ var init_parser5 = __esm(() => {
 });
 
 // src/capabilities/tools/PowerShellTool/gitSafety.ts
-import { basename as basename15, posix as posix5, resolve as resolve22, sep as sep15 } from "path";
+import { basename as basename15, posix as posix5, resolve as resolve23, sep as sep15 } from "path";
 function resolveCwdReentry(normalized) {
   if (!normalized.startsWith("../../../tools"))
     return normalized;
@@ -278307,7 +278744,7 @@ function normalizeGitPathArg(arg) {
 }
 function resolveEscapingPathToCwdRelative(n2) {
   const cwd = getCwd3();
-  const abs = resolve22(cwd, n2);
+  const abs = resolve23(cwd, n2);
   const cwdWithSep = cwd.endsWith(sep15) ? cwd : cwd + sep15;
   const absLower = abs.toLowerCase();
   const cwdLower = cwd.toLowerCase();
@@ -279580,7 +280017,7 @@ var init_modeValidation2 = __esm(() => {
 
 // src/capabilities/tools/PowerShellTool/pathValidation.ts
 import { homedir as homedir20 } from "os";
-import { isAbsolute as isAbsolute19, resolve as resolve23 } from "path";
+import { isAbsolute as isAbsolute19, resolve as resolve24 } from "path";
 function matchesParam(paramLower, paramList) {
   for (const p of paramList) {
     if (p === paramLower || paramLower.length > 1 && p.startsWith(paramLower)) {
@@ -279688,7 +280125,7 @@ function checkDenyRuleForGuessedPath(strippedPath, cwd, toolPermissionContext, o
   if (!strippedPath || strippedPath.includes("\x00"))
     return null;
   const tildeExpanded = expandTilde2(strippedPath);
-  const abs = isAbsolute19(tildeExpanded) ? tildeExpanded : resolve23(cwd, tildeExpanded);
+  const abs = isAbsolute19(tildeExpanded) ? tildeExpanded : resolve24(cwd, tildeExpanded);
   const { resolvedPath } = safeResolvePath(getFsImplementation(), abs);
   const permissionType = operationType === "read" ? "read" : "edit";
   const denyRule = matchingRuleForInput(resolvedPath, toolPermissionContext, permissionType, "deny");
@@ -279778,7 +280215,7 @@ function validatePath2(filePath, cwd, toolPermissionContext, operationType) {
       };
     }
     if (containsPathTraversal(normalizedPath)) {
-      const absolutePath2 = isAbsolute19(normalizedPath) ? normalizedPath : resolve23(cwd, normalizedPath);
+      const absolutePath2 = isAbsolute19(normalizedPath) ? normalizedPath : resolve24(cwd, normalizedPath);
       const { resolvedPath: resolvedPath3, isCanonical: isCanonical2 } = safeResolvePath(getFsImplementation(), absolutePath2);
       const result2 = isPathAllowed2(resolvedPath3, toolPermissionContext, operationType, isCanonical2 ? [resolvedPath3] : undefined);
       return {
@@ -279788,7 +280225,7 @@ function validatePath2(filePath, cwd, toolPermissionContext, operationType) {
       };
     }
     const basePath = getGlobBaseDirectory2(normalizedPath);
-    const absoluteBasePath = isAbsolute19(basePath) ? basePath : resolve23(cwd, basePath);
+    const absoluteBasePath = isAbsolute19(basePath) ? basePath : resolve24(cwd, basePath);
     const { resolvedPath: resolvedPath2 } = safeResolvePath(getFsImplementation(), absoluteBasePath);
     const permissionType = operationType === "read" ? "read" : "edit";
     const denyRule = matchingRuleForInput(resolvedPath2, toolPermissionContext, permissionType, "deny");
@@ -279808,7 +280245,7 @@ function validatePath2(filePath, cwd, toolPermissionContext, operationType) {
       }
     };
   }
-  const absolutePath = isAbsolute19(normalizedPath) ? normalizedPath : resolve23(cwd, normalizedPath);
+  const absolutePath = isAbsolute19(normalizedPath) ? normalizedPath : resolve24(cwd, normalizedPath);
   const { resolvedPath, isCanonical } = safeResolvePath(getFsImplementation(), absolutePath);
   const result = isPathAllowed2(resolvedPath, toolPermissionContext, operationType, isCanonical ? [resolvedPath] : undefined);
   return {
@@ -281738,7 +282175,7 @@ var init_powershellSecurity = __esm(() => {
 var POWERSHELL_TOOL_NAME3 = "PowerShell";
 
 // src/capabilities/tools/PowerShellTool/powershellPermissions.ts
-import { resolve as resolve24 } from "path";
+import { resolve as resolve25 } from "path";
 async function extractCommandName(command) {
   const trimmed = command.trim();
   if (!trimmed) {
@@ -282351,7 +282788,7 @@ async function powershellToolHasPermission(input, context4) {
     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 && resolve24(getCwd3(), target) === getCwd3()) {
+      if (target && resolve25(getCwd3(), target) === getCwd3()) {
         return false;
       }
     }
@@ -282747,8 +283184,8 @@ async function* runPowerShellCommand({
   let assistantAutoBackgrounded = false;
   let resolveProgress = null;
   function createProgressSignal() {
-    return new Promise((resolve25) => {
-      resolveProgress = () => resolve25(null);
+    return new Promise((resolve26) => {
+      resolveProgress = () => resolve26(null);
     });
   }
   const shouldAutoBackground = !isBackgroundTasksDisabled3 && isAutobackgroundingAllowed2(command);
@@ -282818,10 +283255,10 @@ async function* runPowerShellCommand({
     }
     spawnBackgroundTask().then((shellId) => {
       backgroundShellId = shellId;
-      const resolve25 = resolveProgress;
-      if (resolve25) {
+      const resolve26 = resolveProgress;
+      if (resolve26) {
         resolveProgress = null;
-        resolve25();
+        resolve26();
       }
       logEvent(eventName, {
         command_type: getCommandTypeForLogging2(command)
@@ -282859,7 +283296,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((resolve25) => setTimeout((r) => r(null), timeUntilNextProgress, resolve25).unref()), progressSignal]);
+      const result = await Promise.race([resultPromise, new Promise((resolve26) => setTimeout((r) => r(null), timeUntilNextProgress, resolve26).unref()), progressSignal]);
       if (result !== null) {
         if (result.backgroundTaskId !== undefined) {
           markTaskNotified2(result.backgroundTaskId, setAppState);
@@ -284828,10 +285265,10 @@ var init_marketplaceHelpers = __esm(() => {
 });
 
 // src/capabilities/plugins/officialMarketplaceGcs.ts
-import { dirname as dirname31, join as join65, resolve as resolve25, sep as sep16 } from "path";
+import { dirname as dirname31, join as join65, resolve as resolve26, sep as sep16 } from "path";
 async function fetchOfficialMarketplaceFromGcs(installLocation, marketplacesCacheDir) {
-  const cacheDir = resolve25(marketplacesCacheDir);
-  const resolvedLoc = resolve25(installLocation);
+  const cacheDir = resolve26(marketplacesCacheDir);
+  const resolvedLoc = resolve26(installLocation);
   if (resolvedLoc !== cacheDir && !resolvedLoc.startsWith(cacheDir + sep16)) {
     logForDebugging2(`fetchOfficialMarketplaceFromGcs: refusing path outside cache dir: ${installLocation}`, { level: "error" });
     return null;
@@ -284948,7 +285385,7 @@ var init_officialMarketplaceGcs = __esm(() => {
 });
 
 // src/capabilities/plugins/marketplaceManager.ts
-import { basename as basename19, dirname as dirname32, isAbsolute as isAbsolute20, join as join66, resolve as resolve26, sep as sep17 } from "path";
+import { basename as basename19, dirname as dirname32, isAbsolute as isAbsolute20, join as join66, resolve as resolve27, sep as sep17 } from "path";
 function getKnownMarketplacesFile() {
   return join66(getPluginsDirectory(), "known_marketplaces.json");
 }
@@ -285626,14 +286063,14 @@ async function loadAndCacheMarketplace(source, onProgress) {
         throw new Error("NPM marketplace sources not yet implemented");
       }
       case "file": {
-        const absPath = resolve26(source.path);
+        const absPath = resolve27(source.path);
         marketplacePath = absPath;
         temporaryCachePath = dirname32(dirname32(absPath));
         cleanupNeeded = false;
         break;
       }
       case "directory": {
-        const absPath = resolve26(source.path);
+        const absPath = resolve27(source.path);
         marketplacePath = join66(absPath, ".claude-plugin", "marketplace.json");
         temporaryCachePath = absPath;
         cleanupNeeded = false;
@@ -285665,8 +286102,8 @@ async function loadAndCacheMarketplace(source, onProgress) {
       throw new Error(`Failed to parse marketplace file at ${marketplacePath}: ${errorMessage(e)}`);
     }
     const finalCachePath = join66(cacheDir, marketplace.name);
-    const resolvedFinal = resolve26(finalCachePath);
-    const resolvedCacheDir = resolve26(cacheDir);
+    const resolvedFinal = resolve27(finalCachePath);
+    const resolvedCacheDir = resolve27(cacheDir);
     if (!resolvedFinal.startsWith(resolvedCacheDir + sep17)) {
       throw new Error(`Marketplace name '${marketplace.name}' resolves to a path outside the cache directory`);
     }
@@ -285703,7 +286140,7 @@ Technical details: ${errorMsg}`);
 async function addMarketplaceSource(source, onProgress) {
   let resolvedSource = source;
   if (isLocalMarketplaceSource(source) && !isAbsolute20(source.path)) {
-    resolvedSource = { ...source, path: resolve26(source.path) };
+    resolvedSource = { ...source, path: resolve27(source.path) };
   }
   if (!isSourceAllowedByPolicy(resolvedSource)) {
     if (isSourceInBlocklist(resolvedSource)) {
@@ -285751,9 +286188,9 @@ Tip: The shorthand "${resolvedSource.repo}" assumes github.com. ` + `For interna
     }
     logForDebugging2(`Marketplace '${marketplace.name}' exists with different source — overwriting`);
     if (!isLocalMarketplaceSource(oldEntry.source)) {
-      const cacheDir = resolve26(getMarketplacesCacheDir());
-      const resolvedOld = resolve26(oldEntry.installLocation);
-      const resolvedNew = resolve26(cachePath);
+      const cacheDir = resolve27(getMarketplacesCacheDir());
+      const resolvedOld = resolve27(oldEntry.installLocation);
+      const resolvedNew = resolve27(cachePath);
       if (resolvedOld === resolvedNew) {} else if (resolvedOld === cacheDir || resolvedOld.startsWith(cacheDir + sep17)) {
         const fs2 = getFsImplementation();
         await fs2.rm(oldEntry.installLocation, { recursive: true, force: true });
@@ -285980,8 +286417,8 @@ async function refreshMarketplace(name, onProgress, options2) {
       throw new Error(`Marketplace '${name}' is seed-managed (${seedDir}) and its content is ` + `controlled by the seed image. To update: ask your admin to update the seed.`);
     }
     if (!isLocalMarketplaceSource(source)) {
-      const cacheDir = resolve26(getMarketplacesCacheDir());
-      const resolvedLoc = resolve26(installLocation);
+      const cacheDir = resolve27(getMarketplacesCacheDir());
+      const resolvedLoc = resolve27(installLocation);
       if (resolvedLoc !== cacheDir && !resolvedLoc.startsWith(cacheDir + sep17)) {
         throw new Error(`Marketplace '${name}' has a corrupted installLocation ` + `(${installLocation}) — expected a path inside ${cacheDir}. ` + `This can happen after cross-platform path writes or manual edits ` + `to known_marketplaces.json. ` + `Run: claude plugin marketplace remove "${name}" and re-add it.`);
       }
@@ -286799,14 +287236,14 @@ var init_pluginVersioning = __esm(() => {
 
 // src/capabilities/plugins/pluginInstallationHelpers.ts
 import { randomBytes as randomBytes7 } from "crypto";
-import { dirname as dirname34, join as join68, resolve as resolve27, sep as sep19 } from "path";
+import { dirname as dirname34, join as join68, resolve as resolve28, sep as sep19 } from "path";
 function getCurrentTimestamp() {
   return new Date().toISOString();
 }
 function validatePathWithinBase(basePath, relativePath) {
-  const resolvedPath = resolve27(basePath, relativePath);
-  const normalizedBase = resolve27(basePath) + sep19;
-  if (!resolvedPath.startsWith(normalizedBase) && resolvedPath !== resolve27(basePath)) {
+  const resolvedPath = resolve28(basePath, relativePath);
+  const normalizedBase = resolve28(basePath) + sep19;
+  if (!resolvedPath.startsWith(normalizedBase) && resolvedPath !== resolve28(basePath)) {
     throw new Error(`Path traversal detected: "${relativePath}" would escape the base directory`);
   }
   return resolvedPath;
@@ -287046,7 +287483,7 @@ var init_pluginInstallationHelpers = __esm(() => {
 });
 
 // src/capabilities/plugins/pluginLoader.ts
-import { basename as basename20, dirname as dirname35, join as join69, relative as relative11, resolve as resolve28, sep as sep20 } from "path";
+import { basename as basename20, dirname as dirname35, join as join69, relative as relative11, resolve as resolve29, sep as sep20 } from "path";
 function getPluginCachePath() {
   return join69(getPluginsDirectory(), "cache");
 }
@@ -288400,7 +288837,7 @@ async function loadSessionOnlyPlugins(sessionPluginPaths) {
   const errors4 = [];
   for (const [index, pluginPath] of sessionPluginPaths.entries()) {
     try {
-      const resolvedPath = resolve28(pluginPath);
+      const resolvedPath = resolve29(pluginPath);
       if (!await pathExists(resolvedPath)) {
         logForDebugging2(`Plugin path does not exist: ${resolvedPath}, skipping`, { level: "warn" });
         errors4.push({
@@ -290258,14 +290695,14 @@ function waitForCallback(port, expectedState, abortSignal, onListening) {
       abortHandler = null;
     }
   };
-  return new Promise((resolve29, reject2) => {
+  return new Promise((resolve30, reject2) => {
     let resolved = false;
     const resolveOnce = (v) => {
       if (resolved)
         return;
       resolved = true;
       cleanup();
-      resolve29(v);
+      resolve30(v);
     };
     const rejectOnce = (e) => {
       if (resolved)
@@ -290871,13 +291308,13 @@ async function performMCPOAuthFlow(serverName, serverConfig, onAuthorizationUrl,
       }
       logMCPDebug(serverName, `MCP OAuth server cleaned up`);
     };
-    const authorizationCode = await new Promise((resolve29, reject2) => {
+    const authorizationCode = await new Promise((resolve30, reject2) => {
       let resolved = false;
       const resolveOnce = (code) => {
         if (resolved)
           return;
         resolved = true;
-        resolve29(code);
+        resolve30(code);
       };
       const rejectOnce = (error41) => {
         if (resolved)
@@ -291692,7 +292129,7 @@ async function readClientSecret() {
   if (!process.stdin.isTTY) {
     throw new Error("No TTY available to prompt for client secret. Set MCP_CLIENT_SECRET env var instead.");
   }
-  return new Promise((resolve29, reject2) => {
+  return new Promise((resolve30, reject2) => {
     process.stderr.write("Enter OAuth client secret: ");
     process.stdin.setRawMode?.(true);
     let secret = "";
@@ -291704,7 +292141,7 @@ async function readClientSecret() {
         process.stdin.removeListener("data", onData);
         process.stderr.write(`
 `);
-        resolve29(secret);
+        resolve30(secret);
       } else if (c6 === "\x03") {
         process.stdin.setRawMode?.(false);
         process.stdin.removeListener("data", onData);
@@ -291855,8 +292292,8 @@ function createMcpAuthTool(serverName, config2) {
       }
       const sseOrHttpConfig = config2;
       let resolveAuthUrl;
-      const authUrlPromise = new Promise((resolve29) => {
-        resolveAuthUrl = resolve29;
+      const authUrlPromise = new Promise((resolve30) => {
+        resolveAuthUrl = resolve30;
       });
       const controller = new AbortController;
       const { setAppState } = context4;
@@ -292338,15 +292775,15 @@ class WebSocketTransport {
   isBun = typeof Bun !== "undefined";
   constructor(ws) {
     this.ws = ws;
-    this.opened = new Promise((resolve29, reject2) => {
+    this.opened = new Promise((resolve30, reject2) => {
       if (this.ws.readyState === WS_OPEN) {
-        resolve29();
+        resolve30();
       } else if (this.isBun) {
         const nws = this.ws;
         const onOpen = () => {
           nws.removeEventListener("open", onOpen);
           nws.removeEventListener("error", onError);
-          resolve29();
+          resolve30();
         };
         const onError = (event) => {
           nws.removeEventListener("open", onOpen);
@@ -292359,7 +292796,7 @@ class WebSocketTransport {
       } else {
         const nws = this.ws;
         nws.on("open", () => {
-          resolve29();
+          resolve30();
         });
         nws.on("error", (error41) => {
           logForDiagnosticsNoPII("error", "mcp_websocket_connect_fail");
@@ -292458,12 +292895,12 @@ class WebSocketTransport {
       if (this.isBun) {
         this.ws.send(json2);
       } else {
-        await new Promise((resolve29, reject2) => {
+        await new Promise((resolve30, reject2) => {
           this.ws.send(json2, (error41) => {
             if (error41) {
               reject2(error41);
             } else {
-              resolve29();
+              resolve30();
             }
           });
         });
@@ -292725,9 +293162,9 @@ function registerElicitationHandler(client, serverName, setAppState) {
           return hookResponse;
         }
         const elicitationId = mode === "url" && "elicitationId" in request.params ? request.params.elicitationId : undefined;
-        const response = new Promise((resolve29) => {
+        const response = new Promise((resolve30) => {
           const onAbort = () => {
-            resolve29({ action: "cancel" });
+            resolve30({ action: "cancel" });
           };
           if (extra.signal.aborted) {
             onAbort();
@@ -292751,7 +293188,7 @@ function registerElicitationHandler(client, serverName, setAppState) {
                       mode,
                       action: result2.action
                     });
-                    resolve29(result2);
+                    resolve30(result2);
                   }
                 }
               ]
@@ -296437,8 +296874,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;
   }
@@ -296446,11 +296883,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(dirname37(cachePath), { recursive: true });
-    await getFsImplementation().writeFile(cachePath, jsonStringify(cache2));
+    await getFsImplementation().writeFile(cachePath, jsonStringify(cache3));
     authCachePromise = null;
   }).catch(() => {});
 }
@@ -296770,12 +297207,12 @@ async function getMcpToolsCommandsAndResources(onConnectionAttempt, mcpConfigs)
   ]);
 }
 function prefetchAllMcpResources(mcpConfigs) {
-  return new Promise((resolve29) => {
+  return new Promise((resolve30) => {
     let pendingCount = 0;
     let completedCount = 0;
     pendingCount = Object.keys(mcpConfigs).length;
     if (pendingCount === 0) {
-      resolve29({
+      resolve30({
         clients: [],
         tools: [],
         commands: []
@@ -296800,7 +297237,7 @@ function prefetchAllMcpResources(mcpConfigs) {
           commands_count: commands.length,
           commands_metadata_length: commandsMetadataLength
         });
-        resolve29({
+        resolve30({
           clients,
           tools,
           commands
@@ -296808,7 +297245,7 @@ function prefetchAllMcpResources(mcpConfigs) {
       }
     }, mcpConfigs).catch((error41) => {
       logMCPError("prefetchAllMcpResources", `Failed to get MCP resources: ${errorMessage(error41)}`);
-      resolve29({
+      resolve30({
         clients: [],
         tools: [],
         commands: []
@@ -296988,9 +297425,9 @@ async function callMCPToolWithUrlElicitationRetry({
             actionLabel: "Retry now",
             showCancel: true
           };
-          userResult = await new Promise((resolve29) => {
+          userResult = await new Promise((resolve30) => {
             const onAbort = () => {
-              resolve29({ action: "cancel" });
+              resolve30({ action: "cancel" });
             };
             if (signal.aborted) {
               onAbort();
@@ -297013,14 +297450,14 @@ async function callMCPToolWithUrlElicitationRetry({
                         return;
                       }
                       signal.removeEventListener("abort", onAbort);
-                      resolve29(result);
+                      resolve30(result);
                     },
                     onWaitingDismiss: (action) => {
                       signal.removeEventListener("abort", onAbort);
                       if (action === "retry") {
-                        resolve29({ action: "accept" });
+                        resolve30({ action: "accept" });
                       } else {
-                        resolve29({ action: "cancel" });
+                        resolve30({ action: "cancel" });
                       }
                     }
                   }
@@ -297774,7 +298211,7 @@ var init_client5 = __esm(() => {
                 logMCPDebug(name, `Error sending SIGINT: ${error41}`);
                 return;
               }
-              await new Promise(async (resolve29) => {
+              await new Promise(async (resolve30) => {
                 let resolved = false;
                 const checkInterval = setInterval(() => {
                   try {
@@ -297785,7 +298222,7 @@ var init_client5 = __esm(() => {
                       clearInterval(checkInterval);
                       clearTimeout(failsafeTimeout);
                       logMCPDebug(name, "MCP server process exited cleanly");
-                      resolve29();
+                      resolve30();
                     }
                   }
                 }, 50);
@@ -297794,7 +298231,7 @@ var init_client5 = __esm(() => {
                     resolved = true;
                     clearInterval(checkInterval);
                     logMCPDebug(name, "Cleanup timeout reached, stopping process monitoring");
-                    resolve29();
+                    resolve30();
                   }
                 }, 600);
                 try {
@@ -297810,14 +298247,14 @@ var init_client5 = __esm(() => {
                         resolved = true;
                         clearInterval(checkInterval);
                         clearTimeout(failsafeTimeout);
-                        resolve29();
+                        resolve30();
                         return;
                       }
                     } catch {
                       resolved = true;
                       clearInterval(checkInterval);
                       clearTimeout(failsafeTimeout);
-                      resolve29();
+                      resolve30();
                       return;
                     }
                     await sleep2(400);
@@ -297834,7 +298271,7 @@ var init_client5 = __esm(() => {
                         resolved = true;
                         clearInterval(checkInterval);
                         clearTimeout(failsafeTimeout);
-                        resolve29();
+                        resolve30();
                       }
                     }
                   }
@@ -297842,14 +298279,14 @@ var init_client5 = __esm(() => {
                     resolved = true;
                     clearInterval(checkInterval);
                     clearTimeout(failsafeTimeout);
-                    resolve29();
+                    resolve30();
                   }
                 } catch {
                   if (!resolved) {
                     resolved = true;
                     clearInterval(checkInterval);
                     clearTimeout(failsafeTimeout);
-                    resolve29();
+                    resolve30();
                   }
                 }
               });
@@ -298352,7 +298789,7 @@ var init_idePathConversion = () => {};
 // src/capabilities/ide.ts
 import { createConnection } from "net";
 import * as os4 from "os";
-import { basename as basename21, join as join76, sep as pathSeparator, resolve as resolve29 } from "path";
+import { basename as basename21, join as join76, sep as pathSeparator, resolve as resolve30 } from "path";
 function isProcessRunning2(pid) {
   try {
     process.kill(pid, 0);
@@ -298463,7 +298900,7 @@ async function readIdeLockfile(path13) {
 }
 async function checkIdeConnection(host, port, timeout = 500) {
   try {
-    return new Promise((resolve30) => {
+    return new Promise((resolve31) => {
       const socket = createConnection({
         host,
         port,
@@ -298471,14 +298908,14 @@ async function checkIdeConnection(host, port, timeout = 500) {
       });
       socket.on("connect", () => {
         socket.destroy();
-        resolve30(true);
+        resolve31(true);
       });
       socket.on("error", () => {
-        resolve30(false);
+        resolve31(false);
       });
       socket.on("timeout", () => {
         socket.destroy();
-        resolve30(false);
+        resolve31(false);
       });
     });
   } catch (_) {
@@ -298496,7 +298933,7 @@ async function getIdeLockfilesPaths() {
   if (windowsHome) {
     const converter = new WindowsToWSLConverter(process.env.WSL_DISTRO_NAME);
     const wslPath = converter.toLocalPath(windowsHome);
-    paths2.push(resolve29(wslPath, BUILT_IN_BINDINGS.claude.configDir, PATH_SEGMENTS.runtime.ideDir));
+    paths2.push(resolve30(wslPath, BUILT_IN_BINDINGS.claude.configDir, PATH_SEGMENTS.runtime.ideDir));
   }
   try {
     const usersDir = "/mnt/c/Users";
@@ -298640,14 +299077,14 @@ async function detectIDEs(includeInvalid) {
             if (!checkWSLDistroMatch(idePath, process.env.WSL_DISTRO_NAME)) {
               return false;
             }
-            const resolvedOriginal = resolve29(localPath).normalize("NFC");
+            const resolvedOriginal = resolve30(localPath).normalize("NFC");
             if (cwd === resolvedOriginal || cwd.startsWith(resolvedOriginal + pathSeparator)) {
               return true;
             }
             const converter = new WindowsToWSLConverter(process.env.WSL_DISTRO_NAME);
             localPath = converter.toLocalPath(idePath);
           }
-          const resolvedPath = resolve29(localPath).normalize("NFC");
+          const resolvedPath = resolve30(localPath).normalize("NFC");
           if (getPlatform() === "windows") {
             const normalizedCwd = cwd.replace(/^[a-zA-Z]:/, (match) => match.toUpperCase());
             const normalizedResolvedPath = resolvedPath.replace(/^[a-zA-Z]:/, (match) => match.toUpperCase());
@@ -299040,9 +299477,9 @@ async function installFromArtifactory(command) {
         responseType: "stream"
       });
       const writeStream = getFsImplementation().createWriteStream(tempVsixPath);
-      await new Promise((resolve30, reject2) => {
+      await new Promise((resolve31, reject2) => {
         vsixResponse.data.pipe(writeStream);
-        writeStream.on("finish", resolve30);
+        writeStream.on("finish", resolve31);
         writeStream.on("error", reject2);
       });
       await sleep2(500);
@@ -299758,7 +300195,7 @@ var init_findRelevantMemories = __esm(() => {
 });
 
 // src/session/attachments.ts
-import { dirname as dirname38, parse as parse12, relative as relative12, resolve as resolve30 } from "path";
+import { dirname as dirname38, parse as parse12, relative as relative12, resolve as resolve31 } from "path";
 import { randomUUID as randomUUID16 } from "crypto";
 async function getAttachments(input, toolUseContext, ideSelection, queuedCommands, messages, querySource, options2) {
   if (isEnvTruthy(resolveEnvVar("DISABLE_ATTACHMENTS")) || isEnvTruthy(resolveEnvVar("SIMPLE"))) {
@@ -300136,7 +300573,7 @@ async function getSelectedLinesFromIDE(ideSelection, toolUseContext) {
   ];
 }
 function getDirectoriesToProcess(targetPath, originalCwd) {
-  const targetDir = dirname38(resolve30(targetPath));
+  const targetDir = dirname38(resolve31(targetPath));
   const nestedDirs = [];
   let currentDir = targetDir;
   while (currentDir !== originalCwd && currentDir !== parse12(currentDir).root) {
@@ -300592,7 +301029,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(resolve30(skillDir, name, "SKILL.md"));
+            await getFsImplementation().stat(resolve31(skillDir, name, "SKILL.md"));
             return name;
           } catch {
             return null;
@@ -302931,10 +303368,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);
@@ -304421,21 +304858,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
 var exports_toolSearch = {};
 __export(exports_toolSearch, {
@@ -304565,7 +304987,8 @@ async function calculateDeferredToolDescriptionChars(tools, getToolPermissionCon
       tools,
       agents
     });
-    const inputSchema17 = tool.inputJSONSchema ? jsonStringify(tool.inputJSONSchema) : tool.inputSchema ? jsonStringify(zodToJsonSchema3(tool.inputSchema)) : "";
+    const inputJSONSchema = tool.inputJSONSchema;
+    const inputSchema17 = inputJSONSchema ? jsonStringify(inputJSONSchema) : tool.inputSchema ? jsonStringify(zodToJsonSchema3(tool.inputSchema)) : "";
     return tool.name.length + description.length + inputSchema17.length;
   }));
   return sizes.reduce((total, size) => total + size, 0);
@@ -306264,12 +306687,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);
     }
@@ -306512,11 +306936,13 @@ async function logContextMetrics(mcpConfigs, toolPermissionContext) {
   }
   mcpServersCount = serverNames.size;
   for (const tool of mcpTools) {
-    const schema = "inputJSONSchema" in tool && tool.inputJSONSchema ? tool.inputJSONSchema : zodToJsonSchema3(tool.inputSchema);
+    const inputJSONSchema = tool.inputJSONSchema;
+    const schema = inputJSONSchema ?? zodToJsonSchema3(tool.inputSchema);
     mcpToolsTokens += roughTokenCountEstimation(jsonStringify(schema));
   }
   for (const tool of nonMcpTools) {
-    const schema = "inputJSONSchema" in tool && tool.inputJSONSchema ? tool.inputJSONSchema : zodToJsonSchema3(tool.inputSchema);
+    const inputJSONSchema = tool.inputJSONSchema;
+    const schema = inputJSONSchema ?? zodToJsonSchema3(tool.inputSchema);
     nonMcpToolsTokens += roughTokenCountEstimation(jsonStringify(schema));
   }
   logEvent("tengu_context_size", {
@@ -309470,14 +309896,14 @@ var init_permissions2 = __esm(() => {
 });
 
 // src/lib/addDirValidation.ts
-import { dirname as dirname40, resolve as resolve31 } from "path";
+import { dirname as dirname40, resolve as resolve32 } from "path";
 async function validateDirectoryForWorkspace(directoryPath, permissionContext) {
   if (!directoryPath) {
     return {
       resultType: "emptyPath"
     };
   }
-  const absolutePath = resolve31(expandPath(directoryPath));
+  const absolutePath = resolve32(expandPath(directoryPath));
   try {
     const stats = await getFsImplementation().stat(absolutePath);
     if (!stats.isDirectory()) {
@@ -309539,7 +309965,7 @@ var init_addDirValidation = __esm(() => {
 
 // src/permissions/permissionSetup.ts
 import { relative as relative14 } from "path";
-import { resolve as resolve32 } from "path";
+import { resolve as resolve33 } from "path";
 function isDangerousBashPermission(toolName, ruleContent) {
   if (toolName !== BASH_TOOL_NAME) {
     return false;
@@ -309854,7 +310280,7 @@ function isSymlinkTo({
   originalCwd
 }) {
   const { resolvedPath: resolvedProcessPwd, isSymlink: isProcessPwdSymlink } = safeResolvePath(getFsImplementation(), processPwd);
-  return isProcessPwdSymlink ? resolvedProcessPwd === resolve32(originalCwd) : false;
+  return isProcessPwdSymlink ? resolvedProcessPwd === resolve33(originalCwd) : false;
 }
 function initialPermissionModeFromCLI({
   permissionModeCli,
@@ -310160,7 +310586,7 @@ var init_permissionSetup = __esm(() => {
 
 // src/capabilities/markdownConfigLoader.ts
 import { homedir as homedir23 } from "os";
-import { dirname as dirname41, join as join79, resolve as resolve33, sep as sep21 } from "path";
+import { dirname as dirname41, join as join79, resolve as resolve34, sep as sep21 } from "path";
 function extractDescriptionFromMarkdown(content, defaultDescription = "Custom item") {
   const lines = content.split(`
 `);
@@ -310242,9 +310668,9 @@ function resolveStopBoundary(cwd) {
   return cwdGitRoot;
 }
 function getProjectDirsUpToHome(subdir, cwd) {
-  const home = resolve33(homedir23()).normalize("NFC");
+  const home = resolve34(homedir23()).normalize("NFC");
   const gitRoot = resolveStopBoundary(cwd);
-  let current = resolve33(cwd);
+  let current = resolve34(cwd);
   const dirs = [];
   while (true) {
     if (normalizePathForComparison(current) === normalizePathForComparison(home)) {
@@ -314525,8 +314951,8 @@ class Project {
   decrementPendingWrites() {
     this.pendingWriteCount--;
     if (this.pendingWriteCount === 0) {
-      for (const resolve34 of this.flushResolvers) {
-        resolve34();
+      for (const resolve35 of this.flushResolvers) {
+        resolve35();
       }
       this.flushResolvers = [];
     }
@@ -314540,13 +314966,13 @@ class Project {
     }
   }
   enqueueWrite(filePath, entry) {
-    return new Promise((resolve34) => {
+    return new Promise((resolve35) => {
       let queue3 = this.writeQueues.get(filePath);
       if (!queue3) {
         queue3 = [];
         this.writeQueues.set(filePath, queue3);
       }
-      queue3.push({ entry, resolve: resolve34 });
+      queue3.push({ entry, resolve: resolve35 });
       this.scheduleDrain();
     });
   }
@@ -314580,7 +315006,7 @@ class Project {
       const batch = queue3.splice(0);
       let content = "";
       const resolvers = [];
-      for (const { entry, resolve: resolve34 } of batch) {
+      for (const { entry, resolve: resolve35 } of batch) {
         const line = jsonStringify(entry) + `
 `;
         if (content.length + line.length >= this.MAX_CHUNK_BYTES) {
@@ -314592,7 +315018,7 @@ class Project {
           content = "";
         }
         content += line;
-        resolvers.push(resolve34);
+        resolvers.push(resolve35);
       }
       if (content.length > 0) {
         await this.appendToFile(filePath, content);
@@ -314715,8 +315141,8 @@ class Project {
     if (this.pendingWriteCount === 0) {
       return;
     }
-    return new Promise((resolve34) => {
-      this.flushResolvers.push(resolve34);
+    return new Promise((resolve35) => {
+      this.flushResolvers.push(resolve35);
     });
   }
   async removeMessageByUuid(targetUuid) {
@@ -315568,7 +315994,7 @@ function applySnipRemovals(messages) {
     messages.delete(uuid3);
     removedCount++;
   }
-  const resolve34 = (start) => {
+  const resolve35 = (start) => {
     const path13 = [];
     let cur = start;
     while (cur && toDelete.has(cur)) {
@@ -315587,7 +316013,7 @@ function applySnipRemovals(messages) {
   for (const [uuid3, msg] of messages) {
     if (!msg.parentUuid || !toDelete.has(msg.parentUuid))
       continue;
-    messages.set(uuid3, { ...msg, parentUuid: resolve34(msg.parentUuid) });
+    messages.set(uuid3, { ...msg, parentUuid: resolve35(msg.parentUuid) });
     relinkedCount++;
   }
   logEvent("tengu_snip_resume_filtered", {
@@ -318588,8 +319014,8 @@ class DiskTaskOutput {
       this.#queue.push(content);
     }
     if (!this.#flushPromise) {
-      this.#flushPromise = new Promise((resolve34) => {
-        this.#flushResolve = resolve34;
+      this.#flushPromise = new Promise((resolve35) => {
+        this.#flushResolve = resolve35;
       });
       track(this.#drain());
     }
@@ -318655,10 +319081,10 @@ class DiskTaskOutput {
         }
       }
     } finally {
-      const resolve34 = this.#flushResolve;
+      const resolve35 = this.#flushResolve;
       this.#flushPromise = null;
       this.#flushResolve = null;
-      resolve34();
+      resolve35();
     }
   }
 }
@@ -318944,17 +319370,17 @@ class ShellCommandImpl {
     });
     this.#childProcess.once("exit", this.#exitHandler.bind(this));
     this.#childProcess.once("error", this.#errorHandler.bind(this));
-    this.#stdioClosedPromise = new Promise((resolve34) => {
+    this.#stdioClosedPromise = new Promise((resolve35) => {
       this.#childProcess.once("close", () => {
-        resolve34();
+        resolve35();
       });
     });
     this.#timeoutId = setTimeout(ShellCommandImpl.#handleTimeout, this.#timeout, this);
-    const exitPromise = new Promise((resolve34) => {
-      this.#exitCodeResolver = resolve34;
+    const exitPromise = new Promise((resolve35) => {
+      this.#exitCodeResolver = resolve35;
     });
-    return new Promise((resolve34) => {
-      this.#resultResolver = resolve34;
+    return new Promise((resolve35) => {
+      this.#resultResolver = resolve35;
       exitPromise.then(this.#handleExit.bind(this));
     });
   }
@@ -319002,8 +319428,8 @@ class ShellCommandImpl {
     const graceMs = code === 0 ? OUTPUT_CLOSE_GRACE_MS : ERROR_OUTPUT_CLOSE_GRACE_MS;
     await Promise.race([
       stdioClosedPromise,
-      new Promise((resolve34) => {
-        const timeout = setTimeout(resolve34, graceMs);
+      new Promise((resolve35) => {
+        const timeout = setTimeout(resolve35, graceMs);
         timeout.unref();
       })
     ]);
@@ -320126,7 +320552,7 @@ function executeInBackground({
 }) {
   if (asyncRewake) {
     shellCommand.result.then(async (result) => {
-      await new Promise((resolve34) => setImmediate(resolve34));
+      await new Promise((resolve35) => setImmediate(resolve35));
       const stdout = await shellCommand.taskOutput.getStdout();
       const stderr = shellCommand.taskOutput.getStderr();
       shellCommand.cleanup();
@@ -320569,8 +320995,8 @@ async function execCommandHook(hook, hookEvent, hookName, jsonInput, signal, hoo
   child.stderr.setEncoding("utf8");
   let initialResponseChecked = false;
   let asyncResolve = null;
-  const childIsAsyncPromise = new Promise((resolve34) => {
-    asyncResolve = resolve34;
+  const childIsAsyncPromise = new Promise((resolve35) => {
+    asyncResolve = resolve35;
   });
   const processedPromptLines = new Set;
   let promptChain = Promise.resolve();
@@ -320661,13 +321087,13 @@ async function execCommandHook(hook, hookEvent, hookName, jsonInput, signal, hoo
     hookEvent,
     getOutput: async () => ({ stdout, stderr, output })
   });
-  const stdoutEndPromise = new Promise((resolve34) => {
-    child.stdout.on("end", () => resolve34());
+  const stdoutEndPromise = new Promise((resolve35) => {
+    child.stdout.on("end", () => resolve35());
   });
-  const stderrEndPromise = new Promise((resolve34) => {
-    child.stderr.on("end", () => resolve34());
+  const stderrEndPromise = new Promise((resolve35) => {
+    child.stderr.on("end", () => resolve35());
   });
-  const stdinWritePromise = stdinWritten ? Promise.resolve() : new Promise((resolve34, reject2) => {
+  const stdinWritePromise = stdinWritten ? Promise.resolve() : new Promise((resolve35, reject2) => {
     child.stdin.on("error", (err2) => {
       if (!requestPrompt) {
         reject2(err2);
@@ -320680,12 +321106,12 @@ async function execCommandHook(hook, hookEvent, hookName, jsonInput, signal, hoo
     if (!requestPrompt) {
       child.stdin.end();
     }
-    resolve34();
+    resolve35();
   });
   const childErrorPromise = new Promise((_, reject2) => {
     child.on("error", reject2);
   });
-  const childClosePromise = new Promise((resolve34) => {
+  const childClosePromise = new Promise((resolve35) => {
     let exitCode = null;
     child.on("close", (code) => {
       exitCode = code ?? 1;
@@ -320693,7 +321119,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(`
 `);
-        resolve34({
+        resolve35({
           stdout: finalStdout,
           stderr,
           output,
@@ -322748,12 +323174,12 @@ async function executeFunctionHook({
         hook
       };
     }
-    const passed = await new Promise((resolve34, reject2) => {
+    const passed = await new Promise((resolve35, 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);
-        resolve34(result);
+        resolve35(result);
       }).catch((error41) => {
         abortSignal.removeEventListener("abort", onAbort);
         reject2(error41);
@@ -322965,6 +323391,7 @@ __export(exports_worktree, {
   killTmuxSession: () => killTmuxSession,
   keepWorktree: () => keepWorktree,
   isTmuxAvailable: () => isTmuxAvailable2,
+  isAgentWorktreeIsolationAvailable: () => isAgentWorktreeIsolationAvailable,
   hasWorktreeChanges: () => hasWorktreeChanges,
   getTmuxInstallInstructions: () => getTmuxInstallInstructions2,
   getCurrentWorktreeSession: () => getCurrentWorktreeSession,
@@ -322977,7 +323404,7 @@ __export(exports_worktree, {
   cleanupWorktree: () => cleanupWorktree,
   cleanupStaleAgentWorktrees: () => cleanupStaleAgentWorktrees
 });
-import { spawnSync as spawnSync3 } from "child_process";
+import { spawnSync as spawnSync4 } from "child_process";
 import { basename as basename26, dirname as dirname43, join as join84 } from "path";
 function validateWorktreeSlug(slug) {
   if (slug.length > MAX_WORKTREE_SLUG_LENGTH) {
@@ -323406,10 +323833,11 @@ async function createAgentWorktree(slug) {
     logForDebugging2(`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) {
     logForDebugging2(`Created agent worktree at: ${worktreePath} on branch: ${worktreeBranch}`);
@@ -323421,6 +323849,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);
@@ -323536,7 +323974,7 @@ async function execIntoTmuxWorktree(args) {
       error: "Error: --tmux is not supported on Windows"
     };
   }
-  const tmuxCheck = spawnSync3("tmux", ["-V"], { encoding: "utf-8" });
+  const tmuxCheck = spawnSync4("tmux", ["-V"], { encoding: "utf-8" });
   if (tmuxCheck.status !== 0) {
     const installHint = process.platform === "darwin" ? "Install tmux with: brew install tmux" : "Install tmux with: sudo apt install tmux";
     return {
@@ -323641,7 +324079,7 @@ async function execIntoTmuxWorktree(args) {
     newArgs.push(arg);
   }
   let tmuxPrefix = "C-b";
-  const prefixResult = spawnSync3("tmux", ["show-options", "-g", "prefix"], {
+  const prefixResult = spawnSync4("tmux", ["show-options", "-g", "prefix"], {
     encoding: "utf-8"
   });
   if (prefixResult.status === 0 && prefixResult.stdout) {
@@ -323668,7 +324106,7 @@ async function execIntoTmuxWorktree(args) {
     CLAUDE_CODE_TMUX_PREFIX: tmuxPrefix,
     CLAUDE_CODE_TMUX_PREFIX_CONFLICTS: prefixConflicts ? "1" : ""
   };
-  const hasSessionResult = spawnSync3("tmux", ["has-session", "-t", tmuxSessionName], { encoding: "utf-8" });
+  const hasSessionResult = spawnSync4("tmux", ["has-session", "-t", tmuxSessionName], { encoding: "utf-8" });
   const sessionExists = hasSessionResult.status === 0;
   const isAlreadyInTmux = Boolean(process.env.TMUX);
   const useControlMode = isInITerm2() && !forceClassicTmux && !isAlreadyInTmux;
@@ -323686,7 +324124,7 @@ ${y2("╭─ iTerm2 Tip ──────────────────
   const isClaudeCliInternal = repoName === "claude-cli-internal";
   const shouldSetupDevPanes = isAnt && isClaudeCliInternal && !sessionExists;
   if (shouldSetupDevPanes) {
-    spawnSync3("tmux", [
+    spawnSync4("tmux", [
       "new-session",
       "-d",
       "-s",
@@ -323697,21 +324135,21 @@ ${y2("╭─ iTerm2 Tip ──────────────────
       process.execPath,
       ...newArgs
     ], { cwd: worktreeDir, env: tmuxEnv });
-    spawnSync3("tmux", ["split-window", "-h", "-t", tmuxSessionName, "-c", worktreeDir], { cwd: worktreeDir });
-    spawnSync3("tmux", ["send-keys", "-t", tmuxSessionName, "bun run watch", "Enter"], { cwd: worktreeDir });
-    spawnSync3("tmux", ["split-window", "-v", "-t", tmuxSessionName, "-c", worktreeDir], { cwd: worktreeDir });
-    spawnSync3("tmux", ["send-keys", "-t", tmuxSessionName, "bun run start"], {
+    spawnSync4("tmux", ["split-window", "-h", "-t", tmuxSessionName, "-c", worktreeDir], { cwd: worktreeDir });
+    spawnSync4("tmux", ["send-keys", "-t", tmuxSessionName, "bun run watch", "Enter"], { cwd: worktreeDir });
+    spawnSync4("tmux", ["split-window", "-v", "-t", tmuxSessionName, "-c", worktreeDir], { cwd: worktreeDir });
+    spawnSync4("tmux", ["send-keys", "-t", tmuxSessionName, "bun run start"], {
       cwd: worktreeDir
     });
-    spawnSync3("tmux", ["select-pane", "-t", `${tmuxSessionName}:0.0`], {
+    spawnSync4("tmux", ["select-pane", "-t", `${tmuxSessionName}:0.0`], {
       cwd: worktreeDir
     });
     if (isAlreadyInTmux) {
-      spawnSync3("tmux", ["switch-client", "-t", tmuxSessionName], {
+      spawnSync4("tmux", ["switch-client", "-t", tmuxSessionName], {
         stdio: "inherit"
       });
     } else {
-      spawnSync3("tmux", [...tmuxGlobalArgs, "attach-session", "-t", tmuxSessionName], {
+      spawnSync4("tmux", [...tmuxGlobalArgs, "attach-session", "-t", tmuxSessionName], {
         stdio: "inherit",
         cwd: worktreeDir
       });
@@ -323719,11 +324157,11 @@ ${y2("╭─ iTerm2 Tip ──────────────────
   } else {
     if (isAlreadyInTmux) {
       if (sessionExists) {
-        spawnSync3("tmux", ["switch-client", "-t", tmuxSessionName], {
+        spawnSync4("tmux", ["switch-client", "-t", tmuxSessionName], {
           stdio: "inherit"
         });
       } else {
-        spawnSync3("tmux", [
+        spawnSync4("tmux", [
           "new-session",
           "-d",
           "-s",
@@ -323734,7 +324172,7 @@ ${y2("╭─ iTerm2 Tip ──────────────────
           process.execPath,
           ...newArgs
         ], { cwd: worktreeDir, env: tmuxEnv });
-        spawnSync3("tmux", ["switch-client", "-t", tmuxSessionName], {
+        spawnSync4("tmux", ["switch-client", "-t", tmuxSessionName], {
           stdio: "inherit"
         });
       }
@@ -323751,7 +324189,7 @@ ${y2("╭─ iTerm2 Tip ──────────────────
         process.execPath,
         ...newArgs
       ];
-      spawnSync3("tmux", tmuxArgs, {
+      spawnSync4("tmux", tmuxArgs, {
         stdio: "inherit",
         cwd: worktreeDir,
         env: tmuxEnv
@@ -323778,6 +324216,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 = {
@@ -324007,10 +324446,10 @@ function sequential(fn) {
       return;
     processing = true;
     while (queue3.length > 0) {
-      const { args, resolve: resolve34, reject: reject2, context: context4 } = queue3.shift();
+      const { args, resolve: resolve35, reject: reject2, context: context4 } = queue3.shift();
       try {
         const result = await fn.apply(context4, args);
-        resolve34(result);
+        resolve35(result);
       } catch (error41) {
         reject2(error41);
       }
@@ -324021,8 +324460,8 @@ function sequential(fn) {
     }
   }
   return function(...args) {
-    return new Promise((resolve34, reject2) => {
-      queue3.push({ args, resolve: resolve34, reject: reject2, context: this });
+    return new Promise((resolve35, reject2) => {
+      queue3.push({ args, resolve: resolve35, reject: reject2, context: this });
       processQueue();
     });
   };
@@ -326550,14 +326989,14 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
       prevActScopeDepth !== actScopeDepth - 1 && console.error("You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. ");
       actScopeDepth = prevActScopeDepth;
     }
-    function recursivelyFlushAsyncActWork(returnValue2, resolve34, reject2) {
+    function recursivelyFlushAsyncActWork(returnValue2, resolve35, reject2) {
       var queue3 = ReactSharedInternals.actQueue;
       if (queue3 !== null)
         if (queue3.length !== 0)
           try {
             flushActQueue(queue3);
             enqueueTask(function() {
-              return recursivelyFlushAsyncActWork(returnValue2, resolve34, reject2);
+              return recursivelyFlushAsyncActWork(returnValue2, resolve35, reject2);
             });
             return;
           } catch (error41) {
@@ -326565,7 +327004,7 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
           }
         else
           ReactSharedInternals.actQueue = null;
-      0 < ReactSharedInternals.thrownErrors.length ? (queue3 = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject2(queue3)) : resolve34(returnValue2);
+      0 < ReactSharedInternals.thrownErrors.length ? (queue3 = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject2(queue3)) : resolve35(returnValue2);
     }
     function flushActQueue(queue3) {
       if (!isFlushing) {
@@ -326741,14 +327180,14 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
           didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = true, console.error("You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);"));
         });
         return {
-          then: function(resolve34, reject2) {
+          then: function(resolve35, reject2) {
             didAwaitActCall = true;
             thenable.then(function(returnValue2) {
               popActScope(prevActQueue, prevActScopeDepth);
               if (prevActScopeDepth === 0) {
                 try {
                   flushActQueue(queue3), enqueueTask(function() {
-                    return recursivelyFlushAsyncActWork(returnValue2, resolve34, reject2);
+                    return recursivelyFlushAsyncActWork(returnValue2, resolve35, reject2);
                   });
                 } catch (error$0) {
                   ReactSharedInternals.thrownErrors.push(error$0);
@@ -326759,7 +327198,7 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
                   reject2(_thrownError);
                 }
               } else
-                resolve34(returnValue2);
+                resolve35(returnValue2);
             }, function(error41) {
               popActScope(prevActQueue, prevActScopeDepth);
               0 < ReactSharedInternals.thrownErrors.length ? (error41 = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject2(error41)) : reject2(error41);
@@ -326775,11 +327214,11 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
       if (0 < ReactSharedInternals.thrownErrors.length)
         throw callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
       return {
-        then: function(resolve34, reject2) {
+        then: function(resolve35, reject2) {
           didAwaitActCall = true;
           prevActScopeDepth === 0 ? (ReactSharedInternals.actQueue = queue3, enqueueTask(function() {
-            return recursivelyFlushAsyncActWork(returnValue$jscomp$0, resolve34, reject2);
-          })) : resolve34(returnValue$jscomp$0);
+            return recursivelyFlushAsyncActWork(returnValue$jscomp$0, resolve35, reject2);
+          })) : resolve35(returnValue$jscomp$0);
         }
       };
     };
@@ -333406,8 +333845,8 @@ It can also happen if the client has a browser extension installed which messes
         currentEntangledActionThenable = {
           status: "pending",
           value: undefined,
-          then: function(resolve34) {
-            entangledListeners.push(resolve34);
+          then: function(resolve35) {
+            entangledListeners.push(resolve35);
           }
         };
       }
@@ -333431,8 +333870,8 @@ It can also happen if the client has a browser extension installed which messes
         status: "pending",
         value: null,
         reason: null,
-        then: function(resolve34) {
-          listeners.push(resolve34);
+        then: function(resolve35) {
+          listeners.push(resolve35);
         }
       };
       thenable.then(function() {
@@ -342767,13 +343206,13 @@ function getEventPriority(eventType) {
     case "focus":
     case "blur":
     case "paste":
-      return import_constants52.DiscreteEventPriority;
+      return import_constants53.DiscreteEventPriority;
     case "resize":
     case "scroll":
     case "mousemove":
-      return import_constants52.ContinuousEventPriority;
+      return import_constants53.ContinuousEventPriority;
     default:
-      return import_constants52.DefaultEventPriority;
+      return import_constants53.DefaultEventPriority;
   }
 }
 
@@ -342788,7 +343227,7 @@ class Dispatcher {
     if (this.currentEvent) {
       return getEventPriority(this.currentEvent.type);
     }
-    return import_constants52.DefaultEventPriority;
+    return import_constants53.DefaultEventPriority;
   }
   dispatch(target, event) {
     const previousEvent = this.currentEvent;
@@ -342813,18 +343252,18 @@ class Dispatcher {
   dispatchContinuous(target, event) {
     const previousPriority = this.currentUpdatePriority;
     try {
-      this.currentUpdatePriority = import_constants52.ContinuousEventPriority;
+      this.currentUpdatePriority = import_constants53.ContinuousEventPriority;
       return this.dispatch(target, event);
     } finally {
       this.currentUpdatePriority = previousPriority;
     }
   }
 }
-var import_constants52, NO_EVENT_PRIORITY = 0;
+var import_constants53, NO_EVENT_PRIORITY = 0;
 var init_dispatcher = __esm(() => {
   init_log2();
   init_event_handlers();
-  import_constants52 = __toESM(require_constants9(), 1);
+  import_constants53 = __toESM(require_constants9(), 1);
 });
 
 // src/cli/events/terminal-event.ts
@@ -345126,8 +345565,8 @@ function setTerminalFocused(v) {
     cb();
   }
   if (!v) {
-    for (const resolve34 of resolvers) {
-      resolve34();
+    for (const resolve35 of resolvers) {
+      resolve35();
     }
     resolvers.clear();
   }
@@ -345165,18 +345604,18 @@ class TerminalQuerier {
     this.stdout = stdout;
   }
   send(query2) {
-    return new Promise((resolve34) => {
+    return new Promise((resolve35) => {
       this.queue.push({
         kind: "query",
         match: query2.match,
-        resolve: (r) => resolve34(r)
+        resolve: (r) => resolve35(r)
       });
       this.stdout.write(query2.request);
     });
   }
   flush() {
-    return new Promise((resolve34) => {
-      this.queue.push({ kind: "sentinel", resolve: resolve34 });
+    return new Promise((resolve35) => {
+      this.queue.push({ kind: "sentinel", resolve: resolve35 });
       this.stdout.write(SENTINEL);
     });
   }
@@ -349126,7 +349565,7 @@ function applyPositionedHighlight(screen, stylePool, positions, rowOffset, curre
   }
   return true;
 }
-var import_constants54, timing;
+var import_constants55, timing;
 var init_render_to_screen = __esm(() => {
   init_debug();
   init_dom();
@@ -349135,7 +349574,7 @@ var init_render_to_screen = __esm(() => {
   init_reconciler();
   init_render_node_to_output();
   init_screen();
-  import_constants54 = __toESM(require_constants9(), 1);
+  import_constants55 = __toESM(require_constants9(), 1);
   timing = { reconcile: 0, yoga: 0, paint: 0, scan: 0, calls: 0 };
 });
 
@@ -349452,7 +349891,7 @@ class Ink {
         };
       }
     };
-    this.container = reconciler_default.createContainer(this.rootNode, import_constants55.LegacyRoot, null, false, null, "id", noop_default, (error41) => {
+    this.container = reconciler_default.createContainer(this.rootNode, import_constants56.LegacyRoot, null, false, null, "id", noop_default, (error41) => {
       this.reportRenderError("uncaught", error41);
     }, (error41) => {
       this.reportRenderError("caught", error41);
@@ -350165,8 +350604,8 @@ class Ink {
     }
   }
   async waitUntilExit() {
-    this.exitPromise ||= new Promise((resolve34, reject2) => {
-      this.resolveExitPromise = resolve34;
+    this.exitPromise ||= new Promise((resolve35, reject2) => {
+      this.resolveExitPromise = resolve35;
       this.rejectExitPromise = reject2;
     });
     return this.exitPromise;
@@ -350273,7 +350712,7 @@ function drainStdin(stdin = process.stdin) {
     }
   }
 }
-var import_constants55, jsx_dev_runtime9, ALT_SCREEN_ANCHOR_CURSOR, CURSOR_HOME_PATCH, ERASE_THEN_HOME_PATCH, CONSOLE_STDOUT_METHODS, CONSOLE_STDERR_METHODS;
+var import_constants56, jsx_dev_runtime9, ALT_SCREEN_ANCHOR_CURSOR, CURSOR_HOME_PATCH, ERASE_THEN_HOME_PATCH, CONSOLE_STDOUT_METHODS, CONSOLE_STDERR_METHODS;
 var init_ink = __esm(() => {
   init_noop();
   init_throttle2();
@@ -350305,7 +350744,7 @@ var init_ink = __esm(() => {
   init_dec2();
   init_osc2();
   init_useTerminalNotification();
-  import_constants55 = __toESM(require_constants9(), 1);
+  import_constants56 = __toESM(require_constants9(), 1);
   jsx_dev_runtime9 = __toESM(require_jsx_dev_runtime(), 1);
   ALT_SCREEN_ANCHOR_CURSOR = Object.freeze({
     x: 0,
@@ -353739,8 +354178,8 @@ class Mailbox {
         return Promise.resolve(msg);
       }
     }
-    return new Promise((resolve34) => {
-      this.waiters.push({ fn, resolve: resolve34 });
+    return new Promise((resolve35) => {
+      this.waiters.push({ fn, resolve: resolve35 });
     });
   }
   subscribe = this.changed.subscribe;
@@ -358378,7 +358817,7 @@ var init_option_map = __esm(() => {
 });
 
 // src/cli/components/CustomSelect/use-select-navigation.ts
-import { isDeepStrictEqual } from "util";
+import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
 function useSelectNavigation({
   visibleOptionCount = 5,
   options: options2,
@@ -358394,7 +358833,7 @@ function useSelectNavigation({
   const onFocusRef = import_react46.useRef(onFocus);
   onFocusRef.current = onFocus;
   const [lastOptions, setLastOptions] = import_react46.useState(options2);
-  if (options2 !== lastOptions && !isDeepStrictEqual(options2, lastOptions)) {
+  if (options2 !== lastOptions && !isDeepStrictEqual2(options2, lastOptions)) {
     dispatch({
       type: "reset",
       state: createDefaultState({
@@ -358708,7 +359147,7 @@ var init_use_select_navigation = __esm(() => {
 });
 
 // src/cli/components/CustomSelect/use-multi-select-state.ts
-import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
+import { isDeepStrictEqual as isDeepStrictEqual3 } from "util";
 function useMultiSelectState({
   isDisabled = false,
   visibleOptionCount = 5,
@@ -358728,7 +359167,7 @@ function useMultiSelectState({
   const [selectedValues, setSelectedValues] = import_react47.useState(defaultValue);
   const [isSubmitFocused, setIsSubmitFocused] = import_react47.useState(false);
   const [lastOptions, setLastOptions] = import_react47.useState(options2);
-  if (options2 !== lastOptions && !isDeepStrictEqual2(options2, lastOptions)) {
+  if (options2 !== lastOptions && !isDeepStrictEqual3(options2, lastOptions)) {
     setSelectedValues(defaultValue);
     setLastOptions(options2);
   }
@@ -360913,7 +361352,7 @@ async function checkManagedSettingsSecurity(cachedSettings, newSettings) {
     return "no_check_needed";
   }
   logEvent("tengu_managed_settings_security_dialog_shown", {});
-  return new Promise((resolve34) => {
+  return new Promise((resolve35) => {
     (async () => {
       const {
         unmount
@@ -360924,12 +361363,12 @@ async function checkManagedSettingsSecurity(cachedSettings, newSettings) {
             onAccept: () => {
               logEvent("tengu_managed_settings_security_dialog_accepted", {});
               unmount();
-              resolve34("approved");
+              resolve35("approved");
             },
             onReject: () => {
               logEvent("tengu_managed_settings_security_dialog_rejected", {});
               unmount();
-              resolve34("rejected");
+              resolve35("rejected");
             }
           }, undefined, false, undefined, this)
         }, undefined, false, undefined, this)
@@ -360968,8 +361407,8 @@ function initializeRemoteManagedSettingsLoadingPromise() {
     return;
   }
   if (isRemoteManagedSettingsEligible()) {
-    loadingCompletePromise2 = new Promise((resolve34) => {
-      loadingCompleteResolve2 = resolve34;
+    loadingCompletePromise2 = new Promise((resolve35) => {
+      loadingCompleteResolve2 = resolve35;
       setTimeout(() => {
         if (loadingCompleteResolve2) {
           logForDebugging2("Remote settings: Loading promise timed out, resolving anyway");
@@ -361224,8 +361663,8 @@ async function fetchAndLoadRemoteManagedSettings() {
 }
 async function loadRemoteManagedSettings() {
   if (isRemoteManagedSettingsEligible() && !loadingCompletePromise2) {
-    loadingCompletePromise2 = new Promise((resolve34) => {
-      loadingCompleteResolve2 = resolve34;
+    loadingCompletePromise2 = new Promise((resolve35) => {
+      loadingCompleteResolve2 = resolve35;
     });
   }
   if (getRemoteManagedSettingsSyncFromCache() && loadingCompleteResolve2) {
@@ -361497,7 +361936,7 @@ async function startNodeRelay(wsUrl, authHeader, wsAuthHeader) {
       cleanupConn(states.get(sock));
     });
   });
-  return new Promise((resolve34, reject2) => {
+  return new Promise((resolve35, reject2) => {
     server.once("error", reject2);
     server.listen(0, "127.0.0.1", () => {
       const addr = server.address();
@@ -361505,7 +361944,7 @@ async function startNodeRelay(wsUrl, authHeader, wsAuthHeader) {
         reject2(new Error("upstreamproxy: server has no TCP address"));
         return;
       }
-      resolve34({
+      resolve35({
         port: addr.port,
         stop: () => server.close()
       });
@@ -381298,7 +381737,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((resolve34) => setTimeout(resolve34, 1000));
+          await new Promise((resolve35) => setTimeout(resolve35, 1000));
         } while (extractStatus.status !== "completed");
       } else {
         this.handleError(response, "extract");
@@ -381397,7 +381836,7 @@ var HttpClient = class {
             }
           } else if (["active", "paused", "pending", "queued", "waiting", "scraping"].includes(statusData.status)) {
             checkInterval = Math.max(checkInterval, 2);
-            await new Promise((resolve34) => setTimeout(resolve34, checkInterval * 1000));
+            await new Promise((resolve35) => setTimeout(resolve35, checkInterval * 1000));
           } else {
             throw new FirecrawlError(`Crawl job failed or was stopped. Status: ${statusData.status}`, 500);
           }
@@ -381411,7 +381850,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((resolve34) => setTimeout(resolve34, backoffDelay));
+          await new Promise((resolve35) => setTimeout(resolve35, backoffDelay));
           continue;
         }
         throw new FirecrawlError(error41, 500);
@@ -381494,7 +381933,7 @@ var HttpClient = class {
         if (researchStatus.status !== "processing") {
           break;
         }
-        await new Promise((resolve34) => setTimeout(resolve34, 2000));
+        await new Promise((resolve35) => setTimeout(resolve35, 2000));
       }
       return { success: false, error: "Research job terminated unexpectedly" };
     } catch (error41) {
@@ -381582,7 +382021,7 @@ var HttpClient = class {
         if (researchStatus.status !== "processing") {
           break;
         }
-        await new Promise((resolve34) => setTimeout(resolve34, 2000));
+        await new Promise((resolve35) => setTimeout(resolve35, 2000));
       }
       return { success: false, error: "Research job terminated unexpectedly" };
     } catch (error41) {
@@ -381653,7 +382092,7 @@ var HttpClient = class {
         if (generationStatus.status !== "processing") {
           break;
         }
-        await new Promise((resolve34) => setTimeout(resolve34, 2000));
+        await new Promise((resolve35) => setTimeout(resolve35, 2000));
       }
       return { success: false, error: "LLMs.txt generation job terminated unexpectedly" };
     } catch (error41) {
@@ -382400,7 +382839,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");
@@ -382412,7 +382852,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) => {
@@ -382470,6 +382914,7 @@ var init_TaskStopTool = __esm(() => {
   init_stopTask();
   init_slowOperations();
   init_toolUIRegistry();
+  init_backgroundAbortRegistry();
   ({
     renderToolResultMessage: renderToolResultMessage15,
     renderToolUseMessage: renderToolUseMessage15
@@ -382515,6 +382960,9 @@ var init_TaskStopTool = __esm(() => {
       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}`,
@@ -389481,9 +389929,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(resolve34, reject2) {
+      return new Promise(function(resolve35, reject2) {
         module.exports.request(verb, args[0], args[1], args[2], function(err2, resp) {
-          return err2 ? reject2(err2) : resolve34(resp);
+          return err2 ? reject2(err2) : resolve35(resp);
         });
       });
     };
@@ -396884,7 +397332,7 @@ async function showInvalidConfigDialog({
     ...getBaseRenderOptions(false),
     theme: SAFE_ERROR_THEME_NAME
   };
-  await new Promise(async (resolve34) => {
+  await new Promise(async (resolve35) => {
     const {
       unmount
     } = await render(/* @__PURE__ */ jsx_dev_runtime44.jsxDEV(AppStateProvider, {
@@ -396894,7 +397342,7 @@ async function showInvalidConfigDialog({
           errorDescription: error41.message,
           onExit: () => {
             unmount();
-            resolve34();
+            resolve35();
             process.exit(1);
           },
           onReset: () => {
@@ -396903,7 +397351,7 @@ async function showInvalidConfigDialog({
               encoding: "utf8"
             });
             unmount();
-            resolve34();
+            resolve35();
             process.exit(0);
           }
         }, undefined, false, undefined, this)
@@ -401262,14 +401710,14 @@ class AuthCodeListener {
     this.callbackPath = callbackPath;
   }
   async start(port) {
-    return new Promise((resolve34, reject2) => {
+    return new Promise((resolve35, 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;
-        resolve34(this.port);
+        resolve35(this.port);
       });
     });
   }
@@ -401280,8 +401728,8 @@ class AuthCodeListener {
     return this.pendingResponse !== null;
   }
   async waitForAuthorization(state4, onReady) {
-    return new Promise((resolve34, reject2) => {
-      this.promiseResolver = resolve34;
+    return new Promise((resolve35, reject2) => {
+      this.promiseResolver = resolve35;
       this.promiseRejecter = reject2;
       this.expectedState = state4;
       this.startLocalListener(onReady);
@@ -401450,11 +401898,11 @@ class OAuthService {
     }
   }
   async waitForAuthorizationCode(state4, onReady) {
-    return new Promise((resolve34, reject2) => {
-      this.manualAuthCodeResolver = resolve34;
+    return new Promise((resolve35, reject2) => {
+      this.manualAuthCodeResolver = resolve35;
       this.authCodeListener?.waitForAuthorization(state4, onReady).then((authorizationCode) => {
         this.manualAuthCodeResolver = null;
-        resolve34(authorizationCode);
+        resolve35(authorizationCode);
       }).catch((error41) => {
         this.manualAuthCodeResolver = null;
         reject2(error41);
@@ -419069,7 +419517,7 @@ function extractFirstFrame(output) {
   return output.slice(contentStart, endIndex);
 }
 function renderToAnsiString(node, columns) {
-  return new Promise(async (resolve34) => {
+  return new Promise(async (resolve35) => {
     let output = "";
     const stream4 = new PassThrough3;
     if (columns !== undefined) {
@@ -419085,7 +419533,7 @@ function renderToAnsiString(node, columns) {
       patchConsole: false
     });
     await instance.waitUntilExit();
-    await resolve34(extractFirstFrame(output));
+    await resolve35(extractFirstFrame(output));
   });
 }
 async function renderToString(node, columns) {
@@ -419188,7 +419636,7 @@ var init_exportRenderer = __esm(() => {
 // src/lib/editor.ts
 import {
   spawn as spawn8,
-  spawnSync as spawnSync4
+  spawnSync as spawnSync5
 } from "child_process";
 import { basename as basename32 } from "path";
 function isCommandAvailable3(command) {
@@ -419239,7 +419687,7 @@ function openFileInExternalEditor(filePath, line) {
     let result;
     if (process.platform === "win32") {
       const lineArg = useGotoLine ? `+${line} ` : "";
-      result = spawnSync4(`${editor} ${lineArg}"${filePath}"`, {
+      result = spawnSync5(`${editor} ${lineArg}"${filePath}"`, {
         ...syncOpts,
         shell: true
       });
@@ -419248,7 +419696,7 @@ function openFileInExternalEditor(filePath, line) {
         ...editorArgs,
         ...useGotoLine ? [`+${line}`, filePath] : [filePath]
       ];
-      result = spawnSync4(base2, args, syncOpts);
+      result = spawnSync5(base2, args, syncOpts);
     }
     if (result.error) {
       logForDebugging2(`editor spawn failed: ${result.error}`, {
@@ -430804,10 +431252,28 @@ function deserializeMessagesWithInterruptDetection(serializedMessages) {
     throw error41;
   }
 }
+function hasTerminalContinuationStop(messages) {
+  let lastToolUseIdx = -1;
+  for (let index = messages.length - 1;index >= 0; index--) {
+    const message = messages[index];
+    if (message.type === "assistant" && !message.isApiErrorMessage && message.message.content.some((block2) => block2.type === "tool_use")) {
+      lastToolUseIdx = index;
+      break;
+    }
+  }
+  if (lastToolUseIdx === -1)
+    return false;
+  const terminalBatch = messages.slice(lastToolUseIdx + 1);
+  const hasLaterHumanPrompt = terminalBatch.some((message) => message.type === "user" && !message.isMeta && !message.isCompactSummary && !isToolUseResultMessage(message));
+  return !hasLaterHumanPrompt && terminalBatch.some((message) => message.type === "user" && message.preventContinuation === true);
+}
 function detectTurnInterruption(messages) {
   if (messages.length === 0) {
     return { kind: "none" };
   }
+  if (hasTerminalContinuationStop(messages)) {
+    return { kind: "none" };
+  }
   const lastMessageIdx = messages.findLastIndex((m) => m.type !== "system" && m.type !== "progress" && !(m.type === "assistant" && m.isApiErrorMessage));
   const lastMessage = lastMessageIdx !== -1 ? messages[lastMessageIdx] : undefined;
   if (!lastMessage) {
@@ -431787,7 +432253,7 @@ async function handleTeleportPrerequisites(root2, errorsToIgnore) {
       error_types: Array.from(errors4).join(","),
       errors_ignored: Array.from(errorsToIgnore || []).join(",")
     });
-    await new Promise((resolve34) => {
+    await new Promise((resolve35) => {
       root2.render(/* @__PURE__ */ jsx_dev_runtime160.jsxDEV(AppStateProvider, {
         children: /* @__PURE__ */ jsx_dev_runtime160.jsxDEV(KeybindingSetup, {
           children: /* @__PURE__ */ jsx_dev_runtime160.jsxDEV(TeleportError, {
@@ -431796,7 +432262,7 @@ async function handleTeleportPrerequisites(root2, errorsToIgnore) {
               logEvent("tengu_teleport_errors_resolved", {
                 error_types: Array.from(errors4).join(",")
               });
-              resolve34();
+              resolve35();
             }
           }, undefined, false, undefined, this)
         }, undefined, false, undefined, this)
@@ -442095,7 +442561,7 @@ import {
   writeFile as writeFile7
 } from "fs/promises";
 import { homedir as homedir32 } from "os";
-import { basename as basename45, delimiter as delimiter3, dirname as dirname47, join as join103, resolve as resolve34 } from "path";
+import { basename as basename45, delimiter as delimiter3, dirname as dirname47, join as join103, resolve as resolve35 } from "path";
 function getPlatform3() {
   const os5 = env3.platform;
   const arch = process.arch === "x64" ? "x64" : process.arch === "arm64" ? "arm64" : null;
@@ -442509,8 +442975,8 @@ async function updateSymlink(symlinkPath, targetPath) {
     if (symlinkExists) {
       try {
         const currentTarget = await readlink(symlinkPath);
-        const resolvedCurrentTarget = resolve34(dirname47(symlinkPath), currentTarget);
-        const resolvedTargetPath = resolve34(targetPath);
+        const resolvedCurrentTarget = resolve35(dirname47(symlinkPath), currentTarget);
+        const resolvedTargetPath = resolve35(targetPath);
         if (resolvedCurrentTarget === resolvedTargetPath) {
           return false;
         }
@@ -442550,7 +443016,7 @@ async function checkInstall(force = false) {
   const dirs = getBaseDirectories();
   const messages = [];
   const localBinDir = dirname47(dirs.executable);
-  const resolvedLocalBinPath = resolve34(localBinDir);
+  const resolvedLocalBinPath = resolve35(localBinDir);
   const platform6 = getPlatform3();
   const isWindows2 = platform6.startsWith("win32");
   try {
@@ -442573,7 +443039,7 @@ async function checkInstall(force = false) {
   } else {
     try {
       const target = await readlink(dirs.executable);
-      const absoluteTarget = resolve34(dirname47(dirs.executable), target);
+      const absoluteTarget = resolve35(dirname47(dirs.executable), target);
       if (!await isPossibleClaudeBinary(absoluteTarget)) {
         messages.push({
           message: `Claude symlink points to missing or invalid binary: ${target}`,
@@ -442601,7 +443067,7 @@ async function checkInstall(force = false) {
   }
   const isInCurrentPath = (process.env.PATH || "").split(delimiter3).some((entry) => {
     try {
-      const resolvedEntry = resolve34(entry);
+      const resolvedEntry = resolve35(entry);
       if (isWindows2) {
         return resolvedEntry.toLowerCase() === resolvedLocalBinPath.toLowerCase();
       }
@@ -442680,7 +443146,7 @@ async function installLatestImpl(channelOrVersion, forceReinstall = false) {
 async function getVersionFromSymlink(symlinkPath) {
   try {
     const target = await readlink(symlinkPath);
-    const absoluteTarget = resolve34(dirname47(symlinkPath), target);
+    const absoluteTarget = resolve35(dirname47(symlinkPath), target);
     if (await isPossibleClaudeBinary(absoluteTarget)) {
       return absoluteTarget;
     }
@@ -442696,7 +443162,7 @@ async function lockCurrentVersion() {
   if (!process.execPath.includes(dirs.versions)) {
     return;
   }
-  const versionPath = resolve34(process.execPath);
+  const versionPath = resolve35(process.execPath);
   try {
     const lockfilePath = getLockFilePathFromVersionPath(dirs, versionPath);
     await mkdir11(dirs.locks, { recursive: true });
@@ -442864,7 +443330,7 @@ async function cleanupOldVersions() {
       versionFiles.push({
         name: entry,
         path: entryPath,
-        resolvedPath: resolve34(entryPath),
+        resolvedPath: resolve35(entryPath),
         mtime: stats.mtime
       });
     } catch {}
@@ -442882,7 +443348,7 @@ async function cleanupOldVersions() {
     const currentBinaryPath = process.execPath;
     const protectedVersions = new Set;
     if (currentBinaryPath && currentBinaryPath.includes(dirs.versions)) {
-      protectedVersions.add(resolve34(currentBinaryPath));
+      protectedVersions.add(resolve35(currentBinaryPath));
     }
     const currentSymlinkVersion = await getVersionFromSymlink(dirs.executable);
     if (currentSymlinkVersion) {
@@ -447089,8 +447555,8 @@ class FileIndex {
   }
   loadFromFileListAsync(fileList) {
     let markQueryable = () => {};
-    const queryable = new Promise((resolve35) => {
-      markQueryable = resolve35;
+    const queryable = new Promise((resolve36) => {
+      markQueryable = resolve36;
     });
     const done = this.buildAsync(fileList, markQueryable);
     return { queryable, done };
@@ -447271,7 +447737,7 @@ function isUpper(code) {
   return code >= 65 && code <= 90;
 }
 function yieldToEventLoop() {
-  return new Promise((resolve35) => setImmediate(resolve35));
+  return new Promise((resolve36) => setImmediate(resolve36));
 }
 function computeTopLevelEntries(paths2, limit) {
   const topLevel = new Set;
@@ -453365,10 +453831,10 @@ var require_browser2 = __commonJS((exports) => {
         text = canvas;
         canvas = undefined;
       }
-      return new Promise(function(resolve35, reject2) {
+      return new Promise(function(resolve36, reject2) {
         try {
           const data = QRCode.create(text, opts);
-          resolve35(renderFunc(data, canvas, opts));
+          resolve36(renderFunc(data, canvas, opts));
         } catch (e2) {
           reject2(e2);
         }
@@ -453424,11 +453890,11 @@ function getStringRendererFromType(type) {
 }
 function render2(renderFunc, text, params) {
   if (!params.cb) {
-    return new Promise(function(resolve35, reject2) {
+    return new Promise(function(resolve36, reject2) {
       try {
         const data = QRCode.create(text, params.opts);
         return renderFunc(data, params.opts, function(err2, data2) {
-          return err2 ? reject2(err2) : resolve35(data2);
+          return err2 ? reject2(err2) : resolve36(data2);
         });
       } catch (e2) {
         reject2(e2);
@@ -471445,7 +471911,7 @@ var init_channelPermissions = __esm(() => {
 });
 
 // src/cli/hooks/toolPermission/PermissionContext.ts
-function createResolveOnce(resolve35) {
+function createResolveOnce(resolve36) {
   let claimed = false;
   let delivered = false;
   return {
@@ -471454,7 +471920,7 @@ function createResolveOnce(resolve35) {
         return;
       delivered = true;
       claimed = true;
-      resolve35(value);
+      resolve36(value);
     },
     isResolved() {
       return claimed;
@@ -471499,11 +471965,11 @@ function createPermissionContext(tool, input, toolUseContext, assistantMessage,
       setToolPermissionContext(applyPermissionUpdates(appState.toolPermissionContext, updates));
       return updates.some((update) => supportsPersistence(update.destination));
     },
-    resolveIfAborted(resolve35) {
+    resolveIfAborted(resolve36) {
       if (!toolUseContext.abortController.signal.aborted)
         return false;
       this.logCancelled();
-      resolve35(this.cancelAndAbort(undefined, true));
+      resolve36(this.cancelAndAbort(undefined, true));
       return true;
     },
     cancelAndAbort(feedback, isAbort, contentBlocks) {
@@ -471617,7 +472083,7 @@ var init_PermissionContext = __esm(() => {
 
 // src/cli/hooks/toolPermission/handlers/interactiveHandler.ts
 import { randomUUID as randomUUID34 } from "crypto";
-function handleInteractivePermission(params, resolve35) {
+function handleInteractivePermission(params, resolve36) {
   const {
     ctx,
     description,
@@ -471626,7 +472092,7 @@ function handleInteractivePermission(params, resolve35) {
     bridgeCallbacks,
     channelCallbacks
   } = params;
-  const { resolve: resolveOnce, isResolved, claim } = createResolveOnce(resolve35);
+  const { resolve: resolveOnce, isResolved, claim } = createResolveOnce(resolve36);
   let userInteracted = false;
   let checkmarkTransitionTimer;
   let checkmarkAbortHandler;
@@ -471813,8 +472279,8 @@ async function handleSwarmWorkerPermission(params) {
       ...prev,
       pendingWorkerRequest: null
     }));
-    const decision = await new Promise((resolve35) => {
-      const { resolve: resolveOnce, claim } = createResolveOnce(resolve35);
+    const decision = await new Promise((resolve36) => {
+      const { resolve: resolveOnce, claim } = createResolveOnce(resolve36);
       const request = createPermissionRequest({
         toolName: ctx.tool.name,
         toolUseId: ctx.toolUseID,
@@ -471880,15 +472346,15 @@ function useCanUseTool(setToolUseConfirmQueue, setToolPermissionContext) {
   const $2 = import_react_compiler_runtime191.c(3);
   let t0;
   if ($2[0] !== setToolPermissionContext || $2[1] !== setToolUseConfirmQueue) {
-    t0 = async (tool, input, toolUseContext, assistantMessage, toolUseID, forceDecision) => new Promise((resolve35) => {
+    t0 = async (tool, input, toolUseContext, assistantMessage, toolUseID, forceDecision) => new Promise((resolve36) => {
       const ctx = createPermissionContext(tool, input, toolUseContext, assistantMessage, toolUseID, setToolPermissionContext, createPermissionQueueOps(setToolUseConfirmQueue));
-      if (ctx.resolveIfAborted(resolve35)) {
+      if (ctx.resolveIfAborted(resolve36)) {
         return;
       }
       const decisionPromise = forceDecision !== undefined ? Promise.resolve(forceDecision) : hasPermissionsToUseTool(tool, input, toolUseContext, assistantMessage, toolUseID);
       return decisionPromise.then(async (result) => {
         if (result.behavior === "allow") {
-          if (ctx.resolveIfAborted(resolve35)) {
+          if (ctx.resolveIfAborted(resolve36)) {
             return;
           }
           if (false) {}
@@ -471896,7 +472362,7 @@ function useCanUseTool(setToolUseConfirmQueue, setToolPermissionContext) {
             decision: "accept",
             source: "config"
           });
-          resolve35(ctx.buildAllow(result.updatedInput ?? input, {
+          resolve36(ctx.buildAllow(result.updatedInput ?? input, {
             decisionReason: result.decisionReason
           }));
           return;
@@ -471907,7 +472373,7 @@ function useCanUseTool(setToolUseConfirmQueue, setToolPermissionContext) {
           toolPermissionContext: appState.toolPermissionContext,
           tools: toolUseContext.options.tools
         });
-        if (ctx.resolveIfAborted(resolve35)) {
+        if (ctx.resolveIfAborted(resolve36)) {
           return;
         }
         switch (result.behavior) {
@@ -471923,7 +472389,7 @@ function useCanUseTool(setToolUseConfirmQueue, setToolPermissionContext) {
               source: "config"
             });
             if (false) {}
-            resolve35(result);
+            resolve36(result);
             return;
           }
           case "ask": {
@@ -471936,11 +472402,11 @@ function useCanUseTool(setToolUseConfirmQueue, setToolPermissionContext) {
                 permissionMode: appState.toolPermissionContext.mode
               });
               if (coordinatorDecision) {
-                resolve35(coordinatorDecision);
+                resolve36(coordinatorDecision);
                 return;
               }
             }
-            if (ctx.resolveIfAborted(resolve35)) {
+            if (ctx.resolveIfAborted(resolve36)) {
               return;
             }
             const swarmDecision = await handleSwarmWorkerPermission({
@@ -471951,7 +472417,7 @@ function useCanUseTool(setToolUseConfirmQueue, setToolPermissionContext) {
               suggestions: result.suggestions
             });
             if (swarmDecision) {
-              resolve35(swarmDecision);
+              resolve36(swarmDecision);
               return;
             }
             if (false) {}
@@ -471962,7 +472428,7 @@ function useCanUseTool(setToolUseConfirmQueue, setToolPermissionContext) {
               awaitAutomatedChecksBeforeDialog: appState.toolPermissionContext.awaitAutomatedChecksBeforeDialog,
               bridgeCallbacks: undefined,
               channelCallbacks: undefined
-            }, resolve35);
+            }, resolve36);
             return;
           }
         }
@@ -471970,10 +472436,10 @@ function useCanUseTool(setToolUseConfirmQueue, setToolPermissionContext) {
         if (error41 instanceof AbortError || error41 instanceof CanonicalUserAbortError) {
           logForDebugging2(`Permission check threw ${error41.constructor.name} for tool=${tool.name}: ${error41.message}`);
           ctx.logCancelled();
-          resolve35(ctx.cancelAndAbort(undefined, true));
+          resolve36(ctx.cancelAndAbort(undefined, true));
         } else {
           logError(error41);
-          resolve35(ctx.cancelAndAbort(undefined, true));
+          resolve36(ctx.cancelAndAbort(undefined, true));
         }
       }).finally(() => {
         clearClassifierChecking(toolUseID);
@@ -476098,8 +476564,8 @@ function useManageMCPConnections(dynamicMcpConfig, isStrictMcpConfig = false) {
                 }
                 const backoffMs = Math.min(INITIAL_BACKOFF_MS * Math.pow(2, attempt - 1), MAX_BACKOFF_MS);
                 logMCPDebug(client.name, `Scheduling reconnection attempt ${attempt + 1} in ${backoffMs}ms`);
-                await new Promise((resolve36) => {
-                  const timer = setTimeout(resolve36, backoffMs);
+                await new Promise((resolve37) => {
+                  const timer = setTimeout(resolve37, backoffMs);
                   reconnectTimersRef.current.set(client.name, timer);
                 });
               }
@@ -479203,7 +479669,7 @@ class StructuredIO {
       });
     }
     try {
-      return await new Promise((resolve36, reject2) => {
+      return await new Promise((resolve37, reject2) => {
         this.pendingRequests.set(requestId, {
           request: {
             type: "control_request",
@@ -479211,7 +479677,7 @@ class StructuredIO {
             request
           },
           resolve: (result) => {
-            resolve36(result);
+            resolve37(result);
           },
           reject: reject2,
           schema
@@ -480416,7 +480882,7 @@ function usePluginRecommendationBase() {
   const isCheckingRef = React95.useRef(false);
   let t0;
   if ($2[0] !== recommendation) {
-    t0 = (resolve36) => {
+    t0 = (resolve37) => {
       if (getIsRemoteMode()) {
         return;
       }
@@ -480427,7 +480893,7 @@ function usePluginRecommendationBase() {
         return;
       }
       isCheckingRef.current = true;
-      resolve36().then((rec) => {
+      resolve37().then((rec) => {
         if (rec) {
           setRecommendation(rec);
         }
@@ -481866,7 +482332,7 @@ var init_usePluginAutoupdateNotification = __esm(() => {
 });
 
 // src/capabilities/plugins/reconciler.ts
-import { isAbsolute as isAbsolute23, resolve as resolve36 } from "path";
+import { isAbsolute as isAbsolute23, resolve as resolve37 } from "path";
 function diffMarketplaces(declared, materialized, opts) {
   const missing = [];
   const sourceChanged = [];
@@ -481979,7 +482445,7 @@ function normalizeSource(source, projectRoot) {
     const canonicalRoot = findCanonicalGitRoot(base2);
     return {
       ...source,
-      path: resolve36(canonicalRoot ?? base2, source.path)
+      path: resolve37(canonicalRoot ?? base2, source.path)
     };
   }
   return source;
@@ -485635,12 +486101,12 @@ Error: sandbox required but unavailable: ${reason}
     return () => unregisterLeaderSetToolPermissionContext();
   }, [setToolPermissionContext]);
   const canUseTool = useCanUseTool_default(setToolUseConfirmQueue, setToolPermissionContext);
-  const requestPrompt = import_react234.useCallback((title, toolInputSummary) => (request) => new Promise((resolve37, reject2) => {
+  const requestPrompt = import_react234.useCallback((title, toolInputSummary) => (request) => new Promise((resolve38, reject2) => {
     setPromptQueue((prev) => [...prev, {
       request,
       title,
       toolInputSummary,
-      resolve: resolve37,
+      resolve: resolve38,
       reject: reject2
     }]);
   }), []);
@@ -491619,7 +492085,7 @@ function buildPrimarySection() {
   }, undefined, false, undefined, this);
   return [{
     label: "Version",
-    value: "0.4.18"
+    value: "0.4.20"
   }, {
     label: "Session name",
     value: nameValue
@@ -497743,7 +498209,7 @@ var init_useTurnDiffs = __esm(() => {
 });
 
 // src/cli/components/diff/DiffDetailView.tsx
-import { resolve as resolve37 } from "path";
+import { resolve as resolve38 } from "path";
 function DiffDetailView(t0) {
   const $2 = import_react_compiler_runtime243.c(53);
   const {
@@ -497776,7 +498242,7 @@ function DiffDetailView(t0) {
     let content;
     let t22;
     if ($2[1] !== filePath) {
-      const fullPath = resolve37(getCwd3(), filePath);
+      const fullPath = resolve38(getCwd3(), filePath);
       content = readFileSafe(fullPath);
       t22 = content?.split(`
 `)[0] ?? null;
@@ -501159,7 +501625,7 @@ function getGithubDeviceFlowClientId() {
   return process.env.GITHUB_DEVICE_FLOW_CLIENT_ID?.trim() || DEFAULT_GITHUB_DEVICE_FLOW_CLIENT_ID;
 }
 function sleep4(ms) {
-  return new Promise((resolve38) => setTimeout(resolve38, ms));
+  return new Promise((resolve39) => setTimeout(resolve39, ms));
 }
 async function requestDeviceCode(options2) {
   const clientId = options2?.clientId ?? getGithubDeviceFlowClientId();
@@ -510799,7 +511265,7 @@ var init_mcp = __esm(() => {
 
 // src/capabilities/plugins/parseMarketplaceInput.ts
 import { homedir as homedir36 } from "os";
-import { resolve as resolve38 } from "path";
+import { resolve as resolve39 } from "path";
 async function parseMarketplaceInput(input) {
   const trimmed = input.trim();
   const fs4 = getFsImplementation();
@@ -510834,7 +511300,7 @@ async function parseMarketplaceInput(input) {
   const isWindows2 = process.platform === "win32";
   const isWindowsPath = isWindows2 && (trimmed.startsWith(".\\") || trimmed.startsWith("..\\") || /^[a-zA-Z]:[/\\]/.test(trimmed));
   if (trimmed.startsWith("../../utils/plugins") || trimmed.startsWith("../../utils") || trimmed.startsWith("/") || trimmed.startsWith("~") || isWindowsPath) {
-    const resolvedPath = resolve38(trimmed.startsWith("~") ? trimmed.replace(/^~/, homedir36()) : trimmed);
+    const resolvedPath = resolve39(trimmed.startsWith("~") ? trimmed.replace(/^~/, homedir36()) : trimmed);
     let stats;
     try {
       stats = await fs4.stat(resolvedPath);
@@ -539762,7 +540228,7 @@ var init_bridge_kick = __esm(() => {
 var call58 = async () => {
   return {
     type: "text",
-    value: `${"99.0.0"} (built ${"2026-07-16T03:27:09.740Z"})`
+    value: `${"99.0.0"} (built ${"2026-07-21T10:56:17.312Z"})`
   };
 }, version2, version_default;
 var init_version = __esm(() => {
@@ -543899,8 +544365,8 @@ async function withStatsCacheLock(fn) {
     await statsCacheLockPromise;
   }
   let releaseLock2;
-  statsCacheLockPromise = new Promise((resolve40) => {
-    releaseLock2 = resolve40;
+  statsCacheLockPromise = new Promise((resolve41) => {
+    releaseLock2 = resolve41;
   });
   try {
     return await fn();
@@ -548246,7 +548712,7 @@ async function scanAllSessions() {
       });
     }
     if (i3 % 10 === 9) {
-      await new Promise((resolve40) => setImmediate(resolve40));
+      await new Promise((resolve41) => setImmediate(resolve41));
     }
   }
   allSessions.sort((a2, b) => b.mtime - a2.mtime);
@@ -552445,7 +552911,7 @@ __export(exports_UI12, {
   getToolUseSummary: () => getToolUseSummary11,
   countLines: () => countLines
 });
-import { isAbsolute as isAbsolute24, relative as relative31, resolve as resolve40 } from "path";
+import { isAbsolute as isAbsolute24, relative as relative31, resolve as resolve41 } from "path";
 function countLines(content) {
   const parts = content.split(EOL5);
   return content.endsWith(EOL5) ? parts.length - 1 : parts.length;
@@ -552769,7 +553235,7 @@ function WriteRejectionBody(t0) {
 }
 async function loadRejectionDiff2(filePath, content) {
   try {
-    const fullFilePath = isAbsolute24(filePath) ? filePath : resolve40(getCwd3(), filePath);
+    const fullFilePath = isAbsolute24(filePath) ? filePath : resolve41(getCwd3(), filePath);
     const handle = await openForScan(fullFilePath);
     if (handle === null)
       return {
@@ -555527,12 +555993,12 @@ async function getMessagesForSlashCommand(commandName, args, setToolJSX, context
   try {
     switch (command9.type) {
       case "local-jsx": {
-        return new Promise((resolve41) => {
+        return new Promise((resolve42) => {
           let doneWasCalled = false;
           const onDone = (result, options2) => {
             doneWasCalled = true;
             if (options2?.display === "skip") {
-              resolve41({
+              resolve42({
                 messages: [],
                 shouldQuery: false,
                 command: command9,
@@ -555546,7 +556012,7 @@ async function getMessagesForSlashCommand(commandName, args, setToolJSX, context
               isMeta: true
             }));
             const skipTranscript = isFullscreenEnvEnabled() && typeof result === "string" && result.endsWith(" dismissed");
-            resolve41({
+            resolve42({
               messages: options2?.display === "system" ? skipTranscript ? metaMessages : [createCommandInputMessage(formatCommandInput(command9, args)), createCommandInputMessage(`<local-command-stdout>${result}</local-command-stdout>`), ...metaMessages] : [createUserMessage({
                 content: prepareUserContent({
                   inputString: formatCommandInput(command9, args),
@@ -555570,7 +556036,7 @@ async function getMessagesForSlashCommand(commandName, args, setToolJSX, context
             if (jsx == null)
               return;
             if (context7.options.isNonInteractiveSession) {
-              resolve41({
+              resolve42({
                 messages: [],
                 shouldQuery: false,
                 command: command9
@@ -555596,7 +556062,7 @@ async function getMessagesForSlashCommand(commandName, args, setToolJSX, context
               shouldHidePromptInput: false,
               clearLocalJSX: true
             });
-            resolve41({
+            resolve42({
               messages: [],
               shouldQuery: false,
               command: command9
@@ -556580,12 +557046,12 @@ var init_It2SetupPrompt = __esm(() => {
 });
 
 // src/cli/utils/swarm/it2SetupLauncherImpl.tsx
-var React161, launchIt2Setup = ({ setToolJSX, tmuxAvailable: tmuxAvailable2 }) => new Promise((resolve41) => {
+var React161, launchIt2Setup = ({ setToolJSX, tmuxAvailable: tmuxAvailable2 }) => new Promise((resolve42) => {
   setToolJSX({
     jsx: React161.createElement(It2SetupPrompt, {
       onDone: (result) => {
         setToolJSX(null);
-        resolve41(result);
+        resolve42(result);
       },
       tmuxAvailable: tmuxAvailable2
     }),
@@ -556937,8 +557403,8 @@ async function handleMcpjsonServerApprovals(root2) {
   if (pendingServers.length === 0) {
     return;
   }
-  await new Promise((resolve41) => {
-    const done = () => void resolve41();
+  await new Promise((resolve42) => {
+    const done = () => void resolve42();
     if (pendingServers.length === 1 && pendingServers[0] !== undefined) {
       const serverName = pendingServers[0];
       root2.render(/* @__PURE__ */ jsx_dev_runtime465.jsxDEV(AppStateProvider, {
@@ -557529,7 +557995,7 @@ function WelcomeV2() {
             dimColor: true,
             children: [
               "v",
-              "0.4.18",
+              "0.4.20",
               " "
             ]
           }, undefined, true, undefined, this)
@@ -557729,7 +558195,7 @@ function WelcomeV2() {
           dimColor: true,
           children: [
             "v",
-            "0.4.18",
+            "0.4.20",
             " "
           ]
         }, undefined, true, undefined, this)
@@ -557955,7 +558421,7 @@ function AppleTerminalWelcomeV2(t0) {
         dimColor: true,
         children: [
           "v",
-          "0.4.18",
+          "0.4.20",
           " "
         ]
       }, undefined, true, undefined, this);
@@ -558209,7 +558675,7 @@ function AppleTerminalWelcomeV2(t0) {
       dimColor: true,
       children: [
         "v",
-        "0.4.18",
+        "0.4.20",
         " "
       ]
     }, undefined, true, undefined, this);
@@ -559713,8 +560179,8 @@ function completeOnboarding() {
   }));
 }
 function showDialog(root2, renderer) {
-  return new Promise((resolve41) => {
-    const done = (result) => void resolve41(result);
+  return new Promise((resolve42) => {
+    const done = (result) => void resolve42(result);
     root2.render(renderer(done));
   });
 }
@@ -564857,6 +565323,27 @@ var init_server3 = __esm(() => {
   };
 });
 
+// src/cli/entrypoints/mcpToolDefinition.ts
+async function toMCPToolDefinition(tool, promptOptions) {
+  const inputJSONSchema = tool.inputJSONSchema;
+  let outputSchema32;
+  if (tool.outputSchema) {
+    const convertedSchema = zodToJsonSchema3(tool.outputSchema);
+    if (typeof convertedSchema === "object" && convertedSchema !== null && "type" in convertedSchema && convertedSchema.type === "object") {
+      outputSchema32 = convertedSchema;
+    }
+  }
+  return {
+    name: tool.name,
+    description: await tool.prompt(promptOptions),
+    inputSchema: inputJSONSchema ?? zodToJsonSchema3(tool.inputSchema),
+    ...outputSchema32 && { outputSchema: outputSchema32 }
+  };
+}
+var init_mcpToolDefinition = __esm(() => {
+  init_zodToJsonSchema2();
+});
+
 // src/cli/entrypoints/mcp.ts
 var exports_mcp2 = {};
 __export(exports_mcp2, {
@@ -564878,25 +565365,11 @@ async function startMCPServer(cwd, debug, verbose) {
     const toolPermissionContext = getEmptyToolPermissionContext2();
     const tools = getTools(toolPermissionContext);
     return {
-      tools: await Promise.all(tools.map(async (tool) => {
-        let outputSchema32;
-        if (tool.outputSchema) {
-          const convertedSchema = zodToJsonSchema3(tool.outputSchema);
-          if (typeof convertedSchema === "object" && convertedSchema !== null && "type" in convertedSchema && convertedSchema.type === "object") {
-            outputSchema32 = convertedSchema;
-          }
-        }
-        return {
-          ...tool,
-          description: await tool.prompt({
-            getToolPermissionContext: async () => toolPermissionContext,
-            tools,
-            agents: []
-          }),
-          inputSchema: zodToJsonSchema3(tool.inputSchema),
-          outputSchema: outputSchema32
-        };
-      }))
+      tools: await Promise.all(tools.map((tool) => toMCPToolDefinition(tool, {
+        getToolPermissionContext: async () => toolPermissionContext,
+        tools,
+        agents: []
+      })))
     };
   });
   server.setRequestHandler(CallToolRequestSchema, async ({ params: { name, arguments: args } }) => {
@@ -564988,7 +565461,7 @@ var init_mcp4 = __esm(() => {
   init_Shell();
   init_slowOperations();
   init_toolErrors();
-  init_zodToJsonSchema2();
+  init_mcpToolDefinition();
   if (resolveEnvVar("DISABLE_EXPERIMENTAL_BETAS") === undefined) {
     setEnvVar("DISABLE_EXPERIMENTAL_BETAS", "true");
   }
@@ -565169,7 +565642,7 @@ async function mcpDoctorHandler(name, options2) {
       process.stdout.write(`${formatDoctorReport(report)}
 `);
     }
-    await new Promise((resolve41) => setTimeout(resolve41, 50));
+    await new Promise((resolve42) => setTimeout(resolve42, 50));
     process.exit(report.summary.blocking > 0 ? 1 : 0);
     return;
   } catch (error41) {
@@ -566825,8 +567298,8 @@ class SerialBatchEventUploader {
     if (items.length === 0)
       return;
     while (this.pending.length + items.length > this.config.maxQueueSize && !this.closed) {
-      await new Promise((resolve41) => {
-        this.backpressureResolvers.push(resolve41);
+      await new Promise((resolve42) => {
+        this.backpressureResolvers.push(resolve42);
       });
     }
     if (this.closed)
@@ -566839,8 +567312,8 @@ class SerialBatchEventUploader {
       return Promise.resolve();
     }
     this.drain();
-    return new Promise((resolve41) => {
-      this.flushResolvers.push(resolve41);
+    return new Promise((resolve42) => {
+      this.flushResolvers.push(resolve42);
     });
   }
   close() {
@@ -566851,11 +567324,11 @@ class SerialBatchEventUploader {
     this.pending = [];
     this.sleepResolve?.();
     this.sleepResolve = null;
-    for (const resolve41 of this.backpressureResolvers)
-      resolve41();
+    for (const resolve42 of this.backpressureResolvers)
+      resolve42();
     this.backpressureResolvers = [];
-    for (const resolve41 of this.flushResolvers)
-      resolve41();
+    for (const resolve42 of this.flushResolvers)
+      resolve42();
     this.flushResolvers = [];
   }
   async drain() {
@@ -566890,8 +567363,8 @@ class SerialBatchEventUploader {
     } finally {
       this.draining = false;
       if (this.pending.length === 0) {
-        for (const resolve41 of this.flushResolvers)
-          resolve41();
+        for (const resolve42 of this.flushResolvers)
+          resolve42();
         this.flushResolvers = [];
       }
     }
@@ -566930,16 +567403,16 @@ class SerialBatchEventUploader {
   releaseBackpressure() {
     const resolvers2 = this.backpressureResolvers;
     this.backpressureResolvers = [];
-    for (const resolve41 of resolvers2)
-      resolve41();
+    for (const resolve42 of resolvers2)
+      resolve42();
   }
   sleep(ms) {
-    return new Promise((resolve41) => {
-      this.sleepResolve = resolve41;
-      setTimeout((self2, resolve42) => {
+    return new Promise((resolve42) => {
+      this.sleepResolve = resolve42;
+      setTimeout((self2, resolve43) => {
         self2.sleepResolve = null;
-        resolve42();
-      }, ms, this, resolve41);
+        resolve43();
+      }, ms, this, resolve42);
     });
   }
 }
@@ -573994,8 +574467,8 @@ ${m.text}
               const controller = new AbortController;
               activeOAuthFlows.set(serverName, controller);
               let resolveAuthUrl;
-              const authUrlPromise = new Promise((resolve41) => {
-                resolveAuthUrl = resolve41;
+              const authUrlPromise = new Promise((resolve42) => {
+                resolveAuthUrl = resolve42;
               });
               const oauthPromise = performMCPOAuthFlow(serverName, config3, (url3) => resolveAuthUrl(url3), controller.signal, {
                 skipBrowserOpen: true,
@@ -574108,8 +574581,8 @@ ${m.text}
           });
           const service = new OAuthService;
           let urlResolver;
-          const urlPromise = new Promise((resolve41) => {
-            urlResolver = resolve41;
+          const urlPromise = new Promise((resolve42) => {
+            urlResolver = resolve42;
           });
           const flow = service.startOAuthFlow(async (manualUrl, automaticUrl) => {
             urlResolver({ manualUrl, automaticUrl });
@@ -574495,8 +574968,8 @@ function createCanUseToolWithPermissionPrompt(permissionPromptTool) {
         }
       };
     }
-    const abortPromise = new Promise((resolve41) => {
-      combinedSignal.addEventListener("abort", () => resolve41("aborted"), {
+    const abortPromise = new Promise((resolve42) => {
+      combinedSignal.addEventListener("abort", () => resolve42("aborted"), {
         once: true
       });
     });
@@ -576656,7 +577129,7 @@ async function setupTokenHandler(root2) {
   const {
     ConsoleOAuthFlow: ConsoleOAuthFlow2
   } = await Promise.resolve().then(() => (init_ConsoleOAuthFlow(), exports_ConsoleOAuthFlow));
-  await new Promise((resolve41) => {
+  await new Promise((resolve42) => {
     root2.render(/* @__PURE__ */ jsx_dev_runtime486.jsxDEV(AppStateProvider, {
       onChangeAppState,
       children: /* @__PURE__ */ jsx_dev_runtime486.jsxDEV(KeybindingSetup, {
@@ -576680,7 +577153,7 @@ async function setupTokenHandler(root2) {
             }, undefined, true, undefined, this),
             /* @__PURE__ */ jsx_dev_runtime486.jsxDEV(ConsoleOAuthFlow2, {
               onDone: () => {
-                resolve41();
+                resolve42();
               },
               mode: "setup-token",
               startingMessage: "This will guide you through long-lived (1-year) auth token setup for your Claude account. Claude subscription required."
@@ -576716,7 +577189,7 @@ function DoctorWithPlugins(t0) {
 }
 async function doctorHandler(root2) {
   logEvent("tengu_doctor_command", {});
-  await new Promise((resolve41) => {
+  await new Promise((resolve42) => {
     root2.render(/* @__PURE__ */ jsx_dev_runtime486.jsxDEV(AppStateProvider, {
       children: /* @__PURE__ */ jsx_dev_runtime486.jsxDEV(KeybindingSetup, {
         children: /* @__PURE__ */ jsx_dev_runtime486.jsxDEV(MCPConnectionManager, {
@@ -576724,7 +577197,7 @@ async function doctorHandler(root2) {
           isStrictMcpConfig: false,
           children: /* @__PURE__ */ jsx_dev_runtime486.jsxDEV(DoctorWithPlugins, {
             onDone: () => {
-              resolve41();
+              resolve42();
             }
           }, undefined, false, undefined, this)
         }, undefined, false, undefined, this)
@@ -576742,14 +577215,14 @@ async function installHandler(target, options2) {
   const {
     install: install2
   } = await Promise.resolve().then(() => (init_install(), exports_install));
-  await new Promise((resolve41) => {
+  await new Promise((resolve42) => {
     const args = [];
     if (target)
       args.push(target);
     if (options2.force)
       args.push("--force");
     install2.call((result) => {
-      resolve41();
+      resolve42();
       process.exit(result.includes("failed") ? 1 : 0);
     }, {}, args);
   });
@@ -577195,7 +577668,7 @@ __export(exports_main, {
   main: () => main
 });
 import { readFileSync as readFileSync7 } from "fs";
-import { resolve as resolve41 } from "path";
+import { resolve as resolve42 } from "path";
 function logManagedSettings() {
   try {
     const policySettings = getSettingsForSource("policySettings");
@@ -577752,12 +578225,12 @@ ${getTmuxInstallInstructions2()}
         process.exit(1);
       }
       try {
-        const filePath = resolve41(options2.systemPromptFile);
+        const filePath = resolve42(options2.systemPromptFile);
         systemPrompt = readFileSync7(filePath, "utf8");
       } catch (error41) {
         const code = getErrnoCode(error41);
         if (code === "ENOENT") {
-          process.stderr.write(source_default.red(`Error: System prompt file not found: ${resolve41(options2.systemPromptFile)}
+          process.stderr.write(source_default.red(`Error: System prompt file not found: ${resolve42(options2.systemPromptFile)}
 `));
           process.exit(1);
         }
@@ -577774,12 +578247,12 @@ ${getTmuxInstallInstructions2()}
         process.exit(1);
       }
       try {
-        const filePath = resolve41(options2.appendSystemPromptFile);
+        const filePath = resolve42(options2.appendSystemPromptFile);
         appendSystemPrompt = readFileSync7(filePath, "utf8");
       } catch (error41) {
         const code = getErrnoCode(error41);
         if (code === "ENOENT") {
-          process.stderr.write(source_default.red(`Error: Append system prompt file not found: ${resolve41(options2.appendSystemPromptFile)}
+          process.stderr.write(source_default.red(`Error: Append system prompt file not found: ${resolve42(options2.appendSystemPromptFile)}
 `));
           process.exit(1);
         }
@@ -577825,7 +578298,7 @@ ${addendum}` : addendum;
             errors4 = result.errors;
           }
         } else {
-          const configPath = resolve41(configItem);
+          const configPath = resolve42(configItem);
           const result = parseMcpConfigFromFilePath({
             filePath: configPath,
             expandVars: true,
@@ -578575,8 +579048,8 @@ ${customInstructions}` : customInstructions;
         return connectMcpBatch(dedupedClaudeAi, "claudeai");
       });
       let claudeaiTimer;
-      const claudeaiTimedOut = await Promise.race([claudeaiConnect.then(() => false), new Promise((resolve42) => {
-        claudeaiTimer = setTimeout((r) => r(true), CLAUDE_AI_MCP_TIMEOUT_MS, resolve42);
+      const claudeaiTimedOut = await Promise.race([claudeaiConnect.then(() => false), new Promise((resolve43) => {
+        claudeaiTimer = setTimeout((r) => r(true), CLAUDE_AI_MCP_TIMEOUT_MS, resolve43);
       })]);
       if (claudeaiTimer)
         clearTimeout(claudeaiTimer);
@@ -579047,7 +579520,7 @@ Usage: claude --remote "your task description"`, () => gracefulShutdown(1));
         }
       }
       if (options2.resume && typeof options2.resume === "string" && !maybeSessionId) {
-        const resolvedPath = resolve41(options2.resume);
+        const resolvedPath = resolve42(options2.resume);
         try {
           const resumeStart = performance.now();
           let logOption;
@@ -579191,7 +579664,7 @@ Usage: claude --remote "your task description"`, () => gracefulShutdown(1));
         pendingHookMessages
       }, renderAndRun);
     }
-  }).version("0.4.18 (OpenCow)", "-v, --version", "Output the version number");
+  }).version("0.4.20 (OpenCow)", "-v, --version", "Output the version number");
   program2.option("-w, --worktree [name]", "Create a new git worktree for this session (optionally specify a name)");
   program2.option("--tmux", "Create a tmux session for the worktree (requires --worktree). Uses iTerm2 native panes when available; use --tmux=classic for traditional tmux.");
   if (canUserConfigureAdvisor()) {
@@ -579836,7 +580309,7 @@ if (false) {}
 async function main2() {
   const args = process.argv.slice(2);
   if (args.length === 1 && (args[0] === "--version" || args[0] === "-v" || args[0] === "-V")) {
-    console.log(`${"0.4.18"} (OpenCow)`);
+    console.log(`${"0.4.20"} (OpenCow)`);
     return;
   }
   if (args.includes("--provider")) {
@@ -579954,4 +580427,4 @@ async function main2() {
 }
 main2();
 
-//# debugId=B28B6A1F66E05E3B64756E2164756E21
+//# debugId=ED002285A2B093B464756E2164756E21