factory-factory 0.3.20 → 0.4.0

package/dist/src/backend/services/github/service/github-cli.service.test.js

@@ -28,6 +28,7 @@ vi.mock('@/backend/services/logger.service', () => ({
 }));
 import { execFile } from 'node:child_process';
 import { deriveCiStatusFromCheckRollup } from '../../../../shared/core/index.js';
+import { classifyError } from './github-cli/errors.js';
 import { githubCLIService } from './github-cli.service.js';
 vi.mocked(execFile).mockImplementation(mockExecFile);
 describe('GitHubCLIService', () => {
@@ -45,8 +46,6 @@ describe('GitHubCLIService', () => {
                 state: 'OPEN',
                 isDraft: false,
                 reviewDecision: 'APPROVED',
-                mergedAt: null,
-                updatedAt: '2024-01-01T00:00:00Z',
                 statusCheckRollup: [],
             };
             mockExecFile.mockResolvedValue({
@@ -59,8 +58,6 @@ describe('GitHubCLIService', () => {
                 state: 'OPEN',
                 isDraft: false,
                 reviewDecision: 'APPROVED',
-                mergedAt: null,
-                updatedAt: '2024-01-01T00:00:00Z',
                 statusCheckRollup: [],
             });
         });
@@ -143,8 +140,6 @@ describe('GitHubCLIService', () => {
                 state: 'MERGED',
                 isDraft: false,
                 reviewDecision: null,
-                mergedAt: '2024-01-01T00:00:00Z',
-                updatedAt: '2024-01-01T00:00:00Z',
                 statusCheckRollup: null,
             };
             const result = githubCLIService.computePRState(status);
@@ -156,8 +151,6 @@ describe('GitHubCLIService', () => {
                 state: 'CLOSED',
                 isDraft: false,
                 reviewDecision: null,
-                mergedAt: null,
-                updatedAt: '2024-01-01T00:00:00Z',
                 statusCheckRollup: null,
             };
             const result = githubCLIService.computePRState(status);
@@ -169,8 +162,6 @@ describe('GitHubCLIService', () => {
                 state: 'OPEN',
                 isDraft: true,
                 reviewDecision: null,
-                mergedAt: null,
-                updatedAt: '2024-01-01T00:00:00Z',
                 statusCheckRollup: null,
             };
             const result = githubCLIService.computePRState(status);
@@ -182,8 +173,6 @@ describe('GitHubCLIService', () => {
                 state: 'OPEN',
                 isDraft: false,
                 reviewDecision: 'APPROVED',
-                mergedAt: null,
-                updatedAt: '2024-01-01T00:00:00Z',
                 statusCheckRollup: null,
             };
             const result = githubCLIService.computePRState(status);
@@ -195,8 +184,6 @@ describe('GitHubCLIService', () => {
                 state: 'OPEN',
                 isDraft: false,
                 reviewDecision: 'CHANGES_REQUESTED',
-                mergedAt: null,
-                updatedAt: '2024-01-01T00:00:00Z',
                 statusCheckRollup: null,
             };
             const result = githubCLIService.computePRState(status);
@@ -208,8 +195,6 @@ describe('GitHubCLIService', () => {
                 state: 'OPEN',
                 isDraft: false,
                 reviewDecision: null,
-                mergedAt: null,
-                updatedAt: '2024-01-01T00:00:00Z',
                 statusCheckRollup: null,
             };
             const result = githubCLIService.computePRState(status);
@@ -307,6 +292,11 @@ describe('GitHubCLIService', () => {
             });
         });
     });
+    describe('classifyError', () => {
+        it('classifies bad credentials and auth refresh hints as auth_required', () => {
+            expect(classifyError(new Error('HTTP 401: Bad credentials (https://api.github.com/graphql)\nTry authenticating with:  gh auth refresh -h github.com'))).toBe('auth_required');
+        });
+    });
     describe('schema validation', () => {
         describe('getPRStatus with malformed data', () => {
             it('should return null and log error when response is missing required fields', async () => {
@@ -688,14 +678,12 @@ describe('GitHubCLIService', () => {
         });
     });
     describe('computePRState edge cases', () => {
-        it('should return MERGED when mergedAt is set even if state is OPEN', () => {
+        it('should return MERGED when state is MERGED', () => {
             const status = {
                 number: 1,
-                state: 'OPEN',
+                state: 'MERGED',
                 isDraft: false,
                 reviewDecision: null,
-                mergedAt: '2024-01-01T00:00:00Z',
-                updatedAt: '2024-01-01T00:00:00Z',
                 statusCheckRollup: null,
             };
             expect(githubCLIService.computePRState(status)).toBe('MERGED');
@@ -706,8 +694,6 @@ describe('GitHubCLIService', () => {
                 state: 'OPEN',
                 isDraft: false,
                 reviewDecision: 'REVIEW_REQUIRED',
-                mergedAt: null,
-                updatedAt: '2024-01-01T00:00:00Z',
                 statusCheckRollup: null,
             };
             expect(githubCLIService.computePRState(status)).toBe('OPEN');
@@ -718,8 +704,6 @@ describe('GitHubCLIService', () => {
                 state: 'OPEN',
                 isDraft: true,
                 reviewDecision: 'APPROVED',
-                mergedAt: null,
-                updatedAt: '2024-01-01T00:00:00Z',
                 statusCheckRollup: null,
             };
             expect(githubCLIService.computePRState(status)).toBe('DRAFT');
@@ -739,8 +723,6 @@ describe('GitHubCLIService', () => {
                 state: 'OPEN',
                 isDraft: false,
                 reviewDecision: '',
-                mergedAt: null,
-                updatedAt: '2024-01-01T00:00:00Z',
                 statusCheckRollup: null,
             };
             mockExecFile.mockResolvedValue({
@@ -861,6 +843,128 @@ describe('GitHubCLIService', () => {
             ]);
         });
     });
+    describe('getResolvedReviewCommentIds', () => {
+        function makeCommentsConnection(commentIds, pageInfo = {
+            hasNextPage: false,
+            endCursor: null,
+        }) {
+            return {
+                pageInfo,
+                nodes: commentIds.map((id) => ({
+                    fullDatabaseId: id === null ? null : String(id),
+                })),
+            };
+        }
+        function makeReviewThreadsResponse(threads, pageInfo = {
+            hasNextPage: false,
+            endCursor: null,
+        }) {
+            return {
+                data: {
+                    repository: {
+                        pullRequest: {
+                            reviewThreads: {
+                                pageInfo,
+                                nodes: threads.map((thread, index) => ({
+                                    id: `thread-${index}`,
+                                    isResolved: thread.isResolved,
+                                    comments: makeCommentsConnection(thread.commentIds, thread.commentsPageInfo),
+                                })),
+                            },
+                        },
+                    },
+                },
+            };
+        }
+        it('returns comment ids from resolved threads only', async () => {
+            mockExecFile.mockResolvedValue({
+                stdout: JSON.stringify(makeReviewThreadsResponse([
+                    { isResolved: true, commentIds: [1, 2] },
+                    { isResolved: false, commentIds: [3] },
+                    { isResolved: true, commentIds: [3_590_714_831, null] },
+                ])),
+                stderr: '',
+            });
+            const result = await githubCLIService.getResolvedReviewCommentIds('owner/repo', 123);
+            expect(result).toEqual(new Set([1, 2, 3_590_714_831]));
+        });
+        it('paginates review threads until hasNextPage is false', async () => {
+            mockExecFile
+                .mockResolvedValueOnce({
+                stdout: JSON.stringify(makeReviewThreadsResponse([{ isResolved: true, commentIds: [1] }], {
+                    hasNextPage: true,
+                    endCursor: 'cursor-1',
+                })),
+                stderr: '',
+            })
+                .mockResolvedValueOnce({
+                stdout: JSON.stringify(makeReviewThreadsResponse([{ isResolved: true, commentIds: [2] }])),
+                stderr: '',
+            });
+            const result = await githubCLIService.getResolvedReviewCommentIds('owner/repo', 123);
+            expect(result).toEqual(new Set([1, 2]));
+            expect(mockExecFile).toHaveBeenCalledTimes(2);
+            const secondQuery = mockExecFile.mock.calls[1]?.[1]?.join(' ');
+            expect(secondQuery).toContain('after: "cursor-1"');
+        });
+        it('pages through a resolved thread with more than one page of comments', async () => {
+            mockExecFile
+                .mockResolvedValueOnce({
+                stdout: JSON.stringify(makeReviewThreadsResponse([
+                    {
+                        isResolved: true,
+                        commentIds: [1],
+                        commentsPageInfo: { hasNextPage: true, endCursor: 'comment-cursor-1' },
+                    },
+                    { isResolved: false, commentIds: [2] },
+                ])),
+                stderr: '',
+            })
+                .mockResolvedValueOnce({
+                stdout: JSON.stringify({
+                    data: {
+                        node: {
+                            comments: makeCommentsConnection([3], {
+                                hasNextPage: true,
+                                endCursor: 'comment-cursor-2',
+                            }),
+                        },
+                    },
+                }),
+                stderr: '',
+            })
+                .mockResolvedValueOnce({
+                stdout: JSON.stringify({
+                    data: { node: { comments: makeCommentsConnection([4]) } },
+                }),
+                stderr: '',
+            });
+            const result = await githubCLIService.getResolvedReviewCommentIds('owner/repo', 123);
+            expect(result).toEqual(new Set([1, 3, 4]));
+            expect(mockExecFile).toHaveBeenCalledTimes(3);
+            const tailQuery = mockExecFile.mock.calls[1]?.[1]?.join(' ');
+            expect(tailQuery).toContain('node(id: "thread-0")');
+            expect(tailQuery).toContain('after: "comment-cursor-1"');
+            const secondTailQuery = mockExecFile.mock.calls[2]?.[1]?.join(' ');
+            expect(secondTailQuery).toContain('after: "comment-cursor-2"');
+        });
+        it('returns an empty set when the PR is not found', async () => {
+            mockExecFile.mockResolvedValue({
+                stdout: JSON.stringify({ data: { repository: { pullRequest: null } } }),
+                stderr: '',
+            });
+            const result = await githubCLIService.getResolvedReviewCommentIds('owner/repo', 123);
+            expect(result).toEqual(new Set());
+        });
+        it('throws when the gh CLI call fails', async () => {
+            mockExecFile.mockRejectedValue(new Error('network down'));
+            await expect(githubCLIService.getResolvedReviewCommentIds('owner/repo', 123)).rejects.toThrow('Failed to fetch resolved review threads: network down');
+        });
+        it('throws on an invalid repo format', async () => {
+            await expect(githubCLIService.getResolvedReviewCommentIds('bad-repo', 123)).rejects.toThrow('Invalid repo format');
+            expect(mockExecFile).not.toHaveBeenCalled();
+        });
+    });
     describe('checkHealth edge cases', () => {
         it('should return generic error for non-installation failures', async () => {
             mockExecFile.mockRejectedValue(new Error('something weird'));
@@ -886,8 +990,6 @@ describe('GitHubCLIService', () => {
                 state: 'OPEN',
                 isDraft: false,
                 reviewDecision: 'REVIEW_REQUIRED',
-                mergedAt: null,
-                updatedAt: '2026-02-01T00:00:00Z',
                 statusCheckRollup: [{ status: 'COMPLETED', conclusion: 'SUCCESS' }],
             });
             const result = await githubCLIService.fetchAndComputePRState('https://github.com/o/r/pull/77');
@@ -896,6 +998,7 @@ describe('GitHubCLIService', () => {
                 prNumber: 77,
                 prReviewState: 'REVIEW_REQUIRED',
                 prCiStatus: 'SUCCESS',
+                headRefName: null,
             });
             getStatusSpy.mockRestore();
         });
@@ -904,28 +1007,29 @@ describe('GitHubCLIService', () => {
             await expect(githubCLIService.fetchAndComputePRState('https://github.com/o/r/pull/99')).resolves.toBeNull();
             getStatusSpy.mockRestore();
         });
-        it('lists review requests and enriches with per-PR details', async () => {
-            mockExecFile
-                .mockResolvedValueOnce({
-                stdout: JSON.stringify([
-                    {
-                        number: 12,
-                        title: 'Fix bug',
-                        url: 'https://github.com/o/r/pull/12',
-                        repository: { nameWithOwner: 'o/r' },
-                        author: { login: 'alice' },
-                        createdAt: '2026-01-10T00:00:00Z',
-                        isDraft: false,
-                    },
-                ]),
-                stderr: '',
-            })
-                .mockResolvedValueOnce({
+        it('lists review requests via single GraphQL call', async () => {
+            mockExecFile.mockResolvedValueOnce({
                 stdout: JSON.stringify({
-                    reviewDecision: 'APPROVED',
-                    additions: 10,
-                    deletions: 3,
-                    changedFiles: 2,
+                    data: {
+                        search: {
+                            pageInfo: { hasNextPage: false, endCursor: null },
+                            nodes: [
+                                {
+                                    number: 12,
+                                    title: 'Fix bug',
+                                    url: 'https://github.com/o/r/pull/12',
+                                    repository: { nameWithOwner: 'o/r' },
+                                    author: { login: 'alice' },
+                                    createdAt: '2026-01-10T00:00:00Z',
+                                    isDraft: false,
+                                    reviewDecision: 'APPROVED',
+                                    additions: 10,
+                                    deletions: 3,
+                                    changedFiles: 2,
+                                },
+                            ],
+                        },
+                    },
                 }),
                 stderr: '',
             });
@@ -944,31 +1048,76 @@ describe('GitHubCLIService', () => {
                     changedFiles: 2,
                 },
             ]);
+            expect(mockExecFile).toHaveBeenCalledTimes(1);
         });
-        it('falls back to default details when per-PR detail lookup fails', async () => {
+        it('paginates review requests until GitHub search has no next page', async () => {
             mockExecFile
                 .mockResolvedValueOnce({
-                stdout: JSON.stringify([
-                    {
-                        number: 13,
-                        title: 'Fallback test',
-                        url: 'https://github.com/o/r/pull/13',
-                        repository: { nameWithOwner: 'o/r' },
-                        author: { login: 'bob' },
-                        createdAt: '2026-01-11T00:00:00Z',
-                        isDraft: true,
+                stdout: JSON.stringify({
+                    data: {
+                        search: {
+                            pageInfo: { hasNextPage: true, endCursor: 'cursor-1' },
+                            nodes: [
+                                {
+                                    number: 50,
+                                    title: 'Boundary PR',
+                                    url: 'https://github.com/o/r/pull/50',
+                                    repository: { nameWithOwner: 'o/r' },
+                                    author: { login: 'alice' },
+                                    createdAt: '2026-01-10T00:00:00Z',
+                                    isDraft: false,
+                                    reviewDecision: null,
+                                    additions: 1,
+                                    deletions: 2,
+                                    changedFiles: 3,
+                                },
+                            ],
+                        },
                     },
-                ]),
+                }),
                 stderr: '',
             })
-                .mockRejectedValueOnce(new Error('gh pr view failed'));
+                .mockResolvedValueOnce({
+                stdout: JSON.stringify({
+                    data: {
+                        search: {
+                            pageInfo: { hasNextPage: false, endCursor: 'cursor-2' },
+                            nodes: [
+                                {
+                                    number: 51,
+                                    title: 'Overflow PR',
+                                    url: 'https://github.com/o/r/pull/51',
+                                    repository: { nameWithOwner: 'o/r' },
+                                    author: null,
+                                    createdAt: '2026-01-11T00:00:00Z',
+                                    isDraft: true,
+                                },
+                            ],
+                        },
+                    },
+                }),
+                stderr: '',
+            });
             await expect(githubCLIService.listReviewRequests()).resolves.toEqual([
                 {
-                    number: 13,
-                    title: 'Fallback test',
-                    url: 'https://github.com/o/r/pull/13',
+                    number: 50,
+                    title: 'Boundary PR',
+                    url: 'https://github.com/o/r/pull/50',
+                    repository: { nameWithOwner: 'o/r' },
+                    author: { login: 'alice' },
+                    createdAt: '2026-01-10T00:00:00Z',
+                    isDraft: false,
+                    reviewDecision: null,
+                    additions: 1,
+                    deletions: 2,
+                    changedFiles: 3,
+                },
+                {
+                    number: 51,
+                    title: 'Overflow PR',
+                    url: 'https://github.com/o/r/pull/51',
                     repository: { nameWithOwner: 'o/r' },
-                    author: { login: 'bob' },
+                    author: { login: '' },
                     createdAt: '2026-01-11T00:00:00Z',
                     isDraft: true,
                     reviewDecision: null,
@@ -977,6 +1126,90 @@ describe('GitHubCLIService', () => {
                     changedFiles: 0,
                 },
             ]);
+            expect(mockExecFile).toHaveBeenCalledTimes(2);
+            expect(mockExecFile.mock.calls[1]?.[1]).toEqual(expect.arrayContaining([expect.stringContaining('after: "cursor-1"')]));
+        });
+        it('caps review request pagination at 20 pages', async () => {
+            const continuingPage = {
+                stdout: JSON.stringify({
+                    data: {
+                        search: {
+                            pageInfo: { hasNextPage: true, endCursor: 'repeated-cursor' },
+                            nodes: [],
+                        },
+                    },
+                }),
+                stderr: '',
+            };
+            for (let page = 0; page < 20; page++) {
+                mockExecFile.mockResolvedValueOnce(continuingPage);
+            }
+            mockExecFile.mockRejectedValueOnce(new Error('unexpected 21st page request'));
+            try {
+                await expect(githubCLIService.listReviewRequests()).resolves.toEqual([]);
+                expect(mockExecFile).toHaveBeenCalledTimes(20);
+                expect(mockLoggerWarn).toHaveBeenCalledWith('listReviewRequests: reached MAX_PAGES limit, results may be incomplete', {
+                    totalFetched: 0,
+                    maxPages: 20,
+                });
+            }
+            finally {
+                mockExecFile.mockReset();
+            }
+        });
+        it('falls back to empty array when GraphQL response is malformed', async () => {
+            mockExecFile.mockResolvedValueOnce({
+                stdout: JSON.stringify({ data: { search: { nodes: 'not-an-array' } } }),
+                stderr: '',
+            });
+            await expect(githubCLIService.listReviewRequests()).resolves.toEqual([]);
+        });
+        it('keeps fetched review requests when a later GraphQL page is malformed', async () => {
+            mockExecFile
+                .mockResolvedValueOnce({
+                stdout: JSON.stringify({
+                    data: {
+                        search: {
+                            pageInfo: { hasNextPage: true, endCursor: 'cursor-1' },
+                            nodes: [
+                                {
+                                    number: 50,
+                                    title: 'Boundary PR',
+                                    url: 'https://github.com/o/r/pull/50',
+                                    repository: { nameWithOwner: 'o/r' },
+                                    author: { login: 'alice' },
+                                    createdAt: '2026-01-10T00:00:00Z',
+                                    isDraft: false,
+                                    reviewDecision: null,
+                                    additions: 1,
+                                    deletions: 2,
+                                    changedFiles: 3,
+                                },
+                            ],
+                        },
+                    },
+                }),
+                stderr: '',
+            })
+                .mockResolvedValueOnce({
+                stdout: JSON.stringify({ data: { search: { nodes: 'not-an-array' } } }),
+                stderr: '',
+            });
+            await expect(githubCLIService.listReviewRequests()).resolves.toEqual([
+                {
+                    number: 50,
+                    title: 'Boundary PR',
+                    url: 'https://github.com/o/r/pull/50',
+                    repository: { nameWithOwner: 'o/r' },
+                    author: { login: 'alice' },
+                    createdAt: '2026-01-10T00:00:00Z',
+                    isDraft: false,
+                    reviewDecision: null,
+                    additions: 1,
+                    deletions: 2,
+                    changedFiles: 3,
+                },
+            ]);
         });
         it('approves PR and logs failures with contextual error', async () => {
             mockExecFile.mockResolvedValueOnce({ stdout: '', stderr: '' });
@@ -1071,14 +1304,127 @@ describe('GitHubCLIService', () => {
         });
     });
     describe('centralized exec - singleflight dedup', () => {
+        it('passes abort signals to authenticated-user lookups', async () => {
+            const controller = new AbortController();
+            mockExecFile.mockResolvedValue({ stdout: 'octocat\n', stderr: '' });
+            await expect(githubCLIService.getAuthenticatedUsername(controller.signal)).resolves.toBe('octocat');
+            expect(mockExecFile).toHaveBeenCalledWith('gh', ['api', 'user', '--jq', '.login'], expect.objectContaining({ signal: controller.signal }));
+        });
+        it('passes abort signals to PR detail child processes', async () => {
+            const controller = new AbortController();
+            mockExecFile.mockResolvedValue({
+                stdout: JSON.stringify({
+                    number: 42,
+                    title: 'PR',
+                    url: 'https://github.com/owner/repo/pull/42',
+                    author: { login: 'author' },
+                    createdAt: '2026-01-01T00:00:00Z',
+                    updatedAt: '2026-01-01T00:00:00Z',
+                    isDraft: false,
+                    state: 'OPEN',
+                    reviewDecision: null,
+                    statusCheckRollup: [],
+                    reviews: [],
+                    comments: [],
+                    labels: [],
+                    additions: 0,
+                    deletions: 0,
+                    changedFiles: 0,
+                    headRefName: 'feature',
+                    baseRefName: 'main',
+                    mergeStateStatus: 'CLEAN',
+                }),
+                stderr: '',
+            });
+            await githubCLIService.getPRFullDetails('owner/repo', 42, controller.signal);
+            expect(mockExecFile).toHaveBeenCalledWith('gh', expect.any(Array), expect.objectContaining({ signal: controller.signal }));
+        });
+        it('passes abort signals to review comment child processes', async () => {
+            const controller = new AbortController();
+            mockExecFile.mockResolvedValue({ stdout: '[]', stderr: '' });
+            await githubCLIService.getReviewComments('owner/repo', 42, undefined, controller.signal);
+            expect(mockExecFile).toHaveBeenCalledWith('gh', expect.any(Array), expect.objectContaining({ signal: controller.signal }));
+        });
+        it('does not singleflight identical signal-bound PR reads', async () => {
+            const first = new AbortController();
+            const second = new AbortController();
+            const prDetails = {
+                number: 42,
+                title: 'PR',
+                url: 'https://github.com/owner/repo/pull/42',
+                author: { login: 'author' },
+                createdAt: '2026-01-01T00:00:00Z',
+                updatedAt: '2026-01-01T00:00:00Z',
+                isDraft: false,
+                state: 'OPEN',
+                reviewDecision: null,
+                statusCheckRollup: [],
+                reviews: [],
+                comments: [],
+                labels: [],
+                additions: 0,
+                deletions: 0,
+                changedFiles: 0,
+                headRefName: 'feature',
+                baseRefName: 'main',
+                mergeStateStatus: 'CLEAN',
+            };
+            mockExecFile.mockResolvedValue({ stdout: JSON.stringify(prDetails), stderr: '' });
+            await Promise.all([
+                githubCLIService.getPRFullDetails('owner/repo', 42, first.signal),
+                githubCLIService.getPRFullDetails('owner/repo', 42, second.signal),
+            ]);
+            expect(mockExecFile).toHaveBeenCalledTimes(2);
+        });
+        it('does not spawn a signal-bound read that is cancelled while queued', async () => {
+            const prDetails = {
+                number: 42,
+                title: 'PR',
+                url: 'https://github.com/owner/repo/pull/42',
+                author: { login: 'author' },
+                createdAt: '2026-01-01T00:00:00Z',
+                updatedAt: '2026-01-01T00:00:00Z',
+                isDraft: false,
+                state: 'OPEN',
+                reviewDecision: null,
+                statusCheckRollup: [],
+                reviews: [],
+                comments: [],
+                labels: [],
+                additions: 0,
+                deletions: 0,
+                changedFiles: 0,
+                headRefName: 'feature',
+                baseRefName: 'main',
+                mergeStateStatus: 'CLEAN',
+            };
+            const releases = [];
+            mockExecFile.mockImplementation(() => new Promise((resolve) => {
+                releases.push(() => resolve({ stdout: JSON.stringify(prDetails), stderr: '' }));
+            }));
+            const blockers = Array.from({ length: 5 }, (_, index) => {
+                const controller = new AbortController();
+                return githubCLIService.getPRFullDetails('owner/repo', index + 1, controller.signal);
+            });
+            await vi.waitFor(() => expect(mockExecFile).toHaveBeenCalledTimes(5));
+            const queuedController = new AbortController();
+            const abortReason = new Error('queued request cancelled');
+            const queued = githubCLIService.getPRFullDetails('owner/repo', 99, queuedController.signal);
+            queuedController.abort(abortReason);
+            releases.shift()?.();
+            await expect(queued).rejects.toBe(abortReason);
+            expect(mockExecFile).toHaveBeenCalledTimes(5);
+            for (const release of releases) {
+                release();
+            }
+            await Promise.all(blockers);
+        });
         it('deduplicates identical concurrent read calls', async () => {
             const mockPRData = {
                 number: 42,
                 state: 'OPEN',
                 isDraft: false,
                 reviewDecision: null,
-                mergedAt: null,
-                updatedAt: '2024-01-01T00:00:00Z',
                 statusCheckRollup: [],
             };
             mockExecFile.mockResolvedValue({
@@ -1099,8 +1445,6 @@ describe('GitHubCLIService', () => {
                 state: 'OPEN',
                 isDraft: false,
                 reviewDecision: null,
-                mergedAt: null,
-                updatedAt: '2024-01-01T00:00:00Z',
                 statusCheckRollup: [],
             });
             mockExecFile
@@ -1120,8 +1464,6 @@ describe('GitHubCLIService', () => {
                 state: 'OPEN',
                 isDraft: false,
                 reviewDecision: null,
-                mergedAt: null,
-                updatedAt: '2024-01-01T00:00:00Z',
                 statusCheckRollup: [],
             };
             mockExecFile.mockResolvedValue({ stdout: JSON.stringify(mockPRData), stderr: '' });