tide-commander 1.136.0 → 1.136.1

package/dist/assets/{web-dmnfXY_q.js → web-BahzYw5F.js}

@@ -1 +1 @@
-import{cO as s}from"./main-CHE4wC7P.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class l extends s{constructor(){super(...arguments),this.pending=[],this.deliveredNotifications=[],this.hasNotificationSupport=()=>{if(!("Notification"in window)||!Notification.requestPermission)return!1;if(Notification.permission!=="granted")try{new Notification("")}catch(i){if(i instanceof Error&&i.name==="TypeError")return!1}return!0}}async getDeliveredNotifications(){const i=[];for(const t of this.deliveredNotifications){const e={title:t.title,id:parseInt(t.tag),body:t.body};i.push(e)}return{notifications:i}}async removeDeliveredNotifications(i){for(const t of i.notifications){const e=this.deliveredNotifications.find(n=>n.tag===String(t.id));e==null||e.close(),this.deliveredNotifications=this.deliveredNotifications.filter(()=>!e)}}async removeAllDeliveredNotifications(){for(const i of this.deliveredNotifications)i.close();this.deliveredNotifications=[]}async createChannel(){throw this.unimplemented("Not implemented on web.")}async deleteChannel(){throw this.unimplemented("Not implemented on web.")}async listChannels(){throw this.unimplemented("Not implemented on web.")}async schedule(i){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");for(const t of i.notifications)this.sendNotification(t);return{notifications:i.notifications.map(t=>({id:t.id}))}}async getPending(){return{notifications:this.pending}}async registerActionTypes(){throw this.unimplemented("Not implemented on web.")}async cancel(i){this.pending=this.pending.filter(t=>!i.notifications.find(e=>e.id===t.id))}async areEnabled(){const{display:i}=await this.checkPermissions();return{value:i==="granted"}}async changeExactNotificationSetting(){throw this.unimplemented("Not implemented on web.")}async checkExactNotificationSetting(){throw this.unimplemented("Not implemented on web.")}async requestPermissions(){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");return{display:this.transformNotificationPermission(await Notification.requestPermission())}}async checkPermissions(){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");return{display:this.transformNotificationPermission(Notification.permission)}}transformNotificationPermission(i){switch(i){case"granted":return"granted";case"denied":return"denied";default:return"prompt"}}sendPending(){var i;const t=[],e=new Date().getTime();for(const n of this.pending)!((i=n.schedule)===null||i===void 0)&&i.at&&n.schedule.at.getTime()<=e&&(this.buildNotification(n),t.push(n));this.pending=this.pending.filter(n=>!t.find(o=>o===n))}sendNotification(i){var t;if(!((t=i.schedule)===null||t===void 0)&&t.at){const e=i.schedule.at.getTime()-new Date().getTime();this.pending.push(i),setTimeout(()=>{this.sendPending()},e);return}this.buildNotification(i)}buildNotification(i){const t=new Notification(i.title,{body:i.body,tag:String(i.id)});return t.addEventListener("click",this.onClick.bind(this,i),!1),t.addEventListener("show",this.onShow.bind(this,i),!1),t.addEventListener("close",()=>{this.deliveredNotifications=this.deliveredNotifications.filter(()=>!this)},!1),this.deliveredNotifications.push(t),t}onClick(i){const t={actionId:"tap",notification:i};this.notifyListeners("localNotificationActionPerformed",t)}onShow(i){this.notifyListeners("localNotificationReceived",i)}}export{l as LocalNotificationsWeb};
+import{cO as s}from"./main-Db4or1Jx.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class l extends s{constructor(){super(...arguments),this.pending=[],this.deliveredNotifications=[],this.hasNotificationSupport=()=>{if(!("Notification"in window)||!Notification.requestPermission)return!1;if(Notification.permission!=="granted")try{new Notification("")}catch(i){if(i instanceof Error&&i.name==="TypeError")return!1}return!0}}async getDeliveredNotifications(){const i=[];for(const t of this.deliveredNotifications){const e={title:t.title,id:parseInt(t.tag),body:t.body};i.push(e)}return{notifications:i}}async removeDeliveredNotifications(i){for(const t of i.notifications){const e=this.deliveredNotifications.find(n=>n.tag===String(t.id));e==null||e.close(),this.deliveredNotifications=this.deliveredNotifications.filter(()=>!e)}}async removeAllDeliveredNotifications(){for(const i of this.deliveredNotifications)i.close();this.deliveredNotifications=[]}async createChannel(){throw this.unimplemented("Not implemented on web.")}async deleteChannel(){throw this.unimplemented("Not implemented on web.")}async listChannels(){throw this.unimplemented("Not implemented on web.")}async schedule(i){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");for(const t of i.notifications)this.sendNotification(t);return{notifications:i.notifications.map(t=>({id:t.id}))}}async getPending(){return{notifications:this.pending}}async registerActionTypes(){throw this.unimplemented("Not implemented on web.")}async cancel(i){this.pending=this.pending.filter(t=>!i.notifications.find(e=>e.id===t.id))}async areEnabled(){const{display:i}=await this.checkPermissions();return{value:i==="granted"}}async changeExactNotificationSetting(){throw this.unimplemented("Not implemented on web.")}async checkExactNotificationSetting(){throw this.unimplemented("Not implemented on web.")}async requestPermissions(){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");return{display:this.transformNotificationPermission(await Notification.requestPermission())}}async checkPermissions(){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");return{display:this.transformNotificationPermission(Notification.permission)}}transformNotificationPermission(i){switch(i){case"granted":return"granted";case"denied":return"denied";default:return"prompt"}}sendPending(){var i;const t=[],e=new Date().getTime();for(const n of this.pending)!((i=n.schedule)===null||i===void 0)&&i.at&&n.schedule.at.getTime()<=e&&(this.buildNotification(n),t.push(n));this.pending=this.pending.filter(n=>!t.find(o=>o===n))}sendNotification(i){var t;if(!((t=i.schedule)===null||t===void 0)&&t.at){const e=i.schedule.at.getTime()-new Date().getTime();this.pending.push(i),setTimeout(()=>{this.sendPending()},e);return}this.buildNotification(i)}buildNotification(i){const t=new Notification(i.title,{body:i.body,tag:String(i.id)});return t.addEventListener("click",this.onClick.bind(this,i),!1),t.addEventListener("show",this.onShow.bind(this,i),!1),t.addEventListener("close",()=>{this.deliveredNotifications=this.deliveredNotifications.filter(()=>!this)},!1),this.deliveredNotifications.push(t),t}onClick(i){const t={actionId:"tap",notification:i};this.notifyListeners("localNotificationActionPerformed",t)}onShow(i){this.notifyListeners("localNotificationReceived",i)}}export{l as LocalNotificationsWeb};

