rafcode 1.2.0 → 1.3.2

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

@@ -5,13 +5,40 @@ import { EventEmitter } from 'events';
 const mockSpawn = jest.fn();
 const mockExecSync = jest.fn();
 
+// Create mock fs functions
+const mockExistsSync = jest.fn();
+const mockStatSync = jest.fn();
+const mockReadFileSync = jest.fn();
+
+// Create mock git functions
+const mockGetHeadCommitHash = jest.fn();
+const mockGetHeadCommitMessage = jest.fn();
+const mockIsFileCommittedInHead = jest.fn();
+
 jest.unstable_mockModule('node:child_process', () => ({
   spawn: mockSpawn,
   execSync: mockExecSync,
 }));
 
+jest.unstable_mockModule('node:fs', () => ({
+  default: {
+    existsSync: mockExistsSync,
+    statSync: mockStatSync,
+    readFileSync: mockReadFileSync,
+  },
+  existsSync: mockExistsSync,
+  statSync: mockStatSync,
+  readFileSync: mockReadFileSync,
+}));
+
+jest.unstable_mockModule('../../src/core/git.js', () => ({
+  getHeadCommitHash: mockGetHeadCommitHash,
+  getHeadCommitMessage: mockGetHeadCommitMessage,
+  isFileCommittedInHead: mockIsFileCommittedInHead,
+}));
+
 // Import after mocking
