rafcode 1.0.0

package/tests/unit/execution-prompt.test.ts

@@ -0,0 +1,406 @@
+import { getExecutionPrompt, ExecutionPromptParams, summarizeOutcome } from '../../src/prompts/execution.js';
+
+describe('Execution Prompt', () => {
+  const baseParams: ExecutionPromptParams = {
+    projectPath: '/Users/test/RAF/005-task-naming-improvements',
+    planPath: '/Users/test/RAF/005-task-naming-improvements/plans/001-enhance-identifier-resolution.md',
+    taskId: '001',
+    taskNumber: 1,
+    totalTasks: 5,
+    previousOutcomes: [],
+    autoCommit: true,
+    projectNumber: '005',
+    outcomeFilePath: '/Users/test/RAF/005-task-naming-improvements/outcomes/001-enhance-identifier-resolution.md',
+  };
+
+  describe('Commit Message Format', () => {
+    it('should include RAF commit schema format with description placeholder in prompt', () => {
+      const prompt = getExecutionPrompt(baseParams);
+      expect(prompt).toContain('RAF[005:001] <description>');
+    });
+
+    it('should instruct to write meaningful description', () => {
+      const prompt = getExecutionPrompt(baseParams);
+      expect(prompt).toContain('Write a concise description of what was accomplished');
+      expect(prompt).toContain('Focus on the actual change, not the task name');
+    });
+
+    it('should zero-pad single digit task numbers', () => {
+      const params = { ...baseParams, taskNumber: 1 };
+      const prompt = getExecutionPrompt(params);
+      expect(prompt).toContain('RAF[005:001]');
+    });
+
+    it('should zero-pad double digit task numbers', () => {
+      const params = { ...baseParams, taskNumber: 12 };
+      const prompt = getExecutionPrompt(params);
+      expect(prompt).toContain('RAF[005:012]');
+    });
+
+    it('should not pad triple digit task numbers', () => {
+      const params = { ...baseParams, taskNumber: 123 };
+      const prompt = getExecutionPrompt(params);
+      expect(prompt).toContain('RAF[005:123]');
+    });
+
+    it('should include project number from base36 prefix', () => {
+      const params = { ...baseParams, projectNumber: 'a05' };
+      const prompt = getExecutionPrompt(params);
+      expect(prompt).toContain('RAF[a05:001]');
+    });
+
+    it('should not include commit instructions when autoCommit is false', () => {
+      const params = { ...baseParams, autoCommit: false };
+      const prompt = getExecutionPrompt(params);
+      expect(prompt).not.toContain('Git Instructions');
+      expect(prompt).not.toContain('RAF[');
+    });
+
+    it('should include instruction not to commit on failure', () => {
+      const prompt = getExecutionPrompt(baseParams);
+      expect(prompt).toContain('On Failure');
+      expect(prompt).toContain('do NOT commit');
+      expect(prompt).toContain('<promise>FAILED</promise>');
+    });
+
+    it('should not include failure commit instruction when autoCommit is false', () => {
+      const params = { ...baseParams, autoCommit: false };
+      const prompt = getExecutionPrompt(params);
+      expect(prompt).not.toContain('On Failure');
+      expect(prompt).not.toContain('do NOT commit');
+    });
+  });
+
+  describe('Complete Commit Message', () => {
+    it('should generate correct commit message format for task 006', () => {
+      const params: ExecutionPromptParams = {
+        projectPath: '/Users/test/RAF/005-task-naming-improvements',
+        planPath: '/Users/test/RAF/005-task-naming-improvements/plans/006-update-execution-prompt.md',
+        taskId: '006',
+        taskNumber: 6,
+        totalTasks: 7,
+        previousOutcomes: [],
+        autoCommit: true,
+        projectNumber: '005',
+        outcomeFilePath: '/Users/test/RAF/005-task-naming-improvements/outcomes/006-update-execution-prompt.md',
+      };
+      const prompt = getExecutionPrompt(params);
+      expect(prompt).toContain('RAF[005:006] <description>');
+    });
+
+    it('should generate correct commit message format for first task', () => {
+      const params: ExecutionPromptParams = {
+        projectPath: '/Users/test/RAF/001-fix-bug',
+        planPath: '/Users/test/RAF/001-fix-bug/plans/001-identify-issue.md',
+        taskId: '001',
+        taskNumber: 1,
+        totalTasks: 3,
+        previousOutcomes: [],
+        autoCommit: true,
+        projectNumber: '001',
+        outcomeFilePath: '/Users/test/RAF/001-fix-bug/outcomes/001-identify-issue.md',
+      };
+      const prompt = getExecutionPrompt(params);
+      expect(prompt).toContain('RAF[001:001] <description>');
+    });
+
+    it('should generate correct commit message format for base36 project', () => {
+      const params: ExecutionPromptParams = {
+        projectPath: '/Users/test/RAF/a0b-feature-branch',
+        planPath: '/Users/test/RAF/a0b-feature-branch/plans/002-implement-feature.md',
+        taskId: '002',
+        taskNumber: 2,
+        totalTasks: 4,
+        previousOutcomes: [],
+        autoCommit: true,
+        projectNumber: 'a0b',
+        outcomeFilePath: '/Users/test/RAF/a0b-feature-branch/outcomes/002-implement-feature.md',
+      };
+      const prompt = getExecutionPrompt(params);
+      expect(prompt).toContain('RAF[a0b:002] <description>');
+    });
+  });
+
+  describe('Task Information', () => {
+    it('should include task number and total', () => {
+      const prompt = getExecutionPrompt(baseParams);
+      expect(prompt).toContain('Task: 1 of 5');
+    });
+
+    it('should include task ID', () => {
+      const prompt = getExecutionPrompt(baseParams);
+      expect(prompt).toContain('Task ID: 001');
+    });
+
+    it('should include project path', () => {
+      const prompt = getExecutionPrompt(baseParams);
+      expect(prompt).toContain('Project folder: /Users/test/RAF/005-task-naming-improvements');
+    });
+
+    it('should include plan path', () => {
+      const prompt = getExecutionPrompt(baseParams);
+      expect(prompt).toContain('plans/001-enhance-identifier-resolution.md');
+    });
+  });
+
+  describe('Outcome File Instructions', () => {
+    it('should include outcome file path in prompt', () => {
+      const prompt = getExecutionPrompt(baseParams);
+      expect(prompt).toContain('Outcome file path');
+      expect(prompt).toContain(baseParams.outcomeFilePath);
+    });
+
+    it('should include instructions for writing outcome file', () => {
+      const prompt = getExecutionPrompt(baseParams);
+      expect(prompt).toContain('You MUST write an outcome file');
+      expect(prompt).toContain('summary of what was done');
+    });
+
+    it('should specify that completion marker must be at end of file', () => {
+      const prompt = getExecutionPrompt(baseParams);
+      expect(prompt).toContain('MUST end with one of these markers');
+      expect(prompt).toContain('<promise>COMPLETE</promise>');
+      expect(prompt).toContain('<promise>FAILED</promise>');
+    });
+
+    it('should distinguish between code tasks and documentation tasks', () => {
+      const prompt = getExecutionPrompt(baseParams);
+      expect(prompt).toContain('For code tasks');
+      expect(prompt).toContain('For documentation/report tasks');
+    });
+
+    it('should instruct that marker is last line in outcome file', () => {
+      const prompt = getExecutionPrompt(baseParams);
+      expect(prompt).toContain('completion marker MUST be the LAST line in the outcome file');
+    });
+  });
+
+  describe('Commit Workflow Rules', () => {
+    it('should include rule to commit code and outcome together on success', () => {
+      const prompt = getExecutionPrompt(baseParams);
+      expect(prompt).toContain('On SUCCESS: Commit code changes AND outcome file together');
+    });
+
+    it('should include rule not to commit on failure', () => {
+      const prompt = getExecutionPrompt(baseParams);
+      expect(prompt).toContain('On FAILURE: Do NOT commit');
+    });
+
+    it('should specify that changes are preserved for debugging on failure', () => {
+      const prompt = getExecutionPrompt(baseParams);
+      expect(prompt).toContain('preserved for debugging');
+    });
+  });
+
+  describe('Previous Outcomes', () => {
+    it('should include previous outcomes section when outcomes exist', () => {
+      const params = {
+        ...baseParams,
+        previousOutcomes: [
+          { taskId: '001', content: '## Status: SUCCESS\n\nTask completed successfully.' },
+        ],
+      };
+      const prompt = getExecutionPrompt(params);
+      expect(prompt).toContain('Previous Task Outcomes');
+      expect(prompt).toContain('### Task 001');
+      expect(prompt).toContain('## Status: SUCCESS');
+    });
+
+    it('should not include previous outcomes section when empty', () => {
+      const prompt = getExecutionPrompt(baseParams);
+      expect(prompt).not.toContain('Previous Task Outcomes');
+    });
+  });
+
+  describe('Retry Context', () => {
+    it('should not include retry context on first attempt', () => {
+      const params = {
+        ...baseParams,
+        attemptNumber: 1,
+        previousOutcomeFile: '/path/to/outcome.md',
+      };
+      const prompt = getExecutionPrompt(params);
+      expect(prompt).not.toContain('Retry Context');
+    });
+
+    it('should not include retry context when attemptNumber is not provided', () => {
+      const prompt = getExecutionPrompt(baseParams);
+      expect(prompt).not.toContain('Retry Context');
+    });
+
+    it('should include retry context on second attempt with previous outcome file', () => {
+      const params = {
+        ...baseParams,
+        attemptNumber: 2,
+        previousOutcomeFile: '/Users/test/RAF/005-task-naming-improvements/outcomes/001-enhance-identifier-resolution.md',
+      };
+      const prompt = getExecutionPrompt(params);
+      expect(prompt).toContain('## Retry Context');
+      expect(prompt).toContain('This is attempt 2');
+      expect(prompt).toContain('**Previous outcome file**: /Users/test/RAF/005-task-naming-improvements/outcomes/001-enhance-identifier-resolution.md');
+    });
+
+    it('should include retry context on third attempt', () => {
+      const params = {
+        ...baseParams,
+        attemptNumber: 3,
+        previousOutcomeFile: '/path/to/outcome.md',
+      };
+      const prompt = getExecutionPrompt(params);
+      expect(prompt).toContain('This is attempt 3');
+    });
+
+    it('should not include retry context on second attempt without previous outcome file', () => {
+      const params = {
+        ...baseParams,
+        attemptNumber: 2,
+        previousOutcomeFile: undefined,
+      };
+      const prompt = getExecutionPrompt(params);
+      expect(prompt).not.toContain('Retry Context');
+    });
+
+    it('should instruct to read previous outcome file and avoid same mistakes', () => {
+      const params = {
+        ...baseParams,
+        attemptNumber: 2,
+        previousOutcomeFile: '/path/to/outcome.md',
+      };
+      const prompt = getExecutionPrompt(params);
+      expect(prompt).toContain('Read the previous outcome file first');
+      expect(prompt).toContain('Understand what was attempted and why it failed');
+      expect(prompt).toContain('Account for the previous failure in your approach');
+      expect(prompt).toContain('Avoid making the same mistakes');
+    });
+  });
+
+  describe('Dependency Context', () => {
+    it('should not include dependency context when task has no dependencies', () => {
+      const prompt = getExecutionPrompt(baseParams);
+      expect(prompt).not.toContain('Dependency Context');
+    });
+
+    it('should not include dependency context when dependencyIds is empty', () => {
+      const params = {
+        ...baseParams,
+        dependencyIds: [],
+        dependencyOutcomes: [],
+      };
+      const prompt = getExecutionPrompt(params);
+      expect(prompt).not.toContain('Dependency Context');
+    });
+
+    it('should not include dependency context when dependencyOutcomes is empty', () => {
+      const params = {
+        ...baseParams,
+        dependencyIds: ['001'],
+        dependencyOutcomes: [],
+      };
+      const prompt = getExecutionPrompt(params);
+      expect(prompt).not.toContain('Dependency Context');
+    });
+
+    it('should include dependency context when task has dependencies with outcomes', () => {
+      const params = {
+        ...baseParams,
+        taskId: '002',
+        taskNumber: 2,
+        dependencyIds: ['001'],
+        dependencyOutcomes: [
+          { taskId: '001', content: '## Summary\n\nImplemented the base feature.\n\n<promise>COMPLETE</promise>' },
+        ],
+      };
+      const prompt = getExecutionPrompt(params);
+      expect(prompt).toContain('## Dependency Context');
+      expect(prompt).toContain('**Dependencies**: 001');
+      expect(prompt).toContain('### Task 001');
+      expect(prompt).toContain('Implemented the base feature');
+    });
+
+    it('should include multiple dependency outcomes', () => {
+      const params = {
+        ...baseParams,
+        taskId: '003',
+        taskNumber: 3,
+        dependencyIds: ['001', '002'],
+        dependencyOutcomes: [
+          { taskId: '001', content: '## Summary\n\nFirst task done.\n\n<promise>COMPLETE</promise>' },
+          { taskId: '002', content: '## Summary\n\nSecond task done.\n\n<promise>COMPLETE</promise>' },
+        ],
+      };
+      const prompt = getExecutionPrompt(params);
+      expect(prompt).toContain('**Dependencies**: 001, 002');
+      expect(prompt).toContain('### Task 001');
+      expect(prompt).toContain('First task done');
+      expect(prompt).toContain('### Task 002');
+      expect(prompt).toContain('Second task done');
+    });
+
+    it('should explain purpose of dependency context', () => {
+      const params = {
+        ...baseParams,
+        taskId: '002',
+        taskNumber: 2,
+        dependencyIds: ['001'],
+        dependencyOutcomes: [
+          { taskId: '001', content: '## Summary\n\nDone.\n\n<promise>COMPLETE</promise>' },
+        ],
+      };
+      const prompt = getExecutionPrompt(params);
+      expect(prompt).toContain('depends on the following completed tasks');
+      expect(prompt).toContain('Review their outcomes to understand what was accomplished');
+      expect(prompt).toContain('build upon their work');
+    });
+
+    it('should place dependency context before previous outcomes section', () => {
+      const params = {
+        ...baseParams,
+        taskId: '003',
+        taskNumber: 3,
+        previousOutcomes: [
+          { taskId: '001', content: 'Previous outcome 1' },
+          { taskId: '002', content: 'Previous outcome 2' },
+        ],
+        dependencyIds: ['001'],
+        dependencyOutcomes: [
+          { taskId: '001', content: '## Summary\n\nDependency work.\n\n<promise>COMPLETE</promise>' },
+        ],
+      };
+      const prompt = getExecutionPrompt(params);
+      const depContextIndex = prompt.indexOf('## Dependency Context');
+      const prevOutcomesIndex = prompt.indexOf('## Previous Task Outcomes');
+      expect(depContextIndex).toBeGreaterThan(-1);
+      expect(prevOutcomesIndex).toBeGreaterThan(-1);
+      expect(depContextIndex).toBeLessThan(prevOutcomesIndex);
+    });
+  });
+
+  describe('summarizeOutcome', () => {
+    it('should return content as-is when under size limit', () => {
+      const content = '## Summary\n\nShort content.\n\n<promise>COMPLETE</promise>';
+      const result = summarizeOutcome(content);
+      expect(result).toBe(content);
+    });
+
+    it('should extract Summary section when content is too long', () => {
+      const summary = 'This is the summary of what was done.';
+      const longContent = `## Summary\n\n${summary}\n\n## Details\n\n${'x'.repeat(5000)}\n\n<promise>COMPLETE</promise>`;
+      const result = summarizeOutcome(longContent);
+      expect(result).toContain(summary);
+      expect(result).toContain('[Outcome truncated for context size]');
+    });
+
+    it('should truncate at reasonable break point when no Summary section', () => {
+      const longContent = 'x'.repeat(5000);
+      const result = summarizeOutcome(longContent);
+      expect(result.length).toBeLessThan(5000);
+      expect(result).toContain('[Outcome truncated for context size]');
+    });
+
+    it('should prefer newline as break point when truncating', () => {
+      const content = 'First line.\nSecond line.\n' + 'x'.repeat(5000);
+      const result = summarizeOutcome(content);
+      expect(result).toContain('[Outcome truncated for context size]');
+    });
+  });
+});

