tlc-claude-code 2.2.0 → 2.3.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/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('#');
+    });
+  });
+});

package/server/lib/scope-checker.js

@@ -0,0 +1,127 @@
+/**
+ * Scope Checker
+ * Compare diff files against plan task files to detect scope drift
+ */
+
+/**
+ * Extract planned file paths from PLAN.md content.
+ * Parses all `**Files:**` sections and collects listed file paths.
+ * @param {string} planContent - Raw content of a PLAN.md file
+ * @returns {string[]} Deduplicated array of planned file paths
+ */
+function extractPlannedFiles(planContent) {
+  if (!planContent) return [];
+
+  const files = [];
+  const seen = new Set();
+  const lines = planContent.split('\n');
+  let inFilesSection = false;
+
+  for (const line of lines) {
+    if (line.trim().startsWith('**Files:**')) {
+      inFilesSection = true;
+      continue;
+    }
+
+    if (inFilesSection) {
+      const match = line.match(/^- (.+)/);
+      if (match) {
+        // Strip backticks, em-dashes, and parenthetical annotations like (new), (modify)
+        const filePath = match[1]
+          .replace(/`/g, '')
+          .split(' — ')[0]
+          .split(' -- ')[0]
+          .replace(/\s*\((?:new|modify|delete|update|create)\)\s*$/i, '')
+          .trim();
+        if (!seen.has(filePath)) {
+          seen.add(filePath);
+          files.push(filePath);
+        }
+      } else {
+        // Non-list line ends the Files section
+        inFilesSection = false;
+      }
+    }
+  }
+
+  return files;
+}
+
+/**
+ * Check if a file path is a test file.
+ * Matches `.test.`, `_test.`, and `test_` patterns.
+ * @param {string} filePath - File path to check
+ * @returns {boolean} True if the file is a test file
+ */
+function isTestFile(filePath) {
+  const name = filePath.split('/').pop() || filePath;
+  // Check filename patterns
+  const nameMatch = (
+    name.includes('.test.') ||
+    name.includes('.spec.') ||
+    name.includes('_test.') ||
+    name.startsWith('test_')
+  );
+  if (nameMatch) return true;
+
+  // Check directory-based test paths (tests/, __tests__/, test/, spec/)
+  const dirMatch = /(?:^|\/)(?:tests|__tests__|test|spec)\//.test(filePath);
+  return dirMatch;
+}
+
+/**
+ * Detect scope drift between diff files and planned files.
+ * Returns files present in diff but not in plan (drift),
+ * and files in plan but not in diff (missing).
+ * Test files are excluded from drift detection.
+ * @param {string[]} diffFiles - Files changed in the diff
+ * @param {string[]} plannedFiles - Files listed in the plan
+ * @returns {{ drift: string[], missing: string[] }} Drift report
+ */
+function detectDrift(diffFiles, plannedFiles) {
+  if (!diffFiles || !plannedFiles) return { drift: [], missing: [] };
+
+  const plannedSet = new Set(plannedFiles);
+  const diffSet = new Set(diffFiles);
+
+  const drift = diffFiles.filter(
+    (f) => !plannedSet.has(f) && !isTestFile(f)
+  );
+
+  const missing = plannedFiles.filter((f) => !diffSet.has(f));
+
+  return { drift, missing };
+}
+
+/**
+ * Format a drift report as markdown.
+ * Returns "No drift detected" when both arrays are empty.
+ * @param {string[]} drift - Files in diff but not in plan
+ * @param {string[]} missing - Files in plan but not in diff
+ * @returns {string} Formatted markdown report
+ */
+function formatDriftReport(drift, missing) {
+  if ((!drift || drift.length === 0) && (!missing || missing.length === 0)) {
+    return 'No drift detected';
+  }
+
+  const sections = [];
+
+  if (drift && drift.length > 0) {
+    sections.push(
+      '### Scope Drift\n\nFiles changed but not in plan:\n\n' +
+        drift.map((f) => `- \`${f}\``).join('\n')
+    );
+  }
+
+  if (missing && missing.length > 0) {
+    sections.push(
+      '### Missing Work\n\nPlanned files not yet changed:\n\n' +
+        missing.map((f) => `- \`${f}\``).join('\n')
+    );
+  }
+
+  return sections.join('\n\n');
+}
+
+module.exports = { extractPlannedFiles, isTestFile, detectDrift, formatDriftReport };

package/server/lib/scope-checker.test.js

@@ -0,0 +1,175 @@
+/**
+ * Scope Checker Tests
+ * Detect scope drift between plan files and actual diffs
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  extractPlannedFiles,
+  detectDrift,
+  formatDriftReport,
+} from './scope-checker.js';
+
+describe('scope-checker', () => {
+  describe('extractPlannedFiles', () => {
+    it('extracts file paths from a Files section', () => {
+      const plan = '**Files:**\n- src/auth.ts\n- src/user.ts';
+      const result = extractPlannedFiles(plan);
+      expect(result).toEqual(['src/auth.ts', 'src/user.ts']);
+    });
+
+    it('returns empty array when no Files section exists', () => {
+      const plan = 'no files section';
+      const result = extractPlannedFiles(plan);
+      expect(result).toEqual([]);
+    });
+
+    it('strips parenthetical annotations like (new) and (modify)', () => {
+      const plan = '**Files:**\n- src/auth.ts (new)\n- src/user.ts (modify)\n- src/config.ts (delete)';
+      const result = extractPlannedFiles(plan);
+      expect(result).toEqual(['src/auth.ts', 'src/user.ts', 'src/config.ts']);
+    });
+
+    it('strips backticks from file paths', () => {
+      const plan = '**Files:**\n- `server/lib/review-fixer.js`\n- `server/lib/scope-checker.js` — new module';
+      const result = extractPlannedFiles(plan);
+      expect(result).toEqual(['server/lib/review-fixer.js', 'server/lib/scope-checker.js']);
+    });
+
+    it('collects files from multiple tasks', () => {
+      const plan = [
+        '## Task 1: Auth',
+        '**Files:**',
+        '- src/auth.ts',
+        '- src/auth.test.ts',
+        '',
+        '## Task 2: Users',
+        '**Files:**',
+        '- src/user.ts',
+        '- src/user.test.ts',
+      ].join('\n');
+      const result = extractPlannedFiles(plan);
+      expect(result).toEqual([
+        'src/auth.ts',
+        'src/auth.test.ts',
+        'src/user.ts',
+        'src/user.test.ts',
+      ]);
+    });
+
+    it('handles file entries with descriptions after em-dash', () => {
+      const plan = '**Files:**\n- server/lib/scope-checker.js — compares diff files against plan';
+      const result = extractPlannedFiles(plan);
+      expect(result).toEqual(['server/lib/scope-checker.js']);
+    });
+
+    it('returns empty array for empty string', () => {
+      const result = extractPlannedFiles('');
+      expect(result).toEqual([]);
+    });
+
+    it('deduplicates file paths across tasks', () => {
+      const plan = [
+        '## Task 1',
+        '**Files:**',
+        '- src/shared.ts',
+        '',
+        '## Task 2',
+        '**Files:**',
+        '- src/shared.ts',
+        '- src/other.ts',
+      ].join('\n');
+      const result = extractPlannedFiles(plan);
+      expect(result).toEqual(['src/shared.ts', 'src/other.ts']);
+    });
+  });
+
+  describe('detectDrift', () => {
+    it('returns no drift when diff matches plan exactly', () => {
+      const result = detectDrift(['src/auth.ts'], ['src/auth.ts']);
+      expect(result).toEqual({ drift: [], missing: [] });
+    });
+
+    it('detects extra files not in plan as drift', () => {
+      const result = detectDrift(
+        ['src/auth.ts', 'src/extra.ts'],
+        ['src/auth.ts']
+      );
+      expect(result).toEqual({
+        drift: ['src/extra.ts'],
+        missing: [],
+      });
+    });
+
+    it('detects planned files not in diff as missing', () => {
+      const result = detectDrift(
+        ['src/auth.ts'],
+        ['src/auth.ts', 'src/missing.ts']
+      );
+      expect(result).toEqual({
+        drift: [],
+        missing: ['src/missing.ts'],
+      });
+    });
+
+    it('excludes test files from drift detection', () => {
+      const result = detectDrift(['src/auth.test.ts'], []);
+      expect(result).toEqual({ drift: [], missing: [] });
+    });
+
+    it('excludes _test. pattern from drift detection', () => {
+      const result = detectDrift(['src/auth_test.go'], []);
+      expect(result).toEqual({ drift: [], missing: [] });
+    });
+
+    it('excludes test_ prefix from drift detection', () => {
+      const result = detectDrift(['test_auth.py'], []);
+      expect(result).toEqual({ drift: [], missing: [] });
+    });
+
+    it('returns empty arrays when both inputs are empty', () => {
+      const result = detectDrift([], []);
+      expect(result).toEqual({ drift: [], missing: [] });
+    });
+
+    it('handles both drift and missing simultaneously', () => {
+      const result = detectDrift(
+        ['src/auth.ts', 'src/extra.ts'],
+        ['src/auth.ts', 'src/missing.ts']
+      );
+      expect(result).toEqual({
+        drift: ['src/extra.ts'],
+        missing: ['src/missing.ts'],
+      });
+    });
+  });
+
+  describe('formatDriftReport', () => {
+    it('formats report with both drift and missing sections', () => {
+      const report = formatDriftReport(['extra.ts'], ['missing.ts']);
+      expect(report).toContain('extra.ts');
+      expect(report).toContain('missing.ts');
+      expect(report).toContain('Scope Drift');
+      expect(report).toContain('Missing');
+    });
+
+    it('returns no drift message when both arrays are empty', () => {
+      const report = formatDriftReport([], []);
+      expect(report).toBe('No drift detected');
+    });
+
+    it('formats report with only drift', () => {
+      const report = formatDriftReport(['extra.ts'], []);
+      expect(report).toContain('extra.ts');
+      expect(report).toContain('Scope Drift');
+      expect(report).not.toContain('Missing');
+    });
+
+    it('formats report with only missing', () => {
+      const report = formatDriftReport([], ['missing.ts']);
+      expect(report).toContain('missing.ts');
+      expect(report).toContain('Missing');
+      expect(report).not.toContain('Scope Drift');
+    });
+  });
+});