github-issue-tower-defence-management 1.136.0 → 1.137.1

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

@@ -1,6 +1,14 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import YAML from 'yaml';
+
+jest.mock('fs', () => {
+  const actualFs: typeof fs = jest.requireActual('fs');
+  return {
+    ...actualFs,
+    readFileSync: jest.fn(actualFs.readFileSync),
+  };
+});
 import {
   program,
   loadConfigFile,
@@ -53,8 +61,14 @@ jest.mock('../../repositories/issue/ApiV3CheerioRestIssueRepository', () => ({
     getCachedProject: jest.fn().mockResolvedValue(null),
   })),
 }));
+const mockRunCommand = jest.fn<
+  Promise<{ stdout: string; stderr: string; exitCode: number }>,
+  [string, string[]]
+>();
 jest.mock('../../repositories/NodeLocalCommandRunner', () => ({
-  NodeLocalCommandRunner: jest.fn().mockImplementation(() => ({})),
+  NodeLocalCommandRunner: jest.fn().mockImplementation(() => ({
+    runCommand: mockRunCommand,
+  })),
 }));
 jest.mock('../../repositories/OauthAPIClaudeRepository', () => ({
   OauthAPIClaudeRepository: jest.fn().mockImplementation(() => ({
@@ -151,6 +165,7 @@ describe('CLI', () => {
   beforeEach(() => {
     jest.clearAllMocks();
     mockFetchReturningReadme(null);
+    mockRunCommand.mockResolvedValue({ stdout: '', stderr: '', exitCode: 0 });
     process.env = { ...originalEnv, GH_TOKEN: 'test-token' };
     writeConfig(defaultConfig);
   });
@@ -2142,4 +2157,106 @@ mysteryKey: 'value'
       logSpy.mockRestore();
     });
   });
+
+  describe('killTmuxSession', () => {
+    it('reaches the real repository command sequence to kill a named session via --session', async () => {
+      await program.parseAsync([
+        'node',
+        'test',
+        'killTmuxSession',
+        '--session',
+        'https_//github_com/owner/repo/issues/9',
+      ]);
+
+      const expectedScopeUnitName =
+        'cl-https---github-com-owner-repo-issues-9.scope';
+      expect(mockRunCommand.mock.calls).toEqual([
+        ['systemctl', ['--user', 'reset-failed', expectedScopeUnitName]],
+        ['systemctl', ['--user', 'stop', expectedScopeUnitName]],
+        ['systemctl', ['--user', 'reset-failed', expectedScopeUnitName]],
+        [
+          'tmux',
+          ['kill-session', '-t', '=https_//github_com/owner/repo/issues/9'],
+        ],
+      ]);
+    });
+
+    it('reaches the real repository command sequence to stop its own scope via --self, without calling tmux', async () => {
+      const actualFs = jest.requireActual<typeof fs>('fs');
+      const readFileSyncMock = jest.mocked(fs.readFileSync);
+      readFileSyncMock.mockImplementation(
+        (
+          filePath: Parameters<typeof fs.readFileSync>[0],
+          options: Parameters<typeof fs.readFileSync>[1],
+        ): ReturnType<typeof fs.readFileSync> => {
+          if (filePath === '/proc/self/cgroup') {
+            return '0::/user.slice/user-1000.slice/user@1000.service/app.slice/cl-current-session.scope\n';
+          }
+          return actualFs.readFileSync(filePath, options);
+        },
+      );
+
+      await program.parseAsync(['node', 'test', 'killTmuxSession', '--self']);
+
+      expect(mockRunCommand.mock.calls).toEqual([
+        ['systemctl', ['--user', 'reset-failed', 'cl-current-session.scope']],
+        ['systemctl', ['--user', 'stop', 'cl-current-session.scope']],
+        ['systemctl', ['--user', 'reset-failed', 'cl-current-session.scope']],
+      ]);
+      expect(mockRunCommand.mock.calls.some((call) => call[0] === 'tmux')).toBe(
+        false,
+      );
+
+      readFileSyncMock.mockImplementation(actualFs.readFileSync);
+    });
+
+    it('exits with an error when neither --session nor --self is provided', async () => {
+      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+      const processExitSpy = jest
+        .spyOn(process, 'exit')
+        .mockImplementation(() => {
+          throw new Error('process.exit called');
+        });
+
+      await expect(
+        program.parseAsync(['node', 'test', 'killTmuxSession']),
+      ).rejects.toThrow('process.exit called');
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        'Either --session <name> or --self is required',
+      );
+      expect(processExitSpy).toHaveBeenCalledWith(1);
+
+      consoleErrorSpy.mockRestore();
+      processExitSpy.mockRestore();
+    });
+
+    it('exits with an error when both --session and --self are provided', async () => {
+      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+      const processExitSpy = jest
+        .spyOn(process, 'exit')
+        .mockImplementation(() => {
+          throw new Error('process.exit called');
+        });
+
+      await expect(
+        program.parseAsync([
+          'node',
+          'test',
+          'killTmuxSession',
+          '--session',
+          'some_session',
+          '--self',
+        ]),
+      ).rejects.toThrow('process.exit called');
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        '--session and --self cannot be used together',
+      );
+      expect(processExitSpy).toHaveBeenCalledWith(1);
+
+      consoleErrorSpy.mockRestore();
+      processExitSpy.mockRestore();
+    });
+  });
 });

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

