diff --git a/apps/mobile/src/features/pull-requests/usePullRequestLiveChecks.test.tsx b/apps/mobile/src/features/pull-requests/usePullRequestLiveChecks.test.tsx
new file mode 100644
index 0000000000000..d5794cf908a69
--- /dev/null
+++ b/apps/mobile/src/features/pull-requests/usePullRequestLiveChecks.test.tsx
@@ -0,0 +1,140 @@
+import { RegistryContext } from "@effect/atom-react";
+import type { PullRequestChecks, PullRequestDetail } from "@t3tools/contracts";
+import * as Effect from "effect/Effect";
+import { AsyncResult, Atom, AtomRegistry } from "effect/reactivity";
+import { act } from "react";
+import { createRoot } from "react-dom/client";
+import { expect, it, vi } from "vite-plus/test";
+
+const fixture = vi.hoisted(() => ({
+  active: "active",
+  focused: true,
+  reads: 0,
+  appListeners: new Set<() => void>(),
+  focusListeners: new Set<() => void>(),
+  query: null as Atom.Atom<AsyncResult.AsyncResult<PullRequestChecks, never>> | null,
+}));
+
+vi.mock("react-native", () => ({
+  AppState: {
+    get currentState() {
+      return fixture.active;
+    },
+    addEventListener: (_event: string, listener: () => void) => {
+      fixture.appListeners.add(listener);
+      return { remove: () => fixture.appListeners.delete(listener) };
+    },
+  },
+}));
+vi.mock("@react-navigation/native", async () => {
+  const { useEffect, useSyncExternalStore } = await import("react");
+  const subscribe = (listener: () => void) => {
+    fixture.focusListeners.add(listener);
+    return () => fixture.focusListeners.delete(listener);
+  };
+  const useIsFocused = () => useSyncExternalStore(subscribe, () => fixture.focused);
+  return {
+    useIsFocused,
+    useFocusEffect: (effect: () => (() => void) | undefined) => {
+      const focused = useIsFocused();
+      useEffect(() => (focused ? effect() : undefined), [effect, focused]);
+    },
+  };
+});
+vi.mock("../../state/entities", () => ({
+  useEnvironmentServerConfig: () => ({
+    environment: { capabilities: { pullRequestChecks: true } },
+  }),
+}));
+vi.mock("../../state/pull-requests", () => ({
+  composerPullRequests: { checks: () => fixture.query },
+}));
+vi.mock("./usePullRequestConnected", () => ({ usePullRequestConnected: () => true }));
+vi.mock("./usePullRequestDiff", () => ({ pullRequestTarget: (params: unknown) => params }));
+
+import { usePullRequestLiveChecks } from "./usePullRequestLiveChecks";
+
+function setup(active = "active") {
+  (globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
+  vi.useFakeTimers({
+    toFake: ["Date", "setTimeout", "clearTimeout", "setInterval", "clearInterval"],
+  });
+  vi.setSystemTime(0);
+  fixture.active = active;
+  fixture.focused = true;
+  fixture.reads = 0;
+  fixture.appListeners.clear();
+  fixture.focusListeners.clear();
+  fixture.query = Atom.make(
+    Effect.sync(() => {
+      fixture.reads++;
+      return { state: "open" as const, checks: [], headSha: "head", observedAt: fixture.reads };
+    }),
+  ).pipe(Atom.setIdleTTL(0));
+  const registry = AtomRegistry.make();
+  const root = createRoot(document.createElement("div"));
+  const detail = { state: "open", checks: [], observedAt: 0 } as unknown as PullRequestDetail;
+  function Probe() {
+    usePullRequestLiveChecks(
+      { environmentId: "local", projectId: "project", repository: "acme/app", number: 7 },
+      detail,
+    );
+    return null;
+  }
+  act(() =>
+    root.render(
+      <RegistryContext.Provider value={registry}>
+        <Probe />
+      </RegistryContext.Provider>,
+    ),
+  );
+  return {
+    active(state: string) {
+      act(() => {
+        fixture.active = state;
+        for (const listener of fixture.appListeners) listener();
+      });
+    },
+    focused(focused: boolean) {
+      act(() => {
+        fixture.focused = focused;
+        for (const listener of fixture.focusListeners) listener();
+      });
+    },
+    async advance(milliseconds: number) {
+      await act(async () => vi.advanceTimersByTimeAsync(milliseconds));
+    },
+    [Symbol.dispose]() {
+      act(() => root.unmount());
+      registry.dispose();
+      vi.useRealTimers();
+    },
+  };
+}
+
+it("polls only the foreground focused route and resumes one checks subscription", async () => {
+  using screen = setup();
+  expect(fixture.reads).toBe(1);
+  await screen.advance(45_000);
+  expect(fixture.reads).toBe(2);
+  screen.active("background");
+  await screen.advance(180_000);
+  expect(fixture.reads).toBe(2);
+  screen.active("active");
+  expect(fixture.reads).toBe(3);
+  await screen.advance(45_000);
+  expect(fixture.reads).toBe(4);
+  screen.focused(false);
+  await screen.advance(180_000);
+  expect(fixture.reads).toBe(4);
+  screen.focused(true);
+  expect(fixture.reads).toBe(5);
+});
+
+it("does not subscribe to checks when the route first mounts in the background", async () => {
+  using screen = setup("background");
+  await screen.advance(180_000);
+  expect(fixture.reads).toBe(0);
+  screen.active("active");
+  expect(fixture.reads).toBe(1);
+});
diff --git a/apps/mobile/src/features/pull-requests/usePullRequestLiveChecks.ts b/apps/mobile/src/features/pull-requests/usePullRequestLiveChecks.ts
index b7ce339761704..d108290b10940 100644
--- a/apps/mobile/src/features/pull-requests/usePullRequestLiveChecks.ts
+++ b/apps/mobile/src/features/pull-requests/usePullRequestLiveChecks.ts
@@ -1,9 +1,11 @@
-import { useFocusEffect } from "@react-navigation/native";
+import { useIsFocused } from "@react-navigation/native";
+import { useEffect } from "react";
 import {
   pullRequestChecksRefreshIntervalMs,
   resolvePullRequestDetailChecks,
 } from "@t3tools/client-runtime/pull-request-checks";
 import type { PullRequestDetail } from "@t3tools/contracts";
+import { useAppActive } from "../../lib/appState";
 import { useEnvironmentServerConfig } from "../../state/entities";
 import { composerPullRequests } from "../../state/pull-requests";
 import { useEnvironmentQuery } from "../../state/query";
@@ -19,24 +21,35 @@ export function usePullRequestLiveChecks(
   detail: PullRequestDetail | null,
 ): PullRequestDetail | null {
   const target = pullRequestTarget(params);
+  const active = useAppActive();
+  const focused = useIsFocused();
   const connected = usePullRequestConnected(target.environmentId);
   const supported =
     useEnvironmentServerConfig(target.environmentId)?.environment.capabilities.pullRequestChecks ===
     true;
   const checks = useEnvironmentQuery(
-    supported && detail !== null ? composerPullRequests.checks(target) : null,
+    active && focused && connected && supported && detail !== null
+      ? composerPullRequests.checks(target)
+      : null,
   );
   // Both reads carry the server's observedAt; without it the poll is the fresher stream.
   const live = resolvePullRequestDetailChecks(detail, checks.data, true);
   // A failed read keeps polling; only a host that answers "no checks" (null) stops it.
   const enabled =
-    connected && supported && live?.state === "open" && !(checks.isSuccess && checks.data === null);
+    active &&
+    focused &&
+    connected &&
+    supported &&
+    !checks.isPending &&
+    live?.state === "open" &&
+    !(checks.isSuccess && checks.data === null);
   const intervalMs = pullRequestChecksRefreshIntervalMs(live?.checks ?? []);
   const { refresh } = checks;
-  useFocusEffect(() => {
+  // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- polls while the route is focused and the native app is active
+  useEffect(() => {
     if (!enabled) return;
     const timer = setInterval(refresh, intervalMs);
     return () => clearInterval(timer);
-  });
+  }, [enabled, intervalMs, refresh]);
   return live;
 }
diff --git a/apps/mobile/vite.config.ts b/apps/mobile/vite.config.ts
index e3e21de11d9dd..603bbea0aac1e 100644
--- a/apps/mobile/vite.config.ts
+++ b/apps/mobile/vite.config.ts
@@ -22,6 +22,7 @@ const reactTests = [
   "src/features/files/FileCodeRelationships.test.tsx",
   "src/features/loom/ProjectLoomRouteScreen.test.tsx",
   "src/features/pull-requests/usePullRequestList.test.tsx",
+  "src/features/pull-requests/usePullRequestLiveChecks.test.tsx",
   "src/features/files/ZipArchiveView.test.tsx",
   "src/features/pull-requests/guide/useReviewGuide.test.tsx",
   "src/features/settings/SettingsServerControlsRouteScreen.test.tsx",
diff --git a/apps/server/src/bin.ts b/apps/server/src/bin.ts
index ea863624ca225..d5dec56611989 100644
--- a/apps/server/src/bin.ts
+++ b/apps/server/src/bin.ts
@@ -17,7 +17,10 @@ if (
   // Guard sockets before either dispatch path can load outbound-capable modules.
   const { ignoreMacosTypeOfServiceEinval } = await import("./outboundHttp.ts");
   ignoreMacosTypeOfServiceEinval();
-  if (command === "__document-text") {
+  if (command === "__github-cli") {
+    const { runAgentGitHubCli } = await import("./sourceControl/agentGitHubCli.ts");
+    await runAgentGitHubCli(process.argv[3]!, process.argv.slice(4));
+  } else if (command === "__document-text") {
     const { extractDocumentText } = await import("./provider/documentTextWorker.ts");
     try {
       process.stdout.write(await extractDocumentText(process.argv[3]!, process.argv[4]!));
diff --git a/apps/server/src/mcp/toolkits/pullRequests/tools.ts b/apps/server/src/mcp/toolkits/pullRequests/tools.ts
index 8b89b669d2f3d..b5da76cba42b7 100644
--- a/apps/server/src/mcp/toolkits/pullRequests/tools.ts
+++ b/apps/server/src/mcp/toolkits/pullRequests/tools.ts
@@ -423,7 +423,7 @@ const PullRequestStatusTool = Tool.make("pull_request_status", {
 
 const PullRequestFailuresTool = Tool.make("pull_request_failures", {
   description:
-    "Why a PR's CI failed: each failing check's failed steps, annotations, and a bounded log excerpt around the errors. Use instead of gh run view --log-failed or gh api .../jobs/<id>/logs.",
+    "Why one PR's CI failed: each failing check's failed steps, annotations, and a bounded log excerpt around the errors. Accepts one PR per call; make separate calls for several PRs. Use instead of gh run view --log-failed or gh api .../jobs/<id>/logs.",
   parameters: Schema.Struct({
     environmentId: OrchestratorMcpEnvironmentTarget,
     ...PullRequestFailuresInput.fields,
@@ -440,7 +440,7 @@ const PullRequestFailuresTool = Tool.make("pull_request_failures", {
 
 const PullRequestFeedbackTool = Tool.make("pull_request_feedback", {
   description:
-    "Unresolved review threads, review verdicts, and comments on a PR, bot findings included, newest first. Use instead of gh api .../reviews, .../comments, or reviewThreads GraphQL.",
+    "Unresolved review threads, review verdicts, and comments on one PR, bot findings included, newest first. Accepts one PR per call; make separate calls for several PRs. Use instead of gh api .../reviews, .../comments, or reviewThreads GraphQL.",
   parameters: Schema.Struct({
     environmentId: OrchestratorMcpEnvironmentTarget,
     ...PullRequestReadInput.fields,
diff --git a/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.test.ts
index 036d4cb42e785..9cbbc2ee96dc5 100644
--- a/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.test.ts
+++ b/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.test.ts
@@ -1142,12 +1142,12 @@ describe("CodexAdapterV2 post-settle continuation", () => {
     onRequest: (method: string, params: unknown) => Effect.Effect<void> = () => Effect.void,
     readChildMetadata?: Parameters<typeof withCodexReplayChildMetadata>[2],
     runtimeOptions: Partial<
-      Pick<CodexAdapterV2.CodexAdapterV2Options, "settings" | "resolveRuntime">
-    > & { readonly modelProvider?: string | null } = {},
+      Pick<CodexAdapterV2.CodexAdapterV2Options, "settings" | "resolveRuntime" | "environment">
+    > & { readonly modelProvider?: string | null; readonly shellPath?: string } = {},
     beforeEmitInbound?: CodexReplay.CodexAppServerReplayDriver["beforeEmitInbound"],
   ) =>
     Effect.gen(function* () {
-      const { modelProvider = null, ...adapterRuntimeOptions } = runtimeOptions;
+      const { modelProvider = null, shellPath, ...adapterRuntimeOptions } = runtimeOptions;
       const fileSystem = yield* FileSystem.FileSystem;
       const idAllocator = yield* IdAllocator.IdAllocatorV2;
       const serverConfig = yield* ProviderReplayHarness.makeReplayServerConfig(
@@ -1188,7 +1188,12 @@ describe("CodexAdapterV2 post-settle continuation", () => {
                             ? Effect.sync(() => {
                                 configReadRequests.push(params);
                                 return {
-                                  config: { model_provider: modelProvider },
+                                  config: {
+                                    model_provider: modelProvider,
+                                    ...(shellPath === undefined
+                                      ? {}
+                                      : { shell_environment_policy: { set: { PATH: shellPath } } }),
+                                  },
                                   origins: {},
                                 };
                               })
@@ -1208,8 +1213,8 @@ describe("CodexAdapterV2 post-settle continuation", () => {
       const adapter = yield* CodexAdapterV2.makeCodexAdapterV2({
         instanceId: CodexAdapterV2.CODEX_DEFAULT_INSTANCE_ID,
         settings: DEFAULT_CODEX_SETTINGS,
-        ...adapterRuntimeOptions,
         environment: {},
+        ...adapterRuntimeOptions,
         clientFactory,
         crypto: yield* Crypto.Crypto,
         fileSystem,
@@ -1591,6 +1596,56 @@ describe("CodexAdapterV2 post-settle continuation", () => {
       ),
   );
 
+  it.effect.each([undefined, "/explicit/codex/bin"])(
+    "retains the hydrated managed gh PATH while respecting explicit Codex PATH %s",
+    (shellPath) =>
+      Effect.gen(function* () {
+        const managedPath =
+          "/t3/github/bin/launcher:/user/.nvm/bin:/user/.asdf/shims:/user/bin:/bin";
+        const expectedConfig = {
+          ...CodexAdapterV2.CODEX_THREAD_CONFIG,
+          ...(shellPath === undefined ? { "shell_environment_policy.set.PATH": managedPath } : {}),
+        };
+        const entries = codexReplayPreamble({
+          nativeThreadId: "managed-gh-thread",
+          nativeTurnId: "unused",
+          prompt: "unused",
+        }).slice(0, 5);
+        entries[3] = {
+          type: "expect_outbound",
+          label: "thread/start",
+          frame: { id: 2, method: "thread/start", params: { config: expectedConfig } },
+        };
+        const requests: Array<unknown> = [];
+        const harness = yield* makeCodexReplayHarness(
+          makeCodexReplayTranscript({ scenario: "managed-gh-path", entries }),
+          () => Effect.void,
+          (method, params) =>
+            Effect.sync(() => {
+              if (method === "thread/start") requests.push(params);
+            }),
+          undefined,
+          {
+            ...(shellPath === undefined ? {} : { shellPath }),
+            environment: {
+              PATH: managedPath,
+              T3_GH_SHIM_DIR: "/t3/github/bin/launcher",
+              CUSTOM: "preserved",
+            },
+          },
+        );
+        assert.deepEqual(requests, [
+          { cwd: "/workspace", model: "gpt-5.4", config: expectedConfig },
+        ]);
+        assert.equal(harness.configReadRequests.length, 1);
+      }).pipe(
+        Effect.scoped,
+        Effect.provide(
+          Layer.mergeAll(IdAllocator.layer, McpProviderSessions.layer, NodeServices.layer),
+        ),
+      ),
+  );
+
   it.effect("adds the session MCP server without replacing launch-argument servers", () =>
     Effect.gen(function* () {
       const scenario = "launch-mcp-servers";
diff --git a/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.ts
index 3e094a5b15537..330cdd50ea85d 100644
--- a/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.ts
+++ b/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.ts
@@ -1331,8 +1331,15 @@ export const CODEX_THREAD_CONFIG = {
 // T3 waits can block for an hour; keep Codex's MCP timeout above that.
 const CODEX_T3_MCP_TOOL_TIMEOUT_SEC = 65 * 60;
 
+const decodeCodexShellEnvironment = Schema.decodeUnknownOption(
+  Schema.Struct({
+    shell_environment_policy: Schema.Struct({ set: Schema.Record(Schema.String, Schema.String) }),
+  }),
+);
+
 function codexThreadRuntimeParams(input: {
   readonly mcpSession: McpProviderSession.McpProviderSessionConfig | undefined;
+  readonly environment: NodeJS.ProcessEnv;
   readonly modelSelection?: { readonly model: string };
   readonly runtimePolicy?: ProviderAdapter.ProviderAdapterV2RuntimePolicy;
 }): {
@@ -1341,11 +1348,20 @@ function codexThreadRuntimeParams(input: {
   readonly config: Readonly<Record<string, Schema.Json>>;
 } {
   const { mcpSession } = input;
+  const managedPath =
+    input.environment.T3_GH_SHIM_DIR === undefined
+      ? undefined
+      : input.environment[
+          Object.keys(input.environment).find((key) => key.toUpperCase() === "PATH") ?? "PATH"
+        ];
   return {
     ...(input.runtimePolicy?.cwd == null ? {} : { cwd: input.runtimePolicy.cwd }),
     ...(input.modelSelection === undefined ? {} : { model: input.modelSelection.model }),
     config: {
       ...CODEX_THREAD_CONFIG,
+      // Reapply the hydrated startup PATH after Codex's snapshot, retaining startup profile
+      // tools and our gh launcher. Login profiles stay enabled. Explicit user PATH config wins.
+      ...(managedPath === undefined ? {} : { "shell_environment_policy.set.PATH": managedPath }),
       ...(mcpSession === undefined
         ? {}
         : {
@@ -1668,13 +1684,14 @@ export const makeCodexAdapterV2 = Effect.fn("makeCodexAdapterV2")(function* (
                     }),
                 ),
               );
+        const environment = resolvedRuntime?.environment ?? adapterOptions.environment;
         const client = yield* clientFactory.open({
           instanceId: adapterOptions.instanceId,
           threadId: input.threadId,
           providerSessionId: input.providerSessionId,
           runtimePolicy: input.runtimePolicy,
           settings: resolvedRuntime?.config ?? adapterOptions.settings,
-          environment: resolvedRuntime?.environment ?? adapterOptions.environment,
+          environment,
         });
         const additionalContextByThread = yield* Ref.make(
           new Map<
@@ -1763,6 +1780,7 @@ export const makeCodexAdapterV2 = Effect.fn("makeCodexAdapterV2")(function* (
         // A failed open is discarded, so the next turn spawns the updated binary.
         if (adapterOptions.compatibility !== undefined) yield* ensureInitialized;
         const now = yield* DateTime.now;
+        const configuredShellPaths = yield* Ref.make(new Set<string>());
         const readModelProvider = (runtimePolicy = input.runtimePolicy) =>
           ensureInitialized.pipe(
             Effect.andThen(
@@ -1772,8 +1790,28 @@ export const makeCodexAdapterV2 = Effect.fn("makeCodexAdapterV2")(function* (
               }),
             ),
             Effect.flatMap(Schema.decodeUnknownEffect(CodexSchema.V2ConfigReadResponse)),
+            Effect.tap((response) =>
+              Ref.update(configuredShellPaths, (current) => {
+                const next = new Set(current);
+                const configured = decodeCodexShellEnvironment(response.config);
+                const hasPath =
+                  Option.isSome(configured) &&
+                  Object.keys(configured.value.shell_environment_policy.set).some(
+                    (key) => key.toUpperCase() === "PATH",
+                  );
+                if (hasPath) next.add(runtimePolicy.cwd ?? "");
+                else next.delete(runtimePolicy.cwd ?? "");
+                return next;
+              }),
+            ),
             Effect.map((response) => response.config.model_provider ?? "openai"),
           );
+        const threadEnvironment = (runtimePolicy = input.runtimePolicy) =>
+          Ref.get(configuredShellPaths).pipe(
+            Effect.map((configured) =>
+              configured.has(runtimePolicy.cwd ?? "") ? {} : environment,
+            ),
+          );
         const session = providerSession({
           providerSessionId: input.providerSessionId,
           providerInstanceId: adapterOptions.instanceId,
@@ -6968,15 +7006,25 @@ export const makeCodexAdapterV2 = Effect.fn("makeCodexAdapterV2")(function* (
           }),
           ensureThread: (threadInput) =>
             ensureInitialized.pipe(
+              Effect.andThen(
+                environment.T3_GH_SHIM_DIR === undefined
+                  ? Effect.void
+                  : readModelProvider(threadInput.runtimePolicy),
+              ),
               Effect.andThen(mcpSessions.read(threadInput.threadId)),
               Effect.flatMap((mcpSession) =>
-                client.request(
-                  "thread/start",
-                  codexThreadRuntimeParams({
-                    mcpSession,
-                    modelSelection: threadInput.modelSelection,
-                    runtimePolicy: threadInput.runtimePolicy,
-                  }),
+                threadEnvironment(threadInput.runtimePolicy).pipe(
+                  Effect.flatMap((environment) =>
+                    client.request(
+                      "thread/start",
+                      codexThreadRuntimeParams({
+                        environment,
+                        mcpSession,
+                        modelSelection: threadInput.modelSelection,
+                        runtimePolicy: threadInput.runtimePolicy,
+                      }),
+                    ),
+                  ),
                 ),
               ),
               Effect.map((response): OrchestrationV2ProviderThread =>
@@ -7006,6 +7054,7 @@ export const makeCodexAdapterV2 = Effect.fn("makeCodexAdapterV2")(function* (
                 modelProvider: yield* readModelProvider(threadInput.runtimePolicy),
                 excludeTurns: true,
                 ...codexThreadRuntimeParams({
+                  environment: yield* threadEnvironment(threadInput.runtimePolicy),
                   mcpSession: yield* readMcpSession(
                     threadInput.threadId ?? threadInput.providerThread.appThreadId,
                   ),
@@ -7794,6 +7843,7 @@ export const makeCodexAdapterV2 = Effect.fn("makeCodexAdapterV2")(function* (
                   modelProvider: yield* readModelProvider(),
                   excludeTurns: true,
                   ...codexThreadRuntimeParams({
+                    environment: yield* threadEnvironment(),
                     mcpSession: yield* readMcpSession(threadInput.providerThread.appThreadId),
                     modelSelection: input.modelSelection,
                     runtimePolicy: input.runtimePolicy,
@@ -7847,6 +7897,7 @@ export const makeCodexAdapterV2 = Effect.fn("makeCodexAdapterV2")(function* (
                       ? {}
                       : { lastTurnId: boundary.lastTurnId }),
                     ...codexThreadRuntimeParams({
+                      environment: yield* threadEnvironment(threadInput.runtimePolicy),
                       mcpSession: yield* mcpSessions.read(threadInput.targetThreadId),
                       ...(threadInput.modelSelection === undefined
                         ? {}
diff --git a/apps/server/src/orchestration-v2/FoundationPersistence.test.ts b/apps/server/src/orchestration-v2/FoundationPersistence.test.ts
index 7b9c7c3b528b8..45d4b9d998634 100644
--- a/apps/server/src/orchestration-v2/FoundationPersistence.test.ts
+++ b/apps/server/src/orchestration-v2/FoundationPersistence.test.ts
@@ -2688,6 +2688,7 @@ it.layer(layerTest)("orchestration V2 foundation persistence", (it) => {
         );
         const layerWorker = EffectWorker.layerWithOptions({
           workerId: "hung-delegated-stop-worker",
+          maxAttempts: 1,
         }).pipe(
           Layer.provide(
             Layer.merge(Layer.succeed(EffectOutbox.EffectOutboxV2, outbox), layerExecutor),
@@ -2707,15 +2708,8 @@ it.layer(layerTest)("orchestration V2 foundation persistence", (it) => {
           ]);
           yield* outbox.notifyAvailable();
 
-          const turn = yield* Deferred.await(turnStarted).pipe(
-            Effect.timeoutOption("1 hour"),
-            Effect.forkChild,
-          );
-          yield* TestClock.adjust("1 hour");
-          assert.isTrue(
-            Option.isSome(yield* Fiber.join(turn)),
-            "provider-turn.start never ran behind the hung delegated-tasks.stop",
-          );
+          yield* TestClock.adjust("30 seconds");
+          yield* Deferred.await(turnStarted);
           const stop = yield* outbox.get(stopEffectId);
           assert.isTrue(Option.isSome(stop));
           if (Option.isSome(stop)) {
diff --git a/apps/server/src/orchestration-v2/RunFinalizationService.test.ts b/apps/server/src/orchestration-v2/RunFinalizationService.test.ts
index 38b6732149289..455e340aa528b 100644
--- a/apps/server/src/orchestration-v2/RunFinalizationService.test.ts
+++ b/apps/server/src/orchestration-v2/RunFinalizationService.test.ts
@@ -17,6 +17,7 @@ import * as Effect from "effect/Effect";
 import * as Fiber from "effect/Fiber";
 import * as Layer from "effect/Layer";
 import * as Stream from "effect/Stream";
+import * as TestClock from "effect/testing/TestClock";
 
 import * as CodeIntelligence from "../project/knowledge/CodeIntelligence.ts";
 import * as PullRequestService from "../pullRequest/PullRequestService.ts";
@@ -29,6 +30,47 @@ import * as ProjectionStore from "./ProjectionStore.ts";
 import * as ProjectStore from "./ProjectStore.ts";
 import * as RunFinalization from "./RunFinalizationService.ts";
 
+it.effect("coalesces completed turns without starving later project refreshes", () => {
+  const projectA = ProjectId.make("project-turn-refresh-a");
+  const projectB = ProjectId.make("project-turn-refresh-b");
+  const refreshed: ProjectId[] = [];
+  const layer = RunFinalization.layerObserver.pipe(
+    Layer.provide(
+      Layer.mergeAll(
+        Layer.mock(WorkspaceEntries.WorkspaceEntries)({}),
+        Layer.mock(CodeIntelligence.CodeIntelligence)({}),
+        Layer.mock(VcsStatusBroadcaster.VcsStatusBroadcaster)({}),
+        Layer.mock(ProjectionStore.ProjectionStoreV2)({}),
+        Layer.mock(PullRequestService.PullRequestService)({
+          refreshAfterTurns: (projectIds) =>
+            Effect.sync(() => {
+              refreshed.push(...projectIds);
+            }),
+        }),
+      ),
+    ),
+  );
+  return Effect.gen(function* () {
+    const observer = yield* RunFinalization.RunFinalizationObserver;
+    yield* Effect.forEach(Array.from({ length: 20 }), () => observer.refreshAfterTurn(projectA));
+    assert.deepEqual(refreshed, []);
+    yield* TestClock.adjust("9 seconds");
+    yield* observer.refreshAfterTurn(projectA);
+    yield* observer.refreshAfterTurn(projectB);
+    yield* TestClock.adjust("1 second");
+    assert.deepEqual(refreshed, [projectA, projectB]);
+
+    // Continuous activity starts a new fixed window instead of postponing the last refresh.
+    yield* observer.refreshAfterTurn(projectA);
+    yield* TestClock.adjust("9 seconds");
+    yield* observer.refreshAfterTurn(projectA);
+    yield* TestClock.adjust("1 second");
+    assert.deepEqual(refreshed, [projectA, projectB, projectA]);
+    yield* TestClock.adjust("1 minute");
+    assert.deepEqual(refreshed, [projectA, projectB, projectA]);
+  }).pipe(Effect.provide(layer));
+});
+
 it.effect("completes finalization when the post-checkpoint workspace refresh fails", () => {
   const threadId = ThreadId.make("thread_refresh_failure");
   const runId = RunId.make("run_refresh_failure");
diff --git a/apps/server/src/orchestration-v2/RunFinalizationService.ts b/apps/server/src/orchestration-v2/RunFinalizationService.ts
index 5951580a36e77..6c8fa30f260a3 100644
--- a/apps/server/src/orchestration-v2/RunFinalizationService.ts
+++ b/apps/server/src/orchestration-v2/RunFinalizationService.ts
@@ -2,6 +2,7 @@ import { CheckpointScopeId, ProjectId, RunId, ThreadId } from "@t3tools/contract
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
+import * as Queue from "effect/Queue";
 import * as Schema from "effect/Schema";
 
 import * as CodeIntelligence from "../project/knowledge/CodeIntelligence.ts";
@@ -98,8 +99,36 @@ export const layerObserver = Layer.effect(
     const projections = yield* ProjectionStore.ProjectionStoreV2;
     const pullRequests = yield* PullRequestService.PullRequestService;
     const codeIntelligence = yield* CodeIntelligence.CodeIntelligence;
+
+    // Many agents can finish in the same project at once. Invalidate once per project in a
+    // fixed window, with a trailing refresh even under continuous activity. Pushes and explicit
+    // PR mutations still call PullRequestService directly and refresh immediately.
+    const pendingProjects = new Set<ProjectId>();
+    const refreshes = yield* Queue.dropping<void>(1);
+    const refreshAfterTurn = Effect.fn("RunFinalizationService.refreshAfterTurn")(
+      (projectId: ProjectId) =>
+        Effect.sync(() => {
+          const first = pendingProjects.size === 0;
+          pendingProjects.add(projectId);
+          if (first) Queue.offerUnsafe(refreshes, undefined);
+        }),
+    );
+    yield* Effect.gen(function* () {
+      yield* Queue.take(refreshes);
+      yield* Effect.sleep("10 seconds");
+      const projects = Array.from(pendingProjects);
+      pendingProjects.clear();
+      yield* pullRequests.refreshAfterTurns(projects).pipe(
+        Effect.catchCause((cause) =>
+          Effect.logWarning("failed to refresh pull requests after completed turns", {
+            projectIds: projects,
+            cause,
+          }),
+        ),
+      );
+    }).pipe(Effect.forever, Effect.forkScoped);
     return {
-      refreshAfterTurn: pullRequests.refreshAfterTurn,
+      refreshAfterTurn,
       refresh: Effect.fn("RunFinalizationService.refresh")(
         function* ({ cwd, threadId, runId }) {
           // The index builds in the code intelligence service, off this turn's lane.
diff --git a/apps/server/src/orchestration-v2/testkit/ReplayRuntimeInstructions.ts b/apps/server/src/orchestration-v2/testkit/ReplayRuntimeInstructions.ts
index 83d5c4c930f36..a252866428bf0 100644
--- a/apps/server/src/orchestration-v2/testkit/ReplayRuntimeInstructions.ts
+++ b/apps/server/src/orchestration-v2/testkit/ReplayRuntimeInstructions.ts
@@ -23,6 +23,10 @@ export function materializeReplayTranscriptRuntimeInstructions(
   const pullRequestInstructions = instructions.match(
     /<pull_request_linking>[\s\S]*?<\/pull_request_linking>/u,
   )?.[0];
+  const githubReadInstructions = instructions.match(/<github_reads>[\s\S]*?<\/github_reads>/u)?.[0];
+  const managedInstructions = [pullRequestInstructions, githubReadInstructions]
+    .filter((block): block is string => block !== undefined)
+    .join("\n\n");
 
   return {
     ...transcript,
@@ -55,8 +59,8 @@ export function materializeReplayTranscriptRuntimeInstructions(
         }
         // Keep each turn's recorded model, effort, and user input as protocol assertions.
         const text = firstPart.text.replace(
-          /^(<runtime_info>[\s\S]*?<\/runtime_info>\n\n)<pull_request_linking>[\s\S]*?<\/pull_request_linking>/u,
-          (_match, header: string) => `${header}${pullRequestInstructions}`,
+          /^(<runtime_info>[\s\S]*?<\/runtime_info>\n\n)<pull_request_linking>[\s\S]*?<\/pull_request_linking>(?:\n\n<github_reads>[\s\S]*?<\/github_reads>)?/u,
+          (_match, header: string) => `${header}${managedInstructions}`,
         );
         return text === firstPart.text
           ? entry
diff --git a/apps/server/src/provider/Drivers/AntigravityDriver.test.ts b/apps/server/src/provider/Drivers/AntigravityDriver.test.ts
index 74f4daa1323af..84faf0352b140 100644
--- a/apps/server/src/provider/Drivers/AntigravityDriver.test.ts
+++ b/apps/server/src/provider/Drivers/AntigravityDriver.test.ts
@@ -289,10 +289,14 @@ it.layer(layerTest)("AntigravityDriver", (it) => {
         h.controls.selected = h.second;
         yield* h.refresh();
 
-        expect(h.acquisitions).toEqual([
-          { binaryPath: "", path: h.instancePath },
-          { binaryPath: "", path: h.instancePath },
-        ]);
+        expect(h.acquisitions).toHaveLength(2);
+        expect(h.acquisitions.map(({ binaryPath }) => binaryPath)).toEqual(["", ""]);
+        expect(h.acquisitions[0]?.path).toBe(h.acquisitions[1]?.path);
+        const acquiredPath = h.acquisitions[0]?.path;
+        // The managed gh launcher may prefix PATH, but must preserve the provider's PATH.
+        expect(
+          acquiredPath === h.instancePath || acquiredPath?.endsWith(`:${h.instancePath}`),
+        ).toBe(true);
         const nativeLaunches = h.launches.filter((launch) => launch.harnessPath !== undefined);
         expect(nativeLaunches.map((launch) => launch.command)).toEqual([
           h.first.executablePath,
diff --git a/apps/server/src/provider/ProviderHostLive.ts b/apps/server/src/provider/ProviderHostLive.ts
index 8d73d697705fc..fa10b871d8473 100644
--- a/apps/server/src/provider/ProviderHostLive.ts
+++ b/apps/server/src/provider/ProviderHostLive.ts
@@ -1,15 +1,19 @@
 import * as ProviderHost from "@t3tools/provider-core/server/ProviderHost";
 import { ProviderCredentialError } from "@t3tools/provider-core/server/errors";
+import * as HostProcess from "@t3tools/shared/HostProcess";
+import { resolveSelfInvocation } from "@t3tools/shared/nodeRuntime";
 import * as Crypto from "effect/Crypto";
 import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
+import * as Path from "effect/Path";
 
 import { resolveAttachmentPath } from "../attachmentStore.ts";
 import * as ServerSecretStore from "../auth/ServerSecretStore.ts";
 import * as BackgroundPolicy from "../background/BackgroundPolicy.ts";
 import * as ServerConfig from "../config.ts";
 import * as ServerSettings from "../serverSettings.ts";
+import { prepareAgentGitHubEnvironment } from "../sourceControl/agentGitHubEnvironment.ts";
 import * as DocumentText from "./DocumentText.ts";
 import * as ProviderCredentialStore from "./ProviderCredentialStore.ts";
 
@@ -22,6 +26,9 @@ export const layer = Layer.effect(
     const secrets = yield* ServerSecretStore.ServerSecretStore;
     const crypto = yield* Crypto.Crypto;
     const fileSystem = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const platform = yield* HostProcess.Platform;
+    const invocation = yield* resolveSelfInvocation();
     return ProviderHost.ProviderHost.of({
       paths: {
         cwd: config.cwd,
@@ -37,6 +44,28 @@ export const layer = Layer.effect(
         subscribe: serverSettings.subscribeChanges,
       },
       shouldRunBackgroundWork: backgroundPolicy.shouldRunScopeWork,
+      prepareAgentEnvironment: Effect.fn("ProviderHost.prepareAgentEnvironment")((environment) =>
+        serverSettings.getSettings.pipe(
+          Effect.flatMap((settings) =>
+            prepareAgentGitHubEnvironment({
+              environment,
+              enabled: settings.enableAgentGitHubReadGate,
+              stateDir: config.stateDir,
+              invocation,
+              platform,
+            }),
+          ),
+          Effect.provideService(FileSystem.FileSystem, fileSystem),
+          Effect.provideService(Path.Path, path),
+          Effect.provideService(Crypto.Crypto, crypto),
+          Effect.provideService(HostProcess.Platform, platform),
+          Effect.catch(() =>
+            Effect.logWarning("Could not prepare the managed GitHub CLI launcher.").pipe(
+              Effect.as(environment),
+            ),
+          ),
+        ),
+      ),
       resolveAttachmentPath: (attachment) =>
         resolveAttachmentPath({ attachmentsDir: config.attachmentsDir, attachment }),
       // DocumentText owns the path-resolution span.
diff --git a/apps/server/src/provider/agentContextBudget.json b/apps/server/src/provider/agentContextBudget.json
index 1251013e705cc..6224211bbfeb7 100644
--- a/apps/server/src/provider/agentContextBudget.json
+++ b/apps/server/src/provider/agentContextBudget.json
@@ -1,5 +1,5 @@
 {
   "claudeSystemAppendBytes": 8528,
   "codexAdditionalContextBytes": 10254,
-  "mcpToolListJsonBytes": 63134
+  "mcpToolListJsonBytes": 63454
 }
diff --git a/apps/server/src/pullRequest/PullRequestService.test.ts b/apps/server/src/pullRequest/PullRequestService.test.ts
index 6e4c69d2c2f01..8f57de29f79bd 100644
--- a/apps/server/src/pullRequest/PullRequestService.test.ts
+++ b/apps/server/src/pullRequest/PullRequestService.test.ts
@@ -1496,53 +1496,61 @@ it.effect("keeps two hosts of one provider kind as two accounts", () =>
   }),
 );
 
-it.effect("stops new reads after a rate limit while leaving manual actions available", () =>
-  Effect.gen(function* () {
-    let listCalls = 0;
-    let actionCalls = 0;
-    const service = yield* makeService({
-      projects: [
-        project({ id: "p1", title: "cloud", workspaceRoot: "/cloud", repository: "acme/web" }),
-      ],
-      providers: [
-        fakePullRequestProvider(SourceControlProviderKind.make("github"), {
-          listChangeRequests: () =>
-            Effect.sync(() => {
-              listCalls += 1;
-            }).pipe(
-              Effect.andThen(
-                Effect.fail(
-                  new PullRequestProviderError({
-                    provider: SourceControlProviderKind.make("github"),
-                    operation: "listChangeRequests",
-                    reason: "rate-limited",
-                    detail: "GitHub API rate limit exceeded.",
-                  }),
+it.effect.each(["github", "gitlab"])(
+  "leaves GitHub backoff to its transport and protects other providers (%s)",
+  (kind) =>
+    Effect.gen(function* () {
+      let listCalls = 0;
+      let actionCalls = 0;
+      const service = yield* makeService({
+        projects: [
+          project({
+            id: "p1",
+            title: "cloud",
+            workspaceRoot: "/cloud",
+            repository: "acme/web",
+            provider: kind,
+          }),
+        ],
+        providers: [
+          fakePullRequestProvider(SourceControlProviderKind.make(kind), {
+            listChangeRequests: () =>
+              Effect.sync(() => {
+                listCalls += 1;
+              }).pipe(
+                Effect.andThen(
+                  Effect.fail(
+                    new PullRequestProviderError({
+                      provider: SourceControlProviderKind.make(kind),
+                      operation: "listChangeRequests",
+                      reason: "rate-limited",
+                      detail: "GitHub API rate limit exceeded.",
+                    }),
+                  ),
                 ),
               ),
-            ),
-          runAction: () =>
-            Effect.sync(() => {
-              actionCalls += 1;
-            }),
-        }),
-      ],
-    });
+            runAction: () =>
+              Effect.sync(() => {
+                actionCalls += 1;
+              }),
+          }),
+        ],
+      });
 
-    const first = yield* service.list({ state: "open", involvement: "all" });
-    const paused = yield* service.list({ state: "open", involvement: "authored" });
-    yield* service.runAction({
-      projectId: "p1" as ProjectId,
-      repository: "acme/web",
-      number: 1,
-      action: "close",
-    });
+      const first = yield* service.list({ state: "open", involvement: "all" });
+      const paused = yield* service.list({ state: "open", involvement: "authored" });
+      yield* service.runAction({
+        projectId: "p1" as ProjectId,
+        repository: "acme/web",
+        number: 1,
+        action: "close",
+      });
 
-    assert.strictEqual(listCalls, 1);
-    assert.strictEqual(actionCalls, 1);
-    assert.lengthOf(first.errors, 1);
-    assert.lengthOf(paused.errors, 1);
-  }),
+      assert.strictEqual(listCalls, kind === "github" ? 2 : 1);
+      assert.strictEqual(actionCalls, 1);
+      assert.lengthOf(first.errors, 1);
+      assert.lengthOf(paused.errors, 1);
+    }),
 );
 
 it.effect("refuses a repository that does not belong to the requested project", () =>
@@ -2291,6 +2299,12 @@ it.effect("a refresh or a finished turn drops the provider's own change request
       undefined,
       undefined,
     ]);
+
+    forgotten.length = 0;
+    yield* service.refreshAfterTurns([reference.projectId, "p2" as ProjectId, reference.projectId]);
+    assert.deepStrictEqual(forgotten, [undefined]);
+    yield* service.refreshAfterTurns([]);
+    assert.deepStrictEqual(forgotten, [undefined]);
   }),
 );
 
@@ -2310,6 +2324,13 @@ it.effect("a read during a refresh cannot keep the provider's old change request
           repository: "acme/web",
           provider: "gitlab",
         }),
+        project({
+          id: "p2",
+          title: "api",
+          workspaceRoot: "/b",
+          repository: "acme/api",
+          provider: "gitlab",
+        }),
       ],
       providers: [
         fakePullRequestProvider(SourceControlProviderKind.make("gitlab"), {
@@ -2349,6 +2370,15 @@ it.effect("a read during a refresh cannot keep the provider's old change request
     hostTitle = "after refresh";
     yield* refreshWithReadInBetween(service.invalidate({ reference }));
     assert.strictEqual((yield* service.detail(reference)).title, "after refresh");
+
+    const second = { projectId: "p2" as ProjectId, repository: "acme/api", number: 2 };
+    assert.strictEqual((yield* service.detail(second)).title, "after refresh");
+    hostTitle = "after batch";
+    yield* refreshWithReadInBetween(
+      service.refreshAfterTurns([reference.projectId, second.projectId]),
+    );
+    assert.strictEqual((yield* service.detail(reference)).title, "after batch");
+    assert.strictEqual((yield* service.detail(second)).title, "after batch");
   }),
 );
 
@@ -3090,9 +3120,15 @@ it.effect(
       expect(reads).toBe(0);
       yield* TestClock.adjust("16 seconds");
       yield* service.detail(reference);
+      expect(yield* service.checks(reference)).toMatchObject({
+        state: detail.state,
+        observedAt: 1_000,
+      });
+      expect(reads).toBe(0);
+      yield* TestClock.adjust("30 seconds");
       expect(yield* service.checks(reference)).toMatchObject({
         state: "closed",
-        observedAt: 17_000,
+        observedAt: 47_000,
       });
       expect(reads).toBe(1);
       yield* service.detail(reference);
@@ -3101,6 +3137,56 @@ it.effect(
     }),
 );
 
+it.effect("shares an in-flight GitHub detail with concurrent checks readers", () =>
+  Effect.gen(function* () {
+    const started = yield* Deferred.make<void>();
+    const release = yield* Deferred.make<void>();
+    let detailReads = 0;
+    let checkReads = 0;
+    const reference = { projectId: "p1" as ProjectId, repository: "acme/web", number: 1 };
+    const service = yield* makeService({
+      projects: [project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" })],
+      providers: [
+        fakePullRequestProvider(SourceControlProviderKind.make("github"), {
+          getChangeRequest: () =>
+            Effect.gen(function* () {
+              detailReads += 1;
+              yield* Deferred.succeed(started, undefined);
+              yield* Deferred.await(release);
+              return { ...hostedChangeRequest("Description"), headSha: "abc123" };
+            }),
+          getChangeRequestChecks: () =>
+            Effect.sync(() => {
+              checkReads += 1;
+              return { state: "open" as const, checks: [] };
+            }),
+        }),
+      ],
+    });
+    const detailFiber = yield* service
+      .detail(reference)
+      .pipe(Effect.forkChild({ startImmediately: true }));
+    yield* Deferred.await(started);
+    const readers = yield* Effect.all(
+      Array.from({ length: 8 }, () => service.checks(reference)),
+      { concurrency: "unbounded" },
+    ).pipe(Effect.forkChild({ startImmediately: true }));
+    yield* Deferred.succeed(release, undefined);
+    const detail = yield* Fiber.join(detailFiber);
+    const checks = yield* Fiber.join(readers);
+    expect(checks).toEqual(
+      Array.from({ length: 8 }, () => ({
+        state: detail.state,
+        headSha: detail.headSha,
+        checks: detail.checks,
+        observedAt: detail.observedAt,
+      })),
+    );
+    expect(detailReads).toBe(1);
+    expect(checkReads).toBe(0);
+  }),
+);
+
 it.effect("preserves check observation time on cache hits and advances it on refresh", () =>
   Effect.gen(function* () {
     let reads = 0;
@@ -3123,8 +3209,8 @@ it.effect("preserves check observation time on cache hits and advances it on ref
     yield* TestClock.adjust("1 second");
     expect(yield* service.checks(reference)).toEqual(first);
     expect(reads).toBe(1);
-    yield* TestClock.adjust("15 seconds");
-    expect(yield* service.checks(reference)).toMatchObject({ observedAt: 17_000 });
+    yield* TestClock.adjust("45 seconds");
+    expect(yield* service.checks(reference)).toMatchObject({ observedAt: 47_000 });
     expect(reads).toBe(2);
   }),
 );
@@ -4689,7 +4775,7 @@ it.effect("coalesces completed check failures and separates credentials and atte
     expect((yield* service.checkFailures(input)).log).toMatchObject({ text: "second" });
     expect(calls).toBe(2);
     attempt = 2;
-    yield* TestClock.adjust("16 seconds");
+    yield* TestClock.adjust("46 seconds");
     yield* service.checkFailures({ ...ref, handle: "job:123:2" });
     expect(calls).toBe(3);
     const readsForTwoCalls = Effect.fn(function* (handle: string) {
@@ -4700,7 +4786,7 @@ it.effect("coalesces completed check failures and separates credentials and atte
     });
     attempt = 3;
     log = { _tag: "unavailable", reason: "still-running" };
-    yield* TestClock.adjust("16 seconds");
+    yield* TestClock.adjust("46 seconds");
     expect(yield* readsForTwoCalls("job:123:3")).toBe(2);
     log = { _tag: "unavailable", reason: "no-access" };
     expect(yield* readsForTwoCalls("job:123:3")).toBe(2);
@@ -4708,11 +4794,11 @@ it.effect("coalesces completed check failures and separates credentials and atte
     expect(yield* readsForTwoCalls("job:123:3")).toBe(1);
     attempt = 4;
     log = { _tag: "unavailable", reason: "expired" };
-    yield* TestClock.adjust("16 seconds");
+    yield* TestClock.adjust("46 seconds");
     expect(yield* readsForTwoCalls("job:123:4")).toBe(1);
     attempt = 5;
     log = { _tag: "unavailable", reason: "not-actions" };
-    yield* TestClock.adjust("16 seconds");
+    yield* TestClock.adjust("46 seconds");
     expect(yield* readsForTwoCalls("job:123:5")).toBe(1);
     expect(
       (yield* Effect.flip(service.checkFailures({ ...input, expectedAccountId: "other" })))._tag,
@@ -4720,9 +4806,12 @@ it.effect("coalesces completed check failures and separates credentials and atte
     const settled = calls;
     refuse = true;
     attempt = 6;
-    yield* TestClock.adjust("16 seconds");
+    yield* TestClock.adjust("46 seconds");
     yield* Effect.flip(service.checkFailures({ ...ref, handle: "job:123:6" }));
-    yield* Effect.flip(service.checkFailures(input));
+    expect(yield* service.checkFailures(input)).toMatchObject({
+      attempt: 1,
+      log: { _tag: "excerpt", text: "second" },
+    });
     expect(calls).toBe(settled + 1);
   }),
 );
diff --git a/apps/server/src/pullRequest/PullRequestService.ts b/apps/server/src/pullRequest/PullRequestService.ts
index 13298490cf709..a268f40a92113 100644
--- a/apps/server/src/pullRequest/PullRequestService.ts
+++ b/apps/server/src/pullRequest/PullRequestService.ts
@@ -127,7 +127,7 @@ const DETAIL_CACHE_TTL = Duration.seconds(60);
 const MERGED_DETAIL_CACHE_TTL = Duration.minutes(10);
 const detailTimeToLive = (state: PullRequestState | undefined) =>
   state === "merged" ? MERGED_DETAIL_CACHE_TTL : DETAIL_CACHE_TTL;
-const CHECKS_CACHE_TTL = Duration.seconds(15);
+const CHECKS_CACHE_TTL = Duration.seconds(45);
 const REPORTED_STATE_DEDUPE_MS = 5 * 60 * 1_000;
 const DIFF_CACHE_TTL = Duration.seconds(60);
 const COMMIT_DIFF_CACHE_TTL = Duration.minutes(10);
@@ -227,6 +227,7 @@ export class PullRequestService extends Context.Service<
     ) => Effect.Effect<void, PullRequestError>;
     readonly subscribeRefreshes: Stream.Stream<number>;
     readonly refreshAfterTurn: (projectId: ProjectId) => Effect.Effect<void>;
+    readonly refreshAfterTurns: (projectIds: ReadonlyArray<ProjectId>) => Effect.Effect<void>;
     /** Project and remote lookups inside `effect` read once per filter, e.g. across one sync sweep. */
     readonly withSharedProjectReads: <A, E, R>(
       effect: Effect.Effect<A, E, R>,
@@ -479,34 +480,37 @@ function withRateLimitBackoff(
     effect: Effect.Effect<A, PullRequestProviderError>,
     allowPaused: boolean,
   ) =>
-    limits.check(key, allowPaused ? { allowPaused: true } : undefined).pipe(
-      Effect.mapError(
-        (error) =>
-          new PullRequestProviderError({
-            provider: api.kind,
-            operation,
-            reason: "rate-limited",
-            detail: error.detail,
-            retryAt: error.retryAt,
-            cause: error,
-          }),
-      ),
-      Effect.flatMap((lease) =>
-        effect.pipe(
-          Effect.provideService(SourceControlRateLimit.Interactive, allowPaused),
-          Effect.tap(() => limits.recordSuccess({ ...key, lease })),
-          Effect.tapError((error) =>
-            error.reason === "rate-limited"
-              ? limits.recordRateLimit({
-                  ...key,
-                  lease,
-                  ...(error.retryAt === undefined ? {} : { retryAt: error.retryAt }),
-                })
-              : Effect.void,
+    // GitHub owns credential/resource cooldowns in its shared REST/GraphQL transport.
+    api.kind === "github"
+      ? effect.pipe(Effect.provideService(SourceControlRateLimit.Interactive, allowPaused))
+      : limits.check(key, allowPaused ? { allowPaused: true } : undefined).pipe(
+          Effect.mapError(
+            (error) =>
+              new PullRequestProviderError({
+                provider: api.kind,
+                operation,
+                reason: "rate-limited",
+                detail: error.detail,
+                retryAt: error.retryAt,
+                cause: error,
+              }),
           ),
-        ),
-      ),
-    );
+          Effect.flatMap((lease) =>
+            effect.pipe(
+              Effect.provideService(SourceControlRateLimit.Interactive, allowPaused),
+              Effect.tap(() => limits.recordSuccess({ ...key, lease })),
+              Effect.tapError((error) =>
+                error.reason === "rate-limited"
+                  ? limits.recordRateLimit({
+                      ...key,
+                      lease,
+                      ...(error.retryAt === undefined ? {} : { retryAt: error.retryAt }),
+                    })
+                  : Effect.void,
+              ),
+            ),
+          ),
+        );
   const wrap =
     <Args extends ReadonlyArray<unknown>, A>(
       operation: string,
@@ -1806,7 +1810,7 @@ export const make = Effect.gen(function* () {
             baseBranch: changeRequest.baseBranch,
             createdAt: changeRequest.createdAt,
             updatedAt: changeRequest.updatedAt,
-            observedAt,
+            observedAt: changeRequest.observedAt ?? observedAt,
             mergedAt: changeRequest.mergedAt,
             closedAt: changeRequest.closedAt,
             reviewers: changeRequest.reviewers,
@@ -3086,7 +3090,10 @@ export const make = Effect.gen(function* () {
                 .pipe(
                   Effect.mapError(toPullRequestError("checks")),
                   observeRead,
-                  Effect.map(({ value, observedAt }) => ({ ...value, observedAt })),
+                  Effect.map(({ value, observedAt }) => ({
+                    ...value,
+                    observedAt: value.observedAt ?? observedAt,
+                  })),
                 ),
         ),
       );
@@ -3110,10 +3117,6 @@ export const make = Effect.gen(function* () {
     },
   );
 
-  const checks: PullRequestService["Service"]["checks"] = credentialCached((input) =>
-    Cache.get(checksCache, refCacheKey(input)),
-  );
-
   const checkFailureCache = yield* Cache.makeWith(
     Effect.fn("PullRequestService.readCheckFailure")(function* (key: string) {
       const [refKey, , handle] = decodeCheckFailureKey(key);
@@ -3279,9 +3282,31 @@ export const make = Effect.gen(function* () {
     {
       capacity: DETAIL_CACHE_CAPACITY,
       timeToLive: (exit) =>
-        Exit.isSuccess(exit) ? detailTimeToLive(exit.value.state) : Duration.zero,
+        Exit.isSuccess(exit)
+          ? Duration.millis(
+              Math.max(
+                0,
+                (exit.value.observedAt ?? clock.currentTimeMillisUnsafe()) +
+                  Duration.toMillis(detailTimeToLive(exit.value.state)) -
+                  clock.currentTimeMillisUnsafe(),
+              ),
+            )
+          : Duration.zero,
     },
   );
+  const checks: PullRequestService["Service"]["checks"] = credentialCached(
+    Effect.fn("PullRequestService.checks")(function* (input) {
+      const key = refCacheKey(input);
+      const cached = yield* Cache.getOption(checksCache, key);
+      if (Option.isSome(cached)) return cached.value;
+      // A detail read already in flight seeds its checks before completing.
+      yield* Cache.getOption(detailCache, key).pipe(
+        Effect.orElseSucceed(() => Option.none<PullRequestDetail>()),
+      );
+      return yield* Cache.get(checksCache, key);
+    }),
+  );
+
   const summaryFromDetail = (
     detail: PullRequestDetail,
     previous: PullRequestSummary | undefined,
@@ -3662,28 +3687,37 @@ export const make = Effect.gen(function* () {
     }
   });
 
-  const refreshAfterTurn: PullRequestService["Service"]["refreshAfterTurn"] = Effect.fn(
-    "PullRequestService.refreshAfterTurn",
-  )(function* (projectId) {
+  const refreshAfterTurns: PullRequestService["Service"]["refreshAfterTurns"] = Effect.fn(
+    "PullRequestService.refreshAfterTurns",
+  )(function* (projectIds) {
+    const projects = new Set(projectIds);
+    if (projects.size === 0) return;
     // Everything the provider holds, not just the project's repository: a turn can touch a
     // change request reached through another repository, and no epoch may move until those
     // reads are gone, or a reader in between keeps the old one under the new epoch.
     yield* forgetProviderReads();
     listingsEpoch = ++epochCounter;
-    projectEpochs.delete(projectId);
-    if (projectEpochs.size >= REF_EPOCH_CAPACITY) {
-      const oldest = projectEpochs.keys().next().value;
-      if (oldest !== undefined) {
-        projectEpochFloor = projectEpochs.get(oldest)!;
-        projectEpochs.delete(oldest);
+    for (const projectId of projects) {
+      projectEpochs.delete(projectId);
+      if (projectEpochs.size >= REF_EPOCH_CAPACITY) {
+        const oldest = projectEpochs.keys().next().value;
+        if (oldest !== undefined) {
+          projectEpochFloor = projectEpochs.get(oldest)!;
+          projectEpochs.delete(oldest);
+        }
       }
+      projectEpochs.set(projectId, listingsEpoch);
     }
-    projectEpochs.set(projectId, listingsEpoch);
-    const epoch = listingsEpoch;
-    yield* readCache.invalidate(`project:${projectId}`);
-    yield* SubscriptionRef.set(pullRequestRefreshes, epoch);
+    yield* Effect.forEach(projects, (projectId) => readCache.invalidate(`project:${projectId}`), {
+      discard: true,
+    });
+    yield* SubscriptionRef.set(pullRequestRefreshes, ++epochCounter);
   });
 
+  const refreshAfterTurn: PullRequestService["Service"]["refreshAfterTurn"] = Effect.fn(
+    "PullRequestService.refreshAfterTurn",
+  )((projectId) => refreshAfterTurns([projectId]));
+
   const invalidatedByMutation =
     <I extends PullRequestRef>(
       method: (input: I) => Effect.Effect<void, PullRequestError>,
@@ -3860,6 +3894,7 @@ export const make = Effect.gen(function* () {
       Stream.filter((revision) => revision > 0),
     ),
     refreshAfterTurn,
+    refreshAfterTurns,
     detail: credentialCached(detail),
     checks,
     checkFailures,
diff --git a/apps/server/src/pullRequest/pullRequestReports.test.ts b/apps/server/src/pullRequest/pullRequestReports.test.ts
index 1a0e2cfc304aa..a5b2907da3ad9 100644
--- a/apps/server/src/pullRequest/pullRequestReports.test.ts
+++ b/apps/server/src/pullRequest/pullRequestReports.test.ts
@@ -429,7 +429,7 @@ describe("feedbackOf", () => {
 });
 
 describe("rateLimitedOf", () => {
-  const paused = (retryAt?: number) =>
+  const paused = (retryAt?: number, quota: Partial<PullRequestProviderError> = {}) =>
     new PullRequestOperationError({
       operation: "summary",
       detail: "paused",
@@ -439,15 +439,34 @@ describe("rateLimitedOf", () => {
         reason: "rate-limited",
         detail: "paused",
         ...(retryAt === undefined ? {} : { retryAt }),
+        ...quota,
       }),
     });
 
-  it("names the time and tells the agent its CLI shares the limit", () => {
-    assert.deepEqual(rateLimitedOf(paused(Date.UTC(2026, 9, 30, 20, 5)), GITHUB, 0), {
-      _tag: "RateLimited",
-      until: "2026-10-30T20:05:00.000Z",
+  it.each([
+    {
+      name: "a host throttle with no quota metadata",
+      quota: {},
       message:
         "GitHub is rate limited for this account until 20:05 UTC. Your gh shares that limit; stop GitHub reads until then.",
+    },
+    {
+      name: "a protected REST reserve",
+      quota: { pauseReason: "reserve-protected", resource: "core", remaining: 282, limit: 5000 },
+      message:
+        "T3 is protecting this account's GitHub REST reserve until 20:05 UTC (282 of 5000 remaining). Background refreshes are paused; use T3's cached reads or watch instead of polling with gh.",
+    },
+    {
+      name: "an exhausted GraphQL quota",
+      quota: { pauseReason: "quota-exhausted", resource: "graphql", remaining: 0, limit: 5000 },
+      message:
+        "This account's GitHub GraphQL quota is exhausted until 20:05 UTC. Your gh shares that quota; pause new GraphQL requests until then. T3 can still serve cached data.",
+    },
+  ] as const)("reports $name accurately", ({ quota, message }) => {
+    assert.deepEqual(rateLimitedOf(paused(Date.UTC(2026, 9, 30, 20, 5), quota), GITHUB, 0), {
+      _tag: "RateLimited",
+      until: "2026-10-30T20:05:00.000Z",
+      message,
     });
   });
 
diff --git a/apps/server/src/pullRequest/pullRequestReports.ts b/apps/server/src/pullRequest/pullRequestReports.ts
index a63c0d2cebf18..d854377bda59d 100644
--- a/apps/server/src/pullRequest/pullRequestReports.ts
+++ b/apps/server/src/pullRequest/pullRequestReports.ts
@@ -281,6 +281,32 @@ export function rateLimitedOf(
   if (cause === null) return null;
   const until = isoOf(cause.retryAt ?? now + RATE_LIMIT_FALLBACK_MS);
   const time = `${until.slice(11, 16)} UTC`;
+  const resource =
+    cause.resource === "core"
+      ? "REST"
+      : cause.resource === "graphql"
+        ? "GraphQL"
+        : cause.resource === "search"
+          ? "search"
+          : "API";
+  if (cause.pauseReason === "reserve-protected") {
+    const remaining =
+      cause.remaining !== undefined && cause.limit !== undefined
+        ? ` (${cause.remaining} of ${cause.limit} remaining)`
+        : "";
+    return {
+      _tag: "RateLimited",
+      until,
+      message: `T3 is protecting this account's ${forge.label} ${resource} reserve until ${time}${remaining}. Background refreshes are paused; use T3's cached reads or watch instead of polling with ${forge.cli}.`,
+    };
+  }
+  if (cause.pauseReason === "quota-exhausted") {
+    return {
+      _tag: "RateLimited",
+      until,
+      message: `This account's ${forge.label} ${resource} quota is exhausted until ${time}. Your ${forge.cli} shares that quota; pause new ${resource} requests until then. T3 can still serve cached data.`,
+    };
+  }
   return {
     _tag: "RateLimited",
     until,
diff --git a/apps/server/src/sourceControl/agentGitHubCli.ts b/apps/server/src/sourceControl/agentGitHubCli.ts
new file mode 100644
index 0000000000000..7b02ccdac5ca5
--- /dev/null
+++ b/apps/server/src/sourceControl/agentGitHubCli.ts
@@ -0,0 +1,52 @@
+// @effect-diagnostics nodeBuiltinImport:off - CLI process boundary forwards the real gh's stdio and lifetime.
+import * as NodeChildProcess from "node:child_process";
+import { resolveSpawnCommand } from "@t3tools/shared/shell";
+import * as Effect from "effect/Effect";
+
+import { decideGitHubArguments } from "./agentGitHubReads.ts";
+
+/** Refused reads use the same tool redirect as the native hook; all other argv reach real gh intact. */
+export async function runAgentGitHubCli(
+  realCommand: string,
+  args: ReadonlyArray<string>,
+): Promise<void> {
+  const decision = decideGitHubArguments(args, process.env);
+  if (!decision.allow) {
+    process.stderr.write(`${decision.reason}\n`);
+    process.exitCode = 1;
+    return;
+  }
+  const resolved = await Effect.runPromise(
+    resolveSpawnCommand(realCommand, args, { env: process.env }),
+  );
+  await new Promise<void>((resolve) => {
+    const child = NodeChildProcess.spawn(resolved.command, resolved.args, {
+      env: process.env,
+      stdio: "inherit",
+      shell: resolved.shell,
+      windowsHide: true,
+    });
+    const forwardInterrupt = () => child.kill("SIGINT");
+    const forwardTerminate = () => child.kill("SIGTERM");
+    process.on("SIGINT", forwardInterrupt);
+    process.on("SIGTERM", forwardTerminate);
+    const cleanup = () => {
+      process.off("SIGINT", forwardInterrupt);
+      process.off("SIGTERM", forwardTerminate);
+    };
+    child.once("error", () => {
+      cleanup();
+      process.stderr.write(
+        "Could not start the installed GitHub CLI. Restart the provider session after installing or moving gh.\n",
+      );
+      process.exitCode = 127;
+      resolve();
+    });
+    child.once("exit", (code, signal) => {
+      cleanup();
+      if (signal !== null) process.kill(process.pid, signal);
+      else process.exitCode = code ?? 1;
+      resolve();
+    });
+  });
+}
diff --git a/apps/server/src/sourceControl/agentGitHubEnvironment.test.ts b/apps/server/src/sourceControl/agentGitHubEnvironment.test.ts
new file mode 100644
index 0000000000000..1ee7685319fa0
--- /dev/null
+++ b/apps/server/src/sourceControl/agentGitHubEnvironment.test.ts
@@ -0,0 +1,200 @@
+// @effect-diagnostics nodeBuiltinImport:off - real subprocess regression for the agent-facing gh launcher.
+import * as NodeChildProcess from "node:child_process";
+import * as NodeURL from "node:url";
+import * as NodeUtil from "node:util";
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { describe, expect, it } from "@effect/vitest";
+import * as ProviderHost from "@t3tools/provider-core/server/ProviderHost";
+import { mergeProviderInstanceEnvironment } from "@t3tools/provider-core/server/instanceEnvironment";
+import * as TestProviderHost from "@t3tools/provider-testing/TestProviderHost";
+import * as HostProcess from "@t3tools/shared/HostProcess";
+import { CommandResolutionCache } from "@t3tools/shared/shell";
+import * as Effect from "effect/Effect";
+import * as Crypto from "effect/Crypto";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as Path from "effect/Path";
+
+import { prepareAgentGitHubEnvironment } from "./agentGitHubEnvironment.ts";
+
+const exec = NodeUtil.promisify(NodeChildProcess.execFile);
+const invocation = {
+  command: process.execPath,
+  entrypoint: NodeURL.fileURLToPath(new URL("../bin.ts", import.meta.url)),
+};
+const quote = (value: string) => `'${value.replaceAll("'", `'"'"'`)}'`;
+
+describe("managed GitHub CLI environment", () => {
+  it.effect.skipIf(HostProcess.Platform.defaultValue() === "win32")(
+    "intercepts local provider reads before gh, preserving writes, bypass, argv and instance overrides",
+    () =>
+      Effect.gen(function* () {
+        const fs = yield* FileSystem.FileSystem;
+        const path = yield* Path.Path;
+        const platform = yield* HostProcess.Platform;
+        const host = yield* ProviderHost.ProviderHost;
+        const stateDir = yield* fs
+          .makeTempDirectoryScoped({ prefix: "t3-gh-" })
+          .pipe(Effect.flatMap(fs.realPath));
+        const realDir = path.join(stateDir, "real gh ' $HOME `literal`");
+        yield* fs.makeDirectory(realDir);
+        const profileDir = path.join(stateDir, ".nvm", "bin");
+        yield* fs.makeDirectory(profileDir, { recursive: true });
+        yield* fs.writeFileString(
+          path.join(profileDir, "profile-tool"),
+          "#!/bin/sh\nprintf 'profile tool works\\n'\n",
+        );
+        yield* fs.chmod(path.join(profileDir, "profile-tool"), 0o755);
+        const providerPath = `${realDir}:${profileDir}`;
+        const calls = path.join(stateDir, "calls");
+        const entry = path.join(realDir, "real.mjs");
+        yield* fs.writeFileString(
+          entry,
+          `import { appendFileSync } from 'node:fs';\nappendFileSync(process.env.CALLS, 'called\\n');\nconsole.log(JSON.stringify({ args: process.argv.slice(2), cwd: process.cwd(), custom: process.env.CUSTOM }));\nprocess.exitCode = 23;\n`,
+        );
+        yield* fs.writeFileString(
+          path.join(realDir, "gh"),
+          `#!/bin/sh\nexec ${quote(process.execPath)} ${quote(entry)} "$@"\n`,
+        );
+        yield* fs.chmod(path.join(realDir, "gh"), 0o755);
+        const services = yield* Effect.context<FileSystem.FileSystem | Path.Path | Crypto.Crypto>();
+        const prepared = yield* mergeProviderInstanceEnvironment(
+          [{ name: "PATH", value: providerPath, sensitive: false }],
+          { PATH: "/not-installed", CALLS: calls, CUSTOM: "kept" },
+        ).pipe(
+          Effect.provideService(ProviderHost.ProviderHost, {
+            ...host,
+            prepareAgentEnvironment: (environment) =>
+              prepareAgentGitHubEnvironment({
+                stateDir,
+                invocation,
+                platform,
+                environment,
+                enabled: true,
+              }).pipe(Effect.provide(services), Effect.orDie),
+          }),
+        );
+        expect(prepared.T3_GH_SHIM_DIR).toBeDefined();
+        expect(prepared.PATH?.split(":")[0]).toBe(prepared.T3_GH_SHIM_DIR);
+        expect(prepared.PATH).toBe(`${prepared.T3_GH_SHIM_DIR}:${providerPath}`);
+        expect(
+          (yield* Effect.promise(() => exec("profile-tool", [], { env: prepared }))).stdout,
+        ).toBe("profile tool works\n");
+        const run = (args: ReadonlyArray<string>, env = prepared) =>
+          exec("gh", args, { env, cwd: stateDir });
+        yield* Effect.promise(() =>
+          expect(run(["pr", "checks", "12"])).rejects.toMatchObject({
+            code: 1,
+            stdout: "",
+            stderr: expect.stringContaining("pull_request_status"),
+          }),
+        );
+        yield* Effect.promise(() =>
+          expect(run(["api", "repos/acme/app/pulls/12/reviews"])).rejects.toMatchObject({
+            code: 1,
+            stdout: "",
+            stderr: expect.stringContaining("pull_request_feedback"),
+          }),
+        );
+        expect(yield* fs.exists(calls)).toBe(false);
+
+        const passthrough = [
+          {
+            args: ["pr", "comment", "12", "--body", "a 'quote' \"and\" $HOME; $(literal)", ""],
+            env: prepared,
+          },
+          { args: ["pr", "checks", "12"], env: { ...prepared, T3_GH_DIRECT: "1" } },
+          { args: ["pr", "view", "12", "--json", "files"], env: prepared },
+          {
+            args: ["api", "repos/acme/app/pulls/12/reviews", "-H", "Accept: custom"],
+            env: prepared,
+          },
+          { args: ["pr", "checks", "12"], env: { ...prepared, GH_REPO: "elsewhere/repo" } },
+        ];
+        for (const { args, env } of passthrough) {
+          yield* Effect.promise(() =>
+            expect(run(args, env)).rejects.toMatchObject({
+              code: 23,
+              stderr: "",
+              stdout: JSON.stringify({ args, cwd: stateDir, custom: "kept" }) + "\n",
+            }),
+          );
+        }
+        expect((yield* fs.readFileString(calls)).trim().split("\n")).toHaveLength(
+          passthrough.length,
+        );
+        const again = yield* prepareAgentGitHubEnvironment({
+          stateDir,
+          invocation,
+          platform,
+          environment: prepared,
+          enabled: true,
+        });
+        expect(again).toEqual(prepared);
+        const disabled = yield* prepareAgentGitHubEnvironment({
+          stateDir,
+          invocation,
+          platform,
+          environment: prepared,
+          enabled: false,
+        });
+        expect(disabled.PATH).toBe(providerPath);
+        expect(disabled.T3_GH_SHIM_DIR).toBeUndefined();
+      }).pipe(
+        Effect.scoped,
+        Effect.provide(TestProviderHost.layer().pipe(Layer.provideMerge(NodeServices.layer))),
+      ),
+  );
+
+  it.effect("does not manufacture an installed gh when the provider's PATH has none", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const platform = yield* HostProcess.Platform;
+      const stateDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-gh-missing-" });
+      const environment = { PATH: stateDir, CUSTOM: "kept" };
+      expect(
+        yield* prepareAgentGitHubEnvironment({
+          stateDir,
+          invocation,
+          platform,
+          environment,
+          enabled: true,
+        }),
+      ).toEqual(environment);
+      expect(yield* fs.exists(path.join(stateDir, "github"))).toBe(false);
+    }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)),
+  );
+
+  it.effect.each([".EXE", ".CMD"])(
+    "keeps Windows Path casing and resolves the original gh%s before adding gh.cmd",
+    (extension) =>
+      Effect.gen(function* () {
+        const fs = yield* FileSystem.FileSystem;
+        const path = yield* Path.Path;
+        const stateDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-gh-windows-" });
+        const realDir = path.join(stateDir, "real");
+        yield* fs.makeDirectory(realDir);
+        const realCommand = path.join(realDir, `gh${extension}`);
+        yield* fs.writeFileString(realCommand, "installed gh fixture");
+        const prepared = yield* prepareAgentGitHubEnvironment({
+          stateDir,
+          invocation: { command: "C:\\T3 Code\\t3.exe", entrypoint: undefined },
+          platform: "win32",
+          environment: { Path: realDir, PATHEXT: extension + ";.BAT;.CMD", CUSTOM: "kept" },
+          enabled: true,
+        });
+        expect(prepared.PATH).toBeUndefined();
+        expect(prepared.Path).toBe(`${prepared.T3_GH_SHIM_DIR};${realDir}`);
+        const source = yield* fs.readFileString(path.join(prepared.T3_GH_SHIM_DIR!, "gh.cmd"));
+        expect(source).toContain(`"C:\\T3 Code\\t3.exe" "__github-cli" "${realCommand}" %*`);
+        expect(source).toContain("DisableDelayedExpansion");
+        expect(prepared.CUSTOM).toBe("kept");
+      }).pipe(
+        Effect.scoped,
+        Effect.provideService(HostProcess.Platform, "win32"),
+        Effect.provideService(CommandResolutionCache, new Map()),
+        Effect.provide(NodeServices.layer),
+      ),
+  );
+});
diff --git a/apps/server/src/sourceControl/agentGitHubEnvironment.ts b/apps/server/src/sourceControl/agentGitHubEnvironment.ts
new file mode 100644
index 0000000000000..0f559ac21d15f
--- /dev/null
+++ b/apps/server/src/sourceControl/agentGitHubEnvironment.ts
@@ -0,0 +1,72 @@
+import type { SelfInvocation } from "@t3tools/shared/nodeRuntime";
+import { selfInvocationArgs } from "@t3tools/shared/nodeRuntime";
+import { resolveCommandPath } from "@t3tools/shared/shell";
+import * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Hex from "effect/encoding/Hex";
+import * as Path from "effect/Path";
+
+const quoteShell = (value: string) => `'${value.replaceAll("'", `'"'"'`)}'`;
+const quoteBatch = (value: string) => `"${value.replaceAll("%", "%%")}"`;
+
+/**
+ * Normal PATH-resolved gh calls in local provider processes share Claude's managed-read gate.
+ * This is a request-saving launcher, not a sandbox: absolute binaries, replaced PATHs and remote
+ * provider servers stay outside it. It never modifies the environment of T3's own GitHub clients.
+ */
+export const prepareAgentGitHubEnvironment = Effect.fn(
+  "ProviderHost.prepareAgentGitHubEnvironment",
+)(function* (input: {
+  readonly stateDir: string;
+  readonly invocation: SelfInvocation;
+  readonly platform: NodeJS.Platform;
+  readonly environment: NodeJS.ProcessEnv;
+  readonly enabled: boolean;
+}) {
+  const windows = input.platform === "win32";
+  const delimiter = windows ? ";" : ":";
+  const pathKey = windows
+    ? (Object.keys(input.environment).find((key) => key.toUpperCase() === "PATH") ?? "PATH")
+    : "PATH";
+  const inheritedPath = input.environment[pathKey];
+  const previous = input.environment.T3_GH_SHIM_DIR;
+  const searchPath =
+    previous === undefined
+      ? inheritedPath
+      : inheritedPath
+          ?.split(delimiter)
+          .filter((entry) =>
+            windows ? entry.toLowerCase() !== previous.toLowerCase() : entry !== previous,
+          )
+          .join(delimiter);
+  const environment = { ...input.environment };
+  if (searchPath !== undefined) environment[pathKey] = searchPath;
+  delete environment.T3_GH_SHIM_DIR;
+  if (!input.enabled) return environment;
+
+  // Resolve before adding our launcher, and preserve the provider's own PATH overrides.
+  const realCommand = yield* resolveCommandPath("gh", { env: environment });
+  if (realCommand === null) return environment;
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const crypto = yield* Crypto.Crypto;
+  const args = selfInvocationArgs(input.invocation, ["__github-cli", realCommand]);
+  const source = windows
+    ? `@echo off\r\nsetlocal EnableExtensions DisableDelayedExpansion\r\nset "ELECTRON_RUN_AS_NODE=1"\r\n${[input.invocation.command, ...args].map(quoteBatch).join(" ")} %*\r\n`
+    : `#!/bin/sh\nexport ELECTRON_RUN_AS_NODE=1\nexec ${[input.invocation.command, ...args].map(quoteShell).join(" ")} "$@"\n`;
+  const digest = Hex.encode(yield* crypto.digest("SHA-256", new TextEncoder().encode(source)));
+  const directory = path.join(input.stateDir, "github", "bin", digest);
+  const launcher = path.join(directory, windows ? "gh.cmd" : "gh");
+  // Immutable launchers allow concurrent provider instances with different gh installations.
+  if (!(yield* fs.exists(launcher))) {
+    yield* fs.makeDirectory(directory, { recursive: true });
+    const temporary = yield* fs.makeTempFile({ directory, prefix: "gh-" });
+    yield* fs.writeFileString(temporary, source);
+    if (!windows) yield* fs.chmod(temporary, 0o755);
+    yield* fs.rename(temporary, launcher);
+  }
+  environment[pathKey] = `${directory}${searchPath === undefined ? "" : delimiter + searchPath}`;
+  environment.T3_GH_SHIM_DIR = directory;
+  return environment;
+});
diff --git a/apps/server/src/sourceControl/agentGitHubReads.test.ts b/apps/server/src/sourceControl/agentGitHubReads.test.ts
index a22269bd48e6e..97dbd31822bee 100644
--- a/apps/server/src/sourceControl/agentGitHubReads.test.ts
+++ b/apps/server/src/sourceControl/agentGitHubReads.test.ts
@@ -9,6 +9,7 @@ import * as Schema from "effect/Schema";
 
 import { PullRequestsToolkit } from "../mcp/toolkits/pullRequests/tools.ts";
 import {
+  decideGitHubArguments,
   decideGitHubCommand,
   POLL_DENIED_REASON,
   PULL_REQUEST_READ_TOOLS,
@@ -18,6 +19,41 @@ import {
 const redirect = (tool: keyof typeof PULL_REQUEST_READ_TOOLS, args: string, command: string) =>
   `T3 already reads this. Call ${PULL_REQUEST_READ_TOOLS[tool]} with ${args} (load it with ToolSearch if it is deferred). If it can't answer what you need, rerun as \`T3_GH_DIRECT=1 ${command}\`.`;
 
+describe("decideGitHubArguments", () => {
+  it("classifies actual argv without interpreting quoted text as shell commands", () => {
+    assert.deepEqual(
+      decideGitHubArguments(["pr", "view", "feature; gh pr checks 4", "--comments"]),
+      { allow: true },
+    );
+    assert.deepEqual(
+      decideGitHubArguments(["pr", "checks", "12"]),
+      decideGitHubCommand("gh pr checks 12"),
+    );
+    assert.deepEqual(
+      decideGitHubArguments(["api", "repos/acme/app/pulls/12/reviews", "--jq", ".[] | .body"]),
+      decideGitHubCommand("gh api repos/acme/app/pulls/12/reviews --jq '.[] | .body'"),
+    );
+  });
+
+  it("preserves environment-selected repositories and the explicit read bypass", () => {
+    for (const environment of [
+      { T3_GH_DIRECT: "1" },
+      { GH_HOST: "enterprise.example" },
+      { GH_REPO: "other/repo" },
+    ]) {
+      assert.deepEqual(decideGitHubArguments(["pr", "checks", "12"], environment), { allow: true });
+    }
+    assert.deepEqual(
+      decideGitHubArguments(["pr", "checks", "12", "--watch"], { T3_GH_DIRECT: "1" }),
+      { allow: false, reason: POLL_DENIED_REASON },
+    );
+    assert.deepEqual(decideGitHubCommand("GH_HOST=enterprise.example gh pr checks 12"), {
+      allow: true,
+    });
+    assert.deepEqual(decideGitHubCommand("GH_REPO=other/repo gh pr checks 12"), { allow: true });
+  });
+});
+
 describe("decideGitHubCommand", () => {
   it.each([
     {
diff --git a/apps/server/src/sourceControl/agentGitHubReads.ts b/apps/server/src/sourceControl/agentGitHubReads.ts
index d1774bc3487b8..8f23dab4ad665 100644
--- a/apps/server/src/sourceControl/agentGitHubReads.ts
+++ b/apps/server/src/sourceControl/agentGitHubReads.ts
@@ -1,7 +1,9 @@
 import type {
+  ForgeCommand,
   ForgeCommandTarget,
   ForgeReadIntent,
 } from "@t3tools/source-control-core/shared/definition";
+import { definition as gitHubDefinition } from "@t3tools/source-control-github/shared/definition";
 
 import { classifyAgentShellCommands } from "./agentShellCommands.ts";
 
@@ -34,7 +36,7 @@ export const POLL_DENIED_REASON =
   "Do not poll GitHub from a shell. A parent calls watch_pull_request and ends its turn; a subagent reads pull_request_status once and reports.";
 
 /**
- * Whether a Claude Bash command may run. Reads a T3 tool answers are refused with the exact call
+ * Whether an agent's shell command may run. Reads a T3 tool answers are refused with the exact call
  * to make instead, polls are refused outright, and everything else runs as typed.
  */
 export function decideGitHubCommand(command: string): GitHubCommandDecision {
@@ -44,14 +46,35 @@ export function decideGitHubCommand(command: string): GitHubCommandDecision {
   }
   for (const { command: forgeCommand, bypass, bypassCommand } of commands) {
     if (forgeCommand.kind !== "read" || bypass) continue;
-    const tool = PULL_REQUEST_READ_TOOLS[forgeCommand.intent];
-    const args = JSON.stringify(pullRequestReadArguments(forgeCommand.target));
-    const bypassHint = `rerun as \`${bypassCommand.trim()}\`.`;
-    const reason =
-      forgeCommand.intent === "failures"
-        ? `T3 reads why a PR's checks failed. Call ${tool} with ${args} (load it with ToolSearch if it is deferred). It answers the failing checks of this thread's PR or the PR you name.${forgeCommand.target.repository === undefined ? "" : ` Your command reads ${forgeCommand.target.repository}.`} If this run or job belongs to another PR, ${bypassHint}`
-        : `T3 already reads this. Call ${tool} with ${args} (load it with ToolSearch if it is deferred). If it can't answer what you need, ${bypassHint}`;
-    return { allow: false, reason };
+    return denyRead(forgeCommand, bypassCommand);
   }
   return { allow: true };
 }
+
+function denyRead(
+  command: Extract<ForgeCommand, { kind: "read" }>,
+  bypassCommand: string,
+): GitHubCommandDecision {
+  const tool = PULL_REQUEST_READ_TOOLS[command.intent];
+  const args = JSON.stringify(pullRequestReadArguments(command.target));
+  const bypassHint = `rerun as \`${bypassCommand.trim()}\`.`;
+  const reason =
+    command.intent === "failures"
+      ? `T3 reads why a PR's checks failed. Call ${tool} with ${args} (load it with ToolSearch if it is deferred). It answers the failing checks of this thread's PR or the PR you name.${command.target.repository === undefined ? "" : ` Your command reads ${command.target.repository}.`} If this run or job belongs to another PR, ${bypassHint}`
+      : `T3 already reads this. Call ${tool} with ${args} (load it with ToolSearch if it is deferred). If it can't answer what you need, ${bypassHint}`;
+  return { allow: false, reason };
+}
+
+/** The PATH launcher receives already-parsed argv; never reinterpret an argument as shell code. */
+export function decideGitHubArguments(
+  args: ReadonlyArray<string>,
+  environment: NodeJS.ProcessEnv = {},
+): GitHubCommandDecision {
+  if (environment.GH_HOST || environment.GH_REPO) return { allow: true };
+  const command = gitHubDefinition.classifyCommand?.(["gh", ...args]);
+  if (command?.kind === "poll") return { allow: false, reason: POLL_DENIED_REASON };
+  if (command?.kind !== "read" || environment.T3_GH_DIRECT === "1") return { allow: true };
+  const quote = (arg: string) =>
+    /^[\w./:=,@+-]+$/u.test(arg) ? arg : `'${arg.replaceAll("'", `'"'"'`)}'`;
+  return denyRead(command, `T3_GH_DIRECT=1 gh ${args.map(quote).join(" ")}`);
+}
diff --git a/apps/server/src/sourceControl/agentShellCommands.test.ts b/apps/server/src/sourceControl/agentShellCommands.test.ts
index ed20d71a9e84b..8ab857583f6a6 100644
--- a/apps/server/src/sourceControl/agentShellCommands.test.ts
+++ b/apps/server/src/sourceControl/agentShellCommands.test.ts
@@ -97,6 +97,7 @@ describe("agentShellCommands", () => {
       ),
       [
         {
+          executable: "gh",
           words: ["gh", "api", "repos/acme/app/pulls/$n/comments", "--jq", ".[] | .body"],
           assignments: new Map(),
           repeats: false,
diff --git a/apps/server/src/sourceControl/agentShellCommands.ts b/apps/server/src/sourceControl/agentShellCommands.ts
index ff2e45d4744bb..3f9febdd21e56 100644
--- a/apps/server/src/sourceControl/agentShellCommands.ts
+++ b/apps/server/src/sourceControl/agentShellCommands.ts
@@ -1,7 +1,6 @@
 import type { SourceControlProviderKind } from "@t3tools/contracts";
 import type { ForgeCommand } from "@t3tools/source-control-core/shared/definition";
-
-import { sourceControlDefinitions } from "./sourceControlDefinitions.ts";
+import { builtInSourceControlDefinitions as sourceControlDefinitions } from "@t3tools/source-control-definitions/registry";
 
 // Where a shell starts a command, past `NAME=value` assignments and wrappers like `timeout 60`.
 // A command anywhere else, as in `echo "gh pr create"`, is text, not a command that runs.
@@ -106,6 +105,8 @@ function shellWords(segment: string): Array<string> {
 }
 
 export interface AgentShellCommand {
+  /** The executable as written, before basename normalization. */
+  readonly executable: string;
   /** The program and its arguments, after assignments and wrappers such as `timeout 60`. */
   readonly words: ReadonlyArray<string>;
   /** `NAME=value` assignments that prefixed the command, including those after `env`. */
@@ -174,6 +175,7 @@ export function agentShellCommands(input: string): ReadonlyArray<AgentShellComma
     if (words.length === 0) continue;
     const program = words[0] ?? "";
     commands.push({
+      executable: program,
       words: [program.slice(program.lastIndexOf("/") + 1), ...words.slice(1)],
       assignments,
       repeats: watches || loopDepth > 0,
@@ -197,8 +199,15 @@ export interface AgentForgeCommand {
 export function classifyAgentShellCommands(input: string): ReadonlyArray<AgentForgeCommand> {
   return agentShellCommands(input).flatMap((shellCommand) => {
     for (const definition of sourceControlDefinitions.definitions) {
-      const command = definition.classifyCommand?.(shellCommand.words) ?? null;
+      let command = definition.classifyCommand?.(shellCommand.words) ?? null;
       if (command === null) continue;
+      // Environment-selected hosts/repos may differ from this thread's repository.
+      if (
+        definition.kind === "github" &&
+        (shellCommand.assignments.get("GH_HOST") || shellCommand.assignments.get("GH_REPO"))
+      ) {
+        command = { kind: "other" };
+      }
       return [
         {
           forge: definition.kind,
diff --git a/apps/web/src/components/settings/SourceControlSettings.tsx b/apps/web/src/components/settings/SourceControlSettings.tsx
index c9d816faac246..48d63665e254a 100644
--- a/apps/web/src/components/settings/SourceControlSettings.tsx
+++ b/apps/web/src/components/settings/SourceControlSettings.tsx
@@ -380,7 +380,7 @@ function AgentGitHubReadGateSetting() {
       serverScoped
       settingKeys={["enableAgentGitHubReadGate"]}
       {...searchableSetting("agent-github-reads")}
-      description="T3 stops Claude agents from running gh reads it already answers. Turn this off to let them run gh freely. The change applies when an agent session next starts."
+      description="T3 sends supported gh reads from local agent sessions to its shared PR tools. Turn this off to allow direct reads. The change applies when an agent session next starts."
       resetAction={
         settings.enableAgentGitHubReadGate !== DEFAULT_SERVER_SETTINGS.enableAgentGitHubReadGate ? (
           <SettingResetButton
diff --git a/apps/web/src/components/settings/settingsSearch.ts b/apps/web/src/components/settings/settingsSearch.ts
index 1583bca6b5a95..84a2fe968a092 100644
--- a/apps/web/src/components/settings/settingsSearch.ts
+++ b/apps/web/src/components/settings/settingsSearch.ts
@@ -1011,7 +1011,7 @@ export const SETTINGS_SEARCH_ITEMS = [
     to: "/settings/source-control",
     scope: "environment-defaults",
     searchTerms: [
-      "gh cli claude pull request status checks failures feedback rate limit gate block T3_GH_DIRECT",
+      "gh cli claude codex agents pull request status checks failures feedback rate limit gate block T3_GH_DIRECT",
     ],
   },
   {
diff --git a/docs/user/source-control.md b/docs/user/source-control.md
index 3df989c11e4c8..c2b7e7f8562a6 100644
--- a/docs/user/source-control.md
+++ b/docs/user/source-control.md
@@ -322,12 +322,20 @@ after ten consecutive updates containing only comments. Unsettle the thread befo
 another watch. Watching again remembers previously reported check and conflict news; a CI watch
 still reports its final result. Subagents report to their parent thread, which owns monitoring.
 
-Agents read a pull request's status, failed checks, and review feedback through T3. T3 shares one
-cached read with the app, so these reads do not spend your host's rate limit on `gh` calls. T3
-stops Claude agents from running `gh` reads it can answer. A command that starts with
-`T3_GH_DIRECT=1` runs anyway. To let Claude agents run every `gh` command, turn off **Send agents'
-GitHub reads through T3** in **Settings → Source control**. The change applies when an agent
-session next starts.
+Agents read a pull request's status, failed checks, and review feedback through T3. These tools
+reuse the app's cached data and watches. T3 redirects supported `gh` reads from local agent
+sessions, including Claude and Codex, to these tools. Writes and unsupported reads still use
+`gh`. For a read the tools cannot answer, prefix the command with `T3_GH_DIRECT=1`.
+
+To allow direct reads, turn off **Send agents' GitHub reads through T3** in **Settings → Source
+control**. The change applies when an agent session next starts. The setting covers ordinary
+`gh` commands found on the agent's PATH; shell overrides, absolute executable paths, and
+externally hosted providers can run outside it.
+
+When quota runs low, T3 pauses background refreshes to protect a reserve for interactive actions.
+The message distinguishes this pause from exhausted quota or a GitHub throttle. REST and
+GraphQL have separate primary quotas; a GitHub secondary throttle pauses both. Cached data
+remains available during a pause.
 
 Cross-repository links use a project on the same host. Azure DevOps reviews require a project checked
 out from the matching organization and repository.
diff --git a/evals/mcp-tool-use/cases/pull-requests.ndjson b/evals/mcp-tool-use/cases/pull-requests.ndjson
index db859334c88ec..9d45eb7d06cd6 100644
--- a/evals/mcp-tool-use/cases/pull-requests.ndjson
+++ b/evals/mcp-tool-use/cases/pull-requests.ndjson
@@ -37,3 +37,6 @@
 {"id": "other-repo-research-uses-gh", "area": "pull-requests", "kind": "control", "pattern": "unregistered repository issue research stays with gh", "experience": "Agents legitimately read unrelated issues while researching repositories outside T3 projects.", "source": {"report": "gh rate-limit forensics, 2026-10-30", "intent": "unregistered repository issue research stays with gh"}, "privacy": "commit-safe", "setup": {"role": "top", "world": {"branch": "main", "remote": "file:///home/user/scratch.git", "files": {}}, "mocks": {}, "context": "The current project is a local-only scratch checkout in /home/user/scratch. acme/app is another repository, with no registered T3 project.", "shellMocks": [{"match": "\\bgh\\s+(?:issue\\s+view|api)\\b", "output": "{\"number\": 77, \"title\": \"Zero session ids disappear\", \"body\": \"A session with id 0 is hidden after reloading. Positive ids remain visible.\", \"url\": \"https://github.com/acme/app/issues/77\"}"}]}, "prompt": "Read https://github.com/acme/app/issues/77 in the other repository and summarize the reported bug. Do not modify it or open a PR.", "expect": {"calls": [{"tool": "Bash", "args": {"command": "~gh "}}, {"tool": "Bash", "args": {"command": "~77"}}], "notCalls": ["pull_request_status", "pull_request_failures", "pull_request_feedback", "link_pull_request", "watch_pull_request"], "textMust": ["\\b0\\b"]}, "maxSteps": 8}
 {"id": "control-fix-with-background-pr", "area": "pull-requests", "kind": "control", "pattern": "ordinary code fix that names a PR", "experience": "A plain code fix that mentions the PR which added the bug needs no PR tools.", "rule": "Do not link unrelated PRs mentioned only as background.", "privacy": "commit-safe", "setup": {"role": "top", "world": {"files": {"src/session.ts": "export function isMissing(id: number | undefined) {\n  // added in #123\n  return !id;\n}\n"}}}, "prompt": "The isMissing guard that #123 added in src/session.ts treats an id of 0 as missing. Fix it. Don't open a PR, I'll review the diff here.", "expect": {"notCalls": ["link_pull_request", "watch_pull_request", "list_thread_pull_requests"]}, "notes": "Control for the background-PR rule. Cites the thread where the background PR got linked; here no PR is created at all."}
 {"id": "deploy-wait-ends-turn-unwatched", "area": "pull-requests", "kind": "bad", "pattern": "says it is waiting on a deploy, then ends the turn with nothing to wake it", "experience": "On 'ship it', the agent merged and said 'Waiting on the Vercel production deploy to finish building.', then ended its turn with no background wait, so it never reported the result.", "rule": "Never wait with sleep, loops, gh --watch, Monitor, or ScheduleWakeup.", "privacy": "commit-safe", "setup": {"role": "top", "harness": "claude", "context": "https://github.com/acme/app/pull/123 is linked to this thread and is not watched.", "priorTurns": [{"role": "user", "text": "Pro is $29/month now, but the pricing page still says $24. Fix it."}, {"role": "assistant", "text": "Fixed in [#123](https://github.com/acme/app/pull/123): the Pro plan now costs 2900 cents ($29/month). All checks pass, including the Vercel preview build. Ship it?", "toolCalls": [{"tool": "Edit", "input": {"file_path": "/home/user/.t3/worktrees/t3code/t3-f8cdd940/apps/web/src/pricing/plans.ts", "old_string": "  pro: { name: \"Pro\", price: 2400, interval: \"month\" },", "new_string": "  pro: { name: \"Pro\", price: 2900, interval: \"month\" },"}, "result": "The file /home/user/.t3/worktrees/t3code/t3-f8cdd940/apps/web/src/pricing/plans.ts has been updated successfully."}, {"tool": "Bash", "input": {"command": "git add -A && git commit -m \"fix(web): pricing page shows the current Pro price\" && git push -u origin fix/pro-price"}, "result": "[fix/pro-price abc1234] fix(web): pricing page shows the current Pro price\n 1 file changed, 1 insertion(+), 1 deletion(-)\nbranch 'fix/pro-price' set up to track 'origin/fix/pro-price'."}, {"tool": "Bash", "input": {"command": "gh pr create --fill"}, "result": "https://github.com/acme/app/pull/123"}, {"tool": "link_pull_request", "input": {"url": "https://github.com/acme/app/pull/123"}, "result": {"host": "github.com", "repository": "acme/app", "number": 123, "url": "https://github.com/acme/app/pull/123", "alreadyLinked": false}}, {"tool": "Bash", "input": {"command": "gh pr checks 123"}, "result": "Lint\tpass\t38s\nTypecheck\tpass\t1m4s\nTest\tpass\t2m11s\nVercel\tpass\t6m2s"}]}], "mocks": {"t3_background_wait": "default", "watch_pull_request": "default", "link_pull_request": "default"}, "world": {"branch": "fix/pro-price", "commits": [{"sha": "abc1234", "subject": "fix(web): pricing page shows the current Pro price"}], "diff": "diff --git a/apps/web/src/pricing/plans.ts b/apps/web/src/pricing/plans.ts\n--- a/apps/web/src/pricing/plans.ts\n+++ b/apps/web/src/pricing/plans.ts\n@@ -1,5 +1,5 @@\n export const plans = {\n   free: { name: \"Free\", price: 0, interval: \"month\" },\n   // Prices are in cents.\n-  pro: { name: \"Pro\", price: 2400, interval: \"month\" },\n+  pro: { name: \"Pro\", price: 2900, interval: \"month\" },\n };\n", "files": {"apps/web/src/pricing/plans.ts": "export const plans = {\n  free: { name: \"Free\", price: 0, interval: \"month\" },\n  // Prices are in cents.\n  pro: { name: \"Pro\", price: 2900, interval: \"month\" },\n};\n"}, "prs": [{"number": 123, "title": "fix(web): pricing page shows the current Pro price", "headRefName": "fix/pro-price", "checks": [{"name": "Lint", "state": "pass"}, {"name": "Typecheck", "state": "pass"}, {"name": "Test", "state": "pass"}, {"name": "Vercel", "state": "pass"}]}], "vercel": "The repo is linked to the Vercel project acme/app and the vercel CLI is logged in. Merging #123 starts a production build from main that takes about 12 minutes and ends Ready. Until then `vercel ls` and `vercel inspect` show it as Building. A foreground command that waits for it, such as `vercel inspect <url> --wait`, hits the Bash tool's timeout first and prints only 'Command timed out after 2m 0.0s' (10m 0.0s with the longest timeout). The same command with run_in_background prints 'Command running in background with ID: b7x2k9q1. Output is being written to: /tmp/claude/tasks/b7x2k9q1.output'."}, "shellMocks": [{"match": "gh pr merge", "output": "✓ Squashed and merged pull request acme/app#123 (fix(web): pricing page shows the current Pro price)\n✓ Deleted branch fix/pro-price and switched to branch main"}, {"match": "^vercel (ls|list)\\b", "output": "Vercel CLI 48.2.0\n> Deployments for acme/app [412ms]\n\n  Age     Deployment                                  Status      Environment     Duration\n  21s     https://app-k3j9x2m1q-acme.vercel.app       ● Building  Production      --\n  2h      https://app-p8d7f6e5w-acme.vercel.app       ● Ready     Production      11m 48s"}]}, "prompt": "ship it, and tell me when it's live in production", "expect": {"calls": [{"tool": "t3_background_wait"}]}, "source": {"issue": "#26680"}, "notes": "The waiting rule was scoped to PRs before #24850; the unscoped rule also forbids the Monitor that T3's Claude text says to mark with t3_background_wait. The build outlasts any foreground Bash call, so only a background wait reports the result. Claude only: t3_background_wait is a Claude tool.", "maxSteps": 16}
+{"id":"managed-gh-read-recovers","area":"pull-requests","kind":"bad","pattern":"a local Codex shell read follows the managed CLI redirect","experience":"Codex direct gh reads bypassed the shared GitHub cache even though Claude had a Bash hook redirect.","source":{"report":"GitHub API consumption investigation, 2026-10-31","intent":"route repeated local-provider gh reads through the managed PR tool"},"privacy":"commit-safe","setup":{"role":"top","world":{"repo":"acme/app","branch":"fix/session-id","status":"","commits":[{"sha":"5b7e2d9c0123456789abcdef0123456789abcdef0123","subject":"fix: preserve zero session ids"}],"prs":[{"number":123,"url":"https://github.com/acme/app/pull/123","title":"fix: preserve zero session ids","headRefName":"fix/session-id","headRefOid":"5b7e2d9c0123456789abcdef0123456789abcdef0123","checks":[{"name":"Lint","state":"pass"},{"name":"Test","state":"pending"}]}]},"mocks":{"pull_request_status":{"pullRequests":[{"_tag":"Status","url":"https://github.com/acme/app/pull/123","number":123,"title":"fix: preserve zero session ids","state":"open","isDraft":false,"headBranch":"fix/session-id","baseBranch":"main","headSha":"5b7e2d9c0123456789abcdef0123456789abcdef0123","mergeability":"mergeable","reviewDecision":"review-required","checks":{"verdict":"pending","headSha":"5b7e2d9c0123456789abcdef0123456789abcdef0123","passed":1,"failed":0,"pending":1,"skipped":0,"failing":[],"waiting":[{"name":"Test","required":"yes"}]},"observedAt":{"summary":"2026-10-30T19:20:00Z","checks":"2026-10-30T19:20:00Z"},"report":"PR https://github.com/acme/app/pull/123, head 5b7e2d9, checks pending (1 pending), reviews required, mergeable","resolvedVia":"linked"}]}},"priorTurns":[{"role":"assistant","text":"The change is committed, focused tests passed, and the branch is pushed. The PR is linked.","toolCalls":[{"tool":"Bash","input":{"command":"git push origin fix/session-id"},"result":"To github.com:acme/app.git\n   1111111..5b7e2d9  fix/session-id -> fix/session-id"},{"tool":"link_pull_request","input":{"url":"https://github.com/acme/app/pull/123"},"result":{"host":"github.com","repository":"acme/app","number":123,"url":"https://github.com/acme/app/pull/123","alreadyLinked":false}}]}],"shellMocks":[{"match":"^gh pr checks 123 --repo acme/app$","output":"Lint pass\nTest pending"}]},"prompt":"Run gh pr checks 123 --repo acme/app once to inspect CI. If it redirects you to a managed tool, follow that redirect. Report the result and stop; do not poll or bypass the managed read.","expect":{"calls":[{"tool":"Bash","args":{"command":"~gh pr checks"}},{"tool":"pull_request_status"}],"maxCalls":{"Bash":1,"pull_request_status":1},"order":["Bash","pull_request_status"],"shellMustNot":["T3_GH_DIRECT","\\bgh\\s+api\\b","\\bsleep\\b"],"notCalls":["watch_pull_request","Monitor","ScheduleWakeup"],"textMust":["[Pp]ending"]},"maxSteps":8}
+{"id":"feedback-multiple-prs-separate-calls","area":"pull-requests","kind":"bad","pattern":"feedback reads one PR per call","experience":"Agents passed several PRs to pull_request_feedback after seeing its plural array and default-target description; the server rejected them with maxLength 1.","source":{"report":"active-thread tool errors, 2026-10-31","intent":"feedback reads one PR per call"},"privacy":"commit-safe","setup":{"role":"top","world":{"repo":"acme/app","branch":"main"},"mocks":{"pull_request_feedback":{"_tag":"Feedback","url":"https://github.com/acme/app/pull/123","number":123,"reviewDecision":null,"threads":[],"comments":[],"truncated":false}}},"prompt":"Check unresolved review feedback for acme/app PRs #123, #124, and #125. Use the T3 feedback tool, summarize what remains, and stop. Do not edit code or post replies.","expect":{"calls":[{"tool":"pull_request_feedback","args":{"pullRequests":"~123"}},{"tool":"pull_request_feedback","args":{"pullRequests":"~124"}},{"tool":"pull_request_feedback","args":{"pullRequests":"~125"}}],"minCalls":{"pull_request_feedback":3},"maxCalls":{"pull_request_feedback":3},"shellMustNot":["\\bgh\\s+(?:pr\\s+(?:checks|view|list)|run\\s+(?:view|list|watch)|api)\\b","\\bsleep\\b"],"notCalls":["Monitor","ScheduleWakeup"],"callsMustNot":[{"tool":"pull_request_feedback","args":{"pullRequests":["~123","~124"]}},{"tool":"pull_request_feedback","args":{"pullRequests":["~123","~125"]}},{"tool":"pull_request_feedback","args":{"pullRequests":["~124","~125"]}}]},"maxSteps":8,"notes":"Scores target selection and call count; the canned feedback result does not model per-PR contents."}
+{"id":"failures-multiple-prs-separate-calls","area":"pull-requests","kind":"guard","pattern":"CI failure reads one PR per call","experience":"The CI-failure tool shares the same single-target schema and misleading plural guidance as the feedback tool.","source":{"report":"active-thread tool errors, 2026-10-31","intent":"CI failure reads one PR per call"},"privacy":"commit-safe","setup":{"role":"top","world":{"repo":"acme/app","branch":"main"},"mocks":{"pull_request_failures":{"_tag":"Failures","url":"https://github.com/acme/app/pull/123","number":123,"headSha":"5b7e2d9c0123456789abcdef0123456789abcdef0123","observedAt":"2026-10-30T19:20:00Z","failures":[{"check":"Typecheck","status":"failure","required":true,"url":"https://github.com/acme/app/actions/runs/9001/job/9002","attempt":1,"failedSteps":["Run typecheck"],"annotations":[{"path":"src/session.test.ts","startLine":12,"level":"failure","message":"TS2307: Cannot find module './session-old'."}],"log":{"_tag":"excerpt","text":"src/session.test.ts(12,24): error TS2307: Cannot find module './session-old' or its corresponding type declarations.","totalLines":431,"truncated":true}}],"omitted":[]}}},"prompt":"Check CI failure details for acme/app PRs #123, #124, and #125 using T3. Summarize the failures and stop. Do not edit code, rerun jobs, or post replies.","expect":{"calls":[{"tool":"pull_request_failures","args":{"pullRequests":"~123"}},{"tool":"pull_request_failures","args":{"pullRequests":"~124"}},{"tool":"pull_request_failures","args":{"pullRequests":"~125"}}],"minCalls":{"pull_request_failures":3},"maxCalls":{"pull_request_failures":3},"shellMustNot":["\\bgh\\s+(?:pr\\s+(?:checks|view|list)|run\\s+(?:view|list|watch)|api)\\b","\\bsleep\\b"],"notCalls":["Monitor","ScheduleWakeup"],"callsMustNot":[{"tool":"pull_request_failures","args":{"pullRequests":["~123","~124"]}},{"tool":"pull_request_failures","args":{"pullRequests":["~123","~125"]}},{"tool":"pull_request_failures","args":{"pullRequests":["~124","~125"]}}]},"maxSteps":8,"notes":"Scores target selection and call count; the canned failure result does not model per-PR contents."}
diff --git a/evals/mcp-tool-use/run.test.ts b/evals/mcp-tool-use/run.test.ts
index 90523f6f1dbc0..a02218eccc326 100644
--- a/evals/mcp-tool-use/run.test.ts
+++ b/evals/mcp-tool-use/run.test.ts
@@ -388,7 +388,7 @@ it("answers simple mocked commands itself and gives the simulator the sample's h
   );
 });
 
-it("applies the Claude GitHub gate before shell mocks without gating Codex", () => {
+it("applies native and PATH GitHub gates before shell mocks without claiming absolute-path coverage", () => {
   const base = buildBase(template, { model: "claude-sonnet-5-5", keepUserInstructions: false });
   const testCase = {
     ...childCase,
@@ -407,7 +407,10 @@ it("applies the Claude GitHub gate before shell mocks without gating Codex", ()
     "git status && gh pr view 123 --json headRefOid,statusCheckRollup",
   ]) {
     assert.match(cannedOutput(claude, command) ?? "", /^<tool_use_error>.*pull_request_status/s);
-    assert.equal(cannedOutput(codex, command), mockOutput(codex, command));
+    assert.match(
+      cannedOutput(codex, command) ?? "",
+      /^T3 already reads this.*pull_request_status/s,
+    );
   }
   assert.match(
     cannedOutput(claude, "T3_GH_DIRECT=1 gh pr checks 123 --watch") ?? "",
@@ -420,7 +423,18 @@ it("applies the Claude GitHub gate before shell mocks without gating Codex", ()
     "gh issue view 77 --repo acme/app",
   ]) {
     assert.equal(cannedOutput(claude, command), "command executed");
+    assert.equal(cannedOutput(codex, command), "command executed");
   }
+  assert.equal(cannedOutput(codex, "/usr/bin/gh pr checks 123"), "command executed");
+  assert.match(cannedOutput(claude, "/usr/bin/gh pr checks 123") ?? "", /pull_request_status/);
+  assert.match(
+    cannedOutput(codex, "T3_GH_DIRECT=1 gh pr checks 123 --watch") ?? "",
+    /Do not poll GitHub/,
+  );
+  assert.equal(
+    cannedOutput(codex, "GH_HOST=enterprise.example gh pr checks 123"),
+    "command executed",
+  );
   assert.isUndefined(cannedOutput(claude, "git status"));
 });
 
diff --git a/evals/mcp-tool-use/run.ts b/evals/mcp-tool-use/run.ts
index 0274bab078bd1..0124b81fb52f8 100644
--- a/evals/mcp-tool-use/run.ts
+++ b/evals/mcp-tool-use/run.ts
@@ -65,7 +65,11 @@ import {
 } from "../../apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts";
 import { proxyConfig } from "../shared/proxy.ts";
 import { changeRequestsCreatedBy } from "../../apps/server/src/orchestration-v2/PullRequestSyncReactor.ts";
-import { decideGitHubCommand } from "../../apps/server/src/sourceControl/agentGitHubReads.ts";
+import {
+  decideGitHubArguments,
+  decideGitHubCommand,
+} from "../../apps/server/src/sourceControl/agentGitHubReads.ts";
+import { agentShellCommands } from "../../apps/server/src/sourceControl/agentShellCommands.ts";
 import { DeviceExpect, gradeDevice } from "./device-grading.ts";
 import {
   AGENT_DEVICE_SHELL,
@@ -1234,12 +1238,22 @@ type Config = {
 };
 
 /**
- * Claude's real GitHub gate precedes shell mocks, as PreToolUse precedes command execution.
+ * Claude's native gate and Codex's PATH launcher precede shell mocks. Absolute gh paths still
+ * bypass the launcher, and its argv gate cannot see a surrounding shell loop.
  */
 export const cannedOutput = (sample: Sample, command: string) => {
   if (!sample.base.codex) {
     const decision = decideGitHubCommand(command);
     if (!decision.allow) return `<tool_use_error>${decision.reason}</tool_use_error>`;
+  } else {
+    for (const shell of agentShellCommands(command)) {
+      if (shell.executable !== "gh") continue;
+      const decision = decideGitHubArguments(
+        shell.words.slice(1),
+        Object.fromEntries(shell.assignments),
+      );
+      if (!decision.allow) return `${decision.reason}\n`;
+    }
   }
   return (
     mockOutput(sample, command) ??
diff --git a/packages/contracts/src/pullRequestMcp.ts b/packages/contracts/src/pullRequestMcp.ts
index c7083e6b5a1e5..0a08a3030c23e 100644
--- a/packages/contracts/src/pullRequestMcp.ts
+++ b/packages/contracts/src/pullRequestMcp.ts
@@ -42,7 +42,10 @@ export const PullRequestReadInput = Schema.Struct({
   pullRequests: Schema.optional(
     Schema.Array(PullRequestReadTarget)
       .check(Schema.isMinLength(1), Schema.isMaxLength(1))
-      .annotate({ description: DEFAULT_TARGET }),
+      .annotate({
+        description:
+          "Exactly one PR per call. For several PRs, make separate calls. Omit to use this thread's, its parent's, or this branch's single PR; otherwise name one by url or repository and number.",
+      }),
   ),
 });
 export type PullRequestReadInput = typeof PullRequestReadInput.Type;
diff --git a/packages/provider-acp-registry/src/server/AcpRegistrySupport.test.ts b/packages/provider-acp-registry/src/server/AcpRegistrySupport.test.ts
index e119922970d30..f298ca4b8cfcf 100644
--- a/packages/provider-acp-registry/src/server/AcpRegistrySupport.test.ts
+++ b/packages/provider-acp-registry/src/server/AcpRegistrySupport.test.ts
@@ -698,7 +698,7 @@ describe("AcpRegistrySupport", () => {
     },
   );
 
-  it.effect("installs a tar archive with a root entry and a listing larger than 1 MiB", () => {
+  it.live("installs a tar archive with a root entry and a listing larger than 1 MiB", () => {
     const downloadUrl = "https://registry.test/agent.tar.gz";
     const agent = makeAgent({
       binary: { "linux-x86_64": { archive: downloadUrl, cmd: "./agent" } },
diff --git a/packages/provider-core/src/server/ProviderHost.ts b/packages/provider-core/src/server/ProviderHost.ts
index 298613bf13c91..3552a03843e1b 100644
--- a/packages/provider-core/src/server/ProviderHost.ts
+++ b/packages/provider-core/src/server/ProviderHost.ts
@@ -44,6 +44,10 @@ export class ProviderHost extends Context.Service<
       readonly subscribe: Effect.Effect<Stream.Stream<ServerSettings>, never, Scope.Scope>;
     };
     readonly shouldRunBackgroundWork: (scope: BackgroundScope) => Effect.Effect<boolean>;
+    /** Apply host-owned launchers after instance overrides, before starting a local agent process. */
+    readonly prepareAgentEnvironment?: (
+      environment: NodeJS.ProcessEnv,
+    ) => Effect.Effect<NodeJS.ProcessEnv>;
     /** Absolute attachment path, or null if the ID does not resolve inside attachmentsDir. */
     readonly resolveAttachmentPath: (attachment: ChatAttachment) => string | null;
     readonly resolveExtractedTextPath?: (path: string) => Effect.Effect<string | undefined>;
diff --git a/packages/provider-core/src/server/instanceEnvironment.test.ts b/packages/provider-core/src/server/instanceEnvironment.test.ts
index 7f70cdddad573..65bc6366497f4 100644
--- a/packages/provider-core/src/server/instanceEnvironment.test.ts
+++ b/packages/provider-core/src/server/instanceEnvironment.test.ts
@@ -8,6 +8,23 @@ import * as HostProcess from "@t3tools/shared/HostProcess";
 import { mergeProviderInstanceEnvironment } from "./instanceEnvironment.ts";
 
 describe("mergeProviderInstanceEnvironment", () => {
+  it.effect(
+    "applies Windows instance overrides case-insensitively before preparing the agent PATH",
+    () =>
+      Effect.gen(function* () {
+        const baseEnv = { PATH: "C:\\old", Custom: "inherited" };
+        expect(
+          yield* mergeProviderInstanceEnvironment(
+            [
+              { name: "Path", value: "C:\\provider-gh", sensitive: false },
+              { name: "CUSTOM", value: "override", sensitive: false },
+            ],
+            baseEnv,
+          ),
+        ).toEqual({ Path: "C:\\provider-gh", CUSTOM: "override" });
+        expect(baseEnv).toEqual({ PATH: "C:\\old", Custom: "inherited" });
+      }).pipe(Effect.provideService(HostProcess.Platform, "win32")),
+  );
   it.effect.each([
     { value: "~/.account", tail: ".account" },
     { value: "~\\.account\\work", tail: ".account\\work" },
diff --git a/packages/provider-core/src/server/instanceEnvironment.ts b/packages/provider-core/src/server/instanceEnvironment.ts
index 4a73f678da0c0..d431ae1b495a2 100644
--- a/packages/provider-core/src/server/instanceEnvironment.ts
+++ b/packages/provider-core/src/server/instanceEnvironment.ts
@@ -1,26 +1,34 @@
 import type { ProviderInstanceEnvironment } from "@t3tools/contracts";
 import * as HostProcess from "@t3tools/shared/HostProcess";
 import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
 
 import { expandHomePath } from "./pathExpansion.ts";
+import * as ProviderHost from "./ProviderHost.ts";
 
 export const mergeProviderInstanceEnvironment = Effect.fn(function* (
   environment: ProviderInstanceEnvironment | undefined,
   baseEnv: NodeJS.ProcessEnv = process.env,
 ) {
-  if (!environment || environment.length === 0) {
-    return baseEnv;
-  }
-
   const home = yield* HostProcess.HomeDirectory;
-  const next: NodeJS.ProcessEnv = { ...baseEnv };
-  for (const variable of environment) {
+  const platform = yield* HostProcess.Platform;
+  const next: NodeJS.ProcessEnv = environment?.length ? { ...baseEnv } : baseEnv;
+  for (const variable of environment ?? []) {
     // An unresolved secret reference carries no value; the registry resolves it for the provider.
     if (typeof variable.value !== "string") continue;
+    if (platform === "win32") {
+      for (const key of Object.keys(next)) {
+        if (key !== variable.name && key.toUpperCase() === variable.name.toUpperCase())
+          delete next[key];
+      }
+    }
     next[variable.name] =
       variable.name === "CODEX_HOME" || variable.name === "CLAUDE_CONFIG_DIR"
         ? expandHomePath(variable.value, home)
         : variable.value;
   }
-  return next;
+  const host = yield* Effect.serviceOption(ProviderHost.ProviderHost);
+  return Option.isSome(host) && host.value.prepareAgentEnvironment !== undefined
+    ? yield* host.value.prepareAgentEnvironment(next)
+    : next;
 });
diff --git a/packages/source-control-core/src/server/PullRequestProvider.ts b/packages/source-control-core/src/server/PullRequestProvider.ts
index 900c675c4aea7..9469c9d4d4e8b 100644
--- a/packages/source-control-core/src/server/PullRequestProvider.ts
+++ b/packages/source-control-core/src/server/PullRequestProvider.ts
@@ -39,6 +39,7 @@ import type {
   SourceControlProviderKind,
 } from "@t3tools/contracts";
 import { SourceControlProviderKind as SourceControlProviderKindSchema } from "@t3tools/contracts";
+import { SourceControlPauseReason } from "./SourceControlRateLimit.ts";
 
 export class PullRequestProviderError extends Schema.TaggedError<PullRequestProviderError>()(
   "PullRequestProviderError",
@@ -54,6 +55,10 @@ export class PullRequestProviderError extends Schema.TaggedError<PullRequestProv
     ]),
     detail: Schema.String,
     retryAt: Schema.optional(Schema.Number),
+    pauseReason: Schema.optional(SourceControlPauseReason),
+    resource: Schema.optional(Schema.String),
+    remaining: Schema.optional(Schema.Finite),
+    limit: Schema.optional(Schema.Finite),
     /**
      * Why the host would not return a repository and what to change, in the reader's terms.
      * Shown beside that repository in the list; `detail` is about the failed call instead.
@@ -76,6 +81,10 @@ export interface PullRequestProviderFailure {
   readonly reason: PullRequestProviderError["reason"];
   readonly retryAt?: number | undefined;
   readonly accessHint?: string | undefined;
+  readonly pauseReason?: PullRequestProviderError["pauseReason"];
+  readonly resource?: string | undefined;
+  readonly remaining?: number | undefined;
+  readonly limit?: number | undefined;
 }
 
 export interface ProviderChangeRequest {
@@ -190,6 +199,8 @@ export interface ProviderChangeRequestStat {
 }
 
 export interface ProviderChangeRequestDetail extends ProviderChangeRequest {
+  /** When these fields were fetched, if the provider reuses a previous observation. */
+  readonly observedAt?: number;
   readonly maintainerCanModify?: boolean;
   readonly headSha?: string | null;
   readonly body: string;
@@ -365,7 +376,7 @@ export interface PullRequestProviderApi {
   readonly getChangeRequestChecks?: (
     input: ProviderRepositoryRef & { readonly number: number },
   ) => Effect.Effect<
-    Pick<PullRequestChecks, "state" | "checks" | "headSha">,
+    Pick<PullRequestChecks, "state" | "checks" | "headSha" | "observedAt">,
     PullRequestProviderError
   >;
 
diff --git a/packages/source-control-core/src/server/SourceControlRateLimit.test.ts b/packages/source-control-core/src/server/SourceControlRateLimit.test.ts
index fcfe33b6df9ae..6d854ff76f9fb 100644
--- a/packages/source-control-core/src/server/SourceControlRateLimit.test.ts
+++ b/packages/source-control-core/src/server/SourceControlRateLimit.test.ts
@@ -73,6 +73,19 @@ it.effect("keeps providers and hosts isolated", () =>
   }).pipe(Effect.provide(SourceControlRateLimit.layer)),
 );
 
+it.effect("isolates primary quota cooldowns within one host", () =>
+  Effect.gen(function* () {
+    const limits = yield* SourceControlRateLimit.SourceControlRateLimit;
+    const graphql = { ...github, resource: "graphql" };
+    const lease = yield* limits.check(graphql);
+    yield* limits.recordRateLimit({ ...graphql, lease });
+
+    yield* limits.check(github);
+    yield* limits.check({ ...github, resource: "core" });
+    assert.strictEqual((yield* Effect.flip(limits.check(graphql))).resource, "graphql");
+  }).pipe(Effect.provide(SourceControlRateLimit.layer)),
+);
+
 it.effect("does not let an older success clear a concurrent pause", () =>
   Effect.gen(function* () {
     const limits = yield* SourceControlRateLimit.SourceControlRateLimit;
diff --git a/packages/source-control-core/src/server/SourceControlRateLimit.ts b/packages/source-control-core/src/server/SourceControlRateLimit.ts
index fd1c4ab1e002a..6cb4310e8d393 100644
--- a/packages/source-control-core/src/server/SourceControlRateLimit.ts
+++ b/packages/source-control-core/src/server/SourceControlRateLimit.ts
@@ -13,6 +13,12 @@ import {
 const FALLBACK_COOLDOWN = Duration.seconds(30);
 const MAX_FALLBACK_COOLDOWN = Duration.minutes(15);
 
+export const SourceControlPauseReason = Schema.Literals([
+  "reserve-protected",
+  "quota-exhausted",
+  "rate-limited",
+]);
+
 export const CredentialScope = Context.Reference<string>(
   "@t3tools/source-control-core/server/SourceControlRateLimit/CredentialScope",
   {
@@ -20,7 +26,7 @@ export const CredentialScope = Context.Reference<string>(
   },
 );
 
-/** Interactive requests may use reserved quota and bypass pauses caused by background reads. */
+/** Interactive requests may use reserved quota; providers still enforce server cooldowns. */
 export const Interactive = Context.Reference<boolean>(
   "@t3tools/source-control-core/server/SourceControlRateLimit/Interactive",
   { defaultValue: () => false },
@@ -29,6 +35,7 @@ export const Interactive = Context.Reference<boolean>(
 interface RateLimitKey {
   readonly provider: SourceControlProviderKind;
   readonly host: string;
+  readonly resource?: string | undefined;
 }
 
 interface RateLimitLease extends RateLimitKey {
@@ -47,9 +54,19 @@ export class SourceControlRateLimitPausedError extends Schema.TaggedError<Source
     provider: SourceControlProviderKindSchema,
     host: Schema.String,
     retryAt: Schema.Number,
+    pauseReason: Schema.optional(SourceControlPauseReason),
+    resource: Schema.optional(Schema.String),
+    remaining: Schema.optional(Schema.Finite),
+    limit: Schema.optional(Schema.Finite),
   },
 ) {
   get detail(): string {
+    if (this.pauseReason === "reserve-protected") {
+      return `T3 paused background ${this.resource ?? "API"} reads to ${this.host} to protect the remaining quota${this.remaining === undefined ? "" : ` (${this.remaining}${this.limit === undefined ? "" : ` of ${this.limit}`} remaining)`}. Interactive actions can use the reserve.`;
+    }
+    if (this.pauseReason === "quota-exhausted") {
+      return `${this.provider} ${this.resource ?? "API"} quota for ${this.host} is exhausted. Requests resume when that quota resets.`;
+    }
     return `${this.provider} requests to ${this.host} are paused until the rate limit resets.`;
   }
 
@@ -66,19 +83,25 @@ export class SourceControlRateLimit extends Context.Service<
       options?: { readonly allowPaused: boolean },
     ) => Effect.Effect<number, SourceControlRateLimitPausedError>;
     readonly recordRateLimit: (
-      input: RateLimitLease & { readonly retryAt?: number | undefined },
+      input: RateLimitLease & {
+        readonly retryAt?: number | undefined;
+        readonly minimumCooldownMs?: number | undefined;
+      },
     ) => Effect.Effect<void>;
     readonly recordSuccess: (input: RateLimitLease) => Effect.Effect<void>;
   }
 >()("@t3tools/source-control-core/server/SourceControlRateLimit") {}
 
 function normalizedKey(key: RateLimitKey, scope: string): string {
-  return `${key.provider}\0${key.host.trim().toLowerCase()}\0${scope}`;
+  return `${key.provider}\0${key.host.trim().toLowerCase()}\0${scope}\0${key.resource ?? ""}`;
 }
 
-function fallbackCooldownMs(attempt: number): number {
+function fallbackCooldownMs(
+  attempt: number,
+  minimum = Duration.toMillis(FALLBACK_COOLDOWN),
+): number {
   return Math.min(
-    Duration.toMillis(FALLBACK_COOLDOWN) * 2 ** Math.max(0, attempt - 1),
+    Math.max(Duration.toMillis(FALLBACK_COOLDOWN), minimum) * 2 ** Math.max(0, attempt - 1),
     Duration.toMillis(MAX_FALLBACK_COOLDOWN),
   );
 }
@@ -110,6 +133,8 @@ export const make = Effect.gen(function* () {
         provider: input.provider,
         host: input.host.trim().toLowerCase(),
         retryAt: entry.retryAt,
+        pauseReason: input.resource === undefined ? "rate-limited" : "quota-exhausted",
+        ...(input.resource === undefined ? {} : { resource: input.resource }),
       });
     }
     return entry?.generation ?? 0;
@@ -140,7 +165,7 @@ export const make = Effect.gen(function* () {
       const proposedRetryAt =
         input.retryAt !== undefined && input.retryAt > now
           ? input.retryAt
-          : now + fallbackCooldownMs(attempt);
+          : now + fallbackCooldownMs(attempt, input.minimumCooldownMs);
       const retryAt =
         previous !== undefined && previous.retryAt > now
           ? Math.max(previous.retryAt, proposedRetryAt)
diff --git a/packages/source-control-github/src/server/GitHubPullRequestApi.test.ts b/packages/source-control-github/src/server/GitHubPullRequestApi.test.ts
index 1638a8d184414..3ea1c0a5bda2d 100644
--- a/packages/source-control-github/src/server/GitHubPullRequestApi.test.ts
+++ b/packages/source-control-github/src/server/GitHubPullRequestApi.test.ts
@@ -10,6 +10,7 @@ import * as Result from "effect/Result";
 import * as Schema from "effect/Schema";
 import * as TestClock from "effect/testing/TestClock";
 import * as Redacted from "effect/Redacted";
+import { SourceControlProviderKind } from "@t3tools/contracts";
 
 import { HttpClient, HttpClientResponse } from "effect/http";
 
@@ -559,6 +560,10 @@ const checkContextsPage = (
       repository: {
         pullRequest: {
           headRefOid,
+          headRefName: "feat/page",
+          headRepositoryOwner: { __typename: "User", login: "octocat" },
+          isCrossRepository: true,
+          state: "OPEN",
           commits: {
             nodes: [
               {
@@ -733,6 +738,62 @@ it.effect(
 );
 
 layer("GitHubPullRequestApi.layer", (it) => {
+  it.effect.each([false, true])(
+    "reads checks directly across pages without mixing heads (head changed: %s)",
+    (headChanged) =>
+      Effect.gen(function* () {
+        mockedExecute.mockReturnValueOnce(
+          Effect.succeed(
+            output(
+              checkContextsPage(
+                [checkRun({ name: "build", status: "COMPLETED", conclusion: "SUCCESS" })],
+                "next",
+              ),
+            ),
+          ),
+        );
+        mockedExecute.mockReturnValueOnce(
+          Effect.succeed(
+            output(
+              checkContextsPage(
+                [checkRun({ name: "tests", status: "COMPLETED", conclusion: "FAILURE" })],
+                null,
+                headChanged ? "def456" : "abc123",
+              ),
+            ),
+          ),
+        );
+        const api = yield* GitHubPullRequestApi.GitHubPullRequestApi;
+        if (headChanged) {
+          expect(yield* api.getPullRequestChecks(pullRequestInput).pipe(Effect.flip)).toMatchObject(
+            {
+              _tag: "GitHubPullRequestReadError",
+              operation: "getPullRequestChecks",
+            },
+          );
+        } else {
+          const result = yield* api.getPullRequestChecks(pullRequestInput);
+          expect(result).toMatchObject({
+            state: "open",
+            headSha: "abc123",
+            headBranch: "feat/page",
+            headRepositoryOwner: "octocat",
+            isCrossRepository: true,
+          });
+          expect(result.checks.map(({ name, status }) => ({ name, status }))).toEqual([
+            { name: "tests", status: "failure" },
+            { name: "build", status: "success" },
+          ]);
+        }
+        expect(variablesOf("PullRequestCore")).toHaveLength(0);
+        expect(variablesOf("PullRequestCheckContexts")).toEqual([
+          expect.objectContaining({ number: 7 }),
+          expect.objectContaining({ number: 7, after: "next" }),
+        ]);
+        expect(mockedExecute).toHaveBeenCalledTimes(2);
+      }),
+  );
+
   it.effect("turns maintainer edits off without rewriting the pull request's text", () =>
     Effect.gen(function* () {
       mockedExecute.mockImplementation((call) =>
@@ -3000,77 +3061,99 @@ layer("GitHubPullRequestApi.layer", (it) => {
     }),
   );
 
-  it.effect("verifies a REST-forbidden account through GraphQL with the pinned credential", () =>
-    Effect.gen(function* () {
-      const input = { cwd: "/w", host: "github.identity-fallback.test" };
-      const original = {
-        token: Redacted.make("original-token"),
-        fingerprint: `${input.host}:original`,
-      };
-      mockedCredential.mockReturnValue(Effect.succeed(original));
-      mockedExecute.mockImplementation((call) =>
-        Effect.gen(function* () {
-          expect(yield* SourceControlRateLimit.CredentialScope).toBe(original.fingerprint);
-          if (call.kind === "rest") {
-            expect(call.path).toBe("user");
-            expect(yield* GitHubRequestPolicy.PinnedGitHubCredential).toMatchObject({
-              host: input.host,
-              credentialFingerprint: original.fingerprint,
-            });
-            mockedCredential.mockReturnValue(
-              Effect.succeed({
-                token: Redacted.make("replacement-token"),
-                fingerprint: `${input.host}:replacement`,
-              }),
+  it.effect.each(["forbidden", "core-rate-limit", "core-paused"])(
+    "verifies a REST $0 account through GraphQL with the pinned credential",
+    (reason) =>
+      Effect.gen(function* () {
+        const input = { cwd: "/w", host: `github.identity-fallback-${reason}.test` };
+        const original = {
+          token: Redacted.make("original-token"),
+          fingerprint: `${input.host}:original`,
+        };
+        mockedCredential.mockReturnValue(Effect.succeed(original));
+        mockedExecute.mockImplementation((call) =>
+          Effect.gen(function* () {
+            expect(yield* SourceControlRateLimit.CredentialScope).toBe(original.fingerprint);
+            if (call.kind === "rest") {
+              expect(call.path).toBe("user");
+              expect(yield* GitHubRequestPolicy.PinnedGitHubCredential).toMatchObject({
+                host: input.host,
+                credentialFingerprint: original.fingerprint,
+              });
+              mockedCredential.mockReturnValue(
+                Effect.succeed({
+                  token: Redacted.make("replacement-token"),
+                  fingerprint: `${input.host}:replacement`,
+                }),
+              );
+              const context = {
+                host: input.host,
+                operation: "getRoutingIdentity",
+              };
+              if (reason === "core-rate-limit") {
+                return yield* new GitHubRequestPolicy.GitHubApiRateLimitError({
+                  ...context,
+                  resource: "core",
+                });
+              }
+              if (reason === "core-paused") {
+                return yield* new SourceControlRateLimit.SourceControlRateLimitPausedError({
+                  provider: SourceControlProviderKind.make("github"),
+                  host: input.host,
+                  resource: "core",
+                  pauseReason: "quota-exhausted",
+                  retryAt: Date.parse("2099-08-13T14:00:00Z"),
+                });
+              }
+              return yield* new GitHubRequestPolicy.GitHubApiResponseError({
+                ...context,
+                status: 403,
+                githubErrors: ["Resource not accessible by integration"],
+              });
+            }
+            expect(call.host).toBe(input.host);
+            expect(call.authorization).toBe("Bearer original-token");
+            expect(call.query).toMatch(/viewer\s*\{/);
+            expect(call.query).toContain("databaseId");
+            expect(call.query).toContain("login");
+            return output(
+              '{"data":{"viewer":{"databaseId":789,"login":"acme-app[bot]"}}}',
+              false,
+              false,
+              graphqlQuota(0),
             );
-            return yield* new GitHubRequestPolicy.GitHubApiResponseError({
-              host: input.host,
-              operation: "getRoutingIdentity",
-              status: 403,
-              githubErrors: ["Resource not accessible by integration"],
-            });
-          }
-          expect(call.host).toBe(input.host);
-          expect(call.authorization).toBe("Bearer original-token");
-          expect(call.query).toMatch(/viewer\s*\{/);
-          expect(call.query).toContain("databaseId");
-          expect(call.query).toContain("login");
-          return output(
-            '{"data":{"viewer":{"databaseId":789,"login":"acme-app[bot]"}}}',
-            false,
-            false,
-            graphqlQuota(0),
-          );
-        }),
-      );
-      const cli = yield* GitHubPullRequestApi.GitHubPullRequestApi;
-      const quota = yield* GitHubQuota.GitHubQuota;
-      yield* quota
-        .observe(input.host, graphqlQuota(1))
-        .pipe(Effect.provideService(SourceControlRateLimit.CredentialScope, original.fingerprint));
-      const identity = { accountId: "789", viewer: "acme-app[bot]" };
-      expect(yield* cli.getRoutingIdentity(input)).toEqual(identity);
-
-      mockedCredential.mockReturnValue(Effect.succeed(original));
-      expect(yield* cli.getRoutingIdentity(input)).toEqual(identity);
-      expect(mockedExecute).toHaveBeenCalledTimes(2);
-
-      const exhausted = yield* quota
-        .admit(input.host, "graphql")
-        .pipe(
-          Effect.provideService(SourceControlRateLimit.CredentialScope, original.fingerprint),
-          Effect.flip,
-        );
-      expect(exhausted._tag).toBe("SourceControlRateLimitPausedError");
-      yield* quota
-        .admit(input.host, "graphql")
-        .pipe(
-          Effect.provideService(
-            SourceControlRateLimit.CredentialScope,
-            `${input.host}:replacement`,
-          ),
+          }),
         );
-    }),
+        const cli = yield* GitHubPullRequestApi.GitHubPullRequestApi;
+        const quota = yield* GitHubQuota.GitHubQuota;
+        yield* quota
+          .observe(input.host, graphqlQuota(1))
+          .pipe(
+            Effect.provideService(SourceControlRateLimit.CredentialScope, original.fingerprint),
+          );
+        const identity = { accountId: "789", viewer: "acme-app[bot]" };
+        expect(yield* cli.getRoutingIdentity(input)).toEqual(identity);
+
+        mockedCredential.mockReturnValue(Effect.succeed(original));
+        expect(yield* cli.getRoutingIdentity(input)).toEqual(identity);
+        expect(mockedExecute).toHaveBeenCalledTimes(2);
+
+        const exhausted = yield* quota
+          .admit(input.host, "graphql")
+          .pipe(
+            Effect.provideService(SourceControlRateLimit.CredentialScope, original.fingerprint),
+            Effect.flip,
+          );
+        expect(exhausted._tag).toBe("SourceControlRateLimitPausedError");
+        yield* quota
+          .admit(input.host, "graphql")
+          .pipe(
+            Effect.provideService(
+              SourceControlRateLimit.CredentialScope,
+              `${input.host}:replacement`,
+            ),
+          );
+      }),
   );
 
   it.effect("rejects a null GraphQL account id without caching it", () =>
@@ -3112,6 +3195,16 @@ layer("GitHubPullRequestApi.layer", (it) => {
       operation: "getRoutingIdentity",
       status: 500,
     }),
+    new GitHubRequestPolicy.GitHubApiRateLimitError({
+      host: "github.identity-secondary-error.test",
+      operation: "getRoutingIdentity",
+    }),
+    new SourceControlRateLimit.SourceControlRateLimitPausedError({
+      provider: SourceControlProviderKind.make("github"),
+      host: "github.identity-secondary-paused.test",
+      pauseReason: "rate-limited",
+      retryAt: Date.parse("2099-08-13T14:00:00Z"),
+    }),
   ])("preserves $_tag from REST identity verification without trying GraphQL", (error) =>
     Effect.gen(function* () {
       mockedExecute.mockReturnValue(Effect.fail(error));
diff --git a/packages/source-control-github/src/server/GitHubPullRequestApi.ts b/packages/source-control-github/src/server/GitHubPullRequestApi.ts
index 8241fba5d6951..a6e6e056d69ba 100644
--- a/packages/source-control-github/src/server/GitHubPullRequestApi.ts
+++ b/packages/source-control-github/src/server/GitHubPullRequestApi.ts
@@ -478,6 +478,19 @@ export class GitHubPullRequestApi extends Context.Service<
     readonly getCheckFailure: Effect.Success<typeof makeGitHubCheckFailureReader>;
     readonly revalidateChecks: Effect.Success<typeof makeChecksRevalidator>;
 
+    readonly getPullRequestChecks: (input: {
+      readonly cwd: string;
+      readonly repository: string;
+      readonly host: string;
+      readonly number: number;
+    }) => Effect.Effect<
+      Pick<
+        GitHubPullRequestCore,
+        "state" | "checks" | "headSha" | "headBranch" | "headRepositoryOwner" | "isCrossRepository"
+      >,
+      GitHubPullRequestApiError
+    >;
+
     readonly getPullRequestDetail: (input: {
       readonly cwd: string;
       readonly repository: string;
@@ -949,6 +962,22 @@ export const make = Effect.gen(function* () {
               const cached = routingIdentities.get(key);
               if (cached !== undefined && now - cached.at < 10 * 60_000)
                 return { ...credential, ...cached.value };
+              const viewerIdentity = client.RoutingIdentityViewer({}).pipe(
+                GitHubGraphQlClient.call({
+                  host,
+                  operation: "getRoutingIdentity",
+                  allowReserve: true,
+                }),
+                Effect.catchTags({
+                  GraphQLClientError: () => Effect.fail(unavailable()),
+                }),
+                Effect.flatMap(({ viewer }) =>
+                  decodeViewerIdentity({
+                    id: viewer.databaseId,
+                    login: viewer.login,
+                  }).pipe(Effect.mapError(unavailable)),
+                ),
+              );
               // Pin verification so an auth switch cannot poison its cache entry.
               const identity = yield* api
                 .rest({ host, operation: "getRoutingIdentity", path: "user", allowReserve: true })
@@ -957,24 +986,16 @@ export const make = Effect.gen(function* () {
                     decodeRoutingIdentity(response.body).pipe(Effect.mapError(unavailable)),
                   ),
                   Effect.catchTags({
-                    // The enclosing operation owns the span for this inline handler.
-                    GitHubApiResponseError: Effect.fnUntraced(function* (error) {
-                      if (error.status !== 403) return yield* error;
-                      const { viewer } = yield* client.RoutingIdentityViewer({}).pipe(
-                        GitHubGraphQlClient.call({
-                          host,
-                          operation: "getRoutingIdentity",
-                          allowReserve: true,
-                        }),
-                        Effect.catchTags({
-                          GraphQLClientError: () => Effect.fail(unavailable()),
-                        }),
-                      );
-                      return yield* decodeViewerIdentity({
-                        id: viewer.databaseId,
-                        login: viewer.login,
-                      }).pipe(Effect.mapError(unavailable));
-                    }),
+                    GitHubApiResponseError: (error) =>
+                      error.status === 403 ? viewerIdentity : Effect.fail(error),
+                    GitHubApiRateLimitError: (error) =>
+                      error.resource === "core" ? viewerIdentity : Effect.fail(error),
+                    SourceControlRateLimitPausedError: (error) =>
+                      error.resource === "core" &&
+                      (error.pauseReason === "quota-exhausted" ||
+                        error.pauseReason === "reserve-protected")
+                        ? viewerIdentity
+                        : Effect.fail(error),
                   }),
                   Effect.provideService(GitHubRequestPolicy.PinnedGitHubCredential, credential),
                   Effect.provideService(SourceControlRateLimit.CredentialScope, key),
@@ -1381,9 +1402,10 @@ export const make = Effect.gen(function* () {
   const readAllCheckContexts = Effect.fn("GitHubPullRequestApi.readAllCheckContexts")(function* (
     input: Parameters<GitHubPullRequestApi["Service"]["getPullRequestDetail"]>[0],
     allowReserve: boolean,
+    operation = "getPullRequestDetail",
   ) {
     const { owner, name } = parseRepositorySelector(input.repository);
-    const target = { ...input, operation: "getPullRequestDetail", allowReserve };
+    const target = { ...input, operation, allowReserve };
     let headSha: string | null = null;
     const { pages, truncated } = yield* readPages(
       GraphQLClient.pages(client.PullRequestCheckContexts, {
@@ -1405,7 +1427,7 @@ export const make = Effect.gen(function* () {
             ? Effect.fail(
                 readError(
                   input.cwd,
-                  "getPullRequestDetail",
+                  operation,
                   new Error("Pull request head changed while reading checks."),
                 ),
               )
@@ -1418,13 +1440,43 @@ export const make = Effect.gen(function* () {
         hasNextPage: (page) => page.nextCursor !== null,
       },
     ).pipe(graphql(target));
+    const first = yield* found(target)(pages[0] ?? null);
     return {
-      headSha: pages[0]?.headSha ?? null,
+      headSha: first.headSha,
+      headBranch: first.headBranch,
+      headRepositoryOwner: first.headRepositoryOwner,
+      isCrossRepository: first.isCrossRepository,
+      state: first.state,
       contexts: pages.flatMap((page) => page.contexts),
       truncated,
     };
   });
 
+  const getPullRequestChecks: GitHubPullRequestApi["Service"]["getPullRequestChecks"] = Effect.fn(
+    "GitHubPullRequestApi.getPullRequestChecks",
+  )(function* (input) {
+    const all = yield* readAllCheckContexts(
+      input,
+      yield* SourceControlRateLimit.Interactive,
+      "getPullRequestChecks",
+    );
+    if (all.truncated) {
+      return yield* readError(
+        input.cwd,
+        "getPullRequestChecks",
+        new Error("Pull request checks were truncated."),
+      );
+    }
+    return {
+      state: all.state,
+      headSha: all.headSha,
+      headBranch: all.headBranch,
+      headRepositoryOwner: all.headRepositoryOwner,
+      isCrossRepository: all.isCrossRepository,
+      checks: pullRequestChecksFromContexts(all.contexts).checks,
+    };
+  });
+
   const getPullRequestDetail: GitHubPullRequestApi["Service"]["getPullRequestDetail"] = (input) => {
     const { owner, name } = parseRepositorySelector(input.repository);
     const operation = "getPullRequestDetail";
@@ -1979,6 +2031,7 @@ export const make = Effect.gen(function* () {
     getPullRequestSummary,
     getPullRequestWatchFingerprint,
 
+    getPullRequestChecks,
     getPullRequestDetail,
     getPullRequestPreview: Effect.fn("GitHubPullRequestApi.getPullRequestPreview")(
       function (input) {
diff --git a/packages/source-control-github/src/server/GitHubPullRequestProvider.test.ts b/packages/source-control-github/src/server/GitHubPullRequestProvider.test.ts
index 61a32ebc79977..6e602e1025d32 100644
--- a/packages/source-control-github/src/server/GitHubPullRequestProvider.test.ts
+++ b/packages/source-control-github/src/server/GitHubPullRequestProvider.test.ts
@@ -1,5 +1,7 @@
 import { describe, expect, it } from "@effect/vitest";
 import * as Effect from "effect/Effect";
+import * as Deferred from "effect/Deferred";
+import * as Fiber from "effect/Fiber";
 import * as Layer from "effect/Layer";
 import * as Redacted from "effect/Redacted";
 import * as TestClock from "effect/testing/TestClock";
@@ -69,6 +71,53 @@ it.effect("maps credential verification failures without relabeling operation fa
   }),
 );
 
+it.effect("polls checks without loading pull request details and keeps fork approval gates", () =>
+  Effect.gen(function* () {
+    const provider = yield* make.pipe(
+      Effect.provide(
+        Layer.mock(GitHubPullRequestApi.GitHubPullRequestApi)({
+          revalidateChecks: (_input, read) => read,
+          getPullRequestDetail: () => Effect.die("Checks must not fetch the full pull request"),
+          getPullRequestChecks: () =>
+            Effect.succeed({
+              state: "open",
+              headSha: "abc123",
+              headBranch: "contribution",
+              headRepositoryOwner: "octocat",
+              isCrossRepository: true,
+              checks: [{ name: "build", status: "success", description: null, url: null }],
+            }),
+          listWorkflowRunsRequiringApproval: () =>
+            Effect.succeed([
+              {
+                id: 123,
+                name: "contributor tests",
+                url: "https://github.com/acme/web/actions/runs/123",
+              },
+            ]),
+        }),
+      ),
+    );
+    const read = provider.getChangeRequestChecks;
+    if (read === undefined) return yield* Effect.die("checks read missing");
+    expect(
+      yield* read({ cwd: "/w", host: "github.com", repository: "acme/web", number: 7 }),
+    ).toEqual({
+      state: "open",
+      headSha: "abc123",
+      checks: [
+        { name: "build", status: "success", description: null, url: null },
+        {
+          name: "contributor tests",
+          status: "action-required",
+          description: "A maintainer must approve this workflow before it can run.",
+          url: "https://github.com/acme/web/actions/runs/123",
+        },
+      ],
+    });
+  }),
+);
+
 it.effect("advertises standalone branch deletion for source repository writers", () =>
   Effect.gen(function* () {
     let action: string | undefined;
@@ -336,6 +385,23 @@ describe("gitHubViewerPermissions", () => {
       Effect.provide(
         Layer.mock(GitHubPullRequestApi.GitHubPullRequestApi)({
           revalidateChecks: (_input, read) => read,
+          getPullRequestChecks: () =>
+            Effect.succeed({
+              state: "open",
+              headSha: "abc123",
+              headBranch: "feat/page",
+              headRepositoryOwner: "octocat",
+              isCrossRepository: true,
+              checks: [
+                {
+                  name: "manual gate",
+                  status: "action-required",
+                  description: null,
+                  url: "https://example.com/manual-gate",
+                },
+                { name: "build", status: "success", description: null, url: null },
+              ],
+            }),
           getPullRequestDetail: () =>
             Effect.succeed({
               ...coreFields,
@@ -431,6 +497,165 @@ const openDetail = {
   commits: [],
 };
 
+const pinned = <A, E>(read: Effect.Effect<A, E>, fingerprint = "first", host = "github.com") =>
+  read.pipe(
+    Effect.provideService(GitHubRequestPolicy.PinnedGitHubCredential, {
+      host,
+      token: Redacted.make(`token-${fingerprint}`),
+      credentialFingerprint: fingerprint,
+    }),
+  );
+
+it.effect("shares pinned PR observations across worktrees without extending their age", () =>
+  Effect.gen(function* () {
+    yield* TestClock.setTime(1_000);
+    const entered = yield* Deferred.make<void>();
+    const release = yield* Deferred.make<void>();
+    let detailReads = 0;
+    let checksReads = 0;
+    let headSha = "old";
+    const provider = yield* make.pipe(
+      Effect.provide(
+        Layer.mock(GitHubPullRequestApi.GitHubPullRequestApi)({
+          revalidateChecks: (_input, read) => read,
+          getPullRequestDetail: () =>
+            Effect.gen(function* () {
+              detailReads++;
+              const result = { ...openDetail, isCrossRepository: false, headSha };
+              if (detailReads === 1) {
+                yield* Deferred.succeed(entered, undefined);
+                yield* Deferred.await(release);
+              }
+              return result;
+            }),
+          getPullRequestChecks: () =>
+            Effect.sync(() => {
+              checksReads++;
+              return { ...openDetail, isCrossRepository: false, headSha };
+            }),
+        }),
+      ),
+    );
+    const checks = provider.getChangeRequestChecks;
+    if (checks === undefined) return yield* Effect.die("checks missing");
+    const input = { cwd: "/first", host: "github.com", repository: "acme/web", number: 7 };
+    const detail = yield* Effect.forkChild(pinned(provider.getChangeRequest(input)), {
+      startImmediately: true,
+    });
+    yield* Deferred.await(entered);
+    const readers = yield* Effect.forkChild(
+      Effect.all(
+        Array.from({ length: 8 }, (_, index) =>
+          pinned(checks({ ...input, cwd: `/worktree-${index}` })),
+        ),
+        { concurrency: "unbounded" },
+      ),
+      { startImmediately: true },
+    );
+    yield* Deferred.succeed(release, undefined);
+    const first = yield* Fiber.join(detail);
+    const results = yield* Fiber.join(readers);
+    expect(first).toMatchObject({ headSha: "old", observedAt: 1_000 });
+    expect(results).toEqual(
+      Array.from({ length: 8 }, () => ({
+        state: "open",
+        checks: [],
+        headSha: "old",
+        observedAt: 1_000,
+      })),
+    );
+    expect({ detailReads, checksReads }).toEqual({ detailReads: 1, checksReads: 0 });
+    yield* TestClock.adjust("16 seconds");
+    expect(yield* pinned(provider.getChangeRequest({ ...input, cwd: "/second" }))).toMatchObject({
+      observedAt: 1_000,
+    });
+    headSha = "new";
+    yield* TestClock.adjust("30 seconds");
+    expect(yield* pinned(checks(input))).toMatchObject({ headSha: "new", observedAt: 47_000 });
+    expect({ detailReads, checksReads }).toEqual({ detailReads: 1, checksReads: 1 });
+    yield* pinned(provider.getChangeRequest(input));
+    yield* pinned(provider.getChangeRequest(input), "second");
+    yield* provider.getChangeRequest(input);
+    yield* provider.getChangeRequest(input);
+    const enterprise = { ...input, host: "github.acme.com" };
+    yield* pinned(provider.getChangeRequest(enterprise));
+    yield* pinned(provider.getChangeRequest(enterprise));
+    yield* pinned(provider.getChangeRequest(enterprise), "first", enterprise.host);
+    yield* pinned(provider.getChangeRequest(enterprise), "first", enterprise.host);
+    expect(detailReads).toBe(8);
+  }),
+);
+
+it.effect(
+  "detaches reads before and after a failed mutation, including reads still in flight",
+  () =>
+    Effect.gen(function* () {
+      const oldReadEntered = yield* Deferred.make<void>();
+      const releaseOldRead = yield* Deferred.make<void>();
+      const writeEntered = yield* Deferred.make<void>();
+      const releaseWrite = yield* Deferred.make<void>();
+      let headSha = "before";
+      let reads = 0;
+      const provider = yield* make.pipe(
+        Effect.provide(
+          Layer.mock(GitHubPullRequestApi.GitHubPullRequestApi)({
+            getPullRequestDetail: () =>
+              Effect.gen(function* () {
+                reads++;
+                const result = { ...openDetail, isCrossRepository: false, headSha };
+                if (reads === 1) {
+                  yield* Deferred.succeed(oldReadEntered, undefined);
+                  yield* Deferred.await(releaseOldRead);
+                }
+                return result;
+              }),
+            runPullRequestAction: () =>
+              Effect.gen(function* () {
+                headSha = "during";
+                yield* Deferred.succeed(writeEntered, undefined);
+                yield* Deferred.await(releaseWrite);
+                headSha = "after";
+                return yield* new GitHubRequestPolicy.GitHubApiResponseError({
+                  host: "github.com",
+                  operation: "runPullRequestAction",
+                  status: 502,
+                });
+              }),
+          }),
+        ),
+      );
+      const input = { cwd: "/first", host: "github.com", repository: "acme/web", number: 7 };
+      const oldRead = yield* Effect.forkChild(pinned(provider.getChangeRequest(input)), {
+        startImmediately: true,
+      });
+      yield* Deferred.await(oldReadEntered);
+      const write = yield* Effect.forkChild(
+        pinned(provider.runAction({ ...input, action: "update-branch" })).pipe(Effect.exit),
+        { startImmediately: true },
+      );
+      yield* Deferred.await(writeEntered);
+      const during = yield* Effect.forkChild(
+        pinned(provider.getChangeRequest({ ...input, cwd: "/second" })),
+        { startImmediately: true },
+      );
+      // Release the old lookup after the new reader has had to choose its cache entry.
+      yield* Deferred.succeed(releaseOldRead, undefined);
+      expect(yield* Fiber.join(during)).toMatchObject({ headSha: "during" });
+      yield* Deferred.succeed(releaseWrite, undefined);
+      expect((yield* Fiber.join(write))._tag).toBe("Failure");
+      expect(yield* pinned(provider.getChangeRequest(input))).toMatchObject({ headSha: "after" });
+      expect(yield* Fiber.join(oldRead)).toMatchObject({ headSha: "before" });
+      expect(yield* pinned(provider.getChangeRequest(input))).toMatchObject({ headSha: "after" });
+      expect(reads).toBe(3);
+      const forget = provider.forgetChangeRequestReads;
+      if (forget === undefined) return yield* Effect.die("invalidation missing");
+      headSha = "pushed";
+      yield* forget({ repository: input.repository, number: input.number });
+      expect(yield* pinned(provider.getChangeRequest(input))).toMatchObject({ headSha: "pushed" });
+      expect(reads).toBe(4);
+    }),
+);
+
 it.effect("does not classify same-repository gates as fork workflow approvals", () =>
   Effect.gen(function* () {
     const provider = yield* make;
diff --git a/packages/source-control-github/src/server/GitHubPullRequestProvider.ts b/packages/source-control-github/src/server/GitHubPullRequestProvider.ts
index 2f4cd1d761d55..76e9acc88eaf3 100644
--- a/packages/source-control-github/src/server/GitHubPullRequestProvider.ts
+++ b/packages/source-control-github/src/server/GitHubPullRequestProvider.ts
@@ -1,11 +1,14 @@
 import { SourceControlProviderKind } from "@t3tools/contracts";
 import { removeAgentCredits } from "@t3tools/source-control-core/server/mergeMessage";
+import { normalizeHost } from "@t3tools/source-control-core/server/pullRequestUtils";
 import * as Cache from "effect/Cache";
+import * as Clock from "effect/Clock";
 import * as Duration from "effect/Duration";
 import * as Equal from "effect/Equal";
 import * as Exit from "effect/Exit";
 import * as Hash from "effect/Hash";
 import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
 import type {
   PullRequestActor,
   PullRequestCapabilities,
@@ -16,6 +19,7 @@ import type {
 
 import * as SourceControlRateLimit from "@t3tools/source-control-core/server/SourceControlRateLimit";
 import * as GitHubPullRequestApi from "./GitHubPullRequestApi.ts";
+import * as GitHubRequestPolicy from "./GitHubRequestPolicy.ts";
 import {
   PullRequestProviderError,
   type PullRequestProviderFailure,
@@ -26,6 +30,7 @@ import {
 } from "@t3tools/source-control-core/server/PullRequestProvider";
 import type { GitHubCredentialSource } from "./GitHubCredentials.ts";
 import type {
+  GitHubPullRequestCore,
   GitHubRepositoryAccess,
   GitHubViewerAccess,
   GitHubWorkflowRunApproval,
@@ -117,9 +122,18 @@ function gitHubProviderFailure(
       return {
         reason: "rate-limited",
         ...(error.retryAt === undefined ? {} : { retryAt: error.retryAt }),
+        pauseReason: error.resource === undefined ? "rate-limited" : "quota-exhausted",
+        ...(error.resource === undefined ? {} : { resource: error.resource }),
       };
     case "SourceControlRateLimitPausedError":
-      return { reason: "rate-limited", retryAt: error.retryAt };
+      return {
+        reason: "rate-limited",
+        retryAt: error.retryAt,
+        ...(error.pauseReason === undefined ? {} : { pauseReason: error.pauseReason }),
+        ...(error.resource === undefined ? {} : { resource: error.resource }),
+        ...(error.remaining === undefined ? {} : { remaining: error.remaining }),
+        ...(error.limit === undefined ? {} : { limit: error.limit }),
+      };
     case "GitHubApiNotFoundError":
       return error.credential === undefined || error.credential === "app"
         ? { reason: "not-found" }
@@ -219,11 +233,48 @@ class SearchCoverage {
   }
 }
 
+const PULL_REQUEST_READ_TTL = Duration.seconds(45);
+const PULL_REQUEST_READ_CAPACITY = 128;
+type PullRequestRef = ProviderRepositoryRef & { readonly number: number };
+type Observed<A> = A & { readonly observedAt: number };
+
+/** The exact pinned token sees the same PR from every checkout; unpinned reads never share. */
+class PullRequestRead<A> {
+  readonly key: string;
+  readonly repository: string;
+  readonly number: number;
+  readonly lookup: Effect.Effect<A, GitHubPullRequestApi.GitHubPullRequestApiError>;
+
+  constructor(
+    input: PullRequestRef,
+    fingerprint: string,
+    lookup: Effect.Effect<A, GitHubPullRequestApi.GitHubPullRequestApiError>,
+  ) {
+    this.repository = input.repository.trim().toLowerCase();
+    this.number = input.number;
+    this.lookup = lookup;
+    this.key = JSON.stringify([
+      fingerprint,
+      normalizeHost(input.host),
+      this.repository,
+      this.number,
+    ]);
+  }
+
+  [Equal.symbol](that: unknown): boolean {
+    return that instanceof PullRequestRead && that.key === this.key;
+  }
+  [Hash.symbol](): number {
+    return Hash.string(this.key);
+  }
+}
+
 const rendersEmpty = (body: string): boolean =>
   body.replace(/<!--[\s\S]*?-->/g, "").trim().length === 0;
 
 export const make = Effect.gen(function* () {
   const cli = yield* GitHubPullRequestApi.GitHubPullRequestApi;
+  const clock = yield* Clock.Clock;
 
   // GitHub does not index every repository for search: a renamed one answers for its old name
   // with silence rather than with an error. Where search has any pull request for a repository it
@@ -290,8 +341,16 @@ export const make = Effect.gen(function* () {
       cause: error,
     });
 
-  const readChecks = (input: ProviderRepositoryRef & { readonly number: number }) =>
-    cli.getPullRequestDetail(input).pipe(
+  const withWorkflowChecks = <
+    A extends Pick<
+      GitHubPullRequestCore,
+      "state" | "checks" | "headSha" | "headBranch" | "headRepositoryOwner" | "isCrossRepository"
+    >,
+  >(
+    input: ProviderRepositoryRef & { readonly number: number },
+    read: Effect.Effect<A, GitHubPullRequestApi.GitHubPullRequestApiError>,
+  ) =>
+    read.pipe(
       Effect.flatMap((pullRequest) =>
         (pullRequest.state !== "open" || pullRequest.isCrossRepository !== true
           ? Effect.succeed({
@@ -327,7 +386,6 @@ export const make = Effect.gen(function* () {
         ).pipe(
           Effect.map((workflowApprovals) => ({
             ...pullRequest,
-            author: withAvatar(pullRequest.author, new Map(), input.host),
             checks: withWorkflowApprovals(
               pullRequest.checks,
               workflowApprovals.runs,
@@ -341,6 +399,131 @@ export const make = Effect.gen(function* () {
       ),
     );
 
+  const observe = Effect.fnUntraced(function* <A>(
+    read: Effect.Effect<A, GitHubPullRequestApi.GitHubPullRequestApiError>,
+  ) {
+    const observedAt = yield* Clock.currentTimeMillis;
+    return { ...(yield* read), observedAt };
+  });
+  const sharedReadTtl = <A extends { readonly observedAt: number }>(
+    exit: Exit.Exit<A, GitHubPullRequestApi.GitHubPullRequestApiError>,
+  ) =>
+    Exit.isSuccess(exit)
+      ? Duration.millis(
+          Math.max(
+            0,
+            exit.value.observedAt +
+              Duration.toMillis(PULL_REQUEST_READ_TTL) -
+              clock.currentTimeMillisUnsafe(),
+          ),
+        )
+      : Duration.zero;
+  const detailRequest = (input: PullRequestRef, fingerprint: string) =>
+    new PullRequestRead(
+      input,
+      fingerprint,
+      observe(withWorkflowChecks(input, cli.getPullRequestDetail(input))),
+    );
+  type DetailObservation = Effect.Success<ReturnType<typeof detailRequest>["lookup"]>;
+  const details = yield* Cache.makeWith(
+    (request: PullRequestRead<DetailObservation>) => request.lookup,
+    {
+      capacity: PULL_REQUEST_READ_CAPACITY,
+      timeToLive: sharedReadTtl,
+    },
+  );
+  const readChecks = (input: PullRequestRef) =>
+    cli.revalidateChecks(input, withWorkflowChecks(input, cli.getPullRequestChecks(input)));
+  type ChecksObservation = Observed<Effect.Success<ReturnType<typeof readChecks>>>;
+  const checkReads = yield* Cache.makeWith(
+    (request: PullRequestRead<ChecksObservation>) => request.lookup,
+    {
+      capacity: PULL_REQUEST_READ_CAPACITY,
+      timeToLive: sharedReadTtl,
+    },
+  );
+  const pinnedFingerprint = Effect.fnUntraced(function* (input: PullRequestRef) {
+    const credential = yield* GitHubRequestPolicy.PinnedGitHubCredential;
+    return credential !== null &&
+      normalizeHost(credential.host) === normalizeHost(input.host) &&
+      credential.credentialFingerprint.length > 0
+      ? credential.credentialFingerprint
+      : null;
+  });
+  const readSharedDetail = Effect.fn("GitHubPullRequestProvider.readSharedDetail")(function* (
+    input: PullRequestRef,
+  ) {
+    const fingerprint = yield* pinnedFingerprint(input);
+    return fingerprint === null
+      ? yield* withWorkflowChecks(input, cli.getPullRequestDetail(input))
+      : yield* Cache.get(details, detailRequest(input, fingerprint));
+  });
+  const readSharedChecks = Effect.fn("GitHubPullRequestProvider.readSharedChecks")(function* (
+    input: PullRequestRef,
+  ) {
+    const fingerprint = yield* pinnedFingerprint(input);
+    if (fingerprint === null) return yield* readChecks(input);
+    return yield* Cache.get(
+      checkReads,
+      new PullRequestRead<ChecksObservation>(
+        input,
+        fingerprint,
+        Effect.gen(function* () {
+          const detail = yield* Cache.getOption(details, detailRequest(input, fingerprint)).pipe(
+            Effect.orElseSucceed(() => Option.none<DetailObservation>()),
+          );
+          if (Option.isNone(detail)) return yield* observe(readChecks(input));
+          return {
+            state: detail.value.state,
+            checks: detail.value.checks,
+            ...(detail.value.headSha == null ? {} : { headSha: detail.value.headSha }),
+            observedAt: detail.value.observedAt,
+          };
+        }),
+      ),
+    );
+  });
+  type ReadScope = Parameters<NonNullable<PullRequestProviderApi["forgetChangeRequestReads"]>>[0];
+  const forgetCache = <A>(
+    cache: Cache.Cache<PullRequestRead<A>, A, GitHubPullRequestApi.GitHubPullRequestApiError>,
+    scope: ReadScope,
+  ) =>
+    Cache.keys(cache).pipe(
+      Effect.flatMap((keys) =>
+        Effect.forEach(
+          Array.from(keys).filter(
+            (key) =>
+              scope === undefined ||
+              (key.repository === scope.repository.trim().toLowerCase() &&
+                (scope.number === undefined || key.number === scope.number)),
+          ),
+          (key) => Cache.invalidate(cache, key),
+          { discard: true },
+        ),
+      ),
+    );
+  const forgetChangeRequestReads = Effect.fn("GitHubPullRequestProvider.forgetChangeRequestReads")(
+    function* (scope?: ReadScope) {
+      // Removing an entry detaches its in-flight lookup too; completion cannot put it back.
+      yield* forgetCache(details, scope);
+      yield* forgetCache(checkReads, scope);
+    },
+  );
+  const writing =
+    <I extends PullRequestRef, A, E>(write: (input: I) => Effect.Effect<A, E>) =>
+    (input: I) => {
+      const invalidate = forgetChangeRequestReads({
+        repository: input.repository,
+        ...("stackNumber" in input && input.stackNumber !== undefined
+          ? {}
+          : { number: input.number }),
+      });
+      return invalidate.pipe(
+        Effect.andThen(() => write(input)),
+        Effect.ensuring(invalidate),
+      );
+    };
+
   const provider: PullRequestProviderApi = {
     kind: SourceControlProviderKind.make("github"),
     capabilities: CAPABILITIES,
@@ -447,17 +630,18 @@ export const make = Effect.gen(function* () {
       cli.getCheckFailure(input).pipe(Effect.mapError(fail("getChangeRequestCheckFailure"))),
 
     getChangeRequestChecks: (input) =>
-      cli.revalidateChecks(input, readChecks(input)).pipe(
-        Effect.map(({ state, checks, headSha }) => ({
-          state,
-          checks,
-          ...(headSha == null ? {} : { headSha }),
+      readSharedChecks(input).pipe(
+        Effect.map((value) => ({
+          ...("observedAt" in value ? { observedAt: value.observedAt } : {}),
+          state: value.state,
+          checks: value.checks,
+          ...(value.headSha == null ? {} : { headSha: value.headSha }),
         })),
         Effect.mapError(fail("getChangeRequestChecks")),
       ),
 
     getChangeRequest: (input) =>
-      readChecks(input).pipe(
+      readSharedDetail(input).pipe(
         Effect.map((pullRequest): ProviderChangeRequestDetail => ({
           ...pullRequest,
           author: withAvatar(pullRequest.author, new Map<string, string>(), input.host),
@@ -490,6 +674,8 @@ export const make = Effect.gen(function* () {
         Effect.mapError(fail("getChangeRequest")),
       ),
 
+    forgetChangeRequestReads,
+
     getChangeRequestActivity: (input) =>
       Effect.all(
         [
@@ -632,7 +818,7 @@ export const make = Effect.gen(function* () {
     listReviewerCandidates: (input) =>
       cli.listReviewerCandidates(input).pipe(Effect.mapError(fail("listReviewerCandidates"))),
 
-    setReviewerRequest: (input) =>
+    setReviewerRequest: writing((input) =>
       cli
         .setReviewerRequest({
           cwd: input.cwd,
@@ -643,6 +829,7 @@ export const make = Effect.gen(function* () {
           requested: input.requested,
         })
         .pipe(Effect.mapError(fail("setReviewerRequest"))),
+    ),
 
     listLabelCandidates: (input) =>
       cli.listLabelCandidates(input).pipe(Effect.mapError(fail("listLabelCandidates"))),
@@ -653,7 +840,7 @@ export const make = Effect.gen(function* () {
     searchRepositoryAuthors: (input) =>
       cli.searchRepositoryAuthors(input).pipe(Effect.mapError(fail("searchRepositoryAuthors"))),
 
-    setLabels: (input) =>
+    setLabels: writing((input) =>
       cli
         .setLabels({
           cwd: input.cwd,
@@ -664,8 +851,9 @@ export const make = Effect.gen(function* () {
           applied: input.applied,
         })
         .pipe(Effect.mapError(fail("setLabels"))),
+    ),
 
-    runAction: (input) =>
+    runAction: writing((input) =>
       cli
         .runPullRequestAction({
           cwd: input.cwd,
@@ -682,8 +870,9 @@ export const make = Effect.gen(function* () {
           ...(input.updateMethod === undefined ? {} : { updateMethod: input.updateMethod }),
         })
         .pipe(Effect.mapError(fail("runAction"))),
+    ),
 
-    updateChangeRequest: (input) =>
+    updateChangeRequest: writing((input) =>
       cli
         .updatePullRequest({
           ...(input.maintainerCanModify === undefined
@@ -697,10 +886,13 @@ export const make = Effect.gen(function* () {
           ...(input.body === undefined ? {} : { body: input.body }),
         })
         .pipe(Effect.mapError(fail("updateChangeRequest"))),
+    ),
 
-    comment: (input) => cli.commentOnPullRequest(input).pipe(Effect.mapError(fail("comment"))),
+    comment: writing((input) =>
+      cli.commentOnPullRequest(input).pipe(Effect.mapError(fail("comment"))),
+    ),
 
-    updateComment: (input) =>
+    updateComment: writing((input) =>
       cli
         .updateComment({
           cwd: input.cwd,
@@ -712,10 +904,13 @@ export const make = Effect.gen(function* () {
           body: input.body,
         })
         .pipe(Effect.mapError(fail("updateComment"))),
+    ),
 
-    submitReview: (input) => cli.submitReview(input).pipe(Effect.mapError(fail("submitReview"))),
+    submitReview: writing((input) =>
+      cli.submitReview(input).pipe(Effect.mapError(fail("submitReview"))),
+    ),
 
-    replyToThread: (input) =>
+    replyToThread: writing((input) =>
       cli
         .replyToReviewThread({
           cwd: input.cwd,
@@ -725,8 +920,9 @@ export const make = Effect.gen(function* () {
           body: input.body,
         })
         .pipe(Effect.mapError(fail("replyToThread"))),
+    ),
 
-    setReaction: (input) =>
+    setReaction: writing((input) =>
       cli
         .setReaction({
           cwd: input.cwd,
@@ -738,8 +934,9 @@ export const make = Effect.gen(function* () {
           reacted: input.reacted,
         })
         .pipe(Effect.mapError(fail("setReaction"))),
+    ),
 
-    setThreadResolution: (input) =>
+    setThreadResolution: writing((input) =>
       cli
         .setReviewThreadResolution({
           cwd: input.cwd,
@@ -749,6 +946,7 @@ export const make = Effect.gen(function* () {
           resolved: input.resolved,
         })
         .pipe(Effect.mapError(fail("setThreadResolution"))),
+    ),
   };
 
   return provider;
diff --git a/packages/source-control-github/src/server/GitHubQuota.test.ts b/packages/source-control-github/src/server/GitHubQuota.test.ts
index 14365ee87d1f1..a72405e95dcaf 100644
--- a/packages/source-control-github/src/server/GitHubQuota.test.ts
+++ b/packages/source-control-github/src/server/GitHubQuota.test.ts
@@ -19,6 +19,10 @@ describe("GitHubQuota", () => {
       yield* quota.observe("github.com", headers(499));
       const refused = yield* Effect.flip(quota.admit("github.com", "graphql"));
       assert.strictEqual(refused.retryAt, RESET);
+      assert.strictEqual(refused.pauseReason, "reserve-protected");
+      assert.strictEqual(refused.resource, "graphql");
+      assert.strictEqual(refused.remaining, 499);
+      assert.strictEqual(refused.limit, 5_000);
       yield* quota.admit("github.com", "core");
       yield* quota.admit("ghe.example", "graphql");
       yield* quota.admit("github.com", "graphql").pipe(Effect.provideService(CredentialScope, "b"));
@@ -53,6 +57,8 @@ describe("GitHubQuota", () => {
         quota.admit("github.com", "graphql", { allowReserve: true }),
       );
       assert.strictEqual(refused.retryAt, RESET);
+      assert.strictEqual(refused.pauseReason, "quota-exhausted");
+      assert.strictEqual(refused.remaining, 0);
     }).pipe(Effect.provide(GitHubQuota.layer)),
   );
 
diff --git a/packages/source-control-github/src/server/GitHubQuota.ts b/packages/source-control-github/src/server/GitHubQuota.ts
index 1cdf214f07bd7..aa30357f48340 100644
--- a/packages/source-control-github/src/server/GitHubQuota.ts
+++ b/packages/source-control-github/src/server/GitHubQuota.ts
@@ -70,6 +70,10 @@ const make = Effect.gen(function* () {
         provider: SourceControlProviderKind.make("github"),
         host: host.trim().toLowerCase(),
         retryAt: snapshot.resetAtMs,
+        pauseReason: snapshot.remaining === 0 ? "quota-exhausted" : "reserve-protected",
+        resource,
+        remaining: snapshot.remaining,
+        limit: snapshot.limit,
       });
     },
   );
diff --git a/packages/source-control-github/src/server/GitHubRequestPolicy.ts b/packages/source-control-github/src/server/GitHubRequestPolicy.ts
index 5b58a4af4314b..4a543ff82a383 100644
--- a/packages/source-control-github/src/server/GitHubRequestPolicy.ts
+++ b/packages/source-control-github/src/server/GitHubRequestPolicy.ts
@@ -24,6 +24,7 @@ export const gitHubRequestsTotal = Metric.counter("t3_github_requests_total", {
 });
 
 const DEFAULT_TIMEOUT = Duration.seconds(30);
+const MINIMUM_RATE_LIMIT_COOLDOWN_MS = 60_000;
 /** GitHub's secondary limits penalize concurrent bursts. */
 const CONCURRENCY = 8;
 const REQUEST_HEADERS = { "x-github-api-version": "2022-11-28", "user-agent": "t3code" };
@@ -62,6 +63,7 @@ export class GitHubApiRateLimitError extends Schema.TaggedError<GitHubApiRateLim
     host: Schema.String,
     operation: Schema.String,
     retryAt: Schema.optionalKey(Schema.Finite),
+    resource: Schema.optional(Schema.String),
   },
 ) {
   override get message(): string {
@@ -146,23 +148,38 @@ function retryAtFrom(
   now: number,
 ): number | undefined {
   const fromRetryAfter = SourceControlRateLimit.retryAtFromHeader(headers["retry-after"], now);
-  if (fromRetryAfter !== undefined) return fromRetryAfter;
   const reset = Number(headers["x-ratelimit-reset"]) * 1_000;
-  return Number.isFinite(reset) && reset > now ? reset : undefined;
+  if (headers["x-ratelimit-remaining"] === "0" && Number.isFinite(reset) && reset > now) {
+    return Math.max(reset, fromRetryAfter ?? 0);
+  }
+  return fromRetryAfter;
 }
 
-/** HTTP 200 GraphQL rate limits use RATE_LIMITED or untyped errors with quota headers. */
-export function isRateLimited(input: {
-  readonly status: number;
+interface RateLimitResponse {
   readonly headers: Readonly<Record<string, string | undefined>>;
   readonly graphqlErrors?: ReadonlyArray<{ readonly type?: unknown; readonly message?: unknown }>;
   readonly body?: string;
-}): boolean {
+}
+
+export function isSecondaryRateLimited(input: RateLimitResponse): boolean {
+  return (
+    input.headers["retry-after"] !== undefined ||
+    /secondary rate limit/i.test(input.body ?? "") ||
+    (input.graphqlErrors ?? []).some(
+      (error) => typeof error.message === "string" && /secondary rate limit/i.test(error.message),
+    )
+  );
+}
+
+/** HTTP 200 GraphQL rate limits use RATE_LIMITED or untyped errors with quota headers. */
+export function isRateLimited(input: RateLimitResponse & { readonly status: number }): boolean {
   const { status, headers, graphqlErrors: errors } = input;
   return (
     status === 429 ||
     (errors !== undefined &&
+      errors.length > 0 &&
       (headers["x-ratelimit-remaining"] === "0" ||
+        isSecondaryRateLimited(input) ||
         errors.some(
           (error) =>
             error.type === "RATE_LIMITED" ||
@@ -186,7 +203,8 @@ export type GitHubAnswer<A> = {
       /** GitHub left part of the answer out as not found or forbidden for this credential. */
       readonly withheld?: boolean;
     }
-  | { readonly _tag: "RateLimited" | "Unauthorized" | "NotFound" }
+  | { readonly _tag: "RateLimited"; readonly secondary?: boolean }
+  | { readonly _tag: "Unauthorized" | "NotFound" }
   | { readonly _tag: "Failed"; readonly messages?: ReadonlyArray<string> | undefined }
 );
 
@@ -200,7 +218,7 @@ export interface GitHubRequest {
   readonly timeout?: Duration.Input | undefined;
 }
 
-/** REST/GraphQL share credentials, slots, quota reserves and host-wide pauses. */
+/** REST/GraphQL share credentials, slots and secondary pauses; primary quotas stay separate. */
 export class GitHubRequestPolicy extends Context.Service<
   GitHubRequestPolicy,
   {
@@ -346,13 +364,12 @@ export const make = Effect.gen(function* () {
       "github.operation": input.operation,
     });
     const scope = yield* SourceControlRateLimit.CredentialScope;
-    // A refusal pauses the whole host, whichever quota it spent: the key PullRequestService
-    // records its own backoff under.
     const key = { provider: SourceControlProviderKind.make("github"), host };
+    const resourceKey = { ...key, resource: input.resource };
 
     // Settlement annotates the request span with status and rate-limit attributes.
     const settle = Effect.fnUntraced(function* (
-      lease: number,
+      leases: { readonly host: number; readonly resource: number },
       answer: GitHubAnswer<A>,
       held: ChosenCredential,
     ) {
@@ -363,18 +380,45 @@ export const make = Effect.gen(function* () {
       });
       switch (answer._tag) {
         case "Ok":
-          yield* limits.recordSuccess({ ...key, lease });
+          yield* limits.recordSuccess({ ...key, lease: leases.host });
+          yield* limits.recordSuccess({ ...resourceKey, lease: leases.resource });
           return answer.value;
         case "RateLimited": {
-          const retryAt = retryAtFrom(answer.headers, yield* Clock.currentTimeMillis);
-          yield* limits.recordRateLimit({ ...key, lease, retryAt });
+          const now = yield* Clock.currentTimeMillis;
+          const primary = answer.headers["x-ratelimit-remaining"] === "0";
+          const secondary =
+            !primary || answer.secondary === true || answer.headers["retry-after"] !== undefined;
+          const proposedRetryAt = retryAtFrom(answer.headers, now);
+          if (primary) {
+            yield* limits.recordRateLimit({
+              ...resourceKey,
+              lease: leases.resource,
+              retryAt: proposedRetryAt,
+              minimumCooldownMs: MINIMUM_RATE_LIMIT_COOLDOWN_MS,
+            });
+          }
+          if (secondary) {
+            yield* limits.recordRateLimit({
+              ...key,
+              lease: leases.host,
+              retryAt: SourceControlRateLimit.retryAtFromHeader(answer.headers["retry-after"], now),
+              minimumCooldownMs: MINIMUM_RATE_LIMIT_COOLDOWN_MS,
+            });
+          }
+          const retryAt = yield* limits.check(secondary ? key : resourceKey).pipe(
+            Effect.match({
+              onFailure: (paused) => paused.retryAt,
+              onSuccess: () => proposedRetryAt ?? now + MINIMUM_RATE_LIMIT_COOLDOWN_MS,
+            }),
+          );
           yield* Effect.annotateCurrentSpan({
             "github.rate_limited": true,
-            ...(retryAt === undefined ? {} : { "github.retry_at": retryAt }),
+            "github.retry_at": retryAt,
           });
           return yield* new GitHubApiRateLimitError({
             ...context,
-            ...(retryAt === undefined ? {} : { retryAt }),
+            retryAt,
+            ...(secondary ? {} : { resource: input.resource }),
           });
         }
         case "Unauthorized":
@@ -401,19 +445,21 @@ export const make = Effect.gen(function* () {
       slots
         .withPermit(
           Effect.gen(function* () {
-            const lease = yield* quota
-              .admit(host, input.resource, { allowReserve: input.allowReserve })
-              .pipe(
-                Effect.andThen(
-                  limits.check(key, input.allowReserve ? { allowPaused: true } : undefined),
-                ),
-                Effect.tapError((paused) =>
-                  Effect.annotateCurrentSpan({
-                    "github.paused": true,
-                    "github.retry_at": paused.retryAt,
-                  }),
-                ),
-              );
+            const leases = yield* Effect.all({
+              host: limits.check(key),
+              resource: limits.check(resourceKey),
+            }).pipe(
+              Effect.tap(() =>
+                quota.admit(host, input.resource, { allowReserve: input.allowReserve }),
+              ),
+              Effect.tapError((paused) =>
+                Effect.annotateCurrentSpan({
+                  "github.paused": true,
+                  "github.retry_at": paused.retryAt,
+                  "github.pause_reason": paused.pauseReason ?? "rate-limited",
+                }),
+              ),
+            );
             // One deadline covers the headers and the body: a host that answers headers and then
             // stalls must not hold a shared slot for undici's own five-minute body timeout.
             const answer = yield* send(
@@ -448,12 +494,13 @@ export const make = Effect.gen(function* () {
               const personal = yield* Effect.option(personalCredential(host));
               if (Option.isSome(personal)) {
                 yield* quota.observe(host, answer.headers);
-                yield* limits.recordSuccess({ ...key, lease });
+                yield* limits.recordSuccess({ ...key, lease: leases.host });
+                yield* limits.recordSuccess({ ...resourceKey, lease: leases.resource });
                 yield* Effect.annotateCurrentSpan({ "github.app_refused": true });
                 return { _tag: "Retry", with: personal.value } as const;
               }
             }
-            return { _tag: "Done", value: yield* settle(lease, answer, held) } as const;
+            return { _tag: "Done", value: yield* settle(leases, answer, held) } as const;
           }),
         )
         // The rate-limit scope follows the credential, so a pause on one account never blocks another.
diff --git a/packages/source-control-github/src/server/GitHubRest.test.ts b/packages/source-control-github/src/server/GitHubRest.test.ts
index 1b34a51232631..7163c56d90983 100644
--- a/packages/source-control-github/src/server/GitHubRest.test.ts
+++ b/packages/source-control-github/src/server/GitHubRest.test.ts
@@ -156,7 +156,7 @@ describe("GitHubRest", () => {
     }).pipe(Effect.provide(layer), Effect.withTracer(tracer));
   });
 
-  it.effect("lets an interactive request through a pause a background read recorded", () => {
+  it.effect("honors an exhausted quota for interactive requests until its reset", () => {
     const reset = Math.floor(NOW / 1000) + 600;
     let call = 0;
     const { layer, requests } = harness(() =>
@@ -176,7 +176,7 @@ describe("GitHubRest", () => {
       const read = { host: "github.com", operation: "sweep", path: "repos/acme/web/pulls" };
       yield* Effect.flip(api.rest(read));
       expect((yield* Effect.flip(api.rest(read)))._tag).toBe("SourceControlRateLimitPausedError");
-      const merged = yield* api
+      const merge = api
         .rest({
           host: "github.com",
           operation: "merge",
@@ -184,6 +184,15 @@ describe("GitHubRest", () => {
           path: "repos/acme/web/pulls/7/merge",
         })
         .pipe(Effect.provideService(SourceControlRateLimit.Interactive, true));
+      expect(yield* Effect.flip(merge)).toMatchObject({
+        _tag: "SourceControlRateLimitPausedError",
+        pauseReason: "quota-exhausted",
+        resource: "core",
+        retryAt: reset * 1_000,
+      });
+      expect(requests).toHaveLength(1);
+      yield* TestClock.setTime(reset * 1_000);
+      const merged = yield* merge;
       expect(merged.status).toBe(200);
       expect(requests).toHaveLength(2);
     }).pipe(Effect.provide(layer));
diff --git a/packages/source-control-github/src/server/GitHubRest.ts b/packages/source-control-github/src/server/GitHubRest.ts
index a3aec906dd321..52f0c660b773b 100644
--- a/packages/source-control-github/src/server/GitHubRest.ts
+++ b/packages/source-control-github/src/server/GitHubRest.ts
@@ -137,7 +137,11 @@ function classify(input: {
   const { status, headers, body } = input.answer;
   const meta = { status, headers };
   if (GitHubRequestPolicy.isRateLimited({ status, headers, body })) {
-    return { _tag: "RateLimited", ...meta };
+    return {
+      _tag: "RateLimited",
+      secondary: GitHubRequestPolicy.isSecondaryRateLimited({ headers, body }),
+      ...meta,
+    };
   }
   if (status === 401) return { _tag: "Unauthorized", ...meta };
   if (status === 404) return { _tag: "NotFound", ...meta };
diff --git a/packages/source-control-github/src/server/GitHubSourceControlProvider.ts b/packages/source-control-github/src/server/GitHubSourceControlProvider.ts
index 4a42e9422a5de..1a102da26f96d 100644
--- a/packages/source-control-github/src/server/GitHubSourceControlProvider.ts
+++ b/packages/source-control-github/src/server/GitHubSourceControlProvider.ts
@@ -346,11 +346,12 @@ function fromGitHubApiError(
         error,
       );
     case "GitHubApiRateLimitError":
-    case "SourceControlRateLimitPausedError":
       return failure(
         "GitHub API rate limit exceeded. Requests resume when the limit resets.",
         error,
       );
+    case "SourceControlRateLimitPausedError":
+      return failure(error.message, error);
     case "GitHubApiNotFoundError":
       return failure(notFound, error);
     case "GitHubCliFailedError":
diff --git a/packages/source-control-github/src/server/gitHubConditionalChecks.test.ts b/packages/source-control-github/src/server/gitHubConditionalChecks.test.ts
index 2e8654956aec0..bed509712f220 100644
--- a/packages/source-control-github/src/server/gitHubConditionalChecks.test.ts
+++ b/packages/source-control-github/src/server/gitHubConditionalChecks.test.ts
@@ -2,7 +2,10 @@ import { expect, it } from "@effect/vitest";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Redacted from "effect/Redacted";
+import { SourceControlProviderKind } from "@t3tools/contracts";
+import * as SourceControlRateLimit from "@t3tools/source-control-core/server/SourceControlRateLimit";
 import * as GitHubRest from "./GitHubRest.ts";
+import * as GitHubRequestPolicy from "./GitHubRequestPolicy.ts";
 import { PinnedGitHubCredential } from "./GitHubRequestPolicy.ts";
 import { makeChecksRevalidator } from "./gitHubConditionalChecks.ts";
 
@@ -49,3 +52,106 @@ it.effect("keeps the checks head through conditional 304 revalidation and head c
     }),
   );
 });
+
+it.effect.each([
+  { reason: "reserve-protected", fallback: true },
+  { reason: "quota-exhausted", fallback: true },
+  { reason: "core-rate-limit", fallback: true },
+  { reason: "secondary-pause", fallback: false },
+  { reason: "secondary-rate-limit", fallback: false },
+  { reason: "authentication", fallback: false },
+] as const)(
+  "falls back from REST checks only for primary core limits: $reason",
+  ({ reason, fallback }) => {
+    const input = { cwd: "/repo", host: "github.com", repository: "acme/web", number: 1 };
+    const error =
+      reason === "reserve-protected" || reason === "quota-exhausted"
+        ? new SourceControlRateLimit.SourceControlRateLimitPausedError({
+            provider: SourceControlProviderKind.make("github"),
+            host: input.host,
+            resource: "core",
+            pauseReason: reason,
+            retryAt: 60_000,
+          })
+        : reason === "secondary-pause"
+          ? new SourceControlRateLimit.SourceControlRateLimitPausedError({
+              provider: SourceControlProviderKind.make("github"),
+              host: input.host,
+              pauseReason: "rate-limited",
+              retryAt: 60_000,
+            })
+          : reason === "authentication"
+            ? new GitHubRequestPolicy.GitHubApiAuthenticationError({
+                host: input.host,
+                operation: "revalidateChecks",
+              })
+            : new GitHubRequestPolicy.GitHubApiRateLimitError({
+                host: input.host,
+                operation: "revalidateChecks",
+                ...(reason === "core-rate-limit" ? { resource: "core" } : {}),
+              });
+    let reads = 0;
+    const detail = { state: "open" as const, headSha: "a".repeat(40), checks: [] };
+    return Effect.gen(function* () {
+      const read = yield* makeChecksRevalidator;
+      const result = read(
+        input,
+        Effect.sync(() => {
+          reads++;
+          return detail;
+        }),
+      );
+      if (fallback) expect(yield* result).toEqual(detail);
+      else expect(yield* result.pipe(Effect.flip)).toBe(error);
+      expect(reads).toBe(fallback ? 1 : 0);
+    }).pipe(
+      Effect.provide(Layer.mock(GitHubRest.GitHubRest)({ rest: () => Effect.fail(error) })),
+      Effect.provideService(PinnedGitHubCredential, {
+        host: input.host,
+        token: Redacted.make("test"),
+        credentialFingerprint: "test",
+      }),
+    );
+  },
+);
+
+it.effect("does not use conditional checks under a different host's credential", () => {
+  let requests = 0;
+  const detail = { state: "open" as const, headSha: "a".repeat(40), checks: [] };
+  return Effect.gen(function* () {
+    const read = yield* makeChecksRevalidator;
+    expect(
+      yield* read(
+        { cwd: "/repo", host: "github.enterprise.test", repository: "acme/web", number: 1 },
+        Effect.succeed(detail),
+      ),
+    ).toEqual(detail);
+    expect(requests).toBe(0);
+  }).pipe(
+    Effect.provide(
+      Layer.mock(GitHubRest.GitHubRest)({
+        rest: (input) =>
+          Effect.sync(() => {
+            requests++;
+            return {
+              status: 200,
+              headers: {},
+              body: input.path.endsWith("/pulls/1")
+                ? JSON.stringify({
+                    head: { sha: detail.headSha, repo: { id: 1 } },
+                    base: { repo: { id: 1 } },
+                  })
+                : "{}",
+              truncated: false,
+              invalidUtf8: false,
+            };
+          }),
+      }),
+    ),
+    Effect.provideService(PinnedGitHubCredential, {
+      host: "github.com",
+      token: Redacted.make("test"),
+      credentialFingerprint: "test",
+    }),
+  );
+});
diff --git a/packages/source-control-github/src/server/gitHubConditionalChecks.ts b/packages/source-control-github/src/server/gitHubConditionalChecks.ts
index 3d1e9b5ea4399..ec4cb1a2b9449 100644
--- a/packages/source-control-github/src/server/gitHubConditionalChecks.ts
+++ b/packages/source-control-github/src/server/gitHubConditionalChecks.ts
@@ -6,6 +6,7 @@ import * as Option from "effect/Option";
 import * as Schema from "effect/Schema";
 import * as Semaphore from "effect/Semaphore";
 import { PositiveInt, type PullRequestChecks } from "@t3tools/contracts";
+import { normalizeHost } from "@t3tools/source-control-core/server/pullRequestUtils";
 
 import * as GitHubRest from "./GitHubRest.ts";
 import * as GitHubRequestPolicy from "./GitHubRequestPolicy.ts";
@@ -75,7 +76,9 @@ export const makeChecksRevalidator = Effect.gen(function* () {
   ) =>
     Effect.gen(function* () {
       const credential = yield* GitHubRequestPolicy.PinnedGitHubCredential;
-      if (credential === null) return yield* read;
+      if (credential === null || normalizeHost(credential.host) !== normalizeHost(input.host)) {
+        return yield* read;
+      }
       const key = `${credential.credentialFingerprint}\0${input.host}\0${input.repository}\0${input.number}`;
       const entry = yield* Cache.get(entries, key);
       return yield* entry.gate.withPermit(
@@ -101,6 +104,14 @@ export const makeChecksRevalidator = Effect.gen(function* () {
               })
               .pipe(
                 Effect.catchTags({
+                  GitHubApiRateLimitError: (error) =>
+                    error.resource === "core" ? Effect.succeed(null) : Effect.fail(error),
+                  SourceControlRateLimitPausedError: (error) =>
+                    error.resource === "core" &&
+                    (error.pauseReason === "reserve-protected" ||
+                      error.pauseReason === "quota-exhausted")
+                      ? Effect.succeed(null)
+                      : Effect.fail(error),
                   GitHubApiNotFoundError: () =>
                     Effect.sync(() => {
                       entry.supported = false;
diff --git a/packages/source-control-github/src/server/gitHubGraphQlClient.test.ts b/packages/source-control-github/src/server/gitHubGraphQlClient.test.ts
index 667dc4f8f4c22..e14f4df359c51 100644
--- a/packages/source-control-github/src/server/gitHubGraphQlClient.test.ts
+++ b/packages/source-control-github/src/server/gitHubGraphQlClient.test.ts
@@ -146,7 +146,7 @@ describe("GitHubGraphQlAuth", () => {
     },
   );
 
-  it.effect("pauses the host on a RATE_LIMITED answer sent with HTTP 200", () => {
+  it.effect("pauses only GraphQL on a primary RATE_LIMITED answer sent with HTTP 200", () => {
     const reset = Math.floor(NOW / 1000) + 600;
     const { layer, requests } = harness(() =>
       json(
@@ -158,12 +158,23 @@ describe("GitHubGraphQlAuth", () => {
       yield* TestClock.setTime(NOW);
       const first = yield* Effect.flip(readStats("github.com"));
       expect(first).toMatchObject({ _tag: "GitHubApiRateLimitError", retryAt: reset * 1000 });
+      expect(yield* Effect.flip(readStats("github.com", 8))).toMatchObject({
+        _tag: "SourceControlRateLimitPausedError",
+        resource: "graphql",
+        pauseReason: "quota-exhausted",
+      });
       const api = yield* GitHubRest.GitHubRest;
-      const rest = yield* Effect.flip(
-        api.rest({ host: "github.com", operation: "stack", path: "repos/acme/web/stacks" }),
-      );
-      expect(rest).toMatchObject({ _tag: "SourceControlRateLimitPausedError" });
-      expect(requests).toHaveLength(1);
+      const rest = yield* api.rest({
+        host: "github.com",
+        operation: "stack",
+        path: "repos/acme/web/stacks",
+      });
+      expect(rest.status).toBe(200);
+      expect(yield* Effect.flip(readStats("github.com", 9))).toMatchObject({
+        _tag: "SourceControlRateLimitPausedError",
+        resource: "graphql",
+      });
+      expect(requests).toHaveLength(2);
     }).pipe(Effect.provide(layer));
   });
 
@@ -219,19 +230,67 @@ describe("GitHubGraphQlAuth", () => {
     }).pipe(Effect.provide(layer), Effect.withTracer(tracer));
   });
 
-  it.effect("reads a 403 secondary limit as a rate limit, and a 401 as a refused token", () => {
-    const answers = [
-      json({ message: "You have exceeded a secondary rate limit." }, { status: 403 }),
-      json({ message: "Bad credentials" }, { status: 401 }),
-    ];
-    const { layer, invalidations } = harness(() => answers.shift()!);
+  it.effect.each([
+    { status: 403, remaining: "282" },
+    { status: 200, remaining: "282" },
+    { status: 200, remaining: "0" },
+  ])(
+    "reads a $status secondary limit with $remaining remaining, and a refused token",
+    ({ status, remaining }) => {
+      const answers = [
+        json(
+          status === 200
+            ? { data: null, errors: [{ message: "You have exceeded a secondary rate limit." }] }
+            : { message: "You have exceeded a secondary rate limit." },
+          {
+            status,
+            headers: {
+              "x-ratelimit-resource": "graphql",
+              "x-ratelimit-limit": "5000",
+              "x-ratelimit-remaining": remaining,
+              "x-ratelimit-reset": String(NOW / 1_000 + 3_600),
+            },
+          },
+        ),
+        json({ message: "Bad credentials" }, { status: 401 }),
+      ];
+      const { layer, requests, invalidations } = harness(() => answers.shift()!);
+      return Effect.gen(function* () {
+        yield* TestClock.setTime(NOW);
+        expect((yield* Effect.flip(readStats("github.com")))._tag).toBe("GitHubApiRateLimitError");
+        expect(yield* Effect.flip(readStats("github.com", 8))).toMatchObject({
+          _tag: "SourceControlRateLimitPausedError",
+          pauseReason: "rate-limited",
+          retryAt: NOW + 60_000,
+        });
+        const api = yield* GitHubRest.GitHubRest;
+        expect(
+          yield* Effect.flip(
+            api.rest({ host: "github.com", operation: "user", path: "user", allowReserve: true }),
+          ),
+        ).toMatchObject({
+          _tag: "SourceControlRateLimitPausedError",
+          pauseReason: "rate-limited",
+          retryAt: NOW + 60_000,
+        });
+        expect(requests).toHaveLength(1);
+        expect((yield* Effect.flip(readStats("github.example")))._tag).toBe(
+          "GitHubApiAuthenticationError",
+        );
+        expect(invalidations()).toBe(1);
+      }).pipe(Effect.provide(layer));
+    },
+  );
+
+  it.effect("accepts the last successful GraphQL answer with an empty errors list", () => {
+    const { layer } = harness(() =>
+      json(
+        { data: { _0_repository: { pullRequest: stats } }, errors: [] },
+        { headers: { "x-ratelimit-remaining": "0" } },
+      ),
+    );
     return Effect.gen(function* () {
-      yield* TestClock.setTime(NOW);
-      expect((yield* Effect.flip(readStats("github.com")))._tag).toBe("GitHubApiRateLimitError");
-      expect((yield* Effect.flip(readStats("github.example")))._tag).toBe(
-        "GitHubApiAuthenticationError",
-      );
-      expect(invalidations()).toBe(1);
+      expect(yield* readStats("github.com")).toEqual({ repository: { pullRequest: stats } });
     }).pipe(Effect.provide(layer));
   });
 
diff --git a/packages/source-control-github/src/server/gitHubGraphQlClient.ts b/packages/source-control-github/src/server/gitHubGraphQlClient.ts
index 7030abb1742e2..225f3c0d97e6c 100644
--- a/packages/source-control-github/src/server/gitHubGraphQlClient.ts
+++ b/packages/source-control-github/src/server/gitHubGraphQlClient.ts
@@ -86,7 +86,15 @@ export class GitHubGraphQlAuth extends GraphQLMiddleware.Service<
                     (error) => error["type"] === "NOT_FOUND" || error["type"] === "FORBIDDEN",
                   );
                   return rateLimited
-                    ? { _tag: "RateLimited" as const, status, headers: responseHeaders }
+                    ? {
+                        _tag: "RateLimited" as const,
+                        status,
+                        headers: responseHeaders,
+                        secondary: GitHubRequestPolicy.isSecondaryRateLimited({
+                          headers: responseHeaders,
+                          ...(answer.errors === undefined ? {} : { graphqlErrors: answer.errors }),
+                        }),
+                      }
                     : {
                         _tag: "Ok" as const,
                         // The source is local; never trust one GitHub's answer carries.
@@ -151,7 +159,16 @@ const refused = Effect.fn("gitHubGraphQlClient.refused")(function* (
       : status === 404
         ? "NotFound"
         : "Failed";
-  return { _tag: tag, status: status ?? 200, headers } as const;
+  return {
+    _tag: tag,
+    status: status ?? 200,
+    headers,
+    secondary: GitHubRequestPolicy.isSecondaryRateLimited({
+      headers,
+      body,
+      ...(reason._tag === "ResponseError" ? { graphqlErrors: reason.errors } : {}),
+    }),
+  } as const;
 });
 
 /**
diff --git a/packages/source-control-github/src/server/gitHubPullRequestJson.ts b/packages/source-control-github/src/server/gitHubPullRequestJson.ts
index 7dda1fa573a30..9bf9edbd7cc04 100644
--- a/packages/source-control-github/src/server/gitHubPullRequestJson.ts
+++ b/packages/source-control-github/src/server/gitHubPullRequestJson.ts
@@ -1175,6 +1175,10 @@ function toCheckContexts(nodes: ReadonlyArray<CheckContext>): ReadonlyArray<GitH
 
 export function toPullRequestCheckContextsPage(result: PullRequestCheckContexts.Result): {
   readonly headSha: string;
+  readonly headBranch: string;
+  readonly headRepositoryOwner: string | null;
+  readonly isCrossRepository: boolean;
+  readonly state: PullRequestState;
   readonly contexts: ReadonlyArray<GitHubCheckContext>;
   readonly nextCursor: string | null;
 } | null {
@@ -1183,6 +1187,10 @@ export function toPullRequestCheckContextsPage(result: PullRequestCheckContexts.
   const contexts = nodesOf(pr.commits)[0]?.commit.statusCheckRollup?.contexts;
   return {
     headSha: pr.headRefOid,
+    headBranch: pr.headRefName,
+    headRepositoryOwner: pr.headRepositoryOwner?.login ?? null,
+    isCrossRepository: pr.isCrossRepository,
+    state: toState(pr),
     contexts: toCheckContexts(nodesOf(contexts)),
     nextCursor: nextCursorOf(contexts?.pageInfo),
   };
diff --git a/packages/source-control-github/src/server/pullRequestReads.graphql b/packages/source-control-github/src/server/pullRequestReads.graphql
index 1479471042be7..e485c712096d1 100644
--- a/packages/source-control-github/src/server/pullRequestReads.graphql
+++ b/packages/source-control-github/src/server/pullRequestReads.graphql
@@ -179,6 +179,12 @@ query PullRequestCheckContexts(
 ) {
   repository(owner: $owner, name: $name) {
     pullRequest(number: $number) {
+      state
+      isCrossRepository
+      headRefName
+      headRepositoryOwner {
+        login
+      }
       headRefOid
       commits(last: 1) {
         nodes {
diff --git a/packages/source-control-github/src/server/pullRequestReads.graphql.ts b/packages/source-control-github/src/server/pullRequestReads.graphql.ts
index be437dcfc84b3..842e3e48a0091 100644
--- a/packages/source-control-github/src/server/pullRequestReads.graphql.ts
+++ b/packages/source-control-github/src/server/pullRequestReads.graphql.ts
@@ -537,6 +537,14 @@ export interface PullRequestCheckContextsRepositoryPullRequestCommitsPullRequest
 
 /** A repository pull request. */
 export const PullRequestCheckContextsRepositoryPullRequestPullRequest = Schema.Struct({
+  /** Identifies the state of the pull request. */
+  state: GraphQL.enumLiterals(Shared.PullRequestState.literals),
+  /** The head and base repositories are different. */
+  isCrossRepository: Schema.Boolean,
+  /** Identifies the name of the head Ref associated with the pull request, even if the ref has been deleted. */
+  headRefName: Schema.String,
+  /** The owner of the repository associated with this pull request's head Ref. */
+  headRepositoryOwner: Schema.NullOr(RepositoryOwner),
   /** Identifies the oid of the head ref associated with the pull request, even if the ref has been deleted. */
   headRefOid: Shared.GitObjectID,
   /** A list of commits present in this pull request's head branch not present in the base branch. */
@@ -562,7 +570,7 @@ export const PullRequestCheckContexts = GraphQL.query("PullRequestCheckContexts"
       { name: "after", body: "String" }
     ],
     selections: [
-      { name: "repository", body: ["(owner:$", "owner", " name:$", "name", "){pullRequest(number:$", "number", "){headRefOid commits(last:1){nodes{commit{statusCheckRollup{contexts(first:100 after:$", "after", "){nodes{__typename...", "CheckContext", "}pageInfo{hasNextPage endCursor}}}}}}}}"] }
+      { name: "repository", body: ["(owner:$", "owner", " name:$", "name", "){pullRequest(number:$", "number", "){state isCrossRepository headRefName headRepositoryOwner{__typename login}headRefOid commits(last:1){nodes{commit{statusCheckRollup{contexts(first:100 after:$", "after", "){nodes{__typename...", "CheckContext", "}pageInfo{hasNextPage endCursor}}}}}}}}"] }
     ],
     fragments: [
       { name: "CheckContext", body: ["on StatusCheckRollupContext{__typename...on StatusContext{context state targetUrl createdAt description isRequired(pullRequestNumber:$", "number", ")@include(if:$", "required", ")}...on CheckRun{databaseId title name status conclusion startedAt completedAt detailsUrl isRequired(pullRequestNumber:$", "number", ")@include(if:$", "required", ")checkSuite{workflowRun{runAttempt workflow{name}}}}}"] }
diff --git a/packages/source-control-github/src/shared/ghCommand.test.ts b/packages/source-control-github/src/shared/ghCommand.test.ts
index 10e347fc6010e..fb5051af4baf7 100644
--- a/packages/source-control-github/src/shared/ghCommand.test.ts
+++ b/packages/source-control-github/src/shared/ghCommand.test.ts
@@ -73,7 +73,7 @@ describe("classifyGhCommand", () => {
     ],
     [
       "gh api https://api.github.com/repos/acme/app/check-runs/119542773959/annotations",
-      { kind: "read", intent: "failures", target: { repository: "acme/app" } },
+      { kind: "other" },
     ],
     [
       "gh api -X GET -f per_page=100 repos/acme/app/actions/jobs/1/logs",
@@ -91,15 +91,9 @@ describe("classifyGhCommand", () => {
       "gh -R=acme/app pr checks 123",
       { kind: "read", intent: "status", target: { repository: "acme/app", number: 123 } },
     ],
-    [
-      "gh --hostname=github.com api repos/acme/app/pulls/4/reviews",
-      { kind: "read", intent: "feedback", target: { repository: "acme/app", number: 4 } },
-    ],
+    ["gh --hostname=github.com api repos/acme/app/pulls/4/reviews", { kind: "other" }],
     ["gh -R acme/app pr checks 123 --watch", { kind: "poll" }],
-    [
-      "gh --hostname github.com api --method GET repos/acme/app/pulls/4/reviews",
-      { kind: "read", intent: "feedback", target: { repository: "acme/app", number: 4 } },
-    ],
+    ["gh --hostname github.com api --method GET repos/acme/app/pulls/4/reviews", { kind: "other" }],
     // Polls.
     ["gh pr checks 4497 --watch", { kind: "poll" }],
     ["gh run watch 39810344331", { kind: "poll" }],
@@ -137,6 +131,14 @@ describe("classifyGhCommand", () => {
     ["gh search prs --review-requested=@me", { kind: "other" }],
     ["gh issue list --state open --limit 150", { kind: "other" }],
     ["gh auth status", { kind: "other" }],
+    // An owner/repo target loses host and header semantics; these must stay with gh.
+    ["gh pr checks 12 -R enterprise.example/acme/app", { kind: "other" }],
+    ["gh pr checks 12 --repo https://enterprise.example/acme/app", { kind: "other" }],
+    ["gh run view 9 --log-failed -R enterprise.example/acme/app", { kind: "other" }],
+    ["gh api --hostname enterprise.example repos/acme/app/pulls/4/reviews", { kind: "other" }],
+    ["gh api https://enterprise.example/repos/acme/app/pulls/4/reviews", { kind: "other" }],
+    ["gh api repos/acme/app/pulls/4/reviews -H Accept:custom", { kind: "other" }],
+    ["gh api repos/acme/app/pulls/4/reviews --header=Authorization:custom", { kind: "other" }],
     ["gh", { kind: "other" }],
   ] as const)("%s", (command, expected) => {
     expect(classifyGhCommand(words(command))).toEqual(expected);
diff --git a/packages/source-control-github/src/shared/ghCommand.ts b/packages/source-control-github/src/shared/ghCommand.ts
index 662161fdd843f..d409adab3f1e6 100644
--- a/packages/source-control-github/src/shared/ghCommand.ts
+++ b/packages/source-control-github/src/shared/ghCommand.ts
@@ -74,6 +74,8 @@ const VALUE_FLAGS = new Set([
 ]);
 // `gh api` reads `-i` as `--include` and `-H` as a header; both still take or skip a value as listed.
 const API_VALUE_FLAGS = new Set([
+  "-R",
+  "--repo",
   "--hostname",
   "-X",
   "--method",
@@ -94,7 +96,7 @@ const API_VALUE_FLAGS = new Set([
 ]);
 const API_BODY_FLAGS = new Set(["-f", "--raw-field", "-F", "--field", "--input"]);
 
-const REPOSITORY = /([^/\s]+\/[^/\s]+)\/?$/u;
+const REPOSITORY = /^([^/\s]+\/[^/\s]+)\/?$/u;
 const NUMBER = /^\d+$/u;
 const URL = /^https?:\/\//u;
 
@@ -136,10 +138,16 @@ const has = (args: ParsedArgs, ...flags: ReadonlyArray<string>) =>
 const value = (args: ParsedArgs, ...flags: ReadonlyArray<string>) =>
   flags.flatMap((flag) => args.flags.get(flag) ?? []).at(-1);
 
-/** `-R acme/app`, `-R github.com/acme/app` or a repository URL, as `owner/repo`. */
+/** Explicit hosts and headers cannot be represented by a hostless owner/repo tool input. */
+function hasExplicitHost(args: ParsedArgs): boolean {
+  const repository = value(args, "-R", "--repo");
+  return has(args, "--hostname") || (repository !== undefined && !REPOSITORY.test(repository));
+}
+
+/** A bare `-R acme/app`, as `owner/repo`. */
 function repositoryOf(args: ParsedArgs): ForgeCommandTarget {
   const repo = value(args, "-R", "--repo");
-  const match = repo === undefined ? null : REPOSITORY.exec(repo.replace(/^https?:\/\//u, ""));
+  const match = repo === undefined ? null : REPOSITORY.exec(repo);
   return match === null || repo?.includes("{") ? {} : { repository: match[1]!.toLowerCase() };
 }
 
@@ -164,6 +172,7 @@ const OTHER: ForgeCommand = { kind: "other" };
 function classifyPullRequest(subcommand: string, rest: ReadonlyArray<string>): ForgeCommand {
   if (PR_WRITES.has(subcommand)) return WRITE;
   const args = parseArgs(rest, VALUE_FLAGS);
+  if (hasExplicitHost(args)) return OTHER;
   if (subcommand === "checks" && has(args, "--watch")) return POLL;
   const target = pullRequestTarget(args);
   if (target === null) return OTHER;
@@ -179,10 +188,11 @@ function classifyPullRequest(subcommand: string, rest: ReadonlyArray<string>): F
 }
 
 function classifyRun(subcommand: string, rest: ReadonlyArray<string>): ForgeCommand {
-  if (subcommand === "watch") return POLL;
   if (RUN_WRITES.has(subcommand)) return WRITE;
-  if (subcommand !== "view") return OTHER;
   const args = parseArgs(rest, VALUE_FLAGS);
+  if (hasExplicitHost(args)) return OTHER;
+  if (subcommand === "watch") return POLL;
+  if (subcommand !== "view") return OTHER;
   return has(args, "--log", "--log-failed") ? read("failures", repositoryOf(args)) : OTHER;
 }
 
@@ -207,10 +217,10 @@ function classifyApi(rest: ReadonlyArray<string>): ForgeCommand {
     // gh api turns a body flag into a POST unless the method says otherwise.
     (has(args, ...API_BODY_FLAGS) ? "POST" : "GET");
   if (method !== "GET") return WRITE;
-  const path = (args.positionals[0] ?? "")
-    .replace(/^https?:\/\/[^/]+\//u, "")
-    .replace(/^\/+/u, "")
-    .replace(/[?#][\s\S]*$/u, "");
+  if (hasExplicitHost(args) || has(args, "-H", "--header") || URL.test(args.positionals[0] ?? "")) {
+    return OTHER;
+  }
+  const path = (args.positionals[0] ?? "").replace(/^\/+/u, "").replace(/[?#][\s\S]*$/u, "");
   const job = JOB_ROUTE.exec(path) ?? ANNOTATIONS_ROUTE.exec(path);
   if (job !== null) return read("failures", routeTarget(job[1]!));
   const feedback = FEEDBACK_ROUTE.exec(path);