@in-the-loop-labs/pair-review 2.6.3 → 3.0.0

package/public/js/local.js

@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright 2026 Tim Perkins (tjwp) | SPDX-License-Identifier: Apache-2.0
 /**
  * Local Mode Manager
  *
@@ -230,10 +230,6 @@ class LocalManager {
 
     // Override triggerAIAnalysis for local mode
     manager.triggerAIAnalysis = async function() {
-      // Timeout (ms) for stale check — git commands can hang on locked repos.
-      // Defined locally to avoid relying on cross-script const from pr.js.
-      const STALE_TIMEOUT = 2000;
-
       if (manager.isAnalyzing) {
         manager.reopenModal();
         return;
@@ -257,19 +253,13 @@ class LocalManager {
           return;
         }
 
-        // Run stale check and settings fetch in parallel to minimize dialog delay
-        // Use AbortController so the fetch is truly cancelled on timeout,
-        // freeing the HTTP connection for subsequent requests.
+        // Run stale check and settings fetch in parallel to minimize dialog delay.
+        // Reuse the on-load staleness promise if still available, otherwise fetch fresh.
         const _tParallel0 = performance.now();
-        const staleAbort = new AbortController();
-        const staleTimer = setTimeout(() => {
-          console.debug(`[Analyze] stale-check timed out after ${STALE_TIMEOUT}ms, aborting`);
-          staleAbort.abort();
-        }, STALE_TIMEOUT);
-        const staleCheckWithTimeout = fetch(`/api/local/${reviewId}/check-stale`, { signal: staleAbort.signal })
-          .then(r => r.ok ? r.json() : null)
-          .then(result => { clearTimeout(staleTimer); return result; })
-          .catch(() => { clearTimeout(staleTimer); return null; });
+        const staleCheckWithTimeout = manager._stalenessPromise
+          ? manager._stalenessPromise
+          : self._fetchLocalStaleness();
+        manager._stalenessPromise = null; // consume it
         const [staleResult, repoSettings, reviewSettings] = await Promise.all([
           staleCheckWithTimeout,
           manager.fetchRepoSettings().catch(() => null),
@@ -644,9 +634,11 @@ class LocalManager {
   }
 
   /**
-   * Refresh the diff from the working directory
+   * Refresh the diff from the working directory.
+   * @param {Object} [opts] - Options
+   * @param {boolean} [opts.silent] - When true, auto-update on HEAD change without dialog
    */
