github-issue-tower-defence-management 1.189.2 → 1.191.0

package/src/domain/usecases/ConflictedIssueRevertUseCase.ts

@@ -0,0 +1,138 @@
+import { Issue } from '../entities/Issue';
+import { IssueRepository } from './adapter-interfaces/IssueRepository';
+import { ProjectRepository } from './adapter-interfaces/ProjectRepository';
+import { IssueCommentRepository } from './adapter-interfaces/IssueCommentRepository';
+import {
+  AWAITING_WORKSPACE_STATUS_NAME,
+  DONE_STATUS_NAME,
+  FAILED_PREPARATION_STATUS_NAME,
+  ICEBOX_STATUS_NAME,
+  IN_TMUX_STATUS_NAME,
+} from '../entities/WorkflowStatus';
+
+const EXCLUDED_STATUSES = new Set([
+  AWAITING_WORKSPACE_STATUS_NAME,
+  DONE_STATUS_NAME,
+  ICEBOX_STATUS_NAME,
+  FAILED_PREPARATION_STATUS_NAME,
+  IN_TMUX_STATUS_NAME,
+]);
+
+export class ConflictedIssueRevertUseCase {
+  constructor(
+    private readonly projectRepository: Pick<
+      ProjectRepository,
+      'findProjectIdByUrl' | 'getProject'
+    >,
+    private readonly issueRepository: Pick<
+      IssueRepository,
+      'getAllIssues' | 'getOpenPullRequests' | 'updateStatus'
+    >,
+    private readonly issueCommentRepository: Pick<
+      IssueCommentRepository,
+      'createComment'
+    >,
+  ) {}
+
+  run = async (params: { projectUrl: string }): Promise<void> => {
+    const projectId = await this.projectRepository.findProjectIdByUrl(
+      params.projectUrl,
+    );
+    if (!projectId) {
+      throw new Error(`Project not found. projectUrl: ${params.projectUrl}`);
+    }
+    const project = await this.projectRepository.getProject(projectId);
+    if (!project) {
+      throw new Error(
+        `Project not found. projectId: ${projectId} projectUrl: ${params.projectUrl}`,
+      );
+    }
+
+    const awaitingWorkspaceStatusOption = project.status.statuses.find(
+      (s) => s.name === AWAITING_WORKSPACE_STATUS_NAME,
+    );
+    if (!awaitingWorkspaceStatusOption) {
+      return;
+    }
+
+    const { issues } = await this.issueRepository.getAllIssues(projectId);
+
+    const targetIssues = issues.filter(
+      (issue) =>
+        !issue.isPr &&
+        (issue.status === null || !EXCLUDED_STATUSES.has(issue.status)),
+    );
+
+    const relatedOpenPrUrlsByIssueUrl =
+      this.buildRelatedOpenPrUrlsByIssueUrl(issues);
+
+    const allPrUrls = Array.from(
+      new Set(
+        targetIssues.flatMap(
+          (issue) => relatedOpenPrUrlsByIssueUrl.get(issue.url) ?? [],
+        ),
+      ),
+    );
+
+    if (allPrUrls.length === 0) {
+      return;
+    }
+
+    const resolvedPrByUrl =
+      await this.issueRepository.getOpenPullRequests(allPrUrls);
+
+    for (const issue of targetIssues) {
+      const prUrls = relatedOpenPrUrlsByIssueUrl.get(issue.url) ?? [];
+      if (prUrls.length === 0) {
+        continue;
+      }
+
+      const relatedPrs = prUrls
+        .map((url) => resolvedPrByUrl.get(url) ?? null)
+        .filter((pr): pr is NonNullable<typeof pr> => pr !== null);
+
+      const hasUnknownMergeable = relatedPrs.some(
+        (pr) => pr.mergeable === 'UNKNOWN',
+      );
+      if (hasUnknownMergeable) {
+        continue;
+      }
+
+      const hasConflict = relatedPrs.some((pr) => pr.isConflicted);
+      if (!hasConflict) {
+        continue;
+      }
+
+      await this.issueRepository.updateStatus(
+        project,
+        issue,
+        awaitingWorkspaceStatusOption.id,
+      );
+      await this.issueCommentRepository.createComment(issue, 'conflict');
+    }
+  };
+
+  private buildRelatedOpenPrUrlsByIssueUrl = (
+    issues: Issue[],
+  ): Map<string, string[]> => {
+    const openPrUrlsByIssueUrl = new Map<string, Set<string>>();
+    for (const issue of issues) {
+      if (!issue.isPr || issue.isClosed) {
+        continue;
+      }
+      for (const referencedIssueUrl of issue.closingIssueReferenceUrls) {
+        const existing = openPrUrlsByIssueUrl.get(referencedIssueUrl);
+        if (existing) {
+          existing.add(issue.url);
+        } else {
+          openPrUrlsByIssueUrl.set(referencedIssueUrl, new Set([issue.url]));
+        }
+      }
+    }
+    const result = new Map<string, string[]>();
+    for (const [issueUrl, prUrls] of openPrUrlsByIssueUrl) {
+      result.set(issueUrl, Array.from(prUrls));
+    }
+    return result;
+  };
+}

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

