github-issue-tower-defence-management 2.19.1 → 2.19.2

package/src/domain/usecases/SetupTowerDefenceProjectUseCase.ts

@@ -1,215 +0,0 @@
-import { FieldOption } from '../entities/Project';
-import { ProjectRepository } from './adapter-interfaces/ProjectRepository';
-import { IssueRepository } from './adapter-interfaces/IssueRepository';
-import { StatusDefaultRepository } from './adapter-interfaces/StatusDefaultRepository';
-import {
-  AWAITING_WORKSPACE_STATUS_NAME,
-  DONE_STATUS_NAME,
-  IN_TMUX_STATUS_NAME,
-  LEGACY_AWAITING_TASK_BREAKDOWN_STATUS_NAME,
-  LEGACY_IN_TMUX_STATUS_NAME,
-  LEGACY_TODO_STATUS_NAME,
-  PC_TODO_STATUS_NAME,
-  REQUIRED_WORKFLOW_STATUSES,
-  TODO_STATUS_NAME,
-  WorkflowStatusDefinition,
-} from '../entities/WorkflowStatus';
-
-export class SetupTowerDefenceProjectUseCase {
-  constructor(
-    private readonly projectRepository: Pick<
-      ProjectRepository,
-      'getByUrl' | 'updateStatusList'
-    >,
-    private readonly issueRepository: Pick<
-      IssueRepository,
-      'getAllIssues' | 'updateStatus'
-    >,
-    private readonly statusDefaultRepository: Pick<
-      StatusDefaultRepository,
-      'setStatusFieldDefault'
-    >,
-  ) {}
-
-  private static readonly LEGACY_STATUS_NAMES: Readonly<
-    Record<string, string>
-  > = {
-    [AWAITING_WORKSPACE_STATUS_NAME]: LEGACY_TODO_STATUS_NAME,
-    [TODO_STATUS_NAME]: LEGACY_TODO_STATUS_NAME,
-    [IN_TMUX_STATUS_NAME]: LEGACY_IN_TMUX_STATUS_NAME,
-  };
-
-  private static readonly UNREAD_MIGRATED_STATUS_NAME = 'Unread' as const;
-
-  private static readonly MIGRATED_FROM_NAMES: ReadonlySet<string> = new Set([
-    LEGACY_TODO_STATUS_NAME,
-    LEGACY_IN_TMUX_STATUS_NAME,
-    PC_TODO_STATUS_NAME,
-    LEGACY_AWAITING_TASK_BREAKDOWN_STATUS_NAME,
-    SetupTowerDefenceProjectUseCase.UNREAD_MIGRATED_STATUS_NAME,
-  ]);
-
-  run = async (params: { projectUrl: string }): Promise<void> => {
-    const project = await this.projectRepository.getByUrl(params.projectUrl);
-    const existing = project.status.statuses;
-    const awaitingWorkspaceStatus = existing.find(
-      (s) => s.name === AWAITING_WORKSPACE_STATUS_NAME,
-    );
-
-    let issuesPromise: ReturnType<IssueRepository['getAllIssues']> | null =
-      null;
-    const fetchIssues = () => {
-      if (!issuesPromise) {
-        issuesPromise = this.issueRepository.getAllIssues(project.id);
-      }
-      return issuesPromise;
-    };
-
-    const unreadStatus = existing.find(
-      (s) =>
-        s.name === SetupTowerDefenceProjectUseCase.UNREAD_MIGRATED_STATUS_NAME,
-    );
-    if (unreadStatus && awaitingWorkspaceStatus) {
-      const { issues } = await fetchIssues();
-      const unreadIssues = issues.filter(
-        (issue) =>
-          issue.status ===
-          SetupTowerDefenceProjectUseCase.UNREAD_MIGRATED_STATUS_NAME,
-      );
-      for (const issue of unreadIssues) {
-        await this.issueRepository.updateStatus(
-          project,
-          issue,
-          awaitingWorkspaceStatus.id,
-        );
-      }
-    }
-
-    const awaitingTaskBreakdownStatus = existing.find(
-      (s) => s.name === LEGACY_AWAITING_TASK_BREAKDOWN_STATUS_NAME,
-    );
-    if (awaitingTaskBreakdownStatus) {
-      const todoStatus = existing.find((s) => s.name === TODO_STATUS_NAME);
-      if (todoStatus) {
-        const { issues } = await fetchIssues();
-        const awaitingTaskBreakdownIssues = issues.filter(
-          (issue) =>
-            issue.status === LEGACY_AWAITING_TASK_BREAKDOWN_STATUS_NAME,
-        );
-        for (const issue of awaitingTaskBreakdownIssues) {
-          await this.issueRepository.updateStatus(
-            project,
-            issue,
-            todoStatus.id,
-          );
-        }
-      }
-    }
-
-    if (awaitingWorkspaceStatus) {
-      const { issues } = await fetchIssues();
-      const limboIssues = issues.filter(
-        (issue) =>
-          issue.state === 'OPEN' &&
-          (issue.status === DONE_STATUS_NAME || issue.status === null),
-      );
-      for (const issue of limboIssues) {
-        await this.issueRepository.updateStatus(
-          project,
-          issue,
-          awaitingWorkspaceStatus.id,
-        );
-      }
-    }
-
-    const awaitingWorkspaceOptionId: string | undefined =
-      awaitingWorkspaceStatus?.id;
-
-    const hasMigratedFromName = existing.some((s) =>
-      SetupTowerDefenceProjectUseCase.MIGRATED_FROM_NAMES.has(s.name),
-    );
-    if (
-      !hasMigratedFromName &&
-      SetupTowerDefenceProjectUseCase.hasRequiredStatusesInCanonicalOrder(
-        existing,
-      )
-    ) {
-      if (awaitingWorkspaceOptionId !== undefined) {
-        await this.statusDefaultRepository.setStatusFieldDefault(
-          project,
-          awaitingWorkspaceOptionId,
-        );
-      }
-      return;
-    }
-
-    const requiredNames = new Set(
-      REQUIRED_WORKFLOW_STATUSES.map((s) => s.name),
-    );
-    const others = existing.filter(
-      (status) =>
-        !requiredNames.has(status.name) &&
-        !SetupTowerDefenceProjectUseCase.MIGRATED_FROM_NAMES.has(status.name),
-    );
-
-    const reusedOptionIds = new Set<FieldOption['id']>();
-    const newStatusList: (Omit<FieldOption, 'id'> & {
-      id: FieldOption['id'] | null;
-    })[] = [
-      ...REQUIRED_WORKFLOW_STATUSES.map((required) => {
-        const legacyName =
-          SetupTowerDefenceProjectUseCase.LEGACY_STATUS_NAMES[required.name];
-        const found =
-          existing.find((status) => status.name === required.name) ??
-          (legacyName !== undefined
-            ? existing.find(
-                (status) =>
-                  status.name === legacyName && !reusedOptionIds.has(status.id),
-              )
-            : undefined);
-        if (found) {
-          reusedOptionIds.add(found.id);
-        }
-        return {
-          id: found ? found.id : null,
-          name: required.name,
-          color: required.color,
-          description: '',
-        };
-      }),
-      ...others.map((other) => ({
-        id: other.id,
-        name: other.name,
-        color: other.color,
-        description: other.description,
-      })),
-    ];
-
-    await this.projectRepository.updateStatusList(project, newStatusList);
-
-    if (awaitingWorkspaceOptionId !== undefined) {
-      await this.statusDefaultRepository.setStatusFieldDefault(
-        project,
-        awaitingWorkspaceOptionId,
-      );
-    }
-  };
-
-  private static hasRequiredStatusesInCanonicalOrder = (
-    existing: FieldOption[],
-  ): boolean => {
-    if (existing.length < REQUIRED_WORKFLOW_STATUSES.length) {
-      return false;
-    }
-    return REQUIRED_WORKFLOW_STATUSES.every(
-      (required: WorkflowStatusDefinition, index: number) => {
-        const actual = existing[index];
-        return (
-          actual.name === required.name &&
-          actual.color === required.color &&
-          actual.description === ''
-        );
-      },
-    );
-  };
-}

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

