@in-the-loop-labs/pair-review 3.1.2 → 3.1.4

package/src/ai/gemini-provider.js

@@ -20,6 +20,16 @@ const BIN_DIR = path.join(__dirname, '..', '..', 'bin');
  * Gemini model definitions with tier mappings
  */
 const GEMINI_MODELS = [
+  {
+    id: 'gemini-3.1-flash-lite-preview',
+    aliases: ['gemini-3.1-flash-lite'],
+    name: '3.1 Flash Lite',
+    tier: 'fast',
+    tagline: 'Cheapest',
+    description: 'Ultra-efficient model for high-volume cost-conscious scans',
+    badge: 'Cheapest',
+    badgeClass: 'badge-speed'
+  },
   {
     id: 'gemini-3-flash-preview',
     aliases: ['gemini-3-flash'],

package/src/ai/pi-provider.js

@@ -16,7 +16,10 @@
  * for cross-provider switching, which translates to `--provider <provider> --model <model>`.
  */
 
+const crypto = require('crypto');
 const path = require('path');
+const os = require('os');
+const fs = require('fs');
 const { spawn } = require('child_process');
 const { AIProvider, registerProvider, quoteShellArgs } = require('./provider');
 const logger = require('../utils/logger');
@@ -244,19 +247,23 @@ class PiProvider extends AIProvider {
 
       const levelPrefix = logPrefix || `[Level ${level}]`;
       logger.info(`${levelPrefix} Executing Pi CLI...`);
-      logger.info(`${levelPrefix} Writing prompt via stdin: ${prompt.length} bytes`);
+      logger.info(`${levelPrefix} Prompt: ${prompt.length} bytes`);
+
+      // Write prompt to a temp file and use Pi's @file syntax as a positional arg.
+      // This bypasses devx stdin interference that breaks --mode json output.
+      const tmpFile = path.join(os.tmpdir(), `pair-review-prompt-${Date.now()}-${process.pid}-${crypto.randomUUID()}.txt`);
+      fs.writeFileSync(tmpFile, prompt);
+      const cleanupTmpFile = () => { try { fs.unlinkSync(tmpFile); } catch { /* ignore */ } };
 
-      // Use stdin for prompt instead of CLI argument (avoids shell escaping issues)
-      // Pi reads from stdin when using -p with no positional message arguments
       let fullCommand;
       let fullArgs;
 
       if (this.useShell) {
-        fullCommand = `${this.piCmd} ${quoteShellArgs(this.baseArgs).join(' ')}`;
+        fullCommand = `${this.piCmd} ${quoteShellArgs([...this.baseArgs, `@${tmpFile}`]).join(' ')}`;
         fullArgs = [];
       } else {
         fullCommand = this.piCmd;
-        fullArgs = [...this.baseArgs];
+        fullArgs = [...this.baseArgs, `@${tmpFile}`];
       }
 
       const pi = spawn(fullCommand, fullArgs, {
@@ -269,6 +276,10 @@ class PiProvider extends AIProvider {
         shell: this.useShell
       });
 
+      // Close stdin immediately — prompt is delivered via @file, but some
+      // wrappers (e.g., devx) keep the process alive until stdin is closed.
+      pi.stdin.end();
+
       const pid = pi.pid;
       logger.debug(`${levelPrefix} Pi CLI command: ${fullCommand} ${fullArgs.join(' ')}`);
       logger.info(`${levelPrefix} Spawned Pi CLI process: PID ${pid}`);
@@ -340,6 +351,7 @@ class PiProvider extends AIProvider {
 
       // Handle completion
       pi.on('close', (code) => {
+        cleanupTmpFile();
         if (settled) return;  // Already settled by timeout or error
 
         // Flush any remaining stream parser buffer
@@ -413,7 +425,7 @@ class PiProvider extends AIProvider {
 
           // Use async IIFE to handle the async LLM extraction
           (async () => {
-            // Guard: if already settled (by timeout, stdin error, or cancellation),
+            // Guard: if already settled (by timeout, process error, or cancellation),
             // skip the LLM extraction entirely to avoid misleading log output
             if (settled) return;
 
@@ -437,6 +449,7 @@ class PiProvider extends AIProvider {
 
       // Handle errors
       pi.on('error', (error) => {
+        cleanupTmpFile();
         if (error.code === 'ENOENT') {
           logger.error(`${levelPrefix} Pi CLI not found. Please ensure Pi CLI is installed.`);
           settle(reject, new Error(`${levelPrefix} Pi CLI not found. ${PiProvider.getInstallInstructions()}`));
@@ -445,21 +458,6 @@ class PiProvider extends AIProvider {
           settle(reject, error);
         }
       });
-
-      // Handle stdin errors (e.g., EPIPE if process exits before write completes)
-      pi.stdin.on('error', (err) => {
-        logger.error(`${levelPrefix} stdin error: ${err.message}`);
-      });
-
-      // Send the prompt to stdin (Pi reads from stdin when using -p with no args)
-      pi.stdin.write(prompt, (err) => {
-        if (err) {
-          logger.error(`${levelPrefix} Failed to write prompt to stdin: ${err}`);
-          pi.kill('SIGTERM');
-          settle(reject, new Error(`${levelPrefix} Failed to write prompt to stdin: ${err}`));
-        }
-      });
-      pi.stdin.end();
     });
   }
 
@@ -740,14 +738,13 @@ class PiProvider extends AIProvider {
     // Build args consistently using the shared method, applying provider and model extra_args
     const args = this.buildArgsForModel(model);
 
-    // For extraction, we pass the prompt via stdin
-    // Pi reads from stdin when using -p with no positional message arguments
+    // Use @file syntax for prompt delivery (bypasses devx stdin interference)
     if (useShell) {
       return {
         command: `${piCmd} ${quoteShellArgs(args).join(' ')}`,
         args: [],
         useShell: true,
-        promptViaStdin: true,
+        promptViaFile: true,
         env: this.extraEnv
       };
     }
@@ -755,7 +752,7 @@ class PiProvider extends AIProvider {
       command: piCmd,
       args,
       useShell: false,
-      promptViaStdin: true,
+      promptViaFile: true,
       env: this.extraEnv
     };
   }

package/src/ai/provider.js

@@ -6,7 +6,10 @@
  * and provides a factory function to create provider instances.
  */
 
+const crypto = require('crypto');
 const path = require('path');
+const os = require('os');
+const fs = require('fs');
 const { spawn } = require('child_process');
 const logger = require('../utils/logger');
 const { extractJSON } = require('../utils/json-extractor');
@@ -181,6 +184,7 @@ class AIProvider {
    * @property {string[]} args - Arguments (prompt will be appended if promptViaStdin is false)
    * @property {boolean} useShell - Whether to use shell mode
    * @property {boolean} promptViaStdin - If true, send prompt to stdin; if false, append to args
+   * @property {boolean} promptViaFile - If true, write prompt to a temp file and pass @filepath as a positional arg (Pi-specific @file syntax; currently only used by PiProvider)
    */
   getExtractionConfig(model) {
     // Default: extraction not supported
@@ -213,7 +217,7 @@ class AIProvider {
       };
     }
 
-    const { command, args, useShell, promptViaStdin, env: configEnv } = config;
+    const { command, args, useShell, promptViaStdin, promptViaFile, env: configEnv } = config;
     const prompt = `Extract the JSON object from the following text. Return ONLY the valid JSON, nothing else. Do not include any explanation, markdown formatting, or code blocks - just the raw JSON.
 
 === BEGIN INPUT TEXT ===
@@ -222,7 +226,21 @@ ${rawResponse}
 
     return new Promise((resolve) => {
       // Build final command and args based on prompt delivery method
-      const finalArgs = promptViaStdin ? args : [...args, prompt];
+      // promptViaFile: write to temp file, pass @filepath as positional arg (Pi @file syntax)
+      // promptViaStdin: write to process stdin after spawn
+      // default: pass prompt as positional CLI arg
+      let tmpFile = null;
+      let cleanupTmpFile = () => {};
+      let finalArgs;
+
+      if (promptViaFile) {
+        tmpFile = path.join(os.tmpdir(), `pair-review-extract-${Date.now()}-${process.pid}-${crypto.randomUUID()}.txt`);
+        fs.writeFileSync(tmpFile, prompt);
+        cleanupTmpFile = () => { try { fs.unlinkSync(tmpFile); } catch { /* ignore */ } };
+        finalArgs = [...args, `@${tmpFile}`];
+      } else {
+        finalArgs = promptViaStdin ? args : [...args, prompt];
+      }
 
       logger.info(`${levelPrefix} Attempting LLM-based JSON extraction with ${extractionModel}...`);
 
@@ -269,6 +287,7 @@ ${rawResponse}
       });
 
       proc.on('close', (code) => {
+        cleanupTmpFile();
         if (settled) return;
 
         if (code !== 0) {
@@ -295,11 +314,12 @@ ${rawResponse}
       });
 
       proc.on('error', (error) => {
+        cleanupTmpFile();
         logger.warn(`${levelPrefix} LLM extraction process error: ${error.message}`);
         settle({ success: false, error: error.message });
       });
 
-      // Send prompt via stdin if configured
+      // Deliver prompt based on config method
       if (promptViaStdin) {
         // Handle stdin errors (e.g., EPIPE if process exits before write completes)
         proc.stdin.on('error', (err) => {
@@ -314,6 +334,9 @@ ${rawResponse}
           }
         });
         proc.stdin.end();
+      } else if (promptViaFile) {
+        // Prompt delivered via @file arg — close stdin so wrappers (e.g., devx) don't hang
+        proc.stdin.end();
       }
     });
   }

package/src/chat/pi-bridge.js

@@ -35,6 +35,7 @@ class PiBridge extends EventEmitter {
    * @param {boolean} [options.useShell] - Use shell mode for multi-word commands
    * @param {string[]} [options.skills] - Array of skill file paths to load via --skill
    * @param {string[]} [options.extensions] - Array of extension directory paths to load via -e
+   * @param {string[]} [options.extraArgs] - Extra CLI args to append (e.g., from config extra_args)
    * @param {string} [options.sessionPath] - Path to a session file for resumption
    */
   constructor(options = {}) {
@@ -49,6 +50,7 @@ class PiBridge extends EventEmitter {
     this.useShell = options.useShell || false;
     this.skills = options.skills || [];
     this.extensions = options.extensions || [];
+    this.extraArgs = options.extraArgs || [];
     this.sessionPath = options.sessionPath || null;
 
     this._process = null;
@@ -288,6 +290,12 @@ class PiBridge extends EventEmitter {
       args.push('-e', ext);
     }
 
+    // Append extra args from provider config (e.g., extra_args in chat_providers).
+    // These go last so they can override earlier flags if needed.
+    if (this.extraArgs.length > 0) {
+      args.push(...this.extraArgs);
+    }
+
     return args;
   }
 

package/src/chat/prompt-builder.js

@@ -8,7 +8,7 @@
  */
 
 const logger = require('../utils/logger');
-const { scopeGitHints, DEFAULT_SCOPE } = require('../local-scope');
+const { scopeGitHints, reviewScope } = require('../local-scope');
 
 /**
  * Build a lean system prompt for chat sessions.
@@ -142,8 +142,7 @@ function buildReviewContext(review, prData) {
     lines.push('');
     lines.push('## Viewing Code Changes');
 
-    const scopeStart = review.local_scope_start || DEFAULT_SCOPE.start;
-    const scopeEnd = review.local_scope_end || DEFAULT_SCOPE.end;
+    const { start: scopeStart, end: scopeEnd } = reviewScope(review);
     const baseBranch = review.local_base_branch || null;
     const hints = scopeGitHints(scopeStart, scopeEnd, baseBranch);
 

package/src/chat/session-manager.js

@@ -580,6 +580,7 @@ class ChatSessionManager {
       provider: def?.provider || null,
       model: options.model || def?.model,
       piCommand: def?.command,
+      extraArgs: def?.args,
       env: def?.env,
       useShell: def?.useShell,
       tools: CHAT_TOOLS,

package/src/config.js

@@ -385,6 +385,7 @@ function showWelcomeMessage() {
  */
 function expandPath(p) {
   if (!p) return p;
+  if (p === '~') return os.homedir();
   if (p.startsWith('~/')) {
     return path.join(os.homedir(), p.slice(2));
   }

package/src/database.js

@@ -20,7 +20,7 @@ function getDbPath() {
 /**
  * Current schema version - increment this when adding new migrations
  */
-const CURRENT_SCHEMA_VERSION = 35;
+const CURRENT_SCHEMA_VERSION = 36;
 
 /**
  * Database schema SQL statements
@@ -1605,6 +1605,36 @@ const MIGRATIONS = {
     addColumnIfNotExists('comments', 'severity', 'TEXT');
 
     console.log('Migration to schema version 35 complete');
+  },
+
+  // Migration to version 36: Normalize diff scopes to always include 'unstaged'.
+  // AI models read files from the working tree, so the diff scope must always
+  // cover at least the unstaged state for review context to be coherent.
+  36: (db) => {
+    console.log('Running migration to schema version 36...');
+
+    // Expand scopes where end < unstaged (branch-only, branch-staged, staged-only)
+    const expandEnd = db.prepare(
+      `UPDATE reviews SET local_scope_end = 'unstaged'
+       WHERE local_scope_end IN ('branch', 'staged') AND review_type = 'local'`
+    );
+    const expandResult = expandEnd.run();
+    if (expandResult.changes > 0) {
+      console.log(`  Expanded scope end to 'unstaged' for ${expandResult.changes} review(s)`);
+    }
+
+    // Fix untracked-only → unstaged..untracked
+    const fixUntracked = db.prepare(
+      `UPDATE reviews SET local_scope_start = 'unstaged'
+       WHERE local_scope_start = 'untracked' AND local_scope_end = 'untracked'
+       AND review_type = 'local'`
+    );
+    const fixResult = fixUntracked.run();
+    if (fixResult.changes > 0) {
+      console.log(`  Normalized untracked-only scope for ${fixResult.changes} review(s)`);
+    }
+
+    console.log('Migration to schema version 36 complete');
   }
 };
 

package/src/local-review.js

@@ -10,7 +10,7 @@ const { fireHooks, hasHooks } = require('./hooks/hook-runner');
 const { buildReviewStartedPayload, buildReviewLoadedPayload, getCachedUser } = require('./hooks/payloads');
 
 const execAsync = promisify(exec);
-const { STOPS, scopeIncludes, includesBranch, DEFAULT_SCOPE, scopeLabel } = require('./local-scope');
+const { STOPS, scopeIncludes, includesBranch, DEFAULT_SCOPE, scopeLabel, reviewScope } = require('./local-scope');
 const { initializeDatabase, ReviewRepository, RepoSettingsRepository } = require('./database');
 const { startServer } = require('./server');
 const { localReviewDiffs } = require('./routes/shared');
@@ -472,6 +472,13 @@ async function generateScopedDiff(repoPath, scopeStart, scopeEnd, baseBranch, op
   const hasUnstaged = scopeIncludes(scopeStart, scopeEnd, 'unstaged');
   const hasUntracked = scopeIncludes(scopeStart, scopeEnd, 'untracked');
 
+  // Fail fast if the scope is invalid. scopeIncludes returns false for all
+  // stops when the scope is invalid, so all four flags would be false and the
+  // branching logic below would silently produce a wrong diff.
+  if (!hasUnstaged) {
+    throw new Error(`Invalid scope ${scopeStart}..${scopeEnd}: scope must include 'unstaged'`);
+  }
+
   let mergeBaseSha = null;
   let diff = '';
 
@@ -483,46 +490,30 @@ async function generateScopedDiff(repoPath, scopeStart, scopeEnd, baseBranch, op
     mergeBaseSha = await findMergeBase(repoPath, baseBranch);
   }
 
-  // Build the git diff command based on scope range
+  // Build the git diff command based on scope range.
+  // hasUnstaged is always true by invariant — isValidScope requires the scope
+  // to include 'unstaged', since AI models read files from the working tree
+  // and the diff must cover at least the unstaged state.
   try {
-    if (hasBranch && !hasStaged && !hasUnstaged) {
-      // Branch only → committed changes since merge-base
-      diff = execSync(`git diff ${mergeBaseSha}..HEAD ${GIT_DIFF_FLAGS}${contextFlag}${extraArgsStr}${wFlag}`, {
-        cwd: repoPath, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
-        maxBuffer: 50 * 1024 * 1024
-      });
-    } else if (hasBranch && hasStaged && !hasUnstaged) {
-      // Branch–Staged → staged changes relative to merge-base
-      diff = execSync(`git diff --cached ${mergeBaseSha} ${GIT_DIFF_FLAGS}${contextFlag}${extraArgsStr}${wFlag}`, {
-        cwd: repoPath, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
-        maxBuffer: 50 * 1024 * 1024
-      });
-    } else if (hasBranch && hasUnstaged) {
-      // Branch–Unstaged (or Branch–Untracked) → working tree vs merge-base
+    if (hasBranch) {
+      // Branch scope → working tree vs merge-base (includes committed + staged + unstaged)
       diff = execSync(`git diff ${mergeBaseSha} ${GIT_DIFF_FLAGS}${contextFlag}${extraArgsStr}${wFlag}`, {
         cwd: repoPath, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
         maxBuffer: 50 * 1024 * 1024
       });
-    } else if (hasStaged && !hasUnstaged) {
-      // Staged only → cached changes
-      diff = execSync(`git diff --cached ${GIT_DIFF_FLAGS}${contextFlag}${extraArgsStr}${wFlag}`, {
-        cwd: repoPath, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
-        maxBuffer: 50 * 1024 * 1024
-      });
-    } else if (hasStaged && hasUnstaged) {
-      // Staged–Unstaged (or Staged–Untracked) → all changes vs HEAD
+    } else if (hasStaged) {
+      // Staged + Unstaged scope → all changes vs HEAD
       diff = execSync(`git diff HEAD ${GIT_DIFF_FLAGS}${contextFlag}${extraArgsStr}${wFlag}`, {
         cwd: repoPath, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
         maxBuffer: 50 * 1024 * 1024
       });
-    } else if (hasUnstaged) {
-      // Unstaged only or Unstaged–Untracked → working tree changes
+    } else {
+      // Unstaged only (or Unstaged–Untracked) → working tree changes
       diff = execSync(`git diff ${GIT_DIFF_FLAGS}${contextFlag}${extraArgsStr}${wFlag}`, {
         cwd: repoPath, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
         maxBuffer: 50 * 1024 * 1024
       });
     }
-    // hasUntracked-only: no git diff needed, just untracked files below
   } catch (error) {
     if (error.message && error.message.includes('maxBuffer')) {
       throw new Error('Diff output exceeded maximum buffer size (50MB).');
@@ -798,8 +789,8 @@ async function handleLocalReview(targetPath, flags = {}) {
     }
 
     // Read scope from session (or use defaults for new sessions)
-    const scopeStart = existingReview?.local_scope_start || DEFAULT_SCOPE.start;
-    const scopeEnd = existingReview?.local_scope_end || DEFAULT_SCOPE.end;
+    // Use reviewScope() to normalize legacy scopes that may not include 'unstaged'
+    const { start: scopeStart, end: scopeEnd } = existingReview ? reviewScope(existingReview) : DEFAULT_SCOPE;
 
     // Fire review hook (non-blocking)
     const hookEvent = existingReview ? 'review.loaded' : 'review.started';
@@ -937,7 +928,7 @@ async function computeLocalDiffDigest(localPath) {
  * @returns {Promise<{diff: string, stats: Object, mergeBaseSha: string}>}
  */
 async function generateBranchDiff(repoPath, baseBranch, options = {}) {
-  return generateScopedDiff(repoPath, 'branch', 'branch', baseBranch, options);
+  return generateScopedDiff(repoPath, 'branch', 'unstaged', baseBranch, options);
 }
 
 /**

package/src/local-scope.js

@@ -4,10 +4,29 @@ const STOPS = ['branch', 'staged', 'unstaged', 'untracked'];
 
 const DEFAULT_SCOPE = { start: 'unstaged', end: 'untracked' };
 
+const UNSTAGED_INDEX = STOPS.indexOf('unstaged');
+
 function isValidScope(start, end) {
   const si = STOPS.indexOf(start);
   const ei = STOPS.indexOf(end);
-  return si !== -1 && ei !== -1 && si <= ei;
+  // Scope must be contiguous AND must include the 'unstaged' stop.
+  // This ensures the diff always covers the working tree state that AI models
+  // see when reading files, since we cannot modify local git state.
+  return si !== -1 && ei !== -1 && si <= ei && si <= UNSTAGED_INDEX && ei >= UNSTAGED_INDEX;
+}
+
+function normalizeScope(start, end) {
+  if (isValidScope(start, end)) return { start, end };
+  const si = STOPS.indexOf(start);
+  const ei = STOPS.indexOf(end);
+  if (si === -1 || ei === -1) return { start: DEFAULT_SCOPE.start, end: DEFAULT_SCOPE.end };
+  const newEi = Math.max(ei, UNSTAGED_INDEX);
+  const newSi = Math.min(si, UNSTAGED_INDEX);
+  const finalSi = Math.min(newSi, newEi);
+  const newStart = STOPS[finalSi];
+  const newEnd = STOPS[newEi];
+  if (isValidScope(newStart, newEnd)) return { start: newStart, end: newEnd };
+  return { start: DEFAULT_SCOPE.start, end: DEFAULT_SCOPE.end };
 }
 
 function scopeIncludes(start, end, stop) {
@@ -27,11 +46,18 @@ function fromLegacyMode(localMode) {
     return { start: 'unstaged', end: 'untracked' };
   }
   if (localMode === 'branch') {
-    return { start: 'branch', end: 'branch' };
+    return { start: 'branch', end: 'unstaged' };
   }
   return { start: DEFAULT_SCOPE.start, end: DEFAULT_SCOPE.end };
 }
 
+function reviewScope(review) {
+  return normalizeScope(
+    review.local_scope_start || DEFAULT_SCOPE.start,
+    review.local_scope_end || DEFAULT_SCOPE.end
+  );
+}
+
 function scopeLabel(start, end) {
   if (!isValidScope(start, end)) return '';
   const label = s => s.charAt(0).toUpperCase() + s.slice(1);
@@ -57,16 +83,6 @@ function scopeGitHints(start, end, baseBranch) {
 
   const key = start + '-' + end;
   const hints = {
-    'branch-branch': {
-      description: 'Committed changes on this branch since the merge-base.',
-      diffCommand: 'git diff --no-ext-diff ' + mb + '..HEAD',
-      excludes: 'Staged, unstaged, and untracked changes are NOT included in the review.'
-    },
-    'branch-staged': {
-      description: 'Committed changes plus staged changes, relative to the merge-base.',
-      diffCommand: 'git diff --no-ext-diff --cached ' + mb,
-      excludes: 'Unstaged and untracked changes are NOT included in the review.'
-    },
     'branch-unstaged': {
       description: 'All tracked changes (committed, staged, and unstaged) relative to the merge-base.',
       diffCommand: 'git diff --no-ext-diff ' + mb,
@@ -77,11 +93,6 @@ function scopeGitHints(start, end, baseBranch) {
       diffCommand: 'git diff --no-ext-diff ' + mb,
       excludes: ''
     },
-    'staged-staged': {
-      description: 'Only staged changes (added to the index but not yet committed).',
-      diffCommand: 'git diff --no-ext-diff --cached',
-      excludes: 'Unstaged, untracked, and committed branch changes are NOT included in the review.'
-    },
     'staged-unstaged': {
       description: 'Staged and unstaged changes relative to HEAD.',
       diffCommand: 'git diff --no-ext-diff HEAD',
@@ -101,11 +112,6 @@ function scopeGitHints(start, end, baseBranch) {
       description: 'Unstaged and untracked local changes.',
       diffCommand: 'git diff --no-ext-diff',
       excludes: 'Staged changes (`git diff --no-ext-diff --cached`) are treated as already reviewed.'
-    },
-    'untracked-untracked': {
-      description: 'Only untracked files (new files not yet added to git).',
-      diffCommand: 'git ls-files --others --exclude-standard',
-      excludes: 'Tracked file changes (staged, unstaged, committed) are NOT included in the review.'
     }
   };
 
@@ -117,7 +123,7 @@ function scopeGitHints(start, end, baseBranch) {
     description: entry.description,
     diffCommand: entry.diffCommand,
     excludes: entry.excludes,
-    includesUntracked: incUntracked && key !== 'untracked-untracked'
+    includesUntracked: incUntracked
   };
 }
 
@@ -125,6 +131,8 @@ const LocalScope = {
   STOPS,
   DEFAULT_SCOPE,
   isValidScope,
+  normalizeScope,
+  reviewScope,
   scopeIncludes,
   includesBranch,
   fromLegacyMode,

package/src/routes/executable-analysis.js

@@ -55,15 +55,10 @@ async function generateDiffForExecutable(cwd, context, diffArgs, outputPath) {
   let diff;
   const extraFlags = diffArgs.length > 0 ? ' ' + diffArgs.join(' ') : '';
 
-  if (context.baseSha && context.headSha) {
-    // PR mode: straightforward base...head diff
-    const { stdout } = await execPromise(
-      `git diff ${GIT_DIFF_FLAGS}${extraFlags} ${context.baseSha}...${context.headSha}`,
-      { cwd, maxBuffer: 50 * 1024 * 1024 }
-    );
-    diff = stdout;
-  } else if (context.scopeStart && context.scopeEnd) {
-    // Local mode: scope-aware diff generation
+  if (context.scopeStart && context.scopeEnd) {
+    // Local mode: scope-aware diff generation (checked first because local reviews
+    // may also carry baseSha/headSha pointing at the same commit, which would
+    // produce an empty diff if the SHA path ran instead).
     // Note: diffArgs are passed as extraArgs to generateScopedDiff, which handles
     // appending them to the git diff command internally (extraFlags is not used here).
     const result = await generateScopedDiff(
@@ -74,6 +69,13 @@ async function generateDiffForExecutable(cwd, context, diffArgs, outputPath) {
       { contextLines: 3, extraArgs: diffArgs }
     );
     diff = result.diff;
+  } else if (context.baseSha && context.headSha) {
+    // PR mode: straightforward base...head diff
+    const { stdout } = await execPromise(
+      `git diff ${GIT_DIFF_FLAGS}${extraFlags} ${context.baseSha}...${context.headSha}`,
+      { cwd, maxBuffer: 50 * 1024 * 1024 }
+    );
+    diff = stdout;
   } else {
     // Fallback: simple working-tree diff
     const { stdout } = await execPromise(