@@ -24,6 +24,7 @@ import { UpdateIssueStatusByLabelUseCase } from './UpdateIssueStatusByLabelUseCa
 import { IssueNoStatusUpdateUseCase } from './IssueNoStatusUpdateUseCase';
 import { StartPreparationUseCase } from './StartPreparationUseCase';
 import { RevertOrphanedPreparationUseCase } from './RevertOrphanedPreparationUseCase';
+import { ConflictedIssueRevertUseCase } from './ConflictedIssueRevertUseCase';
 import { RevertNotReadyReviewQueueIssueUseCase } from './RevertNotReadyReviewQueueIssueUseCase';
 import { TriagerApprovalDispatchUseCase } from './TriagerApprovalDispatchUseCase';
 import { AgentDesignationLabelAdoptUseCase } from './AgentDesignationLabelAdoptUseCase';
@@ -127,6 +128,8 @@ describe('HandleScheduledEventUseCase', () => {
     const mockStartPreparationUseCase = mock<StartPreparationUseCase>();
     const mockRevertOrphanedPreparationUseCase =
       mock<RevertOrphanedPreparationUseCase>();
+    const mockConflictedIssueRevertUseCase =
+      mock<ConflictedIssueRevertUseCase>();
     const mockRevertNotReadyReviewQueueIssueUseCase =
       mock<RevertNotReadyReviewQueueIssueUseCase>();
     const mockTriagerApprovalDispatchUseCase =
@@ -164,6 +167,7 @@ describe('HandleScheduledEventUseCase', () => {
       mockIssueNoStatusUpdateUseCase,
       mockStartPreparationUseCase,
       mockRevertOrphanedPreparationUseCase,
+      mockConflictedIssueRevertUseCase,
       mockRevertNotReadyReviewQueueIssueUseCase,
       mockTriagerApprovalDispatchUseCase,
       mockAgentDesignationLabelAdoptUseCase,
@@ -504,6 +508,31 @@ describe('HandleScheduledEventUseCase', () => {
       );
     });
 
+    it('should invoke conflictedIssueRevertUseCase on every scheduled run', async () => {
+      const input = {
+        projectName: 'test-project',
+        org: 'test-org',
+        projectUrl: 'https://github.com/test-org/test-project',
+        manager: 'test-manager',
+        workingReport: {
+          repo: 'test-repo',
+          members: ['member1'],
+          spreadsheetUrl: 'https://docs.google.com/spreadsheets/test',
+        },
+        urlOfStoryView: 'https://github.com/test-org/test-project/issues',
+        disabled: false,
+      };
+
+      mockProjectRepository.getProject.mockResolvedValue(mock<Project>());
+      await useCase.run(input);
+
+      expect(mockConflictedIssueRevertUseCase.run).toHaveBeenCalledWith(
+        expect.objectContaining({
+          projectUrl: 'https://github.com/test-org/test-project',
+        }),
+      );
+    });
+
     it('should invoke revertNotReadyReviewQueueIssueUseCase on every scheduled run', async () => {
       const input = {
         projectName: 'test-project',
@@ -1781,6 +1810,7 @@ describe('HandleScheduledEventUseCase', () => {
       mock<IssueNoStatusUpdateUseCase>(),
       mock<StartPreparationUseCase>(),
       mock<RevertOrphanedPreparationUseCase>(),
+      mock<ConflictedIssueRevertUseCase>(),
       mock<RevertNotReadyReviewQueueIssueUseCase>(),
       mock<TriagerApprovalDispatchUseCase>(),
       mock<AgentDesignationLabelAdoptUseCase>(),

package/src/domain/usecases/HandleScheduledEventUseCase.ts

@@ -42,6 +42,7 @@ import {
 } from './DailySecurityScanUseCase';
 import { QualityCheckAdvanceUseCase } from './QualityCheckAdvanceUseCase';
 import { ReopenedDoneIssueRevertUseCase } from './ReopenedDoneIssueRevertUseCase';
+import { ConflictedIssueRevertUseCase } from './ConflictedIssueRevertUseCase';
 
 export class ProjectNotFoundError extends Error {
   constructor(message: string) {
@@ -138,6 +139,7 @@ export class HandleScheduledEventUseCase {
     readonly issueNoStatusUpdateUseCase: IssueNoStatusUpdateUseCase,
     readonly startPreparationUseCase: StartPreparationUseCase,
     readonly revertOrphanedPreparationUseCase: RevertOrphanedPreparationUseCase,
+    readonly conflictedIssueRevertUseCase: ConflictedIssueRevertUseCase,
     readonly revertNotReadyReviewQueueIssueUseCase: RevertNotReadyReviewQueueIssueUseCase,
     readonly triagerApprovalDispatchUseCase: TriagerApprovalDispatchUseCase,
     readonly agentDesignationLabelAdoptUseCase: AgentDesignationLabelAdoptUseCase,
@@ -436,6 +438,9 @@ ${JSON.stringify(e)}
       issues,
       agents: input.agents ?? null,
     });
+    await this.conflictedIssueRevertUseCase.run({
+      projectUrl: input.projectUrl,
+    });
     await this.revertNotReadyReviewQueueIssueUseCase.run({
       projectUrl: input.projectUrl,
       manager: input.manager,

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

@@ -4665,4 +4665,90 @@ 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 () => {
+      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.update).toHaveBeenCalledWith(
+        expect.objectContaining({ status: 'Awaiting Workspace' }),
+        mockProject,
+      );
+      expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+        mockProject,
+        expect.objectContaining({ status: 'Awaiting Workspace' }),
+        'awaiting-workspace-id',
+      );
+      expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+        expect.objectContaining({ url: issueUrl }),
+        expect.stringContaining('Auto Status Check: AWAITING_OWNER_APPROVAL'),
+      );
+      expect(mockIssueRepository.updateStatus).not.toHaveBeenCalledWith(
+        mockProject,
+        expect.anything(),
+        'failed-preparation-id',
+      );
+    });
+
+    it('escalates to Failed Preparation after ownerApprovalTimeoutCycles AWAITING_OWNER_APPROVAL messages', 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```',
+        }),
+        createMockComment({
+          content:
+            'Auto Status Check: AWAITING_OWNER_APPROVAL\nThe last report declared that this task is waiting for owner approval. Returning to Awaiting Workspace for the next cycle.',
+        }),
+        createMockComment({
+          content:
+            'Auto Status Check: AWAITING_OWNER_APPROVAL\nThe last report declared that this task is waiting for owner approval. Returning to Awaiting Workspace for the next cycle.',
+        }),
+      ]);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl,
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+        allowedIssueAuthors: null,
+        ownerApprovalTimeoutCycles: 2,
+      });
+
+      expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+        mockProject,
+        expect.anything(),
+        'failed-preparation-id',
+      );
+      expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+        expect.anything(),
+        expect.stringContaining(
+          'Owner approval was not received after 2 cycles. Moving to Failed Preparation.',
+        ),
+      );
+    });
+  });
 });

package/src/domain/usecases/NotifyFinishedIssuePreparationUseCase.ts

@@ -20,6 +20,11 @@ import {
   RETURNED_TO_AWAITING_WORKSPACE_MESSAGE,
   RETURNED_TO_AWAITING_WORKSPACE_MESSAGE_HEAD,
 } from './returnedToAwaitingWorkspaceMessage';
+import { isWaitingForOwnerApproval } from './isWaitingForOwnerApproval';
+import {
+  AWAITING_OWNER_APPROVAL_MESSAGE,
+  AWAITING_OWNER_APPROVAL_MESSAGE_HEAD,
+} from './awaitingOwnerApprovalMessage';
 import {
   ConsoleListItem,
   ConsoleTabName,
@@ -121,6 +126,7 @@ export class NotifyFinishedIssuePreparationUseCase {
     manager?: string | null;
     developerAgentName?: string | null;
     deferPreparation?: boolean | null;
+    ownerApprovalTimeoutCycles?: number | null;
   }): Promise<void> => {
     const project = await this.projectRepository.getByUrl(params.projectUrl);
 
@@ -309,6 +315,52 @@ export class NotifyFinishedIssuePreparationUseCase {
       return;
     }
 
+    if (
+      lastAgentReport !== null &&
+      isWaitingForOwnerApproval(lastAgentReport.content)
+    ) {
+      const ownerApprovalTimeoutCycles =
+        params.ownerApprovalTimeoutCycles ?? 12;
+      const awaitingOwnerApprovalCount = comments.filter(
+        (comment) =>
+          isTrustedAuthor(comment.author) &&
+          comment.content.startsWith(AWAITING_OWNER_APPROVAL_MESSAGE_HEAD),
+      ).length;
+      if (awaitingOwnerApprovalCount < ownerApprovalTimeoutCycles) {
+        issue.status = AWAITING_WORKSPACE_STATUS_NAME;
+        await this.issueRepository.update(issue, project);
+        await this.issueRepository.updateStatus(
+          project,
+          issue,
+          awaitingWorkspaceStatusOption.id,
+        );
+        await this.patchConsoleTab(issue);
+        await this.issueCommentRepository.createComment(
+          issue,
+          AWAITING_OWNER_APPROVAL_MESSAGE,
+        );
+        return;
+      }
+      issue.status = FAILED_PREPARATION_STATUS_NAME;
+      await this.issueRepository.update(issue, project);
+      await this.issueRepository.updateStatus(
+        project,
+        issue,
+        failedPreparationStatusOption.id,
+      );
+      await this.patchConsoleTab(issue);
+      await this.issueCommentRepository.createComment(
+        issue,
+        `Owner approval was not received after ${ownerApprovalTimeoutCycles} cycles. Moving to Failed Preparation.`,
+      );
+      await this.sendWorkflowBlockerNotification(
+        params.issueUrl,
+        params.workflowBlockerResolvedWebhookUrl,
+        project,
+      );
+      return;
+    }
+
     const { rejections, approvedPrUrl } = await this.collectRejections(
       issue,
       comments,

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

@@ -2158,4 +2158,97 @@ describe('RevertOrphanedPreparationUseCase', () => {
       'Auto Status Check: REJECTED',
     );
   });
+
+  it('should return orphaned issue to Awaiting Workspace with AWAITING_OWNER_APPROVAL when last report declares waitingForOwnerApproval', async () => {
+    const stuckIssue = createMockIssue({
+      url: 'https://github.com/user/repo/issues/10',
+      status: 'Preparation',
+    });
+    mockIssueRepository.getAllIssues.mockResolvedValue({
+      project: mockProject,
+      issues: [stuckIssue],
+      cacheUsed: false,
+    });
+    mockLocalCommandRunner.runCommand.mockResolvedValue({
+      stdout: '',
+      stderr: '',
+      exitCode: 1,
+    });
+    mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+      {
+        author: 'agent-bot',
+        content:
+          'From: :robot: systems-analyst (model)\n```json\n{"pullRequestRequired": false, "waitingForOwnerApproval": true}\n```',
+        createdAt: new Date(),
+      },
+    ]);
+    mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      preparationProcessCheckCommand: 'pgrep -fa "claude-agent.*{URL}"',
+      thresholdForAutoReject: 3,
+      allowedIssueAuthors: ['agent-bot'],
+    });
+
+    expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
+    expect(mockIssueRepository.updateStatus.mock.calls[0][2]).toBe('1');
+    expect(mockIssueCommentRepository.createComment.mock.calls).toHaveLength(1);
+    expect(mockIssueCommentRepository.createComment.mock.calls[0][1]).toContain(
+      'Auto Status Check: AWAITING_OWNER_APPROVAL',
+    );
+  });
+
+  it('should escalate to Failed Preparation after ownerApprovalTimeoutCycles AWAITING_OWNER_APPROVAL messages in RevertOrphaned', async () => {
+    const stuckIssue = createMockIssue({
+      url: 'https://github.com/user/repo/issues/10',
+      status: 'Preparation',
+    });
+    mockIssueRepository.getAllIssues.mockResolvedValue({
+      project: mockProject,
+      issues: [stuckIssue],
+      cacheUsed: false,
+    });
+    mockLocalCommandRunner.runCommand.mockResolvedValue({
+      stdout: '',
+      stderr: '',
+      exitCode: 1,
+    });
+    mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+      {
+        author: 'agent-bot',
+        content:
+          'From: :robot: systems-analyst (model)\n```json\n{"pullRequestRequired": false, "waitingForOwnerApproval": true}\n```',
+        createdAt: new Date(),
+      },
+      {
+        author: 'agent-bot',
+        content:
+          'Auto Status Check: AWAITING_OWNER_APPROVAL\nThe last report declared that this task is waiting for owner approval. Returning to Awaiting Workspace for the next cycle.',
+        createdAt: new Date(),
+      },
+      {
+        author: 'agent-bot',
+        content:
+          'Auto Status Check: AWAITING_OWNER_APPROVAL\nThe last report declared that this task is waiting for owner approval. Returning to Awaiting Workspace for the next cycle.',
+        createdAt: new Date(),
+      },
+    ]);
+    mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      preparationProcessCheckCommand: 'pgrep -fa "claude-agent.*{URL}"',
+      thresholdForAutoReject: 3,
+      allowedIssueAuthors: ['agent-bot'],
+      ownerApprovalTimeoutCycles: 2,
+    });
+
+    expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
+    expect(mockIssueRepository.updateStatus.mock.calls[0][2]).toBe('5');
+    expect(mockIssueCommentRepository.createComment.mock.calls).toHaveLength(1);
+    expect(mockIssueCommentRepository.createComment.mock.calls[0][1]).toContain(
+      'Owner approval was not received after 2 cycles. Moving to Failed Preparation.',
+    );
+  });
 });

package/src/domain/usecases/RevertOrphanedPreparationUseCase.ts

@@ -22,6 +22,11 @@ import {
   RETURNED_TO_AWAITING_WORKSPACE_MESSAGE,
   RETURNED_TO_AWAITING_WORKSPACE_MESSAGE_HEAD,
 } from './returnedToAwaitingWorkspaceMessage';
+import { isWaitingForOwnerApproval } from './isWaitingForOwnerApproval';
+import {
+  AWAITING_OWNER_APPROVAL_MESSAGE,
+  AWAITING_OWNER_APPROVAL_MESSAGE_HEAD,
+} from './awaitingOwnerApprovalMessage';
 import { extractNextStepAgent } from './extractNextStepAgent';
 import { findLastAgentReport } from './findLastAgentReport';
 import { isAgentReportBody } from './isAgentReportBody';
@@ -35,7 +40,10 @@ import {
 const ORPHANED_PREPARATION_REJECTION_DETAIL = 'ORPHANED_PREPARATION';
 
 type OrphanedPreparationOutcome =
-  'advanceToQualityCheck' | 'returnToLabelSelectedAgent' | 'reject';
+  | 'advanceToQualityCheck'
+  | 'returnToLabelSelectedAgent'
+  | 'returnToOwnerApprovalCycle'
+  | 'reject';
 
 export class RevertOrphanedPreparationUseCase {
   constructor(
@@ -74,6 +82,7 @@ export class RevertOrphanedPreparationUseCase {
     labelsAsLlmAgentName?: string[] | null;
     labelsNotRequiringPullRequest?: string[] | null;
     allowedIssueAuthors?: string[] | null;
+    ownerApprovalTimeoutCycles?: number | null;
   }): Promise<void> => {
     const projectId = await this.projectRepository.findProjectIdByUrl(
       params.projectUrl,
@@ -191,6 +200,40 @@ export class RevertOrphanedPreparationUseCase {
         }
         continue;
       }
+      if (outcome === 'returnToOwnerApprovalCycle') {
+        const ownerApprovalTimeoutCycles =
+          params.ownerApprovalTimeoutCycles ?? 12;
+        const awaitingOwnerApprovalCount = comments.filter(
+          (comment) =>
+            isAuthorAuthorizedForAutoStatusCheck(
+              comment.author,
+              params.allowedIssueAuthors,
+            ) &&
+            comment.content.startsWith(AWAITING_OWNER_APPROVAL_MESSAGE_HEAD),
+        ).length;
+        if (awaitingOwnerApprovalCount < ownerApprovalTimeoutCycles) {
+          await this.issueRepository.updateStatus(
+            project,
+            issue,
+            awaitingWorkspaceStatusOption.id,
+          );
+          await this.issueCommentRepository.createComment(
+            issue,
+            AWAITING_OWNER_APPROVAL_MESSAGE,
+          );
+        } else if (failedPreparationStatusOption) {
+          await this.issueRepository.updateStatus(
+            project,
+            issue,
+            failedPreparationStatusOption.id,
+          );
+          await this.issueCommentRepository.createComment(
+            issue,
+            `Owner approval was not received after ${ownerApprovalTimeoutCycles} cycles. Moving to Failed Preparation.`,
+          );
+        }
+        continue;
+      }
       if (outcome === 'returnToLabelSelectedAgent') {
         await this.issueRepository.updateStatus(
           project,
@@ -324,6 +367,9 @@ export class RevertOrphanedPreparationUseCase {
       ) &&
       !this.reportBodyHasNextStep(lastReport.content)
     ) {
+      if (isWaitingForOwnerApproval(lastReport.content)) {
+        return { outcome: 'returnToOwnerApprovalCycle', comments };
+      }
       const alreadyReturnedToWorkspace = comments.some(
         (comment) =>
           isTrustedAuthor(comment.author) &&

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

@@ -979,6 +979,82 @@ describe('StartPreparationUseCase', () => {
       ],
     ]);
   });
+  it('should not treat a cross-repository PR as duplicate when a same-repository PR exists', async () => {
+    const awaitingIssues: Issue[] = [
+      createMockIssue({
+        url: 'https://github.com/HiromiShikata/secretary/issues/4290',
+        title: 'Issue 4290',
+        nameWithOwner: 'HiromiShikata/secretary',
+        number: 4290,
+        org: 'HiromiShikata',
+        repo: 'secretary',
+        labels: ['category:impl'],
+        status: 'Awaiting Workspace',
+      }),
+    ];
+    const sameRepoPR: RelatedPullRequest = {
+      url: 'https://github.com/HiromiShikata/secretary/pull/4610',
+      branchName: 'i4290',
+      createdAt: new Date('2026-08-28T13:38:00Z'),
+      isDraft: false,
+      isConflicted: false,
+      mergeable: null,
+      isPassedAllCiJob: false,
+      isCiStateSuccess: false,
+      isResolvedAllReviewComments: false,
+      isBranchOutOfDate: false,
+      missingRequiredCheckNames: [],
+    };
+    const crossRepoPR: RelatedPullRequest = {
+      url: 'https://github.com/HiromiShikata/npm-cli-github-issue-tower-defence-management/pull/1813',
+      branchName: 'i4290',
+      createdAt: new Date('2026-08-28T10:55:00Z'),
+      isDraft: false,
+      isConflicted: false,
+      mergeable: null,
+      isPassedAllCiJob: false,
+      isCiStateSuccess: false,
+      isResolvedAllReviewComments: false,
+      isBranchOutOfDate: false,
+      missingRequiredCheckNames: [],
+    };
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
+    mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+      sameRepoPR,
+      crossRepoPR,
+    ]);
+    mockLocalCommandRunner.runCommand.mockResolvedValue({
+      stdout: '',
+      stderr: '',
+      exitCode: 0,
+    });
+    await useCase.run({
+      projectUrl: 'https://github.com/users/user/projects/1',
+      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(mockIssueRepository.closePullRequest).not.toHaveBeenCalled();
+    expect(mockIssueRepository.deletePullRequestBranch).not.toHaveBeenCalled();
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
+    expect(mockLocalCommandRunner.runCommand.mock.calls[0][1]).toContain(
+      '--branch',
+    );
+    expect(mockLocalCommandRunner.runCommand.mock.calls[0][1]).toContain(
+      'i4290',
+    );
+  });
   it('should skip issue after resolving duplicates when adopted canonical PR has null branchName', async () => {
     const awaitingIssues: Issue[] = [
       createMockIssue({

package/src/domain/usecases/StartPreparationUseCase.ts

@@ -554,8 +554,12 @@ export class StartPreparationUseCase {
         const relatedPRs = await this.issueRepository.findRelatedOpenPRs(
           issue.url,
         );
-        if (relatedPRs.length > 1) {
-          const sortedPRs = [...relatedPRs].sort(
+        const sameRepoRelatedPRs = relatedPRs.filter((pr) => {
+          const match = /^https?:\/\/[^/]+\/([^/]+\/[^/]+)\//.exec(pr.url);
+          return match === null || match[1] === issue.nameWithOwner;
+        });
+        if (sameRepoRelatedPRs.length > 1) {
+          const sortedPRs = [...sameRepoRelatedPRs].sort(
             (a, b) => a.createdAt.getTime() - b.createdAt.getTime(),
           );
           const canonicalPR = sortedPRs[0];
@@ -585,14 +589,14 @@ export class StartPreparationUseCase {
             continue;
           }
           branchName = canonicalPR.branchName;
-        } else if (relatedPRs.length === 1) {
-          if (relatedPRs[0].branchName === null) {
+        } else if (sameRepoRelatedPRs.length === 1) {
+          if (sameRepoRelatedPRs[0].branchName === null) {
             console.warn(
               `Skipping issue ${issue.url}: related open PR has unavailable head branch.`,
             );
             continue;
           }
-          branchName = relatedPRs[0].branchName;
+          branchName = sameRepoRelatedPRs[0].branchName;
         } else {
           branchName = `i${issue.number}`;
         }