claude-teammate 0.1.83 → 0.1.85

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-teammate",
-  "version": "0.1.83",
+  "version": "0.1.85",
   "description": "CLI bootstrapper for Claude Teammate.",
   "license": "MIT",
   "type": "module",

package/src/commands/start.js

@@ -6,6 +6,7 @@ import process from "node:process";
 import { ensurePlaywrightMcpAvailable, verifyClaudeCli } from "../claude.js";
 import { createForgeRegistry } from "../forge/index.js";
 import { createJiraClient } from "../jira.js";
+import { listKnownRepos } from "../memory.js";
 import {
   REQUIRED_FIELDS,
   ensureGlobalConfigDir,
@@ -71,7 +72,7 @@ export async function runStartCommand({ projectRoot, entrypointPath, args = [] }
 
     process.stdout.write("Checking Jira credentials...\n");
     await verifyJiraCredentials(values);
-    await verifyForgeCredentials(values);
+    await verifyForgeCredentials(values, configRoot);
 
     const logFd = openSync(runtimePaths.logFile, "a");
     const child = spawn(process.execPath, [entrypointPath, "run-worker", configRoot], {
@@ -176,31 +177,46 @@ async function verifyJiraCredentials(config) {
   }
 }
 
-async function verifyForgeCredentials(config) {
+async function verifyForgeCredentials(config, configRoot) {
   const forge = createForgeRegistry(config);
-  const providers = forge.listConfiguredClients();
+  const provider = forge.getActiveClient();
 
-  for (const provider of providers) {
-    if (!shouldVerifyProviderAtStart(provider.id, config)) {
-      process.stdout.write(`Skipping ${provider.label} credential preflight.\n`);
-      continue;
-    }
+  if (!provider) {
+    return;
+  }
+
+  const verificationTargets = await getForgeVerificationTargets(provider.id, config, configRoot);
+  if (verificationTargets.length === 0) {
+    process.stdout.write(`Skipping ${provider.label} credential preflight.\n`);
+    return;
+  }
 
-    process.stdout.write(`Checking ${provider.label} credentials...\n`);
-    try {
-      await provider.client.fetchCurrentUser();
-    } catch (error) {
-      throw new Error(`${provider.label} credential check failed: ${formatError(error)}`);
+  process.stdout.write(`Checking ${provider.label} credentials...\n`);
+  try {
+    for (const target of verificationTargets) {
+      await provider.client.fetchCurrentUser(target);
     }
+  } catch (error) {
+    throw new Error(`${provider.label} credential check failed: ${formatError(error)}`);
   }
 }
 
-export function shouldVerifyProviderAtStart(providerId, config) {
+export async function getForgeVerificationTargets(providerId, config, configRoot) {
   if (providerId === "gitlab") {
-    return Boolean(String(config.GITLAB_BASE_URL || "").trim());
+    const configuredBaseUrl = String(config.GITLAB_BASE_URL || "").trim();
+    if (configuredBaseUrl) {
+      return [configuredBaseUrl];
+    }
+
+    const repos = await listKnownRepos(configRoot);
+    return [...new Set(
+      repos
+        .map((repo) => String(repo?.url || "").trim())
+        .filter((repoUrl) => repoUrl.includes("gitlab"))
+    )];
   }
 
-  return true;
+  return [""];
 }
 
 function formatError(error) {

package/src/commands/worker.js

@@ -125,7 +125,7 @@ export async function runWorkerCommand({ projectRoot }) {
   const jira = createJiraClient(values);
   const forgeRegistry = createForgeRegistry(values);
   const jiraBotUser = await loadJiraBotUser(jira, values, logger);
-  const forgeBotUsers = await loadForgeBotUsers(forgeRegistry, logger);
+  const forgeBotUsers = new Map();
   const state = {
     ...previousState,
     projectRoot,
@@ -239,12 +239,12 @@ export async function runWorkerCommand({ projectRoot }) {
     }
     githubFlag.value = true;
     await runPoll("GitHub", "GitHub", state, async () => {
-      const repos = await listKnownRepos(projectRoot);
+      const repos = filterReposForActiveForge(await listKnownRepos(projectRoot), forgeRegistry);
       const processedIssues = [];
       let trackedIssueCount = 0;
       for (const repo of repos) {
         const provider = forgeRegistry.getClientForRepo(repo.url);
-        const botUser = getForgeBotUserForRepo(forgeBotUsers, repo.url);
+        const botUser = await getForgeBotUserForRepo(forgeRegistry, forgeBotUsers, repo.url, logger);
         const localPath = await resolveRepoLocalPath(repo, runtimePaths.reposDir, logger, `${provider.label} repo`);
         if (localPath === null) {
           continue;
@@ -283,12 +283,12 @@ export async function runWorkerCommand({ projectRoot }) {
     prFlag.value = true;
     const prJira = createJiraClient(values);
     await runPoll("Pr", "Pull request", state, async () => {
-      const repos = await listKnownRepos(projectRoot);
+      const repos = filterReposForActiveForge(await listKnownRepos(projectRoot), forgeRegistry);
       const processedPrs = [];
       let trackedPrCount = 0;
       for (const repo of repos) {
         const provider = forgeRegistry.getClientForRepo(repo.url);
-        const botUser = getForgeBotUserForRepo(forgeBotUsers, repo.url);
+        const botUser = await getForgeBotUserForRepo(forgeRegistry, forgeBotUsers, repo.url, logger);
         const localPath = await resolveRepoLocalPath(repo, runtimePaths.reposDir, logger, "draft PR repo");
         if (localPath === null) {
           continue;
@@ -330,7 +330,10 @@ export async function runWorkerCommand({ projectRoot }) {
     reviewFlag.value = true;
     await runPoll("Review", "PR review", state, async () => {
       const processedPrs = [];
-      const prs = await forgeRegistry.listPrsNeedingReview();
+      const repos = filterReposForActiveForge(await listKnownRepos(projectRoot), forgeRegistry);
+      const prs = await forgeRegistry.listPrsNeedingReview({
+        repoUrls: repos.map((repo) => repo.url)
+      });
       let reviewedPrCount = prs.length;
       for (const pr of prs) {
         if (!pr.repoUrl) {
@@ -451,6 +454,7 @@ async function processJiraIssue({ issue, jira, forgeRegistry, botUser, config, p
   const epicMemoryRecord = await loadEpicMemory(projectRoot, config.JIRA_BASE_URL, detail);
   let epicMemory = epicMemoryRecord.data;
   let issueMemory = issueMemoryRecord.data;
+  epicMemory.repos = filterReposForActiveForge(epicMemory.repos, forgeRegistry);
 
   try {
     issueMemory.last_error = "";
@@ -477,6 +481,7 @@ async function processJiraIssue({ issue, jira, forgeRegistry, botUser, config, p
 
     if (repoUrlsFromComments.length > 0) {
       epicMemory.repos = mergeRepoUrls(epicMemory.repos, repoUrlsFromComments);
+      epicMemory.repos = filterReposForActiveForge(epicMemory.repos, forgeRegistry);
       if (
         issueMemory.workflow_state === "awaiting_repo_request" ||
         issueMemory.workflow_state === "awaiting_repo_response" ||
@@ -1630,30 +1635,27 @@ async function loadJiraBotUser(jira, config, logger) {
   }
 }
 
-async function loadForgeBotUsers(forgeRegistry, logger) {
-  const users = new Map();
-
-  for (const provider of forgeRegistry.listConfiguredClients()) {
-    try {
-      users.set(provider.id, await provider.client.fetchCurrentUser());
-    } catch (error) {
-      await logger.error(`${provider.label} bot identity lookup failed`, { error });
-      users.set(provider.id, {
-        login: null,
-        id: null
-      });
-    }
+async function getForgeBotUserForRepo(forgeRegistry, forgeBotUsers, repoUrl, logger) {
+  const repo = parseRepoUrl(repoUrl);
+  const cacheKey = `${repo.provider}:${repo.host}`;
+  if (forgeBotUsers.has(cacheKey)) {
+    return forgeBotUsers.get(cacheKey);
   }
 
-  return users;
-}
-
-function getForgeBotUserForRepo(forgeBotUsers, repoUrl) {
-  const repo = parseRepoUrl(repoUrl);
-  return forgeBotUsers.get(repo.provider) || {
-    login: null,
-    id: null
-  };
+  const provider = forgeRegistry.getClientForRepo(repoUrl);
+  try {
+    const user = await provider.fetchCurrentUser(repoUrl);
+    forgeBotUsers.set(cacheKey, user);
+    return user;
+  } catch (error) {
+    await logger.error(`${provider.label} bot identity lookup failed`, { repo: repoUrl, error });
+    const fallback = {
+      login: null,
+      id: null
+    };
+    forgeBotUsers.set(cacheKey, fallback);
+    return fallback;
+  }
 }
 
 function isToDoStatus(status) {
@@ -2234,6 +2236,21 @@ function mergeRepoUrls(existingRepos, repoUrls) {
   return merged;
 }
 
+function filterReposForActiveForge(repos, forgeRegistry) {
+  const activeProviderId = forgeRegistry.getActiveProviderId();
+  if (!activeProviderId) {
+    return [];
+  }
+
+  return (Array.isArray(repos) ? repos : []).filter((repo) => {
+    try {
+      return parseRepoUrl(repo?.url || "").provider === activeProviderId;
+    } catch {
+      return false;
+    }
+  });
+}
+
 function dedupeGitHubIssues(githubIssues) {
   const seen = new Set();
   const deduped = [];

package/src/config.js

@@ -34,6 +34,12 @@ export const REQUIRED_FIELDS = [
     secret: true,
     required: true
   },
+  {
+    key: "FORGE_PROVIDER",
+    prompt: "Forge provider (gitlab or github)",
+    example: "gitlab",
+    required: false
+  },
   {
     key: "GITHUB_PAT",
     prompt: "GitHub personal access token",
@@ -94,7 +100,16 @@ export function getMissingFields(values) {
     .filter((field) => field.required !== false && !values[field.key])
     .map((field) => field.key);
 
-  if (!hasConfiguredForgeToken(values)) {
+  const provider = normalizeForgeProvider(values.FORGE_PROVIDER);
+  if (provider === "github") {
+    if (!String(values.GITHUB_PAT || "").trim()) {
+      missing.push("GITHUB_PAT");
+    }
+  } else if (provider === "gitlab") {
+    if (!String(values.GITLAB_TOKEN || "").trim()) {
+      missing.push("GITLAB_TOKEN");
+    }
+  } else if (!hasConfiguredForgeToken(values)) {
     missing.push("GITHUB_PAT or GITLAB_TOKEN");
   }
 
@@ -105,6 +120,11 @@ export function hasConfiguredForgeToken(values) {
   return Boolean(String(values.GITHUB_PAT || "").trim() || String(values.GITLAB_TOKEN || "").trim());
 }
 
+export function normalizeForgeProvider(value) {
+  const normalized = String(value || "").trim().toLowerCase();
+  return normalized === "gitlab" || normalized === "github" ? normalized : "";
+}
+
 export function maskSecret(value) {
   if (value.length <= 4) {
     return "*".repeat(value.length);

package/src/forge/gitlab.js

@@ -7,8 +7,10 @@ export function createGitLabClient(config) {
     id: "gitlab",
     label: "GitLab",
 
-    async fetchCurrentUser() {
-      const payload = await requestGitLab(config, "/api/v4/user");
+    async fetchCurrentUser(repoUrl = "") {
+      const payload = await requestGitLab(config, "/api/v4/user", {
+        baseUrl: resolveGitLabBaseUrl(config, repoUrl)
+      });
       return {
         login: payload.username ?? null,
         id: payload.id ?? null
@@ -17,7 +19,7 @@ export function createGitLabClient(config) {
 
     async findIssueByJiraKey(repoUrl, jiraKey) {
       const repo = parseGitLabRepoUrl(repoUrl);
-      const payload = await requestGitLab(config, projectPath(repo, "/issues"), {
+      const payload = await requestGitLabProject(config, repo, "/issues", {
         searchParams: {
           state: "all",
           search: jiraKey,
@@ -38,7 +40,7 @@ export function createGitLabClient(config) {
 
     async createIssue(repoUrl, issue) {
       const repo = parseGitLabRepoUrl(repoUrl);
-      const payload = await requestGitLab(config, projectPath(repo, "/issues"), {
+      const payload = await requestGitLabProject(config, repo, "/issues", {
         method: "POST",
         body: {
           title: issue.title,
@@ -53,8 +55,8 @@ export function createGitLabClient(config) {
 
     async fetchIssue(repoUrl, issueNumber) {
       const repo = parseGitLabRepoUrl(repoUrl);
-      const payload = await requestGitLab(config, projectPath(repo, `/issues/${issueNumber}`));
-      const comments = await requestGitLab(config, projectPath(repo, `/issues/${issueNumber}/notes`), {
+      const payload = await requestGitLabProject(config, repo, `/issues/${issueNumber}`);
+      const comments = await requestGitLabProject(config, repo, `/issues/${issueNumber}/notes`, {
         searchParams: {
           sort: "asc",
           per_page: "100"
@@ -66,7 +68,7 @@ export function createGitLabClient(config) {
 
     async listIssues(repoUrl) {
       const repo = parseGitLabRepoUrl(repoUrl);
-      const payload = await requestGitLab(config, projectPath(repo, "/issues"), {
+      const payload = await requestGitLabProject(config, repo, "/issues", {
         searchParams: {
           state: "opened",
           per_page: "100"
@@ -87,7 +89,7 @@ export function createGitLabClient(config) {
 
     async listPullRequests(repoUrl) {
       const repo = parseGitLabRepoUrl(repoUrl);
-      const payload = await requestGitLab(config, projectPath(repo, "/merge_requests"), {
+      const payload = await requestGitLabProject(config, repo, "/merge_requests", {
         searchParams: {
           state: "opened",
           per_page: "100"
@@ -100,8 +102,8 @@ export function createGitLabClient(config) {
 
     async fetchPullRequest(repoUrl, pullNumber) {
       const repo = parseGitLabRepoUrl(repoUrl);
-      const payload = await requestGitLab(config, projectPath(repo, `/merge_requests/${pullNumber}`));
-      const comments = await requestGitLab(config, projectPath(repo, `/merge_requests/${pullNumber}/notes`), {
+      const payload = await requestGitLabProject(config, repo, `/merge_requests/${pullNumber}`);
+      const comments = await requestGitLabProject(config, repo, `/merge_requests/${pullNumber}/notes`, {
         searchParams: {
           sort: "asc",
           per_page: "100"
@@ -110,7 +112,9 @@ export function createGitLabClient(config) {
       let headRepoCloneUrl = null;
       if (payload.source_project_id) {
         try {
-          const sourceProject = await requestGitLab(config, `/api/v4/projects/${payload.source_project_id}`);
+          const sourceProject = await requestGitLab(config, `/api/v4/projects/${payload.source_project_id}`, {
+            baseUrl: `${repo.origin}/`
+          });
           headRepoCloneUrl = sourceProject.http_url_to_repo || null;
         } catch {
           headRepoCloneUrl = null;
@@ -122,7 +126,7 @@ export function createGitLabClient(config) {
 
     async updateIssue(repoUrl, issueNumber, updates) {
       const repo = parseGitLabRepoUrl(repoUrl);
-      const payload = await requestGitLab(config, projectPath(repo, `/issues/${issueNumber}`), {
+      const payload = await requestGitLabProject(config, repo, `/issues/${issueNumber}`, {
         method: "PUT",
         body: {
           title: updates.title,
@@ -134,7 +138,7 @@ export function createGitLabClient(config) {
 
     async postIssueComment(repoUrl, issueNumber, body) {
       const repo = parseGitLabRepoUrl(repoUrl);
-      const payload = await requestGitLab(config, projectPath(repo, issueNotePath(issueNumber)), {
+      const payload = await requestGitLabProject(config, repo, issueNotePath(issueNumber), {
         method: "POST",
         body: { body }
       });
@@ -143,7 +147,7 @@ export function createGitLabClient(config) {
 
     async createIssueReaction(repoUrl, issueNumber, content = "eyes") {
       const repo = parseGitLabRepoUrl(repoUrl);
-      return requestGitLab(config, projectPath(repo, `${issueNotePath(issueNumber)}/award_emoji`), {
+      return requestGitLabProject(config, repo, `${issueNotePath(issueNumber)}/award_emoji`, {
         method: "POST",
         body: {
           name: mapReaction(content)
@@ -163,6 +167,7 @@ export function createGitLabClient(config) {
       for (const candidate of candidates) {
         try {
           return await requestGitLab(config, candidate, {
+            baseUrl: `${repo.origin}/`,
             method: "POST",
             body
           });
@@ -177,6 +182,7 @@ export function createGitLabClient(config) {
     async isRepoCollaborator(repoUrl, username) {
       const repo = parseGitLabRepoUrl(repoUrl);
       const users = await requestGitLab(config, "/api/v4/users", {
+        baseUrl: resolveGitLabBaseUrl(config, repoUrl),
         searchParams: {
           username,
           per_page: "1"
@@ -191,7 +197,7 @@ export function createGitLabClient(config) {
       }
 
       try {
-        await requestGitLab(config, projectPath(repo, `/members/all/${user.id}`));
+        await requestGitLabProject(config, repo, `/members/all/${user.id}`);
         return true;
       } catch (error) {
         if (String(error.message || "").includes("returned 404")) {
@@ -210,7 +216,7 @@ export function createGitLabClient(config) {
       if (updates.state === "closed") {
         body.state_event = "close";
       }
-      const payload = await requestGitLab(config, projectPath(repo, `/merge_requests/${pullNumber}`), {
+      const payload = await requestGitLabProject(config, repo, `/merge_requests/${pullNumber}`, {
         method: "PUT",
         body
       });
@@ -219,9 +225,9 @@ export function createGitLabClient(config) {
 
     async markPullRequestReady(repoUrl, pullNumber) {
       const repo = parseGitLabRepoUrl(repoUrl);
-      const current = await requestGitLab(config, projectPath(repo, `/merge_requests/${pullNumber}`));
+      const current = await requestGitLabProject(config, repo, `/merge_requests/${pullNumber}`);
       const title = stripDraftPrefix(current.title ?? "");
-      const payload = await requestGitLab(config, projectPath(repo, `/merge_requests/${pullNumber}`), {
+      const payload = await requestGitLabProject(config, repo, `/merge_requests/${pullNumber}`, {
         method: "PUT",
         body: { title }
       });
@@ -230,7 +236,7 @@ export function createGitLabClient(config) {
 
     async findPullRequestByHead(repoUrl, headBranch) {
       const repo = parseGitLabRepoUrl(repoUrl);
-      const payload = await requestGitLab(config, projectPath(repo, "/merge_requests"), {
+      const payload = await requestGitLabProject(config, repo, "/merge_requests", {
         searchParams: {
           state: "all",
           source_branch: headBranch,
@@ -248,38 +254,58 @@ export function createGitLabClient(config) {
 
     async getDefaultBranch(repoUrl) {
       const repo = parseGitLabRepoUrl(repoUrl);
-      const payload = await requestGitLab(config, projectPath(repo));
+      const payload = await requestGitLabProject(config, repo);
       return payload.default_branch;
     },
 
-    async listPrsNeedingReview() {
-      const currentUser = await this.fetchCurrentUser();
-      if (!currentUser.login) {
+    async listPrsNeedingReview(options = {}) {
+      const repoUrls = [...new Set((options.repoUrls || []).map((value) => String(value || "").trim()).filter(Boolean))];
+      if (repoUrls.length === 0 && !String(config.GITLAB_BASE_URL || "").trim()) {
         return [];
       }
-      const payload = await requestGitLab(config, "/api/v4/merge_requests", {
-        searchParams: {
-          state: "opened",
-          reviewer_username: currentUser.login,
-          scope: "all",
-          per_page: "100"
+      const baseUrls = repoUrls.length > 0
+        ? [...new Set(repoUrls.map((repoUrl) => resolveGitLabBaseUrl(config, repoUrl)))]
+        : [resolveGitLabBaseUrl(config)];
+
+      const results = [];
+
+      for (const baseUrl of baseUrls) {
+        if (!baseUrl) {
+          continue;
         }
-      });
-      return Array.isArray(payload)
-        ? payload
-            .filter((mergeRequest) => !Array.isArray(mergeRequest.labels) || !mergeRequest.labels.includes("AI-reviewed"))
-            .map((mergeRequest) => ({
-              repoUrl: String(mergeRequest.web_url || "").replace(/\/-\/merge_requests\/\d+$/u, ""),
-              number: mergeRequest.iid,
-              title: mergeRequest.title ?? ""
-            }))
-            .filter((mergeRequest) => Boolean(mergeRequest.repoUrl))
-        : [];
+
+        const currentUser = await this.fetchCurrentUser(baseUrl);
+        if (!currentUser.login) {
+          continue;
+        }
+        const payload = await requestGitLab(config, "/api/v4/merge_requests", {
+          baseUrl,
+          searchParams: {
+            state: "opened",
+            reviewer_username: currentUser.login,
+            scope: "all",
+            per_page: "100"
+          }
+        });
+        if (!Array.isArray(payload)) {
+          continue;
+        }
+        results.push(...payload
+          .filter((mergeRequest) => !Array.isArray(mergeRequest.labels) || !mergeRequest.labels.includes("AI-reviewed"))
+          .map((mergeRequest) => ({
+            repoUrl: String(mergeRequest.web_url || "").replace(/\/-\/merge_requests\/\d+$/u, ""),
+            number: mergeRequest.iid,
+            title: mergeRequest.title ?? ""
+          }))
+          .filter((mergeRequest) => Boolean(mergeRequest.repoUrl)));
+      }
+
+      return results;
     },
 
     async addLabelsToPullRequest(repoUrl, prNumber, labels) {
       const repo = parseGitLabRepoUrl(repoUrl);
-      return requestGitLab(config, projectPath(repo, `/merge_requests/${prNumber}`), {
+      return requestGitLabProject(config, repo, `/merge_requests/${prNumber}`, {
         method: "PUT",
         body: {
           add_labels: labels.join(",")
@@ -290,7 +316,7 @@ export function createGitLabClient(config) {
     async createPullRequestReview(repoUrl, prNumber, body, suggestions) {
       const repo = parseGitLabRepoUrl(repoUrl);
       const reviewBody = buildGitLabReviewBody(body, suggestions);
-      return requestGitLab(config, projectPath(repo, `/merge_requests/${prNumber}/notes`), {
+      return requestGitLabProject(config, repo, `/merge_requests/${prNumber}/notes`, {
         method: "POST",
         body: {
           body: reviewBody
@@ -300,13 +326,13 @@ export function createGitLabClient(config) {
 
     async fetchPullRequestDiff(repoUrl, prNumber) {
       const repo = parseGitLabRepoUrl(repoUrl);
-      const payload = await requestGitLab(config, projectPath(repo, `/merge_requests/${prNumber}/changes`));
+      const payload = await requestGitLabProject(config, repo, `/merge_requests/${prNumber}/changes`);
       return buildGitLabDiff(payload.changes || []);
     },
 
     async createPullRequest(repoUrl, pullRequest) {
       const repo = parseGitLabRepoUrl(repoUrl);
-      const payload = await requestGitLab(config, projectPath(repo, "/merge_requests"), {
+      const payload = await requestGitLabProject(config, repo, "/merge_requests", {
         method: "POST",
         body: {
           title: pullRequest.draft === true ? ensureDraftTitle(pullRequest.title) : pullRequest.title,
@@ -339,6 +365,13 @@ function issueNotePath(issueNumber) {
   return `/issues/${issueNumber}/notes`;
 }
 
+function requestGitLabProject(config, repo, suffix = "", init = {}) {
+  return requestGitLab(config, projectPath(repo, suffix), {
+    ...init,
+    baseUrl: `${repo.origin}/`
+  });
+}
+
 function buildGitLabReviewBody(body, suggestions = []) {
   const base = [String(body || "").trim()];
   if (Array.isArray(suggestions) && suggestions.length > 0) {
@@ -462,7 +495,7 @@ function mapReaction(content) {
 async function requestGitLab(config, pathOrUrl, init = {}) {
   const url = pathOrUrl.startsWith("http")
     ? new URL(pathOrUrl)
-    : new URL(pathOrUrl, determineGitLabBaseUrl(config));
+    : new URL(pathOrUrl, init.baseUrl || determineGitLabBaseUrl(config));
 
   if (init.searchParams) {
     for (const [key, value] of Object.entries(init.searchParams)) {
@@ -503,6 +536,30 @@ function determineGitLabBaseUrl(config) {
   return "https://gitlab.com/";
 }
 
+function resolveGitLabBaseUrl(config, repoUrl = "") {
+  const configured = String(config.GITLAB_BASE_URL || "").trim();
+  if (configured) {
+    return configured.endsWith("/") ? configured : `${configured}/`;
+  }
+
+  const repoValue = String(repoUrl || "").trim();
+  if (!repoValue) {
+    return "";
+  }
+
+  try {
+    const url = new URL(repoValue);
+    if (url.pathname === "/" || url.pathname === "") {
+      return `${url.origin}/`;
+    }
+  } catch {
+    // Fall through to repo URL parsing below.
+  }
+
+  const repo = parseGitLabRepoUrl(repoValue);
+  return `${repo.origin}/`;
+}
+
 function buildGitLabRequestError(status, url, body) {
   const detail = String(body || "").slice(0, 300);
   return `GitLab request ${url.pathname}${url.search} failed with ${status}: ${detail}`;

package/src/forge/index.js

@@ -1,47 +1,76 @@
 import { createGitHubClient } from "./github.js";
 import { createGitLabClient } from "./gitlab.js";
 import { getProviderLabel, parseRepoUrl } from "./repo-host.js";
+import { normalizeForgeProvider } from "../config.js";
 
 export function createForgeRegistry(config) {
-  const clients = new Map();
-
-  if (String(config.GITHUB_PAT || "").trim()) {
-    clients.set("github", createGitHubClient(config));
-  }
-
-  if (String(config.GITLAB_TOKEN || "").trim()) {
-    clients.set("gitlab", createGitLabClient(config));
-  }
+  const providerId = getActiveForgeProvider(config);
+  const client = createClient(providerId, config);
 
   return {
     hasClients() {
-      return clients.size > 0;
+      return Boolean(client);
     },
 
-    listConfiguredClients() {
-      return [...clients.entries()].map(([id, client]) => ({
-        id,
-        label: client.label || getProviderLabel(id),
-        client
-      }));
+    getActiveProviderId() {
+      return providerId;
+    },
+
+    getActiveClient() {
+      return client
+        ? {
+            id: providerId,
+            label: client.label || getProviderLabel(providerId),
+            client
+          }
+        : null;
     },
 
     getClientForRepo(repoUrl) {
-      const repo = parseRepoUrl(repoUrl);
-      const client = clients.get(repo.provider);
-      if (!client) {
+      if (!client || !providerId) {
+        const repo = parseRepoUrl(repoUrl);
         throw new Error(`${getProviderLabel(repo.provider)} token is not configured for ${repo.host}.`);
       }
+
+      const repo = parseRepoUrl(repoUrl);
+      if (repo.provider !== providerId) {
+        throw new Error(`Active forge is ${getProviderLabel(providerId)}, but repo uses ${getProviderLabel(repo.provider)}.`);
+      }
       return client;
     },
 
-    async listPrsNeedingReview() {
-      const results = [];
-      for (const client of clients.values()) {
-        const items = await client.listPrsNeedingReview();
-        results.push(...items);
+    async listPrsNeedingReview(options = {}) {
+      if (!client) {
+        return [];
       }
-      return results;
+      return client.listPrsNeedingReview(options);
     }
   };
 }
+
+export function getActiveForgeProvider(config) {
+  const explicit = normalizeForgeProvider(config.FORGE_PROVIDER);
+  if (explicit === "gitlab" && String(config.GITLAB_TOKEN || "").trim()) {
+    return "gitlab";
+  }
+  if (explicit === "github" && String(config.GITHUB_PAT || "").trim()) {
+    return "github";
+  }
+  if (String(config.GITLAB_TOKEN || "").trim()) {
+    return "gitlab";
+  }
+  if (String(config.GITHUB_PAT || "").trim()) {
+    return "github";
+  }
+  return "";
+}
+
+function createClient(providerId, config) {
+  if (providerId === "gitlab") {
+    return createGitLabClient(config);
+  }
+  if (providerId === "github") {
+    return createGitHubClient(config);
+  }
+  return null;
+}