tide-commander 1.136.0 → 1.136.2

package/dist/src/packages/server/routes/files.js

@@ -274,6 +274,60 @@ function findBySuffixMatch(rawPath, walkRoot) {
     }
     return null;
 }
+// The suffix walk skips node_modules for cost, but locally linked / installed
+// packages (e.g. a monorepo's own `tide-api`) legitimately live there — so a
+// path like `tide-api/src/api-core.js` can only be found under a node_modules
+// tree. Instead of walking all of node_modules (huge), we locate WHERE the
+// node_modules dirs are (shallow — they sit at workspace roots, and we never
+// descend INTO one) and then probe the requested path's tail-slices under each.
+const NODE_MODULES_SCAN_MAX_DEPTH = 4;
+const NODE_MODULES_MAX_DIRS = 24;
+function collectNodeModulesDirs(base, depth, out) {
+    if (out.length >= NODE_MODULES_MAX_DIRS || depth > NODE_MODULES_SCAN_MAX_DEPTH)
+        return;
+    let entries;
+    try {
+        entries = fs.readdirSync(base, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const e of entries) {
+        if (!e.isDirectory())
+            continue;
+        if (e.name === 'node_modules') {
+            out.push(path.join(base, e.name));
+            if (out.length >= NODE_MODULES_MAX_DIRS)
+                return;
+            continue; // don't recurse into node_modules; tail-slice probing covers depth
+        }
+        if (e.name.startsWith('.') || SUFFIX_WALK_IGNORE.has(e.name))
+            continue;
+        collectNodeModulesDirs(path.join(base, e.name), depth + 1, out);
+        if (out.length >= NODE_MODULES_MAX_DIRS)
+            return;
+    }
+}
+// Probe the requested path (and each of its tail-slices) under every
+// node_modules dir found beneath `base`. Uses the shared tryCandidate so hits
+// are validated + recorded in `tried`. Returns the first existing file.
+function findInNodeModules(rawPath, base, tryCandidate) {
+    if (!fs.existsSync(base))
+        return null;
+    const segments = rawPath.replace(/^\/+/, '').split(path.sep).filter(Boolean);
+    if (segments.length === 0)
+        return null;
+    const dirs = [];
+    collectNodeModulesDirs(base, 0, dirs);
+    for (const nm of dirs) {
+        for (let i = 0; i < segments.length; i++) {
+            const hit = tryCandidate(path.join(nm, ...segments.slice(i)));
+            if (hit)
+                return hit;
+        }
+    }
+    return null;
+}
 /**
  * Resolve a requested file path to an existing file on disk, with fallbacks.
  * Tries (in order):
@@ -282,8 +336,10 @@ function findBySuffixMatch(rawPath, walkRoot) {
  *   3. parent-walk        — tail slices anchored at baseDir AND each ancestor up to /
  *   4. git-root           — tail slices anchored at the git toplevel from baseDir
  *   5. suffix-match       — depth-limited walk of baseDir, unique trailing-segment match
- *   6. area-root          — verbatim join against each user-configured area directory
- *   7. area-suffix-match  — same depth-limited walk but rooted at each area directory
+ *   6. node-modules-match — tail slices probed under each node_modules dir beneath baseDir
+ *   7. area-root          — verbatim join against each user-configured area directory
+ *   8. area-suffix-match  — same depth-limited walk but rooted at each area directory
+ *   9. node-modules-match — same node_modules probe but rooted at each area directory
  * On miss, returns the absolute path requested AND the list of paths tried so
  * the caller can surface a clear, debuggable error.
  */
@@ -295,6 +351,17 @@ export function findFileWithFallbacks(rawPath, baseDir) {
     if (!resolution.ok) {
         return resolution;
     }
+    // A path that resolves directly to an existing directory is a "browse this
+    // folder" request, not a missing file. Short-circuit here so we return a
+    // clear directory signal instead of running the whole fallback walk — which
+    // rejects the directory at every candidate (tryCandidate skips directories)
+    // and would surface dozens of futile "tried" locations before 404-ing.
+    try {
+        if (fs.existsSync(resolution.path) && fs.statSync(resolution.path).isDirectory()) {
+            return { ok: false, status: 400, error: 'Path is a directory', requested: resolution.path };
+        }
+    }
+    catch { /* stat failed (perms/broken symlink) — fall through to normal resolution */ }
     const tried = [];
     const seen = new Set();
     const tryCandidate = (p) => {
@@ -375,7 +442,18 @@ export function findFileWithFallbacks(rawPath, baseDir) {
                 }
             }
         }
-        catch { /* walk failed entirely — fall through to area strategies */ }
+        catch { /* walk failed entirely — fall through to node_modules/area strategies */ }
+        // node_modules-anchored: the suffix walk above skips node_modules, so a
+        // locally-linked package path (e.g. tide-api/src/api-core.js) is only
+        // reachable here.
+        try {
+            const nmHit = findInNodeModules(rawPath, absBase, tryCandidate);
+            if (nmHit) {
+                rememberResolution(rawPath, nmHit, 'node-modules-match');
+                return { ok: true, path: nmHit, strategy: 'node-modules-match' };
+            }
+        }
+        catch { /* scan failed — fall through to area strategies */ }
     }
     // Area strategies: try the user's configured area directories. Runs whether
     // or not baseDir is set — area paths are independent. Capped to keep cold
