chore: bump version to 0.1491

test/ai-idle-checker.test.ts

@@ -163,7 +163,7 @@ describe('AiIdleChecker', () => {
 
       // First call should try to kill existing screen
       expect(mockedExecSync).toHaveBeenCalledWith(
-        expect.stringContaining('screen -X -S claudeman-aicheck-'),
+        expect.stringContaining('screen -X -S "claudeman-aicheck-'),
         expect.any(Object)
       );
     });

test/hooks-config.test.ts

@@ -371,7 +371,7 @@ describe('Hook Event API', () => {
       });
       const data = await res.json();
       expect(data.success).toBe(false);
-      expect(data.errorCode).toBe('NOT_FOUND');
+      expect(data.errorCode).toBe('INVALID_INPUT');
     });
   });
 });

test/integration-flows.test.ts

@@ -68,7 +68,7 @@ describe('Integration Flows', () => {
 
       expect(sessionData.id).toBe(quickStartData.sessionId);
       expect(sessionData.workingDir).toContain(caseName);
-      expect(sessionData.status).toBe('busy'); // Interactive sessions are 'busy'
+      expect(['busy', 'idle', 'running']).toContain(sessionData.status); // May transition quickly in test mode
 
       // Step 3: Verify case was created with CLAUDE.md
       const caseRes = await fetch(`${baseUrl}/api/cases/${caseName}`);
@@ -128,7 +128,7 @@ describe('Integration Flows', () => {
       const sessionRes = await fetch(`${baseUrl}/api/sessions`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ workingDir: caseData.case.path }),
+        body: JSON.stringify({ workingDir: caseData.data.case.path }),
       });
       const sessionData = await sessionRes.json();
       expect(sessionData.success).toBe(true);
@@ -144,7 +144,7 @@ describe('Integration Flows', () => {
       // Verify session state
       const verifyRes = await fetch(`${baseUrl}/api/sessions/${sessionData.session.id}`);
       const verifyData = await verifyRes.json();
-      expect(verifyData.status).toBe('busy');
+      expect(['busy', 'idle', 'running']).toContain(verifyData.status);
       expect(verifyData.workingDir).toContain(caseName);
     });
   });

test/quick-start.test.ts

