Something went wrong. Try again.
source dump of claude code forked from oppi.li/claude-code
Something went wrong. Try again.
66 kB · 523 lines
TSX
at main
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523import { feature } from 'bun:bundle';import { stat } from 'fs/promises';import { OUTPUT_FILE_TAG, STATUS_TAG, SUMMARY_TAG, TASK_ID_TAG, TASK_NOTIFICATION_TAG, TOOL_USE_ID_TAG } from '../../constants/xml.js';import { abortSpeculation } from '../../services/PromptSuggestion/speculation.js';import type { AppState } from '../../state/AppState.js';import type { LocalShellSpawnInput, SetAppState, Task, TaskContext, TaskHandle } from '../../Task.js';import { createTaskStateBase } from '../../Task.js';import type { AgentId } from '../../types/ids.js';import { registerCleanup } from '../../utils/cleanupRegistry.js';import { tailFile } from '../../utils/fsOperations.js';import { logError } from '../../utils/log.js';import { enqueuePendingNotification } from '../../utils/messageQueueManager.js';import type { ShellCommand } from '../../utils/ShellCommand.js';import { evictTaskOutput, getTaskOutputPath } from '../../utils/task/diskOutput.js';import { registerTask, updateTaskState } from '../../utils/task/framework.js';import { escapeXml } from '../../utils/xml.js';import { backgroundAgentTask, isLocalAgentTask } from '../LocalAgentTask/LocalAgentTask.js';import { isMainSessionTask } from '../LocalMainSessionTask.js';import { type BashTaskKind, isLocalShellTask, type LocalShellTaskState } from './guards.js';import { killTask } from './killShellTasks.js';
/** Prefix that identifies a LocalShellTask summary to the UI collapse transform. */export const BACKGROUND_BASH_SUMMARY_PREFIX = 'Background command ';const STALL_CHECK_INTERVAL_MS = 5_000;const STALL_THRESHOLD_MS = 45_000;const STALL_TAIL_BYTES = 1024;
// Last-line patterns that suggest a command is blocked waiting for keyboard// input. Used to gate the stall notification — we stay silent on commands that// are merely slow (git log -S, long builds) and only notify when the tail// looks like an interactive prompt the model can act on. See CC-1175.const PROMPT_PATTERNS = [/\(y\/n\)/i,// (Y/n), (y/N)/\[y\/n\]/i,// [Y/n], [y/N]/\(yes\/no\)/i, /\b(?:Do you|Would you|Shall I|Are you sure|Ready to)\b.*\? *$/i,// directed questions/Press (any key|Enter)/i, /Continue\?/i, /Overwrite\?/i];export function looksLikePrompt(tail: string): boolean { const lastLine = tail.trimEnd().split('\n').pop() ?? ''; return PROMPT_PATTERNS.some(p => p.test(lastLine));}
// Output-side analog of peekForStdinData (utils/process.ts): fire a one-shot// notification if output stops growing and the tail looks like a prompt.function startStallWatchdog(taskId: string, description: string, kind: BashTaskKind | undefined, toolUseId?: string, agentId?: AgentId): () => void { if (kind === 'monitor') return () => {}; const outputPath = getTaskOutputPath(taskId); let lastSize = 0; let lastGrowth = Date.now(); let cancelled = false; const timer = setInterval(() => { void stat(outputPath).then(s => { if (s.size > lastSize) { lastSize = s.size; lastGrowth = Date.now(); return; } if (Date.now() - lastGrowth < STALL_THRESHOLD_MS) return; void tailFile(outputPath, STALL_TAIL_BYTES).then(({ content }) => { if (cancelled) return; if (!looksLikePrompt(content)) { // Not a prompt — keep watching. Reset so the next check is // 45s out instead of re-reading the tail on every tick. lastGrowth = Date.now(); return; } // Latch before the async-boundary-visible side effects so an // overlapping tick's callback sees cancelled=true and bails. cancelled = true; clearInterval(timer); const toolUseIdLine = toolUseId ? `\n<${TOOL_USE_ID_TAG}>${toolUseId}</${TOOL_USE_ID_TAG}>` : ''; const summary = `${BACKGROUND_BASH_SUMMARY_PREFIX}"${description}" appears to be waiting for interactive input`; // No <status> tag — print.ts treats <status> as a terminal // signal and an unknown value falls through to 'completed', // falsely closing the task for SDK consumers. Statusless // notifications are skipped by the SDK emitter (progress ping). const message = `<${TASK_NOTIFICATION_TAG}><${TASK_ID_TAG}>${taskId}</${TASK_ID_TAG}>${toolUseIdLine}<${OUTPUT_FILE_TAG}>${outputPath}</${OUTPUT_FILE_TAG}><${SUMMARY_TAG}>${escapeXml(summary)}</${SUMMARY_TAG}></${TASK_NOTIFICATION_TAG}>Last output:${content.trimEnd()}
The command is likely blocked on an interactive prompt. Kill this task and re-run with piped input (e.g., \`echo y | command\`) or a non-interactive flag if one exists.`; enqueuePendingNotification({ value: message, mode: 'task-notification', priority: 'next', agentId }); }, () => {}); }, () => {} // File may not exist yet ); }, STALL_CHECK_INTERVAL_MS); timer.unref(); return () => { cancelled = true; clearInterval(timer); };}function enqueueShellNotification(taskId: string, description: string, status: 'completed' | 'failed' | 'killed', exitCode: number | undefined, setAppState: SetAppState, toolUseId?: string, kind: BashTaskKind = 'bash', agentId?: AgentId): 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(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); let summary: string; if (feature('MONITOR_TOOL') && kind === 'monitor') { // Monitor is streaming-only (post-#22764) — the script exiting means // the stream ended, not "condition met". Distinct from the bash prefix // so Monitor completions don't fold into the "N background commands // completed" collapse. switch (status) { case 'completed': summary = `Monitor "${description}" stream ended`; break; case 'failed': summary = `Monitor "${description}" script failed${exitCode !== undefined ? ` (exit ${exitCode})` : ''}`; break; case 'killed': summary = `Monitor "${description}" stopped`; break; } } else { switch (status) { case 'completed': summary = `${BACKGROUND_BASH_SUMMARY_PREFIX}"${description}" completed${exitCode !== undefined ? ` (exit code ${exitCode})` : ''}`; break; case 'failed': summary = `${BACKGROUND_BASH_SUMMARY_PREFIX}"${description}" failed${exitCode !== undefined ? ` with exit code ${exitCode}` : ''}`; break; case 'killed': summary = `${BACKGROUND_BASH_SUMMARY_PREFIX}"${description}" was stopped`; break; } } const outputPath = getTaskOutputPath(taskId); const toolUseIdLine = toolUseId ? `\n<${TOOL_USE_ID_TAG}>${toolUseId}</${TOOL_USE_ID_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}>${escapeXml(summary)}</${SUMMARY_TAG}></${TASK_NOTIFICATION_TAG}>`; enqueuePendingNotification({ value: message, mode: 'task-notification', priority: feature('MONITOR_TOOL') ? 'next' : 'later', agentId });}export const LocalShellTask: Task = { name: 'LocalShellTask', type: 'local_bash', async kill(taskId, setAppState) { killTask(taskId, setAppState); }};export async function spawnShellTask(input: LocalShellSpawnInput & { shellCommand: ShellCommand;}, context: TaskContext): Promise<TaskHandle> { const { command, description, shellCommand, toolUseId, agentId, kind } = input; const { setAppState } = context;
// TaskOutput owns the data — use its taskId so disk writes are consistent const { taskOutput } = shellCommand; const taskId = taskOutput.taskId; const unregisterCleanup = registerCleanup(async () => { killTask(taskId, setAppState); }); const taskState: LocalShellTaskState = { ...createTaskStateBase(taskId, 'local_bash', description, toolUseId), type: 'local_bash', status: 'running', command, completionStatusSentInAttachment: false, shellCommand, unregisterCleanup, lastReportedTotalLines: 0, isBackgrounded: true, agentId, kind }; registerTask(taskState, setAppState);
// Data flows through TaskOutput automatically — no stream listeners needed. // Just transition to backgrounded state so the process keeps running. shellCommand.background(taskId); const cancelStallWatchdog = startStallWatchdog(taskId, description, kind, toolUseId, agentId); void shellCommand.result.then(async result => { cancelStallWatchdog(); await flushAndCleanup(shellCommand); let wasKilled = false; updateTaskState<LocalShellTaskState>(taskId, setAppState, task => { if (task.status === 'killed') { wasKilled = true; return task; } return { ...task, status: result.code === 0 ? 'completed' : 'failed', result: { code: result.code, interrupted: result.interrupted }, shellCommand: null, unregisterCleanup: undefined, endTime: Date.now() }; }); enqueueShellNotification(taskId, description, wasKilled ? 'killed' : result.code === 0 ? 'completed' : 'failed', result.code, setAppState, toolUseId, kind, agentId); void evictTaskOutput(taskId); }); return { taskId, cleanup: () => { unregisterCleanup(); } };}
/** * Register a foreground task that could be backgrounded later. * Called when a bash command has been running long enough to show the BackgroundHint. * @returns taskId for the registered task */export function registerForeground(input: LocalShellSpawnInput & { shellCommand: ShellCommand;}, setAppState: SetAppState, toolUseId?: string): string { const { command, description, shellCommand, agentId } = input; const taskId = shellCommand.taskOutput.taskId; const unregisterCleanup = registerCleanup(async () => { killTask(taskId, setAppState); }); const taskState: LocalShellTaskState = { ...createTaskStateBase(taskId, 'local_bash', description, toolUseId), type: 'local_bash', status: 'running', command, completionStatusSentInAttachment: false, shellCommand, unregisterCleanup, lastReportedTotalLines: 0, isBackgrounded: false, // Not yet backgrounded - running in foreground agentId }; registerTask(taskState, setAppState); return taskId;}
/** * Background a specific foreground task. * @returns true if backgrounded successfully, false otherwise */function backgroundTask(taskId: string, getAppState: () => AppState, setAppState: SetAppState): boolean { // Step 1: Get the task and shell command from current state const state = getAppState(); const task = state.tasks[taskId]; if (!isLocalShellTask(task) || task.isBackgrounded || !task.shellCommand) { return false; } const shellCommand = task.shellCommand; const description = task.description; const { toolUseId, kind, agentId } = task;
// Transition to backgrounded — TaskOutput continues receiving data automatically if (!shellCommand.background(taskId)) { return false; } setAppState(prev => { const prevTask = prev.tasks[taskId]; if (!isLocalShellTask(prevTask) || prevTask.isBackgrounded) { return prev; } return { ...prev, tasks: { ...prev.tasks, [taskId]: { ...prevTask, isBackgrounded: true } } }; }); const cancelStallWatchdog = startStallWatchdog(taskId, description, kind, toolUseId, agentId);
// Set up result handler void shellCommand.result.then(async result => { cancelStallWatchdog(); await flushAndCleanup(shellCommand); let wasKilled = false; let cleanupFn: (() => void) | undefined; updateTaskState<LocalShellTaskState>(taskId, setAppState, t => { if (t.status === 'killed') { wasKilled = true; return t; }
// Capture cleanup function to call outside of updater cleanupFn = t.unregisterCleanup; return { ...t, status: result.code === 0 ? 'completed' : 'failed', result: { code: result.code, interrupted: result.interrupted }, shellCommand: null, unregisterCleanup: undefined, endTime: Date.now() }; });
// Call cleanup outside of the state updater (avoid side effects in updater) cleanupFn?.(); if (wasKilled) { enqueueShellNotification(taskId, description, 'killed', result.code, setAppState, toolUseId, kind, agentId); } else { const finalStatus = result.code === 0 ? 'completed' : 'failed'; enqueueShellNotification(taskId, description, finalStatus, result.code, setAppState, toolUseId, kind, agentId); } void evictTaskOutput(taskId); }); return true;}
/** * Background ALL foreground tasks (bash commands and agents). * Called when user presses Ctrl+B to background all running tasks. *//** * Check if there are any foreground tasks (bash or agent) that can be backgrounded. * Used to determine whether Ctrl+B should background existing tasks vs. background the session. */export function hasForegroundTasks(state: AppState): boolean { return Object.values(state.tasks).some(task => { if (isLocalShellTask(task) && !task.isBackgrounded && task.shellCommand) { return true; } // Exclude main session tasks - they display in the main view, not as foreground tasks if (isLocalAgentTask(task) && !task.isBackgrounded && !isMainSessionTask(task)) { return true; } return false; });}export function backgroundAll(getAppState: () => AppState, setAppState: SetAppState): void { const state = getAppState();
// Background all foreground bash tasks const foregroundBashTaskIds = Object.keys(state.tasks).filter(id => { const task = state.tasks[id]; return isLocalShellTask(task) && !task.isBackgrounded && task.shellCommand; }); for (const taskId of foregroundBashTaskIds) { backgroundTask(taskId, getAppState, setAppState); }
// Background all foreground agent tasks const foregroundAgentTaskIds = Object.keys(state.tasks).filter(id => { const task = state.tasks[id]; return isLocalAgentTask(task) && !task.isBackgrounded; }); for (const taskId of foregroundAgentTaskIds) { backgroundAgentTask(taskId, getAppState, setAppState); }}
/** * Background an already-registered foreground task in-place. * Unlike spawn(), this does NOT re-register the task — it flips isBackgrounded * on the existing registration and sets up a completion handler. * Used when the auto-background timer fires after registerForeground() has * already registered the task (avoiding duplicate task_started SDK events * and leaked cleanup callbacks). */export function backgroundExistingForegroundTask(taskId: string, shellCommand: ShellCommand, description: string, setAppState: SetAppState, toolUseId?: string): boolean { if (!shellCommand.background(taskId)) { return false; } let agentId: AgentId | undefined; setAppState(prev => { const prevTask = prev.tasks[taskId]; if (!isLocalShellTask(prevTask) || prevTask.isBackgrounded) { return prev; } agentId = prevTask.agentId; return { ...prev, tasks: { ...prev.tasks, [taskId]: { ...prevTask, isBackgrounded: true } } }; }); const cancelStallWatchdog = startStallWatchdog(taskId, description, undefined, toolUseId, agentId);
// Set up result handler (mirrors backgroundTask's handler) void shellCommand.result.then(async result => { cancelStallWatchdog(); await flushAndCleanup(shellCommand); let wasKilled = false; let cleanupFn: (() => void) | undefined; updateTaskState<LocalShellTaskState>(taskId, setAppState, t => { if (t.status === 'killed') { wasKilled = true; return t; } cleanupFn = t.unregisterCleanup; return { ...t, status: result.code === 0 ? 'completed' : 'failed', result: { code: result.code, interrupted: result.interrupted }, shellCommand: null, unregisterCleanup: undefined, endTime: Date.now() }; }); cleanupFn?.(); const finalStatus = wasKilled ? 'killed' : result.code === 0 ? 'completed' : 'failed'; enqueueShellNotification(taskId, description, finalStatus, result.code, setAppState, toolUseId, undefined, agentId); void evictTaskOutput(taskId); }); return true;}
/** * Mark a task as notified to suppress a pending enqueueShellNotification. * Used when backgrounding raced with completion — the tool result already * carries the full output, so the <task_notification> would be redundant. */export function markTaskNotified(taskId: string, setAppState: SetAppState): void { updateTaskState(taskId, setAppState, t => t.notified ? t : { ...t, notified: true });}
/** * Unregister a foreground task when the command completes without being backgrounded. */export function unregisterForeground(taskId: string, setAppState: SetAppState): void { let cleanupFn: (() => void) | undefined; setAppState(prev => { const task = prev.tasks[taskId]; // Only remove if it's a foreground task (not backgrounded) if (!isLocalShellTask(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?.();}async function flushAndCleanup(shellCommand: ShellCommand): Promise<void> { try { await shellCommand.taskOutput.flush(); shellCommand.cleanup(); } catch (error) { logError(error); }}//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["feature","stat","OUTPUT_FILE_TAG","STATUS_TAG","SUMMARY_TAG","TASK_ID_TAG","TASK_NOTIFICATION_TAG","TOOL_USE_ID_TAG","abortSpeculation","AppState","LocalShellSpawnInput","SetAppState","Task","TaskContext","TaskHandle","createTaskStateBase","AgentId","registerCleanup","tailFile","logError","enqueuePendingNotification","ShellCommand","evictTaskOutput","getTaskOutputPath","registerTask","updateTaskState","escapeXml","backgroundAgentTask","isLocalAgentTask","isMainSessionTask","BashTaskKind","isLocalShellTask","LocalShellTaskState","killTask","BACKGROUND_BASH_SUMMARY_PREFIX","STALL_CHECK_INTERVAL_MS","STALL_THRESHOLD_MS","STALL_TAIL_BYTES","PROMPT_PATTERNS","looksLikePrompt","tail","lastLine","trimEnd","split","pop","some","p","test","startStallWatchdog","taskId","description","kind","toolUseId","agentId","outputPath","lastSize","lastGrowth","Date","now","cancelled","timer","setInterval","then","s","size","content","clearInterval","toolUseIdLine","summary","message","value","mode","priority","unref","enqueueShellNotification","status","exitCode","setAppState","shouldEnqueue","task","notified","undefined","LocalShellTask","name","type","kill","spawnShellTask","input","shellCommand","context","Promise","command","taskOutput","unregisterCleanup","taskState","completionStatusSentInAttachment","lastReportedTotalLines","isBackgrounded","background","cancelStallWatchdog","result","flushAndCleanup","wasKilled","code","interrupted","endTime","cleanup","registerForeground","backgroundTask","getAppState","state","tasks","prev","prevTask","cleanupFn","t","finalStatus","hasForegroundTasks","Object","values","backgroundAll","foregroundBashTaskIds","keys","filter","id","foregroundAgentTaskIds","backgroundExistingForegroundTask","markTaskNotified","unregisterForeground","removed","rest","flush","error"],"sources":["LocalShellTask.tsx"],"sourcesContent":["import { feature } from 'bun:bundle'\nimport { stat } from 'fs/promises'\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} from '../../constants/xml.js'\nimport { abortSpeculation } from '../../services/PromptSuggestion/speculation.js'\nimport type { AppState } from '../../state/AppState.js'\nimport type {\n  LocalShellSpawnInput,\n  SetAppState,\n  Task,\n  TaskContext,\n  TaskHandle,\n} from '../../Task.js'\nimport { createTaskStateBase } from '../../Task.js'\nimport type { AgentId } from '../../types/ids.js'\nimport { registerCleanup } from '../../utils/cleanupRegistry.js'\nimport { tailFile } from '../../utils/fsOperations.js'\nimport { logError } from '../../utils/log.js'\nimport { enqueuePendingNotification } from '../../utils/messageQueueManager.js'\nimport type { ShellCommand } from '../../utils/ShellCommand.js'\nimport {\n  evictTaskOutput,\n  getTaskOutputPath,\n} from '../../utils/task/diskOutput.js'\nimport { registerTask, updateTaskState } from '../../utils/task/framework.js'\nimport { escapeXml } from '../../utils/xml.js'\nimport {\n  backgroundAgentTask,\n  isLocalAgentTask,\n} from '../LocalAgentTask/LocalAgentTask.js'\nimport { isMainSessionTask } from '../LocalMainSessionTask.js'\nimport {\n  type BashTaskKind,\n  isLocalShellTask,\n  type LocalShellTaskState,\n} from './guards.js'\nimport { killTask } from './killShellTasks.js'\n\n/** Prefix that identifies a LocalShellTask summary to the UI collapse transform. */\nexport const BACKGROUND_BASH_SUMMARY_PREFIX = 'Background command '\n\nconst STALL_CHECK_INTERVAL_MS = 5_000\nconst STALL_THRESHOLD_MS = 45_000\nconst STALL_TAIL_BYTES = 1024\n\n// Last-line patterns that suggest a command is blocked waiting for keyboard\n// input. Used to gate the stall notification — we stay silent on commands that\n// are merely slow (git log -S, long builds) and only notify when the tail\n// looks like an interactive prompt the model can act on. See CC-1175.\nconst PROMPT_PATTERNS = [\n  /\\(y\\/n\\)/i, // (Y/n), (y/N)\n  /\\[y\\/n\\]/i, // [Y/n], [y/N]\n  /\\(yes\\/no\\)/i,\n  /\\b(?:Do you|Would you|Shall I|Are you sure|Ready to)\\b.*\\? *$/i, // directed questions\n  /Press (any key|Enter)/i,\n  /Continue\\?/i,\n  /Overwrite\\?/i,\n]\n\nexport function looksLikePrompt(tail: string): boolean {\n  const lastLine = tail.trimEnd().split('\\n').pop() ?? ''\n  return PROMPT_PATTERNS.some(p => p.test(lastLine))\n}\n\n// Output-side analog of peekForStdinData (utils/process.ts): fire a one-shot\n// notification if output stops growing and the tail looks like a prompt.\nfunction startStallWatchdog(\n  taskId: string,\n  description: string,\n  kind: BashTaskKind | undefined,\n  toolUseId?: string,\n  agentId?: AgentId,\n): () => void {\n  if (kind === 'monitor') return () => {}\n  const outputPath = getTaskOutputPath(taskId)\n  let lastSize = 0\n  let lastGrowth = Date.now()\n  let cancelled = false\n\n  const timer = setInterval(() => {\n    void stat(outputPath).then(\n      s => {\n        if (s.size > lastSize) {\n          lastSize = s.size\n          lastGrowth = Date.now()\n          return\n        }\n        if (Date.now() - lastGrowth < STALL_THRESHOLD_MS) return\n        void tailFile(outputPath, STALL_TAIL_BYTES).then(\n          ({ content }) => {\n            if (cancelled) return\n            if (!looksLikePrompt(content)) {\n              // Not a prompt — keep watching. Reset so the next check is\n              // 45s out instead of re-reading the tail on every tick.\n              lastGrowth = Date.now()\n              return\n            }\n            // Latch before the async-boundary-visible side effects so an\n            // overlapping tick's callback sees cancelled=true and bails.\n            cancelled = true\n            clearInterval(timer)\n            const toolUseIdLine = toolUseId\n              ? `\\n<${TOOL_USE_ID_TAG}>${toolUseId}</${TOOL_USE_ID_TAG}>`\n              : ''\n            const summary = `${BACKGROUND_BASH_SUMMARY_PREFIX}\"${description}\" appears to be waiting for interactive input`\n            // No <status> tag — print.ts treats <status> as a terminal\n            // signal and an unknown value falls through to 'completed',\n            // falsely closing the task for SDK consumers. Statusless\n            // notifications are skipped by the SDK emitter (progress ping).\n            const message = `<${TASK_NOTIFICATION_TAG}>\n<${TASK_ID_TAG}>${taskId}</${TASK_ID_TAG}>${toolUseIdLine}\n<${OUTPUT_FILE_TAG}>${outputPath}</${OUTPUT_FILE_TAG}>\n<${SUMMARY_TAG}>${escapeXml(summary)}</${SUMMARY_TAG}>\n</${TASK_NOTIFICATION_TAG}>\nLast output:\n${content.trimEnd()}\n\nThe command is likely blocked on an interactive prompt. Kill this task and re-run with piped input (e.g., \\`echo y | command\\`) or a non-interactive flag if one exists.`\n            enqueuePendingNotification({\n              value: message,\n              mode: 'task-notification',\n              priority: 'next',\n              agentId,\n            })\n          },\n          () => {},\n        )\n      },\n      () => {}, // File may not exist yet\n    )\n  }, STALL_CHECK_INTERVAL_MS)\n  timer.unref()\n\n  return () => {\n    cancelled = true\n    clearInterval(timer)\n  }\n}\n\nfunction enqueueShellNotification(\n  taskId: string,\n  description: string,\n  status: 'completed' | 'failed' | 'killed',\n  exitCode: number | undefined,\n  setAppState: SetAppState,\n  toolUseId?: string,\n  kind: BashTaskKind = 'bash',\n  agentId?: AgentId,\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(taskId, setAppState, task => {\n    if (task.notified) {\n      return task\n    }\n    shouldEnqueue = true\n    return { ...task, notified: true }\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  let summary: string\n  if (feature('MONITOR_TOOL') && kind === 'monitor') {\n    // Monitor is streaming-only (post-#22764) — the script exiting means\n    // the stream ended, not \"condition met\". Distinct from the bash prefix\n    // so Monitor completions don't fold into the \"N background commands\n    // completed\" collapse.\n    switch (status) {\n      case 'completed':\n        summary = `Monitor \"${description}\" stream ended`\n        break\n      case 'failed':\n        summary = `Monitor \"${description}\" script failed${exitCode !== undefined ? ` (exit ${exitCode})` : ''}`\n        break\n      case 'killed':\n        summary = `Monitor \"${description}\" stopped`\n        break\n    }\n  } else {\n    switch (status) {\n      case 'completed':\n        summary = `${BACKGROUND_BASH_SUMMARY_PREFIX}\"${description}\" completed${exitCode !== undefined ? ` (exit code ${exitCode})` : ''}`\n        break\n      case 'failed':\n        summary = `${BACKGROUND_BASH_SUMMARY_PREFIX}\"${description}\" failed${exitCode !== undefined ? ` with exit code ${exitCode}` : ''}`\n        break\n      case 'killed':\n        summary = `${BACKGROUND_BASH_SUMMARY_PREFIX}\"${description}\" was stopped`\n        break\n    }\n  }\n\n  const outputPath = getTaskOutputPath(taskId)\n  const toolUseIdLine = toolUseId\n    ? `\\n<${TOOL_USE_ID_TAG}>${toolUseId}</${TOOL_USE_ID_TAG}>`\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}>${escapeXml(summary)}</${SUMMARY_TAG}>\n</${TASK_NOTIFICATION_TAG}>`\n\n  enqueuePendingNotification({\n    value: message,\n    mode: 'task-notification',\n    priority: feature('MONITOR_TOOL') ? 'next' : 'later',\n    agentId,\n  })\n}\n\nexport const LocalShellTask: Task = {\n  name: 'LocalShellTask',\n  type: 'local_bash',\n  async kill(taskId, setAppState) {\n    killTask(taskId, setAppState)\n  },\n}\n\nexport async function spawnShellTask(\n  input: LocalShellSpawnInput & { shellCommand: ShellCommand },\n  context: TaskContext,\n): Promise<TaskHandle> {\n  const { command, description, shellCommand, toolUseId, agentId, kind } = input\n  const { setAppState } = context\n\n  // TaskOutput owns the data — use its taskId so disk writes are consistent\n  const { taskOutput } = shellCommand\n  const taskId = taskOutput.taskId\n\n  const unregisterCleanup = registerCleanup(async () => {\n    killTask(taskId, setAppState)\n  })\n\n  const taskState: LocalShellTaskState = {\n    ...createTaskStateBase(taskId, 'local_bash', description, toolUseId),\n    type: 'local_bash',\n    status: 'running',\n    command,\n    completionStatusSentInAttachment: false,\n    shellCommand,\n    unregisterCleanup,\n    lastReportedTotalLines: 0,\n    isBackgrounded: true,\n    agentId,\n    kind,\n  }\n\n  registerTask(taskState, setAppState)\n\n  // Data flows through TaskOutput automatically — no stream listeners needed.\n  // Just transition to backgrounded state so the process keeps running.\n  shellCommand.background(taskId)\n\n  const cancelStallWatchdog = startStallWatchdog(\n    taskId,\n    description,\n    kind,\n    toolUseId,\n    agentId,\n  )\n\n  void shellCommand.result.then(async result => {\n    cancelStallWatchdog()\n    await flushAndCleanup(shellCommand)\n    let wasKilled = false\n\n    updateTaskState<LocalShellTaskState>(taskId, setAppState, task => {\n      if (task.status === 'killed') {\n        wasKilled = true\n        return task\n      }\n\n      return {\n        ...task,\n        status: result.code === 0 ? 'completed' : 'failed',\n        result: { code: result.code, interrupted: result.interrupted },\n        shellCommand: null,\n        unregisterCleanup: undefined,\n        endTime: Date.now(),\n      }\n    })\n\n    enqueueShellNotification(\n      taskId,\n      description,\n      wasKilled ? 'killed' : result.code === 0 ? 'completed' : 'failed',\n      result.code,\n      setAppState,\n      toolUseId,\n      kind,\n      agentId,\n    )\n\n    void evictTaskOutput(taskId)\n  })\n\n  return {\n    taskId,\n    cleanup: () => {\n      unregisterCleanup()\n    },\n  }\n}\n\n/**\n * Register a foreground task that could be backgrounded later.\n * Called when a bash command has been running long enough to show the BackgroundHint.\n * @returns taskId for the registered task\n */\nexport function registerForeground(\n  input: LocalShellSpawnInput & { shellCommand: ShellCommand },\n  setAppState: SetAppState,\n  toolUseId?: string,\n): string {\n  const { command, description, shellCommand, agentId } = input\n\n  const taskId = shellCommand.taskOutput.taskId\n\n  const unregisterCleanup = registerCleanup(async () => {\n    killTask(taskId, setAppState)\n  })\n\n  const taskState: LocalShellTaskState = {\n    ...createTaskStateBase(taskId, 'local_bash', description, toolUseId),\n    type: 'local_bash',\n    status: 'running',\n    command,\n    completionStatusSentInAttachment: false,\n    shellCommand,\n    unregisterCleanup,\n    lastReportedTotalLines: 0,\n    isBackgrounded: false, // Not yet backgrounded - running in foreground\n    agentId,\n  }\n\n  registerTask(taskState, setAppState)\n  return taskId\n}\n\n/**\n * Background a specific foreground task.\n * @returns true if backgrounded successfully, false otherwise\n */\nfunction backgroundTask(\n  taskId: string,\n  getAppState: () => AppState,\n  setAppState: SetAppState,\n): boolean {\n  // Step 1: Get the task and shell command from current state\n  const state = getAppState()\n  const task = state.tasks[taskId]\n  if (!isLocalShellTask(task) || task.isBackgrounded || !task.shellCommand) {\n    return false\n  }\n\n  const shellCommand = task.shellCommand\n  const description = task.description\n  const { toolUseId, kind, agentId } = task\n\n  // Transition to backgrounded — TaskOutput continues receiving data automatically\n  if (!shellCommand.background(taskId)) {\n    return false\n  }\n\n  setAppState(prev => {\n    const prevTask = prev.tasks[taskId]\n    if (!isLocalShellTask(prevTask) || prevTask.isBackgrounded) {\n      return prev\n    }\n    return {\n      ...prev,\n      tasks: {\n        ...prev.tasks,\n        [taskId]: { ...prevTask, isBackgrounded: true },\n      },\n    }\n  })\n\n  const cancelStallWatchdog = startStallWatchdog(\n    taskId,\n    description,\n    kind,\n    toolUseId,\n    agentId,\n  )\n\n  // Set up result handler\n  void shellCommand.result.then(async result => {\n    cancelStallWatchdog()\n    await flushAndCleanup(shellCommand)\n    let wasKilled = false\n    let cleanupFn: (() => void) | undefined\n\n    updateTaskState<LocalShellTaskState>(taskId, setAppState, t => {\n      if (t.status === 'killed') {\n        wasKilled = true\n        return t\n      }\n\n      // Capture cleanup function to call outside of updater\n      cleanupFn = t.unregisterCleanup\n\n      return {\n        ...t,\n        status: result.code === 0 ? 'completed' : 'failed',\n        result: { code: result.code, interrupted: result.interrupted },\n        shellCommand: null,\n        unregisterCleanup: undefined,\n        endTime: Date.now(),\n      }\n    })\n\n    // Call cleanup outside of the state updater (avoid side effects in updater)\n    cleanupFn?.()\n\n    if (wasKilled) {\n      enqueueShellNotification(\n        taskId,\n        description,\n        'killed',\n        result.code,\n        setAppState,\n        toolUseId,\n        kind,\n        agentId,\n      )\n    } else {\n      const finalStatus = result.code === 0 ? 'completed' : 'failed'\n      enqueueShellNotification(\n        taskId,\n        description,\n        finalStatus,\n        result.code,\n        setAppState,\n        toolUseId,\n        kind,\n        agentId,\n      )\n    }\n\n    void evictTaskOutput(taskId)\n  })\n\n  return true\n}\n\n/**\n * Background ALL foreground tasks (bash commands and agents).\n * Called when user presses Ctrl+B to background all running tasks.\n */\n/**\n * Check if there are any foreground tasks (bash or agent) that can be backgrounded.\n * Used to determine whether Ctrl+B should background existing tasks vs. background the session.\n */\nexport function hasForegroundTasks(state: AppState): boolean {\n  return Object.values(state.tasks).some(task => {\n    if (isLocalShellTask(task) && !task.isBackgrounded && task.shellCommand) {\n      return true\n    }\n    // Exclude main session tasks - they display in the main view, not as foreground tasks\n    if (\n      isLocalAgentTask(task) &&\n      !task.isBackgrounded &&\n      !isMainSessionTask(task)\n    ) {\n      return true\n    }\n    return false\n  })\n}\n\nexport function backgroundAll(\n  getAppState: () => AppState,\n  setAppState: SetAppState,\n): void {\n  const state = getAppState()\n\n  // Background all foreground bash tasks\n  const foregroundBashTaskIds = Object.keys(state.tasks).filter(id => {\n    const task = state.tasks[id]\n    return isLocalShellTask(task) && !task.isBackgrounded && task.shellCommand\n  })\n  for (const taskId of foregroundBashTaskIds) {\n    backgroundTask(taskId, getAppState, setAppState)\n  }\n\n  // Background all foreground agent tasks\n  const foregroundAgentTaskIds = Object.keys(state.tasks).filter(id => {\n    const task = state.tasks[id]\n    return isLocalAgentTask(task) && !task.isBackgrounded\n  })\n  for (const taskId of foregroundAgentTaskIds) {\n    backgroundAgentTask(taskId, getAppState, setAppState)\n  }\n}\n\n/**\n * Background an already-registered foreground task in-place.\n * Unlike spawn(), this does NOT re-register the task — it flips isBackgrounded\n * on the existing registration and sets up a completion handler.\n * Used when the auto-background timer fires after registerForeground() has\n * already registered the task (avoiding duplicate task_started SDK events\n * and leaked cleanup callbacks).\n */\nexport function backgroundExistingForegroundTask(\n  taskId: string,\n  shellCommand: ShellCommand,\n  description: string,\n  setAppState: SetAppState,\n  toolUseId?: string,\n): boolean {\n  if (!shellCommand.background(taskId)) {\n    return false\n  }\n\n  let agentId: AgentId | undefined\n  setAppState(prev => {\n    const prevTask = prev.tasks[taskId]\n    if (!isLocalShellTask(prevTask) || prevTask.isBackgrounded) {\n      return prev\n    }\n    agentId = prevTask.agentId\n    return {\n      ...prev,\n      tasks: {\n        ...prev.tasks,\n        [taskId]: { ...prevTask, isBackgrounded: true },\n      },\n    }\n  })\n\n  const cancelStallWatchdog = startStallWatchdog(\n    taskId,\n    description,\n    undefined,\n    toolUseId,\n    agentId,\n  )\n\n  // Set up result handler (mirrors backgroundTask's handler)\n  void shellCommand.result.then(async result => {\n    cancelStallWatchdog()\n    await flushAndCleanup(shellCommand)\n    let wasKilled = false\n    let cleanupFn: (() => void) | undefined\n\n    updateTaskState<LocalShellTaskState>(taskId, setAppState, t => {\n      if (t.status === 'killed') {\n        wasKilled = true\n        return t\n      }\n      cleanupFn = t.unregisterCleanup\n      return {\n        ...t,\n        status: result.code === 0 ? 'completed' : 'failed',\n        result: { code: result.code, interrupted: result.interrupted },\n        shellCommand: null,\n        unregisterCleanup: undefined,\n        endTime: Date.now(),\n      }\n    })\n\n    cleanupFn?.()\n\n    const finalStatus = wasKilled\n      ? 'killed'\n      : result.code === 0\n        ? 'completed'\n        : 'failed'\n    enqueueShellNotification(\n      taskId,\n      description,\n      finalStatus,\n      result.code,\n      setAppState,\n      toolUseId,\n      undefined,\n      agentId,\n    )\n\n    void evictTaskOutput(taskId)\n  })\n\n  return true\n}\n\n/**\n * Mark a task as notified to suppress a pending enqueueShellNotification.\n * Used when backgrounding raced with completion — the tool result already\n * carries the full output, so the <task_notification> would be redundant.\n */\nexport function markTaskNotified(\n  taskId: string,\n  setAppState: SetAppState,\n): void {\n  updateTaskState(taskId, setAppState, t =>\n    t.notified ? t : { ...t, notified: true },\n  )\n}\n\n/**\n * Unregister a foreground task when the command completes without being backgrounded.\n */\nexport function unregisterForeground(\n  taskId: string,\n  setAppState: SetAppState,\n): void {\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 (!isLocalShellTask(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\nasync function flushAndCleanup(shellCommand: ShellCommand): Promise<void> {\n  try {\n    await shellCommand.taskOutput.flush()\n    shellCommand.cleanup()\n  } catch (error) {\n    logError(error)\n  }\n}\n"],"mappings":"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","ignoreList":[]}