rafcode 2.1.0 → 2.1.1

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
+      mockProc.stdout.emit('data', Buffer.from('Error: context length exceeded'));
 
       const result = await runPromise;
       expect(result.contextOverflow).toBe(true);
@@ -338,9 +333,7 @@ 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'));
+        mockProc.stdout.emit('data', Buffer.from(`Error: ${pattern}`));
 
         const result = await runPromise;
         expect(result.contextOverflow).toBe(true);
@@ -362,18 +355,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 +696,7 @@ describe('ClaudeRunner', () => {
       expect(spawnArgs).toContain('--verbose');
     });
 
-    it('should include --output-format stream-json and --verbose flags in run()', async () => {
+    it('should NOT include --output-format or --verbose flags in run()', async () => {
       const mockProc = createMockProcess();
       mockSpawn.mockReturnValue(mockProc);
 
@@ -715,9 +707,9 @@ describe('ClaudeRunner', () => {
       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');
+      expect(spawnArgs).not.toContain('--output-format');
+      expect(spawnArgs).not.toContain('stream-json');
+      expect(spawnArgs).not.toContain('--verbose');
     });
 
     it('should extract text from NDJSON assistant events', async () => {
@@ -804,9 +796,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 +818,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 +869,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 +895,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 +913,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 +937,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 +968,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 +1013,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 +1047,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 +1110,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 +1135,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 +1170,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 +1197,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 +1217,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 +1243,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 +1277,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 +1295,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');
-    });
-  });
 });