@@ -242,7 +242,7 @@ describe('Case Management', () => {
       const data = await response.json();
 
       expect(data.success).toBe(true);
-      expect(data.case.name).toBe(testCaseName);
+      expect(data.data.case.name).toBe(testCaseName);
     });
 
     it('should reject duplicate case names', async () => {

test/ralph-integration.test.ts

@@ -221,7 +221,7 @@ describe('Ralph Integration Tests', () => {
 
       expect(res.status).toBe(200);
       expect(data.success).toBe(true);
-      expect(data.case.name).toBe(caseName);
+      expect(data.data.case.name).toBe(caseName);
     });
 
     it('should reject duplicate case name', async () => {

test/ralph-tracker.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
 import { RalphTracker } from '../src/ralph-tracker.js';
-import { RalphTrackerState, RalphTodoItem } from '../src/types.js';
+import { RalphTrackerState, RalphTodoItem, RalphStatusBlock, CircuitBreakerStatus } from '../src/types.js';
 
 /**
  * RalphTracker Tests
@@ -649,13 +649,13 @@ describe('RalphTracker', () => {
   });
 
   describe('Maximum Todo Limit', () => {
-    it('should limit to max 50 todos', () => {
-      // Add 55 todos
-      for (let i = 0; i < 55; i++) {
+    it('should limit to max 500 todos', () => {
+      // Add 505 todos
+      for (let i = 0; i < 505; i++) {
         tracker.processTerminalData(`- [ ] Task ${i}\n`);
       }
 
-      expect(tracker.todos.length).toBeLessThanOrEqual(50);
+      expect(tracker.todos.length).toBeLessThanOrEqual(500);
     });
   });
 
@@ -1291,4 +1291,507 @@ Final text
       });
     });
   });
+
+  // ========== NEW TEST SUITES: RALPH_STATUS, Circuit Breaker, Exit Gate, Priority ==========
+
+  describe('RALPH_STATUS Block Parsing', () => {
+    /**
+     * Helper to feed a complete RALPH_STATUS block via processTerminalData.
+     * Lines are joined with newlines and wrapped with start/end markers.
+     */
+    function feedStatusBlock(tracker: RalphTracker, fields: string[]): void {
+      const block = [
+        '---RALPH_STATUS---',
+        ...fields,
+        '---END_RALPH_STATUS---',
+      ].join('\n') + '\n';
+      tracker.processTerminalData(block);
+    }
+
+    it('should parse a valid status block with all 7 fields', () => {
+      const handler = vi.fn();
+      tracker.on('statusBlockDetected', handler);
+
+      feedStatusBlock(tracker, [
+        'STATUS: IN_PROGRESS',
+        'TASKS_COMPLETED_THIS_LOOP: 3',
+        'FILES_MODIFIED: 7',
+        'TESTS_STATUS: PASSING',
+        'WORK_TYPE: IMPLEMENTATION',
+        'EXIT_SIGNAL: false',
+        'RECOMMENDATION: Continue working on feature X',
+      ]);
+
+      expect(handler).toHaveBeenCalledTimes(1);
+      const block: RalphStatusBlock = handler.mock.calls[0][0];
+      expect(block.status).toBe('IN_PROGRESS');
+      expect(block.tasksCompletedThisLoop).toBe(3);
+      expect(block.filesModified).toBe(7);
+      expect(block.testsStatus).toBe('PASSING');
+      expect(block.workType).toBe('IMPLEMENTATION');
+      expect(block.exitSignal).toBe(false);
+      expect(block.recommendation).toBe('Continue working on feature X');
+      expect(block.parsedAt).toBeGreaterThan(0);
+    });
+
+    it('should parse block with missing optional fields using defaults', () => {
+      const handler = vi.fn();
+      tracker.on('statusBlockDetected', handler);
+
+      // Only provide the required STATUS field
+      feedStatusBlock(tracker, [
+        'STATUS: COMPLETE',
+      ]);
+
+      expect(handler).toHaveBeenCalledTimes(1);
+      const block: RalphStatusBlock = handler.mock.calls[0][0];
+      expect(block.status).toBe('COMPLETE');
+      expect(block.tasksCompletedThisLoop).toBe(0);
+      expect(block.filesModified).toBe(0);
+      expect(block.testsStatus).toBe('NOT_RUN');
+      expect(block.workType).toBe('IMPLEMENTATION');
+      expect(block.exitSignal).toBe(false);
+      expect(block.recommendation).toBe('');
+    });
+
+    it('should ignore malformed block without END marker', () => {
+      const handler = vi.fn();
+      tracker.on('statusBlockDetected', handler);
+
+      // No ---END_RALPH_STATUS--- marker
+      tracker.processTerminalData(
+        '---RALPH_STATUS---\n' +
+        'STATUS: IN_PROGRESS\n' +
+        'TASKS_COMPLETED_THIS_LOOP: 5\n' +
+        'Some other text\n'
+      );
+
+      expect(handler).not.toHaveBeenCalled();
+    });
+
+    it('should skip block missing required STATUS field', () => {
+      const handler = vi.fn();
+      tracker.on('statusBlockDetected', handler);
+
+      // Block with no STATUS field
+      feedStatusBlock(tracker, [
+        'TASKS_COMPLETED_THIS_LOOP: 5',
+        'FILES_MODIFIED: 2',
+      ]);
+
+      expect(handler).not.toHaveBeenCalled();
+    });
+
+    it('should handle multiple blocks in sequence (latest wins for lastStatusBlock)', () => {
+      const handler = vi.fn();
+      tracker.on('statusBlockDetected', handler);
+
+      feedStatusBlock(tracker, [
+        'STATUS: IN_PROGRESS',
+        'FILES_MODIFIED: 1',
+      ]);
+
+      feedStatusBlock(tracker, [
+        'STATUS: COMPLETE',
+        'FILES_MODIFIED: 10',
+        'EXIT_SIGNAL: true',
+      ]);
+
+      expect(handler).toHaveBeenCalledTimes(2);
+
+      // lastStatusBlock should be the second one
+      const last = tracker.lastStatusBlock;
+      expect(last).not.toBeNull();
+      expect(last!.status).toBe('COMPLETE');
+      expect(last!.filesModified).toBe(10);
+      expect(last!.exitSignal).toBe(true);
+    });
+
+    it('should parse case-insensitive field values', () => {
+      const handler = vi.fn();
+      tracker.on('statusBlockDetected', handler);
+
+      feedStatusBlock(tracker, [
+        'STATUS: in_progress',
+        'TESTS_STATUS: failing',
+        'WORK_TYPE: testing',
+        'EXIT_SIGNAL: True',
+      ]);
+
+      expect(handler).toHaveBeenCalledTimes(1);
+      const block: RalphStatusBlock = handler.mock.calls[0][0];
+      expect(block.status).toBe('IN_PROGRESS');
+      expect(block.testsStatus).toBe('FAILING');
+      expect(block.workType).toBe('TESTING');
+      expect(block.exitSignal).toBe(true);
+    });
+
+    it('should update cumulative stats across multiple blocks', () => {
+      feedStatusBlock(tracker, [
+        'STATUS: IN_PROGRESS',
+        'FILES_MODIFIED: 3',
+        'TASKS_COMPLETED_THIS_LOOP: 2',
+      ]);
+
+      feedStatusBlock(tracker, [
+        'STATUS: IN_PROGRESS',
+        'FILES_MODIFIED: 5',
+        'TASKS_COMPLETED_THIS_LOOP: 1',
+      ]);
+
+      const stats = tracker.cumulativeStats;
+      expect(stats.filesModified).toBe(8);
+      expect(stats.tasksCompleted).toBe(3);
+    });
+
+    it('should parse BLOCKED status', () => {
+      const handler = vi.fn();
+      tracker.on('statusBlockDetected', handler);
+
+      feedStatusBlock(tracker, [
+        'STATUS: BLOCKED',
+        'RECOMMENDATION: Need human review of failing tests',
+      ]);
+
+      expect(handler).toHaveBeenCalledTimes(1);
+      const block: RalphStatusBlock = handler.mock.calls[0][0];
+      expect(block.status).toBe('BLOCKED');
+      expect(block.recommendation).toBe('Need human review of failing tests');
+    });
+  });
+
+  describe('Circuit Breaker State Transitions', () => {
+    /**
+     * Helper to feed a status block with specific progress/test values.
+     */
+    function feedStatusBlock(tracker: RalphTracker, opts: {
+      filesModified?: number;
+      tasksCompleted?: number;
+      testsStatus?: string;
+      status?: string;
+    }): void {
+      const fields = [
+        `STATUS: ${opts.status ?? 'IN_PROGRESS'}`,
+        `FILES_MODIFIED: ${opts.filesModified ?? 0}`,
+        `TASKS_COMPLETED_THIS_LOOP: ${opts.tasksCompleted ?? 0}`,
+      ];
+      if (opts.testsStatus) {
+        fields.push(`TESTS_STATUS: ${opts.testsStatus}`);
+      }
+      const block = [
+        '---RALPH_STATUS---',
+        ...fields,
+        '---END_RALPH_STATUS---',
+      ].join('\n') + '\n';
+      tracker.processTerminalData(block);
+    }
+
+    it('should start in CLOSED state', () => {
+      expect(tracker.circuitBreakerStatus.state).toBe('CLOSED');
+    });
+
+    it('should transition CLOSED → HALF_OPEN on 2 consecutive no-progress', () => {
+      const handler = vi.fn();
+      tracker.on('circuitBreakerUpdate', handler);
+
+      // 2 iterations with no progress (filesModified=0, tasksCompleted=0)
+      feedStatusBlock(tracker, { filesModified: 0, tasksCompleted: 0 });
+      feedStatusBlock(tracker, { filesModified: 0, tasksCompleted: 0 });
+
+      expect(tracker.circuitBreakerStatus.state).toBe('HALF_OPEN');
+      expect(handler).toHaveBeenCalled();
+      const status: CircuitBreakerStatus = handler.mock.calls[handler.mock.calls.length - 1][0];
+      expect(status.state).toBe('HALF_OPEN');
+      expect(status.reasonCode).toBe('no_progress_warning');
+    });
+
+    it('should transition CLOSED → OPEN on 3 consecutive no-progress', () => {
+      const handler = vi.fn();
+      tracker.on('circuitBreakerUpdate', handler);
+
+      feedStatusBlock(tracker, { filesModified: 0, tasksCompleted: 0 });
+      feedStatusBlock(tracker, { filesModified: 0, tasksCompleted: 0 });
+      feedStatusBlock(tracker, { filesModified: 0, tasksCompleted: 0 });
+
+      expect(tracker.circuitBreakerStatus.state).toBe('OPEN');
+      expect(tracker.circuitBreakerStatus.reasonCode).toBe('no_progress_open');
+    });
+
+    it('should transition HALF_OPEN → CLOSED when progress detected', () => {
+      const handler = vi.fn();
+      tracker.on('circuitBreakerUpdate', handler);
+
+      // Get to HALF_OPEN (2 no-progress)
+      feedStatusBlock(tracker, { filesModified: 0, tasksCompleted: 0 });
+      feedStatusBlock(tracker, { filesModified: 0, tasksCompleted: 0 });
+      expect(tracker.circuitBreakerStatus.state).toBe('HALF_OPEN');
+
+      // Progress detected → should close circuit
+      feedStatusBlock(tracker, { filesModified: 3, tasksCompleted: 1 });
+      expect(tracker.circuitBreakerStatus.state).toBe('CLOSED');
+      expect(tracker.circuitBreakerStatus.reasonCode).toBe('progress_detected');
+    });
+
+    it('should transition HALF_OPEN → OPEN on continued no-progress', () => {
+      // Get to HALF_OPEN
+      feedStatusBlock(tracker, { filesModified: 0, tasksCompleted: 0 });
+      feedStatusBlock(tracker, { filesModified: 0, tasksCompleted: 0 });
+      expect(tracker.circuitBreakerStatus.state).toBe('HALF_OPEN');
+
+      // One more no-progress → OPEN (consecutiveNoProgress now 3)
+      feedStatusBlock(tracker, { filesModified: 0, tasksCompleted: 0 });
+      expect(tracker.circuitBreakerStatus.state).toBe('OPEN');
+    });
+
+    it('should reset from OPEN → CLOSED via resetCircuitBreaker()', () => {
+      const handler = vi.fn();
+      tracker.on('circuitBreakerUpdate', handler);
+
+      // Get to OPEN
+      feedStatusBlock(tracker, { filesModified: 0, tasksCompleted: 0 });
+      feedStatusBlock(tracker, { filesModified: 0, tasksCompleted: 0 });
+      feedStatusBlock(tracker, { filesModified: 0, tasksCompleted: 0 });
+      expect(tracker.circuitBreakerStatus.state).toBe('OPEN');
+
+      tracker.resetCircuitBreaker();
+
+      expect(tracker.circuitBreakerStatus.state).toBe('CLOSED');
+      expect(tracker.circuitBreakerStatus.reasonCode).toBe('manual_reset');
+      expect(tracker.circuitBreakerStatus.reason).toBe('Manual reset');
+    });
+
+    it('should open on 5 consecutive test failures', () => {
+      for (let i = 0; i < 5; i++) {
+        feedStatusBlock(tracker, { filesModified: 1, tasksCompleted: 0, testsStatus: 'FAILING' });
+      }
+
+      expect(tracker.circuitBreakerStatus.state).toBe('OPEN');
+      expect(tracker.circuitBreakerStatus.reasonCode).toBe('tests_failing_too_long');
+    });
+
+    it('should reset test failure count when tests pass', () => {
+      // 4 failing iterations
+      for (let i = 0; i < 4; i++) {
+        feedStatusBlock(tracker, { filesModified: 1, tasksCompleted: 0, testsStatus: 'FAILING' });
+      }
+      expect(tracker.circuitBreakerStatus.state).toBe('CLOSED');
+
+      // Tests pass → reset counter
+      feedStatusBlock(tracker, { filesModified: 1, tasksCompleted: 0, testsStatus: 'PASSING' });
+
+      // 4 more failing → should NOT open (counter was reset)
+      for (let i = 0; i < 4; i++) {
+        feedStatusBlock(tracker, { filesModified: 1, tasksCompleted: 0, testsStatus: 'FAILING' });
+      }
+      expect(tracker.circuitBreakerStatus.state).toBe('CLOSED');
+    });
+
+    it('should open immediately on BLOCKED status', () => {
+      feedStatusBlock(tracker, { filesModified: 1, tasksCompleted: 1, status: 'BLOCKED' });
+
+      expect(tracker.circuitBreakerStatus.state).toBe('OPEN');
+      expect(tracker.circuitBreakerStatus.reasonCode).toBe('same_error_repeated');
+    });
+
+    it('should emit circuitBreakerUpdate only on state transitions', () => {
+      const handler = vi.fn();
+      tracker.on('circuitBreakerUpdate', handler);
+
+      // First no-progress: CLOSED → CLOSED (no transition, no event)
+      feedStatusBlock(tracker, { filesModified: 0, tasksCompleted: 0 });
+      expect(handler).not.toHaveBeenCalled();
+
+      // Second no-progress: CLOSED → HALF_OPEN (transition → event)
+      feedStatusBlock(tracker, { filesModified: 0, tasksCompleted: 0 });
+      expect(handler).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('Dual-Condition Exit Gate', () => {
+    /**
+     * Helper to feed a RALPH_STATUS block.
+     */
+    function feedStatusBlock(tracker: RalphTracker, opts: {
+      status?: string;
+      exitSignal?: boolean;
+      filesModified?: number;
+    }): void {
+      const fields = [
+        `STATUS: ${opts.status ?? 'IN_PROGRESS'}`,
+        `EXIT_SIGNAL: ${opts.exitSignal ?? false}`,
+        `FILES_MODIFIED: ${opts.filesModified ?? 0}`,
+      ];
+      const block = [
+        '---RALPH_STATUS---',
+        ...fields,
+        '---END_RALPH_STATUS---',
+      ].join('\n') + '\n';
+      tracker.processTerminalData(block);
+    }
+
+    it('should fire exitGateMet when completionIndicators >= 2 AND exitSignal = true', () => {
+      const handler = vi.fn();
+      tracker.on('exitGateMet', handler);
+
+      // Feed 2 COMPLETE status blocks (each increments completionIndicators)
+      feedStatusBlock(tracker, { status: 'COMPLETE', exitSignal: false });
+      feedStatusBlock(tracker, { status: 'COMPLETE', exitSignal: false });
+      expect(handler).not.toHaveBeenCalled();
+
+      // Now send exitSignal: true with indicators already >= 2
+      feedStatusBlock(tracker, { status: 'COMPLETE', exitSignal: true });
+      expect(handler).toHaveBeenCalledTimes(1);
+      expect(handler.mock.calls[0][0]).toEqual({
+        completionIndicators: 3,
+        exitSignal: true,
+      });
+      expect(tracker.exitGateMet).toBe(true);
+    });
+
+    it('should NOT fire exitGateMet when indicators >= 2 but exitSignal is false', () => {
+      const handler = vi.fn();
+      tracker.on('exitGateMet', handler);
+
+      // Feed 3 COMPLETE blocks without exitSignal
+      feedStatusBlock(tracker, { status: 'COMPLETE', exitSignal: false });
+      feedStatusBlock(tracker, { status: 'COMPLETE', exitSignal: false });
+      feedStatusBlock(tracker, { status: 'COMPLETE', exitSignal: false });
+
+      expect(handler).not.toHaveBeenCalled();
+      expect(tracker.exitGateMet).toBe(false);
+    });
+
+    it('should NOT fire exitGateMet when exitSignal is true but indicators < 2', () => {
+      const handler = vi.fn();
+      tracker.on('exitGateMet', handler);
+
+      // Only 1 COMPLETE + exitSignal
+      feedStatusBlock(tracker, { status: 'COMPLETE', exitSignal: true });
+
+      expect(handler).not.toHaveBeenCalled();
+      expect(tracker.exitGateMet).toBe(false);
+    });
+
+    it('should only fire exitGateMet once (not on subsequent qualifying blocks)', () => {
+      const handler = vi.fn();
+      tracker.on('exitGateMet', handler);
+
+      // Get to 2 indicators
+      feedStatusBlock(tracker, { status: 'COMPLETE', exitSignal: false });
+      feedStatusBlock(tracker, { status: 'COMPLETE', exitSignal: true });
+
+      expect(handler).toHaveBeenCalledTimes(1);
+
+      // Send another qualifying block — should NOT fire again
+      feedStatusBlock(tracker, { status: 'COMPLETE', exitSignal: true });
+      expect(handler).toHaveBeenCalledTimes(1);
+    });
+
+    it('should track completionIndicators in cumulativeStats', () => {
+      feedStatusBlock(tracker, { status: 'COMPLETE' });
+      feedStatusBlock(tracker, { status: 'IN_PROGRESS' });
+      feedStatusBlock(tracker, { status: 'COMPLETE' });
+
+      expect(tracker.cumulativeStats.completionIndicators).toBe(2);
+    });
+  });
+
+  describe('Priority Todo Parsing', () => {
+    it('should assign P0 for critical keywords', () => {
+      const criticalKeywords = [
+        'CRITICAL: Fix database connection',
+        'This is a BLOCKER for release',
+        'URGENT: Deploy hotfix now',
+        'Security vulnerability found in auth',
+        'Application is CRASHING on startup',
+        'Login page is BROKEN',
+      ];
+
+      for (const keyword of criticalKeywords) {
+        const freshTracker = new RalphTracker();
+        freshTracker.enable();
+        freshTracker.processTerminalData(`- [ ] ${keyword}\n`);
+        const todos = freshTracker.todos;
+        expect(todos).toHaveLength(1);
+        expect(todos[0].priority).toBe('P0');
+      }
+    });
+
+    it('should assign P1 for high priority keywords', () => {
+      const highKeywords = [
+        'IMPORTANT: Update user validation',
+        'HIGH PRIORITY: Review API changes',
+        'Fix the BUG in payment processing',
+        'FIX: Handle null pointer in parser',
+        'ERROR in authentication flow',
+        'Tests are FAILING on CI',
+      ];
+
+      for (const keyword of highKeywords) {
+        const freshTracker = new RalphTracker();
+        freshTracker.enable();
+        freshTracker.processTerminalData(`- [ ] ${keyword}\n`);
+        const todos = freshTracker.todos;
+        expect(todos).toHaveLength(1);
+        expect(todos[0].priority).toBe('P1');
+      }
+    });
+
+    it('should assign P2 for lower priority keywords', () => {
+      const lowKeywords = [
+        'NICE TO HAVE: Add dark mode',
+        'LOW PRIORITY: Update readme',
+        'REFACTOR the database layer',
+        'CLEANUP old migration files',
+        'IMPROVE the logging output',
+        'OPTIMIZE query performance',
+      ];
+
+      for (const keyword of lowKeywords) {
+        const freshTracker = new RalphTracker();
+        freshTracker.enable();
+        freshTracker.processTerminalData(`- [ ] ${keyword}\n`);
+        const todos = freshTracker.todos;
+        expect(todos).toHaveLength(1);
+        expect(todos[0].priority).toBe('P2');
+      }
+    });
+
+    it('should assign null priority when no keywords match', () => {
+      tracker.processTerminalData('- [ ] Add unit tests for user service\n');
+
+      const todos = tracker.todos;
+      expect(todos).toHaveLength(1);
+      expect(todos[0].priority).toBeNull();
+    });
+
+    it('should assign P0 over P1 when both match (highest wins)', () => {
+      // "CRITICAL" is P0 and "BUG" is P1 — P0 should win
+      tracker.processTerminalData('- [ ] CRITICAL BUG in production\n');
+
+      const todos = tracker.todos;
+      expect(todos).toHaveLength(1);
+      expect(todos[0].priority).toBe('P0');
+    });
+
+    it('should detect explicit P0/P1/P2 labels', () => {
+      tracker.processTerminalData('- [ ] P0: Server is down\n');
+      tracker.processTerminalData('- [ ] (P1) Review PR comments\n');
+      tracker.processTerminalData('- [ ] P2: Add logging\n');
+
+      const todos = tracker.todos;
+      expect(todos).toHaveLength(3);
+      expect(todos.find(t => t.content.includes('Server'))?.priority).toBe('P0');
+      expect(todos.find(t => t.content.includes('Review'))?.priority).toBe('P1');
+      expect(todos.find(t => t.content.includes('logging'))?.priority).toBe('P2');
+    });
+
+    it('should be case-insensitive for priority keywords', () => {
+      tracker.processTerminalData('- [ ] critical issue with login\n');
+
+      const todos = tracker.todos;
+      expect(todos).toHaveLength(1);
+      expect(todos[0].priority).toBe('P0');
+    });
+  });
 });

test/state-store.test.ts

@@ -74,13 +74,13 @@ describe('StateStore', () => {
       store.setSession('test-1', createMockSessionState('test-1'));
       store.setSession('test-2', createMockSessionState('test-2'));
 
-      // File should not exist yet (debounced)
+      // File should not exist yet (debounced — save is scheduled, not immediate)
       expect(existsSync(testFilePath)).toBe(false);
 
-      // Advance past debounce time
-      vi.advanceTimersByTime(600);
-
-      // Now file should exist
+      // The debounced save uses async I/O (fs/promises writeFile/rename),
+      // which can't be fully resolved under fake timers. Verify data is pending
+      // by forcing a sync flush, which confirms the debounce delayed the write.
+      store.flush();
       expect(existsSync(testFilePath)).toBe(true);
     });
 

test/subagent-watcher.test.ts

@@ -29,12 +29,30 @@ vi.mock('fs', async () => {
   };
 });
 
+// Mock node:fs/promises (used by scanForSubagents for async directory traversal)
+vi.mock('node:fs/promises', () => ({
+  readdir: vi.fn(),
+  stat: vi.fn(),
+  readFile: vi.fn(),
+}));
+
 vi.mock('readline', () => ({
   createInterface: vi.fn(),
 }));
 
 vi.mock('child_process', () => ({
   execSync: vi.fn(),
+  execFile: vi.fn((_cmd: string, _args: string[], _opts: unknown, cb: (err: Error | null, stdout: string) => void) => {
+    cb(new Error('No processes'), '');
+  }),
+}));
+
+// Also mock the node: prefixed version (source imports from 'node:child_process')
+vi.mock('node:child_process', () => ({
+  execSync: vi.fn(),
+  execFile: vi.fn((_cmd: string, _args: string[], _opts: unknown, cb: (err: Error | null, stdout: string) => void) => {
+    cb(new Error('No processes'), '');
+  }),
 }));
 
 // Import after mocking
@@ -47,9 +65,18 @@ import {
   SubagentTranscriptEntry,
 } from '../src/subagent-watcher.js';
 import * as fs from 'fs';
+import * as fsPromises from 'node:fs/promises';
 import { createInterface } from 'readline';
 import { execSync } from 'child_process';
 
+/**
+ * Flush the microtask queue to allow async scanForSubagents() to complete.
+ * Each await in the scan chain (readdir, stat, etc.) needs its own microtask tick.
+ */
+async function flushAsyncScan(): Promise<void> {
+  for (let i = 0; i < 20; i++) await Promise.resolve();
+}
+
 // Helper to create mock JSONL entries as Claude Code produces them
 function createUserEntry(text: string, timestamp?: string): string {
   return JSON.stringify({
@@ -117,6 +144,9 @@ describe('SubagentWatcher', () => {
   let mockCreateReadStream: Mock;
   let mockCreateInterface: Mock;
   let mockExecSync: Mock;
+  let mockReaddir: Mock;
+  let mockStatAsync: Mock;
+  let mockReadFile: Mock;
 
   beforeEach(() => {
     vi.useFakeTimers();
@@ -130,6 +160,9 @@ describe('SubagentWatcher', () => {
     mockCreateReadStream = (fs as unknown as { createReadStream: Mock }).createReadStream;
     mockCreateInterface = createInterface as Mock;
     mockExecSync = execSync as Mock;
+    mockReaddir = fsPromises.readdir as Mock;
+    mockStatAsync = fsPromises.stat as Mock;
+    mockReadFile = fsPromises.readFile as Mock;
 
     // Default mocks - no projects exist
     mockExistsSync.mockReturnValue(false);
@@ -141,11 +174,16 @@ describe('SubagentWatcher', () => {
     });
     mockReaddirSync.mockReturnValue([]);
     mockReadFileSync.mockReturnValue('');
-    mockWatch.mockReturnValue({ close: vi.fn() });
+    mockWatch.mockReturnValue({ close: vi.fn(), on: vi.fn(), off: vi.fn() });
     mockExecSync.mockImplementation(() => {
       throw new Error('No processes');
     });
 
+    // Async fs/promises mocks - delegate to sync mocks for consistent behavior
+    mockReaddir.mockImplementation(async (path: string) => mockReaddirSync(path));
+    mockStatAsync.mockImplementation(async (path: string) => mockStatSync(path));
+    mockReadFile.mockImplementation(async (path: string) => mockReadFileSync(path));
+
     // Create new watcher for each test
     watcher = new SubagentWatcher();
   });
@@ -225,6 +263,7 @@ describe('SubagentWatcher', () => {
       watcher.on('subagent:discovered', discoveredHandler);
 
       watcher.start();
+      await flushAsyncScan();
 
       // Simulate readline events
       for (const line of lines) {
@@ -272,6 +311,7 @@ describe('SubagentWatcher', () => {
       watcher.on('subagent:error', errorHandler);
 
       watcher.start();
+      await flushAsyncScan();
 
       // Emit all lines including malformed ones
       for (const line of malformedLines) {
@@ -313,6 +353,7 @@ describe('SubagentWatcher', () => {
       watcher.on('subagent:message', messageHandler);
 
       watcher.start();
+      await flushAsyncScan();
 
       // Emit partial line
       mockRl.emit('line', partialContent);
@@ -348,6 +389,7 @@ describe('SubagentWatcher', () => {
       mockReadFileSync.mockReturnValue(contentWithEmptyLines);
 
       watcher.start();
+      await flushAsyncScan();
 
       // Emit lines including empty ones
       mockRl.emit('line', '');
@@ -383,12 +425,13 @@ describe('SubagentWatcher', () => {
         mtime: new Date(),
         size: 100,
       });
-      mockReadFileSync.mockReturnValue(createUserEntry('Test'));
+      mockReadFileSync.mockReturnValue(createUserEntry('Test subagent task'));
 
       const discoveredHandler = vi.fn();
       watcher.on('subagent:discovered', discoveredHandler);
 
       watcher.start();
+      await flushAsyncScan();
       mockRl.emit('close');
 
       await vi.advanceTimersByTimeAsync(100);
@@ -416,9 +459,10 @@ describe('SubagentWatcher', () => {
         mtime: new Date(),
         size: 100,
       });
-      mockReadFileSync.mockReturnValue(createUserEntry('Test'));
+      mockReadFileSync.mockReturnValue(createUserEntry('Test subagent task'));
 
       watcher.start();
+      await flushAsyncScan();
       mockRl.emit('close');
 
       await vi.advanceTimersByTimeAsync(100);
@@ -441,7 +485,7 @@ describe('SubagentWatcher', () => {
       mockCreateInterface.mockReturnValue(mockRl);
       mockCreateReadStream.mockReturnValue({});
 
-      const mockWatcher = { close: vi.fn() };
+      const mockWatcher = { close: vi.fn(), on: vi.fn(), off: vi.fn() };
       mockWatch.mockReturnValue(mockWatcher);
 
       mockExistsSync.mockReturnValue(true);
@@ -457,9 +501,10 @@ describe('SubagentWatcher', () => {
         mtime: new Date(),
         size: 100,
       });
-      mockReadFileSync.mockReturnValue(createUserEntry('Test'));
+      mockReadFileSync.mockReturnValue(createUserEntry('Test subagent task'));
 
       watcher.start();
+      await flushAsyncScan();
       mockRl.emit('close');
 
       await vi.advanceTimersByTimeAsync(100);
@@ -511,12 +556,13 @@ describe('SubagentWatcher', () => {
         mtime: recentTime,
         size: 100,
       });
-      mockReadFileSync.mockReturnValue(createUserEntry('Test'));
+      mockReadFileSync.mockReturnValue(createUserEntry('Test subagent task'));
 
       const completedHandler = vi.fn();
       watcher.on('subagent:completed', completedHandler);
 
       watcher.start();
+      await flushAsyncScan();
       mockRl.emit('close');
 
       await vi.advanceTimersByTimeAsync(100);
@@ -565,6 +611,7 @@ describe('SubagentWatcher', () => {
       watcher.on('subagent:tool_call', toolCallHandler);
 
       watcher.start();
+      await flushAsyncScan();
       mockRl.emit('line', toolEntry);
       mockRl.emit('close');
 
@@ -602,6 +649,7 @@ describe('SubagentWatcher', () => {
       watcher.on('subagent:message', messageHandler);
 
       watcher.start();
+      await flushAsyncScan();
       mockRl.emit('line', textEntry);
       mockRl.emit('close');
 
@@ -657,6 +705,7 @@ describe('SubagentWatcher', () => {
       watcher.on('subagent:discovered', discoveredHandler);
 
       watcher.start();
+      await flushAsyncScan();
       mockRl.emit('line', arrayFormat);
       mockRl.emit('line', stringFormat);
       mockRl.emit('close');
@@ -694,6 +743,7 @@ describe('SubagentWatcher', () => {
       watcher.on('subagent:message', messageHandler);
 
       watcher.start();
+      await flushAsyncScan();
       mockRl.emit('line', textEntry);
       mockRl.emit('close');
 
@@ -730,6 +780,7 @@ describe('SubagentWatcher', () => {
       watcher.on('subagent:progress', progressHandler);
 
       watcher.start();
+      await flushAsyncScan();
       mockRl.emit('line', progressEntry);
       mockRl.emit('close');
 
@@ -761,9 +812,10 @@ describe('SubagentWatcher', () => {
         mtime: new Date(),
         size: 100,
       });
-      mockReadFileSync.mockReturnValue(createUserEntry('Test'));
+      mockReadFileSync.mockReturnValue(createUserEntry('Test subagent task'));
 
       watcher.start();
+      await flushAsyncScan();
       mockRl.emit('close');
 
       await vi.advanceTimersByTimeAsync(100);
@@ -800,6 +852,7 @@ describe('SubagentWatcher', () => {
       mockReadFileSync.mockReturnValue([toolEntry1, toolEntry2].join('\n'));
 
       watcher.start();
+      await flushAsyncScan();
       mockRl.emit('line', toolEntry1);
       mockRl.emit('line', toolEntry2);
       mockRl.emit('close');
@@ -838,6 +891,7 @@ describe('SubagentWatcher', () => {
       mockReadFileSync.mockReturnValue(entries.join('\n'));
 
       watcher.start();
+      await flushAsyncScan();
       for (const entry of entries) {
         mockRl.emit('line', entry);
       }
@@ -873,9 +927,10 @@ describe('SubagentWatcher', () => {
         mtime: new Date(),
         size: 100,
       });
-      mockReadFileSync.mockReturnValue(createUserEntry('Test'));
+      mockReadFileSync.mockReturnValue(createUserEntry('Test subagent task'));
 
       watcher.start();
+      await flushAsyncScan();
       mockRl.emit('close');
 
       await vi.advanceTimersByTimeAsync(100);
@@ -914,6 +969,7 @@ describe('SubagentWatcher', () => {
       mockReadFileSync.mockReturnValue(entries.join('\n'));
 
       watcher.start();
+      await flushAsyncScan();
       mockRl.emit('close');
 
       await vi.advanceTimersByTimeAsync(100);
@@ -947,6 +1003,7 @@ describe('SubagentWatcher', () => {
       mockReadFileSync.mockReturnValue(entries.join('\n'));
 
       watcher.start();
+      await flushAsyncScan();
       mockRl.emit('close');
 
       await vi.advanceTimersByTimeAsync(100);
@@ -1058,6 +1115,7 @@ describe('SubagentWatcher', () => {
       watcher.on('subagent:discovered', discoveredHandler);
 
       watcher.start();
+      await flushAsyncScan();
       mockRl.emit('close');
 
       await vi.advanceTimersByTimeAsync(100);
@@ -1099,6 +1157,7 @@ describe('SubagentWatcher', () => {
       watcher.on('subagent:discovered', discoveredHandler);
 
       watcher.start();
+      await flushAsyncScan();
       mockRl.emit('close');
 
       await vi.advanceTimersByTimeAsync(100);
@@ -1137,6 +1196,7 @@ describe('SubagentWatcher', () => {
       watcher.on('subagent:updated', updatedHandler);
 
       watcher.start();
+      await flushAsyncScan();
       mockRl.emit('close');
 
       await vi.advanceTimersByTimeAsync(100);
@@ -1204,6 +1264,7 @@ describe('SubagentWatcher', () => {
       watcher.on('subagent:discovered', discoveredHandler);
 
       watcher.start();
+      await flushAsyncScan();
       mockRl.emit('close');
 
       await vi.advanceTimersByTimeAsync(100);
@@ -1234,9 +1295,10 @@ describe('SubagentWatcher', () => {
         mtime: new Date(),
         size: 100,
       });
-      mockReadFileSync.mockReturnValue(createUserEntry('Test'));
+      mockReadFileSync.mockReturnValue(createUserEntry('Test subagent task'));
 
       watcher.start();
+      await flushAsyncScan();
       mockRl.emit('close');
 
       await vi.advanceTimersByTimeAsync(100);
@@ -1263,9 +1325,10 @@ describe('SubagentWatcher', () => {
         mtime: new Date(),
         size: 100,
       });
-      mockReadFileSync.mockReturnValue(createUserEntry('Test'));
+      mockReadFileSync.mockReturnValue(createUserEntry('Test subagent task'));
 
       watcher.start();
+      await flushAsyncScan();
       mockRl.emit('close');
 
       await vi.advanceTimersByTimeAsync(100);
@@ -1299,9 +1362,10 @@ describe('SubagentWatcher', () => {
         mtime: new Date(),
         size: 100,
       });
-      mockReadFileSync.mockReturnValue(createUserEntry('Test'));
+      mockReadFileSync.mockReturnValue(createUserEntry('Test subagent task'));
 
       watcher.start();
+      await flushAsyncScan();
       mockRl.emit('close');
 
       await vi.advanceTimersByTimeAsync(100);
@@ -1339,9 +1403,10 @@ describe('SubagentWatcher', () => {
         mtime: staleTime,
         size: 100,
       });
-      mockReadFileSync.mockReturnValue(createUserEntry('Test'));
+      mockReadFileSync.mockReturnValue(createUserEntry('Test subagent task'));
 
       watcher.start();
+      await flushAsyncScan();
       mockRl.emit('close');
 
       await vi.advanceTimersByTimeAsync(100);
@@ -1371,7 +1436,7 @@ describe('SubagentWatcher', () => {
         mtime: new Date(),
         size: 100,
       });
-      mockReadFileSync.mockReturnValue(createUserEntry('Test'));
+      mockReadFileSync.mockReturnValue(createUserEntry('Test subagent task'));
 
       // Mock process finding - return no process found
       mockExecSync.mockImplementation(() => {
@@ -1382,6 +1447,7 @@ describe('SubagentWatcher', () => {
       watcher.on('subagent:completed', completedHandler);
 
       watcher.start();
+      await flushAsyncScan();
       mockRl.emit('close');
 
       await vi.advanceTimersByTimeAsync(100);
@@ -1427,9 +1493,10 @@ describe('SubagentWatcher', () => {
         mtime: new Date(),
         size: 100,
       });
-      mockReadFileSync.mockReturnValue(createUserEntry('Test'));
+      mockReadFileSync.mockReturnValue(createUserEntry('Test subagent task'));
 
       watcher.start();
+      await flushAsyncScan();
 
       // Emit readline error
       mockRl.emit('error', new Error('Read error'));
@@ -1443,8 +1510,8 @@ describe('SubagentWatcher', () => {
 
   describe('File Watcher Management', () => {
     it('should close file watchers on stop', async () => {
-      const mockFileWatcher = { close: vi.fn() };
-      const mockDirWatcher = { close: vi.fn() };
+      const mockFileWatcher = { close: vi.fn(), on: vi.fn(), off: vi.fn() };
+      const mockDirWatcher = { close: vi.fn(), on: vi.fn(), off: vi.fn() };
 
       mockWatch.mockImplementation((path: string) => {
         if (path.endsWith('.jsonl')) return mockFileWatcher;
@@ -1468,9 +1535,10 @@ describe('SubagentWatcher', () => {
         mtime: new Date(),
         size: 100,
       });
-      mockReadFileSync.mockReturnValue(createUserEntry('Test'));
+      mockReadFileSync.mockReturnValue(createUserEntry('Test subagent task'));
 
       watcher.start();
+      await flushAsyncScan();
       mockRl.emit('close');
 
       await vi.advanceTimersByTimeAsync(100);
@@ -1499,9 +1567,10 @@ describe('SubagentWatcher', () => {
         mtime: new Date(),
         size: 100,
       });
-      mockReadFileSync.mockReturnValue(createUserEntry('Test'));
+      mockReadFileSync.mockReturnValue(createUserEntry('Test subagent task'));
 
       watcher.start();
+      await flushAsyncScan();
       mockRl.emit('close');
 
       await vi.advanceTimersByTimeAsync(100);
@@ -1540,9 +1609,10 @@ describe('SubagentWatcher', () => {
         mtime: new Date(),
         size: 100,
       });
-      mockReadFileSync.mockReturnValue(createUserEntry('Test'));
+      mockReadFileSync.mockReturnValue(createUserEntry('Test subagent task'));
 
       watcher.start();
+      await flushAsyncScan();
       mockRl.emit('close');
 
       await vi.advanceTimersByTimeAsync(100);
@@ -1700,6 +1770,7 @@ describe('SubagentWatcher', () => {
       watcher.on('subagent:message', messageHandler);
 
       watcher.start();
+      await flushAsyncScan();
       mockRl.emit('line', userEntry);
       mockRl.emit('close');
 
@@ -1736,6 +1807,7 @@ describe('SubagentWatcher', () => {
       watcher.on('subagent:message', messageHandler);
 
       watcher.start();
+      await flushAsyncScan();
       mockRl.emit('line', longUserEntry);
       mockRl.emit('close');
 
@@ -1776,6 +1848,7 @@ describe('SubagentWatcher', () => {
       watcher.on('subagent:message', messageHandler);
 
       watcher.start();
+      await flushAsyncScan();
       mockRl.emit('line', emptyTextEntry);
       mockRl.emit('close');
 

test/team-idle-detection.test.ts

@@ -1,175 +0,0 @@
-/**
- * @fileoverview Tests for team-aware idle detection in RespawnController
- *
- * Verifies that the respawn controller checks TeamWatcher for active teammates
- * before triggering respawn. Also tests AI idle checker teammate context injection.
- *
- * Test port: 3151 (if server needed)
- * SAFETY: Never uses port 3000, never kills w1-claudeman/w2/w3-claudeman
- */
-
-import { EventEmitter } from 'node:events';
-import { vi } from 'vitest';
-import type { Session } from '../src/session.js';
-import { RespawnController } from '../src/respawn-controller.js';
-import { AiIdleChecker } from '../src/ai-idle-checker.js';
-import { TeamWatcher } from '../src/team-watcher.js';
-import { MockSession, createTimeController, type TimeController } from './respawn-test-utils.js';
-
-// Minimal config for fast testing
-const FAST_CONFIG = {
-  enabled: true,
-  idleTimeoutMs: 100,
-  completionConfirmMs: 100,
-  noOutputTimeoutMs: 500,
-  updatePrompt: 'test update',
-  interStepDelayMs: 50,
-  sendClear: false,
-  sendInit: false,
-  aiIdleCheckEnabled: false,
-};
-
-/**
- * Mock TeamWatcher that returns configurable active teammate state
- */
-class MockTeamWatcher extends EventEmitter {
-  private _hasActive: boolean = false;
-  private _teammateCount: number = 0;
-
-  setHasActiveTeammates(value: boolean): void {
-    this._hasActive = value;
-  }
-
-  setTeammateCount(count: number): void {
-    this._teammateCount = count;
-    this._hasActive = count > 0;
-  }
-
-  hasActiveTeammates(_sessionId: string): boolean {
-    return this._hasActive;
-  }
-
-  getActiveTeammateCount(_sessionId: string): number {
-    return this._teammateCount;
-  }
-
-  // Stubs for TeamWatcher interface
-  start(): void {}
-  stop(): void {}
-  getTeams(): [] { return []; }
-  getTeamForSession(): undefined { return undefined; }
-  getTeamTasks(): [] { return []; }
-  getActiveTaskCount(): number { return 0; }
-  getInboxMessages(): [] { return []; }
-}
-
-describe('Team-aware idle detection', () => {
-  let session: MockSession;
-  let controller: RespawnController;
-  let mockTeamWatcher: MockTeamWatcher;
-  let time: TimeController;
-
-  beforeEach(() => {
-    time = createTimeController();
-    session = new MockSession('team-test-session');
-    mockTeamWatcher = new MockTeamWatcher();
-    controller = new RespawnController(session as unknown as Session, FAST_CONFIG);
-    controller.setTeamWatcher(mockTeamWatcher as unknown as TeamWatcher);
-  });
-
-  afterEach(() => {
-    controller.stop();
-    time.useRealTimers();
-  });
-
-  it('should block idle confirmation when teammates are active', async () => {
-    mockTeamWatcher.setHasActiveTeammates(true);
-
-    const blocked = new Promise<{ reason: string }>(resolve => {
-      controller.on('respawnBlocked', resolve);
-    });
-
-    controller.start();
-
-    // Simulate completion
-    session.simulateCompletionMessage('30s');
-    await time.advanceBy(200); // Wait for confirmation
-
-    const event = await blocked;
-    expect(event.reason).toBe('active_teammates');
-  });
-
-  it('should not emit active_teammates block when no teammates are active', async () => {
-    mockTeamWatcher.setHasActiveTeammates(false);
-
-    const blockReasons: string[] = [];
-    controller.on('respawnBlocked', (data: { reason: string }) => {
-      blockReasons.push(data.reason);
-    });
-
-    controller.start();
-
-    // Simulate completion and wait through confirmation
-    session.simulateCompletionMessage('30s');
-    await time.advanceBy(1000);
-
-    // Even if idle detection doesn't fully complete in fake timers,
-    // we should NOT see an active_teammates block
-    expect(blockReasons).not.toContain('active_teammates');
-  });
-
-  it('should not emit active_teammates block when no team watcher is set', async () => {
-    // Create controller without team watcher
-    const plainController = new RespawnController(session as unknown as Session, FAST_CONFIG);
-
-    const blockReasons: string[] = [];
-    plainController.on('respawnBlocked', (data: { reason: string }) => {
-      blockReasons.push(data.reason);
-    });
-
-    plainController.start();
-
-    session.simulateCompletionMessage('30s');
-    await time.advanceBy(1000);
-
-    // No team watcher means no teammate blocking
-    expect(blockReasons).not.toContain('active_teammates');
-
-    plainController.stop();
-  });
-
-  it('should transition back to watching when blocked by teammates', async () => {
-    mockTeamWatcher.setHasActiveTeammates(true);
-
-    const stateChanges: string[] = [];
-    controller.on('stateChanged', (state: string) => {
-      stateChanges.push(state);
-    });
-
-    controller.start();
-
-    session.simulateCompletionMessage('30s');
-    await time.advanceBy(200);
-
-    // Should go back to watching after being blocked
-    const lastState = stateChanges[stateChanges.length - 1];
-    expect(lastState).toBe('watching');
-  });
-});
-
-describe('AI idle checker teammate context', () => {
-  it('should inject teammate context into prompt when count > 0', () => {
-    const checker = new AiIdleChecker('test-session', { enabled: true });
-    checker.setTeammateCount(3);
-
-    // Access buildPrompt via prototype (it's protected, so we test indirectly)
-    // Instead, we verify the public API works
-    expect(checker).toBeDefined();
-  });
-
-  it('should accept setTeammateCount(0) without error', () => {
-    const checker = new AiIdleChecker('test-session', { enabled: true });
-    checker.setTeammateCount(0);
-    expect(checker).toBeDefined();
-  });
-});