rafcode 2.1.0 → 2.2.0

package/tests/unit/claude-runner.test.ts

@@ -140,8 +140,7 @@ describe('ClaudeRunner', () => {
       const runPromise = runner.run('test prompt', { timeout: 5 });
 
       // Emit some output and close the process normally
-      const event = JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: '<promise>COMPLETE</promise>' }] } });
-      mockProc.stdout.emit('data', Buffer.from(event + '\n'));
+      mockProc.stdout.emit('data', Buffer.from('<promise>COMPLETE</promise>'));
       mockProc.emit('close', 0);
 
       const result = await runPromise;
@@ -163,9 +162,8 @@ describe('ClaudeRunner', () => {
 
       const runPromise1 = runner.run('first prompt', { timeout: 2 });
 
-      // Complete first call quickly (NDJSON event)
-      const event = JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: 'output' }] } });
-      mockProc1.stdout.emit('data', Buffer.from(event + '\n'));
+      // Complete first call quickly
+      mockProc1.stdout.emit('data', Buffer.from('output'));
       mockProc1.emit('close', 0);
       await runPromise1;
 
@@ -213,9 +211,8 @@ describe('ClaudeRunner', () => {
       // Advance a bit but not to timeout
       jest.advanceTimersByTime(30000);
 
-      // Complete process (NDJSON event)
-      const event = JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: 'output' }] } });
-      mockProc.stdout.emit('data', Buffer.from(event + '\n'));
+      // Complete process
+      mockProc.stdout.emit('data', Buffer.from('output'));
       mockProc.emit('close', 0);
 
       const result = await runPromise;
@@ -235,9 +232,8 @@ describe('ClaudeRunner', () => {
       jest.advanceTimersByTime(1000);
       expect(mockProc.kill).not.toHaveBeenCalled();
 
-      // Complete the process normally before reaching the 60 minute timeout (NDJSON event)
-      const event = JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: 'output' }] } });
-      mockProc.stdout.emit('data', Buffer.from(event + '\n'));
+      // Complete the process normally before reaching the 60 minute timeout
+      mockProc.stdout.emit('data', Buffer.from('output'));
       mockProc.emit('close', 0);
 
       const result = await runPromise;
@@ -309,9 +305,8 @@ describe('ClaudeRunner', () => {
       const runner = new ClaudeRunner();
       const runPromise = runner.run('test prompt', { timeout: 60 });
 
-      // Emit context overflow message as NDJSON assistant event (run() now uses stream-json)
-      const event = JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: 'Error: context length exceeded' }] } });
-      mockProc.stdout.emit('data', Buffer.from(event + '\n'));
+      // Emit context overflow message (with newline so NDJSON line buffer processes it)
+      mockProc.stdout.emit('data', Buffer.from('Error: context length exceeded\n'));
 
       const result = await runPromise;
       expect(result.contextOverflow).toBe(true);
@@ -338,9 +333,8 @@ describe('ClaudeRunner', () => {
         const runner = new ClaudeRunner();
         const runPromise = runner.run('test prompt', { timeout: 60 });
 
-        // Emit as NDJSON assistant event (run() now uses stream-json)
-        const event = JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: `Error: ${pattern}` }] } });
-        mockProc.stdout.emit('data', Buffer.from(event + '\n'));
+        // Trailing newline needed for NDJSON line buffer processing
+        mockProc.stdout.emit('data', Buffer.from(`Error: ${pattern}\n`));
 
         const result = await runPromise;
         expect(result.contextOverflow).toBe(true);
@@ -362,18 +356,17 @@ describe('ClaudeRunner', () => {
       return proc;
     }
 
-    it('should collect all stdout output from NDJSON events', async () => {
+    it('should collect all stdout output', async () => {
       const mockProc = createMockProcess();
       mockSpawn.mockReturnValue(mockProc);
 
       const runner = new ClaudeRunner();
       const runPromise = runner.run('test prompt', { timeout: 60 });
 
-      // Emit NDJSON assistant events (run() now uses stream-json)
-      const event1 = JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: 'chunk1' }] } });
-      const event2 = JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: 'chunk2' }] } });
-      const event3 = JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: 'chunk3' }] } });
-      mockProc.stdout.emit('data', Buffer.from(event1 + '\n' + event2 + '\n' + event3 + '\n'));
+      // Emit multiple chunks
+      mockProc.stdout.emit('data', Buffer.from('chunk1'));
+      mockProc.stdout.emit('data', Buffer.from('chunk2'));
+      mockProc.stdout.emit('data', Buffer.from('chunk3'));
       mockProc.emit('close', 0);
 
       const result = await runPromise;
