github-issue-tower-defence-management 1.126.1 → 1.126.3

package/src/adapter/repositories/FileSystemSessionOutputActivityRepository.test.ts

@@ -25,6 +25,14 @@ describe('FileSystemSessionOutputActivityRepository', () => {
     },
   });
 
+  const assistantEntryWithoutTimestamp = (): object => ({
+    type: 'assistant',
+    message: {
+      role: 'assistant',
+      content: [{ type: 'text', text: 'no timestamp on this entry' }],
+    },
+  });
+
   const userEntry = (timestamp: string): object => ({
     type: 'user',
     timestamp,
@@ -37,6 +45,51 @@ describe('FileSystemSessionOutputActivityRepository', () => {
     toolUseResult: { stdout: 'done', stderr: '' },
   });
 
+  const systemEntry = (timestamp: string): object => ({
+    type: 'system',
+    timestamp,
+    content: 'Compacting conversation history',
+  });
+
+  const assistantEntryWithToolUse = (
+    timestamp: string,
+    toolUseId: string,
+  ): object => ({
+    type: 'assistant',
+    timestamp,
+    message: {
+      role: 'assistant',
+      stop_reason: 'tool_use',
+      content: [
+        { type: 'text', text: 'running a command' },
+        {
+          type: 'tool_use',
+          id: toolUseId,
+          name: 'Bash',
+          input: { command: 'sleep 590' },
+        },
+      ],
+    },
+  });
+
+  const toolResultUserEntry = (
+    timestamp: string,
+    toolUseId: string,
+  ): object => ({
+    type: 'user',
+    timestamp,
+    message: {
+      role: 'user',
+      content: [
+        {
+          type: 'tool_result',
+          tool_use_id: toolUseId,
+          content: 'done',
+        },
+      ],
+    },
+  });
+
   const untimestampedEntry = (): object => ({
     type: 'summary',
     summary: 'no timestamp on this entry',
@@ -52,11 +105,56 @@ describe('FileSystemSessionOutputActivityRepository', () => {
     return filePath;
   };
 
-  it('returns the latest entry timestamp of any type as the last activity epoch', async () => {
+  it('returns the old last-assistant timestamp when recent system and tool entries follow it', async () => {
+    const transcriptPath = writeTranscript('thrashing.jsonl', [
+      assistantEntry('2026-06-27T01:00:00.000Z'),
+      systemEntry('2026-06-27T09:30:00.000Z'),
+      toolResultEntry('2026-06-27T09:45:00.000Z'),
+      systemEntry('2026-06-27T10:00:00.000Z'),
+    ]);
+    const repository = new FileSystemSessionOutputActivityRepository();
+
+    const result = await repository.listSessionOutputActivities(
+      new Map([['thrashing', transcriptPath]]),
+    );
+
+    expect(result).toEqual([
+      {
+        sessionName: 'thrashing',
+        lastOutputEpochSeconds: Math.floor(
+          Date.parse('2026-06-27T01:00:00.000Z') / 1000,
+        ),
+        hasInProgressToolCall: false,
+      },
+    ]);
+  });
+
+  it('returns the recent timestamp when the latest assistant entry is recent', async () => {
+    const transcriptPath = writeTranscript('working.jsonl', [
+      userEntry('2026-06-27T09:00:00.000Z'),
+      assistantEntry('2026-06-27T09:55:00.000Z'),
+    ]);
+    const repository = new FileSystemSessionOutputActivityRepository();
+
+    const result = await repository.listSessionOutputActivities(
+      new Map([['working', transcriptPath]]),
+    );
+
+    expect(result).toEqual([
+      {
+        sessionName: 'working',
+        lastOutputEpochSeconds: Math.floor(
+          Date.parse('2026-06-27T09:55:00.000Z') / 1000,
+        ),
+        hasInProgressToolCall: false,
+      },
+    ]);
+  });
+
+  it('ignores a later user entry and returns the last assistant timestamp', async () => {
     const transcriptPath = writeTranscript('workbench.jsonl', [
       assistantEntry('2026-06-27T10:00:00.000Z'),
-      userEntry('2026-06-27T10:30:00.000Z'),
-      assistantEntry('2026-06-27T10:05:00.000Z'),
+      userEntry('2026-06-27T11:00:00.000Z'),
     ]);
     const repository = new FileSystemSessionOutputActivityRepository();
 
@@ -68,16 +166,41 @@ describe('FileSystemSessionOutputActivityRepository', () => {
       {
         sessionName: 'workbench',
         lastOutputEpochSeconds: Math.floor(
-          Date.parse('2026-06-27T10:30:00.000Z') / 1000,
+          Date.parse('2026-06-27T10:00:00.000Z') / 1000,
         ),
+        hasInProgressToolCall: false,
       },
     ]);
   });
 
-  it('advances the last activity time when a later user entry follows an assistant entry', async () => {
+  it('ignores a later tool_result entry and returns the last assistant timestamp', async () => {
     const transcriptPath = writeTranscript('workbench.jsonl', [
       assistantEntry('2026-06-27T10:00:00.000Z'),
-      userEntry('2026-06-27T11:00:00.000Z'),
+      toolResultEntry('2026-06-27T10:45:00.000Z'),
+    ]);
+    const repository = new FileSystemSessionOutputActivityRepository();
+
+    const result = await repository.listSessionOutputActivities(
+      new Map([['workbench', transcriptPath]]),
+    );
+
+    expect(result).toEqual([
+      {
+        sessionName: 'workbench',
+        lastOutputEpochSeconds: Math.floor(
+          Date.parse('2026-06-27T10:00:00.000Z') / 1000,
+        ),
+        hasInProgressToolCall: false,
+      },
+    ]);
+  });
+
+  it('returns the last assistant entry timestamp when several entry types interleave', async () => {
+    const transcriptPath = writeTranscript('workbench.jsonl', [
+      assistantEntry('2026-06-27T10:00:00.000Z'),
+      userEntry('2026-06-27T10:10:00.000Z'),
+      assistantEntry('2026-06-27T10:05:00.000Z'),
+      systemEntry('2026-06-27T10:40:00.000Z'),
     ]);
     const repository = new FileSystemSessionOutputActivityRepository();
 
@@ -89,16 +212,17 @@ describe('FileSystemSessionOutputActivityRepository', () => {
       {
         sessionName: 'workbench',
         lastOutputEpochSeconds: Math.floor(
-          Date.parse('2026-06-27T11:00:00.000Z') / 1000,
+          Date.parse('2026-06-27T10:05:00.000Z') / 1000,
         ),
+        hasInProgressToolCall: false,
       },
     ]);
   });
 
-  it('advances the last activity time when a tool_result entry is the latest entry', async () => {
+  it('falls back to the last assistant entry that has a parseable timestamp', async () => {
     const transcriptPath = writeTranscript('workbench.jsonl', [
       assistantEntry('2026-06-27T10:00:00.000Z'),
-      toolResultEntry('2026-06-27T10:45:00.000Z'),
+      assistantEntryWithoutTimestamp(),
     ]);
     const repository = new FileSystemSessionOutputActivityRepository();
 
@@ -110,8 +234,9 @@ describe('FileSystemSessionOutputActivityRepository', () => {
       {
         sessionName: 'workbench',
         lastOutputEpochSeconds: Math.floor(
-          Date.parse('2026-06-27T10:45:00.000Z') / 1000,
+          Date.parse('2026-06-27T10:00:00.000Z') / 1000,
         ),
+        hasInProgressToolCall: false,
       },
     ]);
   });
@@ -135,13 +260,29 @@ describe('FileSystemSessionOutputActivityRepository', () => {
         lastOutputEpochSeconds: Math.floor(
           Date.parse('2026-06-27T10:00:00.000Z') / 1000,
         ),
+        hasInProgressToolCall: false,
       },
     ]);
   });
 
-  it('resolves a transcript whose only entry is a non-assistant entry', async () => {
+  it('omits a transcript whose only entries are non-assistant entries', async () => {
     const transcriptPath = writeTranscript('workbench.jsonl', [
       userEntry('2026-06-27T10:00:00.000Z'),
+      toolResultEntry('2026-06-27T10:05:00.000Z'),
+      systemEntry('2026-06-27T10:10:00.000Z'),
+    ]);
+    const repository = new FileSystemSessionOutputActivityRepository();
+
+    const result = await repository.listSessionOutputActivities(
+      new Map([['workbench', transcriptPath]]),
+    );
+
+    expect(result).toEqual([]);
+  });
+
+  it('omits sessions whose transcript has no parseable timestamp', async () => {
+    const transcriptPath = writeTranscript('workbench.jsonl', [
+      untimestampedEntry(),
     ]);
     const repository = new FileSystemSessionOutputActivityRepository();
 
@@ -149,27 +290,51 @@ describe('FileSystemSessionOutputActivityRepository', () => {
       new Map([['workbench', transcriptPath]]),
     );
 
+    expect(result).toEqual([]);
+  });
+
+  it('flags a session as waiting on a running tool when the last assistant tool_use has no matching tool_result', async () => {
+    const transcriptPath = writeTranscript('busy.jsonl', [
+      assistantEntry('2026-06-27T09:00:00.000Z'),
+      assistantEntryWithToolUse('2026-06-27T09:01:00.000Z', 'toolu_running'),
+    ]);
+    const repository = new FileSystemSessionOutputActivityRepository();
+
+    const result = await repository.listSessionOutputActivities(
+      new Map([['busy', transcriptPath]]),
+    );
+
     expect(result).toEqual([
       {
-        sessionName: 'workbench',
+        sessionName: 'busy',
         lastOutputEpochSeconds: Math.floor(
-          Date.parse('2026-06-27T10:00:00.000Z') / 1000,
+          Date.parse('2026-06-27T09:01:00.000Z') / 1000,
         ),
+        hasInProgressToolCall: true,
       },
     ]);
   });
 
-  it('omits sessions whose transcript has no parseable timestamp', async () => {
-    const transcriptPath = writeTranscript('workbench.jsonl', [
-      untimestampedEntry(),
+  it('does not flag a session once the matching tool_result for its last tool_use is appended', async () => {
+    const transcriptPath = writeTranscript('completed.jsonl', [
+      assistantEntryWithToolUse('2026-06-27T09:01:00.000Z', 'toolu_done'),
+      toolResultUserEntry('2026-06-27T09:05:00.000Z', 'toolu_done'),
     ]);
     const repository = new FileSystemSessionOutputActivityRepository();
 
     const result = await repository.listSessionOutputActivities(
-      new Map([['workbench', transcriptPath]]),
+      new Map([['completed', transcriptPath]]),
     );
 
-    expect(result).toEqual([]);
+    expect(result).toEqual([
+      {
+        sessionName: 'completed',
+        lastOutputEpochSeconds: Math.floor(
+          Date.parse('2026-06-27T09:01:00.000Z') / 1000,
+        ),
+        hasInProgressToolCall: false,
+      },
+    ]);
   });
 
   it('returns an empty list when no sessions are requested', async () => {

package/src/adapter/repositories/FileSystemSessionOutputActivityRepository.ts

@@ -21,41 +21,54 @@ const parseEpochMilliseconds = (timestamp: string | null): number | null => {
   return Number.isNaN(parsed) ? null : parsed;
 };
 
-/**
- * Reads the last main-session activity time for each live session from its
- * already-resolved transcript path. Idle time is computed from the timestamp of
- * the latest entry of any kind (assistant text, owner replies, tool results, or
- * any other entry type) rather than from the transcript file modification time.
- * Because a session that is actively running tool calls keeps appending entries
- * such as `user` and `tool_result` even while it emits no assistant text, every
- * entry with a parseable timestamp counts as activity, so a working session is
- * not mistaken for a silent one.
- */
+const readContentBlocks = (
+  message: Record<string, unknown>,
+): Record<string, unknown>[] => {
+  const content = message.content;
+  if (!Array.isArray(content)) {
+    return [];
+  }
+  return content.filter(isRecord);
+};
+
+type TranscriptActivity = {
+  lastAssistantOutputEpochSeconds: number | null;
+  hasInProgressToolCall: boolean;
+};
+
 export class FileSystemSessionOutputActivityRepository implements SessionOutputActivityRepository {
   listSessionOutputActivities = async (
     transcriptPathBySessionName: Map<string, string>,
   ): Promise<LiveSessionOutputActivity[]> => {
     const activities: LiveSessionOutputActivity[] = [];
     for (const [sessionName, transcriptPath] of transcriptPathBySessionName) {
-      const lastOutputEpochSeconds =
-        this.readLastActivityEpochSeconds(transcriptPath);
-      if (lastOutputEpochSeconds !== null) {
-        activities.push({ sessionName, lastOutputEpochSeconds });
+      const { lastAssistantOutputEpochSeconds, hasInProgressToolCall } =
+        this.readTranscriptActivity(transcriptPath);
+      if (lastAssistantOutputEpochSeconds !== null) {
+        activities.push({
+          sessionName,
+          lastOutputEpochSeconds: lastAssistantOutputEpochSeconds,
+          hasInProgressToolCall,
+        });
       }
     }
     return activities;
   };
 
-  private readLastActivityEpochSeconds = (
+  private readTranscriptActivity = (
     transcriptPath: string,
-  ): number | null => {
+  ): TranscriptActivity => {
     let content: string;
     try {
       content = fs.readFileSync(transcriptPath, 'utf8');
     } catch {
-      return null;
+      return {
+        lastAssistantOutputEpochSeconds: null,
+        hasInProgressToolCall: false,
+      };
     }
-    let lastActivityEpochMs: number | null = null;
+    let lastAssistantOutputEpochMs: number | null = null;
+    const pendingToolUseIds = new Set<string>();
     for (const line of content.split('\n')) {
       const trimmed = line.trim();
       if (trimmed.length === 0) {
@@ -70,17 +83,37 @@ export class FileSystemSessionOutputActivityRepository implements SessionOutputA
       if (!isRecord(parsed)) {
         continue;
       }
-      const epochMs = parseEpochMilliseconds(readString(parsed, 'timestamp'));
-      if (epochMs === null) {
+      const message = parsed.message;
+      if (readString(parsed, 'type') === 'assistant') {
+        const epochMs = parseEpochMilliseconds(readString(parsed, 'timestamp'));
+        if (epochMs !== null) {
+          lastAssistantOutputEpochMs = epochMs;
+        }
+      }
+      if (!isRecord(message)) {
         continue;
       }
-      if (lastActivityEpochMs === null || epochMs > lastActivityEpochMs) {
-        lastActivityEpochMs = epochMs;
+      for (const block of readContentBlocks(message)) {
+        const blockType = readString(block, 'type');
+        if (blockType === 'tool_use') {
+          const toolUseId = readString(block, 'id');
+          if (toolUseId !== null) {
+            pendingToolUseIds.add(toolUseId);
+          }
+        } else if (blockType === 'tool_result') {
+          const toolUseId = readString(block, 'tool_use_id');
+          if (toolUseId !== null) {
+            pendingToolUseIds.delete(toolUseId);
+          }
+        }
       }
     }
-    if (lastActivityEpochMs === null) {
-      return null;
-    }
-    return Math.floor(lastActivityEpochMs / 1000);
+    return {
+      lastAssistantOutputEpochSeconds:
+        lastAssistantOutputEpochMs === null
+          ? null
+          : Math.floor(lastAssistantOutputEpochMs / 1000),
+      hasInProgressToolCall: pendingToolUseIds.size > 0,
+    };
   };
 }

package/src/adapter/repositories/issue/GraphqlProjectItemRepository.test.ts

@@ -838,6 +838,154 @@ describe('GraphqlProjectItemRepository', () => {
 
       expect(result.map((item) => item.id)).toEqual(['PVTI_1']);
     });
+
+    it('retries the full fetch exactly once when the last page reports fewer accumulated items than totalCount and returns the consistent retry result', async () => {
+      const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+      const repository = new GraphqlProjectItemRepository(
+        new LocalStorageRepository(),
+        'dummy-token',
+      );
+      mockPost
+        .mockReturnValueOnce(
+          makeLightPageResponse(
+            false,
+            'cursor-1',
+            [
+              {
+                id: 'PVTI_1',
+                updatedAt: '2026-07-07T10:00:00Z',
+                content: { url: 'https://github.com/o/r/issues/1', number: 1 },
+              },
+            ],
+            2,
+          ),
+        )
+        .mockReturnValueOnce(
+          makeLightPageResponse(
+            false,
+            'cursor-1',
+            [
+              {
+                id: 'PVTI_1',
+                updatedAt: '2026-07-07T10:00:00Z',
+                content: { url: 'https://github.com/o/r/issues/1', number: 1 },
+              },
+              {
+                id: 'PVTI_2',
+                updatedAt: '2026-07-07T11:00:00Z',
+                content: { url: 'https://github.com/o/r/issues/2', number: 2 },
+              },
+            ],
+            2,
+          ),
+        );
+
+      const result = await repository.fetchProjectItemsLight(
+        'test-project-id',
+        'updated:>=2026-07-07',
+      );
+
+      expect(mockPost).toHaveBeenCalledTimes(2);
+      expect(result.map((item) => item.id)).toEqual(['PVTI_1', 'PVTI_2']);
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining(
+          'page 1 has 1 nodes with hasNextPage=false but only 1/2 items accumulated',
+        ),
+      );
+      warnSpy.mockRestore();
+    });
+
+    it('warns and returns the accumulated items without throwing when the retry is still inconsistent', async () => {
+      const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+      const repository = new GraphqlProjectItemRepository(
+        new LocalStorageRepository(),
+        'dummy-token',
+      );
+      const inconsistentPage = () =>
+        makeLightPageResponse(
+          false,
+          'cursor-1',
+          [
+            {
+              id: 'PVTI_1',
+              updatedAt: '2026-07-07T10:00:00Z',
+              content: { url: 'https://github.com/o/r/issues/1', number: 1 },
+            },
+          ],
+          2,
+        );
+      mockPost
+        .mockReturnValueOnce(inconsistentPage())
+        .mockReturnValueOnce(inconsistentPage());
+
+      const result = await repository.fetchProjectItemsLight(
+        'test-project-id',
+        'updated:>=2026-07-07',
+      );
+
+      expect(mockPost).toHaveBeenCalledTimes(2);
+      expect(result.map((item) => item.id)).toEqual(['PVTI_1']);
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining(
+          'page 1 has 1 nodes with hasNextPage=false but only 1/2 items accumulated',
+        ),
+      );
+      warnSpy.mockRestore();
+    });
+
+    it('retries exactly once when the accumulated count exceeds totalCount after the loop and returns the consistent retry result', async () => {
+      const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+      const repository = new GraphqlProjectItemRepository(
+        new LocalStorageRepository(),
+        'dummy-token',
+      );
+      mockPost
+        .mockReturnValueOnce(
+          makeLightPageResponse(
+            false,
+            'cursor-1',
+            [
+              {
+                id: 'PVTI_1',
+                updatedAt: '2026-07-07T10:00:00Z',
+                content: { url: 'https://github.com/o/r/issues/1', number: 1 },
+              },
+              {
+                id: 'PVTI_2',
+                updatedAt: '2026-07-07T11:00:00Z',
+                content: { url: 'https://github.com/o/r/issues/2', number: 2 },
+              },
+            ],
+            1,
+          ),
+        )
+        .mockReturnValueOnce(
+          makeLightPageResponse(
+            false,
+            'cursor-1',
+            [
+              {
+                id: 'PVTI_1',
+                updatedAt: '2026-07-07T10:00:00Z',
+                content: { url: 'https://github.com/o/r/issues/1', number: 1 },
+              },
+            ],
+            1,
+          ),
+        );
+
+      const result = await repository.fetchProjectItemsLight(
+        'test-project-id',
+        'updated:>=2026-07-07',
+      );
+
+      expect(mockPost).toHaveBeenCalledTimes(2);
+      expect(result.map((item) => item.id)).toEqual(['PVTI_1']);
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining('expected 1 items but accumulated 2'),
+      );
+      warnSpy.mockRestore();
+    });
   });
 
   describe('fetchProjectItemsByIds', () => {

package/src/adapter/repositories/issue/GraphqlProjectItemRepository.ts

@@ -719,59 +719,76 @@ query GetProjectItemsLight($projectId: ID!, $after: String, $first: Int!, $query
       }
       return rawData.node.items;
     };
-    const lightItems: ProjectItemLight[] = [];
-    let after: string | null = null;
-    let hasNextPage = true;
-    let totalCount = 0;
-    let cumulativeRawNodes = 0;
-    let pageIndex = 0;
-    while (hasNextPage) {
-      if (after !== null) {
-        await new Promise((resolve) =>
-          setTimeout(resolve, PAGINATION_DELAY_MS),
+    const fetchAllLightPages = async (): Promise<{
+      lightItems: ProjectItemLight[];
+      inconsistencyMessage: string | null;
+    }> => {
+      const lightItems: ProjectItemLight[] = [];
+      let after: string | null = null;
+      let hasNextPage = true;
+      let totalCount = 0;
+      let cumulativeRawNodes = 0;
+      let pageIndex = 0;
+      let inconsistencyMessage: string | null = null;
+      while (hasNextPage) {
+        if (after !== null) {
+          await new Promise((resolve) =>
+            setTimeout(resolve, PAGINATION_DELAY_MS),
+          );
+        }
+        const items = await callGraphql(after);
+        const pageNodes = items.nodes;
+        const pageInfo = items.pageInfo;
+        totalCount = items.totalCount;
+        cumulativeRawNodes += pageNodes.length;
+        pageIndex++;
+        console.log(
+          `fetchProjectItemsLight: page ${pageIndex}, nodes: ${pageNodes.length}, cumulative: ${cumulativeRawNodes}/${totalCount}`,
         );
+        pageNodes.forEach((node) => {
+          if (!node || !node.content || !node.content.url) {
+            return;
+          }
+          lightItems.push({
+            id: node.id,
+            updatedAt: node.updatedAt,
+            url: node.content.url,
+            number: node.content.number,
+          });
+        });
+        if (
+          pageNodes.length > 0 &&
+          !pageInfo.hasNextPage &&
+          cumulativeRawNodes < totalCount
+        ) {
+          inconsistencyMessage = `fetchProjectItemsLight: page ${pageIndex} has ${pageNodes.length} nodes with hasNextPage=false but only ${cumulativeRawNodes}/${totalCount} items accumulated`;
+        }
+        hasNextPage = pageInfo.hasNextPage;
+        after = pageInfo.endCursor;
       }
-      const items = await callGraphql(after);
-      const pageNodes = items.nodes;
-      const pageInfo = items.pageInfo;
-      totalCount = items.totalCount;
-      cumulativeRawNodes += pageNodes.length;
-      pageIndex++;
       console.log(
-        `fetchProjectItemsLight: page ${pageIndex}, nodes: ${pageNodes.length}, cumulative: ${cumulativeRawNodes}/${totalCount}`,
+        `fetchProjectItemsLight: completed, totalCount: ${totalCount}, cumulativeRawNodes: ${cumulativeRawNodes}, items: ${lightItems.length}`,
       );
-      pageNodes.forEach((node) => {
-        if (!node || !node.content || !node.content.url) {
-          return;
-        }
-        lightItems.push({
-          id: node.id,
-          updatedAt: node.updatedAt,
-          url: node.content.url,
-          number: node.content.number,
-        });
-      });
-      if (
-        pageNodes.length > 0 &&
-        !pageInfo.hasNextPage &&
-        cumulativeRawNodes < totalCount
-      ) {
-        throw new Error(
-          `fetchProjectItemsLight: page ${pageIndex} has ${pageNodes.length} nodes with hasNextPage=false but only ${cumulativeRawNodes}/${totalCount} items accumulated`,
-        );
+      if (inconsistencyMessage === null && cumulativeRawNodes !== totalCount) {
+        inconsistencyMessage = `fetchProjectItemsLight: expected ${totalCount} items but accumulated ${cumulativeRawNodes}`;
       }
-      hasNextPage = pageInfo.hasNextPage;
-      after = pageInfo.endCursor;
+      return { lightItems, inconsistencyMessage };
+    };
+    const firstAttempt = await fetchAllLightPages();
+    if (firstAttempt.inconsistencyMessage === null) {
+      return firstAttempt.lightItems;
     }
-    console.log(
-      `fetchProjectItemsLight: completed, totalCount: ${totalCount}, cumulativeRawNodes: ${cumulativeRawNodes}, items: ${lightItems.length}`,
+    console.warn(
+      `${firstAttempt.inconsistencyMessage}, retrying full fetch once`,
     );
-    if (cumulativeRawNodes !== totalCount) {
-      throw new Error(
-        `fetchProjectItemsLight: expected ${totalCount} items but accumulated ${cumulativeRawNodes}`,
-      );
+    const retryAttempt = await fetchAllLightPages();
+    if (retryAttempt.inconsistencyMessage === null) {
+      return retryAttempt.lightItems;
     }
-    return lightItems;
+    console.warn(
+      `${retryAttempt.inconsistencyMessage}, continuing with accumulated items after retry`,
+    );
+    return retryAttempt.lightItems;
   };
   fetchProjectItemsByIds = async (ids: string[]): Promise<ProjectItem[]> => {
     if (ids.length === 0) {