@in-the-loop-labs/pair-review 1.4.3 → 1.5.0

package/src/routes/shared.js

@@ -113,7 +113,7 @@ function determineCompletionInfo(result) {
     // We have orchestrated suggestions - use those as the final count
     totalSuggestions = result.level2Result.orchestratedSuggestions.length;
     progressMessage = `Analysis complete: ${totalSuggestions} orchestrated suggestions stored`;
-    logger.success(`Orchestration successful: ${totalSuggestions} curated suggestions from all levels`);
+    logger.success(`Consolidation successful: ${totalSuggestions} curated suggestions from all levels`);
   } else {
     // Fall back to individual level counts
     const level1Count = result.suggestions.length;
@@ -272,7 +272,11 @@ function createProgressCallback(analysisId) {
     if (!currentStatus) return;
 
     const level = progressUpdate.level;
-    const levelKey = level === 'orchestration' ? 4 : level;
+    // Map consolidation-L* and orchestration to level 4 (consolidation phase)
+    const consolidationMatch = typeof level === 'string' && level.match(/^consolidation-L(\d+)$/);
+    const levelKey = level === 'orchestration' ? 4
+      : consolidationMatch ? 4
+      : level;
 
     // Stream event: store latest and throttle broadcasts
     if (progressUpdate.streamEvent && levelKey) {
@@ -292,6 +296,16 @@ function createProgressCallback(analysisId) {
       }
 
       currentStatus.levels[levelKey].streamEvent = evt;
+      // Propagate voiceId so council progress modal can identify active voice
+      if (progressUpdate.voiceId) {
+        currentStatus.levels[levelKey].voiceId = progressUpdate.voiceId;
+      }
+      // Propagate consolidation step so frontend can identify active consolidation child
+      if (consolidationMatch) {
+        currentStatus.levels[levelKey].consolidationStep = `L${consolidationMatch[1]}`;
+      } else if (level === 'orchestration') {
+        currentStatus.levels[levelKey].consolidationStep = 'orchestration';
+      }
       activeAnalyses.set(analysisId, currentStatus);
 
       // Throttle: only broadcast if enough time has elapsed
@@ -306,20 +320,88 @@ function createProgressCallback(analysisId) {
     // Regular status update (not a stream event)
     // Update the specific level's status, clearing any stale streamEvent
     if (level && level >= 1 && level <= 3) {
-      currentStatus.levels[level] = {
-        status: progressUpdate.status || 'running',
-        progress: progressUpdate.progress || 'In progress...',
-        streamEvent: undefined
-      };
+      if (progressUpdate.voiceId) {
+        // Per-voice update (council mode): track in voices map so concurrent
+        // completions on the same level don't clobber each other
+        if (!currentStatus.levels[level].voices) {
+          currentStatus.levels[level].voices = {};
+        }
+        currentStatus.levels[level].voices[progressUpdate.voiceId] = {
+          status: progressUpdate.status || 'running',
+          progress: progressUpdate.progress || 'In progress...'
+        };
+        // Last-writer-wins: set top-level voiceId for backward compat with frontend
+        // routing. The per-voice detail lives in the `voices` map above.
+        currentStatus.levels[level].voiceId = progressUpdate.voiceId;
+        currentStatus.levels[level].status = progressUpdate.status || 'running';
+        currentStatus.levels[level].progress = progressUpdate.progress || 'In progress...';
+        currentStatus.levels[level].streamEvent = undefined;
+      } else {
+        // Non-voice update (single-model mode)
+        currentStatus.levels[level] = {
+          status: progressUpdate.status || 'running',
+          progress: progressUpdate.progress || 'In progress...',
+          streamEvent: undefined,
+          voiceId: undefined
+        };
+      }
     }
 
-    // Handle orchestration as level 4
-    if (level === 'orchestration') {
-      currentStatus.levels[4] = {
+    // Handle orchestration and consolidation as level 4.
+    //
+    // levels[4] is intentionally denormalized with two parallel maps:
+    //   - `steps`: keyed by consolidation sub-step ("L1", "L2", "L3", "orchestration").
+    //     Tracks which consolidation phases have run/completed. Used to derive the
+    //     aggregate status so one step completing doesn't mark the whole phase done.
+    //   - `voices`: keyed by reviewer voiceId (council mode only). Tracks per-reviewer
+    //     orchestration progress so the frontend can render individual reviewer rows.
+    //
+    // Both maps must be preserved across updates since each progress event only
+    // reports on a single step or voice at a time.
+    if (level === 'orchestration' || consolidationMatch) {
+      const step = consolidationMatch ? `L${consolidationMatch[1]}` : 'orchestration';
+      // Preserve existing consolidation steps when updating level 4
+      const existing = currentStatus.levels[4] || {};
+      const steps = { ...(existing.steps || {}) };
+      steps[step] = {
         status: progressUpdate.status || 'running',
-        progress: progressUpdate.progress || 'Finalizing results...',
-        streamEvent: undefined
+        progress: progressUpdate.progress || (consolidationMatch ? 'Consolidating...' : 'Finalizing results...')
+      };
+      // Derive the top-level consolidation status from the aggregate of step statuses
+      // so that a single step completing doesn't mark the whole phase as completed
+      const stepStatuses = Object.values(steps).map(s => s.status);
+      const derivedStatus = stepStatuses.every(s => s === 'completed') ? 'completed'
+        : stepStatuses.some(s => s === 'failed') ? 'failed'
+        : stepStatuses.some(s => s === 'running') ? 'running'
+        : progressUpdate.status || 'running';
+      // Preserve existing per-voice orchestration states when rebuilding level 4
+      const existingVoices = existing.voices ? { ...existing.voices } : undefined;
+      currentStatus.levels[4] = {
+        status: derivedStatus,
+        progress: progressUpdate.progress || (consolidationMatch ? 'Consolidating...' : 'Finalizing results...'),
+        streamEvent: undefined,
+        consolidationStep: step,
+        steps,
+        voices: existingVoices
       };
+
+      // Track per-voice orchestration state (voice-centric council mode):
+      // When a voiceId is present, store per-voice status in levels[4].voices
+      // so the frontend can update individual reviewer's consolidation row.
+      if (progressUpdate.voiceId) {
+        if (!currentStatus.levels[4].voices) {
+          currentStatus.levels[4].voices = {};
+        }
+        currentStatus.levels[4].voices[progressUpdate.voiceId] = {
+          status: progressUpdate.status || 'running',
+          progress: progressUpdate.progress || 'Consolidating...'
+        };
+        // Last-writer-wins: reflects whichever voice reported most recently.
+        // Intentional — mirrors levels 1-3 behavior (line ~334) and the frontend
+        // uses per-voice detail from the `voices` map, not this top-level field.
+        // This field exists for backward compat with single-model progress routing.
+        currentStatus.levels[4].voiceId = progressUpdate.voiceId;
+      }
     }
 
     // Update overall progress message if provided
@@ -332,6 +414,36 @@ function createProgressCallback(analysisId) {
   };
 }
 
+/**
+ * Parse enabledLevels from a request body into a normalized { 1: bool, 2: bool, 3: bool } object.
+ *
+ * Accepts three formats:
+ *   - Array: e.g. [1, 3]  -> { 1: true, 2: false, 3: true }
+ *   - Object: e.g. { 1: true, 2: false, 3: true } -> filtered to known keys only
+ *   - Null/undefined: falls back to skipLevel3 flag -> { 1: true, 2: true, 3: !skipLevel3 }
+ *
+ * @param {Array|Object|null} requestEnabledLevels - Raw enabledLevels from request body
+ * @param {boolean} [skipLevel3=false] - Fallback flag when enabledLevels is not provided
+ * @returns {Object} Normalized levels config { 1: boolean, 2: boolean, 3: boolean }
+ */
+function parseEnabledLevels(requestEnabledLevels, skipLevel3 = false) {
+  const levelsConfig = {};
+  if (Array.isArray(requestEnabledLevels)) {
+    for (const key of [1, 2, 3]) {
+      levelsConfig[key] = requestEnabledLevels.includes(key);
+    }
+  } else if (requestEnabledLevels && typeof requestEnabledLevels === 'object') {
+    for (const key of [1, 2, 3]) {
+      levelsConfig[key] = !!requestEnabledLevels[key];
+    }
+  } else {
+    levelsConfig[1] = true;
+    levelsConfig[2] = true;
+    levelsConfig[3] = !skipLevel3;
+  }
+  return levelsConfig;
+}
+
 module.exports = {
   CancellationError,
   activeAnalyses,
@@ -351,5 +463,6 @@ module.exports = {
   registerProcess,
   killProcesses,
   isAnalysisCancelled,
-  createProgressCallback
+  createProgressCallback,
+  parseEnabledLevels
 };

package/src/server.js

@@ -2,9 +2,10 @@
 const express = require('express');
 const path = require('path');
 const { loadConfig, getGitHubToken } = require('./config');
-const { initializeDatabase, getDatabaseStatus, queryOne } = require('./database');
+const { initializeDatabase, getDatabaseStatus, queryOne, run } = require('./database');
 const { normalizeRepository } = require('./utils/paths');
 const { applyConfigOverrides, checkAllProviders } = require('./ai');
+const logger = require('./utils/logger');
 
 let db = null;
 let server = null;
@@ -122,7 +123,24 @@ async function startServer(sharedDb = null) {
     } catch (error) {
       console.log('Could not check database status:', error.message);
     }
-    
+
+    // Clean up stale analysis runs that have been "running" for over 30 minutes.
+    // We use a time threshold rather than blanket cleanup because multiple server
+    // processes (e.g. Express + MCP) may share the same database, and a naive
+    // UPDATE would kill legitimately running analyses owned by another process.
+    // TODO: A more robust approach would be to record the owning PID in
+    // analysis_runs and only clean up records whose process is no longer alive.
+    // This would require a schema migration and updating the PID throughout the
+    // analysis lifecycle (since analysis spawns child processes).
+    try {
+      const result = await run(db, "UPDATE analysis_runs SET status = 'failed', completed_at = CURRENT_TIMESTAMP WHERE status = 'running' AND started_at < datetime('now', '-30 minutes')");
+      if (result.changes > 0) {
+        logger.info(`Cleaned up ${result.changes} stale analysis run(s) (running > 30 minutes)`);
+      }
+    } catch (error) {
+      logger.warn(`Failed to clean up orphaned analysis runs: ${error.message}`);
+    }
+
     // Check if public directory exists
     const publicDir = path.join(__dirname, '..', 'public');
     try {
@@ -176,12 +194,22 @@ async function startServer(sharedDb = null) {
       try {
         const existing = await queryOne(db, 'SELECT id FROM pr_metadata WHERE pr_number = ? AND repository = ? COLLATE NOCASE', [prNumber, repository]);
         if (existing) {
-          res.sendFile(path.join(__dirname, '..', 'public', 'pr.html'));
+          // PR metadata exists, but verify the worktree is still present.
+          // When a user deletes a worktree, metadata is preserved but the
+          // worktree record is removed. Without this check the route serves
+          // pr.html for a missing worktree, causing 404s on file fetches.
+          const worktree = await queryOne(db, 'SELECT id FROM worktrees WHERE pr_number = ? AND repository = ? COLLATE NOCASE', [prNumber, repository]);
+          if (worktree) {
+            res.sendFile(path.join(__dirname, '..', 'public', 'pr.html'));
+          } else {
+            logger.info(`PR metadata exists but no worktree for ${repository} #${prNumber}, serving setup page`);
+            res.sendFile(path.join(__dirname, '..', 'public', 'setup.html'));
+          }
         } else {
           res.sendFile(path.join(__dirname, '..', 'public', 'setup.html'));
         }
       } catch (error) {
-        console.error('Failed to query pr_metadata for PR route, falling back to pr.html:', error.message);
+        logger.error('Failed to query pr_metadata for PR route, falling back to pr.html:', error.message);
         res.sendFile(path.join(__dirname, '..', 'public', 'pr.html'));
       }
     });
@@ -225,9 +253,11 @@ async function startServer(sharedDb = null) {
     const localRoutes = require('./routes/local');
     const setupRoutes = require('./routes/setup');
     const mcpRoutes = require('./routes/mcp');
+    const councilRoutes = require('./routes/councils');
 
     // Mount specific routes first to ensure they match before general PR routes
     app.use('/', analysisRoutes);
+    app.use('/', councilRoutes);
     app.use('/', commentsRoutes);
     app.use('/', configRoutes);
     app.use('/', worktreesRoutes);

package/src/utils/stats-calculator.js

@@ -56,6 +56,7 @@ function getStatsQuery(runId = null) {
       query: `
         SELECT type, COUNT(*) as count FROM comments
         WHERE review_id = ? AND source = 'ai' AND ai_level IS NULL
+          AND (is_raw = 0 OR is_raw IS NULL)
           AND ai_run_id = ?
         GROUP BY type
       `,
@@ -67,6 +68,7 @@ function getStatsQuery(runId = null) {
       query: `
         SELECT type, COUNT(*) as count FROM comments
         WHERE review_id = ? AND source = 'ai' AND ai_level IS NULL
+          AND (is_raw = 0 OR is_raw IS NULL)
           AND ai_run_id = (
             SELECT ai_run_id FROM comments
             WHERE review_id = ? AND source = 'ai' AND ai_run_id IS NOT NULL