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

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/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;

package/src/main.js

@@ -829,6 +829,7 @@ async function performHeadlessReview(args, config, db, flags, options) {
     const repoSettingsRepo = new RepoSettingsRepository(db);
     const repoSettings = await repoSettingsRepo.getRepoSettings(repository);
     const repoInstructions = repoSettings?.default_instructions || null;
+    const globalInstructions = config.globalInstructions || null;
 
     // Run AI analysis
     console.log('Running AI analysis (all 3 levels)...');
@@ -837,8 +838,8 @@ async function performHeadlessReview(args, config, db, flags, options) {
 
     let analysisSummary = null;
     try {
-      // Pass repo instructions to ensure they're captured in the analysis run
-      const analysisResult = await analyzer.analyzeAllLevels(review.id, worktreePath, storedPRData, null, { repoInstructions });
+      // Pass all instruction levels to ensure they're captured in the analysis run
+      const analysisResult = await analyzer.analyzeAllLevels(review.id, worktreePath, storedPRData, null, { globalInstructions, repoInstructions });
       analysisSummary = analysisResult.summary;
       console.log('AI analysis completed successfully');
     } catch (analysisError) {

package/src/routes/analyses.js

@@ -300,6 +300,25 @@ router.post('/api/analyses/results', async (req, res) => {
   }
 });
 
+/**
+ * List currently active (running) analyses across all reviews.
+ * Returns lightweight projections from the in-memory activeAnalyses map.
+ */
+router.get('/api/analyses/active', (req, res) => {
+  const active = [];
+  for (const status of activeAnalyses.values()) {
+    if (status.status !== 'running') continue;
+    active.push({
+      analysisId: status.id,
+      reviewId: status.reviewId,
+      reviewType: status.reviewType || null,
+      repository: status.repository || null,
+      prNumber: status.prNumber || null
+    });
+  }
+  res.json({ active });
+});
+
 // ==========================================================================
 // Parameterised :id routes — registered AFTER static paths
 // ==========================================================================
@@ -396,7 +415,10 @@ router.post('/api/analyses/:id/cancel', async (req, res) => {
           : analysis.levels?.[3],
         4: analysis.levels?.[4]?.status === 'running'
           ? { status: 'cancelled', progress: 'Cancelled' }
-          : analysis.levels?.[4]
+          : analysis.levels?.[4],
+        exec: analysis.levels?.exec?.status === 'running'
+          ? { status: 'cancelled', progress: 'Cancelled' }
+          : analysis.levels?.exec
       }
     };
 
@@ -446,7 +468,7 @@ router.post('/api/analyses/:id/cancel', async (req, res) => {
  * @param {Object} modeContext - Mode-specific values
  * @param {Object} councilConfig - Validated council configuration
  * @param {string} councilId - Council ID (for the model field in analysis_runs), or null for inline config
- * @param {Object} instructions - { repoInstructions, requestInstructions }
+ * @param {Object} instructions - { globalInstructions, repoInstructions, requestInstructions }
  * @param {string} [configType='advanced'] - Config type
  * @returns {{ analysisId: string, runId: string }}
  */
@@ -469,10 +491,12 @@ async function launchCouncilAnalysis(db, modeContext, councilConfig, councilId,
     onSuccess,
     runUpdateExtra,
     config: modeConfig,
+    excludePrevious,
+    serverPort,
     hookContext = {},
   } = modeContext;
 
-  const { repoInstructions, requestInstructions } = instructions;
+  const { globalInstructions, repoInstructions, requestInstructions } = instructions;
 
   const isVoiceCentric = configType === 'council';
 
@@ -496,6 +520,7 @@ async function launchCouncilAnalysis(db, modeContext, councilConfig, councilId,
     provider: 'council',
     model: councilId || 'inline-config',
     tier: null,
+    globalInstructions,
     repoInstructions,
     requestInstructions,
     headSha: headSha || null,
@@ -521,7 +546,8 @@ async function launchCouncilAnalysis(db, modeContext, councilConfig, councilId,
       1: isLevelEnabled(councilConfig, '1') ? { status: 'running', progress: 'Starting...' } : { status: 'skipped', progress: 'Skipped' },
       2: isLevelEnabled(councilConfig, '2') ? { status: 'running', progress: 'Starting...' } : { status: 'skipped', progress: 'Skipped' },
       3: isLevelEnabled(councilConfig, '3') ? { status: 'running', progress: 'Starting...' } : { status: 'skipped', progress: 'Skipped' },
-      4: { status: 'pending', progress: 'Pending' }
+      4: { status: 'pending', progress: 'Pending' },
+      exec: { status: 'pending', progress: 'Pending' }
     },
     isCouncil: true,
     councilConfig,
@@ -563,12 +589,12 @@ async function launchCouncilAnalysis(db, modeContext, councilConfig, councilId,
     worktreePath,
     prMetadata,
     changedFiles,
-    instructions: { repoInstructions, requestInstructions }
+    instructions: { globalInstructions, repoInstructions, requestInstructions }
   };
 
   const analysisPromise = isVoiceCentric
-    ? analyzer.runReviewerCentricCouncil(reviewContext, councilConfig, { analysisId, runId, progressCallback })
-    : analyzer.runCouncilAnalysis(reviewContext, councilConfig, { analysisId, runId, progressCallback });
+    ? analyzer.runReviewerCentricCouncil(reviewContext, councilConfig, { analysisId, runId, progressCallback, excludePrevious, serverPort })
+    : analyzer.runCouncilAnalysis(reviewContext, councilConfig, { analysisId, runId, progressCallback, excludePrevious, serverPort });
 
   analysisPromise
     .then(async result => {
@@ -607,7 +633,7 @@ async function launchCouncilAnalysis(db, modeContext, councilConfig, councilId,
           4: { status: 'completed', progress: 'Results finalized' }
         }
       };
-      for (const levelKey of ['1', '2', '3']) {
+      for (const levelKey of ['1', '2', '3', 'exec']) {
         if (currentStatus.levels?.[levelKey]?.status === 'running') {
           completedStatus.levels[levelKey] = { status: 'completed', progress: 'Complete' };
         }