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

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/NotifyFinishedIssuePreparationUseCase.test.ts

@@ -38,6 +38,12 @@ const createMockProject = (overrides: Partial<Project> = {}): Project => ({
         color: 'BLUE',
         description: '',
       },
+      {
+        id: 'todo-by-human-id',
+        name: 'Todo by human',
+        color: 'GREEN',
+        description: '',
+      },
     ],
   },
   nextActionDate: null,
@@ -4669,7 +4675,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
   describe('waitingForOwnerApproval', () => {
     const issueUrl = 'https://github.com/user/repo/issues/1';
 
-    it('returns to Awaiting Workspace and posts AWAITING_OWNER_APPROVAL message when last report declares waitingForOwnerApproval', async () => {
+    it('moves to Todo by human and posts AWAITING_OWNER_APPROVAL message when last report declares waitingForOwnerApproval', async () => {
       const issue = createMockIssue({ url: issueUrl, status: 'Preparation' });
       mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
       mockIssueRepository.get.mockResolvedValue(issue);
@@ -4690,13 +4696,13 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
       });
 
       expect(mockIssueRepository.update).toHaveBeenCalledWith(
-        expect.objectContaining({ status: 'Awaiting Workspace' }),
+        expect.objectContaining({ status: 'Todo by human' }),
         mockProject,
       );
       expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
         mockProject,
-        expect.objectContaining({ status: 'Awaiting Workspace' }),
-        'awaiting-workspace-id',
+        expect.objectContaining({ status: 'Todo by human' }),
+        'todo-by-human-id',
       );
       expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
         expect.objectContaining({ url: issueUrl }),
@@ -4709,6 +4715,74 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
       );
     });
 
+    it('does not return the issue to the dispatch pool when it is waiting for owner approval', async () => {
+      const issue = createMockIssue({ url: issueUrl, status: 'Preparation' });
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment({
+          content:
+            'From: :robot: systems-analyst (model)\n```json\n{"pullRequestRequired": false, "waitingForOwnerApproval": true}\n```',
+        }),
+      ]);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl,
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+        allowedIssueAuthors: null,
+      });
+
+      expect(mockIssueRepository.updateStatus).not.toHaveBeenCalledWith(
+        mockProject,
+        expect.anything(),
+        'awaiting-workspace-id',
+      );
+    });
+
+    it('escalates to Failed Preparation instead of the dispatch pool when the project has no Todo by human status', async () => {
+      const projectWithoutTodo = {
+        ...mockProject,
+        status: {
+          ...mockProject.status,
+          statuses: mockProject.status.statuses.filter(
+            (status) => status.name !== 'Todo by human',
+          ),
+        },
+      };
+      const issue = createMockIssue({ url: issueUrl, status: 'Preparation' });
+      mockProjectRepository.getByUrl.mockResolvedValue(projectWithoutTodo);
+      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment({
+          content:
+            'From: :robot: systems-analyst (model)\n```json\n{"pullRequestRequired": false, "waitingForOwnerApproval": true}\n```',
+        }),
+      ]);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl,
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+        allowedIssueAuthors: null,
+      });
+
+      expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+        projectWithoutTodo,
+        expect.objectContaining({ status: 'Failed Preparation' }),
+        'failed-preparation-id',
+      );
+      expect(mockIssueRepository.updateStatus).not.toHaveBeenCalledWith(
+        projectWithoutTodo,
+        expect.anything(),
+        'awaiting-workspace-id',
+      );
+    });
+
     it('escalates to Failed Preparation after ownerApprovalTimeoutCycles AWAITING_OWNER_APPROVAL messages', async () => {
       const issue = createMockIssue({ url: issueUrl, status: 'Preparation' });
       mockProjectRepository.getByUrl.mockResolvedValue(mockProject);

package/src/domain/usecases/NotifyFinishedIssuePreparationUseCase.ts

@@ -8,6 +8,7 @@ import {
   AWAITING_WORKSPACE_STATUS_NAME,
   FAILED_PREPARATION_STATUS_NAME,
   PREPARATION_STATUS_NAME,
+  TODO_STATUS_NAME,
 } from '../entities/WorkflowStatus';
 import {
   IssueRejectionEvaluator,
@@ -157,6 +158,9 @@ export class NotifyFinishedIssuePreparationUseCase {
       );
       return;
     }
+    const todoStatusOption = project.status.statuses.find(
+      (s) => s.name === TODO_STATUS_NAME,
+    );
 
     const issue = await this.issueRepository.get(params.issueUrl, project);
 
@@ -326,13 +330,21 @@ export class NotifyFinishedIssuePreparationUseCase {
           isTrustedAuthor(comment.author) &&
           comment.content.startsWith(AWAITING_OWNER_APPROVAL_MESSAGE_HEAD),
       ).length;
-      if (awaitingOwnerApprovalCount < ownerApprovalTimeoutCycles) {
-        issue.status = AWAITING_WORKSPACE_STATUS_NAME;
+      if (!todoStatusOption) {
+        console.error(
+          `Todo status option '${TODO_STATUS_NAME}' not found in project; escalating to '${FAILED_PREPARATION_STATUS_NAME}' instead of returning the task to the dispatch pool.`,
+        );
+      }
+      if (
+        awaitingOwnerApprovalCount < ownerApprovalTimeoutCycles &&
+        todoStatusOption
+      ) {
+        issue.status = TODO_STATUS_NAME;
         await this.issueRepository.update(issue, project);
         await this.issueRepository.updateStatus(
           project,
           issue,
-          awaitingWorkspaceStatusOption.id,
+          todoStatusOption.id,
         );
         await this.patchConsoleTab(issue);
         await this.issueCommentRepository.createComment(