-const { ClaudeRunner } = await import('../../src/core/claude-runner.js');
+const { ClaudeRunner, COMPLETION_GRACE_PERIOD_MS, COMPLETION_HARD_MAX_MS, COMMIT_POLL_INTERVAL_MS, OUTCOME_POLL_INTERVAL_MS } = await import('../../src/core/claude-runner.js');
 
 describe('ClaudeRunner', () => {
   beforeEach(() => {
@@ -539,6 +566,93 @@ describe('ClaudeRunner', () => {
     });
   });
 
+  describe('verbose stream-json output', () => {
+    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 include --output-format stream-json and --verbose flags 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 spawnArgs = mockSpawn.mock.calls[0][1] as string[];
+      expect(spawnArgs).toContain('--output-format');
+      expect(spawnArgs).toContain('stream-json');
+      expect(spawnArgs).toContain('--verbose');
+    });
+
+    it('should NOT include --output-format or --verbose flags 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 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');
+    });
+
+    it('should extract text from NDJSON assistant events', async () => {
+      const mockProc = createMockProcess();
+      mockSpawn.mockReturnValue(mockProc);
+
+      const runner = new ClaudeRunner();
+      const runPromise = runner.runVerbose('test prompt', { timeout: 60 });
+
+      // Emit NDJSON lines like real stream-json output
+      const systemEvent = JSON.stringify({ type: 'system', subtype: 'init' });
+      const assistantEvent = JSON.stringify({
+        type: 'assistant',
+        message: { content: [{ type: 'text', text: 'Task complete.\n<promise>COMPLETE</promise>' }] },
+      });
+      const resultEvent = JSON.stringify({ type: 'result', subtype: 'success', result: 'Task complete.' });
+
+      mockProc.stdout.emit('data', Buffer.from(systemEvent + '\n' + assistantEvent + '\n' + resultEvent + '\n'));
+      mockProc.emit('close', 0);
+
+      const result = await runPromise;
+      expect(result.output).toContain('Task complete.');
+      expect(result.output).toContain('<promise>COMPLETE</promise>');
+    });
+
+    it('should extract text from tool_use NDJSON events without adding to output', async () => {
+      const mockProc = createMockProcess();
+      mockSpawn.mockReturnValue(mockProc);
+
+      const runner = new ClaudeRunner();
+      const runPromise = runner.runVerbose('test prompt', { timeout: 60 });
+
+      const toolEvent = JSON.stringify({
+        type: 'assistant',
+        message: { content: [{ type: 'tool_use', name: 'Read', input: { file_path: '/test.ts' } }] },
+      });
+
+      mockProc.stdout.emit('data', Buffer.from(toolEvent + '\n'));
+      mockProc.emit('close', 0);
+
+      const result = await runPromise;
+      // Tool use events don't add text to output
+      expect(result.output).toBe('');
+    });
+  });
+
   describe('retry isolation (timeout per attempt)', () => {
     function createMockProcess() {
       const stdout = new EventEmitter();
@@ -626,4 +740,456 @@ describe('ClaudeRunner', () => {
       expect(result2.timedOut).toBe(true);
     });
   });
+
+  describe('completion detection', () => {
+    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;
+    }
+
+    beforeEach(() => {
+      // Default: no outcome file exists
+      mockExistsSync.mockReturnValue(false);
+    });
+
+    it('should start grace period when COMPLETE marker detected in stdout', async () => {
+      const mockProc = createMockProcess();
+      mockSpawn.mockReturnValue(mockProc);
+
+      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'));
+
+      // Process should not be killed immediately
+      expect(mockProc.kill).not.toHaveBeenCalled();
+
+      // Advance to just before grace period expires
+      jest.advanceTimersByTime(COMPLETION_GRACE_PERIOD_MS - 1);
+      expect(mockProc.kill).not.toHaveBeenCalled();
+
+      // Advance past grace period
+      jest.advanceTimersByTime(2);
+      expect(mockProc.kill).toHaveBeenCalledWith('SIGTERM');
+
+      const result = await runPromise;
+      expect(result.timedOut).toBe(false); // Not a timeout, it's a grace period kill
+      expect(result.output).toContain('<promise>COMPLETE</promise>');
+    });
+
+    it('should start grace period when FAILED marker detected in stdout', async () => {
+      const mockProc = createMockProcess();
+      mockSpawn.mockReturnValue(mockProc);
+
+      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'));
+
+      // Advance past grace period
+      jest.advanceTimersByTime(COMPLETION_GRACE_PERIOD_MS + 1);
+      expect(mockProc.kill).toHaveBeenCalledWith('SIGTERM');
+
+      const result = await runPromise;
+      expect(result.timedOut).toBe(false);
+    });
+
+    it('should detect marker across multiple stdout chunks', async () => {
+      const mockProc = createMockProcess();
+      mockSpawn.mockReturnValue(mockProc);
+
+      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'));
+      jest.advanceTimersByTime(10000);
+      expect(mockProc.kill).not.toHaveBeenCalled();
+
+      // 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);
+      expect(mockProc.kill).toHaveBeenCalledWith('SIGTERM');
+
+      await runPromise;
+    });
+
+    it('should not start grace period if process exits before grace period expires', async () => {
+      const mockProc = createMockProcess();
+      // Override kill to NOT auto-close (so we can test natural close)
+      mockProc.kill = jest.fn();
+      mockSpawn.mockReturnValue(mockProc);
+
+      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'));
+
+      // Process exits naturally before grace period
+      jest.advanceTimersByTime(5000);
+      mockProc.emit('close', 0);
+
+      const result = await runPromise;
+      expect(result.exitCode).toBe(0);
+      expect(result.output).toContain('<promise>COMPLETE</promise>');
+
+      // Grace period should have been cleaned up - advancing further should not call kill
+      jest.advanceTimersByTime(COMPLETION_GRACE_PERIOD_MS);
+      expect(mockProc.kill).not.toHaveBeenCalled();
+    });
+
+    it('should detect completion via outcome file polling', async () => {
+      const mockProc = createMockProcess();
+      mockSpawn.mockReturnValue(mockProc);
+
+      const outcomePath = '/test/project/outcomes/001-task.md';
+
+      // Outcome file doesn't exist initially
+      mockExistsSync.mockReturnValue(false);
+
+      const runner = new ClaudeRunner();
+      const runPromise = runner.run('test prompt', {
+        timeout: 60,
+        outcomeFilePath: outcomePath,
+      });
+
+      // 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);
+      expect(mockProc.kill).not.toHaveBeenCalled();
+
+      // Mock that file now exists with COMPLETE marker
+      mockExistsSync.mockReturnValue(true);
+      mockStatSync.mockReturnValue({ mtimeMs: Date.now() + 1000 });
+      mockReadFileSync.mockReturnValue('# Outcome\n\n<promise>COMPLETE</promise>\n');
+
+      // Advance to trigger poll
+      jest.advanceTimersByTime(2);
+
+      // Grace period started - advance past it
+      jest.advanceTimersByTime(COMPLETION_GRACE_PERIOD_MS + 1);
+      expect(mockProc.kill).toHaveBeenCalledWith('SIGTERM');
+
+      await runPromise;
+    });
+
+    it('should not trigger on pre-existing outcome file from previous run', async () => {
+      const mockProc = createMockProcess();
+      // Override kill to NOT auto-close
+      mockProc.kill = jest.fn();
+      mockSpawn.mockReturnValue(mockProc);
+
+      const outcomePath = '/test/project/outcomes/001-task.md';
+
+      // Outcome file already exists from previous failed run
+      mockExistsSync.mockReturnValue(true);
+      mockStatSync.mockReturnValue({ mtimeMs: 1000 }); // Old timestamp
+      mockReadFileSync.mockReturnValue('# Outcome\n\n<promise>FAILED</promise>\n');
+
+      const runner = new ClaudeRunner();
+      const runPromise = runner.run('test prompt', {
+        timeout: 60,
+        outcomeFilePath: outcomePath,
+      });
+
+      // Advance past several poll intervals - should not trigger because mtime unchanged
+      jest.advanceTimersByTime(OUTCOME_POLL_INTERVAL_MS * 5);
+      expect(mockProc.kill).not.toHaveBeenCalled();
+
+      // Complete normally
+      mockProc.stdout.emit('data', Buffer.from('done'));
+      mockProc.emit('close', 0);
+
+      await runPromise;
+    });
+
+    it('should work with runVerbose() too', async () => {
+      const mockProc = createMockProcess();
+      mockSpawn.mockReturnValue(mockProc);
+
+      const runner = new ClaudeRunner();
+      const runPromise = runner.runVerbose('test prompt', { timeout: 60 });
+
+      // Emit output with completion marker
+      mockProc.stdout.emit('data', Buffer.from('<promise>COMPLETE</promise>\n'));
+
+      // Advance past grace period
+      jest.advanceTimersByTime(COMPLETION_GRACE_PERIOD_MS + 1);
+      expect(mockProc.kill).toHaveBeenCalledWith('SIGTERM');
+
+      const result = await runPromise;
+      expect(result.timedOut).toBe(false);
+    });
+
+    it('should not start multiple grace periods for repeated markers', async () => {
+      const mockProc = createMockProcess();
+      // Override kill to NOT auto-close (to test multiple markers)
+      mockProc.kill = jest.fn();
+      mockSpawn.mockReturnValue(mockProc);
+
+      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'));
+
+      // 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'));
+
+      // Advance remaining grace period from FIRST detection
+      jest.advanceTimersByTime(COMPLETION_GRACE_PERIOD_MS / 2 + 1);
+
+      // Should be killed once (from the first grace period)
+      expect(mockProc.kill).toHaveBeenCalledTimes(1);
+      expect(mockProc.kill).toHaveBeenCalledWith('SIGTERM');
+
+      // Close process manually for cleanup
+      mockProc.emit('close', 1);
+      await runPromise;
+    });
+  });
+
+  describe('commit verification during grace period', () => {
+    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;
+    }
+
+    const commitContext = {
+      preExecutionHead: 'aaa111',
+      expectedPrefix: 'RAF[005:001]',
+      outcomeFilePath: '/project/outcomes/001-task.md',
+    };
+
+    beforeEach(() => {
+      mockExistsSync.mockReturnValue(false);
+      mockGetHeadCommitHash.mockReturnValue('aaa111');
+      mockGetHeadCommitMessage.mockReturnValue(null);
+      mockIsFileCommittedInHead.mockReturnValue(false);
+    });
+
+    it('should kill immediately after grace period when commit is verified within grace period', async () => {
+      const mockProc = createMockProcess();
+      mockSpawn.mockReturnValue(mockProc);
+
+      // Commit lands during grace period
+      mockGetHeadCommitHash.mockReturnValue('bbb222');
+      mockGetHeadCommitMessage.mockReturnValue('RAF[005:001] Add feature');
+      mockIsFileCommittedInHead.mockReturnValue(true);
+
+      const runner = new ClaudeRunner();
+      const runPromise = runner.run('test prompt', {
+        timeout: 60,
+        commitContext,
+      });
+
+      // 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);
+      expect(mockProc.kill).toHaveBeenCalledWith('SIGTERM');
+
+      await runPromise;
+    });
+
+    it('should extend grace period and find commit during extended polling', async () => {
+      const mockProc = createMockProcess();
+      // Override kill to NOT auto-close so we can test polling
+      mockProc.kill = jest.fn();
+      mockSpawn.mockReturnValue(mockProc);
+
+      // Commit not yet made
+      mockGetHeadCommitHash.mockReturnValue('aaa111');
+
+      const runner = new ClaudeRunner();
+      const runPromise = runner.run('test prompt', {
+        timeout: 60,
+        commitContext,
+      });
+
+      // 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);
+      // Should NOT be killed yet because commit verification failed and we extend
+      expect(mockProc.kill).not.toHaveBeenCalled();
+
+      // Now simulate commit landing during extended polling
+      mockGetHeadCommitHash.mockReturnValue('bbb222');
+      mockGetHeadCommitMessage.mockReturnValue('RAF[005:001] Add feature');
+      mockIsFileCommittedInHead.mockReturnValue(true);
+
+      // Advance to next commit poll interval
+      jest.advanceTimersByTime(COMMIT_POLL_INTERVAL_MS);
+      expect(mockProc.kill).toHaveBeenCalledWith('SIGTERM');
+
+      // Clean up
+      mockProc.emit('close', 1);
+      await runPromise;
+    });
+
+    it('should kill after hard maximum when commit never lands', async () => {
+      const mockProc = createMockProcess();
+      mockSpawn.mockReturnValue(mockProc);
+
+      // Commit never lands
+      mockGetHeadCommitHash.mockReturnValue('aaa111');
+
+      const runner = new ClaudeRunner();
+      const runPromise = runner.run('test prompt', {
+        timeout: 60,
+        commitContext,
+      });
+
+      // 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);
+      expect(mockProc.kill).not.toHaveBeenCalled();
+
+      // Advance to hard maximum
+      jest.advanceTimersByTime(COMPLETION_HARD_MAX_MS - COMPLETION_GRACE_PERIOD_MS);
+      expect(mockProc.kill).toHaveBeenCalledWith('SIGTERM');
+
+      await runPromise;
+    });
+
+    it('should NOT extend grace period for FAILED markers', async () => {
+      const mockProc = createMockProcess();
+      mockSpawn.mockReturnValue(mockProc);
+
+      // Commit never lands (doesn't matter - FAILED shouldn't check)
+      mockGetHeadCommitHash.mockReturnValue('aaa111');
+
+      const runner = new ClaudeRunner();
+      const runPromise = runner.run('test prompt', {
+        timeout: 60,
+        commitContext,
+      });
+
+      // 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);
+      expect(mockProc.kill).toHaveBeenCalledWith('SIGTERM');
+
+      await runPromise;
+    });
+
+    it('should work without commitContext (backward compatible)', async () => {
+      const mockProc = createMockProcess();
+      mockSpawn.mockReturnValue(mockProc);
+
+      const runner = new ClaudeRunner();
+      const runPromise = runner.run('test prompt', {
+        timeout: 60,
+        // No commitContext provided
+      });
+
+      // 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);
+      expect(mockProc.kill).toHaveBeenCalledWith('SIGTERM');
+
+      await runPromise;
+    });
+
+    it('should verify commit message prefix matches', async () => {
+      const mockProc = createMockProcess();
+      mockProc.kill = jest.fn();
+      mockSpawn.mockReturnValue(mockProc);
+
+      // HEAD changed but message doesn't match expected prefix
+      mockGetHeadCommitHash.mockReturnValue('bbb222');
+      mockGetHeadCommitMessage.mockReturnValue('RAF[005:002] Wrong task');
+      mockIsFileCommittedInHead.mockReturnValue(true);
+
+      const runner = new ClaudeRunner();
+      const runPromise = runner.run('test prompt', {
+        timeout: 60,
+        commitContext,
+      });
+
+      // 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);
+      expect(mockProc.kill).not.toHaveBeenCalled();
+
+      // Fix commit message
+      mockGetHeadCommitMessage.mockReturnValue('RAF[005:001] Correct task');
+
+      // Next poll finds it
+      jest.advanceTimersByTime(COMMIT_POLL_INTERVAL_MS);
+      expect(mockProc.kill).toHaveBeenCalledWith('SIGTERM');
+
+      mockProc.emit('close', 1);
+      await runPromise;
+    });
+
+    it('should verify outcome file is committed', async () => {
+      const mockProc = createMockProcess();
+      mockProc.kill = jest.fn();
+      mockSpawn.mockReturnValue(mockProc);
+
+      // HEAD changed and message matches, but file not committed
+      mockGetHeadCommitHash.mockReturnValue('bbb222');
+      mockGetHeadCommitMessage.mockReturnValue('RAF[005:001] Add feature');
+      mockIsFileCommittedInHead.mockReturnValue(false);
+
+      const runner = new ClaudeRunner();
+      const runPromise = runner.run('test prompt', {
+        timeout: 60,
+        commitContext,
+      });
+
+      // 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);
+      expect(mockProc.kill).not.toHaveBeenCalled();
+
+      // File now committed
+      mockIsFileCommittedInHead.mockReturnValue(true);
+
+      // Next poll finds it
+      jest.advanceTimersByTime(COMMIT_POLL_INTERVAL_MS);
+      expect(mockProc.kill).toHaveBeenCalledWith('SIGTERM');
+
+      mockProc.emit('close', 1);
+      await runPromise;
+    });
+  });
 });

