@in-the-loop-labs/pair-review 3.6.0 → 3.7.0

package/public/js/pr.js

@@ -80,18 +80,17 @@ class PRManager {
   }
 
   /**
-   * Generate a safe localStorage key for repository-specific settings
-   * Uses base64 encoding to handle special characters in owner/repo names
+   * Generate a safe localStorage key for repository-specific settings.
+   * Delegates to the shared helper in public/js/utils/storage-keys.js
+   * (loaded before pr.js) so keys stay byte-identical with the index/bulk page,
+   * which writes the same per-repo keys this page reads.
    * @param {string} prefix - Key prefix (e.g., 'pair-review-model')
    * @param {string} owner - Repository owner
    * @param {string} repo - Repository name
    * @returns {string} Safe localStorage key
    */
   static getRepoStorageKey(prefix, owner, repo) {
-    // Use encodeURIComponent + btoa to safely handle Unicode characters
-    // btoa() only accepts Latin1, so we encode Unicode first
-    const repoId = btoa(unescape(encodeURIComponent(`${owner}/${repo}`))).replace(/=/g, '');
-    return `${prefix}:${repoId}`;
+    return window.getRepoStorageKey(prefix, owner, repo);
   }
 
   constructor() {
@@ -140,18 +139,40 @@ class PRManager {
     this.commentMinimizer = window.CommentMinimizer ? new window.CommentMinimizer() : null;
     // Hunk summary renderer (Phase 5) — inline natural-language summaries
     this.hunkSummaryRenderer = window.HunkSummaryRenderer ? new window.HunkSummaryRenderer(this) : null;
-    // Per-render anchor map: contentHash -> first code-line <tr> of the hunk
+    // Per-render anchor map, file-scoped so a content-hash shared across two
+    // files (renamed-with-tiny-edits, copy-pasted boilerplate, identical
+    // stubs) can't let the later file's anchor overwrite the earlier one's:
+    //   Map<filePath, Map<contentHash, anchorRow>>
+    // where anchorRow is the first code-line <tr> of the hunk. Symmetric with
+    // `_pendingSummariesByHash` so both sides of the queue/anchor handshake
+    // key on (filePath, hash).
     this._summaryAnchorsByHash = new Map();
     // Per-render file map: filePath -> Set<contentHash>
     this._summaryHashesByFile = new Map();
-    // Summaries that arrived (via WS or fetch) before their hunk had been hashed
+    // Summaries that arrived (via WS or fetch) before their hunk had been
+    // hashed, scoped by file path so a content-hash collision across files
+    // can't let one file's anchor consume another file's queued summary:
+    //   Map<filePath, Map<contentHash, summary>>
+    // The '' bucket holds summaries queued without a file path (the legacy
+    // ungrouped-fetch fallback in _fetchHunkSummaryMap).
     this._pendingSummariesByHash = new Map();
     // Per-file summary visibility (persisted in localStorage per-review)
     this.summariesHiddenFiles = new Set();
     // Render-generation token — incremented at the top of renderDiff() so any
-    // fire-and-forget _kickOffHunkSummaries() from a prior render can detect
+    // fire-and-forget _fetchHunkSummaryMap() from a prior render can detect
     // it's stale and bail (refresh / whitespace toggle / scope change race).
     this._renderGen = 0;
+    // ---- Lazy diff-body rendering (perf for very large PRs) -----------
+    // Each file's wrapper + header render eagerly, but the <tbody> of diff
+    // lines is built on demand: when the body scrolls near the viewport
+    // (IntersectionObserver), when the file is expanded, or when a code path
+    // needs to anchor into it (see ensureFileBodyRendered). Collapsed bodies
+    // are `display:none`, so they never intersect and stay unrendered until
+    // expanded. Key = file path; value = lazy entry (see renderFileDiff).
+    this._lazyFileBodies = new Map();
+    // The IntersectionObserver watching `.d2h-file-body` elements for the
+    // current render generation. Recreated on every renderDiff().
+    this._fileBodyObserver = null;
     // Cached /api/config response (lazy-loaded)
     this._appConfigPromise = null;
     // Review-level summary visibility (persisted in localStorage per-review)
@@ -165,6 +186,15 @@ class PRManager {
     // user can tell nothing has been generated yet. Set true by
     // `_applyHunkSummaries` and the initial existing-summaries fetch.
     this._summariesGenerated = false;
+    // Whether any non-trivial hunk summary EXISTS for this review — mounted
+    // OR merely queued because its lazy file body hasn't rendered yet. This is
+    // deliberately separate from `_summariesGenerated` (which gates the
+    // `.active` blue styling and tracks summaries actually in the DOM): with
+    // lazy bodies a valid summary can arrive before its anchor exists, and the
+    // toolbar must still treat the feature as "has data" so a click toggles
+    // visibility instead of dispatching a duplicate generation job. Set by
+    // `_applyHunkSummaries` / `_fetchHunkSummaryMap`; reset in renderDiff.
+    this._summariesAvailable = false;
     // Tri-state: true when /api/config reports summaries.enabled, false when
     // disabled, null until /api/config resolves. Per-file toggle buttons are
     // gated on this so users on disabled deployments don't see them flicker
@@ -588,7 +618,7 @@ class PRManager {
    * @param {Object} reviewSettings - Review settings from fetchLastReviewSettings()
    * @returns {Promise<Object>} Config object suitable for startAnalysis / startLocalAnalysis
    */
-  async _buildDefaultAnalysisConfig(repoSettings, reviewSettings) {
+  async _buildDefaultAnalysisConfig(repoSettings, reviewSettings, appConfig = {}, providersInfo = null) {
     const defaultTab = repoSettings?.default_tab || 'single';
     const councilId = repoSettings?.default_council_id || reviewSettings?.last_council_id || null;
 
@@ -617,13 +647,44 @@ class PRManager {
       };
     }
 
+    // Resolve provider and model as a MATCHED pair. Resolving each half
+    // independently (repo || app || hardcoded) can mix a provider from one
+    // scope with a model from another, yielding an invalid pair (e.g.
+    // gemini/opus) that startAnalysis would forward to the backend as-is.
+    const providers = providersInfo || await this._getProvidersInfo();
+    const { provider, model } = window.resolveProviderModelPair([
+      { provider: repoSettings?.default_provider, model: repoSettings?.default_model },
+      { provider: appConfig.default_provider, model: appConfig.default_model }
+    ], providers);
+
     return {
-      provider: repoSettings?.default_provider || 'claude',
-      model: repoSettings?.default_model || 'opus',
+      provider,
+      model,
       customInstructions: null
     };
   }
 
+  async _fetchAutoAnalysisConfigFromUrl() {
+    const params = new URLSearchParams(window.location.search);
+    const configId = params.get('analysisConfigId');
+    if (!configId) return { requested: false, config: null, error: null };
+
+    try {
+      const response = await fetch(`/api/bulk-analysis-configs/${encodeURIComponent(configId)}`);
+      if (!response.ok) {
+        throw new Error('Stored analysis settings were not found');
+      }
+      const data = await response.json();
+      if (!data.analysisConfig) {
+        throw new Error('Stored analysis settings response was empty');
+      }
+      return { requested: true, config: data.analysisConfig, error: null };
+    } catch (error) {
+      console.warn('Failed to fetch bulk analysis config:', error);
+      return { requested: true, config: null, error };
+    }
+  }
+
   /**
    * Auto-trigger analysis if ?analyze=true is present in the URL.
    * Skips refresh if data was just loaded fresh by loadPR (to avoid redundant fetches).
@@ -638,6 +699,7 @@ class PRManager {
     const autoAnalyze = new URLSearchParams(window.location.search).get('analyze');
     if (autoAnalyze === 'true' && !this.isAnalyzing) {
       this._autoAnalyzeRequested = true;
+      let shouldCleanUrl = true;
       try {
         // Skip refresh if we just loaded fresh data (loadPR sets _justLoaded = true).
         // Otherwise, refresh to ensure we have the latest PR data in case the worktree
@@ -654,19 +716,39 @@ class PRManager {
           }
         }
 
-        // Fetch repo settings so we honour the repository's default provider/council
-        const [repoSettings, reviewSettings] = await Promise.all([
-          this.fetchRepoSettings().catch(() => null),
-          this.fetchLastReviewSettings().catch(() => ({ custom_instructions: '', last_council_id: null }))
-        ]);
-        const config = await this._buildDefaultAnalysisConfig(repoSettings, reviewSettings);
+        const storedConfig = await this._fetchAutoAnalysisConfigFromUrl();
+        let config;
+        if (storedConfig.requested) {
+          if (!storedConfig.config) {
+            // The stored bulk-analysis config expired (TTL/eviction/restart).
+            // The PR diff has already rendered, so don't replace it with a
+            // full-screen error whose Retry button would just re-trigger the
+            // same failed lookup. Warn, strip the stale params (so a refresh
+            // won't re-trigger), and leave the PR usable for manual analysis.
+            const message = 'Could not load the selected bulk analysis settings. Start analysis manually to choose new settings.';
+            if (window.toast) window.toast.showWarning(message);
+            return;
+          }
+          config = storedConfig.config;
+        } else {
+          // Fetch repo settings so we honour the repository's default provider/council
+          const [repoSettings, reviewSettings, appConfig] = await Promise.all([
+            this.fetchRepoSettings().catch(() => null),
+            this.fetchLastReviewSettings().catch(() => ({ custom_instructions: '', last_council_id: null })),
+            this._getAppConfig()
+          ]);
+          config = await this._buildDefaultAnalysisConfig(repoSettings, reviewSettings, appConfig);
+        }
 
         await this.startAnalysis(owner, repo, prNumber, null, config);
       } finally {
         this._autoAnalyzeRequested = false;
-        const cleanUrl = new URL(window.location);
-        cleanUrl.searchParams.delete('analyze');
-        history.replaceState(null, '', cleanUrl);
+        if (shouldCleanUrl) {
+          const cleanUrl = new URL(window.location);
+          cleanUrl.searchParams.delete('analyze');
+          cleanUrl.searchParams.delete('analysisConfigId');
+          history.replaceState(null, '', cleanUrl);
+        }
       }
     }
   }
@@ -1067,31 +1149,111 @@ class PRManager {
   }
 
   /**
-   * Attach `data-hunk-start` to each anchor row using the server-supplied
-   * `content_hash`, then kick off the initial summary fetch (gated by
-   * `summaries.enabled` in `/api/config`). Drains any summaries that
-   * arrived before mounting finished.
+   * Fetch and cache the provider/model metadata from /api/providers. Used to
+   * resolve a coherent provider/model pair for the non-modal auto-analyze path
+   * (the modal loads its own copy). Resolves to the `providers` array, or [] on
+   * failure so callers can fall back to provider-agnostic defaults.
+   */
+  _getProvidersInfo() {
+    if (!this._providersInfoPromise) {
+      this._providersInfoPromise = fetch('/api/providers')
+        .then((r) => (r.ok ? r.json() : {}))
+        .then((data) => (Array.isArray(data.providers) ? data.providers : []))
+        .catch(() => []);
+    }
+    return this._providersInfoPromise;
+  }
+
+  /**
+   * Wire one file's hunk anchor rows to their server-supplied content hashes
+   * as that file's body renders (called from _renderFileBodyNow), then mount
+   * any summary that already arrived for those hunks.
+   *
+   * Pre-lazy-render this happened once globally in _kickOffHunkSummaries;
+   * with lazy bodies a file's anchor rows don't exist until it renders, so
+   * anchoring is now incremental. The server computes hashes from the
+   * canonical (non-whitespace-filtered) diff so they stay aligned with
+   * persisted summary keys regardless of `?w=1`; records lacking a
+   * `contentHash` are logged-and-skipped.
+   *
+   * The bridge for "summary arrived before its anchor existed" is the existing
+   * `_pendingSummariesByHash` map: _renderOneSummary / _applyHunkSummaries
+   * queue there when no anchor is found, and we drain matching entries here.
+   * @param {Array<{file,header,anchorRow,contentHash}>} records
+   */
+  _registerHunkAnchorsForFile(records) {
+    if (!Array.isArray(records) || records.length === 0) return;
+    const filesWithMounts = new Set();
+    for (const rec of records) {
+      if (!rec.anchorRow || !rec.anchorRow.isConnected) continue;
+      const hex = rec.contentHash;
+      if (!hex) {
+        console.warn(
+          `[HunkSummary] no server contentHash for ${rec.file} ` +
+          `hunk ${rec.header}; skipping (summaries will not anchor here).`
+        );
+        continue;
+      }
+      rec.anchorRow.dataset.hunkStart = hex;
+      // Scope the anchor by file so a hash collision across files can't let
+      // the later file's anchor clobber the earlier file's (which would mount
+      // a summary against the wrong hunk). Symmetric with the file-scoped
+      // pending-summary queue.
+      let anchors = this._summaryAnchorsByHash.get(rec.file);
+      if (!anchors) {
+        anchors = new Map();
+        this._summaryAnchorsByHash.set(rec.file, anchors);
+      }
+      anchors.set(hex, rec.anchorRow);
+      let bucket = this._summaryHashesByFile.get(rec.file);
+      if (!bucket) {
+        bucket = new Set();
+        this._summaryHashesByFile.set(rec.file, bucket);
+      }
+      bucket.add(hex);
+
+      // Mount a summary that arrived before this anchor existed. Look it up by
+      // THIS file + hash so a content-hash that also appears in another file
+      // (renamed-with-tiny-edits, copy-pasted boilerplate, identical stubs)
+      // can't let this file's anchor consume the other file's queued summary.
+      const pending = this._takePendingSummary(rec.file, hex);
+      if (pending) {
+        const row = this._renderOneSummary(pending, rec.file);
+        if (row) {
+          this._summariesGenerated = true;
+          this._summariesAvailable = true;
+          filesWithMounts.add(rec.file);
+        }
+        // If it couldn't mount (anchor not connected after all),
+        // _renderOneSummary re-queued it scoped to rec.file for a later pass.
+      }
+    }
+    if (this._summariesGenerated) this._syncSummaryToolbarButton();
+    for (const filePath of filesWithMounts) this._refreshFileSummaryToggle(filePath);
+  }
+
+  /**
+   * Load the review's hunk summaries from the server and apply them to the
+   * anchors that exist so far (gated by `summaries.enabled` in `/api/config`).
    *
-   * Order matters:
-   *   1. Config gate first — bail before paying any setup cost when the
-   *      feature is off.
+   * With lazy bodies, anchor wiring is incremental (_registerHunkAnchorsForFile
+   * runs as each body renders), so this method no longer walks render records.
+   * Summaries whose file hasn't rendered yet are queued in
+   * `_pendingSummariesByHash` (via _applyHunkSummaries / _renderOneSummary) and
+   * drained when that body renders.
+   *
+   * Order:
+   *   1. Config gate first — bail before paying any cost when the feature is off.
    *   2. Restore localStorage visibility state.
-   *   3. Walk records and wire each anchor row to its server-supplied
-   *      content hash. The server computes hashes from the canonical
-   *      (non-whitespace-filtered) diff so they stay aligned with persisted
-   *      summary keys; records lacking a `contentHash` are logged-and-skipped.
-   *   4. Drain pending summaries against the freshly-built anchor map.
-   *   5. Fetch existing summaries from the server.
+   *   3. Fetch existing summaries and apply/queue them.
    *
-   * Race-safety: `_renderGen` is captured at entry and rechecked after
-   * every `await`. If `renderDiff()` ran again mid-flight, we stop touching
-   * the (now stale) maps and DOM.
+   * Race-safety: `_renderGen` is captured at entry and rechecked after every
+   * `await`. If `renderDiff()` ran again mid-flight, we stop touching the (now
+   * stale) maps and DOM.
    * @returns {Promise<void>}
    */
-  async _kickOffHunkSummaries() {
+  async _fetchHunkSummaryMap() {
     const gen = this._renderGen;
-    const records = this._pendingHunkRecords || [];
-    this._pendingHunkRecords = null; // single-use; renderDiff resets
 
     // 1. Config gate — bail before doing any work when the feature is off.
     const cfg = await this._getAppConfig();
@@ -1119,54 +1281,7 @@ class PRManager {
       }
     }
 
-    // 3. Wire each anchor row to its server-supplied content hash. The
-    // backend computes these from the canonical (unfiltered) diff so they
-    // stay aligned with persisted summary keys regardless of `?w=1`.
-    // Records missing `contentHash` indicate a server bug (or a hash array
-    // length mismatch the renderPatch guard already dropped) — log + skip.
-    for (const rec of records) {
-      if (!rec.anchorRow || !rec.anchorRow.isConnected) continue;
-      const hex = rec.contentHash;
-      if (!hex) {
-        console.warn(
-          `[HunkSummary] no server contentHash for ${rec.file} ` +
-          `hunk ${rec.header}; skipping (summaries will not anchor here).`
-        );
-        continue;
-      }
-      rec.anchorRow.dataset.hunkStart = hex;
-      this._summaryAnchorsByHash.set(hex, rec.anchorRow);
-      let bucket = this._summaryHashesByFile.get(rec.file);
-      if (!bucket) {
-        bucket = new Set();
-        this._summaryHashesByFile.set(rec.file, bucket);
-      }
-      bucket.add(hex);
-    }
-
-    // 4. Drain summaries that arrived (via WS) before hashing finished.
-    if (this._pendingSummariesByHash.size > 0) {
-      const filesWithMounts = new Set();
-      for (const [hash, summary] of this._pendingSummariesByHash.entries()) {
-        if (this._summaryAnchorsByHash.has(hash)) {
-          const row = this._renderOneSummary(summary);
-          if (row) {
-            // Find the file this hash belongs to, so we can re-enable its
-            // toggle button.
-            for (const [filePath, bucket] of this._summaryHashesByFile.entries()) {
-              if (bucket.has(hash)) {
-                filesWithMounts.add(filePath);
-                break;
-              }
-            }
-          }
-          this._pendingSummariesByHash.delete(hash);
-        }
-      }
-      for (const filePath of filesWithMounts) this._refreshFileSummaryToggle(filePath);
-    }
-
-    // 5. Load existing summaries from the server.
+    // 3. Load existing summaries from the server.
     if (!this.currentPR?.id) return;
 
     try {
@@ -1192,13 +1307,14 @@ class PRManager {
       // `_applyHunkSummaries`, which sets the flag on a successful mount.
       if (byFile.size === 0 && summaries.length > 0) {
         let mountedAny = false;
+        let availableAny = false;
         for (const summary of summaries) {
+          if (summary.summary_text) availableAny = true;
           if (this._renderOneSummary(summary)) mountedAny = true;
         }
-        if (mountedAny) {
-          this._summariesGenerated = true;
-          this._syncSummaryToolbarButton();
-        }
+        if (availableAny) this._summariesAvailable = true;
+        if (mountedAny) this._summariesGenerated = true;
+        if (mountedAny || availableAny) this._syncSummaryToolbarButton();
       } else {
         for (const [filePath, fileSummaries] of byFile.entries()) {
           this._applyHunkSummaries(filePath, fileSummaries);
@@ -1228,6 +1344,7 @@ class PRManager {
     if (!Array.isArray(summaries)) return;
     const allowedHashes = this._summaryHashesByFile.get(filePath) || new Set();
     let mountedAny = false;
+    let availableAny = false;
     for (const summary of summaries) {
       if (!summary?.content_hash) continue;
       if (allowedHashes.size > 0 && !allowedHashes.has(summary.content_hash)) {
@@ -1240,15 +1357,26 @@ class PRManager {
         }
         continue;
       }
-      const row = this._renderOneSummary(summary);
+      // A non-trivial summary that belongs to this render (it passed the hash
+      // filter) means the feature has data even if its body hasn't rendered
+      // yet — _renderOneSummary will queue it rather than mount it in that
+      // case. Track availability separately from mounted rows.
+      if (summary.summary_text) availableAny = true;
+      const row = this._renderOneSummary(summary, filePath);
       if (row) mountedAny = true;
     }
+    if (availableAny) this._summariesAvailable = true;
     if (mountedAny) {
-      // At least one summary mounted — the feature now has data, so the
-      // toolbar button can show its `.active` (blue) state.
+      // At least one summary mounted — the feature now has visible data, so
+      // the toolbar button can show its `.active` (blue) state.
       this._summariesGenerated = true;
-      this._syncSummaryToolbarButton();
     }
+    // Refresh the toolbar when either flag changed: `.active` tracks
+    // `_summariesGenerated` (rows in the DOM) while the Generate-vs-Show/Hide
+    // decision tracks `_summariesAvailable` (mounted OR queued). Refreshing on
+    // availableAny prevents a not-yet-rendered file from leaving the toolbar
+    // in "Generate" mode, where a click would start a duplicate job.
+    if (mountedAny || availableAny) this._syncSummaryToolbarButton();
     if (mountedAny && filePath) this._refreshFileSummaryToggle(filePath);
   }
 
@@ -1276,7 +1404,7 @@ class PRManager {
    *
    * Used by three call sites that must agree on the button's visible state:
    *   - createFileHeader (initial render)
-   *   - _kickOffHunkSummaries (rehydrate after localStorage restore)
+   *   - _fetchHunkSummaryMap (rehydrate after localStorage restore)
    *   - _refreshFileSummaryToggle (when summaries arrive late)
    *   - toggleFileSummaries (user click)
    *
@@ -1298,22 +1426,91 @@ class PRManager {
     }
   }
 
+  /**
+   * Queue a summary that arrived before its hunk anchor existed, scoped by
+   * file path so a content-hash collision across files can't let one file's
+   * anchor consume another file's queued summary. Summaries arriving without
+   * a file path (legacy ungrouped fetch) land in the '' bucket.
+   * @param {string|undefined} filePath
+   * @param {Object} summary - must have `content_hash`
+   */
+  _queuePendingSummary(filePath, summary) {
+    const key = filePath || '';
+    let bucket = this._pendingSummariesByHash.get(key);
+    if (!bucket) {
+      bucket = new Map();
+      this._pendingSummariesByHash.set(key, bucket);
+    }
+    bucket.set(summary.content_hash, summary);
+  }
+
+  /**
+   * Pull (and remove) a queued summary for (filePath, hash). Checks the
+   * file-scoped bucket first, then the '' bucket that holds summaries queued
+   * without a file path (legacy ungrouped fetch). Returns null when nothing
+   * is queued for that pair.
+   * @param {string|undefined} filePath
+   * @param {string} hash
+   * @returns {Object|null}
+   */
+  _takePendingSummary(filePath, hash) {
+    for (const key of [filePath || '', '']) {
+      const bucket = this._pendingSummariesByHash.get(key);
+      if (bucket && bucket.has(hash)) {
+        const summary = bucket.get(hash);
+        bucket.delete(hash);
+        if (bucket.size === 0) this._pendingSummariesByHash.delete(key);
+        return summary;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Resolve the anchor row for (filePath, hash) against the file-scoped
+   * `_summaryAnchorsByHash` map.
+   *
+   * When `filePath` is known (the grouped path), the lookup is strictly
+   * scoped to that file so a content-hash shared across files can't pull a
+   * summary onto the wrong file's anchor. When it's absent — the legacy
+   * ungrouped-fetch fallback where summaries arrive without a `file_path` —
+   * there's no file to scope by, so we accept the first file whose bucket
+   * carries the hash. This mirrors `_takePendingSummary`'s `''` fallback
+   * bucket: file-scoped first, best-effort otherwise.
+   * @param {string|undefined} filePath
+   * @param {string} hash
+   * @returns {HTMLTableRowElement|null}
+   */
+  _findSummaryAnchor(filePath, hash) {
+    if (filePath) {
+      return this._summaryAnchorsByHash.get(filePath)?.get(hash) || null;
+    }
+    for (const anchors of this._summaryAnchorsByHash.values()) {
+      const anchor = anchors.get(hash);
+      if (anchor) return anchor;
+    }
+    return null;
+  }
+
   /**
    * Render a single summary row, or queue it if the matching hunk hasn't
    * been hashed yet (race between WS broadcast and post-render hashing).
    * Trivial / model-skipped / model-malformed rows are ignored.
    * @param {Object} summary - { content_hash, summary_text, trivial_reason }
+   * @param {string} [filePath] - File the summary belongs to. Used to scope
+   *   both the anchor lookup and the pending-queue key so a cross-file hash
+   *   collision can't misroute it to the wrong file's hunk.
    * @returns {HTMLTableRowElement|null} The mounted row, or null if queued/skipped.
    */
-  _renderOneSummary(summary) {
+  _renderOneSummary(summary, filePath) {
     if (!summary || !summary.content_hash) return null;
     if (!summary.summary_text) return null; // trivial / opt-out — nothing to show
     const hash = summary.content_hash;
-    const anchor = this._summaryAnchorsByHash.get(hash);
+    const anchor = this._findSummaryAnchor(filePath, hash);
     if (!anchor || !anchor.isConnected) {
       // Anchor missing or detached (stale render) → defer; the next render
       // pass that re-establishes the hash will drain this map.
-      this._pendingSummariesByHash.set(hash, summary);
+      this._queuePendingSummary(filePath, summary);
       return null;
     }
     if (!this.hunkSummaryRenderer) return null;
@@ -1423,9 +1620,12 @@ class PRManager {
       // opens a confirm dialog ("Cancel Summaries" / "OK") instead of
       // toggling visibility. See _handleSummaryToggleClick.
       label = 'Generating summaries… (click to cancel)';
-    } else if (!this._summariesGenerated) {
-      // Pre-generated state: nothing generated yet. Colorless button; a click
-      // kicks off generation. See _handleSummaryToggleClick.
+    } else if (!this._summariesAvailable) {
+      // Pre-generated state: nothing generated yet (mounted or queued).
+      // Colorless button; a click kicks off generation. Gated on
+      // `_summariesAvailable` (not `_summariesGenerated`) so a review whose
+      // summaries exist but haven't mounted shows Show/Hide, matching the
+      // click behavior in _handleSummaryToggleClick.
       label = 'Generate hunk summaries';
     } else {
       label = this._summariesHidden ? 'Show hunk summaries' : 'Hide hunk summaries';
@@ -1505,10 +1705,14 @@ class PRManager {
       });
       return;
     }
-    if (!this._summariesGenerated) {
-      // Pre-generated state: a click triggers generation rather than toggling
-      // visibility. `_startGenerationJob` sets the pulsing `.generating` state
-      // optimistically (there is no `review:background_job_started` event).
+    if (!this._summariesAvailable) {
+      // Nothing generated yet (mounted OR queued): a click triggers generation
+      // rather than toggling visibility. `_startGenerationJob` sets the pulsing
+      // `.generating` state optimistically (there is no
+      // `review:background_job_started` event). We gate on `_summariesAvailable`
+      // rather than `_summariesGenerated` so summaries that exist server-side
+      // but haven't mounted (their lazy file body isn't rendered yet) toggle
+      // visibility instead of kicking off a duplicate generation job.
       await this._startGenerationJob('summary');
       return;
     }
@@ -1594,18 +1798,23 @@ class PRManager {
     const url = isLocal
       ? `/api/local/${encodeURIComponent(pr.id)}/jobs/${encodeURIComponent(jobKey)}/start`
       : `/api/pr/${encodeURIComponent(pr.owner)}/${encodeURIComponent(pr.repo)}/${encodeURIComponent(pr.number)}/jobs/${encodeURIComponent(jobKey)}/start`;
+    // Phrasing varies by job kind. `featureLabel` goes into the HTTP/decline
+    // error messages; `noDiffMessage` is the dedicated "nothing to do" line.
+    // NOTE: the toast singleton is lowercase `window.toast` (see
+    // cancel-background-job.js); `window.Toast` does not exist.
+    const featureLabel = jobKey === 'tour' ? 'tour' : 'summary';
+    const noDiffMessage = jobKey === 'tour' ? 'No tour to generate.' : 'No summaries to generate.';
     try {
       const resp = await fetch(url, { method: 'POST' });
       if (resp.status === 409) {
         // Feature disabled in config — shouldn't happen (the button is hidden
         // when disabled) but surface it rather than failing silently.
-        // NOTE: the toast singleton is lowercase `window.toast` (see
-        // cancel-background-job.js); `window.Toast` does not exist.
-        if (window.toast?.error) window.toast.error('This feature is disabled in config.');
+        window.toast?.showError?.('This feature is disabled in config.');
         return;
       }
       if (!resp.ok) {
         console.warn(`[StartJob] ${jobKey} start POST failed: ${resp.status}`);
+        window.toast?.showError?.(`Failed to start ${featureLabel} generation (HTTP ${resp.status}).`);
         return;
       }
       // Optimistic UI: there is no `review:background_job_started` broadcast,
@@ -1623,9 +1832,20 @@ class PRManager {
           this._tourGenerating = true;
           this._syncTourToolbarButton();
         }
+        return;
+      }
+      // Server accepted the request but declined to enqueue. The known
+      // reason today is `'no-diff'` — review has no changes to act on. Tell
+      // the user so the button doesn't appear inert. Unknown decline
+      // reasons fall through to a generic message rather than silence.
+      if (payload.reason === 'no-diff') {
+        window.toast?.showInfo?.(noDiffMessage);
+      } else {
+        window.toast?.showError?.(`Could not start ${featureLabel} generation.`);
       }
     } catch (err) {
       console.warn(`[StartJob] ${jobKey} start POST error:`, err.message);
+      window.toast?.showError?.(`Failed to start ${featureLabel} generation: ${err.message}`);
     }
   }
 
@@ -1836,7 +2056,11 @@ class PRManager {
           // was awaiting a file fetch / loadContextFiles. Bail before
           // mounting against a torn-down tour.
           if (isStale()) return;
-          const row = this._tourRenderer.mountStop(probe);
+          // mountStop is async (it awaits toggleFileCollapse so a collapsed
+          // file is rendered + visibly expanded before we scroll to it).
+          const row = await this._tourRenderer.mountStop(probe);
+          // Re-check staleness: the await above is a suspension window.
+          if (isStale()) return;
           if (row) {
             nextRow = row;
             nextIndex = probe;
@@ -2437,13 +2661,32 @@ class PRManager {
 
     // Update Graphite link (gated on enable_graphite config)
     const graphiteLink = document.getElementById('graphite-link');
-    if (graphiteLink && pr.html_url && window.__pairReview?.enableGraphite) {
+    if (graphiteLink && pr.html_url && window.__pairReview?.enableGraphite
+        && graphiteLink.dataset.suppressed !== 'true') {
       // Derive from html_url to preserve GitHub's original casing (Graphite URLs are case-sensitive)
       const graphiteUrl = window.__pairReview.toGraphiteUrl(pr.html_url);
       graphiteLink.href = graphiteUrl;
       graphiteLink.style.display = '';
     }
 
+    if (window.RepoLinks && pr.owner && pr.repo) {
+      const linksApplied = window.RepoLinks.fetchAndApplyRepoLinks(pr.owner, pr.repo, {
+        owner: pr.owner,
+        repo: pr.repo,
+        number: pr.number,
+        branch: pr.head_branch,
+        base_branch: pr.base_branch,
+        head_sha: pr.head_sha,
+      });
+      // The repo links (incl. the configured host name) resolve asynchronously
+      // after this synchronous render. Re-render the pending-draft indicator
+      // once they land so it shows the configured host name (e.g. "Meteorite")
+      // instead of the "GitHub" fallback it would otherwise bake in below.
+      if (linksApplied && typeof linksApplied.then === 'function') {
+        linksApplied.then(() => this.updatePendingDraftIndicator(pr.pendingDraft));
+      }
+    }
+
     // Update settings link
     const settingsLink = document.getElementById('settings-link');
     if (settingsLink && pr.owner && pr.repo) {
@@ -2744,13 +2987,20 @@ class PRManager {
       }
 
       // Fetch settings in parallel
-      const [repoSettings, reviewSettings] = await Promise.all([
+      const [repoSettings, reviewSettings, appConfig] = await Promise.all([
         this.fetchRepoSettings().catch(() => null),
-        this.fetchLastReviewSettings().catch(() => ({ custom_instructions: '', last_council_id: null }))
+        this.fetchLastReviewSettings().catch(() => ({ custom_instructions: '', last_council_id: null })),
+        this._getAppConfig()
       ]);
 
-      const currentModel = repoSettings?.default_model || 'opus';
-      const currentProvider = repoSettings?.default_provider || 'claude';
+      // Resolve provider and model as a MATCHED pair so the council/advanced tabs
+      // are never seeded with a cross-provider model (e.g. gemini + opus), which
+      // would blank the model <select> and be rejected by the backend.
+      const providersInfo = await this._getProvidersInfo();
+      const { provider: currentProvider, model: currentModel } = window.resolveProviderModelPair([
+        { provider: repoSettings?.default_provider, model: repoSettings?.default_model },
+        { provider: appConfig.default_provider, model: appConfig.default_model }
+      ], providersInfo);
       const tabStorageKey = PRManager.getRepoStorageKey('pair-review-tab', owner, repo);
       const rememberedTab = localStorage.getItem(tabStorageKey);
       const defaultTab = rememberedTab || repoSettings?.default_tab || 'single';
@@ -2957,14 +3207,22 @@ class PRManager {
     // Don't show if no pending draft
     if (!pendingDraft) return;
 
+    // Resolve the configured host name + URL (alt-host aware). Prefer the
+    // URL built from the repo's url_template over the server-reported
+    // github_url, which some alt-hosts return as a wrong-host github.com URL.
+    const hostName = (window.RepoLinks && typeof window.RepoLinks.hostName === 'function')
+      ? window.RepoLinks.hostName() : 'GitHub';
+    const externalUrl = (window.RepoLinks && typeof window.RepoLinks.externalUrl === 'function')
+      ? window.RepoLinks.externalUrl() : null;
+
     // Create the indicator
     const indicator = document.createElement('a');
     indicator.id = 'pending-draft-indicator';
     indicator.className = 'pending-draft-indicator';
-    indicator.href = pendingDraft.github_url || '#';
+    indicator.href = externalUrl || pendingDraft.github_url || '#';
     indicator.target = '_blank';
     indicator.rel = 'noopener noreferrer';
-    indicator.title = 'View your pending draft review on GitHub';
+    indicator.title = `View your pending draft review on ${hostName}`;
 
     const commentCount = pendingDraft.comments_count || 0;
     const commentText = commentCount === 1 ? '1 comment' : `${commentCount} comments`;
@@ -2973,7 +3231,7 @@ class PRManager {
       <svg width="14" height="14" viewBox="0 0 16 16" fill="currentColor">
         <path d="M0 1.75C0 .784.784 0 1.75 0h12.5C15.216 0 16 .784 16 1.75v9.5A1.75 1.75 0 0 1 14.25 13H8.06l-2.573 2.573A1.458 1.458 0 0 1 3 14.543V13H1.75A1.75 1.75 0 0 1 0 11.25Zm1.75-.25a.25.25 0 0 0-.25.25v9.5c0 .138.112.25.25.25h2a.75.75 0 0 1 .75.75v2.19l2.72-2.72a.749.749 0 0 1 .53-.22h6.5a.25.25 0 0 0 .25-.25v-9.5a.25.25 0 0 0-.25-.25Zm5.03 2.22a.75.75 0 0 1 0 1.06L5.31 6.25l1.47 1.47a.751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018l-2-2a.75.75 0 0 1 0-1.06l2-2a.75.75 0 0 1 1.06 0Zm2.44 0a.75.75 0 0 1 1.06 0l2 2a.75.75 0 0 1 0 1.06l-2 2a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042l1.47-1.47-1.47-1.47a.75.75 0 0 1 0-1.06Z"/>
       </svg>
-      <span class="pending-draft-text">Draft on GitHub (${commentText})</span>
+      <span class="pending-draft-text">Draft on ${this.escapeHtml(hostName)} (${commentText})</span>
     `;
 
     // Insert after the commit element (or at the end of toolbar-meta)
@@ -3022,10 +3280,23 @@ class PRManager {
     // no matching rows keeps the stale `true`, leaving the toolbar stuck in
     // Hide/Show mode with nothing in the DOM and blocking click-to-generate.
     this._summariesGenerated = false;
-    // Bump generation so any in-flight `_kickOffHunkSummaries` from the
+    // Reset alongside `_summariesGenerated`. Set true again only when a fetch
+    // (or WS event) accepts/queues a non-trivial summary for this render.
+    this._summariesAvailable = false;
+    // Bump generation so any in-flight `_fetchHunkSummaryMap` from the
     // previous render bails out instead of mutating maps we just reset.
     this._renderGen = (this._renderGen || 0) + 1;
 
+    // Reset lazy-body state and (re)create the IntersectionObserver. The
+    // `innerHTML = ''` above detached every previously-observed body, so a
+    // stale observer would hold dead references and never fire — tear it down
+    // and start fresh for this render generation. This runs for every render
+    // path (initial load, whitespace toggle, scope change) since they all
+    // funnel through renderDiff().
+    this._teardownFileBodyObserver();
+    this._lazyFileBodies = new Map();
+    this._fileBodyObserver = this._createFileBodyObserver();
+
     // Use changed_files array from API
     const files = pr.changed_files || pr.files || [];
 
@@ -3050,9 +3321,8 @@ class PRManager {
         }
       });
 
-      // Async validate end-of-file gaps - removes any that have no trailing lines
-      // This runs after render to avoid blocking initial display
-      this.validatePendingEofGaps();
+      // NOTE: end-of-file gap validation runs per-file inside _renderFileBodyNow
+      // now (bodies render lazily), not once globally here.
     } else {
       diffContainer.innerHTML = '<div class="no-diff">No files changed</div>';
     }
@@ -3061,11 +3331,13 @@ class PRManager {
     this.contextFiles = [];
     this.loadContextFiles();
 
-    // Kick off hunk-summary hashing + load (Phase 5). Fire-and-forget — the
-    // diff is fully usable while summaries arrive asynchronously.
+    // Fetch hunk summaries (Phase 5). Fire-and-forget — the diff is fully
+    // usable while summaries arrive asynchronously. Anchors are wired lazily
+    // as each file body renders (_registerHunkAnchorsForFile); this just loads
+    // the server's summary map and applies it to whatever has rendered so far.
     if (this.hunkSummaryRenderer) {
-      this._kickOffHunkSummaries().catch((err) => {
-        console.warn('[HunkSummary] kickoff failed:', err);
+      this._fetchHunkSummaryMap().catch((err) => {
+        console.warn('[HunkSummary] summary fetch failed:', err);
       });
     }
 
@@ -3174,8 +3446,8 @@ class PRManager {
 
       // Per-file hunk-summary toggle. Mirrors the toolbar toggle but scoped to
       // one file. Disabled (greyed) when no summaries exist yet for this file;
-      // _applyHunkSummaries / _kickOffHunkSummaries re-enable it as soon as
-      // hashes for this file are recorded (so a summary that arrives later
+      // _applyHunkSummaries / _registerHunkAnchorsForFile re-enable it as soon
+      // as hashes for this file are recorded (so a summary that arrives later
       // doesn't get hidden behind a permanently-disabled button).
       // Gated on `_summariesEnabled`: skipped entirely when /api/config has
       // already reported the feature is off; created hidden + revealed later
@@ -3210,21 +3482,13 @@ class PRManager {
       }
     }
 
-    // Create diff table
+    // Create diff table with an EMPTY tbody. The rows are NOT rendered here —
+    // see the lazy-body machinery below. This is the core large-PR perf fix:
+    // building + syntax-highlighting every line of every (often collapsed)
+    // file up front froze the browser on big diffs.
     const table = document.createElement('table');
     table.className = 'd2h-diff-table';
-
     const tbody = document.createElement('tbody');
-
-    // Parse the diff content
-    if (file.patch) {
-      this.renderPatch(tbody, file.patch, file.file, file.hunk_hashes || null);
-    } else if (file.binary) {
-      const row = document.createElement('tr');
-      row.innerHTML = '<td colspan="2" class="binary-file">Binary file</td>';
-      tbody.appendChild(row);
-    }
-
     table.appendChild(tbody);
 
     // Wrap table in a scrollable container for horizontal scroll of long code lines
@@ -3234,9 +3498,197 @@ class PRManager {
     fileBody.appendChild(table);
     wrapper.appendChild(fileBody);
 
+    // Reserve approximate height for EXPANDED-but-not-yet-rendered bodies so
+    // the scrollbar stays roughly stable as the user scrolls and bodies fill
+    // in. Collapsed bodies are `display:none`, so they contribute no height
+    // and need no placeholder. Cleared once the body actually renders.
+    if (!isCollapsed && file.patch) {
+      const approxLines = file.patch.split('\n').length;
+      fileBody.style.minHeight = (approxLines * PRManager.APPROX_DIFF_LINE_PX) + 'px';
+    }
+
+    // Register the lazy entry. `gen` lets _renderFileBodyNow detect a body
+    // left over from a superseded render and skip anchor registration.
+    this._lazyFileBodies.set(file.file, {
+      fileName: file.file,
+      patch: file.patch || null,
+      binary: !!file.binary,
+      hunkHashes: file.hunk_hashes || null,
+      fileBody,
+      wrapper,
+      rendered: false,
+      renderPromise: null,
+      gen: this._renderGen
+    });
+
+    // Observe the body so it renders as it nears the viewport. Collapsed
+    // bodies (display:none) never intersect → stay unrendered until expanded.
+    if ((file.patch || file.binary) && this._fileBodyObserver) {
+      this._fileBodyObserver.observe(fileBody);
+    }
+
     return wrapper;
   }
 
+  /**
+   * Approximate rendered height (px) of one diff line row. Used only to
+   * reserve placeholder height for expanded-but-unrendered file bodies so the
+   * scrollbar doesn't jump as lazy bodies fill in. Errs slightly high.
+   */
+  static get APPROX_DIFF_LINE_PX() { return 20; }
+
+  /**
+   * Create the IntersectionObserver that renders file bodies as they approach
+   * the viewport. One instance per render generation; recreated in renderDiff.
+   * Returns null where IntersectionObserver is unavailable (e.g. jsdom unit
+   * tests) — bodies then render only on demand via ensureFileBodyRendered().
+   * @returns {IntersectionObserver|null}
+   */
+  _createFileBodyObserver() {
+    if (typeof IntersectionObserver === 'undefined') return null;
+    // `.diff-view` is the vertical scroll container (see pr.css). Fall back to
+    // the viewport when it can't be resolved.
+    const root = document.querySelector('.diff-view') || null;
+    return new IntersectionObserver((entries, observer) => {
+      for (const ioEntry of entries) {
+        if (!ioEntry.isIntersecting) continue;
+        const lazyEntry = this._lazyFileBodyForElement(ioEntry.target);
+        observer.unobserve(ioEntry.target);
+        if (lazyEntry) this._renderFileBodyNow(lazyEntry);
+      }
+    }, { root, rootMargin: '800px 0px', threshold: 0 });
+  }
+
+  /**
+   * Disconnect and drop the current file-body observer, if any.
+   */
+  _teardownFileBodyObserver() {
+    if (this._fileBodyObserver) {
+      this._fileBodyObserver.disconnect();
+      this._fileBodyObserver = null;
+    }
+  }
+
+  /**
+   * Resolve the lazy entry for a `.d2h-file-body` element via its wrapper's
+   * data-file-name. Returns null if not a known lazy body.
+   * @param {Element} bodyEl
+   * @returns {object|null}
+   */
+  _lazyFileBodyForElement(bodyEl) {
+    if (!this._lazyFileBodies) return null;
+    const wrapper = bodyEl?.closest?.('.d2h-file-wrapper');
+    const filePath = wrapper?.dataset?.fileName;
+    if (!filePath) return null;
+    return this._lazyFileBodies.get(filePath) || null;
+  }
+
+  /**
+   * Ensure a file's diff-line body is rendered into the DOM, rendering it now
+   * if it hasn't been. Idempotent and cheap when already rendered. Every code
+   * path that scans a file's `<tr>` rows (comment/suggestion anchoring, gap
+   * expansion, scroll-to-file, expand) must await this first, because a lazy
+   * body has zero rows until rendered.
+   * @param {string|Element} fileOrWrapper - file path, file body, or wrapper
+   * @returns {Promise<HTMLElement|null>} the file body, or null if unknown
+   */
+  async ensureFileBodyRendered(fileOrWrapper) {
+    // No lazy map (e.g. called before renderDiff, or a non-lazy render path) →
+    // treat the body as already present and let callers scan as before.
+    if (!this._lazyFileBodies) return null;
+    let entry = null;
+    if (typeof fileOrWrapper === 'string') {
+      entry = this._lazyFileBodies.get(fileOrWrapper) || null;
+      if (!entry) {
+        // The map is keyed by the canonical `file.file` value, but callers
+        // (AI suggestions, external comments, tour stops) may pass a
+        // non-canonical path form. findFileElement normalizes './', '/', and
+        // git rename syntax ('{old => new}') against data-file-name, so
+        // resolve the wrapper first and retry with its canonical name. This
+        // keeps the strict Map.get fast path while tolerating the same path
+        // variants the rest of the diff UI accepts — without it the body
+        // stays unrendered and the downstream row scan sees zero <tr> rows.
+        const wrapper = this.findFileElement?.(fileOrWrapper);
+        const canonicalFile = wrapper?.dataset?.fileName;
+        if (canonicalFile) entry = this._lazyFileBodies.get(canonicalFile) || null;
+      }
+    } else if (fileOrWrapper && fileOrWrapper.nodeType === 1) {
+      entry = this._lazyFileBodyForElement(fileOrWrapper)
+        || (this._lazyFileBodies.get(fileOrWrapper.dataset?.fileName) || null);
+    }
+    if (!entry) return null;
+    if (entry.rendered) return entry.fileBody;
+    if (entry.renderPromise) return entry.renderPromise;
+    // _renderFileBodyNow is synchronous; wrapping in a resolved promise keeps
+    // the signature async and lets concurrent callers (observer + on-demand)
+    // share one promise so renderPatch runs exactly once.
+    entry.renderPromise = Promise.resolve().then(() => this._renderFileBodyNow(entry));
+    return entry.renderPromise;
+  }
+
+  /**
+   * Synchronously build a file's diff-line body: run renderPatch (or the
+   * binary placeholder), clear the height placeholder, wire hunk-summary
+   * anchors, and validate this file's EOF gap. Idempotent.
+   *
+   * Invariant: there must be NO `await` between the `_pendingHunkRecords`
+   * save and restore below — renderPatch pushes per-hunk anchor records into
+   * the shared `_pendingHunkRecords`, and JS single-threading only guarantees
+   * non-interleaving with other file renders while this stays synchronous.
+   * @param {object} entry - a _lazyFileBodies value
+   * @returns {HTMLElement} the file body element
+   */
+  _renderFileBodyNow(entry) {
+    if (entry.rendered) return entry.fileBody;
+    if (this._fileBodyObserver) this._fileBodyObserver.unobserve(entry.fileBody);
+
+    const tbody = entry.fileBody.querySelector('tbody');
+
+    // Capture only THIS file's hunk anchor records (renderPatch appends to
+    // this._pendingHunkRecords; see invariant above). The swap is wrapped in
+    // try/finally so a renderPatch throw can't leak the temporary buffer: were
+    // the restore skipped, every subsequent file render would append its
+    // anchor records into the stale array, silently cross-wiring
+    // _summaryAnchorsByHash / _summaryHashesByFile for the rest of the session.
+    const prevPending = this._pendingHunkRecords;
+    this._pendingHunkRecords = [];
+    let records;
+    try {
+      if (entry.patch && tbody) {
+        this.renderPatch(tbody, entry.patch, entry.fileName, entry.hunkHashes);
+      } else if (entry.binary && tbody) {
+        const row = document.createElement('tr');
+        row.innerHTML = '<td colspan="2" class="binary-file">Binary file</td>';
+        tbody.appendChild(row);
+      }
+    } finally {
+      records = this._pendingHunkRecords;
+      this._pendingHunkRecords = prevPending;
+    }
+
+    entry.fileBody.style.minHeight = '';
+    entry.rendered = true;
+    entry.renderPromise = null;
+
+    // Skip post-render wiring for a body left over from a superseded render
+    // (its maps were reset and the body is detached). Both anchor registration
+    // and EOF-gap validation are pointless/wasteful for a stale body.
+    if (entry.gen === this._renderGen) {
+      this._registerHunkAnchorsForFile(records);
+      // Validate this file's pending EOF gaps. Pre-lazy-render this was a
+      // single global pass at the end of renderDiff; now it runs per-file as
+      // bodies render. Cheap pre-check first: most files have no pending EOF
+      // gap, so skip the async work (Array.from + Promise.all + per-gap
+      // /file-content fetches) entirely when this body has none. The selector
+      // mirrors the one validatePendingEofGaps scans for.
+      if (entry.fileBody.querySelector('tr.context-expand-row[data-pending-eof-validation="true"]')) {
+        this.validatePendingEofGaps(entry.fileBody);
+      }
+    }
+
+    return entry.fileBody;
+  }
+
   /**
    * Parse and render a unified diff patch
    * @param {HTMLElement} tbody - Table body element
@@ -3389,8 +3841,8 @@ class PRManager {
 
       // Record this hunk's first rendered code row as the anchor for any
       // inline summary annotation. The canonical hash comes from the
-      // backend (`hunkHashes[blockIndex]`); _kickOffHunkSummaries mounts
-      // it as `data-hunk-start` after render finishes so the summary
+      // backend (`hunkHashes[blockIndex]`); _registerHunkAnchorsForFile mounts
+      // it as `data-hunk-start` when this file's body renders so the summary
       // renderer can find the anchor and insert the annotation above it.
       if (this._pendingHunkRecords && firstLineRow) {
         const serverHash = Array.isArray(hunkHashes) ? hunkHashes[blockIndex] || null : null;
@@ -3574,7 +4026,7 @@ class PRManager {
    * Toggle collapse state of a file diff
    * @param {string} filePath - Path of the file
    */
-  toggleFileCollapse(filePath) {
+  async toggleFileCollapse(filePath) {
     const wrapper = this.findFileElement(filePath);
     if (!wrapper) return;
 
@@ -3582,6 +4034,8 @@ class PRManager {
     const header = wrapper.querySelector('.d2h-file-header');
 
     if (isCollapsed) {
+      // Render the body before revealing it (lazy bodies are empty until now).
+      await this.ensureFileBodyRendered(filePath);
       wrapper.classList.remove('collapsed');
       this.collapsedFiles.delete(filePath);
     } else {
@@ -3600,7 +4054,7 @@ class PRManager {
    * @param {string} filePath - Path of the file
    * @param {boolean} isViewed - Whether the file is now viewed
    */
-  toggleFileViewed(filePath, isViewed) {
+  async toggleFileViewed(filePath, isViewed) {
     const wrapper = this.findFileElement(filePath);
 
     if (isViewed) {
@@ -3618,6 +4072,8 @@ class PRManager {
       this.viewedFiles.delete(filePath);
       // Auto-expand when unchecking viewed (match GitHub behavior)
       if (wrapper && wrapper.classList.contains('collapsed')) {
+        // Render the body before revealing it (lazy bodies are empty until now).
+        await this.ensureFileBodyRendered(filePath);
         wrapper.classList.remove('collapsed');
         this.collapsedFiles.delete(filePath);
         const header = wrapper.querySelector('.d2h-file-header');
@@ -3743,7 +4199,7 @@ class PRManager {
    * @deprecated Use toggleFileCollapse instead - kept for backward compatibility
    */
   toggleGeneratedFile(filePath) {
-    this.toggleFileCollapse(filePath);
+    return this.toggleFileCollapse(filePath);
   }
 
   /**
@@ -3772,9 +4228,12 @@ class PRManager {
    * Validate pending end-of-file gaps asynchronously
    * Removes gap rows where there are no trailing lines to expand
    * This ensures users don't see expand buttons that do nothing
+   * @param {ParentNode} [root=document] - Scope the search. With lazy bodies,
+   *   _renderFileBodyNow passes the just-rendered file body so each file's EOF
+   *   gap is validated as it renders (rather than one global post-render pass).
    */
-  async validatePendingEofGaps() {
-    const pendingGaps = document.querySelectorAll('tr.context-expand-row[data-pending-eof-validation="true"]');
+  async validatePendingEofGaps(root = document) {
+    const pendingGaps = root.querySelectorAll('tr.context-expand-row[data-pending-eof-validation="true"]');
 
     // Process all pending gaps in parallel for efficiency
     const validationPromises = Array.from(pendingGaps).map(async (gapRow) => {
@@ -4139,11 +4598,14 @@ class PRManager {
       return false;
     }
 
+    // Render the body first — gap rows (and code rows) only exist once the
+    // lazy body has rendered. Without this the gap query below returns nothing.
+    await this.ensureFileBodyRendered(file);
+
     // Check if file is collapsed (generated files)
     if (fileElement.classList.contains('collapsed')) {
       debugLog?.('expandForSuggestion', 'File is collapsed, expanding first');
-      this.toggleGeneratedFile(file);
-      await new Promise(resolve => setTimeout(resolve, 50));
+      await this.toggleGeneratedFile(file);
     }
 
     // Find the gap section containing the target lines using the shared module
@@ -4227,6 +4689,12 @@ class PRManager {
       const fileElement = this.findFileElement(file);
       if (!fileElement) continue;
 
+      // Render the file body first — with lazy rendering an unrendered file
+      // has zero rows, so the visibility scan below would always miss and the
+      // line would be treated as "hidden in a gap" (then gap-expanded against
+      // zero gap rows → silent anchor failure).
+      await this.ensureFileBodyRendered(file);
+
       // Check if any line in the range is already visible
       let anyLineVisible = false;
       const lineRows = fileElement.querySelectorAll('tr');
@@ -5901,9 +6369,20 @@ class PRManager {
     collapsedBtn.addEventListener('click', () => toggleSidebar(false));
   }
 
-  scrollToFile(filePath) {
+  async scrollToFile(filePath) {
     const fileWrapper = this.findFileElement(filePath);
     if (fileWrapper) {
+      // Render the body so the scroll target has its real height (an empty
+      // lazy body would land the scroll at the wrong offset for expanded
+      // files). Skip it for collapsed files: their body is display:none
+      // (zero height) and `block: 'start'` aligns the header regardless, so
+      // force-rendering would only pay the full renderPatch + per-line
+      // highlight cost for content that stays hidden. scrollToFile does no
+      // post-render row scan, so gating on `!collapsed` is safe; expanding
+      // later still renders on demand via toggleFileCollapse.
+      if (!fileWrapper.classList.contains('collapsed')) {
+        await this.ensureFileBodyRendered(filePath);
+      }
       fileWrapper.scrollIntoView({ behavior: 'smooth', block: 'start' });
     }
   }
@@ -6328,11 +6807,15 @@ class PRManager {
         : this._fetchStaleness(owner, repo, number);
       this._stalenessPromise = null; // consume it
 
+      // Pass owner+repo to /api/config so has_github_token reflects the
+      // repo's actual auth (covers repo-scoped tokens, token_command, and
+      // alt-host bindings — not just the global github_token).
+      const configUrl = `/api/config?owner=${encodeURIComponent(owner)}&repo=${encodeURIComponent(repo)}`;
       const [staleResult, repoSettings, reviewSettings, appConfig] = await Promise.all([
         staleCheckWithTimeout,
         this.fetchRepoSettings(),
         this.fetchLastReviewSettings(),
-        fetch('/api/config').then(r => r.ok ? r.json() : {}).catch(() => ({}))
+        fetch(configUrl).then(r => r.ok ? r.json() : {}).catch(() => ({}))
       ]);
       console.debug(`[Analyze] parallel-fetch (stale+settings): ${Math.round(performance.now() - _tParallel0)}ms`);
 
@@ -6378,9 +6861,14 @@ class PRManager {
 
       const lastCouncilId = reviewSettings.last_council_id;
 
-      // Determine the model and provider to use (priority: repo default > defaults)
-      const currentModel = repoSettings?.default_model || 'opus';
-      const currentProvider = repoSettings?.default_provider || 'claude';
+      // Resolve provider and model as a MATCHED pair so the council/advanced tabs
+      // are never seeded with a cross-provider model (e.g. gemini + opus), which
+      // would blank the model <select> and be rejected by the backend.
+      const providersInfo = await this._getProvidersInfo();
+      const { provider: currentProvider, model: currentModel } = window.resolveProviderModelPair([
+        { provider: repoSettings?.default_provider, model: repoSettings?.default_model },
+        { provider: appConfig.default_provider, model: appConfig.default_model }
+      ], providersInfo);
 
       // Determine default tab (priority: localStorage > repo settings > 'single')
       const tabStorageKey = PRManager.getRepoStorageKey('pair-review-tab', owner, repo);
@@ -6408,7 +6896,12 @@ class PRManager {
         lastCouncilId,
         defaultCouncilId: repoSettings?.default_council_id || null,
         hasPr: true,
-        hasGithubToken: Boolean(appConfig.has_github_token)
+        // Use the repo-aware field (we passed owner+repo to /api/config).
+        // Fall back to the global field only if the response was malformed
+        // or the params were rejected — defensive, should not happen.
+        hasGithubToken: Boolean(
+          appConfig.has_github_token ?? appConfig.has_global_github_token
+        )
       });
 
       // If user cancelled, do nothing
@@ -6554,7 +7047,10 @@ class PRManager {
   showWorktreeNotFoundError(owner, repo, number) {
     let setupUrl = `/pr/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/${encodeURIComponent(number)}`;
     if (this._autoAnalyzeRequested) {
-      setupUrl += '?analyze=true';
+      const params = new URLSearchParams({ analyze: 'true' });
+      const analysisConfigId = new URLSearchParams(window.location.search).get('analysisConfigId');
+      if (analysisConfigId) params.set('analysisConfigId', analysisConfigId);
+      setupUrl += `?${params.toString()}`;
     }
     const container = document.getElementById('pr-container');
     if (container) {