Something went wrong. Try again.
source dump of claude code
Something went wrong. Try again.
83 kB · 683 lines
TSX
at main
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683import { 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 promiseconst 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":[]}