github-issue-tower-defence-management 1.60.1 → 1.63.1

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

@@ -0,0 +1,153 @@
+import { IssueRejectionEvaluator } from './IssueRejectionEvaluator';
+import { RelatedPullRequest } from './adapter-interfaces/IssueRepository';
+
+const createReadyPr = (
+  url = 'https://github.com/user/repo/pull/1',
+  overrides: Partial<RelatedPullRequest> = {},
+): RelatedPullRequest => ({
+  url,
+  branchName: 'feature-branch',
+  createdAt: new Date('2000-01-01T00:00:00Z'),
+  isDraft: false,
+  isConflicted: false,
+  isPassedAllCiJob: true,
+  isCiStateSuccess: true,
+  isResolvedAllReviewComments: true,
+  isBranchOutOfDate: false,
+  missingRequiredCheckNames: [],
+  ...overrides,
+});
+
+describe('IssueRejectionEvaluator', () => {
+  let mockIssueRepository: {
+    findRelatedOpenPRs: jest.Mock;
+    getOpenPullRequest: jest.Mock;
+  };
+  let evaluator: IssueRejectionEvaluator;
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+
+    mockIssueRepository = {
+      findRelatedOpenPRs: jest.fn(),
+      getOpenPullRequest: jest.fn(),
+    };
+
+    evaluator = new IssueRejectionEvaluator(mockIssueRepository);
+  });
+
+  describe('evaluate', () => {
+    it('should return no rejections when PR is ready and not draft', async () => {
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+        createReadyPr(),
+      ]);
+
+      const result = await evaluator.evaluate({
+        url: 'https://github.com/user/repo/issues/1',
+        labels: [],
+        isPr: false,
+      });
+
+      expect(result.rejections).toHaveLength(0);
+      expect(result.approvedPrUrl).toBe('https://github.com/user/repo/pull/1');
+    });
+
+    it('should reject with PULL_REQUEST_IS_DRAFT when PR is in draft state', async () => {
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+        createReadyPr('https://github.com/user/repo/pull/1', { isDraft: true }),
+      ]);
+
+      const result = await evaluator.evaluate({
+        url: 'https://github.com/user/repo/issues/1',
+        labels: [],
+        isPr: false,
+      });
+
+      expect(result.rejections).toHaveLength(1);
+      expect(result.rejections[0].type).toBe('PULL_REQUEST_IS_DRAFT');
+      expect(result.rejections[0].detail).toContain('PULL_REQUEST_IS_DRAFT');
+      expect(result.rejections[0].detail).toContain(
+        'https://github.com/user/repo/pull/1',
+      );
+      expect(result.approvedPrUrl).toBeNull();
+    });
+
+    it('should not approve a draft PR even when all other checks pass', async () => {
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+        createReadyPr('https://github.com/user/repo/pull/1', { isDraft: true }),
+      ]);
+
+      const result = await evaluator.evaluate({
+        url: 'https://github.com/user/repo/issues/1',
+        labels: [],
+        isPr: false,
+      });
+
+      expect(result.approvedPrUrl).toBeNull();
+    });
+
+    it('should accumulate PULL_REQUEST_IS_DRAFT alongside PULL_REQUEST_CONFLICTED when draft PR is also conflicted', async () => {
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+        createReadyPr('https://github.com/user/repo/pull/1', {
+          isDraft: true,
+          isConflicted: true,
+        }),
+      ]);
+
+      const result = await evaluator.evaluate({
+        url: 'https://github.com/user/repo/issues/1',
+        labels: [],
+        isPr: false,
+      });
+
+      const rejectionTypes = result.rejections.map((r) => r.type);
+      expect(rejectionTypes).toContain('PULL_REQUEST_IS_DRAFT');
+      expect(rejectionTypes).toContain('PULL_REQUEST_CONFLICTED');
+      expect(result.approvedPrUrl).toBeNull();
+    });
+
+    it('should reject with PULL_REQUEST_IS_DRAFT when PR item (isPr=true) is in draft state', async () => {
+      mockIssueRepository.getOpenPullRequest.mockResolvedValue(
+        createReadyPr('https://github.com/user/repo/pull/10', {
+          isDraft: true,
+        }),
+      );
+
+      const result = await evaluator.evaluate({
+        url: 'https://github.com/user/repo/pull/10',
+        labels: [],
+        isPr: true,
+      });
+
+      expect(mockIssueRepository.getOpenPullRequest).toHaveBeenCalledWith(
+        'https://github.com/user/repo/pull/10',
+      );
+      expect(result.rejections).toHaveLength(1);
+      expect(result.rejections[0].type).toBe('PULL_REQUEST_IS_DRAFT');
+      expect(result.approvedPrUrl).toBeNull();
+    });
+
+    it('should not reject for draft state when issue has llm-agent label', async () => {
+      const result = await evaluator.evaluate({
+        url: 'https://github.com/user/repo/issues/1',
+        labels: ['llm-agent'],
+        isPr: false,
+      });
+
+      expect(mockIssueRepository.findRelatedOpenPRs).not.toHaveBeenCalled();
+      expect(result.rejections).toHaveLength(0);
+      expect(result.approvedPrUrl).toBeNull();
+    });
+
+    it('should not reject for draft state when issue has non-e2e category label', async () => {
+      const result = await evaluator.evaluate({
+        url: 'https://github.com/user/repo/issues/1',
+        labels: ['category:frontend'],
+        isPr: false,
+      });
+
+      expect(mockIssueRepository.findRelatedOpenPRs).not.toHaveBeenCalled();
+      expect(result.rejections).toHaveLength(0);
+    });
+  });
+});

