github-issue-tower-defence-management 1.148.23 → 1.148.25

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

@@ -10,6 +10,9 @@ describe('ChangeStatusByStoryColorUseCase', () => {
   const mockDateRepository = mock<DateRepository>();
   const mockIssueRepository = mock<IssueRepository>();
 
+  const manager = 'manager-user';
+  const nonManagerAssignee = 'human-owner';
+
   const mockStatus = mock<FieldOption>();
   mockStatus.id = 'status1';
   mockStatus.name = 'ToDo';
@@ -64,12 +67,14 @@ describe('ChangeStatusByStoryColorUseCase', () => {
     title: 'Issue 1',
     number: 789,
     status: 'Unread',
+    assignees: [],
   };
   const basicIssue2 = {
     ...mock<Issue>(),
     title: 'Issue 2',
     number: 101,
     status: 'In Progres',
+    assignees: [],
   };
 
   const basicStoryObject1: StoryObject = {
@@ -119,6 +124,7 @@ describe('ChangeStatusByStoryColorUseCase', () => {
         org: 'testOrg',
         repo: 'testRepo',
         storyObjectMap: basicStoryObjectMap,
+        manager,
       },
       expectedCalls: {
         createComment: [],
@@ -133,6 +139,7 @@ describe('ChangeStatusByStoryColorUseCase', () => {
         org: 'testOrg',
         repo: 'testRepo',
         storyObjectMap: basicStoryObjectMap,
+        manager,
       },
       expectedCalls: {
         createComment: [],
@@ -159,6 +166,7 @@ describe('ChangeStatusByStoryColorUseCase', () => {
           ],
           ['Story 2', basicStoryObject2],
         ]),
+        manager,
       },
       expectedCalls: {
         createComment: [
@@ -192,6 +200,7 @@ describe('ChangeStatusByStoryColorUseCase', () => {
           ],
           ['Story 2', basicStoryObject2],
         ]),
+        manager,
       },
       expectedCalls: {
         createComment: [
@@ -242,8 +251,187 @@ describe('ChangeStatusByStoryColorUseCase', () => {
           org: 'testOrg',
           repo: 'testRepo',
           storyObjectMap: basicStoryObjectMap,
+          manager,
         }),
       ).rejects.toThrow('First status is not found');
     });
   });
+
+  describe('first status assignment for an issue with no status', () => {
+    const activeStory = {
+      ...mock<StoryOption>(),
+      id: 'story1',
+      name: 'Story 1',
+      color: 'RED' as const,
+    };
+
+    const buildStoryObjectMap = (issue: Issue): StoryObjectMap =>
+      new Map([
+        [
+          'Story 1',
+          {
+            ...basicStoryObject1,
+            story: activeStory,
+            issues: [issue],
+          },
+        ],
+      ]);
+
+    const runInput = (issue: Issue) => ({
+      project: basicProject,
+      cacheUsed: false,
+      org: 'testOrg',
+      repo: 'testRepo',
+      storyObjectMap: buildStoryObjectMap(issue),
+      manager,
+    });
+
+    it('should set the first status on an issue with no status whose only assignee is the manager', async () => {
+      const managerAssignedIssueWithoutStatus: Issue = {
+        ...basicIssue1,
+        status: null,
+        assignees: [manager],
+      };
+
+      await useCase.run(runInput(managerAssignedIssueWithoutStatus));
+
+      expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+        basicProject,
+        managerAssignedIssueWithoutStatus,
+        'status1',
+      );
+      expect(mockIssueRepository.createComment).toHaveBeenCalledWith(
+        managerAssignedIssueWithoutStatus,
+        'This issue status is changed because the story is enabled.',
+      );
+    });
+
+    it('should not set the first status on an issue with no status that is assigned to someone other than the manager', async () => {
+      const consoleWarnSpy = jest
+        .spyOn(console, 'warn')
+        .mockImplementation(() => undefined);
+      const humanAssignedIssueWithoutStatus: Issue = {
+        ...basicIssue1,
+        url: 'https://github.com/org/repo/issues/789',
+        status: null,
+        assignees: [nonManagerAssignee],
+      };
+
+      await useCase.run(runInput(humanAssignedIssueWithoutStatus));
+
+      expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
+      expect(mockIssueRepository.createComment).not.toHaveBeenCalled();
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        `ChangeStatusByStoryColorUseCase: skipping the first status write because the issue has no status and is assigned to someone other than the manager. issueUrl: https://github.com/org/repo/issues/789 assignees: ${nonManagerAssignee}`,
+      );
+      consoleWarnSpy.mockRestore();
+    });
+
+    it('should not set the first status on an issue with no status assigned to both the manager and another person', async () => {
+      const consoleWarnSpy = jest
+        .spyOn(console, 'warn')
+        .mockImplementation(() => undefined);
+      const coAssignedIssueWithoutStatus: Issue = {
+        ...basicIssue1,
+        status: null,
+        assignees: [manager, nonManagerAssignee],
+      };
+
+      await useCase.run(runInput(coAssignedIssueWithoutStatus));
+
+      expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
+      expect(mockIssueRepository.createComment).not.toHaveBeenCalled();
+      consoleWarnSpy.mockRestore();
+    });
+
+    it('should set the first status on an issue with no status that has no assignee', async () => {
+      const unassignedIssueWithoutStatus: Issue = {
+        ...basicIssue1,
+        status: null,
+        assignees: [],
+      };
+
+      await useCase.run(runInput(unassignedIssueWithoutStatus));
+
+      expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+        basicProject,
+        unassignedIssueWithoutStatus,
+        'status1',
+      );
+      expect(mockIssueRepository.createComment).toHaveBeenCalledWith(
+        unassignedIssueWithoutStatus,
+        'This issue status is changed because the story is enabled.',
+      );
+    });
+  });
+
+  describe('icebox exit when the story is enabled', () => {
+    const activeStory = {
+      ...mock<StoryOption>(),
+      id: 'story1',
+      name: 'Story 1',
+      color: 'RED' as const,
+    };
+
+    const buildStoryObjectMap = (issue: Issue): StoryObjectMap =>
+      new Map([
+        [
+          'Story 1',
+          {
+            ...basicStoryObject1,
+            story: activeStory,
+            issues: [issue],
+          },
+        ],
+      ]);
+
+    const runInput = (issue: Issue) => ({
+      project: basicProject,
+      cacheUsed: false,
+      org: 'testOrg',
+      repo: 'testRepo',
+      storyObjectMap: buildStoryObjectMap(issue),
+      manager,
+    });
+
+    it('should move an Icebox issue that is assigned to someone other than the manager to the first status', async () => {
+      const assignedIceboxIssue: Issue = {
+        ...basicIssue1,
+        status: 'Icebox',
+        assignees: [nonManagerAssignee],
+      };
+
+      await useCase.run(runInput(assignedIceboxIssue));
+
+      expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+        basicProject,
+        assignedIceboxIssue,
+        'status1',
+      );
+      expect(mockIssueRepository.createComment).toHaveBeenCalledWith(
+        assignedIceboxIssue,
+        'This issue status is changed because the story is enabled.',
+      );
+    });
+
+    it('should move an Icebox issue that has no assignee to the first status', async () => {
+      const unassignedIceboxIssue: Issue = {
+        ...basicIssue1,
+        status: 'Icebox',
+        assignees: [],
+      };
+
+      await useCase.run(runInput(unassignedIceboxIssue));
+
+      expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+        basicProject,
+        unassignedIceboxIssue,
+        'status1',
+      );
+      expect(mockIssueRepository.createComment).toHaveBeenCalledWith(
+        unassignedIceboxIssue,
+        'This issue status is changed because the story is enabled.',
+      );
+    });
+  });
 });

