@within-7/minto 0.4.1 → 0.4.2

package/dist/tools/TaskTool/TaskTool.js

@@ -1,13 +1,13 @@
 import { last, memoize } from "lodash-es";
 import { dirname } from "path";
+import { execFileSync } from "child_process";
 import React from "react";
 import { Box, Text } from "ink";
 import { z } from "zod";
 import { FallbackToolUseRejectedMessage } from "../../components/FallbackToolUseRejectedMessage.js";
-import { getAgentPrompt } from "../../constants/prompts/index.js";
+import { getAgentPrompt, getSystemPrompt } from "../../constants/prompts/index.js";
 import { getContext } from "../../context.js";
 import { hasPermissionsToUseTool } from "../../permissions.js";
-import { query } from "../../query.js";
 import { formatDuration, formatNumber } from "../../utils/format.js";
 import {
   getMessagesPath,
@@ -18,7 +18,6 @@ import {
 import {
   createAssistantMessage,
   createUserMessage,
-  getLastAssistantMessageId,
   INTERRUPT_MESSAGE,
   normalizeMessages
 } from "../../utils/messages.js";
@@ -27,6 +26,7 @@ import { getMaxThinkingTokens } from "../../utils/thinking.js";
 import { getTheme } from "../../utils/theme.js";
 import { generateAgentId } from "../../utils/agentStorage.js";
 import { debug as debugLogger } from "../../utils/debugLogger.js";
+import { getTools, getReadOnlyTools } from "../../tools.js";
 import { getTaskTools, getPrompt } from "./prompt.js";
 import { TOOL_NAME } from "./constants.js";
 import {
@@ -37,15 +37,18 @@ import {
   createAgentTranscript,
   getResumableTranscript,
   appendMessageToTranscript,
-  updateAgentTranscript,
   completeAgentTranscript,
   failAgentTranscript,
   interruptAgentTranscript,
   canResumeTranscript,
   registerToolUseAgent
 } from "../../utils/agentTranscripts.js";
+import {
+  registerBackgroundAgent,
+  completeBackgroundAgent,
+  failBackgroundAgent
+} from "../../utils/backgroundAgentManager.js";
 import { UserFriendlyError } from "../../utils/userFriendlyError.js";
-import { execSync } from "child_process";
 import {
   pushAgentContext,
   popAgentContext,
@@ -65,6 +68,47 @@ import { getSkill, loadSkillContent } from "../../utils/skillLoader.js";
 import { getCwd } from "../../utils/state.js";
 import { getHookManager } from "../../utils/hookManager.js";
 import { substituteVariables } from "../../utils/stringSubstitution.js";
+import {
+  getTeam,
+  addTeammate,
+  updateTeammateStatus,
+  sanitizeTeamName
+} from "../../services/agentTeams/teamManager.js";
+import {
+  markTeammateIdle,
+  markTeammateCompleted
+} from "../../services/agentTeams/teammateSpawner.js";
+import { resolveBackend } from "../../services/agentTeams/backends/resolver.js";
+import {
+  registerInProcessAgent,
+  updateInProcessAgentState,
+  unregisterInProcessAgent
+} from "../../services/agentTeams/backends/inProcess.js";
+const DEFAULT_HEADLESS_TIMEOUT_MS = 10 * 60 * 1e3;
+function scopeEnvVars(vars, options) {
+  if (options?.inProcess) {
+    return () => {
+    };
+  }
+  const saved = {};
+  for (const key of Object.keys(vars)) {
+    saved[key] = process.env[key];
+    if (vars[key] !== void 0) {
+      process.env[key] = vars[key];
+    } else {
+      delete process.env[key];
+    }
+  }
+  return () => {
+    for (const key of Object.keys(saved)) {
+      if (saved[key] !== void 0) {
+        process.env[key] = saved[key];
+      } else {
+        delete process.env[key];
+      }
+    }
+  };
+}
 const inputSchema = z.object({
   description: z.string().describe("A short (3-5 word) description of the task"),
   prompt: z.string().describe("The task for the agent to perform"),
@@ -82,8 +126,19 @@ const inputSchema = z.object({
   ),
   max_turns: z.number().int().positive().optional().describe(
     "Maximum number of agentic turns (API round-trips) before stopping. Used internally for warmup."
+  ),
+  team_name: z.string().optional().describe(
+    "Optional team name. When provided, the subagent is spawned as a teammate with team context, discovery info, and team tools (SendMessage, TaskCreate, etc.)."
+  ),
+  name: z.string().optional().describe(
+    'Optional human-readable name for this teammate (e.g., "researcher", "tester"). Used for team communication.'
+  ),
+  run_in_background: z.boolean().optional().describe(
+    "Set to true to run this agent in the background. The tool result will include an output_file path - use Read tool or Bash tail to check on output."
+  ),
+  isolation: z.enum(["worktree"]).optional().describe(
+    'Isolation mode. "worktree" creates a temporary git worktree so the agent works on an isolated copy of the repo.'
   )
-  // run_in_background parameter removed - concurrent execution is automatic
 });
 const TaskTool = {
   async prompt({ safeMode }) {
@@ -103,14 +158,28 @@ const TaskTool = {
     model,
     subagent_type,
     resume,
-    max_turns
+    max_turns,
+    team_name,
+    name: teammateName,
+    run_in_background,
+    isolation
   }, {
     abortController,
-    options: { safeMode = false, forkNumber, messageLogName, verbose },
+    options: {
+      safeMode = false,
+      safetyMode,
+      forkNumber,
+      messageLogName,
+      verbose
+    },
     readFileTimestamps,
     toolUseId
   }) {
     const startTime = Date.now();
+    const effectiveRunInBackground = team_name ? true : run_in_background;
+    if (team_name) {
+      team_name = sanitizeTeamName(team_name);
+    }
     const agentType = subagent_type || "general-purpose";
     let resumedTranscript = null;
     let agentId;
@@ -171,7 +240,9 @@ Use /agents command to manage agent configurations.`;
       }
       loadedAgentConfig = agentConfig;
       if (agentConfig.systemPrompt) {
-        effectivePrompt = `${agentConfig.systemPrompt}
+        effectivePrompt = `<system-reminder>
+${agentConfig.systemPrompt}
+</system-reminder>
 
 ${prompt}`;
       }
@@ -299,10 +370,11 @@ ${substitutedContent}
       }
     }
     let worktreePath = null;
-    if (loadedAgentConfig?.isolation === "worktree") {
+    const shouldUseWorktree = isolation === "worktree" || loadedAgentConfig?.isolation === "worktree";
+    if (shouldUseWorktree) {
       try {
         const tmpDir = `/tmp/minto-worktree-${agentId}`;
-        execSync(`git worktree add "${tmpDir}" HEAD`, {
+        execFileSync("git", ["worktree", "add", tmpDir, "HEAD"], {
           cwd: getCwd(),
           stdio: "pipe"
         });
@@ -314,6 +386,10 @@ ${effectivePrompt}`;
           agentId,
           worktreePath
         });
+        const hookMgrCreate = getHookManager();
+        hookMgrCreate?.executeWorktreeCreate(worktreePath, agentId, agentType).catch(
+          (err) => debugLogger.trace("HOOK_WORKTREE_CREATE", { error: err })
+        );
       } catch (err) {
         debugLogger.warn("TASK_AGENT_WORKTREE_FAILED", {
           agentId,
@@ -321,24 +397,376 @@ ${effectivePrompt}`;
         });
       }
     }
-    const messages = resumedTranscript ? [...resumedTranscript.messages] : [createUserMessage(effectivePrompt)];
+    let restoreEnvVars = null;
+    if (team_name) {
+      const teammateAgentId = teammateName ? `${teammateName}@${team_name}` : `${agentType}@${team_name}`;
+      try {
+        const { getTeammateColor } = await import("../../constants/agentTeams.js");
+        const teamEntry = getTeam(team_name);
+        const colorIndex = teamEntry?.team.members.length ?? 0;
+        addTeammate(team_name, {
+          id: teammateAgentId,
+          name: teammateName || agentType,
+          agentType,
+          status: "working",
+          prompt,
+          color: getTeammateColor(colorIndex)
+        });
+      } catch {
+      }
+      if (worktreePath && team_name) {
+        try {
+          const { updateTeammateWorktree } = await import("../../services/agentTeams/teamManager.js");
+          updateTeammateWorktree(
+            team_name,
+            teammateName ? `${teammateName}@${team_name}` : `${agentType}@${team_name}`,
+            worktreePath
+          );
+        } catch {
+        }
+      }
+      const effectiveAgentName = teammateName || agentType;
+      let planModeValue;
+      try {
+        const teamEntry = getTeam(team_name);
+        const member = teamEntry?.team.members.find(
+          (m) => m.id === teammateAgentId
+        );
+        planModeValue = member?.planModeRequired ? "1" : void 0;
+      } catch {
+      }
+      const earlyBackend = resolveBackend(
+        getTeam(team_name)?.team.config.displayMode
+      );
+      const isInProcessBackend = earlyBackend.mode === "in-process";
+      const parentDepth = parseInt(
+        process.env.MINTO_AGENT_DEPTH ?? process.env.CLAUDE_AGENT_DEPTH ?? "0",
+        10
+      ) || 0;
+      const childDepth = String(parentDepth + 1);
+      restoreEnvVars = scopeEnvVars(
+        {
+          MINTO_TEAM_NAME: team_name,
+          MINTO_AGENT_ID: teammateAgentId,
+          MINTO_AGENT_TYPE: agentType,
+          MINTO_AGENT_NAME: effectiveAgentName,
+          MINTO_PLAN_MODE_REQUIRED: planModeValue,
+          MINTO_AGENT_DEPTH: childDepth,
+          // CC compat: set CLAUDE_CODE_* so CC ecosystem tools can read them
+          CLAUDE_CODE_TEAM_NAME: team_name,
+          CLAUDE_CODE_AGENT_ID: teammateAgentId,
+          CLAUDE_CODE_AGENT_TYPE: agentType,
+          CLAUDE_CODE_AGENT_NAME: effectiveAgentName,
+          CLAUDE_CODE_PLAN_MODE_REQUIRED: planModeValue,
+          CLAUDE_AGENT_DEPTH: childDepth
+        },
+        { inProcess: isInProcessBackend }
+      );
+      let teamDiscovery = "";
+      try {
+        const { getTeam: getTeamFn } = await import("../../services/agentTeams/teamManager.js");
+        const entry = getTeamFn(team_name);
+        if (entry) {
+          const otherMembers = entry.team.members.filter((m) => m.id !== teammateAgentId && m.name !== teammateName).map((m) => `  - ${m.name} (${m.agentType}): ${m.status}`).join("\n");
+          if (otherMembers) {
+            teamDiscovery = `
+Team members:
+${otherMembers}`;
+          }
+        }
+      } catch {
+      }
+      const teamContext = `
+# Agent Teammate Communication
+
+You are agent "${teammateName || agentType}" in team "${team_name}".
+
+## CRITICAL: Reporting Results
+
+**You MUST use the SendMessage tool to report your results to the team lead.** Your text output is NOT visible to the team lead or any teammate. The ONLY way to deliver your findings is via SendMessage.
+
+When you finish your task:
+1. Use SendMessage with type "message", recipient "team-lead", and your findings as content
+2. Include a brief summary in the summary field
+3. Do NOT just output text \u2014 it will be lost
+
+## Communication
+
+- Use SendMessage with type \`message\` to send messages to specific teammates
+- Use SendMessage with type \`broadcast\` sparingly for team-wide announcements
+- Do NOT send acknowledgment messages ("Got it", "\u5DF2\u6536\u5230") \u2014 only send when you have actionable content
+- ALWAYS respond in the same language as the user's original request
+
+**User guidance**: Sometimes the user may send you direct messages that appear in \`<user-guidance>\` tags. When you receive user guidance, respond directly in your text output \u2014 do NOT forward it to the team lead via SendMessage. The user can see your text output in the focus view.
+
+Team: ${team_name}
+Your agent ID: ${teammateAgentId}
+Your agent type: ${agentType}${teamDiscovery}
+`;
+      effectivePrompt = `<system-reminder>
+${teamContext}
+</system-reminder>
+
+` + effectivePrompt;
+      agentId = teammateAgentId;
+      if (toolUseId) {
+        registerToolUseAgent(toolUseId, agentId);
+      }
+      const backend = resolveBackend(
+        getTeam(team_name)?.team.config.displayMode
+      );
+      effectivePermissionMode = safeMode ? "plan" : "acceptEdits";
+      if (backend.mode !== "in-process") {
+        try {
+          const spawnTeamEntry = getTeam(team_name);
+          const spawnMember = spawnTeamEntry?.team.members.find(
+            (m) => m.id === teammateAgentId
+          );
+          const handle = await backend.spawn({
+            agentId: teammateAgentId,
+            agentName: teammateName || agentType,
+            teamName: team_name,
+            agentType,
+            prompt,
+            model: effectiveModel !== "task" ? effectiveModel : void 0,
+            cwd: process.cwd(),
+            maxTurns: max_turns,
+            mode: effectivePermissionMode,
+            planModeRequired: spawnMember?.planModeRequired,
+            color: spawnMember?.color,
+            parentSessionId: spawnTeamEntry?.team.leadSessionId
+          });
+          createAgentTranscript({
+            agentId: teammateAgentId,
+            agentType,
+            toolUseId,
+            description: description || teammateName || agentType,
+            prompt,
+            model: effectiveModel,
+            forkNumber,
+            messageLogName,
+            messages: [createUserMessage(effectivePrompt)],
+            toolUseCount: 0,
+            metadata: { isBackground: true }
+          });
+          yield {
+            type: "progress",
+            content: createAssistantMessage(
+              `Teammate "${teammateName || agentType}" spawned as independent process (headless mode, agent ID: ${teammateAgentId})`
+            )
+          };
+          if (effectiveRunInBackground) {
+            registerBackgroundAgent(
+              teammateAgentId,
+              agentType,
+              description,
+              abortController
+            );
+            (async () => {
+              const HEADLESS_TIMEOUT_MS2 = DEFAULT_HEADLESS_TIMEOUT_MS;
+              let exitCode2 = null;
+              await new Promise((resolve) => {
+                const timeoutId = setTimeout(() => {
+                  debugLogger.warn("HEADLESS_AGENT_TIMEOUT", {
+                    agentId: teammateAgentId,
+                    timeoutMs: HEADLESS_TIMEOUT_MS2
+                  });
+                  backend.kill(handle).then(resolve, resolve);
+                }, HEADLESS_TIMEOUT_MS2);
+                backend.onExit(handle, (code) => {
+                  exitCode2 = code;
+                  clearTimeout(timeoutId);
+                  resolve();
+                });
+                if (!backend.isAlive(handle)) {
+                  clearTimeout(timeoutId);
+                  resolve();
+                }
+                if (abortController.signal.aborted) {
+                  clearTimeout(timeoutId);
+                  backend.kill(handle).then(resolve, resolve);
+                } else {
+                  abortController.signal.addEventListener(
+                    "abort",
+                    () => {
+                      clearTimeout(timeoutId);
+                      backend.kill(handle).then(resolve, resolve);
+                    },
+                    { once: true }
+                  );
+                }
+              });
+              if (exitCode2 !== null && exitCode2 !== 0) {
+                updateTeammateStatus(team_name, teammateAgentId, "stopped");
+                failBackgroundAgent(teammateAgentId, `exit code ${exitCode2}`);
+                failAgentTranscript(teammateAgentId, `exit code ${exitCode2}`);
+              } else {
+                markTeammateCompleted(
+                  team_name,
+                  teammateAgentId,
+                  teammateName || agentType,
+                  {
+                    summary: `Teammate "${teammateName || agentType}" completed.`
+                  }
+                ).catch(
+                  (err) => debugLogger.trace("MARK_TEAMMATE_COMPLETED", { error: err })
+                );
+                completeBackgroundAgent(teammateAgentId, [
+                  {
+                    type: "text",
+                    text: `Teammate "${teammateName || agentType}" completed.`
+                  }
+                ]);
+                completeAgentTranscript(teammateAgentId);
+              }
+            })();
+            const bgResultText = `Agent "${teammateName || agentType}" running in background`;
+            yield {
+              type: "result",
+              data: [{ type: "text", text: bgResultText }],
+              resultForAssistant: `Teammate "${teammateName || agentType}" is running in the background. You will be notified automatically when they finish \u2014 do NOT check on them.`
+            };
+            hasYieldedResult = true;
+            return;
+          }
+          const HEADLESS_TIMEOUT_MS = DEFAULT_HEADLESS_TIMEOUT_MS;
+          let exitCode = null;
+          await new Promise((resolve) => {
+            const timeoutId = setTimeout(() => {
+              debugLogger.warn("HEADLESS_AGENT_TIMEOUT", {
+                agentId: teammateAgentId,
+                timeoutMs: HEADLESS_TIMEOUT_MS
+              });
+              backend.kill(handle).then(resolve, resolve);
+            }, HEADLESS_TIMEOUT_MS);
+            backend.onExit(handle, (code) => {
+              exitCode = code;
+              clearTimeout(timeoutId);
+              resolve();
+            });
+            if (!backend.isAlive(handle)) {
+              clearTimeout(timeoutId);
+              resolve();
+            }
+            if (abortController.signal.aborted) {
+              clearTimeout(timeoutId);
+              backend.kill(handle).then(resolve, resolve);
+            } else {
+              abortController.signal.addEventListener(
+                "abort",
+                () => {
+                  clearTimeout(timeoutId);
+                  backend.kill(handle).then(resolve, resolve);
+                },
+                { once: true }
+              );
+            }
+          });
+          markTeammateCompleted(
+            team_name,
+            teammateAgentId,
+            teammateName || agentType,
+            {
+              summary: `Teammate "${teammateName || agentType}" completed.`
+            }
+          ).catch(
+            (err) => debugLogger.trace("MARK_TEAMMATE_COMPLETED", { error: err })
+          );
+          const teamEntry = getTeam(team_name);
+          const leadId = `team-lead@${team_name}`;
+          let agentResultText = `Teammate "${teammateName || agentType}" completed.`;
+          if (exitCode !== null && exitCode !== 0) {
+            agentResultText = `Teammate "${teammateName || agentType}" failed (exit code ${exitCode}). The agent process encountered an error during startup or execution.`;
+            failAgentTranscript(teammateAgentId, agentResultText);
+          } else {
+            completeAgentTranscript(teammateAgentId);
+          }
+          if (teamEntry) {
+            const unread = teamEntry.mailbox.getUnread(leadId);
+            const fromAgent = unread.filter((m) => m.from === teammateAgentId);
+            if (fromAgent.length > 0) {
+              const {
+                parseIdleNotification,
+                formatIdleNotificationForInjection,
+                formatTeamMessage
+              } = require("../../services/agentTeams/messageFormatter");
+              agentResultText = fromAgent.map((m) => {
+                const idleData = parseIdleNotification(m.text);
+                if (idleData) {
+                  return formatIdleNotificationForInjection(idleData);
+                }
+                return formatTeamMessage(m);
+              }).join("\n\n");
+              teamEntry.mailbox.markRead(fromAgent.map((m) => m.id));
+            }
+          }
+          yield {
+            type: "result",
+            data: [
+              {
+                type: "text",
+                text: agentResultText
+              }
+            ],
+            resultForAssistant: agentResultText
+          };
+          hasYieldedResult = true;
+          return;
+        } catch (spawnError) {
+          debugLogger.warn("HEADLESS_SPAWN_FAILED", {
+            agentId: teammateAgentId,
+            error: spawnError instanceof Error ? spawnError.message : String(spawnError)
+          });
+        }
+      }
+    }
+    if (team_name) {
+      registerInProcessAgent(agentId, effectivePermissionMode);
+    }
+    let messages = resumedTranscript ? [...resumedTranscript.messages] : [];
     let tools = await getTaskTools(safeMode);
     let allowedSubagentTypes = null;
     if (toolFilter) {
       const isAllArray = Array.isArray(toolFilter) && toolFilter.length === 1 && toolFilter[0] === "*";
       if (toolFilter === "*" || isAllArray) {
       } else if (Array.isArray(toolFilter)) {
-        const taskPatterns = toolFilter.filter((t) => t.startsWith("Task(") && t.endsWith(")")).map((t) => t.slice(5, -1));
+        const taskPatterns = toolFilter.filter(
+          (t) => (t.startsWith("Agent(") || t.startsWith("Task(")) && t.endsWith(")")
+        ).map(
+          (t) => t.startsWith("Agent(") ? t.slice(6, -1) : t.slice(5, -1)
+        );
         if (taskPatterns.length > 0) {
           allowedSubagentTypes = taskPatterns;
         }
-        const baseToolNames = toolFilter.map((t) => t.startsWith("Task(") ? "Task" : t).filter((t, i, arr) => arr.indexOf(t) === i);
+        const baseToolNames = toolFilter.map(
+          (t) => t.startsWith("Agent(") || t.startsWith("Task(") ? TOOL_NAME : t
+        ).filter((t, i, arr) => arr.indexOf(t) === i);
         tools = tools.filter((tool) => baseToolNames.includes(tool.name));
       }
     }
     if (disallowedToolFilter?.length) {
       tools = tools.filter((tool) => !disallowedToolFilter.includes(tool.name));
     }
+    if (team_name) {
+      const currentDepth = parseInt(
+        process.env.MINTO_AGENT_DEPTH ?? process.env.CLAUDE_AGENT_DEPTH ?? "0",
+        10
+      ) || 0;
+      const teamToolNames = /* @__PURE__ */ new Set([
+        "SendMessage",
+        ...currentDepth < 2 ? [TOOL_NAME] : [],
+        "TaskCreate",
+        "TaskUpdate",
+        "TaskList",
+        "TaskGet"
+      ]);
+      const fullTools = await (!safeMode ? getTools() : getReadOnlyTools());
+      for (const tool of fullTools) {
+        if (teamToolNames.has(tool.name) && !tools.some((t) => t.name === tool.name)) {
+          tools.push(tool);
+        }
+      }
+    }
     if (effectivePermissionMode !== "default") {
       const modeConfig = MODE_CONFIGS[effectivePermissionMode];
       if (modeConfig && modeConfig.allowedTools[0] !== "*") {
@@ -394,7 +822,7 @@ ${effectivePrompt}`;
       tools
     };
     const [taskPrompt, context, maxThinkingTokens] = await Promise.all([
-      getAgentPrompt(),
+      team_name ? getSystemPrompt("teammate") : getAgentPrompt(),
       getContext(),
       getMaxThinkingTokens(messages)
     ]);
@@ -424,7 +852,8 @@ IMPORTANT: You are currently running as ${modelToUse}. You do not need to consul
         forkNumber,
         messageLogName,
         messages: [...messages],
-        toolUseCount: 0
+        toolUseCount: 0,
+        ...effectiveRunInBackground && team_name ? { metadata: { isBackground: true } } : {}
       });
     } else {
       appendMessageToTranscript(
@@ -435,106 +864,281 @@ IMPORTANT: You are currently running as ${modelToUse}. You do not need to consul
     const effectiveMaxThinkingTokens = agentMaxThinkingTokens ?? maxThinkingTokens;
     const queryOptions = {
       safeMode,
+      safetyMode,
       forkNumber,
       messageLogName,
       tools,
       commands: [],
       verbose,
       maxThinkingTokens: effectiveMaxThinkingTokens,
-      model: modelToUse
+      model: modelToUse,
+      ...effectivePermissionMode ? { permissionMode: effectivePermissionMode } : {}
     };
     if (temperature !== void 0) {
       queryOptions["temperature"] = temperature;
     }
-    pushAgentContext(agentId);
-    let turnCount = 0;
-    try {
-      for await (const message of query(
-        messages,
-        taskPrompt,
-        context,
-        hasPermissionsToUseTool,
-        {
-          abortController,
-          options: queryOptions,
-          messageId: getLastAssistantMessageId(messages),
-          agentId,
-          readFileTimestamps,
-          setToolJSX: () => {
-          }
-          // No-op implementation for TaskTool
-        }
-      )) {
-        messages.push(message);
-        appendMessageToTranscript(agentId, message);
-        overwriteLog(
-          getMessagesPath(messageLogName, forkNumber, getSidechainNumber()),
-          messages.filter((_) => _.type !== "progress")
+    let effectiveAbortController = abortController;
+    if (team_name) {
+      const agentAC = new AbortController();
+      if (abortController.signal.aborted) {
+        agentAC.abort();
+      } else {
+        abortController.signal.addEventListener(
+          "abort",
+          () => agentAC.abort(),
+          { once: true }
         );
-        if (message.type !== "assistant") {
-          continue;
-        }
-        turnCount++;
-        if (max_turns && turnCount >= max_turns) {
-          debugLogger.info("TASK_AGENT_MAX_TURNS_REACHED", {
+      }
+      effectiveAbortController = agentAC;
+      try {
+        const { registerAgentAbortController } = await import("../../services/agentTeams/teamManager.js");
+        registerAgentAbortController(team_name, agentId, agentAC);
+      } catch {
+      }
+    }
+    if (effectiveRunInBackground && team_name) {
+      registerBackgroundAgent(
+        agentId,
+        agentType,
+        description,
+        effectiveAbortController
+      );
+      (async () => {
+        pushAgentContext(agentId);
+        let bgToolUseCount = 0;
+        try {
+          const { AgentEngine } = await import("../../engine/AgentEngine.js");
+          const { getGlobalRegistry } = await import("../../engine/EngineRegistry.js");
+          const engine = new AgentEngine({
             agentId,
-            turnCount,
-            max_turns
-          });
-          break;
-        }
-        if (message.message.usage) {
-          updateAgentTranscript(agentId, {
-            tokenUsage: {
-              inputTokens: message.message.usage.input_tokens,
-              outputTokens: message.message.usage.output_tokens,
-              cacheReadTokens: message.message.usage.cache_read_input_tokens,
-              cacheCreationTokens: message.message.usage.cache_creation_input_tokens
+            name: teammateName || agentType,
+            role: "teammate",
+            teamName: team_name,
+            systemPrompt: team_name ? () => getSystemPrompt("teammate") : taskPrompt,
+            context,
+            tools: queryOptions.tools,
+            initialMessages: [...messages],
+            idleTimeoutMs: 3e4,
+            heartbeatIntervalMs: 500,
+            maxTurns: max_turns || void 0,
+            maxThinkingTokens: queryOptions.maxThinkingTokens,
+            model: queryOptions.model,
+            forkNumber,
+            messageLogName,
+            verbose: queryOptions.verbose,
+            safeMode: queryOptions.safeMode,
+            safetyMode: queryOptions.safetyMode,
+            permissionMode: effectivePermissionMode,
+            readFileTimestamps,
+            canUseTool: hasPermissionsToUseTool,
+            askUser: () => Promise.resolve([]),
+            setToolJSX: () => {
+            },
+            onMessage: (message) => {
+              appendMessageToTranscript(agentId, message);
+              overwriteLog(
+                getMessagesPath(
+                  messageLogName,
+                  forkNumber,
+                  getSidechainNumber()
+                ),
+                [...engine.messages].filter((_) => _.type !== "progress")
+              );
+              if (message.type === "assistant") {
+                for (const content of message.message.content) {
+                  if (content.type === "tool_use") bgToolUseCount++;
+                }
+              }
             }
           });
-        }
-        const normalizedMessages2 = normalizeMessages(messages);
-        for (const content of message.message.content) {
-          if (content.type === "text" && content.text && content.text !== INTERRUPT_MESSAGE) {
-            const preview = content.text.length > 200 ? content.text.substring(0, 200) + "..." : content.text;
-            yield {
-              type: "progress",
-              content: createAssistantMessage(`${preview}`),
-              normalizedMessages: normalizedMessages2,
-              tools
-            };
-          } else if (content.type === "tool_use") {
-            toolUseCount++;
-            const toolMessage = normalizedMessages2.find(
-              (_) => _.type === "assistant" && _.message.content[0]?.type === "tool_use" && _.message.content[0].id === content.id
+          const globalRegistry = getGlobalRegistry();
+          globalRegistry.register(agentId, engine);
+          if (effectiveAbortController.signal.aborted) {
+            engine.stop();
+          } else {
+            effectiveAbortController.signal.addEventListener(
+              "abort",
+              () => engine.stop(),
+              { once: true }
             );
-            if (toolMessage) {
-              const modifiedMessage = {
-                ...toolMessage,
-                message: {
-                  ...toolMessage.message,
-                  content: toolMessage.message.content.map((c) => {
-                    if (c.type === "tool_use" && c.id === content.id) {
-                      return {
-                        ...c,
-                        name: c.name
-                        // Keep original name, UI will handle display
-                      };
-                    }
-                    return c;
+          }
+          engine.on((event) => {
+            if (event.type === "state_change" && event.to === "stopped") {
+              globalRegistry.unregister(agentId);
+              if (hookMgr) {
+                hookMgr.executeSubagentStop(agentType, agentId).catch(
+                  (err) => debugLogger.warn("SubagentStop hook failed (Path B)", {
+                    error: err
                   })
+                );
+              }
+              const engineMessages = engine.messages;
+              const lastMessage = engineMessages[engineMessages.length - 1];
+              if (lastMessage?.type === "assistant") {
+                completeAgentTranscript(agentId);
+                completeBackgroundAgent(
+                  agentId,
+                  lastMessage.message.content.filter(
+                    (_) => _.type === "text"
+                  )
+                );
+                if (loadedAgentConfig?.hooks?.onComplete?.length) {
+                  const hookContext = createHookContext({
+                    sessionId: agentId,
+                    agentId,
+                    agentType,
+                    result: lastMessage.message.content.filter((_) => _.type === "text").map((_) => _.text).join("\n")
+                  });
+                  executeAgentHooks(
+                    "onComplete",
+                    loadedAgentConfig,
+                    hookContext
+                  ).catch(
+                    (err) => debugLogger.warn(
+                      "TASK_AGENT_ONCOMPLETE_HOOK_FAILED (Path B)",
+                      {
+                        agentId,
+                        agentType,
+                        error: err instanceof Error ? err.message : String(err)
+                      }
+                    )
+                  );
+                }
+                if (loadedAgentConfig?.memory) {
+                  const finalResponse = lastMessage.message.content.filter((_) => _.type === "text").map((_) => _.text).join("\n");
+                  if (finalResponse.trim()) {
+                    saveAgentMemory(
+                      agentType,
+                      loadedAgentConfig.memory,
+                      finalResponse
+                    ).catch(
+                      (err) => debugLogger.warn(
+                        "TASK_AGENT_MEMORY_SAVE_FAILED (Path B)",
+                        {
+                          agentId,
+                          agentType,
+                          error: err instanceof Error ? err.message : String(err)
+                        }
+                      )
+                    );
+                  }
                 }
-              };
-              yield {
-                type: "progress",
-                content: modifiedMessage,
-                normalizedMessages: normalizedMessages2,
-                tools
-              };
+              } else {
+                completeBackgroundAgent(agentId, [
+                  { type: "text", text: "Agent completed." }
+                ]);
+              }
+              const idleSummary = lastMessage?.type === "assistant" ? lastMessage.message.content.filter((_) => _.type === "text").map((_) => _.text).join("\n").slice(0, 2e3) || void 0 : void 0;
+              updateInProcessAgentState(agentId, {
+                isIdle: true,
+                lastReportedToolCount: bgToolUseCount
+              });
+              markTeammateCompleted(
+                team_name,
+                agentId,
+                teammateName || agentType,
+                {
+                  summary: idleSummary
+                }
+              ).catch((err) => {
+                debugLogger.error("TEAMMATE_MARK_COMPLETED_FAILED", {
+                  agentId,
+                  teamName: team_name,
+                  error: err instanceof Error ? err.message : String(err)
+                });
+              });
             }
+          });
+          await engine.start();
+          await engine.submitPrompt(effectivePrompt);
+          if (engine.isRunning) {
+            await new Promise((resolve) => {
+              engine.on((event) => {
+                if (event.type === "state_change" && event.to === "stopped") {
+                  resolve();
+                }
+              });
+            });
+          }
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : String(error);
+          failBackgroundAgent(agentId, errorMsg);
+          failAgentTranscript(agentId, errorMsg);
+          markTeammateIdle(team_name, agentId, teammateName || agentType, {
+            status: "failed",
+            failureReason: errorMsg
+          }).catch((err) => {
+            debugLogger.error("TEAMMATE_MARK_IDLE_FAILED", {
+              agentId,
+              teamName: team_name,
+              error: err instanceof Error ? err.message : String(err)
+            });
+          });
+          if (loadedAgentConfig?.hooks?.onError?.length) {
+            const hookContext = createHookContext({
+              sessionId: agentId,
+              agentId,
+              agentType,
+              error: error instanceof Error ? error : new Error(String(error))
+            });
+            executeAgentHooks("onError", loadedAgentConfig, hookContext).catch(
+              () => {
+              }
+            );
+          }
+        } finally {
+          popAgentContext();
+          cleanupAgentStreamingState(agentId);
+          unregisterInProcessAgent(agentId);
+        }
+      })();
+      const bgResultText = `Agent "${teammateName || agentType}" running in background`;
+      yield {
+        type: "result",
+        data: [{ type: "text", text: bgResultText }],
+        resultForAssistant: `Teammate "${teammateName || agentType}" is running in the background. You will be notified automatically when they finish \u2014 do NOT check on them.`
+      };
+      hasYieldedResult = true;
+      return;
+    }
+    pushAgentContext(agentId);
+    const messagesOut = {
+      current: messages
+    };
+    try {
+      const { runForegroundEngine } = await import("../../engine/foregroundAdapter.js");
+      for await (const item of runForegroundEngine({
+        agentId,
+        teamName: team_name,
+        teammateName,
+        agentType,
+        systemPrompt: team_name ? () => getSystemPrompt("teammate") : taskPrompt,
+        context,
+        tools: queryOptions.tools,
+        initialMessages: [...messages],
+        prompt: effectivePrompt,
+        maxTurns: max_turns || void 0,
+        maxThinkingTokens: queryOptions.maxThinkingTokens,
+        model: queryOptions.model,
+        forkNumber,
+        messageLogName,
+        sidechainNumber: getSidechainNumber(),
+        verbose: queryOptions.verbose,
+        safeMode: queryOptions.safeMode,
+        safetyMode: queryOptions.safetyMode,
+        permissionMode: effectivePermissionMode,
+        readFileTimestamps,
+        abortController: effectiveAbortController,
+        messagesOut
+      })) {
+        yield item;
+        if (item.type === "progress" && item.content?.message?.content) {
+          for (const c of item.content.message.content) {
+            if (c.type === "tool_use") toolUseCount++;
           }
         }
       }
+      messages = messagesOut.current;
       const normalizedMessages = normalizeMessages(messages);
       const lastMessage = last(messages);
       if (lastMessage?.type !== "assistant") {
@@ -615,9 +1219,26 @@ IMPORTANT: You are currently running as ${modelToUse}. You do not need to consul
           tools
         };
       }
+      if (team_name) {
+        updateInProcessAgentState(agentId, {
+          isIdle: true,
+          lastReportedToolCount: toolUseCount,
+          lastReportedTokenCount: lastMessage ? (lastMessage.message.usage.cache_creation_input_tokens ?? 0) + (lastMessage.message.usage.cache_read_input_tokens ?? 0) + lastMessage.message.usage.input_tokens + lastMessage.message.usage.output_tokens : 0
+        });
+        const idleSummary = isInterrupted ? void 0 : lastMessage.message.content.filter((_) => _.type === "text").map((_) => _.text).join("\n").slice(0, 2e3) || void 0;
+        markTeammateIdle(team_name, agentId, teammateName || agentType, {
+          status: isInterrupted ? "failed" : "completed",
+          summary: idleSummary,
+          ...isInterrupted && { failureReason: "interrupted" }
+        }).catch((err) => debugLogger.trace("MARK_TEAMMATE_IDLE", { error: err }));
+        unregisterInProcessAgent(agentId);
+      }
       const data = lastMessage.message.content.filter((_) => _.type === "text");
       const resultWithAgentId = isInterrupted ? `[Interrupted - Agent ID: ${agentId}]
-${this.renderResultForAssistant(data)}` : this.renderResultForAssistant(data);
+${this.renderResultForAssistant(data)}` : `${this.renderResultForAssistant(data)}
+
+Agent completed successfully.
+agentId: ${agentId}`;
       yield {
         type: "result",
         data,
@@ -691,11 +1312,13 @@ ${this.renderResultForAssistant(data)}` : this.renderResultForAssistant(data);
       hasYieldedResult = true;
     } finally {
       if (worktreePath) {
+        let removeSuccess = false;
         try {
-          execSync(`git worktree remove "${worktreePath}" --force`, {
+          execFileSync("git", ["worktree", "remove", worktreePath, "--force"], {
             cwd: getCwd(),
             stdio: "pipe"
           });
+          removeSuccess = true;
           debugLogger.info("TASK_AGENT_WORKTREE_REMOVED", {
             agentId,
             worktreePath
@@ -706,9 +1329,28 @@ ${this.renderResultForAssistant(data)}` : this.renderResultForAssistant(data);
             worktreePath
           });
         }
+        const hookMgrRemove = getHookManager();
+        hookMgrRemove?.executeWorktreeRemove(
+          worktreePath,
+          agentId,
+          agentType,
+          removeSuccess
+        ).catch(
+          (err) => debugLogger.trace("HOOK_WORKTREE_REMOVE", { error: err })
+        );
       }
       popAgentContext();
       cleanupAgentStreamingState(agentId);
+      if (team_name) {
+        try {
+          const { unregisterAgentAbortController } = await import("../../services/agentTeams/teamManager.js");
+          unregisterAgentAbortController(team_name, agentId);
+        } catch {
+        }
+      }
+      if (restoreEnvVars) {
+        restoreEnvVars();
+      }
       if (!hasYieldedResult) {
         interruptAgentTranscript(agentId);
         yield {
@@ -798,7 +1440,14 @@ ${this.renderResultForAssistant(data)}` : this.renderResultForAssistant(data);
   renderResultForAssistant(data) {
     return data.map((block) => block.type === "text" ? block.text : "").join("\n");
   },
-  renderToolUseMessage({ description, prompt, model_name, subagent_type }, { verbose }) {
+  renderToolUseMessage({
+    description,
+    prompt,
+    model_name,
+    subagent_type,
+    team_name,
+    name: teammateName
+  }, { verbose }) {
     if (!description || !prompt) return null;
     const modelManager = getModelManager();
     const defaultTaskModel = modelManager.getModelName("task");
@@ -806,6 +1455,21 @@ ${this.renderResultForAssistant(data)}` : this.renderResultForAssistant(data);
     const agentType = subagent_type || "general-purpose";
     const promptPreview = prompt.length > 80 ? prompt.substring(0, 80) + "..." : prompt;
     const theme = getTheme();
+    if (team_name) {
+      const displayName = teammateName || agentType;
+      if (verbose) {
+        return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, /* @__PURE__ */ React.createElement(Text, null, /* @__PURE__ */ React.createElement(Text, { color: theme.info }, "@", displayName), " ", /* @__PURE__ */ React.createElement(Text, { color: theme.secondaryText }, "(", agentType, ")"), ":", " ", description), /* @__PURE__ */ React.createElement(
+          Box,
+          {
+            paddingLeft: 2,
+            borderLeftStyle: "single",
+            borderLeftColor: theme.secondaryBorder
+          },
+          /* @__PURE__ */ React.createElement(Text, { color: theme.secondaryText }, promptPreview)
+        ));
+      }
+      return `@${displayName} (${agentType}): ${description}`;
+    }
     if (verbose) {
       return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, /* @__PURE__ */ React.createElement(Text, null, "[", agentType, "] ", actualModel, ": ", description), /* @__PURE__ */ React.createElement(
         Box,