package/dist/assets/{web-D1Ur_Mtd.js → web-BnBWe9ee.js}

@@ -1 +1 @@
-import{cO as t}from"./main-CHE4wC7P.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class o extends t{constructor(){super(),this.handleVisibilityChange=()=>{const e={isActive:document.hidden!==!0};this.notifyListeners("appStateChange",e),document.hidden?this.notifyListeners("pause",null):this.notifyListeners("resume",null)},document.addEventListener("visibilitychange",this.handleVisibilityChange,!1)}exitApp(){throw this.unimplemented("Not implemented on web.")}async getInfo(){throw this.unimplemented("Not implemented on web.")}async getLaunchUrl(){return{url:""}}async getState(){return{isActive:document.hidden!==!0}}async minimizeApp(){throw this.unimplemented("Not implemented on web.")}async toggleBackButtonHandler(){throw this.unimplemented("Not implemented on web.")}async getAppLanguage(){return{value:navigator.language.split("-")[0].toLowerCase()}}}export{o as AppWeb};
+import{cO as t}from"./main-Db4or1Jx.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class o extends t{constructor(){super(),this.handleVisibilityChange=()=>{const e={isActive:document.hidden!==!0};this.notifyListeners("appStateChange",e),document.hidden?this.notifyListeners("pause",null):this.notifyListeners("resume",null)},document.addEventListener("visibilitychange",this.handleVisibilityChange,!1)}exitApp(){throw this.unimplemented("Not implemented on web.")}async getInfo(){throw this.unimplemented("Not implemented on web.")}async getLaunchUrl(){return{url:""}}async getState(){return{isActive:document.hidden!==!0}}async minimizeApp(){throw this.unimplemented("Not implemented on web.")}async toggleBackButtonHandler(){throw this.unimplemented("Not implemented on web.")}async getAppLanguage(){return{value:navigator.language.split("-")[0].toLowerCase()}}}export{o as AppWeb};