package/src/domain/usecases/ChangeStatusByStoryColorUseCase.ts

@@ -3,6 +3,7 @@ import { Project } from '../entities/Project';
 import { DateRepository } from './adapter-interfaces/DateRepository';
 import { StoryObjectMap } from '../entities/StoryObjectMap';
 import { ICEBOX_STATUS_NAME } from '../entities/WorkflowStatus';
+import { Member } from '../entities/Member';
 
 export class ChangeStatusByStoryColorUseCase {
   constructor(
@@ -19,6 +20,7 @@ export class ChangeStatusByStoryColorUseCase {
     org: string;
     repo: string;
     storyObjectMap: StoryObjectMap;
+    manager: Member['name'];
   }): Promise<void> => {
     const firstStatus = input.project.status.statuses[0];
     if (!firstStatus) {
@@ -52,6 +54,16 @@ export class ChangeStatusByStoryColorUseCase {
           if (issue.status && issue.status !== ICEBOX_STATUS_NAME) {
             continue;
           }
+          const hasNoStatus = !issue.status;
+          const isOwnedByNonManagerAssignee = issue.assignees.some(
+            (assignee) => assignee !== input.manager,
+          );
+          if (hasNoStatus && isOwnedByNonManagerAssignee) {
+            console.warn(
+              `ChangeStatusByStoryColorUseCase: skipping the first status write because the issue has no status and is assigned to someone other than the manager. issueUrl: ${issue.url} assignees: ${issue.assignees.join(', ')}`,
+            );
+            continue;
+          }
           await this.issueRepository.updateStatus(
             input.project,
             issue,

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

@@ -69,7 +69,9 @@ describe('DefaultSilentSessionMessageComposer', () => {
       ),
     ).toBe(1);
     expect(
-      occurrences('work the owner asked for has been completed or answered'),
+      occurrences(
+        'Resume the assigned work now by taking its next concrete step with a tool call',
+      ),
     ).toBe(1);
   });
 
@@ -85,66 +87,49 @@ describe('DefaultSilentSessionMessageComposer', () => {
     expect(section).toContain('No output has been observed for 10 minutes.');
   });
 
-  it('states the owner-call format guidance exactly once, deferring to the session-documented format', () => {
-    const section = composer.composeMainStalledSection(600);
-    const formatOccurrences =
-      section.split('in the format documented for this session').length - 1;
-    expect(formatOccurrences).toBe(1);
-    expect(section).toContain('written to be self-contained');
-    expect(section).toContain(
-      'so the owner can understand the situation from that single message',
-    );
-  });
-
-  it('explains that the owner is notified only when an owner-call is raised', () => {
+  it('solicits no owner-call anywhere in the main-stalled section', () => {
     const section = composer.composeMainStalledSection(600);
-    expect(section).toContain(
+    const solicitingPhrases = [
+      'share it through a new owner-call',
       'The owner is notified only when an owner-call is raised.',
-    );
+      'in the format documented for this session',
+      're-raise',
+      'This reminder is delivered only to sessions that have no registered unanswered owner-call.',
+      'that call was not registered',
+      'the owner has not been notified',
+      "a completion still awaits the owner's acknowledgment",
+    ];
+    for (const phrase of solicitingPhrases) {
+      expect(section).not.toContain(phrase);
+    }
   });
 
-  it('frames a completed owner request as awaiting acknowledgment rather than a no-action case', () => {
+  it('instructs the main-stalled session to resume the assigned work with a concrete next step', () => {
     const section = composer.composeMainStalledSection(600);
     expect(section).toContain(
-      "a completion still awaits the owner's acknowledgment",
+      'Resume the assigned work now by taking its next concrete step with a tool call',
     );
-    expect(section).toContain('so it is not a no-action case');
-  });
-
-  it('contains no marker-tag example, tag name, or angle bracket in the format guidance', () => {
-    const section = composer.composeMainStalledSection(600);
-    expect(section).not.toContain('marker tag');
-    expect(section).not.toContain('opening and closing pair');
-    expect(section).not.toContain('<');
-    expect(section).not.toContain('>');
-  });
-
-  it('explains in the main-stalled section that the reminder reaches only sessions without a registered unanswered owner-call', () => {
-    const section = composer.composeMainStalledSection(600);
     expect(section).toContain(
-      'This reminder is delivered only to sessions that have no registered unanswered owner-call.',
+      'report the result of that step in your next output',
     );
   });
 
-  it('explains in the main-stalled section that receiving the reminder while believing an owner-call is pending means the call was not registered and the owner was not notified', () => {
+  it('states in the main-stalled section that a period without output is not by itself a reason to contact the owner', () => {
     const section = composer.composeMainStalledSection(600);
     expect(section).toContain(
-      'If you believe you have already raised an owner-call and are waiting for the owner',
+      'A period without output means the assigned work is not progressing, so it is not by itself a reason to contact the owner',
     );
     expect(section).toContain(
-      'receiving this reminder means that call was not registered',
+      'please resume the work rather than sending a message about the absence of progress',
     );
-    expect(section).toContain('the owner has not been notified');
   });
 
-  it('instructs in the main-stalled section to review the documented owner-call format and re-raise the pending request', () => {
+  it('contains no marker-tag example, tag name, or angle bracket in the format guidance', () => {
     const section = composer.composeMainStalledSection(600);
-    expect(section).toContain(
-      'please review the documented owner-call format for this session',
-    );
-    expect(section).toContain(
-      're-raise the pending request as a new owner-call in that format',
-    );
+    expect(section).not.toContain('marker tag');
+    expect(section).not.toContain('opening and closing pair');
+    expect(section).not.toContain('<');
+    expect(section).not.toContain('>');
   });
 
   it('omits the self-diagnosis guidance from the stale-owner-call section', () => {

package/src/domain/usecases/DefaultSilentSessionMessageComposer.ts

@@ -46,14 +46,6 @@ export const composeOwnerCallFormatGuidance = (): string => {
   return 'Please share it through a new owner-call in the format documented for this session, written to be self-contained so the owner can understand the situation from that single message.';
 };
 
-export const composeMainStalledSelfDiagnosisGuidance = (): string => {
-  return [
-    'This reminder is delivered only to sessions that have no registered unanswered owner-call.',
-    "If you believe you have already raised an owner-call and are waiting for the owner's reply, receiving this reminder means that call was not registered — its format or delivery method was incorrect — and the owner has not been notified.",
-    'In that case, please review the documented owner-call format for this session and re-raise the pending request as a new owner-call in that format.',
-  ].join(' ');
-};
-
 const composeMainStalledMessage = (mainSilentSeconds: number): string => {
   const minutes = Math.floor(mainSilentSeconds / 60);
   return [
@@ -61,8 +53,7 @@ const composeMainStalledMessage = (mainSilentSeconds: number): string => {
     `1. Keep the session task list current, marking finished items as done.`,
     `2. Run independent pieces of work in parallel across sub-agents.`,
     `3. Keep a monitor in place that notices when a sub-agent has produced no output for about 5 minutes.`,
-    `4. When an owner decision is needed, or when work the owner asked for has been completed or answered, please share it through a new owner-call — a completion still awaits the owner's acknowledgment, so it is not a no-action case. The owner is notified only when an owner-call is raised. ${composeOwnerCallFormatGuidance()}`,
-    composeMainStalledSelfDiagnosisGuidance(),
+    `4. Resume the assigned work now by taking its next concrete step with a tool call, and report the result of that step in your next output. A period without output means the assigned work is not progressing, so it is not by itself a reason to contact the owner; please resume the work rather than sending a message about the absence of progress.`,
     `Please also include in your next output an estimate of the remaining minutes to finish all tasks.`,
   ].join('\n');
 };

package/src/domain/usecases/HandleScheduledEventUseCase.ts

@@ -565,6 +565,7 @@ ${JSON.stringify(e)}
       org: input.org,
       repo: input.workingReport.repo,
       storyObjectMap: storyObjectMap,
+      manager: input.manager,
     });
     await this.assignNoAssigneeIssueToManagerUseCase.run({
       issues,

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

@@ -281,6 +281,34 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
   });
 
+  it('should read the issue scoped to the project it was given and throw IssueNotFoundError when the issue has no item on that project', async () => {
+    const issueUrlOnAnotherProjectOnly =
+      'https://github.com/user/repo/issues/7';
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.get.mockImplementation(
+      async (issueUrl: string, project: Project) =>
+        project.id === mockProject.id
+          ? null
+          : createMockIssue({ url: issueUrl, status: 'Preparation' }),
+    );
+
+    await expect(
+      useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl: issueUrlOnAnotherProjectOnly,
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+        allowedIssueAuthors: null,
+      }),
+    ).rejects.toThrow(`Issue not found: ${issueUrlOnAnotherProjectOnly}`);
+    expect(mockIssueRepository.get.mock.calls).toEqual([
+      [issueUrlOnAnotherProjectOnly, mockProject],
+    ]);
+    expect(mockIssueRepository.update).not.toHaveBeenCalled();
+    expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
+    expect(mockIssueCommentRepository.createComment).not.toHaveBeenCalled();
+  });
+
   it('should process a pull request URL the same as an issue URL when the project item resolves', async () => {
     const prIssue = createMockIssue({
       url: 'https://github.com/user/repo/pull/77',

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

@@ -112,6 +112,7 @@ describe('RevertOrphanedPreparationUseCase', () => {
       | 'updateStatus'
       | 'findRelatedOpenPRs'
       | 'getOpenPullRequest'
+      | 'get'
     >
   >;
   let mockIssueCommentRepository: Mocked<
@@ -136,6 +137,11 @@ describe('RevertOrphanedPreparationUseCase', () => {
       updateStatus: jest.fn().mockResolvedValue(undefined),
       findRelatedOpenPRs: jest.fn().mockResolvedValue([]),
       getOpenPullRequest: jest.fn().mockResolvedValue(null),
+      get: jest
+        .fn()
+        .mockImplementation(async (issueUrl: string) =>
+          createMockIssue({ url: issueUrl, status: 'Preparation' }),
+        ),
     };
     mockIssueCommentRepository = {
       getCommentsFromIssue: jest.fn().mockResolvedValue([]),
@@ -1424,4 +1430,210 @@ describe('RevertOrphanedPreparationUseCase', () => {
       'Auto Status Check: REJECTED\n- ORPHANED_PREPARATION',
     );
   });
+
+  describe('live status re-read before writing', () => {
+    const arrangeSnapshotSaysPreparation = (
+      liveStatus: string | null,
+      comments: { author: string; content: string; createdAt: Date }[],
+    ): Issue => {
+      const snapshotIssue = createMockIssue({
+        url: 'https://github.com/user/repo/issues/10',
+        status: 'Preparation',
+      });
+      mockIssueRepository.getAllIssues.mockResolvedValue({
+        project: mockProject,
+        issues: [snapshotIssue],
+        cacheUsed: false,
+      });
+      mockIssueRepository.get.mockResolvedValue(
+        liveStatus === null
+          ? null
+          : createMockIssue({
+              url: snapshotIssue.url,
+              status: liveStatus,
+            }),
+      );
+      mockLocalCommandRunner.runCommand.mockResolvedValue({
+        stdout: '',
+        stderr: '',
+        exitCode: 1,
+      });
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue(
+        comments,
+      );
+      return snapshotIssue;
+    };
+
+    it('does not write Failed Preparation when the live status has already moved to Awaiting Workspace', async () => {
+      arrangeSnapshotSaysPreparation('Awaiting Workspace', [
+        {
+          author: 'bot',
+          content: 'Auto Status Check: REJECTED\n- ORPHANED_PREPARATION',
+          createdAt: new Date(),
+        },
+        {
+          author: 'bot',
+          content: 'Auto Status Check: REJECTED\n- ORPHANED_PREPARATION',
+          createdAt: new Date(),
+        },
+        {
+          author: 'bot',
+          content:
+            'Issue has next action date or hour set: nextActionDate=null, nextActionHour=null',
+          createdAt: new Date(),
+        },
+      ]);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/user/repo',
+        preparationProcessCheckCommand: 'pgrep -fa "claude-agent.*{URL}"',
+        thresholdForAutoReject: 3,
+      });
+
+      expect(
+        mockIssueRepository.updateStatus.mock.calls.map((call) => call[2]),
+      ).toEqual([]);
+      expect(mockIssueCommentRepository.createComment.mock.calls).toHaveLength(
+        0,
+      );
+      expect(mockIssueRepository.get.mock.calls).toHaveLength(1);
+      expect(mockIssueRepository.get.mock.calls[0][0]).toBe(
+        'https://github.com/user/repo/issues/10',
+      );
+      expect(mockIssueRepository.get.mock.calls[0][1]).toBe(mockProject);
+    });
+
+    it('does not write Awaiting Quality Check when the live status has already moved to Awaiting Workspace', async () => {
+      arrangeSnapshotSaysPreparation('Awaiting Workspace', [
+        {
+          author: 'bot',
+          content: 'From: :robot: agent',
+          createdAt: new Date(),
+        },
+      ]);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+        createPassingPr(),
+      ]);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/user/repo',
+        preparationProcessCheckCommand: 'pgrep -fa "claude-agent.*{URL}"',
+        thresholdForAutoReject: 3,
+      });
+
+      expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(0);
+      expect(mockIssueCommentRepository.createComment.mock.calls).toHaveLength(
+        0,
+      );
+    });
+
+    it('does not write any status when the live read finds no issue', async () => {
+      arrangeSnapshotSaysPreparation(null, []);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/user/repo',
+        preparationProcessCheckCommand: 'pgrep -fa "claude-agent.*{URL}"',
+        thresholdForAutoReject: 3,
+      });
+
+      expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(0);
+      expect(mockIssueCommentRepository.createComment.mock.calls).toHaveLength(
+        0,
+      );
+    });
+
+    it('still writes Failed Preparation when the live status is confirmed as Preparation', async () => {
+      const snapshotIssue = arrangeSnapshotSaysPreparation('Preparation', [
+        {
+          author: 'bot',
+          content: 'Auto Status Check: REJECTED\n- ORPHANED_PREPARATION',
+          createdAt: new Date(),
+        },
+        {
+          author: 'bot',
+          content: 'Auto Status Check: REJECTED\n- ORPHANED_PREPARATION',
+          createdAt: new Date(),
+        },
+      ]);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/user/repo',
+        preparationProcessCheckCommand: 'pgrep -fa "claude-agent.*{URL}"',
+        thresholdForAutoReject: 3,
+      });
+
+      expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
+      expect(mockIssueRepository.updateStatus.mock.calls[0][1]).toBe(
+        snapshotIssue,
+      );
+      expect(mockIssueRepository.updateStatus.mock.calls[0][2]).toBe('5');
+    });
+
+    it('logs the error, skips the candidate and keeps processing the next candidate when the live read rejects', async () => {
+      const failingIssue = createMockIssue({
+        url: 'https://github.com/user/repo/issues/10',
+        status: 'Preparation',
+      });
+      const followingIssue = createMockIssue({
+        url: 'https://github.com/user/repo/issues/11',
+        number: 11,
+        itemId: 'item-11',
+        status: 'Preparation',
+      });
+      mockIssueRepository.getAllIssues.mockResolvedValue({
+        project: mockProject,
+        issues: [failingIssue, followingIssue],
+        cacheUsed: false,
+      });
+      const liveReadError = new Error(
+        'GitHub GraphQL API returned no data for a single project item read',
+      );
+      mockIssueRepository.get.mockImplementation(async (issueUrl: string) => {
+        if (issueUrl === failingIssue.url) {
+          throw liveReadError;
+        }
+        return createMockIssue({ url: issueUrl, status: 'Preparation' });
+      });
+      mockLocalCommandRunner.runCommand.mockResolvedValue({
+        stdout: '',
+        stderr: '',
+        exitCode: 1,
+      });
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([]);
+      const consoleErrorSpy = jest
+        .spyOn(console, 'error')
+        .mockImplementation(() => undefined);
+
+      try {
+        await useCase.run({
+          projectUrl: 'https://github.com/user/repo',
+          preparationProcessCheckCommand: 'pgrep -fa "claude-agent.*{URL}"',
+          thresholdForAutoReject: 3,
+        });
+
+        expect(
+          consoleErrorSpy.mock.calls.filter(
+            (call) =>
+              typeof call[0] === 'string' &&
+              call[0].includes(failingIssue.url) &&
+              call[1] === liveReadError,
+          ),
+        ).toHaveLength(1);
+      } finally {
+        consoleErrorSpy.mockRestore();
+      }
+
+      expect(
+        mockIssueRepository.updateStatus.mock.calls.map((call) => [
+          call[1].url,
+          call[2],
+        ]),
+      ).toEqual([[followingIssue.url, '1']]);
+      expect(
+        mockIssueCommentRepository.createComment.mock.calls.map(
+          (call) => call[0].url,
+        ),
+      ).toEqual([followingIssue.url]);
+    });
+  });
 });