github-issue-tower-defence-management 1.90.0 → 1.91.1

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

@@ -0,0 +1,21 @@
+export type ConsoleFileStatusBadge = {
+  label: string;
+  color: string;
+};
+
+export const fileStatusBadge = (status: string): ConsoleFileStatusBadge => {
+  switch (status) {
+    case 'added':
+      return { label: 'A', color: '#3fb950' };
+    case 'modified':
+      return { label: 'M', color: '#d29922' };
+    case 'removed':
+      return { label: 'D', color: '#f85149' };
+    case 'renamed':
+      return { label: 'R', color: '#a371f7' };
+    case 'changed':
+      return { label: 'M', color: '#d29922' };
+    default:
+      return { label: '?', color: '#8b949e' };
+  }
+};

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

@@ -0,0 +1,91 @@
+import {
+  buildConsoleListRows,
+  CONSOLE_NO_STORY_LABEL,
+  resolveItemStory,
+  resolveStoryColorEnum,
+} from './grouping';
+import type { ConsoleListItem, ConsoleOverlay } from './types';
+
+const item = (
+  overrides: Partial<ConsoleListItem> &
+    Pick<ConsoleListItem, 'number' | 'story'>,
+): ConsoleListItem => ({
+  title: `Item ${overrides.number}`,
+  url: `https://github.com/o/r/issues/${overrides.number}`,
+  repo: 'o/r',
+  nameWithOwner: 'o/r',
+  projectItemId: `PVTI_${overrides.number}`,
+  itemId: `PVTI_${overrides.number}`,
+  isPr: false,
+  labels: [],
+  createdAt: '2026-06-10T00:00:00.000Z',
+  ...overrides,
+});
+
+describe('resolveStoryColorEnum', () => {
+  it('reads a wrapped color object shape', () => {
+    expect(resolveStoryColorEnum({ s: { color: 'BLUE' } }, 's')).toBe('BLUE');
+  });
+
+  it('reads a bare enum shape', () => {
+    expect(resolveStoryColorEnum({ s: 'RED' }, 's')).toBe('RED');
+  });
+
+  it('returns null for an unknown story', () => {
+    expect(resolveStoryColorEnum({}, 's')).toBeNull();
+  });
+});
+
+describe('resolveItemStory', () => {
+  it('prefers the overlay story name', () => {
+    const overlay: ConsoleOverlay = {
+      PVTI_1: {
+        ts: 1,
+        mode: 'triage',
+        story: { name: 'Overlay', color: 'BLUE' },
+      },
+    };
+    expect(
+      resolveItemStory(item({ number: 1, story: 'Original' }), overlay),
+    ).toBe('Overlay');
+  });
+
+  it('uses the trimmed item story when no overlay story exists', () => {
+    expect(resolveItemStory(item({ number: 2, story: '  Real  ' }), {})).toBe(
+      '  Real  ',
+    );
+  });
+
+  it('falls back to the no-story label when empty', () => {
+    expect(resolveItemStory(item({ number: 3, story: '   ' }), {})).toBe(
+      CONSOLE_NO_STORY_LABEL,
+    );
+  });
+});
+
+describe('buildConsoleListRows', () => {
+  it('inserts a group header whenever the story changes and keeps array order', () => {
+    const items = [
+      item({ number: 1, story: 'Alpha' }),
+      item({ number: 2, story: 'Alpha' }),
+      item({ number: 3, story: 'Beta' }),
+      item({ number: 4, story: 'Alpha' }),
+    ];
+    const rows = buildConsoleListRows(items, {});
+    expect(rows.map((row) => row.kind)).toEqual([
+      'group-header',
+      'item',
+      'item',
+      'group-header',
+      'item',
+      'group-header',
+      'item',
+    ]);
+    const firstHeader = rows[0];
+    expect(firstHeader.kind === 'group-header' && firstHeader.count).toBe(3);
+  });
+
+  it('returns no rows for an empty list', () => {
+    expect(buildConsoleListRows([], {})).toEqual([]);
+  });
+});

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

