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

package/src/routes/pr.js

@@ -32,7 +32,10 @@ const { broadcastReviewEvent } = require('../events/review-events');
 const { fireHooks, hasHooks } = require('../hooks/hook-runner');
 const { buildReviewStartedPayload, buildReviewLoadedPayload, buildAnalysisStartedPayload, buildAnalysisCompletedPayload, getCachedUser } = require('../hooks/payloads');
 const simpleGit = require('simple-git');
+const { execSync } = require('child_process');
+const { readFileSync } = require('fs');
 const { GIT_DIFF_FLAGS_ARRAY, GIT_DIFF_SUMMARY_FLAGS_ARRAY } = require('../git/diff-flags');
+const { tryGraphiteState, readGraphitePRInfo, enrichStackWithPRInfo } = require('../git/base-branch');
 const {
   activeAnalyses,
   reviewToAnalysisId,
@@ -40,11 +43,15 @@ const {
   determineCompletionInfo,
   broadcastProgress,
   createProgressCallback,
-  parseEnabledLevels
+  parseEnabledLevels,
+  registerProcess: registerProcessForCancellation
 } = require('./shared');
 const { safeParseJson } = require('../utils/safe-parse-json');
 const { validateCouncilConfig, normalizeCouncilConfig } = require('./councils');
 const { TIERS, TIER_ALIASES, VALID_TIERS, resolveTier } = require('../ai/prompts/config');
+const { getProviderClass, createProvider } = require('../ai/provider');
+const { CommentRepository } = require('../database');
+const { runExecutableAnalysis } = require('./executable-analysis');
 const analysesRouter = require('./analyses');
 
 const router = express.Router();
@@ -229,6 +236,25 @@ router.get('/api/pr/:owner/:repo/:number', async (req, res) => {
       ? getShaAbbrevLength(extendedData.worktree_path)
       : DEFAULT_SHA_ABBREV_LENGTH;
 
+    // Detect Graphite stack if enabled
+    let stackData = null;
+    {
+      const stackConfig = req.app.get('config') || {};
+      if (stackConfig.enable_graphite === true && extendedData.worktree_path && prMetadata.head_branch) {
+        try {
+          const graphiteResult = tryGraphiteState(extendedData.worktree_path, prMetadata.head_branch, { execSync, readFileSync });
+          if (graphiteResult?.stack) {
+            const prInfo = readGraphitePRInfo(extendedData.worktree_path, { execSync, readFileSync });
+            stackData = prInfo?.prInfos
+              ? enrichStackWithPRInfo(graphiteResult.stack, prInfo.prInfos)
+              : graphiteResult.stack;
+          }
+        } catch {
+          // Non-fatal — stack detection is an enhancement
+        }
+      }
+    }
+
     // Prepare response
     // Use review.id instead of prMetadata.id to avoid ID collision with local mode
     const response = {
@@ -246,6 +272,7 @@ router.get('/api/pr/:owner/:repo/:number', async (req, res) => {
         head_branch: prMetadata.head_branch,
         head_sha: extendedData.head_sha || null,  // Head commit SHA for GitHub API comments
         node_id: extendedData.node_id || null,  // GraphQL node ID for review submission
+        stack_data: stackData,
         shaAbbrevLength,
         created_at: prMetadata.created_at,
         updated_at: prMetadata.updated_at,
@@ -406,6 +433,22 @@ router.post('/api/pr/:owner/:repo/:number/refresh', async (req, res) => {
     const parsedData = prMetadata.pr_data ? JSON.parse(prMetadata.pr_data) : {};
     const [repoOwner, repoName] = repository.split('/');
 
+    // Detect Graphite stack if enabled
+    let stackData = null;
+    if (config.enable_graphite === true && worktreePath && prData.head_branch) {
+      try {
+        const graphiteResult = tryGraphiteState(worktreePath, prData.head_branch, { execSync, readFileSync });
+        if (graphiteResult?.stack) {
+          const prInfo = readGraphitePRInfo(worktreePath, { execSync, readFileSync });
+          stackData = prInfo?.prInfos
+            ? enrichStackWithPRInfo(graphiteResult.stack, prInfo.prInfos)
+            : graphiteResult.stack;
+        }
+      } catch {
+        // Non-fatal — stack detection is an enhancement
+      }
+    }
+
     // Use review.id instead of prMetadata.id to avoid ID collision with local mode
     const response = {
       success: true,
@@ -420,6 +463,7 @@ router.post('/api/pr/:owner/:repo/:number/refresh', async (req, res) => {
         state: parsedData.state || 'open',
         base_branch: prMetadata.base_branch,
         head_branch: prMetadata.head_branch,
+        stack_data: stackData,
         created_at: prMetadata.created_at,
         updated_at: prMetadata.updated_at,
         file_changes: parsedData.changed_files ? parsedData.changed_files.length : 0,
@@ -692,7 +736,7 @@ router.get('/api/pr/:owner/:repo/:number/diff', async (req, res) => {
     const worktreeRepo = new WorktreeRepository(db);
     const worktreeRecord = await worktreeRepo.findByPR(prNumber, repository);
 
-    // When ?w=1, regenerate the diff from the worktree with whitespace changes hidden
+    // When ?w=1, regenerate the diff from the worktree with whitespace hidden
     const hideWhitespace = req.query.w === '1';
     let diffContent = prData.diff || '';
     let changedFiles = prData.changed_files || [];
@@ -702,24 +746,16 @@ router.get('/api/pr/:owner/:repo/:number/diff', async (req, res) => {
         const worktreePath = worktreeRecord.path;
         await fs.access(worktreePath);
         const git = simpleGit(worktreePath);
+
         const baseSha = prData.base_sha;
         const headSha = prData.head_sha;
 
         if (baseSha && headSha) {
-          // Regenerate diff with -w flag to ignore whitespace changes
-          diffContent = await git.diff([
-            `${baseSha}...${headSha}`,
-            '--unified=3',
-            '-w',
-            ...GIT_DIFF_FLAGS_ARRAY
-          ]);
-
-          // Regenerate changed files stats with -w flag
-          const diffSummary = await git.diffSummary([
-            `${baseSha}...${headSha}`,
-            '-w',
-            ...GIT_DIFF_SUMMARY_FLAGS_ARRAY
-          ]);
+          const diffArgs = [`${baseSha}...${headSha}`, '--unified=3', ...GIT_DIFF_FLAGS_ARRAY, '-w'];
+          diffContent = await git.diff(diffArgs);
+
+          const summaryArgs = [`${baseSha}...${headSha}`, ...GIT_DIFF_SUMMARY_FLAGS_ARRAY, '-w'];
+          const diffSummary = await git.diffSummary(summaryArgs);
           const gitattributes = await getGeneratedFilePatterns(worktreePath);
           changedFiles = diffSummary.files.map(file => {
             const resolvedFile = resolveRenamedFile(file.file);
@@ -739,7 +775,7 @@ router.get('/api/pr/:owner/:repo/:number/diff', async (req, res) => {
           });
         }
       } catch (wsError) {
-        logger.warn(`Could not generate whitespace-filtered diff for PR #${prNumber}: ${wsError.message}`);
+        logger.warn(`Could not generate diff for PR #${prNumber}: ${wsError.message}`);
         // Fall back to cached diff (diffContent and changedFiles already set from prData)
       }
     } else if (worktreeRecord && worktreeRecord.path) {
@@ -756,9 +792,8 @@ router.get('/api/pr/:owner/:repo/:number/diff', async (req, res) => {
       }
     }
 
-    // When hideWhitespace is active and diff was regenerated, compute
-    // aggregate stats from the regenerated changedFiles instead of using
-    // stale cached values from prData.
+    // When diff was regenerated (whitespace), compute aggregate stats from
+    // the regenerated changedFiles instead of using stale cached values from prData.
     const additions = hideWhitespace
       ? changedFiles.reduce((sum, f) => sum + (f.insertions || 0), 0)
       : (prData.additions || 0);
@@ -1459,6 +1494,79 @@ router.post('/api/parse-pr-url', (req, res) => {
 // PR Analysis Routes
 // ==========================================================================
 
+/**
+ * Handle analysis for executable providers in PR mode.
+ * Spawns the external CLI against the PR worktree and maps output to suggestions.
+ */
+async function handleExecutablePRAnalysis(req, res, {
+  reviewId, review, prNumber, owner, repo, repository, worktreePath, prMetadata,
+  selectedProvider, selectedModel, repoInstructions, requestInstructions,
+  combinedInstructions, runId, analysisId, reviewRepo
+}) {
+  const prContext = {
+    number: prNumber, owner, repo,
+    author: prMetadata.author, baseBranch: prMetadata.base_branch, headBranch: prMetadata.head_branch,
+    baseSha: prMetadata.base_sha || null, headSha: prMetadata.head_sha || null,
+  };
+
+  return runExecutableAnalysis(req, res, {
+    reviewId,
+    review,
+    selectedProvider,
+    selectedModel,
+    repoInstructions,
+    requestInstructions,
+    runId,
+    analysisId,
+    repository,
+    reviewType: 'pr',
+    headSha: prMetadata.head_sha,
+    extraInitialStatus: { prNumber }
+  }, {
+    activeAnalyses,
+    reviewToAnalysisId,
+    broadcastProgress,
+    broadcastReviewEvent,
+    registerProcessForCancellation
+  }, {
+    logLabel: `PR #${prNumber}`,
+    buildContext: (_r, { selectedModel: model, requestInstructions: customInstructions }) => ({
+      title: prMetadata.title || `PR #${prNumber}`,
+      description: prMetadata.description || '',
+      cwd: worktreePath,
+      model,
+      baseSha: prMetadata.base_sha || null,
+      headSha: prMetadata.head_sha || null,
+      baseBranch: prMetadata.base_branch || null,
+      headBranch: prMetadata.head_branch || null,
+      customInstructions: customInstructions || null
+    }),
+    buildHookPayload: () => ({
+      mode: 'pr',
+      prContext
+    }),
+    onSuccess: async (db, _runId, { summary }) => {
+      // Update pr_metadata with last_ai_run_id
+      const { PRMetadataRepository } = require('../database');
+      const prMetadataRepo = new PRMetadataRepository(db);
+      try {
+        await prMetadataRepo.updateLastAiRunId(prMetadata.id, _runId);
+      } catch (e) {
+        logger.warn(`Failed to update pr_metadata: ${e.message}`);
+      }
+
+      // Save summary
+      if (summary) {
+        try {
+          await reviewRepo.upsertSummary(prNumber, repository, summary);
+        } catch (e) {
+          logger.warn(`Failed to save summary: ${e.message}`);
+        }
+      }
+    }
+  });
+}
+
 /**
  * Trigger AI analysis for a PR
  */
@@ -1467,7 +1575,7 @@ router.post('/api/pr/:owner/:repo/:number/analyses', async (req, res) => {
     const { owner, repo, number } = req.params;
     const prNumber = parseInt(number);
 
-    const { provider: requestProvider, model: requestModel, tier: requestTier, customInstructions: rawInstructions, skipLevel3: requestSkipLevel3, enabledLevels: requestEnabledLevels } = req.body || {};
+    const { provider: requestProvider, model: requestModel, tier: requestTier, customInstructions: rawInstructions, skipLevel3: requestSkipLevel3, enabledLevels: requestEnabledLevels, excludePrevious } = req.body || {};
 
     const MAX_INSTRUCTIONS_LENGTH = 5000;
     let requestInstructions = rawInstructions?.trim() || null;
@@ -1511,6 +1619,9 @@ router.post('/api/pr/:owner/:repo/:number/analyses', async (req, res) => {
       });
     }
 
+    const appConfig = req.app.get('config') || {};
+    const globalInstructions = appConfig.globalInstructions || null;
+
     const { provider, model, repoInstructions, combinedInstructions } = await withTransaction(db, async () => {
       const repoSettingsRepo = new RepoSettingsRepository(db);
       const fetchedRepoSettings = await repoSettingsRepo.getRepoSettings(repository);
@@ -1521,8 +1632,7 @@ router.post('/api/pr/:owner/:repo/:number/analyses', async (req, res) => {
       } else if (fetchedRepoSettings && fetchedRepoSettings.default_provider) {
         selectedProvider = fetchedRepoSettings.default_provider;
       } else {
-        const config = req.app.get('config') || {};
-        selectedProvider = config.default_provider || config.provider || 'claude';
+        selectedProvider = appConfig.default_provider || appConfig.provider || 'claude';
       }
 
       let selectedModel;
@@ -1535,7 +1645,7 @@ router.post('/api/pr/:owner/:repo/:number/analyses', async (req, res) => {
       }
 
       const fetchedRepoInstructions = fetchedRepoSettings?.default_instructions || null;
-      const mergedInstructions = mergeInstructions(fetchedRepoInstructions, requestInstructions);
+      const mergedInstructions = mergeInstructions({ globalInstructions, repoInstructions: fetchedRepoInstructions, requestInstructions });
 
       if (requestInstructions) {
         await reviewRepo.upsertCustomInstructions(prNumber, repository, requestInstructions);
@@ -1554,6 +1664,29 @@ router.post('/api/pr/:owner/:repo/:number/analyses', async (req, res) => {
 
     const { review } = await reviewRepo.getOrCreate({ prNumber, repository });
 
+    // Check if selected provider is an executable provider (external tool)
+    const ProviderClass = getProviderClass(provider);
+    if (ProviderClass?.isExecutable) {
+      return handleExecutablePRAnalysis(req, res, {
+        reviewId: review.id,
+        review,
+        prNumber,
+        owner,
+        repo,
+        repository,
+        worktreePath,
+        prMetadata,
+        selectedProvider: provider,
+        selectedModel: model,
+        repoInstructions,
+        requestInstructions,
+        combinedInstructions,
+        runId,
+        analysisId,
+        reviewRepo
+      });
+    }
+
     const analysisRunRepo = new AnalysisRunRepository(db);
     const levelsConfig = parseEnabledLevels(requestEnabledLevels, requestSkipLevel3);
     const tier = requestTier ? resolveTier(requestTier) : 'balanced';
@@ -1563,6 +1696,7 @@ router.post('/api/pr/:owner/:repo/:number/analyses', async (req, res) => {
       provider,
       model,
       tier,
+      globalInstructions,
       repoInstructions,
       requestInstructions,
       headSha: prMetadata.head_sha || null,
@@ -1596,7 +1730,7 @@ router.post('/api/pr/:owner/:repo/:number/analyses', async (req, res) => {
 
     broadcastProgress(analysisId, initialStatus);
     broadcastReviewEvent(review.id, { type: 'review:analysis_started', analysisId });
-    const analysisConfig = req.app.get('config') || {};
+    const analysisConfig = appConfig;
     const analysisPrContext = {
       number: prNumber, owner, repo,
       author: prMetadata.author, baseBranch: prMetadata.base_branch, headBranch: prMetadata.head_branch,
@@ -1626,7 +1760,7 @@ router.post('/api/pr/:owner/:repo/:number/analyses', async (req, res) => {
 
     const progressCallback = createProgressCallback(analysisId);
 
-    analyzer.analyzeLevel1(review.id, worktreePath, prMetadata, progressCallback, { repoInstructions, requestInstructions }, null, { analysisId, runId, skipRunCreation: true, tier, skipLevel3: requestSkipLevel3, enabledLevels: levelsConfig })
+    analyzer.analyzeLevel1(review.id, worktreePath, prMetadata, progressCallback, { globalInstructions, repoInstructions, requestInstructions }, null, { analysisId, runId, skipRunCreation: true, tier, skipLevel3: requestSkipLevel3, enabledLevels: levelsConfig, excludePrevious, serverPort: req.socket.localPort })
       .then(async result => {
         logger.section('Analysis Results');
         logger.success(`Analysis complete for PR #${prNumber}`);
@@ -1796,7 +1930,7 @@ router.post('/api/pr/:owner/:repo/:number/analyses/council', async (req, res) =>
   try {
     const { owner, repo, number } = req.params;
     const prNumber = parseInt(number);
-    const { councilId, councilConfig: inlineConfig, customInstructions: rawInstructions, configType: requestConfigType } = req.body || {};
+    const { councilId, councilConfig: inlineConfig, customInstructions: rawInstructions, configType: requestConfigType, excludePrevious } = req.body || {};
 
     if (isNaN(prNumber) || prNumber <= 0) {
       return res.status(400).json({ error: 'Invalid pull request number' });
@@ -1855,6 +1989,7 @@ router.post('/api/pr/:owner/:repo/:number/analyses/council', async (req, res) =>
       await reviewRepo.upsertCustomInstructions(prNumber, repository, requestInstructions);
     }
 
+    const prCouncilConfig = req.app.get('config') || {};
     const { analysisId, runId } = await analysesRouter.launchCouncilAnalysis(
       db,
       {
@@ -1866,7 +2001,9 @@ router.post('/api/pr/:owner/:repo/:number/analyses/council', async (req, res) =>
         headSha: prMetadata.head_sha,
         logLabel: `PR #${prNumber}`,
         initialStatusExtra: { prNumber, reviewType: 'pr' },
-        config: req.app.get('config') || {},
+        config: prCouncilConfig,
+        excludePrevious,
+        serverPort: req.socket.localPort,
         hookContext: {
           mode: 'pr',
           prContext: {
@@ -1884,7 +2021,7 @@ router.post('/api/pr/:owner/:repo/:number/analyses/council', async (req, res) =>
       },
       councilConfig,
       councilId,
-      { repoInstructions, requestInstructions },
+      { globalInstructions: prCouncilConfig.globalInstructions || null, repoInstructions, requestInstructions },
       configType
     );
 

package/src/routes/reviews.js

@@ -456,6 +456,8 @@ router.get('/api/reviews/:reviewId/suggestions/check', validateReviewId, async (
  * Query params:
  *   - levels: comma-separated list of levels (e.g., 'final,1,2'). Default: 'final'
  *   - runId: specific analysis run ID. Default: latest run
+ *   - allRuns: when 'true', return suggestions from all analysis runs instead of only the latest
+ *   - excludeRunId: when used with allRuns=true, exclude suggestions from specific run ID(s). Supports comma-separated values (e.g., 'id1,id2')
  */
 router.get('/api/reviews/:reviewId/suggestions', validateReviewId, async (req, res) => {
   try {
@@ -471,6 +473,13 @@ router.get('/api/reviews/:reviewId/suggestions', validateReviewId, async (req, r
     // If not provided, defaults to the latest run
     const runIdParam = req.query.runId;
 
+    // Parse allRuns flag — when true, skip the "latest run only" filter
+    const allRuns = req.query.allRuns === 'true';
+
+    // Parse optional excludeRunId — when used with allRuns=true, exclude suggestions from these runs
+    // Supports comma-separated values for excluding multiple run IDs (e.g., excludeRunId=id1,id2)
+    const excludeRunIds = req.query.excludeRunId ? req.query.excludeRunId.split(',').filter(Boolean) : [];
+
     // Build level filter clause
     const levelConditions = [];
     requestedLevels.forEach(level => {
@@ -487,10 +496,22 @@ router.get('/api/reviews/:reviewId/suggestions', validateReviewId, async (req, r
       : 'ai_level IS NULL';
 
     // Build the run ID filter clause
-    // If a specific runId is provided, use it directly; otherwise use subquery for latest
+    // allRuns=true skips run filtering entirely — return suggestions from all runs
+    // runId param targets a specific run
+    // Default: subquery for the latest run only
     let runIdFilter;
     let queryParams;
-    if (runIdParam) {
+    if (allRuns) {
+      if (excludeRunIds.length > 0) {
+        // Return suggestions from all runs except the excluded ones
+        runIdFilter = `ai_run_id NOT IN (${excludeRunIds.map(() => '?').join(', ')})`;
+        queryParams = [reviewId, ...excludeRunIds];
+      } else {
+        // No run ID filter — return suggestions from all analysis runs
+        runIdFilter = '1 = 1';
+        queryParams = [reviewId];
+      }
+    } else if (runIdParam) {
       runIdFilter = 'ai_run_id = ?';
       queryParams = [reviewId, runIdParam];
     } else {
@@ -514,6 +535,8 @@ router.get('/api/reviews/:reviewId/suggestions', validateReviewId, async (req, r
       queryParams = [reviewId, reviewId];
     }
 
+    const statusFilter = "status IN ('active', 'dismissed', 'adopted', 'draft', 'submitted')";
+
     const rows = await query(db, `
       SELECT
         id,
@@ -533,13 +556,14 @@ router.get('/api/reviews/:reviewId/suggestions', validateReviewId, async (req, r
         reasoning,
         status,
         is_file_level,
+        severity,
         created_at,
         updated_at
       FROM comments
       WHERE review_id = ?
         AND source = 'ai'
         AND ${levelFilter}
-        AND status IN ('active', 'dismissed', 'adopted', 'draft', 'submitted')
+        AND ${statusFilter}
         AND (is_raw = 0 OR is_raw IS NULL)
         AND ${runIdFilter}
       ORDER BY
@@ -564,7 +588,8 @@ router.get('/api/reviews/:reviewId/suggestions', validateReviewId, async (req, r
         body: row.body,
         suggestionText: row.suggestion_text,
         category: row.type,
-        title: row.title
+        title: row.title,
+        severity: row.severity
       }, formatConfig);
 
       return {
@@ -694,7 +719,8 @@ router.post('/api/reviews/:reviewId/suggestions/:id/adopt', validateReviewId, as
       body: suggestion.body,
       suggestionText: suggestion.suggestion_text,
       category: suggestion.type,
-      title: suggestion.title
+      title: suggestion.title,
+      severity: suggestion.severity
     }, formatConfig);
 
     // Atomically adopt: create user comment and update suggestion status in one transaction

package/src/routes/shared.js

@@ -108,13 +108,50 @@ function determineCompletionInfo(result) {
   };
 }
 
+// Track which analysisIds have been announced on the index topic
+const _indexAnnouncedIds = new Set();
+
+/**
+ * Broadcast an analysis status change on the `index:analyses` topic
+ * so the index page can show/hide spinners in real time.
+ * @param {Object} data - Event data (type, analysisId, reviewId, etc.)
+ */
+function broadcastIndexAnalysisEvent(data) {
+  ws.broadcast('index:analyses', data);
+}
+
 /**
  * Broadcast progress update to all WebSocket clients subscribed to `analysis:{analysisId}`.
+ * Also emits index-level start/end events for the index page spinners.
  * @param {string} analysisId - Analysis ID
  * @param {Object} progressData - Progress data to broadcast
  */
 function broadcastProgress(analysisId, progressData) {
   ws.broadcast('analysis:' + analysisId, { type: 'progress', ...progressData });
+
+  // Emit index-level events for analysis lifecycle transitions
+  const status = progressData.status;
+  if (status === 'running' && !_indexAnnouncedIds.has(analysisId)) {
+    _indexAnnouncedIds.add(analysisId);
+    broadcastIndexAnalysisEvent({
+      type: 'analysis_started',
+      analysisId,
+      reviewId: progressData.reviewId,
+      reviewType: progressData.reviewType || null,
+      repository: progressData.repository || null,
+      prNumber: progressData.prNumber || null
+    });
+  } else if (['completed', 'failed', 'cancelled'].includes(status) && _indexAnnouncedIds.has(analysisId)) {
+    _indexAnnouncedIds.delete(analysisId);
+    broadcastIndexAnalysisEvent({
+      type: 'analysis_ended',
+      analysisId,
+      reviewId: progressData.reviewId,
+      reviewType: progressData.reviewType || null,
+      repository: progressData.repository || null,
+      prNumber: progressData.prNumber || null
+    });
+  }
 }
 
 /**
@@ -231,11 +268,13 @@ function createProgressCallback(analysisId) {
         }
       }
 
-      // Per-voice orchestration streams: store in voices map, not shared state.
-      // This prevents per-reviewer orchestration (within each voice's analysis)
-      // from overwriting the shared consolidation streamEvent/consolidationStep.
-      const isPerVoiceOrchestration = (level === 'orchestration' || consolidationMatch) && progressUpdate.voiceId;
-      if (isPerVoiceOrchestration) {
+      // Per-voice streams for orchestration and exec levels: store in voices map.
+      // For orchestration: prevents per-reviewer orchestration from overwriting
+      // the shared consolidation streamEvent/consolidationStep.
+      // For exec: ensures exec.voices[voiceId] stays updated with stream events
+      // so the frontend can render both state and stream text from the same object.
+      const isPerVoiceStream = ((level === 'orchestration' || consolidationMatch) || level === 'exec') && progressUpdate.voiceId;
+      if (isPerVoiceStream) {
         if (!currentStatus.levels[levelKey].voices) {
           currentStatus.levels[levelKey].voices = {};
         }
@@ -301,6 +340,32 @@ function createProgressCallback(analysisId) {
       }
     }
 
+    // Handle executable voice progress (level === 'exec').
+    // Executable voices run a single analysis step instead of L1/L2/L3.
+    // Track per-voice state in levels.exec.voices, mirroring the L1-L3 pattern.
+    if (level === 'exec' && currentStatus.levels.exec) {
+      if (progressUpdate.voiceId) {
+        if (!currentStatus.levels.exec.voices) {
+          currentStatus.levels.exec.voices = {};
+        }
+        currentStatus.levels.exec.voices[progressUpdate.voiceId] = {
+          status: progressUpdate.status || 'running',
+          progress: progressUpdate.progress || 'In progress...'
+        };
+        currentStatus.levels.exec.voiceId = progressUpdate.voiceId;
+        currentStatus.levels.exec.status = progressUpdate.status || 'running';
+        currentStatus.levels.exec.progress = progressUpdate.progress || 'In progress...';
+        currentStatus.levels.exec.streamEvent = undefined;
+      } else {
+        currentStatus.levels.exec = {
+          status: progressUpdate.status || 'running',
+          progress: progressUpdate.progress || 'In progress...',
+          streamEvent: undefined,
+          voiceId: undefined
+        };
+      }
+    }
+
     // Handle orchestration and consolidation as level 4.
     //
     // levels[4] is intentionally denormalized with two parallel maps:
@@ -411,6 +476,8 @@ module.exports = {
   getModel,
   determineCompletionInfo,
   broadcastProgress,
+  broadcastIndexAnalysisEvent,
+  _indexAnnouncedIds,
   broadcastSetupProgress,
   registerProcess,
   killProcesses,

package/src/routes/worktrees.js

@@ -154,7 +154,8 @@ router.get('/api/worktrees/recent', async (req, res) => {
         json_extract(pm.pr_data, '$.html_url') as html_url,
         w.id as worktree_id,
         w.path as worktree_path,
-        w.branch
+        w.branch,
+        (SELECT r.id FROM reviews r WHERE r.pr_number = pm.pr_number AND r.repository = pm.repository COLLATE NOCASE ORDER BY r.updated_at DESC LIMIT 1) as review_id
       FROM pr_metadata pm
       LEFT JOIN worktrees w ON pm.pr_number = w.pr_number AND pm.repository = w.repository COLLATE NOCASE
       WHERE pm.title IS NOT NULL AND pm.title != ''
@@ -195,7 +196,8 @@ router.get('/api/worktrees/recent', async (req, res) => {
         last_accessed_at: row.last_accessed_at,
         created_at: row.created_at,
         storage_status: storageStatus,
-        html_url: row.html_url || null
+        html_url: row.html_url || null,
+        review_id: row.review_id || null
       });
     }
 

package/src/utils/comment-formatter.js

@@ -8,15 +8,17 @@ const { getEmoji } = require('./category-emoji');
 
 /**
  * Preset format templates for adopted comments.
- * Template placeholders: {emoji}, {category}, {title}, {description}, {suggestion}
+ * Template placeholders: {emoji}, {category}, {severity}, {SEVERITY}, {title}, {description}, {suggestion}
+ * {severity} renders as Title Case (e.g., "Critical"), {SEVERITY} renders as UPPERCASE (e.g., "CRITICAL").
  * Conditional sections: {?field}...{/field} — content is kept when field is truthy, stripped when falsy.
+ * Nesting is supported: {?outer}...{?inner}...{/inner}...{/outer}
  */
 const PRESETS = {
   legacy: '{emoji} **{category}**: {description}{?suggestion}\n\n**Suggestion:** {suggestion}{/suggestion}',
   minimal: '[{category}] {description}{?suggestion}\n\n{suggestion}{/suggestion}',
   plain: '{description}{?suggestion}\n\n{suggestion}{/suggestion}',
   'emoji-only': '{emoji} {description}{?suggestion}\n\n{suggestion}{/suggestion}',
-  maximal: '{emoji} **{category}**{?title}: {title}{/title}\n\n{description}{?suggestion}\n\n**Suggestion:** {suggestion}{/suggestion}'
+  maximal: '{emoji} **{category}**{?title}: {title}{?severity} ({severity}){/severity}{/title}\n\n{description}{?suggestion}\n\n**Suggestion:** {suggestion}{/suggestion}'
 };
 
 /**
@@ -63,25 +65,32 @@ function capitalizeCategory(category) {
  * @returns {string} Template with conditional sections resolved
  */
 function processConditionalSections(template, values) {
-  return template.replace(/\{\?(\w+)\}([\s\S]*?)\{\/\1\}/g, (match, fieldName, content) => {
-    const value = values[fieldName];
-    if (value !== undefined && value !== null && value !== '') {
-      return content;
-    }
-    return '';
-  });
+  // Loop to resolve nested conditionals (outer pass exposes inner ones)
+  let result = template;
+  let prev;
+  do {
+    prev = result;
+    result = result.replace(/\{\?(\w+)\}([\s\S]*?)\{\/\1\}/g, (match, fieldName, content) => {
+      const value = values[fieldName];
+      if (value !== undefined && value !== null && value !== '') {
+        return content;
+      }
+      return '';
+    });
+  } while (result !== prev);
+  return result;
 }
 
 /**
  * Format an adopted comment using the given format configuration.
  * Handles legacy data where suggestion_text was concatenated into body.
  *
- * @param {{ body: string, suggestionText?: string, category?: string, title?: string }} fields
+ * @param {{ body: string, suggestionText?: string, category?: string, title?: string, severity?: string }} fields
  * @param {{ template: string, emojiOverrides: Object, categoryOverrides: Object }} formatConfig
  * @returns {string} Formatted comment text
  */
 function formatAdoptedComment(fields, formatConfig) {
-  const { body, title } = fields;
+  const { body, title, severity } = fields;
   let { category, suggestionText } = fields;
 
   if (!category) {
@@ -111,9 +120,15 @@ function formatAdoptedComment(fields, formatConfig) {
   const capitalizedCategory = capitalizeCategory(category);
 
   // Process conditional sections first, then replace individual placeholders
+  const capitalizedSeverity = severity ? capitalizeCategory(severity) : '';
+
+  const uppercaseSeverity = severity ? severity.toUpperCase() : '';
+
   const fieldValues = {
     suggestion: suggestionText || '',
     title: title || '',
+    severity: capitalizedSeverity,
+    SEVERITY: uppercaseSeverity,
     emoji,
     category: capitalizedCategory,
     description
@@ -124,6 +139,8 @@ function formatAdoptedComment(fields, formatConfig) {
   // Replace placeholders
   result = result.replace(/\{emoji\}/g, emoji);
   result = result.replace(/\{category\}/g, capitalizedCategory);
+  result = result.replace(/\{severity\}/g, capitalizedSeverity);
+  result = result.replace(/\{SEVERITY\}/g, uppercaseSeverity);
   result = result.replace(/\{title\}/g, title || '');
   result = result.replace(/\{description\}/g, description);
   result = result.replace(/\{suggestion\}/g, suggestionText || '');