@iaforged/context-code 1.0.72 → 1.0.74

package/dist/src/tasks/LocalShellTask/LocalShellTask.js

@@ -0,0 +1,475 @@
+import { feature } from '../../recovery/bunBundleShim.js';
+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 { createTaskStateBase } from '../../Task.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 { 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 { isLocalShellTask } 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) {
+    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, description, kind, toolUseId, agentId) {
+    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, description, status, exitCode, setAppState, toolUseId, kind = 'bash', agentId) {
+    // 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;
+    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 = {
+    name: 'LocalShellTask',
+    type: 'local_bash',
+    async kill(taskId, setAppState) {
+        killTask(taskId, setAppState);
+    }
+};
+export async function spawnShellTask(input, context) {
+    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 = {
+        ...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(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, setAppState, toolUseId) {
+    const { command, description, shellCommand, agentId } = input;
+    const taskId = shellCommand.taskOutput.taskId;
+    const unregisterCleanup = registerCleanup(async () => {
+        killTask(taskId, setAppState);
+    });
+    const taskState = {
+        ...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, getAppState, setAppState) {
+    // 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;
+        updateTaskState(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) {
+    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, setAppState) {
+    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, shellCommand, description, setAppState, toolUseId) {
+    if (!shellCommand.background(taskId)) {
+        return false;
+    }
+    let agentId;
+    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;
+        updateTaskState(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, setAppState) {
+    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, setAppState) {
+    let cleanupFn;
+    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) {
+    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":[]}

package/dist/src/tasks/LocalShellTask/guards.js

@@ -0,0 +1,9 @@
+// Pure type + type guard for LocalShellTask state.
+// Extracted from LocalShellTask.tsx so non-React consumers (stopTask.ts via
+// print.ts) don't pull React/ink into the module graph.
+export function isLocalShellTask(task) {
+    return (typeof task === 'object' &&
+        task !== null &&
+        'type' in task &&
+        task.type === 'local_bash');
+}

package/dist/src/tasks/LocalShellTask/killShellTasks.js

@@ -0,0 +1,59 @@
+// Pure (non-React) kill helpers for LocalShellTask.
+// Extracted so runAgent.ts can kill agent-scoped bash tasks without pulling
+// React/Ink into its module graph (same rationale as guards.ts).
+import { logForDebugging } from '../../utils/debug.js';
+import { logError } from '../../utils/log.js';
+import { dequeueAllMatching } from '../../utils/messageQueueManager.js';
+import { evictTaskOutput } from '../../utils/task/diskOutput.js';
+import { updateTaskState } from '../../utils/task/framework.js';
+import { isLocalShellTask } from './guards.js';
+export function killTask(taskId, setAppState) {
+    updateTaskState(taskId, setAppState, task => {
+        if (task.status !== 'running' || !isLocalShellTask(task)) {
+            return task;
+        }
+        try {
+            logForDebugging(`LocalShellTask ${taskId} kill requested`);
+            task.shellCommand?.kill();
+            task.shellCommand?.cleanup();
+        }
+        catch (error) {
+            logError(error);
+        }
+        task.unregisterCleanup?.();
+        if (task.cleanupTimeoutId) {
+            clearTimeout(task.cleanupTimeoutId);
+        }
+        return {
+            ...task,
+            status: 'killed',
+            notified: true,
+            shellCommand: null,
+            unregisterCleanup: undefined,
+            cleanupTimeoutId: undefined,
+            endTime: Date.now(),
+        };
+    });
+    void evictTaskOutput(taskId);
+}
+/**
+ * Kill all running bash tasks spawned by a given agent.
+ * Called from runAgent.ts finally block so background processes don't outlive
+ * the agent that started them (prevents 10-day fake-logs.sh zombies).
+ */
+export function killShellTasksForAgent(agentId, getAppState, setAppState) {
+    const tasks = getAppState().tasks ?? {};
+    for (const [taskId, task] of Object.entries(tasks)) {
+        if (isLocalShellTask(task) &&
+            task.agentId === agentId &&
+            task.status === 'running') {
+            logForDebugging(`killShellTasksForAgent: killing orphaned shell task ${taskId} (agent ${agentId} exiting)`);
+            killTask(taskId, setAppState);
+        }
+    }
+    // Purge any queued notifications addressed to this agent — its query loop
+    // has exited and won't drain them. killTask fires 'killed' notifications
+    // asynchronously; drop the ones already queued and any that land later sit
+    // harmlessly (no consumer matches a dead agentId).
+    dequeueAllMatching(cmd => cmd.agentId === agentId);
+}