@within-7/minto 0.4.2 → 0.4.3

package/dist/tools/TaskTool/TaskTool.js

@@ -1,1525 +0,0 @@
-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, getSystemPrompt } from "../../constants/prompts/index.js";
-import { getContext } from "../../context.js";
-import { hasPermissionsToUseTool } from "../../permissions.js";
-import { formatDuration, formatNumber } from "../../utils/format.js";
-import {
-  getMessagesPath,
-  getNextAvailableLogSidechainNumber,
-  overwriteLog,
-  logError
-} from "../../utils/log.js";
-import {
-  createAssistantMessage,
-  createUserMessage,
-  INTERRUPT_MESSAGE,
-  normalizeMessages
-} from "../../utils/messages.js";
-import { getModelManager } from "../../utils/model.js";
-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 {
-  getAgentByType,
-  getAvailableAgentTypes
-} from "../../utils/agentLoader.js";
-import {
-  createAgentTranscript,
-  getResumableTranscript,
-  appendMessageToTranscript,
-  completeAgentTranscript,
-  failAgentTranscript,
-  interruptAgentTranscript,
-  canResumeTranscript,
-  registerToolUseAgent
-} from "../../utils/agentTranscripts.js";
-import {
-  registerBackgroundAgent,
-  completeBackgroundAgent,
-  failBackgroundAgent
-} from "../../utils/backgroundAgentManager.js";
-import { UserFriendlyError } from "../../utils/userFriendlyError.js";
-import {
-  pushAgentContext,
-  popAgentContext,
-  cleanupAgentStreamingState
-} from "../../utils/streamingState.js";
-import {
-  validateAgentPermission,
-  MODE_CONFIGS
-} from "../../types/PermissionMode.js";
-import { executeAgentHooks, createHookContext } from "../../utils/agentHookExecutor.js";
-import {
-  loadAgentMemory,
-  saveAgentMemory,
-  formatMemoryForPrompt
-} from "../../utils/agentMemory.js";
-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"),
-  model_name: z.string().optional().describe(
-    "Optional: Specific model name to use for this task. If not provided, uses the default task model pointer."
-  ),
-  model: z.enum(["sonnet", "opus", "haiku"]).optional().describe(
-    "Optional model hint for this agent. Maps to configured model pointers: sonnet\u2192main, opus\u2192reasoning, haiku\u2192quick. If not specified, uses the task model pointer. Prefer haiku for quick, straightforward tasks."
-  ),
-  subagent_type: z.string().optional().describe(
-    'The specialized agent type to use. MUST be an exact name from the available agents list in the tool description. Defaults to "general-purpose" if not specified.'
-  ),
-  resume: z.string().optional().describe(
-    "Optional agent ID to resume from. If provided, the agent will continue from the previous execution transcript."
-  ),
-  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.'
-  )
-});
-const TaskTool = {
-  async prompt({ safeMode }) {
-    return await getPrompt(safeMode);
-  },
-  name: TOOL_NAME,
-  async description() {
-    const availableTypes = await getAvailableAgentTypes();
-    const typesList = availableTypes.join(", ");
-    return `Launch a specialized agent to handle tasks autonomously. You MUST use an exact agent type name from this list: ${typesList}. Default to "general-purpose" if unsure.`;
-  },
-  inputSchema,
-  async *call({
-    description,
-    prompt,
-    model_name,
-    model,
-    subagent_type,
-    resume,
-    max_turns,
-    team_name,
-    name: teammateName,
-    run_in_background,
-    isolation
-  }, {
-    abortController,
-    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;
-    if (resume) {
-      resumedTranscript = getResumableTranscript(resume);
-      if (!resumedTranscript) {
-        yield {
-          type: "result",
-          data: [
-            {
-              type: "text",
-              text: `Cannot resume agent '${resume}': transcript not found or not resumable (status must be 'running' or 'interrupted')`
-            }
-          ],
-          resultForAssistant: `Cannot resume agent '${resume}': transcript not found or not resumable`
-        };
-        return;
-      }
-      agentId = resume;
-      debugLogger.info("TASK_AGENT_RESUMING", {
-        agentId,
-        agentType: resumedTranscript.agentType,
-        messageCount: resumedTranscript.messages.length,
-        previousStatus: resumedTranscript.status
-      });
-    } else {
-      agentId = generateAgentId();
-    }
-    if (toolUseId) {
-      registerToolUseAgent(toolUseId, agentId);
-    }
-    let hasYieldedResult = false;
-    let effectivePrompt = prompt;
-    let effectiveModel = model_name || "task";
-    let toolFilter = null;
-    let disallowedToolFilter = null;
-    let temperature = void 0;
-    let agentMaxThinkingTokens = void 0;
-    let effectivePermissionMode = "default";
-    let loadedAgentConfig = null;
-    if (agentType) {
-      const agentConfig = await getAgentByType(agentType);
-      if (!agentConfig) {
-        const availableTypes = await getAvailableAgentTypes();
-        const helpMessage = `Agent type '${agentType}' not found.
-
-Available agents:
-${availableTypes.map((t) => `  \u2022 ${t}`).join("\n")}
-
-Use /agents command to manage agent configurations.`;
-        yield {
-          type: "result",
-          data: [{ type: "text", text: helpMessage }],
-          resultForAssistant: helpMessage
-        };
-        hasYieldedResult = true;
-        return;
-      }
-      loadedAgentConfig = agentConfig;
-      if (agentConfig.systemPrompt) {
-        effectivePrompt = `<system-reminder>
-${agentConfig.systemPrompt}
-</system-reminder>
-
-${prompt}`;
-      }
-      if (!model_name && agentConfig.model_name) {
-        if (agentConfig.model_name !== "inherit") {
-          effectiveModel = agentConfig.model_name;
-        }
-      }
-      toolFilter = agentConfig.tools;
-      if (agentConfig.disallowedTools?.length) {
-        disallowedToolFilter = agentConfig.disallowedTools;
-      }
-      if (agentConfig.maxThinkingTokens) {
-        agentMaxThinkingTokens = agentConfig.maxThinkingTokens;
-      }
-      if (agentConfig.permissionMode) {
-        const sessionMode = safeMode ? "plan" : "default";
-        effectivePermissionMode = validateAgentPermission(
-          agentConfig.permissionMode,
-          sessionMode
-        );
-      }
-      if (agentConfig.memory) {
-        try {
-          const memoryContent = await loadAgentMemory(
-            agentConfig.agentType,
-            agentConfig.memory
-          );
-          if (memoryContent) {
-            effectivePrompt = formatMemoryForPrompt(memoryContent, agentConfig.agentType) + "\n" + effectivePrompt;
-          }
-        } catch (error) {
-          debugLogger.warn("TASK_AGENT_MEMORY_LOAD_FAILED", {
-            agentId,
-            agentType,
-            error: error instanceof Error ? error.message : String(error)
-          });
-        }
-      }
-      if (agentConfig.skills?.length) {
-        for (const skillName of agentConfig.skills) {
-          try {
-            const skill = getSkill(skillName);
-            if (skill) {
-              const skillContent = await loadSkillContent(skill);
-              const skillBaseDir = dirname(skill.filePath);
-              const resolvedContent = skillContent.replace(
-                /\{baseDir\}/g,
-                skillBaseDir
-              );
-              const substitutedContent = await substituteVariables(
-                resolvedContent,
-                "",
-                // No arguments for preloaded skills
-                {
-                  sessionId: agentId,
-                  cwd: process.cwd(),
-                  env: { BASE_DIR: skillBaseDir }
-                }
-              );
-              effectivePrompt += `
-
-<preloaded-skill name="${skillName}">
-${substitutedContent}
-</preloaded-skill>`;
-            }
-          } catch (error) {
-            debugLogger.warn("TASK_AGENT_SKILL_PRELOAD_FAILED", {
-              agentId,
-              skillName,
-              error: error instanceof Error ? error.message : String(error)
-            });
-          }
-        }
-      }
-      if (agentConfig.hooks?.onStart?.length) {
-        try {
-          const hookContext = createHookContext({
-            sessionId: agentId,
-            agentId,
-            agentType
-          });
-          const hookResult = await executeAgentHooks(
-            "onStart",
-            agentConfig,
-            hookContext
-          );
-          if (!hookResult.continue) {
-            yield {
-              type: "result",
-              data: [
-                {
-                  type: "text",
-                  text: `Agent ${agentType} blocked by onStart hook: ${hookResult.reason || "Hook requested stop"}`
-                }
-              ],
-              resultForAssistant: `Agent blocked by onStart hook: ${hookResult.reason}`
-            };
-            hasYieldedResult = true;
-            return;
-          }
-        } catch (error) {
-          debugLogger.warn("TASK_AGENT_ONSTART_HOOK_FAILED", {
-            agentId,
-            agentType,
-            error: error instanceof Error ? error.message : String(error)
-          });
-        }
-      }
-    }
-    if (model) {
-      const modelPointerMap = {
-        sonnet: "main",
-        // Use main model for standard tasks
-        opus: "reasoning",
-        // Use reasoning model for complex tasks
-        haiku: "quick"
-        // Use quick model for fast tasks
-      };
-      const pointerType = modelPointerMap[model] || "task";
-      const modelManager = getModelManager();
-      const resolvedModelName = modelManager.getModelName(pointerType);
-      if (resolvedModelName) {
-        effectiveModel = resolvedModelName;
-      }
-    }
-    let worktreePath = null;
-    const shouldUseWorktree = isolation === "worktree" || loadedAgentConfig?.isolation === "worktree";
-    if (shouldUseWorktree) {
-      try {
-        const tmpDir = `/tmp/minto-worktree-${agentId}`;
-        execFileSync("git", ["worktree", "add", tmpDir, "HEAD"], {
-          cwd: getCwd(),
-          stdio: "pipe"
-        });
-        worktreePath = tmpDir;
-        effectivePrompt = `[Working in isolated git worktree: ${tmpDir}]
-
-${effectivePrompt}`;
-        debugLogger.info("TASK_AGENT_WORKTREE_CREATED", {
-          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,
-          error: err instanceof Error ? err.message : String(err)
-        });
-      }
-    }
-    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("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("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] !== "*") {
-        tools = tools.filter(
-          (tool) => modeConfig.allowedTools.includes(tool.name)
-        );
-      }
-    }
-    const modelToUse = effectiveModel;
-    if (resumedTranscript) {
-      yield {
-        type: "progress",
-        content: createAssistantMessage(
-          `Resuming agent: ${agentType} (${agentId})`
-        ),
-        normalizedMessages: normalizeMessages(messages),
-        tools
-      };
-      yield {
-        type: "progress",
-        content: createAssistantMessage(
-          `Restored ${resumedTranscript.messages.length} messages, ${resumedTranscript.toolUseCount} tool uses`
-        ),
-        normalizedMessages: normalizeMessages(messages),
-        tools
-      };
-    } else {
-      yield {
-        type: "progress",
-        content: createAssistantMessage(`Starting agent: ${agentType}`),
-        normalizedMessages: normalizeMessages(messages),
-        tools
-      };
-    }
-    yield {
-      type: "progress",
-      content: createAssistantMessage(`Using model: ${modelToUse}`),
-      normalizedMessages: normalizeMessages(messages),
-      tools
-    };
-    yield {
-      type: "progress",
-      content: createAssistantMessage(`Task: ${description}`),
-      normalizedMessages: normalizeMessages(messages),
-      tools
-    };
-    yield {
-      type: "progress",
-      content: createAssistantMessage(
-        `Prompt: ${prompt.length > 150 ? prompt.substring(0, 150) + "..." : prompt}`
-      ),
-      normalizedMessages: normalizeMessages(messages),
-      tools
-    };
-    const [taskPrompt, context, maxThinkingTokens] = await Promise.all([
-      team_name ? getSystemPrompt("teammate") : getAgentPrompt(),
-      getContext(),
-      getMaxThinkingTokens(messages)
-    ]);
-    taskPrompt.push(
-      `
-IMPORTANT: You are currently running as ${modelToUse}. You do not need to consult ${modelToUse} via AskExpertModel since you ARE ${modelToUse}. Complete tasks directly using your capabilities.`
-    );
-    let toolUseCount = resumedTranscript?.toolUseCount || 0;
-    const getSidechainNumber = memoize(
-      () => getNextAvailableLogSidechainNumber(messageLogName, forkNumber)
-    );
-    const hookMgr = getHookManager();
-    if (hookMgr) {
-      hookMgr.executeSubagentStart(agentType, description).catch(
-        (err) => debugLogger.warn("SubagentStart hook failed", { error: err })
-      );
-    }
-    if (!resumedTranscript) {
-      createAgentTranscript({
-        agentId,
-        agentType,
-        toolUseId,
-        // Include toolUseId for event-driven UI updates
-        description,
-        prompt,
-        model: modelToUse,
-        forkNumber,
-        messageLogName,
-        messages: [...messages],
-        toolUseCount: 0,
-        ...effectiveRunInBackground && team_name ? { metadata: { isBackground: true } } : {}
-      });
-    } else {
-      appendMessageToTranscript(
-        agentId,
-        createUserMessage(`[Resumed] ${prompt}`)
-      );
-    }
-    const effectiveMaxThinkingTokens = agentMaxThinkingTokens ?? maxThinkingTokens;
-    const queryOptions = {
-      safeMode,
-      safetyMode,
-      forkNumber,
-      messageLogName,
-      tools,
-      commands: [],
-      verbose,
-      maxThinkingTokens: effectiveMaxThinkingTokens,
-      model: modelToUse,
-      ...effectivePermissionMode ? { permissionMode: effectivePermissionMode } : {}
-    };
-    if (temperature !== void 0) {
-      queryOptions["temperature"] = temperature;
-    }
-    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 }
-        );
-      }
-      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,
-            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 globalRegistry = getGlobalRegistry();
-          globalRegistry.register(agentId, engine);
-          if (effectiveAbortController.signal.aborted) {
-            engine.stop();
-          } else {
-            effectiveAbortController.signal.addEventListener(
-              "abort",
-              () => engine.stop(),
-              { once: true }
-            );
-          }
-          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)
-                        }
-                      )
-                    );
-                  }
-                }
-              } 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") {
-        throw new Error("Last message was not an assistant message");
-      }
-      const tokenUsage = {
-        inputTokens: lastMessage.message.usage.input_tokens,
-        outputTokens: lastMessage.message.usage.output_tokens,
-        cacheReadTokens: lastMessage.message.usage.cache_read_input_tokens,
-        cacheCreationTokens: lastMessage.message.usage.cache_creation_input_tokens
-      };
-      const isInterrupted = lastMessage.message.content.some(
-        (_) => _.type === "text" && _.text === INTERRUPT_MESSAGE
-      );
-      if (isInterrupted) {
-        interruptAgentTranscript(agentId);
-        debugLogger.info("TASK_AGENT_INTERRUPTED", { agentId, toolUseCount });
-      } else {
-        completeAgentTranscript(agentId, tokenUsage);
-        debugLogger.info("TASK_AGENT_COMPLETED", { agentId, toolUseCount });
-        if (hookMgr) {
-          hookMgr.executeSubagentStop(agentType, agentId).catch(
-            (err) => debugLogger.warn("SubagentStop hook failed", { error: err })
-          );
-        }
-        if (loadedAgentConfig?.hooks?.onComplete?.length) {
-          try {
-            const hookContext = createHookContext({
-              sessionId: agentId,
-              agentId,
-              agentType,
-              result: this.renderResultForAssistant(
-                lastMessage.message.content.filter((_) => _.type === "text")
-              )
-            });
-            await executeAgentHooks(
-              "onComplete",
-              loadedAgentConfig,
-              hookContext
-            );
-          } catch (hookError) {
-            debugLogger.warn("TASK_AGENT_ONCOMPLETE_HOOK_FAILED", {
-              agentId,
-              agentType,
-              error: hookError instanceof Error ? hookError.message : String(hookError)
-            });
-          }
-        }
-        if (loadedAgentConfig?.memory) {
-          try {
-            const finalResponse = lastMessage.message.content.filter((_) => _.type === "text").map((_) => _.text).join("\n");
-            if (finalResponse.trim()) {
-              await saveAgentMemory(
-                agentType,
-                loadedAgentConfig.memory,
-                finalResponse
-              );
-            }
-          } catch (memoryError) {
-            debugLogger.warn("TASK_AGENT_MEMORY_SAVE_FAILED", {
-              agentId,
-              agentType,
-              error: memoryError instanceof Error ? memoryError.message : String(memoryError)
-            });
-          }
-        }
-        const result = [
-          toolUseCount === 1 ? "1 tool use" : `${toolUseCount} tool uses`,
-          formatNumber(
-            (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
-          ) + " tokens",
-          formatDuration(Date.now() - startTime)
-        ];
-        yield {
-          type: "progress",
-          content: createAssistantMessage(`Done (${result.join(" \xB7 ")})`),
-          normalizedMessages,
-          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)}
-
-Agent completed successfully.
-agentId: ${agentId}`;
-      yield {
-        type: "result",
-        data,
-        resultForAssistant: resultWithAgentId
-      };
-      hasYieldedResult = true;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      const isAbortError = error instanceof Error && (error.name === "AbortError" || error.message.includes("aborted") || error.message.includes("abort"));
-      if (isAbortError) {
-        interruptAgentTranscript(agentId);
-        debugLogger.info("TASK_AGENT_INTERRUPTED_BY_ABORT", {
-          agentId,
-          toolUseCount
-        });
-        yield {
-          type: "result",
-          data: [
-            {
-              type: "text",
-              text: `Task [${agentType}] interrupted
-[Agent ID: ${agentId}]`
-            }
-          ],
-          resultForAssistant: `Task [${agentType}] interrupted by user
-[Agent ID: ${agentId} - can be resumed]`
-        };
-      } else {
-        const friendlyError = error instanceof UserFriendlyError ? error : new UserFriendlyError(error, {
-          operation: "agent task",
-          model: agentType
-        });
-        const friendlyMessage = friendlyError.getUserMessage();
-        logError(`TaskTool [${agentType}] error: ${errorMessage}`);
-        failAgentTranscript(agentId, friendlyMessage);
-        debugLogger.error("TASK_AGENT_FAILED", {
-          agentId,
-          error: errorMessage,
-          errorId: friendlyError.id
-        });
-        if (loadedAgentConfig?.hooks?.onError?.length) {
-          try {
-            const hookContext = createHookContext({
-              sessionId: agentId,
-              agentId,
-              agentType,
-              error: error instanceof Error ? error : new Error(String(error))
-            });
-            await executeAgentHooks("onError", loadedAgentConfig, hookContext);
-          } catch (hookError) {
-            debugLogger.warn("TASK_AGENT_ONERROR_HOOK_FAILED", {
-              agentId,
-              agentType,
-              error: hookError instanceof Error ? hookError.message : String(hookError)
-            });
-          }
-        }
-        yield {
-          type: "result",
-          data: [
-            {
-              type: "text",
-              text: `${friendlyMessage}
-[Agent ID: ${agentId}]`
-            }
-          ],
-          resultForAssistant: `Task [${agentType}] failed: ${errorMessage}
-[Agent ID: ${agentId} - can be resumed]`
-        };
-      }
-      hasYieldedResult = true;
-    } finally {
-      if (worktreePath) {
-        let removeSuccess = false;
-        try {
-          execFileSync("git", ["worktree", "remove", worktreePath, "--force"], {
-            cwd: getCwd(),
-            stdio: "pipe"
-          });
-          removeSuccess = true;
-          debugLogger.info("TASK_AGENT_WORKTREE_REMOVED", {
-            agentId,
-            worktreePath
-          });
-        } catch {
-          debugLogger.warn("TASK_AGENT_WORKTREE_CLEANUP_FAILED", {
-            agentId,
-            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 {
-          type: "result",
-          data: [
-            {
-              type: "text",
-              text: `Task [${agentType}] terminated unexpectedly
-[Agent ID: ${agentId}]`
-            }
-          ],
-          resultForAssistant: `Task [${agentType}] terminated unexpectedly
-[Agent ID: ${agentId} - can be resumed]`
-        };
-      }
-    }
-  },
-  isReadOnly() {
-    return true;
-  },
-  isConcurrencySafe() {
-    return true;
-  },
-  async validateInput(input, context) {
-    if (!input.description || typeof input.description !== "string") {
-      return {
-        result: false,
-        message: "Description is required and must be a string"
-      };
-    }
-    if (!input.prompt || typeof input.prompt !== "string") {
-      return {
-        result: false,
-        message: "Prompt is required and must be a string"
-      };
-    }
-    if (input.model_name) {
-      const modelManager = getModelManager();
-      const availableModels = modelManager.getAllAvailableModelNames();
-      if (!availableModels.includes(input.model_name)) {
-        return {
-          result: false,
-          message: `Model '${input.model_name}' does not exist. Available models: ${availableModels.join(", ")}`,
-          meta: {
-            model_name: input.model_name,
-            availableModels
-          }
-        };
-      }
-    }
-    if (input.subagent_type) {
-      const availableTypes = await getAvailableAgentTypes();
-      if (!availableTypes.includes(input.subagent_type)) {
-        return {
-          result: false,
-          message: `Agent type '${input.subagent_type}' does not exist. Available types: ${availableTypes.join(", ")}`,
-          meta: {
-            subagent_type: input.subagent_type,
-            availableTypes
-          }
-        };
-      }
-    }
-    if (input.resume) {
-      if (!canResumeTranscript(input.resume)) {
-        return {
-          result: false,
-          message: `Cannot resume agent '${input.resume}': transcript not found or not resumable (status must be 'running' or 'interrupted')`,
-          meta: {
-            resume: input.resume
-          }
-        };
-      }
-    }
-    return { result: true };
-  },
-  async isEnabled() {
-    return true;
-  },
-  userFacingName(input) {
-    const agentType = input?.subagent_type || "general-purpose";
-    return `agent-${agentType}`;
-  },
-  needsPermissions() {
-    return false;
-  },
-  renderResultForAssistant(data) {
-    return data.map((block) => block.type === "text" ? block.text : "").join("\n");
-  },
-  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");
-    const actualModel = model_name || defaultTaskModel;
-    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,
-        {
-          paddingLeft: 2,
-          borderLeftStyle: "single",
-          borderLeftColor: theme.secondaryBorder
-        },
-        /* @__PURE__ */ React.createElement(Text, { color: theme.secondaryText }, promptPreview)
-      ));
-    }
-    return `[${agentType}] ${actualModel}: ${description}`;
-  },
-  renderToolUseRejectedMessage() {
-    return /* @__PURE__ */ React.createElement(FallbackToolUseRejectedMessage, null);
-  },
-  renderToolResultMessage(content, options) {
-    const theme = getTheme();
-    const verbose = options?.verbose ?? false;
-    if (!content) {
-      return /* @__PURE__ */ React.createElement(Box, { flexDirection: "row" }, /* @__PURE__ */ React.createElement(Text, null, "\xA0\xA0\u23BF \xA0"), /* @__PURE__ */ React.createElement(Text, { color: theme.success }, "Done"));
-    }
-    if (Array.isArray(content)) {
-      const textBlocks = content.filter(
-        (block) => block && block.type === "text"
-      );
-      const totalLength = textBlocks.reduce(
-        (sum, block) => sum + (block.text?.length || 0),
-        0
-      );
-      const isInterrupted = content.some(
-        (block) => block && block.type === "text" && block.text === INTERRUPT_MESSAGE
-      );
-      if (isInterrupted) {
-        return /* @__PURE__ */ React.createElement(Box, { flexDirection: "row" }, /* @__PURE__ */ React.createElement(Text, null, "\xA0\xA0\u23BF \xA0"), /* @__PURE__ */ React.createElement(Text, { color: theme.error }, "Interrupted by user"));
-      }
-      const outputText = textBlocks.map((b) => b.text).join("\n");
-      const getOutputPreview = () => {
-        if (!verbose || !outputText) return null;
-        const maxLen = 500;
-        if (outputText.length <= maxLen) return outputText;
-        return outputText.substring(0, maxLen) + "...";
-      };
-      const outputPreview = getOutputPreview();
-      return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, /* @__PURE__ */ React.createElement(Box, { justifyContent: "space-between", width: "100%" }, /* @__PURE__ */ React.createElement(Box, { flexDirection: "row" }, /* @__PURE__ */ React.createElement(Text, null, "\xA0\xA0\u23BF \xA0"), /* @__PURE__ */ React.createElement(Text, { color: theme.success }, "Done"), textBlocks.length > 0 && verbose && /* @__PURE__ */ React.createElement(Text, { color: theme.secondaryText }, " (", totalLength, " chars)"))), outputPreview && /* @__PURE__ */ React.createElement(Box, { marginTop: 1, paddingLeft: 4 }, /* @__PURE__ */ React.createElement(Text, { color: theme.mutedText }, outputPreview)));
-    }
-    return /* @__PURE__ */ React.createElement(Box, { flexDirection: "row" }, /* @__PURE__ */ React.createElement(Text, null, "\xA0\xA0\u23BF \xA0"), /* @__PURE__ */ React.createElement(Text, { color: theme.success }, "Done"));
-  }
-};
-export {
-  TaskTool
-};
-//# sourceMappingURL=TaskTool.js.map