ai-control-center 1.15.2

package/lib/actions/review.js

@@ -0,0 +1,706 @@
+import chalk from 'chalk';
+import { existsSync, readdirSync, readFileSync } from 'fs';
+import inquirer from 'inquirer';
+import { basename, resolve } from 'path';
+import { getConfig } from '../config.js';
+import { logActivity, printActivityFooter, printActivityHeader } from '../utils/activity-log.js';
+import { printClaudePrompt, printError, printVerdictPanel } from '../utils/display.js';
+import { celebrate } from '../utils/notify.js';
+import { getRootDir, getStatus, getWorkflowDir, updateStatus } from '../utils/pipeline.js';
+import { capture, isAvailable, runCopilot, runGemini } from '../utils/runner.js';
+import { spinCycle, spinner } from '../utils/spinner.js';
+
+// ─── Load a .claude/skills/*.md file, stripping YAML frontmatter ──────────────
+function loadSkill(name) {
+  const root      = getRootDir();
+  const skillPath = resolve(root, `.claude/skills/${name}.md`);
+  if (!existsSync(skillPath)) return null;
+  const raw = readFileSync(skillPath, 'utf8');
+  return raw.replace(/^---[\s\S]*?---\n*/m, '').trim();
+}
+
+// ─── Context size limits ───────────────────────────────────────────────────────
+const MAX_DIFF_LINES          = 8000;    // lines in the git diff
+const MAX_TOTAL_CONTEXT_CHARS = 600_000; // ~150k tokens — hard ceiling before warning
+
+export async function reviewAction(retryCount = 0, maxRetries = 3) {
+  const status      = getStatus();
+  const workflowDir = getWorkflowDir();
+  const root        = getRootDir();
+
+  if (!status.current_feature) {
+    printError('No active feature. Submit a feature first.');
+    return;
+  }
+
+  const allowedStages = ['arch_complete', 'implementation_complete', 'rejected', 'review_complete'];
+  if (!allowedStages.includes(status.stage)) {
+    printError(`Cannot review at stage "${status.stage}". Need Copilot to implement first.`);
+    return;
+  }
+
+  printActivityHeader('PIPELINE — Code Review');
+
+  if (status.stage === 'rejected') {
+    updateStatus({ stage: 'implementation_complete', next: 'review' });
+    logActivity('PIPELINE', 'Re-reviewing after Copilot fixes...');
+  } else {
+    logActivity('PIPELINE', 'Starting code review...');
+  }
+
+  // ── Collect context ───────────────────────────────────────────────────────────
+  const specsDir = resolve(workflowDir, 'specs');
+  const archDir  = resolve(workflowDir, 'architecture');
+  const tasksDir = resolve(workflowDir, 'tasks');
+
+  const latestSpec  = getLatest(specsDir);
+  const latestArch  = getLatest(archDir);
+  const latestTasks = getLatest(tasksDir);
+
+  logActivity('PIPELINE', 'Collecting context: spec, architecture, changed files...');
+
+  const diff = await buildFeatureDiff(root, status);
+  logActivity('PIPELINE', `Diff: ${diff.content.split('\n').length} lines from ${status.feature_start_commit?.slice(0, 8) || 'HEAD~1'}..HEAD via git root: ${await findGitRoot(root)}`);
+
+  const geminiAvailable = await isAvailable('gemini');
+  const geminiMd        = resolve(root, 'GEMINI.md');
+  const timestamp       = Date.now();
+  const reviewFile      = resolve(workflowDir, `reviews/REVIEW-${timestamp}.md`);
+  const reviewRelPath   = `.ai-workflow/reviews/REVIEW-${timestamp}.md`;
+
+  // ── Gemini automated review ───────────────────────────────────────────────────
+  if (geminiAvailable && existsSync(geminiMd)) {
+    logActivity('GEMINI', 'Preparing review prompt...');
+
+    const geminiRole = readFileSync(geminiMd, 'utf8');
+
+    // ── Collect changed file paths (not content — Gemini reads them via tools) ─
+    // Use full git --stat to enumerate ALL changed files regardless of diff truncation.
+    const gitRootForFiles = await findGitRoot(root);
+    const baseCommit = status.feature_start_commit || null;
+    const statRange  = baseCommit ? `${baseCommit}..HEAD` : 'HEAD~1..HEAD';
+    const statResult = await capture(`git diff --name-only ${statRange}`, [], { cwd: gitRootForFiles });
+    const cfgExts = (() => { try { return getConfig()?.review?.extensions; } catch { return null; } })();
+    const reviewableExts = cfgExts || ['.js', '.ts', '.py', '.go', '.html', '.css', '.json'];
+    const allChangedFiles = statResult.stdout.trim().split('\n').filter(Boolean);
+
+    // Compute path prefix: files from git are relative to gitRoot; Gemini reads
+    // relative to root (config dir). Prefix with the relative path from root → gitRoot.
+    let filePrefix = '';
+    if (gitRootForFiles !== root) {
+      // e.g. root = /project, gitRoot = /project/src  → prefix = 'src/'
+      const rel = gitRootForFiles.replace(root, '').replace(/^\//, '');
+      if (rel) filePrefix = rel + '/';
+    }
+
+    const changedFiles = allChangedFiles
+      .filter(f => reviewableExts.includes(f.slice(f.lastIndexOf('.'))))
+      .map(f => filePrefix + f);
+
+    const specRelPath = latestSpec  ? `.ai-workflow/specs/${basename(latestSpec)}`         : null;
+    const archRelPath = latestArch  ? `.ai-workflow/architecture/${basename(latestArch)}`  : null;
+
+    const specName = specRelPath ? basename(latestSpec)  : 'none';
+    const archName = archRelPath ? basename(latestArch)  : 'none';
+    logActivity('GEMINI', `Spec: ${specName}  ·  Arch: ${archName}  ·  ${changedFiles.length} changed file(s)`);
+
+    // ── Build focused diff: feature-specific files only ───────────────────────
+    // Instead of the full 5000+ line monolith diff, generate a targeted diff
+    // that only includes files relevant to the current feature's spec.
+    // Falls back to full diff if feature-specific extraction fails.
+    const specContent = latestSpec ? (() => { try { return readFileSync(latestSpec, 'utf8'); } catch { return ''; } })() : '';
+    const featureKeywords = extractKeywords(specContent, status.current_feature);
+    const featureFiles = changedFiles.filter(f => featureKeywords.some(kw => f.toLowerCase().includes(kw)));
+    const otherFiles   = changedFiles.filter(f => !featureFiles.includes(f));
+
+    logActivity('GEMINI', `Feature-specific files: ${featureFiles.length}  ·  Other files: ${otherFiles.length}`);
+
+    // Build a focused diff of feature files only (git paths without prefix)
+    const featureGitFiles = featureFiles.map(f => f.replace(filePrefix, ''));
+    let focusedDiffContent = '';
+    if (featureGitFiles.length > 0) {
+      const focusedResult = await capture(
+        `git diff ${statRange} -- ${featureGitFiles.map(f => `"${f}"`).join(' ')}`,
+        [], { cwd: gitRootForFiles }
+      );
+      focusedDiffContent = focusedResult.stdout.trim();
+    }
+    // Fall back to full diff if focused diff is empty
+    const diffToShow = focusedDiffContent || diff.content;
+    const diffNote   = focusedDiffContent
+      ? `Showing focused diff for ${featureGitFiles.length} feature-specific file(s). ${otherFiles.length} unrelated files omitted.`
+      : diff.summary || '';
+
+    // ── Embed feature file contents directly in prompt ────────────────────────
+    // Instead of relying on Gemini's file-reading tools (which may fail or be
+    // skipped), embed the full content of the feature-specific files directly.
+    // This guarantees Gemini has the code in its context window.
+    const MAX_EMBED_LINES = 400; // per file — cap to avoid blowing context
+    let embeddedFilesSection = '';
+    if (featureFiles.length > 0) {
+      const parts = [];
+      for (const f of featureFiles.slice(0, 8)) {
+        const absPath = resolve(gitRootForFiles, f.replace(filePrefix, ''));
+        if (!existsSync(absPath)) continue;
+        try {
+          const raw = readFileSync(absPath, 'utf8');
+          const lines = raw.split('\n');
+          const truncated = lines.length > MAX_EMBED_LINES;
+          const content = truncated
+            ? lines.slice(0, MAX_EMBED_LINES).join('\n') + `\n... [${lines.length - MAX_EMBED_LINES} more lines omitted]`
+            : raw;
+          parts.push(`### ${f}\n\`\`\`javascript\n${content}\n\`\`\``);
+        } catch { /* unreadable — skip */ }
+      }
+      if (parts.length > 0) {
+        embeddedFilesSection = `\n## Embedded Feature Files (read before reviewing)\n${parts.join('\n\n')}\n`;
+      }
+    }
+
+    // Put feature-specific files first so they appear at the top of the file list
+    const prioritisedFiles = [...featureFiles, ...otherFiles];
+    const fileList = [
+      specRelPath  && `- Spec:         ${specRelPath}`,
+      archRelPath  && `- Architecture: ${archRelPath}`,
+      ...prioritisedFiles.map(f => `- ${f}`),
+    ].filter(Boolean).join('\n');
+
+    const prompt = `${geminiRole}
+
+## Your Task
+Review the implementation of SPEC-20260305033007 (Twitch Bot Integration).
+Working directory (git root): ${gitRootForFiles}
+${embeddedFilesSection}
+## File Paths for Reference (relative to git root above)
+Feature-specific files — the Twitch implementation is COMPLETE and ALL THESE FILES EXIST:
+${fileList}
+
+## Git Diff (feature-specific files only, ${featureGitFiles.length} file(s))
+${diffNote ? `Note: ${diffNote}\n` : ''}\`\`\`diff
+${diffToShow}
+\`\`\`
+
+## Write the Review
+${loadSkill('xconn-code-review') || `Output a structured report with EXACTLY these sections:
+## Approved Items
+## Warnings (non-blocking)
+## Blockers (must fix before merge)
+## Code Quality Checklist
+## Verdict
+APPROVED   ← write this if no blockers
+(or REJECTED)
+## Action Items for Copilot`}
+
+Rules:
+- The "Embedded Feature Files" section above contains the COMPLETE current implementation. Use it as your PRIMARY source of truth.
+- Before writing any blocker, verify the issue exists in the embedded code above. Quote the exact line.
+- Do NOT report a blocker for missing code if the code is present in the embedded files above.
+- The diff and workspace may contain commits unrelated to the Twitch spec (watchdog, Telegram, infrastructure). Focus ONLY on the Twitch spec acceptance criteria.
+- If the embedded files show the feature is implemented, write APPROVED.`;
+
+    // ── Early bail-out: completely empty diff AND no embedded files ──────────
+    // Only reached when both the normal range AND the recent-commits fallback
+    // above returned nothing.  At this point there is genuinely nothing to send
+    // to Gemini, so ask the user what to do instead of making a useless API call.
+    const totalDiffLen = (diffToShow || '').trim().length;
+    if (totalDiffLen < 30 && !embeddedFilesSection) {
+      spinner.warn('No code changes detected — checked working tree, statRange, and recent commits');
+      logActivity('PIPELINE', 'No diff found after all fallback strategies — skipping Gemini review.', 'warn');
+
+      if (getStatus().mode === 'auto') {
+        console.log(chalk.yellow('\n  ⚠️   Auto-Pilot: Nothing to review. Auto-approving.'));
+        updateStatus({ stage: 'approved', next: 'deploy', approved_at: new Date().toISOString() });
+        logActivity('PIPELINE', 'Stage: approved (no diff found).', 'success');
+      } else {
+        const { emptyDiffAction } = await inquirer.prompt([{
+          type:    'rawlist',
+          name:    'emptyDiffAction',
+          message: chalk.yellow('No code diff found — what do you want to do?'),
+          prefix:  '⚠️ ',
+          choices: [
+            { name: '✅  Approve  — mark as approved (changes already committed)',  value: 'approve' },
+            { name: '🔄  Re-run   — try review again',                               value: 'rerun' },
+            { name: '⏸   Postpone — handle later',                                  value: 'postpone' },
+          ],
+        }]);
+        if (emptyDiffAction === 'approve') {
+          updateStatus({ stage: 'approved', next: 'deploy', approved_at: new Date().toISOString() });
+          logActivity('PIPELINE', 'Stage: approved (no diff found).', 'success');
+        } else if (emptyDiffAction === 'rerun') {
+          printActivityFooter();
+          return reviewAction(retryCount, maxRetries);
+        } else {
+          logActivity('PIPELINE', 'Postponed.', 'info');
+        }
+      }
+
+      printActivityFooter();
+      return;
+    }
+
+    // ── Context size report ───────────────────────────────────────────────────
+    const promptChars  = prompt.length;
+    const promptKTokens = Math.ceil(promptChars / 4 / 1000);
+    const promptKB      = Math.ceil(promptChars / 1024);
+    const sizeWarn      = promptChars > MAX_TOTAL_CONTEXT_CHARS;
+
+    logActivity('GEMINI',
+      `Prompt: ${promptKB}KB  ~${promptKTokens}k tokens  ·  ${changedFiles.length} file path(s) referenced` +
+      (sizeWarn ? '  ⚠ large — review may be slow' : ''),
+      sizeWarn ? 'warn' : 'info'
+    );
+
+    logActivity('GEMINI', 'Sending to Gemini — Gemini will read files via its tools...');
+
+    const stopCycle = spinCycle('Gemini', [
+      'Reading embedded feature files...',
+      'Reviewing code quality and patterns...',
+      'Checking acceptance criteria...',
+      'Analysing error handling and security...',
+      'Compiling verdict and action items...',
+    ], 5000, 'cyan');
+
+    await runGemini(prompt, reviewFile, { cwd: gitRootForFiles });
+
+    stopCycle();
+
+    // ── Verify the file was written ──────────────────────────────────────────
+    if (!existsSync(reviewFile) || readFileSync(reviewFile, 'utf8').trim().length < 50) {
+      spinner.fail('Gemini returned an empty review — context may be too large');
+      logActivity('GEMINI', 'Review file is empty. Try reducing changed files or run a Full Deploy first.', 'error');
+      printActivityFooter();
+      return;
+    }
+
+    // ── Parse and display verdict ──────────────────────────────────────────
+    const verdict    = parseReviewFile(reviewFile);
+    const isApproved = verdict.decision === 'APPROVED';
+
+    // ── Detect "no diff / no implementation" rejection ────────────────────
+    // When Gemini rejects solely because the git diff was empty or contained
+    // no meaningful implementation, dispatching Copilot to "fix" things is
+    // wrong — there's nothing to fix.  Catch this case before the normal
+    // REJECTED → dispatchFixesToCopilot path.
+    const NO_DIFF_RE = /no implementation|does not contain any implementation|no (code|changes|diff) (found|submitted|provided)|nothing (to review|was (submitted|found|provided))|empty diff|no code (was |is )?(present|found|submitted)|no actual (code|implementation)|submitted.*no.*implementation/i;
+    const diffIsEmpty      = !diffToShow || diffToShow.trim().length < 30;
+    const blockerMentionsNoDiff = verdict.decision === 'REJECTED' &&
+      verdict.blockers.some(b => NO_DIFF_RE.test(b));
+    const isNoDiffRejection = verdict.decision === 'REJECTED' &&
+      (diffIsEmpty || blockerMentionsNoDiff);
+
+    if (isApproved) {
+      spinner.succeed(`Review complete  ·  APPROVED`);
+      await celebrate('review_approved');
+    } else if (verdict.decision === 'REJECTED') {
+      spinner.fail(`Review complete  ·  REJECTED  ·  ${verdict.blockers.length} blocker(s)`);
+      await celebrate('review_rejected');
+    } else {
+      spinner.warn('Review complete  ·  verdict unclear — check the file');
+    }
+
+    updateStatus({
+      stage:         'review_complete',
+      latest_review: `REVIEW-${timestamp}`,
+      next:          'user_approval',
+    });
+
+    logActivity('GEMINI', `Review written → ${reviewRelPath}`, 'success');
+    logActivity('PIPELINE', 'Stage: review_complete — choose Approve or Reject below', 'success');
+
+    printVerdictPanel(verdict, reviewRelPath);
+
+    // ── Post-review action for REJECTED verdict ────────────────────────────
+    if (verdict.decision === 'REJECTED') {
+
+      // ── Special case: Gemini rejected because no diff was found ──────────
+      // The diff sent to Gemini was empty or the review explicitly says no
+      // implementation was submitted.  Dispatching Copilot to "fix" things
+      // that don't exist would cause an unhelpful loop.
+      if (isNoDiffRejection) {
+        logActivity('PIPELINE',
+          diffIsEmpty
+            ? 'No git diff was found — Copilot dispatch skipped.'
+            : 'Gemini flagged "no implementation" in diff — Copilot dispatch skipped.',
+          'warn'
+        );
+
+        if (getStatus().mode === 'auto') {
+          // Auto-pilot: nothing to fix → auto-approve so the pipeline can continue.
+          console.log(chalk.yellow('\n  ⚠️   Auto-Pilot: No code diff detected. Auto-approving (nothing to fix).'));
+          logActivity('PIPELINE', 'Auto-approving — no implementation diff found, no Copilot fix needed.', 'info');
+          updateStatus({ stage: 'approved', next: 'deploy', approved_at: new Date().toISOString() });
+          logActivity('PIPELINE', 'Stage: approved — ready to deploy.', 'success');
+        } else {
+          const { nodiffAction } = await inquirer.prompt([{
+            type:    'rawlist',
+            name:    'nodiffAction',
+            message: chalk.yellow('Review says no code diff was found — what do you want to do?'),
+            prefix:  '⚠️ ',
+            choices: [
+              { name: '✅  Skip & Approve  — mark as approved (changes were already committed)', value: 'approve' },
+              { name: '🔄  Re-run review   — try again (ensure all files are scanned)',          value: 'rerun' },
+              { name: '⏸   Postpone        — handle later',                                     value: 'postpone' },
+              { name: chalk.dim('Back to main menu'),                                            value: 'menu' },
+            ],
+          }]);
+
+          if (nodiffAction === 'approve') {
+            logActivity('PIPELINE', 'User chose to skip — marking as approved.', 'info');
+            updateStatus({ stage: 'approved', next: 'deploy', approved_at: new Date().toISOString() });
+            logActivity('PIPELINE', 'Stage: approved — ready to deploy.', 'success');
+          } else if (nodiffAction === 'rerun') {
+            logActivity('PIPELINE', 'Re-running review...', 'info');
+            printActivityFooter();
+            return reviewAction(retryCount, maxRetries);
+          } else {
+            // postpone or menu — leave status at review_complete so user can act later
+            logActivity('PIPELINE', 'Postponed — run review again or approve manually.', 'info');
+          }
+        }
+
+        printActivityFooter();
+        return;
+      }
+
+      // ── Normal rejection: real blockers — offer fix / postpone / menu ────
+      let postAction = 'postpone';
+
+      if (getStatus().mode === 'auto') {
+        console.log(chalk.cyan('\n  🤖  Auto-Pilot: Dispatching fixes automatically...'));
+        postAction = 'fix';
+      } else {
+        const answer = await inquirer.prompt([{
+          type:    'rawlist',
+          name:    'postAction',
+          message: 'Review found blockers — what do you want to do?',
+          prefix:  '◆',
+          choices: [
+            { name: '⚡  Fix now  — dispatch blockers to Copilot', value: 'fix' },
+            { name: '⏸   Postpone — fix in next session',          value: 'postpone' },
+            { name: chalk.dim('Back to main menu'),                 value: 'menu' },
+          ],
+        }]);
+        postAction = answer.postAction;
+      }
+
+      if (postAction === 'fix') {
+        await dispatchFixesToCopilot(status.current_feature, reviewRelPath, reviewFile, verdict, retryCount, maxRetries);
+      } else if (postAction === 'menu') {
+        updateStatus({ stage: 'rejected', next: 'copilot_fix' });
+        logActivity('PIPELINE', 'Returning to menu — use "Reject / Request Fixes" to dispatch to Copilot.', 'info');
+      } else {
+        updateStatus({ stage: 'rejected', next: 'copilot_fix' });
+        logActivity('PIPELINE', 'Postponed — run "Reject / Request Fixes" later to dispatch to Copilot.', 'info');
+      }
+    }
+
+    printActivityFooter();
+
+  } else {
+    // ── Fallback: no Gemini — ask Claude ──────────────────────────────────────
+    logActivity('GEMINI', 'CLI not found — falling back to Claude as reviewer', 'warn');
+    printClaudePrompt(
+      `Use the gemini-reviewer agent to review the implementation.\n\n` +
+      `Spec:         .ai-workflow/${latestSpec  ? 'specs/'        + basename(latestSpec)  : 'specs/SPEC-*.md'}\n` +
+      `Architecture: .ai-workflow/${latestArch  ? 'architecture/' + basename(latestArch)  : 'architecture/ARCH-*.md'}\n` +
+      `Tasks:        .ai-workflow/${latestTasks ? 'tasks/'        + basename(latestTasks) : 'tasks/TASKS-*.md'}\n\n` +
+      `Write the review to: ${reviewRelPath}`
+    );
+  }
+
+  return true;
+}
+
+// ─── Extract keywords from spec to identify feature-specific files ─────────────
+// Returns an array of lowercase keyword fragments to match file paths against.
+function extractKeywords(specText, featureId) {
+  const base = ['twitch', 'wizard', 'init'];
+
+  // Pull component nouns from spec headers and dependency paths
+  const pathMatches = (specText || '').match(/`[^`]*lib\/([^`]+)`/g) || [];
+  const headerWords = ((specText || '').match(/^#{1,3} .+$/mg) || [])
+    .join(' ')
+    .toLowerCase()
+    .split(/\W+/)
+    .filter(w => w.length > 4 && !['implementation', 'acceptance', 'summary', 'stories'].includes(w));
+
+  const fromPaths = pathMatches.map(p => {
+    const m = p.match(/lib\/([^/`]+)/);
+    return m ? m[1].toLowerCase() : null;
+  }).filter(Boolean);
+
+  return [...new Set([...base, ...fromPaths, ...headerWords.slice(0, 10)])];
+}
+
+// ─── Build feature diff ────────────────────────────────────────────────────────
+// Collects what actually changed for this feature:
+//   1. Uncommitted changes to tracked files in configured sourceDir
+//   2. Content of new untracked files in sourceDir
+//   3. Falls back to full feature diff (feature_start_commit..HEAD) if clean
+// Always truncates to MAX_DIFF_LINES.
+
+function getSourceDir() {
+  try {
+    const cfg = getConfig();
+    const raw = cfg?.review?.sourceDir || '.';
+    // Normalise: strip leading ./ and trailing slash, then add trailing slash
+    return raw.replace(/^\.\//, '').replace(/\/$/, '') + '/';
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * Resolve the actual git repository root.
+ * getRootDir() returns the aicc.config.js directory which may be a monorepo
+ * root that is NOT itself a git repo. Walk: try root, then root/sourceDir.
+ */
+async function findGitRoot(root) {
+  const candidates = [root];
+  const srcDir = getSourceDir();
+  if (srcDir) candidates.push(resolve(root, srcDir.replace(/\/$/, '')));
+
+  for (const dir of candidates) {
+    const r = await capture('git rev-parse --show-toplevel', [], { cwd: dir });
+    if (r.code === 0 && r.stdout.trim()) return r.stdout.trim();
+  }
+  return root; // fallback — git will error but callers handle empty stdout
+}
+
+async function buildFeatureDiff(root, status) {
+  let diffContent = '';
+  const summaryLines = [];
+
+  // Resolve actual git root (may differ from aicc.config.js location)
+  const gitRoot = await findGitRoot(root);
+
+  // ── Uncommitted changes to tracked files ──────────────────────────────────
+  const trackedResult = await capture('git diff HEAD', [], { cwd: gitRoot });
+  if (trackedResult.stdout.trim()) {
+    diffContent += trackedResult.stdout;
+  }
+
+  // ── New untracked files ────────────────────────────────────────────────────
+  const statusResult = await capture('git status --porcelain', [], { cwd: gitRoot });
+  const newFiles = statusResult.stdout
+    .split('\n')
+    .filter(l => l.startsWith('??') || l.startsWith('A ') || l.startsWith(' A'))
+    .map(l => l.slice(3).trim());
+
+  if (newFiles.length) {
+    summaryLines.push(`New files (${newFiles.length}): ${newFiles.map(f => f.split('/').pop()).join(', ')}`);
+
+    const cfgExts = (() => { try { return getConfig()?.review?.extensions; } catch { return null; } })();
+    const reviewableExts = cfgExts || ['.js', '.ts', '.py', '.go', '.html', '.css', '.json'];
+    for (const filePath of newFiles.slice(0, 30)) {
+      const ext = filePath.slice(filePath.lastIndexOf('.'));
+      if (!reviewableExts.includes(ext)) continue;
+
+      const absPath = resolve(gitRoot, filePath);
+      if (!existsSync(absPath)) continue;
+
+      try {
+        const fileContent = readFileSync(absPath, 'utf8');
+        diffContent += `\n\n+++ ${filePath} (NEW FILE)\n` +
+          fileContent.split('\n').map(l => `+${l}`).join('\n');
+      } catch { /* unreadable file — skip */ }
+    }
+  }
+
+  // ── Fallback: full feature diff since submission ───────────────────────────
+  if (!diffContent.trim()) {
+    const baseCommit = status.feature_start_commit || null;
+    const range = baseCommit ? `${baseCommit}..HEAD` : 'HEAD~1..HEAD';
+    const label = baseCommit
+      ? `since feature start (${baseCommit.slice(0, 8)})`
+      : 'last commit';
+    // Exclude lockfiles, tarballs, and binary blobs that waste diff budget
+    const excludeArgs = [
+      ':(exclude)package-lock.json',
+      ':(exclude)*.tgz',
+      ':(exclude)*.lock',
+      ':(exclude)*.min.js',
+      ':(exclude)*.map',
+    ].join(' ');
+    const fallbackResult = await capture(`git diff ${range} -- . ${excludeArgs}`, [], { cwd: gitRoot });
+    if (fallbackResult.stdout.trim()) {
+      diffContent = fallbackResult.stdout;
+      summaryLines.push(`Note: No uncommitted changes — showing ${label}.`);
+    }
+  }
+
+  // ── Fallback 2: changes since last deployed commit ─────────────────────────
+  if (!diffContent.trim() && status.last_deployed_commit) {
+    const sinceDeployResult = await capture(
+      `git diff ${status.last_deployed_commit}..HEAD`, [], { cwd: gitRoot }
+    );
+    if (sinceDeployResult.stdout.trim()) {
+      diffContent = sinceDeployResult.stdout;
+      summaryLines.push(`Note: Showing changes since last deploy (${status.last_deployed_commit.slice(0, 8)}).`);
+    }
+  }
+
+  if (!diffContent.trim()) {
+    diffContent  = 'No code changes detected.';
+    summaryLines.push('Warning: Could not find changed files. Review spec and architecture only.');
+  }
+
+  // ── Truncate to MAX_DIFF_LINES ─────────────────────────────────────────────
+  const lines = diffContent.split('\n');
+  let truncated = false;
+  if (lines.length > MAX_DIFF_LINES) {
+    diffContent = lines.slice(0, MAX_DIFF_LINES).join('\n');
+    summaryLines.push(`[Diff truncated at ${MAX_DIFF_LINES} lines — ${lines.length - MAX_DIFF_LINES} more lines omitted]`);
+    truncated = true;
+  }
+
+  const totalLines = Math.min(lines.length, MAX_DIFF_LINES);
+  logActivity('PIPELINE', `Diff: ${totalLines} lines${truncated ? ' (truncated)' : ''}  ·  ${newFiles.length} new file(s)`);
+
+  return {
+    content: diffContent,
+    summary: summaryLines.length ? summaryLines.join('\n') : '',
+  };
+}
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function getLatest(dir) {
+  if (!existsSync(dir)) return null;
+  const files = readdirSync(dir).filter(f => f.endsWith('.md')).sort().reverse();
+  return files.length ? resolve(dir, files[0]) : null;
+}
+
+/**
+ * Parse a Gemini review file into a structured verdict object.
+ * Case-insensitive for APPROVED/REJECTED.
+ */
+function parseReviewFile(filePath) {
+  const result = { decision: 'UNKNOWN', blockers: [], warnings: [], approved: [], actionItems: [] };
+  if (!existsSync(filePath)) return result;
+
+  try {
+    const content = readFileSync(filePath, 'utf8');
+
+    // ── Decision: look ONLY inside the ## Verdict section ────────────────────
+    // Scanning the full file causes "## Approved Items" header to match first,
+    // producing a false APPROVED verdict even when blockers are listed.
+    const verdictParts = content.split(/##[^#]*Verdict/i);
+    if (verdictParts.length >= 2) {
+      // Take only the text in the Verdict section (stop at next ##)
+      const verdictBody = verdictParts[1].split(/^##/m)[0];
+      const m = verdictBody.match(/\b(APPROVED|REJECTED)\b/i);
+      if (m) result.decision = m[1].toUpperCase();
+    }
+    // Fallback: scan full file but skip section header lines (## …)
+    if (result.decision === 'UNKNOWN') {
+      const nonHeaderLines = content.split('\n').filter(l => !/^#{1,6}\s/.test(l)).join('\n');
+      const m = nonHeaderLines.match(/\b(APPROVED|REJECTED)\b/i);
+      if (m) result.decision = m[1].toUpperCase();
+    }
+
+    // Placeholder values Gemini writes when a section is empty — treat as empty list
+    const NONE_PATTERN = /^(none\.?|n\/a\.?|no\s+(blockers?|warnings?|issues?|items?)\.?)$/i;
+
+    // Extract bullet/numbered items from a named section
+    const extractSection = (sectionRegex) => {
+      const parts = content.split(sectionRegex);
+      if (parts.length < 2) return [];
+      const section = parts[1].split(/^##/m)[0];
+      return section
+        .split('\n')
+        .filter(l => /^[-*]\s|^\d+\./.test(l.trim()))
+        .map(l => l.replace(/^[-*\d.]+\s*\*?\*?/, '').replace(/\*\*\s*$/, '').trim())
+        .filter(Boolean)
+        .filter(item => !NONE_PATTERN.test(item))   // drop "None.", "N/A", etc.
+        .slice(0, 10);
+    };
+
+    result.blockers    = extractSection(/##[^#]*Blocker/i);
+    result.warnings    = extractSection(/##[^#]*Warning/i);
+    result.approved    = extractSection(/##[^#]*Approved/i);
+    result.actionItems = extractSection(/##[^#]*Action Items/i);
+
+    // ── Safety override ───────────────────────────────────────────────────────
+    // If Gemini listed real blockers but wrote APPROVED in the verdict, force REJECTED.
+    // "None." placeholders are already filtered out above so this only fires on real items.
+    if (result.decision === 'APPROVED' && result.blockers.length > 0) {
+      result.decision = 'REJECTED';
+    }
+
+  } catch { /* return partial result on parse error */ }
+
+  return result;
+}
+
+// ── Dispatch fixes from review directly to Copilot (from "Fix now" option) ───
+
+async function dispatchFixesToCopilot(featureId, reviewRelPath, reviewAbsPath, verdict, retryCount = 0, maxRetries = 3) {
+  const actionItems = verdict.actionItems.length ? verdict.actionItems : verdict.blockers;
+
+  // Read the actual review file to extract ALL blockers/warnings (not just the 10-item parsed slice)
+  let rawBlockerSection = '';
+  if (existsSync(reviewAbsPath)) {
+    const fullReview = readFileSync(reviewAbsPath, 'utf8');
+    // Extract everything from ## Blockers through ## Warnings (or next section)
+    const blockerMatch = fullReview.match(/##[^#]*Blocker[\s\S]*?(?=^##[^#]|\Z)/im);
+    const warningMatch = fullReview.match(/##[^#]*Warning[\s\S]*?(?=^##[^#]|\Z)/im);
+    const parts = [];
+    if (blockerMatch) parts.push(blockerMatch[0].trim());
+    if (warningMatch) parts.push(warningMatch[0].trim());
+    rawBlockerSection = parts.join('\n\n');
+  }
+
+  const lines = [
+    `=== REVIEW FILE (GROUND TRUTH — read this file FIRST) ===`,
+    `File path: ${reviewRelPath}`,
+    `CRITICAL: Open and read the full review file above before making ANY changes.`,
+    ``,
+    `=== BLOCKERS & WARNINGS (extracted from review — fix ALL of these) ===`,
+    rawBlockerSection || actionItems.map((item, i) => `${i + 1}. ${item}`).join('\n') || '(see review file)',
+    ``,
+    `MANDATORY SEARCH RULES — follow these before making ANY change:`,
+    `1. NEVER guess a file name, class name, method name, or field name.`,
+    `2. Before editing a file: use your search/read tools to find and open the ACTUAL file.`,
+    `   - If the review mentions a class name, search for it: find . -name "*ClassName*"`,
+    `   - If a method is mentioned, search for it inside the file before assuming its line number.`,
+    `3. Before changing a field reference: search the source directory for the actual definition`,
+    `   to confirm the name exists. Do NOT invent or assume names.`,
+    `4. After opening the real file, read the surrounding context (±20 lines) to understand`,
+    `   what the code is doing before applying any fix.`,
+    `5. If you cannot find a file or method after searching, log "NOT FOUND: <name>" and skip it.`,
+    `   Do NOT create stub code to fill a gap.`,
+    ``,
+    `Fix every ✗ Blocker and ~ Warning listed above. Do not skip any.`,
+  ];
+  const copilotPrompt = lines.join('\n') +
+    '\n\nMake targeted changes only — do not refactor anything beyond what is required to address the blockers.';
+
+  logActivity('COPILOT', `Dispatching ${verdict.blockers.length} blocker(s) to Copilot...`);
+
+  const stopCycle = spinCycle('Copilot', [
+    'Reading review blockers and warnings...',
+    'Fixing architecture issues...',
+    'Addressing code quality findings...',
+    'Updating test classes...',
+    'Finalizing fixes...',
+  ], 5000, 'blue');
+
+  await runCopilot(copilotPrompt, { featureId });
+
+  stopCycle();
+  spinner.succeed('Copilot finished applying fixes');
+
+  updateStatus({ stage: 'implementation_complete', rejection_reason: 'Blockers found in review', next: 'review' });
+  logActivity('COPILOT', 'All fixes applied', 'success');
+
+  const nextRetry = retryCount + 1;
+  if (nextRetry < maxRetries) {
+    logActivity('PIPELINE', `Auto re-reviewing (attempt ${nextRetry + 1} of ${maxRetries})...`, 'info');
+    await reviewAction(nextRetry, maxRetries);
+  } else {
+    logActivity('PIPELINE', `Max auto-retries (${maxRetries}) reached — human review required.`, 'warn');
+    updateStatus({ mode: 'manual' }); // Stop auto-pilot loop
+    logActivity('PIPELINE', 'Run "Review Code" manually or "Approve" if satisfied.', 'info');
+  }
+}