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

package/src/routes/local.js

@@ -24,8 +24,10 @@ const { broadcastReviewEvent } = require('../events/review-events');
 const { fireHooks, hasHooks } = require('../hooks/hook-runner');
 const { buildReviewStartedPayload, buildReviewLoadedPayload, buildAnalysisStartedPayload, buildAnalysisCompletedPayload, getCachedUser } = require('../hooks/payloads');
 const { mergeInstructions } = require('../utils/instructions');
-const { getGitHubToken, resolveLoadSkills, buildCouncilProviderOverrides } = require('../config');
-const { generateScopedDiff, computeScopedDigest, getBranchCommitCount, getFirstCommitSubject, detectAndBuildBranchInfo, findMergeBase, getCurrentBranch, getRepositoryName } = require('../local-review');
+const { getGitHubToken, resolveLoadSkills, buildCouncilProviderOverrides, getSummaryEnabled, getTourEnabled } = require('../config');
+const { backgroundQueue } = require('../ai/background-queue');
+const localReview = require('../local-review');
+const { generateScopedDiff, computeScopedDigest, getBranchCommitCount, getFirstCommitSubject, detectAndBuildBranchInfo, findMergeBase, getCurrentBranch, getRepositoryName } = localReview;
 const { STOPS, isValidScope, normalizeScope, reviewScope, includesBranch, DEFAULT_SCOPE } = require('../local-scope');
 const { getGeneratedFilePatterns } = require('../git/gitattributes');
 const { getShaAbbrevLength } = require('../git/sha-abbrev');
@@ -36,6 +38,12 @@ const { getDefaultBranch, tryGraphiteState } = require('../git/base-branch');
 const { CommentRepository } = require('../database');
 const { runExecutableAnalysis, getChangedFiles } = require('./executable-analysis');
 const { rejectUrlLikeLocalReviewPath } = require('../utils/local-path-input');
