@in-the-loop-labs/pair-review 3.9.1 → 4.1.0

package/src/ai/stream-parser.js

@@ -212,56 +212,6 @@ function parseCodexLine(line, options = {}) {
   }
 }
 
-/**
- * Parse a single Gemini stream-json JSONL line into a normalized event.
- * Returns null if the line should not be emitted.
- *
- * Gemini stream-json event types:
- * - message (role: "assistant") → assistant_text
- * - tool_use (tool_name, parameters) → tool_use
- * - init, message (role: "user"), tool_result, result → filtered out
- *
- * @param {string} line - A single JSONL line from Gemini stdout
- * @param {Object} [options] - Parse options
- * @param {string} [options.cwd] - Working directory to strip from file paths
- * @returns {{ type: string, text: string, timestamp: number } | null}
- */
-function parseGeminiLine(line, options = {}) {
-  if (!line || !line.trim()) return null;
-
-  const { cwd } = options;
-
-  try {
-    const event = JSON.parse(line);
-    const eventType = event.type;
-
-    if (eventType === 'message' && event.role === 'assistant' && event.content && event.content.trim()) {
-      return {
-        type: 'assistant_text',
-        text: truncateSnippet(event.content),
-        timestamp: Date.now()
-      };
-    }
-
-    if (eventType === 'tool_use') {
-      const toolName = event.tool_name || 'unknown';
-      const detail = extractToolDetail(event.parameters, cwd);
-      const text = detail ? `${toolName}: ${detail}` : toolName;
-      return {
-        type: 'tool_use',
-        text: truncateSnippet(text),
-        timestamp: Date.now()
-      };
-    }
-
-    // init, user messages, tool_result, result — never emit
-    return null;
-  } catch {
-    // Best-effort side channel — silently ignore non-JSON or malformed lines.
-    return null;
-  }
-}
-
 /**
  * Parse a single OpenCode JSONL line into a normalized event.
  * Returns null if the line should not be emitted.
@@ -323,7 +273,7 @@ function parseOpenCodeLine(line, options = {}) {
  */
 class StreamParser {
   /**
-   * @param {Function} parseLine - Provider-specific line parser (e.g. parseClaudeLine, parseGeminiLine)
+   * @param {Function} parseLine - Provider-specific line parser (e.g. parseClaudeLine, parseCodexLine)
    * @param {Function} onEvent - Callback receiving normalized events { type, text, timestamp }
    * @param {Object} [options] - Options passed through to parseLine (e.g. { cwd })
    */
@@ -636,7 +586,6 @@ module.exports = {
   extractToolDetail,
   parseClaudeLine,
   parseCodexLine,
-  parseGeminiLine,
   parseOpenCodeLine,
   parseCursorAgentLine,
   parsePiLine,

package/src/chat/acp-bridge.js

@@ -82,7 +82,7 @@ class AcpBridge extends EventEmitter {
     const args = [...this.acpArgs];
     const useShell = this.useShell;
 
-    // For multi-word commands (e.g. "devx gemini"), use shell mode
+    // For multi-word commands (e.g. "devx claude"), use shell mode
     const spawnCmd = useShell ? `${command} ${args.join(' ')}` : command;
     const spawnArgs = useShell ? [] : args;
 

package/src/chat/chat-providers.js

@@ -2,7 +2,7 @@
 /**
  * Chat Provider Registry
  *
- * Defines named chat providers (Pi, Copilot, Gemini, OpenCode, Claude, Codex, Cursor) with their
+ * Defines named chat providers (Pi, Copilot, OpenCode, Claude, Codex, Cursor) with their
  * default commands/args, config overrides, and availability checks.
  */
 
@@ -32,14 +32,6 @@ const CHAT_PROVIDERS = {
     args: ['--acp', '--stdio'],
     env: {},
   },
-  'gemini-acp': {
-    id: 'gemini-acp',
-    name: 'Gemini (ACP)',
-    type: 'acp',
-    command: 'gemini',
-    args: ['--experimental-acp'],
-    env: {},
-  },
   'opencode-acp': {
     id: 'opencode-acp',
     name: 'OpenCode (ACP)',

package/src/config.js

@@ -66,8 +66,8 @@ const DEFAULT_CONFIG = {
   port: 7247,
   single_port: true,  // When true, reuse a single server on the configured port; new invocations delegate to the running server
   theme: "light",
-  default_provider: "claude",  // AI provider: 'claude', 'gemini', 'codex', 'copilot', 'opencode', 'cursor-agent', 'pi'
-  default_model: "opus",       // Model within the provider (e.g., 'opus' for Claude, 'gemini-2.5-pro' for Gemini)
+  default_provider: "claude",  // AI provider: 'claude', 'antigravity', 'codex', 'copilot', 'opencode', 'cursor-agent', 'pi'
+  default_model: "opus",       // Model within the provider (e.g., 'opus' for Claude, 'gemini-3.1-pro-low' for Antigravity)
   tours: {
     enabled: false,            // When true, the guided-tour feature is available (toolbar button visible, etc.)
     auto_generate: true,       // When true, a tour generation job is kicked off automatically on review load
@@ -89,7 +89,7 @@ const DEFAULT_CONFIG = {
   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 (uses chat_provider)
-  chat_provider: "pi",  // Chat provider: 'pi', 'copilot-acp', 'gemini-acp', 'opencode-acp', 'cursor-acp', 'codex'
+  chat_provider: "pi",  // Chat provider: 'pi', 'copilot-acp', 'opencode-acp', 'cursor-acp', 'codex'
   comment_format: "legacy",  // Comment format preset or custom template for adopted suggestions
   chat: { enable_shortcuts: true, enter_to_send: true },  // Chat panel settings (enable_shortcuts: show action shortcut buttons, enter_to_send: Enter sends message instead of newline)
   providers: {},  // Custom AI analysis provider configurations (overrides built-in defaults)
@@ -534,26 +534,61 @@ function _resolveFeatures(apiHost, explicit) {
   return out;
 }
 
+/**
+ * Whether a repo config describes an *exclusive* alt-host repo — one whose
+ * every PR lives on the configured `api_host` and which has no github.com
+ * presence. True iff `api_host` is a non-empty string AND `exclusive` is not
+ * explicitly `false`. Omitting `exclusive` therefore preserves today's
+ * behaviour (an `api_host` repo is alt-host-only). Setting `exclusive: false`
+ * marks a *dual* repo whose PRs may live on github.com OR the alt host.
+ *
+ * @param {Object|null|undefined} repoConfig - A single `repos[...]` entry
+ * @returns {boolean}
+ */
+function isExclusiveAltHost(repoConfig) {
+  if (!repoConfig || typeof repoConfig !== 'object') return false;
+  const apiHost = typeof repoConfig.api_host === 'string' && repoConfig.api_host;
+  if (!apiHost) return false;
+  return repoConfig.exclusive !== false;
+}
+
 /**
  * Resolves the host binding for a given repository. The binding describes
  * which API host pair-review should talk to, the token to authenticate
  * with, and per-area dispatch flags.
  *
- * Token resolution priority for a repo with no `api_host` (github.com):
+ * The optional `options.host` selects the binding *flavor* for repos that can
+ * live on more than one host (dual repos, `exclusive: false`):
+ *   - `undefined` (or no options) — legacy + ambiguity rule: an EXCLUSIVE
+ *     alt-host repo binds to its alt host (today's behaviour); a DUAL repo or
+ *     a plain github.com repo binds to github.com.
+ *   - `null` — force a github.com binding. For an EXCLUSIVE alt-host repo this
+ *     is a caller bug (that repo has no github.com presence) and throws.
+ *   - `'<url>'` — force an alt-host binding; the string must equal the repo's
+ *     configured `api_host`, otherwise the stored host no longer matches
+ *     config and this throws.
+ *
+ * Token resolution priority for a github.com (github-flavored) binding of a
+ * plain repo:
  *   1. GITHUB_TOKEN environment variable
  *   2. repo-level `token`
  *   3. repo-level `token_command` (cached per (repo, command))
  *   4. top-level `github_token`
  *   5. top-level `github_token_command` (cached per (repo, command))
  *
- * For a repo with an `api_host` (alt-host), the github.com top-level
- * credentials are NOT used — `GITHUB_TOKEN`, `config.github_token`, and
- * `config.github_token_command` are all github.com-only and would be
- * the wrong token for an alt-host endpoint. Only the repo-scoped
- * `token` / `token_command` keys are consulted; missing those, the
- * lookup returns an empty token so the caller can surface a clear
+ * For an alt-host binding, the github.com top-level credentials are NOT used —
+ * `GITHUB_TOKEN`, `config.github_token`, and `config.github_token_command` are
+ * all github.com-only and would be the wrong token for an alt-host endpoint.
+ * Only the repo-scoped `token` / `token_command` keys are consulted; missing
+ * those, the lookup returns an empty token so the caller can surface a clear
  * "missing credential" error.
  *
+ * For the github.com binding of a DUAL repo, the reverse holds: the repo-scoped
+ * `token` / `token_command` are alt-host credentials and are NOT used — only
+ * the top-level github.com chain (env → `github_token` → `github_token_command`)
+ * is consulted. The repo's explicit `features` block (written for the alt host)
+ * also does not apply to its github.com binding.
+ *
  * Refreshable sources (`repo:token_command`, `config:github_token_command`)
  * additionally carry a `refresh` closure on the returned binding. Calling
  * `refresh()` busts the cached token for that exact source, re-runs the
@@ -564,58 +599,101 @@ function _resolveFeatures(apiHost, explicit) {
  *
  * @param {string|null|undefined} repository - "owner/repo" identifier, or null/undefined for no-repo fallback
  * @param {Object} config - Configuration object from loadConfig()
- * @returns {{ apiHost: string|null, token: string, features: Object, source: string, refresh: (function(): string)|null }}
+ * @param {{ host?: string|null }} [options] - Per-PR host override (see above)
+ * @returns {{ apiHost: string|null, host: string|null, token: string, features: Object, source: string, refresh: (function(): string)|null }}
  */
-function resolveHostBinding(repository, config) {
+function resolveHostBinding(repository, config, options = {}) {
   const safeConfig = config || {};
   const repoConfig = repository ? getRepoConfig(safeConfig, repository) : null;
-  const apiHost = (repoConfig && typeof repoConfig.api_host === 'string' && repoConfig.api_host)
+  const configuredApiHost = (repoConfig && typeof repoConfig.api_host === 'string' && repoConfig.api_host)
     ? repoConfig.api_host
     : null;
-  const features = _resolveFeatures(apiHost, repoConfig?.features);
+  const requestedHost = options ? options.host : undefined;
+  const exclusive = isExclusiveAltHost(repoConfig);
+
+  // Decide the binding flavor from the requested host + repo config.
+  // `apiHost` null → github.com binding; non-null → alt-host binding.
+  let apiHost;
+  if (requestedHost === undefined) {
+    // Ambiguity rule: exclusive alt-host repo → alt binding (legacy);
+    // dual repo and plain github repo → github binding.
+    apiHost = exclusive ? configuredApiHost : null;
+  } else if (requestedHost === null) {
+    if (exclusive) {
+      throw new Error(
+        `resolveHostBinding: repository "${repository}" is an exclusive alt-host repo (api_host "${configuredApiHost}") and has no github.com presence, but a github.com binding was requested (host=null). This is a caller bug; pass the api_host string, or set "exclusive": false on the repo config.`
+      );
+    }
+    apiHost = null;
+  } else {
+    // A specific alt host was requested; it must match this repo's config.
+    if (requestedHost !== configuredApiHost) {
+      throw new Error(
+        `resolveHostBinding: requested host "${requestedHost}" for repository "${repository}" does not match its configured api_host (${configuredApiHost === null ? 'none' : `"${configuredApiHost}"`}). The stored host no longer matches config — re-open the PR from a URL to re-resolve its host.`
+      );
+    }
+    apiHost = configuredApiHost;
+  }
+
+  // Binding flavor booleans:
+  //  - alt binding uses ONLY repo-scoped credentials + the repo's features.
+  //  - github binding uses ONLY the top-level github.com chain.
+  //  - the github binding of a DUAL repo must skip the repo-scoped
+  //    credentials/features (they belong to the alt host).
+  const isAltBinding = apiHost !== null;
+  const isDualGithubBinding = !isAltBinding && configuredApiHost !== null;
+  const useRepoScopedToken = !isDualGithubBinding;
+  const useGithubChain = !isAltBinding;
+
+  // A dual repo's explicit `features` block was authored for its alt host, so
+  // it does not apply to the github.com binding; use plain github defaults.
+  const explicitFeatures = isDualGithubBinding ? undefined : repoConfig?.features;
+  const features = _resolveFeatures(apiHost, explicitFeatures);
 
   // Token resolution
   let token = '';
   let source = 'none';
 
-  // 1. GITHUB_TOKEN env var, only for github.com (no api_host)
-  if (apiHost === null && process.env.GITHUB_TOKEN) {
+  // 1. GITHUB_TOKEN env var, only for a github.com binding
+  if (useGithubChain && process.env.GITHUB_TOKEN) {
     token = process.env.GITHUB_TOKEN;
     source = 'env:GITHUB_TOKEN';
     logger.debug('Using GitHub token from GITHUB_TOKEN environment variable');
-    return { apiHost, token, features, source, refresh: null };
+    return { apiHost, host: apiHost, token, features, source, refresh: null };
   }
 
-  // 2. Repo-level literal token
-  if (repoConfig && typeof repoConfig.token === 'string' && repoConfig.token) {
+  // 2. Repo-level literal token (alt-host credential; not used for a dual
+  // repo's github.com binding)
+  if (useRepoScopedToken && repoConfig && typeof repoConfig.token === 'string' && repoConfig.token) {
     token = repoConfig.token;
     source = 'repo:token';
     logger.debug(`Using token from repos[${repository}].token`);
-    return { apiHost, token, features, source, refresh: null };
+    return { apiHost, host: apiHost, token, features, source, refresh: null };
   }
 
   // 3. Repo-level token_command
-  if (repoConfig && typeof repoConfig.token_command === 'string' && repoConfig.token_command) {
+  if (useRepoScopedToken && repoConfig && typeof repoConfig.token_command === 'string' && repoConfig.token_command) {
     const result = _runTokenCommand(repoConfig.token_command, repository, 'repo:token_command');
     if (result) {
       return {
         apiHost,
+        host: apiHost,
         token: result,
         features,
         source: 'repo:token_command',
-        refresh: _makeRefresh(repository, safeConfig, 'repo:token_command')
+        refresh: _makeRefresh(repository, safeConfig, 'repo:token_command', options)
       };
     }
   }
 
-  // 4. Top-level github_token. Only consulted for github.com bindings —
+  // 4. Top-level github_token. Only consulted for a github.com binding —
   // the top-level token is a github.com credential and would fail
   // authentication when sent to an alt-host.
-  if (apiHost === null && typeof safeConfig.github_token === 'string' && safeConfig.github_token) {
+  if (useGithubChain && typeof safeConfig.github_token === 'string' && safeConfig.github_token) {
     token = safeConfig.github_token;
     source = 'config:github_token';
     logger.debug('Using GitHub token from config.github_token');
-    return { apiHost, token, features, source, refresh: null };
+    return { apiHost, host: apiHost, token, features, source, refresh: null };
   }
 
   // 5. Top-level github_token_command. Like step 4, github.com-only.
@@ -623,25 +701,26 @@ function resolveHostBinding(repository, config) {
   // command only — keying on repository would re-invoke the (often
   // slow) command per repo per session. Repo-level `token_command`
   // above keeps its per-(repo, command) cache key.
-  if (apiHost === null && typeof safeConfig.github_token_command === 'string' && safeConfig.github_token_command) {
+  if (useGithubChain && typeof safeConfig.github_token_command === 'string' && safeConfig.github_token_command) {
     const result = _runTokenCommand(safeConfig.github_token_command, null, 'config:github_token_command');
     if (result) {
       return {
         apiHost,
+        host: apiHost,
         token: result,
         features,
         source: 'config:github_token_command',
-        refresh: _makeRefresh(repository, safeConfig, 'config:github_token_command')
+        refresh: _makeRefresh(repository, safeConfig, 'config:github_token_command', options)
       };
     }
   }
 
-  if (apiHost !== null && repository) {
+  if (isAltBinding && repository) {
     logger.debug(`No repo-scoped token resolved for alt-host repo ${repository} (${apiHost}); github.com top-level credentials are not used for alt-hosts`);
   } else {
     logger.debug('No token resolved for host binding');
   }
-  return { apiHost, token: '', features, source: 'none', refresh: null };
+  return { apiHost, host: apiHost, token: '', features, source: 'none', refresh: null };
 }
 
 /**
@@ -656,14 +735,15 @@ function resolveHostBinding(repository, config) {
  * @param {string|null|undefined} repository - "owner/repo" identifier as supplied to resolveHostBinding
  * @param {Object} config - Configuration object from loadConfig()
  * @param {('repo:token_command'|'config:github_token_command')} source - The refreshable source backing the binding
+ * @param {{ host?: string|null }} [options] - The same host override the binding was resolved with, so the refresh re-resolves the SAME flavor (a two-arg re-resolve would apply the ambiguity rule and could pick the wrong host for a dual repo)
  * @returns {function(): string} - Closure resolving to the fresh token (empty string on failure)
  */
-function _makeRefresh(repository, config, source) {
+function _makeRefresh(repository, config, source, options = {}) {
   return function refresh() {
     invalidateTokenCache(repository, config, source);
     // Re-resolve after invalidation so _runTokenCommand re-executes the
     // command. Returns '' if the command now fails or yields nothing.
-    return resolveHostBinding(repository, config).token;
+    return resolveHostBinding(repository, config, options).token;
   };
 }
 
@@ -795,6 +875,22 @@ function validateRepoConfig(config) {
     const apiHost = (typeof repoEntry.api_host === 'string' && repoEntry.api_host) ? repoEntry.api_host : null;
     const features = (repoEntry.features && typeof repoEntry.features === 'object') ? repoEntry.features : {};
 
+    // `exclusive` marks whether an alt-host repo's PRs live ONLY on its
+    // `api_host` (default) or may also live on github.com (`exclusive: false`,
+    // a dual repo). It is meaningless without `api_host`.
+    if (repoEntry.exclusive !== undefined && repoEntry.exclusive !== null) {
+      if (typeof repoEntry.exclusive !== 'boolean') {
+        throw new Error(
+          `Invalid pair-review config: repos["${repoKey}"].exclusive must be a boolean.`
+        );
+      }
+      if (!apiHost) {
+        throw new Error(
+          `Invalid pair-review config: repos["${repoKey}"].exclusive is only valid when api_host is set.`
+        );
+      }
+    }
+
     for (const [area, value] of Object.entries(features)) {
       // Endpoint-override sub-keys (e.g. `pending_review_comments_endpoint`)
       // are validated separately below. Reject anything that ends in
@@ -910,6 +1006,31 @@ function validateRepoConfig(config) {
           `Invalid pair-review config: repos["${repoKey}"].url_pattern is not a valid regular expression: ${err.message}`
         );
       }
+
+      // An `api_host`-bearing pattern must never match a canonical github.com /
+      // Graphite URL — doing so pre-pins a github PR to the alt host and bypasses
+      // the setup probe (a silent, durable wrong binding). Warn (do NOT throw —
+      // we must not break existing configs; parsePRUrl also guards this at
+      // runtime by discarding such matches) when the pattern is over-broad.
+      if (typeof repoEntry.api_host === 'string' && repoEntry.api_host) {
+        try {
+          const rx = new RegExp(repoEntry.url_pattern);
+          const canaries = [
+            'https://github.com/o/r/pull/1',
+            'https://app.graphite.dev/github/pr/o/r/1',
+            'https://app.graphite.com/github/o/r/pull/1'
+          ];
+          if (canaries.some((u) => rx.test(u))) {
+            logger.warn(
+              `repos["${repoKey}"].url_pattern also matches canonical github.com / Graphite URLs; ` +
+              `anchor it (e.g. start with "^https://<your-alt-host>/") so it never pre-pins a github.com ` +
+              `PR to the alt host. pair-review will still route such URLs to github.com.`
+            );
+          }
+        } catch {
+          // Invalid regex already reported above; nothing more to check.
+        }
+      }
     }
 
     // Optional escape-hatch regex used by parseRepositoryFromURL to match
@@ -1512,6 +1633,7 @@ module.exports = {
   validatePort,
   getGitHubToken,
   resolveHostBinding,
+  isExclusiveAltHost,
   invalidateTokenCache,
   validateRepoConfig,
   matchRepoByUrl,

package/src/database.js

@@ -21,7 +21,7 @@ function getDbPath() {
 /**
  * Current schema version - increment this when adding new migrations
  */
-const CURRENT_SCHEMA_VERSION = 48;
+const CURRENT_SCHEMA_VERSION = 51;
 
 /**
  * Database schema SQL statements
@@ -123,6 +123,7 @@ const SCHEMA_SQL = {
       pr_data TEXT,
       last_ai_run_id TEXT,
       last_accessed_at TEXT,
+      host TEXT,
       UNIQUE(pr_number, repository)
     )
   `,
@@ -312,6 +313,7 @@ const SCHEMA_SQL = {
       html_url TEXT,
       state TEXT DEFAULT 'open',
       collection TEXT NOT NULL,
+      host TEXT,
       fetched_at DATETIME DEFAULT CURRENT_TIMESTAMP
     )
   `,
@@ -349,6 +351,7 @@ const SCHEMA_SQL = {
       diff_position INTEGER,
       commit_sha TEXT,
       is_outdated INTEGER NOT NULL DEFAULT 0,
+      is_file_level INTEGER NOT NULL DEFAULT 0,
       original_line_start INTEGER,
       original_line_end INTEGER,
       original_commit_sha TEXT,
@@ -397,8 +400,14 @@ const INDEX_SQL = [
   'CREATE INDEX IF NOT EXISTS idx_context_files_review ON context_files(review_id)',
   // Hunk summaries indexes
   'CREATE INDEX IF NOT EXISTS idx_hunk_summaries_review ON hunk_summaries(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)',
+  // GitHub PR cache indexes. `host` is part of the unique key so a dual-host
+  // repo can cache the same (collection, owner, repo, number) from github.com
+  // (host NULL) AND its alt host (host = api_host URL) without colliding —
+  // independently-numbered PRs across systems overlap on small numbers. SQLite
+  // treats NULLs as distinct in unique indexes, so two NULL-host rows would not
+  // collide, but the collections refresh DELETEs the collection before
+  // re-inserting, so duplicate NULL-host rows can't accumulate. See migration 51.
+  'CREATE UNIQUE INDEX IF NOT EXISTS idx_github_pr_cache_unique ON github_pr_cache(collection, owner, repo, number, host)',
   // Worktree pool indexes
   'CREATE INDEX IF NOT EXISTS idx_worktree_pool_repo ON worktree_pool(repository)',
   'CREATE INDEX IF NOT EXISTS idx_worktree_pool_status ON worktree_pool(repository, status)',
@@ -1305,6 +1314,9 @@ const MIGRATIONS = {
           fetched_at DATETIME DEFAULT CURRENT_TIMESTAMP
         )
       `);
+      // Historical shape: no `host` column exists at v26 (added in migration
+      // 50). Migration 51 widens this index to include `host`. Do NOT add
+      // `host` here — it would reference a column that doesn't exist yet.
       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 {
@@ -2159,6 +2171,72 @@ const MIGRATIONS = {
       console.log('  Table tours already exists');
     }
     console.log('Migration to schema version 48 complete');
+  },
+
+  // Migration to version 49: Add is_file_level flag to external_comments so
+  // file-level review comments (GitHub subject_type='file') can be rendered in
+  // the per-file comments zone instead of as a bogus line-1 annotation.
+  // Idempotent single-column ALTER guarded by columnExists — safe to re-run.
+  // A single DDL statement needs no transaction wrapper.
+  49: (db) => {
+    console.log('Running migration to schema version 49: Add is_file_level to external_comments...');
+    if (!tableExists(db, 'external_comments')) {
+      // Table not created yet (older instance below version 45). Migration 45
+      // creates it with the current base schema; nothing to alter here.
+      console.log('  external_comments table not present; nothing to alter');
+    } else if (!columnExists(db, 'external_comments', 'is_file_level')) {
+      db.exec('ALTER TABLE external_comments ADD COLUMN is_file_level INTEGER NOT NULL DEFAULT 0');
+      console.log('  Added is_file_level column to external_comments');
+    } else {
+      console.log('  Column is_file_level already exists');
+    }
+    console.log('Migration to schema version 49 complete');
+  },
+
+  // Migration to version 50: Add host column to pr_metadata and github_pr_cache
+  // for per-PR host resolution (dual GitHub + alt-host repos). NULL means
+  // github.com; otherwise the configured api_host URL string. No backfill — the
+  // NULL-means-github fallback makes existing rows resolve identically, and rows
+  // are re-stamped on next fetch. Each ALTER is guarded by columnExists so the
+  // migration is idempotent; single DDL statements need no transaction wrapper.
+  50: (db) => {
+    console.log('Running migration to schema version 50: Add host to pr_metadata and github_pr_cache...');
+    if (tableExists(db, 'pr_metadata') && !columnExists(db, 'pr_metadata', 'host')) {
+      db.exec('ALTER TABLE pr_metadata ADD COLUMN host TEXT');
+      console.log('  Added host column to pr_metadata');
+    } else {
+      console.log('  Column host already exists on pr_metadata (or table absent)');
+    }
+    if (tableExists(db, 'github_pr_cache') && !columnExists(db, 'github_pr_cache', 'host')) {
+      db.exec('ALTER TABLE github_pr_cache ADD COLUMN host TEXT');
+      console.log('  Added host column to github_pr_cache');
+    } else {
+      console.log('  Column host already exists on github_pr_cache (or table absent)');
+    }
+    console.log('Migration to schema version 50 complete');
+  },
+
+  // Migration to version 51: widen idx_github_pr_cache_unique to include host.
+  // The collections refresh inserts github rows (host NULL) and alt-host rows
+  // (host = api_host URL) under the same collection in one transaction. For a
+  // dual-host repo whose PRs are numbered independently per system, a shared
+  // (collection, owner, repo, number) would violate the old 4-column unique
+  // index — and the single throw rolls back the DELETE plus BOTH insert loops,
+  // so the user sees zero PRs for that collection. Adding host to the key lets
+  // the two systems' same-numbered PRs coexist. The new index is strictly wider
+  // than the old one, so existing data can never violate it. Idempotent:
+  // DROP IF EXISTS then CREATE IF NOT EXISTS yields the same shape on re-run and
+  // is safe on both a v50 DB (old 4-column index) and a fresh DB.
+  51: (db) => {
+    console.log('Running migration to schema version 51: widen idx_github_pr_cache_unique to include host...');
+    if (tableExists(db, 'github_pr_cache')) {
+      db.exec('DROP INDEX IF EXISTS idx_github_pr_cache_unique');
+      db.exec('CREATE UNIQUE INDEX IF NOT EXISTS idx_github_pr_cache_unique ON github_pr_cache(collection, owner, repo, number, host)');
+      console.log('  Rebuilt idx_github_pr_cache_unique with host in the key');
+    } else {
+      console.log('  Table github_pr_cache absent; nothing to reindex');
+    }
+    console.log('Migration to schema version 51 complete');
   }
 };
 
@@ -4974,6 +5052,52 @@ class PRMetadataRepository {
     };
   }
 
+  /**
+   * Get the stored host binding for a PR.
+   *
+   * Distinguishes "no row" from "row says github". Used by per-PR host
+   * resolution (dual GitHub + alt-host repos) to decide which system a PR
+   * lives on before building a binding.
+   *
+   * @param {string} repository - Repository in owner/repo format
+   * @param {number} prNumber - Pull request number
+   * @returns {Promise<string|null|undefined>} The stored api_host URL string,
+   *   `null` when the row exists but host is unset (github.com), or `undefined`
+   *   when no pr_metadata row exists for the PR.
+   */
+  async getPRHost(repository, prNumber) {
+    const row = await queryOne(this.db, `
+      SELECT host FROM pr_metadata
+      WHERE pr_number = ? AND repository = ? COLLATE NOCASE
+    `, [prNumber, repository]);
+
+    if (!row) return undefined;
+    return row.host;
+  }
+
+  /**
+   * Update ONLY the host binding for a PR's metadata row.
+   *
+   * Used to persist an explicit host correction (e.g. a `?host` query param on
+   * the /pr fast path) without re-running full setup. Leaves every other column
+   * untouched.
+   *
+   * @param {string} repository - Repository in owner/repo format
+   * @param {number} prNumber - Pull request number
+   * @param {string|null} host - api_host URL string, or null for github.com
+   * @returns {Promise<boolean>} True if a matching row was updated, false when
+   *   no pr_metadata row exists for the PR.
+   */
+  async updatePRHost(repository, prNumber, host) {
+    const result = await run(this.db, `
+      UPDATE pr_metadata
+      SET host = ?, updated_at = CURRENT_TIMESTAMP
+      WHERE pr_number = ? AND repository = ? COLLATE NOCASE
+    `, [host, prNumber, repository]);
+
+    return result.changes > 0;
+  }
+
   /**
    * Update the last_ai_run_id for a PR metadata record
    * @param {number} id - PR metadata record ID
@@ -5007,7 +5131,7 @@ class AnalysisRunRepository {
    * @param {Object} runInfo - Run information
    * @param {string} runInfo.id - Unique run ID (UUID)
    * @param {number} runInfo.reviewId - Review ID (references reviews.id, works for both PR and local modes)
-   * @param {string} [runInfo.provider] - AI provider (claude, gemini, etc.)
+   * @param {string} [runInfo.provider] - AI provider (claude, antigravity, etc.)
    * @param {string} [runInfo.model] - AI model name
    * @param {string} [runInfo.customInstructions] - Merged custom instructions (kept for backward compatibility)
    * @param {string} [runInfo.globalInstructions] - Global instructions from ~/.pair-review/global-instructions.md