github-issue-tower-defence-management 1.104.4 → 1.106.0

package/src/domain/usecases/StaleTmuxSessionKillUseCase.test.ts

@@ -0,0 +1,286 @@
+import {
+  StaleTmuxSessionKillUseCase,
+  DEFAULT_EXCLUDED_STATUS,
+  DEFAULT_IDLE_THRESHOLD_SECONDS,
+} from './StaleTmuxSessionKillUseCase';
+import { IssueRepository } from './adapter-interfaces/IssueRepository';
+import { TmuxSessionRepository } from './adapter-interfaces/TmuxSessionRepository';
+import { toTmuxSessionName } from './intmux/InTmuxByHumanSessionReconcileUseCase';
+import { Issue } from '../entities/Issue';
+import { LiveTmuxSession } from '../entities/LiveTmuxSession';
+import { Project } from '../entities/Project';
+import { IN_TMUX_STATUS_NAME } from '../entities/WorkflowStatus';
+
+type Mocked<T> = jest.Mocked<T> & jest.MockedObject<T>;
+
+const createMockProject = (): Project => ({
+  id: 'project-1',
+  url: 'https://github.com/users/user/projects/1',
+  databaseId: 1,
+  name: 'Test Project',
+  status: {
+    name: 'Status',
+    fieldId: 'field-1',
+    statuses: [],
+  },
+  nextActionDate: null,
+  nextActionHour: null,
+  story: null,
+  remainingEstimationMinutes: null,
+  dependedIssueUrlSeparatedByComma: null,
+  completionDate50PercentConfidence: null,
+});
+
+let issueCounter = 0;
+const createMockIssue = (overrides: Partial<Issue> = {}): Issue => {
+  issueCounter += 1;
+  return {
+    nameWithOwner: 'user/repo',
+    number: issueCounter,
+    title: `Test Issue ${issueCounter}`,
+    state: 'OPEN',
+    status: IN_TMUX_STATUS_NAME,
+    story: null,
+    nextActionDate: null,
+    nextActionHour: null,
+    estimationMinutes: null,
+    dependedIssueUrls: [],
+    completionDate50PercentConfidence: null,
+    url: `https://github.com/user/repo/issues/${issueCounter}`,
+    assignees: [],
+    labels: [],
+    org: 'user',
+    repo: 'repo',
+    body: '',
+    itemId: `item-${issueCounter}`,
+    isPr: false,
+    isInProgress: false,
+    isClosed: false,
+    createdAt: new Date(),
+    author: 'testuser',
+    closingIssueReferenceUrls: [],
+    ...overrides,
+  };
+};
+
+describe('StaleTmuxSessionKillUseCase', () => {
+  let useCase: StaleTmuxSessionKillUseCase;
+  let mockIssueRepository: Mocked<Pick<IssueRepository, 'getAllOpened'>>;
+  let mockTmuxSessionRepository: Mocked<
+    Pick<TmuxSessionRepository, 'listLiveSessionsWithActivity' | 'killSession'>
+  >;
+  let mockProject: Project;
+  const now = new Date('2026-06-26T00:00:00Z');
+  const nowEpochSeconds = Math.floor(now.getTime() / 1000);
+  const allowCacheMinutes = 10;
+
+  const runParams = (): {
+    project: Project;
+    allowCacheMinutes: number;
+    excludedStatus: string;
+    idleThresholdSeconds: number;
+    now: Date;
+  } => ({
+    project: mockProject,
+    allowCacheMinutes,
+    excludedStatus: DEFAULT_EXCLUDED_STATUS,
+    idleThresholdSeconds: DEFAULT_IDLE_THRESHOLD_SECONDS,
+    now,
+  });
+
+  const setLiveSessions = (sessions: LiveTmuxSession[]): void => {
+    mockTmuxSessionRepository.listLiveSessionsWithActivity.mockResolvedValue(
+      sessions,
+    );
+  };
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+    jest.spyOn(console, 'log').mockImplementation(() => undefined);
+    mockProject = createMockProject();
+    mockIssueRepository = {
+      getAllOpened: jest.fn().mockResolvedValue([]),
+    };
+    mockTmuxSessionRepository = {
+      listLiveSessionsWithActivity: jest.fn().mockResolvedValue([]),
+      killSession: jest.fn().mockResolvedValue(undefined),
+    };
+    useCase = new StaleTmuxSessionKillUseCase(
+      mockIssueRepository,
+      mockTmuxSessionRepository,
+    );
+  });
+
+  it('exposes the excluded status and idle threshold as named constants', () => {
+    expect(DEFAULT_EXCLUDED_STATUS).toBe('In Tmux by human');
+    expect(DEFAULT_EXCLUDED_STATUS).toBe(IN_TMUX_STATUS_NAME);
+    expect(DEFAULT_IDLE_THRESHOLD_SECONDS).toBe(86400);
+  });
+
+  it('lists live sessions with activity and loads open issues for the project', async () => {
+    setLiveSessions([]);
+    await useCase.run(runParams());
+    expect(
+      mockTmuxSessionRepository.listLiveSessionsWithActivity,
+    ).toHaveBeenCalledTimes(1);
+    expect(mockIssueRepository.getAllOpened).toHaveBeenCalledWith(
+      mockProject,
+      allowCacheMinutes,
+    );
+  });
+
+  it('kills a session mapping to an open issue whose status is not the excluded status', async () => {
+    const issue = createMockIssue({ status: 'In Progress' });
+    const sessionName = toTmuxSessionName(issue.url);
+    setLiveSessions([{ sessionName, activityEpochSeconds: nowEpochSeconds }]);
+    mockIssueRepository.getAllOpened.mockResolvedValue([issue]);
+    await useCase.run(runParams());
+    expect(mockTmuxSessionRepository.killSession).toHaveBeenCalledWith(
+      sessionName,
+    );
+  });
+
+  it('kills a session mapping to an open issue whose status is null', async () => {
+    const issue = createMockIssue({ status: null });
+    const sessionName = toTmuxSessionName(issue.url);
+    setLiveSessions([{ sessionName, activityEpochSeconds: nowEpochSeconds }]);
+    mockIssueRepository.getAllOpened.mockResolvedValue([issue]);
+    await useCase.run(runParams());
+    expect(mockTmuxSessionRepository.killSession).toHaveBeenCalledWith(
+      sessionName,
+    );
+  });
+
+  it('kills an excluded-status session that has a next action date set', async () => {
+    const issue = createMockIssue({
+      status: DEFAULT_EXCLUDED_STATUS,
+      nextActionDate: new Date('2026-06-27T00:00:00Z'),
+    });
+    const sessionName = toTmuxSessionName(issue.url);
+    setLiveSessions([{ sessionName, activityEpochSeconds: nowEpochSeconds }]);
+    mockIssueRepository.getAllOpened.mockResolvedValue([issue]);
+    await useCase.run(runParams());
+    expect(mockTmuxSessionRepository.killSession).toHaveBeenCalledWith(
+      sessionName,
+    );
+  });
+
+  it('kills an excluded-status session that has a next action hour set', async () => {
+    const issue = createMockIssue({
+      status: DEFAULT_EXCLUDED_STATUS,
+      nextActionHour: 9,
+    });
+    const sessionName = toTmuxSessionName(issue.url);
+    setLiveSessions([{ sessionName, activityEpochSeconds: nowEpochSeconds }]);
+    mockIssueRepository.getAllOpened.mockResolvedValue([issue]);
+    await useCase.run(runParams());
+    expect(mockTmuxSessionRepository.killSession).toHaveBeenCalledWith(
+      sessionName,
+    );
+  });
+
+  it('never kills an excluded-status session that has no reactivation trigger', async () => {
+    const issue = createMockIssue({
+      status: DEFAULT_EXCLUDED_STATUS,
+      nextActionDate: null,
+      nextActionHour: null,
+    });
+    const sessionName = toTmuxSessionName(issue.url);
+    setLiveSessions([{ sessionName, activityEpochSeconds: nowEpochSeconds }]);
+    mockIssueRepository.getAllOpened.mockResolvedValue([issue]);
+    await useCase.run(runParams());
+    expect(mockTmuxSessionRepository.killSession).not.toHaveBeenCalled();
+  });
+
+  it('kills a no-task session that has been idle at least the idle threshold', async () => {
+    const sessionName = 'no_task_session';
+    const idleActivity = nowEpochSeconds - DEFAULT_IDLE_THRESHOLD_SECONDS;
+    setLiveSessions([{ sessionName, activityEpochSeconds: idleActivity }]);
+    mockIssueRepository.getAllOpened.mockResolvedValue([]);
+    await useCase.run(runParams());
+    expect(mockTmuxSessionRepository.killSession).toHaveBeenCalledWith(
+      sessionName,
+    );
+  });
+
+  it('never kills a no-task session that was active within the idle threshold', async () => {
+    const sessionName = 'no_task_session';
+    const recentActivity = nowEpochSeconds - DEFAULT_IDLE_THRESHOLD_SECONDS + 1;
+    setLiveSessions([{ sessionName, activityEpochSeconds: recentActivity }]);
+    mockIssueRepository.getAllOpened.mockResolvedValue([]);
+    await useCase.run(runParams());
+    expect(mockTmuxSessionRepository.killSession).not.toHaveBeenCalled();
+  });
+
+  it('does nothing when there are no live sessions', async () => {
+    setLiveSessions([]);
+    mockIssueRepository.getAllOpened.mockResolvedValue([]);
+    await useCase.run(runParams());
+    expect(mockTmuxSessionRepository.killSession).not.toHaveBeenCalled();
+  });
+
+  it('maps a session back to its issue using the dot-and-colon-to-underscore convention', async () => {
+    const issue = createMockIssue({
+      url: 'https://github.com/owner/repo/issues/9',
+      status: 'In Progress',
+    });
+    const sessionName = 'https_//github_com/owner/repo/issues/9';
+    expect(toTmuxSessionName(issue.url)).toBe(sessionName);
+    setLiveSessions([{ sessionName, activityEpochSeconds: nowEpochSeconds }]);
+    mockIssueRepository.getAllOpened.mockResolvedValue([issue]);
+    await useCase.run(runParams());
+    expect(mockTmuxSessionRepository.killSession).toHaveBeenCalledWith(
+      sessionName,
+    );
+  });
+
+  it('enumerates and logs the kill-candidate list before killing', async () => {
+    const logSpy = jest.spyOn(console, 'log');
+    const killOrder: string[] = [];
+    mockTmuxSessionRepository.killSession.mockImplementation(
+      async (sessionName: string) => {
+        killOrder.push(sessionName);
+      },
+    );
+    const issue = createMockIssue({ status: 'In Progress' });
+    const sessionName = toTmuxSessionName(issue.url);
+    setLiveSessions([{ sessionName, activityEpochSeconds: nowEpochSeconds }]);
+    mockIssueRepository.getAllOpened.mockResolvedValue([issue]);
+
+    await useCase.run(runParams());
+
+    const candidateLogIndex = logSpy.mock.calls.findIndex((call) =>
+      String(call[0]).startsWith('Kill candidate:'),
+    );
+    const killedLogIndex = logSpy.mock.calls.findIndex((call) =>
+      String(call[0]).startsWith('Killed tmux session:'),
+    );
+    expect(candidateLogIndex).toBeGreaterThanOrEqual(0);
+    expect(killedLogIndex).toBeGreaterThan(candidateLogIndex);
+    expect(killOrder).toEqual([sessionName]);
+  });
+
+  it('does not suppress errors raised while killing a session', async () => {
+    const issue = createMockIssue({ status: 'In Progress' });
+    const sessionName = toTmuxSessionName(issue.url);
+    setLiveSessions([{ sessionName, activityEpochSeconds: nowEpochSeconds }]);
+    mockIssueRepository.getAllOpened.mockResolvedValue([issue]);
+    mockTmuxSessionRepository.killSession.mockRejectedValue(
+      new Error('tmux kill failed'),
+    );
+    await expect(useCase.run(runParams())).rejects.toThrow('tmux kill failed');
+  });
+
+  it('does not kill any session when loading open issues fails', async () => {
+    const sessionName = 'no_task_session';
+    const idleActivity = nowEpochSeconds - DEFAULT_IDLE_THRESHOLD_SECONDS;
+    setLiveSessions([{ sessionName, activityEpochSeconds: idleActivity }]);
+    mockIssueRepository.getAllOpened.mockRejectedValue(
+      new Error('failed to load issues'),
+    );
+    await expect(useCase.run(runParams())).rejects.toThrow(
+      'failed to load issues',
+    );
+    expect(mockTmuxSessionRepository.killSession).not.toHaveBeenCalled();
+  });
+});

