github-issue-tower-defence-management 1.122.1 → 1.122.3

package/src/adapter/entry-points/console/consoleOperationApi.test.ts

@@ -7,6 +7,7 @@ import { Project } from '../../../domain/entities/Project';
 import { Issue } from '../../../domain/entities/Issue';
 import {
   ConsoleOperationContext,
+  ConsoleProjectBinding,
   handleComment,
   handleIntmux,
   handleReview,
@@ -73,6 +74,7 @@ describe('consoleOperationApi', () => {
       issueRepository,
       resolveProject: async (pjcode: string) =>
         pjcode === 'umino' ? { pjcode, project } : null,
+      isPjcodeConfigured: (pjcode: string) => pjcode === 'umino',
       consoleDataOutputDir: baseDir,
     };
   });
@@ -83,6 +85,7 @@ describe('consoleOperationApi', () => {
     issueRepository,
     resolveProject: async (pjcode: string) =>
       pjcode === 'umino' ? { pjcode, project: nextProject } : null,
+    isPjcodeConfigured: (pjcode: string) => pjcode === 'umino',
     consoleDataOutputDir: baseDir,
   });
 
@@ -112,9 +115,13 @@ describe('consoleOperationApi', () => {
       );
       expect(issueRepository.updateStatus).toHaveBeenCalledWith(
         project,
-        { ...issue, itemId: 'PVTI_a' },
+        expect.objectContaining({
+          itemId: 'PVTI_a',
+          url: 'https://github.com/o/r/pull/1',
+        }),
         'status_aw',
       );
+      expect(issueRepository.get).not.toHaveBeenCalled();
       expectRecordedAcrossTabs('PVTI_a');
     });
 
@@ -234,7 +241,7 @@ describe('consoleOperationApi', () => {
       expect(response.statusCode).toBe(400);
     });
 