@@ -1,170 +0,0 @@
-import { mock } from 'jest-mock-extended';
-import { IssueRepository } from './adapter-interfaces/IssueRepository';
-import { StaleTaskPullRequestCloseUseCase } from './StaleTaskPullRequestCloseUseCase';
-import { Issue } from '../entities/Issue';
-
-describe('StaleTaskPullRequestCloseUseCase', () => {
-  const mockIssueRepository = mock<IssueRepository>();
-  const useCase = new StaleTaskPullRequestCloseUseCase(mockIssueRepository);
-
-  const openTaskIssue: Issue = {
-    ...mock<Issue>(),
-    url: 'https://github.com/owner/repo/issues/1',
-    isPr: false,
-    isClosed: false,
-    state: 'OPEN',
-    closingIssueReferenceUrls: [],
-  };
-  const closedTaskIssue: Issue = {
-    ...mock<Issue>(),
-    url: 'https://github.com/owner/repo/issues/2',
-    isPr: false,
-    isClosed: true,
-    state: 'CLOSED',
-    closingIssueReferenceUrls: [],
-  };
-  const anotherClosedTaskIssue: Issue = {
-    ...mock<Issue>(),
-    url: 'https://github.com/owner/repo/issues/3',
-    isPr: false,
-    isClosed: true,
-    state: 'CLOSED',
-    closingIssueReferenceUrls: [],
-  };
-
-  const openPrWithClosedTaskIssue: Issue = {
-    ...mock<Issue>(),
-    url: 'https://github.com/owner/repo/pull/100',
-    isPr: true,
-    isClosed: false,
-    state: 'OPEN',
-    closingIssueReferenceUrls: [closedTaskIssue.url],
-  };
-  const openPrWithOpenTaskIssue: Issue = {
-    ...mock<Issue>(),
-    url: 'https://github.com/owner/repo/pull/101',
-    isPr: true,
-    isClosed: false,
-    state: 'OPEN',
-    closingIssueReferenceUrls: [openTaskIssue.url],
-  };
-  const openPrWithoutTaskIssue: Issue = {
-    ...mock<Issue>(),
-    url: 'https://github.com/owner/repo/pull/102',
-    isPr: true,
-    isClosed: false,
-    state: 'OPEN',
-    closingIssueReferenceUrls: [],
-  };
-  const openPrWithUnknownTaskIssue: Issue = {
-    ...mock<Issue>(),
-    url: 'https://github.com/owner/repo/pull/103',
-    isPr: true,
-    isClosed: false,
-    state: 'OPEN',
-    closingIssueReferenceUrls: ['https://github.com/owner/repo/issues/999'],
-  };
-  const openPrWithClosedAndOpenTaskIssues: Issue = {
-    ...mock<Issue>(),
-    url: 'https://github.com/owner/repo/pull/104',
-    isPr: true,
-    isClosed: false,
-    state: 'OPEN',
-    closingIssueReferenceUrls: [closedTaskIssue.url, openTaskIssue.url],
-  };
-  const closedPrWithClosedTaskIssue: Issue = {
-    ...mock<Issue>(),
-    url: 'https://github.com/owner/repo/pull/105',
-    isPr: true,
-    isClosed: true,
-    state: 'CLOSED',
-    closingIssueReferenceUrls: [closedTaskIssue.url],
-  };
-  const anotherOpenPrWithClosedTaskIssue: Issue = {
-    ...mock<Issue>(),
-    url: 'https://github.com/owner/repo/pull/106',
-    isPr: true,
-    isClosed: false,
-    state: 'OPEN',
-    closingIssueReferenceUrls: [anotherClosedTaskIssue.url],
-  };
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it('should close an open pull request whose every closing issue reference is a closed task issue', async () => {
-    await useCase.run({
-      issues: [closedTaskIssue, openPrWithClosedTaskIssue],
-    });
-
-    expect(mockIssueRepository.closePullRequest).toHaveBeenCalledTimes(1);
-    expect(mockIssueRepository.closePullRequest).toHaveBeenCalledWith(
-      openPrWithClosedTaskIssue.url,
-    );
-  });
-
-  it('should not close a pull request whose closing issue reference is still open', async () => {
-    await useCase.run({
-      issues: [openTaskIssue, openPrWithOpenTaskIssue],
-    });
-
-    expect(mockIssueRepository.closePullRequest).not.toHaveBeenCalled();
-  });
-
-  it('should not close a pull request that has no closing issue reference', async () => {
-    await useCase.run({
-      issues: [closedTaskIssue, openPrWithoutTaskIssue],
-    });
-
-    expect(mockIssueRepository.closePullRequest).not.toHaveBeenCalled();
-  });
-
-  it('should not close a pull request whose closing issue reference is not among the given issues', async () => {
-    await useCase.run({
-      issues: [closedTaskIssue, openPrWithUnknownTaskIssue],
-    });
-
-    expect(mockIssueRepository.closePullRequest).not.toHaveBeenCalled();
-  });
-
-  it('should not close a pull request when only some of its closing issue references are closed', async () => {
-    await useCase.run({
-      issues: [
-        closedTaskIssue,
-        openTaskIssue,
-        openPrWithClosedAndOpenTaskIssues,
-      ],
-    });
-
-    expect(mockIssueRepository.closePullRequest).not.toHaveBeenCalled();
-  });
-
-  it('should not close a pull request that is already closed', async () => {
-    await useCase.run({
-      issues: [closedTaskIssue, closedPrWithClosedTaskIssue],
-    });
-
-    expect(mockIssueRepository.closePullRequest).not.toHaveBeenCalled();
-  });
-
-  it('should continue with the remaining pull requests when closing one of them fails', async () => {
-    mockIssueRepository.closePullRequest.mockRejectedValueOnce(
-      new Error('close failed'),
-    );
-
-    await useCase.run({
-      issues: [
-        closedTaskIssue,
-        anotherClosedTaskIssue,
-        openPrWithClosedTaskIssue,
-        anotherOpenPrWithClosedTaskIssue,
-      ],
-    });
-
-    expect(mockIssueRepository.closePullRequest).toHaveBeenCalledTimes(2);
-    expect(mockIssueRepository.closePullRequest).toHaveBeenCalledWith(
-      anotherOpenPrWithClosedTaskIssue.url,
-    );
-  });
-});

