@xelauvas/xela-cli 0.1.0

package/src/tasks/LocalAgentTask/LocalAgentTask.tsx

@@ -0,0 +1,683 @@
+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":[]}