src/tasks/LocalAgentTask/LocalAgentTask.tsx

import { getSdkAgentProgressSummariesEnabled } from '../../bootstrap/state.js';
import { OUTPUT_FILE_TAG, STATUS_TAG, SUMMARY_TAG, TASK_ID_TAG, TASK_NOTIFICATION_TAG, TOOL_USE_ID_TAG, WORKTREE_BRANCH_TAG, WORKTREE_PATH_TAG, WORKTREE_TAG } from '../../constants/xml.js';
import { abortSpeculation } from '../../services/PromptSuggestion/speculation.js';
import type { AppState } from '../../state/AppState.js';
import type { SetAppState, Task, TaskStateBase } from '../../Task.js';
import { createTaskStateBase } from '../../Task.js';
import type { Tools } from '../../Tool.js';
import { findToolByName } from '../../Tool.js';
import type { AgentToolResult } from '../../tools/AgentTool/agentToolUtils.js';
import type { AgentDefinition } from '../../tools/AgentTool/loadAgentsDir.js';
import { SYNTHETIC_OUTPUT_TOOL_NAME } from '../../tools/SyntheticOutputTool/SyntheticOutputTool.js';
import { asAgentId } from '../../types/ids.js';
import type { Message } from '../../types/message.js';
import { createAbortController, createChildAbortController } from '../../utils/abortController.js';
import { registerCleanup } from '../../utils/cleanupRegistry.js';
import { getToolSearchOrReadInfo } from '../../utils/collapseReadSearch.js';
import { enqueuePendingNotification } from '../../utils/messageQueueManager.js';
import { getAgentTranscriptPath } from '../../utils/sessionStorage.js';
import { evictTaskOutput, getTaskOutputPath, initTaskOutputAsSymlink } from '../../utils/task/diskOutput.js';
import { PANEL_GRACE_MS, registerTask, updateTaskState } from '../../utils/task/framework.js';
import { emitTaskProgress } from '../../utils/task/sdkProgress.js';
import type { TaskState } from '../types.js';
export type ToolActivity = {
  toolName: string;
  input: Record<string, unknown>;
  /** Pre-computed activity description from the tool, e.g. "Reading src/foo.ts" */
  activityDescription?: string;
  /** Pre-computed: true if this is a search operation (Grep, Glob, etc.) */
  isSearch?: boolean;
  /** Pre-computed: true if this is a read operation (Read, cat, etc.) */
  isRead?: boolean;
};
export type AgentProgress = {
  toolUseCount: number;
  tokenCount: number;
  lastActivity?: ToolActivity;
  recentActivities?: ToolActivity[];
  summary?: string;
};
const MAX_RECENT_ACTIVITIES = 5;
export type ProgressTracker = {
  toolUseCount: number;
  // Track input and output separately to avoid double-counting.
  // input_tokens in Claude API is cumulative per turn (includes all previous context),
  // so we keep the latest value. output_tokens is per-turn, so we sum those.
  latestInputTokens: number;
  cumulativeOutputTokens: number;
  recentActivities: ToolActivity[];
};
export function createProgressTracker(): ProgressTracker {
  return {
    toolUseCount: 0,
    latestInputTokens: 0,
    cumulativeOutputTokens: 0,
    recentActivities: []
  };
}
export function getTokenCountFromTracker(tracker: ProgressTracker): number {
  return tracker.latestInputTokens + tracker.cumulativeOutputTokens;
}

/**
 * Resolver function that returns a human-readable activity description
 * for a given tool name and input. Used to pre-compute descriptions
 * from Tool.getActivityDescription() at recording time.
 */
export type ActivityDescriptionResolver = (toolName: string, input: Record<string, unknown>) => string | undefined;
export function updateProgressFromMessage(tracker: ProgressTracker, message: Message, resolveActivityDescription?: ActivityDescriptionResolver, tools?: Tools): void {
  if (message.type !== 'assistant') {
    return;
  }
  const usage = message.message.usage;
  // Keep latest input (it's cumulative in the API), sum outputs
  tracker.latestInputTokens = usage.input_tokens + (usage.cache_creation_input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0);
  tracker.cumulativeOutputTokens += usage.output_tokens;
  for (const content of message.message.content) {
    if (content.type === 'tool_use') {
      tracker.toolUseCount++;
      // Omit StructuredOutput from preview - it's an internal tool
      if (content.name !== SYNTHETIC_OUTPUT_TOOL_NAME) {
        const input = content.input as Record<string, unknown>;
        const classification = tools ? getToolSearchOrReadInfo(content.name, input, tools) : undefined;
        tracker.recentActivities.push({
          toolName: content.name,
          input,
          activityDescription: resolveActivityDescription?.(content.name, input),
          isSearch: classification?.isSearch,
          isRead: classification?.isRead
        });
      }
    }
  }
  while (tracker.recentActivities.length > MAX_RECENT_ACTIVITIES) {
    tracker.recentActivities.shift();
  }
}
export function getProgressUpdate(tracker: ProgressTracker): AgentProgress {
  return {
    toolUseCount: tracker.toolUseCount,
    tokenCount: getTokenCountFromTracker(tracker),
    lastActivity: tracker.recentActivities.length > 0 ? tracker.recentActivities[tracker.recentActivities.length - 1] : undefined,
    recentActivities: [...tracker.recentActivities]
  };
}

/**
 * Creates an ActivityDescriptionResolver from a tools list.
 * Looks up the tool by name and calls getActivityDescription if available.
 */
export function createActivityDescriptionResolver(tools: Tools): ActivityDescriptionResolver {
  return (toolName, input) => {
    const tool = findToolByName(tools, toolName);
    return tool?.getActivityDescription?.(input) ?? undefined;
  };
}
export type LocalAgentTaskState = TaskStateBase & {
  type: 'local_agent';
  agentId: string;
  prompt: string;
  selectedAgent?: AgentDefinition;
  agentType: string;
  model?: string;
  abortController?: AbortController;
  unregisterCleanup?: () => void;
  error?: string;
  result?: AgentToolResult;
  progress?: AgentProgress;
  retrieved: boolean;
  messages?: Message[];
  // Track what we last reported for computing deltas
  lastReportedToolCount: number;
  lastReportedTokenCount: number;
  // Whether the task has been backgrounded (false = foreground running, true = backgrounded)
  isBackgrounded: boolean;
  // Messages queued mid-turn via SendMessage, drained at tool-round boundaries
  pendingMessages: string[];
  // UI is holding this task: blocks eviction, enables stream-append, triggers
  // disk bootstrap. Set by enterTeammateView. Separate from viewingAgentTaskId
  // (which is "what am I LOOKING at") — retain is "what am I HOLDING."
  retain: boolean;
  // Bootstrap has read the sidechain JSONL and UUID-merged into messages.
  // One-shot per retain cycle; stream appends from there.
  diskLoaded: boolean;
  // Panel visibility deadline. undefined = no deadline (running or retained);
  // timestamp = hide + GC-eligible after this time. Set at terminal transition
  // and on unselect; cleared on retain.
  evictAfter?: number;
};
export function isLocalAgentTask(task: unknown): task is LocalAgentTaskState {
  return typeof task === 'object' && task !== null && 'type' in task && task.type === 'local_agent';
}