@@ -0,0 +1,79 @@
+import type {
+  ConsoleColor,
+  ConsoleListItem,
+  ConsoleOverlay,
+  ConsoleStoryColorSource,
+} from './types';
+
+export const CONSOLE_NO_STORY_LABEL = '(No story)';
+
+export const resolveStoryColorEnum = (
+  storyColors: ConsoleStoryColorSource,
+  storyName: string,
+): ConsoleColor | null => {
+  const entry = storyColors[storyName];
+  if (entry === undefined) {
+    return null;
+  }
+  if (typeof entry === 'string') {
+    return entry;
+  }
+  return entry.color;
+};
+
+export const resolveItemStory = (
+  item: ConsoleListItem,
+  overlay: ConsoleOverlay,
+): string => {
+  const overlayKey =
+    item.projectItemId !== '' ? item.projectItemId : item.itemId;
+  const overlayEntry = overlay[overlayKey];
+  if (
+    overlayEntry?.story?.name !== undefined &&
+    overlayEntry.story.name !== ''
+  ) {
+    return overlayEntry.story.name;
+  }
+  const trimmed = item.story.trim();
+  return trimmed !== '' ? item.story : CONSOLE_NO_STORY_LABEL;
+};
+
+export type ConsoleListGroupRow = {
+  kind: 'group-header';
+  story: string;
+  count: number;
+};
+
+export type ConsoleItemSummary = {
+  kind: 'item';
+  item: ConsoleListItem;
+};
+
+export type ConsoleListRow = ConsoleListGroupRow | ConsoleItemSummary;
+
+export const buildConsoleListRows = (
+  items: ConsoleListItem[],
+  overlay: ConsoleOverlay,
+): ConsoleListRow[] => {
+  const storyCounts = new Map<string, number>();
+  for (const item of items) {
+    const story = resolveItemStory(item, overlay);
+    storyCounts.set(story, (storyCounts.get(story) ?? 0) + 1);
+  }
+
+  const rows: ConsoleListRow[] = [];
+  let previousStory: string | null = null;
+  for (const item of items) {
+    const story = resolveItemStory(item, overlay);
+    if (story !== previousStory) {
+      rows.push({
+        kind: 'group-header',
+        story,
+        count: storyCounts.get(story) ?? 0,
+      });
+      previousStory = story;
+    }
+    rows.push({ kind: 'item', item });
+  }
+  return rows;
+};

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

@@ -0,0 +1,97 @@
+import { CONSOLE_ITEM_ICONS, resolveConsoleItemIconKind } from './itemIcons';
+
+describe('resolveConsoleItemIconKind', () => {
+  it('resolves a draft pull request to prDraft', () => {
+    expect(
+      resolveConsoleItemIconKind({
+        isPr: true,
+        state: 'open',
+        merged: false,
+        isDraft: true,
+        stateReason: '',
+      }),
+    ).toBe('prDraft');
+  });
+
+  it('resolves a merged pull request to prMerged', () => {
+    expect(
+      resolveConsoleItemIconKind({
+        isPr: true,
+        state: 'closed',
+        merged: true,
+        isDraft: false,
+        stateReason: '',
+      }),
+    ).toBe('prMerged');
+  });
+
+  it('resolves a closed pull request to prClosed', () => {
+    expect(
+      resolveConsoleItemIconKind({
+        isPr: true,
+        state: 'closed',
+        merged: false,
+        isDraft: false,
+        stateReason: '',
+      }),
+    ).toBe('prClosed');
+  });
+
+  it('resolves an open pull request to prOpen', () => {
+    expect(
+      resolveConsoleItemIconKind({
+        isPr: true,
+        state: 'open',
+        merged: false,
+        isDraft: false,
+        stateReason: '',
+      }),
+    ).toBe('prOpen');
+  });
+
+  it('resolves a completed closed issue to issueClosed', () => {
+    expect(
+      resolveConsoleItemIconKind({
+        isPr: false,
+        state: 'closed',
+        merged: false,
+        isDraft: false,
+        stateReason: 'completed',
+      }),
+    ).toBe('issueClosed');
+  });
+
+  it('resolves a not-planned closed issue to issueClosedNotPlanned', () => {
+    expect(
+      resolveConsoleItemIconKind({
+        isPr: false,
+        state: 'closed',
+        merged: false,
+        isDraft: false,
+        stateReason: 'not_planned',
+      }),
+    ).toBe('issueClosedNotPlanned');
+  });
+
+  it('resolves an open issue to issueOpen', () => {
+    expect(
+      resolveConsoleItemIconKind({
+        isPr: false,
+        state: 'open',
+        merged: false,
+        isDraft: false,
+        stateReason: '',
+      }),
+    ).toBe('issueOpen');
+  });
+
+  it('uses the documented colors for each kind', () => {
+    expect(CONSOLE_ITEM_ICONS.prDraft.color).toBe('#8b949e');
+    expect(CONSOLE_ITEM_ICONS.prMerged.color).toBe('#a371f7');
+    expect(CONSOLE_ITEM_ICONS.prClosed.color).toBe('#f85149');
+    expect(CONSOLE_ITEM_ICONS.prOpen.color).toBe('#3fb950');
+    expect(CONSOLE_ITEM_ICONS.issueClosedNotPlanned.color).toBe('#848d97');
+    expect(CONSOLE_ITEM_ICONS.issueClosed.color).toBe('#a371f7');
+    expect(CONSOLE_ITEM_ICONS.issueOpen.color).toBe('#3fb950');
+  });
+});

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