@@ -704,7 +697,7 @@ describe('ClaudeRunner', () => {
       expect(spawnArgs).toContain('--verbose');
     });
 
-    it('should include --output-format stream-json and --verbose flags in run()', async () => {
+    it('should include --output-format stream-json and --verbose flags in run() (unified stream-json)', async () => {
       const mockProc = createMockProcess();
       mockSpawn.mockReturnValue(mockProc);
 
@@ -764,6 +757,169 @@ describe('ClaudeRunner', () => {
     });
   });
 
+  describe('usage data extraction', () => {
+    function createMockProcess() {
+      const stdout = new EventEmitter();
+      const stderr = new EventEmitter();
+      const proc = new EventEmitter() as any;
+      proc.stdout = stdout;
+      proc.stderr = stderr;
+      proc.kill = jest.fn();
+      return proc;
+    }
+
+    it('should return usageData from run() when result event has usage', async () => {
+      const mockProc = createMockProcess();
+      mockSpawn.mockReturnValue(mockProc);
+
+      const runner = new ClaudeRunner();
+      const runPromise = runner.run('test prompt', { timeout: 60 });
+
+      const assistantEvent = JSON.stringify({
+        type: 'assistant',
+        message: { content: [{ type: 'text', text: 'Done' }] },
+      });
+      const resultEvent = JSON.stringify({
+        type: 'result',
+        usage: { input_tokens: 1000, output_tokens: 500, cache_read_input_tokens: 200, cache_creation_input_tokens: 100 },
+        modelUsage: { 'claude-opus-4-6': { inputTokens: 1000, outputTokens: 500, cacheReadInputTokens: 200, cacheCreationInputTokens: 100 } },
+      });
+
+      mockProc.stdout.emit('data', Buffer.from(assistantEvent + '\n' + resultEvent + '\n'));
+      mockProc.emit('close', 0);
+
+      const result = await runPromise;
+      expect(result.usageData).toBeDefined();
+      expect(result.usageData!.inputTokens).toBe(1000);
+      expect(result.usageData!.outputTokens).toBe(500);
+      expect(result.usageData!.modelUsage['claude-opus-4-6']).toEqual({
+        inputTokens: 1000,
+        outputTokens: 500,
+        cacheReadInputTokens: 200,
+        cacheCreationInputTokens: 100,
+      });
+    });
+
+    it('should return usageData from runVerbose() when result event has usage', async () => {
+      const mockProc = createMockProcess();
+      mockSpawn.mockReturnValue(mockProc);
+
+      const runner = new ClaudeRunner();
+      const runPromise = runner.runVerbose('test prompt', { timeout: 60 });
+
+      const resultEvent = JSON.stringify({
+        type: 'result',
+        usage: { input_tokens: 2000, output_tokens: 800 },
+        modelUsage: { 'claude-sonnet-4-5-20250929': { inputTokens: 2000, outputTokens: 800 } },
+      });
+
+      mockProc.stdout.emit('data', Buffer.from(resultEvent + '\n'));
+      mockProc.emit('close', 0);
+
+      const result = await runPromise;
+      expect(result.usageData).toBeDefined();
+      expect(result.usageData!.inputTokens).toBe(2000);
+      expect(result.usageData!.outputTokens).toBe(800);
+    });
+
+    it('should return undefined usageData when no result event', async () => {
+      const mockProc = createMockProcess();
+      mockSpawn.mockReturnValue(mockProc);
+
+      const runner = new ClaudeRunner();
+      const runPromise = runner.run('test prompt', { timeout: 60 });
+
+      const assistantEvent = JSON.stringify({
+        type: 'assistant',
+        message: { content: [{ type: 'text', text: 'Output' }] },
+      });
+
+      mockProc.stdout.emit('data', Buffer.from(assistantEvent + '\n'));
+      mockProc.emit('close', 0);
+
+      const result = await runPromise;
+      expect(result.usageData).toBeUndefined();
+    });
+
+    it('should suppress display in run() but still capture usage data', async () => {
+      const mockProc = createMockProcess();
+      mockSpawn.mockReturnValue(mockProc);
+
+      // Spy on stdout.write to verify no display output in non-verbose mode
+      const writeSpy = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+
+      const runner = new ClaudeRunner();
+      const runPromise = runner.run('test prompt', { timeout: 60 });
+
+      const toolEvent = JSON.stringify({
+        type: 'assistant',
+        message: { content: [
+          { type: 'text', text: 'Working...' },
+          { type: 'tool_use', name: 'Read', input: { file_path: '/test.ts' } },
+        ] },
+      });
+      const resultEvent = JSON.stringify({
+        type: 'result',
+        usage: { input_tokens: 100, output_tokens: 50 },
+      });
+
+      mockProc.stdout.emit('data', Buffer.from(toolEvent + '\n' + resultEvent + '\n'));
+      mockProc.emit('close', 0);
+
+      const result = await runPromise;
+
+      // No display output (run() is non-verbose)
+      expect(writeSpy).not.toHaveBeenCalled();
+
+      // But usage data is still captured
+      expect(result.usageData).toBeDefined();
+      expect(result.usageData!.inputTokens).toBe(100);
+
+      // And text content is captured
+      expect(result.output).toContain('Working...');
+
+      writeSpy.mockRestore();
+    });
+
+    it('should use verboseCheck callback to dynamically control display', async () => {
+      const mockProc = createMockProcess();
+      mockSpawn.mockReturnValue(mockProc);
+
+      const writeSpy = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+
+      let dynamicVerbose = false;
+      const runner = new ClaudeRunner();
+      const runPromise = runner.run('test prompt', {
+        timeout: 60,
+        verboseCheck: () => dynamicVerbose,
+      });
+
+      // First event with verbose OFF — should not display
+      const event1 = JSON.stringify({
+        type: 'assistant',
+        message: { content: [{ type: 'tool_use', name: 'Read', input: { file_path: '/a.ts' } }] },
+      });
+      mockProc.stdout.emit('data', Buffer.from(event1 + '\n'));
+      expect(writeSpy).not.toHaveBeenCalled();
+
+      // Toggle verbose ON
+      dynamicVerbose = true;
+
+      // Second event with verbose ON — should display
+      const event2 = JSON.stringify({
+        type: 'assistant',
+        message: { content: [{ type: 'tool_use', name: 'Read', input: { file_path: '/b.ts' } }] },
+      });
+      mockProc.stdout.emit('data', Buffer.from(event2 + '\n'));
+      expect(writeSpy).toHaveBeenCalled();
+
+      mockProc.emit('close', 0);
+      await runPromise;
+
+      writeSpy.mockRestore();
+    });
+  });
+
   describe('retry isolation (timeout per attempt)', () => {
     function createMockProcess() {
       const stdout = new EventEmitter();
@@ -804,9 +960,8 @@ describe('ClaudeRunner', () => {
       jest.advanceTimersByTime(60000);
       expect(mockProc2.kill).not.toHaveBeenCalled();
 
-      // Complete successfully (NDJSON event)
-      const successEvent = JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: 'success' }] } });
-      mockProc2.stdout.emit('data', Buffer.from(successEvent + '\n'));
+      // Complete successfully
+      mockProc2.stdout.emit('data', Buffer.from('success'));
       mockProc2.emit('close', 0);
 
       const result2 = await runPromise2;
@@ -827,9 +982,8 @@ describe('ClaudeRunner', () => {
       // Run for 4 minutes (240000ms)
       jest.advanceTimersByTime(240000);
 
-      // Fail without timeout (NDJSON event)
-      const failEvent = JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: '<promise>FAILED</promise>' }] } });
-      mockProc1.stdout.emit('data', Buffer.from(failEvent + '\n'));
+      // Fail without timeout
+      mockProc1.stdout.emit('data', Buffer.from('<promise>FAILED</promise>'));
       mockProc1.emit('close', 1);
 
       const result1 = await runPromise1;