@@ -29,6 +29,7 @@ import { LocalStorageCacheRepository } from '../../repositories/LocalStorageCach
 import { SystemDateRepository } from '../../repositories/SystemDateRepository';
 import { BaseGitHubRepository } from '../../repositories/BaseGitHubRepository';
 import { NodeLocalCommandRunner } from '../../repositories/NodeLocalCommandRunner';
+import { NodeTmuxSessionRepository } from '../../repositories/NodeTmuxSessionRepository';
 import { GitHubIssueCommentRepository } from '../../repositories/GitHubIssueCommentRepository';
 import { FetchWebhookRepository } from '../../repositories/FetchWebhookRepository';
 import { RevertOrphanedPreparationUseCase } from '../../../domain/usecases/RevertOrphanedPreparationUseCase';
@@ -124,6 +125,11 @@ type CountInTmuxByHumanSessionsPerTokenOptions = {
   tokenListJsonPath?: string;
 };
 
+type KillTmuxSessionOptions = {
+  session?: string;
+  self?: boolean;
+};
+
 const buildGithubRepositoryParams = (
   localStorageRepository: LocalStorageRepository,
   token: string,
@@ -1028,6 +1034,38 @@ program
     }
   });
 
+program
+  .command('killTmuxSession')
+  .description(
+    'Cleanly kill a tmux session by running tmux kill-session and stopping its cl-*.scope systemd --user unit. Use --session <name> to kill another named session, or --self to terminate the current session from inside it.',
+  )
+  .option('--session <name>', 'Name of the tmux session to kill')
+  .option(
+    '--self',
+    'Terminate the current session by stopping its own cl-*.scope systemd user unit, derived from /proc/self/cgroup',
+  )
+  .action(async (options: KillTmuxSessionOptions) => {
+    if (!options.session && !options.self) {
+      console.error('Either --session <name> or --self is required');
+      process.exit(1);
+    }
+    if (options.session && options.self) {
+      console.error('--session and --self cannot be used together');
+      process.exit(1);
+    }
+
+    const localCommandRunner = new NodeLocalCommandRunner();
+    const tmuxSessionRepository = new NodeTmuxSessionRepository(
+      localCommandRunner,
+    );
+
+    if (options.self) {
+      await tmuxSessionRepository.killOwnSession();
+    } else if (options.session) {
+      await tmuxSessionRepository.killSession(options.session);
+    }
+  });
+
 /* istanbul ignore next */
 if (process.argv && require.main === module) {
   program.parse(process.argv);

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

@@ -554,6 +554,7 @@ export class HandleScheduledEventUseCaseHandler {
           assigneeLogin: input.manager,
           issues: result.issues,
           localCommandRunner: nodeLocalCommandRunner,
+          issueStateRepository: issueRepository,
           now: inTmuxNow,
         });
       } catch (error) {

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

@@ -1,4 +1,5 @@
 import { Issue } from '../../../domain/entities/Issue';
+import { IssueRepository } from '../../../domain/usecases/adapter-interfaces/IssueRepository';
 import { LocalCommandRunner } from '../../../domain/usecases/adapter-interfaces/LocalCommandRunner';
 import { reconcileInTmuxByHumanSessions } from './inTmuxByHumanSessionReconciler';
 
@@ -39,6 +40,16 @@ const createMockRunner = (): Mocked<LocalCommandRunner> => ({
   runCommand: jest.fn(),
 });
 
+const createIssueStateRepository = (
+  state = 'open',
+): Pick<IssueRepository, 'getIssueOrPullRequestState'> => ({
+  getIssueOrPullRequestState: async () => ({
+    state,
+    merged: false,
+    isPullRequest: false,
+  }),
+});
+
 describe('reconcileInTmuxByHumanSessions', () => {
   it('does nothing when no launcher command is configured', async () => {
     const runner = createMockRunner();
@@ -48,6 +59,7 @@ describe('reconcileInTmuxByHumanSessions', () => {
       assigneeLogin: ASSIGNEE,
       issues: [makeIssue()],
       localCommandRunner: runner,
+      issueStateRepository: createIssueStateRepository(),
       now: NOW,
     });
 
@@ -71,6 +83,7 @@ describe('reconcileInTmuxByHumanSessions', () => {
       assigneeLogin: ASSIGNEE,
       issues: [makeIssue()],
       localCommandRunner: runner,
+      issueStateRepository: createIssueStateRepository(),
       now: NOW,
     });
 
@@ -118,6 +131,30 @@ describe('reconcileInTmuxByHumanSessions', () => {
       assigneeLogin: ASSIGNEE,
       issues: [makeIssue()],
       localCommandRunner: runner,
+      issueStateRepository: createIssueStateRepository(),
+      now: NOW,
+    });
+
+    const newSessionCalls = runner.runCommand.mock.calls.filter(
+      (call) => call[0] === 'tmux' && call[1][0] === 'new-session',
+    );
+    expect(newSessionCalls).toHaveLength(0);
+  });
+
+  it('does not launch when the live GitHub state of the issue is closed', async () => {
+    const runner = createMockRunner();
+    runner.runCommand.mockImplementation(async () => ({
+      stdout: '',
+      stderr: '',
+      exitCode: 0,
+    }));
+
+    await reconcileInTmuxByHumanSessions({
+      inTmuxLauncherCommand: 'cl',
+      assigneeLogin: ASSIGNEE,
+      issues: [makeIssue()],
+      localCommandRunner: runner,
+      issueStateRepository: createIssueStateRepository('closed'),
       now: NOW,
     });
 

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

@@ -1,4 +1,5 @@
 import { Issue } from '../../../domain/entities/Issue';
+import { IssueRepository } from '../../../domain/usecases/adapter-interfaces/IssueRepository';
 import { LocalCommandRunner } from '../../../domain/usecases/adapter-interfaces/LocalCommandRunner';
 import { InTmuxByHumanSessionReconcileUseCase } from '../../../domain/usecases/intmux/InTmuxByHumanSessionReconcileUseCase';
 import { NodeTmuxSessionRepository } from '../../repositories/NodeTmuxSessionRepository';
@@ -8,6 +9,7 @@ export type ReconcileInTmuxByHumanSessionsParams = {
   assigneeLogin: string;
   issues: Issue[];
   localCommandRunner: LocalCommandRunner;
+  issueStateRepository: Pick<IssueRepository, 'getIssueOrPullRequestState'>;
   now: Date;
 };
 
@@ -19,6 +21,7 @@ export const reconcileInTmuxByHumanSessions = async (
     assigneeLogin,
     issues,
     localCommandRunner,
+    issueStateRepository,
     now,
   } = params;
   if (!inTmuxLauncherCommand || !assigneeLogin) {
@@ -26,6 +29,7 @@ export const reconcileInTmuxByHumanSessions = async (
   }
   const useCase = new InTmuxByHumanSessionReconcileUseCase(
     new NodeTmuxSessionRepository(localCommandRunner),
+    issueStateRepository,
   );
   await useCase.run({
     issues,

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

@@ -102,7 +102,7 @@ describe('cleanStaleTmuxSessions', () => {
     expect(killCall?.[1]).toEqual([
       'kill-session',
       '-t',
-      'https_//github_com/demo/repo/issues/1',
+      '=https_//github_com/demo/repo/issues/1',
     ]);
   });
 
@@ -160,6 +160,6 @@ describe('cleanStaleTmuxSessions', () => {
       (call) => call[0] === 'tmux' && call[1][0] === 'kill-session',
     );
     expect(killCalls).toHaveLength(1);
-    expect(killCalls[0][1]).toEqual(['kill-session', '-t', 'idle_no_task']);
+    expect(killCalls[0][1]).toEqual(['kill-session', '-t', '=idle_no_task']);
   });
 });

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

@@ -1,3 +1,6 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
 import { LocalCommandRunner } from '../../domain/usecases/adapter-interfaces/LocalCommandRunner';
 import { NodeTmuxSessionRepository } from './NodeTmuxSessionRepository';
 
@@ -91,7 +94,7 @@ describe('NodeTmuxSessionRepository', () => {
   });
 
   describe('killSession', () => {
-    it('kills the tmux session by name', async () => {
+    it('kills the tmux session by exact name', async () => {
       const runner = createMockRunner();
       runner.runCommand.mockResolvedValue({
         stdout: '',
@@ -102,20 +105,22 @@ describe('NodeTmuxSessionRepository', () => {
 
       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',
+      const tmuxCall = runner.runCommand.mock.calls.find(
+        (call) => call[0] === 'tmux',
+      );
+      expect(tmuxCall).toEqual([
+        'tmux',
+        ['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,
+      runner.runCommand.mockImplementation(async (program: string) => {
+        if (program === 'tmux') {
+          return { stdout: '', stderr: "can't find session", exitCode: 1 };
+        }
+        return { stdout: '', stderr: '', exitCode: 0 };
       });
       const repository = new NodeTmuxSessionRepository(runner);
 
@@ -124,7 +129,7 @@ describe('NodeTmuxSessionRepository', () => {
       );
     });
 
-    it('stops the systemd user scope for the session after killing it, wrapping the stop with reset-failed', async () => {
+    it('stops the systemd user scope for the session before killing it, wrapping the stop with reset-failed', async () => {
       const runner = createMockRunner();
       runner.runCommand.mockResolvedValue({
         stdout: '',
@@ -137,16 +142,14 @@ describe('NodeTmuxSessionRepository', () => {
 
       const expectedScopeUnitName =
         'cl-https---github-com-owner-repo-issues-9.scope';
-      const calls = runner.runCommand.mock.calls;
-      expect(calls[0]).toEqual([
-        'tmux',
-        ['kill-session', '-t', 'https_//github_com/owner/repo/issues/9'],
-      ]);
-      const systemctlCalls = calls.filter((call) => call[0] === 'systemctl');
-      expect(systemctlCalls).toEqual([
+      expect(runner.runCommand.mock.calls).toEqual([
         ['systemctl', ['--user', 'reset-failed', expectedScopeUnitName]],
         ['systemctl', ['--user', 'stop', expectedScopeUnitName]],
         ['systemctl', ['--user', 'reset-failed', expectedScopeUnitName]],
+        [
+          'tmux',
+          ['kill-session', '-t', '=https_//github_com/owner/repo/issues/9'],
+        ],
       ]);
     });
 
@@ -180,6 +183,63 @@ describe('NodeTmuxSessionRepository', () => {
     });
   });
 
+  describe('killOwnSession', () => {
+    let procDirectory: string;
+
+    beforeEach(() => {
+      procDirectory = fs.mkdtempSync(
+        path.join(os.tmpdir(), 'node-tmux-session-repository-proc-'),
+      );
+    });
+
+    afterEach(() => {
+      fs.rmSync(procDirectory, { recursive: true, force: true });
+    });
+
+    const writeCgroupContent = (content: string): void => {
+      const selfDirectory = path.join(procDirectory, 'self');
+      fs.mkdirSync(selfDirectory, { recursive: true });
+      fs.writeFileSync(path.join(selfDirectory, 'cgroup'), content);
+    };
+
+    it('stops only the current session scope derived from /proc/self/cgroup, without calling tmux', async () => {
+      writeCgroupContent(
+        '0::/user.slice/user-1000.slice/user@1000.service/app.slice/cl-leader-session.scope\n',
+      );
+      const runner = createMockRunner();
+      runner.runCommand.mockResolvedValue({
+        stdout: '',
+        stderr: '',
+        exitCode: 0,
+      });
+      const repository = new NodeTmuxSessionRepository(runner, procDirectory);
+
+      await repository.killOwnSession();
+
+      expect(runner.runCommand.mock.calls).toEqual([
+        ['systemctl', ['--user', 'reset-failed', 'cl-leader-session.scope']],
+        ['systemctl', ['--user', 'stop', 'cl-leader-session.scope']],
+        ['systemctl', ['--user', 'reset-failed', 'cl-leader-session.scope']],
+      ]);
+      expect(
+        runner.runCommand.mock.calls.some((call) => call[0] === 'tmux'),
+      ).toBe(false);
+    });
+
+    it('throws when no cl-*.scope unit can be found in /proc/self/cgroup', async () => {
+      writeCgroupContent(
+        '0::/user.slice/user-1000.slice/user@1000.service/app.slice/vte-spawn-abc.scope\n',
+      );
+      const runner = createMockRunner();
+      const repository = new NodeTmuxSessionRepository(runner, procDirectory);
+
+      await expect(repository.killOwnSession()).rejects.toThrow(
+        'Failed to determine the current cl-*.scope systemd user unit from /proc/self/cgroup',
+      );
+      expect(runner.runCommand.mock.calls).toHaveLength(0);
+    });
+  });
+
   describe('listInteractiveProcessCommandLines', () => {
     it('parses process command lines from ps output', async () => {
       const runner = createMockRunner();

package/src/adapter/repositories/NodeTmuxSessionRepository.ts

@@ -1,10 +1,16 @@
+import * as fs from 'fs';
+import * as path from 'path';
 import { LocalCommandRunner } from '../../domain/usecases/adapter-interfaces/LocalCommandRunner';
 import { TmuxSessionRepository } from '../../domain/usecases/adapter-interfaces/TmuxSessionRepository';
 import { LiveTmuxSession } from '../../domain/entities/LiveTmuxSession';
 import { clSessionScopeUnitName } from './clSessionScopeUnitName';
+import { clSessionScopeUnitNameFromCgroupContent } from './clSessionScopeUnitNameFromCgroupContent';
 
 export class NodeTmuxSessionRepository implements TmuxSessionRepository {
-  constructor(private readonly localCommandRunner: LocalCommandRunner) {}
+  constructor(
+    private readonly localCommandRunner: LocalCommandRunner,
+    private readonly procDirectory: string = '/proc',
+  ) {}
 
   listLiveSessionNames = async (): Promise<string[]> => {
     const { stdout, exitCode } = await this.localCommandRunner.runCommand(
@@ -75,9 +81,11 @@ export class NodeTmuxSessionRepository implements TmuxSessionRepository {
   };
 
   killSession = async (sessionName: string): Promise<void> => {
+    const scopeUnitName = clSessionScopeUnitName(sessionName);
+    await this.stopScopeUnit(scopeUnitName);
     const { stderr, exitCode } = await this.localCommandRunner.runCommand(
       'tmux',
-      ['kill-session', '-t', sessionName],
+      ['kill-session', '-t', `=${sessionName}`],
     );
     if (exitCode !== 0) {
       throw new Error(
@@ -86,11 +94,24 @@ export class NodeTmuxSessionRepository implements TmuxSessionRepository {
         }`,
       );
     }
-    await this.stopClSessionScope(sessionName);
   };
 
-  private stopClSessionScope = async (sessionName: string): Promise<void> => {
-    const scopeUnitName = clSessionScopeUnitName(sessionName);
+  killOwnSession = async (): Promise<void> => {
+    const cgroupContent = fs.readFileSync(
+      path.join(this.procDirectory, 'self', 'cgroup'),
+      'utf8',
+    );
+    const scopeUnitName =
+      clSessionScopeUnitNameFromCgroupContent(cgroupContent);
+    if (scopeUnitName === null) {
+      throw new Error(
+        'Failed to determine the current cl-*.scope systemd user unit from /proc/self/cgroup',
+      );
+    }
+    await this.stopScopeUnit(scopeUnitName);
+  };
+
+  private stopScopeUnit = async (scopeUnitName: string): Promise<void> => {
     await this.localCommandRunner.runCommand('systemctl', [
       '--user',
       'reset-failed',
@@ -107,7 +128,7 @@ export class NodeTmuxSessionRepository implements TmuxSessionRepository {
     ]);
     if (exitCode !== 0) {
       console.error(
-        `Failed to stop systemd user scope "${scopeUnitName}" for tmux session "${sessionName}": exit code ${exitCode}${
+        `Failed to stop systemd user scope "${scopeUnitName}": exit code ${exitCode}${
           stderr ? `: ${stderr}` : ''
         }`,
       );

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

@@ -0,0 +1,34 @@
+import { clSessionScopeUnitNameFromCgroupContent } from './clSessionScopeUnitNameFromCgroupContent';
+
+describe('clSessionScopeUnitNameFromCgroupContent', () => {
+  it('extracts the cl-*.scope unit from a cgroup v2 single-hierarchy line', () => {
+    const cgroupContent =
+      '0::/user.slice/user-1000.slice/user@1000.service/app.slice/cl-https---github-com-owner-repo-issues-9.scope\n';
+
+    const result = clSessionScopeUnitNameFromCgroupContent(cgroupContent);
+
+    expect(result).toBe('cl-https---github-com-owner-repo-issues-9.scope');
+  });
+
+  it('extracts the cl-*.scope unit from a multi-hierarchy cgroup v1 file', () => {
+    const cgroupContent = [
+      '12:pids:/user.slice/user-1000.slice/user@1000.service/app.slice/cl-leader-session.scope',
+      '11:cpu,cpuacct:/user.slice/user-1000.slice/user@1000.service/app.slice/cl-leader-session.scope',
+      '0::/user.slice/user-1000.slice/user@1000.service/app.slice/cl-leader-session.scope',
+      '',
+    ].join('\n');
+
+    const result = clSessionScopeUnitNameFromCgroupContent(cgroupContent);
+
+    expect(result).toBe('cl-leader-session.scope');
+  });
+
+  it('returns null when no cl-*.scope unit is present', () => {
+    const cgroupContent =
+      '0::/user.slice/user-1000.slice/user@1000.service/app.slice/vte-spawn-abc.scope\n';
+
+    const result = clSessionScopeUnitNameFromCgroupContent(cgroupContent);
+
+    expect(result).toBeNull();
+  });
+});

package/src/adapter/repositories/clSessionScopeUnitNameFromCgroupContent.ts

@@ -0,0 +1,8 @@
+const CL_SESSION_SCOPE_UNIT_PATTERN = /cl-[A-Za-z0-9._-]+\.scope/;
+
+export const clSessionScopeUnitNameFromCgroupContent = (
+  cgroupContent: string,
+): string | null => {
+  const match = cgroupContent.match(CL_SESSION_SCOPE_UNIT_PATTERN);
+  return match ? match[0] : null;
+};

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

@@ -123,26 +123,36 @@ describe('SetWorkflowManagementIssueToStoryUseCase', () => {
       expect(mockIssueRepository.removeLabel).not.toHaveBeenCalled();
     });
 
-    it('should do nothing when cacheUsed is true', async () => {
-      await useCase.run({
+    it('should map story label to matching story when cacheUsed is true', async () => {
+      const issue: Issue = {
+        ...mock<Issue>(),
+        labels: ['story:high-priority'],
+        story: null,
+        state: 'OPEN',
+        nextActionDate: null,
+        nextActionHour: null,
+        isPr: false,
+      };
+
+      const promise = useCase.run({
         targetDates: [targetDate],
         project: basicProject,
-        issues: [
-          {
-            ...mock<Issue>(),
-            labels: ['story:high-priority'],
-            story: null,
-            state: 'OPEN',
-            nextActionDate: null,
-            nextActionHour: null,
-            isPr: false,
-          },
-        ],
+        issues: [issue],
         cacheUsed: true,
       });
+      await jest.runAllTimersAsync();
+      await promise;
 
-      expect(mockIssueRepository.updateStory).not.toHaveBeenCalled();
-      expect(mockIssueRepository.removeLabel).not.toHaveBeenCalled();
+      expect(mockIssueRepository.updateStory.mock.calls).toEqual([
+        [
+          { ...basicProject, story: basicProject.story },
+          issue,
+          'highPriorityId',
+        ],
+      ]);
+      expect(mockIssueRepository.removeLabel.mock.calls).toEqual([
+        [issue, 'story:high-priority'],
+      ]);
     });
 
     it('should map story label to matching story on non-minute-0 target date', async () => {

package/src/domain/usecases/SetWorkflowManagementIssueToStoryUseCase.ts

@@ -25,7 +25,7 @@ export class SetWorkflowManagementIssueToStoryUseCase {
     cacheUsed: boolean;
   }): Promise<void> => {
     const story = input.project.story;
-    if (!story || input.cacheUsed) {
+    if (!story) {
       return;
     }
     for (const issue of input.issues) {

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

@@ -10,4 +10,5 @@ export interface TmuxSessionRepository {
     issueUrl: string,
   ) => Promise<void>;
   killSession: (sessionName: string) => Promise<void>;
+  killOwnSession: () => Promise<void>;
 }