github-issue-tower-defence-management 1.95.0 → 1.97.0

package/src/adapter/entry-points/cli/index.ts

@@ -42,6 +42,7 @@ import {
   createConsoleProjectResolver,
 } from '../console/consoleProjectResolver';
 import { OauthTokenSelectHandler } from '../handlers/OauthTokenSelectHandler';
+import { LiveSessionOauthTokenSelectHandler } from '../handlers/LiveSessionOauthTokenSelectHandler';
 
 type StartDaemonOptions = {
   projectUrl?: string;
@@ -89,6 +90,11 @@ type SelectOauthTokenOptions = {
   cacheDir?: string;
 };
 
+type SelectLiveSessionOauthTokenOptions = {
+  tokenListJsonPath?: string;
+  cacheDir?: string;
+};
+
 const buildGithubRepositoryParams = (
   localStorageRepository: LocalStorageRepository,
   token: string,
@@ -757,6 +763,38 @@ program
     process.stdout.write(`${output.selectedToken}\n`);
   });
 
+program
+  .command('selectLiveSessionOauthToken')
+  .description(
+    'Print exactly one Claude Code OAuth token chosen for a new live interactive session. Among rate-limit-eligible tokens it prefers the one with the fewest current live sessions (by distinct CLAUDE_CODE_SESSION_ID found in running Claude Code processes), tiebreaking on the soonest 7d reset. The token string is written to stdout (pipeable); the per-candidate decision trace is written to stderr. Exits non-zero when no token passes the filter.',
+  )
+  .option(
+    '--tokenListJsonPath <path>',
+    'Path to the JSON array of { name, token } records. Falls back to the CLAUDE_CODE_OAUTH_TOKEN_LIST_JSON_PATH environment variable.',
+  )
+  .option(
+    '--cacheDir <path>',
+    'Directory holding per-token rate-limit cache files. Falls back to the TDPM_RATELIMIT_CACHE_DIR environment variable, then to ${XDG_CACHE_HOME:-~/.cache}/tdpm/ratelimit.',
+  )
+  .action((options: SelectLiveSessionOauthTokenOptions) => {
+    const handler = new LiveSessionOauthTokenSelectHandler();
+    const output = handler.handle({
+      tokenListJsonPath: options.tokenListJsonPath ?? null,
+      cacheDirectory: options.cacheDir ?? null,
+      nowEpochSeconds: Date.now() / 1000,
+    });
+
+    for (const line of output.diagnostics) {
+      console.error(line);
+    }
+
+    if (output.selectedToken === null) {
+      process.exit(1);
+    }
+
+    process.stdout.write(`${output.selectedToken}\n`);
+  });
+
 /* istanbul ignore next */
 if (process.argv && require.main === module) {
   program.parse(process.argv);

package/src/adapter/entry-points/console/ui/biome.json

@@ -8,7 +8,13 @@
   },
   "files": {
     "ignoreUnknown": false,
-    "includes": ["src/**", ".storybook/**"]
+    "includes": [
+      "src/**",
+      ".storybook/**",
+      "e2e/**",
+      "!e2e/report/**",
+      "!e2e/test-results/**"
+    ]
   },
   "formatter": {
     "enabled": true,

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

@@ -0,0 +1,93 @@
+import { expect, type Page, test } from '@playwright/test';
+import {
+  type ConsoleE2eHarness,
+  startConsoleE2eHarness,
+} from './consoleTestHarness';
+
+let harness: ConsoleE2eHarness;
+
+test.beforeAll(async () => {
+  harness = await startConsoleE2eHarness();
+});
+
+test.afterAll(async () => {
+  if (harness !== undefined) {
+    await harness.stop();
+  }
+});
+
+const activeTabLabel = (page: Page) =>
+  page.locator('.console-tab[data-active="true"] .console-tab-label');
+
+const tabByLabel = (page: Page, label: string) =>
+  page.locator('.console-tab', { hasText: label });
+
+const tabBadge = (page: Page, label: string) =>
+  tabByLabel(page, label).locator('.console-tab-badge');
+
+const itemRowByText = (page: Page, text: string) =>
+  page.locator('.console-item-row', { hasText: text });
+
+const processSelectedItemViaStatus = async (page: Page): Promise<void> => {
+  const statusButton = page
+    .locator('.console-op-button', { hasText: 'Awaiting Workspace' })
+    .first();
+  await expect(statusButton).toBeVisible();
+  await statusButton.click();
+};
+
+test('processing tabs drives auto-advance and keeps emptied badges at zero', async ({
+  page,
+}) => {
+  await page.goto(harness.appUrl);
+
+  await expect(activeTabLabel(page)).toHaveText('Awaiting Quality Check');
+  await expect(tabBadge(page, 'Awaiting Quality Check')).toHaveText('1');
+  await expect(tabBadge(page, 'Unread')).toHaveText('2');
+  await expect(tabBadge(page, 'Triage')).toHaveText('2');
+  await expect(tabBadge(page, 'Todo by human')).toHaveText('1');
+
+  await itemRowByText(
+    page,
+    'Serve the committed console UI bundle from serveConsole',
+  ).click();
+  const approveButton = page
+    .locator('.console-op-button', { hasText: 'Approve' })
+    .first();
+  await expect(approveButton).toBeVisible();
+  await approveButton.click();
+
+  await expect(activeTabLabel(page)).toHaveText('Triage', { timeout: 8000 });
+  await expect(tabByLabel(page, 'Awaiting Quality Check')).toHaveCount(0, {
+    timeout: 8000,
+  });
+
+  await itemRowByText(
+    page,
+    'Add Sonnet to Opus weekly-limit fallback routing per token',
+  ).click();
+  await processSelectedItemViaStatus(page);
+  await expect(tabBadge(page, 'Triage')).toHaveText('1', { timeout: 8000 });
+  await page.locator('.console-back-button').click();
+
+  await itemRowByText(
+    page,
+    'Publish the generated documentation site to GitHub Pages',
+  ).click();
+  await processSelectedItemViaStatus(page);
+
+  await expect(activeTabLabel(page)).toHaveText('Unread', { timeout: 8000 });
+  await expect(tabByLabel(page, 'Triage')).toHaveCount(0, {
+    timeout: 8000,
+  });
+
+  await tabByLabel(page, 'Todo by human').click();
+  await expect(activeTabLabel(page)).toHaveText('Todo by human');
+  await expect(tabByLabel(page, 'Triage')).toHaveCount(0);
+  await expect(tabBadge(page, 'Todo by human')).toHaveText('1');
+
+  await tabByLabel(page, 'Unread').click();
+  await expect(activeTabLabel(page)).toHaveText('Unread');
+  await expect(tabByLabel(page, 'Triage')).toHaveCount(0);
+  await expect(tabBadge(page, 'Unread')).toHaveText('2');
+});

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

@@ -0,0 +1,380 @@
+import * as fs from 'node:fs';
+import type * as http from 'node:http';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import type { Issue } from '../../../../../domain/entities/Issue';
+import type { Project } from '../../../../../domain/entities/Project';
+import type {
+  IssueComment,
+  IssueRepository,
+  PullRequestCommit,
+  PullRequestDetail,
+  RelatedPullRequest,
+} from '../../../../../domain/usecases/adapter-interfaces/IssueRepository';
+import type { ConsoleProjectBinding } from '../../consoleOperationApi';
+import { IssueTitleStateCache } from '../../consoleReadApi';
+import { startConsoleServer } from '../../consoleServer';
+
+export const CONSOLE_E2E_PJCODE = 'umino';
+export const CONSOLE_E2E_TOKEN = 'console-e2e-fixture-token-3f9c1a';
+
+type ConsoleFixtureListItem = {
+  number: number;
+  title: string;
+  url: string;
+  repo: string;
+  nameWithOwner: string;
+  projectItemId: string;
+  itemId: string;
+  isPr: boolean;
+  story: string;
+  labels: string[];
+  createdAt: string;
+};
+
+type ConsoleFixtureFieldOption = {
+  id: string;
+  name: string;
+  color: string;
+};
+
+type ConsoleFixtureSnapshot = {
+  pjcode: string;
+  generatedAt: string;
+  statusOptions: ConsoleFixtureFieldOption[];
+  storyOptions: ConsoleFixtureFieldOption[];
+  storyColors: Record<string, { color: string }>;
+  items: ConsoleFixtureListItem[];
+};
+
+const REPO_NAME_WITH_OWNER =
+  'HiromiShikata/npm-cli-github-issue-tower-defence-management';
+
+const AWAITING_WORKSPACE_OPTION: ConsoleFixtureFieldOption = {
+  id: 'd1c19cce',
+  name: 'Awaiting Workspace',
+  color: 'BLUE',
+};
+
+const STATUS_OPTIONS: ConsoleFixtureFieldOption[] = [
+  { id: 'f75ad846', name: 'Unread', color: 'ORANGE' },
+  AWAITING_WORKSPACE_OPTION,
+  { id: 'f57f1ce9', name: 'Preparation', color: 'YELLOW' },
+  { id: 'fd313492', name: 'Failed Preparation', color: 'RED' },
+  { id: 'e9931e57', name: 'Todo by human', color: 'PINK' },
+  { id: 'c2d278b2', name: 'In Tmux by human', color: 'RED' },
+  { id: 'e9f6a726', name: 'In Tmux by agent', color: 'YELLOW' },
+];
+
+const STORY_OPTIONS: ConsoleFixtureFieldOption[] = [
+  { id: '1491051e', name: 'TDPM Console port', color: 'BLUE' },
+  { id: '28415d6c', name: 'regular / workflow improvement', color: 'GRAY' },
+  {
+    id: 'f7cd5cbc',
+    name: 'Publish product documentation site',
+    color: 'GREEN',
+  },
+];
+
+const STORY_COLORS: Record<string, { color: string }> = {
+  'TDPM Console port': { color: 'BLUE' },
+  'regular / workflow improvement': { color: 'GRAY' },
+  'Publish product documentation site': { color: 'GREEN' },
+};
+
+const issueItem = (
+  number: number,
+  title: string,
+  projectItemSuffix: string,
+  story: string,
+  createdAt: string,
+): ConsoleFixtureListItem => ({
+  number,
+  title,
+  url: `https://github.com/${REPO_NAME_WITH_OWNER}/issues/${number}`,
+  repo: REPO_NAME_WITH_OWNER,
+  nameWithOwner: REPO_NAME_WITH_OWNER,
+  projectItemId: `PVTI_lADOABCD1234zg${projectItemSuffix}`,
+  itemId: `PVTI_lADOABCD1234zg${projectItemSuffix}`,
+  isPr: false,
+  story,
+  labels: [],
+  createdAt,
+});
+
+const pullRequestItem = (
+  number: number,
+  title: string,
+  projectItemSuffix: string,
+  story: string,
+  createdAt: string,
+): ConsoleFixtureListItem => ({
+  number,
+  title,
+  url: `https://github.com/${REPO_NAME_WITH_OWNER}/pull/${number}`,
+  repo: REPO_NAME_WITH_OWNER,
+  nameWithOwner: REPO_NAME_WITH_OWNER,
+  projectItemId: `PVTI_lADOABCD1234zg${projectItemSuffix}`,
+  itemId: `PVTI_lADOABCD1234zg${projectItemSuffix}`,
+  isPr: true,
+  story,
+  labels: ['claude'],
+  createdAt,
+});
+
+const buildSnapshot = (
+  items: ConsoleFixtureListItem[],
+): ConsoleFixtureSnapshot => ({
+  pjcode: CONSOLE_E2E_PJCODE,
+  generatedAt: '2026-06-18T01:22:09.000Z',
+  statusOptions: STATUS_OPTIONS,
+  storyOptions: STORY_OPTIONS,
+  storyColors: STORY_COLORS,
+  items,
+});
+
+export const CONSOLE_E2E_TAB_ITEMS: Record<string, ConsoleFixtureListItem[]> = {
+  prs: [
+    pullRequestItem(
+      867,
+      'Serve the committed console UI bundle from serveConsole',
+      'PRS00867',
+      'TDPM Console port',
+      '2026-06-17T23:41:08.000Z',
+    ),
+  ],
+  triage: [
+    issueItem(
+      778,
+      'Add Sonnet to Opus weekly-limit fallback routing per token',
+      'TRI00778',
+      'regular / workflow improvement',
+      '2026-06-12T23:01:55.000Z',
+    ),
+    issueItem(
+      692,
+      'Publish the generated documentation site to GitHub Pages',
+      'TRI00692',
+      'Publish product documentation site',
+      '2026-06-10T11:42:00.000Z',
+    ),
+  ],
+  unread: [
+    issueItem(
+      845,
+      'Scaffold React console UI under entry-points with build bundling',
+      'UNR00845',
+      'TDPM Console port',
+      '2026-06-16T22:01:55.000Z',
+    ),
+    issueItem(
+      853,
+      'Add server-side console API handlers for read and operation endpoints',
+      'UNR00853',
+      'TDPM Console port',
+      '2026-06-17T05:48:09.000Z',
+    ),
+  ],
+  'failed-preparation': [],
+  'todo-by-human': [
+    issueItem(
+      869,
+      'Auto-advance to the next non-empty console tab when one empties',
+      'TODO00869',
+      'TDPM Console port',
+      '2026-06-18T00:14:51.000Z',
+    ),
+  ],
+};
+
+const writeFixtureData = (consoleDataOutputDir: string): void => {
+  for (const [tab, items] of Object.entries(CONSOLE_E2E_TAB_ITEMS)) {
+    const tabDir = path.join(consoleDataOutputDir, CONSOLE_E2E_PJCODE, tab);
+    fs.mkdirSync(tabDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(tabDir, 'list.json'),
+      JSON.stringify(buildSnapshot(items)),
+    );
+  }
+};
+
+const buildE2eProject = (): Project => ({
+  id: 'PVT_console_e2e',
+  url: `https://github.com/orgs/HiromiShikata/projects/1`,
+  databaseId: 1,
+  name: 'TDPM',
+  status: {
+    name: 'Status',
+    fieldId: 'PVTSSF_status',
+    statuses: STATUS_OPTIONS.map((option) => ({
+      id: option.id,
+      name: option.name,
+      color: option.color as Project['status']['statuses'][number]['color'],
+      description: '',
+    })),
+  },
+  nextActionDate: { name: 'Next Action Date', fieldId: 'PVTF_nad' },
+  nextActionHour: { name: 'Next Action Hour', fieldId: 'PVTF_nah' },
+  story: {
+    name: 'Story',
+    fieldId: 'PVTSSF_story',
+    databaseId: 2,
+    stories: STORY_OPTIONS.map((option) => ({
+      id: option.id,
+      name: option.name,
+      color: option.color as Project['status']['statuses'][number]['color'],
+      description: '',
+    })),
+    workflowManagementStory: { id: 'wms_1', name: 'regular / workflow' },
+  },
+  remainingEstimationMinutes: null,
+  dependedIssueUrlSeparatedByComma: null,
+  completionDate50PercentConfidence: null,
+});
+
+const buildIssueForUrl = (url: string): Issue => ({
+  nameWithOwner: REPO_NAME_WITH_OWNER,
+  number: 0,
+  title: 'Console E2E fixture issue',
+  state: 'OPEN',
+  status: null,
+  story: null,
+  nextActionDate: null,
+  nextActionHour: null,
+  estimationMinutes: null,
+  dependedIssueUrls: [],
+  completionDate50PercentConfidence: null,
+  url,
+  assignees: [],
+  labels: [],
+  org: 'HiromiShikata',
+  repo: 'npm-cli-github-issue-tower-defence-management',
+  body: 'Console E2E fixture issue body.',
+  itemId: '',
+  isPr: url.includes('/pull/'),
+  isInProgress: false,
+  isClosed: false,
+  createdAt: new Date('2026-06-18T00:00:00.000Z'),
+  author: 'HiromiShikata',
+});
+
+const notImplemented = (method: string): never => {
+  throw new Error(`console E2E stub does not implement ${method}`);
+};
+
+const createStubIssueRepository = (): IssueRepository => ({
+  getAllIssues: () => notImplemented('getAllIssues'),
+  getIssueByUrl: async (url: string): Promise<Issue | null> =>
+    buildIssueForUrl(url),
+  createNewIssue: () => notImplemented('createNewIssue'),
+  searchIssue: () => notImplemented('searchIssue'),
+  updateIssue: () => notImplemented('updateIssue'),
+  updateNextActionDate: async (): Promise<void> => undefined,
+  updateNextActionHour: () => notImplemented('updateNextActionHour'),
+  updateProjectTextField: () => notImplemented('updateProjectTextField'),
+  updateStory: async (): Promise<void> => undefined,
+  updateStatus: async (): Promise<void> => undefined,
+  clearProjectField: () => notImplemented('clearProjectField'),
+  createComment: () => notImplemented('createComment'),
+  updateLabels: () => notImplemented('updateLabels'),
+  removeLabel: () => notImplemented('removeLabel'),
+  updateAssigneeList: () => notImplemented('updateAssigneeList'),
+  get: async (issueUrl: string): Promise<Issue | null> =>
+    buildIssueForUrl(issueUrl),
+  update: () => notImplemented('update'),
+  findRelatedOpenPRs: async (): Promise<RelatedPullRequest[]> => [],
+  getOpenPullRequest: async (): Promise<RelatedPullRequest | null> => null,
+  getPullRequestChangedFilePaths: async (): Promise<string[]> => [],
+  approvePullRequest: async (): Promise<void> => undefined,
+  requestChangesWithInlineComment: async (): Promise<void> => undefined,
+  closePullRequest: async (): Promise<void> => undefined,
+  closeIssueByUrl: async (): Promise<void> => undefined,
+  deletePullRequestBranch: () => notImplemented('deletePullRequestBranch'),
+  createCommentByUrl: async (): Promise<void> => undefined,
+  getAllOpened: () => notImplemented('getAllOpened'),
+  getStoryObjectMap: () => notImplemented('getStoryObjectMap'),
+  addIssueToProject: () => notImplemented('addIssueToProject'),
+  setDependedIssueUrl: () => notImplemented('setDependedIssueUrl'),
+  getIssueOrPullRequestBody: async (): Promise<string> =>
+    '## Console E2E fixture\n\nThis body is served by the isolated E2E stub.',
+  getIssueOrPullRequestComments: async (): Promise<IssueComment[]> => [],
+  getPullRequestDetail: async (): Promise<PullRequestDetail | null> => null,
+  getPullRequestCommits: async (): Promise<PullRequestCommit[]> => [],
+  getIssueOrPullRequestState: async (
+    url: string,
+  ): Promise<{ state: string; merged: boolean; isPullRequest: boolean }> => ({
+    state: 'open',
+    merged: false,
+    isPullRequest: url.includes('/pull/'),
+  }),
+  getPullRequestSummary: async (): Promise<{
+    title: string;
+    body: string;
+    additions: number;
+    deletions: number;
+    changedFiles: number;
+  } | null> => null,
+});
+
+export type ConsoleE2eHarness = {
+  baseUrl: string;
+  appUrl: string;
+  consoleDataOutputDir: string;
+  stop: () => Promise<void>;
+};
+
+export const startConsoleE2eHarness = async (): Promise<ConsoleE2eHarness> => {
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'console-e2e-'));
+  const consoleDataOutputDir = path.join(tmpRoot, 'data');
+  writeFixtureData(consoleDataOutputDir);
+
+  const uiDistDir = path.resolve(__dirname, '..', '..', 'ui-dist');
+
+  const project = buildE2eProject();
+  const resolveProject = async (
+    pjcode: string,
+  ): Promise<ConsoleProjectBinding | null> =>
+    pjcode === CONSOLE_E2E_PJCODE ? { pjcode, project } : null;
+
+  const server = await startConsoleServer({
+    accessToken: CONSOLE_E2E_TOKEN,
+    uiDistDir,
+    consoleDataOutputDir,
+    issueRepository: createStubIssueRepository(),
+    resolveProject,
+    issueTitleStateCache: new IssueTitleStateCache(),
+    inTmuxDataDir: null,
+    dashboardDir: null,
+    port: 0,
+  });
+
+  const address = server.address();
+  if (address === null || typeof address === 'string') {
+    await closeServer(server);
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+    throw new Error('console E2E server is not listening on a TCP port');
+  }
+  const baseUrl = `http://127.0.0.1:${address.port}`;
+  const appUrl = `${baseUrl}/projects/${CONSOLE_E2E_PJCODE}?k=${CONSOLE_E2E_TOKEN}`;
+
+  return {
+    baseUrl,
+    appUrl,
+    consoleDataOutputDir,
+    stop: async (): Promise<void> => {
+      await closeServer(server);
+      fs.rmSync(tmpRoot, { recursive: true, force: true });
+    },
+  };
+};
+
+const closeServer = (server: http.Server): Promise<void> =>
+  new Promise((resolve, reject) => {
+    server.close((error) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve();
+    });
+  });

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