@@ -879,9 +1033,8 @@ describe('ClaudeRunner', () => {
       const runner = new ClaudeRunner();
       const runPromise = runner.run('test prompt', { timeout: 60 });
 
-      // Emit output with completion marker (NDJSON event)
-      const event = JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: 'Writing outcome...\n<promise>COMPLETE</promise>' }] } });
-      mockProc.stdout.emit('data', Buffer.from(event + '\n'));
+      // Emit output with completion marker
+      mockProc.stdout.emit('data', Buffer.from('Writing outcome...\n<promise>COMPLETE</promise>\n'));
 
       // Process should not be killed immediately
       expect(mockProc.kill).not.toHaveBeenCalled();
@@ -906,9 +1059,8 @@ describe('ClaudeRunner', () => {
       const runner = new ClaudeRunner();
       const runPromise = runner.run('test prompt', { timeout: 60 });
 
-      // Emit output with failed marker (NDJSON event)
-      const event = JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: '<promise>FAILED</promise>\nReason: test error' }] } });
-      mockProc.stdout.emit('data', Buffer.from(event + '\n'));
+      // Emit output with failed marker
+      mockProc.stdout.emit('data', Buffer.from('<promise>FAILED</promise>\nReason: test error'));
 
       // Advance past grace period
       jest.advanceTimersByTime(COMPLETION_GRACE_PERIOD_MS + 1);