@@ -0,0 +1,95 @@
+export type ConsoleItemIconKind =
+  | 'issueOpen'
+  | 'issueClosed'
+  | 'issueClosedNotPlanned'
+  | 'prOpen'
+  | 'prMerged'
+  | 'prClosed'
+  | 'prDraft';
+
+export type ConsoleItemIconDefinition = {
+  color: string;
+  paths: string[];
+};
+
+export const CONSOLE_ITEM_ICONS: Record<
+  ConsoleItemIconKind,
+  ConsoleItemIconDefinition
+> = {
+  issueOpen: {
+    color: '#3fb950',
+    paths: [
+      'M8 9.5a1.5 1.5 0 1 0 0-3 1.5 1.5 0 0 0 0 3Z',
+      'M8 0a8 8 0 1 1 0 16A8 8 0 0 1 8 0ZM1.5 8a6.5 6.5 0 1 0 13 0 6.5 6.5 0 0 0-13 0Z',
+    ],
+  },
+  issueClosed: {
+    color: '#a371f7',
+    paths: [
+      'M11.28 6.78a.75.75 0 0 0-1.06-1.06L7.25 8.69 5.78 7.22a.75.75 0 0 0-1.06 1.06l2 2a.75.75 0 0 0 1.06 0l3.5-3.5Z',
+      'M16 8A8 8 0 1 1 0 8a8 8 0 0 1 16 0Zm-1.5 0a6.5 6.5 0 1 0-13 0 6.5 6.5 0 0 0 13 0Z',
+    ],
+  },
+  issueClosedNotPlanned: {
+    color: '#848d97',
+    paths: [
+      'M8 0a8 8 0 1 1 0 16A8 8 0 0 1 8 0ZM1.5 8a6.5 6.5 0 1 0 13 0 6.5 6.5 0 0 0-13 0Zm9.78-2.22-5.5 5.5a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734l5.5-5.5a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042Z',
+    ],
+  },
+  prOpen: {
+    color: '#3fb950',
+    paths: [
+      'M1.5 3.25a2.25 2.25 0 1 1 3 2.122v5.256a2.251 2.251 0 1 1-1.5 0V5.372A2.25 2.25 0 0 1 1.5 3.25Zm5.677-.177L9.573.677A.25.25 0 0 1 10 .854V2.5h1A2.5 2.5 0 0 1 13.5 5v5.628a2.251 2.251 0 1 1-1.5 0V5a1 1 0 0 0-1-1h-1v1.646a.25.25 0 0 1-.427.177L7.177 3.427a.25.25 0 0 1 0-.354ZM3.75 2.5a.75.75 0 1 0 0 1.5.75.75 0 0 0 0-1.5Zm0 9.5a.75.75 0 1 0 0 1.5.75.75 0 0 0 0-1.5Zm8.25.75a.75.75 0 1 0 1.5 0 .75.75 0 0 0-1.5 0Z',
+    ],
+  },
+  prMerged: {
+    color: '#a371f7',
+    paths: [
+      'M5.45 5.154A4.25 4.25 0 0 0 9.25 7.5h1.378a2.251 2.251 0 1 1 0 1.5H9.25A5.734 5.734 0 0 1 5 7.123v3.505a2.25 2.25 0 1 1-1.5 0V5.372a2.25 2.25 0 1 1 1.95-.218ZM4.25 13.5a.75.75 0 1 0 0-1.5.75.75 0 0 0 0 1.5Zm8.5-4.5a.75.75 0 1 0 0-1.5.75.75 0 0 0 0 1.5ZM5 3.25a.75.75 0 1 0 0 .005V3.25Z',
+    ],
+  },
+  prClosed: {
+    color: '#f85149',
+    paths: [
+      'M3.25 1A2.25 2.25 0 0 1 4 5.372v5.256a2.251 2.251 0 1 1-1.5 0V5.372A2.251 2.251 0 0 1 3.25 1Zm9.5 5.5a.75.75 0 0 1 .75.75v3.378a2.251 2.251 0 1 1-1.5 0V7.25a.75.75 0 0 1 .75-.75Zm-2.03-5.273a.75.75 0 0 1 1.06 0l.97.97.97-.97a.748.748 0 0 1 1.265.332.75.75 0 0 1-.205.729l-.97.97.97.97a.751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018l-.97-.97-.97.97a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734l.97-.97-.97-.97a.75.75 0 0 1 0-1.06ZM2.5 3.25a.75.75 0 1 0 1.5 0 .75.75 0 0 0-1.5 0ZM3.25 12a.75.75 0 1 0 0 1.5.75.75 0 0 0 0-1.5Zm9.5 0a.75.75 0 1 0 0 1.5.75.75 0 0 0 0-1.5Z',
+    ],
+  },
+  prDraft: {
+    color: '#8b949e',
+    paths: [
+      'M3.25 1A2.25 2.25 0 0 1 4 5.372v5.256a2.251 2.251 0 1 1-1.5 0V5.372A2.251 2.251 0 0 1 3.25 1Zm9.5 14a2.25 2.25 0 1 1 0-4.5 2.25 2.25 0 0 1 0 4.5ZM2.5 3.25a.75.75 0 1 0 1.5 0 .75.75 0 0 0-1.5 0ZM3.25 12a.75.75 0 1 0 0 1.5.75.75 0 0 0 0-1.5Zm9.5 0a.75.75 0 1 0 0 1.5.75.75 0 0 0 0-1.5ZM14 7.5a1.25 1.25 0 1 1-2.5 0 1.25 1.25 0 0 1 2.5 0Zm0-4.25a1.25 1.25 0 1 1-2.5 0 1.25 1.25 0 0 1 2.5 0Z',
+    ],
+  },
+};
+
+export type ConsoleItemIconInput = {
+  isPr: boolean;
+  state: string;
+  merged: boolean;
+  isDraft: boolean;
+  stateReason: string;
+};
+
+export const resolveConsoleItemIconKind = ({
+  isPr,
+  state,
+  merged,
+  isDraft,
+  stateReason,
+}: ConsoleItemIconInput): ConsoleItemIconKind => {
+  if (isPr) {
+    if (isDraft) {
+      return 'prDraft';
+    }
+    if (merged) {
+      return 'prMerged';
+    }
+    return state === 'closed' ? 'prClosed' : 'prOpen';
+  }
+  if (state === 'closed') {
+    return stateReason === 'not_planned'
+      ? 'issueClosedNotPlanned'
+      : 'issueClosed';
+  }
+  return 'issueOpen';
+};

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

