@in-the-loop-labs/pair-review 3.0.6 → 3.1.1

package/src/chat/session-manager.js

@@ -44,6 +44,12 @@ class ChatSessionManager {
    * @returns {Promise<{id: number, status: string}>}
    */
   async createSession({ provider, model, reviewId, contextCommentId, systemPrompt, cwd, initialContext }) {
+    // Resolve provider definition once — used for model fallback and bridge construction
+    const providerDef = getChatProvider(provider);
+
+    // Resolve model: explicit request value > provider config default
+    const resolvedModel = model || providerDef?.model || null;
+
     // Insert session record into DB
     const stmt = this._db.prepare(`
       INSERT INTO chat_sessions (review_id, context_comment_id, provider, model, status)
@@ -53,20 +59,20 @@ class ChatSessionManager {
       reviewId,
       contextCommentId || null,
       provider,
-      model || null
+      resolvedModel
     );
     const sessionId = Number(result.lastInsertRowid);
 
-    logger.info(`[ChatSession] Creating session ${sessionId} (provider=${provider}, review=${reviewId})`);
+    logger.info(`[ChatSession] Creating session ${sessionId} (provider=${provider}, model=${resolvedModel}, review=${reviewId})`);
 
     // Create and start the bridge
     // Chat sessions get bash for git commands; review analysis uses the safe default
     const bridge = this._createBridge(provider, {
       provider,
-      model,
+      model: resolvedModel,
       cwd,
       systemPrompt,
-    });
+    }, providerDef);
 
     const listeners = {
       delta: new Set(),
@@ -530,39 +536,38 @@ class ChatSessionManager {
    * ACP providers get an AcpBridge; everything else gets a PiBridge with tools/skills.
    * @param {string} provider
    * @param {Object} options - Bridge constructor options
+   * @param {Object} [providerDef] - Pre-resolved provider definition (avoids redundant getChatProvider calls)
    * @returns {PiBridge|AcpBridge}
    */
-  _createBridge(provider, options) {
+  _createBridge(provider, options, providerDef) {
+    const def = providerDef || getChatProvider(provider);
     if (isAcpProvider(provider)) {
-      const providerDef = getChatProvider(provider);
       return new AcpBridge({
         ...options,
-        model: options.model || providerDef?.model,
-        acpCommand: providerDef?.command,
-        acpArgs: providerDef?.args,
-        env: providerDef?.env,
-        useShell: providerDef?.useShell,
+        model: options.model || def?.model,
+        acpCommand: def?.command,
+        acpArgs: def?.args,
+        env: def?.env,
+        useShell: def?.useShell,
       });
     }
     if (isClaudeCodeProvider(provider)) {
-      const providerDef = getChatProvider(provider);
       return new ClaudeCodeBridge({
         ...options,
-        model: options.model || providerDef?.model,
-        claudeCommand: providerDef?.command,
-        env: providerDef?.env,
-        useShell: providerDef?.useShell,
+        model: options.model || def?.model,
+        claudeCommand: def?.command,
+        env: def?.env,
+        useShell: def?.useShell,
       });
     }
     if (isCodexProvider(provider)) {
-      const providerDef = getChatProvider(provider);
       return new CodexBridge({
         ...options,
-        model: options.model || providerDef?.model,
-        codexCommand: providerDef?.command,
-        codexArgs: providerDef?.args,
-        env: providerDef?.env,
-        useShell: providerDef?.useShell,
+        model: options.model || def?.model,
+        codexCommand: def?.command,
+        codexArgs: def?.args,
+        env: def?.env,
+        useShell: def?.useShell,
       });
     }
     // Pi provider — resolve config overrides (command, model, env) from provider def.
@@ -570,14 +575,13 @@ class ChatSessionManager {
     // which would forward it as `--provider pi` to the Pi CLI.  The CLI's --provider flag
     // expects a model provider ("google", "anthropic", etc.) and should only come from
     // explicit user configuration (providerDef.provider).
-    const providerDef = getChatProvider(provider);
     return new PiBridge({
       ...options,
-      provider: providerDef?.provider || null,
-      model: options.model || providerDef?.model,
-      piCommand: providerDef?.command,
-      env: providerDef?.env,
-      useShell: providerDef?.useShell,
+      provider: def?.provider || null,
+      model: options.model || def?.model,
+      piCommand: def?.command,
+      env: def?.env,
+      useShell: def?.useShell,
       tools: CHAT_TOOLS,
       extensions: [taskExtensionDir],
     });

package/src/config.js

@@ -31,7 +31,7 @@ const DEFAULT_CONFIG = {
   enable_chat: true,  // When true, enables the chat panel feature (uses chat_provider)
   chat_provider: "pi",  // Chat provider: 'pi', 'copilot-acp', 'gemini-acp', 'opencode-acp', 'cursor-acp', 'codex'
   comment_format: "legacy",  // Comment format preset or custom template for adopted suggestions
-  chat: { enable_shortcuts: true },  // Chat panel settings (enable_shortcuts: show action shortcut buttons)
+  chat: { enable_shortcuts: true, enter_to_send: true },  // Chat panel settings (enable_shortcuts: show action shortcut buttons, enter_to_send: Enter sends message instead of newline)
   providers: {},  // Custom AI analysis provider configurations (overrides built-in defaults)
   chat_providers: {},  // Custom chat provider configurations (overrides built-in defaults)
   monorepos: {},  // Monorepo configurations: { "owner/repo": { path: "~/path/to/clone" } }
@@ -227,6 +227,20 @@ async function loadConfig() {
     process.exit(1);
   }
 
+  // Load global instructions from ~/.pair-review/global-instructions.md
+  const globalInstructionsPath = path.join(CONFIG_DIR, 'global-instructions.md');
+  try {
+    const content = await fs.readFile(globalInstructionsPath, 'utf-8');
+    const trimmed = content.trim();
+    if (trimmed) {
+      mergedConfig.globalInstructions = trimmed;
+    }
+  } catch (error) {
+    if (error.code !== 'ENOENT') {
+      logger.warn(`Could not read global instructions from ${globalInstructionsPath}: ${error.message}`);
+    }
+  }
+
   return { config: mergedConfig, isFirstRun };
 }
 
@@ -535,7 +549,6 @@ function shouldSkipUpdateNotifier() {
 module.exports = {
   deepMerge,
   loadConfig,
-  saveConfig,
   getConfigDir,
   validatePort,
   getGitHubToken,

package/src/database.js

@@ -20,7 +20,7 @@ function getDbPath() {
 /**
  * Current schema version - increment this when adding new migrations
  */
-const CURRENT_SCHEMA_VERSION = 33;
+const CURRENT_SCHEMA_VERSION = 35;
 
 /**
  * Database schema SQL statements
@@ -96,6 +96,8 @@ const SCHEMA_SQL = {
       voice_id TEXT,
       is_raw INTEGER DEFAULT 0,
 
+      severity TEXT,
+
       created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
       updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
 
@@ -162,6 +164,7 @@ const SCHEMA_SQL = {
       model TEXT,
       tier TEXT,
       custom_instructions TEXT,
+      global_instructions TEXT,
       repo_instructions TEXT,
       request_instructions TEXT,
       head_sha TEXT,
@@ -1564,6 +1567,44 @@ const MIGRATIONS = {
 
     console.log('  Recreated comments with ON DELETE CASCADE for review_id');
     console.log('Migration to schema version 33 complete');
+  },
+
+  34: (db) => {
+    console.log('Migrating to schema version 34: Add global_instructions to analysis_runs');
+
+    if (!columnExists(db, 'analysis_runs', 'global_instructions')) {
+      try {
+        db.prepare('ALTER TABLE analysis_runs ADD COLUMN global_instructions TEXT').run();
+        console.log('  Added global_instructions column to analysis_runs');
+      } catch (error) {
+        if (!error.message.includes('duplicate column name')) {
+          throw error;
+        }
+        console.log('  Column global_instructions already exists (race condition)');
+      }
+    } else {
+      console.log('  Column global_instructions already exists');
+    }
+
+    console.log('Migration to schema version 34 complete');
+  },
+
+  // Migration to version 35: Add severity column to comments table
+  35: (db) => {
+    console.log('Running migration to schema version 35...');
+
+    const addColumnIfNotExists = (table, column, definition) => {
+      const tableInfo = db.prepare(`PRAGMA table_info(${table})`).all();
+      const columnExists = tableInfo.some(col => col.name === column);
+      if (!columnExists) {
+        db.prepare(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`).run();
+        console.log(`  Added column ${column} to ${table}`);
+      }
+    };
+
+    addColumnIfNotExists('comments', 'severity', 'TEXT');
+
+    console.log('Migration to schema version 35 complete');
   }
 };
 
