aicodeman 0.5.3 → 0.5.5

package/dist/respawn-controller.js

@@ -53,6 +53,7 @@ import { RespawnAdaptiveTiming } from './respawn-adaptive-timing.js';
 import { RespawnCycleMetricsTracker } from './respawn-metrics.js';
 import { calculateHealthScore, shouldSkipClear } from './respawn-health.js';
 import { AI_CHECK_MODEL, AI_IDLE_CHECK_MAX_CONTEXT, AI_PLAN_CHECK_MAX_CONTEXT, AI_IDLE_CHECK_TIMEOUT_MS, AI_IDLE_CHECK_COOLDOWN_MS, AI_PLAN_CHECK_TIMEOUT_MS, AI_PLAN_CHECK_COOLDOWN_MS, } from './config/ai-defaults.js';
+import { getErrorMessage, } from './types.js';
 // ========== Constants ==========
 // COMPLETION_TIME_PATTERN moved to ./respawn-patterns.ts
 /** Pre-filter: numbered option pattern for plan mode detection */
@@ -310,24 +311,27 @@ export class RespawnController extends EventEmitter {
                 c[field] = DEFAULT_CONFIG[field];
             }
         };
-        // Ensure timeouts are positive
-        validatePositiveTimeout('idleTimeoutMs');
-        validatePositiveTimeout('completionConfirmMs');
-        validatePositiveTimeout('noOutputTimeoutMs');
-        validatePositiveTimeout('autoAcceptDelayMs', true);
-        validatePositiveTimeout('interStepDelayMs');
+        const REQUIRED_TIMEOUT_FIELDS = [
+            'idleTimeoutMs',
+            'completionConfirmMs',
+            'noOutputTimeoutMs',
+            'interStepDelayMs',
+            'aiIdleCheckTimeoutMs',
+            'aiIdleCheckMaxContext',
+            'aiPlanCheckTimeoutMs',
+            'aiPlanCheckMaxContext',
+        ];
+        for (const field of REQUIRED_TIMEOUT_FIELDS) {
+            validatePositiveTimeout(field);
+        }
+        const ALLOW_ZERO_FIELDS = ['autoAcceptDelayMs', 'aiIdleCheckCooldownMs', 'aiPlanCheckCooldownMs'];
+        for (const field of ALLOW_ZERO_FIELDS) {
+            validatePositiveTimeout(field, true);
+        }
         // Ensure completion confirm doesn't exceed no-output timeout
         if (c.completionConfirmMs > c.noOutputTimeoutMs) {
             c.completionConfirmMs = c.noOutputTimeoutMs;
         }