/**
 * A local_agent task that the CoordinatorTaskPanel manages (not main-session).
 * For ants, these render in the panel instead of the background-task pill.
 * This is the ONE predicate that all pill/panel filters must agree on — if
 * the gate changes, change it here.
 */
export function isPanelAgentTask(t: unknown): t is LocalAgentTaskState {
  return isLocalAgentTask(t) && t.agentType !== 'main-session';
}
export function queuePendingMessage(taskId: string, msg: string, setAppState: (f: (prev: AppState) => AppState) => void): void {
  updateTaskState<LocalAgentTaskState>(taskId, setAppState, task => ({
    ...task,
    pendingMessages: [...task.pendingMessages, msg]
  }));
}

/**
 * Append a message to task.messages so it appears in the viewed transcript
 * immediately. Caller constructs the Message (breaks the messages.ts cycle).
 * queuePendingMessage and resumeAgentBackground route the prompt to the
 * agent's API input but don't touch the display.
 */
export function appendMessageToLocalAgent(taskId: string, message: Message, setAppState: (f: (prev: AppState) => AppState) => void): void {
  updateTaskState<LocalAgentTaskState>(taskId, setAppState, task => ({
    ...task,
    messages: [...(task.messages ?? []), message]
  }));
}
export function drainPendingMessages(taskId: string, getAppState: () => AppState, setAppState: (f: (prev: AppState) => AppState) => void): string[] {
  const task = getAppState().tasks[taskId];
  if (!isLocalAgentTask(task) || task.pendingMessages.length === 0) {
    return [];
  }
  const drained = task.pendingMessages;
  updateTaskState<LocalAgentTaskState>(taskId, setAppState, t => ({
    ...t,
    pendingMessages: []
  }));
  return drained;
}

/**
 * Enqueue an agent notification to the message queue.
 */
export function enqueueAgentNotification({
  taskId,
  description,
  status,
  error,
  setAppState,
  finalMessage,
  usage,
  toolUseId,
  worktreePath,
  worktreeBranch
}: {
  taskId: string;
  description: string;
  status: 'completed' | 'failed' | 'killed';
  error?: string;
  setAppState: SetAppState;
  finalMessage?: string;
  usage?: {
    totalTokens: number;
    toolUses: number;
    durationMs: number;
  };
  toolUseId?: string;
  worktreePath?: string;
  worktreeBranch?: string;
}): void {
  // Atomically check and set notified flag to prevent duplicate notifications.
  // If the task was already marked as notified (e.g., by TaskStopTool), skip
  // enqueueing to avoid sending redundant messages to the model.
  let shouldEnqueue = false;
  updateTaskState<LocalAgentTaskState>(taskId, setAppState, task => {
    if (task.notified) {
      return task;
    }
    shouldEnqueue = true;
    return {
      ...task,
      notified: true
    };
  });
  if (!shouldEnqueue) {
    return;
  }

  // Abort any active speculation — background task state changed, so speculated
  // results may reference stale task output. The prompt suggestion text is
  // preserved; only the pre-computed response is discarded.
  abortSpeculation(setAppState);
  const summary = status === 'completed' ? `Agent "${description}" completed` : status === 'failed' ? `Agent "${description}" failed: ${error || 'Unknown error'}` : `Agent "${description}" was stopped`;
  const outputPath = getTaskOutputPath(taskId);
  const toolUseIdLine = toolUseId ? `\n<${TOOL_USE_ID_TAG}>${toolUseId}</${TOOL_USE_ID_TAG}>` : '';
  const resultSection = finalMessage ? `\n<result>${finalMessage}</result>` : '';
  const usageSection = usage ? `\n<usage><total_tokens>${usage.totalTokens}</total_tokens><tool_uses>${usage.toolUses}</tool_uses><duration_ms>${usage.durationMs}</duration_ms></usage>` : '';
  const worktreeSection = worktreePath ? `\n<${WORKTREE_TAG}><${WORKTREE_PATH_TAG}>${worktreePath}</${WORKTREE_PATH_TAG}>${worktreeBranch ? `<${WORKTREE_BRANCH_TAG}>${worktreeBranch}</${WORKTREE_BRANCH_TAG}>` : ''}</${WORKTREE_TAG}>` : '';
  const message = `<${TASK_NOTIFICATION_TAG}>
<${TASK_ID_TAG}>${taskId}</${TASK_ID_TAG}>${toolUseIdLine}
<${OUTPUT_FILE_TAG}>${outputPath}</${OUTPUT_FILE_TAG}>
<${STATUS_TAG}>${status}</${STATUS_TAG}>
<${SUMMARY_TAG}>${summary}</${SUMMARY_TAG}>${resultSection}${usageSection}${worktreeSection}
</${TASK_NOTIFICATION_TAG}>`;
  enqueuePendingNotification({
    value: message,
    mode: 'task-notification'
  });
}

/**
 * LocalAgentTask - Handles background agent execution.
 *
 * Replaces the AsyncAgent implementation from src/tools/AgentTool/asyncAgentUtils.ts
 * with a unified Task interface.
 */
export const LocalAgentTask: Task = {
  name: 'LocalAgentTask',
  type: 'local_agent',
  async kill(taskId, setAppState) {
    killAsyncAgent(taskId, setAppState);
  }
};

/**
 * Kill an agent task. No-op if already killed/completed.
 */
export function killAsyncAgent(taskId: string, setAppState: SetAppState): void {
  let killed = false;
  updateTaskState<LocalAgentTaskState>(taskId, setAppState, task => {
    if (task.status !== 'running') {
      return task;
    }
    killed = true;
    task.abortController?.abort();
    task.unregisterCleanup?.();
    return {
      ...task,
      status: 'killed',
      endTime: Date.now(),
      evictAfter: task.retain ? undefined : Date.now() + PANEL_GRACE_MS,
      abortController: undefined,
      unregisterCleanup: undefined,
      selectedAgent: undefined
    };
  });
  if (killed) {
    void evictTaskOutput(taskId);
  }
}

/**
 * Kill all running agent tasks.
 * Used by ESC cancellation in coordinator mode to stop all subagents.
 */
export function killAllRunningAgentTasks(tasks: Record<string, TaskState>, setAppState: SetAppState): void {
  for (const [taskId, task] of Object.entries(tasks)) {
    if (task.type === 'local_agent' && task.status === 'running') {
      killAsyncAgent(taskId, setAppState);
    }
  }
}