@@ -0,0 +1,30 @@
+import path from 'node:path';
+import { defineConfig, devices } from '@playwright/test';
+
+export default defineConfig({
+  testDir: __dirname,
+  testMatch: '**/*.spec.ts',
+  fullyParallel: false,
+  forbidOnly: !!process.env.CI,
+  retries: 0,
+  workers: 1,
+  reporter: [
+    ['list'],
+    ['html', { open: 'never', outputFolder: path.join(__dirname, 'report') }],
+  ],
+  outputDir: path.join(__dirname, 'test-results'),
+  timeout: 60_000,
+  expect: { timeout: 3_000 },
+  use: {
+    actionTimeout: 3_000,
+    navigationTimeout: 3_000,
+    trace: 'on-first-retry',
+    screenshot: 'only-on-failure',
+  },
+  projects: [
+    {
+      name: 'chromium',
+      use: { ...devices['Desktop Chrome'] },
+    },
+  ],
+});

package/src/adapter/entry-points/console/ui/e2e/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "CommonJS",
+    "moduleResolution": "Node",
+    "ignoreDeprecations": "6.0",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "forceConsistentCasingInFileNames": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "types": ["node"]
+  },
+  "include": ["."]
+}

package/src/adapter/entry-points/console/ui/src/features/console/pages/ConsolePage.test.tsx