package/tests/unit/git-commit-helpers.test.ts

@@ -0,0 +1,103 @@
+import { jest } from '@jest/globals';
+
+const mockExecSync = jest.fn();
+
+jest.unstable_mockModule('node:child_process', () => ({
+  execSync: mockExecSync,
+}));
+
+const { getHeadCommitHash, getHeadCommitMessage, isFileCommittedInHead } = await import('../../src/core/git.js');
+
+describe('git commit helper functions', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('getHeadCommitHash', () => {
+    it('should return the current HEAD hash', () => {
+      mockExecSync.mockReturnValue('abc123def456\n');
+      expect(getHeadCommitHash()).toBe('abc123def456');
+    });
+
+    it('should return null if not in a git repo', () => {
+      mockExecSync.mockImplementation(() => {
+        throw new Error('not a git repository');
+      });
+      expect(getHeadCommitHash()).toBeNull();
+    });
+
+    it('should return null for empty output', () => {
+      mockExecSync.mockReturnValue('');
+      expect(getHeadCommitHash()).toBeNull();
+    });
+
+    it('should trim whitespace from hash', () => {
+      mockExecSync.mockReturnValue('  abc123  \n');
+      expect(getHeadCommitHash()).toBe('abc123');
+    });
+  });
+
+  describe('getHeadCommitMessage', () => {
+    it('should return the HEAD commit message', () => {
+      mockExecSync.mockReturnValue('RAF[005:001] Add validation\n');
+      expect(getHeadCommitMessage()).toBe('RAF[005:001] Add validation');
+    });
+
+    it('should return null if not in a git repo', () => {
+      mockExecSync.mockImplementation(() => {
+        throw new Error('not a git repository');
+      });
+      expect(getHeadCommitMessage()).toBeNull();
+    });
+
+    it('should return null for empty output', () => {
+      mockExecSync.mockReturnValue('');
+      expect(getHeadCommitMessage()).toBeNull();
+    });
+  });
+
+  describe('isFileCommittedInHead', () => {
+    it('should return true when file exists in HEAD', () => {
+      mockExecSync.mockImplementation((cmd: string) => {
+        if (typeof cmd === 'string' && cmd.includes('--show-toplevel')) {
+          return '/project\n';
+        }
+        if (typeof cmd === 'string' && cmd.includes('ls-tree')) {
+          return '100644 blob abc123\tRAF/outcomes/001-task.md\n';
+        }
+        return '';
+      });
+      expect(isFileCommittedInHead('/project/RAF/outcomes/001-task.md')).toBe(true);
+    });
+
+    it('should return false when file does not exist in HEAD', () => {
+      mockExecSync.mockImplementation((cmd: string) => {
+        if (typeof cmd === 'string' && cmd.includes('--show-toplevel')) {
+          return '/project\n';
+        }
+        if (typeof cmd === 'string' && cmd.includes('ls-tree')) {
+          return '';
+        }
+        return '';
+      });
+      expect(isFileCommittedInHead('/project/RAF/outcomes/001-task.md')).toBe(false);
+    });
+
+    it('should return false if not in a git repo', () => {
+      mockExecSync.mockImplementation(() => {
+        throw new Error('not a git repository');
+      });
+      expect(isFileCommittedInHead('/any/path')).toBe(false);
+    });
+
+    it('should return false on git command failure', () => {
+      mockExecSync.mockImplementation((cmd: string) => {
+        if (typeof cmd === 'string' && cmd.includes('--show-toplevel')) {
+          return '/project\n';
+        }
+        throw new Error('git ls-tree failed');
+      });
+      expect(isFileCommittedInHead('/project/file.ts')).toBe(false);
+    });
+  });
+});