github-issue-tower-defence-management 1.105.0 → 1.107.0

package/src/adapter/entry-points/handlers/staleTmuxSessionCleaner.test.ts

@@ -0,0 +1,170 @@
+import { Issue } from '../../../domain/entities/Issue';
+import { Project } from '../../../domain/entities/Project';
+import { LocalCommandRunner } from '../../../domain/usecases/adapter-interfaces/LocalCommandRunner';
+import { IssueRepository } from '../../../domain/usecases/adapter-interfaces/IssueRepository';
+import { IN_TMUX_STATUS_NAME } from '../../../domain/entities/WorkflowStatus';
+import { cleanStaleTmuxSessions } from './staleTmuxSessionCleaner';
+
+const NOW = new Date('2026-06-26T00:00:00.000Z');
+const NOW_EPOCH_SECONDS = Math.floor(NOW.getTime() / 1000);
+const ALLOW_CACHE_MINUTES = 10;
+
+const makeProject = (): 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,
+});
+
+const makeIssue = (overrides: Partial<Issue> = {}): Issue => ({
+  nameWithOwner: 'demo/repo',
+  number: 1,
+  title: 'Issue 1',
+  state: 'OPEN',
+  status: IN_TMUX_STATUS_NAME,
+  story: null,
+  nextActionDate: null,
+  nextActionHour: null,
+  estimationMinutes: null,
+  dependedIssueUrls: [],
+  completionDate50PercentConfidence: null,
+  url: 'https://github.com/demo/repo/issues/1',
+  assignees: [],
+  labels: [],
+  org: 'demo',
+  repo: 'repo',
+  body: '',
+  itemId: 'item-1',
+  isPr: false,
+  isInProgress: false,
+  isClosed: false,
+  createdAt: new Date(),
+  author: '',
+  closingIssueReferenceUrls: [],
+  ...overrides,
+});
+
+type Mocked<T> = jest.Mocked<T> & jest.MockedObject<T>;
+
+const createMockRunner = (): Mocked<LocalCommandRunner> => ({
+  runCommand: jest.fn(),
+});
+
+const createMockIssueRepository = (
+  issues: Issue[],
+): Pick<IssueRepository, 'getAllOpened'> => ({
+  getAllOpened: jest.fn().mockResolvedValue(issues),
+});
+
+describe('cleanStaleTmuxSessions', () => {
+  beforeEach(() => {
+    jest.spyOn(console, 'log').mockImplementation(() => undefined);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('kills a session mapping to an open issue whose status is not the excluded status', async () => {
+    const runner = createMockRunner();
+    runner.runCommand.mockImplementation(async (program, args) => {
+      if (program === 'tmux' && args[0] === 'list-sessions') {
+        return {
+          stdout: `https_//github_com/demo/repo/issues/1 ${NOW_EPOCH_SECONDS}\n`,
+          stderr: '',
+          exitCode: 0,
+        };
+      }
+      return { stdout: '', stderr: '', exitCode: 0 };
+    });
+
+    await cleanStaleTmuxSessions({
+      project: makeProject(),
+      allowCacheMinutes: ALLOW_CACHE_MINUTES,
+      issueRepository: createMockIssueRepository([
+        makeIssue({ status: 'In Progress' }),
+      ]),
+      localCommandRunner: runner,
+      now: NOW,
+    });
+
+    const killCall = runner.runCommand.mock.calls.find(
+      (call) => call[0] === 'tmux' && call[1][0] === 'kill-session',
+    );
+    expect(killCall?.[1]).toEqual([
+      'kill-session',
+      '-t',
+      'https_//github_com/demo/repo/issues/1',
+    ]);
+  });
+
+  it('does not kill an excluded-status session that has no reactivation trigger', async () => {
+    const runner = createMockRunner();
+    runner.runCommand.mockImplementation(async (program, args) => {
+      if (program === 'tmux' && args[0] === 'list-sessions') {
+        return {
+          stdout: `https_//github_com/demo/repo/issues/1 ${NOW_EPOCH_SECONDS}\n`,
+          stderr: '',
+          exitCode: 0,
+        };
+      }
+      return { stdout: '', stderr: '', exitCode: 0 };
+    });
+
+    await cleanStaleTmuxSessions({
+      project: makeProject(),
+      allowCacheMinutes: ALLOW_CACHE_MINUTES,
+      issueRepository: createMockIssueRepository([
+        makeIssue({ status: IN_TMUX_STATUS_NAME }),
+      ]),
+      localCommandRunner: runner,
+      now: NOW,
+    });
+
+    const killCalls = runner.runCommand.mock.calls.filter(
+      (call) => call[0] === 'tmux' && call[1][0] === 'kill-session',
+    );
+    expect(killCalls).toHaveLength(0);
+  });
+
+  it('kills a no-task session idle at least 24 hours and spares a recently active one', async () => {
+    const runner = createMockRunner();
+    const idleActivity = NOW_EPOCH_SECONDS - 24 * 60 * 60;
+    const recentActivity = NOW_EPOCH_SECONDS - 24 * 60 * 60 + 1;
+    runner.runCommand.mockImplementation(async (program, args) => {
+      if (program === 'tmux' && args[0] === 'list-sessions') {
+        return {
+          stdout: `idle_no_task ${idleActivity}\nrecent_no_task ${recentActivity}\n`,
+          stderr: '',
+          exitCode: 0,
+        };
+      }
+      return { stdout: '', stderr: '', exitCode: 0 };
+    });
+
+    await cleanStaleTmuxSessions({
+      project: makeProject(),
+      allowCacheMinutes: ALLOW_CACHE_MINUTES,
+      issueRepository: createMockIssueRepository([]),
+      localCommandRunner: runner,
+      now: NOW,
+    });
+
+    const killCalls = runner.runCommand.mock.calls.filter(
+      (call) => call[0] === 'tmux' && call[1][0] === 'kill-session',
+    );
+    expect(killCalls).toHaveLength(1);
+    expect(killCalls[0][1]).toEqual(['kill-session', '-t', 'idle_no_task']);
+  });
+});

package/src/adapter/entry-points/handlers/staleTmuxSessionCleaner.ts

@@ -0,0 +1,40 @@
+import { Project } from '../../../domain/entities/Project';
+import { LocalCommandRunner } from '../../../domain/usecases/adapter-interfaces/LocalCommandRunner';
+import { IssueRepository } from '../../../domain/usecases/adapter-interfaces/IssueRepository';
+import {
+  StaleTmuxSessionKillUseCase,
+  DEFAULT_EXCLUDED_STATUS,
+  DEFAULT_IDLE_THRESHOLD_SECONDS,
+} from '../../../domain/usecases/StaleTmuxSessionKillUseCase';
+import { NodeTmuxSessionRepository } from '../../repositories/NodeTmuxSessionRepository';
+
+export type CleanStaleTmuxSessionsParams = {
+  project: Project;
+  allowCacheMinutes: number;
+  issueRepository: Pick<IssueRepository, 'getAllOpened'>;
+  localCommandRunner: LocalCommandRunner;
+  now: Date;
+};
+
+export const cleanStaleTmuxSessions = async (
+  params: CleanStaleTmuxSessionsParams,
+): Promise<void> => {
+  const {
+    project,
+    allowCacheMinutes,
+    issueRepository,
+    localCommandRunner,
+    now,
+  } = params;
+  const useCase = new StaleTmuxSessionKillUseCase(
+    issueRepository,
+    new NodeTmuxSessionRepository(localCommandRunner),
+  );
+  await useCase.run({
+    project,
+    allowCacheMinutes,
+    excludedStatus: DEFAULT_EXCLUDED_STATUS,
+    idleThresholdSeconds: DEFAULT_IDLE_THRESHOLD_SECONDS,
+    now,
+  });
+};

package/src/adapter/repositories/NodeTmuxSessionRepository.test.ts

@@ -44,6 +44,87 @@ describe('NodeTmuxSessionRepository', () => {
     });
   });
 
