fix(frontend): populate session.pullRequest from /pr endpoint (#251)

WorkspaceSession.pullRequest was declared but never populated, so every
Boolean(session.pullRequest) check was dead: the Summary tab gated its PR
fetch on it (never ran), and the Board card and /prs page read it directly
(always empty).

Hydrate the field centrally in fetchWorkspaces — the single place that
builds session objects for the workspace, board, PR page, and sidebar — by
fetching GET /sessions/{sessionId}/pr per non-terminated session in parallel
and attaching {number, state}. A per-session fetch error degrades to "no PR"
rather than failing the whole workspace query; terminated sessions are
skipped. GET /sessions/{sessionId}/pr stays the single source of truth, so
no new backend endpoint and no changes to the consuming components.

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

Author: neversettle17-101

frontend/src/renderer/hooks/useWorkspaceQuery.test.tsx

@@ -20,10 +20,15 @@ function wrapper({ children }: { children: ReactNode }) {
 function respondWith(payload: {
 	projects?: { data?: unknown; error?: unknown };
 	sessions?: { data?: unknown; error?: unknown };
+	prsBySession?: Record<string, { data?: unknown; error?: unknown }>;
 }) {
-	getMock.mockImplementation(async (url: string) => {
+	getMock.mockImplementation(async (url: string, options?: { params?: { path?: { sessionId?: string } } }) => {
 		if (url === "/api/v1/projects") return payload.projects ?? { data: { projects: [] }, error: undefined };
 		if (url === "/api/v1/sessions") return payload.sessions ?? { data: { sessions: [] }, error: undefined };
+		if (url === "/api/v1/sessions/{sessionId}/pr") {
+			const sessionId = options?.params?.path?.sessionId ?? "";
+			return payload.prsBySession?.[sessionId] ?? { data: { sessionId, prs: [] }, error: undefined };
+		}
 		throw new Error(`unexpected GET ${url}`);
 	});
 }
@@ -91,6 +96,78 @@ describe("useWorkspaceQuery", () => {
 		});
 	});
 
+	it("hydrates each session's pullRequest from the /pr endpoint (issue #251)", async () => {
+		respondWith({
+			projects: { data: { projects: [{ id: "proj-1", name: "my-app", path: "/p" }] }, error: undefined },
+			sessions: {
+				data: {
+					sessions: [
+						{ id: "sess-1", projectId: "proj-1", status: "pr_open", isTerminated: false, updatedAt: "2026-06-10T16:15:04Z" },
+						{ id: "sess-2", projectId: "proj-1", status: "working", isTerminated: false, updatedAt: "2026-06-10T16:15:04Z" },
+					],
+				},
+				error: undefined,
+			},
+			prsBySession: {
+				"sess-1": {
+					data: {
+						sessionId: "sess-1",
+						prs: [{ number: 278, state: "open", url: "u", ci: "passing", review: "approved", mergeability: "clean", reviewComments: false, updatedAt: "2026-06-10T16:15:04Z" }],
+					},
+					error: undefined,
+				},
+			},
+		});
+
+		const { result } = renderHook(() => useWorkspaceQuery(), { wrapper });
+		await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+		const sessions = result.current.data?.[0].sessions ?? [];
+		expect(sessions[0].pullRequest).toEqual({ number: 278, state: "open" });
+		// No PR for the endpoint's empty response → undefined, so the empty states render.
+		expect(sessions[1].pullRequest).toBeUndefined();
+	});
+
+	it("treats a per-session PR fetch error as no PR without failing the query", async () => {
+		respondWith({
+			projects: { data: { projects: [{ id: "proj-1", name: "my-app", path: "/p" }] }, error: undefined },
+			sessions: {
+				data: {
+					sessions: [
+						{ id: "sess-1", projectId: "proj-1", status: "pr_open", isTerminated: false, updatedAt: "2026-06-10T16:15:04Z" },
+					],
+				},
+				error: undefined,
+			},
+			prsBySession: { "sess-1": { data: undefined, error: new Error("pr backend down") } },
+		});
+
+		const { result } = renderHook(() => useWorkspaceQuery(), { wrapper });
+		await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+		expect(result.current.data?.[0].sessions[0].pullRequest).toBeUndefined();
+	});
+
+	it("skips the PR fetch for terminated sessions", async () => {
+		respondWith({
+			projects: { data: { projects: [{ id: "proj-1", name: "my-app", path: "/p" }] }, error: undefined },
+			sessions: {
+				data: {
+					sessions: [
+						{ id: "sess-1", projectId: "proj-1", status: "merged", isTerminated: true, updatedAt: "2026-06-10T16:15:04Z" },
+					],
+				},
+				error: undefined,
+			},
+		});
+
+		const { result } = renderHook(() => useWorkspaceQuery(), { wrapper });
+		await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+		expect(getMock).not.toHaveBeenCalledWith("/api/v1/sessions/{sessionId}/pr", expect.anything());
+		expect(result.current.data?.[0].sessions[0].pullRequest).toBeUndefined();
+	});
+
 	it("marks terminated sessions regardless of their reported status", async () => {
 		respondWith({
 			projects: { data: { projects: [{ id: "proj-1", name: "my-app", path: "/p" }] }, error: undefined },

frontend/src/renderer/hooks/useWorkspaceQuery.ts

@@ -1,11 +1,25 @@
 import { useQuery } from "@tanstack/react-query";
 import { apiClient } from "../lib/api-client";
 import { mockWorkspaces } from "../lib/mock-data";
-import { toAgentProvider, toSessionStatus, type WorkspaceSummary } from "../types/workspace";
+import { toAgentProvider, toSessionStatus, type WorkspaceSession, type WorkspaceSummary } from "../types/workspace";
 
 export const workspaceQueryKey = ["workspaces"] as const;
 const usePreviewData = import.meta.env.VITE_NO_ELECTRON === "1";
 
+// GET /sessions/{sessionId}/pr is the single source of truth for PR facts — no
+// PR data rides on the session list — so we hydrate each session's lightweight
+// {number, state} here, centrally, for every consumer (Summary, Board, PR page,
+// Sidebar) that reads this query's cache. A per-session failure is treated as
+// "no PR" rather than failing the whole workspace query.
+async function fetchSessionPR(sessionId: string): Promise<WorkspaceSession["pullRequest"]> {
+	const { data, error } = await apiClient.GET("/api/v1/sessions/{sessionId}/pr", {
+		params: { path: { sessionId } },
+	});
+	if (error) return undefined;
+	const pr = data?.prs?.[0];
+	return pr ? { number: pr.number, state: pr.state } : undefined;
+}
+
 async function fetchWorkspaces(): Promise<WorkspaceSummary[]> {
 	if (usePreviewData) {
 		return mockWorkspaces;
@@ -16,11 +30,21 @@ async function fetchWorkspaces(): Promise<WorkspaceSummary[]> {
 
 	if (projectsError || sessionsError) throw projectsError ?? sessionsError;
 
+	const sessions = sessionsData?.sessions ?? [];
+	// Skip terminated sessions — their PRs are archived and the call is wasted.
+	const prBySession = new Map(
+		await Promise.all(
+			sessions
+				.filter((session) => !session.isTerminated)
+				.map(async (session) => [session.id, await fetchSessionPR(session.id)] as const),
+		),
+	);
+
 	return (projectsData?.projects ?? []).map((project) => ({
 		id: project.id,
 		name: project.name,
 		path: project.path,
-		sessions: (sessionsData?.sessions ?? [])
+		sessions: sessions
 			.filter((session) => session.projectId === project.id)
 			.map((session) => ({
 				id: session.id,
@@ -34,6 +58,7 @@ async function fetchWorkspaces(): Promise<WorkspaceSummary[]> {
 				status: toSessionStatus(session.status, session.isTerminated),
 				createdAt: session.createdAt,
 				updatedAt: session.updatedAt,
+				pullRequest: prBySession.get(session.id),
 			})),
 	}));
 }