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

package/src/routes/config.js

@@ -10,7 +10,7 @@
  */
 
 const express = require('express');
-const { RepoSettingsRepository, ReviewRepository } = require('../database');
+const { RepoSettingsRepository, ReviewRepository, queryOne } = require('../database');
 const {
   getAllProvidersInfo,
   testProviderAvailability,
@@ -82,7 +82,7 @@ router.patch('/api/config', async (req, res) => {
     });
 
   } catch (error) {
-    console.error('Error updating config:', error);
+    logger.error('Error updating config:', error);
     res.status(500).json({
       error: 'Failed to update configuration'
     });
@@ -109,7 +109,9 @@ router.get('/api/repos/:owner/:repo/settings', async (req, res) => {
         default_instructions: null,
         default_provider: null,
         default_model: null,
-        local_path: null
+        local_path: null,
+        default_council_id: null,
+        default_tab: null
       });
     }
 
@@ -119,12 +121,14 @@ router.get('/api/repos/:owner/:repo/settings', async (req, res) => {
       default_provider: settings.default_provider,
       default_model: settings.default_model,
       local_path: settings.local_path,
+      default_council_id: settings.default_council_id,
+      default_tab: settings.default_tab,
       created_at: settings.created_at,
       updated_at: settings.updated_at
     });
 
   } catch (error) {
-    console.error('Error fetching repo settings:', error);
+    logger.error('Error fetching repo settings:', error);
     res.status(500).json({
       error: 'Failed to fetch repository settings'
     });
@@ -138,14 +142,14 @@ router.get('/api/repos/:owner/:repo/settings', async (req, res) => {
 router.post('/api/repos/:owner/:repo/settings', async (req, res) => {
   try {
     const { owner, repo } = req.params;
-    const { default_instructions, default_provider, default_model, local_path } = req.body;
+    const { default_instructions, default_provider, default_model, local_path, default_council_id, default_tab } = req.body;
     const repository = normalizeRepository(owner, repo);
     const db = req.app.get('db');
 
     // Validate that at least one setting is provided
-    if (default_instructions === undefined && default_provider === undefined && default_model === undefined && local_path === undefined) {
+    if (default_instructions === undefined && default_provider === undefined && default_model === undefined && local_path === undefined && default_council_id === undefined && default_tab === undefined) {
       return res.status(400).json({
-        error: 'At least one setting (default_instructions, default_provider, default_model, or local_path) must be provided'
+        error: 'At least one setting (default_instructions, default_provider, default_model, local_path, default_council_id, or default_tab) must be provided'
       });
     }
 
@@ -154,7 +158,9 @@ router.post('/api/repos/:owner/:repo/settings', async (req, res) => {
       default_instructions,
       default_provider,
       default_model,
-      local_path
+      local_path,
+      default_council_id,
+      default_tab
     });
 
     logger.info(`Saved repo settings for ${repository}`);
@@ -167,12 +173,14 @@ router.post('/api/repos/:owner/:repo/settings', async (req, res) => {
         default_provider: settings.default_provider,
         default_model: settings.default_model,
         local_path: settings.local_path,
+        default_council_id: settings.default_council_id,
+        default_tab: settings.default_tab,
         updated_at: settings.updated_at
       }
     });
 
   } catch (error) {
-    console.error('Error saving repo settings:', error);
+    logger.error('Error saving repo settings:', error);
     res.status(500).json({
       error: 'Failed to save repository settings'
     });
@@ -202,16 +210,29 @@ router.get('/api/pr/:owner/:repo/:number/review-settings', async (req, res) => {
 
     if (!review) {
       return res.json({
-        custom_instructions: null
+        custom_instructions: null,
+        last_council_id: null
       });
     }
 
+    // Find the last council used for this review
+    let last_council_id = null;
+    const lastCouncilRun = await queryOne(db, `
+      SELECT model FROM analysis_runs
+      WHERE review_id = ? AND provider = 'council' AND model != 'inline-config'
+      ORDER BY started_at DESC LIMIT 1
+    `, [review.id]);
+    if (lastCouncilRun) {
+      last_council_id = lastCouncilRun.model;
+    }
+
     res.json({
-      custom_instructions: review.custom_instructions || null
+      custom_instructions: review.custom_instructions || null,
+      last_council_id
     });
 
   } catch (error) {
-    console.error('Error fetching review settings:', error);
+    logger.error('Error fetching review settings:', error);
     res.status(500).json({
       error: 'Failed to fetch review settings'
     });
@@ -238,7 +259,7 @@ router.get('/api/providers', (req, res) => {
       checkInProgress: isCheckInProgress()
     });
   } catch (error) {
-    console.error('Error fetching providers:', error);
+    logger.error('Error fetching providers:', error);
     res.status(500).json({
       error: 'Failed to fetch AI providers'
     });
@@ -261,7 +282,7 @@ router.get('/api/providers/:providerId/test', async (req, res) => {
       installInstructions: result.installInstructions || null
     });
   } catch (error) {
-    console.error('Error testing provider:', error);
+    logger.error('Error testing provider:', error);
     res.status(500).json({
       error: 'Failed to test provider availability'
     });
@@ -298,7 +319,7 @@ router.post('/api/providers/refresh-availability', async (req, res) => {
       checkInProgress: true
     });
   } catch (error) {
-    console.error('Error refreshing provider availability:', error);
+    logger.error('Error refreshing provider availability:', error);
     res.status(500).json({
       error: 'Failed to refresh provider availability'
     });

package/src/routes/councils.js

@@ -0,0 +1,351 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+/**
+ * Council Routes
+ *
+ * CRUD endpoints for managing Review Council configurations.
+ * Councils define multi-voice, multi-provider analysis configurations
+ * that run in parallel and consolidate results.
+ */
+
+const express = require('express');
+const { v4: uuidv4 } = require('uuid');
+const logger = require('../utils/logger');
+const { CouncilRepository } = require('../database');
+
+const router = express.Router();
+
+/**
+ * Normalize a council config to match the expected shape for its type.
+ *
+ * When type is 'council' (voice-centric) but the config is in the levels-based
+ * (advanced) format — e.g. from a previously saved council or a migration — this
+ * extracts the voices and converts the levels to booleans so it passes validation.
+ *
+ * When type is anything else, or the config already matches, returns the config
+ * as-is.
+ *
+ * @param {Object} config - Council configuration
+ * @param {string} [type] - The council type ('council' or 'advanced')
+ * @returns {Object} Normalized config (may be the original object if no changes needed)
+ */
+function normalizeCouncilConfig(config, type) {
+  if (!config || typeof config !== 'object' || type !== 'council') {
+    return config;
+  }
+
+  // If it already has a voices array, it's already in voice-centric format
+  if (Array.isArray(config.voices) && config.voices.length > 0) {
+    return config;
+  }
+
+  // Check if levels are in the advanced format (objects with enabled/voices)
+  if (!config.levels || typeof config.levels !== 'object') {
+    return config;
+  }
+
+  const hasAdvancedLevels = Object.values(config.levels).some(
+    val => typeof val === 'object' && val !== null && 'enabled' in val
+  );
+
+  if (!hasAdvancedLevels) {
+    return config;
+  }
+
+  // Convert from advanced (levels-based) to voice-centric format
+  const normalizedVoices = [];
+  const seenVoices = new Set();
+  const normalizedLevels = {};
+
+  for (const [key, levelConfig] of Object.entries(config.levels)) {
+    if (typeof levelConfig === 'object' && levelConfig !== null) {
+      normalizedLevels[key] = levelConfig.enabled !== false;
+      if (levelConfig.enabled !== false && Array.isArray(levelConfig.voices)) {
+        for (const v of levelConfig.voices) {
+          const voiceSig = JSON.stringify(v, Object.keys(v).sort());
+          if (!seenVoices.has(voiceSig)) {
+            seenVoices.add(voiceSig);
+            normalizedVoices.push(v);
+          }
+        }
+      }
+    } else {
+      // Already boolean — keep as-is
+      normalizedLevels[key] = levelConfig !== false;
+    }
+  }
+
+  // Destructure out orchestration so it does not leak into the normalized output
+  const { orchestration, ...rest } = config;
+  return {
+    ...rest,
+    voices: normalizedVoices,
+    levels: normalizedLevels,
+    consolidation: config.consolidation || orchestration || undefined
+  };
+}
+
+/**
+ * Validate a council config object
+ * @param {Object} config - Council configuration
+ * @param {string} [type] - The council type ('council' or 'advanced'), provided as a sibling field from req.body
+ * @returns {string|null} Error message or null if valid
+ */
+function validateCouncilConfig(config, type) {
+  if (!config || typeof config !== 'object') {
+    return 'config must be an object';
+  }
+
+  // Dispatch based on explicit type parameter (from req.body.type, not config.type)
+  if (type === 'council') {
+    return validateCouncilFormat(config);
+  }
+
+  // Legacy configs (no type) and type === 'advanced' use level-centric format
+  return validateAdvancedFormat(config);
+}
+
+/**
+ * Validate the voice-centric council format (type: 'council')
+ * @param {Object} config
+ * @returns {string|null} Error message or null if valid
+ */
+function validateCouncilFormat(config) {
+  // Validate voices array
+  if (!Array.isArray(config.voices) || config.voices.length === 0) {
+    return 'config.voices must be a non-empty array';
+  }
+
+  for (const [i, voice] of config.voices.entries()) {
+    if (!voice.provider) {
+      return `voices[${i}].provider is required`;
+    }
+    if (!voice.model) {
+      return `voices[${i}].model is required`;
+    }
+  }
+
+  // Validate levels
+  if (!config.levels || typeof config.levels !== 'object') {
+    return 'config.levels is required and must be an object';
+  }
+
+  const validLevels = ['1', '2', '3'];
+  const hasEnabled = Object.entries(config.levels).some(([key, val]) =>
+    validLevels.includes(key) && val === true
+  );
+  if (!hasEnabled) {
+    return 'At least one level (1, 2, or 3) must be enabled';
+  }
+
+  // Validate consolidation (optional)
+  if (config.consolidation) {
+    if (!config.consolidation.provider || !config.consolidation.model) {
+      return 'consolidation.provider and consolidation.model are required when consolidation is specified';
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Validate the level-centric advanced format (type: 'advanced' or legacy no-type)
+ * @param {Object} config
+ * @returns {string|null} Error message or null if valid
+ */
+function validateAdvancedFormat(config) {
+  // Validate levels
+  if (!config.levels || typeof config.levels !== 'object') {
+    return 'config.levels is required and must be an object';
+  }
+
+  const validLevels = ['1', '2', '3'];
+  for (const [levelKey, level] of Object.entries(config.levels)) {
+    if (!validLevels.includes(levelKey)) {
+      return `Invalid level key: "${levelKey}". Valid keys: ${validLevels.join(', ')}`;
+    }
+
+    if (typeof level.enabled !== 'boolean') {
+      return `levels.${levelKey}.enabled must be a boolean`;
+    }
+
+    if (level.enabled) {
+      if (!Array.isArray(level.voices) || level.voices.length === 0) {
+        return `levels.${levelKey}.voices must be a non-empty array when enabled`;
+      }
+
+      for (const [i, voice] of level.voices.entries()) {
+        if (!voice.provider) {
+          return `levels.${levelKey}.voices[${i}].provider is required`;
+        }
+        if (!voice.model) {
+          return `levels.${levelKey}.voices[${i}].model is required`;
+        }
+      }
+    }
+  }
+
+  // Ensure at least one level is enabled with voices
+  const hasEnabledLevel = Object.values(config.levels).some(l => l.enabled);
+  if (!hasEnabledLevel) {
+    return 'At least one level must be enabled';
+  }
+
+  // Validate orchestration (optional — defaults will be applied at runtime)
+  if (config.orchestration) {
+    if (!config.orchestration.provider || !config.orchestration.model) {
+      return 'orchestration.provider and orchestration.model are required when orchestration is specified';
+    }
+  }
+
+  return null;
+}
+
+/**
+ * GET /api/councils — List all saved councils
+ */
+router.get('/api/councils', async (req, res) => {
+  try {
+    const db = req.app.get('db');
+    const councilRepo = new CouncilRepository(db);
+    const councils = await councilRepo.list();
+
+    res.json({ councils });
+  } catch (error) {
+    logger.error('Error listing councils:', error);
+    res.status(500).json({ error: 'Failed to list councils' });
+  }
+});
+
+/**
+ * GET /api/councils/:id — Get a specific council
+ */
+router.get('/api/councils/:id', async (req, res) => {
+  try {
+    const { id } = req.params;
+    const db = req.app.get('db');
+    const councilRepo = new CouncilRepository(db);
+    const council = await councilRepo.getById(id);
+
+    if (!council) {
+      return res.status(404).json({ error: 'Council not found' });
+    }
+
+    res.json({ council });
+  } catch (error) {
+    logger.error('Error fetching council:', error);
+    res.status(500).json({ error: 'Failed to fetch council' });
+  }
+});
+
+/**
+ * POST /api/councils — Create a new council
+ */
+router.post('/api/councils', async (req, res) => {
+  try {
+    const { name, config, type } = req.body || {};
+
+    if (!name || !name.trim()) {
+      return res.status(400).json({ error: 'name is required' });
+    }
+
+    if (!config) {
+      return res.status(400).json({ error: 'config is required' });
+    }
+
+    const effectiveType = type || 'advanced';
+    const validationError = validateCouncilConfig(config, effectiveType);
+    if (validationError) {
+      return res.status(400).json({ error: validationError });
+    }
+
+    const db = req.app.get('db');
+    const councilRepo = new CouncilRepository(db);
+    const id = uuidv4();
+    const council = await councilRepo.create({ id, name: name.trim(), config, type: effectiveType });
+
+    res.status(201).json({ council });
+  } catch (error) {
+    logger.error('Error creating council:', error);
+    res.status(500).json({ error: 'Failed to create council' });
+  }
+});
+
+/**
+ * PUT /api/councils/:id — Update a council
+ */
+router.put('/api/councils/:id', async (req, res) => {
+  try {
+    const { id } = req.params;
+    const { name, config, type } = req.body || {};
+
+    const db = req.app.get('db');
+    const councilRepo = new CouncilRepository(db);
+
+    // Verify council exists
+    const existing = await councilRepo.getById(id);
+    if (!existing) {
+      return res.status(404).json({ error: 'Council not found' });
+    }
+
+    // Validate config if provided
+    if (config) {
+      // A PUT might update config without changing type, so use the effective type:
+      // prefer the explicitly provided type, fall back to the existing record's type
+      const effectiveType = type !== undefined ? type : existing.type;
+      const validationError = validateCouncilConfig(config, effectiveType);
+      if (validationError) {
+        return res.status(400).json({ error: validationError });
+      }
+    } else if (type !== undefined && type !== existing.type) {
+      // Type is changing without a new config — validate existing config against the new type
+      const validationError = validateCouncilConfig(existing.config, type);
+      if (validationError) {
+        return res.status(400).json({ error: `Existing config is incompatible with type '${type}': ${validationError}` });
+      }
+    }
+
+    const updates = {};
+    if (name !== undefined) {
+      const trimmed = name.trim();
+      if (!trimmed) {
+        return res.status(400).json({ error: 'name cannot be empty' });
+      }
+      updates.name = trimmed;
+    }
+    if (config !== undefined) updates.config = config;
+    if (type !== undefined) updates.type = type;
+
+    await councilRepo.update(id, updates);
+    const updated = await councilRepo.getById(id);
+
+    res.json({ council: updated });
+  } catch (error) {
+    logger.error('Error updating council:', error);
+    res.status(500).json({ error: 'Failed to update council' });
+  }
+});
+
+/**
+ * DELETE /api/councils/:id — Delete a council
+ */
+router.delete('/api/councils/:id', async (req, res) => {
+  try {
+    const { id } = req.params;
+    const db = req.app.get('db');
+    const councilRepo = new CouncilRepository(db);
+
+    const existed = await councilRepo.delete(id);
+    if (!existed) {
+      return res.status(404).json({ error: 'Council not found' });
+    }
+
+    res.json({ success: true });
+  } catch (error) {
+    logger.error('Error deleting council:', error);
+    res.status(500).json({ error: 'Failed to delete council' });
+  }
+});
+
+module.exports = router;
+module.exports.validateCouncilConfig = validateCouncilConfig;
+module.exports.normalizeCouncilConfig = normalizeCouncilConfig;

package/src/routes/local.js

@@ -33,7 +33,8 @@ const {
   determineCompletionInfo,
   broadcastProgress,
   CancellationError,
-  createProgressCallback
+  createProgressCallback,
+  parseEnabledLevels
 } = require('./shared');
 
 const router = express.Router();
@@ -603,7 +604,7 @@ router.post('/api/local/:reviewId/analyze', async (req, res) => {
     }
 
     // Extract optional provider, model, tier, customInstructions and skipLevel3 from request body
-    const { provider: requestProvider, model: requestModel, tier: requestTier, customInstructions: rawInstructions, skipLevel3: requestSkipLevel3 } = req.body || {};
+    const { provider: requestProvider, model: requestModel, tier: requestTier, customInstructions: rawInstructions, skipLevel3: requestSkipLevel3, enabledLevels: requestEnabledLevels } = req.body || {};
 
     // Trim and validate custom instructions
     const MAX_INSTRUCTIONS_LENGTH = 5000;
@@ -680,6 +681,7 @@ router.post('/api/local/:reviewId/analyze', async (req, res) => {
 
     // Create DB analysis_runs record immediately so it's queryable for polling
     const analysisRunRepo = new AnalysisRunRepository(db);
+    const levelsConfig = parseEnabledLevels(requestEnabledLevels, requestSkipLevel3);
     try {
       await analysisRunRepo.create({
         id: runId,
@@ -688,7 +690,9 @@ router.post('/api/local/:reviewId/analyze', async (req, res) => {
         model: selectedModel,
         repoInstructions,
         requestInstructions,
-        headSha: review.local_head_sha || null
+        headSha: review.local_head_sha || null,
+        configType: 'single',
+        levelsConfig
       });
     } catch (error) {
       logger.error('Failed to create analysis run record:', error);
@@ -705,9 +709,9 @@ router.post('/api/local/:reviewId/analyze', async (req, res) => {
       startedAt: new Date().toISOString(),
       progress: 'Starting analysis...',
       levels: {
-        1: { status: 'running', progress: 'Starting...' },
-        2: { status: 'running', progress: 'Starting...' },
-        3: requestSkipLevel3 ? { status: 'skipped', progress: 'Skipped' } : { status: 'running', progress: 'Starting...' },
+        1: levelsConfig[1] ? { status: 'running', progress: 'Starting...' } : { status: 'skipped', progress: 'Skipped' },
+        2: levelsConfig[2] ? { status: 'running', progress: 'Starting...' } : { status: 'skipped', progress: 'Skipped' },
+        3: levelsConfig[3] ? { status: 'running', progress: 'Starting...' } : { status: 'skipped', progress: 'Skipped' },
         4: { status: 'pending', progress: 'Pending' }
       },
       filesAnalyzed: 0,
@@ -760,7 +764,7 @@ router.post('/api/local/:reviewId/analyze', 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)
-    analyzer.analyzeLevel1(reviewId, localPath, localMetadata, progressCallback, { repoInstructions, requestInstructions }, changedFiles, { analysisId, runId, skipRunCreation: true, tier, skipLevel3: requestSkipLevel3 })
+    analyzer.analyzeLevel1(reviewId, localPath, localMetadata, progressCallback, { repoInstructions, requestInstructions }, changedFiles, { analysisId, runId, skipRunCreation: true, tier, skipLevel3: requestSkipLevel3, enabledLevels: levelsConfig })
       .then(async result => {
         logger.section('Local Analysis Results');
         logger.success(`Analysis complete for local review #${reviewId}`);
@@ -979,6 +983,7 @@ router.get('/api/local/:reviewId/suggestions', async (req, res) => {
         AND source = 'ai'
         AND ${levelFilter}
         AND status IN ('active', 'dismissed', 'adopted', 'draft', 'submitted')
+        AND (is_raw = 0 OR is_raw IS NULL)
         AND ${runIdFilter}
       ORDER BY
         CASE
@@ -1741,10 +1746,11 @@ router.get('/api/local/:reviewId/has-ai-suggestions', async (req, res) => {
     }
 
     // Check if any AI suggestions exist for this review
+    // Exclude raw council voice suggestions (is_raw=1) — only count final/consolidated suggestions
     const result = await queryOne(db, `
       SELECT EXISTS(
         SELECT 1 FROM comments
-        WHERE review_id = ? AND source = 'ai'
+        WHERE review_id = ? AND source = 'ai' AND (is_raw = 0 OR is_raw IS NULL)
       ) as has_suggestions
     `, [reviewId]);
 
@@ -1997,12 +2003,25 @@ router.get('/api/local/:reviewId/review-settings', async (req, res) => {
 
     if (!review) {
       return res.json({
-        custom_instructions: null
+        custom_instructions: null,
+        last_council_id: null
       });
     }
 
+    // Find the last council used for this review
+    let last_council_id = null;
+    const lastCouncilRun = await queryOne(db, `
+      SELECT model FROM analysis_runs
+      WHERE review_id = ? AND provider = 'council' AND model != 'inline-config'
+      ORDER BY started_at DESC LIMIT 1
+    `, [review.id]);
+    if (lastCouncilRun) {
+      last_council_id = lastCouncilRun.model;
+    }
+
     res.json({
-      custom_instructions: review.custom_instructions || null
+      custom_instructions: review.custom_instructions || null,
+      last_council_id
     });
 
   } catch (error) {
@@ -2072,7 +2091,10 @@ router.get('/api/local/:reviewId/analysis-runs', async (req, res) => {
     const analysisRunRepo = new AnalysisRunRepository(db);
     const runs = await analysisRunRepo.getByReviewId(reviewId);
 
-    res.json({ runs });
+    res.json({ runs: runs.map(r => ({
+      ...r,
+      levels_config: r.levels_config ? JSON.parse(r.levels_config) : null
+    })) });
   } catch (error) {
     logger.error('Error fetching analysis runs:', error);
     res.status(500).json({ error: 'Failed to fetch analysis runs' });

package/src/routes/mcp.js

@@ -273,6 +273,8 @@ function createMCPServer(db, options = {}) {
       ...reviewLookupSchema,
       limit: z.number().int().positive().optional()
         .describe('Maximum number of runs to return (most recent first). Use limit=1 to poll for the latest run.'),
+      includeChildRuns: z.boolean().optional()
+        .describe('Include child reviewer runs from council analyses. Defaults to false (only top-level runs).'),
     },
     async (args) => {
       const { review, error } = await resolveReview(args, db);
@@ -281,7 +283,12 @@ function createMCPServer(db, options = {}) {
       }
 
       const runRepo = new AnalysisRunRepository(db);
-      const runs = await runRepo.getByReviewId(review.id, { limit: args.limit });
+      let runs = await runRepo.getByReviewId(review.id, { limit: args.limit });
+
+      // By default, exclude child runs (they're an internal implementation detail)
+      if (!args.includeChildRuns) {
+        runs = runs.filter(r => !r.parent_run_id);
+      }
 
       return {
         content: [{
@@ -368,7 +375,7 @@ function createMCPServer(db, options = {}) {
 
       // Build parameterized WHERE conditions
       const params = [runId];
-      const conditions = ["ai_run_id = ?", "source = 'ai'", 'ai_level IS NULL'];
+      const conditions = ["ai_run_id = ?", "source = 'ai'", 'ai_level IS NULL', '(is_raw = 0 OR is_raw IS NULL)'];
 
       if (args.status) {
         conditions.push('status = ?');

package/src/routes/setup.js

@@ -91,7 +91,9 @@ router.post('/api/setup/pr/:owner/:repo/:number', async (req, res) => {
       return res.json({ setupId: existing.setupId });
     }
 
-    // Check if we already have data for this PR in the database
+    // Check if we already have data AND a worktree for this PR in the database.
+    // When a user deletes a worktree, PR metadata is preserved but the worktree
+    // record is removed. We must re-run setup to recreate the worktree.
     const repository = normalizeRepository(owner, repo);
     const existingPR = await queryOne(
       db,
@@ -99,7 +101,15 @@ router.post('/api/setup/pr/:owner/:repo/:number', async (req, res) => {
       [prNumber, repository]
     );
     if (existingPR) {
-      return res.json({ existing: true, reviewUrl: `/pr/${owner}/${repo}/${prNumber}` });
+      const worktree = await queryOne(
+        db,
+        'SELECT id FROM worktrees WHERE pr_number = ? AND repository = ? COLLATE NOCASE',
+        [prNumber, repository]
+      );
+      if (worktree) {
+        return res.json({ existing: true, reviewUrl: `/pr/${owner}/${repo}/${prNumber}` });
+      }
+      logger.info(`PR metadata exists but worktree missing for ${repository} #${prNumber}, re-running setup`);
     }
 
     // Start the async setup