@@ -415,6 +493,20 @@ export function findFileWithFallbacks(rawPath, baseDir) {
         }
         catch { /* walk failed for this area — try next */ }
     }
+    // node_modules-anchored search within each area dir (same reasoning as the
+    // baseDir pass above: locally-linked packages under an area's node_modules).
+    for (const { areaId, areaName, dir } of areaDirs) {
+        if (!fs.existsSync(dir))
+            continue;
+        try {
+            const nmHit = findInNodeModules(rawPath, dir, tryCandidate);
+            if (nmHit) {
+                rememberResolution(rawPath, nmHit, 'node-modules-match');
+                return { ok: true, path: nmHit, strategy: 'node-modules-match', areaId, areaName };
+            }
+        }
+        catch { /* scan failed for this area — try next */ }
+    }
     return {
         ok: false,
         status: 404,
@@ -513,10 +605,10 @@ router.get('/resolve', async (req, res) => {
             }
             catch { /* skip */ }
         }
-        // Search for files matching the basename (searchFiles may re-find .claude/ files)
+        // Search for files matching the basename (searchFilesAsync may re-find .claude/ files)
         const existingPaths = new Set(results.map(r => r.path));
         const searchResults = [];
-        searchFiles(searchRoot, basename, searchResults, 20);
+        await searchFilesAsync(searchRoot, basename.toLowerCase(), searchResults, 20);
         for (const r of searchResults) {
             if (!existingPaths.has(r.path))
                 results.push(r);
@@ -993,43 +1085,61 @@ router.post('/paste', (req, res) => {
         res.status(500).json({ error: err.message });
     }
 });
-// Helper function to search files recursively
-function searchFiles(dirPath, query, results, maxResults, depth = 0) {
-    if (results.length >= maxResults || depth > 10)
+// Directories that are always skipped during file/content search. Kept as a
+// Set for O(1) lookups (this is checked once per directory entry during the
+// tree walk). Union of the old filename + content skip lists.
+const SEARCH_SKIP_DIRS = new Set([
+    'node_modules', 'dist', 'build', '.git', '__pycache__',
+    'venv', '.venv', 'target', 'vendor', '.next', '.cache',
+]);
+const MAX_SEARCH_DEPTH = 10;
+// Helper function to search files recursively (async / non-blocking).
+// Uses fs.promises so a deep tree walk never blocks the event loop, which
+// matters on a shared multi-agent server. `queryLower` must be pre-lowercased.
+async function searchFilesAsync(dirPath, queryLower, results, maxResults, depth = 0) {
+    if (results.length >= maxResults || depth > MAX_SEARCH_DEPTH)
         return;
+    let entries;
     try {
-        const entries = fs.readdirSync(dirPath, { withFileTypes: true });
-        for (const entry of entries) {
-            if (results.length >= maxResults)
-                break;
-            // Skip common non-essential directories
-            if (['node_modules', 'dist', '.git', '__pycache__', 'venv', '.venv'].includes(entry.name))
-                continue;
-            const fullPath = path.join(dirPath, entry.name);
-            // Check if name matches query (case-insensitive)
-            if (entry.name.toLowerCase().includes(query.toLowerCase())) {
-                try {
-                    const stats = fs.statSync(fullPath);
-                    results.push({
-                        name: entry.name,
-                        path: fullPath,
-                        isDirectory: entry.isDirectory(),
-                        size: stats.size,
-                        extension: entry.isDirectory() ? '' : path.extname(entry.name).toLowerCase(),
-                    });
-                }
-                catch {
-                    // Skip
-                }
+        entries = await fs.promises.readdir(dirPath, { withFileTypes: true });
+    }
+    catch {
+        return; // Skip directories we can't read
+    }
+    const subdirs = [];
+    for (const entry of entries) {
+        if (results.length >= maxResults)
+            break;
+        const isDir = entry.isDirectory();
+        // Skip common non-essential directories
+        if (isDir && SEARCH_SKIP_DIRS.has(entry.name))
+            continue;
+        const fullPath = path.join(dirPath, entry.name);
+        // Check if name matches query (case-insensitive)
+        if (entry.name.toLowerCase().includes(queryLower)) {
+            let size = 0;
+            try {
+                size = (await fs.promises.stat(fullPath)).size;
             }
-            // Recurse into directories
-            if (entry.isDirectory()) {
-                searchFiles(fullPath, query, results, maxResults, depth + 1);
+            catch {
+                // Keep size 0 if stat fails (broken symlink etc.) but still surface it
             }
+            results.push({
+                name: entry.name,
+                path: fullPath,
+                isDirectory: isDir,
+                size,
+                extension: isDir ? '' : path.extname(entry.name).toLowerCase(),
+            });
         }
+        if (isDir)
+            subdirs.push(fullPath);
     }
-    catch {
-        // Skip directories we can't read
+    // Recurse after listing this level so match/recurse order stays bounded.
+    for (const sub of subdirs) {
+        if (results.length >= maxResults)
+            break;
+        await searchFilesAsync(sub, queryLower, results, maxResults, depth + 1);
     }
 }
 // GET /api/files/search - Search for files
@@ -1051,7 +1161,7 @@ router.get('/search', async (req, res) => {
             return;
         }
         const results = [];
-        searchFiles(dirPath, query, results, maxResults);
+        await searchFilesAsync(dirPath, query.toLowerCase(), results, maxResults);
         // Sort: files first (more likely what user wants), then by name
         results.sort((a, b) => {
             if (a.isDirectory !== b.isDirectory) {
@@ -1077,67 +1187,155 @@ const TEXT_EXTENSIONS = new Set([
     '.editorconfig', '.prettierrc', '.eslintrc', '.babelrc',
     '.log', '.csv', '.tsv', '.svg', '.vue', '.svelte',
 ]);
-// Helper function to search file contents recursively
-function searchFileContents(dirPath, query, results, maxResults, depth = 0) {
-    if (results.length >= maxResults || depth > 10)
-        return;
-    try {
-        const entries = fs.readdirSync(dirPath, { withFileTypes: true });
-        const queryLower = query.toLowerCase();
-        for (const entry of entries) {
-            if (results.length >= maxResults)
-                break;
-            // Skip common non-essential directories
-            if (['node_modules', 'dist', 'build', '.git', '__pycache__', 'venv', '.venv', 'target', 'vendor'].includes(entry.name))
-                continue;
-            const fullPath = path.join(dirPath, entry.name);
-            if (entry.isDirectory()) {
-                // Recurse into directories
-                searchFileContents(fullPath, query, results, maxResults, depth + 1);
-            }
-            else {
-                // Check if it's a text file we can search
-                const ext = path.extname(entry.name).toLowerCase();
-                if (!TEXT_EXTENSIONS.has(ext) && ext !== '')
+// Max matches surfaced per file (both search paths respect this).
+const MAX_MATCHES_PER_FILE = 5;
+// Skip files larger than 1MB for content search.
+const MAX_CONTENT_FILE_SIZE = 1024 * 1024;
+// Primary content search: shell out to ripgrep. It runs off the event loop as
+// a child process (never blocking the server) and is orders of magnitude faster
+// than a JS tree walk. Resolves { ok:false } when rg is missing or errors, so
+// the caller can fall back to the pure-JS walker.
+function searchFileContentsRipgrep(dirPath, query, maxResults) {
+    return new Promise((resolve) => {
+        const args = [
+            '--json',
+            '--ignore-case',
+            '--fixed-strings', // treat the query as a literal substring
+            '--max-count', String(MAX_MATCHES_PER_FILE),
+            '--max-filesize', String(MAX_CONTENT_FILE_SIZE),
+            '--max-depth', String(MAX_SEARCH_DEPTH + 1),
+            '--hidden', // include dotfiles (.env, .github, ...)
+            '--no-ignore', // don't honor .gitignore (match old behavior)
+            '--no-messages', // suppress permission/binary warnings on stderr
+            ...[...SEARCH_SKIP_DIRS].flatMap((d) => ['--glob', `!**/${d}/**`]),
+            '--',
+            query,
+            dirPath,
+        ];
+        let child;
+        try {
+            child = spawn('rg', args, { stdio: ['ignore', 'pipe', 'pipe'] });
+        }
+        catch {
+            resolve({ ok: false, results: [] });
+            return;
+        }
+        const byFile = new Map();
+        let buffer = '';
+        let settled = false;
+        const finish = (ok) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve({ ok, results: [...byFile.values()] });
+        };
+        // Spawn failure (e.g. rg not installed) → fall back to the JS walker.
+        child.on('error', () => finish(false));
+        child.stdout?.setEncoding('utf-8');
+        child.stdout?.on('data', (chunk) => {
+            buffer += chunk;
+            let nl;
+            while ((nl = buffer.indexOf('\n')) !== -1) {
+                const line = buffer.slice(0, nl);
+                buffer = buffer.slice(nl + 1);
+                if (!line)
                     continue;
+                let evt;
                 try {
-                    const stats = fs.statSync(fullPath);
-                    // Skip files larger than 1MB
-                    if (stats.size > 1024 * 1024)
-                        continue;
-                    const content = fs.readFileSync(fullPath, 'utf-8');
-                    const lines = content.split('\n');
-                    const matches = [];
-                    for (let i = 0; i < lines.length && matches.length < 5; i++) {
-                        const line = lines[i];
-                        if (line.toLowerCase().includes(queryLower)) {
-                            matches.push({
-                                line: i + 1,
-                                content: line.slice(0, 200), // Truncate long lines
-                                context: {
-                                    before: i > 0 ? lines[i - 1].slice(0, 100) : '',
-                                    after: i < lines.length - 1 ? lines[i + 1].slice(0, 100) : '',
-                                },
-                            });
-                        }
-                    }
-                    if (matches.length > 0) {
-                        results.push({
-                            path: fullPath,
-                            name: entry.name,
-                            extension: ext,
-                            matches,
-                        });
-                    }
+                    evt = JSON.parse(line);
                 }
                 catch {
-                    // Skip files we can't read (binary, permission issues)
+                    continue;
+                }
+                if (evt.type !== 'match')
+                    continue;
+                const filePath = evt.data?.path?.text;
+                if (!filePath)
+                    continue;
+                let cm = byFile.get(filePath);
+                if (!cm) {
+                    // Cap the number of distinct files we track.
+                    if (byFile.size >= maxResults) {
+                        child.kill();
+                        break;
+                    }
+                    cm = {
+                        path: filePath,
+                        name: path.basename(filePath),
+                        extension: path.extname(filePath).toLowerCase(),
+                        matches: [],
+                    };
+                    byFile.set(filePath, cm);
                 }
+                if (cm.matches.length >= MAX_MATCHES_PER_FILE)
+                    continue;
+                const text = (evt.data?.lines?.text ?? '').replace(/\r?\n$/, '');
+                cm.matches.push({
+                    line: evt.data?.line_number ?? 0,
+                    content: text.slice(0, 200),
+                });
             }
-        }
+        });
+        // rg exit codes: 0 = matches, 1 = no matches, 2 = error. Only a real error
+        // (or a kill, code null) that produced nothing should trigger the fallback.
+        child.on('close', (code) => finish(!(code === 2 && byFile.size === 0)));
+    });
+}
+// Fallback content search (async / non-blocking) used only when ripgrep is
+// unavailable. Mirrors the old behavior but with fs.promises so it never
+// blocks the event loop.
+async function searchFileContentsAsync(dirPath, queryLower, results, maxResults, depth = 0) {
+    if (results.length >= maxResults || depth > MAX_SEARCH_DEPTH)
+        return;
+    let entries;
+    try {
+        entries = await fs.promises.readdir(dirPath, { withFileTypes: true });
     }
     catch {
-        // Skip directories we can't read
+        return; // Skip directories we can't read
+    }
+    const subdirs = [];
+    for (const entry of entries) {
+        if (results.length >= maxResults)
+            break;
+        if (entry.isDirectory()) {
+            if (!SEARCH_SKIP_DIRS.has(entry.name))
+                subdirs.push(path.join(dirPath, entry.name));
+            continue;
+        }
+        // Check if it's a text file we can search
+        const ext = path.extname(entry.name).toLowerCase();
+        if (!TEXT_EXTENSIONS.has(ext) && ext !== '')
+            continue;
+        const fullPath = path.join(dirPath, entry.name);
+        try {
+            const stats = await fs.promises.stat(fullPath);
+            if (stats.size > MAX_CONTENT_FILE_SIZE)
+                continue;
+            const content = await fs.promises.readFile(fullPath, 'utf-8');
+            const lines = content.split('\n');
+            const matches = [];
+            for (let i = 0; i < lines.length && matches.length < MAX_MATCHES_PER_FILE; i++) {
+                const line = lines[i];
+                if (line.toLowerCase().includes(queryLower)) {
+                    matches.push({
+                        line: i + 1,
+                        content: line.slice(0, 200), // Truncate long lines
+                    });
+                }
+            }
+            if (matches.length > 0) {
+                results.push({ path: fullPath, name: entry.name, extension: ext, matches });
+            }
+        }
+        catch {
+            // Skip files we can't read (binary, permission issues)
+        }
+    }
+    for (const sub of subdirs) {
+        if (results.length >= maxResults)
+            break;
+        await searchFileContentsAsync(sub, queryLower, results, maxResults, depth + 1);
     }
 }
 // GET /api/files/search-content - Search file contents
@@ -1162,8 +1360,15 @@ router.get('/search-content', async (req, res) => {
             res.status(404).json({ error: 'Directory not found' });
             return;
         }
-        const results = [];
-        searchFileContents(dirPath, query, results, maxResults);
+        let results = [];
+        const rg = await searchFileContentsRipgrep(dirPath, query, maxResults);
+        if (rg.ok) {
+            results = rg.results;
+        }
+        else {
+            // ripgrep unavailable — fall back to the pure-JS async walker.
+            await searchFileContentsAsync(dirPath, query.toLowerCase(), results, maxResults);
+        }
         res.json({ results });
     }
     catch (err) {

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;
 }