+const reviewsRouter = require('./reviews');
+const summaryGenerator = require('../ai/summary-generator');
+const tourGenerator = require('../ai/tour-generator');
+const { parseUnifiedDiffPatches } = require('../utils/diff-file-list');
+const { parseHunks } = require('../utils/diff-hunks');
+const { hashHunk } = require('../ai/hunk-hashing');
 const {
   activeAnalyses,
   localReviewDiffs,
@@ -489,10 +497,13 @@ router.post('/api/local/start', async (req, res) => {
     const digest = await computeScopedDigest(repoPath, scopeStart, scopeEnd);
 
     // Branch detection: when no uncommitted changes, check if branch has commits ahead
+    const { resolveHostBinding: _resolveHostBindingForBranch } = require('../config');
+    const branchBinding = repository ? _resolveHostBindingForBranch(repository, config) : null;
     const branchInfo = await detectAndBuildBranchInfo(repoPath, branch, {
       repository,
       diff,
-      githubToken: getGitHubToken(config),
+      githubToken: branchBinding?.token || getGitHubToken(config),
+      hostBinding: branchBinding,
       enableGraphite: config.enable_graphite === true
     });
 
@@ -519,6 +530,30 @@ router.post('/api/local/start', async (req, res) => {
       }
     });
 
+    (async () => {
+      await summaryGenerator.kickOffSummaryJob({
+        db,
+        config,
+        reviewId: sessionId,
+        diffText: diff,
+        worktreePath: repoPath,
+        reviewContext: { prTitle: branch },
+        trigger: 'auto'
+      });
+    })().catch((err) => logger.warn(`Hunk summary job failed for review ${sessionId}: ${err.message}`));
+
+    (async () => {
+      await tourGenerator.kickOffTourJob({
+        db,
+        config,
+        reviewId: sessionId,
+        diffText: diff,
+        worktreePath: repoPath,
+        reviewContext: { prTitle: branch },
+        trigger: 'auto'
+      });
+    })().catch((err) => logger.warn(`Tour job failed for review ${sessionId}: ${err.message}`));
+
   } catch (error) {
     logger.error(`Error starting local review: ${error.message}`);
     res.status(500).json({
@@ -684,13 +719,18 @@ router.get('/api/local/:reviewId', async (req, res) => {
         && branchName && branchName !== 'HEAD' && branchName !== 'unknown'
         && repositoryName && repositoryName.includes('/')) {
       const bgConfig = req.app.get('config') || {};
-      const bgToken = getGitHubToken(bgConfig);
+      const { resolveHostBinding: _resolveHostBinding } = require('../config');
+      const bgBinding = _resolveHostBinding(repositoryName, bgConfig);
+      const bgToken = bgBinding.token;
       const bgT0 = Date.now();
       const { detectBaseBranch } = require('../git/base-branch');
       detectBaseBranch(review.local_path, branchName, {
         repository: repositoryName,
         enableGraphite: bgConfig.enable_graphite === true,
-        _deps: bgToken ? { getGitHubToken: () => bgToken } : undefined
+        _deps: bgToken ? {
+          getGitHubToken: () => bgToken,
+          getHostBinding: () => bgBinding
+        } : undefined
       }).then(detection => {
         if (detection && detection.baseBranch) {
           return reviewRepo.updateReview(reviewId, { local_base_branch: detection.baseBranch });
@@ -719,6 +759,48 @@ router.get('/api/local/:reviewId', async (req, res) => {
       }).catch(err => { logger.warn(`Review hook failed: ${err.message}`); });
     }
 
+    // Background: re-trigger hunk summary + tour generation on review load.
+    // Self-invoked so any rejection here cannot reach the outer try/catch
+    // and call res.status(500) on an already-flushed response.
+    (async () => {
+      let bgDiffText = getLocalReviewDiff(reviewId)?.diff;
+      if (!bgDiffText) {
+        const persistedDiff = await reviewRepo.getLocalDiff(reviewId);
+        bgDiffText = persistedDiff?.diff;
+      }
+      if (!bgDiffText) {
+        logger.debug(`Skipping background AI kickoff for review ${reviewId}: no diff available`);
+        return;
+      }
+      const reviewContext = { prTitle: review.name || branchName };
+      const results = await Promise.allSettled([
+        summaryGenerator.kickOffSummaryJob({
+          db,
+          config: localConfig,
+          reviewId,
+          diffText: bgDiffText,
+          worktreePath: review.local_path,
+          reviewContext,
+          trigger: 'auto'
+        }),
+        tourGenerator.kickOffTourJob({
+          db,
+          config: localConfig,
+          reviewId,
+          diffText: bgDiffText,
+          worktreePath: review.local_path,
+          reviewContext,
+          trigger: 'auto'
+        })
+      ]);
+      const labels = ['Hunk summary', 'Tour'];
+      results.forEach((r, i) => {
+        if (r.status === 'rejected') {
+          logger.warn(`${labels[i]} kickoff failed for review ${reviewId}: ${r.reason?.message || r.reason}`);
+        }
+      });
+    })().catch((err) => logger.warn(`Background AI kickoff failed for review ${reviewId}: ${err.message}`));
+
   } catch (error) {
     logger.error('Error fetching local review:', error.stack || error.message);
     res.status(500).json({
@@ -805,7 +887,11 @@ router.get('/api/local/:reviewId/diff', async (req, res) => {
 
     if ((hideWhitespace || baseBranchOverride) && review.local_path) {
       try {
-        const wsResult = await generateScopedDiff(review.local_path, scopeStart, scopeEnd, baseBranch, { hideWhitespace });
+        // Call via the module namespace so tests can stub `generateScopedDiff`
+        // with `vi.spyOn(localReview, 'generateScopedDiff')`. The destructured
+        // top-level binding is captured at require time and would not honor a
+        // spy.
+        const wsResult = await localReview.generateScopedDiff(review.local_path, scopeStart, scopeEnd, baseBranch, { hideWhitespace });
         diffData = { diff: wsResult.diff, stats: wsResult.stats };
       } catch (wsError) {
         logger.warn(`Could not generate diff for review #${reviewId}: ${wsError.message}`);
@@ -854,6 +940,52 @@ router.get('/api/local/:reviewId/diff', async (req, res) => {
       }
     }
 
+    // Compute per-file hunk hashes for the hunk-summary feature.
+    //
+    // The frontend stamps these hashes onto rendered hunks BY INDEX
+    // (`hunkHashes[blockIndex]`), so the array MUST be aligned to the
+    // diff that was actually returned to the client. Two cases:
+    //
+    //   1. `?w=1`: `git diff -w` only DROPS whitespace-only hunks; it
+    //      never rewrites kept hunks. The frontend renderPatch length
+    //      guard catches the drop case (mismatch between canonical hash
+    //      count and rendered block count) and bails. So for kept hunks
+    //      the canonical hash still identifies the right rendered hunk
+    //      AND matches the persisted summary key — fall back to the
+    //      canonical diff here for hash computation.
+    //
+    //   2. `?base=<branch>`: regen produces a DIFFERENT diff against a
+    //      different base. Hunk counts may match by coincidence, but the
+    //      content can differ. Hashing the canonical diff would mount a
+    //      summary onto an override hunk whose code it doesn't describe
+    //      — silent and wrong. Hash the override diff instead so:
+    //        - identical-content hunks (hash equals canonical) still
+    //          match a persisted summary and mount correctly;
+    //        - divergent-content hunks miss (hash mismatch) and stay
+    //          unmounted — visibly missing rather than silently wrong.
+    let canonicalDiff = diffContent;
+    if (hideWhitespace && !baseBranchOverride) {
+      const cached = getLocalReviewDiff(reviewId);
+      if (cached?.diff) {
+        canonicalDiff = cached.diff;
+      } else {
+        const persisted = await reviewRepo.getLocalDiff(reviewId);
+        if (persisted?.diff) canonicalDiff = persisted.diff;
+      }
+    }
+    const hunkHashesByFile = {};
+    if (canonicalDiff) {
+      const filePatchMap = parseUnifiedDiffPatches(canonicalDiff);
+      for (const [filePath, filePatch] of filePatchMap.entries()) {
+        const hunks = parseHunks(filePatch);
+        if (hunks.length > 0) {
+          hunkHashesByFile[filePath] = hunks.map((h) =>
+            hashHunk(filePath, `${h.header}\n${h.lines.join('\n')}`)
+          );
+        }
+      }
+    }
+
     const diffElapsed = Date.now() - tEndpoint;
     if (diffElapsed > 200) {
       logger.debug(`[perf] diff#${reviewId} took ${diffElapsed}ms (threshold: 200ms)`);
@@ -861,6 +993,7 @@ router.get('/api/local/:reviewId/diff', async (req, res) => {
     res.json({
       diff: diffContent || '',
       generated_files: generatedFiles,
+      hunk_hashes_by_file: hunkHashesByFile,
       stats: {
         trackedChanges: stats?.trackedChanges || 0,
         untrackedFiles: stats?.untrackedFiles || 0,
@@ -1325,7 +1458,9 @@ router.post('/api/local/:reviewId/analyses', async (req, res) => {
 
     const progressCallback = createProgressCallback(analysisId);
 
-    // Start analysis asynchronously (skipRunCreation since we created the record above; also passes changedFiles for local mode path validation, tier for prompt selection, and skipLevel3 flag)
+    // Start analysis asynchronously (skipRunCreation since we created the record above; also passes changedFiles for local mode path validation, tier for prompt selection, and skipLevel3 flag).
+    // Local mode has no associated GitHub PR, so githubClient is intentionally omitted —
+    // the analyzer drops the GitHub dedup section when no client is supplied.
     analyzer.analyzeLevel1(reviewId, localPath, localMetadata, progressCallback, { globalInstructions, repoInstructions, requestInstructions }, changedFiles, { analysisId, runId, skipRunCreation: true, tier, skipLevel3: requestSkipLevel3, enabledLevels: levelsConfig, excludePrevious, serverPort: req.socket.localPort })
       .then(async result => {
         logger.section('Local Analysis Results');
@@ -1605,6 +1740,25 @@ router.post('/api/local/:reviewId/refresh', async (req, res) => {
       }
     });
 
+    // Re-kick the summary and tour jobs against the fresh diff. Each kickoff
+    // is dedup'd by digest (summaries) or hash (tour); a no-op when the
+    // canonical diff is unchanged (e.g. user clicked refresh but nothing
+    // upstream changed). When the digest IS new, the kickoffs auto-cancel
+    // the stale in-flight job before enqueueing the fresh one — see
+    // kickOffSummaryJob / kickOffTourJob.
+    const config = req.app.get('config') || {};
+    const reviewContext = { prTitle: branchName || review.local_head_branch || undefined };
+    (async () => {
+      await summaryGenerator.kickOffSummaryJob({
+        db, config, reviewId, diffText: diff, worktreePath: localPath, reviewContext, trigger: 'auto'
+      });
+    })().catch((err) => logger.warn(`Hunk summary job failed for review ${reviewId}: ${err.message}`));
+    (async () => {
+      await tourGenerator.kickOffTourJob({
+        db, config, reviewId, diffText: diff, worktreePath: localPath, reviewContext, trigger: 'auto'
+      });
+    })().catch((err) => logger.warn(`Tour job failed for review ${reviewId}: ${err.message}`));
+
   } catch (error) {
     logger.error('Error refreshing local diff:', error);
     res.status(500).json({
@@ -1683,7 +1837,29 @@ router.post('/api/local/:reviewId/resolve-head-change', async (req, res) => {
       // branch-ahead commit, making the Branch scope stop selectable.
       const branchAvailable = isBranchAvailable(headBranch, scopeStart, localPath);
 
-      return res.json({ success: true, action: 'updated', branchAvailable });
+      res.json({ success: true, action: 'updated', branchAvailable });
+
+      // Re-kick the summary and tour jobs against the freshly-recomputed diff.
+      // The frontend's _resolveHeadChange path applies the refreshed diff in
+      // place via GET /diff (which is read-only and does NOT enqueue), so
+      // without an explicit kickoff here the in-flight stale job from the
+      // previous HEAD would keep burning tokens against a now-stale diff.
+      // Each kickoff is dedup'd by digest/hash; a no-op when the recomputed
+      // diff matches. When the digest IS new, the kickoffs auto-cancel the
+      // stale in-flight job before enqueueing the fresh one.
+      const config = req.app.get('config') || {};
+      const reviewContext = { prTitle: headBranch || review.local_head_branch || undefined };
+      (async () => {
+        await summaryGenerator.kickOffSummaryJob({
+          db, config, reviewId, diffText: scopedResult.diff, worktreePath: localPath, reviewContext, trigger: 'auto'
+        });
+      })().catch((err) => logger.warn(`Hunk summary job failed for review ${reviewId}: ${err.message}`));
+      (async () => {
+        await tourGenerator.kickOffTourJob({
+          db, config, reviewId, diffText: scopedResult.diff, worktreePath: localPath, reviewContext, trigger: 'auto'
+        });
+      })().catch((err) => logger.warn(`Tour job failed for review ${reviewId}: ${err.message}`));
+      return;
     }
 
     // action === 'new-session'
@@ -1774,11 +1950,16 @@ router.post('/api/local/:reviewId/set-scope', async (req, res) => {
         } else {
           const { detectBaseBranch } = require('../git/base-branch');
           const config = req.app.get('config') || {};
-          const token = getGitHubToken(config);
+          const { resolveHostBinding: _resolveHostBinding } = require('../config');
+          const localBinding = _resolveHostBinding(review.repository, config);
+          const token = localBinding.token;
           const detection = await detectBaseBranch(localPath, currentBranch, {
             repository: review.repository,
             enableGraphite: config.enable_graphite === true,
-            _deps: token ? { getGitHubToken: () => token } : undefined
+            _deps: token ? {
+              getGitHubToken: () => token,
+              getHostBinding: () => localBinding
+            } : undefined
           });
           if (!detection) {
             return res.status(400).json({ error: 'Could not detect base branch' });
@@ -1839,6 +2020,23 @@ router.post('/api/local/:reviewId/set-scope', async (req, res) => {
       }
     });
 
+    // Re-kick the summary and tour jobs against the freshly-scoped diff.
+    // Each kickoff is dedup'd by diff digest/hash; when the scope change
+    // actually produces a different diff, the kickoffs auto-cancel the
+    // stale in-flight job before enqueueing the fresh one.
+    const config = req.app.get('config') || {};
+    const reviewContext = { prTitle: currentBranch || review.local_head_branch || undefined };
+    (async () => {
+      await summaryGenerator.kickOffSummaryJob({
+        db, config, reviewId, diffText: diff, worktreePath: localPath, reviewContext, trigger: 'auto'
+      });
+    })().catch((err) => logger.warn(`Hunk summary job failed for review ${reviewId}: ${err.message}`));
+    (async () => {
+      await tourGenerator.kickOffTourJob({
+        db, config, reviewId, diffText: diff, worktreePath: localPath, reviewContext, trigger: 'auto'
+      });
+    })().catch((err) => logger.warn(`Tour job failed for review ${reviewId}: ${err.message}`));
+
   } catch (error) {
     logger.error(`Error setting scope: ${error.message}`);
     res.status(500).json({ error: 'Failed to set scope: ' + error.message });
@@ -2074,11 +2272,19 @@ router.post('/api/local/:reviewId/analyses/council', async (req, res) => {
       baseBranch: review.local_base_branch || null,
     });
 
-    // Generate and cache diff
+    // Generate and cache diff. Hoist the result out of the try so we can also
+    // persist it to `local_diffs` below (after reviewRepo is constructed) — the
+    // council path previously cached the diff in-memory only, which left the
+    // manual tour/summary buttons reporting a false "no-diff" after a restart.
+    let councilDiff = null;
+    let councilStats = null;
+    let councilDigest = null;
     try {
       const diffResult = await generateScopedDiff(localPath, councilScopeStart, councilScopeEnd, review.local_base_branch);
-      const digest = await computeScopedDigest(localPath, councilScopeStart, councilScopeEnd);
-      setLocalReviewDiff(reviewId, { diff: diffResult.diff, stats: diffResult.stats, digest });
+      councilDigest = await computeScopedDigest(localPath, councilScopeStart, councilScopeEnd);
+      councilDiff = diffResult.diff;
+      councilStats = diffResult.stats;
+      setLocalReviewDiff(reviewId, { diff: councilDiff, stats: councilStats, digest: councilDigest });
     } catch (diffError) {
       logger.warn(`Could not generate diff for local council review ${reviewId}: ${diffError.message}`);
     }
@@ -2086,6 +2292,16 @@ router.post('/api/local/:reviewId/analyses/council', async (req, res) => {
     // Resolve instructions
     const repoSettingsRepo = new RepoSettingsRepository(db);
     const reviewRepo = new ReviewRepository(db);
+
+    // Durably persist the diff so it survives a restart and the manual
+    // tour/summary buttons can find it (parity with the analysis-push path).
+    if (councilDiff) {
+      try {
+        await reviewRepo.saveLocalDiff(reviewId, { diff: councilDiff, stats: councilStats, digest: councilDigest });
+      } catch (saveError) {
+        logger.warn(`Could not persist diff for local council review ${reviewId}: ${saveError.message}`);
+      }
+    }
     const repoSettings = await repoSettingsRepo.getRepoSettings(review.repository);
     const repoInstructions = repoSettings?.default_instructions || null;
     const requestInstructions = rawInstructions?.trim() || null;
@@ -2103,6 +2319,8 @@ router.post('/api/local/:reviewId/analyses/council', async (req, res) => {
     const { providerOverrides: councilProviderOverrides, providerOverridesMap: councilProviderOverridesMap } =
       buildCouncilProviderOverrides(localCouncilConfig, review.repository, repoSettings);
 
+    // Local mode has no associated GitHub PR, so we do not pass a githubClient.
+    // The analyzer drops the GitHub dedup section when no client is supplied.
     const { analysisId, runId } = await analysesRouter.launchCouncilAnalysis(
       db,
       {
@@ -2144,4 +2362,183 @@ router.post('/api/local/:reviewId/analyses/council', async (req, res) => {
   }
 });
 
+/**
+ * POST /api/local/:reviewId/jobs/:jobKey/start
+ *
+ * Manually trigger a summary or tour generation job for this local review.
+ * Used by the frontend when `auto_generate` is off and the user clicks the
+ * toolbar button.
+ *
+ * Mirrors the server-side kickoff that runs on local review load, but passes
+ * `trigger: 'manual'` so it bypasses the `auto_generate` gate (the `enabled`
+ * gate still applies — disabled features return 409).
+ *
+ * Request:
+ *   - `jobKey` path param: `summary` or `tour`
+ *
+ * Responses:
+ *   - 200 `{ started: true,  alreadyRunning: false }` — enqueued
+ *   - 200 `{ started: false, alreadyRunning: true  }` — feature on but a job
+ *                                                       is already in flight
+ *                                                       (idempotent no-op)
+ *   - 200 `{ started: false, reason: 'no-diff' }`   — diff is empty
+ *   - 400 `{ error: 'Invalid jobKey' }`             — unknown jobKey
+ *   - 404 `{ error: '...' }`                        — review not found
+ *   - 409 `{ error: '... disabled' }`               — feature disabled in config
+ */
+const LOCAL_MANUAL_START_JOB_KEYS = new Set(['summary', 'tour']);
+
+router.post('/api/local/:reviewId/jobs/:jobKey/start', async (req, res) => {
+  try {
+    const reviewId = parseInt(req.params.reviewId, 10);
+    if (!Number.isInteger(reviewId) || reviewId <= 0) {
+      return res.status(400).json({ error: 'Invalid review ID' });
+    }
+    const { jobKey } = req.params;
+    if (!LOCAL_MANUAL_START_JOB_KEYS.has(jobKey)) {
+      return res.status(400).json({ error: `Invalid jobKey "${jobKey}" (expected "summary" or "tour")` });
+    }
+
+    const db = req.app.get('db');
+    const config = req.app.get('config') || {};
+
+    if (jobKey === 'summary' && !getSummaryEnabled(config)) {
+      return res.status(409).json({ error: 'Summaries feature is disabled in config' });
+    }
+    if (jobKey === 'tour' && !getTourEnabled(config)) {
+      return res.status(409).json({ error: 'Tours feature is disabled in config' });
+    }
+
+    const reviewRepo = new ReviewRepository(db);
+    const review = await reviewRepo.getLocalReviewById(reviewId);
+    if (!review) {
+      return res.status(404).json({ error: `Local review #${reviewId} not found` });
+    }
+
+    const worktreePath = review.local_path || null;
+
+    // Resolve the diff through the same chain the rest of this file uses, rather
+    // than a DB-only read. Reviews created via the analysis-push, council, or MCP
+    // paths may have a diff only in the in-memory cache (or nowhere yet), so a
+    // DB-only read would falsely report "no-diff" for a review that clearly has
+    // changes. Order: (1) in-memory cache, (2) persisted `local_diffs` row,
+    // (3) regenerate from the live working tree (scope-aware) and persist.
+    let diffText = getLocalReviewDiff(reviewId)?.diff || '';
+
+    if (!diffText) {
+      const persistedDiff = await reviewRepo.getLocalDiff(reviewId);
+      diffText = persistedDiff?.diff || '';
+    }
+
+    if (!diffText && worktreePath) {
+      // Regenerate from the current working tree and persist (in-memory + DB) so
+      // the next read is fast and durable, and so pre-Fix-B reviews self-heal.
+      // Mirrors the council diff block above: on error, log and leave it empty.
+      try {
+        const { start: scopeStart, end: scopeEnd } = reviewScope(review);
+        const hasBranch = includesBranch(scopeStart);
+
+        // Snapshot guard: mirror the HEAD invariant enforced by the refresh-diff
+        // handler (see ~line 1702). For a non-branch review, the persisted diff is
+        // pinned to `local_head_sha`. If HEAD has since moved, regenerating here
+        // would silently re-snapshot the CURRENT worktree onto a row that still
+        // claims the OLDER SHA — a data-consistency hole. So we only regenerate
+        // when HEAD still matches; otherwise we leave diffText empty and let the
+        // `{ started: false, reason: 'no-diff' }` response funnel the user through
+        // the established refresh-diff / resolve-head-change flow. Branch-scoped
+        // reviews persist across HEAD changes, so they always regenerate.
+        let headPinned = true;
+        if (!hasBranch && review.local_head_sha) {
+          // Lazy require keeps getHeadSha stubbable via vi.spyOn in tests.
+          const { getHeadSha } = require('../local-review');
+          const currentHeadSha = await getHeadSha(worktreePath);
+          if (currentHeadSha !== review.local_head_sha) {
+            headPinned = false;
+            logger.warn(`Skipping self-heal diff regen for local review ${reviewId} (${jobKey}): HEAD moved on non-branch review (recorded ${review.local_head_sha}, current ${currentHeadSha}) — funneling through resolve-head-change`);
+          }
+        }
+
+        if (headPinned) {
+          const diffResult = await generateScopedDiff(worktreePath, scopeStart, scopeEnd, review.local_base_branch);
+          diffText = diffResult.diff || '';
+          if (diffText) {
+            const digest = await computeScopedDigest(worktreePath, scopeStart, scopeEnd);
+            setLocalReviewDiff(reviewId, { diff: diffText, stats: diffResult.stats, digest });
+            await reviewRepo.saveLocalDiff(reviewId, { diff: diffText, stats: diffResult.stats, digest });
+          }
+        }
+      } catch (regenError) {
+        // A getHeadSha throw (e.g. missing worktree) lands here: leave diffText
+        // empty so the no-diff response fires, matching prior behavior.
+        logger.warn(`Could not regenerate diff for local review ${reviewId} manual ${jobKey} start: ${regenError.message}`);
+      }
+    }
+
+    if (!diffText || !worktreePath) {
+      return res.json({ started: false, reason: 'no-diff' });
+    }
+
+    const activeJobType = typeof backgroundQueue.findActiveJobType === 'function'
+      ? backgroundQueue.findActiveJobType(reviewId, jobKey === 'summary' ? 'summaries' : 'tour')
+      : null;
+    if (activeJobType) {
+      return res.json({ started: false, alreadyRunning: true });
+    }
+
+    const reviewContext = {
+      prTitle: review.name || review.local_head_branch || undefined
+    };
+
+    if (jobKey === 'summary') {
+      Promise.resolve(summaryGenerator.kickOffSummaryJob({
+        db, config, reviewId, diffText, worktreePath, reviewContext, trigger: 'manual'
+      })).catch((err) => logger.warn(`Manual hunk summary kickoff failed for review ${reviewId}: ${err.message}`));
+    } else {
+      Promise.resolve(tourGenerator.kickOffTourJob({
+        db, config, reviewId, diffText, worktreePath, reviewContext, trigger: 'manual'
+      })).catch((err) => logger.warn(`Manual tour kickoff failed for review ${reviewId}: ${err.message}`));
+    }
+
+    return res.json({ started: true, alreadyRunning: false });
+  } catch (error) {
+    logger.error(`Error starting manual job for local review: ${error.message}`);
+    res.status(500).json({ error: 'Failed to start job: ' + error.message });
+  }
+});
+
+/**
+ * POST /api/local/:reviewId/jobs/:jobKey/cancel
+ *
+ * Local-mode wrapper around the shared cancel handler in reviews.js.
+ * The unified `/api/reviews/:reviewId/jobs/:jobKey/cancel` already works
+ * for local reviews (both modes share the `reviews` table), but exposing
+ * it under both prefixes lets the frontend pick whichever helper matches
+ * its current mode without a special case. See `handleJobCancel` in
+ * `src/routes/reviews.js` for the canonical implementation.
+ */
+router.post('/api/local/:reviewId/jobs/:jobKey/cancel', async (req, res) => {
+  try {
+    const reviewId = parseInt(req.params.reviewId, 10);
+    if (isNaN(reviewId) || reviewId <= 0) {
+      return res.status(400).json({ error: 'Invalid review ID' });
+    }
+    const db = req.app.get('db');
+    // Same shape that validateReviewId attaches — we re-derive here because
+    // local routes don't pass through that middleware by convention.
+    const review = await queryOne(db, 'SELECT * FROM reviews WHERE id = ?', [reviewId]);
+    if (!review) {
+      return res.status(404).json({ error: `Review #${reviewId} not found` });
+    }
+    req.reviewId = reviewId;
+    req.review = review;
+    // await (not return) so any rejection from the delegated handler is
+    // caught by the outer try/catch — Express 4 does not forward rejected
+    // promises from async route handlers.
+    await reviewsRouter.handleJobCancel(req, res);
+  } catch (error) {
+    logger.error(`Error cancelling background job for local review: ${error.message}`);
+    res.status(500).json({ error: 'Failed to cancel background job' });
+  }
+});
+
 module.exports = router;

package/src/routes/mcp.js

@@ -11,19 +11,22 @@ const { getTierForModel } = require('../ai/provider');
 const { TIERS, TIER_ALIASES, resolveTier } = require('../ai/prompts/config');
 const { GitWorktreeManager } = require('../git/worktree');
 const path = require('path');
-const { getCurrentBranch } = require('../local-review');
+const { getCurrentBranch, generateScopedDiff, computeScopedDigest } = require('../local-review');
+const { reviewScope } = require('../local-scope');
 const { normalizeRepository } = require('../utils/paths');
 const logger = require('../utils/logger');
 const { broadcastReviewEvent } = require('../events/review-events');
 const {
   activeAnalyses,
   reviewToAnalysisId,
+  localReviewDiffs,
   determineCompletionInfo,
   broadcastProgress,
   createProgressCallback
 } = require('./shared');
 const { safeParseJson } = require('../utils/safe-parse-json');
-const { resolveLoadSkills } = require('../config');
+const { resolveLoadSkills, resolveHostBinding } = require('../config');
+const { GitHubClient } = require('../github/client');
 
 // All valid tier values: canonical tiers + aliases (for Zod enum validation)
 const ALL_TIER_VALUES = /** @type {[string, ...string[]]} */ ([...TIERS, ...Object.keys(TIER_ALIASES)]);
@@ -557,6 +560,32 @@ function createMCPServer(db, options = {}) {
 
           const review = await reviewRepo.getLocalReviewById(reviewId);
 
+          // Persist the diff so the web UI can display it and the manual
+          // tour/summary buttons work (including after a restart). The MCP path
+          // previously stored the diff only in analysis_runs, leaving no
+          // `local_diffs` row.
+          //
+          // Use the review's recorded scope — not the default-scope wrapper — so
+          // re-using a review that was moved to `staged` or `branch` scope does
+          // not clobber its durable row with a narrower default-scope patch. Set
+          // the in-memory cache alongside the DB row so the cache-first readers
+          // in routes/local.js don't keep serving a stale entry. Non-fatal:
+          // matches the analysis-push path.
+          try {
+            const { start: scopeStart, end: scopeEnd } = reviewScope(review);
+            const diffResult = await generateScopedDiff(
+              localPath,
+              scopeStart,
+              scopeEnd,
+              review.local_base_branch || null
+            );
+            const digest = await computeScopedDigest(localPath, scopeStart, scopeEnd);
+            localReviewDiffs.set(reviewId, { diff: diffResult.diff, stats: diffResult.stats, digest });
+            await reviewRepo.saveLocalDiff(reviewId, { diff: diffResult.diff, stats: diffResult.stats, digest });
+          } catch (diffError) {
+            logger.warn(`Could not generate or persist diff for local review ${reviewId}: ${diffError.message}`);
+          }
+
           // Resolve provider and model
           const repoSettings = repository ? await repoSettingsRepo.getRepoSettings(repository) : null;
           const provider = process.env.PAIR_REVIEW_PROVIDER || repoSettings?.default_provider || config.default_provider || config.provider || 'claude';
@@ -640,7 +669,9 @@ function createMCPServer(db, options = {}) {
             headSha: localHeadSha
           });
 
-          // Launch analysis asynchronously (skipRunCreation since we created the record above)
+          // Launch analysis asynchronously (skipRunCreation since we created the record above).
+          // Local mode has no associated GitHub PR, so githubClient is intentionally
+          // omitted — the analyzer drops the GitHub dedup section when no client is supplied.
           analyzer.analyzeLevel1(reviewId, localPath, localMetadata, progressCallback, { repoInstructions, requestInstructions }, changedFiles, { analysisId, runId, skipRunCreation: true, tier, skipLevel3: args.skipLevel3, excludePrevious: args.excludePrevious, serverPort: (options.port || config.port || 7247) })
             .then(result => handleAnalysisCompletion(analysisId, runId, result, async (r) => {
               if (r.summary) {
@@ -762,6 +793,18 @@ function createMCPServer(db, options = {}) {
           const progressCallback = createProgressCallback(analysisId);
           const tier = resolveTier(args.tier);
 
+          // Build a GitHubClient so the analyzer can pre-fetch existing PR
+          // review comments when args.excludePrevious.github is set. Uses
+          // the repo's binding so alt-host repos route to the right host
+          // with the right token.
+          const prAnalysisBinding = resolveHostBinding(repository, config);
+          const prAnalysisGithubClient = prAnalysisBinding.token
+            ? new GitHubClient(prAnalysisBinding)
+            : undefined;
+          if (prAnalysisGithubClient) {
+            logger.debug(`analyzer githubClient wired for ${owner}/${repo}#${prNumber} (mcp)`);
+          }
+
           logger.log('MCP', `Starting PR analysis: PR #${prNumber} in ${repository}, runId=${runId}`, 'magenta');
 
           // Create DB analysis_runs record just before launching so it's queryable for polling
@@ -779,7 +822,7 @@ function createMCPServer(db, options = {}) {
           });
 
           // Launch analysis asynchronously (skipRunCreation since we created the record above)
-          analyzer.analyzeLevel1(review.id, worktreePath, prMetadata, progressCallback, { repoInstructions, requestInstructions }, null, { analysisId, runId, skipRunCreation: true, tier, skipLevel3: args.skipLevel3, excludePrevious: args.excludePrevious, serverPort: (options.port || config.port || 7247) })
+          analyzer.analyzeLevel1(review.id, worktreePath, prMetadata, progressCallback, { repoInstructions, requestInstructions }, null, { analysisId, runId, skipRunCreation: true, tier, skipLevel3: args.skipLevel3, excludePrevious: args.excludePrevious, serverPort: (options.port || config.port || 7247), githubClient: prAnalysisGithubClient })
             .then(result => handleAnalysisCompletion(analysisId, runId, result, async (r) => {
               try { await prMetadataRepo.updateLastAiRunId(prMetadata.id, r.runId); } catch (_) { /* ignore */ }
               if (r.summary) {