tlc-claude-code 2.2.1 → 2.4.0

package/server/lib/overdrive-command.test.js

@@ -75,11 +75,11 @@ describe('overdrive-command', () => {
 
     it('parses --model flag', () => {
       expect(parseOverdriveArgs('--model opus').model).toBe('opus');
-      expect(parseOverdriveArgs('--model sonnet').model).toBe('sonnet');
-      expect(parseOverdriveArgs('--model haiku').model).toBe('haiku');
     });
 
-    it('ignores invalid model values', () => {
+    it('ignores non-opus model values', () => {
+      expect(parseOverdriveArgs('--model sonnet').model).toBeNull();
+      expect(parseOverdriveArgs('--model haiku').model).toBeNull();
       expect(parseOverdriveArgs('--model gpt4').model).toBeNull();
     });
 
@@ -89,12 +89,12 @@ describe('overdrive-command', () => {
     });
 
     it('parses multiple flags including new ones', () => {
-      const options = parseOverdriveArgs('5 --agents 2 --mode test --model sonnet --max-turns 25 --dry-run');
+      const options = parseOverdriveArgs('5 --agents 2 --mode test --model opus --max-turns 25 --dry-run');
 
       expect(options.phase).toBe(5);
       expect(options.agents).toBe(2);
       expect(options.mode).toBe('test');
-      expect(options.model).toBe('sonnet');
+      expect(options.model).toBe('opus');
       expect(options.maxTurns).toBe(25);
       expect(options.dryRun).toBe(true);
     });
@@ -152,7 +152,7 @@ describe('overdrive-command', () => {
       expect(prompts[0].prompt).toContain('Fix any failing tests');
     });
 
-    it('assigns model based on task complexity', () => {
+    it('assigns opus for all task complexities', () => {
       const tasks = [
         { id: 1, title: 'Refactor authentication system' },
         { id: 2, title: 'Add helper function' },
@@ -163,9 +163,9 @@ describe('overdrive-command', () => {
         mode: 'build', projectDir: '/p', phase: 1,
       });
 
-      expect(prompts[0].model).toBe('opus');    // refactor = heavy
-      expect(prompts[1].model).toBe('sonnet');   // default = standard
-      expect(prompts[2].model).toBe('haiku');    // enum = light
+      expect(prompts[0].model).toBe('opus');
+      expect(prompts[1].model).toBe('opus');
+      expect(prompts[2].model).toBe('opus');
     });
 
     it('respects model override', () => {
@@ -176,11 +176,11 @@ describe('overdrive-command', () => {
 
       const prompts = generateAgentPrompts(tasks, {
         mode: 'build', projectDir: '/p', phase: 1,
-        model: 'haiku',
+        model: 'opus',
       });
 
-      expect(prompts[0].model).toBe('haiku');
-      expect(prompts[1].model).toBe('haiku');
+      expect(prompts[0].model).toBe('opus');
+      expect(prompts[1].model).toBe('opus');
     });
 
     it('respects maxTurns override', () => {
@@ -286,8 +286,8 @@ describe('overdrive-command', () => {
   describe('generateTaskCalls', () => {
     it('generates task tool calls with model and max_turns', () => {
       const prompts = [
-        { taskId: 1, taskTitle: 'Test', prompt: 'Do task 1', agentType: 'general-purpose', model: 'sonnet', maxTurns: 50 },
-        { taskId: 2, taskTitle: 'Test 2', prompt: 'Do task 2', agentType: 'general-purpose', model: 'haiku', maxTurns: 30 },
+        { taskId: 1, taskTitle: 'Test', prompt: 'Do task 1', agentType: 'general-purpose', model: 'opus', maxTurns: 50 },
+        { taskId: 2, taskTitle: 'Test 2', prompt: 'Do task 2', agentType: 'general-purpose', model: 'opus', maxTurns: 30 },
       ];
 
       const calls = generateTaskCalls(prompts);
@@ -297,9 +297,9 @@ describe('overdrive-command', () => {
       expect(calls[0].params.description).toContain('Agent 1');
       expect(calls[0].params.run_in_background).toBe(true);
       expect(calls[0].params.subagent_type).toBe('general-purpose');
-      expect(calls[0].params.model).toBe('sonnet');
+      expect(calls[0].params.model).toBe('opus');
       expect(calls[0].params.max_turns).toBe(50);
-      expect(calls[1].params.model).toBe('haiku');
+      expect(calls[1].params.model).toBe('opus');
       expect(calls[1].params.max_turns).toBe(30);
     });
   });
@@ -497,16 +497,16 @@ Blocked by Task 1
       expect(getModelForTask({ title: 'Refactor auth' })).toBe('opus');
     });
 
-    it('returns sonnet for standard tasks', () => {
-      expect(getModelForTask({ title: 'Add endpoint' })).toBe('sonnet');
+    it('returns opus for standard tasks', () => {
+      expect(getModelForTask({ title: 'Add endpoint' })).toBe('opus');
     });
 
-    it('returns haiku for light tasks', () => {
-      expect(getModelForTask({ title: 'Create enum' })).toBe('haiku');
+    it('returns opus for light tasks', () => {
+      expect(getModelForTask({ title: 'Create enum' })).toBe('opus');
     });
 
     it('respects model override', () => {
-      expect(getModelForTask({ title: 'Refactor auth' }, 'haiku')).toBe('haiku');
+      expect(getModelForTask({ title: 'Refactor auth' }, 'opus')).toBe('opus');
       expect(getModelForTask({ title: 'Create enum' }, 'opus')).toBe('opus');
     });
   });
@@ -533,10 +533,10 @@ Blocked by Task 1
       expect(AGENT_TYPES.PLAN).toBe('Plan');
     });
 
-    it('exports valid model tiers', () => {
+    it('exports valid model tiers (all opus)', () => {
       expect(MODEL_TIERS.HEAVY).toBe('opus');
-      expect(MODEL_TIERS.STANDARD).toBe('sonnet');
-      expect(MODEL_TIERS.LIGHT).toBe('haiku');
+      expect(MODEL_TIERS.STANDARD).toBe('opus');
+      expect(MODEL_TIERS.LIGHT).toBe('opus');
     });
 
     it('exports default max turns', () => {
@@ -562,8 +562,7 @@ Blocked by Task 1
 
       expect(output).toContain('Opus 4.6');
       expect(output).toContain('[opus]');
-      expect(output).toContain('[haiku]');
-      expect(output).toContain('Model selection per task complexity');
+      expect(output).toContain('All agents use opus');
       expect(output).toContain('Agent resumption');
       expect(output).toContain('TaskOutput');
       expect(output).toContain('TaskStop');

package/server/lib/prompt-packager.js

@@ -0,0 +1,98 @@
+/**
+ * Prompt Packager Module
+ * Serializes project context into a single prompt string for CLI dispatch to external LLMs.
+ */
+
+const DEFAULT_TOKEN_BUDGET = 100000;
+const TRUNCATION_MARKER = '...';
+
+/**
+ * Format a source file as a labeled block for inclusion in the prompt.
+ * @param {string} filePath - Relative path to the file
+ * @param {string} content - File contents
+ * @returns {string} Formatted block with path header
+ */
+function formatFileBlock(filePath, content) {
+  return `--- ${filePath} ---\n${content}`;
+}
+
+/**
+ * Truncate text to fit within a character budget.
+ * When truncation is needed, cuts at a character boundary and appends an ellipsis marker.
+ * @param {string} text - The text to truncate
+ * @param {number} budget - Maximum character count
+ * @returns {string} The text, truncated if necessary
+ */
+function truncateToBudget(text, budget) {
+  if (budget <= 0) return '';
+  if (text.length <= budget) return text;
+  const cutLen = budget - TRUNCATION_MARKER.length;
+  if (cutLen <= 0) return text.slice(0, budget);
+  return text.slice(0, cutLen) + TRUNCATION_MARKER;
+}
+
+/**
+ * Package project context and an agent prompt into a single string for external LLM dispatch.
+ * @param {object} opts
+ * @param {string} opts.agentPrompt - The command's instruction text (required)
+ * @param {string|null} [opts.projectDoc] - Contents of PROJECT.md
+ * @param {string|null} [opts.planDoc] - Contents of current phase PLAN.md
+ * @param {string|null} [opts.codingStandards] - Contents of CODING-STANDARDS.md
+ * @param {Array<{path: string, content: string}>|null} [opts.files] - Relevant source files
+ * @param {number} [opts.tokenBudget=100000] - Maximum characters in output
+ * @returns {string} Serialized prompt string
+ */
+function packagePrompt({
+  agentPrompt,
+  projectDoc = null,
+  planDoc = null,
+  codingStandards = null,
+  files = null,
+  tokenBudget = DEFAULT_TOKEN_BUDGET,
+}) {
+  if (tokenBudget <= 0) return '';
+
+  // Pre-truncate large individual file contents to a per-file budget.
+  // Each file gets at most half the total budget to leave room for other sections.
+  const perFileBudget = Math.floor(tokenBudget / 2);
+  const sortedFiles =
+    files && files.length > 0
+      ? [...files]
+          .sort((a, b) => a.path.localeCompare(b.path))
+          .map((f) => ({
+            path: f.path,
+            content: truncateToBudget(f.content, perFileBudget),
+          }))
+      : null;
+
+  // Task section goes FIRST so truncation of context never drops the instruction
+  const sections = [];
+
+  sections.push(`--- Task ---\n${agentPrompt}`);
+
+  sections.push('\nYou are working on the following project:');
+
+  if (projectDoc != null) {
+    sections.push(`\n--- PROJECT.md ---\n${projectDoc}`);
+  }
+
+  if (planDoc != null) {
+    sections.push(`\n--- Current Phase Plan ---\n${planDoc}`);
+  }
+
+  if (codingStandards != null) {
+    sections.push(`\n--- Coding Standards ---\n${codingStandards}`);
+  }
+
+  if (sortedFiles && sortedFiles.length > 0) {
+    const fileBlocks = sortedFiles
+      .map((f) => formatFileBlock(f.path, f.content))
+      .join('\n\n');
+    sections.push(`\n--- Relevant Files ---\n\n${fileBlocks}`);
+  }
+
+  const full = sections.join('\n');
+  return truncateToBudget(full, tokenBudget);
+}
+
+module.exports = { packagePrompt, truncateToBudget, formatFileBlock };

package/server/lib/prompt-packager.test.js

@@ -0,0 +1,185 @@
+import { describe, it, expect } from 'vitest';
+import {
+  packagePrompt,
+  truncateToBudget,
+  formatFileBlock,
+} from './prompt-packager.js';
+
+describe('prompt-packager', () => {
+  describe('formatFileBlock', () => {
+    it('produces correct header format', () => {
+      const result = formatFileBlock('src/auth/login.ts', 'const x = 1;');
+      expect(result).toBe('--- src/auth/login.ts ---\nconst x = 1;');
+    });
+
+    it('handles empty content', () => {
+      const result = formatFileBlock('empty.js', '');
+      expect(result).toBe('--- empty.js ---\n');
+    });
+  });
+
+  describe('truncateToBudget', () => {
+    it('returns text unchanged when within budget', () => {
+      const text = 'Hello world';
+      expect(truncateToBudget(text, 100)).toBe(text);
+    });
+
+    it('truncates at char boundary with ellipsis marker', () => {
+      const text = 'abcdefghij'; // 10 chars
+      const result = truncateToBudget(text, 8);
+      expect(result.length).toBeLessThanOrEqual(8);
+      expect(result).toContain('...');
+    });
+
+    it('returns empty string for budget of 0', () => {
+      expect(truncateToBudget('anything', 0)).toBe('');
+    });
+
+    it('handles text exactly at budget', () => {
+      const text = 'exact';
+      expect(truncateToBudget(text, 5)).toBe('exact');
+    });
+
+    it('handles empty text', () => {
+      expect(truncateToBudget('', 100)).toBe('');
+    });
+  });
+
+  describe('packagePrompt', () => {
+    const fullInput = {
+      agentPrompt: 'Implement the login feature',
+      projectDoc: '# My Project\nA cool project.',
+      planDoc: '## Phase 1\n- [ ] Task 1',
+      codingStandards: '## Standards\nUse JSDoc.',
+      files: [
+        { path: 'src/auth/login.ts', content: 'export function login() {}' },
+        { path: 'tests/auth/login.test.ts', content: 'test("login", () => {})' },
+      ],
+    };
+
+    it('packages all sections when everything provided', () => {
+      const result = packagePrompt(fullInput);
+      expect(result).toContain('You are working on the following project:');
+      expect(result).toContain('--- PROJECT.md ---');
+      expect(result).toContain('# My Project');
+      expect(result).toContain('--- Current Phase Plan ---');
+      expect(result).toContain('## Phase 1');
+      expect(result).toContain('--- Coding Standards ---');
+      expect(result).toContain('## Standards');
+      expect(result).toContain('--- Relevant Files ---');
+      expect(result).toContain('--- src/auth/login.ts ---');
+      expect(result).toContain('export function login() {}');
+      expect(result).toContain('--- tests/auth/login.test.ts ---');
+      expect(result).toContain('test("login", () => {})');
+      expect(result).toContain('--- Task ---');
+      expect(result).toContain('Implement the login feature');
+    });
+
+    it('omits PROJECT.md section when null', () => {
+      const result = packagePrompt({ ...fullInput, projectDoc: null });
+      expect(result).not.toContain('--- PROJECT.md ---');
+      expect(result).toContain('--- Current Phase Plan ---');
+      expect(result).toContain('--- Task ---');
+    });
+
+    it('omits plan section when null', () => {
+      const result = packagePrompt({ ...fullInput, planDoc: null });
+      expect(result).not.toContain('--- Current Phase Plan ---');
+      expect(result).toContain('--- PROJECT.md ---');
+      expect(result).toContain('--- Task ---');
+    });
+
+    it('omits coding standards when null', () => {
+      const result = packagePrompt({ ...fullInput, codingStandards: null });
+      expect(result).not.toContain('--- Coding Standards ---');
+      expect(result).toContain('--- PROJECT.md ---');
+      expect(result).toContain('--- Task ---');
+    });
+
+    it('omits files section when null', () => {
+      const result = packagePrompt({ ...fullInput, files: null });
+      expect(result).not.toContain('--- Relevant Files ---');
+      expect(result).toContain('--- PROJECT.md ---');
+      expect(result).toContain('--- Task ---');
+    });
+
+    it('omits files section when empty array', () => {
+      const result = packagePrompt({ ...fullInput, files: [] });
+      expect(result).not.toContain('--- Relevant Files ---');
+      expect(result).toContain('--- Task ---');
+    });
+
+    it('empty agentPrompt still produces valid output', () => {
+      const result = packagePrompt({ ...fullInput, agentPrompt: '' });
+      expect(result).toContain('--- Task ---');
+      expect(result).toContain('--- PROJECT.md ---');
+    });
+
+    it('files sorted by path for deterministic output', () => {
+      const result = packagePrompt({
+        agentPrompt: 'do it',
+        files: [
+          { path: 'z/last.js', content: 'last' },
+          { path: 'a/first.js', content: 'first' },
+          { path: 'm/middle.js', content: 'middle' },
+        ],
+      });
+      const aIdx = result.indexOf('--- a/first.js ---');
+      const mIdx = result.indexOf('--- m/middle.js ---');
+      const zIdx = result.indexOf('--- z/last.js ---');
+      expect(aIdx).toBeLessThan(mIdx);
+      expect(mIdx).toBeLessThan(zIdx);
+    });
+
+    it('truncates to budget when total exceeds limit', () => {
+      const result = packagePrompt({
+        ...fullInput,
+        tokenBudget: 50,
+      });
+      expect(result.length).toBeLessThanOrEqual(50);
+    });
+
+    it('budget of 0 returns empty string', () => {
+      const result = packagePrompt({ ...fullInput, tokenBudget: 0 });
+      expect(result).toBe('');
+    });
+
+    it('large individual files truncated before total budget check', () => {
+      const largeContent = 'x'.repeat(200000);
+      const result = packagePrompt({
+        agentPrompt: 'task',
+        files: [{ path: 'big.js', content: largeContent }],
+        tokenBudget: 1000,
+      });
+      expect(result.length).toBeLessThanOrEqual(1000);
+      // The file should be present but truncated
+      expect(result).toContain('--- big.js ---');
+    });
+
+    it('places task section before context so truncation never drops the instruction', () => {
+      const result = packagePrompt(fullInput);
+      const taskIdx = result.indexOf('--- Task ---');
+      const projectIdx = result.indexOf('--- PROJECT.md ---');
+      expect(taskIdx).toBeLessThan(projectIdx);
+    });
+
+    it('uses default tokenBudget of 100000 when not specified', () => {
+      const largeProject = 'x'.repeat(200000);
+      const result = packagePrompt({
+        agentPrompt: 'task',
+        projectDoc: largeProject,
+      });
+      expect(result.length).toBeLessThanOrEqual(100000);
+    });
+
+    it('handles minimal input with only agentPrompt', () => {
+      const result = packagePrompt({ agentPrompt: 'just do it' });
+      expect(result).toContain('--- Task ---');
+      expect(result).toContain('just do it');
+      expect(result).not.toContain('--- PROJECT.md ---');
+      expect(result).not.toContain('--- Current Phase Plan ---');
+      expect(result).not.toContain('--- Coding Standards ---');
+      expect(result).not.toContain('--- Relevant Files ---');
+    });
+  });
+});

package/server/lib/review-fixer.js

@@ -0,0 +1,107 @@
+/**
+ * Review Fixer Module
+ * Classifies review findings as AUTO-FIX (apply immediately) or ASK (batch for user approval).
+ */
+
+/**
+ * Finding types that can be automatically fixed without user input.
+ * These are mechanical, low-risk corrections.
+ */
+const AUTO_FIX_TYPES = {
+  any_type: 'Type annotation can be inferred or added mechanically',
+  missing_return_type: 'Return type can be inferred from implementation',
+  console_log: 'Debug logging can be safely removed',
+  missing_test_skeleton: 'Test skeleton can be generated from function signature',
+  hardcoded_url: 'URL can be extracted to environment variable',
+};
+
+/**
+ * Finding types that require user decision.
+ * These involve judgment, security, or architectural choices.
+ */
+const ASK_TYPES = {
+  ownership_missing: 'Ownership assignment requires team decision',
+  secrets_in_response: 'Secret handling requires security review',
+  architectural_decision: 'Architecture changes need explicit approval',
+  ambiguous_security: 'Security implications need human assessment',
+  scope_creep: 'Scope change requires product owner approval',
+};
+
+/**
+ * Classify a review finding into auto-fix or ask category
+ * @param {string} type - The finding type identifier
+ * @returns {{ action: 'auto-fix' | 'ask', reason: string }} Classification result
+ */
+function classifyFinding(type) {
+  if (!type || typeof type !== 'string') {
+    return { action: 'ask', reason: 'Invalid or missing finding type' };
+  }
+
+  if (AUTO_FIX_TYPES[type]) {
+    return { action: 'auto-fix', reason: AUTO_FIX_TYPES[type] };
+  }
+
+  if (ASK_TYPES[type]) {
+    return { action: 'ask', reason: ASK_TYPES[type] };
+  }
+
+  return { action: 'ask', reason: `Finding type "${type}" is unknown — defaulting to ask for safety` };
+}
+
+/**
+ * Split an array of findings into auto-fix and ask buckets
+ * @param {Array<{ type: string }>} findings - Array of finding objects with a type property
+ * @returns {{ autoFix: Array, ask: Array }} Separated findings
+ */
+function splitFindings(findings) {
+  if (!Array.isArray(findings)) {
+    return { autoFix: [], ask: [] };
+  }
+
+  const autoFix = [];
+  const ask = [];
+
+  for (const finding of findings) {
+    const classification = classifyFinding(finding.type);
+    if (classification.action === 'auto-fix') {
+      autoFix.push(finding);
+    } else {
+      ask.push(finding);
+    }
+  }
+
+  return { autoFix, ask };
+}
+
+/**
+ * Format a markdown summary report of fix results
+ * @param {number} autoFixed - Count of automatically fixed findings
+ * @param {number} needsInput - Count of findings needing user input
+ * @returns {string} Formatted markdown report
+ */
+function formatFixReport(autoFixed, needsInput) {
+  const total = autoFixed + needsInput;
+
+  const lines = [
+    `## Review Fix Report`,
+    '',
+    `**${total}** findings processed.`,
+    '',
+    `### Auto-Fixed: ${autoFixed}`,
+    '',
+    autoFixed > 0
+      ? `${autoFixed} finding(s) were automatically resolved.`
+      : 'No findings were auto-fixed.',
+    '',
+    `### Needs Input: ${needsInput}`,
+    '',
+    needsInput > 0
+      ? `${needsInput} finding(s) require your review and decision.`
+      : 'No findings need your input.',
+  ];
+
+  return lines.join('\n');
+}
+
+
+module.exports = { classifyFinding, splitFindings, formatFixReport };

package/server/lib/review-fixer.test.js

@@ -0,0 +1,152 @@
+import { describe, it, expect } from 'vitest';
+import {
+  classifyFinding,
+  splitFindings,
+  formatFixReport,
+} from './review-fixer.js';
+
+describe('review-fixer', () => {
+  describe('classifyFinding', () => {
+    it('classifies any_type as auto-fix', () => {
+      const result = classifyFinding('any_type');
+      expect(result.action).toBe('auto-fix');
+      expect(result.reason).toBeTypeOf('string');
+      expect(result.reason.length).toBeGreaterThan(0);
+    });
+
+    it('classifies ownership_missing as ask', () => {
+      const result = classifyFinding('ownership_missing');
+      expect(result.action).toBe('ask');
+      expect(result.reason).toBeTypeOf('string');
+      expect(result.reason.length).toBeGreaterThan(0);
+    });
+
+    it('classifies console_log as auto-fix', () => {
+      const result = classifyFinding('console_log');
+      expect(result.action).toBe('auto-fix');
+    });
+
+    it('classifies missing_return_type as auto-fix', () => {
+      const result = classifyFinding('missing_return_type');
+      expect(result.action).toBe('auto-fix');
+    });
+
+    it('classifies missing_test_skeleton as auto-fix', () => {
+      const result = classifyFinding('missing_test_skeleton');
+      expect(result.action).toBe('auto-fix');
+    });
+
+    it('classifies hardcoded_url as auto-fix', () => {
+      const result = classifyFinding('hardcoded_url');
+      expect(result.action).toBe('auto-fix');
+    });
+
+    it('classifies secrets_in_response as ask', () => {
+      const result = classifyFinding('secrets_in_response');
+      expect(result.action).toBe('ask');
+    });
+
+    it('classifies architectural_decision as ask', () => {
+      const result = classifyFinding('architectural_decision');
+      expect(result.action).toBe('ask');
+    });
+
+    it('classifies ambiguous_security as ask', () => {
+      const result = classifyFinding('ambiguous_security');
+      expect(result.action).toBe('ask');
+    });
+
+    it('classifies scope_creep as ask', () => {
+      const result = classifyFinding('scope_creep');
+      expect(result.action).toBe('ask');
+    });
+
+    it('defaults unknown types to ask (safe default)', () => {
+      const result = classifyFinding('unknown_type');
+      expect(result.action).toBe('ask');
+      expect(result.reason).toContain('unknown');
+    });
+
+    it('defaults another unrecognized type to ask', () => {
+      const result = classifyFinding('some_random_finding');
+      expect(result.action).toBe('ask');
+    });
+  });
+
+  describe('splitFindings', () => {
+    it('correctly separates auto-fix from ask findings', () => {
+      const findings = [
+        { type: 'any_type', file: 'a.js', line: 1 },
+        { type: 'ownership_missing', file: 'b.js', line: 5 },
+        { type: 'console_log', file: 'c.js', line: 10 },
+        { type: 'architectural_decision', file: 'd.js', line: 3 },
+        { type: 'hardcoded_url', file: 'e.js', line: 7 },
+      ];
+
+      const result = splitFindings(findings);
+
+      expect(result.autoFix).toHaveLength(3);
+      expect(result.ask).toHaveLength(2);
+
+      expect(result.autoFix.map(f => f.type)).toContain('any_type');
+      expect(result.autoFix.map(f => f.type)).toContain('console_log');
+      expect(result.autoFix.map(f => f.type)).toContain('hardcoded_url');
+
+      expect(result.ask.map(f => f.type)).toContain('ownership_missing');
+      expect(result.ask.map(f => f.type)).toContain('architectural_decision');
+    });
+
+    it('returns empty arrays for empty input', () => {
+      const result = splitFindings([]);
+      expect(result.autoFix).toEqual([]);
+      expect(result.ask).toEqual([]);
+    });
+
+    it('handles all auto-fix findings', () => {
+      const findings = [
+        { type: 'any_type', file: 'a.js', line: 1 },
+        { type: 'console_log', file: 'b.js', line: 2 },
+      ];
+      const result = splitFindings(findings);
+      expect(result.autoFix).toHaveLength(2);
+      expect(result.ask).toHaveLength(0);
+    });
+
+    it('handles all ask findings', () => {
+      const findings = [
+        { type: 'ownership_missing', file: 'a.js', line: 1 },
+        { type: 'scope_creep', file: 'b.js', line: 2 },
+      ];
+      const result = splitFindings(findings);
+      expect(result.autoFix).toHaveLength(0);
+      expect(result.ask).toHaveLength(2);
+    });
+  });
+
+  describe('formatFixReport', () => {
+    it('includes counts and section headers', () => {
+      const report = formatFixReport(3, 2);
+      expect(report).toContain('3');
+      expect(report).toContain('2');
+      expect(report).toContain('Auto-Fix');
+      expect(report).toContain('Needs Input');
+    });
+
+    it('handles zero auto-fixed', () => {
+      const report = formatFixReport(0, 4);
+      expect(report).toContain('0');
+      expect(report).toContain('4');
+    });
+
+    it('handles zero needing input', () => {
+      const report = formatFixReport(5, 0);
+      expect(report).toContain('5');
+      expect(report).toContain('0');
+    });
+
+    it('returns valid markdown', () => {
+      const report = formatFixReport(2, 1);
+      expect(report).toContain('#');
+    });
+  });
+});