tide-commander 1.134.2 → 1.136.0

package/dist/src/packages/server/services/subagent-jsonl-watcher.js

@@ -19,9 +19,12 @@ import { createLogger } from '../utils/logger.js';
 import { encodeProjectPath } from '../claude/session-loader.js';
 const log = createLogger('SubagentJSONL');
 const MAX_ENTRIES_PER_BROADCAST = 20;
-const IDLE_TIMEOUT_MS = 180_000; // Stop after 3 minutes of no file changes (subagents can run long builds)
+const IDLE_TIMEOUT_MS = 600_000; // Stop after 10 minutes of no file changes (long thinking/tool gaps on xhigh effort)
 const POLL_INTERVAL_MS = 2_000; // Poll file every 2s (fallback if fs.watch misses events)
-const MAX_WATCH_DURATION_MS = 900_000; // Hard limit: 15 minutes max per watcher
+const MAX_WATCH_DURATION_MS = 3_600_000; // Hard limit: 60 minutes max per watcher (background agents routinely run 20-30 min)
+const BIND_POLL_INTERVAL_MS = 1_000; // Retry transcript binding every second until found
+const BIND_GIVE_UP_MS = 120_000; // Stop an unbound watcher after 2 minutes (no transcript ever appeared)
+const FALLBACK_BIND_GRACE_MS = 15_000; // Give meta.json time to appear before the newest-file fallback
 // Key param extraction per tool name
 const TOOL_KEY_PARAMS = {
     Bash: 'command',
@@ -48,7 +51,7 @@ export function getSubagentsDir(cwd, sessionId) {
 /**
  * Start watching for a subagent's JSONL file
  */
-export function startWatching(toolUseId, parentAgentId, subagentsDir, onBroadcast, onToolResult) {
+export function startWatching(toolUseId, parentAgentId, subagentsDir, onBroadcast, onToolResult, options) {
     if (activeWatchers.has(toolUseId)) {
         log.warn(`[Watcher] Already watching for toolUseId=${toolUseId}`);
         return;
@@ -57,6 +60,8 @@ export function startWatching(toolUseId, parentAgentId, subagentsDir, onBroadcas
         toolUseId,
         parentAgentId,
         subagentsDir,
+        startedAt: Date.now(),
+        startAtEnd: options?.startAtEnd === true,
         readPosition: 0,
         lineBuffer: '',
         pendingEntries: [],
@@ -76,6 +81,10 @@ export function startWatching(toolUseId, parentAgentId, subagentsDir, onBroadcas
     // Try to find existing files first, then watch for new ones
     tryFindAndWatchFile(watcher);
 }
+/** Whether a live watcher exists for this Task/Agent toolUseId. */
+export function isWatching(toolUseId) {
+    return activeWatchers.has(toolUseId);
+}
 /**
  * Signal that the subagent's Task tool has completed.
  * For team agents, the Task returns immediately but the subagent keeps running.
@@ -105,6 +114,7 @@ function doStop(watcher) {
     }
     flushEntries(watcher);
     // Cleanup all timers and watchers
+    clearBindTimer(watcher);
     watcher.dirWatcher?.close();
     watcher.fileWatcher?.close();
     if (watcher.broadcastTimer)
@@ -138,91 +148,42 @@ function resetIdleTimer(watcher) {
     }, IDLE_TIMEOUT_MS);
 }
 /**
- * Try to find an existing JSONL file or watch the directory for new ones
+ * Bind this watcher to its subagent's transcript inside the shared
+ * subagents/ directory, retrying until it appears.
+ *
+ * Exact binding: each subagent writes agent-<id>.meta.json containing the
+ * parent Task/Agent toolUseId — match it against ours. The old "newest
+ * .jsonl in the dir" heuristic mis-binds when several subagents run
+ * concurrently: at tool_start time the newest file usually belongs to a
+ * sibling (this subagent hasn't written anything yet), so this subagent's
+ * tool_results never bridge and its Bash cards spin forever.
  */
 function tryFindAndWatchFile(watcher) {
-    const { subagentsDir } = watcher;
-    // Check if directory exists yet
-    if (!fs.existsSync(subagentsDir)) {
-        // Directory doesn't exist yet - watch parent for it to appear
-        const parentDir = path.dirname(subagentsDir);
-        if (!fs.existsSync(parentDir)) {
-            // Session directory doesn't exist either - retry periodically
-            const retryInterval = setInterval(() => {
-                if (watcher.stopped) {
-                    clearInterval(retryInterval);
-                    return;
-                }
-                if (fs.existsSync(subagentsDir)) {
-                    clearInterval(retryInterval);
-                    watchDirectory(watcher);
-                }
-            }, 500);
-            // Give up after 30 seconds
-            setTimeout(() => clearInterval(retryInterval), 30000);
+    if (tryBindTranscript(watcher))
+        return;
+    // Retry on a timer — also covers the "session/subagents directory doesn't
+    // exist yet" case (readdir fails → keep polling).
+    watcher.bindTimer = setInterval(() => {
+        if (watcher.stopped) {
+            clearBindTimer(watcher);
             return;
         }
-        // Watch parent directory for subagents/ to appear
-        try {
-            const parentWatcher = fs.watch(parentDir, (eventType, filename) => {
-                if (watcher.stopped)
-                    return;
-                if (filename === 'subagents' && fs.existsSync(subagentsDir)) {
-                    parentWatcher.close();
-                    watchDirectory(watcher);
-                }
-            });
-            parentWatcher.on('error', () => parentWatcher.close());
-        }
-        catch {
-            log.warn(`[Watcher] Failed to watch parent dir: ${parentDir}`);
-        }
-        return;
-    }
-    // Directory exists - look for existing files or watch for new ones
-    watchDirectory(watcher);
-}
-/**
- * Watch the subagents directory for JSONL files
- */
-function watchDirectory(watcher) {
-    if (watcher.stopped)
-        return;
-    const { subagentsDir } = watcher;
-    // Check for existing .jsonl files
-    try {
-        const files = fs.readdirSync(subagentsDir).filter(f => f.endsWith('.jsonl'));
-        if (files.length > 0) {
-            // Pick the most recently modified file
-            let newest = files[0];
-            let newestMtime = 0;
-            for (const f of files) {
-                try {
-                    const stat = fs.statSync(path.join(subagentsDir, f));
-                    if (stat.mtimeMs > newestMtime) {
-                        newestMtime = stat.mtimeMs;
-                        newest = f;
-                    }
-                }
-                catch { /* skip */ }
-            }
-            startFileWatch(watcher, path.join(subagentsDir, newest));
+        if (tryBindTranscript(watcher)) {
+            clearBindTimer(watcher);
             return;
         }
-    }
-    catch { /* directory may have been removed */ }
-    // No files yet - watch for new ones
+        if (Date.now() - watcher.startedAt > BIND_GIVE_UP_MS) {
+            log.warn(`[Watcher] No transcript appeared for toolUseId=${watcher.toolUseId} after ${BIND_GIVE_UP_MS / 1000}s, giving up`);
+            doStop(watcher);
+        }
+    }, BIND_POLL_INTERVAL_MS);
+    // React faster than the poll when the directory already exists.
     try {
-        watcher.dirWatcher = fs.watch(subagentsDir, (eventType, filename) => {
-            if (watcher.stopped)
+        watcher.dirWatcher = fs.watch(watcher.subagentsDir, () => {
+            if (watcher.stopped || watcher.jsonlPath)
                 return;
-            if (filename && filename.endsWith('.jsonl') && !watcher.jsonlPath) {
-                const filePath = path.join(subagentsDir, filename);
-                if (fs.existsSync(filePath)) {
-                    watcher.dirWatcher?.close();
-                    watcher.dirWatcher = undefined;
-                    startFileWatch(watcher, filePath);
-                }
+            if (tryBindTranscript(watcher)) {
+                clearBindTimer(watcher);
             }
         });
         watcher.dirWatcher.on('error', () => {
@@ -230,9 +191,69 @@ function watchDirectory(watcher) {
             watcher.dirWatcher = undefined;
         });
     }
+    catch { /* directory not created yet — the bind poll covers it */ }
+}
+function clearBindTimer(watcher) {
+    if (watcher.bindTimer) {
+        clearInterval(watcher.bindTimer);
+        watcher.bindTimer = undefined;
+    }
+}
+/**
+ * One binding attempt. Returns true when a file watch was started.
+ *
+ * Fallback for CLI layouts that don't write meta files: after a grace
+ * period, bind to the newest .jsonl that has no .meta.json sibling. Files
+ * WITH a meta sibling are never eligible — a non-matching meta means the
+ * file belongs to a different Task/Agent call.
+ */
+function tryBindTranscript(watcher) {
+    const { subagentsDir } = watcher;
+    let files;
+    try {
+        files = fs.readdirSync(subagentsDir);
+    }
     catch {
-        log.warn(`[Watcher] Failed to watch directory: ${subagentsDir}`);
+        return false; // directory doesn't exist yet
+    }
+    // Exact match via meta.json (agent-<id>.meta.json → agent-<id>.jsonl)
+    for (const f of files) {
+        if (!f.endsWith('.meta.json'))
+            continue;
+        try {
+            const meta = JSON.parse(fs.readFileSync(path.join(subagentsDir, f), 'utf8'));
+            if (meta?.toolUseId !== watcher.toolUseId)
+                continue;
+            const jsonl = f.replace(/\.meta\.json$/, '.jsonl');
+            if (files.includes(jsonl)) {
+                startFileWatch(watcher, path.join(subagentsDir, jsonl));
+                return true;
+            }
+            return false; // our meta exists but the transcript doesn't yet — keep waiting
+        }
+        catch { /* unreadable/partially-written meta — skip */ }
+    }
+    // Fallback: newest orphan .jsonl (no meta sibling), after a grace period
+    // that gives our meta.json time to appear.
+    if (Date.now() - watcher.startedAt < FALLBACK_BIND_GRACE_MS)
+        return false;
+    const orphans = files.filter((f) => f.endsWith('.jsonl') && !files.includes(f.replace(/\.jsonl$/, '.meta.json')));
+    if (orphans.length === 0)
+        return false;
+    let newest = orphans[0];
+    let newestMtime = 0;
+    for (const f of orphans) {
+        try {
+            const stat = fs.statSync(path.join(subagentsDir, f));
+            if (stat.mtimeMs > newestMtime) {
+                newestMtime = stat.mtimeMs;
+                newest = f;
+            }
+        }
+        catch { /* skip */ }
     }
+    startFileWatch(watcher, path.join(subagentsDir, newest));
+    return true;
 }
 /**
  * Start watching a specific JSONL file for new content
@@ -240,8 +261,17 @@ function watchDirectory(watcher) {
 function startFileWatch(watcher, filePath) {
     if (watcher.stopped)
         return;
+    // Binding done — the directory watcher is no longer needed.
+    watcher.dirWatcher?.close();
+    watcher.dirWatcher = undefined;
     watcher.jsonlPath = filePath;
-    log.log(`[Watcher] Found JSONL file: ${filePath} for toolUseId=${watcher.toolUseId}`);
+    log.log(`[Watcher] Found JSONL file: ${filePath} for toolUseId=${watcher.toolUseId}${watcher.startAtEnd ? ' (tail from EOF)' : ''}`);
+    if (watcher.startAtEnd) {
+        try {
+            watcher.readPosition = fs.statSync(filePath).size;
+        }
+        catch { /* file vanished — readNewLines will retry from 0 */ }
+    }
     // Read existing content
     readNewLines(watcher);
     // Start idle timer

package/dist/src/packages/server/websocket/handlers/agent-handler.js

@@ -910,6 +910,9 @@ export async function handleUpdateAgentProperties(ctx, payload) {
     if (updates.autoCollapseTz !== undefined) {
         agentUpdates.autoCollapseTz = updates.autoCollapseTz || undefined;
     }
+    if (updates.autoCollapsePrompt !== undefined) {
+        agentUpdates.autoCollapsePrompt = updates.autoCollapsePrompt || undefined;
+    }
     // Apply agent property updates if any
     // agentService.updateAgent tracks pending property changes for notification on next command
     if (Object.keys(agentUpdates).length > 0) {

package/dist/src/packages/server/websocket/listeners/runtime-listeners.js

@@ -6,7 +6,7 @@ import { parseAllFormats } from '../handlers/agent-handler.js';
 import { agentService, runtimeService } from '../../services/index.js';
 import { logger, formatToolActivity } from '../../utils/index.js';
 import { parseBossDelegation, parseBossSpawn, getBossForSubordinate, clearDelegation } from '../handlers/boss-response-handler.js';
-import { startWatching as startJsonlWatching, stopWatching as stopJsonlWatching, getSubagentsDir } from '../../services/subagent-jsonl-watcher.js';
+import { startWatching as startJsonlWatching, stopWatching as stopJsonlWatching, isWatching as isJsonlWatching, getSubagentsDir } from '../../services/subagent-jsonl-watcher.js';
 const log = logger.ws;
 const MAX_SYNTHETIC_DIFF_FILE_BYTES = 256 * 1024;
 function sanitizeParsedContextStats(stats) {
@@ -31,6 +31,38 @@ export function setupRuntimeListeners(ctx) {
     const bossAccumulatedText = new Map();
     // Track agents currently in compacting state so we can clear it when they resume
     const compactingAgents = new Set();
+    function armSubagentJsonlWatcher(agentId, toolUseId, options) {
+        const parentAgent = agentService.getAgent(agentId);
+        if (!parentAgent?.sessionId)
+            return;
+        const subagentsDir = getSubagentsDir(parentAgent.cwd, parentAgent.sessionId);
+        startJsonlWatching(toolUseId, agentId, subagentsDir, (watchedToolUseId, parentAgentId, entries) => {
+            ctx.broadcast({
+                type: 'subagent_stream',
+                payload: { toolUseId: watchedToolUseId, parentAgentId, entries },
+            });
+        }, (watchedToolUseId, parentAgentId, result) => {
+            // The parent CLI stream never echoes subagent tool_result events
+            // (only tool_use), so without this bridge the subagent Bash
+            // cards in the terminal keep their "running" spinner forever.
+            // Mirror the parent-agent behavior: only Bash results get a card.
+            if (result.toolName !== 'Bash')
+                return;
+            ctx.broadcast({
+                type: 'event',
+                payload: {
+                    agentId: parentAgentId,
+                    type: 'tool_result',
+                    toolName: 'Bash',
+                    toolOutput: result.output,
+                    parentToolUseId: watchedToolUseId,
+                    // Subagent-internal tool_use id — matches the uuid of the
+                    // corresponding tool_start card so the client pairs exactly.
+                    uuid: result.toolUseId,
+                },
+            });
+        }, options);
+    }
     runtimeService.on('event', (agentId, event) => {
         // Clear compacting state when agent resumes with new output after compaction
         if (compactingAgents.has(agentId) && event.type !== 'compacting') {
@@ -100,35 +132,7 @@ export function setupRuntimeListeners(ctx) {
                     ctx.sendActivity(agentId, `Spawned subagent: ${subagent.name} (${subagent.subagentType})`);
                     log.log(`[Subagent] Broadcast subagent_started: ${subagent.name} (${subagent.id})`);
                     // Start streaming JSONL file for this subagent
-                    if (parentAgent?.sessionId) {
-                        const subagentsDir = getSubagentsDir(parentAgent.cwd, parentAgent.sessionId);
-                        startJsonlWatching(event.toolUseId, agentId, subagentsDir, (toolUseId, parentAgentId, entries) => {
-                            ctx.broadcast({
-                                type: 'subagent_stream',
-                                payload: { toolUseId, parentAgentId, entries },
-                            });
-                        }, (toolUseId, parentAgentId, result) => {
-                            // The parent CLI stream never echoes subagent tool_result events
-                            // (only tool_use), so without this bridge the subagent Bash
-                            // cards in the terminal keep their "running" spinner forever.
-                            // Mirror the parent-agent behavior: only Bash results get a card.
-                            if (result.toolName !== 'Bash')
-                                return;
-                            ctx.broadcast({
-                                type: 'event',
-                                payload: {
-                                    agentId: parentAgentId,
-                                    type: 'tool_result',
-                                    toolName: 'Bash',
-                                    toolOutput: result.output,
-                                    parentToolUseId: toolUseId,
-                                    // Subagent-internal tool_use id — matches the uuid of the
-                                    // corresponding tool_start card so the client pairs exactly.
-                                    uuid: result.toolUseId,
-                                },
-                            });
-                        });
-                    }
+                    armSubagentJsonlWatcher(agentId, event.toolUseId);
                 }
             }
         }
@@ -171,6 +175,12 @@ export function setupRuntimeListeners(ctx) {
         }
         // Forward subagent internal tool activity to client (events with parentToolUseId)
         if (event.parentToolUseId && event.type === 'tool_start' && event.toolName !== 'Task' && event.toolName !== 'Agent') {
+            // Self-heal: if this subagent's watcher is gone (idle/max timeout hit,
+            // server restarted mid-run) or was never armed, re-arm it tailing from
+            // EOF so this tool's result can still resolve its card's spinner.
+            if (!isJsonlWatching(event.parentToolUseId)) {
+                armSubagentJsonlWatcher(agentId, event.parentToolUseId, { startAtEnd: true });
+            }
             const toolDesc = formatToolActivity(event.toolName, event.toolInput);
             ctx.broadcast({
                 type: 'subagent_output',

package/package.json

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