package/src/domain/usecases/StaleTmuxSessionKillUseCase.ts

@@ -0,0 +1,102 @@
+import { Issue } from '../entities/Issue';
+import { LiveTmuxSession } from '../entities/LiveTmuxSession';
+import { Project } from '../entities/Project';
+import { IN_TMUX_STATUS_NAME } from '../entities/WorkflowStatus';
+import { IssueRepository } from './adapter-interfaces/IssueRepository';
+import { TmuxSessionRepository } from './adapter-interfaces/TmuxSessionRepository';
+import { toTmuxSessionName } from './intmux/InTmuxByHumanSessionReconcileUseCase';
+
+export const DEFAULT_EXCLUDED_STATUS = IN_TMUX_STATUS_NAME;
+export const DEFAULT_IDLE_THRESHOLD_SECONDS = 24 * 60 * 60;
+
+type KillCandidate = {
+  sessionName: string;
+  reason: string;
+};
+
+export class StaleTmuxSessionKillUseCase {
+  constructor(
+    private readonly issueRepository: Pick<IssueRepository, 'getAllOpened'>,
+    private readonly tmuxSessionRepository: Pick<
+      TmuxSessionRepository,
+      'listLiveSessionsWithActivity' | 'killSession'
+    >,
+  ) {}
+
+  run = async (params: {
+    project: Project;
+    allowCacheMinutes: number;
+    excludedStatus: string;
+    idleThresholdSeconds: number;
+    now: Date;
+  }): Promise<void> => {
+    const liveSessions =
+      await this.tmuxSessionRepository.listLiveSessionsWithActivity();
+    const openIssues = await this.issueRepository.getAllOpened(
+      params.project,
+      params.allowCacheMinutes,
+    );
+    const issueBySessionName = new Map<string, Issue>();
+    for (const issue of openIssues) {
+      issueBySessionName.set(toTmuxSessionName(issue.url), issue);
+    }
+
+    const nowEpochSeconds = Math.floor(params.now.getTime() / 1000);
+    const killCandidates: KillCandidate[] = [];
+    for (const session of liveSessions) {
+      const reason = this.evaluateKillReason(
+        session,
+        issueBySessionName.get(session.sessionName) ?? null,
+        nowEpochSeconds,
+        params.excludedStatus,
+        params.idleThresholdSeconds,
+      );
+      if (reason !== null) {
+        killCandidates.push({ sessionName: session.sessionName, reason });
+      }
+    }
+
+    console.log(
+      `Stale tmux session cleanup: ${killCandidates.length} kill candidate(s) of ${liveSessions.length} live session(s).`,
+    );
+    for (const candidate of killCandidates) {
+      console.log(
+        `Kill candidate: ${candidate.sessionName} (${candidate.reason})`,
+      );
+    }
+
+    for (const candidate of killCandidates) {
+      await this.tmuxSessionRepository.killSession(candidate.sessionName);
+      console.log(
+        `Killed tmux session: ${candidate.sessionName} (${candidate.reason})`,
+      );
+    }
+  };
+
+  private evaluateKillReason = (
+    session: LiveTmuxSession,
+    issue: Issue | null,
+    nowEpochSeconds: number,
+    excludedStatus: string,
+    idleThresholdSeconds: number,
+  ): string | null => {
+    if (issue !== null) {
+      if (issue.status !== excludedStatus) {
+        return `mapped to open issue ${issue.url} with status "${issue.status ?? 'null'}" which is not the excluded status "${excludedStatus}"`;
+      }
+      if (issue.nextActionDate !== null) {
+        return `mapped to open issue ${issue.url} which has a next action date set`;
+      }
+      if (issue.nextActionHour !== null) {
+        return `mapped to open issue ${issue.url} which has a next action hour set`;
+      }
+      return null;
+    }
+
+    const idleSeconds = nowEpochSeconds - session.activityEpochSeconds;
+    if (idleSeconds >= idleThresholdSeconds) {
+      return `maps to no open issue and has been idle for ${idleSeconds} seconds (threshold ${idleThresholdSeconds} seconds)`;
+    }
+    return null;
+  };
+}