-  async refreshDiff() {
+  async refreshDiff(opts = {}) {
     const manager = window.prManager;
     const refreshBtn = document.getElementById('local-refresh-btn');
 
@@ -669,64 +661,25 @@ class LocalManager {
       const result = await response.json();
       console.log('Diff refreshed:', result.stats);
 
-      // Check if HEAD has changed (user made a commit)
-      if (result.sessionChanged && result.newSessionId) {
-        // Show confirmation dialog to user
-        const originalSha = result.originalHeadSha ? result.originalHeadSha.substring(0, 7) : 'unknown';
-        const newSha = result.newHeadSha ? result.newHeadSha.substring(0, 7) : 'unknown';
-
-        if (window.confirmDialog) {
-          const dialogResult = await window.confirmDialog.show({
-            title: 'HEAD Has Changed',
-            message: `A new commit was detected (${originalSha} -> ${newSha}). Your comments and AI suggestions are tied to the previous commit.\n\nWould you like to switch to the new session for the current HEAD?`,
-            confirmText: 'Switch to New Session',
-            cancelText: 'Stay on Current Session',
-            confirmClass: 'btn-primary'
-          });
-
-          if (dialogResult === 'confirm') {
-            // Redirect to the new session
-            window.location.href = `/local/${result.newSessionId}`;
+      // HEAD change handling — branch scope is auto-updated by the backend;
+      // non-branch scope requires user decision via resolve-head-change.
+      if (result.headShaChanged) {
+        const LS = window.LocalScope;
+        const hasBranch = LS ? LS.scopeIncludes(this.scopeStart, this.scopeEnd, 'branch') : false;
+
+        if (!hasBranch) {
+          // Non-branch scope: let the user (or silent mode) decide
+          const resolved = await this._resolveHeadChange(result, opts);
+          if (!resolved) {
+            // User cancelled — keep old diff, early return
             return;
           }
-        } else {
-          // Fallback if confirmDialog is not available
-          const switchSession = confirm(
-            `HEAD has changed (${originalSha} -> ${newSha}). ` +
-            `Your comments and AI suggestions are tied to the previous commit. ` +
-            `Switch to the new session?`
-          );
-
-          if (switchSession) {
-            window.location.href = `/local/${result.newSessionId}`;
-            return;
-          }
-        }
-
-        // User chose to stay, show info toast
-        if (window.toast) {
-          window.toast.showInfo('Staying on current session. Refresh again to see this option.');
         }
+        // Branch scope: backend already updated SHA and persisted diff — fall through
       }
 
       // Reload the diff display
-      await this.loadLocalDiff();
-
-      // Re-render comments and AI suggestions on the fresh DOM
-      // (renderDiff clears the diff container, so we must re-populate)
-      const includeDismissed = window.aiPanel?.showDismissedComments || false;
-      await manager.loadUserComments(includeDismissed);
-      // Note: Unlike loadLocalReview() which skips this when analysisHistoryManager exists
-      // (because the manager triggers loadAISuggestions via onSelectionChange on init),
-      // refresh must call unconditionally since the manager won't re-fire its callback.
-      await manager.loadAISuggestions(null, manager.selectedRunId);
-
-      // Show success toast
-      if (window.toast) {
-        window.toast.showSuccess('Diff refreshed successfully');
-      } else if (window.showToast) {
-        window.showToast('Diff refreshed successfully', 'success');
-      }
+      await this._applyRefreshedDiff(manager, result);
 
     } catch (error) {
       console.error('Error refreshing diff:', error);
@@ -746,6 +699,198 @@ class LocalManager {
     }
   }
 
+  /**
+   * Handle a non-branch-scope HEAD SHA change.
+   * Shows a 3-option dialog (or auto-updates in silent mode).
+   * @returns {boolean} true if the session was updated in-place (caller should apply diff),
+   *                    false if cancelled or redirecting away (caller should skip _applyRefreshedDiff)
+   */
+  async _resolveHeadChange(result, opts) {
+    const abbrevLen = this.localData?.shaAbbrevLength || 7;
+    const originalSha = result.previousHeadSha ? result.previousHeadSha.substring(0, abbrevLen) : 'unknown';
+    const newSha = result.currentHeadSha ? result.currentHeadSha.substring(0, abbrevLen) : 'unknown';
+
+    let action = 'update'; // default for silent mode
+
+    if (!opts.silent && window.confirmDialog) {
+      const dialogResult = await window.confirmDialog.show({
+        title: 'New Commit Detected',
+        message: `HEAD has moved from ${originalSha} to ${newSha}. Your review is based on the old commit.`,
+        confirmText: 'Continue This Session',
+        confirmDesc: 'Keep comments and suggestions, refresh diff to new HEAD',
+        confirmClass: 'btn-primary',
+        secondaryText: 'Start New Session',
+        secondaryDesc: 'Begin a fresh review from the new commit',
+        cancelText: 'Ignore the Change',
+        cancelDesc: 'Continue reviewing using the previous diff'
+      });
+
+      if (dialogResult === 'confirm') {
+        action = 'update';
+      } else if (dialogResult === 'secondary') {
+        action = 'new-session';
+      } else {
+        // Cancel — keep old diff
+        if (window.toast) {
+          window.toast.showInfo('Staying on current session with previous diff.');
+        }
+        return false;
+      }
+    } else if (!opts.silent) {
+      // Fallback if confirmDialog is not available
+      const switchSession = confirm(
+        `HEAD has changed (${originalSha} \u2192 ${newSha}). ` +
+        `Update this session with the new diff?`
+      );
+      action = switchSession ? 'update' : 'cancel';
+      if (action === 'cancel') return false;
+    }
+
+    // Call resolve-head-change endpoint
+    const resp = await fetch(`/api/local/${this.reviewId}/resolve-head-change`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ action, newHeadSha: result.currentHeadSha })
+    });
+
+    if (!resp.ok) {
+      const err = await resp.json();
+      throw new Error(err.error || 'Failed to resolve head change');
+    }
+
+    const data = await resp.json();
+
+    if (data.action === 'redirect') {
+      // UNIQUE conflict — redirect to existing session
+      window.location.href = `/local/${data.sessionId}`;
+      return false; // navigating away — caller must not fire _applyRefreshedDiff
+    }
+
+    if (data.action === 'new-session') {
+      window.location.href = `/local/${data.newSessionId}`;
+      return false; // navigating away — caller must not fire _applyRefreshedDiff
+    }
+
+    // action === 'updated' — session SHA + diff updated, continue to reload
+    return true;
+  }
+
+  /**
+   * Reload the diff display, re-anchor comments, notify chat, clear stale state.
+   * Shared by refreshDiff() for both normal refreshes and HEAD-change updates.
+   */
+  async _applyRefreshedDiff(manager, result) {
+    // Notify chat agent about diff refresh
+    if (window.chatPanel) {
+      if (result.headShaChanged) {
+        const prev = result.previousHeadSha;
+        const abbrevLen = this.localData?.shaAbbrevLength || 7;
+        window.chatPanel.queueDiffStateNotification(
+          `HEAD SHA changed: ${prev ? prev.substring(0, abbrevLen) : 'unknown'} \u2192 ${result.currentHeadSha ? result.currentHeadSha.substring(0, abbrevLen) : 'unknown'}.`
+        );
+      }
+      window.chatPanel.queueDiffStateNotification(
+        'Local diff refreshed from working directory.'
+      );
+    }
+
+    // Reload the diff display
+    await this.loadLocalDiff();
+
+    // Re-render comments and AI suggestions on the fresh DOM
+    // (renderDiff clears the diff container, so we must re-populate)
+    const includeDismissed = window.aiPanel?.showDismissedComments || false;
+    await manager.loadUserComments(includeDismissed);
+    // Note: Unlike loadLocalReview() which skips this when analysisHistoryManager exists
+    // (because the manager triggers loadAISuggestions via onSelectionChange on init),
+    // refresh must call unconditionally since the manager won't re-fire its callback.
+    await manager.loadAISuggestions(null, manager.selectedRunId);
+
+    // Clear stale state after successful refresh
+    manager._hideStaleBadge();
+    manager._stalenessPromise = null;
+
+    // Show success toast
+    if (window.toast) {
+      window.toast.showSuccess('Diff refreshed successfully');
+    } else if (window.showToast) {
+      window.showToast('Diff refreshed successfully', 'success');
+    }
+  }
+
+  /**
+   * Check staleness on page load and show badge or auto-refresh.
+   *
+   * Logic mirrors PRManager._checkStalenessOnLoad but uses the local
+   * GET endpoint and only supports the 'stale' badge type (no merged/closed).
+   * @returns {Promise<Object|null>} The staleness result, or null on failure.
+   */
+  async _checkLocalStalenessOnLoad() {
+    try {
+      const result = await this._fetchLocalStaleness();
+      if (!result) return null;
+
+      // Notify chat of HEAD SHA change even when diff digest is unchanged
+      // (e.g. git commit --amend with identical content, or rebase)
+      const abbrevLen = this.localData?.shaAbbrevLength || 7;
+      if (result.headShaChanged && window.chatPanel) {
+        window.chatPanel.queueDiffStateNotification(
+          `HEAD SHA changed (${result.previousHeadSha ? result.previousHeadSha.substring(0, abbrevLen) : 'unknown'} → ${result.currentHeadSha ? result.currentHeadSha.substring(0, abbrevLen) : 'unknown'}). The branch may have been rebased.`
+        );
+      }
+      if (result.isStale !== true) return result;
+
+      // Stale — decide: silent refresh or show badge
+      const manager = window.prManager;
+      const hasData = await manager._hasActiveSessionData();
+      if (hasData) {
+        console.debug('[Local] working directory stale, session has data — showing badge');
+        manager._showStaleBadge('stale', 'Working directory has changed');
+        if (window.chatPanel) {
+          // Notify chat of HEAD SHA change only when we have session data to protect
+          // (the !hasData path calls refreshDiff() which queues its own notification)
+          if (result.headShaChanged) {
+            window.chatPanel.queueDiffStateNotification(
+              `HEAD SHA changed (${result.previousHeadSha ? result.previousHeadSha.substring(0, abbrevLen) : 'unknown'} → ${result.currentHeadSha ? result.currentHeadSha.substring(0, abbrevLen) : 'unknown'}). The branch may have been rebased.`
+            );
+          }
+          window.chatPanel.queueDiffStateNotification(
+            'Working directory has changed since the diff was captured.'
+          );
+        }
+      } else {
+        // No user work to protect — refresh silently (auto-update on HEAD change)
+        console.debug('[Local] working directory stale, no session data — auto-refreshing');
+        await this.refreshDiff({ silent: true });
+      }
+      return result;
+    } catch {
+      // Fail silently — staleness badge is best-effort
+      return null;
+    }
+  }
+
+  /**
+   * Fetch staleness data from the local review endpoint with a timeout.
+   * Uses GET to check the local review staleness endpoint.
+   * @returns {Promise<Object|null>} The parsed staleness result, or null on failure/timeout.
+   */
+  async _fetchLocalStaleness() {
+    try {
+      const staleAbort = new AbortController();
+      const staleTimer = setTimeout(() => staleAbort.abort(), STALE_TIMEOUT);
+      const response = await fetch(
+        `/api/local/${this.reviewId}/check-stale`,
+        { signal: staleAbort.signal }
+      );
+      clearTimeout(staleTimer);
+      if (!response.ok) return null;
+      return await response.json();
+    } catch {
+      return null;
+    }
+  }
+
   /**
    * Load local review data
    */
@@ -770,20 +915,47 @@ class LocalManager {
       const reviewData = await response.json();
       this.localData = reviewData;
 
+      // Read scope from metadata (backend now returns these)
+      const LS = window.LocalScope;
+      const scopeStart = reviewData.scopeStart || (LS ? LS.DEFAULT_SCOPE.start : 'unstaged');
+      const scopeEnd = reviewData.scopeEnd || (LS ? LS.DEFAULT_SCOPE.end : 'untracked');
+      this.scopeStart = scopeStart;
+      this.scopeEnd = scopeEnd;
+
       // Create a currentPR-like object for compatibility
+      const hasBranch = LS ? LS.scopeIncludes(scopeStart, scopeEnd, 'branch') : false;
       manager.currentPR = {
         id: reviewData.id,
         owner: 'local',
         repo: reviewData.repository,
         number: reviewData.id,
-        title: `Local Changes - ${reviewData.branch}`,
+        title: hasBranch
+          ? `Branch Changes - ${reviewData.branch} vs ${reviewData.baseBranch}`
+          : `Local Changes - ${reviewData.branch}`,
         head_branch: reviewData.branch,
-        base_branch: reviewData.branch,
+        base_branch: hasBranch ? reviewData.baseBranch : reviewData.branch,
         head_sha: reviewData.localHeadSha,
+        shaAbbrevLength: reviewData.shaAbbrevLength || 7,
         reviewType: 'local',
         localPath: reviewData.localPath
       };
 
+      // Re-initialize DiffOptionsDropdown with scope options
+      const branchAvailable = Boolean(reviewData.branchAvailable);
+      if (manager.diffOptionsDropdown) {
+        manager.diffOptionsDropdown.destroy();
+      }
+      const diffOptionsBtn = document.getElementById('diff-options-btn');
+      if (diffOptionsBtn && window.DiffOptionsDropdown) {
+        manager.diffOptionsDropdown = new window.DiffOptionsDropdown(diffOptionsBtn, {
+          onToggleWhitespace: (hide) => manager.handleWhitespaceToggle(hide),
+          onToggleMinimize: (minimized) => manager.handleMinimizeToggle(minimized),
+          onScopeChange: (start, end) => this._handleScopeChange(start, end),
+          initialScope: { start: scopeStart, end: scopeEnd },
+          branchAvailable
+        });
+      }
+
       // Update header with local info
       this.updateLocalHeader(reviewData);
 
@@ -813,6 +985,7 @@ class LocalManager {
         manager.analysisHistoryManager = new window.AnalysisHistoryManager({
           reviewId: this.reviewId,
           mode: 'local',
+          shaAbbrevLength: reviewData.shaAbbrevLength || 7,
           onSelectionChange: (runId, _run) => {
             manager.selectedRunId = runId;
             manager.loadAISuggestions(null, runId);
@@ -837,6 +1010,9 @@ class LocalManager {
         window.prManager._initReviewEventListeners();
       }
 
+      // Fire-and-forget staleness check — shows badge or auto-refreshes
+      manager._stalenessPromise = this._checkLocalStalenessOnLoad();
+
     } catch (error) {
       console.error('Error loading local review:', error);
       manager.showError(error.message);
@@ -951,6 +1127,36 @@ class LocalManager {
       branchText.textContent = reviewData.branch || 'unknown';
     }
 
+    // Set descriptive tab title
+    if (window.tabTitle && reviewData.branch) {
+      window.tabTitle.setBase(reviewData.branch);
+    }
+
+    // Show base branch badge when branch is in scope
+    const LS = window.LocalScope;
+    const scopeStart = this.scopeStart || (LS ? LS.DEFAULT_SCOPE.start : 'unstaged');
+    const scopeEnd = this.scopeEnd || (LS ? LS.DEFAULT_SCOPE.end : 'untracked');
+    const hasBranch = LS ? LS.scopeIncludes(scopeStart, scopeEnd, 'branch') : false;
+
+    const branchVs = document.getElementById('local-branch-vs');
+    const baseBranchEl = document.getElementById('local-base-branch');
+    const baseBranchText = document.getElementById('local-base-branch-text');
+    if (hasBranch && reviewData.baseBranch) {
+      if (branchVs) branchVs.style.display = '';
+      if (baseBranchEl) baseBranchEl.style.display = '';
+      if (baseBranchText) baseBranchText.textContent = reviewData.baseBranch;
+    } else {
+      if (branchVs) branchVs.style.display = 'none';
+      if (baseBranchEl) baseBranchEl.style.display = 'none';
+    }
+
+    // Update refresh button tooltip based on scope
+    const refreshBtn = document.getElementById('local-refresh-btn');
+    if (refreshBtn) {
+      const scopeLabel = LS ? LS.scopeLabel(scopeStart, scopeEnd) : 'directory';
+      refreshBtn.title = `Refresh diff (${scopeLabel})`;
+    }
+
     // Update branch name (toolbar) and wire up copy button
     const branchName = document.getElementById('pr-branch-name');
     if (branchName) {
@@ -977,7 +1183,8 @@ class LocalManager {
     // Update commit SHA and wire up copy button
     const commitSha = document.getElementById('pr-commit-sha');
     if (commitSha && reviewData.localHeadSha) {
-      commitSha.textContent = reviewData.localHeadSha.substring(0, 7);
+      const abbrevLen = reviewData.shaAbbrevLength || 7;
+      commitSha.textContent = reviewData.localHeadSha.substring(0, abbrevLen);
       commitSha.dataset.fullSha = reviewData.localHeadSha;
     }
 
@@ -1100,10 +1307,26 @@ class LocalManager {
       const generatedFiles = new Set(data.generated_files || []);
 
       if (!diffContent) {
-        // Clear the diff container
         const diffContainer = document.getElementById('diff-container');
         if (diffContainer) {
-          diffContainer.innerHTML = '<div class="no-diff">No unstaged changes to review. Make some changes to your files and click the <strong>Refresh</strong> button to reload.</div>';
+          const reviewData = this.localData;
+          const branchInfo = reviewData?.branchInfo;
+          const LS = window.LocalScope;
+          const hasBranch = LS ? LS.scopeIncludes(this.scopeStart, this.scopeEnd, 'branch') : false;
+
+          // Show scope-aware empty message
+          if (!hasBranch && branchInfo) {
+            const scopeLabel = LS ? LS.scopeLabel(this.scopeStart, this.scopeEnd) : 'current scope';
+            diffContainer.innerHTML = `<div class="no-diff">No changes in ${scopeLabel} scope.</div>`;
+          } else {
+            const scopeLabel = LS ? LS.scopeLabel(this.scopeStart, this.scopeEnd) : 'current scope';
+            diffContainer.innerHTML = `<div class="no-diff">No changes in ${scopeLabel} scope. Change <strong>Diff scope</strong> or make some changes and click <strong>Refresh</strong> to reload.</div>`;
+          }
+
+          // If branch has commits ahead and branch is not in scope, offer to expand
+          if (!hasBranch && branchInfo) {
+            this.showBranchReviewDialog(branchInfo);
+          }
         }
 
         // Clear the file navigation sidebar
@@ -1204,6 +1427,271 @@ class LocalManager {
     }
   }
 
+  /**
+   * Apply the result of a scope-change POST to local state, UI, and diff.
+   * Shared by _handleScopeChange and showBranchReviewDialog.handleConfirm.
+   * @param {string} scopeStart - New start stop
+   * @param {string} scopeEnd - New end stop
+   * @param {Object} result - Response body from POST set-scope
+   */
+  async _applyScopeResult(scopeStart, scopeEnd, result) {
+    const manager = window.prManager;
+    const LS = window.LocalScope;
+
+    // Update local state
+    this.scopeStart = scopeStart;
+    this.scopeEnd = scopeEnd;
+
+    // Update localData
+    if (this.localData) {
+      this.localData.scopeStart = scopeStart;
+      this.localData.scopeEnd = scopeEnd;
+      if (result.baseBranch) {
+        this.localData.baseBranch = result.baseBranch;
+      }
+      if (result.localMode) {
+        this.localData.localMode = result.localMode;
+      }
+    }
+
+    // Update currentPR
+    const hasBranch = LS ? LS.includesBranch(scopeStart) : false;
+    if (manager?.currentPR) {
+      manager.currentPR.base_branch = hasBranch
+        ? (result.baseBranch || this.localData?.baseBranch || manager.currentPR.head_branch)
+        : manager.currentPR.head_branch;
+      manager.currentPR.title = hasBranch
+        ? `Branch Changes - ${manager.currentPR.head_branch} vs ${manager.currentPR.base_branch}`
+        : `Local Changes - ${manager.currentPR.head_branch}`;
+    }
+
+    // Update header and reload diff
+    this.updateLocalHeader(this.localData);
+    await this.loadLocalDiff();
+
+    // Re-anchor comments and suggestions
+    const includeDismissed = window.aiPanel?.showDismissedComments || false;
+    await manager.loadUserComments(includeDismissed);
+    await manager.loadAISuggestions(null, manager.selectedRunId);
+
+    // Only update dropdown if user hasn't clicked again since this request started
+    if (manager?.diffOptionsDropdown) {
+      const current = manager.diffOptionsDropdown.scope;
+      if (current.start === scopeStart && current.end === scopeEnd) {
+        manager.diffOptionsDropdown.clearScopeStatus();
+      }
+    }
+  }
+
+  /**
+   * Handle scope change from DiffOptionsDropdown.
+   * POSTs new scope to backend, reloads diff on success.
+   * @param {string} scopeStart - New start stop
+   * @param {string} scopeEnd - New end stop
+   */
+  async _handleScopeChange(scopeStart, scopeEnd) {
+    const manager = window.prManager;
+    const LS = window.LocalScope;
+    const oldStart = this.scopeStart;
+    const oldEnd = this.scopeEnd;
+
+    try {
+      const resp = await fetch(`/api/local/${this.reviewId}/set-scope`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ scopeStart, scopeEnd })
+      });
+
+      if (!resp.ok) {
+        const err = await resp.json();
+        throw new Error(err.error || 'Failed to set scope');
+      }
+
+      const result = await resp.json();
+      await this._applyScopeResult(scopeStart, scopeEnd, result);
+
+      // Notify chat agent about scope change
+      if (window.chatPanel) {
+        const label = LS ? LS.scopeLabel(scopeStart, scopeEnd) : `${scopeStart}\u2013${scopeEnd}`;
+        window.chatPanel.queueDiffStateNotification(
+          `Diff scope changed to ${label}. The set of reviewed files has changed.`
+        );
+      }
+
+      if (window.toast) {
+        const label = LS ? LS.scopeLabel(scopeStart, scopeEnd) : `${scopeStart}\u2013${scopeEnd}`;
+        window.toast.showSuccess(`Scope: ${label}`);
+      }
+    } catch (error) {
+      console.error('Failed to change scope:', error);
+      if (window.toast) {
+        window.toast.showError('Failed to change scope: ' + error.message);
+      }
+      // Rollback dropdown only if user hasn't clicked again
+      if (manager?.diffOptionsDropdown) {
+        const current = manager.diffOptionsDropdown.scope;
+        if (current.start === scopeStart && current.end === scopeEnd) {
+          manager.diffOptionsDropdown.scope = { start: oldStart, end: oldEnd };
+          manager.diffOptionsDropdown.clearScopeStatus();
+        }
+      }
+    }
+  }
+
+  /**
+   * Show a dialog prompting the user to review branch changes.
+   * Uses the same modal pattern as ConfirmDialog/TextInputDialog.
+   * @param {Object} branchInfo - Branch info with commitCount and baseBranch
+   */
+  showBranchReviewDialog(branchInfo) {
+    // Remove any existing branch review dialog
+    const existing = document.getElementById('branch-review-dialog');
+    if (existing) existing.remove();
+
+    const commitLabel = branchInfo.commitCount === 1 ? 'commit' : 'commits';
+
+    const overlay = document.createElement('div');
+    overlay.id = 'branch-review-dialog';
+    overlay.className = 'modal-overlay';
+    overlay.style.display = 'flex';
+
+    overlay.innerHTML = `
+      <div class="modal-backdrop" data-action="cancel"></div>
+      <div class="modal-container confirm-dialog-container" style="width: 440px; height: auto;">
+        <div class="modal-header">
+          <h3>Branch Has Changes</h3>
+          <button class="modal-close-btn" data-action="cancel" title="Close">
+            <svg width="16" height="16" viewBox="0 0 16 16" fill="currentColor">
+              <path d="M3.72 3.72a.75.75 0 011.06 0L8 6.94l3.22-3.22a.75.75 0 111.06 1.06L9.06 8l3.22 3.22a.75.75 0 11-1.06 1.06L8 9.06l-3.22 3.22a.75.75 0 01-1.06-1.06L6.94 8 3.72 4.78a.75.75 0 010-1.06z"/>
+            </svg>
+          </button>
+        </div>
+
+        <div class="modal-body" style="padding: 16px 20px;">
+          <p style="margin: 0 0 12px 0; font-size: 14px;">
+            No uncommitted changes. This branch has <strong>${branchInfo.commitCount}</strong> ${commitLabel} ahead of <code style="padding: 2px 6px; background: var(--color-bg-tertiary); border-radius: 4px; font-size: 12px;">${branchInfo.baseBranch}</code>.
+          </p>
+          <label style="font-size: 12px; color: var(--color-text-tertiary); cursor: pointer; display: inline-flex; align-items: center; gap: 6px;">
+            <input type="checkbox" id="branch-review-dont-ask" style="cursor: pointer;">
+            Don't ask again for this repository
+          </label>
+        </div>
+
+        <div class="modal-footer">
+          <button class="btn btn-secondary" data-action="cancel">Cancel</button>
+          <button class="btn btn-primary" id="branch-review-confirm-btn" data-action="confirm">
+            Expand Scope to Branch
+          </button>
+        </div>
+      </div>
+    `;
+
+    document.body.appendChild(overlay);
+
+    const reviewId = this.reviewId;
+    const self = this;
+
+    const closeDialog = () => {
+      overlay.style.display = 'none';
+      overlay.remove();
+      document.removeEventListener('keydown', keyHandler);
+    };
+
+    const handleConfirm = async () => {
+      const confirmBtn = overlay.querySelector('#branch-review-confirm-btn');
+      if (confirmBtn) {
+        confirmBtn.disabled = true;
+        confirmBtn.textContent = 'Expanding...';
+      }
+
+      // Save "don't ask" preference if checked
+      const dontAsk = overlay.querySelector('#branch-review-dont-ask');
+      if (dontAsk?.checked) {
+        try {
+          await fetch(`/api/local/${reviewId}/branch-review-preference`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ preference: -1 })
+          });
+        } catch { /* non-fatal */ }
+      }
+
+      try {
+        const LS = window.LocalScope;
+        const newEnd = self.scopeEnd || (LS ? LS.DEFAULT_SCOPE.end : 'untracked');
+        const resp = await fetch(`/api/local/${reviewId}/set-scope`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            scopeStart: 'branch',
+            scopeEnd: newEnd,
+            baseBranch: branchInfo.baseBranch
+          })
+        });
+        if (!resp.ok) {
+          const err = await resp.json();
+          throw new Error(err.error || 'Failed to expand scope');
+        }
+
+        const result = await resp.json();
+
+        // Update the dropdown branchAvailable flag
+        const manager = window.prManager;
+        if (manager?.diffOptionsDropdown) {
+          manager.diffOptionsDropdown.branchAvailable = true;
+          manager.diffOptionsDropdown.scope = { start: 'branch', end: newEnd };
+        }
+
+        closeDialog();
+
+        await self._applyScopeResult('branch', newEnd, result);
+
+        if (window.chatPanel) {
+          const label = LS ? LS.scopeLabel('branch', newEnd) : 'branch';
+          window.chatPanel.queueDiffStateNotification(
+            `Diff scope changed to ${label} via branch review. The set of reviewed files has changed.`
+          );
+        }
+
+        if (window.toast) {
+          const label = LS ? LS.scopeLabel('branch', newEnd) : 'Branch';
+          window.toast.showSuccess(`Scope expanded to ${label}`);
+        }
+      } catch (error) {
+        if (confirmBtn) {
+          confirmBtn.disabled = false;
+          confirmBtn.textContent = 'Expand Scope to Branch';
+        }
+        console.error('Failed to expand scope to branch:', error);
+        if (window.toast) {
+          window.toast.showError('Failed to expand scope: ' + error.message);
+        }
+      }
+    };
+
+    // Event delegation for clicks
+    overlay.addEventListener('click', (e) => {
+      const action = e.target.closest('[data-action]')?.dataset.action;
+      if (action === 'confirm') {
+        handleConfirm();
+      } else if (action === 'cancel') {
+        closeDialog();
+      }
+    });
+
+    // Keyboard handler
+    const keyHandler = (e) => {
+      if (e.key === 'Escape') {
+        closeDialog();
+      } else if (e.key === 'Enter') {
+        e.preventDefault();
+        const btn = overlay.querySelector('#branch-review-confirm-btn');
+        if (!btn?.disabled) handleConfirm();
+      }
+    };
+    document.addEventListener('keydown', keyHandler);
+  }
+
   /**
    * Get the progress dots container element
    * @returns {HTMLElement|null}
@@ -1255,6 +1743,11 @@ class LocalManager {
 }
 
 // Initialize LocalManager when in local mode
-if (window.PAIR_REVIEW_LOCAL_MODE) {
+if (typeof window !== 'undefined' && window.PAIR_REVIEW_LOCAL_MODE) {
   window.localManager = new LocalManager();
 }
+
+// Export for testing (Node.js environment)
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = { LocalManager };
+}