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

package/dist/cli.mjs

@@ -94620,7 +94620,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.19"}${RESET}`);
   out.push("");
   process.stdout.write(out.join(`
 `) + `
@@ -241530,6 +241530,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,
@@ -244610,7 +244613,7 @@ function getAnthropicEnvMetadata() {
 function getBuildAgeMinutes() {
   if (false)
     ;
-  const buildTime = new Date("2026-07-16T03:27:09.740Z").getTime();
+  const buildTime = new Date("2026-07-20T09:45:03.714Z").getTime();
   if (isNaN(buildTime))
     return;
   return Math.floor((Date.now() - buildTime) / 60000);
@@ -247203,18 +247206,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 +248128,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 +248167,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 +248178,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 +248373,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 +248596,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 +248726,7 @@ var init_runAgent = __esm(() => {
   init_config7();
   init_permissions2();
   init_killShellTasks();
+  init_LocalAgentTask();
   init_attachments();
   init_errors2();
   init_file();
@@ -275179,6 +275302,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 +275491,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 +275516,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 +275776,7 @@ var init_LocalShellTask = __esm(() => {
   init_LocalAgentTask();
   init_killShellTasks();
   init_fsOperations();
+  init_backgroundTaskScope();
   PROMPT_PATTERNS = [
     /\(y\/n\)/i,
     /\[y\/n\]/i,
@@ -382400,7 +382599,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 +382612,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 +382674,7 @@ var init_TaskStopTool = __esm(() => {
   init_stopTask();
   init_slowOperations();
   init_toolUIRegistry();
+  init_backgroundAbortRegistry();
   ({
     renderToolResultMessage: renderToolResultMessage15,
     renderToolUseMessage: renderToolUseMessage15
@@ -382515,6 +382720,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}`,
@@ -491619,7 +491827,7 @@ function buildPrimarySection() {
   }, undefined, false, undefined, this);
   return [{
     label: "Version",
-    value: "0.4.18"
+    value: "0.4.19"
   }, {
     label: "Session name",
     value: nameValue
@@ -539762,7 +539970,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-20T09:45:03.714Z"})`
   };
 }, version2, version_default;
 var init_version = __esm(() => {
@@ -557529,7 +557737,7 @@ function WelcomeV2() {
             dimColor: true,
             children: [
               "v",
-              "0.4.18",
+              "0.4.19",
               " "
             ]
           }, undefined, true, undefined, this)
@@ -557729,7 +557937,7 @@ function WelcomeV2() {
           dimColor: true,
           children: [
             "v",
-            "0.4.18",
+            "0.4.19",
             " "
           ]
         }, undefined, true, undefined, this)
@@ -557955,7 +558163,7 @@ function AppleTerminalWelcomeV2(t0) {
         dimColor: true,
         children: [
           "v",
-          "0.4.18",
+          "0.4.19",
           " "
         ]
       }, undefined, true, undefined, this);
@@ -558209,7 +558417,7 @@ function AppleTerminalWelcomeV2(t0) {
       dimColor: true,
       children: [
         "v",
-        "0.4.18",
+        "0.4.19",
         " "
       ]
     }, undefined, true, undefined, this);
@@ -579191,7 +579399,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.19 (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 +580044,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.19"} (OpenCow)`);
     return;
   }
   if (args.includes("--provider")) {
@@ -579954,4 +580162,4 @@ async function main2() {
 }
 main2();
 
-//# debugId=B28B6A1F66E05E3B64756E2164756E21
+//# debugId=194C54719A60782464756E2164756E21