package/src/domain/usecases/IssueRejectionEvaluator.ts

@@ -6,6 +6,7 @@ import {
 export type PrRejectedReasonType =
   | 'PULL_REQUEST_NOT_FOUND'
   | 'MULTIPLE_PULL_REQUESTS_FOUND'
+  | 'PULL_REQUEST_IS_DRAFT'
   | 'PULL_REQUEST_CONFLICTED'
   | 'ANY_CI_JOB_FAILED_OR_IN_PROGRESS'
   | 'REQUIRED_CI_JOB_NEVER_STARTED'
@@ -59,6 +60,12 @@ export class IssueRejectionEvaluator {
         });
       } else {
         const pr = prsToCheck[0];
+        if (pr.isDraft) {
+          rejections.push({
+            type: 'PULL_REQUEST_IS_DRAFT',
+            detail: `PULL_REQUEST_IS_DRAFT: ${pr.url}`,
+          });
+        }
         if (pr.isConflicted) {
           rejections.push({
             type: 'PULL_REQUEST_CONFLICTED',
@@ -90,6 +97,7 @@ export class IssueRejectionEvaluator {
           });
         }
         if (
+          !pr.isDraft &&
           !pr.isConflicted &&
           pr.isPassedAllCiJob &&
           pr.isResolvedAllReviewComments

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

@@ -77,7 +77,7 @@ const createMockIssue = (overrides: Partial<Issue> = {}): Issue => ({
 
 const createMockComment = (overrides: Partial<Comment> = {}): Comment => ({
   author: 'test-user',
-  content: 'From: Test comment',
+  content: 'From: :robot: Test comment',
   createdAt: new Date(),
   ...overrides,
 });
@@ -108,7 +108,12 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
   beforeEach(() => {
     jest.resetAllMocks();
 
-    mockProject = createMockProject();
+    mockProject = createMockProject({
+      dependedIssueUrlSeparatedByComma: {
+        name: 'Depended Issue URL',
+        fieldId: 'depended-field-id',
+      },
+    });
 
     mockProjectRepository = {
       getByUrl: jest.fn(),
@@ -150,7 +155,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
     mockIssueRepository.get.mockResolvedValue(issue);
     mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
-      createMockComment({ content: 'From: Test report' }),
+      createMockComment({ content: 'From: :robot: Test report' }),
     ]);
     mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
       {
@@ -205,7 +210,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
     mockIssueRepository.get.mockResolvedValue(issue);
     mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
-      createMockComment({ content: 'From: Agent report' }),
+      createMockComment({ content: 'From: :robot: Agent report' }),
     ]);
     mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
       {
@@ -511,6 +516,53 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     );
   });
 
+  it('should reject with NO_REPORT_FROM_AGENT_BOT when last comment is a cross-issue notification starting with From: :warning:', async () => {
+    const issue = createMockIssue({
+      url: 'https://github.com/user/repo/issues/1',
+      status: 'Preparation',
+    });
+
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.get.mockResolvedValue(issue);
+    mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+      createMockComment({
+        content:
+          'From: :warning: This message is from https://github.com/user/repo/tree/i999 AI HS Implement AI Agent (claude-sonnet-4-6)',
+      }),
+    ]);
+    mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+      {
+        url: 'https://github.com/user/repo/pull/1',
+        isConflicted: false,
+        isPassedAllCiJob: true,
+        isCiStateSuccess: true,
+        isResolvedAllReviewComments: true,
+        isBranchOutOfDate: false,
+        missingRequiredCheckNames: [],
+      },
+    ]);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/users/user/projects/1',
+      issueUrl: 'https://github.com/user/repo/issues/1',
+      thresholdForAutoReject: 3,
+      workflowBlockerResolvedWebhookUrl: null,
+    });
+
+    expect(mockIssueRepository.update).toHaveBeenCalledWith(
+      expect.objectContaining({
+        status: 'Awaiting Workspace',
+      }),
+      mockProject,
+    );
+    expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+      expect.objectContaining({
+        url: 'https://github.com/user/repo/issues/1',
+      }),
+      expect.stringContaining('NO_REPORT_FROM_AGENT_BOT'),
+    );
+  });
+
   it('should reject and set status to Awaiting Workspace when no comments exist', async () => {
     const issue = createMockIssue({
       url: 'https://github.com/user/repo/issues/1',
@@ -559,7 +611,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
       createMockComment({
         content:
-          'From: Agent report\n```json\n{"nextStep": "Fix the tests"}\n```',
+          'From: :robot: Agent report\n```json\n{"nextStep": "Fix the tests"}\n```',
       }),
     ]);
     mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
@@ -601,7 +653,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     mockIssueRepository.get.mockResolvedValue(issue);
     mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
       createMockComment({
-        content: 'From: Agent report\n```json\n{"nextStep": null}\n```',
+        content: 'From: :robot: Agent report\n```json\n{"nextStep": null}\n```',
       }),
     ]);
     mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