@@ -925,15 +1077,13 @@ describe('ClaudeRunner', () => {
       const runner = new ClaudeRunner();
       const runPromise = runner.run('test prompt', { timeout: 60 });
 
-      // Emit partial output (no marker yet) as NDJSON
-      const event1 = JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: 'Working on task...' }] } });
-      mockProc.stdout.emit('data', Buffer.from(event1 + '\n'));
+      // Emit partial output (no marker yet)
+      mockProc.stdout.emit('data', Buffer.from('Working on task...\n'));
       jest.advanceTimersByTime(10000);
       expect(mockProc.kill).not.toHaveBeenCalled();
 
-      // Emit marker in second chunk as NDJSON
-      const event2 = JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: '<promise>COMPLETE</promise>' }] } });
-      mockProc.stdout.emit('data', Buffer.from(event2 + '\n'));
+      // Emit marker in second chunk
+      mockProc.stdout.emit('data', Buffer.from('<promise>COMPLETE</promise>\n'));
 
       // Grace period starts now - advance past it
       jest.advanceTimersByTime(COMPLETION_GRACE_PERIOD_MS + 1);
@@ -951,9 +1101,8 @@ describe('ClaudeRunner', () => {
       const runner = new ClaudeRunner();
       const runPromise = runner.run('test prompt', { timeout: 60 });
 
-      // Emit completion marker as NDJSON
-      const event = JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: '<promise>COMPLETE</promise>' }] } });
-      mockProc.stdout.emit('data', Buffer.from(event + '\n'));
+      // Emit completion marker
+      mockProc.stdout.emit('data', Buffer.from('<promise>COMPLETE</promise>\n'));
 
       // Process exits naturally before grace period
       jest.advanceTimersByTime(5000);
@@ -983,9 +1132,8 @@ describe('ClaudeRunner', () => {
         outcomeFilePath: outcomePath,
       });
 
-      // No output marker in stdout - just regular output (NDJSON event)
-      const event = JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: 'Working on task...' }] } });
-      mockProc.stdout.emit('data', Buffer.from(event + '\n'));
+      // No output marker in stdout - just regular output
+      mockProc.stdout.emit('data', Buffer.from('Working on task...'));
 
       // After some time, outcome file appears with marker
       jest.advanceTimersByTime(OUTCOME_POLL_INTERVAL_MS - 1);
@@ -1029,9 +1177,8 @@ describe('ClaudeRunner', () => {
       jest.advanceTimersByTime(OUTCOME_POLL_INTERVAL_MS * 5);
       expect(mockProc.kill).not.toHaveBeenCalled();
 
-      // Complete normally (NDJSON event)
-      const doneEvent = JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: 'done' }] } });
-      mockProc.stdout.emit('data', Buffer.from(doneEvent + '\n'));
+      // Complete normally
+      mockProc.stdout.emit('data', Buffer.from('done'));
       mockProc.emit('close', 0);
 
       await runPromise;
@@ -1064,16 +1211,14 @@ describe('ClaudeRunner', () => {
       const runner = new ClaudeRunner();
       const runPromise = runner.run('test prompt', { timeout: 60 });
 
-      // Emit first marker as NDJSON
-      const event1 = JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: '<promise>COMPLETE</promise>' }] } });
-      mockProc.stdout.emit('data', Buffer.from(event1 + '\n'));
+      // Emit first marker
+      mockProc.stdout.emit('data', Buffer.from('<promise>COMPLETE</promise>\n'));
 
       // Advance halfway through grace period
       jest.advanceTimersByTime(COMPLETION_GRACE_PERIOD_MS / 2);
 
