rafcode 1.3.2 → 2.1.0

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

@@ -140,7 +140,8 @@ describe('ClaudeRunner', () => {
       const runPromise = runner.run('test prompt', { timeout: 5 });
 
       // Emit some output and close the process normally
-      mockProc.stdout.emit('data', Buffer.from('<promise>COMPLETE</promise>'));
+      const event = JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: '<promise>COMPLETE</promise>' }] } });
+      mockProc.stdout.emit('data', Buffer.from(event + '\n'));
       mockProc.emit('close', 0);
 
       const result = await runPromise;
@@ -162,8 +163,9 @@ describe('ClaudeRunner', () => {
 
       const runPromise1 = runner.run('first prompt', { timeout: 2 });
 
-      // Complete first call quickly
-      mockProc1.stdout.emit('data', Buffer.from('output'));
+      // 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'));
       mockProc1.emit('close', 0);
       await runPromise1;
 
@@ -211,8 +213,9 @@ describe('ClaudeRunner', () => {
       // Advance a bit but not to timeout
       jest.advanceTimersByTime(30000);
 
-      // Complete process
-      mockProc.stdout.emit('data', Buffer.from('output'));
+      // Complete process (NDJSON event)
+      const event = JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: 'output' }] } });
+      mockProc.stdout.emit('data', Buffer.from(event + '\n'));
       mockProc.emit('close', 0);
 
       const result = await runPromise;