package/src/domain/usecases/adapter-interfaces/TakeOwnershipSpawnRepository.ts

@@ -0,0 +1,8 @@
+export type TakeOwnershipSpawn = {
+  token: string;
+  logPath: string;
+};
+
+export interface TakeOwnershipSpawnRepository {
+  listSpawns: () => TakeOwnershipSpawn[];
+}

package/src/domain/usecases/adapter-interfaces/TmuxSessionRepository.ts

@@ -1,9 +1,13 @@
+import { LiveTmuxSession } from '../../entities/LiveTmuxSession';
+
 export interface TmuxSessionRepository {
   listLiveSessionNames: () => Promise<string[]>;
+  listLiveSessionsWithActivity: () => Promise<LiveTmuxSession[]>;
   listInteractiveProcessCommandLines: () => Promise<string[]>;
   launchDetachedSession: (
     sessionName: string,
     launcherCommand: string,
     issueUrl: string,
   ) => Promise<void>;
+  killSession: (sessionName: string) => Promise<void>;
 }

package/src/domain/usecases/dashboard/GenerateDashboardRowUseCase.test.ts

@@ -0,0 +1,159 @@
+import { Issue } from '../../entities/Issue';
+import { GenerateDashboardRowUseCase } from './GenerateDashboardRowUseCase';
+
+const ASSIGNEE = 'HiromiShikata';
+
+let issueCounter = 0;
+const makeIssue = (overrides: Partial<Issue>): Issue => {
+  issueCounter += 1;
+  return {
+    nameWithOwner: 'demo/repo',
+    number: issueCounter,
+    title: `Issue ${issueCounter}`,
+    state: 'OPEN',
+    status: null,
+    story: null,
+    nextActionDate: null,
+    nextActionHour: null,
+    estimationMinutes: null,
+    dependedIssueUrls: [],
+    completionDate50PercentConfidence: null,
+    url: `https://github.com/demo/repo/issues/${issueCounter}`,
+    assignees: [ASSIGNEE],
+    labels: [],
+    org: 'demo',
+    repo: 'repo',
+    body: '',
+    itemId: `item-${issueCounter}`,
+    isPr: false,
+    isInProgress: false,
+    isClosed: false,
+    createdAt: new Date('2026-06-13T08:18:45.000Z'),
+    author: 'someone',
+    closingIssueReferenceUrls: [],
+    ...overrides,
+  };
+};
+
+describe('GenerateDashboardRowUseCase', () => {
+  const usecase = new GenerateDashboardRowUseCase();
+
+  beforeEach(() => {
+    issueCounter = 0;
+  });
+
+  it('returns all-zero counts for an empty issue list', () => {
+    expect(usecase.run({ issues: [], assigneeLogin: ASSIGNEE })).toEqual({
+      unread: 0,
+      todo: 0,
+      qc: 0,
+      fail: 0,
+      pr: 0,
+      ws: 0,
+      dep: 0,
+      blocker: 0,
+    });
+  });
+
+  it('counts actionable Unread, Todo, Awaiting Quality Check and Awaiting Workspace issues', () => {
+    const issues = [
+      makeIssue({ status: 'Unread' }),
+      makeIssue({ status: 'Todo by human' }),
+      makeIssue({ status: 'Awaiting Quality Check' }),
+      makeIssue({ status: 'Awaiting Workspace' }),
+    ];
+
+    expect(usecase.run({ issues, assigneeLogin: ASSIGNEE })).toEqual({
+      unread: 1,
+      todo: 1,
+      qc: 1,
+      fail: 0,
+      pr: 0,
+      ws: 1,
+      dep: 0,
+      blocker: 0,
+    });
+  });
+
+  it('excludes non-actionable issues from actionable status columns', () => {
+    const issues = [
+      makeIssue({ status: 'Unread', nextActionDate: new Date() }),
+      makeIssue({ status: 'Unread', nextActionHour: 9 }),
+      makeIssue({
+        status: 'Awaiting Quality Check',
+        dependedIssueUrls: ['https://github.com/demo/repo/issues/999'],
+      }),
+      makeIssue({ status: 'Todo by human', assignees: ['someone-else'] }),
+      makeIssue({ status: 'Awaiting Workspace', isClosed: true }),
+    ];
+
+    expect(usecase.run({ issues, assigneeLogin: ASSIGNEE })).toEqual({
+      unread: 0,
+      todo: 0,
+      qc: 0,
+      fail: 0,
+      pr: 0,
+      ws: 0,
+      dep: 0,
+      blocker: 0,
+    });
+  });
+
+  it('counts Preparation and Failed Preparation by whole status without the actionable predicate', () => {
+    const issues = [
+      makeIssue({ status: 'Preparation', nextActionHour: 9 }),
+      makeIssue({
+        status: 'Failed Preparation',
+        dependedIssueUrls: ['https://github.com/demo/repo/issues/999'],
+      }),
+      makeIssue({ status: 'Preparation', isClosed: true }),
+      makeIssue({ status: 'Failed Preparation', assignees: ['someone-else'] }),
+    ];
+
+    expect(usecase.run({ issues, assigneeLogin: ASSIGNEE })).toEqual({
+      unread: 0,
+      todo: 0,
+      qc: 0,
+      fail: 1,
+      pr: 1,
+      ws: 0,
+      dep: 0,
+      blocker: 0,
+    });
+  });
+
+  it('counts dep as Awaiting Workspace issues blocked by a dependency, and never as ws', () => {
+    const issues = [
+      makeIssue({ status: 'Awaiting Workspace' }),
+      makeIssue({
+        status: 'Awaiting Workspace',
+        dependedIssueUrls: ['https://github.com/demo/repo/issues/999'],
+      }),
+    ];
+
+    expect(usecase.run({ issues, assigneeLogin: ASSIGNEE })).toMatchObject({
+      ws: 1,
+      dep: 1,
+    });
+  });
+
+  it('counts blocker by case-insensitive workflow blocker story membership for non-closed mine issues', () => {
+    const issues = [
+      makeIssue({ status: 'Unread', story: 'Workflow Blocker / urgent' }),
+      makeIssue({ status: 'Awaiting Workspace', story: 'workflow blocker' }),
+      makeIssue({ status: 'Unread', story: 'regular / maintenance' }),
+      makeIssue({
+        status: 'Unread',
+        story: 'workflow blocker',
+        isClosed: true,
+      }),
+      makeIssue({
+        status: 'Unread',
+        story: 'workflow blocker',
+        assignees: ['someone-else'],
+      }),
+    ];
+
+    expect(usecase.run({ issues, assigneeLogin: ASSIGNEE }).blocker).toBe(2);
+  });
+});