/**
 * Mark a task as notified without enqueueing a notification.
 * Used by chat:killAgents bulk kill to suppress per-agent async notifications
 * when a single aggregate message is sent instead.
 */
export function markAgentsNotified(taskId: string, setAppState: SetAppState): void {
  updateTaskState<LocalAgentTaskState>(taskId, setAppState, task => {
    if (task.notified) {
      return task;
    }
    return {
      ...task,
      notified: true
    };
  });
}

/**
 * Update progress for an agent task.
 * Preserves the existing summary field so that background summarization
 * results are not clobbered by progress updates from assistant messages.
 */
export function updateAgentProgress(taskId: string, progress: AgentProgress, setAppState: SetAppState): void {
  updateTaskState<LocalAgentTaskState>(taskId, setAppState, task => {
    if (task.status !== 'running') {
      return task;
    }
    const existingSummary = task.progress?.summary;
    return {
      ...task,
      progress: existingSummary ? {
        ...progress,
        summary: existingSummary
      } : progress
    };
  });
}

/**
 * Update the background summary for an agent task.
 * Called by the periodic summarization service to store a 1-2 sentence progress summary.
 */
export function updateAgentSummary(taskId: string, summary: string, setAppState: SetAppState): void {
  let captured: {
    tokenCount: number;
    toolUseCount: number;
    startTime: number;
    toolUseId: string | undefined;
  } | null = null;
  updateTaskState<LocalAgentTaskState>(taskId, setAppState, task => {
    if (task.status !== 'running') {
      return task;
    }
    captured = {
      tokenCount: task.progress?.tokenCount ?? 0,
      toolUseCount: task.progress?.toolUseCount ?? 0,
      startTime: task.startTime,
      toolUseId: task.toolUseId
    };
    return {
      ...task,
      progress: {
        ...task.progress,
        toolUseCount: task.progress?.toolUseCount ?? 0,
        tokenCount: task.progress?.tokenCount ?? 0,
        summary
      }
    };
  });

  // Emit summary to SDK consumers (e.g. VS Code subagent panel). No-op in TUI.
  // Gate on the SDK option so coordinator-mode sessions without the flag don't
  // leak summary events to consumers who didn't opt in.
  if (captured && getSdkAgentProgressSummariesEnabled()) {
    const {
      tokenCount,
      toolUseCount,
      startTime,
      toolUseId
    } = captured;
    emitTaskProgress({
      taskId,
      toolUseId,
      description: summary,
      startTime,
      totalTokens: tokenCount,
      toolUses: toolUseCount,
      summary
    });
  }
}

/**
 * Complete an agent task with result.
 */
export function completeAgentTask(result: AgentToolResult, setAppState: SetAppState): void {
  const taskId = result.agentId;
  updateTaskState<LocalAgentTaskState>(taskId, setAppState, task => {
    if (task.status !== 'running') {
      return task;
    }
    task.unregisterCleanup?.();
    return {
      ...task,
      status: 'completed',
      result,
      endTime: Date.now(),
      evictAfter: task.retain ? undefined : Date.now() + PANEL_GRACE_MS,
      abortController: undefined,
      unregisterCleanup: undefined,
      selectedAgent: undefined
    };
  });
  void evictTaskOutput(taskId);
  // Note: Notification is sent by AgentTool via enqueueAgentNotification
}

/**
 * Fail an agent task with error.
 */
export function failAgentTask(taskId: string, error: string, setAppState: SetAppState): void {
  updateTaskState<LocalAgentTaskState>(taskId, setAppState, task => {
    if (task.status !== 'running') {
      return task;
    }
    task.unregisterCleanup?.();
    return {
      ...task,
      status: 'failed',
      error,
      endTime: Date.now(),
      evictAfter: task.retain ? undefined : Date.now() + PANEL_GRACE_MS,
      abortController: undefined,
      unregisterCleanup: undefined,
      selectedAgent: undefined
    };
  });
  void evictTaskOutput(taskId);
  // Note: Notification is sent by AgentTool via enqueueAgentNotification
}

/**
 * Register an agent task.
 * Called by AgentTool to create a new background agent.
 *
 * @param parentAbortController - Optional parent abort controller. If provided,
 *   the agent's abort controller will be a child that auto-aborts when parent aborts.
 *   This ensures subagents are aborted when their parent (e.g., in-process teammate) aborts.
 */
export function registerAsyncAgent({
  agentId,
  description,
  prompt,
  selectedAgent,
  setAppState,
  parentAbortController,
  toolUseId
}: {
  agentId: string;
  description: string;
  prompt: string;
  selectedAgent: AgentDefinition;
  setAppState: SetAppState;
  parentAbortController?: AbortController;
  toolUseId?: string;
}): LocalAgentTaskState {
  void initTaskOutputAsSymlink(agentId, getAgentTranscriptPath(asAgentId(agentId)));

  // Create abort controller - if parent provided, create child that auto-aborts with parent
  const abortController = parentAbortController ? createChildAbortController(parentAbortController) : createAbortController();
  const taskState: LocalAgentTaskState = {
    ...createTaskStateBase(agentId, 'local_agent', description, toolUseId),
    type: 'local_agent',
    status: 'running',
    agentId,
    prompt,
    selectedAgent,
    agentType: selectedAgent.agentType ?? 'general-purpose',
    abortController,
    retrieved: false,
    lastReportedToolCount: 0,
    lastReportedTokenCount: 0,
    isBackgrounded: true,
    // registerAsyncAgent immediately backgrounds
    pendingMessages: [],
    retain: false,
    diskLoaded: false
  };

  // Register cleanup handler
  const unregisterCleanup = registerCleanup(async () => {
    killAsyncAgent(agentId, setAppState);
  });
  taskState.unregisterCleanup = unregisterCleanup;

  // Register task in AppState
  registerTask(taskState, setAppState);
  return taskState;
}

// Map of taskId -> resolve function for background signals
// When backgroundAgentTask is called, it resolves the corresponding promise
const backgroundSignalResolvers = new Map<string, () => void>();

/**
 * Register a foreground agent task that could be backgrounded later.
 * Called when an agent has been running long enough to show the BackgroundHint.
 * @returns object with taskId and backgroundSignal promise
 */