@@ -691,7 +743,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
       createMockComment({ content: 'Auto Status Check: REJECTED - first' }),
       createMockComment({ content: 'Auto Status Check: REJECTED - second' }),
       createMockComment({ content: 'Auto Status Check: REJECTED - third' }),
-      createMockComment({ content: 'From: Agent final report' }),
+      createMockComment({ content: 'From: :robot: Agent final report' }),
     ]);
     mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
       {
@@ -915,7 +967,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
     mockIssueRepository.get.mockResolvedValue(issue);
     mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
-      createMockComment({ content: 'From: Test report' }),
+      createMockComment({ content: 'From: :robot: Test report' }),
     ]);
     mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
 
@@ -949,7 +1001,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
     mockIssueRepository.get.mockResolvedValue(issue);
     mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
-      createMockComment({ content: 'From: Test report' }),
+      createMockComment({ content: 'From: :robot: Test report' }),
     ]);
     mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
       {
@@ -1002,7 +1054,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
     mockIssueRepository.get.mockResolvedValue(issue);
     mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
-      createMockComment({ content: 'From: Test report' }),
+      createMockComment({ content: 'From: :robot: Test report' }),
     ]);
     mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
       {
@@ -1046,7 +1098,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
     mockIssueRepository.get.mockResolvedValue(issue);
     mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
-      createMockComment({ content: 'From: Test report' }),
+      createMockComment({ content: 'From: :robot: Test report' }),
     ]);
     mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
       {
@@ -1090,7 +1142,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
     mockIssueRepository.get.mockResolvedValue(issue);
     mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
-      createMockComment({ content: 'From: Test report' }),
+      createMockComment({ content: 'From: :robot: Test report' }),
     ]);
     mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
       {
@@ -1140,7 +1192,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
     mockIssueRepository.get.mockResolvedValue(issue);
     mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
-      createMockComment({ content: 'From: Test report' }),
+      createMockComment({ content: 'From: :robot: Test report' }),
     ]);
     mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
       {
@@ -1190,7 +1242,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
     mockIssueRepository.get.mockResolvedValue(issue);
     mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
-      createMockComment({ content: 'From: Test report' }),
+      createMockComment({ content: 'From: :robot: Test report' }),
     ]);
     mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
       {
@@ -1228,7 +1280,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
     mockIssueRepository.get.mockResolvedValue(issue);
     mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
-      createMockComment({ content: 'From: Test report' }),
+      createMockComment({ content: 'From: :robot: Test report' }),
     ]);
     mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
       {
@@ -1263,6 +1315,51 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     );
   });
 