@@ -2567,6 +2608,7 @@ class CommentRepository {
         status,
         parent_id,
         is_file_level,
+        severity,
         created_at,
         updated_at
       FROM comments
@@ -2634,8 +2676,8 @@ class CommentRepository {
       await run(this.db, `
         INSERT INTO comments (
           review_id, source, author, ai_run_id, ai_level, ai_confidence,
-          file, line_start, line_end, side, type, title, body, suggestion_text, reasoning, status, is_file_level
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          file, line_start, line_end, side, type, title, body, suggestion_text, reasoning, status, is_file_level, severity
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       `, [
         reviewId,
         'ai',
@@ -2653,7 +2695,8 @@ class CommentRepository {
         suggestionText,
         suggestion.reasoning ? JSON.stringify(suggestion.reasoning) : null,
         'active',
-        isFileLevel
+        isFileLevel,
+        suggestion.severity ?? null
       ]);
     }
   }
@@ -3482,6 +3525,7 @@ class AnalysisRunRepository {
    * @param {string} [runInfo.provider] - AI provider (claude, gemini, etc.)
    * @param {string} [runInfo.model] - AI model name
    * @param {string} [runInfo.customInstructions] - Merged custom instructions (kept for backward compatibility)
+   * @param {string} [runInfo.globalInstructions] - Global instructions from ~/.pair-review/global-instructions.md
    * @param {string} [runInfo.repoInstructions] - Repository-level instructions from repo_settings
    * @param {string} [runInfo.requestInstructions] - Request-level instructions from the analyze request
    * @param {string} [runInfo.headSha] - Git HEAD SHA at the time of analysis (PR head commit or local HEAD)
@@ -3489,14 +3533,14 @@ class AnalysisRunRepository {
    * @param {string} [runInfo.status='running'] - Initial status (default 'running'; pass 'completed' for externally-produced results)
    * @returns {Promise<Object>} Created analysis run record
    */
-  async create({ id, reviewId, provider = null, model = null, tier = null, customInstructions = null, repoInstructions = null, requestInstructions = null, headSha = null, diff = null, status = 'running', parentRunId = null, configType = 'single', levelsConfig = null, scopeStart = null, scopeEnd = null }) {
+  async create({ id, reviewId, provider = null, model = null, tier = null, customInstructions = null, globalInstructions = null, repoInstructions = null, requestInstructions = null, headSha = null, diff = null, status = 'running', parentRunId = null, configType = 'single', levelsConfig = null, scopeStart = null, scopeEnd = null }) {
     const isTerminal = ['completed', 'failed', 'cancelled'].includes(status);
     const completedAt = isTerminal ? 'CURRENT_TIMESTAMP' : 'NULL';
     const levelsConfigJson = levelsConfig ? JSON.stringify(levelsConfig) : null;
     await run(this.db, `
-      INSERT INTO analysis_runs (id, review_id, provider, model, tier, custom_instructions, repo_instructions, request_instructions, head_sha, diff, status, completed_at, parent_run_id, config_type, levels_config, scope_start, scope_end)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ${completedAt}, ?, ?, ?, ?, ?)
-    `, [id, reviewId, provider, model, tier, customInstructions, repoInstructions, requestInstructions, headSha, diff, status, parentRunId, configType, levelsConfigJson, scopeStart, scopeEnd]);
+      INSERT INTO analysis_runs (id, review_id, provider, model, tier, custom_instructions, global_instructions, repo_instructions, request_instructions, head_sha, diff, status, completed_at, parent_run_id, config_type, levels_config, scope_start, scope_end)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ${completedAt}, ?, ?, ?, ?, ?)
+    `, [id, reviewId, provider, model, tier, customInstructions, globalInstructions, repoInstructions, requestInstructions, headSha, diff, status, parentRunId, configType, levelsConfigJson, scopeStart, scopeEnd]);
 
     // Query back the inserted row to return actual database values (including timestamps)
     return await this.getById(id);
@@ -3579,12 +3623,12 @@ class AnalysisRunRepository {
    */
   async getById(id, { includeDiff = false } = {}) {
     const columns = [
-      'id', 'review_id', 'provider', 'model', 'tier', 'custom_instructions', 'repo_instructions', 'request_instructions',
+      'id', 'review_id', 'provider', 'model', 'tier', 'custom_instructions', 'global_instructions', 'repo_instructions', 'request_instructions',
       'head_sha', 'summary', 'status', 'total_suggestions', 'files_analyzed', 'started_at', 'completed_at',
       'parent_run_id', 'config_type', 'levels_config'
     ];
     if (includeDiff) {
-      columns.splice(9, 0, 'diff'); // Insert diff after head_sha
+      columns.splice(columns.indexOf('head_sha') + 1, 0, 'diff'); // Insert diff after head_sha
     }
     const row = await queryOne(this.db, `
       SELECT ${columns.join(', ')}
@@ -3607,12 +3651,12 @@ class AnalysisRunRepository {
   async getByReviewId(reviewId, { limit, includeDiff = false } = {}) {
     const params = [reviewId];
     const columns = [
-      'id', 'review_id', 'provider', 'model', 'tier', 'custom_instructions', 'repo_instructions', 'request_instructions',
+      'id', 'review_id', 'provider', 'model', 'tier', 'custom_instructions', 'global_instructions', 'repo_instructions', 'request_instructions',
       'head_sha', 'summary', 'status', 'total_suggestions', 'files_analyzed', 'started_at', 'completed_at',
       'parent_run_id', 'config_type', 'levels_config'
     ];
     if (includeDiff) {
-      columns.splice(9, 0, 'diff'); // Insert diff after head_sha
+      columns.splice(columns.indexOf('head_sha') + 1, 0, 'diff'); // Insert diff after head_sha
     }
     let sql = `
       SELECT ${columns.join(', ')}
@@ -3645,12 +3689,12 @@ class AnalysisRunRepository {
    */
   async getLatestCompletedByReviewId(reviewId, { includeDiff = false } = {}) {
     const columns = [
-      'id', 'review_id', 'provider', 'model', 'tier', 'custom_instructions', 'repo_instructions', 'request_instructions',
+      'id', 'review_id', 'provider', 'model', 'tier', 'custom_instructions', 'global_instructions', 'repo_instructions', 'request_instructions',
       'head_sha', 'summary', 'status', 'total_suggestions', 'files_analyzed', 'started_at', 'completed_at',
       'parent_run_id', 'config_type', 'levels_config'
     ];
     if (includeDiff) {
-      columns.splice(9, 0, 'diff'); // Insert diff after head_sha
+      columns.splice(columns.indexOf('head_sha') + 1, 0, 'diff'); // Insert diff after head_sha
     }
     const row = await queryOne(this.db, `
       SELECT ${columns.join(', ')}
@@ -3672,7 +3716,7 @@ class AnalysisRunRepository {
     // Note: diff column is intentionally omitted - child runs share the same diff as parent
     // to avoid data duplication. Use the parent run's diff when needed.
     return query(this.db, `
-      SELECT id, review_id, provider, model, tier, custom_instructions, repo_instructions, request_instructions,
+      SELECT id, review_id, provider, model, tier, custom_instructions, global_instructions, repo_instructions, request_instructions,
              head_sha, summary, status, total_suggestions, files_analyzed, started_at, completed_at,
              parent_run_id, config_type, levels_config
       FROM analysis_runs

package/src/git/base-branch.js

@@ -1,9 +1,12 @@
 // Copyright 2026 Tim Perkins (tjwp) | SPDX-License-Identifier: Apache-2.0
 const { execSync } = require('child_process');
+const { readFileSync } = require('fs');
+const path = require('path');
 const logger = require('../utils/logger');
 
 const defaults = {
   execSync,
+  readFileSync,
   // Callers should pass a resolved token via _deps.getGitHubToken.
   // This default returns empty so GitHub lookup is silently skipped
   // when no token is provided — never re-resolve config internally.
@@ -18,7 +21,7 @@ const defaults = {
  * Detect the base branch for the current branch.
  *
  * Priority:
- *   1. Graphite — `gt trunk` and `gt parent`
+ *   1. Graphite — `gt state` (single call for trunk, parent, and stack)
  *   2. GitHub PR — look up an open PR for this branch
  *   3. Default branch — `git remote show origin` or local main/master
  *
@@ -28,7 +31,7 @@ const defaults = {
  * @param {string} [options.repository] - owner/repo string (needed for GitHub lookup)
  * @param {boolean} [options.enableGraphite] - When true, try Graphite CLI for parent branch
  * @param {Object} [options._deps] - Dependency overrides for testing
- * @returns {Promise<{baseBranch: string, source: string, prNumber?: number}|null>}
+ * @returns {Promise<{baseBranch: string, source: string, prNumber?: number, stack?: Array}|null>}
  */
 async function detectBaseBranch(repoPath, currentBranch, options = {}) {
   const deps = { ...defaults, ...options._deps };
@@ -40,7 +43,7 @@ async function detectBaseBranch(repoPath, currentBranch, options = {}) {
 
   // 1. Graphite (only when enabled via config)
   if (options.enableGraphite) {
-    const graphiteResult = tryGraphite(repoPath, currentBranch, deps);
+    const graphiteResult = tryGraphiteState(repoPath, currentBranch, deps);
     if (graphiteResult) return graphiteResult;
   }
 
@@ -56,46 +59,127 @@ async function detectBaseBranch(repoPath, currentBranch, options = {}) {
 }
 
 /**
- * Try Graphite CLI to find the parent branch.
+ * Try Graphite CLI `gt state` to find the parent branch and build the stack.
+ * Single execSync call replaces the previous 3 serial calls.
  */
-function tryGraphite(repoPath, currentBranch, deps) {
+function tryGraphiteState(repoPath, currentBranch, deps) {
   try {
-    // Check if gt is installed
-    deps.execSync('which gt', {
+    const raw = deps.execSync('gt state', {
+      cwd: repoPath,
       encoding: 'utf8',
       stdio: ['pipe', 'pipe', 'pipe'],
-      timeout: 3000
+      timeout: 5000
     });
 
-    // Get trunk branch
-    const trunk = deps.execSync('gt trunk', {
-      cwd: repoPath,
-      encoding: 'utf8',
-      stdio: ['pipe', 'pipe', 'pipe'],
-      timeout: 3000
-    }).trim();
+    const state = JSON.parse(raw);
+    const trunk = Object.entries(state).find(([, v]) => v.trunk)?.[0];
+    const entry = state[currentBranch];
+    const parent = entry?.parents?.[0]?.ref;
+
+    if (!entry || !parent || parent === currentBranch) {
+      return null;
+    }
+
+    const stack = buildStack(state, currentBranch, trunk);
+    return { baseBranch: parent, source: 'graphite', stack };
+  } catch (error) {
+    logger.debug(`Graphite state failed: ${error.message}`);
+  }
+
+  return null;
+}
+
+/**
+ * Walk from currentBranch up via parents[0].ref to build the stack,
+ * ordered trunk-first. Includes cycle protection.
+ *
+ * @param {Object} state - Parsed `gt state` output
+ * @param {string} currentBranch - Current branch name
+ * @param {string|undefined} trunk - Trunk branch name
+ * @returns {Array<{branch: string, parentBranch: string|null, parentSha: string|null, isTrunk: boolean}>}
+ */
+function buildStack(state, currentBranch, trunk) {
+  const entries = [];
+  const visited = new Set();
+  let branch = currentBranch;
+
+  while (branch && !visited.has(branch)) {
+    visited.add(branch);
+    const info = state[branch];
+    if (!info) break;
+
+    const parentRef = info.parents?.[0]?.ref || null;
+    const parentSha = info.parents?.[0]?.sha || null;
+    entries.push({
+      branch,
+      parentBranch: parentRef,
+      parentSha,
+      isTrunk: !!info.trunk
+    });
+
+    branch = parentRef;
+  }
 
-    // Get parent branch
-    const parent = deps.execSync('gt parent', {
+  entries.reverse();
+
+  // If the walk terminated before reaching the trunk, prepend it
+  if (trunk && !visited.has(trunk) && state[trunk]) {
+    entries.unshift({
+      branch: trunk,
+      parentBranch: null,
+      parentSha: null,
+      isTrunk: true
+    });
+  }
+
+  return entries;
+}
+
+/**
+ * Read Graphite PR info from the `.graphite_pr_info` file in the git dir.
+ *
+ * @param {string} repoPath - Absolute path to the repository
+ * @param {Object} deps - Dependencies (execSync, readFileSync)
+ * @returns {Object|null} Parsed PR info object with `prInfos` array, or null
+ */
+function readGraphitePRInfo(repoPath, deps) {
+  try {
+    const gitCommonDir = deps.execSync('git rev-parse --git-common-dir', {
       cwd: repoPath,
       encoding: 'utf8',
-      stdio: ['pipe', 'pipe', 'pipe'],
-      timeout: 3000
+      stdio: ['pipe', 'pipe', 'pipe']
     }).trim();
 
-    if (parent && parent !== currentBranch) {
-      return { baseBranch: parent, source: 'graphite' };
-    }
+    const prInfoPath = path.resolve(repoPath, gitCommonDir, '.graphite_pr_info');
+    const raw = deps.readFileSync(prInfoPath, 'utf8');
+    return JSON.parse(raw);
+  } catch (error) {
+    logger.debug(`Graphite PR info read failed: ${error.message}`);
+    return null;
+  }
+}
 
-    // If parent is ourselves or empty, try trunk
-    if (trunk && trunk !== currentBranch) {
-      return { baseBranch: trunk, source: 'graphite' };
+/**
+ * Enrich stack entries with PR numbers from Graphite PR info.
+ *
+ * @param {Array} stack - Stack entries from buildStack
+ * @param {Array} prInfos - Array of PR info objects with headRefName and prNumber
+ * @returns {Array} New array of stack entries, each with optional prNumber
+ */
+function enrichStackWithPRInfo(stack, prInfos) {
+  if (!prInfos || !Array.isArray(prInfos)) return stack;
+
+  const prMap = new Map();
+  for (const info of prInfos) {
+    if (info.headRefName) {
+      prMap.set(info.headRefName, info.prNumber);
     }
-  } catch {
-    // Graphite not installed or failed — fall through silently
   }
 
-  return null;
+  return stack.map(entry => {
+    const prNumber = prMap.get(entry.branch);
+    return prNumber != null ? { ...entry, prNumber } : { ...entry };
+  });
 }
 
 /**
@@ -218,4 +302,4 @@ function getDefaultBranch(localPath, _deps) {
   return null;
 }
 
-module.exports = { detectBaseBranch, getDefaultBranch };
+module.exports = { detectBaseBranch, getDefaultBranch, tryGraphiteState, buildStack, readGraphitePRInfo, enrichStackWithPRInfo };

package/src/github/parser.js

@@ -113,7 +113,7 @@ class PRArgumentParser {
    */
   parseGraphiteURL(url) {
     // Match Graphite PR URL pattern: https://app.graphite.{dev|com}/github/pr/owner/repo/number[/optional-title]
-    const match = url.match(/^https:\/\/app\.graphite\.(?:dev|com)\/github\/pr\/([^\/]+)\/([^\/]+)\/(\d+)(?:\/.*)?$/);
+    const match = url.match(/^https:\/\/app\.graphite\.(?:dev|com)\/github\/pr\/([^\/]+)\/([^\/]+)\/(\d+)(?:\/[^?]*)?(?:\?.*)?$/);
 
     if (!match) {
       throw new Error('Invalid Graphite URL format. Expected: https://app.graphite.com/github/pr/owner/repo/number');

package/src/local-review.js

@@ -394,9 +394,11 @@ async function findMergeBase(repoPath, baseBranch) {
  * @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')
  * @returns {string} Combined diff text for untracked files
  */
-function generateUntrackedDiffs(repoPath, untrackedFiles, wFlag) {
+function generateUntrackedDiffs(repoPath, untrackedFiles, wFlag, contextFlag = '', extraArgsStr = '') {
   let diff = '';
   for (const untracked of untrackedFiles) {
     if (!untracked.skipped) {
@@ -404,7 +406,7 @@ function generateUntrackedDiffs(repoPath, untrackedFiles, wFlag) {
         const filePath = path.join(repoPath, untracked.file);
         let fileDiff;
         try {
-          fileDiff = execSync(`git diff --no-index ${GIT_DIFF_FLAGS}${wFlag} -- /dev/null "${filePath}"`, {
+          fileDiff = execSync(`git diff --no-index ${GIT_DIFF_FLAGS}${contextFlag}${extraArgsStr}${wFlag} -- /dev/null "${filePath}"`, {
             cwd: repoPath,
             encoding: 'utf8',
             stdio: ['pipe', 'pipe', 'pipe'],
@@ -450,10 +452,14 @@ function generateUntrackedDiffs(repoPath, untrackedFiles, wFlag) {
  * @param {string} [baseBranch] - Base branch name (required when branch is in scope)
  * @param {Object} [options]
  * @param {boolean} [options.hideWhitespace] - Whether to hide whitespace changes
+ * @param {number} [options.contextLines=25] - Number of unified context lines (--unified=N). Defaults to 25.
+ * @param {string[]} [options.extraArgs=[]] - Additional git diff flags appended to each diff command
  * @returns {Promise<{diff: string, stats: Object, mergeBaseSha: string|null}>}
  */
 async function generateScopedDiff(repoPath, scopeStart, scopeEnd, baseBranch, options = {}) {
   const wFlag = options.hideWhitespace ? ' -w' : '';
+  const contextFlag = ` --unified=${options.contextLines ?? 25}`;
+  const extraArgsStr = (options.extraArgs || []).length > 0 ? ' ' + options.extraArgs.join(' ') : '';
   const stats = {
     trackedChanges: 0,
     untrackedFiles: 0,
@@ -481,37 +487,37 @@ async function generateScopedDiff(repoPath, scopeStart, scopeEnd, baseBranch, op
   try {
     if (hasBranch && !hasStaged && !hasUnstaged) {
       // Branch only → committed changes since merge-base
-      diff = execSync(`git diff ${mergeBaseSha}..HEAD ${GIT_DIFF_FLAGS} --unified=25${wFlag}`, {
+      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} --unified=25${wFlag}`, {
+      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
-      diff = execSync(`git diff ${mergeBaseSha} ${GIT_DIFF_FLAGS} --unified=25${wFlag}`, {
+      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} --unified=25${wFlag}`, {
+      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
-      diff = execSync(`git diff HEAD ${GIT_DIFF_FLAGS} --unified=25${wFlag}`, {
+      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
-      diff = execSync(`git diff ${GIT_DIFF_FLAGS} --unified=25${wFlag}`, {
+      diff = execSync(`git diff ${GIT_DIFF_FLAGS}${contextFlag}${extraArgsStr}${wFlag}`, {
         cwd: repoPath, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
         maxBuffer: 50 * 1024 * 1024
       });
@@ -555,7 +561,7 @@ async function generateScopedDiff(repoPath, scopeStart, scopeEnd, baseBranch, op
     const untrackedFiles = await getUntrackedFiles(repoPath);
     stats.untrackedFiles = untrackedFiles.length;
 
-    const untrackedDiff = generateUntrackedDiffs(repoPath, untrackedFiles, wFlag);
+    const untrackedDiff = generateUntrackedDiffs(repoPath, untrackedFiles, wFlag, contextFlag, extraArgsStr);
     if (untrackedDiff) {
       if (diff) diff += '\n';
       diff += untrackedDiff;