export function registerAgentForeground({
  agentId,
  description,
  prompt,
  selectedAgent,
  setAppState,
  autoBackgroundMs,
  toolUseId
}: {
  agentId: string;
  description: string;
  prompt: string;
  selectedAgent: AgentDefinition;
  setAppState: SetAppState;
  autoBackgroundMs?: number;
  toolUseId?: string;
}): {
  taskId: string;
  backgroundSignal: Promise<void>;
  cancelAutoBackground?: () => void;
} {
  void initTaskOutputAsSymlink(agentId, getAgentTranscriptPath(asAgentId(agentId)));
  const abortController = createAbortController();
  const unregisterCleanup = registerCleanup(async () => {
    killAsyncAgent(agentId, setAppState);
  });
  const taskState: LocalAgentTaskState = {
    ...createTaskStateBase(agentId, 'local_agent', description, toolUseId),
    type: 'local_agent',
    status: 'running',
    agentId,
    prompt,
    selectedAgent,
    agentType: selectedAgent.agentType ?? 'general-purpose',
    abortController,
    unregisterCleanup,
    retrieved: false,
    lastReportedToolCount: 0,
    lastReportedTokenCount: 0,
    isBackgrounded: false,
    // Not yet backgrounded - running in foreground
    pendingMessages: [],
    retain: false,
    diskLoaded: false
  };

  // Create background signal promise
  let resolveBackgroundSignal: () => void;
  const backgroundSignal = new Promise<void>(resolve => {
    resolveBackgroundSignal = resolve;
  });
  backgroundSignalResolvers.set(agentId, resolveBackgroundSignal!);
  registerTask(taskState, setAppState);

  // Auto-background after timeout if configured
  let cancelAutoBackground: (() => void) | undefined;
  if (autoBackgroundMs !== undefined && autoBackgroundMs > 0) {
    const timer = setTimeout((setAppState, agentId) => {
      // Mark task as backgrounded and resolve the signal
      setAppState(prev => {
        const prevTask = prev.tasks[agentId];
        if (!isLocalAgentTask(prevTask) || prevTask.isBackgrounded) {
          return prev;
        }
        return {
          ...prev,
          tasks: {
            ...prev.tasks,
            [agentId]: {
              ...prevTask,
              isBackgrounded: true
            }
          }
        };
      });
      const resolver = backgroundSignalResolvers.get(agentId);
      if (resolver) {
        resolver();
        backgroundSignalResolvers.delete(agentId);
      }
    }, autoBackgroundMs, setAppState, agentId);
    cancelAutoBackground = () => clearTimeout(timer);
  }
  return {
    taskId: agentId,
    backgroundSignal,
    cancelAutoBackground
  };
}

/**
 * Background a specific foreground agent task.
 * @returns true if backgrounded successfully, false otherwise
 */
export function backgroundAgentTask(taskId: string, getAppState: () => AppState, setAppState: SetAppState): boolean {
  const state = getAppState();
  const task = state.tasks[taskId];
  if (!isLocalAgentTask(task) || task.isBackgrounded) {
    return false;
  }

  // Update state to mark as backgrounded
  setAppState(prev => {
    const prevTask = prev.tasks[taskId];
    if (!isLocalAgentTask(prevTask)) {
      return prev;
    }
    return {
      ...prev,
      tasks: {
        ...prev.tasks,
        [taskId]: {
          ...prevTask,
          isBackgrounded: true
        }
      }
    };
  });

  // Resolve the background signal to interrupt the agent loop
  const resolver = backgroundSignalResolvers.get(taskId);
  if (resolver) {
    resolver();
    backgroundSignalResolvers.delete(taskId);
  }
  return true;
}

/**
 * Unregister a foreground agent task when the agent completes without being backgrounded.
 */