+  it('should reject when PR is in draft state', async () => {
+    const issue = createMockIssue({
+      url: 'https://github.com/user/repo/issues/1',
+      status: 'Preparation',
+    });
+
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.get.mockResolvedValue(issue);
+    mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+      createMockComment({ content: 'From: Test report' }),
+    ]);
+    mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+      {
+        url: 'https://github.com/user/repo/pull/1',
+        isDraft: true,
+        isConflicted: false,
+        isPassedAllCiJob: true,
+        isCiStateSuccess: true,
+        isResolvedAllReviewComments: true,
+        isBranchOutOfDate: false,
+        missingRequiredCheckNames: [],
+      },
+    ]);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/users/user/projects/1',
+      issueUrl: 'https://github.com/user/repo/issues/1',
+      thresholdForAutoReject: 3,
+      workflowBlockerResolvedWebhookUrl: null,
+    });
+
+    expect(mockIssueRepository.update).toHaveBeenCalledWith(
+      expect.objectContaining({
+        status: 'Awaiting Workspace',
+      }),
+      mockProject,
+    );
+    expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+      expect.objectContaining({
+        url: 'https://github.com/user/repo/issues/1',
+      }),
+      expect.stringContaining('PULL_REQUEST_IS_DRAFT'),
+    );
+  });
+
   it('should skip PR checks and update to Awaiting Quality Check when issue has category label', async () => {
     const issue = createMockIssue({
       url: 'https://github.com/user/repo/issues/1',
@@ -1273,7 +1370,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
     mockIssueRepository.get.mockResolvedValue(issue);
     mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
-      createMockComment({ content: 'From: Test report' }),
+      createMockComment({ content: 'From: :robot: Test report' }),
     ]);
     mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
 
@@ -1302,7 +1399,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
     mockIssueRepository.get.mockResolvedValue(issue);
     mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
-      createMockComment({ content: 'From: Test report' }),
+      createMockComment({ content: 'From: :robot: Test report' }),
     ]);
     mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
       {
@@ -1379,7 +1476,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
     mockIssueRepository.get.mockResolvedValue(issue);
     mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
-      createMockComment({ content: 'From: Test report' }),
+      createMockComment({ content: 'From: :robot: Test report' }),
     ]);
     mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
 
@@ -1406,7 +1503,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
     mockIssueRepository.get.mockResolvedValue(issue);
     mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
-      createMockComment({ content: 'From: Test report' }),
+      createMockComment({ content: 'From: :robot: Test report' }),
     ]);
     mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
 
@@ -1466,7 +1563,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
     mockIssueRepository.get.mockResolvedValue(prIssue);
     mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
-      createMockComment({ content: 'From: Agent report' }),
+      createMockComment({ content: 'From: :robot: Agent report' }),
     ]);
     mockIssueRepository.getOpenPullRequest.mockResolvedValue({
       url: 'https://github.com/user/repo/pull/10',
@@ -1665,6 +1762,53 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
         'https://github.com/user/repo/issues/1',
       );
     });
+
+    it('should log a warning and skip setDependedIssueUrl when dependedIssueUrlSeparatedByComma is not configured in project', async () => {
+      const projectWithoutDependedField = createMockProject({
+        dependedIssueUrlSeparatedByComma: null,
+      });
+      const issue = createMockIssue({
+        url: 'https://github.com/user/repo/issues/1',
+        status: 'Preparation',
+      });
+
+      mockProjectRepository.getByUrl.mockResolvedValue(
+        projectWithoutDependedField,
+      );
+      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment({ content: 'From: Agent report' }),
+      ]);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+        {
+          url: 'https://github.com/user/repo/pull/10',
+          isConflicted: false,
+          isPassedAllCiJob: true,
+          isCiStateSuccess: true,
+          isResolvedAllReviewComments: true,
+          isBranchOutOfDate: false,
+          missingRequiredCheckNames: [],
+        },
+      ]);
+
+      const consoleWarnSpy = jest
+        .spyOn(console, 'warn')
+        .mockImplementation(() => {});
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl: 'https://github.com/user/repo/issues/1',
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+      });
+
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        expect.stringContaining('dependedIssueUrlSeparatedByComma'),
+      );
+      expect(mockIssueRepository.setDependedIssueUrl).not.toHaveBeenCalled();
+
+      consoleWarnSpy.mockRestore();
+    });
   });
 
   describe('workflow blocker webhook notification', () => {
@@ -1713,7 +1857,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
       mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
       mockIssueRepository.get.mockResolvedValue(issue);
       mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
-        createMockComment({ content: 'From: Test report' }),
+        createMockComment({ content: 'From: :robot: Test report' }),
       ]);
       mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
         {
@@ -1794,7 +1938,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
       mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
       mockIssueRepository.get.mockResolvedValue(issue);
       mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
-        createMockComment({ content: 'From: Test report' }),
+        createMockComment({ content: 'From: :robot: Test report' }),
       ]);
       mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
         {
@@ -1831,7 +1975,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
       mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
       mockIssueRepository.get.mockResolvedValue(issue);
       mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
-        createMockComment({ content: 'From: Test report' }),
+        createMockComment({ content: 'From: :robot: Test report' }),
       ]);
       mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
         {
@@ -1864,7 +2008,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
       mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
       mockIssueRepository.get.mockResolvedValue(issue);
       mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
-        createMockComment({ content: 'From: Test report' }),
+        createMockComment({ content: 'From: :robot: Test report' }),
       ]);
       mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
         {
@@ -1919,7 +2063,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
       mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
       mockIssueRepository.get.mockResolvedValue(issue);
       mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
-        createMockComment({ content: 'From: Test report' }),
+        createMockComment({ content: 'From: :robot: Test report' }),
       ]);
       mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
         {
@@ -1974,7 +2118,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
       new Error('Story map unavailable'),
     );
     mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