-        // Ensure AI check timeouts are positive
-        validatePositiveTimeout('aiIdleCheckTimeoutMs');
-        validatePositiveTimeout('aiIdleCheckCooldownMs', true);
-        validatePositiveTimeout('aiIdleCheckMaxContext');
-        // Ensure plan check timeouts are positive
-        validatePositiveTimeout('aiPlanCheckTimeoutMs');
-        validatePositiveTimeout('aiPlanCheckCooldownMs', true);
-        validatePositiveTimeout('aiPlanCheckMaxContext');
     }
     /** Wire up AI checker events to controller events (removes existing listeners first to prevent duplicates) */
     setupAiCheckerListeners() {
@@ -796,88 +800,13 @@ export class RespawnController extends EventEmitter {
             this.lastTokenCount = tokenCount;
             this.lastTokenChangeTime = now;
         }
-        // Detect completion message FIRST (Layer 1) - PRIMARY DETECTION
-        // Check this before working patterns because completion message indicates
-        // the work is done, even if working patterns are still in the rolling window
-        if (isCompletionMessage(data)) {
-            // Clear the rolling window - completion marks a transition point
-            this.clearWorkingPatternWindow();
-            this.workingDetected = false;
-            this.completionMessageTime = now;
-            this.cancelAutoAcceptTimer(); // Normal idle flow handles this
-            this.log(`Completion message detected: "${data.trim().substring(0, 50)}..."`);
-            // In watching state, start completion confirmation timer
-            if (this._state === 'watching') {
-                this.startCompletionConfirmTimer();
-                return;
-            }
-            // In waiting states, also use confirmation timer (same detection logic)
-            // This ensures we wait for Claude to finish before proceeding
-            // Note: 'watching' is already handled above and returns early
-            switch (this._state) {
-                case 'waiting_update':
-                    this.startStepConfirmTimer('update');
-                    break;
-                case 'waiting_clear':
-                    this.checkClearComplete(); // /clear is quick, no need to wait
-                    break;
-                case 'waiting_init':
-                    this.startStepConfirmTimer('init');
-                    break;
-                case 'waiting_kickstart':
-                    this.startStepConfirmTimer('kickstart');
-                    break;
-                // Non-waiting states: completion message is ignored
-                case 'confirming_idle':
-                case 'ai_checking':
-                case 'sending_update':
-                case 'sending_clear':
-                case 'sending_init':
-                case 'monitoring_init':
-                case 'sending_kickstart':
-                case 'stopped':
-                    // Completion message during these states is ignored
-                    break;
-                default:
-                    assertNever(this._state, `Unhandled RespawnState in completion detection: ${this._state}`);
-            }
+        // Layer 1: Completion message (PRIMARY) — checked before working patterns
+        if (this._detectCompletionMessage(data, now))
             return;
-        }
-        // Detect working patterns (Layer 4)
-        const isWorking = this.checkWorkingPattern(data);
-        if (isWorking) {
-            this.workingDetected = true;
-            this.promptDetected = false;
-            this.elicitationDetected = false; // Clear on new work cycle
-            this.resetHookState(); // Clear hook signals on new work
-            this.lastWorkingPatternTime = now;
-            // Cancel hook confirmation timer if running
-            this.cancelTrackedTimer('hook-confirm', 'working patterns detected');
-            // Cancel any pending completion confirmation
-            this.cancelCompletionConfirm();
-            // Cancel any pending step confirmation (Claude is still working)
-            this.cancelStepConfirm();
-            // If AI check is running, cancel it (Claude is working)
-            if (this._state === 'ai_checking') {
-                this.log('Working patterns detected during AI check, cancelling');
-                this.aiChecker.cancel();
-                this.setState('watching');
-            }
-            // Cancel plan check if running (Claude started working)
-            if (this.planChecker.status === 'checking') {
-                this.log('Working patterns detected during plan check, cancelling');
-                this.planChecker.cancel();
-            }
-            // If we're monitoring init and work started, go to watching (no kickstart needed)
-            if (this._state === 'monitoring_init') {
-                this.log('/init triggered work, skipping kickstart');
-                this.emit('stepCompleted', 'init');
-                this.completeCycle();
-            }
+        // Layer 4: Working patterns
+        if (this._detectWorkingPattern(data, now))
             return;
-        }
-        // In confirming_idle or ai_checking state, substantial output cancels the flow.
-        // This prevents false triggers when Claude pauses briefly mid-work.
+        // Substantial output during confirming_idle/ai_checking cancels the flow
         if (this._state === 'confirming_idle' || this._state === 'ai_checking') {
             // Strip ANSI escape codes to check if there's real content
             ANSI_ESCAPE_PATTERN_SIMPLE.lastIndex = 0;
@@ -896,42 +825,125 @@ export class RespawnController extends EventEmitter {
                 return;
             }
         }
-        // Legacy fallback: detect prompt characters (still useful for waiting_* states)
+        // Legacy fallback: prompt detection
+        this._detectPrompt(data);
+    }
+    _detectCompletionMessage(data, now) {
+        if (!isCompletionMessage(data))
+            return false;
+        // Clear the rolling window - completion marks a transition point
+        this.clearWorkingPatternWindow();
+        this.workingDetected = false;
+        this.completionMessageTime = now;
+        this.cancelAutoAcceptTimer(); // Normal idle flow handles this
+        this.log(`Completion message detected: "${data.trim().substring(0, 50)}..."`);
+        // In watching state, start completion confirmation timer
+        if (this._state === 'watching') {
+            this.startCompletionConfirmTimer();
+            return true;
+        }
+        // In waiting states, also use confirmation timer (same detection logic)
+        // This ensures we wait for Claude to finish before proceeding
+        // Note: 'watching' is already handled above and returns early
+        switch (this._state) {
+            case 'waiting_update':
+                this.startStepConfirmTimer('update');
+                break;
+            case 'waiting_clear':
+                this.checkClearComplete(); // /clear is quick, no need to wait
+                break;
+            case 'waiting_init':
+                this.startStepConfirmTimer('init');
+                break;
+            case 'waiting_kickstart':
+                this.startStepConfirmTimer('kickstart');
+                break;
+            // Non-waiting states: completion message is ignored
+            case 'confirming_idle':
+            case 'ai_checking':
+            case 'sending_update':
+            case 'sending_clear':
+            case 'sending_init':
+            case 'monitoring_init':
+            case 'sending_kickstart':
+            case 'stopped':
+                // Completion message during these states is ignored
+                break;
+            default:
+                assertNever(this._state, `Unhandled RespawnState in completion detection: ${this._state}`);
+        }
+        return true;
+    }
+    _detectWorkingPattern(data, now) {
+        const isWorking = this.checkWorkingPattern(data);
+        if (!isWorking)
+            return false;
+        this.workingDetected = true;
+        this.promptDetected = false;
+        this.elicitationDetected = false; // Clear on new work cycle
+        this.resetHookState(); // Clear hook signals on new work
+        this.lastWorkingPatternTime = now;
+        // Cancel hook confirmation timer if running
+        this.cancelTrackedTimer('hook-confirm', 'working patterns detected');
+        // Cancel any pending completion confirmation
+        this.cancelCompletionConfirm();
+        // Cancel any pending step confirmation (Claude is still working)
+        this.cancelStepConfirm();
+        // If AI check is running, cancel it (Claude is working)
+        if (this._state === 'ai_checking') {
+            this.log('Working patterns detected during AI check, cancelling');
+            this.aiChecker.cancel();
+            this.setState('watching');
+        }
+        // Cancel plan check if running (Claude started working)
+        if (this.planChecker.status === 'checking') {
+            this.log('Working patterns detected during plan check, cancelling');
+            this.planChecker.cancel();
+        }
+        // If we're monitoring init and work started, go to watching (no kickstart needed)
+        if (this._state === 'monitoring_init') {
+            this.log('/init triggered work, skipping kickstart');
+            this.emit('stepCompleted', 'init');
+            this.completeCycle();
+        }
+        return true;
+    }
+    _detectPrompt(data) {
         const hasPrompt = PROMPT_PATTERNS.some((pattern) => data.includes(pattern));
-        if (hasPrompt) {
-            this.promptDetected = true;
-            this.workingDetected = false;
-            // Handle legacy detection in waiting states - also use confirmation timers
-            switch (this._state) {
-                case 'waiting_update':
-                    this.startStepConfirmTimer('update');
-                    break;
-                case 'waiting_clear':
-                    this.checkClearComplete(); // /clear is quick, no need to wait
-                    break;
-                case 'waiting_init':
-                    this.startStepConfirmTimer('init');
-                    break;
-                case 'monitoring_init':
-                    this.checkMonitoringInitIdle();
-                    break;
-                case 'waiting_kickstart':
-                    this.startStepConfirmTimer('kickstart');
-                    break;
-                // Non-waiting states: prompt detection is informational only
-                case 'watching':
-                case 'confirming_idle':
-                case 'ai_checking':
-                case 'sending_update':
-                case 'sending_clear':
-                case 'sending_init':
-                case 'sending_kickstart':
-                case 'stopped':
-                    // Prompt detection during these states doesn't trigger action
-                    break;
-                default:
-                    assertNever(this._state, `Unhandled RespawnState in prompt detection: ${this._state}`);
-            }
+        if (!hasPrompt)
+            return;
+        this.promptDetected = true;
+        this.workingDetected = false;
+        // Handle legacy detection in waiting states - also use confirmation timers
+        switch (this._state) {
+            case 'waiting_update':
+                this.startStepConfirmTimer('update');
+                break;
+            case 'waiting_clear':
+                this.checkClearComplete(); // /clear is quick, no need to wait
+                break;
+            case 'waiting_init':
+                this.startStepConfirmTimer('init');
+                break;
+            case 'monitoring_init':
+                this.checkMonitoringInitIdle();
+                break;
+            case 'waiting_kickstart':
+                this.startStepConfirmTimer('kickstart');
+                break;
+            // Non-waiting states: prompt detection is informational only
+            case 'watching':
+            case 'confirming_idle':
+            case 'ai_checking':
+            case 'sending_update':
+            case 'sending_clear':
+            case 'sending_init':
+            case 'sending_kickstart':
+            case 'stopped':
+                // Prompt detection during these states doesn't trigger action
+                break;
+            default:
+                assertNever(this._state, `Unhandled RespawnState in prompt detection: ${this._state}`);
         }
     }
     /**
@@ -1375,6 +1387,17 @@ export class RespawnController extends EventEmitter {
             this.logAction('detection', 'Skipped AI check: Session is working');
             return;
         }
+        // Check for active child processes (bash tools, test suites, builds, etc.)
+        // These may produce no terminal output, so restart timers to retry periodically.
+        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})`);
+            this.startNoOutputTimer();
+            this.startPreFilterTimer();
+            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}`);
@@ -1459,7 +1482,7 @@ export class RespawnController extends EventEmitter {
             if (this._state === 'stopped')
                 return; // Guard against stopped state
             if (this._state === 'ai_checking') {
-                const errorMsg = err instanceof Error ? err.message : String(err);
+                const errorMsg = getErrorMessage(err);
                 this.logAction('ai-check', `Failed: ${errorMsg.substring(0, 50)}`);
                 this.emit('aiCheckFailed', errorMsg);
                 this.setState('watching');
@@ -1637,7 +1660,7 @@ export class RespawnController extends EventEmitter {
             }
         })
             .catch((err) => {
-            const errorMsg = err instanceof Error ? err.message : String(err);
+            const errorMsg = getErrorMessage(err);
             this.emit('planCheckFailed', errorMsg);
             this.logAction('plan-check', `Failed: ${errorMsg.substring(0, 50)}`);
         });
@@ -1899,6 +1922,17 @@ export class RespawnController extends EventEmitter {
             this.startPreFilterTimer();
             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(`Detection status: confidence=${status.confidenceLevel}%, ` +