package/src/domain/usecases/StaleTaskPullRequestCloseUseCase.ts

@@ -1,38 +0,0 @@
-import { Issue } from '../entities/Issue';
-import { IssueRepository } from './adapter-interfaces/IssueRepository';
-
-export class StaleTaskPullRequestCloseUseCase {
-  constructor(
-    readonly issueRepository: Pick<IssueRepository, 'closePullRequest'>,
-  ) {}
-
-  run = async (input: { issues: Issue[] }): Promise<void> => {
-    const closedTaskIssueUrls = new Set(
-      input.issues
-        .filter((issue) => !issue.isPr && issue.isClosed)
-        .map((issue) => issue.url),
-    );
-    for (const issue of input.issues) {
-      if (!issue.isPr || issue.isClosed) {
-        continue;
-      }
-      if (issue.closingIssueReferenceUrls.length === 0) {
-        continue;
-      }
-      const everyReferencedTaskIssueClosed =
-        issue.closingIssueReferenceUrls.every((url) =>
-          closedTaskIssueUrls.has(url),
-        );
-      if (!everyReferencedTaskIssueClosed) {
-        continue;
-      }
-      try {
-        await this.issueRepository.closePullRequest(issue.url);
-      } catch (error) {
-        console.warn(
-          `Failed to close stale pull request ${issue.url}, skipping and continuing with remaining pull requests: ${error instanceof Error ? error.message : String(error)}`,
-        );
-      }
-    }
-  };
-}

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

@@ -1,283 +0,0 @@
-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,
-  agent: 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: [],
-    agent: null,
-    stateReason: null,
-    ...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 runParams = (): {
-    project: Project;
-    excludedStatus: string;
-    idleThresholdSeconds: number;
-    now: Date;
-  } => ({
-    project: mockProject,
-    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);
-  });
-
-  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();
-  });
-});