github-issue-tower-defence-management 1.193.0 → 1.194.0

package/src/adapter/entry-points/console/ui-dist/index.html

@@ -4,7 +4,7 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>TDPM Console</title>
-    <script type="module" crossorigin src="/assets/index-RaFqjB7u.js"></script>
+    <script type="module" crossorigin src="/assets/index-CYwLv9pf.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-CLHvrafO.css">
   </head>
   <body>

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

@@ -40,6 +40,7 @@ type Mocked<T> = jest.Mocked<T> & jest.MockedObject<T>;
 
 const createMockRunner = (): Mocked<LocalCommandRunner> => ({
   runCommand: jest.fn(),
+  spawnInteractive: jest.fn(),
 });
 
 const createIssueStateRepository = (

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

@@ -38,6 +38,7 @@ const createMockRunner = (): Mocked<LocalCommandRunner> => ({
     stderr: '',
     exitCode: 0,
   }),
+  spawnInteractive: jest.fn(),
 });
 
 describe('notifySilentTmuxSessions', () => {

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

@@ -34,7 +34,10 @@ describe('resetDegeneratedTmuxSessions', () => {
   it('wires the real adapters and runs end to end without acting when no sessions exist', async () => {
     const runCommand: jest.MockedFunction<LocalCommandRunner['runCommand']> =
       jest.fn().mockResolvedValue({ stdout: '', stderr: '', exitCode: 0 });
-    const commandRunner: LocalCommandRunner = { runCommand };
+    const commandRunner: LocalCommandRunner = {
+      runCommand,
+      spawnInteractive: jest.fn(),
+    };
 
     await resetDegeneratedTmuxSessions({
       enabled: false,

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

@@ -413,6 +413,7 @@ describe('writeSituationFile', () => {
         );
       const mockRunner: LocalCommandRunner = {
         runCommand: mockRunCommand,
+        spawnInteractive: jest.fn(),
       };
       const issues = [
         createIssue({
@@ -444,6 +445,7 @@ describe('writeSituationFile', () => {
       const mockRunCommand = jest.fn();
       const mockRunner: LocalCommandRunner = {
         runCommand: mockRunCommand,
+        spawnInteractive: jest.fn(),
       };
 
       await writeSituationFile({

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

@@ -60,6 +60,7 @@ type Mocked<T> = jest.Mocked<T> & jest.MockedObject<T>;
 
 const createMockRunner = (): Mocked<LocalCommandRunner> => ({
   runCommand: jest.fn(),
+  spawnInteractive: jest.fn(),
 });
 
 const createMockIssueRepository = (

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

@@ -140,6 +140,7 @@ export const toTokenRateLimitSnapshot = (
     sevenDayOpusRejected:
       snapshot.modelWeeklyLimits[SEVEN_DAY_OPUS_LIMIT_TYPE]?.rejected ?? false,
     hasWindowData,
+    lastUpdatedEpoch: snapshot.lastUpdatedEpoch,
   };
 };
 

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

@@ -84,6 +84,7 @@ describe('LocalCommandIssueAttachmentRepository', () => {
           exitCode: 0,
         };
       },
+      spawnInteractive: jest.fn(),
     };
     const repository = new LocalCommandIssueAttachmentRepository(
       runner,
@@ -117,6 +118,7 @@ describe('LocalCommandIssueAttachmentRepository', () => {
           exitCode: 0,
         };
       },
+      spawnInteractive: jest.fn(),
     };
     const repository = new LocalCommandIssueAttachmentRepository(
       runner,
@@ -148,6 +150,7 @@ describe('LocalCommandIssueAttachmentRepository', () => {
         stderr: 'Error: No GitHub web session is available\n',
         exitCode: 1,
       }),
+      spawnInteractive: jest.fn(),
     };
     const repository = new LocalCommandIssueAttachmentRepository(
       runner,
@@ -171,6 +174,7 @@ describe('LocalCommandIssueAttachmentRepository', () => {
     const root = await mkdtemp(join(tmpdir(), 'attachment-test-root-'));
     const runner: LocalCommandRunner = {
       runCommand: async () => ({ stdout: '\n', stderr: '', exitCode: 0 }),
+      spawnInteractive: jest.fn(),
     };
     const repository = new LocalCommandIssueAttachmentRepository(
       runner,

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

@@ -22,6 +22,7 @@ describe('LocalProcessLiveSessionProcessSnapshotProvider', () => {
         exitCode: handler.exitCode ?? 0,
       };
     }),
+    spawnInteractive: jest.fn(),
   });
 
   const makeEnvironReader = (

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

@@ -1,7 +1,11 @@
 const mockExecFileAsync = jest.fn();
+const mockSpawnSync = jest.fn();
 
 jest.mock('child_process', () => ({
   execFile: jest.fn(),
+  spawnSync: jest.fn((...args: unknown[]) => {
+    mockSpawnSync(...args);
+  }),
 }));
 
 jest.mock('util', () => ({
@@ -99,4 +103,16 @@ describe('NodeLocalCommandRunner', () => {
       );
     });
   });
+
+  describe('spawnInteractive', () => {
+    it('calls spawnSync with stdio inherit', () => {
+      runner.spawnInteractive('tmux', ['attach-session', '-t', '=wq7x3mk']);
+
+      expect(mockSpawnSync).toHaveBeenCalledWith(
+        'tmux',
+        ['attach-session', '-t', '=wq7x3mk'],
+        { stdio: 'inherit' },
+      );
+    });
+  });
 });

package/src/adapter/repositories/NodeLocalCommandRunner.ts

@@ -2,7 +2,7 @@ import {
   LocalCommandRunner,
   LocalCommandRunnerOptions,
 } from '../../domain/usecases/adapter-interfaces/LocalCommandRunner';
-import { execFile } from 'child_process';
+import { execFile, spawnSync } from 'child_process';
 import { promisify } from 'util';
 
 const execFileAsync = promisify(execFile);
@@ -59,4 +59,8 @@ export class NodeLocalCommandRunner implements LocalCommandRunner {
       throw error;
     }
   }
+
+  spawnInteractive = (program: string, args: string[]): void => {
+    spawnSync(program, args, { stdio: 'inherit' });
+  };
 }

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

@@ -8,6 +8,7 @@ const createRunner = (
   exitCode = 0,
 ): Mocked<LocalCommandRunner> => ({
   runCommand: jest.fn().mockResolvedValue({ stdout, stderr: '', exitCode }),
+  spawnInteractive: jest.fn(),
 });
 
 describe('NodeSubAgentProcessLister', () => {

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

@@ -8,6 +8,7 @@ type Mocked<T> = jest.Mocked<T> & jest.MockedObject<T>;
 
 const createMockRunner = (): Mocked<LocalCommandRunner> => ({
   runCommand: jest.fn(),
+  spawnInteractive: jest.fn(),
 });
 
 describe('NodeTmuxSessionRepository', () => {
@@ -411,4 +412,135 @@ describe('NodeTmuxSessionRepository', () => {
       ).rejects.toThrow('Failed to relaunch bare-name leader session "app"');
     });
   });
+
+  describe('attachOrCreateInteractiveSession', () => {
+    const issueUrl = 'https://github.com/owner/repo/issues/9';
+
+    it('attaches to the registered session when the registry returns a live session name', async () => {
+      const runner = createMockRunner();
+      runner.runCommand
+        .mockResolvedValueOnce({ stdout: 'wq7x3mk\n', stderr: '', exitCode: 0 })
+        .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 });
+      const repository = new NodeTmuxSessionRepository(runner);
+
+      await repository.attachOrCreateInteractiveSession(
+        issueUrl,
+        '/path/to/cl-scope-lib.sh',
+      );
+
+      expect(runner.runCommand.mock.calls[0]).toEqual([
+        'bash',
+        ['/path/to/cl-scope-lib.sh', 'registry-get-session', issueUrl],
+      ]);
+      expect(runner.runCommand.mock.calls[1]).toEqual([
+        'tmux',
+        ['has-session', '-t', '=wq7x3mk'],
+      ]);
+      expect(runner.spawnInteractive.mock.calls).toEqual([
+        ['tmux', ['attach-session', '-t', '=wq7x3mk']],
+      ]);
+    });
+
+    it('creates a new session when no session is registered', async () => {
+      const runner = createMockRunner();
+      runner.runCommand.mockResolvedValueOnce({
+        stdout: '',
+        stderr: '',
+        exitCode: 0,
+      });
+      const repository = new NodeTmuxSessionRepository(runner);
+
+      await repository.attachOrCreateInteractiveSession(
+        issueUrl,
+        '/path/to/cl-scope-lib.sh',
+      );
+
+      expect(runner.runCommand.mock.calls).toHaveLength(1);
+      expect(runner.spawnInteractive.mock.calls).toEqual([
+        ['tmux', ['new-session', '-A', '-s', issueUrl, 'cl', issueUrl]],
+      ]);
+    });
+
+    it('creates a new session when the registered session is no longer alive', async () => {
+      const runner = createMockRunner();
+      runner.runCommand
+        .mockResolvedValueOnce({ stdout: 'wq7x3mk\n', stderr: '', exitCode: 0 })
+        .mockResolvedValueOnce({
+          stdout: '',
+          stderr: "can't find session",
+          exitCode: 1,
+        });
+      const repository = new NodeTmuxSessionRepository(runner);
+
+      await repository.attachOrCreateInteractiveSession(
+        issueUrl,
+        '/path/to/cl-scope-lib.sh',
+      );
+
+      expect(runner.runCommand.mock.calls[1]).toEqual([
+        'tmux',
+        ['has-session', '-t', '=wq7x3mk'],
+      ]);
+      expect(runner.spawnInteractive.mock.calls).toEqual([
+        ['tmux', ['new-session', '-A', '-s', issueUrl, 'cl', issueUrl]],
+      ]);
+    });
+
+    it('creates a new session when the registry lookup fails', async () => {
+      const runner = createMockRunner();
+      runner.runCommand.mockResolvedValueOnce({
+        stdout: '',
+        stderr: 'registry error',
+        exitCode: 1,
+      });
+      const repository = new NodeTmuxSessionRepository(runner);
+
+      await repository.attachOrCreateInteractiveSession(
+        issueUrl,
+        '/path/to/cl-scope-lib.sh',
+      );
+
+      expect(runner.runCommand.mock.calls).toHaveLength(1);
+      expect(runner.spawnInteractive.mock.calls).toEqual([
+        ['tmux', ['new-session', '-A', '-s', issueUrl, 'cl', issueUrl]],
+      ]);
+    });
+
+    it('creates a new session without calling the registry when no scope lib path is provided', async () => {
+      const runner = createMockRunner();
+      const repository = new NodeTmuxSessionRepository(runner);
+
+      await repository.attachOrCreateInteractiveSession(issueUrl, null);
+
+      expect(runner.runCommand.mock.calls).toHaveLength(0);
+      expect(runner.spawnInteractive.mock.calls).toEqual([
+        ['tmux', ['new-session', '-A', '-s', issueUrl, 'cl', issueUrl]],
+      ]);
+    });
+
+    it('trims whitespace from the registered session name before checking tmux', async () => {
+      const runner = createMockRunner();
+      runner.runCommand
+        .mockResolvedValueOnce({
+          stdout: '  abc123  \n',
+          stderr: '',
+          exitCode: 0,
+        })
+        .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 });
+      const repository = new NodeTmuxSessionRepository(runner);
+
+      await repository.attachOrCreateInteractiveSession(
+        issueUrl,
+        '/path/to/cl-scope-lib.sh',
+      );
+
+      expect(runner.runCommand.mock.calls[1]).toEqual([
+        'tmux',
+        ['has-session', '-t', '=abc123'],
+      ]);
+      expect(runner.spawnInteractive.mock.calls).toEqual([
+        ['tmux', ['attach-session', '-t', '=abc123']],
+      ]);
+    });
+  });
 });

package/src/adapter/repositories/NodeTmuxSessionRepository.ts

@@ -165,6 +165,43 @@ export class NodeTmuxSessionRepository implements TmuxSessionRepository {
     await this.sendEnter(sessionName);
   };
 
+  attachOrCreateInteractiveSession = async (
+    issueUrl: string,
+    scopeLibPath: string | null,
+  ): Promise<void> => {
+    if (scopeLibPath !== null) {
+      const { stdout, exitCode } = await this.localCommandRunner.runCommand(
+        'bash',
+        [scopeLibPath, 'registry-get-session', issueUrl],
+      );
+      if (exitCode === 0 && stdout.trim().length > 0) {
+        const registeredSessionName = stdout.trim();
+        const { exitCode: hasSessionExitCode } =
+          await this.localCommandRunner.runCommand('tmux', [
+            'has-session',
+            '-t',
+            `=${registeredSessionName}`,
+          ]);
+        if (hasSessionExitCode === 0) {
+          this.localCommandRunner.spawnInteractive('tmux', [
+            'attach-session',
+            '-t',
+            `=${registeredSessionName}`,
+          ]);
+          return;
+        }
+      }
+    }
+    this.localCommandRunner.spawnInteractive('tmux', [
+      'new-session',
+      '-A',
+      '-s',
+      issueUrl,
+      'cl',
+      issueUrl,
+    ]);
+  };
+
   launchBareNameLeaderSession = async (name: string): Promise<void> => {
     const sessionName = name.replace(/[.:]/g, '_');
     const leaderCommand = `cl ${shellSingleQuote(name)}; exec /bin/bash`;

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

@@ -74,6 +74,7 @@ describe('ProxyClaudeTokenUsageRepository', () => {
 
     const futureReset = Math.floor(Date.now() / 1000) + 3600;
     const pastReset = Math.floor(Date.now() / 1000) - 3600;
+    const observedAfterReset = Math.floor(Date.now() / 1000) - 60;
 
     it('should map each token to its cached utilization and include name', async () => {
       mockLoadTokenEntries.mockReturnValue([
@@ -210,6 +211,7 @@ describe('ProxyClaudeTokenUsageRepository', () => {
       mockReadRateLimit.mockReturnValue({
         fiveHourUtilization: 100,
         fiveHourReset: pastReset,
+        lastUpdatedEpoch: observedAfterReset,
         sevenDayUtilization: 30,
         sevenDayReset: futureReset,
         blocked: false,
@@ -284,6 +286,7 @@ describe('ProxyClaudeTokenUsageRepository', () => {
       mockReadRateLimit.mockReturnValue({
         fiveHourUtilization: 100,
         fiveHourReset: pastReset,
+        lastUpdatedEpoch: observedAfterReset,
         sevenDayUtilization: 0,
         sevenDayReset: futureReset,
         blocked: false,
@@ -323,6 +326,7 @@ describe('ProxyClaudeTokenUsageRepository', () => {
         fiveHourReset: futureReset,
         sevenDayUtilization: 100,
         sevenDayReset: pastReset,
+        lastUpdatedEpoch: observedAfterReset,
         blocked: false,
         rejected: true,
         unifiedRejected: false,
@@ -393,6 +397,7 @@ describe('ProxyClaudeTokenUsageRepository', () => {
       mockReadRateLimit.mockReturnValue({
         fiveHourUtilization: 100,
         fiveHourReset: pastReset,
+        lastUpdatedEpoch: observedAfterReset,
         sevenDayUtilization: 100,
         sevenDayReset: futureReset,
         blocked: false,
@@ -430,6 +435,7 @@ describe('ProxyClaudeTokenUsageRepository', () => {
       mockReadRateLimit.mockReturnValue({
         fiveHourUtilization: 100,
         fiveHourReset: pastReset,
+        lastUpdatedEpoch: observedAfterReset,
         sevenDayUtilization: 0,
         sevenDayReset: futureReset,
         blocked: false,
@@ -734,6 +740,7 @@ describe('ProxyClaudeTokenUsageRepository', () => {
         fiveHourReset: futureReset,
         sevenDayUtilization: 0,
         sevenDayReset: pastReset,
+        lastUpdatedEpoch: observedAfterReset,
         blocked: false,
         rejected: false,
         unifiedRejected: false,
@@ -1130,3 +1137,34 @@ describe('ProxyClaudeTokenUsageRepository', () => {
     });
   });
 });
+
+describe('ProxyClaudeTokenUsageRepository window rollover inference', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should keep the last observed sevenDayUtilization when the snapshot predates the 7d reset it reports', async () => {
+    const pastReset = Math.floor(Date.now() / 1000) - 3600;
+    const observedBeforeReset = pastReset - 72000;
+    mockLoadTokenEntries.mockReturnValue([{ name: 'alice', token: 'token-a' }]);
+    mockReadRateLimit.mockReturnValue({
+      fiveHourUtilization: 0,
+      fiveHourReset: Math.floor(Date.now() / 1000) + 3600,
+      sevenDayUtilization: 98,
+      sevenDayReset: pastReset,
+      blocked: false,
+      rejected: true,
+      unifiedRejected: false,
+      fiveHourRejected: false,
+      sevenDayRejected: true,
+      lastUpdatedEpoch: observedBeforeReset,
+      modelWeeklyLimits: {},
+    });
+    const repository = new ProxyClaudeTokenUsageRepository('/tokens.json');
+
+    const result = await repository.getAvailableTokenUsages();
+
+    expect(result[0].sevenDayUtilization).toBe(98);
+    expect(result[0].rejected).toBe(true);
+  });
+});

package/src/adapter/repositories/ProxyClaudeTokenUsageRepository.ts

@@ -43,8 +43,12 @@ export class ProxyClaudeTokenUsageRepository implements ClaudeTokenUsageReposito
           selectionWeight,
         };
       }
-      const fiveHourExpired = nowEpochSeconds > snapshot.fiveHourReset;
-      const sevenDayExpired = nowEpochSeconds > snapshot.sevenDayReset;
+      const fiveHourExpired =
+        nowEpochSeconds > snapshot.fiveHourReset &&
+        snapshot.lastUpdatedEpoch >= snapshot.fiveHourReset;
+      const sevenDayExpired =
+        nowEpochSeconds > snapshot.sevenDayReset &&
+        snapshot.lastUpdatedEpoch >= snapshot.sevenDayReset;
       const fiveHourUtilization = fiveHourExpired
         ? 0
         : snapshot.fiveHourUtilization;

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

@@ -10,6 +10,7 @@ const createMockRunner = (): Mocked<LocalCommandRunner> => ({
     stderr: '',
     exitCode: 0,
   }),
+  spawnInteractive: jest.fn(),
 });
 
 const createMockSleeper = (): Mocked<Sleeper> => ({
@@ -42,6 +43,7 @@ const createPaneAwareRunner = (
       capturedPaneIndex += 1;
       return Promise.resolve({ stdout: paneText, stderr: '', exitCode: 0 });
     }),
+    spawnInteractive: jest.fn(),
   };
 };
 

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

@@ -164,6 +164,7 @@ describe('RevertOrphanedPreparationUseCase', () => {
     };
     mockLocalCommandRunner = {
       runCommand: jest.fn(),
+      spawnInteractive: jest.fn(),
     };
     useCase = new RevertOrphanedPreparationUseCase(
       mockProjectRepository,

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

@@ -132,6 +132,7 @@ describe('StartPreparationUseCase', () => {
     };
     mockLocalCommandRunner = {
       runCommand: jest.fn(),
+      spawnInteractive: jest.fn(),
     };
     mockClaudeTokenUsageRepository = {
       ensureObservable: jest.fn().mockResolvedValue(undefined),
@@ -6891,6 +6892,112 @@ describe('StartPreparationUseCase', () => {
     expect(storyUnsetWarningCalls).toHaveLength(0);
     consoleWarnSpy.mockRestore();
   });
+
+  describe('token in-flight count refresh', () => {
+    it('refreshes the token in-flight counts once before abandoning a run so a freed slot is used', async () => {
+      const awaitingIssue = createMockIssue({
+        url: 'url1',
+        title: 'Issue 1',
+        labels: ['category:impl'],
+        status: 'Awaiting Workspace',
+        number: 1,
+        itemId: 'item-1',
+      });
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+        createMockStoryObjectMap([awaitingIssue]),
+      );
+      mockLocalCommandRunner.runCommand.mockResolvedValue({
+        stdout: '',
+        stderr: '',
+        exitCode: 0,
+      });
+      mockClaudeTokenUsageRepository.getAvailableTokenUsages.mockResolvedValue([
+        {
+          name: 'token-a',
+          token: 'token-a',
+          fiveHourUtilization: 0.1,
+          sevenDayUtilization: 0.1,
+          blocked: false,
+          rejected: false,
+          fiveHourRejected: false,
+          blockedUntilEpoch: 0,
+          modelWeeklyLimits: {},
+        },
+      ]);
+      mockClaudeTokenUsageRepository.getTokenInFlightCounts
+        .mockResolvedValueOnce({ 'token-a': 6 })
+        .mockResolvedValueOnce({ 'token-a': 0 });
+
+      await useCase.run({
+        projectUrl: 'https://github.com/user/repo',
+        defaultAgentName: 'agent1',
+        defaultLlmModelName: 'claude-opus',
+        fallbackLlmModelName: null,
+        defaultLlmAgentName: null,
+        configFilePath: '/path/to/config.yml',
+        maximumPreparingIssuesCount: null,
+        utilizationPercentageThreshold: 90,
+        allowedIssueAuthors: ['testuser'],
+        manager: 'manager-user',
+        codexHomeCandidates: null,
+        labelsAsLlmAgentName: null,
+      });
+
+      expect(
+        mockClaudeTokenUsageRepository.getTokenInFlightCounts.mock.calls,
+      ).toHaveLength(2);
+      expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
+    });
+
+    it('abandons the run when the refreshed in-flight counts still leave no token slot', async () => {
+      const awaitingIssue = createMockIssue({
+        url: 'url1',
+        title: 'Issue 1',
+        labels: ['category:impl'],
+        status: 'Awaiting Workspace',
+        number: 1,
+        itemId: 'item-1',
+      });
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+        createMockStoryObjectMap([awaitingIssue]),
+      );
+      mockClaudeTokenUsageRepository.getAvailableTokenUsages.mockResolvedValue([
+        {
+          name: 'token-a',
+          token: 'token-a',
+          fiveHourUtilization: 0.1,
+          sevenDayUtilization: 0.1,
+          blocked: false,
+          rejected: false,
+          fiveHourRejected: false,
+          blockedUntilEpoch: 0,
+          modelWeeklyLimits: {},
+        },
+      ]);
+      mockClaudeTokenUsageRepository.getTokenInFlightCounts.mockResolvedValue({
+        'token-a': 6,
+      });
+
+      await useCase.run({
+        projectUrl: 'https://github.com/user/repo',
+        defaultAgentName: 'agent1',
+        defaultLlmModelName: 'claude-opus',
+        fallbackLlmModelName: null,
+        defaultLlmAgentName: null,
+        configFilePath: '/path/to/config.yml',
+        maximumPreparingIssuesCount: null,
+        utilizationPercentageThreshold: 90,
+        allowedIssueAuthors: ['testuser'],
+        manager: 'manager-user',
+        codexHomeCandidates: null,
+        labelsAsLlmAgentName: null,
+      });
+
+      expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(0);
+    });
+  });
 });
 
 describe('StartPreparationUseCase.buildRotationOrder', () => {
@@ -6929,6 +7036,7 @@ describe('StartPreparationUseCase.buildRotationOrder', () => {
   };
   const mockLocalCommandRunnerForRotation: Mocked<LocalCommandRunner> = {
     runCommand: jest.fn(),
+    spawnInteractive: jest.fn(),
   };
   const mockClaudeTokenUsageRepositoryForRotation: Mocked<ClaudeTokenUsageRepository> =
     {
@@ -7235,7 +7343,7 @@ describe('StartPreparationUseCase.getTokenConcurrentLimit', () => {
         setIssueAgentField: jest.fn(),
         removeLabel: jest.fn(),
       },
-      { runCommand: jest.fn() },
+      { runCommand: jest.fn(), spawnInteractive: jest.fn() },
       {
         ensureObservable: jest.fn(),
         getAvailableTokenUsages: jest.fn(),
@@ -7326,7 +7434,7 @@ describe('StartPreparationUseCase.fetchSpawnCandidateBranchSources', () => {
         removeLabel: jest.fn(),
         ...issueRepositoryOverrides,
       },
-      { runCommand: jest.fn() },
+      { runCommand: jest.fn(), spawnInteractive: jest.fn() },
       {
         ensureObservable: jest.fn(),
         getAvailableTokenUsages: jest.fn(),