export function unregisterAgentForeground(taskId: string, setAppState: SetAppState): void {
  // Clean up the background signal resolver
  backgroundSignalResolvers.delete(taskId);
  let cleanupFn: (() => void) | undefined;
  setAppState(prev => {
    const task = prev.tasks[taskId];
    // Only remove if it's a foreground task (not backgrounded)
    if (!isLocalAgentTask(task) || task.isBackgrounded) {
      return prev;
    }

    // Capture cleanup function to call outside of updater
    cleanupFn = task.unregisterCleanup;
    const {
      [taskId]: removed,
      ...rest
    } = prev.tasks;
    return {
      ...prev,
      tasks: rest
    };
  });

  // Call cleanup outside of the state updater (avoid side effects in updater)
  cleanupFn?.();
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["getSdkAgentProgressSummariesEnabled","OUTPUT_FILE_TAG","STATUS_TAG","SUMMARY_TAG","TASK_ID_TAG","TASK_NOTIFICATION_TAG","TOOL_USE_ID_TAG","WORKTREE_BRANCH_TAG","WORKTREE_PATH_TAG","WORKTREE_TAG","abortSpeculation","AppState","SetAppState","Task","TaskStateBase","createTaskStateBase","Tools","findToolByName","AgentToolResult","AgentDefinition","SYNTHETIC_OUTPUT_TOOL_NAME","asAgentId","Message","createAbortController","createChildAbortController","registerCleanup","getToolSearchOrReadInfo","enqueuePendingNotification","getAgentTranscriptPath","evictTaskOutput","getTaskOutputPath","initTaskOutputAsSymlink","PANEL_GRACE_MS","registerTask","updateTaskState","emitTaskProgress","TaskState","ToolActivity","toolName","input","Record","activityDescription","isSearch","isRead","AgentProgress","toolUseCount","tokenCount","lastActivity","recentActivities","summary","MAX_RECENT_ACTIVITIES","ProgressTracker","latestInputTokens","cumulativeOutputTokens","createProgressTracker","getTokenCountFromTracker","tracker","ActivityDescriptionResolver","updateProgressFromMessage","message","resolveActivityDescription","tools","type","usage","input_tokens","cache_creation_input_tokens","cache_read_input_tokens","output_tokens","content","name","classification","undefined","push","length","shift","getProgressUpdate","createActivityDescriptionResolver","tool","getActivityDescription","LocalAgentTaskState","agentId","prompt","selectedAgent","agentType","model","abortController","AbortController","unregisterCleanup","error","result","progress","retrieved","messages","lastReportedToolCount","lastReportedTokenCount","isBackgrounded","pendingMessages","retain","diskLoaded","evictAfter","isLocalAgentTask","task","isPanelAgentTask","t","queuePendingMessage","taskId","msg","setAppState","f","prev","appendMessageToLocalAgent","drainPendingMessages","getAppState","tasks","drained","enqueueAgentNotification","description","status","finalMessage","toolUseId","worktreePath","worktreeBranch","totalTokens","toolUses","durationMs","shouldEnqueue","notified","outputPath","toolUseIdLine","resultSection","usageSection","worktreeSection","value","mode","LocalAgentTask","kill","killAsyncAgent","killed","abort","endTime","Date","now","killAllRunningAgentTasks","Object","entries","markAgentsNotified","updateAgentProgress","existingSummary","updateAgentSummary","captured","startTime","completeAgentTask","failAgentTask","registerAsyncAgent","parentAbortController","taskState","backgroundSignalResolvers","Map","registerAgentForeground","autoBackgroundMs","backgroundSignal","Promise","cancelAutoBackground","resolveBackgroundSignal","resolve","set","timer","setTimeout","prevTask","resolver","get","delete","clearTimeout","backgroundAgentTask","state","unregisterAgentForeground","cleanupFn","removed","rest"],"sources":["LocalAgentTask.tsx"],"sourcesContent":["import { getSdkAgentProgressSummariesEnabled } from '../../bootstrap/state.js'\nimport {\n  OUTPUT_FILE_TAG,\n  STATUS_TAG,\n  SUMMARY_TAG,\n  TASK_ID_TAG,\n  TASK_NOTIFICATION_TAG,\n  TOOL_USE_ID_TAG,\n  WORKTREE_BRANCH_TAG,\n  WORKTREE_PATH_TAG,\n  WORKTREE_TAG,\n} from '../../constants/xml.js'\nimport { abortSpeculation } from '../../services/PromptSuggestion/speculation.js'\nimport type { AppState } from '../../state/AppState.js'\nimport type { SetAppState, Task, TaskStateBase } from '../../Task.js'\nimport { createTaskStateBase } from '../../Task.js'\nimport type { Tools } from '../../Tool.js'\nimport { findToolByName } from '../../Tool.js'\nimport type { AgentToolResult } from '../../tools/AgentTool/agentToolUtils.js'\nimport type { AgentDefinition } from '../../tools/AgentTool/loadAgentsDir.js'\nimport { SYNTHETIC_OUTPUT_TOOL_NAME } from '../../tools/SyntheticOutputTool/SyntheticOutputTool.js'\nimport { asAgentId } from '../../types/ids.js'\nimport type { Message } from '../../types/message.js'\nimport {\n  createAbortController,\n  createChildAbortController,\n} from '../../utils/abortController.js'\nimport { registerCleanup } from '../../utils/cleanupRegistry.js'\nimport { getToolSearchOrReadInfo } from '../../utils/collapseReadSearch.js'\nimport { enqueuePendingNotification } from '../../utils/messageQueueManager.js'\nimport { getAgentTranscriptPath } from '../../utils/sessionStorage.js'\nimport {\n  evictTaskOutput,\n  getTaskOutputPath,\n  initTaskOutputAsSymlink,\n} from '../../utils/task/diskOutput.js'\nimport {\n  PANEL_GRACE_MS,\n  registerTask,\n  updateTaskState,\n} from '../../utils/task/framework.js'\nimport { emitTaskProgress } from '../../utils/task/sdkProgress.js'\nimport type { TaskState } from '../types.js'\n\nexport type ToolActivity = {\n  toolName: string\n  input: Record<string, unknown>\n  /** Pre-computed activity description from the tool, e.g. \"Reading src/foo.ts\" */\n  activityDescription?: string\n  /** Pre-computed: true if this is a search operation (Grep, Glob, etc.) */\n  isSearch?: boolean\n  /** Pre-computed: true if this is a read operation (Read, cat, etc.) */\n  isRead?: boolean\n}\n\nexport type AgentProgress = {\n  toolUseCount: number\n  tokenCount: number\n  lastActivity?: ToolActivity\n  recentActivities?: ToolActivity[]\n  summary?: string\n}\n\nconst MAX_RECENT_ACTIVITIES = 5\n\nexport type ProgressTracker = {\n  toolUseCount: number\n  // Track input and output separately to avoid double-counting.\n  // input_tokens in Claude API is cumulative per turn (includes all previous context),\n  // so we keep the latest value. output_tokens is per-turn, so we sum those.\n  latestInputTokens: number\n  cumulativeOutputTokens: number\n  recentActivities: ToolActivity[]\n}\n\nexport function createProgressTracker(): ProgressTracker {\n  return {\n    toolUseCount: 0,\n    latestInputTokens: 0,\n    cumulativeOutputTokens: 0,\n    recentActivities: [],\n  }\n}\n\nexport function getTokenCountFromTracker(tracker: ProgressTracker): number {\n  return tracker.latestInputTokens + tracker.cumulativeOutputTokens\n}\n\n/**\n * Resolver function that returns a human-readable activity description\n * for a given tool name and input. Used to pre-compute descriptions\n * from Tool.getActivityDescription() at recording time.\n */\nexport type ActivityDescriptionResolver = (\n  toolName: string,\n  input: Record<string, unknown>,\n) => string | undefined\n\nexport function updateProgressFromMessage(\n  tracker: ProgressTracker,\n  message: Message,\n  resolveActivityDescription?: ActivityDescriptionResolver,\n  tools?: Tools,\n): void {\n  if (message.type !== 'assistant') {\n    return\n  }\n  const usage = message.message.usage\n  // Keep latest input (it's cumulative in the API), sum outputs\n  tracker.latestInputTokens =\n    usage.input_tokens +\n    (usage.cache_creation_input_tokens ?? 0) +\n    (usage.cache_read_input_tokens ?? 0)\n  tracker.cumulativeOutputTokens += usage.output_tokens\n  for (const content of message.message.content) {\n    if (content.type === 'tool_use') {\n      tracker.toolUseCount++\n      // Omit StructuredOutput from preview - it's an internal tool\n      if (content.name !== SYNTHETIC_OUTPUT_TOOL_NAME) {\n        const input = content.input as Record<string, unknown>\n        const classification = tools\n          ? getToolSearchOrReadInfo(content.name, input, tools)\n          : undefined\n        tracker.recentActivities.push({\n          toolName: content.name,\n          input,\n          activityDescription: resolveActivityDescription?.(\n            content.name,\n            input,\n          ),\n          isSearch: classification?.isSearch,\n          isRead: classification?.isRead,\n        })\n      }\n    }\n  }\n  while (tracker.recentActivities.length > MAX_RECENT_ACTIVITIES) {\n    tracker.recentActivities.shift()\n  }\n}\n\nexport function getProgressUpdate(tracker: ProgressTracker): AgentProgress {\n  return {\n    toolUseCount: tracker.toolUseCount,\n    tokenCount: getTokenCountFromTracker(tracker),\n    lastActivity:\n      tracker.recentActivities.length > 0\n        ? tracker.recentActivities[tracker.recentActivities.length - 1]\n        : undefined,\n    recentActivities: [...tracker.recentActivities],\n  }\n}\n\n/**\n * Creates an ActivityDescriptionResolver from a tools list.\n * Looks up the tool by name and calls getActivityDescription if available.\n */\nexport function createActivityDescriptionResolver(\n  tools: Tools,\n): ActivityDescriptionResolver {\n  return (toolName, input) => {\n    const tool = findToolByName(tools, toolName)\n    return tool?.getActivityDescription?.(input) ?? undefined\n  }\n}\n\nexport type LocalAgentTaskState = TaskStateBase & {\n  type: 'local_agent'\n  agentId: string\n  prompt: string\n  selectedAgent?: AgentDefinition\n  agentType: string\n  model?: string\n  abortController?: AbortController\n  unregisterCleanup?: () => void\n  error?: string\n  result?: AgentToolResult\n  progress?: AgentProgress\n  retrieved: boolean\n  messages?: Message[]\n  // Track what we last reported for computing deltas\n  lastReportedToolCount: number\n  lastReportedTokenCount: number\n  // Whether the task has been backgrounded (false = foreground running, true = backgrounded)\n  isBackgrounded: boolean\n  // Messages queued mid-turn via SendMessage, drained at tool-round boundaries\n  pendingMessages: string[]\n  // UI is holding this task: blocks eviction, enables stream-append, triggers\n  // disk bootstrap. Set by enterTeammateView. Separate from viewingAgentTaskId\n  // (which is \"what am I LOOKING at\") — retain is \"what am I HOLDING.\"\n  retain: boolean\n  // Bootstrap has read the sidechain JSONL and UUID-merged into messages.\n  // One-shot per retain cycle; stream appends from there.\n  diskLoaded: boolean\n  // Panel visibility deadline. undefined = no deadline (running or retained);\n  // timestamp = hide + GC-eligible after this time. Set at terminal transition\n  // and on unselect; cleared on retain.\n  evictAfter?: number\n}\n\nexport function isLocalAgentTask(task: unknown): task is LocalAgentTaskState {\n  return (\n    typeof task === 'object' &&\n    task !== null &&\n    'type' in task &&\n    task.type === 'local_agent'\n  )\n}\n\n/**\n * A local_agent task that the CoordinatorTaskPanel manages (not main-session).\n * For ants, these render in the panel instead of the background-task pill.\n * This is the ONE predicate that all pill/panel filters must agree on — if\n * the gate changes, change it here.\n */\nexport function isPanelAgentTask(t: unknown): t is LocalAgentTaskState {\n  return isLocalAgentTask(t) && t.agentType !== 'main-session'\n}\n\nexport function queuePendingMessage(\n  taskId: string,\n  msg: string,\n  setAppState: (f: (prev: AppState) => AppState) => void,\n): void {\n  updateTaskState<LocalAgentTaskState>(taskId, setAppState, task => ({\n    ...task,\n    pendingMessages: [...task.pendingMessages, msg],\n  }))\n}\n\n/**\n * Append a message to task.messages so it appears in the viewed transcript\n * immediately. Caller constructs the Message (breaks the messages.ts cycle).\n * queuePendingMessage and resumeAgentBackground route the prompt to the\n * agent's API input but don't touch the display.\n */\nexport function appendMessageToLocalAgent(\n  taskId: string,\n  message: Message,\n  setAppState: (f: (prev: AppState) => AppState) => void,\n): void {\n  updateTaskState<LocalAgentTaskState>(taskId, setAppState, task => ({\n    ...task,\n    messages: [...(task.messages ?? []), message],\n  }))\n}\n\nexport function drainPendingMessages(\n  taskId: string,\n  getAppState: () => AppState,\n  setAppState: (f: (prev: AppState) => AppState) => void,\n): string[] {\n  const task = getAppState().tasks[taskId]\n  if (!isLocalAgentTask(task) || task.pendingMessages.length === 0) {\n    return []\n  }\n  const drained = task.pendingMessages\n  updateTaskState<LocalAgentTaskState>(taskId, setAppState, t => ({\n    ...t,\n    pendingMessages: [],\n  }))\n  return drained\n}\n\n/**\n * Enqueue an agent notification to the message queue.\n */\nexport function enqueueAgentNotification({\n  taskId,\n  description,\n  status,\n  error,\n  setAppState,\n  finalMessage,\n  usage,\n  toolUseId,\n  worktreePath,\n  worktreeBranch,\n}: {\n  taskId: string\n  description: string\n  status: 'completed' | 'failed' | 'killed'\n  error?: string\n  setAppState: SetAppState\n  finalMessage?: string\n  usage?: {\n    totalTokens: number\n    toolUses: number\n    durationMs: number\n  }\n  toolUseId?: string\n  worktreePath?: string\n  worktreeBranch?: string\n}): void {\n  // Atomically check and set notified flag to prevent duplicate notifications.\n  // If the task was already marked as notified (e.g., by TaskStopTool), skip\n  // enqueueing to avoid sending redundant messages to the model.\n  let shouldEnqueue = false\n  updateTaskState<LocalAgentTaskState>(taskId, setAppState, task => {\n    if (task.notified) {\n      return task\n    }\n    shouldEnqueue = true\n    return {\n      ...task,\n      notified: true,\n    }\n  })\n\n  if (!shouldEnqueue) {\n    return\n  }\n\n  // Abort any active speculation — background task state changed, so speculated\n  // results may reference stale task output. The prompt suggestion text is\n  // preserved; only the pre-computed response is discarded.\n  abortSpeculation(setAppState)\n\n  const summary =\n    status === 'completed'\n      ? `Agent \"${description}\" completed`\n      : status === 'failed'\n        ? `Agent \"${description}\" failed: ${error || 'Unknown error'}`\n        : `Agent \"${description}\" was stopped`\n\n  const outputPath = getTaskOutputPath(taskId)\n  const toolUseIdLine = toolUseId\n    ? `\\n<${TOOL_USE_ID_TAG}>${toolUseId}</${TOOL_USE_ID_TAG}>`\n    : ''\n  const resultSection = finalMessage ? `\\n<result>${finalMessage}</result>` : ''\n  const usageSection = usage\n    ? `\\n<usage><total_tokens>${usage.totalTokens}</total_tokens><tool_uses>${usage.toolUses}</tool_uses><duration_ms>${usage.durationMs}</duration_ms></usage>`\n    : ''\n  const worktreeSection = worktreePath\n    ? `\\n<${WORKTREE_TAG}><${WORKTREE_PATH_TAG}>${worktreePath}</${WORKTREE_PATH_TAG}>${worktreeBranch ? `<${WORKTREE_BRANCH_TAG}>${worktreeBranch}</${WORKTREE_BRANCH_TAG}>` : ''}</${WORKTREE_TAG}>`\n    : ''\n\n  const message = `<${TASK_NOTIFICATION_TAG}>\n<${TASK_ID_TAG}>${taskId}</${TASK_ID_TAG}>${toolUseIdLine}\n<${OUTPUT_FILE_TAG}>${outputPath}</${OUTPUT_FILE_TAG}>\n<${STATUS_TAG}>${status}</${STATUS_TAG}>\n<${SUMMARY_TAG}>${summary}</${SUMMARY_TAG}>${resultSection}${usageSection}${worktreeSection}\n</${TASK_NOTIFICATION_TAG}>`\n\n  enqueuePendingNotification({ value: message, mode: 'task-notification' })\n}\n\n/**\n * LocalAgentTask - Handles background agent execution.\n *\n * Replaces the AsyncAgent implementation from src/tools/AgentTool/asyncAgentUtils.ts\n * with a unified Task interface.\n */\nexport const LocalAgentTask: Task = {\n  name: 'LocalAgentTask',\n  type: 'local_agent',\n\n  async kill(taskId, setAppState) {\n    killAsyncAgent(taskId, setAppState)\n  },\n}\n\n/**\n * Kill an agent task. No-op if already killed/completed.\n */\nexport function killAsyncAgent(taskId: string, setAppState: SetAppState): void {\n  let killed = false\n  updateTaskState<LocalAgentTaskState>(taskId, setAppState, task => {\n    if (task.status !== 'running') {\n      return task\n    }\n    killed = true\n    task.abortController?.abort()\n    task.unregisterCleanup?.()\n    return {\n      ...task,\n      status: 'killed',\n      endTime: Date.now(),\n      evictAfter: task.retain ? undefined : Date.now() + PANEL_GRACE_MS,\n      abortController: undefined,\n      unregisterCleanup: undefined,\n      selectedAgent: undefined,\n    }\n  })\n  if (killed) {\n    void evictTaskOutput(taskId)\n  }\n}\n\n/**\n * Kill all running agent tasks.\n * Used by ESC cancellation in coordinator mode to stop all subagents.\n */\nexport function killAllRunningAgentTasks(\n  tasks: Record<string, TaskState>,\n  setAppState: SetAppState,\n): void {\n  for (const [taskId, task] of Object.entries(tasks)) {\n    if (task.type === 'local_agent' && task.status === 'running') {\n      killAsyncAgent(taskId, setAppState)\n    }\n  }\n}\n\n/**\n * Mark a task as notified without enqueueing a notification.\n * Used by chat:killAgents bulk kill to suppress per-agent async notifications\n * when a single aggregate message is sent instead.\n */\nexport function markAgentsNotified(\n  taskId: string,\n  setAppState: SetAppState,\n): void {\n  updateTaskState<LocalAgentTaskState>(taskId, setAppState, task => {\n    if (task.notified) {\n      return task\n    }\n    return {\n      ...task,\n      notified: true,\n    }\n  })\n}\n\n/**\n * Update progress for an agent task.\n * Preserves the existing summary field so that background summarization\n * results are not clobbered by progress updates from assistant messages.\n */\nexport function updateAgentProgress(\n  taskId: string,\n  progress: AgentProgress,\n  setAppState: SetAppState,\n): void {\n  updateTaskState<LocalAgentTaskState>(taskId, setAppState, task => {\n    if (task.status !== 'running') {\n      return task\n    }\n\n    const existingSummary = task.progress?.summary\n    return {\n      ...task,\n      progress: existingSummary\n        ? { ...progress, summary: existingSummary }\n        : progress,\n    }\n  })\n}\n\n/**\n * Update the background summary for an agent task.\n * Called by the periodic summarization service to store a 1-2 sentence progress summary.\n */\nexport function updateAgentSummary(\n  taskId: string,\n  summary: string,\n  setAppState: SetAppState,\n): void {\n  let captured: {\n    tokenCount: number\n    toolUseCount: number\n    startTime: number\n    toolUseId: string | undefined\n  } | null = null\n\n  updateTaskState<LocalAgentTaskState>(taskId, setAppState, task => {\n    if (task.status !== 'running') {\n      return task\n    }\n\n    captured = {\n      tokenCount: task.progress?.tokenCount ?? 0,\n      toolUseCount: task.progress?.toolUseCount ?? 0,\n      startTime: task.startTime,\n      toolUseId: task.toolUseId,\n    }\n\n    return {\n      ...task,\n      progress: {\n        ...task.progress,\n        toolUseCount: task.progress?.toolUseCount ?? 0,\n        tokenCount: task.progress?.tokenCount ?? 0,\n        summary,\n      },\n    }\n  })\n\n  // Emit summary to SDK consumers (e.g. VS Code subagent panel). No-op in TUI.\n  // Gate on the SDK option so coordinator-mode sessions without the flag don't\n  // leak summary events to consumers who didn't opt in.\n  if (captured && getSdkAgentProgressSummariesEnabled()) {\n    const { tokenCount, toolUseCount, startTime, toolUseId } = captured\n    emitTaskProgress({\n      taskId,\n      toolUseId,\n      description: summary,\n      startTime,\n      totalTokens: tokenCount,\n      toolUses: toolUseCount,\n      summary,\n    })\n  }\n}\n\n/**\n * Complete an agent task with result.\n */\nexport function completeAgentTask(\n  result: AgentToolResult,\n  setAppState: SetAppState,\n): void {\n  const taskId = result.agentId\n  updateTaskState<LocalAgentTaskState>(taskId, setAppState, task => {\n    if (task.status !== 'running') {\n      return task\n    }\n\n    task.unregisterCleanup?.()\n\n    return {\n      ...task,\n      status: 'completed',\n      result,\n      endTime: Date.now(),\n      evictAfter: task.retain ? undefined : Date.now() + PANEL_GRACE_MS,\n      abortController: undefined,\n      unregisterCleanup: undefined,\n      selectedAgent: undefined,\n    }\n  })\n  void evictTaskOutput(taskId)\n  // Note: Notification is sent by AgentTool via enqueueAgentNotification\n}\n\n/**\n * Fail an agent task with error.\n */\nexport function failAgentTask(\n  taskId: string,\n  error: string,\n  setAppState: SetAppState,\n): void {\n  updateTaskState<LocalAgentTaskState>(taskId, setAppState, task => {\n    if (task.status !== 'running') {\n      return task\n    }\n\n    task.unregisterCleanup?.()\n\n    return {\n      ...task,\n      status: 'failed',\n      error,\n      endTime: Date.now(),\n      evictAfter: task.retain ? undefined : Date.now() + PANEL_GRACE_MS,\n      abortController: undefined,\n      unregisterCleanup: undefined,\n      selectedAgent: undefined,\n    }\n  })\n  void evictTaskOutput(taskId)\n  // Note: Notification is sent by AgentTool via enqueueAgentNotification\n}\n\n/**\n * Register an agent task.\n * Called by AgentTool to create a new background agent.\n *\n * @param parentAbortController - Optional parent abort controller. If provided,\n *   the agent's abort controller will be a child that auto-aborts when parent aborts.\n *   This ensures subagents are aborted when their parent (e.g., in-process teammate) aborts.\n */\nexport function registerAsyncAgent({\n  agentId,\n  description,\n  prompt,\n  selectedAgent,\n  setAppState,\n  parentAbortController,\n  toolUseId,\n}: {\n  agentId: string\n  description: string\n  prompt: string\n  selectedAgent: AgentDefinition\n  setAppState: SetAppState\n  parentAbortController?: AbortController\n  toolUseId?: string\n}): LocalAgentTaskState {\n  void initTaskOutputAsSymlink(\n    agentId,\n    getAgentTranscriptPath(asAgentId(agentId)),\n  )\n\n  // Create abort controller - if parent provided, create child that auto-aborts with parent\n  const abortController = parentAbortController\n    ? createChildAbortController(parentAbortController)\n    : createAbortController()\n\n  const taskState: LocalAgentTaskState = {\n    ...createTaskStateBase(agentId, 'local_agent', description, toolUseId),\n    type: 'local_agent',\n    status: 'running',\n    agentId,\n    prompt,\n    selectedAgent,\n    agentType: selectedAgent.agentType ?? 'general-purpose',\n    abortController,\n    retrieved: false,\n    lastReportedToolCount: 0,\n    lastReportedTokenCount: 0,\n    isBackgrounded: true, // registerAsyncAgent immediately backgrounds\n    pendingMessages: [],\n    retain: false,\n    diskLoaded: false,\n  }\n\n  // Register cleanup handler\n  const unregisterCleanup = registerCleanup(async () => {\n    killAsyncAgent(agentId, setAppState)\n  })\n\n  taskState.unregisterCleanup = unregisterCleanup\n\n  // Register task in AppState\n  registerTask(taskState, setAppState)\n\n  return taskState\n}\n\n// Map of taskId -> resolve function for background signals\n// When backgroundAgentTask is called, it resolves the corresponding promise\nconst backgroundSignalResolvers = new Map<string, () => void>()\n\n/**\n * Register a foreground agent task that could be backgrounded later.\n * Called when an agent has been running long enough to show the BackgroundHint.\n * @returns object with taskId and backgroundSignal promise\n */\nexport function registerAgentForeground({\n  agentId,\n  description,\n  prompt,\n  selectedAgent,\n  setAppState,\n  autoBackgroundMs,\n  toolUseId,\n}: {\n  agentId: string\n  description: string\n  prompt: string\n  selectedAgent: AgentDefinition\n  setAppState: SetAppState\n  autoBackgroundMs?: number\n  toolUseId?: string\n}): {\n  taskId: string\n  backgroundSignal: Promise<void>\n  cancelAutoBackground?: () => void\n} {\n  void initTaskOutputAsSymlink(\n    agentId,\n    getAgentTranscriptPath(asAgentId(agentId)),\n  )\n\n  const abortController = createAbortController()\n\n  const unregisterCleanup = registerCleanup(async () => {\n    killAsyncAgent(agentId, setAppState)\n  })\n\n  const taskState: LocalAgentTaskState = {\n    ...createTaskStateBase(agentId, 'local_agent', description, toolUseId),\n    type: 'local_agent',\n    status: 'running',\n    agentId,\n    prompt,\n    selectedAgent,\n    agentType: selectedAgent.agentType ?? 'general-purpose',\n    abortController,\n    unregisterCleanup,\n    retrieved: false,\n    lastReportedToolCount: 0,\n    lastReportedTokenCount: 0,\n    isBackgrounded: false, // Not yet backgrounded - running in foreground\n    pendingMessages: [],\n    retain: false,\n    diskLoaded: false,\n  }\n\n  // Create background signal promise\n  let resolveBackgroundSignal: () => void\n  const backgroundSignal = new Promise<void>(resolve => {\n    resolveBackgroundSignal = resolve\n  })\n  backgroundSignalResolvers.set(agentId, resolveBackgroundSignal!)\n\n  registerTask(taskState, setAppState)\n\n  // Auto-background after timeout if configured\n  let cancelAutoBackground: (() => void) | undefined\n  if (autoBackgroundMs !== undefined && autoBackgroundMs > 0) {\n    const timer = setTimeout(\n      (setAppState, agentId) => {\n        // Mark task as backgrounded and resolve the signal\n        setAppState(prev => {\n          const prevTask = prev.tasks[agentId]\n          if (!isLocalAgentTask(prevTask) || prevTask.isBackgrounded) {\n            return prev\n          }\n          return {\n            ...prev,\n            tasks: {\n              ...prev.tasks,\n              [agentId]: { ...prevTask, isBackgrounded: true },\n            },\n          }\n        })\n        const resolver = backgroundSignalResolvers.get(agentId)\n        if (resolver) {\n          resolver()\n          backgroundSignalResolvers.delete(agentId)\n        }\n      },\n      autoBackgroundMs,\n      setAppState,\n      agentId,\n    )\n    cancelAutoBackground = () => clearTimeout(timer)\n  }\n\n  return { taskId: agentId, backgroundSignal, cancelAutoBackground }\n}\n\n/**\n * Background a specific foreground agent task.\n * @returns true if backgrounded successfully, false otherwise\n */\nexport function backgroundAgentTask(\n  taskId: string,\n  getAppState: () => AppState,\n  setAppState: SetAppState,\n): boolean {\n  const state = getAppState()\n  const task = state.tasks[taskId]\n  if (!isLocalAgentTask(task) || task.isBackgrounded) {\n    return false\n  }\n\n  // Update state to mark as backgrounded\n  setAppState(prev => {\n    const prevTask = prev.tasks[taskId]\n    if (!isLocalAgentTask(prevTask)) {\n      return prev\n    }\n    return {\n      ...prev,\n      tasks: {\n        ...prev.tasks,\n        [taskId]: { ...prevTask, isBackgrounded: true },\n      },\n    }\n  })\n\n  // Resolve the background signal to interrupt the agent loop\n  const resolver = backgroundSignalResolvers.get(taskId)\n  if (resolver) {\n    resolver()\n    backgroundSignalResolvers.delete(taskId)\n  }\n\n  return true\n}\n\n/**\n * Unregister a foreground agent task when the agent completes without being backgrounded.\n */\nexport function unregisterAgentForeground(\n  taskId: string,\n  setAppState: SetAppState,\n): void {\n  // Clean up the background signal resolver\n  backgroundSignalResolvers.delete(taskId)\n\n  let cleanupFn: (() => void) | undefined\n\n  setAppState(prev => {\n    const task = prev.tasks[taskId]\n    // Only remove if it's a foreground task (not backgrounded)\n    if (!isLocalAgentTask(task) || task.isBackgrounded) {\n      return prev\n    }\n\n    // Capture cleanup function to call outside of updater\n    cleanupFn = task.unregisterCleanup\n\n    const { [taskId]: removed, ...rest } = prev.tasks\n    return { ...prev, tasks: rest }\n  })\n\n  // Call cleanup outside of the state updater (avoid side effects in updater)\n  cleanupFn?.()\n}\n"],"mappings":"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","ignoreList":[]}