feat(server,web): a GitHub owner can use its own account

Per-host account choice cannot serve personal and work repositories on the
same host. Settings can now pin a gh login to a user or organization; its
repositories are read and written with that login, and viewers, searches and
stat batches are grouped by account.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: ulughbeck

apps/server/src/pullRequest/GitHubPullRequestCli.test.ts

@@ -77,6 +77,7 @@ const mockApi = Layer.effect(
   Effect.gen(function* () {
     const budget = yield* GitHubGraphQlBudget.GitHubGraphQlBudget;
     return GitHubApi.GitHubApi.of({
+      accountFor: () => Effect.succeed(null),
       graphql: (input) =>
         budget
           .query(input.host, input.query, input.allowReserve ? { allowReserve: true } : undefined)
@@ -467,6 +468,7 @@ it.effect(
       const credentials = Layer.succeed(
         GitHubCredentials.GitHubCredentials,
         GitHubCredentials.GitHubCredentials.of({
+          accountFor: () => Effect.succeed(null),
           get: (host) =>
             Effect.sync(() => ({
               host,

apps/server/src/pullRequest/GitHubPullRequestCli.ts

@@ -482,6 +482,11 @@ export class GitHubPullRequestCli extends Context.Service<
       readonly cwd: string;
       readonly host: string;
     }) => Effect.Effect<string, GitHubPullRequestCliError>;
+    /** The login Settings pin for this repository's owner, or null for the host's own. */
+    readonly repositoryAccount: (input: {
+      readonly host: string;
+      readonly repository: string;
+    }) => Effect.Effect<string | null>;
 
     readonly listPullRequests: (input: {
       readonly cwd: string;
@@ -1765,6 +1770,8 @@ export const make = Effect.gen(function* () {
         Context.getOrElse(context, GitHubApi.PinnedGitHubCredential, () => null)
           ?.credentialFingerprint ?? null,
         Context.getOrElse(context, SourceControlRateLimit.CredentialScope, () => ""),
+        // An owner with its own account is read with its own token, never batched with others.
+        Context.getOrElse(context, GitHubApi.GitHubRepositoryOwner, () => null),
       ]),
     resolver: (entries) => {
       const [first] = entries;
@@ -1845,6 +1852,8 @@ export const make = Effect.gen(function* () {
         Context.getOrElse(context, GitHubApi.PinnedGitHubCredential, () => null)
           ?.credentialFingerprint ?? null,
         Context.getOrElse(context, SourceControlRateLimit.CredentialScope, () => ""),
+        // An owner with its own account is read with its own token, never batched with others.
+        Context.getOrElse(context, GitHubApi.GitHubRepositoryOwner, () => null),
       ]),
     resolver: (entries) => {
       const [first] = entries;
@@ -1893,6 +1902,8 @@ export const make = Effect.gen(function* () {
     getRoutingIdentity,
     getViewerLogin: (input) =>
       getRoutingIdentity(input).pipe(Effect.map((identity) => identity.viewer)),
+    repositoryAccount: (input) =>
+      api.accountFor(input.host, parseRepositorySelector(input.repository).owner),
 
     listPullRequests: (input) => {
       const fallbackMaxRows = Math.max(input.limit + 1, PULL_REQUEST_FALLBACK_MAX_ROWS);

apps/server/src/pullRequest/GitHubPullRequestProvider.ts

@@ -262,6 +262,7 @@ export const make = Effect.gen(function* () {
   const provider: PullRequestProviderApi = {
     kind: "github",
     capabilities: CAPABILITIES,
+    repositoryAccount: (input) => cli.repositoryAccount(input),
     getRoutingIdentity: (input) =>
       cli.getRoutingIdentity(input).pipe(Effect.mapError(fail("routeIdentity"))),
     withVerifiedCredential: (input, use) =>

apps/server/src/pullRequest/PullRequestProvider.ts

@@ -328,8 +328,18 @@ export interface ProviderRepositoryRef {
  * failing at call time.
  */
 export interface PullRequestProviderApi {
+  /**
+   * The account that serves a repository when it is not the host's own, or null. GitHub can pin
+   * an owner's repositories to their own login; the service groups viewers and batched reads by
+   * this so one request never mixes two accounts.
+   */
+  readonly repositoryAccount?: (input: {
+    readonly host: string;
+    readonly repository: string;
+  }) => Effect.Effect<string | null>;
+  /** `repository`, when given, selects the account that serves it (see `repositoryAccount`). */
   readonly withVerifiedCredential?: <A, E, R>(
-    input: { readonly cwd: string; readonly host: string },
+    input: { readonly cwd: string; readonly host: string; readonly repository?: string },
     use: (identity: {
       readonly accountId: string;
       readonly viewer: string;
@@ -339,17 +349,22 @@ export interface PullRequestProviderApi {
   readonly getRoutingIdentity?: (input: {
     readonly cwd: string;
     readonly host: string;
+    readonly repository?: string;
   }) => Effect.Effect<
     { readonly accountId: string; readonly viewer: string },
     PullRequestProviderError
   >;
   readonly kind: SourceControlProviderKind;
   readonly capabilities: PullRequestCapabilities;
 
-  /** The signed-in account, which is what involvement filtering compares against. */
+  /**
+   * The signed-in account, which is what involvement filtering compares against. `repository`,
+   * when given, asks for the account that serves it rather than the host's own.
+   */
   readonly getViewer: (input: {
     readonly cwd: string;
     readonly host?: string;
+    readonly repository?: string;
   }) => Effect.Effect<string, PullRequestProviderError>;
 
   readonly listChangeRequests: (

apps/server/src/pullRequest/PullRequestService.test.ts

@@ -2,6 +2,7 @@ import * as NodeServices from "@effect/platform-node/NodeServices";
 import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner";
 import * as KeyValueStore from "effect/persistence/KeyValueStore";
 import { assert, it } from "@effect/vitest";
+import { GitHubRepositoryOwner } from "../sourceControl/GitHubApi.ts";
 import * as Cause from "effect/Cause";
 import * as Clock from "effect/Clock";
 import * as Deferred from "effect/Deferred";
@@ -1279,6 +1280,67 @@ it.effect("tries another workspace on the same host for the viewer", () =>
   }),
 );
 
+it.effect("reads an owner with its own account under that account, apart from the rest", () =>
+  Effect.gen(function* () {
+    const searches: Array<{
+      readonly viewer: string;
+      readonly owner: string | null;
+      readonly repositories: ReadonlyArray<string>;
+    }> = [];
+    const statReads: Array<{ readonly owner: string | null; readonly count: number }> = [];
+    const service = yield* makeService({
+      projects: [
+        project({ id: "p1", title: "personal", workspaceRoot: "/p1", repository: "me/one" }),
+        project({ id: "p2", title: "other", workspaceRoot: "/p2", repository: "me/two" }),
+        project({ id: "w1", title: "work", workspaceRoot: "/w1", repository: "Acme/web" }),
+      ],
+      providers: [
+        fakeProvider("github", {
+          repositoryAccount: ({ repository }) =>
+            Effect.succeed(repository.toLowerCase().startsWith("acme/") ? "work" : null),
+          getViewer: () =>
+            Effect.map(GitHubRepositoryOwner, (owner) => (owner === null ? "personal" : "work")),
+          listChangeRequestsAcross: (input) =>
+            Effect.map(GitHubRepositoryOwner, (owner) => {
+              searches.push({ viewer: input.viewer, owner, repositories: input.repositories });
+              return {
+                items: input.repositories.map((repository, index) =>
+                  batchedChangeRequest(index + 1, repository, "2026-07-02T00:00:00Z"),
+                ),
+                truncated: false,
+              };
+            }),
+          listChangeRequestStats: (input) =>
+            Effect.map(GitHubRepositoryOwner, (owner) => {
+              statReads.push({ owner, count: input.changeRequests.length });
+              return input.changeRequests.map((ref) => ({ ...ref, additions: 1, deletions: 1 }));
+            }),
+        }),
+      ],
+    });
+    const result = yield* service.list({ state: "open", involvement: "all" });
+    assert.strictEqual(result.entries.length, 3);
+    assert.sameDeepMembers(searches, [
+      { viewer: "personal", owner: null, repositories: ["me/one", "me/two"] },
+      { viewer: "work", owner: "Acme", repositories: ["Acme/web"] },
+    ]);
+    assert.strictEqual(result.viewers["github.com"], "personal");
+    assert.strictEqual(result.viewers["github.com/acme"], "work");
+
+    yield* service.listStats({
+      refs: result.entries.map(({ projectId, repository, number }) => ({
+        projectId,
+        repository,
+        number,
+      })),
+    });
+    assert.sameDeepMembers(statReads, [
+      { owner: null, count: 2 },
+      { owner: "Acme", count: 1 },
+    ]);
+  }),
+);
+
 it.effect("routing verifies the current account on the requested host without caching it", () =>
   Effect.gen(function* () {
     let viewer = "first-account";
@@ -1295,7 +1357,11 @@ it.effect("routing verifies the current account on the requested host without ca
       providers: [
         fakeProvider("github", {
           getRoutingIdentity: (input) => {
-            assert.deepStrictEqual(input, { cwd: "/a", host: "github.example.test" });
+            assert.deepStrictEqual(input, {
+              cwd: "/a",
+              host: "github.example.test",
+              repository: "acme/web",
+            });
             return Effect.succeed({
               viewer,
               accountId: viewer === "first-account" ? "123" : "456",