@in-the-loop-labs/pair-review 3.2.2 → 3.3.0

package/src/routes/executable-analysis.js

@@ -234,7 +234,8 @@ async function runExecutableAnalysis(req, res, params, shared, callbacks) {
     reviewId, review, selectedProvider, selectedModel,
     repoInstructions, requestInstructions,
     runId, analysisId, repository, reviewType, headSha,
-    extraInitialStatus
+    extraInitialStatus,
+    providerOverrides = {}
   } = params;
 
   const {
@@ -291,32 +292,48 @@ async function runExecutableAnalysis(req, res, params, shared, callbacks) {
   broadcastProgress(analysisId, initialStatus);
   broadcastReviewEvent(reviewId, { type: 'review:analysis_started', analysisId });
 
-  // 3. Fire analysis.started hook
+  // Register analysis hold for pool worktree usage tracking.
+  // startAnalysis is inside the try so a synchronous exception in setup still
+  // cleans up the hold (the .finally() inside the async IIFE only covers errors after it starts).
+  const poolLifecycle = params.poolLifecycle;
+  let poolWorktreeId;
   const analysisHookConfig = req.app.get('config') || {};
   const hookPayloadFields = buildHookPayload(review, {});
-  if (hasHooks('analysis.started', analysisHookConfig)) {
-    getCachedUser(analysisHookConfig).then(user => {
-      fireHooks('analysis.started', buildAnalysisStartedPayload({
-        reviewId, analysisId, provider: selectedProvider, model: selectedModel,
-        ...hookPayloadFields,
-        user,
-      }), analysisHookConfig);
-    }).catch(() => {});
-  }
+  try {
+    poolWorktreeId = await poolLifecycle?.startAnalysis(reviewId, analysisId);
+
+    // 3. Fire analysis.started hook
+    if (hasHooks('analysis.started', analysisHookConfig)) {
+      getCachedUser(analysisHookConfig).then(user => {
+        fireHooks('analysis.started', buildAnalysisStartedPayload({
+          reviewId, analysisId, provider: selectedProvider, model: selectedModel,
+          ...hookPayloadFields,
+          user,
+        }), analysisHookConfig);
+      }).catch(() => {});
+    }
 
-  // 4. Respond immediately — analysis runs async
-  res.json({
-    analysisId,
-    runId,
-    status: 'running',
-    message: 'Executable provider analysis started'
-  });
+    // 4. Respond immediately — analysis runs async
+    res.json({
+      analysisId,
+      runId,
+      status: 'running',
+      message: 'Executable provider analysis started'
+    });
+  } catch (setupError) {
+    // Synchronous setup failure — clean up the analysis hold immediately
+    reviewToAnalysisId.delete(reviewId);
+    if (poolWorktreeId) {
+      poolLifecycle?.endAnalysis(analysisId);
+    }
+    throw setupError;
+  }
 
   // 5. Run the executable provider asynchronously
   (async () => {
     const tmpDir = await fsPromises.mkdtemp(path.join(os.tmpdir(), 'pair-review-exec-'));
     try {
-      const provider = createProvider(selectedProvider, selectedModel);
+      const provider = createProvider(selectedProvider, selectedModel, providerOverrides);
 
       const executableContext = {
         ...buildContext(review, { selectedModel, requestInstructions }),
@@ -476,6 +493,8 @@ async function runExecutableAnalysis(req, res, params, shared, callbacks) {
       // Do NOT delete activeAnalyses entry — leave it with terminal status so
       // clients can poll for final results via HTTP (matches local.js/pr.js).
       reviewToAnalysisId.delete(reviewId);
+      // Remove pool worktree analysis hold
+      poolLifecycle?.endAnalysis(analysisId);
 
       // Clean up temp directory (keep in debug mode for inspection)
       if (tmpDir) {

package/src/routes/local.js

@@ -24,7 +24,7 @@ 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 } = require('../config');
+const { getGitHubToken, resolveLoadSkills, buildCouncilProviderOverrides } = require('../config');
 const { generateScopedDiff, computeScopedDigest, getBranchCommitCount, getFirstCommitSubject, detectAndBuildBranchInfo, findMergeBase, getCurrentBranch, getRepositoryName } = require('../local-review');
 const { STOPS, isValidScope, normalizeScope, reviewScope, includesBranch, DEFAULT_SCOPE } = require('../local-scope');
 const { getGeneratedFilePatterns } = require('../git/gitattributes');
@@ -1023,7 +1023,8 @@ router.get('/api/local/:reviewId/check-stale', async (req, res) => {
  */
 async function handleExecutableAnalysis(req, res, {
   reviewId, review, localPath, repository, selectedProvider, selectedModel,
-  repoInstructions, requestInstructions, combinedInstructions, runId, analysisId, reviewRepo
+  repoInstructions, requestInstructions, combinedInstructions, runId, analysisId, reviewRepo,
+  providerOverrides
 }) {
   return runExecutableAnalysis(req, res, {
     reviewId,
@@ -1036,7 +1037,8 @@ async function handleExecutableAnalysis(req, res, {
     analysisId,
     repository,
     reviewType: review.review_type || 'local',
-    headSha: review.local_head_sha
+    headSha: review.local_head_sha,
+    providerOverrides
   }, {
     activeAnalyses,
     reviewToAnalysisId,
@@ -1171,6 +1173,11 @@ router.post('/api/local/:reviewId/analyses', async (req, res) => {
     const runId = uuidv4();
     const analysisId = runId;
 
+    // Resolve load_skills across all config tiers
+    const providerLoadSkills = appConfig.providers?.[selectedProvider]?.load_skills;
+    const loadSkills = resolveLoadSkills(appConfig, repository, repoSettings, providerLoadSkills);
+    const providerOverrides = { load_skills: loadSkills };
+
     // Check if selected provider is an executable provider (external tool)
     const ProviderClass = getProviderClass(selectedProvider);
     if (ProviderClass?.isExecutable) {
@@ -1186,7 +1193,8 @@ router.post('/api/local/:reviewId/analyses', async (req, res) => {
         combinedInstructions,
         runId,
         analysisId,
-        reviewRepo
+        reviewRepo,
+        providerOverrides
       });
     }
 
@@ -1258,7 +1266,7 @@ router.post('/api/local/:reviewId/analyses', async (req, res) => {
     }
 
     // Create analyzer instance with provider and model
-    const analyzer = new Analyzer(db, selectedModel, selectedProvider);
+    const analyzer = new Analyzer(db, selectedModel, selectedProvider, providerOverrides);
 
     // Build local review metadata for the analyzer
     // The analyzer uses base_sha and head_sha for git diff commands
@@ -2051,7 +2059,6 @@ router.post('/api/local/:reviewId/analyses/council', async (req, res) => {
       scopeEnd: councilScopeEnd,
     };
 
-    const analyzer = new Analyzer(db, 'council', 'council');
     // Use the scope-aware helper so the file list matches the generated diff
     // (covers branch, staged, unstaged, and untracked stops as appropriate).
     const changedFiles = await getChangedFiles(localPath, {
@@ -2085,6 +2092,10 @@ router.post('/api/local/:reviewId/analyses/council', async (req, res) => {
     // Import launchCouncilAnalysis from analyses.js
     const analysesRouter = require('./analyses');
     const localCouncilConfig = req.app.get('config') || {};
+
+    const { providerOverrides: councilProviderOverrides, providerOverridesMap: councilProviderOverridesMap } =
+      buildCouncilProviderOverrides(localCouncilConfig, review.repository, repoSettings);
+
     const { analysisId, runId } = await analysesRouter.launchCouncilAnalysis(
       db,
       {
@@ -2099,6 +2110,8 @@ router.post('/api/local/:reviewId/analyses/council', async (req, res) => {
         config: localCouncilConfig,
         excludePrevious,
         serverPort: req.socket.localPort,
+        providerOverrides: councilProviderOverrides,
+        providerOverridesMap: councilProviderOverridesMap,
         hookContext: {
           mode: 'local',
           localContext: { path: localPath, branch: review.local_head_branch, headSha: review.local_head_sha },

package/src/routes/mcp.js

@@ -23,6 +23,7 @@ const {
   createProgressCallback
 } = require('./shared');
 const { safeParseJson } = require('../utils/safe-parse-json');
+const { resolveLoadSkills } = require('../config');
 
 // All valid tier values: canonical tiers + aliases (for Zod enum validation)
 const ALL_TIER_VALUES = /** @type {[string, ...string[]]} */ ([...TIERS, ...Object.keys(TIER_ALIASES)]);
@@ -595,8 +596,13 @@ function createMCPServer(db, options = {}) {
           broadcastProgress(analysisId, initialStatus);
           broadcastReviewEvent(reviewId, { type: 'review:analysis_started', analysisId });
 
+          // Resolve load_skills across all config tiers
+          const providerLoadSkills = config.providers?.[provider]?.load_skills;
+          const loadSkills = resolveLoadSkills(config, repository, repoSettings, providerLoadSkills);
+          const providerOverrides = { load_skills: loadSkills };
+
           // Create analyzer and launch asynchronously
-          const analyzer = new Analyzer(db, model, provider);
+          const analyzer = new Analyzer(db, model, provider, providerOverrides);
           const localMetadata = {
             id: reviewId,
             repository: review.repository,
@@ -747,7 +753,12 @@ function createMCPServer(db, options = {}) {
           broadcastProgress(analysisId, initialStatus);
           broadcastReviewEvent(review.id, { type: 'review:analysis_started', analysisId });
 
-          const analyzer = new Analyzer(db, model, provider);
+          // Resolve load_skills across all config tiers
+          const prProviderLoadSkills = config.providers?.[provider]?.load_skills;
+          const prLoadSkills = resolveLoadSkills(config, repository, repoSettings, prProviderLoadSkills);
+          const prProviderOverrides = { load_skills: prLoadSkills };
+
+          const analyzer = new Analyzer(db, model, provider, prProviderOverrides);
           const progressCallback = createProgressCallback(analysisId);
           const tier = resolveTier(args.tier);
 

package/src/routes/pr.js

@@ -25,7 +25,7 @@ const Analyzer = require('../ai/analyzer');
 const { v4: uuidv4 } = require('uuid');
 const fs = require('fs').promises;
 const path = require('path');
-const { getGitHubToken } = require('../config');
+const { getGitHubToken, getWorktreeDisplayName, resolveLoadSkills, buildCouncilProviderOverrides } = require('../config');
 const logger = require('../utils/logger');
 const { buildDiffLineSet } = require('../utils/diff-annotator');
 const { broadcastReviewEvent } = require('../events/review-events');
@@ -278,6 +278,8 @@ router.get('/api/pr/:owner/:repo/:number', async (req, res) => {
         additions: extendedData.additions || 0,
         deletions: extendedData.deletions || 0,
         diff_content: extendedData.diff || '',
+        worktree_path: extendedData.worktree_path || null,
+        worktree_name: getWorktreeDisplayName(extendedData.worktree_path, req.app.get('config') || {}, repository),
         html_url: extendedData.html_url || `https://github.com/${repoOwner}/${repoName}/pull/${prMetadata.pr_number}`,
         pendingDraft: pendingDraft ? {
           id: pendingDraft.id,
@@ -392,7 +394,8 @@ router.post('/api/pr/:owner/:repo/:number/refresh', async (req, res) => {
       html_url: prData.html_url,
       base_sha: prData.base_sha,
       head_sha: prData.head_sha,
-      node_id: prData.node_id  // GraphQL node ID for PR (required for GraphQL review submission)
+      node_id: prData.node_id,  // GraphQL node ID for PR (required for GraphQL review submission)
+      worktree_path: worktreePath
     };
 
     // Update database with new data
@@ -485,7 +488,9 @@ router.post('/api/pr/:owner/:repo/:number/refresh', async (req, res) => {
         html_url: parsedData.html_url || `https://github.com/${repoOwner}/${repoName}/pull/${prMetadata.pr_number}`,
         head_sha: parsedData.head_sha,
         base_sha: parsedData.base_sha,
-        node_id: parsedData.node_id
+        node_id: parsedData.node_id,
+        worktree_path: parsedData.worktree_path || null,
+        worktree_name: getWorktreeDisplayName(parsedData.worktree_path, config, repository)
       }
     };
 
@@ -1513,7 +1518,7 @@ router.post('/api/parse-pr-url', (req, res) => {
 async function handleExecutablePRAnalysis(req, res, {
   reviewId, review, prNumber, owner, repo, repository, worktreePath, prMetadata,
   selectedProvider, selectedModel, repoInstructions, requestInstructions,
-  combinedInstructions, runId, analysisId, reviewRepo
+  combinedInstructions, runId, analysisId, reviewRepo, poolLifecycle, providerOverrides
 }) {
   const prContext = {
     number: prNumber, owner, repo,
@@ -1533,7 +1538,9 @@ async function handleExecutablePRAnalysis(req, res, {
     repository,
     reviewType: 'pr',
     headSha: prMetadata.head_sha,
-    extraInitialStatus: { prNumber }
+    extraInitialStatus: { prNumber },
+    poolLifecycle,
+    providerOverrides
   }, {
     activeAnalyses,
     reviewToAnalysisId,
@@ -1645,7 +1652,7 @@ 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 { provider, model, repoInstructions, combinedInstructions, repoSettings: fetchedRepoSettings } = await withTransaction(db, async () => {
       const repoSettingsRepo = new RepoSettingsRepository(db);
       const fetchedRepoSettings = await repoSettingsRepo.getRepoSettings(repository);
 
@@ -1678,7 +1685,8 @@ router.post('/api/pr/:owner/:repo/:number/analyses', async (req, res) => {
         provider: selectedProvider,
         model: selectedModel,
         repoInstructions: fetchedRepoInstructions,
-        combinedInstructions: mergedInstructions
+        combinedInstructions: mergedInstructions,
+        repoSettings: fetchedRepoSettings
       };
     });
 
@@ -1687,6 +1695,11 @@ router.post('/api/pr/:owner/:repo/:number/analyses', async (req, res) => {
 
     const { review } = await reviewRepo.getOrCreate({ prNumber, repository });
 
+    // Resolve load_skills across all config tiers
+    const providerLoadSkills = appConfig.providers?.[provider]?.load_skills;
+    const loadSkills = resolveLoadSkills(appConfig, repository, fetchedRepoSettings, providerLoadSkills);
+    const providerOverrides = { load_skills: loadSkills };
+
     // Check if selected provider is an executable provider (external tool)
     const ProviderClass = getProviderClass(provider);
     if (ProviderClass?.isExecutable) {
@@ -1706,7 +1719,9 @@ router.post('/api/pr/:owner/:repo/:number/analyses', async (req, res) => {
         combinedInstructions,
         runId,
         analysisId,
-        reviewRepo
+        reviewRepo,
+        poolLifecycle: req.app.get('poolLifecycle'),
+        providerOverrides
       });
     }
 
@@ -1753,37 +1768,56 @@ router.post('/api/pr/:owner/:repo/:number/analyses', async (req, res) => {
 
     broadcastProgress(analysisId, initialStatus);
     broadcastReviewEvent(review.id, { type: 'review:analysis_started', analysisId });
+
+    // Register analysis hold for pool worktree usage tracking.
+    // startAnalysis is inside the try so a synchronous exception in setup still
+    // cleans up the hold (the .finally() on the promise chain only covers async errors).
+    const poolLifecycle = req.app.get('poolLifecycle');
+    let poolWorktreeId;
     const analysisConfig = appConfig;
     const analysisPrContext = {
       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,
     };
-    if (hasHooks('analysis.started', analysisConfig)) {
-      getCachedUser(analysisConfig).then(user => {
-        fireHooks('analysis.started', buildAnalysisStartedPayload({
-          reviewId: review.id, analysisId, provider, model, mode: 'pr', prContext: analysisPrContext, user,
-        }), analysisConfig);
-      }).catch(() => {});
-    }
+    let analysisPromise;
+    try {
+      poolWorktreeId = await poolLifecycle?.startAnalysis(review.id, analysisId);
+      if (hasHooks('analysis.started', analysisConfig)) {
+        getCachedUser(analysisConfig).then(user => {
+          fireHooks('analysis.started', buildAnalysisStartedPayload({
+            reviewId: review.id, analysisId, provider, model, mode: 'pr', prContext: analysisPrContext, user,
+          }), analysisConfig);
+        }).catch(() => {});
+      }
 
-    const analyzer = new Analyzer(req.app.get('db'), model, provider);
+      const analyzer = new Analyzer(req.app.get('db'), model, provider, providerOverrides);
+
+      logger.section(`AI Analysis Request - PR #${prNumber}`);
+      logger.log('API', `Repository: ${repository}`, 'magenta');
+      logger.log('API', `Worktree: ${worktreePath}`, 'magenta');
+      logger.log('API', `Analysis ID: ${analysisId}`, 'magenta');
+      logger.log('API', `Review ID: ${review.id}`, 'magenta');
+      logger.log('API', `Provider: ${provider}`, 'cyan');
+      logger.log('API', `Model: ${model}`, 'cyan');
+      logger.log('API', `Tier: ${tier}`, 'cyan');
+      if (combinedInstructions) {
+        logger.log('API', `Custom instructions: ${combinedInstructions.length} chars`, 'cyan');
+      }
 
-    logger.section(`AI Analysis Request - PR #${prNumber}`);
-    logger.log('API', `Repository: ${repository}`, 'magenta');
-    logger.log('API', `Worktree: ${worktreePath}`, 'magenta');
-    logger.log('API', `Analysis ID: ${analysisId}`, 'magenta');
-    logger.log('API', `Review ID: ${review.id}`, 'magenta');
-    logger.log('API', `Provider: ${provider}`, 'cyan');
-    logger.log('API', `Model: ${model}`, 'cyan');
-    logger.log('API', `Tier: ${tier}`, 'cyan');
-    if (combinedInstructions) {
-      logger.log('API', `Custom instructions: ${combinedInstructions.length} chars`, 'cyan');
-    }
+      const progressCallback = createProgressCallback(analysisId);
 
-    const progressCallback = createProgressCallback(analysisId);
+      analysisPromise = 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 });
+    } catch (setupError) {
+      // Synchronous setup failure — clean up the analysis hold immediately
+      reviewToAnalysisId.delete(review.id);
+      if (poolWorktreeId) {
+        poolLifecycle?.endAnalysis(analysisId);
+      }
+      throw setupError;
+    }
 
-    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 })
+    analysisPromise
       .then(async result => {
         logger.section('Analysis Results');
         logger.success(`Analysis complete for PR #${prNumber}`);
@@ -1929,6 +1963,8 @@ router.post('/api/pr/:owner/:repo/:number/analyses', async (req, res) => {
       .finally(() => {
         // Clean up review to analysis ID mapping (unified map)
         reviewToAnalysisId.delete(review.id);
+        // Remove pool worktree analysis hold
+        poolLifecycle?.endAnalysis(analysisId);
       });
 
     res.json({
@@ -2013,6 +2049,10 @@ router.post('/api/pr/:owner/:repo/:number/analyses/council', async (req, res) =>
     }
 
     const prCouncilConfig = req.app.get('config') || {};
+
+    const { providerOverrides: councilProviderOverrides, providerOverridesMap: councilProviderOverridesMap } =
+      buildCouncilProviderOverrides(prCouncilConfig, repository, repoSettings);
+
     const { analysisId, runId } = await analysesRouter.launchCouncilAnalysis(
       db,
       {
@@ -2027,6 +2067,9 @@ router.post('/api/pr/:owner/:repo/:number/analyses/council', async (req, res) =>
         config: prCouncilConfig,
         excludePrevious,
         serverPort: req.socket.localPort,
+        poolLifecycle: req.app.get('poolLifecycle'),
+        providerOverrides: councilProviderOverrides,
+        providerOverridesMap: councilProviderOverridesMap,
         hookContext: {
           mode: 'pr',
           prContext: {

package/src/routes/setup.js

@@ -16,7 +16,7 @@ const { activeSetups, broadcastSetupProgress } = require('./shared');
 const { setupPRReview } = require('../setup/pr-setup');
 const { setupLocalReview } = require('../setup/local-setup');
 const { getGitHubToken, expandPath } = require('../config');
-const { queryOne } = require('../database');
+const { queryOne, ReviewRepository } = require('../database');
 const { normalizeRepository } = require('../utils/paths');
 const logger = require('../utils/logger');
 
@@ -81,7 +81,7 @@ router.post('/api/setup/pr/:owner/:repo/:number', async (req, res) => {
     const repository = normalizeRepository(owner, repo);
     const existingPR = await queryOne(
       db,
-      'SELECT id FROM pr_metadata WHERE pr_number = ? AND repository = ? COLLATE NOCASE',
+      'SELECT id, pr_data FROM pr_metadata WHERE pr_number = ? AND repository = ? COLLATE NOCASE',
       [prNumber, repository]
     );
     if (existingPR) {
@@ -91,9 +91,44 @@ router.post('/api/setup/pr/:owner/:repo/:number', async (req, res) => {
         [prNumber, repository]
       );
       if (worktree) {
-        return res.json({ existing: true, reviewUrl: `/pr/${owner}/${repo}/${prNumber}` });
+        // If the worktree belongs to the pool, verify it is still actively
+        // owned (in_use). Pool slots retain their worktrees row after being
+        // released — markAvailable() clears ownership without deleting the
+        // record. A released slot may have been reassigned to a different PR,
+        // so we must fall through to re-run setup and reacquire a pool slot.
+        const poolLifecycle = req.app.get('poolLifecycle');
+        const poolEntry = poolLifecycle ? await poolLifecycle.poolRepo.getPoolEntry(worktree.id) : null;
+        if (poolEntry && poolEntry.status !== 'in_use') {
+          if (poolEntry.status === 'available' && poolEntry.current_pr_number === prNumber) {
+            // Still associated with this PR — reclaim without re-setup
+            logger.info(`Reclaiming pool worktree ${worktree.id} for ${repository} #${prNumber} (was ${poolEntry.status})`);
+            await poolLifecycle.poolRepo.markInUse(poolEntry.id, prNumber);
+            const reviewRepo = new ReviewRepository(db);
+            const { review } = await reviewRepo.getOrCreate({ prNumber, repository });
+            await poolLifecycle.poolRepo.setCurrentReviewId(poolEntry.id, review.id);
+            return res.json({ existing: true, reviewUrl: `/pr/${owner}/${repo}/${prNumber}` });
+          }
+          logger.info(`Pool worktree ${worktree.id} for ${repository} #${prNumber} is ${poolEntry.status}, re-running setup to reacquire`);
+        } else {
+          return res.json({ existing: true, reviewUrl: `/pr/${owner}/${repo}/${prNumber}` });
+        }
+      } else {
+        logger.info(`PR metadata exists but worktree missing for ${repository} #${prNumber}, re-running setup`);
+      }
+    }
+
+    // If we have stored PR data with a head_sha, pass it to setupPRReview
+    // so it can attempt restore mode (skip GitHub fetch + diff regeneration).
+    let restoreMetadata = null;
+    if (existingPR && existingPR.pr_data) {
+      try {
+        const parsed = JSON.parse(existingPR.pr_data);
+        if (parsed.head_sha) {
+          restoreMetadata = parsed;
+        }
+      } catch (e) {
+        logger.warn(`Could not parse stored pr_data for ${repository} #${prNumber}`);
       }
-      logger.info(`PR metadata exists but worktree missing for ${repository} #${prNumber}, re-running setup`);
     }
 
     // Start the async setup
@@ -108,6 +143,8 @@ router.post('/api/setup/pr/:owner/:repo/:number', async (req, res) => {
           prNumber,
           githubToken,
           config,
+          poolLifecycle: req.app.get('poolLifecycle'),
+          restoreMetadata,
           onProgress: (progress) => {
             sendSetupEvent(setupId, 'step', progress);
           }

package/src/routes/stack-analysis.js

@@ -19,7 +19,7 @@ const { normalizeRepository } = require('../utils/paths');
 const { mergeInstructions } = require('../utils/instructions');
 const { GitWorktreeManager } = require('../git/worktree');
 const { GitHubClient } = require('../github/client');
-const { getGitHubToken } = require('../config');
+const { getGitHubToken, resolveLoadSkills, buildCouncilProviderOverrides } = require('../config');
 const { setupStackPR } = require('../setup/stack-setup');
 const Analyzer = require('../ai/analyzer');
 const { getProviderClass, createProvider } = require('../ai/provider');
@@ -265,7 +265,7 @@ async function executeStackAnalysis(params) {
         broadcastStackProgress(stackAnalysisId, state);
 
         const prInfo = { owner, repo, number: prNum };
-        const perPRWorktreePath = await worktreeManager.createWorktreeForPR(
+        const { path: perPRWorktreePath } = await worktreeManager.createWorktreeForPR(
           prInfo, prData, repositoryPath
         );
         worktreePathMap.set(prNum, perPRWorktreePath);
@@ -374,29 +374,41 @@ async function analyzeStackPR(deps, db, config, {
   let analysisResult;
 
   if (configType === 'council' || configType === 'advanced' || isCouncil) {
+    const { providerOverrides: councilProviderOverrides, providerOverridesMap: councilProviderOverridesMap } =
+      buildCouncilProviderOverrides(config, repository, repoSettings);
+
     analysisResult = await launchStackCouncilAnalysis(deps, db, config, {
       reviewId, worktreePath, prMetadata, prNum, owner, repo, repository,
       globalInstructions, repoInstructions, requestInstructions,
-      councilId, rawCouncilConfig, configType, onAnalysisIdReady
+      councilId, rawCouncilConfig, configType, onAnalysisIdReady,
+      providerOverrides: councilProviderOverrides,
+      providerOverridesMap: councilProviderOverridesMap
     });
   } else {
     let selectedProvider = reqProvider || repoSettings?.default_provider || config.default_provider || config.provider || 'claude';
     let selectedModel = reqModel || repoSettings?.default_model || config.default_model || config.model || 'opus';
 
+    // Resolve load_skills across all config tiers
+    const providerLoadSkills = config.providers?.[selectedProvider]?.load_skills;
+    const loadSkills = resolveLoadSkills(config, repository, repoSettings, providerLoadSkills);
+    const providerOverrides = { load_skills: loadSkills };
+
     const ProviderClass = deps.getProviderClass(selectedProvider);
 
     if (ProviderClass?.isExecutable) {
       analysisResult = await launchStackExecutableAnalysis(deps, db, config, {
         reviewId, worktreePath, prMetadata, prNum, owner, repo, repository,
         selectedProvider, selectedModel,
-        repoInstructions, requestInstructions, onAnalysisIdReady
+        repoInstructions, requestInstructions, onAnalysisIdReady,
+        providerOverrides
       });
     } else {
       analysisResult = await launchStackSingleAnalysis(deps, db, config, {
         reviewId, worktreePath, prMetadata, prNum, owner, repo, repository,
         selectedProvider, selectedModel,
         globalInstructions, repoInstructions, requestInstructions,
-        reqTier, reqEnabledLevels, onAnalysisIdReady
+        reqTier, reqEnabledLevels, onAnalysisIdReady,
+        providerOverrides
       });
     }
   }
@@ -415,7 +427,8 @@ async function launchStackSingleAnalysis(deps, db, config, {
   reviewId, worktreePath, prMetadata, prNum, owner, repo, repository,
   selectedProvider, selectedModel,
   globalInstructions, repoInstructions, requestInstructions,
-  reqTier, reqEnabledLevels, onAnalysisIdReady
+  reqTier, reqEnabledLevels, onAnalysisIdReady,
+  providerOverrides = {}
 }) {
   const runId = uuidv4();
   const analysisId = runId;
@@ -462,7 +475,7 @@ async function launchStackSingleAnalysis(deps, db, config, {
   broadcastProgress(analysisId, initialStatus);
   broadcastReviewEvent(reviewId, { type: 'review:analysis_started', analysisId });
 
-  const analyzer = new deps.Analyzer(db, selectedModel, selectedProvider);
+  const analyzer = new deps.Analyzer(db, selectedModel, selectedProvider, providerOverrides);
   const progressCallback = createProgressCallback(analysisId);
 
   logger.info(`Stack analysis: starting single-model analysis for PR #${prNum} (${selectedProvider}/${selectedModel})`);
@@ -538,7 +551,9 @@ async function launchStackSingleAnalysis(deps, db, config, {
 async function launchStackCouncilAnalysis(deps, db, config, {
   reviewId, worktreePath, prMetadata, prNum, owner, repo, repository,
   globalInstructions, repoInstructions, requestInstructions,
-  councilId, rawCouncilConfig, configType, onAnalysisIdReady
+  councilId, rawCouncilConfig, configType, onAnalysisIdReady,
+  providerOverrides = {},
+  providerOverridesMap = null
 }) {
   let councilConfig;
   let resolvedConfigType = configType;
@@ -580,6 +595,8 @@ async function launchStackCouncilAnalysis(deps, db, config, {
       logLabel: `Stack PR #${prNum}`,
       initialStatusExtra: { prNumber: prNum, reviewType: 'pr' },
       config,
+      providerOverrides,
+      providerOverridesMap,
       hookContext: {
         mode: 'pr',
         prContext: {
@@ -623,7 +640,8 @@ async function launchStackCouncilAnalysis(deps, db, config, {
 async function launchStackExecutableAnalysis(deps, db, config, {
   reviewId, worktreePath, prMetadata, prNum, owner, repo, repository,
   selectedProvider, selectedModel,
-  repoInstructions, requestInstructions, onAnalysisIdReady
+  repoInstructions, requestInstructions, onAnalysisIdReady,
+  providerOverrides = {}
 }) {
   const runId = uuidv4();
   const analysisId = runId;
@@ -671,7 +689,8 @@ async function launchStackExecutableAnalysis(deps, db, config, {
     repository,
     reviewType: 'pr',
     headSha: prMetadata.head_sha,
-    extraInitialStatus: { prNumber: prNum }
+    extraInitialStatus: { prNumber: prNum },
+    providerOverrides
   }, {
     activeAnalyses,
     reviewToAnalysisId,