-      createMockComment({ content: 'From: Test report' }),
+      createMockComment({ content: 'From: :robot: Test report' }),
     ]);
     mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
       {
@@ -2019,7 +2163,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
     mockIssueRepository.get.mockResolvedValue(prIssue);
     mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
-      createMockComment({ content: 'From: Agent report' }),
+      createMockComment({ content: 'From: :robot: Agent report' }),
     ]);
     mockIssueRepository.getOpenPullRequest.mockResolvedValue(null);
 
@@ -2053,7 +2197,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     mockIssueRepository.get.mockResolvedValue(issue);
     mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
       createMockComment({
-        content: 'From: Agent report\n```json\n{invalid json}\n```',
+        content: 'From: :robot: Agent report\n```json\n{invalid json}\n```',
       }),
     ]);
     mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
@@ -2091,7 +2235,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     mockIssueRepository.get.mockResolvedValue(issue);
     mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
       createMockComment({
-        content: 'From: Agent report\n```json\nnull\n```',
+        content: 'From: :robot: Agent report\n```json\nnull\n```',
       }),
     ]);
     mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
@@ -2130,7 +2274,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
       createMockComment({
         content:
-          'From: Agent report\n```json\n{"status": "done", "result": "success"}\n```',
+          'From: :robot: Agent report\n```json\n{"status": "done", "result": "success"}\n```',
       }),
     ]);
     mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
@@ -2168,7 +2312,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     mockIssueRepository.get.mockResolvedValue(issue);
     mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
       createMockComment({
-        content: 'From: Agent report\n```json\n"just a string"\n```',
+        content: 'From: :robot: Agent report\n```json\n"just a string"\n```',
       }),
     ]);
     mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([

package/src/domain/usecases/NotifyFinishedIssuePreparationUseCase.ts

@@ -266,7 +266,7 @@ export class NotifyFinishedIssuePreparationUseCase {
     const rejections: { type: RejectedReasonType; detail: string }[] = [];
 
     const lastComment = comments[comments.length - 1];
-    if (!lastComment || !lastComment.content.startsWith('From:')) {
+    if (!lastComment || !lastComment.content.startsWith('From: :robot:')) {
       rejections.push({
         type: 'NO_REPORT_FROM_AGENT_BOT',
         detail: 'NO_REPORT_FROM_AGENT_BOT',
@@ -313,6 +313,12 @@ export class NotifyFinishedIssuePreparationUseCase {
     issueUrl: string,
     project: Parameters<IssueRepository['get']>[1],
   ): Promise<void> => {
+    if (!project.dependedIssueUrlSeparatedByComma) {
+      console.warn(
+        `dependedIssueUrlSeparatedByComma field not configured in project, skipping depended issue URL update for issue ${issueUrl}`,
+      );
+      return;
+    }
     const openPRs = issue.isPr
       ? await this.resolveOpenPrsForPrItem(issue.url)
       : await this.issueRepository.findRelatedOpenPRs(issue.url);

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

@@ -304,6 +304,38 @@ describe('RevertNotReadyAwaitingQualityCheckUseCase', () => {
     );
   });
 
+  it('should revert issue when linked PR is in draft state', async () => {
+    const issue = createMockIssue({
+      status: 'Awaiting Quality Check',
+    });
+    mockIssueRepository.getAllIssues.mockResolvedValue({
+      issues: [issue],
+      cacheUsed: false,
+    });
+    mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+      { ...createReadyPr(), isDraft: true },
+    ]);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/users/user/projects/1',
+      allowIssueCacheMinutes: 10,
+    });
+
+    expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+      mockProject,
+      issue,
+      'awaiting-workspace-id',
+    );
+    expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+      issue,
+      expect.stringContaining('Auto Status Check: REJECTED'),
+    );
+    expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+      issue,
+      expect.stringContaining('PULL_REQUEST_IS_DRAFT'),
+    );
+  });
+
   it('should revert issue when multiple linked open PRs are found', async () => {
     const issue = createMockIssue({
       status: 'Awaiting Quality Check',