@@ -100,7 +100,7 @@ describe('ConsolePage', () => {
   it('shows a cancellable toast and only drives the tab to zero after the five second window', async () => {
     jest.useFakeTimers();
     try {
-      const { getByText, findByText } = render(<ConsolePage />);
+      const { getByText, findByText, queryByText } = render(<ConsolePage />);
       await waitFor(() => {
         expect(getByText('Add serveConsole subcommand')).toBeInTheDocument();
       });
@@ -127,9 +127,7 @@ describe('ConsolePage', () => {
       });
 
       await waitFor(() => {
-        expect(
-          getByText('Unread').closest('a')?.getAttribute('aria-current'),
-        ).toBe('page');
+        expect(queryByText('Awaiting Quality Check')).toBeNull();
       });
     } finally {
       jest.useRealTimers();

package/src/adapter/entry-points/console/ui/src/features/console/pages/ConsolePage.tsx

@@ -53,7 +53,8 @@ export const ConsolePage = () => {
   const pjcode = useConsolePjcode();
   const { snapshots, isLoading, error } = useConsoleTabData(pjcode);
   const navigation = useConsoleNavigation(pjcode);
-  const { activeTab, selectedItemKey } = navigation;
+  const { activeTab, selectedItemKey, openItem, closeItem, selectTab } =
+    navigation;
 
   const overlayState = useConsoleOverlay(pjcode ?? OVERLAY_NAMESPACE_FALLBACK);
   const caches = useConsoleCaches();
@@ -124,11 +125,11 @@ export const ConsolePage = () => {
     if (previous.count > 0 && activeCount === 0) {
       const nextTab = findNextNonEmptyTabToRight(activeTab, counts);
       if (nextTab !== null) {
-        navigation.selectTab(nextTab);
-        navigation.closeItem();
+        selectTab(nextTab);
+        closeItem();
       }
     }
-  }, [activeTab, activeCount, counts, navigation]);
+  }, [activeTab, activeCount, counts, selectTab, closeItem]);
 
   const overlayStatusForSelected = ((): ConsoleOverlayStatus | null => {
     if (selectedItem === null) {
@@ -143,8 +144,6 @@ export const ConsolePage = () => {
       ? resolveItemStory(selectedItem, overlayState.overlay)
       : null;
 
-  const { openItem, closeItem } = navigation;
-
   const advanceToNext = useCallback(
     (actedKey: string): void => {
       const nextKey = nextPendingKeyAfter(orderedPendingKeys, actedKey);