@@ -0,0 +1,37 @@
+import {
+  IN_TMUX_BY_HUMAN_NAME,
+  isTodoByHumanTab,
+  STATUS_BUTTON_NAMES,
+  TOTALLY_WRONG_COMMENT_BODY,
+  UNNECESSARY_COMMENT_BODY,
+} from './operations';
+
+describe('operation constants', () => {
+  it('defines the totally wrong comment body', () => {
+    expect(TOTALLY_WRONG_COMMENT_BODY).toBe('totally wrong');
+  });
+
+  it('defines the unnecessary comment body', () => {
+    expect(UNNECESSARY_COMMENT_BODY).toBe('This pull request is unnecessary.');
+  });
+
+  it('lists the status buttons left to right', () => {
+    expect(STATUS_BUTTON_NAMES).toEqual([
+      'In Tmux by agent',
+      'In Tmux by human',
+      'Todo by human',
+      'Awaiting Workspace',
+    ]);
+  });
+
+  it('names the in-tmux-by-human status', () => {
+    expect(IN_TMUX_BY_HUMAN_NAME).toBe('In Tmux by human');
+  });
+});
+
+describe('isTodoByHumanTab', () => {
+  it('is true only for the todo-by-human tab', () => {
+    expect(isTodoByHumanTab('todo-by-human')).toBe(true);
+    expect(isTodoByHumanTab('prs')).toBe(false);
+  });
+});

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