package/src/domain/usecases/dashboard/GenerateDashboardRowUseCase.ts

@@ -0,0 +1,72 @@
+import { Issue } from '../../entities/Issue';
+import {
+  AWAITING_QUALITY_CHECK_STATUS_NAME,
+  AWAITING_WORKSPACE_STATUS_NAME,
+  DEFAULT_STATUS_NAME,
+  FAILED_PREPARATION_STATUS_NAME,
+  PREPARATION_STATUS_NAME,
+  TODO_STATUS_NAME,
+} from '../../entities/WorkflowStatus';
+
+export type DashboardRow = {
+  unread: number;
+  todo: number;
+  qc: number;
+  fail: number;
+  pr: number;
+  ws: number;
+  dep: number;
+  blocker: number;
+};
+
+export type GenerateDashboardRowInput = {
+  issues: Issue[];
+  assigneeLogin: string;
+};
+
+const WORKFLOW_BLOCKER_STORY_MARKER = 'workflow blocker';
+
+export class GenerateDashboardRowUseCase {
+  run = (input: GenerateDashboardRowInput): DashboardRow => {
+    const { issues, assigneeLogin } = input;
+
+    const mine = (issue: Issue): boolean =>
+      issue.isClosed === false && issue.assignees.includes(assigneeLogin);
+
+    const actionable = (issue: Issue): boolean =>
+      mine(issue) &&
+      issue.dependedIssueUrls.length === 0 &&
+      issue.nextActionDate === null &&
+      issue.nextActionHour === null;
+
+    const countActionableWithStatus = (statusName: string): number =>
+      issues.filter((issue) => issue.status === statusName && actionable(issue))
+        .length;
+
+    const countMineWithStatus = (statusName: string): number =>
+      issues.filter((issue) => mine(issue) && issue.status === statusName)
+        .length;
+
+    return {
+      unread: countActionableWithStatus(DEFAULT_STATUS_NAME),
+      todo: countActionableWithStatus(TODO_STATUS_NAME),
+      qc: countActionableWithStatus(AWAITING_QUALITY_CHECK_STATUS_NAME),
+      fail: countMineWithStatus(FAILED_PREPARATION_STATUS_NAME),
+      pr: countMineWithStatus(PREPARATION_STATUS_NAME),
+      ws: countActionableWithStatus(AWAITING_WORKSPACE_STATUS_NAME),
+      dep: issues.filter(
+        (issue) =>
+          mine(issue) &&
+          issue.status === AWAITING_WORKSPACE_STATUS_NAME &&
+          issue.dependedIssueUrls.length > 0,
+      ).length,
+      blocker: issues.filter(
+        (issue) =>
+          mine(issue) &&
+          (issue.story ?? '')
+            .toLowerCase()
+            .includes(WORKFLOW_BLOCKER_STORY_MARKER),
+      ).length,
+    };
+  };
+}