-    it('returns 400 when the issue cannot be loaded during approve', async () => {
+    it('approves using the request project item id without a GraphQL item fetch', async () => {
       issueRepository.get.mockResolvedValue(null);
       const response = await handleReview(context, {
         pjcode: 'umino',
@@ -242,8 +249,13 @@ describe('consoleOperationApi', () => {
         prUrl: 'https://github.com/o/r/pull/1',
         projectItemId: 'PVTI_c',
       });
-      expect(response.statusCode).toBe(400);
-      expect(issueRepository.updateStatus).not.toHaveBeenCalled();
+      expect(response.statusCode).toBe(200);
+      expect(issueRepository.get).not.toHaveBeenCalled();
+      expect(issueRepository.updateStatus).toHaveBeenCalledWith(
+        project,
+        expect.objectContaining({ itemId: 'PVTI_c' }),
+        'status_aw',
+      );
     });
 
     it('returns 400 when the Awaiting workspace status is absent', async () => {
@@ -273,9 +285,13 @@ describe('consoleOperationApi', () => {
       expect(response.statusCode).toBe(200);
       expect(issueRepository.updateStatus).toHaveBeenCalledWith(
         project,
-        { ...issue, itemId: 'PVTI_d' },
+        expect.objectContaining({
+          itemId: 'PVTI_d',
+          url: 'https://github.com/o/r/issues/1',
+        }),
         'status_todo',
       );
+      expect(issueRepository.get).not.toHaveBeenCalled();
       expectRecordedAcrossTabs('PVTI_d');
     });
 
@@ -302,9 +318,10 @@ describe('consoleOperationApi', () => {
       expect(response.statusCode).toBe(200);
       expect(issueRepository.updateStory).toHaveBeenCalledWith(
         expect.objectContaining({ id: 'PVT_1' }),
-        { ...issue, itemId: 'PVTI_e' },
+        expect.objectContaining({ itemId: 'PVTI_e' }),
         'story_opt_1',
       );
+      expect(issueRepository.get).not.toHaveBeenCalled();
       expectRecordedAcrossTabs('PVTI_e');
     });
 
@@ -457,7 +474,7 @@ describe('consoleOperationApi', () => {
       expect(response.statusCode).toBe(400);
     });
 
-    it('returns 400 when the issue cannot be loaded for set_story', async () => {
+    it('sets the story using the request project item id without a GraphQL item fetch', async () => {
       issueRepository.get.mockResolvedValue(null);
       const response = await handleTriage(context, {
         pjcode: 'umino',
@@ -466,7 +483,157 @@ describe('consoleOperationApi', () => {
         projectItemId: 'PVTI_h',
         storyOptionId: 'story_opt_1',
       });
+      expect(response.statusCode).toBe(200);
+      expect(issueRepository.get).not.toHaveBeenCalled();
+      expect(issueRepository.updateStory).toHaveBeenCalledWith(
+        expect.objectContaining({ id: 'PVT_1' }),
+        expect.objectContaining({ itemId: 'PVTI_h' }),
+        'story_opt_1',
+      );
+    });
+  });
+
+  describe('close operations avoid loading the project via GraphQL', () => {
+    let resolveProjectSpy: jest.Mock<
+      Promise<ConsoleProjectBinding | null>,
+      [string]
+    >;
+    let spiedContext: ConsoleOperationContext;
+
+    beforeEach(() => {
+      resolveProjectSpy = jest.fn(async (pjcode: string) =>
+        pjcode === 'umino' ? { pjcode, project } : null,
+      );
+      spiedContext = {
+        issueRepository,
+        resolveProject: resolveProjectSpy,
+        isPjcodeConfigured: (pjcode: string) => pjcode === 'umino',
+        consoleDataOutputDir: baseDir,
+      };
+    });
+
+    it('closes an issue via triage without resolving the project', async () => {
+      const response = await handleTriage(spiedContext, {
+        pjcode: 'umino',
+        action: 'close',
+        issueUrl: 'https://github.com/o/r/issues/1',
+        projectItemId: 'PVTI_noproj_close',
+        commentBody: 'duplicate',
+      });
+      expect(response.statusCode).toBe(200);
+      expect(issueRepository.closeIssueByUrl).toHaveBeenCalledWith(
+        'https://github.com/o/r/issues/1',
+        'completed',
+      );
+      expect(issueRepository.createCommentByUrl).toHaveBeenCalledWith(
+        'https://github.com/o/r/issues/1',
+        'duplicate',
+      );
+      expect(resolveProjectSpy).not.toHaveBeenCalled();
+      expect(issueRepository.get).not.toHaveBeenCalled();
+    });
+
+    it('closes not planned via triage without resolving the project', async () => {
+      const response = await handleTriage(spiedContext, {
+        pjcode: 'umino',
+        action: 'close_not_planned',
+        issueUrl: 'https://github.com/o/r/issues/1',
+        projectItemId: 'PVTI_noproj_np',
+      });
+      expect(response.statusCode).toBe(200);
+      expect(issueRepository.closeIssueByUrl).toHaveBeenCalledWith(
+        'https://github.com/o/r/issues/1',
+        'not_planned',
+      );
+      expect(resolveProjectSpy).not.toHaveBeenCalled();
+    });
+
+    it('closes a pull request via review without resolving the project', async () => {
+      const response = await handleReview(spiedContext, {
+        pjcode: 'umino',
+        action: 'close',
+        prUrl: 'https://github.com/o/r/pull/1',
+        projectItemId: 'PVTI_noproj_reviewclose',
+      });
+      expect(response.statusCode).toBe(200);
+      expect(issueRepository.closePullRequest).toHaveBeenCalledWith(
+        'https://github.com/o/r/pull/1',
+      );
+      expect(resolveProjectSpy).not.toHaveBeenCalled();
+    });
+
+    it('rejects a close whose pjcode is not configured without resolving the project', async () => {
+      const response = await handleTriage(spiedContext, {
+        pjcode: 'unconfigured',
+        action: 'close',
+        issueUrl: 'https://github.com/o/r/issues/1',
+        projectItemId: 'PVTI_noproj_badpj',
+      });
       expect(response.statusCode).toBe(400);
+      expect(issueRepository.closeIssueByUrl).not.toHaveBeenCalled();
+      expect(resolveProjectSpy).not.toHaveBeenCalled();
+    });
+
+    it('sets intmux without a GraphQL item fetch while resolving the project', async () => {
+      const response = await handleIntmux(spiedContext, {
+        pjcode: 'umino',
+        action: 'set_intmux',
+        issueUrl: 'https://github.com/o/r/issues/1',
+        projectItemId: 'PVTI_needproj_intmux',
+      });
+      expect(response.statusCode).toBe(200);
+      expect(resolveProjectSpy).toHaveBeenCalledTimes(1);
+      expect(issueRepository.get).not.toHaveBeenCalled();
+      expect(issueRepository.updateStatus).toHaveBeenCalledWith(
+        project,
+        expect.objectContaining({ itemId: 'PVTI_needproj_intmux' }),
+        'status_intmux',
+      );
+    });
+
+    it('resolves the project for set_status but performs no GraphQL item fetch', async () => {
+      const response = await handleTriage(spiedContext, {
+        pjcode: 'umino',
+        action: 'set_status',
+        issueUrl: 'https://github.com/o/r/issues/1',
+        projectItemId: 'PVTI_needproj_status',
+        statusName: 'Todo',
+      });
+      expect(response.statusCode).toBe(200);
+      expect(resolveProjectSpy).toHaveBeenCalledTimes(1);
+      expect(issueRepository.get).not.toHaveBeenCalled();
+      expect(issueRepository.updateStatus).toHaveBeenCalledTimes(1);
+    });
+
+    it('resolves the project for set_story but performs no GraphQL item fetch', async () => {
+      const response = await handleTriage(spiedContext, {
+        pjcode: 'umino',
+        action: 'set_story',
+        issueUrl: 'https://github.com/o/r/issues/1',
+        projectItemId: 'PVTI_needproj_story',
+        storyOptionId: 'story_opt_1',
+      });
+      expect(response.statusCode).toBe(200);
+      expect(resolveProjectSpy).toHaveBeenCalledTimes(1);
+      expect(issueRepository.get).not.toHaveBeenCalled();
+      expect(issueRepository.updateStory).toHaveBeenCalledTimes(1);
+    });
+
+    it('resolves the project for snooze and passes the item id without a GraphQL item fetch', async () => {
+      const response = await handleTriage(spiedContext, {
+        pjcode: 'umino',
+        action: 'snooze_1day',
+        issueUrl: 'https://github.com/o/r/issues/1',
+        projectItemId: 'PVTI_needproj_snooze',
+      });
+      expect(response.statusCode).toBe(200);
+      expect(resolveProjectSpy).toHaveBeenCalledTimes(1);
+      expect(issueRepository.get).not.toHaveBeenCalled();
+      const call = issueRepository.updateNextActionDate.mock.calls[0];
+      expect(call[0]).toBe('https://github.com/o/r/issues/1');
+      expect(call[1]).toBe(project);
+      expect(call[2]).toBeInstanceOf(Date);
+      expect(call[3]).toBe('PVTI_needproj_snooze');
     });
   });
 
@@ -481,9 +648,13 @@ describe('consoleOperationApi', () => {
       expect(response.statusCode).toBe(200);
       expect(issueRepository.updateStatus).toHaveBeenCalledWith(
         project,
-        { ...issue, itemId: 'PVTI_i' },
+        expect.objectContaining({
+          itemId: 'PVTI_i',
+          url: 'https://github.com/o/r/issues/1',
+        }),
         'status_intmux',
       );
+      expect(issueRepository.get).not.toHaveBeenCalled();
       expectRecordedAcrossTabs('PVTI_i');
     });
 
@@ -497,7 +668,7 @@ describe('consoleOperationApi', () => {
       expect(response.statusCode).toBe(400);
     });
 
-    it('returns 400 when the issue cannot be loaded', async () => {
+    it('sets intmux using the request project item id without a GraphQL item fetch', async () => {
       issueRepository.get.mockResolvedValue(null);
       const response = await handleIntmux(context, {
         pjcode: 'umino',
@@ -505,7 +676,13 @@ describe('consoleOperationApi', () => {
         issueUrl: 'https://github.com/o/r/issues/1',
         projectItemId: 'PVTI_i',
       });
-      expect(response.statusCode).toBe(400);
+      expect(response.statusCode).toBe(200);
+      expect(issueRepository.get).not.toHaveBeenCalled();
+      expect(issueRepository.updateStatus).toHaveBeenCalledWith(
+        project,
+        expect.objectContaining({ itemId: 'PVTI_i' }),
+        'status_intmux',
+      );
     });
 
     it('rejects a missing issueUrl', async () => {
@@ -573,6 +750,8 @@ describe('consoleOperationApi', () => {
           }
           return null;
         },
+        isPjcodeConfigured: (pjcode: string) =>
+          pjcode === 'umino' || pjcode === 'xmile',
         consoleDataOutputDir: baseDir,
       };
       const response = await handleTriage(multiContext, {
@@ -585,7 +764,7 @@ describe('consoleOperationApi', () => {
       expect(response.statusCode).toBe(200);
       expect(issueRepository.updateStatus).toHaveBeenCalledWith(
         otherProject,
-        { ...issue, itemId: 'PVTI_x' },
+        expect.objectContaining({ itemId: 'PVTI_x' }),
         'status_todo',
       );
       for (const tab of CONSOLE_DONE_TAB_NAMES) {

package/src/adapter/entry-points/console/consoleOperationApi.ts

@@ -18,9 +18,12 @@ export type ConsoleProjectResolver = (
   pjcode: string,
 ) => Promise<ConsoleProjectBinding | null>;
 
+export type ConsolePjcodeValidator = (pjcode: string) => boolean;
+
 export type ConsoleOperationContext = {
   issueRepository: IssueRepository;
   resolveProject: ConsoleProjectResolver;
+  isPjcodeConfigured: ConsolePjcodeValidator;
   consoleDataOutputDir: string | null;
 };
 
@@ -69,18 +72,40 @@ const resolveStatusId = (
   return match ? match.id : null;
 };
 
-const loadIssueWithProjectItemId = async (
-  issueRepository: IssueRepository,
-  project: Project,
+// Builds the minimal Issue reference the ProjectV2 mutations need. The dashboard
+// already supplies the project item id in the request body, and updateStatus,
+// updateStory and updateNextActionHour read only `issue.itemId` (plus `url` for
+// context). Constructing the reference locally avoids the GraphQL
+// fetchProjectItemByUrl call that issueRepository.get would otherwise perform.
+const projectItemReference = (
   issueUrl: string,
   projectItemId: string,
-): Promise<Issue | null> => {
-  const issue = await issueRepository.get(issueUrl, project);
-  if (issue === null) {
-    return null;
-  }
-  return { ...issue, itemId: projectItemId };
-};
+): Issue => ({
+  nameWithOwner: '',
+  number: 0,
+  title: '',
+  state: 'OPEN',
+  status: null,
+  story: null,
+  nextActionDate: null,
+  nextActionHour: null,
+  estimationMinutes: null,
+  dependedIssueUrls: [],
+  completionDate50PercentConfidence: null,
+  url: issueUrl,
+  assignees: [],
+  labels: [],
+  org: '',
+  repo: '',
+  body: '',
+  itemId: projectItemId,
+  isPr: isPullRequestUrl(issueUrl),
+  isInProgress: false,
+  isClosed: false,
+  createdAt: new Date(0),
+  author: '',
+  closingIssueReferenceUrls: [],
+});
 
 const recordDone = (
   context: ConsoleOperationContext,
@@ -117,6 +142,25 @@ const isOperationResponse = (
 ): value is ConsoleOperationResponse =>
   Object.prototype.hasOwnProperty.call(value, 'statusCode');
 
+// Validates that a pjcode is configured WITHOUT loading the ProjectV2 via
+// GraphQL. Close operations only need the pjcode (for recordDone namespacing)
+// and the issue/PR URL, both of which are handled through REST. Loading the
+// full project here would make close fail whenever the GraphQL quota is
+// exhausted, even though closing a GitHub issue or PR needs only REST.
+const resolveConfiguredPjcode = (
+  context: ConsoleOperationContext,
+  body: Record<string, unknown>,
+): string | ConsoleOperationResponse => {
+  const pjcode = body.pjcode;
+  if (!isNonEmptyString(pjcode)) {
+    return badRequest('pjcode is required');
+  }
+  if (!context.isPjcodeConfigured(pjcode)) {
+    return badRequest(`no project configured for pjcode "${pjcode}"`);
+  }
+  return pjcode;
+};
+
 const updateStatusByName = async (
   issueRepository: IssueRepository,
   project: Project,
@@ -128,16 +172,11 @@ const updateStatusByName = async (
   if (statusId === null) {
     return badRequest(`status option "${statusName}" not found in project`);
   }
-  const issue = await loadIssueWithProjectItemId(
-    issueRepository,
+  await issueRepository.updateStatus(
     project,
-    issueUrl,
-    projectItemId,
+    projectItemReference(issueUrl, projectItemId),
+    statusId,
   );
-  if (issue === null) {
-    return badRequest('issue not found');
-  }
-  await issueRepository.updateStatus(project, issue, statusId);
   return null;
 };
 
@@ -157,6 +196,20 @@ export const handleReview = async (
   if (!isNonEmptyString(projectItemId)) {
     return badRequest('projectItemId is required');
   }
+
+  if (action === 'close') {
+    const pjcodeResult = resolveConfiguredPjcode(context, body);
+    if (typeof pjcodeResult !== 'string') {
+      return pjcodeResult;
+    }
+    await context.issueRepository.closePullRequest(prUrl);
+    if (isNonEmptyString(body.commentBody)) {
+      await context.issueRepository.createCommentByUrl(prUrl, body.commentBody);
+    }
+    recordDone(context, pjcodeResult, projectItemId);
+    return ok();
+  }
+
   const binding = await resolveBinding(context, body);
   if (isOperationResponse(binding)) {
     return binding;
@@ -213,15 +266,6 @@ export const handleReview = async (
     return ok();
   }
 
-  if (action === 'close') {
-    await context.issueRepository.closePullRequest(prUrl);
-    if (isNonEmptyString(body.commentBody)) {
-      await context.issueRepository.createCommentByUrl(prUrl, body.commentBody);
-    }
-    recordDone(context, pjcode, projectItemId);
-    return ok();
-  }
-
   return badRequest(`unknown review action "${action}"`);
 };
 
@@ -241,6 +285,30 @@ export const handleTriage = async (
   if (!isNonEmptyString(projectItemId)) {
     return badRequest('projectItemId is required');
   }
+
+  if (action === 'close' || action === 'close_not_planned') {
+    const pjcodeResult = resolveConfiguredPjcode(context, body);
+    if (typeof pjcodeResult !== 'string') {
+      return pjcodeResult;
+    }
+    if (isNonEmptyString(body.commentBody)) {
+      await context.issueRepository.createCommentByUrl(
+        issueUrl,
+        body.commentBody,
+      );
+    }
+    if (isPullRequestUrl(issueUrl)) {
+      await context.issueRepository.closePullRequest(issueUrl);
+    } else {
+      await context.issueRepository.closeIssueByUrl(
+        issueUrl,
+        action === 'close_not_planned' ? 'not_planned' : 'completed',
+      );
+    }
+    recordDone(context, pjcodeResult, projectItemId);
+    return ok();
+  }
+
   const binding = await resolveBinding(context, body);
   if (isOperationResponse(binding)) {
     return binding;
@@ -274,43 +342,15 @@ export const handleTriage = async (
     if (project.story === null) {
       return badRequest('project does not have a story field');
     }
-    const issue = await loadIssueWithProjectItemId(
-      context.issueRepository,
-      project,
-      issueUrl,
-      projectItemId,
-    );
-    if (issue === null) {
-      return badRequest('issue not found');
-    }
     await context.issueRepository.updateStory(
       { ...project, story: project.story },
-      issue,
+      projectItemReference(issueUrl, projectItemId),
       storyOptionId,
     );
     recordDone(context, pjcode, projectItemId);
     return ok();
   }
 
-  if (action === 'close' || action === 'close_not_planned') {
-    if (isNonEmptyString(body.commentBody)) {
-      await context.issueRepository.createCommentByUrl(
-        issueUrl,
-        body.commentBody,
-      );
-    }
-    if (isPullRequestUrl(issueUrl)) {
-      await context.issueRepository.closePullRequest(issueUrl);
-    } else {
-      await context.issueRepository.closeIssueByUrl(
-        issueUrl,
-        action === 'close_not_planned' ? 'not_planned' : 'completed',
-      );
-    }
-    recordDone(context, pjcode, projectItemId);
-    return ok();
-  }
-
   if (action === 'snooze_1day' || action === 'snooze_1week') {
     const days = action === 'snooze_1day' ? 1 : 7;
     const target = new Date(Date.now() + days * 24 * 60 * 60 * 1000);
@@ -318,6 +358,7 @@ export const handleTriage = async (
       issueUrl,
       project,
       target,
+      projectItemId,
     );
     recordDone(context, pjcode, projectItemId);
     return ok();

package/src/adapter/entry-points/console/consoleProjectResolver.test.ts

@@ -3,6 +3,7 @@ import { Project } from '../../../domain/entities/Project';
 import {
   buildPjcodeToProjectUrl,
   createConsoleProjectResolver,
+  createPjcodeConfigChecker,
 } from './consoleProjectResolver';
 
 describe('buildPjcodeToProjectUrl', () => {
@@ -39,6 +40,18 @@ describe('buildPjcodeToProjectUrl', () => {
   });
 });
 
+describe('createPjcodeConfigChecker', () => {
+  it('reports true only for a configured pjcode without loading any project', () => {
+    const isConfigured = createPjcodeConfigChecker({
+      umino: 'https://github.com/orgs/umino/projects/1',
+      xmile: 'https://github.com/orgs/xmile/projects/2',
+    });
+    expect(isConfigured('umino')).toBe(true);
+    expect(isConfigured('xmile')).toBe(true);
+    expect(isConfigured('unknown')).toBe(false);
+  });
+});
+
 describe('createConsoleProjectResolver', () => {
   const uminoProject: Project = { ...mock<Project>(), id: 'PVT_umino' };
   const xmileProject: Project = { ...mock<Project>(), id: 'PVT_xmile' };

package/src/adapter/entry-points/console/consoleProjectResolver.ts

@@ -1,5 +1,6 @@
 import { Project } from '../../../domain/entities/Project';
 import {
+  ConsolePjcodeValidator,
   ConsoleProjectBinding,
   ConsoleProjectResolver,
 } from './consoleOperationApi';
@@ -25,6 +26,16 @@ export const buildPjcodeToProjectUrl = (
   return mapping;
 };
 
+// Builds a synchronous predicate that reports whether a pjcode is configured,
+// using only the local pjcode-to-project-url mapping. This lets close
+// operations validate the pjcode without loading the ProjectV2 via GraphQL.
+export const createPjcodeConfigChecker = (
+  pjcodeToProjectUrl: Record<string, string>,
+): ConsolePjcodeValidator => {
+  return (pjcode: string): boolean =>
+    Object.prototype.hasOwnProperty.call(pjcodeToProjectUrl, pjcode);
+};
+
 export const createConsoleProjectResolver = (
   pjcodeToProjectUrl: Record<string, string>,
   loadProject: ConsoleProjectLoader,

package/src/adapter/entry-points/console/ui/e2e/consoleTestHarness.ts

@@ -505,6 +505,8 @@ export const startConsoleE2eHarness = async (): Promise<ConsoleE2eHarness> => {
     pjcode: string,
   ): Promise<ConsoleProjectBinding | null> =>
     pjcode === CONSOLE_E2E_PJCODE ? { pjcode, project } : null;
+  const isPjcodeConfigured = (pjcode: string): boolean =>
+    pjcode === CONSOLE_E2E_PJCODE;
 
   const reviewCommentCalls: ConsoleE2eReviewCommentCall[] = [];
   const requestChangesCalls: ConsoleE2eRequestChangesCall[] = [];
@@ -518,6 +520,7 @@ export const startConsoleE2eHarness = async (): Promise<ConsoleE2eHarness> => {
       requestChangesCalls,
     ),
     resolveProject,
+    isPjcodeConfigured,
     issueTitleStateCache: new IssueTitleStateCache(),
     pullRequestStatusCache: new PullRequestStatusCache(),
     inTmuxDataDir: null,

package/src/adapter/entry-points/console/ui/src/features/console/logic/overlay.test.ts

@@ -1,12 +1,9 @@
 import {
   countPendingItems,
-  countTabPendingItems,
   filterPendingItems,
-  filterTabPendingItems,
   isOverlayEntryActed,
   overlayKeyForItem,
   overlayStorageKey,
-  tabIgnoresDoneOverlay,
   writeOverlayEntry,
 } from './overlay';
 import type { ConsoleListItem, ConsoleOverlay } from './types';
@@ -126,59 +123,29 @@ describe('filterPendingItems', () => {
   });
 });
 
-describe('tabIgnoresDoneOverlay', () => {
-  it('ignores the done overlay on the workflow-blocker tab', () => {
-    expect(tabIgnoresDoneOverlay('workflow-blocker')).toBe(true);
-  });
-
-  it('applies the done overlay on every other tab', () => {
-    expect(tabIgnoresDoneOverlay('prs')).toBe(false);
-    expect(tabIgnoresDoneOverlay('triage')).toBe(false);
-    expect(tabIgnoresDoneOverlay('unread')).toBe(false);
-    expect(tabIgnoresDoneOverlay('failed-preparation')).toBe(false);
-    expect(tabIgnoresDoneOverlay('todo-by-human')).toBe(false);
-  });
-});
-
-describe('countTabPendingItems', () => {
-  it('counts every workflow-blocker item even when all are marked done', () => {
+describe('workflow-blocker items are filtered by the done overlay like every other tab', () => {
+  it('subtracts a processed workflow-blocker item from the count', () => {
     const overlay: ConsoleOverlay = {
       PVTI_1: { ts: 100, mode: 'workflow-blocker', done: true },
-      PVTI_2: { ts: 100, mode: 'workflow-blocker', done: true },
     };
-    expect(
-      countTabPendingItems([item(1), item(2)], overlay, 'workflow-blocker'),
-    ).toBe(2);
+    expect(countPendingItems([item(1), item(2)], overlay)).toBe(1);
   });
 
-  it('subtracts done items on tabs other than workflow-blocker', () => {
+  it('removes a processed workflow-blocker item from the list', () => {
     const overlay: ConsoleOverlay = {
-      PVTI_1: { ts: 100, mode: 'prs', done: true },
+      PVTI_1: { ts: 100, mode: 'workflow-blocker', done: true },
     };
-    expect(countTabPendingItems([item(1), item(2)], overlay, 'prs')).toBe(1);
+    const result = filterPendingItems([item(1), item(2)], overlay);
+    expect(result.map((entry) => entry.number)).toEqual([2]);
   });
-});
 
-describe('filterTabPendingItems', () => {
-  it('keeps every workflow-blocker item even when all are marked done', () => {
+  it('drives the count to zero when every workflow-blocker item is processed', () => {
     const overlay: ConsoleOverlay = {
       PVTI_1: { ts: 100, mode: 'workflow-blocker', done: true },
       PVTI_2: { ts: 100, mode: 'workflow-blocker', done: true },
     };
-    const result = filterTabPendingItems(
-      [item(1), item(2)],
-      overlay,
-      'workflow-blocker',
-    );
-    expect(result.map((entry) => entry.number)).toEqual([1, 2]);
-  });
-
-  it('drops done items on tabs other than workflow-blocker', () => {
-    const overlay: ConsoleOverlay = {
-      PVTI_1: { ts: 100, mode: 'prs', done: true },
-    };
-    const result = filterTabPendingItems([item(1), item(2)], overlay, 'prs');
-    expect(result.map((entry) => entry.number)).toEqual([2]);
+    expect(countPendingItems([item(1), item(2)], overlay)).toBe(0);
+    expect(filterPendingItems([item(1), item(2)], overlay)).toEqual([]);
   });
 });