@in-the-loop-labs/pair-review 2.3.2 → 2.4.0

package/src/chat/prompt-builder.js

@@ -17,11 +17,10 @@ const logger = require('../utils/logger');
  * @param {Object} options
  * @param {Object} options.review - Review metadata {id, pr_number, repository, review_type, local_path, name}
  * @param {Object} [options.prData] - PR data with base_sha/head_sha (for PR reviews)
- * @param {string} [options.skillPath] - Absolute path to the pair-review-api SKILL.md file
  * @param {string} [options.chatInstructions] - Custom instructions from repo settings to append to system prompt
  * @returns {string} System prompt for the chat agent
  */
-function buildChatPrompt({ review, prData, skillPath, chatInstructions }) {
+function buildChatPrompt({ review, prData, chatInstructions }) {
   const sections = [];
 
   // Role
@@ -46,20 +45,22 @@ function buildChatPrompt({ review, prData, skillPath, chatInstructions }) {
     '- **Workflow**: AI generates suggestions → reviewer triages (adopt, edit, or dismiss) → adopted suggestions become comments.',
     '- **IMPORTANT**: Do NOT adopt, dismiss, or modify suggestions or comments unless the user explicitly asks you to. Your role is to discuss and explain — the reviewer decides what action to take.',
     '- **Analysis runs** are the process that produces suggestions. Each run has a provider, model, tier, and status.',
-    '- **Review ID** is a stable integer identifying this review session, used in all API calls.'
+    '- **Review ID** is a stable integer identifying this review session, used in all API calls.',
+    '- **IMPORTANT**: Never mention internal IDs (comment IDs, suggestion IDs, run IDs) in your responses to the user. These are meaningless to the user and not shown in the UI. Refer to comments and suggestions by their content, title, file location, or line number instead.'
   ];
   if (review && review.id) {
-    domainLines.push(`- The review ID for this session is: ${review.id} (e.g. \`/api/reviews/${review.id}/comments\`).`);
+    domainLines.push(`- The internal review ID for this session to use with API requests is: ${review.id} (e.g. \`/api/reviews/${review.id}/comments\`).`);
   }
   sections.push(domainLines.join('\n'));
 
-  // API capability — MUST load the skill for endpoint details
-  const skillRef = skillPath
-    ? `(\`${skillPath}\`)`
-    : '(`.pi/skills/pair-review-api/SKILL.md`)';
+  // API Access — cheat-sheet is injected into initial context; full docs available via GET /api.md
   sections.push(
-    `You MUST read the pair-review-api skill ${skillRef} for endpoint details using the Read tool. With it you can create, update, and delete review comments, adopt or dismiss AI suggestions, and trigger new analyses via curl.\n` +
-    'IMPORTANT: Do NOT mention that you are reading a skill file, loading API documentation, or consulting reference material. Just use the API naturally as if you already know it.'
+    '## API Access\n\n' +
+    'You have **read-only access to the code**. To modify the review (create comments, adopt suggestions, trigger analysis) or interact with the pair-review app, you MUST use the pair-review API via `curl`. ' +
+    'All endpoints accept and return JSON.\n\n' +
+    'A compact API reference and the server URL are provided in the initial context of each session. ' +
+    `For the full API reference, fetch it with \`curl http://localhost:<port>/api.md?reviewId=${review?.id || '<id>'}\` (use the real port from your context).\n\n` +
+    'IMPORTANT: Do NOT mention that you are reading API documentation or consulting reference material. Just use the API naturally as if you already know it.'
   );
 
   // File reference syntax and context files
@@ -82,7 +83,7 @@ function buildChatPrompt({ review, prData, skillPath, chatInstructions }) {
     '## Tool usage\n\n' +
     'Prefer answering from context you already have (the diff, suggestions, and prior conversation). ' +
     'For simple lookups — reading a file, searching for a symbol, running a git command — use the basic tools directly. ' +
-    'Only use the Task tool for genuinely large, multi-step operations that would consume significant context ' +
+    'Only use the Task/Agent tool for genuinely large, multi-step operations that would consume significant context ' +
     '(e.g., tracing a complex call chain across many files, or broad codebase exploration). ' +
     'Most chat questions should not require a Task.'
   );

package/src/chat/session-manager.js

@@ -2,7 +2,7 @@
 /**
  * Chat Session Manager
  *
- * Manages active chat sessions, each backed by a Pi RPC bridge process.
+ * Manages active chat sessions, each backed by a provider-specific bridge process.
  * Handles session lifecycle (create, message, close), persistence to SQLite,
  * and event dispatch (delta, complete, tool_use) to registered listeners.
  */
@@ -10,9 +10,12 @@
 const fs = require('fs');
 const path = require('path');
 const PiBridge = require('./pi-bridge');
+const AcpBridge = require('./acp-bridge');
+const ClaudeCodeBridge = require('./claude-code-bridge');
+const CodexBridge = require('./codex-bridge');
+const { getChatProvider, isAcpProvider, isClaudeCodeProvider, isCodexProvider, applyConfigOverrides: applyChatConfigOverrides } = require('./chat-providers');
 const logger = require('../utils/logger');
 
-const pairReviewSkillPath = path.resolve(__dirname, '../../.pi/skills/pair-review-api/SKILL.md');
 const taskExtensionDir = path.resolve(__dirname, '../../.pi/extensions/task');
 
 const CHAT_TOOLS = 'read,bash,grep,find,ls';
@@ -20,16 +23,18 @@ const CHAT_TOOLS = 'read,bash,grep,find,ls';
 class ChatSessionManager {
   /**
    * @param {Database} db - better-sqlite3 database instance
+   * @param {Object} [configOverrides] - Provider config overrides from config.chat_providers
    */
-  constructor(db) {
+  constructor(db, configOverrides = {}) {
     this._db = db;
     this._sessions = new Map(); // sessionId -> { bridge, listeners }
+    applyChatConfigOverrides(configOverrides);
   }
 
   /**
    * Create a new chat session and spawn the agent process.
    * @param {Object} options
-   * @param {string} options.provider - 'pi' (and later 'claude')
+   * @param {string} options.provider - any configured chat provider
    * @param {string} [options.model] - Model ID
    * @param {number} options.reviewId - Review ID
    * @param {number} [options.contextCommentId] - Optional suggestion ID that triggered chat
@@ -56,14 +61,11 @@ class ChatSessionManager {
 
     // Create and start the bridge
     // Chat sessions get bash for git commands; review analysis uses the safe default
-    const bridge = new PiBridge({
+    const bridge = this._createBridge(provider, {
       provider,
       model,
       cwd,
       systemPrompt,
-      tools: CHAT_TOOLS,
-      skills: [pairReviewSkillPath],
-      extensions: [taskExtensionDir]
     });
 
     const listeners = {
@@ -134,6 +136,12 @@ class ChatSessionManager {
       messageForAgent = context + '\n\n---\n\n' + messageForAgent;
     }
 
+    // Then prepend resume context (port correction after session resume — middle layer)
+    if (session.resumeContext) {
+      messageForAgent = session.resumeContext + '\n\n---\n\n' + messageForAgent;
+      session.resumeContext = null; // Only prepend once
+    }
+
     // Then prepend initial session context (all suggestions — outermost)
     if (session.initialContext) {
       messageForAgent = session.initialContext + '\n\n---\n\n' + messageForAgent;
@@ -308,6 +316,22 @@ class ChatSessionManager {
     logger.info(`[ChatSession] Session ${sessionId} closed`);
   }
 
+  /**
+   * Set context to prepend on the next sendMessage call for a resumed session.
+   * Similar to initialContext but set after resume rather than at creation.
+   * The context is consumed (prepended to the agent message, then cleared) on
+   * the next sendMessage call.
+   * @param {number} sessionId
+   * @param {string} context - Context string to prepend on next message
+   */
+  setResumeContext(sessionId, context) {
+    const session = this._sessions.get(sessionId);
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found or not active`);
+    }
+    session.resumeContext = context || null;
+  }
+
   /**
    * Get session info from the database.
    * @param {number} sessionId
@@ -377,7 +401,7 @@ class ChatSessionManager {
   }
 
   /**
-   * Resume a previously closed chat session by re-spawning the Pi bridge
+   * Resume a previously closed chat session by re-spawning the chat bridge
    * with the stored session file path.
    * @param {number} sessionId
    * @param {Object} options
@@ -397,29 +421,39 @@ class ChatSessionManager {
       throw new Error(`Session ${sessionId} not found`);
     }
 
-    if (!row.agent_session_id) {
-      throw new Error(`Session ${sessionId} has no session file — cannot resume`);
-    }
+    const isAcp = isAcpProvider(row.provider);
+    const isClaudeCode = isClaudeCodeProvider(row.provider);
+    const isCodex = isCodexProvider(row.provider);
+    const usesOpaqueSessionId = isAcp || isClaudeCode;
 
-    // Verify file exists on disk
-    if (!fs.existsSync(row.agent_session_id)) {
-      // Null out the stale path
-      this._db.prepare('UPDATE chat_sessions SET agent_session_id = NULL WHERE id = ?').run(sessionId);
-      throw new Error(`Session file not found on disk: ${row.agent_session_id}`);
+    if (!usesOpaqueSessionId && !isCodex) {
+      // Pi sessions require a session file on disk
+      if (!row.agent_session_id) {
+        throw new Error(`Session ${sessionId} has no session file — cannot resume`);
+      }
+      if (!fs.existsSync(row.agent_session_id)) {
+        this._db.prepare('UPDATE chat_sessions SET agent_session_id = NULL WHERE id = ?').run(sessionId);
+        throw new Error(`Session file not found on disk: ${row.agent_session_id}`);
+      }
     }
 
-    logger.info(`[ChatSession] Resuming session ${sessionId} from ${row.agent_session_id}`);
+    logger.info(`[ChatSession] Resuming session ${sessionId}${usesOpaqueSessionId ? ` (session ${row.agent_session_id || 'new'})` : isCodex ? ` (Codex thread ${row.agent_session_id || 'new'})` : ` from ${row.agent_session_id}`}`);
 
-    // Create bridge with session path for resumption
-    const bridge = new PiBridge({
+    let resumeOptions = {};
+    if (isCodex) {
+      resumeOptions = row.agent_session_id ? { resumeThreadId: row.agent_session_id } : {};
+    } else if (usesOpaqueSessionId) {
+      resumeOptions = row.agent_session_id ? { resumeSessionId: row.agent_session_id } : {};
+    } else {
+      resumeOptions = { sessionPath: row.agent_session_id };
+    }
+
+    const bridge = this._createBridge(row.provider, {
       provider: row.provider,
       model: row.model,
       cwd,
       systemPrompt,
-      tools: CHAT_TOOLS,
-      skills: [pairReviewSkillPath],
-      extensions: [taskExtensionDir],
-      sessionPath: row.agent_session_id
+      ...resumeOptions,
     });
 
     const listeners = {
@@ -491,11 +525,57 @@ class ChatSessionManager {
   // Private methods
   // ---------------------------------------------------------------------------
 
+  /**
+   * Create the appropriate bridge instance for a provider.
+   * ACP providers get an AcpBridge; everything else gets a PiBridge with tools/skills.
+   * @param {string} provider
+   * @param {Object} options - Bridge constructor options
+   * @returns {PiBridge|AcpBridge}
+   */
+  _createBridge(provider, options) {
+    if (isAcpProvider(provider)) {
+      const providerDef = getChatProvider(provider);
+      return new AcpBridge({
+        ...options,
+        model: options.model || providerDef?.model,
+        acpCommand: providerDef?.command,
+        acpArgs: providerDef?.args,
+        env: providerDef?.env,
+        useShell: providerDef?.useShell,
+      });
+    }
+    if (isClaudeCodeProvider(provider)) {
+      const providerDef = getChatProvider(provider);
+      return new ClaudeCodeBridge({
+        ...options,
+        claudeCommand: providerDef?.command,
+        env: providerDef?.env,
+        useShell: providerDef?.useShell,
+      });
+    }
+    if (isCodexProvider(provider)) {
+      const providerDef = getChatProvider(provider);
+      return new CodexBridge({
+        ...options,
+        model: options.model || providerDef?.model,
+        codexCommand: providerDef?.command,
+        codexArgs: providerDef?.args,
+        env: providerDef?.env,
+        useShell: providerDef?.useShell,
+      });
+    }
+    return new PiBridge({
+      ...options,
+      tools: CHAT_TOOLS,
+      extensions: [taskExtensionDir],
+    });
+  }
+
   /**
    * Wire up bridge event handlers that dispatch to the session's listener sets
    * and handle DB persistence (e.g., storing assistant messages on completion).
    * @param {number} sessionId
-   * @param {PiBridge} bridge
+   * @param {PiBridge|AcpBridge} bridge
    * @param {Object} listeners - Listener sets keyed by event type
    */
   _wireBridgeEvents(sessionId, bridge, listeners) {
@@ -591,13 +671,14 @@ class ChatSessionManager {
     });
 
     bridge.on('session', (event) => {
-      if (event.sessionFile) {
+      const sessionRef = event.sessionFile || event.sessionId || event.threadId;
+      if (sessionRef) {
         try {
           this._db.prepare('UPDATE chat_sessions SET agent_session_id = ? WHERE id = ?')
-            .run(event.sessionFile, sessionId);
-          logger.info(`[ChatSession] Session ${sessionId} session file: ${event.sessionFile}`);
+            .run(sessionRef, sessionId);
+          logger.info(`[ChatSession] Session ${sessionId} agent ref: ${sessionRef}`);
         } catch (err) {
-          logger.warn(`[ChatSession] Failed to store session file: ${err.message}`);
+          logger.warn(`[ChatSession] Failed to store session ref: ${err.message}`);
         }
       }
     });

package/src/config.js

@@ -22,10 +22,12 @@ const DEFAULT_CONFIG = {
   debug_stream: false,  // When true, logs AI provider streaming events (equivalent to --debug-stream CLI flag)
   db_name: "",  // Custom database filename (default: database.db). Useful for per-worktree isolation.
   yolo: false,  // When true, skips fine-grained AI provider permission setup (equivalent to --yolo CLI flag)
-  enable_chat: true,  // When true, enables the chat panel feature (requires Pi AI provider)
+  enable_chat: true,  // When true, enables the chat panel feature (uses chat_provider)
+  chat_provider: "pi",  // Chat provider: 'pi', 'copilot-acp', 'gemini-acp', 'opencode-acp', 'cursor-acp', 'codex'
   comment_format: "legacy",  // Comment format preset or custom template for adopted suggestions
   chat: { enable_shortcuts: true },  // Chat panel settings (enable_shortcuts: show action shortcut buttons)
-  providers: {},  // Custom provider configurations (overrides built-in defaults)
+  providers: {},  // Custom AI analysis provider configurations (overrides built-in defaults)
+  chat_providers: {},  // Custom chat provider configurations (overrides built-in defaults)
   monorepos: {},  // Monorepo configurations: { "owner/repo": { path: "~/path/to/clone" } }
   assisted_by_url: "https://github.com/in-the-loop-labs/pair-review"  // URL for "Review assisted by" footer link
 };

package/src/database.js

@@ -20,7 +20,7 @@ function getDbPath() {
 /**
  * Current schema version - increment this when adding new migrations
  */
-const CURRENT_SCHEMA_VERSION = 25;
+const CURRENT_SCHEMA_VERSION = 26;
 
 /**
  * Database schema SQL statements
@@ -247,6 +247,22 @@ const SCHEMA_SQL = {
       created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
       FOREIGN KEY (review_id) REFERENCES reviews(id) ON DELETE CASCADE
     )
+  `,
+
+  github_pr_cache: `
+    CREATE TABLE IF NOT EXISTS github_pr_cache (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      owner TEXT NOT NULL,
+      repo TEXT NOT NULL,
+      number INTEGER NOT NULL,
+      title TEXT,
+      author TEXT,
+      updated_at TEXT,
+      html_url TEXT,
+      state TEXT DEFAULT 'open',
+      collection TEXT NOT NULL,
+      fetched_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
   `
 };
 
@@ -282,7 +298,9 @@ const INDEX_SQL = [
   'CREATE INDEX IF NOT EXISTS idx_chat_sessions_review ON chat_sessions(review_id)',
   'CREATE INDEX IF NOT EXISTS idx_chat_messages_session ON chat_messages(session_id)',
   // Context files indexes
-  'CREATE INDEX IF NOT EXISTS idx_context_files_review ON context_files(review_id)'
+  'CREATE INDEX IF NOT EXISTS idx_context_files_review ON context_files(review_id)',
+  // GitHub PR cache indexes
+  'CREATE UNIQUE INDEX IF NOT EXISTS idx_github_pr_cache_unique ON github_pr_cache(collection, owner, repo, number)'
 ];
 
 /**
@@ -1158,6 +1176,36 @@ const MIGRATIONS = {
     }
 
     console.log('Migration to schema version 25 complete');
+  },
+
+  // Migration to version 26: adds github_pr_cache table for PR collections
+  26: (db) => {
+    console.log('Migrating to schema version 26: Add github_pr_cache table');
+
+    const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='github_pr_cache'").all();
+    if (tables.length === 0) {
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS github_pr_cache (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          owner TEXT NOT NULL,
+          repo TEXT NOT NULL,
+          number INTEGER NOT NULL,
+          title TEXT,
+          author TEXT,
+          updated_at TEXT,
+          html_url TEXT,
+          state TEXT DEFAULT 'open',
+          collection TEXT NOT NULL,
+          fetched_at DATETIME DEFAULT CURRENT_TIMESTAMP
+        )
+      `);
+      db.exec('CREATE UNIQUE INDEX IF NOT EXISTS idx_github_pr_cache_unique ON github_pr_cache(collection, owner, repo, number)');
+      console.log('  Created github_pr_cache table');
+    } else {
+      console.log('  Table github_pr_cache already exists');
+    }
+
+    console.log('Migration to schema version 26 complete');
   }
 };
 

package/src/github/client.js

@@ -1145,6 +1145,49 @@ class GitHubClient {
     throw new Error(`Failed to submit review: ${error.message}`);
   }
 
+  /**
+   * Search GitHub pull requests using the search API.
+   * @param {string} searchQuery - Search query string (e.g., "is:pr is:open user-review-requested:USERNAME")
+   * @returns {Promise<Array<{owner: string, repo: string, number: number, title: string, author: string, updated_at: string, html_url: string, state: string}>>}
+   */
+  async searchPullRequests(searchQuery) {
+    const items = await this.octokit.paginate(
+      this.octokit.rest.search.issuesAndPullRequests,
+      { q: searchQuery, per_page: 100 }
+    );
+
+    return items.map(item => {
+      // repository_url format: https://api.github.com/repos/OWNER/REPO
+      const parts = item.repository_url.split('/');
+      const repo = parts.pop();
+      const owner = parts.pop();
+
+      return {
+        owner,
+        repo,
+        number: item.number,
+        title: item.title,
+        author: item.user?.login || null,
+        updated_at: item.updated_at,
+        html_url: item.html_url,
+        state: item.state
+      };
+    });
+  }
+
+  /**
+   * Get the authenticated user's information.
+   * @returns {Promise<{login: string, name: string, avatar_url: string}>}
+   */
+  async getAuthenticatedUser() {
+    const { data } = await this.octokit.rest.users.getAuthenticated();
+    return {
+      login: data.login,
+      name: data.name,
+      avatar_url: data.avatar_url
+    };
+  }
+
   /**
    * Retry API calls with exponential backoff
    * @param {Function} apiCall - The API call function

package/src/routes/chat.js

@@ -12,15 +12,13 @@
  */
 
 const express = require('express');
-const path = require('path');
 const { queryOne, query, AnalysisRunRepository, RepoSettingsRepository } = require('../database');
 const { buildChatPrompt, buildInitialContext } = require('../chat/prompt-builder');
+const { renderApiDocs, buildApiCheatSheet } = require('../chat/api-reference');
 const { GitWorktreeManager } = require('../git/worktree');
 const logger = require('../utils/logger');
 const ws = require('../ws');
 
-const pairReviewSkillPath = path.resolve(__dirname, '../../.pi/skills/pair-review-api/SKILL.md');
-
 const router = express.Router();
 
 /**
@@ -90,7 +88,7 @@ const broadcastUnsubscribers = new Map();
  * @returns {RegExp}
  */
 function buildPairReviewApiRe(port) {
-  return new RegExp(`\\bcurl\\b.*\\bhttps?://(?:localhost|127\\.0\\.0\\.1):${port}/api/`);
+  return new RegExp(`\\bcurl\\b.*\\bhttps?://(?:localhost|127\\.0\\.0\\.1):${port}/api`);
 }
 
 /**
@@ -139,15 +137,6 @@ function registerChatBroadcast(chatSessionManager, sessionId, port) {
         }
       }
 
-      // Suppress tool badges for reading the API skill file
-      if (data.toolName?.toLowerCase() === 'read') {
-        const readPath = data.args?.path || data.args?.file_path || '';
-        if (readPath.endsWith('pair-review-api/SKILL.md')) {
-          hiddenToolCallIds.add(data.toolCallId);
-          return;
-        }
-      }
-
       // Suppress follow-up events (update/end) for any hidden tool call
       if (hiddenToolCallIds.has(data.toolCallId)) {
         if (data.status === 'end') hiddenToolCallIds.delete(data.toolCallId);
@@ -245,7 +234,7 @@ router.post('/api/chat/session', async (req, res) => {
       const chatInstructions = await getChatInstructions(db, review);
       const prData = await fetchPrData(db, review);
 
-      finalSystemPrompt = buildChatPrompt({ review, prData, skillPath: pairReviewSkillPath, chatInstructions });
+      finalSystemPrompt = buildChatPrompt({ review, prData, chatInstructions });
 
       if (!skipAnalysisContext) {
         // Fetch all AI suggestions from the latest analysis run
@@ -287,15 +276,16 @@ router.post('/api/chat/session', async (req, res) => {
     // Resolve cwd: explicit from request body, or the review's code directory
     const resolvedCwd = cwd || await resolveReviewCwd(db, review);
 
-    // Inject the server port into the initial context so the agent learns it
-    // once at session start. This avoids wasting tokens by repeating the port
-    // with every user message.  If the server restarts on a new port, the next
-    // session will pick up the new value automatically.
+    // Inject the server port and API cheat-sheet into the initial context so
+    // the agent learns it once at session start.  If the server restarts on a
+    // new port, the next session will pick up the new value automatically.
     const serverPort = req.socket.localPort;
     const portContext = `[Server port: ${serverPort}] The pair-review API is at http://localhost:${serverPort}`;
+    const cheatSheet = buildApiCheatSheet({ port: serverPort, reviewId: review.id });
+    const sessionPreamble = portContext + '\n\n' + cheatSheet;
     const initialContextWithPort = initialContext
-      ? portContext + '\n\n' + initialContext
-      : portContext;
+      ? sessionPreamble + '\n\n' + initialContext
+      : sessionPreamble;
 
     const session = await chatSessionManager.createSession({
       provider,
@@ -354,6 +344,7 @@ router.post('/api/chat/session/:id/message', async (req, res) => {
     const db = req.app.get('db');
 
     // Auto-resume: if session is not active in memory, try to resume it
+    let portCorrectionContext = null;
     if (!chatSessionManager.isSessionActive(sessionId)) {
       const session = chatSessionManager.getSession(sessionId);
       if (!session) {
@@ -372,7 +363,7 @@ router.post('/api/chat/session/:id/message', async (req, res) => {
       const chatInstructions = await getChatInstructions(db, review);
       const prData = await fetchPrData(db, review);
 
-      const systemPrompt = buildChatPrompt({ review, prData, skillPath: pairReviewSkillPath, chatInstructions });
+      const systemPrompt = buildChatPrompt({ review, prData, chatInstructions });
       const cwd = await resolveReviewCwd(db, review);
 
       try {
@@ -380,14 +371,27 @@ router.post('/api/chat/session/:id/message', async (req, res) => {
         unregisterChatBroadcast(sessionId);
         registerChatBroadcast(chatSessionManager, sessionId, req.socket.localPort);
         logger.info(`[ChatRoute] Auto-resumed session ${sessionId} for message delivery`);
+
+        // Inject port correction so the agent knows the current server address,
+        // even if the conversational history has a stale port from session creation.
+        const serverPort = req.socket.localPort;
+        portCorrectionContext = `[Server port: ${serverPort}] The pair-review API is at http://localhost:${serverPort}`;
+        // Note: we intentionally do NOT re-inject the API cheat sheet on resume.
+        // The agent already has the endpoint shapes from the original session context —
+        // it only needs the updated port to adjust its curl calls.
       } catch (err) {
         logger.error(`[ChatRoute] Failed to auto-resume session ${sessionId}: ${err.message}`);
         return res.status(410).json({ error: 'Failed to resume session: ' + err.message });
       }
     }
 
+    // Merge port correction context (from auto-resume) with any request-body context
+    const mergedContext = portCorrectionContext
+      ? (context ? portCorrectionContext + '\n\n' + context : portCorrectionContext)
+      : context;
+
     logger.debug(`[ChatRoute] Forwarding message to session ${sessionId} (${content.length} chars)`);
-    const result = await chatSessionManager.sendMessage(sessionId, content, { context, contextData, actionContext });
+    const result = await chatSessionManager.sendMessage(sessionId, content, { context: mergedContext, contextData, actionContext });
     logger.debug(`[ChatRoute] Message stored as ID ${result.id}, awaiting agent response via WebSocket`);
     res.json({ data: { messageId: result.id } });
   } catch (error) {
@@ -490,18 +494,28 @@ router.post('/api/chat/session/:id/resume', async (req, res) => {
       return res.status(404).json({ error: 'Review not found for session' });
     }
 
-    // Pi's --session replays the original conversation; --append-system-prompt
-    // re-injects the review context so the agent retains awareness of the codebase
-    // even if the system prompt was only in the initial session's context.
+    // Pi's --session replays the original conversation;
+    // --append-system-prompt re-injects the review context so the agent retains
+    // awareness of the codebase even if the system prompt was only in the
+    // initial session's context.
     const chatInstructions = await getChatInstructions(db, review);
     const prData = await fetchPrData(db, review);
 
-    const systemPrompt = buildChatPrompt({ review, prData, skillPath: pairReviewSkillPath, chatInstructions });
+    const systemPrompt = buildChatPrompt({ review, prData, chatInstructions });
     const cwd = await resolveReviewCwd(db, review);
 
     await chatSessionManager.resumeSession(sessionId, { systemPrompt, cwd });
     unregisterChatBroadcast(sessionId);
-    registerChatBroadcast(chatSessionManager, sessionId, req.socket.localPort);
+    const serverPort = req.socket.localPort;
+    registerChatBroadcast(chatSessionManager, sessionId, serverPort);
+
+    // Inject port correction so the agent knows the current server address,
+    // even if the conversational history has a stale port from session creation.
+    // Uses resumeContext (consumed on next sendMessage) instead of saveContextMessage
+    // (which only writes to DB and never reaches the agent process).
+    chatSessionManager.setResumeContext(sessionId,
+      `[Server port: ${serverPort}] The pair-review API is at http://localhost:${serverPort}`
+    );
 
     logger.info(`[ChatRoute] Explicitly resumed session ${sessionId}`);
     res.json({ data: { id: sessionId, status: 'active' } });
@@ -611,6 +625,25 @@ router.get('/api/chat/analysis-context/:runId', async (req, res) => {
   }
 });
 
+/**
+ * Serve the full API reference as rendered markdown with real values baked in.
+ * Requires ?reviewId=N so the docs contain the correct review ID.
+ */
+router.get('/api.md', (req, res) => {
+  try {
+    const reviewId = parseInt(req.query.reviewId, 10);
+    if (!reviewId || !Number.isInteger(reviewId)) {
+      return res.status(400).json({ error: 'Missing required query parameter: reviewId' });
+    }
+    const port = req.socket.localPort;
+    const md = renderApiDocs({ port, reviewId });
+    res.type('text/markdown').send(md);
+  } catch (error) {
+    logger.error(`Error serving API docs: ${error.message}`);
+    res.status(500).json({ error: 'Failed to render API docs' });
+  }
+});
+
 module.exports = router;
 
 // Expose internals for testing

package/src/routes/config.js

@@ -21,6 +21,7 @@ const {
 } = require('../ai');
 const { normalizeRepository } = require('../utils/paths');
 const { isRunningViaNpx, saveConfig } = require('../config');
+const { getAllChatProviders, getAllCachedChatAvailability } = require('../chat/chat-providers');
 const { PRESETS } = require('../utils/comment-formatter');
 const logger = require('../utils/logger');
 
@@ -33,6 +34,12 @@ const router = express.Router();
 router.get('/api/config', (req, res) => {
   const config = req.app.get('config') || {};
 
+  // Build chat_providers array with availability
+  const chatAvailability = getAllCachedChatAvailability();
+  const chatProviders = getAllChatProviders().map(p => ({
+    id: p.id, name: p.name, available: chatAvailability[p.id]?.available || false
+  }));
+
   // Only return safe configuration values (not secrets like github_token)
   res.json({
     theme: config.theme || 'light',
@@ -41,9 +48,25 @@ router.get('/api/config', (req, res) => {
     // Include npx detection for frontend command examples
     is_running_via_npx: isRunningViaNpx(),
     enable_chat: config.enable_chat !== false,
+    chat_provider: config.chat_provider || 'pi',
+    chat_providers: chatProviders,
     chat_enable_shortcuts: config.chat?.enable_shortcuts !== false,
     pi_available: getCachedAvailability('pi')?.available || false,
-    assisted_by_url: config.assisted_by_url || 'https://github.com/in-the-loop-labs/pair-review'
+    assisted_by_url: config.assisted_by_url || 'https://github.com/in-the-loop-labs/pair-review',
+    // Share configuration for external review viewers.
+    // - url: The base URL of the external share site
+    // - method: Plumbed through for future use (e.g., POST-based share flows).
+    //           The current implementation only uses GET via window.open().
+    // - icon: Optional custom SVG icon for the share button
+    // - label: Optional custom label for the share menu item (e.g., "Share to Acme")
+    // - description: Optional tooltip text shown on hover (e.g., "Share to Acme review board")
+    share: config.share ? {
+      url: config.share.url || null,
+      method: config.share.method || 'GET',
+      icon: config.share.icon || null,
+      label: config.share.label || null,
+      description: config.share.description || null
+    } : null
   });
 });