package/tests/unit/failure-analyzer.test.ts

@@ -0,0 +1,276 @@
+import {
+  detectProgrammaticFailure,
+  generateProgrammaticReport,
+  analyzeFailure,
+  type ProgrammaticFailureType,
+} from '../../src/core/failure-analyzer.js';
+
+describe('Failure Analyzer', () => {
+  describe('detectProgrammaticFailure', () => {
+    describe('context overflow detection', () => {
+      it('should detect "context length exceeded"', () => {
+        const output = 'Error: context length exceeded';
+        expect(detectProgrammaticFailure(output, '')).toBe('context_overflow');
+      });
+
+      it('should detect "token limit"', () => {
+        const output = 'The token limit has been reached';
+        expect(detectProgrammaticFailure(output, '')).toBe('context_overflow');
+      });
+
+      it('should detect "maximum context"', () => {
+        const output = 'Maximum context size reached';
+        expect(detectProgrammaticFailure(output, '')).toBe('context_overflow');
+      });
+
+      it('should detect "context window"', () => {
+        const output = 'Error: context window exceeded';
+        expect(detectProgrammaticFailure(output, '')).toBe('context_overflow');
+      });
+
+      it('should detect "too many tokens"', () => {
+        const output = 'Error: too many tokens in request';
+        expect(detectProgrammaticFailure(output, '')).toBe('context_overflow');
+      });
+    });
+
+    describe('rate limit detection', () => {
+      it('should detect "rate limit"', () => {
+        const output = 'rate limit exceeded';
+        expect(detectProgrammaticFailure(output, '')).toBe('rate_limit');
+      });
+
+      it('should detect "too many requests"', () => {
+        const output = 'Error: too many requests';
+        expect(detectProgrammaticFailure(output, '')).toBe('rate_limit');
+      });
+
+      it('should detect "429 too many requests"', () => {
+        const output = 'HTTP 429 too many requests';
+        expect(detectProgrammaticFailure(output, '')).toBe('rate_limit');
+      });
+
+      it('should detect "quota exceeded"', () => {
+        const output = 'quota exceeded for this billing period';
+        expect(detectProgrammaticFailure(output, '')).toBe('rate_limit');
+      });
+
+      it('should detect "throttled"', () => {
+        const output = 'Request throttled due to high load';
+        expect(detectProgrammaticFailure(output, '')).toBe('rate_limit');
+      });
+    });
+
+    describe('API error detection', () => {
+      it('should detect "api error"', () => {
+        const output = 'API error occurred';
+        expect(detectProgrammaticFailure(output, '')).toBe('api_error');
+      });
+
+      it('should detect "internal server error"', () => {
+        const output = 'Internal Server Error';
+        expect(detectProgrammaticFailure(output, '')).toBe('api_error');
+      });
+
+      it('should detect "500 server error"', () => {
+        const output = 'HTTP 500 Internal Server Error';
+        expect(detectProgrammaticFailure(output, '')).toBe('api_error');
+      });
+
+      it('should detect "502 bad gateway"', () => {
+        const output = '502 Bad Gateway';
+        expect(detectProgrammaticFailure(output, '')).toBe('api_error');
+      });
+
+      it('should detect "503 service unavailable"', () => {
+        const output = '503 Service Unavailable';
+        expect(detectProgrammaticFailure(output, '')).toBe('api_error');
+      });
+
+      it('should detect "APIError"', () => {
+        const output = 'APIError: Something went wrong';
+        expect(detectProgrammaticFailure(output, '')).toBe('api_error');
+      });
+    });
+
+    describe('timeout detection', () => {
+      it('should detect "timeout" in failure reason', () => {
+        expect(detectProgrammaticFailure('', 'Task timeout')).toBe('timeout');
+      });
+
+      it('should detect "timed out" in failure reason', () => {
+        expect(detectProgrammaticFailure('', 'Task timed out after 60 minutes')).toBe('timeout');
+      });
+    });
+
+    describe('non-programmatic failures', () => {
+      it('should return null for regular failures', () => {
+        const output = 'Error: Could not find file foo.txt';
+        expect(detectProgrammaticFailure(output, 'File not found')).toBeNull();
+      });
+
+      it('should return null for test failures', () => {
+        const output = 'FAILED: 3 tests failed';
+        expect(detectProgrammaticFailure(output, 'Tests failed')).toBeNull();
+      });
+
+      it('should return null for compilation errors', () => {
+        const output = 'error TS2304: Cannot find name "foo"';
+        expect(detectProgrammaticFailure(output, 'Compilation failed')).toBeNull();
+      });
+    });
+
+    describe('priority ordering', () => {
+      it('should prioritize context overflow over rate limit', () => {
+        const output = 'context length exceeded, rate limit warning';
+        expect(detectProgrammaticFailure(output, '')).toBe('context_overflow');
+      });
+
+      it('should prioritize rate limit over api error', () => {
+        const output = 'API error: rate limit exceeded';
+        expect(detectProgrammaticFailure(output, '')).toBe('rate_limit');
+      });
+    });
+  });
+
+  describe('generateProgrammaticReport', () => {
+    describe('api_error report', () => {
+      it('should generate API error report with correct structure', () => {
+        const report = generateProgrammaticReport('api_error', 'API error', 'error output');
+
+        expect(report).toContain('## Failure Reason');
+        expect(report).toContain('API error occurred');
+        expect(report).toContain('## Analysis');
+        expect(report).toContain('## Suggested Fix');
+        expect(report).toContain('## Relevant Output');
+        expect(report).toContain('<promise>FAILED</promise>');
+      });
+
+      it('should include relevant output in code block', () => {
+        const report = generateProgrammaticReport('api_error', 'API error', 'some error message');
+
+        expect(report).toContain('```');
+        expect(report).toContain('some error message');
+      });
+    });
+
+    describe('rate_limit report', () => {
+      it('should generate rate limit report with correct structure', () => {
+        const report = generateProgrammaticReport('rate_limit', 'Rate limited', 'output');
+
+        expect(report).toContain('## Failure Reason');
+        expect(report).toContain('Rate limit exceeded');
+        expect(report).toContain('## Analysis');
+        expect(report).toContain('## Suggested Fix');
+        expect(report).toContain('Wait 1-2 minutes');
+        expect(report).toContain('<promise>FAILED</promise>');
+      });
+    });
+
+    describe('timeout report', () => {
+      it('should generate timeout report with correct structure', () => {
+        const report = generateProgrammaticReport('timeout', 'Task timed out', 'output');
+
+        expect(report).toContain('## Failure Reason');
+        expect(report).toContain('timed out');
+        expect(report).toContain('## Analysis');
+        expect(report).toContain('## Suggested Fix');
+        expect(report).toContain('--timeout');
+        expect(report).toContain('<promise>FAILED</promise>');
+      });
+    });
+
+    describe('context_overflow report', () => {
+      it('should generate context overflow report with correct structure', () => {
+        const report = generateProgrammaticReport('context_overflow', 'Context exceeded', 'output');
+
+        expect(report).toContain('## Failure Reason');
+        expect(report).toContain('Context window exceeded');
+        expect(report).toContain('## Analysis');
+        expect(report).toContain('## Suggested Fix');
+        expect(report).toContain('smaller');
+        expect(report).toContain('<promise>FAILED</promise>');
+      });
+    });
+
+    describe('output truncation', () => {
+      it('should truncate long output', () => {
+        const longOutput = Array(100).fill('Line of output').join('\n');
+        const report = generateProgrammaticReport('api_error', 'Error', longOutput);
+
+        expect(report).toContain('...(truncated)');
+      });
+
+      it('should not truncate short output', () => {
+        const shortOutput = 'Short error message';
+        const report = generateProgrammaticReport('api_error', 'Error', shortOutput);
+
+        expect(report).not.toContain('...(truncated)');
+      });
+    });
+  });
+
+  describe('analyzeFailure', () => {
+    describe('programmatic failures', () => {
+      it('should handle context overflow without API call', async () => {
+        const output = 'Error: context length exceeded';
+        const result = await analyzeFailure(output, 'Context overflow', '001');
+
+        expect(result).toContain('## Failure Reason');
+        expect(result).toContain('Context window exceeded');
+        expect(result).toContain('<promise>FAILED</promise>');
+      });
+
+      it('should handle rate limit without API call', async () => {
+        const output = 'rate limit exceeded';
+        const result = await analyzeFailure(output, 'Rate limited', '002');
+
+        expect(result).toContain('## Failure Reason');
+        expect(result).toContain('Rate limit exceeded');
+        expect(result).toContain('<promise>FAILED</promise>');
+      });
+
+      it('should handle timeout without API call', async () => {
+        const output = 'Task running...';
+        const result = await analyzeFailure(output, 'Task timed out', '003');
+
+        expect(result).toContain('## Failure Reason');
+        expect(result).toContain('timed out');
+        expect(result).toContain('<promise>FAILED</promise>');
+      });
+
+      it('should handle API error without API call', async () => {
+        const output = '500 Internal Server Error';
+        const result = await analyzeFailure(output, 'API failed', '004');
+
+        expect(result).toContain('## Failure Reason');
+        expect(result).toContain('API error');
+        expect(result).toContain('<promise>FAILED</promise>');
+      });
+    });
+
+    describe('all failure reports end with FAILED marker', () => {
+      const failureTypes: ProgrammaticFailureType[] = ['api_error', 'rate_limit', 'timeout', 'context_overflow'];
+
+      for (const type of failureTypes) {
+        it(`should end with <promise>FAILED</promise> for ${type}`, () => {
+          const report = generateProgrammaticReport(type, 'reason', 'output');
+          expect(report.trim().endsWith('<promise>FAILED</promise>')).toBe(true);
+        });
+      }
+    });
+
+    describe('report structure', () => {
+      it('should include all required sections for programmatic failures', async () => {
+        const result = await analyzeFailure('context length exceeded', 'Error', '001');
+
+        // Check all required sections are present
+        expect(result).toContain('## Failure Reason');
+        expect(result).toContain('## Analysis');
+        expect(result).toContain('## Suggested Fix');
+        expect(result).toContain('## Relevant Output');
+        expect(result).toContain('<promise>FAILED</promise>');
+      });
+    });
+  });
+});