tools/AgentTool/AgentTool.tsx

🖥️ Source preview

import { feature } from 'bun:bundle';
import * as React from 'react';
import { buildTool, type ToolDef, toolMatchesName } from 'src/Tool.js';
import type { Message as MessageType, NormalizedUserMessage } from 'src/types/message.js';
import { getQuerySourceForAgent } from 'src/utils/promptCategory.js';
import { z } from 'zod/v4';
import { clearInvokedSkillsForAgent, getSdkAgentProgressSummariesEnabled } from '../../bootstrap/state.js';
import { enhanceSystemPromptWithEnvDetails, getSystemPrompt } from '../../constants/prompts.js';
import { isCoordinatorMode } from '../../coordinator/coordinatorMode.js';
import { startAgentSummarization } from '../../services/AgentSummary/agentSummary.js';
import { getFeatureValue_CACHED_MAY_BE_STALE } from '../../services/analytics/growthbook.js';
import { type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, logEvent } from '../../services/analytics/index.js';
import { clearDumpState } from '../../services/api/dumpPrompts.js';
import { completeAgentTask as completeAsyncAgent, createActivityDescriptionResolver, createProgressTracker, enqueueAgentNotification, failAgentTask as failAsyncAgent, getProgressUpdate, getTokenCountFromTracker, isLocalAgentTask, killAsyncAgent, registerAgentForeground, registerAsyncAgent, unregisterAgentForeground, updateAgentProgress as updateAsyncAgentProgress, updateProgressFromMessage } from '../../tasks/LocalAgentTask/LocalAgentTask.js';
import { checkRemoteAgentEligibility, formatPreconditionError, getRemoteTaskSessionUrl, registerRemoteAgentTask } from '../../tasks/RemoteAgentTask/RemoteAgentTask.js';
import { assembleToolPool } from '../../tools.js';
import { asAgentId } from '../../types/ids.js';
import { runWithAgentContext } from '../../utils/agentContext.js';
import { isAgentSwarmsEnabled } from '../../utils/agentSwarmsEnabled.js';
import { getCwd, runWithCwdOverride } from '../../utils/cwd.js';
import { logForDebugging } from '../../utils/debug.js';
import { isEnvTruthy } from '../../utils/envUtils.js';
import { AbortError, errorMessage, toError } from '../../utils/errors.js';
import type { CacheSafeParams } from '../../utils/forkedAgent.js';
import { lazySchema } from '../../utils/lazySchema.js';
import { createUserMessage, extractTextContent, isSyntheticMessage, normalizeMessages } from '../../utils/messages.js';
import { getAgentModel } from '../../utils/model/agent.js';
import { permissionModeSchema } from '../../utils/permissions/PermissionMode.js';
import type { PermissionResult } from '../../utils/permissions/PermissionResult.js';
import { filterDeniedAgents, getDenyRuleForAgent } from '../../utils/permissions/permissions.js';
import { enqueueSdkEvent } from '../../utils/sdkEventQueue.js';
import { writeAgentMetadata } from '../../utils/sessionStorage.js';
import { sleep } from '../../utils/sleep.js';
import { buildEffectiveSystemPrompt } from '../../utils/systemPrompt.js';
import { asSystemPrompt } from '../../utils/systemPromptType.js';
import { getTaskOutputPath } from '../../utils/task/diskOutput.js';
import { getParentSessionId, isTeammate } from '../../utils/teammate.js';
import { isInProcessTeammate } from '../../utils/teammateContext.js';
import { teleportToRemote } from '../../utils/teleport.js';
import { getAssistantMessageContentLength } from '../../utils/tokens.js';
import { createAgentId } from '../../utils/uuid.js';
import { createAgentWorktree, hasWorktreeChanges, removeAgentWorktree } from '../../utils/worktree.js';
import { BASH_TOOL_NAME } from '../BashTool/toolName.js';
import { BackgroundHint } from '../BashTool/UI.js';
import { FILE_READ_TOOL_NAME } from '../FileReadTool/prompt.js';
import { spawnTeammate } from '../shared/spawnMultiAgent.js';
import { setAgentColor } from './agentColorManager.js';
import { agentToolResultSchema, classifyHandoffIfNeeded, emitTaskProgress, extractPartialResult, finalizeAgentTool, getLastToolUseName, runAsyncAgentLifecycle } from './agentToolUtils.js';
import { GENERAL_PURPOSE_AGENT } from './built-in/generalPurposeAgent.js';
import { AGENT_TOOL_NAME, LEGACY_AGENT_TOOL_NAME, ONE_SHOT_BUILTIN_AGENT_TYPES } from './constants.js';
import { buildForkedMessages, buildWorktreeNotice, FORK_AGENT, isForkSubagentEnabled, isInForkChild } from './forkSubagent.js';
import type { AgentDefinition } from './loadAgentsDir.js';
import { filterAgentsByMcpRequirements, hasRequiredMcpServers, isBuiltInAgent } from './loadAgentsDir.js';
import { getPrompt } from './prompt.js';
import { runAgent } from './runAgent.js';
import { renderGroupedAgentToolUse, renderToolResultMessage, renderToolUseErrorMessage, renderToolUseMessage, renderToolUseProgressMessage, renderToolUseRejectedMessage, renderToolUseTag, userFacingName, userFacingNameBackgroundColor } from './UI.js';

/* eslint-disable @typescript-eslint/no-require-imports */
const proactiveModule = feature('PROACTIVE') || feature('KAIROS') ? require('../../proactive/index.js') as typeof import('../../proactive/index.js') : null;
/* eslint-enable @typescript-eslint/no-require-imports */

// Progress display constants (for showing background hint)
const PROGRESS_THRESHOLD_MS = 2000; // Show background hint after 2 seconds

// Check if background tasks are disabled at module load time
const isBackgroundTasksDisabled =
// eslint-disable-next-line custom-rules/no-process-env-top-level -- Intentional: schema must be defined at module load
isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_BACKGROUND_TASKS);

// Auto-background agent tasks after this many ms (0 = disabled)
// Enabled by env var OR GrowthBook gate (checked lazily since GB may not be ready at module load)
function getAutoBackgroundMs(): number {
  if (isEnvTruthy(process.env.CLAUDE_AUTO_BACKGROUND_TASKS) || getFeatureValue_CACHED_MAY_BE_STALE('tengu_auto_background_agents', false)) {
    return 120_000;
  }
  return 0;
}

// Multi-agent type constants are defined inline inside gated blocks to enable dead code elimination

// Base input schema without multi-agent parameters
const baseInputSchema = lazySchema(() => 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'),
  subagent_type: z.string().optional().describe('The type of specialized agent to use for this task'),
  model: z.enum(['sonnet', 'opus', 'haiku']).optional().describe("Optional model override for this agent. Takes precedence over the agent definition's model frontmatter. If omitted, uses the agent definition's model, or inherits from the parent."),
  run_in_background: z.boolean().optional().describe('Set to true to run this agent in the background. You will be notified when it completes.')
}));

// Full schema combining base + multi-agent params + isolation
const fullInputSchema = lazySchema(() => {
  // Multi-agent parameters
  const multiAgentInputSchema = z.object({
    name: z.string().optional().describe('Name for the spawned agent. Makes it addressable via SendMessage({to: name}) while running.'),
    team_name: z.string().optional().describe('Team name for spawning. Uses current team context if omitted.'),
    mode: permissionModeSchema().optional().describe('Permission mode for spawned teammate (e.g., "plan" to require plan approval).')
  });
  return baseInputSchema().merge(multiAgentInputSchema).extend({
    isolation: ("external" === 'ant' ? z.enum(['worktree', 'remote']) : z.enum(['worktree'])).optional().describe("external" === 'ant' ? 'Isolation mode. "worktree" creates a temporary git worktree so the agent works on an isolated copy of the repo. "remote" launches the agent in a remote CCR environment (always runs in background).' : 'Isolation mode. "worktree" creates a temporary git worktree so the agent works on an isolated copy of the repo.'),
    cwd: z.string().optional().describe('Absolute path to run the agent in. Overrides the working directory for all filesystem and shell operations within this agent. Mutually exclusive with isolation: "worktree".')
  });
});

// Strip optional fields from the schema when the backing feature is off so
// the model never sees them. Done via .omit() rather than conditional spread
// inside .extend() because the spread-ternary breaks Zod's type inference
// (field type collapses to `unknown`). The ternary return produces a union
// type, but call() destructures via the explicit AgentToolInput type below
// which always includes all optional fields.
export const inputSchema = lazySchema(() => {
  const schema = feature('KAIROS') ? fullInputSchema() : fullInputSchema().omit({
    cwd: true
  });

  // GrowthBook-in-lazySchema is acceptable here (unlike subagent_type, which
  // was removed in 906da6c723): the divergence window is one-session-per-
  // gate-flip via _CACHED_MAY_BE_STALE disk read, and worst case is either
  // "schema shows a no-op param" (gate flips on mid-session: param ignored
  // by forceAsync) or "schema hides a param that would've worked" (gate
  // flips off mid-session: everything still runs async via memoized
  // forceAsync). No Zod rejection, no crash — unlike required→optional.
  return isBackgroundTasksDisabled || isForkSubagentEnabled() ? schema.omit({
    run_in_background: true
  }) : schema;
});
type InputSchema = ReturnType<typeof inputSchema>;

// Explicit type widens the schema inference to always include all optional
// fields even when .omit() strips them for gating (cwd, run_in_background).
// subagent_type is optional; call() defaults it to general-purpose when the
// fork gate is off, or routes to the fork path when the gate is on.
type AgentToolInput = z.infer<ReturnType<typeof baseInputSchema>> & {
  name?: string;
  team_name?: string;
  mode?: z.infer<ReturnType<typeof permissionModeSchema>>;
  isolation?: 'worktree' | 'remote';
  cwd?: string;
};

// Output schema - multi-agent spawned schema added dynamically at runtime when enabled
export const outputSchema = lazySchema(() => {
  const syncOutputSchema = agentToolResultSchema().extend({
    status: z.literal('completed'),
    prompt: z.string()
  });
  const asyncOutputSchema = z.object({
    status: z.literal('async_launched'),
    agentId: z.string().describe('The ID of the async agent'),
    description: z.string().describe('The description of the task'),
    prompt: z.string().describe('The prompt for the agent'),
    outputFile: z.string().describe('Path to the output file for checking agent progress'),
    canReadOutputFile: z.boolean().optional().describe('Whether the calling agent has Read/Bash tools to check progress')
  });
  return z.union([syncOutputSchema, asyncOutputSchema]);
});
type OutputSchema = ReturnType<typeof outputSchema>;
type Output = z.input<OutputSchema>;

// Private type for teammate spawn results - excluded from exported schema for dead code elimination
// The 'teammate_spawned' status string is only included when ENABLE_AGENT_SWARMS is true
type TeammateSpawnedOutput = {
  status: 'teammate_spawned';
  prompt: string;
  teammate_id: string;
  agent_id: string;
  agent_type?: string;
  model?: string;
  name: string;
  color?: string;
  tmux_session_name: string;
  tmux_window_name: string;
  tmux_pane_id: string;
  team_name?: string;
  is_splitpane?: boolean;
  plan_mode_required?: boolean;
};