@@ -0,0 +1,35 @@
+import type { ConsoleFieldOption, ConsoleTabName } from './types';
+
+export const TOTALLY_WRONG_COMMENT_BODY = 'totally wrong';
+export const UNNECESSARY_COMMENT_BODY = 'This pull request is unnecessary.';
+
+export type ConsoleReviewAction =
+  | 'approve'
+  | 'request_changes'
+  | 'unnecessary'
+  | 'totally_wrong';
+
+export type ConsoleNextActionDateAction = 'snooze_1day' | 'snooze_1week';
+
+export type ConsoleCloseAction = 'close' | 'close_not_planned';
+
+export type ConsoleOperationHandlers = {
+  onReview: (action: ConsoleReviewAction) => void;
+  onSetNextActionDate: (action: ConsoleNextActionDateAction) => void;
+  onSetStory: (option: ConsoleFieldOption) => void;
+  onSetStatus: (option: ConsoleFieldOption) => void;
+  onSetInTmuxByHuman: (option: ConsoleFieldOption) => void;
+  onClose: (action: ConsoleCloseAction) => void;
+};
+
+export const STATUS_BUTTON_NAMES: string[] = [
+  'In Tmux by agent',
+  'In Tmux by human',
+  'Todo by human',
+  'Awaiting Workspace',
+];
+
+export const IN_TMUX_BY_HUMAN_NAME = 'In Tmux by human';
+
+export const isTodoByHumanTab = (tab: ConsoleTabName): boolean =>
+  tab === 'todo-by-human';

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

@@ -0,0 +1,124 @@
+import {
+  countPendingItems,
+  filterPendingItems,
+  getOverlayEntry,
+  isOverlayEntryActedForMode,
+  isOverlayEntryExpiredForMode,
+  overlayKeyForItem,
+  overlayStorageKey,
+  parseGeneratedAtMs,
+  writeOverlayEntry,
+} from './overlay';
+import type { ConsoleListItem, ConsoleOverlay } from './types';
+
+const item = (number: number): ConsoleListItem => ({
+  number,
+  title: `Item ${number}`,
+  url: `https://github.com/o/r/issues/${number}`,
+  repo: 'o/r',
+  nameWithOwner: 'o/r',
+  projectItemId: `PVTI_${number}`,
+  itemId: `PVTI_${number}`,
+  isPr: false,
+  story: 'Story',
+  labels: [],
+  createdAt: '2026-06-10T00:00:00.000Z',
+});
+
+describe('overlay helpers', () => {
+  it('builds the per-project storage key', () => {
+    expect(overlayStorageKey('umino')).toBe('pv_overlay_umino');
+  });
+
+  it('uses the projectItemId as the overlay key when present', () => {
+    expect(overlayKeyForItem(item(5))).toBe('PVTI_5');
+  });
+
+  it('parses a generatedAt timestamp', () => {
+    expect(parseGeneratedAtMs('2026-06-10T00:00:00.000Z')).toBe(
+      Date.parse('2026-06-10T00:00:00.000Z'),
+    );
+    expect(parseGeneratedAtMs('not-a-date')).toBe(0);
+  });
+});
+
+describe('mode-aware expiry', () => {
+  it('expires a same-mode entry written before the snapshot', () => {
+    expect(
+      isOverlayEntryExpiredForMode(
+        { ts: 100, mode: 'prs', done: true },
+        200,
+        'prs',
+      ),
+    ).toBe(true);
+  });
+
+  it('does not expire an entry written in a different mode', () => {
+    expect(
+      isOverlayEntryExpiredForMode(
+        { ts: 100, mode: 'triage', done: true },
+        200,
+        'prs',
+      ),
+    ).toBe(false);
+  });
+
+  it('does not expire an entry written after the snapshot', () => {
+    expect(
+      isOverlayEntryExpiredForMode(
+        { ts: 300, mode: 'prs', done: true },
+        200,
+        'prs',
+      ),
+    ).toBe(false);
+  });
+});
+
+describe('counts driven to zero do not revive on tab switch', () => {
+  it('keeps a done item subtracted in its own mode', () => {
+    const overlay: ConsoleOverlay = {
+      PVTI_1: { ts: 500, mode: 'prs', done: true },
+    };
+    const generatedAtMs = 400;
+    expect(countPendingItems([item(1)], overlay, generatedAtMs, 'prs')).toBe(0);
+  });
+
+  it('treats a done entry from another mode as still acted', () => {
+    const overlay: ConsoleOverlay = {
+      PVTI_1: { ts: 100, mode: 'triage', done: true },
+    };
+    expect(isOverlayEntryActedForMode(overlay.PVTI_1, 999, 'prs')).toBe(true);
+    expect(countPendingItems([item(1)], overlay, 999, 'prs')).toBe(0);
+  });
+
+  it('revives the count only when a newer same-mode snapshot supersedes the entry', () => {
+    const overlay: ConsoleOverlay = {
+      PVTI_1: { ts: 100, mode: 'prs', done: true },
+    };
+    expect(countPendingItems([item(1)], overlay, 200, 'prs')).toBe(1);
+  });
+});
+
+describe('filterPendingItems', () => {
+  it('drops acted items and keeps the rest', () => {
+    const overlay: ConsoleOverlay = {
+      PVTI_1: { ts: 500, mode: 'prs', done: true },
+    };
+    const result = filterPendingItems([item(1), item(2)], overlay, 400, 'prs');
+    expect(result.map((entry) => entry.number)).toEqual([2]);
+  });
+});
+
+describe('getOverlayEntry and writeOverlayEntry', () => {
+  it('returns null for an expired entry', () => {
+    const overlay: ConsoleOverlay = {
+      PVTI_1: { ts: 100, mode: 'prs', done: true },
+    };
+    expect(getOverlayEntry(overlay, item(1), 200, 'prs')).toBeNull();
+  });
+
+  it('stamps the timestamp and mode on write', () => {
+    const next = writeOverlayEntry({}, 'PVTI_1', { done: true }, 'prs', 1234);
+    expect(next.PVTI_1).toEqual({ done: true, ts: 1234, mode: 'prs' });
+  });
+});

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