package/dist/assets/{web-C4yrL2Hp.js → web-BsXkVdvj.js}

@@ -1 +1 @@
-import{cO as a}from"./main-CHE4wC7P.js";import{ImpactStyle as i,NotificationType as r}from"./index-CLmNQzTF.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class h extends a{constructor(){super(...arguments),this.selectionStarted=!1}async impact(t){const e=this.patternForImpact(t==null?void 0:t.style);this.vibrateWithPattern(e)}async notification(t){const e=this.patternForNotification(t==null?void 0:t.type);this.vibrateWithPattern(e)}async vibrate(t){const e=(t==null?void 0:t.duration)||300;this.vibrateWithPattern([e])}async selectionStart(){this.selectionStarted=!0}async selectionChanged(){this.selectionStarted&&this.vibrateWithPattern([70])}async selectionEnd(){this.selectionStarted=!1}patternForImpact(t=i.Heavy){return t===i.Medium?[43]:t===i.Light?[20]:[61]}patternForNotification(t=r.Success){return t===r.Warning?[30,40,30,50,60]:t===r.Error?[27,45,50]:[35,65,21]}vibrateWithPattern(t){if(navigator.vibrate)navigator.vibrate(t);else throw this.unavailable("Browser does not support the vibrate API")}}export{h as HapticsWeb};
+import{cO as a}from"./main-Db4or1Jx.js";import{ImpactStyle as i,NotificationType as r}from"./index-BvfNZfX7.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class h extends a{constructor(){super(...arguments),this.selectionStarted=!1}async impact(t){const e=this.patternForImpact(t==null?void 0:t.style);this.vibrateWithPattern(e)}async notification(t){const e=this.patternForNotification(t==null?void 0:t.type);this.vibrateWithPattern(e)}async vibrate(t){const e=(t==null?void 0:t.duration)||300;this.vibrateWithPattern([e])}async selectionStart(){this.selectionStarted=!0}async selectionChanged(){this.selectionStarted&&this.vibrateWithPattern([70])}async selectionEnd(){this.selectionStarted=!1}patternForImpact(t=i.Heavy){return t===i.Medium?[43]:t===i.Light?[20]:[61]}patternForNotification(t=r.Success){return t===r.Warning?[30,40,30,50,60]:t===r.Error?[27,45,50]:[35,65,21]}vibrateWithPattern(t){if(navigator.vibrate)navigator.vibrate(t);else throw this.unavailable("Browser does not support the vibrate API")}}export{h as HapticsWeb};

package/dist/index.html

@@ -22,10 +22,10 @@
     <link rel="icon" type="image/png" sizes="16x16" href="/assets/icons/favicon-16x16.png" />
     <link rel="apple-touch-icon" sizes="180x180" href="/assets/icons/apple-touch-icon.png" />
     <title>Tide Commander</title>
-    <script type="module" crossorigin src="/assets/main-CHE4wC7P.js"></script>
+    <script type="module" crossorigin src="/assets/main-Db4or1Jx.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/vendor-react--Eh9ivFN.js">
     <link rel="modulepreload" crossorigin href="/assets/vendor-three-Chj50gSY.js">
