feat: detect active child processes to prevent false idle during running tools

When Claude Code spawns bash tools (test suites, builds, servers), the
respawn controller could falsely detect idle if terminal output paused.
Now checks the process tree for active children of the Claude process
before triggering AI idle checks or confirming idle state.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

src/respawn-controller.ts

@@ -2078,6 +2078,15 @@ export class RespawnController extends EventEmitter {
       return;
     }
 
+    // Check for active child processes (bash tools, test suites, builds, etc.)
+    const activeProcesses = this.session.getActiveChildProcesses();
+    if (activeProcesses.length > 0) {
+      const names = activeProcesses.map((p) => p.command).join(', ');
+      this.log(`Skipping AI check - ${activeProcesses.length} active child process(es): ${names}`);
+      this.logAction('detection', `Skipped AI check: child processes running (${names})`);
+      return;
+    }
+
     // If AI check is disabled or errored out, fall back to direct idle confirmation
     if (!this.config.aiIdleCheckEnabled || this.aiChecker.status === 'disabled') {
       this.log(`AI check unavailable (${this.aiChecker.status}), confirming idle directly via: ${reason}`);
@@ -2682,6 +2691,18 @@ export class RespawnController extends EventEmitter {
       return;
     }
 
+    // Safety check: if child processes are running (bash tools, test suites, builds, etc.)
+    const activeProcesses = this.session.getActiveChildProcesses();
+    if (activeProcesses.length > 0) {
+      const names = activeProcesses.map((p) => p.command).join(', ');
+      this.log(`Idle confirmation rejected - ${activeProcesses.length} active child process(es): ${names}`);
+      this.logAction('detection', `Rejected: child processes running (${names})`);
+      this.setState('watching');
+      this.startNoOutputTimer();
+      this.startPreFilterTimer();
+      return;
+    }
+
     this.log(`Idle confirmed via: ${reason}`);
     const status = this.getDetectionStatus();
     this.log(

src/session.ts

@@ -29,6 +29,7 @@
  */
 
 import { EventEmitter } from 'node:events';
+import { execSync } from 'node:child_process';
 import { v4 as uuidv4 } from 'uuid';
 import * as pty from 'node-pty';
 import {
@@ -65,6 +66,7 @@ import {
   MAX_MESSAGES,
   MAX_LINE_BUFFER_SIZE,
 } from './config/buffer-limits.js';
+import { EXEC_TIMEOUT_MS } from './config/exec-timeout.js';
 import {
   buildInteractiveArgs,
   buildPromptArgs,
@@ -539,6 +541,77 @@ export class Session extends EventEmitter {
     return this._isWorking;
   }
 
+  /**
+   * Check if the Claude CLI process inside this session's tmux pane has active child processes.
+   * This detects running bash tools, test suites, builds, servers, etc. that Claude spawned.
+   *
+   * Returns an array of {pid, command} for each child process, or empty array if none.
+   * Returns empty array if no mux session or on error (fail-open to avoid blocking respawn).
+   */
+  getActiveChildProcesses(): { pid: number; command: string }[] {
+    if (!this._muxSession) return [];
+
+    try {
+      // Get direct children of the pane PID (typically just the claude process)
+      const panePid = this._muxSession.pid;
+      const claudeChildren = execSync(`pgrep -P ${panePid}`, {
+        encoding: 'utf-8',
+        timeout: EXEC_TIMEOUT_MS,
+      }).trim();
+      if (!claudeChildren) return [];
+
+      const claudePids = claudeChildren
+        .split('\n')
+        .map((p) => parseInt(p, 10))
+        .filter((p) => !Number.isNaN(p));
+
+      // For each Claude process, check for its children (the actual running tools/processes)
+      const activeProcesses: { pid: number; command: string }[] = [];
+      for (const claudePid of claudePids) {
+        try {
+          const toolChildren = execSync(`pgrep -P ${claudePid}`, {
+            encoding: 'utf-8',
+            timeout: EXEC_TIMEOUT_MS,
+          }).trim();
+          if (!toolChildren) continue;
+
+          const toolPids = toolChildren
+            .split('\n')
+            .map((p) => parseInt(p, 10))
+            .filter((p) => !Number.isNaN(p));
+
+          if (toolPids.length === 0) continue;
+
+          // Get command names for the child processes in a single ps call
+          try {
+            const psOutput = execSync(`ps -o pid=,comm= -p ${toolPids.join(',')} 2>/dev/null`, {
+              encoding: 'utf-8',
+              timeout: EXEC_TIMEOUT_MS,
+            }).trim();
+            for (const line of psOutput.split('\n')) {
+              const match = line.trim().match(/^(\d+)\s+(.+)/);
+              if (match) {
+                activeProcesses.push({ pid: parseInt(match[1], 10), command: match[2].trim() });
+              }
+            }
+          } catch {
+            // ps failed — just record PIDs without command names
+            for (const pid of toolPids) {
+              activeProcesses.push({ pid, command: 'unknown' });
+            }
+          }
+        } catch {
+          // No children for this Claude process
+        }
+      }
+
+      return activeProcesses;
+    } catch {
+      // pgrep fails with exit code 1 when no matches — that's normal (no children)
+      return [];
+    }
+  }
+
   get lastPromptTime(): number {
     return this._lastPromptTime;
   }