perf(server): port #13689 to V2 — post-turn PR discovery refreshes the repository identity

Main raised RepositoryIdentityResolver's positive cache TTL from 1 to 15
minutes so the per-minute sweeps stop spawning git for every project,
and made PR discovery after a turn resolve with refresh: true (a turn
can add the remote the pull request lives on). The TTL change and the
publish-repository refresh in ws.ts merged cleanly and apply to V2.

V2's ThreadPullRequestService resolves the identity itself, and did so
without refresh, so after the merge it could miss a newly added remote
for up to 15 minutes instead of one. Discovery requests that already
carry refresh: true (run finished, checkpoint captured, unsettled) now
pass it to the resolver.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

Author: juliusmarminge

apps/server/src/orchestration-v2/ThreadPullRequestService.test.ts

@@ -68,6 +68,31 @@ describe("ThreadPullRequestServiceV2 project guard", () => {
     }),
   );
 
+  it.effect("refreshes the cached repository identity only when asked", () =>
+    Effect.gen(function* () {
+      const project: OrchestrationProjectShell = {
+        id: ProjectId.make("project-1"),
+        title: "Project",
+        workspaceRoot: "/workspace/project",
+        defaultModelSelection: null,
+        scripts: [],
+        repositoryIdentity: null,
+        createdAt: "2026-08-01T00:00:00.000Z",
+        updatedAt: "2026-08-01T00:00:00.000Z",
+      };
+      const refreshes: Array<boolean | undefined> = [];
+      const resolver = {
+        resolve: (_root: string, options?: { readonly refresh?: boolean }) => {
+          refreshes.push(options?.refresh);
+          return Effect.succeed(null);
+        },
+      };
+      yield* resolveProjectForPullRequestDiscovery(project, resolver);
+      yield* resolveProjectForPullRequestDiscovery(project, resolver, { refresh: true });
+      expect(refreshes).toEqual([false, true]);
+    }),
+  );
+
   it("rejects a pull-request result when the project root changes before dispatch", () => {
     const currentProject = Option.some({
       workspaceRoot: "/workspace/replaced",

apps/server/src/orchestration-v2/ThreadPullRequestService.ts

@@ -67,8 +67,13 @@ export const resolveProjectForPullRequestDiscovery = Effect.fn(
 )(function* (
   project: OrchestrationProjectShell,
   repositoryIdentities: RepositoryIdentityResolver.RepositoryIdentityResolver["Service"],
+  options?: { readonly refresh?: boolean },
 ) {
-  const repositoryIdentity = yield* repositoryIdentities.resolve(project.workspaceRoot);
+  // Identities stay cached for 15 minutes. A finished turn may have added the
+  // remote its pull request lives on, so post-turn discovery refreshes.
+  const repositoryIdentity = yield* repositoryIdentities.resolve(project.workspaceRoot, {
+    refresh: options?.refresh ?? false,
+  });
   return {
     project: { ...project, repositoryIdentity },
     repository: sourceControlRepositorySelector(repositoryIdentity),
@@ -173,7 +178,9 @@ export const make = Effect.gen(function* () {
           const project = projects.get(first.projectId);
           if (project === undefined) return finishBackfill(group);
           const { project: resolvedProject, repository } =
-            yield* resolveProjectForPullRequestDiscovery(project, repositoryIdentities);
+            yield* resolveProjectForPullRequestDiscovery(project, repositoryIdentities, {
+              refresh: request.refresh,
+            });
           if (first.branch !== null && repository === null) return finishBackfill(group);
           const worktreeExists =
             first.worktreePath !== null && (yield* fileSystem.exists(first.worktreePath));