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

package/src/main.js

@@ -1,10 +1,11 @@
 // Copyright 2026 Tim Perkins (tjwp) | SPDX-License-Identifier: Apache-2.0
 const fs = require('fs');
-const { loadConfig, getConfigDir, getGitHubToken, showWelcomeMessage, resolveDbName, resolveMonorepoOptions } = require('./config');
-const { initializeDatabase, run, queryOne, query, migrateExistingWorktrees, WorktreeRepository, ReviewRepository, RepoSettingsRepository, GitHubReviewRepository } = require('./database');
+const { loadConfig, getConfigDir, getGitHubToken, showWelcomeMessage, resolveDbName, resolveRepoOptions, resolvePoolConfig, getRepoResetScript, resolveLoadSkills } = require('./config');
+const { initializeDatabase, run, queryOne, query, migrateExistingWorktrees, WorktreeRepository, ReviewRepository, RepoSettingsRepository, GitHubReviewRepository, WorktreePoolRepository } = require('./database');
 const { PRArgumentParser } = require('./github/parser');
 const { GitHubClient } = require('./github/client');
 const { GitWorktreeManager } = require('./git/worktree');
+const { WorktreePoolLifecycle } = require('./git/worktree-pool-lifecycle');
 const { startServer } = require('./server');
 const Analyzer = require('./ai/analyzer');
 const { applyConfigOverrides } = require('./ai');
@@ -445,6 +446,10 @@ AI PROVIDERS:
       console.warn('Some worktrees could not be migrated:', migrationResult.errors);
     }
 
+    // Reset stale pool entries, wire idle callbacks, and rehydrate preserved entries
+    const poolLifecycle = new WorktreePoolLifecycle(db, config);
+    await poolLifecycle.resetAndRehydrate();
+
     // Parse command line arguments including flags
     const { prArgs, flags } = parseArgs(args);
 
@@ -477,8 +482,9 @@ AI PROVIDERS:
       // Async cleanup of stale worktrees and reviews (don't block startup)
       cleanupStaleWorktreesAsync(config);
       cleanupStaleReviewsAsync(config);
+      startPoolBackgroundFetches(db, config);
 
-      return; // Exit after local review
+      return;
     }
 
     // Auto-detect GitHub Actions environment