-      // Emit second marker (e.g., Claude reading back what it wrote) as NDJSON
-      const event2 = JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: 'Verified: <promise>COMPLETE</promise>' }] } });
-      mockProc.stdout.emit('data', Buffer.from(event2 + '\n'));
+      // Emit second marker (e.g., Claude reading back what it wrote)
+      mockProc.stdout.emit('data', Buffer.from('Verified: <promise>COMPLETE</promise>\n'));
 
       // Advance remaining grace period from FIRST detection
       jest.advanceTimersByTime(COMPLETION_GRACE_PERIOD_MS / 2 + 1);
@@ -1129,9 +1274,8 @@ describe('ClaudeRunner', () => {
         commitContext,
       });
 
-      // Emit COMPLETE marker as NDJSON
-      const event = JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: '<promise>COMPLETE</promise>' }] } });
-      mockProc.stdout.emit('data', Buffer.from(event + '\n'));
+      // Emit COMPLETE marker
+      mockProc.stdout.emit('data', Buffer.from('<promise>COMPLETE</promise>\n'));
 
       // Advance to grace period expiry - commit already verified
       jest.advanceTimersByTime(COMPLETION_GRACE_PERIOD_MS + 1);
@@ -1155,9 +1299,8 @@ describe('ClaudeRunner', () => {
         commitContext,
       });
 
-      // Emit COMPLETE marker as NDJSON
-      const event = JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: '<promise>COMPLETE</promise>' }] } });
-      mockProc.stdout.emit('data', Buffer.from(event + '\n'));
+      // Emit COMPLETE marker
+      mockProc.stdout.emit('data', Buffer.from('<promise>COMPLETE</promise>\n'));
 
       // Advance past initial grace period - commit not found, should extend
       jest.advanceTimersByTime(COMPLETION_GRACE_PERIOD_MS + 1);
@@ -1191,9 +1334,8 @@ describe('ClaudeRunner', () => {
         commitContext,
       });
 
-      // Emit COMPLETE marker as NDJSON
-      const event = JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: '<promise>COMPLETE</promise>' }] } });
-      mockProc.stdout.emit('data', Buffer.from(event + '\n'));
+      // Emit COMPLETE marker
+      mockProc.stdout.emit('data', Buffer.from('<promise>COMPLETE</promise>\n'));
 
       // Advance past initial grace period
       jest.advanceTimersByTime(COMPLETION_GRACE_PERIOD_MS + 1);
@@ -1219,9 +1361,8 @@ describe('ClaudeRunner', () => {
         commitContext,
       });
 
-      // Emit FAILED marker (not COMPLETE) as NDJSON
-      const event = JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: '<promise>FAILED</promise>' }] } });
-      mockProc.stdout.emit('data', Buffer.from(event + '\n'));
+      // Emit FAILED marker (not COMPLETE)
+      mockProc.stdout.emit('data', Buffer.from('<promise>FAILED</promise>\n'));
 
       // Grace period should expire normally without extension
       jest.advanceTimersByTime(COMPLETION_GRACE_PERIOD_MS + 1);
@@ -1240,9 +1381,8 @@ describe('ClaudeRunner', () => {
         // No commitContext provided
       });
 
-      // Emit COMPLETE marker as NDJSON
-      const event = JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: '<promise>COMPLETE</promise>' }] } });
-      mockProc.stdout.emit('data', Buffer.from(event + '\n'));
+      // Emit COMPLETE marker
+      mockProc.stdout.emit('data', Buffer.from('<promise>COMPLETE</promise>\n'));
 
       // Grace period should expire normally (no commit check)
       jest.advanceTimersByTime(COMPLETION_GRACE_PERIOD_MS + 1);
@@ -1267,9 +1407,8 @@ describe('ClaudeRunner', () => {
         commitContext,
       });
 
-      // Emit COMPLETE marker as NDJSON
-      const event = JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: '<promise>COMPLETE</promise>' }] } });
-      mockProc.stdout.emit('data', Buffer.from(event + '\n'));
+      // Emit COMPLETE marker
+      mockProc.stdout.emit('data', Buffer.from('<promise>COMPLETE</promise>\n'));
 
       // Grace period expires - commit message doesn't match, should extend
       jest.advanceTimersByTime(COMPLETION_GRACE_PERIOD_MS + 1);
@@ -1302,9 +1441,8 @@ describe('ClaudeRunner', () => {
         commitContext,
       });
 