// Combined output type including both public and internal types
// Note: TeammateSpawnedOutput type is fine - TypeScript types are erased at compile time
// Private type for remote-launched results — excluded from exported schema
// like TeammateSpawnedOutput for dead code elimination purposes. Exported
// for UI.tsx to do proper discriminated-union narrowing instead of ad-hoc casts.
export type RemoteLaunchedOutput = {
  status: 'remote_launched';
  taskId: string;
  sessionUrl: string;
  description: string;
  prompt: string;
  outputFile: string;
};
type InternalOutput = Output | TeammateSpawnedOutput | RemoteLaunchedOutput;
import type { AgentToolProgress, ShellProgress } from '../../types/tools.js';
// AgentTool forwards both its own progress events and shell progress
// events from the sub-agent so the SDK receives tool_progress updates during bash/powershell runs.
export type Progress = AgentToolProgress | ShellProgress;
export const AgentTool = buildTool({
  async prompt({
    agents,
    tools,
    getToolPermissionContext,
    allowedAgentTypes
  }) {
    const toolPermissionContext = await getToolPermissionContext();

    // Get MCP servers that have tools available
    const mcpServersWithTools: string[] = [];
    for (const tool of tools) {
      if (tool.name?.startsWith('mcp__')) {
        const parts = tool.name.split('__');
        const serverName = parts[1];
        if (serverName && !mcpServersWithTools.includes(serverName)) {
          mcpServersWithTools.push(serverName);
        }
      }
    }

    // Filter agents: first by MCP requirements, then by permission rules
    const agentsWithMcpRequirementsMet = filterAgentsByMcpRequirements(agents, mcpServersWithTools);
    const filteredAgents = filterDeniedAgents(agentsWithMcpRequirementsMet, toolPermissionContext, AGENT_TOOL_NAME);

    // Use inline env check instead of coordinatorModule to avoid circular
    // dependency issues during test module loading.
    const isCoordinator = feature('COORDINATOR_MODE') ? isEnvTruthy(process.env.CLAUDE_CODE_COORDINATOR_MODE) : false;
    return await getPrompt(filteredAgents, isCoordinator, allowedAgentTypes);
  },
  name: AGENT_TOOL_NAME,
  searchHint: 'delegate work to a subagent',
  aliases: [LEGACY_AGENT_TOOL_NAME],
  maxResultSizeChars: 100_000,
  async description() {
    return 'Launch a new agent';
  },
  get inputSchema(): InputSchema {
    return inputSchema();
  },
  get outputSchema(): OutputSchema {
    return outputSchema();
  },
  async call({
    prompt,
    subagent_type,
    description,
    model: modelParam,
    run_in_background,
    name,
    team_name,
    mode: spawnMode,
    isolation,
    cwd
  }: AgentToolInput, toolUseContext, canUseTool, assistantMessage, onProgress?) {
    const startTime = Date.now();
    const model = isCoordinatorMode() ? undefined : modelParam;

    // Get app state for permission mode and agent filtering
    const appState = toolUseContext.getAppState();
    const permissionMode = appState.toolPermissionContext.mode;
    // In-process teammates get a no-op setAppState; setAppStateForTasks
    // reaches the root store so task registration/progress/kill stay visible.
    const rootSetAppState = toolUseContext.setAppStateForTasks ?? toolUseContext.setAppState;

    // Check if user is trying to use agent teams without access
    if (team_name && !isAgentSwarmsEnabled()) {
      throw new Error('Agent Teams is not yet available on your plan.');
    }

    // Teammates (in-process or tmux) passing `name` would trigger spawnTeammate()
    // below, but TeamFile.members is a flat array with one leadAgentId — nested
    // teammates land in the roster with no provenance and confuse the lead.
    const teamName = resolveTeamName({
      team_name
    }, appState);
    if (isTeammate() && teamName && name) {
      throw new Error('Teammates cannot spawn other teammates — the team roster is flat. To spawn a subagent instead, omit the `name` parameter.');
    }
    // In-process teammates cannot spawn background agents (their lifecycle is
    // tied to the leader's process). Tmux teammates are separate processes and
    // can manage their own background agents.
    if (isInProcessTeammate() && teamName && run_in_background === true) {
      throw new Error('In-process teammates cannot spawn background agents. Use run_in_background=false for synchronous subagents.');
    }

    // Check if this is a multi-agent spawn request
    // Spawn is triggered when team_name is set (from param or context) and name is provided
    if (teamName && name) {
      // Set agent definition color for grouped UI display before spawning
      const agentDef = subagent_type ? toolUseContext.options.agentDefinitions.activeAgents.find(a => a.agentType === subagent_type) : undefined;
      if (agentDef?.color) {
        setAgentColor(subagent_type!, agentDef.color);
      }
      const result = await spawnTeammate({
        name,
        prompt,
        description,
        team_name: teamName,
        use_splitpane: true,
        plan_mode_required: spawnMode === 'plan',
        model: model ?? agentDef?.model,
        agent_type: subagent_type,
        invokingRequestId: assistantMessage?.requestId
      }, toolUseContext);

      // Type assertion uses TeammateSpawnedOutput (defined above) instead of any.
      // This type is excluded from the exported outputSchema for dead code elimination.
      // Cast through unknown because TeammateSpawnedOutput is intentionally
      // not part of the exported Output union (for dead code elimination purposes).
      const spawnResult: TeammateSpawnedOutput = {
        status: 'teammate_spawned' as const,
        prompt,
        ...result.data
      };
      return {
        data: spawnResult
      } as unknown as {
        data: Output;
      };
    }

    // Fork subagent experiment routing:
    // - subagent_type set: use it (explicit wins)
    // - subagent_type omitted, gate on: fork path (undefined)
    // - subagent_type omitted, gate off: default general-purpose
    const effectiveType = subagent_type ?? (isForkSubagentEnabled() ? undefined : GENERAL_PURPOSE_AGENT.agentType);
    const isForkPath = effectiveType === undefined;
    let selectedAgent: AgentDefinition;
    if (isForkPath) {
      // Recursive fork guard: fork children keep the Agent tool in their
      // pool for cache-identical tool defs, so reject fork attempts at call
      // time. Primary check is querySource (compaction-resistant — set on
      // context.options at spawn time, survives autocompact's message
      // rewrite). Message-scan fallback catches any path where querySource
      // wasn't threaded.
      if (toolUseContext.options.querySource === `agent:builtin:${FORK_AGENT.agentType}` || isInForkChild(toolUseContext.messages)) {
        throw new Error('Fork is not available inside a forked worker. Complete your task directly using your tools.');
      }
      selectedAgent = FORK_AGENT;
    } else {
      // Filter agents to exclude those denied via Agent(AgentName) syntax
      const allAgents = toolUseContext.options.agentDefinitions.activeAgents;
      const {
        allowedAgentTypes
      } = toolUseContext.options.agentDefinitions;
      const agents = filterDeniedAgents(
      // When allowedAgentTypes is set (from Agent(x,y) tool spec), restrict to those types
      allowedAgentTypes ? allAgents.filter(a => allowedAgentTypes.includes(a.agentType)) : allAgents, appState.toolPermissionContext, AGENT_TOOL_NAME);
      const found = agents.find(agent => agent.agentType === effectiveType);
      if (!found) {
        // Check if the agent exists but is denied by permission rules
        const agentExistsButDenied = allAgents.find(agent => agent.agentType === effectiveType);
        if (agentExistsButDenied) {
          const denyRule = getDenyRuleForAgent(appState.toolPermissionContext, AGENT_TOOL_NAME, effectiveType);
          throw new Error(`Agent type '${effectiveType}' has been denied by permission rule '${AGENT_TOOL_NAME}(${effectiveType})' from ${denyRule?.source ?? 'settings'}.`);
        }
        throw new Error(`Agent type '${effectiveType}' not found. Available agents: ${agents.map(a => a.agentType).join(', ')}`);
      }
      selectedAgent = found;
    }

    // Same lifecycle constraint as the run_in_background guard above, but for
    // agent definitions that force background via `background: true`. Checked
    // here because selectedAgent is only now resolved.
    if (isInProcessTeammate() && teamName && selectedAgent.background === true) {
      throw new Error(`In-process teammates cannot spawn background agents. Agent '${selectedAgent.agentType}' has background: true in its definition.`);
    }

    // Capture for type narrowing — `let selectedAgent` prevents TS from
    // narrowing property types across the if-else assignment above.
    const requiredMcpServers = selectedAgent.requiredMcpServers;

    // Check if required MCP servers have tools available
    // A server that's connected but not authenticated won't have any tools
    if (requiredMcpServers?.length) {
      // If any required servers are still pending (connecting), wait for them
      // before checking tool availability. This avoids a race condition where
      // the agent is invoked before MCP servers finish connecting.
      const hasPendingRequiredServers = appState.mcp.clients.some(c => c.type === 'pending' && requiredMcpServers.some(pattern => c.name.toLowerCase().includes(pattern.toLowerCase())));
      let currentAppState = appState;
      if (hasPendingRequiredServers) {
        const MAX_WAIT_MS = 30_000;
        const POLL_INTERVAL_MS = 500;
        const deadline = Date.now() + MAX_WAIT_MS;
        while (Date.now() < deadline) {
          await sleep(POLL_INTERVAL_MS);
          currentAppState = toolUseContext.getAppState();

          // Early exit: if any required server has already failed, no point
          // waiting for other pending servers — the check will fail regardless.
          const hasFailedRequiredServer = currentAppState.mcp.clients.some(c => c.type === 'failed' && requiredMcpServers.some(pattern => c.name.toLowerCase().includes(pattern.toLowerCase())));
          if (hasFailedRequiredServer) break;
          const stillPending = currentAppState.mcp.clients.some(c => c.type === 'pending' && requiredMcpServers.some(pattern => c.name.toLowerCase().includes(pattern.toLowerCase())));
          if (!stillPending) break;
        }
      }

      // Get servers that actually have tools (meaning they're connected AND authenticated)
      const serversWithTools: string[] = [];
      for (const tool of currentAppState.mcp.tools) {
        if (tool.name?.startsWith('mcp__')) {
          // Extract server name from tool name (format: mcp__serverName__toolName)
          const parts = tool.name.split('__');
          const serverName = parts[1];
          if (serverName && !serversWithTools.includes(serverName)) {
            serversWithTools.push(serverName);
          }
        }
      }
      if (!hasRequiredMcpServers(selectedAgent, serversWithTools)) {
        const missing = requiredMcpServers.filter(pattern => !serversWithTools.some(server => server.toLowerCase().includes(pattern.toLowerCase())));
        throw new Error(`Agent '${selectedAgent.agentType}' requires MCP servers matching: ${missing.join(', ')}. ` + `MCP servers with tools: ${serversWithTools.length > 0 ? serversWithTools.join(', ') : 'none'}. ` + `Use /mcp to configure and authenticate the required MCP servers.`);
      }
    }

    // Initialize the color for this agent if it has a predefined one
    if (selectedAgent.color) {
      setAgentColor(selectedAgent.agentType, selectedAgent.color);
    }

    // Resolve agent params for logging (these are already resolved in runAgent)
    const resolvedAgentModel = getAgentModel(selectedAgent.model, toolUseContext.options.mainLoopModel, isForkPath ? undefined : model, permissionMode);
    logEvent('tengu_agent_tool_selected', {
      agent_type: selectedAgent.agentType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
      model: resolvedAgentModel as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
      source: selectedAgent.source as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
      color: selectedAgent.color as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
      is_built_in_agent: isBuiltInAgent(selectedAgent),
      is_resume: false,
      is_async: (run_in_background === true || selectedAgent.background === true) && !isBackgroundTasksDisabled,
      is_fork: isForkPath
    });

    // Resolve effective isolation mode (explicit param overrides agent def)
    const effectiveIsolation = isolation ?? selectedAgent.isolation;

    // Remote isolation: delegate to CCR. Gated ant-only — the guard enables
    // dead code elimination of the entire block for external builds.
    if ("external" === 'ant' && effectiveIsolation === 'remote') {
      const eligibility = await checkRemoteAgentEligibility();
      if (!eligibility.eligible) {
        const reasons = eligibility.errors.map(formatPreconditionError).join('\n');
        throw new Error(`Cannot launch remote agent:\n${reasons}`);
      }
      let bundleFailHint: string | undefined;
      const session = await teleportToRemote({
        initialMessage: prompt,
        description,
        signal: toolUseContext.abortController.signal,
        onBundleFail: msg => {
          bundleFailHint = msg;
        }
      });
      if (!session) {
        throw new Error(bundleFailHint ?? 'Failed to create remote session');
      }
      const {
        taskId,
        sessionId
      } = registerRemoteAgentTask({
        remoteTaskType: 'remote-agent',
        session: {
          id: session.id,
          title: session.title || description
        },
        command: prompt,
        context: toolUseContext,
        toolUseId: toolUseContext.toolUseId
      });
      logEvent('tengu_agent_tool_remote_launched', {
        agent_type: selectedAgent.agentType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
      });
      const remoteResult: RemoteLaunchedOutput = {
        status: 'remote_launched',
        taskId,
        sessionUrl: getRemoteTaskSessionUrl(sessionId),
        description,
        prompt,
        outputFile: getTaskOutputPath(taskId)
      };
      return {
        data: remoteResult
      } as unknown as {
        data: Output;
      };
    }
    // System prompt + prompt messages: branch on fork path.
    //
    // Fork path: child inherits the PARENT's system prompt (not FORK_AGENT's)
    // for cache-identical API request prefixes. Prompt messages are built via
    // buildForkedMessages() which clones the parent's full assistant message
    // (all tool_use blocks) + placeholder tool_results + per-child directive.
    //
    // Normal path: build the selected agent's own system prompt with env
    // details, and use a simple user message for the prompt.
    let enhancedSystemPrompt: string[] | undefined;
    let forkParentSystemPrompt: ReturnType<typeof buildEffectiveSystemPrompt> | undefined;
    let promptMessages: MessageType[];
    if (isForkPath) {
      if (toolUseContext.renderedSystemPrompt) {
        forkParentSystemPrompt = toolUseContext.renderedSystemPrompt;
      } else {
        // Fallback: recompute. May diverge from parent's cached bytes if
        // GrowthBook state changed between parent turn-start and fork spawn.
        const mainThreadAgentDefinition = appState.agent ? appState.agentDefinitions.activeAgents.find(a => a.agentType === appState.agent) : undefined;
        const additionalWorkingDirectories = Array.from(appState.toolPermissionContext.additionalWorkingDirectories.keys());
        const defaultSystemPrompt = await getSystemPrompt(toolUseContext.options.tools, toolUseContext.options.mainLoopModel, additionalWorkingDirectories, toolUseContext.options.mcpClients);
        forkParentSystemPrompt = buildEffectiveSystemPrompt({
          mainThreadAgentDefinition,
          toolUseContext,
          customSystemPrompt: toolUseContext.options.customSystemPrompt,
          defaultSystemPrompt,
          appendSystemPrompt: toolUseContext.options.appendSystemPrompt
        });
      }
      promptMessages = buildForkedMessages(prompt, assistantMessage);
    } else {
      try {
        const additionalWorkingDirectories = Array.from(appState.toolPermissionContext.additionalWorkingDirectories.keys());

        // All agents have getSystemPrompt - pass toolUseContext to all
        const agentPrompt = selectedAgent.getSystemPrompt({
          toolUseContext
        });

        // Log agent memory loaded event for subagents
        if (selectedAgent.memory) {
          logEvent('tengu_agent_memory_loaded', {
            ...("external" === 'ant' && {
              agent_type: selectedAgent.agentType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
            }),
            scope: selectedAgent.memory as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
            source: 'subagent' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
          });
        }

        // Apply environment details enhancement
        enhancedSystemPrompt = await enhanceSystemPromptWithEnvDetails([agentPrompt], resolvedAgentModel, additionalWorkingDirectories);
      } catch (error) {
        logForDebugging(`Failed to get system prompt for agent ${selectedAgent.agentType}: ${errorMessage(error)}`);
      }
      promptMessages = [createUserMessage({
        content: prompt
      })];
    }
    const metadata = {
      prompt,
      resolvedAgentModel,
      isBuiltInAgent: isBuiltInAgent(selectedAgent),
      startTime,
      agentType: selectedAgent.agentType,
      isAsync: (run_in_background === true || selectedAgent.background === true) && !isBackgroundTasksDisabled
    };

    // Use inline env check instead of coordinatorModule to avoid circular
    // dependency issues during test module loading.
    const isCoordinator = feature('COORDINATOR_MODE') ? isEnvTruthy(process.env.CLAUDE_CODE_COORDINATOR_MODE) : false;

    // Fork subagent experiment: force ALL spawns async for a unified
    // <task-notification> interaction model (not just fork spawns — all of them).
    const forceAsync = isForkSubagentEnabled();

    // Assistant mode: force all agents async. Synchronous subagents hold the
    // main loop's turn open until they complete — the daemon's inputQueue
    // backs up, and the first overdue cron catch-up on spawn becomes N
    // serial subagent turns blocking all user input. Same gate as
    // executeForkedSlashCommand's fire-and-forget path; the
    // <task-notification> re-entry there is handled by the else branch
    // below (registerAsyncAgentTask + notifyOnCompletion).
    const assistantForceAsync = feature('KAIROS') ? appState.kairosEnabled : false;
    const shouldRunAsync = (run_in_background === true || selectedAgent.background === true || isCoordinator || forceAsync || assistantForceAsync || (proactiveModule?.isProactiveActive() ?? false)) && !isBackgroundTasksDisabled;
    // Assemble the worker's tool pool independently of the parent's.
    // Workers always get their tools from assembleToolPool with their own
    // permission mode, so they aren't affected by the parent's tool
    // restrictions. This is computed here so that runAgent doesn't need to
    // import from tools.ts (which would create a circular dependency).
    const workerPermissionContext = {
      ...appState.toolPermissionContext,
      mode: selectedAgent.permissionMode ?? 'acceptEdits'
    };
    const workerTools = assembleToolPool(workerPermissionContext, appState.mcp.tools);

    // Create a stable agent ID early so it can be used for worktree slug
    const earlyAgentId = createAgentId();

    // Set up worktree isolation if requested
    let worktreeInfo: {
      worktreePath: string;
      worktreeBranch?: string;
      headCommit?: string;
      gitRoot?: string;
      hookBased?: boolean;
    } | null = null;
    if (effectiveIsolation === 'worktree') {
      const slug = `agent-${earlyAgentId.slice(0, 8)}`;
      worktreeInfo = await createAgentWorktree(slug);
    }

    // Fork + worktree: inject a notice telling the child to translate paths
    // and re-read potentially stale files. Appended after the fork directive
    // so it appears as the most recent guidance the child sees.
    if (isForkPath && worktreeInfo) {
      promptMessages.push(createUserMessage({
        content: buildWorktreeNotice(getCwd(), worktreeInfo.worktreePath)
      }));
    }
    const runAgentParams: Parameters<typeof runAgent>[0] = {
      agentDefinition: selectedAgent,
      promptMessages,
      toolUseContext,
      canUseTool,
      isAsync: shouldRunAsync,
      querySource: toolUseContext.options.querySource ?? getQuerySourceForAgent(selectedAgent.agentType, isBuiltInAgent(selectedAgent)),
      model: isForkPath ? undefined : model,
      // Fork path: pass parent's system prompt AND parent's exact tool
      // array (cache-identical prefix). workerTools is rebuilt under
      // permissionMode 'bubble' which differs from the parent's mode, so
      // its tool-def serialization diverges and breaks cache at the first
      // differing tool. useExactTools also inherits the parent's
      // thinkingConfig and isNonInteractiveSession (see runAgent.ts).
      //
      // Normal path: when a cwd override is in effect (worktree isolation
      // or explicit cwd), skip the pre-built system prompt so runAgent's
      // buildAgentSystemPrompt() runs inside wrapWithCwd where getCwd()
      // returns the override path.
      override: isForkPath ? {
        systemPrompt: forkParentSystemPrompt
      } : enhancedSystemPrompt && !worktreeInfo && !cwd ? {
        systemPrompt: asSystemPrompt(enhancedSystemPrompt)
      } : undefined,
      availableTools: isForkPath ? toolUseContext.options.tools : workerTools,
      // Pass parent conversation when the fork-subagent path needs full
      // context. useExactTools inherits thinkingConfig (runAgent.ts:624).
      forkContextMessages: isForkPath ? toolUseContext.messages : undefined,
      ...(isForkPath && {
        useExactTools: true
      }),
      worktreePath: worktreeInfo?.worktreePath,
      description
    };

    // Helper to wrap execution with a cwd override: explicit cwd arg (KAIROS)
    // takes precedence over worktree isolation path.
    const cwdOverridePath = cwd ?? worktreeInfo?.worktreePath;
    const wrapWithCwd = <T,>(fn: () => T): T => cwdOverridePath ? runWithCwdOverride(cwdOverridePath, fn) : fn();

    // Helper to clean up worktree after agent completes
    const cleanupWorktreeIfNeeded = async (): Promise<{
      worktreePath?: string;
      worktreeBranch?: string;
    }> => {
      if (!worktreeInfo) return {};
      const {
        worktreePath,
        worktreeBranch,
        headCommit,
        gitRoot,
        hookBased
      } = worktreeInfo;
      // Null out to make idempotent — guards against double-call if code
      // between cleanup and end of try throws into catch
      worktreeInfo = null;
      if (hookBased) {
        // Hook-based worktrees are always kept since we can't detect VCS changes
        logForDebugging(`Hook-based agent worktree kept at: ${worktreePath}`);
        return {
          worktreePath
        };
      }
      if (headCommit) {
        const changed = await hasWorktreeChanges(worktreePath, headCommit);
        if (!changed) {
          await removeAgentWorktree(worktreePath, worktreeBranch, gitRoot);
          // Clear worktreePath from metadata so resume doesn't try to use
          // a deleted directory. Fire-and-forget to match runAgent's
          // writeAgentMetadata handling.
          void writeAgentMetadata(asAgentId(earlyAgentId), {
            agentType: selectedAgent.agentType,
            description
          }).catch(_err => logForDebugging(`Failed to clear worktree metadata: ${_err}`));
          return {};
        }
      }
      logForDebugging(`Agent worktree has changes, keeping: ${worktreePath}`);
      return {
        worktreePath,
        worktreeBranch
      };
    };
    if (shouldRunAsync) {
      const asyncAgentId = earlyAgentId;
      const agentBackgroundTask = registerAsyncAgent({
        agentId: asyncAgentId,
        description,
        prompt,
        selectedAgent,
        setAppState: rootSetAppState,
        // Don't link to parent's abort controller -- background agents should
        // survive when the user presses ESC to cancel the main thread.
        // They are killed explicitly via chat:killAgents.
        toolUseId: toolUseContext.toolUseId
      });

      // Register name → agentId for SendMessage routing. Post-registerAsyncAgent
      // so we don't leave a stale entry if spawn fails. Sync agents skipped —
      // coordinator is blocked, so SendMessage routing doesn't apply.
      if (name) {
        rootSetAppState(prev => {
          const next = new Map(prev.agentNameRegistry);
          next.set(name, asAgentId(asyncAgentId));
          return {
            ...prev,
            agentNameRegistry: next
          };
        });
      }

      // Wrap async agent execution in agent context for analytics attribution
      const asyncAgentContext = {
        agentId: asyncAgentId,
        // For subagents from teammates: use team lead's session
        // For subagents from main REPL: undefined (no parent session)
        parentSessionId: getParentSessionId(),
        agentType: 'subagent' as const,
        subagentName: selectedAgent.agentType,
        isBuiltIn: isBuiltInAgent(selectedAgent),
        invokingRequestId: assistantMessage?.requestId,
        invocationKind: 'spawn' as const,
        invocationEmitted: false
      };

      // Workload propagation: handlePromptSubmit wraps the entire turn in
      // runWithWorkload (AsyncLocalStorage). ALS context is captured at
      // invocation time — when this `void` fires — and survives every await
      // inside. No capture/restore needed; the detached closure sees the
      // parent turn's workload automatically, isolated from its finally.
      void runWithAgentContext(asyncAgentContext, () => wrapWithCwd(() => runAsyncAgentLifecycle({
        taskId: agentBackgroundTask.agentId,
        abortController: agentBackgroundTask.abortController!,
        makeStream: onCacheSafeParams => runAgent({
          ...runAgentParams,
          override: {
            ...runAgentParams.override,
            agentId: asAgentId(agentBackgroundTask.agentId),
            abortController: agentBackgroundTask.abortController!
          },
          onCacheSafeParams
        }),
        metadata,
        description,
        toolUseContext,
        rootSetAppState,
        agentIdForCleanup: asyncAgentId,
        enableSummarization: isCoordinator || isForkSubagentEnabled() || getSdkAgentProgressSummariesEnabled(),
        getWorktreeResult: cleanupWorktreeIfNeeded
      })));
      const canReadOutputFile = toolUseContext.options.tools.some(t => toolMatchesName(t, FILE_READ_TOOL_NAME) || toolMatchesName(t, BASH_TOOL_NAME));
      return {
        data: {
          isAsync: true as const,
          status: 'async_launched' as const,
          agentId: agentBackgroundTask.agentId,
          description: description,
          prompt: prompt,
          outputFile: getTaskOutputPath(agentBackgroundTask.agentId),
          canReadOutputFile
        }
      };
    } else {
      // Create an explicit agentId for sync agents
      const syncAgentId = asAgentId(earlyAgentId);

      // Set up agent context for sync execution (for analytics attribution)
      const syncAgentContext = {
        agentId: syncAgentId,
        // For subagents from teammates: use team lead's session
        // For subagents from main REPL: undefined (no parent session)
        parentSessionId: getParentSessionId(),
        agentType: 'subagent' as const,
        subagentName: selectedAgent.agentType,
        isBuiltIn: isBuiltInAgent(selectedAgent),
        invokingRequestId: assistantMessage?.requestId,
        invocationKind: 'spawn' as const,
        invocationEmitted: false
      };

      // Wrap entire sync agent execution in context for analytics attribution
      // and optionally in a worktree cwd override for filesystem isolation
      return runWithAgentContext(syncAgentContext, () => wrapWithCwd(async () => {
        const agentMessages: MessageType[] = [];
        const agentStartTime = Date.now();
        const syncTracker = createProgressTracker();
        const syncResolveActivity = createActivityDescriptionResolver(toolUseContext.options.tools);

        // Yield initial progress message to carry metadata (prompt)
        if (promptMessages.length > 0) {
          const normalizedPromptMessages = normalizeMessages(promptMessages);
          const normalizedFirstMessage = normalizedPromptMessages.find((m): m is NormalizedUserMessage => m.type === 'user');
          if (normalizedFirstMessage && normalizedFirstMessage.type === 'user' && onProgress) {
            onProgress({
              toolUseID: `agent_${assistantMessage.message.id}`,
              data: {
                message: normalizedFirstMessage,
                type: 'agent_progress',
                prompt,
                agentId: syncAgentId
              }
            });
          }
        }

        // Register as foreground task immediately so it can be backgrounded at any time
        // Skip registration if background tasks are disabled
        let foregroundTaskId: string | undefined;
        // Create the background race promise once outside the loop — otherwise
        // each iteration adds a new .then() reaction to the same pending
        // promise, accumulating callbacks for the lifetime of the agent.
        let backgroundPromise: Promise<{
          type: 'background';
        }> | undefined;
        let cancelAutoBackground: (() => void) | undefined;
        if (!isBackgroundTasksDisabled) {
          const registration = registerAgentForeground({
            agentId: syncAgentId,
            description,
            prompt,
            selectedAgent,
            setAppState: rootSetAppState,
            toolUseId: toolUseContext.toolUseId,
            autoBackgroundMs: getAutoBackgroundMs() || undefined
          });
          foregroundTaskId = registration.taskId;
          backgroundPromise = registration.backgroundSignal.then(() => ({
            type: 'background' as const
          }));
          cancelAutoBackground = registration.cancelAutoBackground;
        }

        // Track if we've shown the background hint UI
        let backgroundHintShown = false;
        // Track if the agent was backgrounded (cleanup handled by backgrounded finally)
        let wasBackgrounded = false;
        // Per-scope stop function — NOT shared with the backgrounded closure.
        // idempotent: startAgentSummarization's stop() checks `stopped` flag.
        let stopForegroundSummarization: (() => void) | undefined;
        // const capture for sound type narrowing inside the callback below
        const summaryTaskId = foregroundTaskId;

        // Get async iterator for the agent
        const agentIterator = runAgent({
          ...runAgentParams,
          override: {
            ...runAgentParams.override,
            agentId: syncAgentId
          },
          onCacheSafeParams: summaryTaskId && getSdkAgentProgressSummariesEnabled() ? (params: CacheSafeParams) => {
            const {
              stop
            } = startAgentSummarization(summaryTaskId, syncAgentId, params, rootSetAppState);
            stopForegroundSummarization = stop;
          } : undefined
        })[Symbol.asyncIterator]();

        // Track if an error occurred during iteration
        let syncAgentError: Error | undefined;
        let wasAborted = false;
        let worktreeResult: {
          worktreePath?: string;
          worktreeBranch?: string;
        } = {};
        try {
          while (true) {
            const elapsed = Date.now() - agentStartTime;

            // Show background hint after threshold (but task is already registered)
            // Skip if background tasks are disabled
            if (!isBackgroundTasksDisabled && !backgroundHintShown && elapsed >= PROGRESS_THRESHOLD_MS && toolUseContext.setToolJSX) {
              backgroundHintShown = true;
              toolUseContext.setToolJSX({
                jsx: <BackgroundHint />,
                shouldHidePromptInput: false,
                shouldContinueAnimation: true,
                showSpinner: true
              });
            }

            // Race between next message and background signal
            // If background tasks are disabled, just await the next message directly
            const nextMessagePromise = agentIterator.next();
            const raceResult = backgroundPromise ? await Promise.race([nextMessagePromise.then(r => ({
              type: 'message' as const,
              result: r
            })), backgroundPromise]) : {
              type: 'message' as const,
              result: await nextMessagePromise
            };

            // Check if we were backgrounded via backgroundAll()
            // foregroundTaskId is guaranteed to be defined if raceResult.type is 'background'
            // because backgroundPromise is only defined when foregroundTaskId is defined
            if (raceResult.type === 'background' && foregroundTaskId) {
              const appState = toolUseContext.getAppState();
              const task = appState.tasks[foregroundTaskId];
              if (isLocalAgentTask(task) && task.isBackgrounded) {
                // Capture the taskId for use in the async callback
                const backgroundedTaskId = foregroundTaskId;
                wasBackgrounded = true;
                // Stop foreground summarization; the backgrounded closure
                // below owns its own independent stop function.
                stopForegroundSummarization?.();

                // Workload: inherited via ALS at `void` invocation time,
                // same as the async-from-start path above.
                // Continue agent in background and return async result
                void runWithAgentContext(syncAgentContext, async () => {
                  let stopBackgroundedSummarization: (() => void) | undefined;
                  try {
                    // Clean up the foreground iterator so its finally block runs
                    // (releases MCP connections, session hooks, prompt cache tracking, etc.)
                    // Timeout prevents blocking if MCP server cleanup hangs.
                    // .catch() prevents unhandled rejection if timeout wins the race.
                    await Promise.race([agentIterator.return(undefined).catch(() => {}), sleep(1000)]);
                    // Initialize progress tracking from existing messages
                    const tracker = createProgressTracker();
                    const resolveActivity2 = createActivityDescriptionResolver(toolUseContext.options.tools);
                    for (const existingMsg of agentMessages) {
                      updateProgressFromMessage(tracker, existingMsg, resolveActivity2, toolUseContext.options.tools);
                    }
                    for await (const msg of runAgent({
                      ...runAgentParams,
                      isAsync: true,
                      // Agent is now running in background
                      override: {
                        ...runAgentParams.override,
                        agentId: asAgentId(backgroundedTaskId),
                        abortController: task.abortController
                      },
                      onCacheSafeParams: getSdkAgentProgressSummariesEnabled() ? (params: CacheSafeParams) => {
                        const {
                          stop
                        } = startAgentSummarization(backgroundedTaskId, asAgentId(backgroundedTaskId), params, rootSetAppState);
                        stopBackgroundedSummarization = stop;
                      } : undefined
                    })) {
                      agentMessages.push(msg);

                      // Track progress for backgrounded agents
                      updateProgressFromMessage(tracker, msg, resolveActivity2, toolUseContext.options.tools);
                      updateAsyncAgentProgress(backgroundedTaskId, getProgressUpdate(tracker), rootSetAppState);
                      const lastToolName = getLastToolUseName(msg);
                      if (lastToolName) {
                        emitTaskProgress(tracker, backgroundedTaskId, toolUseContext.toolUseId, description, startTime, lastToolName);
                      }
                    }
                    const agentResult = finalizeAgentTool(agentMessages, backgroundedTaskId, metadata);

                    // Mark task completed FIRST so TaskOutput(block=true)
                    // unblocks immediately. classifyHandoffIfNeeded and
                    // cleanupWorktreeIfNeeded can hang — they must not gate
                    // the status transition (gh-20236).
                    completeAsyncAgent(agentResult, rootSetAppState);

                    // Extract text from agent result content for the notification
                    let finalMessage = extractTextContent(agentResult.content, '\n');
                    if (feature('TRANSCRIPT_CLASSIFIER')) {
                      const backgroundedAppState = toolUseContext.getAppState();
                      const handoffWarning = await classifyHandoffIfNeeded({
                        agentMessages,
                        tools: toolUseContext.options.tools,
                        toolPermissionContext: backgroundedAppState.toolPermissionContext,
                        abortSignal: task.abortController!.signal,
                        subagentType: selectedAgent.agentType,
                        totalToolUseCount: agentResult.totalToolUseCount
                      });
                      if (handoffWarning) {
                        finalMessage = `${handoffWarning}\n\n${finalMessage}`;
                      }
                    }

                    // Clean up worktree before notification so we can include it
                    const worktreeResult = await cleanupWorktreeIfNeeded();
                    enqueueAgentNotification({
                      taskId: backgroundedTaskId,
                      description,
                      status: 'completed',
                      setAppState: rootSetAppState,
                      finalMessage,
                      usage: {
                        totalTokens: getTokenCountFromTracker(tracker),
                        toolUses: agentResult.totalToolUseCount,
                        durationMs: agentResult.totalDurationMs
                      },
                      toolUseId: toolUseContext.toolUseId,
                      ...worktreeResult
                    });
                  } catch (error) {
                    if (error instanceof AbortError) {
                      // Transition status BEFORE worktree cleanup so
                      // TaskOutput unblocks even if git hangs (gh-20236).
                      killAsyncAgent(backgroundedTaskId, rootSetAppState);
                      logEvent('tengu_agent_tool_terminated', {
                        agent_type: metadata.agentType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
                        model: metadata.resolvedAgentModel as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
                        duration_ms: Date.now() - metadata.startTime,
                        is_async: true,
                        is_built_in_agent: metadata.isBuiltInAgent,
                        reason: 'user_cancel_background' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
                      });
                      const worktreeResult = await cleanupWorktreeIfNeeded();
                      const partialResult = extractPartialResult(agentMessages);
                      enqueueAgentNotification({
                        taskId: backgroundedTaskId,
                        description,
                        status: 'killed',
                        setAppState: rootSetAppState,
                        toolUseId: toolUseContext.toolUseId,
                        finalMessage: partialResult,
                        ...worktreeResult
                      });
                      return;
                    }
                    const errMsg = errorMessage(error);
                    failAsyncAgent(backgroundedTaskId, errMsg, rootSetAppState);
                    const worktreeResult = await cleanupWorktreeIfNeeded();
                    enqueueAgentNotification({
                      taskId: backgroundedTaskId,
                      description,
                      status: 'failed',
                      error: errMsg,
                      setAppState: rootSetAppState,
                      toolUseId: toolUseContext.toolUseId,
                      ...worktreeResult
                    });
                  } finally {
                    stopBackgroundedSummarization?.();
                    clearInvokedSkillsForAgent(syncAgentId);
                    clearDumpState(syncAgentId);
                    // Note: worktree cleanup is done before enqueueAgentNotification
                    // in both try and catch paths so we can include worktree info
                  }
                });

                // Return async_launched result immediately
                const canReadOutputFile = toolUseContext.options.tools.some(t => toolMatchesName(t, FILE_READ_TOOL_NAME) || toolMatchesName(t, BASH_TOOL_NAME));
                return {
                  data: {
                    isAsync: true as const,
                    status: 'async_launched' as const,
                    agentId: backgroundedTaskId,
                    description: description,
                    prompt: prompt,
                    outputFile: getTaskOutputPath(backgroundedTaskId),
                    canReadOutputFile
                  }
                };
              }
            }

            // Process the message from the race result
            if (raceResult.type !== 'message') {
              // This shouldn't happen - background case handled above
              continue;
            }
            const {
              result
            } = raceResult;
            if (result.done) break;
            const message = result.value;
            agentMessages.push(message);

            // Emit task_progress for the VS Code subagent panel
            updateProgressFromMessage(syncTracker, message, syncResolveActivity, toolUseContext.options.tools);
            if (foregroundTaskId) {
              const lastToolName = getLastToolUseName(message);
              if (lastToolName) {
                emitTaskProgress(syncTracker, foregroundTaskId, toolUseContext.toolUseId, description, agentStartTime, lastToolName);
                // Keep AppState task.progress in sync when SDK summaries are
                // enabled, so updateAgentSummary reads correct token/tool counts
                // instead of zeros.
                if (getSdkAgentProgressSummariesEnabled()) {
                  updateAsyncAgentProgress(foregroundTaskId, getProgressUpdate(syncTracker), rootSetAppState);
                }
              }
            }

            // Forward bash_progress events from sub-agent to parent so the SDK
            // receives tool_progress events just as it does for the main agent.
            if (message.type === 'progress' && (message.data.type === 'bash_progress' || message.data.type === 'powershell_progress') && onProgress) {
              onProgress({
                toolUseID: message.toolUseID,
                data: message.data
              });
            }
            if (message.type !== 'assistant' && message.type !== 'user') {
              continue;
            }

            // Increment token count in spinner for assistant messages
            // Subagent streaming events are filtered out in runAgent.ts, so we
            // need to count tokens from completed messages here
            if (message.type === 'assistant') {
              const contentLength = getAssistantMessageContentLength(message);
              if (contentLength > 0) {
                toolUseContext.setResponseLength(len => len + contentLength);
              }
            }
            const normalizedNew = normalizeMessages([message]);
            for (const m of normalizedNew) {
              for (const content of m.message.content) {
                if (content.type !== 'tool_use' && content.type !== 'tool_result') {
                  continue;
                }

                // Forward progress updates
                if (onProgress) {
                  onProgress({
                    toolUseID: `agent_${assistantMessage.message.id}`,
                    data: {
                      message: m,
                      type: 'agent_progress',
                      // prompt only needed on first progress message (UI.tsx:624
                      // reads progressMessages[0]). Omit here to avoid duplication.
                      prompt: '',
                      agentId: syncAgentId
                    }
                  });
                }
              }
            }
          }
        } catch (error) {
          // Handle errors from the sync agent loop
          // AbortError should be re-thrown for proper interruption handling
          if (error instanceof AbortError) {
            wasAborted = true;
            logEvent('tengu_agent_tool_terminated', {
              agent_type: metadata.agentType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
              model: metadata.resolvedAgentModel as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
              duration_ms: Date.now() - metadata.startTime,
              is_async: false,
              is_built_in_agent: metadata.isBuiltInAgent,
              reason: 'user_cancel_sync' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
            });
            throw error;
          }

          // Log the error for debugging
          logForDebugging(`Sync agent error: ${errorMessage(error)}`, {
            level: 'error'
          });

          // Store the error to handle after cleanup
          syncAgentError = toError(error);
        } finally {
          // Clear the background hint UI
          if (toolUseContext.setToolJSX) {
            toolUseContext.setToolJSX(null);
          }

          // Stop foreground summarization. Idempotent — if already stopped at
          // the backgrounding transition, this is a no-op. The backgrounded
          // closure owns a separate stop function (stopBackgroundedSummarization).
          stopForegroundSummarization?.();

          // Unregister foreground task if agent completed without being backgrounded
          if (foregroundTaskId) {
            unregisterAgentForeground(foregroundTaskId, rootSetAppState);
            // Notify SDK consumers (e.g. VS Code subagent panel) that this
            // foreground agent is done. Goes through drainSdkEvents() — does
            // NOT trigger the print.ts XML task_notification parser or the LLM loop.
            if (!wasBackgrounded) {
              const progress = getProgressUpdate(syncTracker);
              enqueueSdkEvent({
                type: 'system',
                subtype: 'task_notification',
                task_id: foregroundTaskId,
                tool_use_id: toolUseContext.toolUseId,
                status: syncAgentError ? 'failed' : wasAborted ? 'stopped' : 'completed',
                output_file: '',
                summary: description,
                usage: {
                  total_tokens: progress.tokenCount,
                  tool_uses: progress.toolUseCount,
                  duration_ms: Date.now() - agentStartTime
                }
              });
            }
          }

          // Clean up scoped skills so they don't accumulate in the global map
          clearInvokedSkillsForAgent(syncAgentId);

          // Clean up dumpState entry for this agent to prevent unbounded growth
          // Skip if backgrounded — the backgrounded agent's finally handles cleanup
          if (!wasBackgrounded) {
            clearDumpState(syncAgentId);
          }

          // Cancel auto-background timer if agent completed before it fired
          cancelAutoBackground?.();

          // Clean up worktree if applicable (in finally to handle abort/error paths)
          // Skip if backgrounded — the background continuation is still running in it
          if (!wasBackgrounded) {
            worktreeResult = await cleanupWorktreeIfNeeded();
          }
        }

        // Re-throw abort errors
        // TODO: Find a cleaner way to express this
        const lastMessage = agentMessages.findLast(_ => _.type !== 'system' && _.type !== 'progress');
        if (lastMessage && isSyntheticMessage(lastMessage)) {
          logEvent('tengu_agent_tool_terminated', {
            agent_type: metadata.agentType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
            model: metadata.resolvedAgentModel as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
            duration_ms: Date.now() - metadata.startTime,
            is_async: false,
            is_built_in_agent: metadata.isBuiltInAgent,
            reason: 'user_cancel_sync' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
          });
          throw new AbortError();
        }

        // If an error occurred during iteration, try to return a result with
        // whatever messages we have. If we have no assistant messages,
        // re-throw the error so it's properly handled by the tool framework.
        if (syncAgentError) {
          // Check if we have any assistant messages to return
          const hasAssistantMessages = agentMessages.some(msg => msg.type === 'assistant');
          if (!hasAssistantMessages) {
            // No messages collected, re-throw the error
            throw syncAgentError;
          }

          // We have some messages, try to finalize and return them
          // This allows the parent agent to see partial progress even after an error
          logForDebugging(`Sync agent recovering from error with ${agentMessages.length} messages`);
        }
        const agentResult = finalizeAgentTool(agentMessages, syncAgentId, metadata);
        if (feature('TRANSCRIPT_CLASSIFIER')) {
          const currentAppState = toolUseContext.getAppState();
          const handoffWarning = await classifyHandoffIfNeeded({
            agentMessages,
            tools: toolUseContext.options.tools,
            toolPermissionContext: currentAppState.toolPermissionContext,
            abortSignal: toolUseContext.abortController.signal,
            subagentType: selectedAgent.agentType,
            totalToolUseCount: agentResult.totalToolUseCount
          });
          if (handoffWarning) {
            agentResult.content = [{
              type: 'text' as const,
              text: handoffWarning
            }, ...agentResult.content];
          }
        }
        return {
          data: {
            status: 'completed' as const,
            prompt,
            ...agentResult,
            ...worktreeResult
          }
        };
      }));
    }
  },
  isReadOnly() {
    return true; // delegates permission checks to its underlying tools
  },
  toAutoClassifierInput(input) {
    const i = input as AgentToolInput;
    const tags = [i.subagent_type, i.mode ? `mode=${i.mode}` : undefined].filter((t): t is string => t !== undefined);
    const prefix = tags.length > 0 ? `(${tags.join(', ')}): ` : ': ';
    return `${prefix}${i.prompt}`;
  },
  isConcurrencySafe() {
    return true;
  },
  userFacingName,
  userFacingNameBackgroundColor,
  getActivityDescription(input) {
    return input?.description ?? 'Running task';
  },
  async checkPermissions(input, context): Promise<PermissionResult> {
    const appState = context.getAppState();

    // Only route through auto mode classifier when in auto mode
    // In all other modes, auto-approve sub-agent generation
    // Note: "external" === 'ant' guard enables dead code elimination for external builds
    if ("external" === 'ant' && appState.toolPermissionContext.mode === 'auto') {
      return {
        behavior: 'passthrough',
        message: 'Agent tool requires permission to spawn sub-agents.'
      };
    }
    return {
      behavior: 'allow',
      updatedInput: input
    };
  },
  mapToolResultToToolResultBlockParam(data, toolUseID) {
    // Multi-agent spawn result
    const internalData = data as InternalOutput;
    if (typeof internalData === 'object' && internalData !== null && 'status' in internalData && internalData.status === 'teammate_spawned') {
      const spawnData = internalData as TeammateSpawnedOutput;
      return {
        tool_use_id: toolUseID,
        type: 'tool_result',
        content: [{
          type: 'text',
          text: `Spawned successfully.
agent_id: ${spawnData.teammate_id}
name: ${spawnData.name}
team_name: ${spawnData.team_name}
The agent is now running and will receive instructions via mailbox.`
        }]
      };
    }
    if ('status' in internalData && internalData.status === 'remote_launched') {
      const r = internalData;
      return {
        tool_use_id: toolUseID,
        type: 'tool_result',
        content: [{
          type: 'text',
          text: `Remote agent launched in CCR.\ntaskId: ${r.taskId}\nsession_url: ${r.sessionUrl}\noutput_file: ${r.outputFile}\nThe agent is running remotely. You will be notified automatically when it completes.\nBriefly tell the user what you launched and end your response.`
        }]
      };
    }
    if (data.status === 'async_launched') {
      const prefix = `Async agent launched successfully.\nagentId: ${data.agentId} (internal ID - do not mention to user. Use SendMessage with to: '${data.agentId}' to continue this agent.)\nThe agent is working in the background. You will be notified automatically when it completes.`;
      const instructions = data.canReadOutputFile ? `Do not duplicate this agent's work — avoid working with the same files or topics it is using. Work on non-overlapping tasks, or briefly tell the user what you launched and end your response.\noutput_file: ${data.outputFile}\nIf asked, you can check progress before completion by using ${FILE_READ_TOOL_NAME} or ${BASH_TOOL_NAME} tail on the output file.` : `Briefly tell the user what you launched and end your response. Do not generate any other text — agent results will arrive in a subsequent message.`;
      const text = `${prefix}\n${instructions}`;
      return {
        tool_use_id: toolUseID,
        type: 'tool_result',
        content: [{
          type: 'text',
          text
        }]
      };
    }
    if (data.status === 'completed') {
      const worktreeData = data as Record<string, unknown>;
      const worktreeInfoText = worktreeData.worktreePath ? `\nworktreePath: ${worktreeData.worktreePath}\nworktreeBranch: ${worktreeData.worktreeBranch}` : '';
      // If the subagent completes with no content, the tool_result is just the
      // agentId/usage trailer below — a metadata-only block at the prompt tail.
      // Some models read that as "nothing to act on" and end their turn
      // immediately. Say so explicitly so the parent has something to react to.
      const contentOrMarker = data.content.length > 0 ? data.content : [{
        type: 'text' as const,
        text: '(Subagent completed but returned no output.)'
      }];
      // One-shot built-ins (Explore, Plan) are never continued via SendMessage
      // — the agentId hint and <usage> block are dead weight (~135 chars ×
      // 34M Explore runs/week ≈ 1-2 Gtok/week). Telemetry doesn't parse this
      // block (it uses logEvent in finalizeAgentTool), so dropping is safe.
      // agentType is optional for resume compat — missing means show trailer.
      if (data.agentType && ONE_SHOT_BUILTIN_AGENT_TYPES.has(data.agentType) && !worktreeInfoText) {
        return {
          tool_use_id: toolUseID,
          type: 'tool_result',
          content: contentOrMarker
        };
      }
      return {
        tool_use_id: toolUseID,
        type: 'tool_result',
        content: [...contentOrMarker, {
          type: 'text',
          text: `agentId: ${data.agentId} (use SendMessage with to: '${data.agentId}' to continue this agent)${worktreeInfoText}
<usage>total_tokens: ${data.totalTokens}
tool_uses: ${data.totalToolUseCount}
duration_ms: ${data.totalDurationMs}</usage>`
        }]
      };
    }
    data satisfies never;
    throw new Error(`Unexpected agent tool result status: ${(data as {
      status: string;
    }).status}`);
  },
  renderToolResultMessage,
  renderToolUseMessage,
  renderToolUseTag,
  renderToolUseProgressMessage,
  renderToolUseRejectedMessage,
  renderToolUseErrorMessage,
  renderGroupedToolUse: renderGroupedAgentToolUse
} satisfies ToolDef<InputSchema, Output, Progress>);
function resolveTeamName(input: {
  team_name?: string;
}, appState: {
  teamContext?: {
    teamName: string;
  };
}): string | undefined {
  if (!isAgentSwarmsEnabled()) return undefined;
  return input.team_name || appState.teamContext?.teamName;
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["feature","React","buildTool","ToolDef","toolMatchesName","Message","MessageType","NormalizedUserMessage","getQuerySourceForAgent","z","clearInvokedSkillsForAgent","getSdkAgentProgressSummariesEnabled","enhanceSystemPromptWithEnvDetails","getSystemPrompt","isCoordinatorMode","startAgentSummarization","getFeatureValue_CACHED_MAY_BE_STALE","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","logEvent","clearDumpState","completeAgentTask","completeAsyncAgent","createActivityDescriptionResolver","createProgressTracker","enqueueAgentNotification","failAgentTask","failAsyncAgent","getProgressUpdate","getTokenCountFromTracker","isLocalAgentTask","killAsyncAgent","registerAgentForeground","registerAsyncAgent","unregisterAgentForeground","updateAgentProgress","updateAsyncAgentProgress","updateProgressFromMessage","checkRemoteAgentEligibility","formatPreconditionError","getRemoteTaskSessionUrl","registerRemoteAgentTask","assembleToolPool","asAgentId","runWithAgentContext","isAgentSwarmsEnabled","getCwd","runWithCwdOverride","logForDebugging","isEnvTruthy","AbortError","errorMessage","toError","CacheSafeParams","lazySchema","createUserMessage","extractTextContent","isSyntheticMessage","normalizeMessages","getAgentModel","permissionModeSchema","PermissionResult","filterDeniedAgents","getDenyRuleForAgent","enqueueSdkEvent","writeAgentMetadata","sleep","buildEffectiveSystemPrompt","asSystemPrompt","getTaskOutputPath","getParentSessionId","isTeammate","isInProcessTeammate","teleportToRemote","getAssistantMessageContentLength","createAgentId","createAgentWorktree","hasWorktreeChanges","removeAgentWorktree","BASH_TOOL_NAME","BackgroundHint","FILE_READ_TOOL_NAME","spawnTeammate","setAgentColor","agentToolResultSchema","classifyHandoffIfNeeded","emitTaskProgress","extractPartialResult","finalizeAgentTool","getLastToolUseName","runAsyncAgentLifecycle","GENERAL_PURPOSE_AGENT","AGENT_TOOL_NAME","LEGACY_AGENT_TOOL_NAME","ONE_SHOT_BUILTIN_AGENT_TYPES","buildForkedMessages","buildWorktreeNotice","FORK_AGENT","isForkSubagentEnabled","isInForkChild","AgentDefinition","filterAgentsByMcpRequirements","hasRequiredMcpServers","isBuiltInAgent","getPrompt","runAgent","renderGroupedAgentToolUse","renderToolResultMessage","renderToolUseErrorMessage","renderToolUseMessage","renderToolUseProgressMessage","renderToolUseRejectedMessage","renderToolUseTag","userFacingName","userFacingNameBackgroundColor","proactiveModule","require","PROGRESS_THRESHOLD_MS","isBackgroundTasksDisabled","process","env","CLAUDE_CODE_DISABLE_BACKGROUND_TASKS","getAutoBackgroundMs","CLAUDE_AUTO_BACKGROUND_TASKS","baseInputSchema","object","description","string","describe","prompt","subagent_type","optional","model","enum","run_in_background","boolean","fullInputSchema","multiAgentInputSchema","name","team_name","mode","merge","extend","isolation","cwd","inputSchema","schema","omit","InputSchema","ReturnType","AgentToolInput","infer","outputSchema","syncOutputSchema","status","literal","asyncOutputSchema","agentId","outputFile","canReadOutputFile","union","OutputSchema","Output","input","TeammateSpawnedOutput","teammate_id","agent_id","agent_type","color","tmux_session_name","tmux_window_name","tmux_pane_id","is_splitpane","plan_mode_required","RemoteLaunchedOutput","taskId","sessionUrl","InternalOutput","AgentToolProgress","ShellProgress","Progress","AgentTool","agents","tools","getToolPermissionContext","allowedAgentTypes","toolPermissionContext","mcpServersWithTools","tool","startsWith","parts","split","serverName","includes","push","agentsWithMcpRequirementsMet","filteredAgents","isCoordinator","CLAUDE_CODE_COORDINATOR_MODE","searchHint","aliases","maxResultSizeChars","call","modelParam","spawnMode","toolUseContext","canUseTool","assistantMessage","onProgress","startTime","Date","now","undefined","appState","getAppState","permissionMode","rootSetAppState","setAppStateForTasks","setAppState","Error","teamName","resolveTeamName","agentDef","options","agentDefinitions","activeAgents","find","a","agentType","result","use_splitpane","invokingRequestId","requestId","spawnResult","const","data","effectiveType","isForkPath","selectedAgent","querySource","messages","allAgents","filter","found","agent","agentExistsButDenied","denyRule","source","map","join","background","requiredMcpServers","length","hasPendingRequiredServers","mcp","clients","some","c","type","pattern","toLowerCase","currentAppState","MAX_WAIT_MS","POLL_INTERVAL_MS","deadline","hasFailedRequiredServer","stillPending","serversWithTools","missing","server","resolvedAgentModel","mainLoopModel","is_built_in_agent","is_resume","is_async","is_fork","effectiveIsolation","eligibility","eligible","reasons","errors","bundleFailHint","session","initialMessage","signal","abortController","onBundleFail","msg","sessionId","remoteTaskType","id","title","command","context","toolUseId","remoteResult","enhancedSystemPrompt","forkParentSystemPrompt","promptMessages","renderedSystemPrompt","mainThreadAgentDefinition","additionalWorkingDirectories","Array","from","keys","defaultSystemPrompt","mcpClients","customSystemPrompt","appendSystemPrompt","agentPrompt","memory","scope","error","content","metadata","isAsync","forceAsync","assistantForceAsync","kairosEnabled","shouldRunAsync","isProactiveActive","workerPermissionContext","workerTools","earlyAgentId","worktreeInfo","worktreePath","worktreeBranch","headCommit","gitRoot","hookBased","slug","slice","runAgentParams","Parameters","agentDefinition","override","systemPrompt","availableTools","forkContextMessages","useExactTools","cwdOverridePath","wrapWithCwd","fn","T","cleanupWorktreeIfNeeded","Promise","changed","catch","_err","asyncAgentId","agentBackgroundTask","prev","next","Map","agentNameRegistry","set","asyncAgentContext","parentSessionId","subagentName","isBuiltIn","invocationKind","invocationEmitted","makeStream","onCacheSafeParams","agentIdForCleanup","enableSummarization","getWorktreeResult","t","syncAgentId","syncAgentContext","agentMessages","agentStartTime","syncTracker","syncResolveActivity","normalizedPromptMessages","normalizedFirstMessage","m","toolUseID","message","foregroundTaskId","backgroundPromise","cancelAutoBackground","registration","autoBackgroundMs","backgroundSignal","then","backgroundHintShown","wasBackgrounded","stopForegroundSummarization","summaryTaskId","agentIterator","params","stop","Symbol","asyncIterator","syncAgentError","wasAborted","worktreeResult","elapsed","setToolJSX","jsx","shouldHidePromptInput","shouldContinueAnimation","showSpinner","nextMessagePromise","raceResult","race","r","task","tasks","isBackgrounded","backgroundedTaskId","stopBackgroundedSummarization","return","tracker","resolveActivity2","existingMsg","lastToolName","agentResult","finalMessage","backgroundedAppState","handoffWarning","abortSignal","subagentType","totalToolUseCount","usage","totalTokens","toolUses","durationMs","totalDurationMs","duration_ms","reason","partialResult","errMsg","done","value","contentLength","setResponseLength","len","normalizedNew","level","progress","subtype","task_id","tool_use_id","output_file","summary","total_tokens","tokenCount","tool_uses","toolUseCount","lastMessage","findLast","_","hasAssistantMessages","text","isReadOnly","toAutoClassifierInput","i","tags","prefix","isConcurrencySafe","getActivityDescription","checkPermissions","behavior","updatedInput","mapToolResultToToolResultBlockParam","internalData","spawnData","instructions","worktreeData","Record","worktreeInfoText","contentOrMarker","has","renderGroupedToolUse","teamContext"],"sources":["AgentTool.tsx"],"sourcesContent":["import { feature } from 'bun:bundle'\nimport * as React from 'react'\nimport { buildTool, type ToolDef, toolMatchesName } from 'src/Tool.js'\nimport type {\n  Message as MessageType,\n  NormalizedUserMessage,\n} from 'src/types/message.js'\nimport { getQuerySourceForAgent } from 'src/utils/promptCategory.js'\nimport { z } from 'zod/v4'\nimport {\n  clearInvokedSkillsForAgent,\n  getSdkAgentProgressSummariesEnabled,\n} from '../../bootstrap/state.js'\nimport {\n  enhanceSystemPromptWithEnvDetails,\n  getSystemPrompt,\n} from '../../constants/prompts.js'\nimport { isCoordinatorMode } from '../../coordinator/coordinatorMode.js'\nimport { startAgentSummarization } from '../../services/AgentSummary/agentSummary.js'\nimport { getFeatureValue_CACHED_MAY_BE_STALE } from '../../services/analytics/growthbook.js'\nimport {\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  logEvent,\n} from '../../services/analytics/index.js'\nimport { clearDumpState } from '../../services/api/dumpPrompts.js'\nimport {\n  completeAgentTask as completeAsyncAgent,\n  createActivityDescriptionResolver,\n  createProgressTracker,\n  enqueueAgentNotification,\n  failAgentTask as failAsyncAgent,\n  getProgressUpdate,\n  getTokenCountFromTracker,\n  isLocalAgentTask,\n  killAsyncAgent,\n  registerAgentForeground,\n  registerAsyncAgent,\n  unregisterAgentForeground,\n  updateAgentProgress as updateAsyncAgentProgress,\n  updateProgressFromMessage,\n} from '../../tasks/LocalAgentTask/LocalAgentTask.js'\nimport {\n  checkRemoteAgentEligibility,\n  formatPreconditionError,\n  getRemoteTaskSessionUrl,\n  registerRemoteAgentTask,\n} from '../../tasks/RemoteAgentTask/RemoteAgentTask.js'\nimport { assembleToolPool } from '../../tools.js'\nimport { asAgentId } from '../../types/ids.js'\nimport { runWithAgentContext } from '../../utils/agentContext.js'\nimport { isAgentSwarmsEnabled } from '../../utils/agentSwarmsEnabled.js'\nimport { getCwd, runWithCwdOverride } from '../../utils/cwd.js'\nimport { logForDebugging } from '../../utils/debug.js'\nimport { isEnvTruthy } from '../../utils/envUtils.js'\nimport { AbortError, errorMessage, toError } from '../../utils/errors.js'\nimport type { CacheSafeParams } from '../../utils/forkedAgent.js'\nimport { lazySchema } from '../../utils/lazySchema.js'\nimport {\n  createUserMessage,\n  extractTextContent,\n  isSyntheticMessage,\n  normalizeMessages,\n} from '../../utils/messages.js'\nimport { getAgentModel } from '../../utils/model/agent.js'\nimport { permissionModeSchema } from '../../utils/permissions/PermissionMode.js'\nimport type { PermissionResult } from '../../utils/permissions/PermissionResult.js'\nimport {\n  filterDeniedAgents,\n  getDenyRuleForAgent,\n} from '../../utils/permissions/permissions.js'\nimport { enqueueSdkEvent } from '../../utils/sdkEventQueue.js'\nimport { writeAgentMetadata } from '../../utils/sessionStorage.js'\nimport { sleep } from '../../utils/sleep.js'\nimport { buildEffectiveSystemPrompt } from '../../utils/systemPrompt.js'\nimport { asSystemPrompt } from '../../utils/systemPromptType.js'\nimport { getTaskOutputPath } from '../../utils/task/diskOutput.js'\nimport { getParentSessionId, isTeammate } from '../../utils/teammate.js'\nimport { isInProcessTeammate } from '../../utils/teammateContext.js'\nimport { teleportToRemote } from '../../utils/teleport.js'\nimport { getAssistantMessageContentLength } from '../../utils/tokens.js'\nimport { createAgentId } from '../../utils/uuid.js'\nimport {\n  createAgentWorktree,\n  hasWorktreeChanges,\n  removeAgentWorktree,\n} from '../../utils/worktree.js'\nimport { BASH_TOOL_NAME } from '../BashTool/toolName.js'\nimport { BackgroundHint } from '../BashTool/UI.js'\nimport { FILE_READ_TOOL_NAME } from '../FileReadTool/prompt.js'\nimport { spawnTeammate } from '../shared/spawnMultiAgent.js'\nimport { setAgentColor } from './agentColorManager.js'\nimport {\n  agentToolResultSchema,\n  classifyHandoffIfNeeded,\n  emitTaskProgress,\n  extractPartialResult,\n  finalizeAgentTool,\n  getLastToolUseName,\n  runAsyncAgentLifecycle,\n} from './agentToolUtils.js'\nimport { GENERAL_PURPOSE_AGENT } from './built-in/generalPurposeAgent.js'\nimport {\n  AGENT_TOOL_NAME,\n  LEGACY_AGENT_TOOL_NAME,\n  ONE_SHOT_BUILTIN_AGENT_TYPES,\n} from './constants.js'\nimport {\n  buildForkedMessages,\n  buildWorktreeNotice,\n  FORK_AGENT,\n  isForkSubagentEnabled,\n  isInForkChild,\n} from './forkSubagent.js'\nimport type { AgentDefinition } from './loadAgentsDir.js'\nimport {\n  filterAgentsByMcpRequirements,\n  hasRequiredMcpServers,\n  isBuiltInAgent,\n} from './loadAgentsDir.js'\nimport { getPrompt } from './prompt.js'\nimport { runAgent } from './runAgent.js'\nimport {\n  renderGroupedAgentToolUse,\n  renderToolResultMessage,\n  renderToolUseErrorMessage,\n  renderToolUseMessage,\n  renderToolUseProgressMessage,\n  renderToolUseRejectedMessage,\n  renderToolUseTag,\n  userFacingName,\n  userFacingNameBackgroundColor,\n} from './UI.js'\n\n/* eslint-disable @typescript-eslint/no-require-imports */\nconst proactiveModule =\n  feature('PROACTIVE') || feature('KAIROS')\n    ? (require('../../proactive/index.js') as typeof import('../../proactive/index.js'))\n    : null\n/* eslint-enable @typescript-eslint/no-require-imports */\n\n// Progress display constants (for showing background hint)\nconst PROGRESS_THRESHOLD_MS = 2000 // Show background hint after 2 seconds\n\n// Check if background tasks are disabled at module load time\nconst isBackgroundTasksDisabled =\n  // eslint-disable-next-line custom-rules/no-process-env-top-level -- Intentional: schema must be defined at module load\n  isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_BACKGROUND_TASKS)\n\n// Auto-background agent tasks after this many ms (0 = disabled)\n// Enabled by env var OR GrowthBook gate (checked lazily since GB may not be ready at module load)\nfunction getAutoBackgroundMs(): number {\n  if (\n    isEnvTruthy(process.env.CLAUDE_AUTO_BACKGROUND_TASKS) ||\n    getFeatureValue_CACHED_MAY_BE_STALE('tengu_auto_background_agents', false)\n  ) {\n    return 120_000\n  }\n  return 0\n}\n\n// Multi-agent type constants are defined inline inside gated blocks to enable dead code elimination\n\n// Base input schema without multi-agent parameters\nconst baseInputSchema = lazySchema(() =>\n  z.object({\n    description: z\n      .string()\n      .describe('A short (3-5 word) description of the task'),\n    prompt: z.string().describe('The task for the agent to perform'),\n    subagent_type: z\n      .string()\n      .optional()\n      .describe('The type of specialized agent to use for this task'),\n    model: z\n      .enum(['sonnet', 'opus', 'haiku'])\n      .optional()\n      .describe(\n        \"Optional model override for this agent. Takes precedence over the agent definition's model frontmatter. If omitted, uses the agent definition's model, or inherits from the parent.\",\n      ),\n    run_in_background: z\n      .boolean()\n      .optional()\n      .describe(\n        'Set to true to run this agent in the background. You will be notified when it completes.',\n      ),\n  }),\n)\n\n// Full schema combining base + multi-agent params + isolation\nconst fullInputSchema = lazySchema(() => {\n  // Multi-agent parameters\n  const multiAgentInputSchema = z.object({\n    name: z\n      .string()\n      .optional()\n      .describe(\n        'Name for the spawned agent. Makes it addressable via SendMessage({to: name}) while running.',\n      ),\n    team_name: z\n      .string()\n      .optional()\n      .describe(\n        'Team name for spawning. Uses current team context if omitted.',\n      ),\n    mode: permissionModeSchema()\n      .optional()\n      .describe(\n        'Permission mode for spawned teammate (e.g., \"plan\" to require plan approval).',\n      ),\n  })\n\n  return baseInputSchema()\n    .merge(multiAgentInputSchema)\n    .extend({\n      isolation: (\"external\" === 'ant'\n        ? z.enum(['worktree', 'remote'])\n        : z.enum(['worktree'])\n      )\n        .optional()\n        .describe(\n          \"external\" === 'ant'\n            ? 'Isolation mode. \"worktree\" creates a temporary git worktree so the agent works on an isolated copy of the repo. \"remote\" launches the agent in a remote CCR environment (always runs in background).'\n            : 'Isolation mode. \"worktree\" creates a temporary git worktree so the agent works on an isolated copy of the repo.',\n        ),\n      cwd: z\n        .string()\n        .optional()\n        .describe(\n          'Absolute path to run the agent in. Overrides the working directory for all filesystem and shell operations within this agent. Mutually exclusive with isolation: \"worktree\".',\n        ),\n    })\n})\n\n// Strip optional fields from the schema when the backing feature is off so\n// the model never sees them. Done via .omit() rather than conditional spread\n// inside .extend() because the spread-ternary breaks Zod's type inference\n// (field type collapses to `unknown`). The ternary return produces a union\n// type, but call() destructures via the explicit AgentToolInput type below\n// which always includes all optional fields.\nexport const inputSchema = lazySchema(() => {\n  const schema = feature('KAIROS')\n    ? fullInputSchema()\n    : fullInputSchema().omit({ cwd: true })\n\n  // GrowthBook-in-lazySchema is acceptable here (unlike subagent_type, which\n  // was removed in 906da6c723): the divergence window is one-session-per-\n  // gate-flip via _CACHED_MAY_BE_STALE disk read, and worst case is either\n  // \"schema shows a no-op param\" (gate flips on mid-session: param ignored\n  // by forceAsync) or \"schema hides a param that would've worked\" (gate\n  // flips off mid-session: everything still runs async via memoized\n  // forceAsync). No Zod rejection, no crash — unlike required→optional.\n  return isBackgroundTasksDisabled || isForkSubagentEnabled()\n    ? schema.omit({ run_in_background: true })\n    : schema\n})\ntype InputSchema = ReturnType<typeof inputSchema>\n\n// Explicit type widens the schema inference to always include all optional\n// fields even when .omit() strips them for gating (cwd, run_in_background).\n// subagent_type is optional; call() defaults it to general-purpose when the\n// fork gate is off, or routes to the fork path when the gate is on.\ntype AgentToolInput = z.infer<ReturnType<typeof baseInputSchema>> & {\n  name?: string\n  team_name?: string\n  mode?: z.infer<ReturnType<typeof permissionModeSchema>>\n  isolation?: 'worktree' | 'remote'\n  cwd?: string\n}\n\n// Output schema - multi-agent spawned schema added dynamically at runtime when enabled\nexport const outputSchema = lazySchema(() => {\n  const syncOutputSchema = agentToolResultSchema().extend({\n    status: z.literal('completed'),\n    prompt: z.string(),\n  })\n\n  const asyncOutputSchema = z.object({\n    status: z.literal('async_launched'),\n    agentId: z.string().describe('The ID of the async agent'),\n    description: z.string().describe('The description of the task'),\n    prompt: z.string().describe('The prompt for the agent'),\n    outputFile: z\n      .string()\n      .describe('Path to the output file for checking agent progress'),\n    canReadOutputFile: z\n      .boolean()\n      .optional()\n      .describe(\n        'Whether the calling agent has Read/Bash tools to check progress',\n      ),\n  })\n\n  return z.union([syncOutputSchema, asyncOutputSchema])\n})\ntype OutputSchema = ReturnType<typeof outputSchema>\ntype Output = z.input<OutputSchema>\n\n// Private type for teammate spawn results - excluded from exported schema for dead code elimination\n// The 'teammate_spawned' status string is only included when ENABLE_AGENT_SWARMS is true\ntype TeammateSpawnedOutput = {\n  status: 'teammate_spawned'\n  prompt: string\n  teammate_id: string\n  agent_id: string\n  agent_type?: string\n  model?: string\n  name: string\n  color?: string\n  tmux_session_name: string\n  tmux_window_name: string\n  tmux_pane_id: string\n  team_name?: string\n  is_splitpane?: boolean\n  plan_mode_required?: boolean\n}\n\n// Combined output type including both public and internal types\n// Note: TeammateSpawnedOutput type is fine - TypeScript types are erased at compile time\n// Private type for remote-launched results — excluded from exported schema\n// like TeammateSpawnedOutput for dead code elimination purposes. Exported\n// for UI.tsx to do proper discriminated-union narrowing instead of ad-hoc casts.\nexport type RemoteLaunchedOutput = {\n  status: 'remote_launched'\n  taskId: string\n  sessionUrl: string\n  description: string\n  prompt: string\n  outputFile: string\n}\n\ntype InternalOutput = Output | TeammateSpawnedOutput | RemoteLaunchedOutput\n\nimport type { AgentToolProgress, ShellProgress } from '../../types/tools.js'\n// AgentTool forwards both its own progress events and shell progress\n// events from the sub-agent so the SDK receives tool_progress updates during bash/powershell runs.\nexport type Progress = AgentToolProgress | ShellProgress\n\nexport const AgentTool = buildTool({\n  async prompt({ agents, tools, getToolPermissionContext, allowedAgentTypes }) {\n    const toolPermissionContext = await getToolPermissionContext()\n\n    // Get MCP servers that have tools available\n    const mcpServersWithTools: string[] = []\n    for (const tool of tools) {\n      if (tool.name?.startsWith('mcp__')) {\n        const parts = tool.name.split('__')\n        const serverName = parts[1]\n        if (serverName && !mcpServersWithTools.includes(serverName)) {\n          mcpServersWithTools.push(serverName)\n        }\n      }\n    }\n\n    // Filter agents: first by MCP requirements, then by permission rules\n    const agentsWithMcpRequirementsMet = filterAgentsByMcpRequirements(\n      agents,\n      mcpServersWithTools,\n    )\n    const filteredAgents = filterDeniedAgents(\n      agentsWithMcpRequirementsMet,\n      toolPermissionContext,\n      AGENT_TOOL_NAME,\n    )\n\n    // Use inline env check instead of coordinatorModule to avoid circular\n    // dependency issues during test module loading.\n    const isCoordinator = feature('COORDINATOR_MODE')\n      ? isEnvTruthy(process.env.CLAUDE_CODE_COORDINATOR_MODE)\n      : false\n    return await getPrompt(filteredAgents, isCoordinator, allowedAgentTypes)\n  },\n  name: AGENT_TOOL_NAME,\n  searchHint: 'delegate work to a subagent',\n  aliases: [LEGACY_AGENT_TOOL_NAME],\n  maxResultSizeChars: 100_000,\n  async description() {\n    return 'Launch a new agent'\n  },\n  get inputSchema(): InputSchema {\n    return inputSchema()\n  },\n  get outputSchema(): OutputSchema {\n    return outputSchema()\n  },\n  async call(\n    {\n      prompt,\n      subagent_type,\n      description,\n      model: modelParam,\n      run_in_background,\n      name,\n      team_name,\n      mode: spawnMode,\n      isolation,\n      cwd,\n    }: AgentToolInput,\n    toolUseContext,\n    canUseTool,\n    assistantMessage,\n    onProgress?,\n  ) {\n    const startTime = Date.now()\n    const model = isCoordinatorMode() ? undefined : modelParam\n\n    // Get app state for permission mode and agent filtering\n    const appState = toolUseContext.getAppState()\n    const permissionMode = appState.toolPermissionContext.mode\n    // In-process teammates get a no-op setAppState; setAppStateForTasks\n    // reaches the root store so task registration/progress/kill stay visible.\n    const rootSetAppState =\n      toolUseContext.setAppStateForTasks ?? toolUseContext.setAppState\n\n    // Check if user is trying to use agent teams without access\n    if (team_name && !isAgentSwarmsEnabled()) {\n      throw new Error('Agent Teams is not yet available on your plan.')\n    }\n\n    // Teammates (in-process or tmux) passing `name` would trigger spawnTeammate()\n    // below, but TeamFile.members is a flat array with one leadAgentId — nested\n    // teammates land in the roster with no provenance and confuse the lead.\n    const teamName = resolveTeamName({ team_name }, appState)\n    if (isTeammate() && teamName && name) {\n      throw new Error(\n        'Teammates cannot spawn other teammates — the team roster is flat. To spawn a subagent instead, omit the `name` parameter.',\n      )\n    }\n    // In-process teammates cannot spawn background agents (their lifecycle is\n    // tied to the leader's process). Tmux teammates are separate processes and\n    // can manage their own background agents.\n    if (isInProcessTeammate() && teamName && run_in_background === true) {\n      throw new Error(\n        'In-process teammates cannot spawn background agents. Use run_in_background=false for synchronous subagents.',\n      )\n    }\n\n    // Check if this is a multi-agent spawn request\n    // Spawn is triggered when team_name is set (from param or context) and name is provided\n    if (teamName && name) {\n      // Set agent definition color for grouped UI display before spawning\n      const agentDef = subagent_type\n        ? toolUseContext.options.agentDefinitions.activeAgents.find(\n            a => a.agentType === subagent_type,\n          )\n        : undefined\n      if (agentDef?.color) {\n        setAgentColor(subagent_type!, agentDef.color)\n      }\n      const result = await spawnTeammate(\n        {\n          name,\n          prompt,\n          description,\n          team_name: teamName,\n          use_splitpane: true,\n          plan_mode_required: spawnMode === 'plan',\n          model: model ?? agentDef?.model,\n          agent_type: subagent_type,\n          invokingRequestId: assistantMessage?.requestId,\n        },\n        toolUseContext,\n      )\n\n      // Type assertion uses TeammateSpawnedOutput (defined above) instead of any.\n      // This type is excluded from the exported outputSchema for dead code elimination.\n      // Cast through unknown because TeammateSpawnedOutput is intentionally\n      // not part of the exported Output union (for dead code elimination purposes).\n      const spawnResult: TeammateSpawnedOutput = {\n        status: 'teammate_spawned' as const,\n        prompt,\n        ...result.data,\n      }\n      return { data: spawnResult } as unknown as { data: Output }\n    }\n\n    // Fork subagent experiment routing:\n    // - subagent_type set: use it (explicit wins)\n    // - subagent_type omitted, gate on: fork path (undefined)\n    // - subagent_type omitted, gate off: default general-purpose\n    const effectiveType =\n      subagent_type ??\n      (isForkSubagentEnabled() ? undefined : GENERAL_PURPOSE_AGENT.agentType)\n    const isForkPath = effectiveType === undefined\n\n    let selectedAgent: AgentDefinition\n    if (isForkPath) {\n      // Recursive fork guard: fork children keep the Agent tool in their\n      // pool for cache-identical tool defs, so reject fork attempts at call\n      // time. Primary check is querySource (compaction-resistant — set on\n      // context.options at spawn time, survives autocompact's message\n      // rewrite). Message-scan fallback catches any path where querySource\n      // wasn't threaded.\n      if (\n        toolUseContext.options.querySource ===\n          `agent:builtin:${FORK_AGENT.agentType}` ||\n        isInForkChild(toolUseContext.messages)\n      ) {\n        throw new Error(\n          'Fork is not available inside a forked worker. Complete your task directly using your tools.',\n        )\n      }\n      selectedAgent = FORK_AGENT\n    } else {\n      // Filter agents to exclude those denied via Agent(AgentName) syntax\n      const allAgents = toolUseContext.options.agentDefinitions.activeAgents\n      const { allowedAgentTypes } = toolUseContext.options.agentDefinitions\n      const agents = filterDeniedAgents(\n        // When allowedAgentTypes is set (from Agent(x,y) tool spec), restrict to those types\n        allowedAgentTypes\n          ? allAgents.filter(a => allowedAgentTypes.includes(a.agentType))\n          : allAgents,\n        appState.toolPermissionContext,\n        AGENT_TOOL_NAME,\n      )\n\n      const found = agents.find(agent => agent.agentType === effectiveType)\n      if (!found) {\n        // Check if the agent exists but is denied by permission rules\n        const agentExistsButDenied = allAgents.find(\n          agent => agent.agentType === effectiveType,\n        )\n        if (agentExistsButDenied) {\n          const denyRule = getDenyRuleForAgent(\n            appState.toolPermissionContext,\n            AGENT_TOOL_NAME,\n            effectiveType,\n          )\n          throw new Error(\n            `Agent type '${effectiveType}' has been denied by permission rule '${AGENT_TOOL_NAME}(${effectiveType})' from ${denyRule?.source ?? 'settings'}.`,\n          )\n        }\n        throw new Error(\n          `Agent type '${effectiveType}' not found. Available agents: ${agents\n            .map(a => a.agentType)\n            .join(', ')}`,\n        )\n      }\n      selectedAgent = found\n    }\n\n    // Same lifecycle constraint as the run_in_background guard above, but for\n    // agent definitions that force background via `background: true`. Checked\n    // here because selectedAgent is only now resolved.\n    if (\n      isInProcessTeammate() &&\n      teamName &&\n      selectedAgent.background === true\n    ) {\n      throw new Error(\n        `In-process teammates cannot spawn background agents. Agent '${selectedAgent.agentType}' has background: true in its definition.`,\n      )\n    }\n\n    // Capture for type narrowing — `let selectedAgent` prevents TS from\n    // narrowing property types across the if-else assignment above.\n    const requiredMcpServers = selectedAgent.requiredMcpServers\n\n    // Check if required MCP servers have tools available\n    // A server that's connected but not authenticated won't have any tools\n    if (requiredMcpServers?.length) {\n      // If any required servers are still pending (connecting), wait for them\n      // before checking tool availability. This avoids a race condition where\n      // the agent is invoked before MCP servers finish connecting.\n      const hasPendingRequiredServers = appState.mcp.clients.some(\n        c =>\n          c.type === 'pending' &&\n          requiredMcpServers.some(pattern =>\n            c.name.toLowerCase().includes(pattern.toLowerCase()),\n          ),\n      )\n\n      let currentAppState = appState\n      if (hasPendingRequiredServers) {\n        const MAX_WAIT_MS = 30_000\n        const POLL_INTERVAL_MS = 500\n        const deadline = Date.now() + MAX_WAIT_MS\n\n        while (Date.now() < deadline) {\n          await sleep(POLL_INTERVAL_MS)\n          currentAppState = toolUseContext.getAppState()\n\n          // Early exit: if any required server has already failed, no point\n          // waiting for other pending servers — the check will fail regardless.\n          const hasFailedRequiredServer = currentAppState.mcp.clients.some(\n            c =>\n              c.type === 'failed' &&\n              requiredMcpServers.some(pattern =>\n                c.name.toLowerCase().includes(pattern.toLowerCase()),\n              ),\n          )\n          if (hasFailedRequiredServer) break\n\n          const stillPending = currentAppState.mcp.clients.some(\n            c =>\n              c.type === 'pending' &&\n              requiredMcpServers.some(pattern =>\n                c.name.toLowerCase().includes(pattern.toLowerCase()),\n              ),\n          )\n          if (!stillPending) break\n        }\n      }\n\n      // Get servers that actually have tools (meaning they're connected AND authenticated)\n      const serversWithTools: string[] = []\n      for (const tool of currentAppState.mcp.tools) {\n        if (tool.name?.startsWith('mcp__')) {\n          // Extract server name from tool name (format: mcp__serverName__toolName)\n          const parts = tool.name.split('__')\n          const serverName = parts[1]\n          if (serverName && !serversWithTools.includes(serverName)) {\n            serversWithTools.push(serverName)\n          }\n        }\n      }\n\n      if (!hasRequiredMcpServers(selectedAgent, serversWithTools)) {\n        const missing = requiredMcpServers.filter(\n          pattern =>\n            !serversWithTools.some(server =>\n              server.toLowerCase().includes(pattern.toLowerCase()),\n            ),\n        )\n        throw new Error(\n          `Agent '${selectedAgent.agentType}' requires MCP servers matching: ${missing.join(', ')}. ` +\n            `MCP servers with tools: ${serversWithTools.length > 0 ? serversWithTools.join(', ') : 'none'}. ` +\n            `Use /mcp to configure and authenticate the required MCP servers.`,\n        )\n      }\n    }\n\n    // Initialize the color for this agent if it has a predefined one\n    if (selectedAgent.color) {\n      setAgentColor(selectedAgent.agentType, selectedAgent.color)\n    }\n\n    // Resolve agent params for logging (these are already resolved in runAgent)\n    const resolvedAgentModel = getAgentModel(\n      selectedAgent.model,\n      toolUseContext.options.mainLoopModel,\n      isForkPath ? undefined : model,\n      permissionMode,\n    )\n\n    logEvent('tengu_agent_tool_selected', {\n      agent_type:\n        selectedAgent.agentType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      model:\n        resolvedAgentModel as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      source:\n        selectedAgent.source as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      color:\n        selectedAgent.color as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      is_built_in_agent: isBuiltInAgent(selectedAgent),\n      is_resume: false,\n      is_async:\n        (run_in_background === true || selectedAgent.background === true) &&\n        !isBackgroundTasksDisabled,\n      is_fork: isForkPath,\n    })\n\n    // Resolve effective isolation mode (explicit param overrides agent def)\n    const effectiveIsolation = isolation ?? selectedAgent.isolation\n\n    // Remote isolation: delegate to CCR. Gated ant-only — the guard enables\n    // dead code elimination of the entire block for external builds.\n    if (\"external\" === 'ant' && effectiveIsolation === 'remote') {\n      const eligibility = await checkRemoteAgentEligibility()\n      if (!eligibility.eligible) {\n        const reasons = eligibility.errors\n          .map(formatPreconditionError)\n          .join('\\n')\n        throw new Error(`Cannot launch remote agent:\\n${reasons}`)\n      }\n\n      let bundleFailHint: string | undefined\n      const session = await teleportToRemote({\n        initialMessage: prompt,\n        description,\n        signal: toolUseContext.abortController.signal,\n        onBundleFail: msg => {\n          bundleFailHint = msg\n        },\n      })\n      if (!session) {\n        throw new Error(bundleFailHint ?? 'Failed to create remote session')\n      }\n\n      const { taskId, sessionId } = registerRemoteAgentTask({\n        remoteTaskType: 'remote-agent',\n        session: { id: session.id, title: session.title || description },\n        command: prompt,\n        context: toolUseContext,\n        toolUseId: toolUseContext.toolUseId,\n      })\n\n      logEvent('tengu_agent_tool_remote_launched', {\n        agent_type:\n          selectedAgent.agentType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      })\n\n      const remoteResult: RemoteLaunchedOutput = {\n        status: 'remote_launched',\n        taskId,\n        sessionUrl: getRemoteTaskSessionUrl(sessionId),\n        description,\n        prompt,\n        outputFile: getTaskOutputPath(taskId),\n      }\n      return { data: remoteResult } as unknown as { data: Output }\n    }\n    // System prompt + prompt messages: branch on fork path.\n    //\n    // Fork path: child inherits the PARENT's system prompt (not FORK_AGENT's)\n    // for cache-identical API request prefixes. Prompt messages are built via\n    // buildForkedMessages() which clones the parent's full assistant message\n    // (all tool_use blocks) + placeholder tool_results + per-child directive.\n    //\n    // Normal path: build the selected agent's own system prompt with env\n    // details, and use a simple user message for the prompt.\n    let enhancedSystemPrompt: string[] | undefined\n    let forkParentSystemPrompt:\n      | ReturnType<typeof buildEffectiveSystemPrompt>\n      | undefined\n    let promptMessages: MessageType[]\n\n    if (isForkPath) {\n      if (toolUseContext.renderedSystemPrompt) {\n        forkParentSystemPrompt = toolUseContext.renderedSystemPrompt\n      } else {\n        // Fallback: recompute. May diverge from parent's cached bytes if\n        // GrowthBook state changed between parent turn-start and fork spawn.\n        const mainThreadAgentDefinition = appState.agent\n          ? appState.agentDefinitions.activeAgents.find(\n              a => a.agentType === appState.agent,\n            )\n          : undefined\n        const additionalWorkingDirectories = Array.from(\n          appState.toolPermissionContext.additionalWorkingDirectories.keys(),\n        )\n        const defaultSystemPrompt = await getSystemPrompt(\n          toolUseContext.options.tools,\n          toolUseContext.options.mainLoopModel,\n          additionalWorkingDirectories,\n          toolUseContext.options.mcpClients,\n        )\n        forkParentSystemPrompt = buildEffectiveSystemPrompt({\n          mainThreadAgentDefinition,\n          toolUseContext,\n          customSystemPrompt: toolUseContext.options.customSystemPrompt,\n          defaultSystemPrompt,\n          appendSystemPrompt: toolUseContext.options.appendSystemPrompt,\n        })\n      }\n      promptMessages = buildForkedMessages(prompt, assistantMessage)\n    } else {\n      try {\n        const additionalWorkingDirectories = Array.from(\n          appState.toolPermissionContext.additionalWorkingDirectories.keys(),\n        )\n\n        // All agents have getSystemPrompt - pass toolUseContext to all\n        const agentPrompt = selectedAgent.getSystemPrompt({ toolUseContext })\n\n        // Log agent memory loaded event for subagents\n        if (selectedAgent.memory) {\n          logEvent('tengu_agent_memory_loaded', {\n            ...(\"external\" === 'ant' && {\n              agent_type:\n                selectedAgent.agentType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n            }),\n            scope:\n              selectedAgent.memory as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n            source:\n              'subagent' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n          })\n        }\n\n        // Apply environment details enhancement\n        enhancedSystemPrompt = await enhanceSystemPromptWithEnvDetails(\n          [agentPrompt],\n          resolvedAgentModel,\n          additionalWorkingDirectories,\n        )\n      } catch (error) {\n        logForDebugging(\n          `Failed to get system prompt for agent ${selectedAgent.agentType}: ${errorMessage(error)}`,\n        )\n      }\n      promptMessages = [createUserMessage({ content: prompt })]\n    }\n\n    const metadata = {\n      prompt,\n      resolvedAgentModel,\n      isBuiltInAgent: isBuiltInAgent(selectedAgent),\n      startTime,\n      agentType: selectedAgent.agentType,\n      isAsync:\n        (run_in_background === true || selectedAgent.background === true) &&\n        !isBackgroundTasksDisabled,\n    }\n\n    // Use inline env check instead of coordinatorModule to avoid circular\n    // dependency issues during test module loading.\n    const isCoordinator = feature('COORDINATOR_MODE')\n      ? isEnvTruthy(process.env.CLAUDE_CODE_COORDINATOR_MODE)\n      : false\n\n    // Fork subagent experiment: force ALL spawns async for a unified\n    // <task-notification> interaction model (not just fork spawns — all of them).\n    const forceAsync = isForkSubagentEnabled()\n\n    // Assistant mode: force all agents async. Synchronous subagents hold the\n    // main loop's turn open until they complete — the daemon's inputQueue\n    // backs up, and the first overdue cron catch-up on spawn becomes N\n    // serial subagent turns blocking all user input. Same gate as\n    // executeForkedSlashCommand's fire-and-forget path; the\n    // <task-notification> re-entry there is handled by the else branch\n    // below (registerAsyncAgentTask + notifyOnCompletion).\n    const assistantForceAsync = feature('KAIROS')\n      ? appState.kairosEnabled\n      : false\n\n    const shouldRunAsync =\n      (run_in_background === true ||\n        selectedAgent.background === true ||\n        isCoordinator ||\n        forceAsync ||\n        assistantForceAsync ||\n        (proactiveModule?.isProactiveActive() ?? false)) &&\n      !isBackgroundTasksDisabled\n    // Assemble the worker's tool pool independently of the parent's.\n    // Workers always get their tools from assembleToolPool with their own\n    // permission mode, so they aren't affected by the parent's tool\n    // restrictions. This is computed here so that runAgent doesn't need to\n    // import from tools.ts (which would create a circular dependency).\n    const workerPermissionContext = {\n      ...appState.toolPermissionContext,\n      mode: selectedAgent.permissionMode ?? 'acceptEdits',\n    }\n    const workerTools = assembleToolPool(\n      workerPermissionContext,\n      appState.mcp.tools,\n    )\n\n    // Create a stable agent ID early so it can be used for worktree slug\n    const earlyAgentId = createAgentId()\n\n    // Set up worktree isolation if requested\n    let worktreeInfo: {\n      worktreePath: string\n      worktreeBranch?: string\n      headCommit?: string\n      gitRoot?: string\n      hookBased?: boolean\n    } | null = null\n\n    if (effectiveIsolation === 'worktree') {\n      const slug = `agent-${earlyAgentId.slice(0, 8)}`\n      worktreeInfo = await createAgentWorktree(slug)\n    }\n\n    // Fork + worktree: inject a notice telling the child to translate paths\n    // and re-read potentially stale files. Appended after the fork directive\n    // so it appears as the most recent guidance the child sees.\n    if (isForkPath && worktreeInfo) {\n      promptMessages.push(\n        createUserMessage({\n          content: buildWorktreeNotice(getCwd(), worktreeInfo.worktreePath),\n        }),\n      )\n    }\n\n    const runAgentParams: Parameters<typeof runAgent>[0] = {\n      agentDefinition: selectedAgent,\n      promptMessages,\n      toolUseContext,\n      canUseTool,\n      isAsync: shouldRunAsync,\n      querySource:\n        toolUseContext.options.querySource ??\n        getQuerySourceForAgent(\n          selectedAgent.agentType,\n          isBuiltInAgent(selectedAgent),\n        ),\n      model: isForkPath ? undefined : model,\n      // Fork path: pass parent's system prompt AND parent's exact tool\n      // array (cache-identical prefix). workerTools is rebuilt under\n      // permissionMode 'bubble' which differs from the parent's mode, so\n      // its tool-def serialization diverges and breaks cache at the first\n      // differing tool. useExactTools also inherits the parent's\n      // thinkingConfig and isNonInteractiveSession (see runAgent.ts).\n      //\n      // Normal path: when a cwd override is in effect (worktree isolation\n      // or explicit cwd), skip the pre-built system prompt so runAgent's\n      // buildAgentSystemPrompt() runs inside wrapWithCwd where getCwd()\n      // returns the override path.\n      override: isForkPath\n        ? { systemPrompt: forkParentSystemPrompt }\n        : enhancedSystemPrompt && !worktreeInfo && !cwd\n          ? { systemPrompt: asSystemPrompt(enhancedSystemPrompt) }\n          : undefined,\n      availableTools: isForkPath ? toolUseContext.options.tools : workerTools,\n      // Pass parent conversation when the fork-subagent path needs full\n      // context. useExactTools inherits thinkingConfig (runAgent.ts:624).\n      forkContextMessages: isForkPath ? toolUseContext.messages : undefined,\n      ...(isForkPath && { useExactTools: true }),\n      worktreePath: worktreeInfo?.worktreePath,\n      description,\n    }\n\n    // Helper to wrap execution with a cwd override: explicit cwd arg (KAIROS)\n    // takes precedence over worktree isolation path.\n    const cwdOverridePath = cwd ?? worktreeInfo?.worktreePath\n    const wrapWithCwd = <T,>(fn: () => T): T =>\n      cwdOverridePath ? runWithCwdOverride(cwdOverridePath, fn) : fn()\n\n    // Helper to clean up worktree after agent completes\n    const cleanupWorktreeIfNeeded = async (): Promise<{\n      worktreePath?: string\n      worktreeBranch?: string\n    }> => {\n      if (!worktreeInfo) return {}\n      const { worktreePath, worktreeBranch, headCommit, gitRoot, hookBased } =\n        worktreeInfo\n      // Null out to make idempotent — guards against double-call if code\n      // between cleanup and end of try throws into catch\n      worktreeInfo = null\n      if (hookBased) {\n        // Hook-based worktrees are always kept since we can't detect VCS changes\n        logForDebugging(`Hook-based agent worktree kept at: ${worktreePath}`)\n        return { worktreePath }\n      }\n      if (headCommit) {\n        const changed = await hasWorktreeChanges(worktreePath, headCommit)\n        if (!changed) {\n          await removeAgentWorktree(worktreePath, worktreeBranch, gitRoot)\n          // Clear worktreePath from metadata so resume doesn't try to use\n          // a deleted directory. Fire-and-forget to match runAgent's\n          // writeAgentMetadata handling.\n          void writeAgentMetadata(asAgentId(earlyAgentId), {\n            agentType: selectedAgent.agentType,\n            description,\n          }).catch(_err =>\n            logForDebugging(`Failed to clear worktree metadata: ${_err}`),\n          )\n          return {}\n        }\n      }\n      logForDebugging(`Agent worktree has changes, keeping: ${worktreePath}`)\n      return { worktreePath, worktreeBranch }\n    }\n\n    if (shouldRunAsync) {\n      const asyncAgentId = earlyAgentId\n      const agentBackgroundTask = registerAsyncAgent({\n        agentId: asyncAgentId,\n        description,\n        prompt,\n        selectedAgent,\n        setAppState: rootSetAppState,\n        // Don't link to parent's abort controller -- background agents should\n        // survive when the user presses ESC to cancel the main thread.\n        // They are killed explicitly via chat:killAgents.\n        toolUseId: toolUseContext.toolUseId,\n      })\n\n      // Register name → agentId for SendMessage routing. Post-registerAsyncAgent\n      // so we don't leave a stale entry if spawn fails. Sync agents skipped —\n      // coordinator is blocked, so SendMessage routing doesn't apply.\n      if (name) {\n        rootSetAppState(prev => {\n          const next = new Map(prev.agentNameRegistry)\n          next.set(name, asAgentId(asyncAgentId))\n          return { ...prev, agentNameRegistry: next }\n        })\n      }\n\n      // Wrap async agent execution in agent context for analytics attribution\n      const asyncAgentContext = {\n        agentId: asyncAgentId,\n        // For subagents from teammates: use team lead's session\n        // For subagents from main REPL: undefined (no parent session)\n        parentSessionId: getParentSessionId(),\n        agentType: 'subagent' as const,\n        subagentName: selectedAgent.agentType,\n        isBuiltIn: isBuiltInAgent(selectedAgent),\n        invokingRequestId: assistantMessage?.requestId,\n        invocationKind: 'spawn' as const,\n        invocationEmitted: false,\n      }\n\n      // Workload propagation: handlePromptSubmit wraps the entire turn in\n      // runWithWorkload (AsyncLocalStorage). ALS context is captured at\n      // invocation time — when this `void` fires — and survives every await\n      // inside. No capture/restore needed; the detached closure sees the\n      // parent turn's workload automatically, isolated from its finally.\n      void runWithAgentContext(asyncAgentContext, () =>\n        wrapWithCwd(() =>\n          runAsyncAgentLifecycle({\n            taskId: agentBackgroundTask.agentId,\n            abortController: agentBackgroundTask.abortController!,\n            makeStream: onCacheSafeParams =>\n              runAgent({\n                ...runAgentParams,\n                override: {\n                  ...runAgentParams.override,\n                  agentId: asAgentId(agentBackgroundTask.agentId),\n                  abortController: agentBackgroundTask.abortController!,\n                },\n                onCacheSafeParams,\n              }),\n            metadata,\n            description,\n            toolUseContext,\n            rootSetAppState,\n            agentIdForCleanup: asyncAgentId,\n            enableSummarization:\n              isCoordinator ||\n              isForkSubagentEnabled() ||\n              getSdkAgentProgressSummariesEnabled(),\n            getWorktreeResult: cleanupWorktreeIfNeeded,\n          }),\n        ),\n      )\n\n      const canReadOutputFile = toolUseContext.options.tools.some(\n        t =>\n          toolMatchesName(t, FILE_READ_TOOL_NAME) ||\n          toolMatchesName(t, BASH_TOOL_NAME),\n      )\n      return {\n        data: {\n          isAsync: true as const,\n          status: 'async_launched' as const,\n          agentId: agentBackgroundTask.agentId,\n          description: description,\n          prompt: prompt,\n          outputFile: getTaskOutputPath(agentBackgroundTask.agentId),\n          canReadOutputFile,\n        },\n      }\n    } else {\n      // Create an explicit agentId for sync agents\n      const syncAgentId = asAgentId(earlyAgentId)\n\n      // Set up agent context for sync execution (for analytics attribution)\n      const syncAgentContext = {\n        agentId: syncAgentId,\n        // For subagents from teammates: use team lead's session\n        // For subagents from main REPL: undefined (no parent session)\n        parentSessionId: getParentSessionId(),\n        agentType: 'subagent' as const,\n        subagentName: selectedAgent.agentType,\n        isBuiltIn: isBuiltInAgent(selectedAgent),\n        invokingRequestId: assistantMessage?.requestId,\n        invocationKind: 'spawn' as const,\n        invocationEmitted: false,\n      }\n\n      // Wrap entire sync agent execution in context for analytics attribution\n      // and optionally in a worktree cwd override for filesystem isolation\n      return runWithAgentContext(syncAgentContext, () =>\n        wrapWithCwd(async () => {\n          const agentMessages: MessageType[] = []\n          const agentStartTime = Date.now()\n          const syncTracker = createProgressTracker()\n          const syncResolveActivity = createActivityDescriptionResolver(\n            toolUseContext.options.tools,\n          )\n\n          // Yield initial progress message to carry metadata (prompt)\n          if (promptMessages.length > 0) {\n            const normalizedPromptMessages = normalizeMessages(promptMessages)\n            const normalizedFirstMessage = normalizedPromptMessages.find(\n              (m): m is NormalizedUserMessage => m.type === 'user',\n            )\n            if (\n              normalizedFirstMessage &&\n              normalizedFirstMessage.type === 'user' &&\n              onProgress\n            ) {\n              onProgress({\n                toolUseID: `agent_${assistantMessage.message.id}`,\n                data: {\n                  message: normalizedFirstMessage,\n                  type: 'agent_progress',\n                  prompt,\n                  agentId: syncAgentId,\n                },\n              })\n            }\n          }\n\n          // Register as foreground task immediately so it can be backgrounded at any time\n          // Skip registration if background tasks are disabled\n          let foregroundTaskId: string | undefined\n          // Create the background race promise once outside the loop — otherwise\n          // each iteration adds a new .then() reaction to the same pending\n          // promise, accumulating callbacks for the lifetime of the agent.\n          let backgroundPromise: Promise<{ type: 'background' }> | undefined\n          let cancelAutoBackground: (() => void) | undefined\n          if (!isBackgroundTasksDisabled) {\n            const registration = registerAgentForeground({\n              agentId: syncAgentId,\n              description,\n              prompt,\n              selectedAgent,\n              setAppState: rootSetAppState,\n              toolUseId: toolUseContext.toolUseId,\n              autoBackgroundMs: getAutoBackgroundMs() || undefined,\n            })\n            foregroundTaskId = registration.taskId\n            backgroundPromise = registration.backgroundSignal.then(() => ({\n              type: 'background' as const,\n            }))\n            cancelAutoBackground = registration.cancelAutoBackground\n          }\n\n          // Track if we've shown the background hint UI\n          let backgroundHintShown = false\n          // Track if the agent was backgrounded (cleanup handled by backgrounded finally)\n          let wasBackgrounded = false\n          // Per-scope stop function — NOT shared with the backgrounded closure.\n          // idempotent: startAgentSummarization's stop() checks `stopped` flag.\n          let stopForegroundSummarization: (() => void) | undefined\n          // const capture for sound type narrowing inside the callback below\n          const summaryTaskId = foregroundTaskId\n\n          // Get async iterator for the agent\n          const agentIterator = runAgent({\n            ...runAgentParams,\n            override: {\n              ...runAgentParams.override,\n              agentId: syncAgentId,\n            },\n            onCacheSafeParams:\n              summaryTaskId && getSdkAgentProgressSummariesEnabled()\n                ? (params: CacheSafeParams) => {\n                    const { stop } = startAgentSummarization(\n                      summaryTaskId,\n                      syncAgentId,\n                      params,\n                      rootSetAppState,\n                    )\n                    stopForegroundSummarization = stop\n                  }\n                : undefined,\n          })[Symbol.asyncIterator]()\n\n          // Track if an error occurred during iteration\n          let syncAgentError: Error | undefined\n          let wasAborted = false\n          let worktreeResult: {\n            worktreePath?: string\n            worktreeBranch?: string\n          } = {}\n\n          try {\n            while (true) {\n              const elapsed = Date.now() - agentStartTime\n\n              // Show background hint after threshold (but task is already registered)\n              // Skip if background tasks are disabled\n              if (\n                !isBackgroundTasksDisabled &&\n                !backgroundHintShown &&\n                elapsed >= PROGRESS_THRESHOLD_MS &&\n                toolUseContext.setToolJSX\n              ) {\n                backgroundHintShown = true\n                toolUseContext.setToolJSX({\n                  jsx: <BackgroundHint />,\n                  shouldHidePromptInput: false,\n                  shouldContinueAnimation: true,\n                  showSpinner: true,\n                })\n              }\n\n              // Race between next message and background signal\n              // If background tasks are disabled, just await the next message directly\n              const nextMessagePromise = agentIterator.next()\n              const raceResult = backgroundPromise\n                ? await Promise.race([\n                    nextMessagePromise.then(r => ({\n                      type: 'message' as const,\n                      result: r,\n                    })),\n                    backgroundPromise,\n                  ])\n                : {\n                    type: 'message' as const,\n                    result: await nextMessagePromise,\n                  }\n\n              // Check if we were backgrounded via backgroundAll()\n              // foregroundTaskId is guaranteed to be defined if raceResult.type is 'background'\n              // because backgroundPromise is only defined when foregroundTaskId is defined\n              if (raceResult.type === 'background' && foregroundTaskId) {\n                const appState = toolUseContext.getAppState()\n                const task = appState.tasks[foregroundTaskId]\n                if (isLocalAgentTask(task) && task.isBackgrounded) {\n                  // Capture the taskId for use in the async callback\n                  const backgroundedTaskId = foregroundTaskId\n                  wasBackgrounded = true\n                  // Stop foreground summarization; the backgrounded closure\n                  // below owns its own independent stop function.\n                  stopForegroundSummarization?.()\n\n                  // Workload: inherited via ALS at `void` invocation time,\n                  // same as the async-from-start path above.\n                  // Continue agent in background and return async result\n                  void runWithAgentContext(syncAgentContext, async () => {\n                    let stopBackgroundedSummarization: (() => void) | undefined\n                    try {\n                      // Clean up the foreground iterator so its finally block runs\n                      // (releases MCP connections, session hooks, prompt cache tracking, etc.)\n                      // Timeout prevents blocking if MCP server cleanup hangs.\n                      // .catch() prevents unhandled rejection if timeout wins the race.\n                      await Promise.race([\n                        agentIterator.return(undefined).catch(() => {}),\n                        sleep(1000),\n                      ])\n                      // Initialize progress tracking from existing messages\n                      const tracker = createProgressTracker()\n                      const resolveActivity2 =\n                        createActivityDescriptionResolver(\n                          toolUseContext.options.tools,\n                        )\n                      for (const existingMsg of agentMessages) {\n                        updateProgressFromMessage(\n                          tracker,\n                          existingMsg,\n                          resolveActivity2,\n                          toolUseContext.options.tools,\n                        )\n                      }\n                      for await (const msg of runAgent({\n                        ...runAgentParams,\n                        isAsync: true, // Agent is now running in background\n                        override: {\n                          ...runAgentParams.override,\n                          agentId: asAgentId(backgroundedTaskId),\n                          abortController: task.abortController,\n                        },\n                        onCacheSafeParams: getSdkAgentProgressSummariesEnabled()\n                          ? (params: CacheSafeParams) => {\n                              const { stop } = startAgentSummarization(\n                                backgroundedTaskId,\n                                asAgentId(backgroundedTaskId),\n                                params,\n                                rootSetAppState,\n                              )\n                              stopBackgroundedSummarization = stop\n                            }\n                          : undefined,\n                      })) {\n                        agentMessages.push(msg)\n\n                        // Track progress for backgrounded agents\n                        updateProgressFromMessage(\n                          tracker,\n                          msg,\n                          resolveActivity2,\n                          toolUseContext.options.tools,\n                        )\n                        updateAsyncAgentProgress(\n                          backgroundedTaskId,\n                          getProgressUpdate(tracker),\n                          rootSetAppState,\n                        )\n\n                        const lastToolName = getLastToolUseName(msg)\n                        if (lastToolName) {\n                          emitTaskProgress(\n                            tracker,\n                            backgroundedTaskId,\n                            toolUseContext.toolUseId,\n                            description,\n                            startTime,\n                            lastToolName,\n                          )\n                        }\n                      }\n                      const agentResult = finalizeAgentTool(\n                        agentMessages,\n                        backgroundedTaskId,\n                        metadata,\n                      )\n\n                      // Mark task completed FIRST so TaskOutput(block=true)\n                      // unblocks immediately. classifyHandoffIfNeeded and\n                      // cleanupWorktreeIfNeeded can hang — they must not gate\n                      // the status transition (gh-20236).\n                      completeAsyncAgent(agentResult, rootSetAppState)\n\n                      // Extract text from agent result content for the notification\n                      let finalMessage = extractTextContent(\n                        agentResult.content,\n                        '\\n',\n                      )\n\n                      if (feature('TRANSCRIPT_CLASSIFIER')) {\n                        const backgroundedAppState =\n                          toolUseContext.getAppState()\n                        const handoffWarning = await classifyHandoffIfNeeded({\n                          agentMessages,\n                          tools: toolUseContext.options.tools,\n                          toolPermissionContext:\n                            backgroundedAppState.toolPermissionContext,\n                          abortSignal: task.abortController!.signal,\n                          subagentType: selectedAgent.agentType,\n                          totalToolUseCount: agentResult.totalToolUseCount,\n                        })\n                        if (handoffWarning) {\n                          finalMessage = `${handoffWarning}\\n\\n${finalMessage}`\n                        }\n                      }\n\n                      // Clean up worktree before notification so we can include it\n                      const worktreeResult = await cleanupWorktreeIfNeeded()\n\n                      enqueueAgentNotification({\n                        taskId: backgroundedTaskId,\n                        description,\n                        status: 'completed',\n                        setAppState: rootSetAppState,\n                        finalMessage,\n                        usage: {\n                          totalTokens: getTokenCountFromTracker(tracker),\n                          toolUses: agentResult.totalToolUseCount,\n                          durationMs: agentResult.totalDurationMs,\n                        },\n                        toolUseId: toolUseContext.toolUseId,\n                        ...worktreeResult,\n                      })\n                    } catch (error) {\n                      if (error instanceof AbortError) {\n                        // Transition status BEFORE worktree cleanup so\n                        // TaskOutput unblocks even if git hangs (gh-20236).\n                        killAsyncAgent(backgroundedTaskId, rootSetAppState)\n                        logEvent('tengu_agent_tool_terminated', {\n                          agent_type:\n                            metadata.agentType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n                          model:\n                            metadata.resolvedAgentModel as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n                          duration_ms: Date.now() - metadata.startTime,\n                          is_async: true,\n                          is_built_in_agent: metadata.isBuiltInAgent,\n                          reason:\n                            'user_cancel_background' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n                        })\n                        const worktreeResult = await cleanupWorktreeIfNeeded()\n                        const partialResult =\n                          extractPartialResult(agentMessages)\n                        enqueueAgentNotification({\n                          taskId: backgroundedTaskId,\n                          description,\n                          status: 'killed',\n                          setAppState: rootSetAppState,\n                          toolUseId: toolUseContext.toolUseId,\n                          finalMessage: partialResult,\n                          ...worktreeResult,\n                        })\n                        return\n                      }\n                      const errMsg = errorMessage(error)\n                      failAsyncAgent(\n                        backgroundedTaskId,\n                        errMsg,\n                        rootSetAppState,\n                      )\n                      const worktreeResult = await cleanupWorktreeIfNeeded()\n                      enqueueAgentNotification({\n                        taskId: backgroundedTaskId,\n                        description,\n                        status: 'failed',\n                        error: errMsg,\n                        setAppState: rootSetAppState,\n                        toolUseId: toolUseContext.toolUseId,\n                        ...worktreeResult,\n                      })\n                    } finally {\n                      stopBackgroundedSummarization?.()\n                      clearInvokedSkillsForAgent(syncAgentId)\n                      clearDumpState(syncAgentId)\n                      // Note: worktree cleanup is done before enqueueAgentNotification\n                      // in both try and catch paths so we can include worktree info\n                    }\n                  })\n\n                  // Return async_launched result immediately\n                  const canReadOutputFile = toolUseContext.options.tools.some(\n                    t =>\n                      toolMatchesName(t, FILE_READ_TOOL_NAME) ||\n                      toolMatchesName(t, BASH_TOOL_NAME),\n                  )\n                  return {\n                    data: {\n                      isAsync: true as const,\n                      status: 'async_launched' as const,\n                      agentId: backgroundedTaskId,\n                      description: description,\n                      prompt: prompt,\n                      outputFile: getTaskOutputPath(backgroundedTaskId),\n                      canReadOutputFile,\n                    },\n                  }\n                }\n              }\n\n              // Process the message from the race result\n              if (raceResult.type !== 'message') {\n                // This shouldn't happen - background case handled above\n                continue\n              }\n              const { result } = raceResult\n              if (result.done) break\n              const message = result.value\n\n              agentMessages.push(message)\n\n              // Emit task_progress for the VS Code subagent panel\n              updateProgressFromMessage(\n                syncTracker,\n                message,\n                syncResolveActivity,\n                toolUseContext.options.tools,\n              )\n              if (foregroundTaskId) {\n                const lastToolName = getLastToolUseName(message)\n                if (lastToolName) {\n                  emitTaskProgress(\n                    syncTracker,\n                    foregroundTaskId,\n                    toolUseContext.toolUseId,\n                    description,\n                    agentStartTime,\n                    lastToolName,\n                  )\n                  // Keep AppState task.progress in sync when SDK summaries are\n                  // enabled, so updateAgentSummary reads correct token/tool counts\n                  // instead of zeros.\n                  if (getSdkAgentProgressSummariesEnabled()) {\n                    updateAsyncAgentProgress(\n                      foregroundTaskId,\n                      getProgressUpdate(syncTracker),\n                      rootSetAppState,\n                    )\n                  }\n                }\n              }\n\n              // Forward bash_progress events from sub-agent to parent so the SDK\n              // receives tool_progress events just as it does for the main agent.\n              if (\n                message.type === 'progress' &&\n                (message.data.type === 'bash_progress' ||\n                  message.data.type === 'powershell_progress') &&\n                onProgress\n              ) {\n                onProgress({\n                  toolUseID: message.toolUseID,\n                  data: message.data,\n                })\n              }\n\n              if (message.type !== 'assistant' && message.type !== 'user') {\n                continue\n              }\n\n              // Increment token count in spinner for assistant messages\n              // Subagent streaming events are filtered out in runAgent.ts, so we\n              // need to count tokens from completed messages here\n              if (message.type === 'assistant') {\n                const contentLength = getAssistantMessageContentLength(message)\n                if (contentLength > 0) {\n                  toolUseContext.setResponseLength(len => len + contentLength)\n                }\n              }\n\n              const normalizedNew = normalizeMessages([message])\n              for (const m of normalizedNew) {\n                for (const content of m.message.content) {\n                  if (\n                    content.type !== 'tool_use' &&\n                    content.type !== 'tool_result'\n                  ) {\n                    continue\n                  }\n\n                  // Forward progress updates\n                  if (onProgress) {\n                    onProgress({\n                      toolUseID: `agent_${assistantMessage.message.id}`,\n                      data: {\n                        message: m,\n                        type: 'agent_progress',\n                        // prompt only needed on first progress message (UI.tsx:624\n                        // reads progressMessages[0]). Omit here to avoid duplication.\n                        prompt: '',\n                        agentId: syncAgentId,\n                      },\n                    })\n                  }\n                }\n              }\n            }\n          } catch (error) {\n            // Handle errors from the sync agent loop\n            // AbortError should be re-thrown for proper interruption handling\n            if (error instanceof AbortError) {\n              wasAborted = true\n              logEvent('tengu_agent_tool_terminated', {\n                agent_type:\n                  metadata.agentType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n                model:\n                  metadata.resolvedAgentModel as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n                duration_ms: Date.now() - metadata.startTime,\n                is_async: false,\n                is_built_in_agent: metadata.isBuiltInAgent,\n                reason:\n                  'user_cancel_sync' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n              })\n              throw error\n            }\n\n            // Log the error for debugging\n            logForDebugging(`Sync agent error: ${errorMessage(error)}`, {\n              level: 'error',\n            })\n\n            // Store the error to handle after cleanup\n            syncAgentError = toError(error)\n          } finally {\n            // Clear the background hint UI\n            if (toolUseContext.setToolJSX) {\n              toolUseContext.setToolJSX(null)\n            }\n\n            // Stop foreground summarization. Idempotent — if already stopped at\n            // the backgrounding transition, this is a no-op. The backgrounded\n            // closure owns a separate stop function (stopBackgroundedSummarization).\n            stopForegroundSummarization?.()\n\n            // Unregister foreground task if agent completed without being backgrounded\n            if (foregroundTaskId) {\n              unregisterAgentForeground(foregroundTaskId, rootSetAppState)\n              // Notify SDK consumers (e.g. VS Code subagent panel) that this\n              // foreground agent is done. Goes through drainSdkEvents() — does\n              // NOT trigger the print.ts XML task_notification parser or the LLM loop.\n              if (!wasBackgrounded) {\n                const progress = getProgressUpdate(syncTracker)\n                enqueueSdkEvent({\n                  type: 'system',\n                  subtype: 'task_notification',\n                  task_id: foregroundTaskId,\n                  tool_use_id: toolUseContext.toolUseId,\n                  status: syncAgentError\n                    ? 'failed'\n                    : wasAborted\n                      ? 'stopped'\n                      : 'completed',\n                  output_file: '',\n                  summary: description,\n                  usage: {\n                    total_tokens: progress.tokenCount,\n                    tool_uses: progress.toolUseCount,\n                    duration_ms: Date.now() - agentStartTime,\n                  },\n                })\n              }\n            }\n\n            // Clean up scoped skills so they don't accumulate in the global map\n            clearInvokedSkillsForAgent(syncAgentId)\n\n            // Clean up dumpState entry for this agent to prevent unbounded growth\n            // Skip if backgrounded — the backgrounded agent's finally handles cleanup\n            if (!wasBackgrounded) {\n              clearDumpState(syncAgentId)\n            }\n\n            // Cancel auto-background timer if agent completed before it fired\n            cancelAutoBackground?.()\n\n            // Clean up worktree if applicable (in finally to handle abort/error paths)\n            // Skip if backgrounded — the background continuation is still running in it\n            if (!wasBackgrounded) {\n              worktreeResult = await cleanupWorktreeIfNeeded()\n            }\n          }\n\n          // Re-throw abort errors\n          // TODO: Find a cleaner way to express this\n          const lastMessage = agentMessages.findLast(\n            _ => _.type !== 'system' && _.type !== 'progress',\n          )\n          if (lastMessage && isSyntheticMessage(lastMessage)) {\n            logEvent('tengu_agent_tool_terminated', {\n              agent_type:\n                metadata.agentType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n              model:\n                metadata.resolvedAgentModel as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n              duration_ms: Date.now() - metadata.startTime,\n              is_async: false,\n              is_built_in_agent: metadata.isBuiltInAgent,\n              reason:\n                'user_cancel_sync' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n            })\n            throw new AbortError()\n          }\n\n          // If an error occurred during iteration, try to return a result with\n          // whatever messages we have. If we have no assistant messages,\n          // re-throw the error so it's properly handled by the tool framework.\n          if (syncAgentError) {\n            // Check if we have any assistant messages to return\n            const hasAssistantMessages = agentMessages.some(\n              msg => msg.type === 'assistant',\n            )\n\n            if (!hasAssistantMessages) {\n              // No messages collected, re-throw the error\n              throw syncAgentError\n            }\n\n            // We have some messages, try to finalize and return them\n            // This allows the parent agent to see partial progress even after an error\n            logForDebugging(\n              `Sync agent recovering from error with ${agentMessages.length} messages`,\n            )\n          }\n\n          const agentResult = finalizeAgentTool(\n            agentMessages,\n            syncAgentId,\n            metadata,\n          )\n\n          if (feature('TRANSCRIPT_CLASSIFIER')) {\n            const currentAppState = toolUseContext.getAppState()\n            const handoffWarning = await classifyHandoffIfNeeded({\n              agentMessages,\n              tools: toolUseContext.options.tools,\n              toolPermissionContext: currentAppState.toolPermissionContext,\n              abortSignal: toolUseContext.abortController.signal,\n              subagentType: selectedAgent.agentType,\n              totalToolUseCount: agentResult.totalToolUseCount,\n            })\n            if (handoffWarning) {\n              agentResult.content = [\n                { type: 'text' as const, text: handoffWarning },\n                ...agentResult.content,\n              ]\n            }\n          }\n\n          return {\n            data: {\n              status: 'completed' as const,\n              prompt,\n              ...agentResult,\n              ...worktreeResult,\n            },\n          }\n        }),\n      )\n    }\n  },\n  isReadOnly() {\n    return true // delegates permission checks to its underlying tools\n  },\n  toAutoClassifierInput(input) {\n    const i = input as AgentToolInput\n    const tags = [\n      i.subagent_type,\n      i.mode ? `mode=${i.mode}` : undefined,\n    ].filter((t): t is string => t !== undefined)\n    const prefix = tags.length > 0 ? `(${tags.join(', ')}): ` : ': '\n    return `${prefix}${i.prompt}`\n  },\n  isConcurrencySafe() {\n    return true\n  },\n  userFacingName,\n  userFacingNameBackgroundColor,\n  getActivityDescription(input) {\n    return input?.description ?? 'Running task'\n  },\n  async checkPermissions(input, context): Promise<PermissionResult> {\n    const appState = context.getAppState()\n\n    // Only route through auto mode classifier when in auto mode\n    // In all other modes, auto-approve sub-agent generation\n    // Note: \"external\" === 'ant' guard enables dead code elimination for external builds\n    if (\n      \"external\" === 'ant' &&\n      appState.toolPermissionContext.mode === 'auto'\n    ) {\n      return {\n        behavior: 'passthrough',\n        message: 'Agent tool requires permission to spawn sub-agents.',\n      }\n    }\n\n    return { behavior: 'allow', updatedInput: input }\n  },\n  mapToolResultToToolResultBlockParam(data, toolUseID) {\n    // Multi-agent spawn result\n    const internalData = data as InternalOutput\n    if (\n      typeof internalData === 'object' &&\n      internalData !== null &&\n      'status' in internalData &&\n      internalData.status === 'teammate_spawned'\n    ) {\n      const spawnData = internalData as TeammateSpawnedOutput\n      return {\n        tool_use_id: toolUseID,\n        type: 'tool_result',\n        content: [\n          {\n            type: 'text',\n            text: `Spawned successfully.\nagent_id: ${spawnData.teammate_id}\nname: ${spawnData.name}\nteam_name: ${spawnData.team_name}\nThe agent is now running and will receive instructions via mailbox.`,\n          },\n        ],\n      }\n    }\n    if ('status' in internalData && internalData.status === 'remote_launched') {\n      const r = internalData\n      return {\n        tool_use_id: toolUseID,\n        type: 'tool_result',\n        content: [\n          {\n            type: 'text',\n            text: `Remote agent launched in CCR.\\ntaskId: ${r.taskId}\\nsession_url: ${r.sessionUrl}\\noutput_file: ${r.outputFile}\\nThe agent is running remotely. You will be notified automatically when it completes.\\nBriefly tell the user what you launched and end your response.`,\n          },\n        ],\n      }\n    }\n    if (data.status === 'async_launched') {\n      const prefix = `Async agent launched successfully.\\nagentId: ${data.agentId} (internal ID - do not mention to user. Use SendMessage with to: '${data.agentId}' to continue this agent.)\\nThe agent is working in the background. You will be notified automatically when it completes.`\n      const instructions = data.canReadOutputFile\n        ? `Do not duplicate this agent's work — avoid working with the same files or topics it is using. Work on non-overlapping tasks, or briefly tell the user what you launched and end your response.\\noutput_file: ${data.outputFile}\\nIf asked, you can check progress before completion by using ${FILE_READ_TOOL_NAME} or ${BASH_TOOL_NAME} tail on the output file.`\n        : `Briefly tell the user what you launched and end your response. Do not generate any other text — agent results will arrive in a subsequent message.`\n      const text = `${prefix}\\n${instructions}`\n      return {\n        tool_use_id: toolUseID,\n        type: 'tool_result',\n        content: [\n          {\n            type: 'text',\n            text,\n          },\n        ],\n      }\n    }\n    if (data.status === 'completed') {\n      const worktreeData = data as Record<string, unknown>\n      const worktreeInfoText = worktreeData.worktreePath\n        ? `\\nworktreePath: ${worktreeData.worktreePath}\\nworktreeBranch: ${worktreeData.worktreeBranch}`\n        : ''\n      // If the subagent completes with no content, the tool_result is just the\n      // agentId/usage trailer below — a metadata-only block at the prompt tail.\n      // Some models read that as \"nothing to act on\" and end their turn\n      // immediately. Say so explicitly so the parent has something to react to.\n      const contentOrMarker =\n        data.content.length > 0\n          ? data.content\n          : [\n              {\n                type: 'text' as const,\n                text: '(Subagent completed but returned no output.)',\n              },\n            ]\n      // One-shot built-ins (Explore, Plan) are never continued via SendMessage\n      // — the agentId hint and <usage> block are dead weight (~135 chars ×\n      // 34M Explore runs/week ≈ 1-2 Gtok/week). Telemetry doesn't parse this\n      // block (it uses logEvent in finalizeAgentTool), so dropping is safe.\n      // agentType is optional for resume compat — missing means show trailer.\n      if (\n        data.agentType &&\n        ONE_SHOT_BUILTIN_AGENT_TYPES.has(data.agentType) &&\n        !worktreeInfoText\n      ) {\n        return {\n          tool_use_id: toolUseID,\n          type: 'tool_result',\n          content: contentOrMarker,\n        }\n      }\n      return {\n        tool_use_id: toolUseID,\n        type: 'tool_result',\n        content: [\n          ...contentOrMarker,\n          {\n            type: 'text',\n            text: `agentId: ${data.agentId} (use SendMessage with to: '${data.agentId}' to continue this agent)${worktreeInfoText}\n<usage>total_tokens: ${data.totalTokens}\ntool_uses: ${data.totalToolUseCount}\nduration_ms: ${data.totalDurationMs}</usage>`,\n          },\n        ],\n      }\n    }\n    data satisfies never\n    throw new Error(\n      `Unexpected agent tool result status: ${(data as { status: string }).status}`,\n    )\n  },\n  renderToolResultMessage,\n  renderToolUseMessage,\n  renderToolUseTag,\n  renderToolUseProgressMessage,\n  renderToolUseRejectedMessage,\n  renderToolUseErrorMessage,\n  renderGroupedToolUse: renderGroupedAgentToolUse,\n} satisfies ToolDef<InputSchema, Output, Progress>)\n\nfunction resolveTeamName(\n  input: { team_name?: string },\n  appState: { teamContext?: { teamName: string } },\n): string | undefined {\n  if (!isAgentSwarmsEnabled()) return undefined\n  return input.team_name || appState.teamContext?.teamName\n}\n"],"mappings":"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","ignoreList":[]}