@@ -232,8 +235,9 @@ describe('ClaudeRunner', () => {
       jest.advanceTimersByTime(1000);
       expect(mockProc.kill).not.toHaveBeenCalled();
 
-      // Complete the process normally before reaching the 60 minute timeout
-      mockProc.stdout.emit('data', Buffer.from('output'));
+      // 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'));
       mockProc.emit('close', 0);
 
       const result = await runPromise;
@@ -305,8 +309,9 @@ describe('ClaudeRunner', () => {
       const runner = new ClaudeRunner();
       const runPromise = runner.run('test prompt', { timeout: 60 });
 
-      // Emit context overflow message
-      mockProc.stdout.emit('data', Buffer.from('Error: context length exceeded'));
+      // 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'));
 
       const result = await runPromise;
       expect(result.contextOverflow).toBe(true);
@@ -333,7 +338,9 @@ describe('ClaudeRunner', () => {
         const runner = new ClaudeRunner();
         const runPromise = runner.run('test prompt', { timeout: 60 });
 
-        mockProc.stdout.emit('data', Buffer.from(`Error: ${pattern}`));
+        // 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'));
 
         const result = await runPromise;
         expect(result.contextOverflow).toBe(true);
@@ -355,17 +362,18 @@ describe('ClaudeRunner', () => {
       return proc;
     }
 
-    it('should collect all stdout output', async () => {
+    it('should collect all stdout output from NDJSON events', async () => {
       const mockProc = createMockProcess();
       mockSpawn.mockReturnValue(mockProc);
 
       const runner = new ClaudeRunner();
       const runPromise = runner.run('test prompt', { timeout: 60 });
 
-      // Emit multiple chunks
-      mockProc.stdout.emit('data', Buffer.from('chunk1'));
-      mockProc.stdout.emit('data', Buffer.from('chunk2'));
-      mockProc.stdout.emit('data', Buffer.from('chunk3'));
+      // 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'));
       mockProc.emit('close', 0);
 
       const result = await runPromise;
@@ -472,6 +480,109 @@ describe('ClaudeRunner', () => {
     });
   });
 
+  describe('effort level', () => {
+    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 set CLAUDE_CODE_EFFORT_LEVEL env var in run() when effortLevel is provided', async () => {
+      const mockProc = createMockProcess();
+      mockSpawn.mockReturnValue(mockProc);
+
+      const runner = new ClaudeRunner();
+      const runPromise = runner.run('test prompt', { 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');
+    });
+
+    it('should set CLAUDE_CODE_EFFORT_LEVEL env var in runVerbose() when effortLevel is provided', async () => {
+      const mockProc = createMockProcess();
+      mockSpawn.mockReturnValue(mockProc);
+
+      const runner = new ClaudeRunner();
+      const runPromise = runner.runVerbose('test prompt', { 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');
+    });
+
+    it('should NOT set CLAUDE_CODE_EFFORT_LEVEL when effortLevel is not provided in run()', async () => {
+      const mockProc = createMockProcess();
+      mockSpawn.mockReturnValue(mockProc);
+
+      const runner = new ClaudeRunner();
+      const runPromise = runner.run('test prompt', { timeout: 60 });
+
+      mockProc.emit('close', 0);
+      await runPromise;
+
+      const spawnOptions = mockSpawn.mock.calls[0][2];
+      // env should be process.env directly (no CLAUDE_CODE_EFFORT_LEVEL override)
+      expect(spawnOptions.env).toBe(process.env);
+    });
+
+    it('should NOT set CLAUDE_CODE_EFFORT_LEVEL when effortLevel is not provided in runVerbose()', async () => {
+      const mockProc = createMockProcess();
+      mockSpawn.mockReturnValue(mockProc);
+
+      const runner = new ClaudeRunner();
+      const runPromise = runner.runVerbose('test prompt', { timeout: 60 });
+
+      mockProc.emit('close', 0);
+      await runPromise;
+
+      const spawnOptions = mockSpawn.mock.calls[0][2];
+      // env should be process.env directly (no CLAUDE_CODE_EFFORT_LEVEL override)
+      expect(spawnOptions.env).toBe(process.env);
+    });
+
+    it('should support different effort levels', async () => {
+      for (const level of ['low', 'medium', 'high'] as const) {
+        const mockProc = createMockProcess();
+        mockSpawn.mockReturnValue(mockProc);
+
+        const runner = new ClaudeRunner();
+        const runPromise = runner.run('test prompt', { timeout: 60, effortLevel: level });
+
+        mockProc.emit('close', 0);
+        await runPromise;
+
+        const spawnOptions = mockSpawn.mock.calls[mockSpawn.mock.calls.length - 1][2];
+        expect(spawnOptions.env.CLAUDE_CODE_EFFORT_LEVEL).toBe(level);
+      }
+    });
+
+    it('should preserve other env vars when effortLevel is set', async () => {
+      const mockProc = createMockProcess();
+      mockSpawn.mockReturnValue(mockProc);
+
+      const runner = new ClaudeRunner();
+      const runPromise = runner.run('test prompt', { timeout: 60, effortLevel: 'medium' });
+
+      mockProc.emit('close', 0);
+      await runPromise;
+
+      const spawnOptions = mockSpawn.mock.calls[0][2];
+      // Should have PATH from process.env
+      expect(spawnOptions.env.PATH).toBe(process.env.PATH);
+      // And the injected effort level
+      expect(spawnOptions.env.CLAUDE_CODE_EFFORT_LEVEL).toBe('medium');
+    });
+  });
+
   describe('system prompt append flag', () => {
     function createMockProcess() {
       const stdout = new EventEmitter();
@@ -593,7 +704,7 @@ describe('ClaudeRunner', () => {
       expect(spawnArgs).toContain('--verbose');
     });
 
-    it('should NOT include --output-format or --verbose flags in run()', async () => {
+    it('should include --output-format stream-json and --verbose flags in run()', async () => {
       const mockProc = createMockProcess();
       mockSpawn.mockReturnValue(mockProc);
 
@@ -604,9 +715,9 @@ describe('ClaudeRunner', () => {
       await runPromise;
 
       const spawnArgs = mockSpawn.mock.calls[0][1] as string[];
-      expect(spawnArgs).not.toContain('--output-format');
-      expect(spawnArgs).not.toContain('stream-json');
-      expect(spawnArgs).not.toContain('--verbose');
+      expect(spawnArgs).toContain('--output-format');
+      expect(spawnArgs).toContain('stream-json');
+      expect(spawnArgs).toContain('--verbose');
     });
 
     it('should extract text from NDJSON assistant events', async () => {
@@ -693,8 +804,9 @@ describe('ClaudeRunner', () => {
       jest.advanceTimersByTime(60000);
       expect(mockProc2.kill).not.toHaveBeenCalled();
 
-      // Complete successfully
-      mockProc2.stdout.emit('data', Buffer.from('success'));
+      // Complete successfully (NDJSON event)
+      const successEvent = JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: 'success' }] } });
+      mockProc2.stdout.emit('data', Buffer.from(successEvent + '\n'));
       mockProc2.emit('close', 0);
 
       const result2 = await runPromise2;
@@ -715,8 +827,9 @@ describe('ClaudeRunner', () => {
       // Run for 4 minutes (240000ms)
       jest.advanceTimersByTime(240000);
 
-      // Fail without timeout
-      mockProc1.stdout.emit('data', Buffer.from('<promise>FAILED</promise>'));
+      // 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'));
       mockProc1.emit('close', 1);
 
       const result1 = await runPromise1;
@@ -766,8 +879,9 @@ describe('ClaudeRunner', () => {
       const runner = new ClaudeRunner();
       const runPromise = runner.run('test prompt', { timeout: 60 });
 
-      // Emit output with completion marker
-      mockProc.stdout.emit('data', Buffer.from('Writing outcome...\n<promise>COMPLETE</promise>\n'));
+      // 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'));
 
       // Process should not be killed immediately
       expect(mockProc.kill).not.toHaveBeenCalled();
@@ -792,8 +906,9 @@ describe('ClaudeRunner', () => {
       const runner = new ClaudeRunner();
       const runPromise = runner.run('test prompt', { timeout: 60 });
 
-      // Emit output with failed marker
-      mockProc.stdout.emit('data', Buffer.from('<promise>FAILED</promise>\nReason: test error'));
+      // 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'));
 
       // Advance past grace period
       jest.advanceTimersByTime(COMPLETION_GRACE_PERIOD_MS + 1);
@@ -810,13 +925,15 @@ describe('ClaudeRunner', () => {
       const runner = new ClaudeRunner();
       const runPromise = runner.run('test prompt', { timeout: 60 });
 
-      // Emit partial output (no marker yet)
-      mockProc.stdout.emit('data', Buffer.from('Working on task...\n'));
+      // 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'));
       jest.advanceTimersByTime(10000);
       expect(mockProc.kill).not.toHaveBeenCalled();
 
-      // Emit marker in second chunk
-      mockProc.stdout.emit('data', Buffer.from('<promise>COMPLETE</promise>\n'));
+      // 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'));
 
       // Grace period starts now - advance past it
       jest.advanceTimersByTime(COMPLETION_GRACE_PERIOD_MS + 1);
@@ -834,8 +951,9 @@ describe('ClaudeRunner', () => {
       const runner = new ClaudeRunner();
       const runPromise = runner.run('test prompt', { timeout: 60 });
 
-      // Emit completion marker
-      mockProc.stdout.emit('data', Buffer.from('<promise>COMPLETE</promise>\n'));
+      // 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'));
 
       // Process exits naturally before grace period
       jest.advanceTimersByTime(5000);
@@ -854,7 +972,7 @@ describe('ClaudeRunner', () => {
       const mockProc = createMockProcess();
       mockSpawn.mockReturnValue(mockProc);
 
-      const outcomePath = '/test/project/outcomes/001-task.md';
+      const outcomePath = '/test/project/outcomes/01-task.md';
 
       // Outcome file doesn't exist initially
       mockExistsSync.mockReturnValue(false);
@@ -865,8 +983,9 @@ describe('ClaudeRunner', () => {
         outcomeFilePath: outcomePath,
       });
 
-      // No output marker in stdout - just regular output
-      mockProc.stdout.emit('data', Buffer.from('Working on task...'));
+      // 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'));
 
       // After some time, outcome file appears with marker
       jest.advanceTimersByTime(OUTCOME_POLL_INTERVAL_MS - 1);
@@ -893,7 +1012,7 @@ describe('ClaudeRunner', () => {
       mockProc.kill = jest.fn();
       mockSpawn.mockReturnValue(mockProc);
 
-      const outcomePath = '/test/project/outcomes/001-task.md';
+      const outcomePath = '/test/project/outcomes/01-task.md';
 
       // Outcome file already exists from previous failed run
       mockExistsSync.mockReturnValue(true);
@@ -910,8 +1029,9 @@ describe('ClaudeRunner', () => {
       jest.advanceTimersByTime(OUTCOME_POLL_INTERVAL_MS * 5);
       expect(mockProc.kill).not.toHaveBeenCalled();
 
-      // Complete normally
-      mockProc.stdout.emit('data', Buffer.from('done'));
+      // Complete normally (NDJSON event)
+      const doneEvent = JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: 'done' }] } });
+      mockProc.stdout.emit('data', Buffer.from(doneEvent + '\n'));
       mockProc.emit('close', 0);
 
       await runPromise;
@@ -944,14 +1064,16 @@ describe('ClaudeRunner', () => {
       const runner = new ClaudeRunner();
       const runPromise = runner.run('test prompt', { timeout: 60 });
 
-      // Emit first marker
-      mockProc.stdout.emit('data', Buffer.from('<promise>COMPLETE</promise>\n'));
+      // 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'));
 
       // Advance halfway through grace period
       jest.advanceTimersByTime(COMPLETION_GRACE_PERIOD_MS / 2);
 
-      // Emit second marker (e.g., Claude reading back what it wrote)
-      mockProc.stdout.emit('data', Buffer.from('Verified: <promise>COMPLETE</promise>\n'));
+      // 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'));
 
       // Advance remaining grace period from FIRST detection
       jest.advanceTimersByTime(COMPLETION_GRACE_PERIOD_MS / 2 + 1);
@@ -981,8 +1103,8 @@ describe('ClaudeRunner', () => {
 
     const commitContext = {
       preExecutionHead: 'aaa111',
-      expectedPrefix: 'RAF[005:001]',
-      outcomeFilePath: '/project/outcomes/001-task.md',
+      expectedPrefix: 'RAF[005:01]',
+      outcomeFilePath: '/project/outcomes/01-task.md',
     };
 
     beforeEach(() => {
@@ -998,7 +1120,7 @@ describe('ClaudeRunner', () => {
 
       // Commit lands during grace period
       mockGetHeadCommitHash.mockReturnValue('bbb222');
-      mockGetHeadCommitMessage.mockReturnValue('RAF[005:001] Add feature');
+      mockGetHeadCommitMessage.mockReturnValue('RAF[005:01] Add feature');
       mockIsFileCommittedInHead.mockReturnValue(true);
 
       const runner = new ClaudeRunner();
@@ -1007,8 +1129,9 @@ describe('ClaudeRunner', () => {
         commitContext,
       });
 
-      // Emit COMPLETE marker
-      mockProc.stdout.emit('data', Buffer.from('<promise>COMPLETE</promise>\n'));
+      // 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'));
 
       // Advance to grace period expiry - commit already verified
       jest.advanceTimersByTime(COMPLETION_GRACE_PERIOD_MS + 1);
@@ -1032,8 +1155,9 @@ describe('ClaudeRunner', () => {
         commitContext,
       });
 
-      // Emit COMPLETE marker
-      mockProc.stdout.emit('data', Buffer.from('<promise>COMPLETE</promise>\n'));
+      // 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'));
 
       // Advance past initial grace period - commit not found, should extend
       jest.advanceTimersByTime(COMPLETION_GRACE_PERIOD_MS + 1);
@@ -1042,7 +1166,7 @@ describe('ClaudeRunner', () => {
 
       // Now simulate commit landing during extended polling
       mockGetHeadCommitHash.mockReturnValue('bbb222');
-      mockGetHeadCommitMessage.mockReturnValue('RAF[005:001] Add feature');
+      mockGetHeadCommitMessage.mockReturnValue('RAF[005:01] Add feature');
       mockIsFileCommittedInHead.mockReturnValue(true);
 
       // Advance to next commit poll interval
@@ -1067,8 +1191,9 @@ describe('ClaudeRunner', () => {
         commitContext,
       });
 
-      // Emit COMPLETE marker
-      mockProc.stdout.emit('data', Buffer.from('<promise>COMPLETE</promise>\n'));
+      // 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'));
 
       // Advance past initial grace period
       jest.advanceTimersByTime(COMPLETION_GRACE_PERIOD_MS + 1);
@@ -1094,8 +1219,9 @@ describe('ClaudeRunner', () => {
         commitContext,
       });
 
-      // Emit FAILED marker (not COMPLETE)
-      mockProc.stdout.emit('data', Buffer.from('<promise>FAILED</promise>\n'));
+      // 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'));
 
       // Grace period should expire normally without extension
       jest.advanceTimersByTime(COMPLETION_GRACE_PERIOD_MS + 1);
@@ -1114,8 +1240,9 @@ describe('ClaudeRunner', () => {
         // No commitContext provided
       });
 
-      // Emit COMPLETE marker
-      mockProc.stdout.emit('data', Buffer.from('<promise>COMPLETE</promise>\n'));
+      // 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'));
 
       // Grace period should expire normally (no commit check)
       jest.advanceTimersByTime(COMPLETION_GRACE_PERIOD_MS + 1);
@@ -1131,7 +1258,7 @@ describe('ClaudeRunner', () => {
 
       // HEAD changed but message doesn't match expected prefix
       mockGetHeadCommitHash.mockReturnValue('bbb222');
-      mockGetHeadCommitMessage.mockReturnValue('RAF[005:002] Wrong task');
+      mockGetHeadCommitMessage.mockReturnValue('RAF[005:02] Wrong task');
       mockIsFileCommittedInHead.mockReturnValue(true);
 
       const runner = new ClaudeRunner();
@@ -1140,15 +1267,16 @@ describe('ClaudeRunner', () => {
         commitContext,
       });
 
-      // Emit COMPLETE marker
-      mockProc.stdout.emit('data', Buffer.from('<promise>COMPLETE</promise>\n'));
+      // 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'));
 
       // Grace period expires - commit message doesn't match, should extend
       jest.advanceTimersByTime(COMPLETION_GRACE_PERIOD_MS + 1);
       expect(mockProc.kill).not.toHaveBeenCalled();
 
       // Fix commit message
-      mockGetHeadCommitMessage.mockReturnValue('RAF[005:001] Correct task');
+      mockGetHeadCommitMessage.mockReturnValue('RAF[005:01] Correct task');
 
       // Next poll finds it
       jest.advanceTimersByTime(COMMIT_POLL_INTERVAL_MS);
@@ -1165,7 +1293,7 @@ describe('ClaudeRunner', () => {
 
       // HEAD changed and message matches, but file not committed
       mockGetHeadCommitHash.mockReturnValue('bbb222');
-      mockGetHeadCommitMessage.mockReturnValue('RAF[005:001] Add feature');
+      mockGetHeadCommitMessage.mockReturnValue('RAF[005:01] Add feature');
       mockIsFileCommittedInHead.mockReturnValue(false);
 
       const runner = new ClaudeRunner();
@@ -1174,8 +1302,9 @@ describe('ClaudeRunner', () => {
         commitContext,
       });
 
-      // Emit COMPLETE marker
-      mockProc.stdout.emit('data', Buffer.from('<promise>COMPLETE</promise>\n'));
+      // 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'));
 
       // Grace period expires - file not committed, should extend
       jest.advanceTimersByTime(COMPLETION_GRACE_PERIOD_MS + 1);
@@ -1192,4 +1321,329 @@ 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');
+    });
+  });
 });