+  describe('listLiveSessionsWithActivity', () => {
+    it('parses session names and activity epoch seconds and drops blank lines', async () => {
+      const runner = createMockRunner();
+      runner.runCommand.mockResolvedValue({
+        stdout:
+          'https_//github_com/owner/repo/issues/9 1700000000\nno_task_session 1699000000\n\n',
+        stderr: '',
+        exitCode: 0,
+      });
+      const repository = new NodeTmuxSessionRepository(runner);
+
+      const result = await repository.listLiveSessionsWithActivity();
+
+      expect(result).toEqual([
+        {
+          sessionName: 'https_//github_com/owner/repo/issues/9',
+          activityEpochSeconds: 1700000000,
+        },
+        {
+          sessionName: 'no_task_session',
+          activityEpochSeconds: 1699000000,
+        },
+      ]);
+      expect(runner.runCommand.mock.calls[0][0]).toBe('tmux');
+      expect(runner.runCommand.mock.calls[0][1]).toEqual([
+        'list-sessions',
+        '-F',
+        '#{session_name} #{session_activity}',
+      ]);
+    });
+
+    it('returns an empty list when tmux exits non-zero', async () => {
+      const runner = createMockRunner();
+      runner.runCommand.mockResolvedValue({
+        stdout: '',
+        stderr: 'no server running',
+        exitCode: 1,
+      });
+      const repository = new NodeTmuxSessionRepository(runner);
+
+      const result = await repository.listLiveSessionsWithActivity();
+
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe('killSession', () => {
+    it('kills the tmux session by name', async () => {
+      const runner = createMockRunner();
+      runner.runCommand.mockResolvedValue({
+        stdout: '',
+        stderr: '',
+        exitCode: 0,
+      });
+      const repository = new NodeTmuxSessionRepository(runner);
+
+      await repository.killSession('no_task_session');
+
+      expect(runner.runCommand.mock.calls[0][0]).toBe('tmux');
+      expect(runner.runCommand.mock.calls[0][1]).toEqual([
+        'kill-session',
+        '-t',
+        'no_task_session',
+      ]);
+    });
+
+    it('throws when tmux exits non-zero', async () => {
+      const runner = createMockRunner();
+      runner.runCommand.mockResolvedValue({
+        stdout: '',
+        stderr: "can't find session",
+        exitCode: 1,
+      });
+      const repository = new NodeTmuxSessionRepository(runner);
+
+      await expect(repository.killSession('missing_session')).rejects.toThrow(
+        'Failed to kill tmux session "missing_session": exit code 1',
+      );
+    });
+  });
+
   describe('listInteractiveProcessCommandLines', () => {
     it('parses process command lines from ps output', async () => {
       const runner = createMockRunner();

package/src/adapter/repositories/NodeTmuxSessionRepository.ts

@@ -1,5 +1,6 @@
 import { LocalCommandRunner } from '../../domain/usecases/adapter-interfaces/LocalCommandRunner';
 import { TmuxSessionRepository } from '../../domain/usecases/adapter-interfaces/TmuxSessionRepository';
+import { LiveTmuxSession } from '../../domain/entities/LiveTmuxSession';
 
 export class NodeTmuxSessionRepository implements TmuxSessionRepository {
   constructor(private readonly localCommandRunner: LocalCommandRunner) {}
@@ -18,6 +19,26 @@ export class NodeTmuxSessionRepository implements TmuxSessionRepository {
       .filter((line) => line.length > 0);
   };
 
+  listLiveSessionsWithActivity = async (): Promise<LiveTmuxSession[]> => {
+    const { stdout, exitCode } = await this.localCommandRunner.runCommand(
+      'tmux',
+      ['list-sessions', '-F', '#{session_name} #{session_activity}'],
+    );
+    if (exitCode !== 0) {
+      return [];
+    }
+    return stdout
+      .split('\n')
+      .map((line) => line.trim())
+      .filter((line) => line.length > 0)
+      .map((line) => {
+        const separatorIndex = line.lastIndexOf(' ');
+        const sessionName = line.slice(0, separatorIndex);
+        const activityEpochSeconds = Number(line.slice(separatorIndex + 1));
+        return { sessionName, activityEpochSeconds };
+      });
+  };
+
   listInteractiveProcessCommandLines = async (): Promise<string[]> => {
     const { stdout, exitCode } = await this.localCommandRunner.runCommand(
       'ps',
@@ -51,4 +72,18 @@ export class NodeTmuxSessionRepository implements TmuxSessionRepository {
       issueUrl,
     ]);
   };
+
+  killSession = async (sessionName: string): Promise<void> => {
+    const { stderr, exitCode } = await this.localCommandRunner.runCommand(
+      'tmux',
+      ['kill-session', '-t', sessionName],
+    );
+    if (exitCode !== 0) {
+      throw new Error(
+        `Failed to kill tmux session "${sessionName}": exit code ${exitCode}${
+          stderr ? `: ${stderr}` : ''
+        }`,
+      );
+    }
+  };
 }

package/src/domain/entities/LiveTmuxSession.ts

@@ -0,0 +1,4 @@
+export type LiveTmuxSession = {
+  sessionName: string;
+  activityEpochSeconds: number;
+};

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();
+  });
+});