@@ -0,0 +1,101 @@
+import type {
+  ConsoleListItem,
+  ConsoleOverlay,
+  ConsoleOverlayEntry,
+  ConsoleTabName,
+} from './types';
+
+export const overlayStorageKey = (pjcode: string): string =>
+  `pv_overlay_${pjcode}`;
+
+export const overlayKeyForItem = (item: ConsoleListItem): string =>
+  item.projectItemId !== '' ? item.projectItemId : item.itemId;
+
+export const parseGeneratedAtMs = (generatedAt: string): number => {
+  const parsed = Date.parse(generatedAt);
+  return Number.isNaN(parsed) ? 0 : parsed;
+};
+
+export const isOverlayEntryExpiredForMode = (
+  entry: ConsoleOverlayEntry,
+  generatedAtMs: number,
+  mode: ConsoleTabName,
+): boolean =>
+  entry.ts > 0 &&
+  generatedAtMs > 0 &&
+  entry.mode === mode &&
+  entry.ts < generatedAtMs;
+
+export const getOverlayEntry = (
+  overlay: ConsoleOverlay,
+  item: ConsoleListItem,
+  generatedAtMs: number,
+  mode: ConsoleTabName,
+): ConsoleOverlayEntry | null => {
+  const entry = overlay[overlayKeyForItem(item)];
+  if (entry === undefined) {
+    return null;
+  }
+  if (isOverlayEntryExpiredForMode(entry, generatedAtMs, mode)) {
+    return null;
+  }
+  return entry;
+};
+
+export const isOverlayEntryActedForMode = (
+  entry: ConsoleOverlayEntry | undefined,
+  generatedAtMs: number,
+  mode: ConsoleTabName,
+): boolean => {
+  if (entry === undefined || entry.done !== true) {
+    return false;
+  }
+  return !isOverlayEntryExpiredForMode(entry, generatedAtMs, mode);
+};
+
+export const countPendingItems = (
+  items: ConsoleListItem[],
+  overlay: ConsoleOverlay,
+  generatedAtMs: number,
+  mode: ConsoleTabName,
+): number =>
+  items.filter(
+    (item) =>
+      !isOverlayEntryActedForMode(
+        overlay[overlayKeyForItem(item)],
+        generatedAtMs,
+        mode,
+      ),
+  ).length;
+
+export const filterPendingItems = (
+  items: ConsoleListItem[],
+  overlay: ConsoleOverlay,
+  generatedAtMs: number,
+  mode: ConsoleTabName,
+): ConsoleListItem[] =>
+  items.filter(
+    (item) =>
+      !isOverlayEntryActedForMode(
+        overlay[overlayKeyForItem(item)],
+        generatedAtMs,
+        mode,
+      ),
+  );
+
+export const writeOverlayEntry = (
+  overlay: ConsoleOverlay,
+  key: string,
+  patch: Partial<Omit<ConsoleOverlayEntry, 'ts' | 'mode'>>,
+  mode: ConsoleTabName,
+  now: number,
+): ConsoleOverlay => {
+  const existing = overlay[key];
+  const next: ConsoleOverlayEntry = {
+    ...(existing ?? {}),
+    ...patch,
+    ts: now,
+    mode,
+  };
+  return { ...overlay, [key]: next };
+};