-    <link rel="stylesheet" crossorigin href="/assets/main-DM0iS4EN.css">
+    <link rel="stylesheet" crossorigin href="/assets/main-Ba3wdQK_.css">
   </head>
   <body>
     <div id="app"></div>

package/dist/src/packages/server/claude/backend.js

@@ -15,6 +15,12 @@ const log = createLogger('Backend');
 // Track tool_use_id to tool_name mapping for matching tool_result events
 // This is a module-level map that persists across parseEvent calls
 const toolUseIdToName = new Map();
+// Marker text of the immediate tool_result the CLI returns when a Task/Agent tool
+// launches in the background (the real result arrives later as a <task-notification>)
+function isBackgroundLaunchStub(content) {
+    return content.includes('Async agent launched successfully')
+        || content.includes('The agent is working in the background');
+}
 /**
  * Write prompt content to a temp file for use with --system-prompt-file / --append-system-prompt-file
  * This avoids issues with multiline prompts and shell escaping
@@ -268,7 +274,7 @@ export class ClaudeBackend {
         const message = event.message;
         // Handle array content (tool_result blocks)
         if (Array.isArray(message?.content)) {
-            const toolResults = [];
+            const events = [];
             for (const block of message.content) {
                 if (block.type === 'tool_result' && block.tool_use_id) {
                     // Prefer tool_use_result.stdout (raw output) over block.content (may be truncated)
@@ -288,6 +294,16 @@ export class ClaudeBackend {
                     // Look up the tool name from the tool_use_id mapping
                     const toolName = toolUseIdToName.get(block.tool_use_id) || 'unknown';
                     log.log(`parseUserEvent: Found tool_result for tool_use_id=${block.tool_use_id}, toolName=${toolName}, content length=${content?.length || 0}, hasToolUseResult=${!!event.tool_use_result}`);
+                    // Background Task launch stub: the CLI answers the tool_use immediately with
+                    // "Async agent launched..." while the subagent keeps running. Reclassify as
+                    // task_started so downstream doesn't complete the subagent or idle the agent —
+                    // the real completion arrives later as a <task-notification> user message.
+                    if ((toolName === 'Task' || toolName === 'Agent') && isBackgroundLaunchStub(content)) {
+                        log.log(`parseUserEvent: background launch stub for tool_use_id=${block.tool_use_id} — task still running`);
+                        events.push({ type: 'task_started', toolUseId: block.tool_use_id });
+                        toolUseIdToName.delete(block.tool_use_id);
+                        continue;
+                    }
                     const toolResult = {
                         type: 'tool_result',
                         toolName,
@@ -310,14 +326,29 @@ export class ClaudeBackend {
                     if (event.parent_tool_use_id) {
                         toolResult.parentToolUseId = event.parent_tool_use_id;
                     }
-                    toolResults.push(toolResult);
+                    events.push(toolResult);
                     // Clean up the mapping after use (tool_use_id is unique per invocation)
                     toolUseIdToName.delete(block.tool_use_id);
                 }
             }
-            if (toolResults.length > 0) {
-                log.log(`parseUserEvent: Extracted ${toolResults.length} tool_result(s)`);
-                return toolResults.length === 1 ? toolResults[0] : toolResults;
+            // Background task completions: the CLI wakes the model with a user message
+            // containing <task-notification> blocks (one per finished background task).
+            for (const block of message.content) {
+                if (block.type !== 'text' || typeof block.text !== 'string' || !block.text.includes('<task-notification>')) {
+                    continue;
+                }
+                for (const chunk of block.text.match(/<task-notification>[\s\S]*?(?:<\/task-notification>|$)/g) ?? []) {
+                    const toolUseId = /<tool-use-id>([^<]+)<\/tool-use-id>/.exec(chunk)?.[1];
+                    const taskId = /<task-id>([^<]+)<\/task-id>/.exec(chunk)?.[1];
+                    if (toolUseId) {
+                        log.log(`parseUserEvent: task_notification for tool_use_id=${toolUseId} (task_id=${taskId || 'unknown'})`);
+                        events.push({ type: 'task_notification', toolUseId, taskId });
+                    }
+                }
+            }
+            if (events.length > 0) {
+                log.log(`parseUserEvent: Extracted ${events.length} event(s)`);
+                return events.length === 1 ? events[0] : events;
             }
         }
         // Check for local-command-stdout (from /context, /cost, /usage etc. commands)
@@ -354,9 +385,28 @@ export class ClaudeBackend {
                 errorMessage: event.error,
             };
         }
-        // Capture task_started events (links task_id to tool_use_id)
+        // Background Task launched (links task_id to the Task tool_use_id). The tool_result
+        // that follows immediately is only a launch stub — the task keeps running until a
+        // <task-notification> user message arrives.
         if (event.subtype === 'task_started' && event.task_id) {
             log.log(`parseSystemEvent: task_started - task_id=${event.task_id}, tool_use_id=${event.tool_use_id}`);
+            if (event.tool_use_id) {
+                return {
+                    type: 'task_started',
+                    taskId: event.task_id,
+                    toolUseId: event.tool_use_id,
+                };
+            }
+        }
+        // Background task finished (fires for async Task/Agent launches and for slow Bash
+        // commands the CLI promotes to tasks) — resolves pending-task tracking.
+        if (event.subtype === 'task_notification' && (event.tool_use_id || event.task_id)) {
+            log.log(`parseSystemEvent: task_notification - task_id=${event.task_id}, tool_use_id=${event.tool_use_id}`);
+            return {
+                type: 'task_notification',
+                taskId: event.task_id,
+                toolUseId: event.tool_use_id,
+            };
         }
         // Context compaction status
         if (event.subtype === 'status' && event.status === 'compacting') {

package/dist/src/packages/server/claude/runner/stdout-pipeline.js

@@ -85,6 +85,10 @@ export class RunnerStdoutPipeline {
             }
             const eventOrEvents = this.backend.parseEvent(rawEvent);
             if (!eventOrEvents) {
+                // Even unmapped events (task_progress, thinking_tokens, ...) prove the CLI is
+                // alive and mid-work — keep the watchdog's activity clock fresh so a session
+                // waiting on background tasks isn't idle-killed or flagged as stuck.
+                this.bus.emit({ type: 'runner.activity', agentId, timestamp: Date.now() });
                 return;
             }
             if (Array.isArray(eventOrEvents)) {

package/dist/src/packages/server/claude/runner/watchdog.js

@@ -2,6 +2,7 @@ import { createLogger } from '../../utils/logger.js';
 import { isProcessRunning } from '../../data/index.js';
 import { hasTmuxSession, isTmuxPaneCommandAlive, killTmuxSession } from './tmux-helper.js';
 import * as agentService from '../../services/agent-service.js';
+import { clearPendingBackgroundTasks } from '../../services/runtime-subagents.js';
 import { getTmuxIdleTimeoutMs } from '../../services/system-prompt-service.js';
 const log = createLogger('Runner');
 const MAX_DEATH_HISTORY = 50;
@@ -10,6 +11,13 @@ const MAX_DEATH_HISTORY = 50;
 // can hang for many minutes without an exit signal) and SIGKILL it so the normal
 // process_closed → maybeAutoRestart path can respawn with session resume.
 const IDLE_RESPAWN_MS = Number.parseInt(process.env.TIDE_IDLE_RESPAWN_MS ?? '', 10) || 180_000;
+// A 'working' agent whose turn already ended (waiting_for_input) and whose stream has
+// been silent this long is stuck — a background-task completion signal we missed
+// (killed task, CLI wording change) or a stale status restored across a server
+// restart. Reconcile to idle. Live background tasks emit task_progress lines that
+// count as activity, and message sends flip turnState to 'processing', so neither
+// can trip this.
+const STUCK_WORKING_RECONCILE_MS = Number.parseInt(process.env.TIDE_STUCK_WORKING_RECONCILE_MS ?? '', 10) || 180_000;
 export class RunnerWatchdog {
     activeProcesses;
     lastStderr;
@@ -28,6 +36,7 @@ export class RunnerWatchdog {
         const idleTimeoutMs = getTmuxIdleTimeoutMs();
         const now = Date.now();
         for (const [agentId, activeProcess] of this.activeProcesses) {
+            this.reconcileStuckWorking(agentId, activeProcess, now);
             // tmux mode: the launcher PID exits immediately — check the tmux session instead
             if (activeProcess.tmuxSession) {
                 const sessionAlive = hasTmuxSession(agentId);
@@ -146,6 +155,31 @@ export class RunnerWatchdog {
             }
         }
     }
+    // Safety net for stuck 'working' status: the turn ended, no events are flowing,
+    // yet the agent still shows working. Flip it to idle and drop any pending
+    // background-task tracking so the tmux idle-timeout can later reclaim the session.
+    reconcileStuckWorking(agentId, activeProcess, now) {
+        if (activeProcess.turnState !== 'waiting_for_input') {
+            return;
+        }
+        const lastActivity = activeProcess.lastActivityTime ?? activeProcess.startTime;
+        if (now - lastActivity < STUCK_WORKING_RECONCILE_MS) {
+            return;
+        }
+        const agent = agentService.getAgent(agentId);
+        if (agent?.status !== 'working') {
+            return;
+        }
+        const silentSec = Math.round((now - lastActivity) / 1000);
+        log.error(`🐕 [WATCHDOG] Agent ${agentId}: status 'working' but turn ended and stream silent for ${silentSec}s `
+            + `(threshold=${STUCK_WORKING_RECONCILE_MS / 1000}s) — reconciling to idle and clearing pending background tasks`);
+        clearPendingBackgroundTasks(agentId);
+        agentService.updateAgent(agentId, {
+            status: 'idle',
+            currentTask: undefined,
+            currentTool: undefined,
+        });
+    }
     recordDeath(info) {
         this.recentDeaths.unshift(info);
         if (this.recentDeaths.length > MAX_DEATH_HISTORY) {

package/dist/src/packages/server/services/runtime-events.js

@@ -1,7 +1,7 @@
 import { loadSession } from '../claude/session-loader.js';
 import * as agentService from './agent-service.js';
 import { clearPendingSilentContextRefresh, consumeStepCompleteReceived, markStepCompleteReceived, } from './runtime-watchdog.js';
-import { handleTaskToolResult, handleTaskToolStart } from './runtime-subagents.js';
+import { addPendingBackgroundTask, clearPendingBackgroundTasks, getActiveSubagentByToolUseId, handleTaskToolResult, handleTaskToolStart, hasPendingBackgroundTasks, resolvePendingBackgroundTask, resolvePendingBackgroundTaskByTaskId, } from './runtime-subagents.js';
 const DEFAULT_CLAUDE_CONTEXT_WINDOW = 200000;
 const DEFAULT_CODEX_CONTEXT_WINDOW = 258400;
 const CODEX_ROLLING_CONTEXT_TURNS = 40;
@@ -173,8 +173,56 @@ export function createRuntimeEventHandlers(deps) {
                 break;
             case 'tool_result':
                 handleTaskToolResult(agentId, event, log);
+                if (event.toolUseId) {
+                    // Any tool_result for a tracked toolUseId means that task delivered its
+                    // result. The CLI assigns task_ids to slow Bash commands too, so resolution
+                    // must NOT be limited to Task/Agent tools — that gap pinned agents 'working'.
+                    resolvePendingBackgroundTask(agentId, event.toolUseId);
+                }
                 agentService.updateAgent(agentId, { currentTool: undefined });
                 break;
+            case 'task_started':
+                // Tool promoted to a background task (async Task/Agent, slow Bash): it can
+                // outlive the parent turn, so step_complete must not flip the agent idle
+                // while it runs.
+                if (event.toolUseId) {
+                    addPendingBackgroundTask(agentId, event.toolUseId, event.taskId);
+                    log.log(`[task] Background task pending for ${agentId}: toolUseId=${event.toolUseId}${event.taskId ? `, taskId=${event.taskId}` : ''}`);
+                }
+                break;
+            case 'task_notification': {
+                // A background task finished and the CLI is waking the model with its result.
+                if (!event.toolUseId && event.taskId) {
+                    resolvePendingBackgroundTaskByTaskId(agentId, event.taskId);
+                }
+                if (event.toolUseId) {
+                    resolvePendingBackgroundTask(agentId, event.toolUseId);
+                    // Complete the subagent now (its launch-stub tool_result was suppressed).
+                    if (getActiveSubagentByToolUseId(event.toolUseId)) {
+                        const completion = {
+                            type: 'tool_result',
+                            toolName: 'Agent',
+                            toolUseId: event.toolUseId,
+                        };
+                        handleTaskToolResult(agentId, completion, log);
+                        emitEvent(agentId, completion);
+                    }
+                }
+                if (processActive && agent.status === 'idle') {
+                    agentService.updateAgent(agentId, { status: 'working' });
+                }
+                break;
+            }
+            case 'text':
+            case 'thinking':
+                // The model produced output — it's working, even right after a step_complete
+                // (background-task wakes often start with text/thinking, not a tool call).
+                // Subagent-bridged events (parentToolUseId set) don't count: the JSONL watcher
+                // can drain trailing lines after the parent is genuinely done.
+                if (processActive && agent.status === 'idle' && !event.parentToolUseId) {
+                    agentService.updateAgent(agentId, { status: 'working' });
+                }
+                break;
             case 'usage_snapshot': {
                 // Skip subagent events — their token counts reflect the subagent's context,
                 // not the parent's. Updating the parent's contextUsed here would corrupt it.
@@ -356,14 +404,26 @@ export function createRuntimeEventHandlers(deps) {
                 }
                 agentService.updateAgent(agentId, updates);
                 if (!isCodexProvider && !isOpencodeProvider) {
-                    setTimeout(() => {
-                        log.log(`[step_complete] Setting status to idle for agent ${agentId} (lastTask: ${agent.lastAssignedTask})`);
-                        agentService.updateAgent(agentId, {
-                            status: 'idle',
-                            currentTask: undefined,
-                            currentTool: undefined,
-                        });
-                    }, 200);
+                    if (hasPendingBackgroundTasks(agentId)) {
+                        // The turn ended but background tasks are still running — the CLI will wake
+                        // the model with a <task-notification> when they finish. Not idle yet.
+                        log.log(`[step_complete] Agent ${agentId} has pending background task(s) — keeping status '${agent.status}'`);
+                        agentService.updateAgent(agentId, { currentTool: undefined });
+                    }
+                    else {
+                        setTimeout(() => {
+                            if (hasPendingBackgroundTasks(agentId)) {
+                                log.log(`[step_complete] Agent ${agentId} gained pending background task(s) — skipping idle`);
+                                return;
+                            }
+                            log.log(`[step_complete] Setting status to idle for agent ${agentId} (lastTask: ${agent.lastAssignedTask})`);
+                            agentService.updateAgent(agentId, {
+                                status: 'idle',
+                                currentTask: undefined,
+                                currentTool: undefined,
+                            });
+                        }, 200);
+                    }
                 }
                 else {
                     log.log(`[step_complete] ${isCodexProvider ? 'Codex' : 'OpenCode'} agent ${agentId} will be set idle on process completion`);
@@ -374,6 +434,9 @@ export function createRuntimeEventHandlers(deps) {
                 break;
             }
             case 'error':
+                // Background tasks are children of the CLI process — an errored run means
+                // they're gone; a stale pending set would pin the agent 'working' forever.
+                clearPendingBackgroundTasks(agentId);
                 agentService.updateAgent(agentId, { status: 'error' });
                 break;
             case 'context_stats':
@@ -401,6 +464,8 @@ export function createRuntimeEventHandlers(deps) {
         }
     }
     function handleComplete(agentId, success) {
+        // Process closed — any background tasks died with it.
+        clearPendingBackgroundTasks(agentId);
         const receivedStepComplete = consumeStepCompleteReceived(agentId);
         const agent = agentService.getAgent(agentId);
         const isCodexProvider = (agent?.provider ?? 'claude') === 'codex';
@@ -438,6 +503,8 @@ export function createRuntimeEventHandlers(deps) {
         }
     }
     function handleError(agentId, error) {
+        // Same as 'error' events: a failed run takes its background tasks with it.
+        clearPendingBackgroundTasks(agentId);
         const agent = agentService.getAgent(agentId);
         const timestamp = new Date().toISOString();
         const isCodexProvider = (agent?.provider ?? 'claude') === 'codex';

package/dist/src/packages/server/services/runtime-subagents.js

@@ -1,6 +1,11 @@
 let subagentCounter = 0;
 const activeSubagents = new Map();
 const subagentIdToToolUseId = new Map();
+// Background tasks: the CLI assigns task_ids to async Task/Agent launches AND to slow
+// Bash commands. The parent turn can end while these still run — the CLI wakes the
+// model with a task-notification when each finishes. While any are pending the agent
+// must NOT be flipped to idle.
+const pendingBackgroundTasks = new Map(); // parentAgentId -> toolUseId -> taskId
 function generateSubagentId() {
     return `sub_${Date.now().toString(36)}_${(subagentCounter++).toString(36)}`;
 }
@@ -41,6 +46,42 @@ export function handleTaskToolResult(agentId, event, log) {
     activeSubagents.delete(event.toolUseId);
     subagentIdToToolUseId.delete(subagent.id);
 }
+export function addPendingBackgroundTask(agentId, toolUseId, taskId) {
+    let tasks = pendingBackgroundTasks.get(agentId);
+    if (!tasks) {
+        tasks = new Map();
+        pendingBackgroundTasks.set(agentId, tasks);
+    }
+    tasks.set(toolUseId, taskId);
+}
+export function resolvePendingBackgroundTask(agentId, toolUseId) {
+    const tasks = pendingBackgroundTasks.get(agentId);
+    if (!tasks?.delete(toolUseId)) {
+        return false;
+    }
+    if (tasks.size === 0) {
+        pendingBackgroundTasks.delete(agentId);
+    }
+    return true;
+}
+export function resolvePendingBackgroundTaskByTaskId(agentId, taskId) {
+    const tasks = pendingBackgroundTasks.get(agentId);
+    if (!tasks) {
+        return false;
+    }
+    for (const [toolUseId, pendingTaskId] of tasks) {
+        if (pendingTaskId === taskId) {
+            return resolvePendingBackgroundTask(agentId, toolUseId);
+        }
+    }
+    return false;
+}
+export function hasPendingBackgroundTasks(agentId) {
+    return (pendingBackgroundTasks.get(agentId)?.size ?? 0) > 0;
+}
+export function clearPendingBackgroundTasks(agentId) {
+    pendingBackgroundTasks.delete(agentId);
+}
 export function getActiveSubagentByToolUseId(toolUseId) {
     return activeSubagents.get(toolUseId);
 }
@@ -50,5 +91,6 @@ export function getActiveSubagentsForAgent(parentAgentId) {
 export function resetSubagentStateForTests() {
     activeSubagents.clear();
     subagentIdToToolUseId.clear();
+    pendingBackgroundTasks.clear();
     subagentCounter = 0;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tide-commander",
-  "version": "1.136.0",
+  "version": "1.136.1",
   "description": "Visual multi-agent orchestrator and manager for Claude Code with 3D/2D interface",
   "repository": {
     "type": "git",