-      // Emit COMPLETE marker as NDJSON
-      const event = JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: '<promise>COMPLETE</promise>' }] } });
-      mockProc.stdout.emit('data', Buffer.from(event + '\n'));
+      // Emit COMPLETE marker
+      mockProc.stdout.emit('data', Buffer.from('<promise>COMPLETE</promise>\n'));
 
       // Grace period expires - file not committed, should extend
       jest.advanceTimersByTime(COMPLETION_GRACE_PERIOD_MS + 1);
@@ -1321,329 +1459,4 @@ describe('ClaudeRunner', () => {
       await runPromise;
     });
   });
-
-  describe('session ID extraction', () => {
-    function createMockProcess() {
-      const stdout = new EventEmitter();
-      const stderr = new EventEmitter();
-      const proc = new EventEmitter() as any;
-      proc.stdout = stdout;
-      proc.stderr = stderr;
-      proc.kill = jest.fn();
-      return proc;
-    }
-
-    it('should extract sessionId from system init event in run()', async () => {
-      const mockProc = createMockProcess();
-      mockSpawn.mockReturnValue(mockProc);
-
-      const runner = new ClaudeRunner();
-      const runPromise = runner.run('test prompt', { timeout: 60 });
-
-      // Emit system init event with session_id
-      const initEvent = JSON.stringify({
-        type: 'system',
-        subtype: 'init',
-        session_id: 'test-session-123',
-        tools: ['Read', 'Write'],
-        model: 'claude-opus-4-6',
-      });
-      const textEvent = JSON.stringify({
-        type: 'assistant',
-        message: { content: [{ type: 'text', text: 'done' }] },
-      });
-      mockProc.stdout.emit('data', Buffer.from(initEvent + '\n' + textEvent + '\n'));
-      mockProc.emit('close', 0);
-
-      const result = await runPromise;
-      expect(result.sessionId).toBe('test-session-123');
-    });
-
-    it('should extract sessionId from system init event in runVerbose()', async () => {
-      const mockProc = createMockProcess();
-      mockSpawn.mockReturnValue(mockProc);
-
-      const runner = new ClaudeRunner();
-      const runPromise = runner.runVerbose('test prompt', { timeout: 60 });
-
-      // Emit system init event with session_id
-      const initEvent = JSON.stringify({
-        type: 'system',
-        subtype: 'init',
-        session_id: 'verbose-session-456',
-        tools: ['Read', 'Write'],
-        model: 'claude-opus-4-6',
-      });
-      mockProc.stdout.emit('data', Buffer.from(initEvent + '\n'));
-      mockProc.emit('close', 0);
-
-      const result = await runPromise;
-      expect(result.sessionId).toBe('verbose-session-456');
-    });
-
-    it('should return undefined sessionId when no system init event', async () => {
-      const mockProc = createMockProcess();
-      mockSpawn.mockReturnValue(mockProc);
-
-      const runner = new ClaudeRunner();
-      const runPromise = runner.run('test prompt', { timeout: 60 });
-
-      // Only emit assistant event, no system init
-      const textEvent = JSON.stringify({
-        type: 'assistant',
-        message: { content: [{ type: 'text', text: 'output' }] },
-      });
-      mockProc.stdout.emit('data', Buffer.from(textEvent + '\n'));
-      mockProc.emit('close', 0);
-
-      const result = await runPromise;
-      expect(result.sessionId).toBeUndefined();
-    });
-
-    it('should expose sessionId via getter on ClaudeRunner', async () => {
-      const mockProc = createMockProcess();
-      mockSpawn.mockReturnValue(mockProc);
-
-      const runner = new ClaudeRunner();
-      expect(runner.sessionId).toBeUndefined();
-
-      const runPromise = runner.run('test prompt', { timeout: 60 });
-
-      const initEvent = JSON.stringify({
-        type: 'system',
-        subtype: 'init',
-        session_id: 'getter-session-789',
-        tools: [],
-        model: 'claude-opus-4-6',
-      });
-      mockProc.stdout.emit('data', Buffer.from(initEvent + '\n'));
-      mockProc.emit('close', 0);
-
-      await runPromise;
-      expect(runner.sessionId).toBe('getter-session-789');
-    });
-
-    it('should only capture the first sessionId (ignore duplicates)', async () => {
-      const mockProc = createMockProcess();
-      mockSpawn.mockReturnValue(mockProc);
-
-      const runner = new ClaudeRunner();
-      const runPromise = runner.run('test prompt', { timeout: 60 });
-
-      // Emit two system init events (shouldn't happen but test robustness)
-      const init1 = JSON.stringify({ type: 'system', subtype: 'init', session_id: 'first-session' });
-      const init2 = JSON.stringify({ type: 'system', subtype: 'init', session_id: 'second-session' });
-      mockProc.stdout.emit('data', Buffer.from(init1 + '\n' + init2 + '\n'));
-      mockProc.emit('close', 0);
-
-      const result = await runPromise;
-      expect(result.sessionId).toBe('first-session');
-    });
-  });
-
-  describe('runResume()', () => {
-    function createMockProcess() {
-      const stdout = new EventEmitter();
-      const stderr = new EventEmitter();
-      const proc = new EventEmitter() as any;
-      proc.stdout = stdout;
-      proc.stderr = stderr;
-      proc.kill = jest.fn().mockImplementation(() => {
-        setImmediate(() => proc.emit('close', 1));
-      });
-      return proc;
-    }
-
-    it('should spawn Claude with --resume flag and session ID', async () => {
-      const mockProc = createMockProcess();
-      mockProc.kill = jest.fn();
-      mockSpawn.mockReturnValue(mockProc);
-
-      const runner = new ClaudeRunner();
-      const runPromise = runner.runResume('test-session-abc', { timeout: 60 });
-
-      const event = JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: 'resumed output' }] } });
-      mockProc.stdout.emit('data', Buffer.from(event + '\n'));
-      mockProc.emit('close', 0);
-
-      await runPromise;
-
-      const spawnArgs = mockSpawn.mock.calls[0][1] as string[];
-      expect(spawnArgs).toContain('--resume');
-      expect(spawnArgs).toContain('test-session-abc');
-
-      // Verify --resume comes before the session ID
-      const resumeIndex = spawnArgs.indexOf('--resume');
-      expect(spawnArgs[resumeIndex + 1]).toBe('test-session-abc');
-    });
-
-    it('should NOT include --model, --append-system-prompt, or -p flags', async () => {
-      const mockProc = createMockProcess();
-      mockProc.kill = jest.fn();
-      mockSpawn.mockReturnValue(mockProc);
-
-      const runner = new ClaudeRunner({ model: 'sonnet' });
-      const runPromise = runner.runResume('session-123', { timeout: 60 });
-
-      mockProc.emit('close', 0);
-      await runPromise;
-
-      const spawnArgs = mockSpawn.mock.calls[0][1] as string[];
-      expect(spawnArgs).not.toContain('--model');
-      expect(spawnArgs).not.toContain('--append-system-prompt');
-      expect(spawnArgs).not.toContain('-p');
-    });
-
-    it('should include --dangerously-skip-permissions flag', async () => {
-      const mockProc = createMockProcess();
-      mockProc.kill = jest.fn();
-      mockSpawn.mockReturnValue(mockProc);
-
-      const runner = new ClaudeRunner();
-      const runPromise = runner.runResume('session-123', { timeout: 60 });
-
-      mockProc.emit('close', 0);
-      await runPromise;
-
-      const spawnArgs = mockSpawn.mock.calls[0][1] as string[];
-      expect(spawnArgs).toContain('--dangerously-skip-permissions');
-    });
-
-    it('should include --output-format stream-json and --verbose flags', async () => {
-      const mockProc = createMockProcess();
-      mockProc.kill = jest.fn();
-      mockSpawn.mockReturnValue(mockProc);
-
-      const runner = new ClaudeRunner();
-      const runPromise = runner.runResume('session-123', { timeout: 60 });
-
-      mockProc.emit('close', 0);
-      await runPromise;
-
-      const spawnArgs = mockSpawn.mock.calls[0][1] as string[];
-      expect(spawnArgs).toContain('--output-format');
-      expect(spawnArgs).toContain('stream-json');
-      expect(spawnArgs).toContain('--verbose');
-    });
-
-    it('should collect output from NDJSON events', async () => {
-      const mockProc = createMockProcess();
-      mockProc.kill = jest.fn();
-      mockSpawn.mockReturnValue(mockProc);
-
-      const runner = new ClaudeRunner();
-      const runPromise = runner.runResume('session-123', { timeout: 60 });
-
-      const event1 = JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: 'chunk1' }] } });
-      const event2 = JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: 'chunk2' }] } });
-      mockProc.stdout.emit('data', Buffer.from(event1 + '\n' + event2 + '\n'));
-      mockProc.emit('close', 0);
-
-      const result = await runPromise;
-      expect(result.output).toBe('chunk1chunk2');
-    });
-
-    it('should handle timeout correctly', async () => {
-      const mockProc = createMockProcess();
-      mockSpawn.mockReturnValue(mockProc);
-
-      const runner = new ClaudeRunner();
-      const runPromise = runner.runResume('session-123', { timeout: 5 }); // 5 minutes
-
-      // Fast forward past timeout
-      jest.advanceTimersByTime(300001);
-      expect(mockProc.kill).toHaveBeenCalledWith('SIGTERM');
-
-      const result = await runPromise;
-      expect(result.timedOut).toBe(true);
-    });
-
-    it('should detect completion markers', async () => {
-      const mockProc = createMockProcess();
-      mockSpawn.mockReturnValue(mockProc);
-
-      const runner = new ClaudeRunner();
-      const runPromise = runner.runResume('session-123', { timeout: 60 });
-
-      const event = JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: '<promise>COMPLETE</promise>' }] } });
-      mockProc.stdout.emit('data', Buffer.from(event + '\n'));
-
-      // Grace period should start
-      expect(mockProc.kill).not.toHaveBeenCalled();
-      jest.advanceTimersByTime(COMPLETION_GRACE_PERIOD_MS + 1);
-      expect(mockProc.kill).toHaveBeenCalledWith('SIGTERM');
-
-      await runPromise;
-    });
-
-    it('should extract session ID from resumed session', async () => {
-      const mockProc = createMockProcess();
-      mockProc.kill = jest.fn();
-      mockSpawn.mockReturnValue(mockProc);
-
-      const runner = new ClaudeRunner();
-      const runPromise = runner.runResume('old-session-123', { timeout: 60 });
-
-      const initEvent = JSON.stringify({ type: 'system', subtype: 'init', session_id: 'new-session-456' });
-      const textEvent = JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: 'done' }] } });
-      mockProc.stdout.emit('data', Buffer.from(initEvent + '\n' + textEvent + '\n'));
-      mockProc.emit('close', 0);
-
-      const result = await runPromise;
-      expect(result.sessionId).toBe('new-session-456');
-      expect(runner.sessionId).toBe('new-session-456');
-    });
-
-    it('should pass cwd to spawn', async () => {
-      const mockProc = createMockProcess();
-      mockProc.kill = jest.fn();
-      mockSpawn.mockReturnValue(mockProc);
-
-      const runner = new ClaudeRunner();
-      const runPromise = runner.runResume('session-123', { timeout: 60, cwd: '/worktree/path' });
-
-      mockProc.emit('close', 0);
-      await runPromise;
-
-      expect(mockSpawn).toHaveBeenCalledWith(
-        expect.any(String),
-        expect.any(Array),
-        expect.objectContaining({ cwd: '/worktree/path' })
-      );
-    });
-
-    it('should detect context overflow', async () => {
-      jest.useRealTimers();
-
-      const mockProc = createMockProcess();
-      mockSpawn.mockReturnValue(mockProc);
-
-      const runner = new ClaudeRunner();
-      const runPromise = runner.runResume('session-123', { timeout: 60 });
-
-      const event = JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: 'Error: context length exceeded' }] } });
-      mockProc.stdout.emit('data', Buffer.from(event + '\n'));
-
-      const result = await runPromise;
-      expect(result.contextOverflow).toBe(true);
-      expect(mockProc.kill).toHaveBeenCalledWith('SIGTERM');
-
-      jest.useFakeTimers();
-    });
-
-    it('should set CLAUDE_CODE_EFFORT_LEVEL env var when effortLevel is provided', async () => {
-      const mockProc = createMockProcess();
-      mockProc.kill = jest.fn();
-      mockSpawn.mockReturnValue(mockProc);
-
-      const runner = new ClaudeRunner();
-      const runPromise = runner.runResume('session-123', { timeout: 60, effortLevel: 'medium' });
-
-      mockProc.emit('close', 0);
-      await runPromise;
-
-      const spawnOptions = mockSpawn.mock.calls[0][2];
-      expect(spawnOptions.env.CLAUDE_CODE_EFFORT_LEVEL).toBe('medium');
-    });
-  });
 });