@in-the-loop-labs/pair-review 3.3.6 → 3.3.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@in-the-loop-labs/pair-review",
-  "version": "3.3.6",
+  "version": "3.3.7",
   "description": "Your AI-powered code review partner - Close the feedback loop with AI coding agents",
   "main": "src/server.js",
   "bin": {

package/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "pair-review",
-  "version": "3.3.6",
+  "version": "3.3.7",
   "description": "pair-review app integration — Open PRs and local changes in the pair-review web UI, run server-side AI analysis, and address review feedback. Requires the pair-review MCP server.",
   "author": {
     "name": "in-the-loop-labs",

package/plugin-code-critic/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "code-critic",
-  "version": "3.3.6",
+  "version": "3.3.7",
   "description": "AI-powered code review analysis — Run three-level AI analysis and implement-review-fix loops directly in your coding agent. Works standalone, no server required.",
   "author": {
     "name": "in-the-loop-labs",

package/public/js/components/AIPanel.js

@@ -965,20 +965,9 @@ class AIPanel {
     expandFileIfCollapsed(file) {
         if (!file) return false;
 
-        // Find the file wrapper - try exact match first, then partial match
-        let fileWrapper = document.querySelector(`[data-file-name="${file}"]`);
-
-        // Fallback: partial path match
-        if (!fileWrapper) {
-            const allWrappers = document.querySelectorAll('.d2h-file-wrapper');
-            for (const wrapper of allWrappers) {
-                const wrapperFile = wrapper.dataset.fileName;
-                if (wrapperFile && (wrapperFile.includes(file) || file.includes(wrapperFile))) {
-                    fileWrapper = wrapper;
-                    break;
-                }
-            }
-        }
+        const fileWrapper = window.prManager?.findFileElement
+            ? window.prManager.findFileElement(file)
+            : window.DiffRenderer?.findFileElement?.(file);
 
         if (!fileWrapper) return false;
 

package/public/js/modules/diff-renderer.js

@@ -194,6 +194,88 @@ class DiffRenderer {
     return div.innerHTML;
   }
 
+  /**
+   * Normalize a file path for DOM matching.
+   *
+   * Frontend mirror of `normalizePath()` + `resolveRenamedFile()` from
+   * `src/utils/paths.js`. Browser code cannot `require()` the backend module,
+   * so the logic is duplicated here. Keep this function in sync with those two
+   * when modifying normalization rules, otherwise the frontend and backend
+   * will disagree on which paths are equivalent.
+   *
+   * @param {string} filePath - File path to normalize
+   * @returns {string} Normalized file path
+   */
+  static normalizeFilePath(filePath) {
+    if (typeof filePath !== 'string') return '';
+
+    let normalized = filePath.trim();
+    if (!normalized) return '';
+
+    // Resolve git rename syntax to the new path.
+    normalized = normalized.replace(/\{[^}]*\s*=>\s*([^}]*)\}/, '$1');
+    normalized = normalized.replace(/\/+/g, '/');
+
+    // Strip leading './' and '/' segments until the string stops changing.
+    // This mirrors normalizePath in src/utils/paths.js for interleaved cases
+    // like '/./src/foo.js'.
+    let prevLength;
+    do {
+      prevLength = normalized.length;
+
+      while (normalized.startsWith('./')) {
+        normalized = normalized.slice(2);
+      }
+
+      while (normalized.startsWith('/')) {
+        normalized = normalized.slice(1);
+      }
+    } while (normalized.length !== prevLength);
+
+    return normalized;
+  }
+
+  /**
+   * Check whether two file paths should be treated as the same DOM target.
+   * @param {string} left - First file path
+   * @param {string} right - Second file path
+   * @returns {boolean} True when the paths refer to the same file
+   */
+  static pathsMatch(left, right) {
+    const normalizedLeft = DiffRenderer.normalizeFilePath(left);
+    const normalizedRight = DiffRenderer.normalizeFilePath(right);
+
+    if (!normalizedLeft || !normalizedRight) return false;
+
+    return normalizedLeft === normalizedRight ||
+      normalizedLeft.endsWith(`/${normalizedRight}`) ||
+      normalizedRight.endsWith(`/${normalizedLeft}`);
+  }
+
+  /**
+   * Try a direct selector lookup for a file path.
+   * Falls back silently when CSS.escape is unavailable or the selector is invalid.
+   * @param {string} attribute - data attribute to match (without brackets)
+   * @param {string} filePath - File path to search for
+   * @returns {Element|null} Matching element if found
+   */
+  static queryFileElement(attribute, filePath) {
+    if (!filePath) {
+      return null;
+    }
+
+    const css = globalThis.CSS;
+    const escapedValue = css && typeof css.escape === 'function'
+      ? css.escape(filePath)
+      : filePath;
+
+    try {
+      return document.querySelector(`[${attribute}="${escapedValue}"]`);
+    } catch {
+      return null;
+    }
+  }
+
   /**
    * Render a single diff line
    * @param {HTMLElement|DocumentFragment} container - Container to append to
@@ -696,18 +778,29 @@ class DiffRenderer {
    * @returns {Element|null} The file wrapper element or null if not found
    */
   static findFileElement(filePath) {
-    // Try exact match first
-    let fileElement = document.querySelector(`[data-file-name="${filePath}"]`);
-    if (fileElement) return fileElement;
+    const normalizedPath = DiffRenderer.normalizeFilePath(filePath);
 
-    fileElement = document.querySelector(`[data-file-path="${filePath}"]`);
-    if (fileElement) return fileElement;
+    // Try direct selector lookups first when we can safely escape the value.
+    const selectorCandidates = [filePath];
+    if (normalizedPath && normalizedPath !== filePath) {
+      selectorCandidates.push(normalizedPath);
+    }
+
+    for (const candidate of selectorCandidates) {
+      let fileElement = DiffRenderer.queryFileElement('data-file-name', candidate);
+      if (fileElement) return fileElement;
+
+      fileElement = DiffRenderer.queryFileElement('data-file-path', candidate);
+      if (fileElement) return fileElement;
+    }
 
-    // Try partial match for path segments
+    // Fall back to normalized iteration so special characters, rename syntax,
+    // and formatted variants still resolve to the rendered wrapper.
     const allFileWrappers = document.querySelectorAll('.d2h-file-wrapper');
     for (const wrapper of allFileWrappers) {
       const fileName = wrapper.dataset.fileName;
-      if (fileName && (fileName === filePath || fileName.endsWith('/' + filePath) || filePath.endsWith('/' + fileName))) {
+      const filePathAttr = wrapper.dataset.filePath;
+      if (DiffRenderer.pathsMatch(fileName, filePath) || DiffRenderer.pathsMatch(filePathAttr, filePath)) {
         return wrapper;
       }
     }

package/public/js/modules/file-comment-manager.js

@@ -1168,17 +1168,22 @@ class FileCommentManager {
    * @param {Array} suggestions - Array of file-level AI suggestions
    */
   loadFileComments(comments, suggestions) {
-    // Group by file
-    const commentsByFile = new Map();
-    const suggestionsByFile = new Map();
+    // Group by rendered file comments zone so path variants still attach to the
+    // correct file on initial load.
+    const commentsByZone = new Map();
+    const suggestionsByZone = new Map();
 
     if (comments) {
       for (const comment of comments) {
         if (comment.is_file_level === 1) {
-          if (!commentsByFile.has(comment.file)) {
-            commentsByFile.set(comment.file, []);
+          const zone = this.findZoneForFile(comment.file);
+          if (!zone) {
+            continue;
           }
-          commentsByFile.get(comment.file).push(comment);
+          if (!commentsByZone.has(zone)) {
+            commentsByZone.set(zone, []);
+          }
+          commentsByZone.get(zone).push(comment);
         }
       }
     }
@@ -1186,10 +1191,14 @@ class FileCommentManager {
     if (suggestions) {
       for (const suggestion of suggestions) {
         if (suggestion.is_file_level === 1) {
-          if (!suggestionsByFile.has(suggestion.file)) {
-            suggestionsByFile.set(suggestion.file, []);
+          const zone = this.findZoneForFile(suggestion.file);
+          if (!zone) {
+            continue;
+          }
+          if (!suggestionsByZone.has(zone)) {
+            suggestionsByZone.set(zone, []);
           }
-          suggestionsByFile.get(suggestion.file).push(suggestion);
+          suggestionsByZone.get(zone).push(suggestion);
         }
       }
     }
@@ -1197,7 +1206,6 @@ class FileCommentManager {
     // Find all file comment zones and populate them
     const zones = document.querySelectorAll('.file-comments-zone');
     for (const zone of zones) {
-      const fileName = zone.dataset.fileName;
       const container = zone.querySelector('.file-comments-container');
 
       // Selectively clear existing cards based on what we're about to reload
@@ -1221,8 +1229,8 @@ class FileCommentManager {
         }
       }
 
-      const fileComments = commentsByFile.get(fileName) || [];
-      const fileSuggestions = suggestionsByFile.get(fileName) || [];
+      const fileComments = commentsByZone.get(zone) || [];
+      const fileSuggestions = suggestionsByZone.get(zone) || [];
 
       // Display AI suggestions first
       for (const suggestion of fileSuggestions) {
@@ -1245,7 +1253,20 @@ class FileCommentManager {
    * @returns {HTMLElement|null} The zone element or null
    */
   findZoneForFile(fileName) {
-    return document.querySelector(`.file-comments-zone[data-file-name="${fileName}"]`);
+    const fileWrapper = window.DiffRenderer?.findFileElement
+      ? window.DiffRenderer.findFileElement(fileName)
+      : null;
+
+    if (fileWrapper) {
+      return fileWrapper.querySelector('.file-comments-zone');
+    }
+
+    try {
+      const escaped = globalThis.CSS?.escape ? CSS.escape(fileName) : fileName;
+      return document.querySelector(`.file-comments-zone[data-file-name="${escaped}"]`);
+    } catch {
+      return null;
+    }
   }
 
   /**

package/public/js/modules/suggestion-manager.js

@@ -160,6 +160,26 @@ class SuggestionManager {
     return window.CategoryEmoji?.getEmoji(category) || '\u{1F4AC}';
   }
 
+  /**
+   * Resolve a diff file wrapper for the provided path.
+   * @param {string} file - File path
+   * @returns {Element|null} Matching file wrapper
+   */
+  findFileElement(file) {
+    if (this.prManager?.findFileElement) {
+      return this.prManager.findFileElement(file);
+    }
+    if (window.DiffRenderer?.findFileElement) {
+      return window.DiffRenderer.findFileElement(file);
+    }
+    try {
+      const escaped = globalThis.CSS?.escape ? CSS.escape(file) : file;
+      return document.querySelector(`[data-file-name="${escaped}"]`);
+    } catch {
+      return null;
+    }
+  }
+
   /**
    * Find suggestions that target lines currently hidden in gaps
    * @param {Array} suggestions - Array of suggestions
@@ -176,9 +196,7 @@ class SuggestionManager {
       const side = suggestion.side || 'RIGHT';
 
       // Find the file wrapper
-      const fileElement = window.DiffRenderer ?
-        window.DiffRenderer.findFileElement(file) :
-        document.querySelector(`[data-file-name="${file}"]`);
+      const fileElement = this.findFileElement(file);
 
       if (!fileElement) {
         // File not in diff at all, not a hidden line issue
@@ -329,9 +347,7 @@ class SuggestionManager {
         const line = parseInt(lineStr);
 
         // Use helper method for file lookup
-        const fileElement = window.DiffRenderer ?
-          window.DiffRenderer.findFileElement(file) :
-          document.querySelector(`[data-file-name="${file}"]`);
+        const fileElement = this.findFileElement(file);
 
         if (!fileElement) {
           // This can happen when AI suggests a file path that doesn't exist in the diff

package/public/js/pr.js

@@ -2032,7 +2032,7 @@ class PRManager {
    * @param {string} filePath - Path of the file
    */
   toggleFileCollapse(filePath) {
-    const wrapper = document.querySelector(`[data-file-name="${filePath}"]`);
+    const wrapper = this.findFileElement(filePath);
     if (!wrapper) return;
 
     const isCollapsed = wrapper.classList.contains('collapsed');
@@ -2058,7 +2058,7 @@ class PRManager {
    * @param {boolean} isViewed - Whether the file is now viewed
    */
   toggleFileViewed(filePath, isViewed) {
-    const wrapper = document.querySelector(`[data-file-name="${filePath}"]`);
+    const wrapper = this.findFileElement(filePath);
 
     if (isViewed) {
       this.viewedFiles.add(filePath);
@@ -4359,7 +4359,7 @@ class PRManager {
   }
 
   scrollToFile(filePath) {
-    const fileWrapper = document.querySelector(`[data-file-name="${filePath}"]`);
+    const fileWrapper = this.findFileElement(filePath);
     if (fileWrapper) {
       fileWrapper.scrollIntoView({ behavior: 'smooth', block: 'start' });
     }

package/src/config.js

@@ -517,6 +517,17 @@ function getRepoResetScript(config, repository) {
   return repoConfig?.reset_script || null;
 }
 
+/**
+ * Gets whether updateWorktree should skip the bulk `git fetch <remote> --prune`
+ * @param {Object} config - Configuration object from loadConfig()
+ * @param {string} repository - Repository in "owner/repo" format
+ * @returns {boolean} - true if the bulk fetch should be skipped (default: false)
+ */
+function getRepoSkipBulkFetch(config, repository) {
+  const repoConfig = getRepoConfig(config, repository);
+  return repoConfig?.skip_bulk_fetch === true;
+}
+
 /**
  * Gets the configured pool size for a repository from file config only.
  * Prefer resolvePoolConfig() when DB repo_settings are available.
@@ -750,6 +761,7 @@ module.exports = {
   getRepoCheckoutTimeout,
   resolveRepoOptions,
   getRepoResetScript,
+  getRepoSkipBulkFetch,
   getRepoPoolSize,
   getRepoPoolFetchInterval,
   getRepoLoadSkills,

package/src/git/diff-flags.js

@@ -30,12 +30,16 @@ const GIT_DIFF_FLAGS_ARRAY = [
 
 /**
  * Array form for simple-git .diffSummary() calls.
+ * Use --numstat so simple-git parses machine-readable output with exact file paths.
+ * The default --stat output is display-oriented and may abbreviate long paths,
+ * which breaks downstream matching for generated route files and similar cases.
  * Omits --src-prefix/--dst-prefix since diffSummary doesn't output file content with prefixes.
  */
 const GIT_DIFF_SUMMARY_FLAGS_ARRAY = [
   '--no-color',
   '--no-ext-diff',
-  '--no-relative'
+  '--no-relative',
+  '--numstat'
 ];
 
 module.exports = {

package/src/git/worktree.js

@@ -733,9 +733,11 @@ class GitWorktreeManager {
    * @param {string} repo - Repository name
    * @param {number} number - PR number
    * @param {Object} prData - PR data from GitHub API (for remote resolution)
+   * @param {Object} [options]
+   * @param {boolean} [options.skipBulkFetch=false] - Skip the bulk `git fetch <remote> --prune`; targeted base-SHA and PR-head fetches still run
    * @returns {Promise<string>} Path to updated worktree
    */
-  async updateWorktree(owner, repo, number, prData) {
+  async updateWorktree(owner, repo, number, prData, options = {}) {
     const prInfo = { owner, repo, number };
     const headSha = this.getPRHeadSha(prData);
     const worktreePath = await this.getWorktreePath(prInfo);
@@ -756,9 +758,26 @@ class GitWorktreeManager {
       const remote = await this.resolveRemoteForPR(worktreeGit, prData, prInfo);
 
       // Fetch the latest from the resolved remote (--prune removes stale
-      // tracking refs that would otherwise block fetch on ref hierarchy conflicts)
-      console.log(`Fetching latest changes from ${remote}...`);
-      await worktreeGit.fetch([remote, '--prune']);
+      // tracking refs that would otherwise block fetch on ref hierarchy conflicts).
+      // Opt out via skip_bulk_fetch on very large monorepos where this is too slow;
+      // the targeted base-SHA and PR-head ref fetches below still run.
+      if (options.skipBulkFetch) {
+        console.log(`Skipping bulk fetch from ${remote} (skip_bulk_fetch enabled)`);
+        // Still fetch only the PR's base branch so ensureBaseShaAvailable does not
+        // have to fall back to `git fetch <remote> <sha>`, which some Git servers
+        // and mirrors reject (they require uploadpack.allowReachableSHA1InWant).
+        // This mirrors the targeted fetch used in createWorktreeForPR.
+        if (prData?.base_branch) {
+          try {
+            await worktreeGit.fetch([remote, `+refs/heads/${prData.base_branch}:refs/remotes/${remote}/${prData.base_branch}`]);
+          } catch (fetchError) {
+            console.warn(`Targeted base-branch fetch failed, will rely on existing refs: ${fetchError.message}`);
+          }
+        }
+      } else {
+        console.log(`Fetching latest changes from ${remote}...`);
+        await worktreeGit.fetch([remote, '--prune']);
+      }
 
       await this.ensureBaseShaAvailable(worktreeGit, prData, remote);
 

package/src/local-review.js

@@ -1,5 +1,5 @@
 // Copyright 2026 Tim Perkins (tjwp) | SPDX-License-Identifier: Apache-2.0
-const { execSync, exec } = require('child_process');
+const { execSync, exec, execFileSync } = require('child_process');
 const { promisify } = require('util');
 const crypto = require('crypto');
 const path = require('path');
@@ -15,7 +15,7 @@ const { initializeDatabase, ReviewRepository, RepoSettingsRepository } = require
 const { startServer } = require('./server');
 const { localReviewDiffs } = require('./routes/shared');
 const { getShaAbbrevLength } = require('./git/sha-abbrev');
-const { GIT_DIFF_FLAGS } = require('./git/diff-flags');
+const { GIT_DIFF_FLAGS, GIT_DIFF_FLAGS_ARRAY } = require('./git/diff-flags');
 const open = (...args) => process.env.PAIR_REVIEW_NO_OPEN ? Promise.resolve() : import('open').then(({ default: open }) => open(...args));
 
 // Design note: This module uses execSync for git commands despite async function signatures.
@@ -393,12 +393,23 @@ async function findMergeBase(repoPath, baseBranch) {
  * Generate diff output for untracked files using git diff --no-index.
  * @param {string} repoPath - Path to the git repository
  * @param {Array} untrackedFiles - Array from getUntrackedFiles()
- * @param {string} wFlag - Whitespace flag (e.g. ' -w' or '')
- * @param {string} [contextFlag=''] - Unified context flag (e.g. ' --unified=3')
- * @param {string} [extraArgsStr=''] - Additional git diff flags (e.g. ' --patience')
+ * @param {Object} [options]
+ * @param {boolean} [options.hideWhitespace=false] - Whether to pass -w
+ * @param {number} [options.contextLines=25] - Number of unified context lines
+ * @param {string[]} [options.extraArgs=[]] - Additional git diff flags
  * @returns {string} Combined diff text for untracked files
  */
-function generateUntrackedDiffs(repoPath, untrackedFiles, wFlag, contextFlag = '', extraArgsStr = '') {
+function generateUntrackedDiffs(repoPath, untrackedFiles, options = {}) {
+  const diffArgs = [
+    'diff',
+    '--no-index',
+    ...GIT_DIFF_FLAGS_ARRAY,
+    `--unified=${options.contextLines ?? 25}`,
+    ...(options.extraArgs || []),
+    ...(options.hideWhitespace ? ['-w'] : []),
+    '--',
+    '/dev/null'
+  ];
   let diff = '';
   for (const untracked of untrackedFiles) {
     if (!untracked.skipped) {
@@ -406,16 +417,21 @@ function generateUntrackedDiffs(repoPath, untrackedFiles, wFlag, contextFlag = '
         const filePath = path.join(repoPath, untracked.file);
         let fileDiff;
         try {
-          fileDiff = execSync(`git diff --no-index ${GIT_DIFF_FLAGS}${contextFlag}${extraArgsStr}${wFlag} -- /dev/null "${filePath}"`, {
+          fileDiff = execFileSync('git', [...diffArgs, filePath], {
             cwd: repoPath,
             encoding: 'utf8',
             stdio: ['pipe', 'pipe', 'pipe'],
             maxBuffer: 10 * 1024 * 1024
           });
         } catch (diffError) {
+          const diffStdout = typeof diffError?.stdout === 'string'
+            ? diffError.stdout
+            : Buffer.isBuffer(diffError?.stdout)
+              ? diffError.stdout.toString('utf8')
+              : null;
           if (diffError && typeof diffError === 'object' &&
-              diffError.status === GIT_DIFF_HAS_DIFFERENCES && typeof diffError.stdout === 'string') {
-            fileDiff = diffError.stdout;
+              diffError.status === GIT_DIFF_HAS_DIFFERENCES && diffStdout !== null) {
+            fileDiff = diffStdout;
           } else {
             throw diffError;
           }
@@ -552,7 +568,7 @@ async function generateScopedDiff(repoPath, scopeStart, scopeEnd, baseBranch, op
     const untrackedFiles = await getUntrackedFiles(repoPath);
     stats.untrackedFiles = untrackedFiles.length;
 
-    const untrackedDiff = generateUntrackedDiffs(repoPath, untrackedFiles, wFlag, contextFlag, extraArgsStr);
+    const untrackedDiff = generateUntrackedDiffs(repoPath, untrackedFiles, options);
     if (untrackedDiff) {
       if (diff) diff += '\n';
       diff += untrackedDiff;

package/src/routes/pr.js

@@ -25,7 +25,7 @@ const Analyzer = require('../ai/analyzer');
 const { v4: uuidv4 } = require('uuid');
 const fs = require('fs').promises;
 const path = require('path');
-const { getGitHubToken, getWorktreeDisplayName, resolveLoadSkills, buildCouncilProviderOverrides } = require('../config');
+const { getGitHubToken, getWorktreeDisplayName, resolveLoadSkills, buildCouncilProviderOverrides, getRepoSkipBulkFetch } = require('../config');
 const logger = require('../utils/logger');
 const { buildDiffLineSet } = require('../utils/diff-annotator');
 const { broadcastReviewEvent } = require('../events/review-events');
@@ -45,6 +45,7 @@ const {
   registerProcess: registerProcessForCancellation
 } = require('./shared');
 const { safeParseJson } = require('../utils/safe-parse-json');
+const { mergeChangedFilesWithDiff } = require('../utils/diff-file-list');
 const { resolveOriginalFileContentSpecs } = require('../utils/diff-file-content');
 const { validateCouncilConfig, normalizeCouncilConfig } = require('./councils');
 const { TIERS, TIER_ALIASES, VALID_TIERS, resolveTier } = require('../ai/prompts/config');
@@ -254,6 +255,8 @@ router.get('/api/pr/:owner/:repo/:number', async (req, res) => {
     }
 
     // Prepare response
+    const changedFiles = mergeChangedFilesWithDiff(extendedData.changed_files || [], extendedData.diff || '');
+
     // Use review.id instead of prMetadata.id to avoid ID collision with local mode
     const response = {
       success: true,
@@ -274,8 +277,8 @@ router.get('/api/pr/:owner/:repo/:number', async (req, res) => {
         shaAbbrevLength,
         created_at: prMetadata.created_at,
         updated_at: prMetadata.updated_at,
-        file_changes: extendedData.changed_files ? extendedData.changed_files.length : 0,
-        changed_files: extendedData.changed_files || [],
+        file_changes: changedFiles.length,
+        changed_files: changedFiles,
         additions: extendedData.additions || 0,
         deletions: extendedData.deletions || 0,
         diff_content: extendedData.diff || '',
@@ -375,7 +378,13 @@ router.post('/api/pr/:owner/:repo/:number/refresh', async (req, res) => {
 
     // Update worktree with latest changes
     const worktreeManager = new GitWorktreeManager(db);
-    const worktreePath = await worktreeManager.updateWorktree(owner, repo, prNumber, prData);
+    const worktreePath = await worktreeManager.updateWorktree(
+      owner,
+      repo,
+      prNumber,
+      prData,
+      { skipBulkFetch: getRepoSkipBulkFetch(config, repository) }
+    );
 
     // Generate fresh diff and get changed files
     const diffPrData = {
@@ -759,6 +768,8 @@ router.get('/api/pr/:owner/:repo/:number/diff', async (req, res) => {
     let diffContent = prData.diff || '';
     let changedFiles = prData.changed_files || [];
 
+    let gitattributes = null;
+
     if (hideWhitespace && worktreeRecord && worktreeRecord.path) {
       try {
         const worktreePath = worktreeRecord.path;
@@ -774,7 +785,7 @@ router.get('/api/pr/:owner/:repo/:number/diff', async (req, res) => {
 
           const summaryArgs = [`${baseSha}...${headSha}`, ...GIT_DIFF_SUMMARY_FLAGS_ARRAY, '-w'];
           const diffSummary = await git.diffSummary(summaryArgs);
-          const gitattributes = await getGeneratedFilePatterns(worktreePath);
+          gitattributes = await getGeneratedFilePatterns(worktreePath);
           changedFiles = diffSummary.files.map(file => {
             const resolvedFile = resolveRenamedFile(file.file);
             const isRenamed = resolvedFile !== file.file;
@@ -799,17 +810,22 @@ router.get('/api/pr/:owner/:repo/:number/diff', async (req, res) => {
     } else if (worktreeRecord && worktreeRecord.path) {
       // Add generated flag to changed files based on .gitattributes
       try {
-        const gitattributes = await getGeneratedFilePatterns(worktreeRecord.path);
-        changedFiles = changedFiles.map(file => ({
-          ...file,
-          generated: gitattributes.isGenerated(file.file)
-        }));
+        gitattributes = await getGeneratedFilePatterns(worktreeRecord.path);
       } catch (error) {
         logger.warn(`Could not load .gitattributes: ${error.message}`);
         // Continue without generated flags
       }
     }
 
+    changedFiles = mergeChangedFilesWithDiff(changedFiles, diffContent);
+
+    if (gitattributes) {
+      changedFiles = changedFiles.map(file => ({
+        ...file,
+        generated: gitattributes.isGenerated(file.file)
+      }));
+    }
+
     // When diff was regenerated (whitespace), compute aggregate stats from
     // the regenerated changedFiles instead of using stale cached values from prData.
     const additions = hideWhitespace

package/src/utils/diff-file-list.js

@@ -3,9 +3,111 @@ const { promisify } = require('util');
 const { exec } = require('child_process');
 const { queryOne } = require('../database');
 const { GIT_DIFF_FLAGS } = require('../git/diff-flags');
+const { normalizePath, resolveRenamedFile } = require('./paths');
 
 const execPromise = promisify(exec);
 
+/**
+ * Parse a unified diff into a map of file path -> per-file patch.
+ * Uses the "b/" path from the diff header as the canonical file path.
+ *
+ * @param {string} diff - Full unified diff
+ * @returns {Map<string, string>} Map of file paths to full patch text
+ */
+function parseUnifiedDiffPatches(diff) {
+  const filePatchMap = new Map();
+  if (!diff) return filePatchMap;
+
+  const parts = diff.split(/(?=^diff --git )/m);
+
+  for (const part of parts) {
+    if (!part.trim()) continue;
+
+    const match = part.match(/^diff --git a\/(.+?) b\/(.+)$/m);
+    if (match) {
+      filePatchMap.set(match[2], part);
+    }
+  }
+
+  return filePatchMap;
+}
+
+/**
+ * Count additions and deletions inside a single patch body.
+ *
+ * @param {string} patch - Per-file patch text
+ * @returns {{ insertions: number, deletions: number }}
+ */
+function countPatchStats(patch) {
+  let insertions = 0;
+  let deletions = 0;
+
+  for (const line of patch.split('\n')) {
+    if (line.startsWith('+') && !line.startsWith('+++ ')) {
+      insertions++;
+    } else if (line.startsWith('-') && !line.startsWith('--- ')) {
+      deletions++;
+    }
+  }
+
+  return { insertions, deletions };
+}
+
+/**
+ * Merge changed_files metadata with the authoritative file list from the diff.
+ * This recovers files when cached changed_files were derived from abbreviated
+ * diff --stat output and no longer match the full patch headers.
+ *
+ * @param {Array<object|string>} changedFiles - Existing changed_files array
+ * @param {string} diff - Full unified diff
+ * @returns {Array<object|string>} Merged changed_files array
+ */
+function mergeChangedFilesWithDiff(changedFiles, diff) {
+  const patchMap = parseUnifiedDiffPatches(diff);
+  if (patchMap.size === 0) {
+    return Array.isArray(changedFiles) ? changedFiles : [];
+  }
+
+  // Drop cached `git diff --stat` ellipsis stubs once we have authoritative
+  // patch headers to recover the full file paths from.
+  const existing = (Array.isArray(changedFiles) ? changedFiles : []).filter(entry => {
+    const filePath = typeof entry === 'string' ? entry : entry?.file;
+    return filePath && !filePath.includes('...');
+  });
+
+  const normalizedExisting = new Set(existing.map(file => {
+    const filePath = typeof file === 'string' ? file : file?.file;
+    return normalizePath(resolveRenamedFile(filePath));
+  }).filter(Boolean));
+
+  const merged = [...existing];
+
+  for (const [filePath, patch] of patchMap.entries()) {
+    const normalizedPatchPath = normalizePath(resolveRenamedFile(filePath));
+    if (normalizedExisting.has(normalizedPatchPath)) {
+      continue;
+    }
+
+    const { insertions, deletions } = countPatchStats(patch);
+    const renameFrom = patch.match(/^rename from (.+)$/m)?.[1] || null;
+    const renameTo = patch.match(/^rename to (.+)$/m)?.[1] || null;
+    const binary = /^Binary files .* differ$/m.test(patch) || /^GIT binary patch$/m.test(patch);
+
+    merged.push({
+      file: filePath,
+      insertions,
+      deletions,
+      changes: insertions + deletions,
+      binary,
+      renamed: Boolean(renameFrom && renameTo),
+      renamedFrom: renameFrom
+    });
+    normalizedExisting.add(normalizedPatchPath);
+  }
+
+  return merged;
+}
+
 /**
  * Return the list of file paths that belong to the review's diff.
  * Works for both PR-mode and local-mode reviews.
@@ -25,7 +127,9 @@ async function getDiffFileList(db, review) {
 
       if (prRecord?.pr_data) {
         const prData = JSON.parse(prRecord.pr_data);
-        return (prData.changed_files || []).map(f => f.file);
+        return mergeChangedFilesWithDiff(prData.changed_files || [], prData.diff || '')
+          .map(f => typeof f === 'string' ? f : f.file)
+          .filter(Boolean);
       }
     } catch {
       // parse / query error – fall through to empty list
@@ -55,4 +159,9 @@ async function getDiffFileList(db, review) {
   return [];
 }
 
-module.exports = { getDiffFileList };
+module.exports = {
+  getDiffFileList,
+  parseUnifiedDiffPatches,
+  countPatchStats,
+  mergeChangedFilesWithDiff
+};

package/src/utils/paths.js

@@ -13,6 +13,8 @@
  * - Handles interleaved patterns like '/./src' by iterating
  * - Normalizes multiple consecutive slashes to single slash
  * - Does NOT modify case (paths are case-sensitive on most systems)
+ * - Frontend mirror lives in `DiffRenderer.normalizeFilePath`
+ *   (`public/js/modules/diff-renderer.js`); keep behavior in sync
  *
  * @param {string} filePath - The file path to normalize
  * @returns {string} Normalized path
@@ -159,6 +161,8 @@ function normalizeRepository(owner, repo) {
  *   "tests/{old.js => new.js}"      → "tests/new.js"
  *   "{old-dir => new-dir}/file.js"  → "new-dir/file.js"
  *   "a/{b => c}/d.js"              → "a/c/d.js"
+ * Frontend mirror lives in `DiffRenderer.normalizeFilePath`
+ * (`public/js/modules/diff-renderer.js`); keep behavior in sync.
  *
  * @param {string} fileName - File name possibly containing rename syntax
  * @returns {string} Resolved file name with the new path, or original if no rename syntax