@@ -510,11 +516,11 @@ AI PROVIDERS:
 
       // Check for --ai-review mode (takes precedence over --ai-draft and --ai)
       if (flags.aiReview) {
-        await handleActionReview(effectivePrArgs, config, db, flags);
+        await handleActionReview(effectivePrArgs, config, db, flags, poolLifecycle);
       } else if (flags.aiDraft) {
-        await handleDraftModeReview(effectivePrArgs, config, db, flags);
+        await handleDraftModeReview(effectivePrArgs, config, db, flags, poolLifecycle);
       } else {
-        await handlePullRequest(effectivePrArgs, config, db, flags);
+        await handlePullRequest(effectivePrArgs, config, db, flags, poolLifecycle);
       }
     } else {
       // Check if --ai or --ai-draft flags were used without PR identifier
@@ -530,7 +536,7 @@ AI PROVIDERS:
 
       // No PR arguments - just start the server
       console.log('No pull request specified. Starting server...');
-      await startServerOnly(config);
+      await startServerOnly(config, poolLifecycle);
     }
     
   } catch (error) {
@@ -545,8 +551,9 @@ AI PROVIDERS:
  * @param {Object} config - Application configuration
  * @param {Object} db - Database instance
  * @param {Object} flags - Parsed command line flags
+ * @param {import('./git/worktree-pool-lifecycle').WorktreePoolLifecycle} [poolLifecycle] - Pool lifecycle instance
  */
-async function handlePullRequest(args, config, db, flags = {}) {
+async function handlePullRequest(args, config, db, flags = {}, poolLifecycle = null) {
   try {
     // Get GitHub token (env var takes precedence over config)
     const githubToken = getGitHubToken(config);
@@ -571,11 +578,12 @@ async function handlePullRequest(args, config, db, flags = {}) {
     }
 
     // Start server and open browser to setup page
-    const port = await startServer(db);
+    const port = await startServer(db, poolLifecycle);
 
     // Async cleanup of stale worktrees and reviews (don't block startup)
     cleanupStaleWorktreesAsync(config);
     cleanupStaleReviewsAsync(config);
+    startPoolBackgroundFetches(db, config);
 
     let url = `http://localhost:${port}/pr/${prInfo.owner}/${prInfo.repo}/${prInfo.number}`;
     if (flags.ai) {
@@ -594,13 +602,15 @@ async function handlePullRequest(args, config, db, flags = {}) {
 /**
  * Start server without PR context
  * @param {Object} config - Application configuration
+ * @param {import('./git/worktree-pool-lifecycle').WorktreePoolLifecycle} [poolLifecycle] - Pool lifecycle instance
  */
-async function startServerOnly(config) {
-  const port = await startServer(db);
+async function startServerOnly(config, poolLifecycle = null) {
+  const port = await startServer(db, poolLifecycle);
 
   // Async cleanup of stale worktrees and reviews (don't block startup)
   cleanupStaleWorktreesAsync(config);
   cleanupStaleReviewsAsync(config);
+  startPoolBackgroundFetches(db, config);
 
   // Open browser to landing page
   const url = `http://localhost:${port}/`;
@@ -641,9 +651,12 @@ function formatAISuggestion(text, category) {
  * @param {string} options.reviewEvent - 'DRAFT' or 'COMMENT'
  * @param {string} options.commentStatus - 'draft' or 'submitted'
  * @param {string} options.modeLabel - Display label for log messages (e.g., 'draft mode', 'action review mode')
+ * @param {import('../git/worktree-pool-lifecycle').WorktreePoolLifecycle} [externalPoolLifecycle] - Shared pool lifecycle instance (avoids creating a fresh singleton)
  */
-async function performHeadlessReview(args, config, db, flags, options) {
+async function performHeadlessReview(args, config, db, flags, options, externalPoolLifecycle = null) {
   let prInfo = null;
+  let poolWorktreeId = null;
+  let poolLifecycle = null;
 
   try {
     // Get GitHub token (env var takes precedence over config)
@@ -746,6 +759,8 @@ async function performHeadlessReview(args, config, db, flags, options) {
       let checkoutScript;
       let checkoutTimeout;
       let worktreeConfig = null;
+      let poolSize = 0;
+      let resetScript = null;
       if (isMatchingRepo) {
         // Current directory is a checkout of the target repository
         repositoryPath = currentDir;
@@ -753,10 +768,14 @@ async function performHeadlessReview(args, config, db, flags, options) {
 
         // Resolve monorepo config options (checkout_script, worktree_directory, worktree_name_template)
         // even when running from inside the target repo, so they are not silently ignored.
-        const resolved = resolveMonorepoOptions(config, repository);
+        const repoSettingsRepo = new RepoSettingsRepository(db);
+        const repoSettings = await repoSettingsRepo.getRepoSettings(repository);
+        const resolved = resolveRepoOptions(config, repository, repoSettings);
         checkoutScript = resolved.checkoutScript;
         checkoutTimeout = resolved.checkoutTimeout;
         worktreeConfig = resolved.worktreeConfig;
+        poolSize = resolved.poolSize || 0;
+        resetScript = resolved.resetScript || null;
       } else {
         // Current directory is not the target repository - find or clone it
         console.log(`Current directory is not a checkout of ${prInfo.owner}/${prInfo.repo}, locating repository...`);
@@ -778,15 +797,37 @@ async function performHeadlessReview(args, config, db, flags, options) {
         checkoutScript = result.checkoutScript;
         checkoutTimeout = result.checkoutTimeout;
         worktreeConfig = result.worktreeConfig;
+        // findRepositoryPath doesn't return pool config; resolve from DB + file config
+        const repoSettingsRepo = new RepoSettingsRepository(db);
+        const repoSettings = await repoSettingsRepo.getRepoSettings(repository);
+        const { poolSize: resolvedPoolSize, poolFetchIntervalMinutes: _resolvedFetchInterval } = resolvePoolConfig(config, repository, repoSettings);
+        poolSize = resolvedPoolSize || 0;
+        resetScript = config ? getRepoResetScript(config, repository) : null;
       }
 
-      console.log('Setting up git worktree...');
       const worktreeManager = new GitWorktreeManager(db, worktreeConfig || {});
-      worktreePath = await worktreeManager.createWorktreeForPR(prInfo, prData, repositoryPath, {
-        worktreeSourcePath,
-        checkoutScript,
-        checkoutTimeout
-      });
+      if (poolSize > 0) {
+        // Pool mode: use WorktreePoolLifecycle
+        console.log('Acquiring pool worktree...');
+        poolLifecycle = externalPoolLifecycle || new WorktreePoolLifecycle(db, config);
+        const result = await poolLifecycle.acquireForPR(
+          { owner: prInfo.owner, repo: prInfo.repo, prNumber: prInfo.number, repository },
+          prData,
+          repositoryPath,
+          { worktreeSourcePath, checkoutScript, checkoutTimeout, resetScript, worktreeConfig, poolSize }
+        );
+        worktreePath = result.worktreePath;
+        poolWorktreeId = result.worktreeId;
+        console.log('Pool worktree acquired');
+      } else {
+        // Non-pool mode: existing behavior
+        console.log('Setting up git worktree...');
+        ({ path: worktreePath } = await worktreeManager.createWorktreeForPR(prInfo, prData, repositoryPath, {
+          worktreeSourcePath,
+          checkoutScript,
+          checkoutTimeout
+        }));
+      }
 
       console.log('Generating unified diff...');
       diff = await worktreeManager.generateUnifiedDiff(worktreePath, prData);
@@ -799,6 +840,11 @@ async function performHeadlessReview(args, config, db, flags, options) {
       skipWorktreeRecord: !!flags.useCheckout
     });
 
+    // Persist review→worktree mapping in DB for pool usage tracking
+    if (poolWorktreeId && poolLifecycle) {
+      await poolLifecycle.setReviewOwner(poolWorktreeId, storedReviewId);
+    }
+
     // Fire review.started hook for new reviews (non-blocking)
     if (isNewReview) {
       fireReviewStartedHook({
@@ -833,8 +879,12 @@ async function performHeadlessReview(args, config, db, flags, options) {
 
     // Run AI analysis
     console.log('Running AI analysis (all 3 levels)...');
-    const model = flags.model || process.env.PAIR_REVIEW_MODEL || 'opus';
-    const analyzer = new Analyzer(db, model);
+    const cliProvider = repoSettings?.default_provider || config.default_provider || config.provider || 'claude';
+    const model = flags.model || process.env.PAIR_REVIEW_MODEL || repoSettings?.default_model || config.default_model || config.model || 'opus';
+    const providerLoadSkills = config.providers?.[cliProvider]?.load_skills;
+    const loadSkills = resolveLoadSkills(config, repository, repoSettings, providerLoadSkills);
+    const providerOverrides = { load_skills: loadSkills };
+    const analyzer = new Analyzer(db, model, cliProvider, providerOverrides);
 
     let analysisSummary = null;
     try {
@@ -1039,7 +1089,19 @@ Found ${validSuggestions.length} suggestion${validSuggestions.length === 1 ? ''
       // For other errors, show a clean message without stack trace
       console.error(`\n❌ Error: ${error.message}\n`);
     }
-    process.exit(1);
+    process.exitCode = 1;
+  } finally {
+    // Release pool worktree after headless review completes (success or failure).
+    // Headless reviews are fire-and-forget with no persistent browser session,
+    // so the pool slot must be freed immediately.
+    if (poolWorktreeId && poolLifecycle) {
+      try {
+        await poolLifecycle.releaseAfterHeadless(poolWorktreeId);
+        logger.info(`Released pool worktree ${poolWorktreeId} after headless review`);
+      } catch (releaseErr) {
+        logger.error(`Failed to release pool worktree ${poolWorktreeId}: ${releaseErr.message}`);
+      }
+    }
   }
 }
 
@@ -1050,14 +1112,15 @@ Found ${validSuggestions.length} suggestion${validSuggestions.length === 1 ? ''
  * @param {Object} config - Application configuration
  * @param {Object} db - Database instance
  * @param {Object} flags - Parsed command line flags
+ * @param {import('../git/worktree-pool-lifecycle').WorktreePoolLifecycle} [poolLifecycle] - Shared pool lifecycle instance
  */
-async function handleDraftModeReview(args, config, db, flags = {}) {
+async function handleDraftModeReview(args, config, db, flags = {}, poolLifecycle = null) {
   await performHeadlessReview(args, config, db, flags, {
     mode: 'draft',
     reviewEvent: 'DRAFT',
     commentStatus: 'draft',
     modeLabel: 'draft mode'
-  });
+  }, poolLifecycle);
 }
 
 /**
@@ -1068,14 +1131,110 @@ async function handleDraftModeReview(args, config, db, flags = {}) {
  * @param {Object} config - Application configuration
  * @param {Object} db - Database instance
  * @param {Object} flags - Parsed command line flags
+ * @param {import('../git/worktree-pool-lifecycle').WorktreePoolLifecycle} [poolLifecycle] - Shared pool lifecycle instance
  */
-async function handleActionReview(args, config, db, flags = {}) {
+async function handleActionReview(args, config, db, flags = {}, poolLifecycle = null) {
   await performHeadlessReview(args, config, db, flags, {
     mode: 'review',
     reviewEvent: 'COMMENT',
     commentStatus: 'submitted',
     modeLabel: 'action review mode'
-  });
+  }, poolLifecycle);
+}
+
+/**
+ * Start periodic background fetches for pool worktrees.
+ * For each repo with pool_fetch_interval_minutes configured, run git fetch
+ * on all pool worktrees serially, coldest first.
+ * @param {Object} db - Database instance
+ * @param {Object} config - Configuration object
+ */
+const POOL_FETCH_TICK_MS = 60 * 1000; // Check every minute
+
+function startPoolBackgroundFetches(db, config) {
+  let fetchInProgress = false;
+
+  const timer = setInterval(async () => {
+    if (fetchInProgress) return;
+    fetchInProgress = true;
+    try {
+      const poolRepo = new WorktreePoolRepository(db);
+      const repoSettingsRepo = new RepoSettingsRepository(db);
+
+      // Collect repos that might have pool config from either source.
+      // Normalize to lowercase to match the database's COLLATE NOCASE identity.
+      const repoNames = new Set(Object.keys(config.repos || {}).map(r => r.toLowerCase()));
+      const allRepoSettings = await query(db, 'SELECT repository, pool_size, pool_fetch_interval_minutes FROM repo_settings WHERE pool_size IS NOT NULL OR pool_fetch_interval_minutes IS NOT NULL');
+      for (const row of allRepoSettings) {
+        repoNames.add(row.repository.toLowerCase());
+      }
+
+      if (repoNames.size === 0) return;
+
+      for (const repoName of repoNames) {
+        const repoSettings = allRepoSettings.find(r => r.repository.toLowerCase() === repoName.toLowerCase()) || null;
+        const { poolSize, poolFetchIntervalMinutes } = resolvePoolConfig(config, repoName, repoSettings);
+        if (!poolSize || !poolFetchIntervalMinutes) continue;
+
+        const intervalMs = poolFetchIntervalMinutes * 60 * 1000;
+        const worktrees = await poolRepo.findAllForFetch(repoName);
+
+        // Check if any worktree actually needs fetching before claiming the lease
+        const needsFetch = worktrees.some(entry => {
+          if (!entry.last_fetched_at) return true;
+          const elapsed = Date.now() - new Date(entry.last_fetched_at).getTime();
+          return elapsed >= intervalMs;
+        });
+        if (!needsFetch) continue;
+
+        // Atomically claim the fetch lease — skips if another instance holds it.
+        // Pool worktrees share a git object store so concurrent fetches conflict.
+        if (!(await repoSettingsRepo.tryClaimFetch(repoName))) {
+          logger.info(`Background fetch skipped for ${repoName}: another instance is fetching`);
+          continue;
+        }
+        try {
+          for (const entry of worktrees) {
+            // Skip if fetched recently (within the configured interval)
+            if (entry.last_fetched_at) {
+              const elapsed = Date.now() - new Date(entry.last_fetched_at).getTime();
+              if (elapsed < intervalMs) continue;
+            }
+
+            logger.info(`Background fetch starting for ${repoName} pool worktree ${entry.id}`);
+            try {
+              const git = simpleGit(entry.path, { timeout: { block: 300000 } });
+              const remotes = await git.getRemotes();
+              const remote = remotes.find(r => r.name === 'origin') || remotes[0];
+              if (remote) await git.fetch([remote.name, '--prune']);
+              await poolRepo.updateLastFetched(entry.id);
+              // Refresh the lease so the stale guard only needs to outlive
+              // a single stalled fetch, not the entire serial loop.
+              await repoSettingsRepo.refreshFetchLease(repoName);
+              logger.info(`Background fetch complete for ${repoName} pool worktree ${entry.id}`);
+            } catch (fetchErr) {
+              logger.warn(`Background fetch failed for ${entry.id}: ${fetchErr.message}`);
+            }
+          }
+        } finally {
+          try {
+            await repoSettingsRepo.markFetchFinished(repoName);
+          } catch (finishErr) {
+            logger.warn(`Failed to release fetch lease for ${repoName}: ${finishErr.message}`);
+          }
+        }
+      }
+    } catch (err) {
+      logger.error(`Background pool fetch error: ${err.message}`, err);
+    } finally {
+      fetchInProgress = false;
+    }
+  }, POOL_FETCH_TICK_MS);
+
+  // Don't keep the process alive just for background fetches
+  if (timer.unref) timer.unref();
+
+  logger.info(`Background pool fetch ticker started (checking every ${POOL_FETCH_TICK_MS / 1000}s)`);
 }
 
 /**

package/src/routes/analyses.js

@@ -37,6 +37,7 @@ const { generateLocalDiff, computeLocalDiffDigest, getCurrentBranch } = require(
 const { validateCouncilConfig, normalizeCouncilConfig } = require('./councils');
 const { TIERS, TIER_ALIASES, VALID_TIERS, resolveTier } = require('../ai/prompts/config');
 
+
 const router = express.Router();
 
 /**
@@ -493,6 +494,8 @@ async function launchCouncilAnalysis(db, modeContext, councilConfig, councilId,
     config: modeConfig,
     excludePrevious,
     serverPort,
+    providerOverrides = {},
+    providerOverridesMap = null,
     hookContext = {},
   } = modeContext;
 
@@ -563,38 +566,55 @@ async function launchCouncilAnalysis(db, modeContext, councilConfig, councilId,
 
   broadcastProgress(analysisId, initialStatus);
   broadcastReviewEvent(reviewId, { 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 = modeContext?.poolLifecycle;
+  let poolWorktreeId;
   const effectiveConfig = modeConfig || {};
-  if (hasHooks('analysis.started', effectiveConfig)) {
-    getCachedUser(effectiveConfig).then(user => {
-      fireHooks('analysis.started', buildAnalysisStartedPayload({
-        reviewId, analysisId, provider: 'council', model: councilId || 'inline-config',
-        mode: initialStatusExtra?.reviewType || 'pr',
-        prContext: hookContext.prContext, localContext: hookContext.localContext,
-        user,
-      }), effectiveConfig);
-    }).catch(err => { logger.warn(`Analysis hook failed: ${err.message}`); });
-  }
+  let analysisPromise;
+  try {
+    poolWorktreeId = await poolLifecycle?.startAnalysis(reviewId, analysisId);
+    if (hasHooks('analysis.started', effectiveConfig)) {
+      getCachedUser(effectiveConfig).then(user => {
+        fireHooks('analysis.started', buildAnalysisStartedPayload({
+          reviewId, analysisId, provider: 'council', model: councilId || 'inline-config',
+          mode: initialStatusExtra?.reviewType || 'pr',
+          prContext: hookContext.prContext, localContext: hookContext.localContext,
+          user,
+        }), effectiveConfig);
+      }).catch(err => { logger.warn(`Analysis hook failed: ${err.message}`); });
+    }
 
-  const analyzer = new Analyzer(db, 'council', 'council');
+    const analyzer = new Analyzer(db, 'council', 'council', providerOverrides, providerOverridesMap);
 
-  logger.section(`Council Analysis Request (${configType}) - ${logLabel}`);
-  logger.log('API', `Repository: ${repository}`, 'magenta');
-  logger.log('API', `Analysis ID: ${analysisId}`, 'magenta');
-  logger.log('API', `Config type: ${configType}`, 'magenta');
+    logger.section(`Council Analysis Request (${configType}) - ${logLabel}`);
+    logger.log('API', `Repository: ${repository}`, 'magenta');
+    logger.log('API', `Analysis ID: ${analysisId}`, 'magenta');
+    logger.log('API', `Config type: ${configType}`, 'magenta');
 
-  const progressCallback = createProgressCallback(analysisId);
+    const progressCallback = createProgressCallback(analysisId);
 
-  const reviewContext = {
-    reviewId,
-    worktreePath,
-    prMetadata,
-    changedFiles,
-    instructions: { globalInstructions, repoInstructions, requestInstructions }
-  };
+    const reviewContext = {
+      reviewId,
+      worktreePath,
+      prMetadata,
+      changedFiles,
+      instructions: { globalInstructions, repoInstructions, requestInstructions }
+    };
 
-  const analysisPromise = isVoiceCentric
-    ? analyzer.runReviewerCentricCouncil(reviewContext, councilConfig, { analysisId, runId, progressCallback, excludePrevious, serverPort })
-    : analyzer.runCouncilAnalysis(reviewContext, councilConfig, { analysisId, runId, progressCallback, excludePrevious, serverPort });
+    analysisPromise = isVoiceCentric
+      ? analyzer.runReviewerCentricCouncil(reviewContext, councilConfig, { analysisId, runId, progressCallback, excludePrevious, serverPort })
+      : analyzer.runCouncilAnalysis(reviewContext, councilConfig, { analysisId, runId, progressCallback, excludePrevious, serverPort });
+  } catch (setupError) {
+    // Synchronous setup failure — clean up the analysis hold immediately
+    reviewToAnalysisId.delete(reviewId);
+    if (poolWorktreeId) {
+      poolLifecycle?.endAnalysis(analysisId);
+    }
+    throw setupError;
+  }
 
   analysisPromise
     .then(async result => {
@@ -700,6 +720,8 @@ async function launchCouncilAnalysis(db, modeContext, councilConfig, councilId,
     .finally(() => {
       // Clean up unified tracking map entry
       reviewToAnalysisId.delete(reviewId);
+      // Remove pool worktree analysis hold
+      poolLifecycle?.endAnalysis(analysisId);
     });
 
   return { analysisId, runId };

package/src/routes/chat.js

@@ -21,6 +21,7 @@ const ws = require('../ws');
 const { fireHooks, hasHooks } = require('../hooks/hook-runner');
 const { buildChatStartedPayload, buildChatResumedPayload, buildChatHookContext, getCachedUser } = require('../hooks/payloads');
 const { resolveFormat } = require('../utils/comment-formatter');
+const { resolveLoadSkills } = require('../config');
 
 /**
  * Fire a chat hook event (non-blocking). Skips async work when no hooks are configured.
@@ -226,6 +227,22 @@ async function getChatInstructions(db, review) {
   return repoSettings ? repoSettings.default_chat_instructions : null;
 }
 
+/**
+ * Resolve load_skills for a chat session based on repo settings and config.
+ * @param {Object} db - Database instance
+ * @param {Object} review - Review record
+ * @param {Object} config - App config
+ * @param {string} provider - Chat provider ID (e.g. 'pi')
+ * @returns {Promise<boolean|undefined>} Resolved load_skills, or undefined if no repo override
+ */
+async function getRepoLoadSkillsForChat(db, review, config, provider) {
+  if (!review || !review.repository) return undefined;
+  const repoSettingsRepo = new RepoSettingsRepository(db);
+  const repoSettings = await repoSettingsRepo.getRepoSettings(review.repository);
+  const providerLoadSkills = config.chat_providers?.[provider]?.load_skills;
+  return resolveLoadSkills(config, review.repository, repoSettings, providerLoadSkills);
+}
+
 /**
  * Create a new chat session
  */
@@ -316,6 +333,10 @@ router.post('/api/chat/session', async (req, res) => {
       ? sessionPreamble + '\n\n' + initialContext
       : sessionPreamble;
 
+    // Resolve load_skills from repo settings, falling back to provider config
+    const loadSkillsConfig = req.app.get('config') || {};
+    const loadSkills = await getRepoLoadSkillsForChat(db, review, loadSkillsConfig, provider);
+
     const session = await chatSessionManager.createSession({
       provider,
       model,
@@ -323,7 +344,8 @@ router.post('/api/chat/session', async (req, res) => {
       contextCommentId: contextCommentId || null,
       systemPrompt: finalSystemPrompt,
       cwd: resolvedCwd,
-      initialContext: initialContextWithPort
+      initialContext: initialContextWithPort,
+      loadSkills
     });
 
     logger.info(`Chat session created: ${session.id} (provider=${provider})`);
@@ -398,9 +420,10 @@ router.post('/api/chat/session/:id/message', async (req, res) => {
 
       const systemPrompt = buildChatPrompt({ review, prData, chatInstructions, commentFormatTemplate: fmtConfig.template });
       const cwd = await resolveReviewCwd(db, review);
+      const loadSkills = await getRepoLoadSkillsForChat(db, review, config, session.provider);
 
       try {
-        await chatSessionManager.resumeSession(sessionId, { systemPrompt, cwd });
+        await chatSessionManager.resumeSession(sessionId, { systemPrompt, cwd, loadSkills });
         unregisterChatBroadcast(sessionId);
         registerChatBroadcast(chatSessionManager, sessionId, req.socket.localPort);
         logger.info(`[ChatRoute] Auto-resumed session ${sessionId} for message delivery`);
@@ -540,8 +563,9 @@ router.post('/api/chat/session/:id/resume', async (req, res) => {
 
     const systemPrompt = buildChatPrompt({ review, prData, chatInstructions, commentFormatTemplate: fmtConfig.template });
     const cwd = await resolveReviewCwd(db, review);
+    const loadSkills = await getRepoLoadSkillsForChat(db, review, config, session.provider);
 
-    await chatSessionManager.resumeSession(sessionId, { systemPrompt, cwd });
+    await chatSessionManager.resumeSession(sessionId, { systemPrompt, cwd, loadSkills });
     unregisterChatBroadcast(sessionId);
     const serverPort = req.socket.localPort;
     registerChatBroadcast(chatSessionManager, sessionId, serverPort);

package/src/routes/config.js

@@ -98,7 +98,10 @@ router.get('/api/repos/:owner/:repo/settings', async (req, res) => {
         local_path: null,
         default_council_id: null,
         default_tab: null,
-        default_chat_instructions: null
+        default_chat_instructions: null,
+        pool_size: null,
+        pool_fetch_interval_minutes: null,
+        load_skills: null
       });
     }
 
@@ -111,6 +114,9 @@ router.get('/api/repos/:owner/:repo/settings', async (req, res) => {
       default_council_id: settings.default_council_id,
       default_tab: settings.default_tab,
       default_chat_instructions: settings.default_chat_instructions,
+      pool_size: settings.pool_size ?? null,
+      pool_fetch_interval_minutes: settings.pool_fetch_interval_minutes ?? null,
+      load_skills: settings.load_skills ?? null,
       created_at: settings.created_at,
       updated_at: settings.updated_at
     });
@@ -130,14 +136,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, default_council_id, default_tab, default_chat_instructions } = req.body;
+    const { default_instructions, default_provider, default_model, local_path, default_council_id, default_tab, default_chat_instructions, pool_size, pool_fetch_interval_minutes, load_skills } = 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 && default_council_id === undefined && default_tab === undefined && default_chat_instructions === undefined) {
+    if (default_instructions === undefined && default_provider === undefined && default_model === undefined && local_path === undefined && default_council_id === undefined && default_tab === undefined && default_chat_instructions === undefined && pool_size === undefined && pool_fetch_interval_minutes === undefined && load_skills === undefined) {
       return res.status(400).json({
-        error: 'At least one setting (default_instructions, default_provider, default_model, local_path, default_council_id, default_tab, or default_chat_instructions) must be provided'
+        error: 'At least one setting must be provided'
       });
     }
 
@@ -149,7 +155,10 @@ router.post('/api/repos/:owner/:repo/settings', async (req, res) => {
       local_path,
       default_council_id,
       default_tab,
-      default_chat_instructions
+      default_chat_instructions,
+      pool_size,
+      pool_fetch_interval_minutes,
+      load_skills
     });
 
     logger.info(`Saved repo settings for ${repository}`);
@@ -165,6 +174,9 @@ router.post('/api/repos/:owner/:repo/settings', async (req, res) => {
         default_council_id: settings.default_council_id,
         default_tab: settings.default_tab,
         default_chat_instructions: settings.default_chat_instructions,
+        pool_size: settings.pool_size ?? null,
+        pool_fetch_interval_minutes: settings.pool_fetch_interval_minutes ?? null,
+        load_skills: settings.load_skills ?? null,
         updated_at: settings.updated_at
       }
     });