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

package/bin/domain/usecases/awaitingOwnerApprovalMessage.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AWAITING_OWNER_APPROVAL_MESSAGE = exports.AWAITING_OWNER_APPROVAL_MESSAGE_HEAD = void 0;
+exports.AWAITING_OWNER_APPROVAL_MESSAGE_HEAD = 'Auto Status Check: AWAITING_OWNER_APPROVAL';
+exports.AWAITING_OWNER_APPROVAL_MESSAGE = `${exports.AWAITING_OWNER_APPROVAL_MESSAGE_HEAD}
+The last report declared that this task is waiting for owner approval. Returning to Awaiting Workspace for the next cycle.`;
+//# sourceMappingURL=awaitingOwnerApprovalMessage.js.map

package/bin/domain/usecases/awaitingOwnerApprovalMessage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"awaitingOwnerApprovalMessage.js","sourceRoot":"","sources":["../../../src/domain/usecases/awaitingOwnerApprovalMessage.ts"],"names":[],"mappings":";;;AAAa,QAAA,oCAAoC,GAC/C,4CAA4C,CAAC;AAElC,QAAA,+BAA+B,GAAG,GAAG,4CAAoC;2HACqC,CAAC"}

package/bin/domain/usecases/isWaitingForOwnerApproval.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWaitingForOwnerApproval = void 0;
+const extractFencedJsonBlocks_1 = require("./extractFencedJsonBlocks");
+const isWaitingForOwnerApproval = (reportContent) => {
+    const blocks = (0, extractFencedJsonBlocks_1.extractFencedJsonBlocks)(reportContent, 'waitingForOwnerApproval');
+    const firstBlock = blocks[0];
+    if (typeof firstBlock !== 'object' || firstBlock === null) {
+        return false;
+    }
+    const report = { ...firstBlock };
+    return (report.pullRequestRequired === false &&
+        report.waitingForOwnerApproval === true);
+};
+exports.isWaitingForOwnerApproval = isWaitingForOwnerApproval;
+//# sourceMappingURL=isWaitingForOwnerApproval.js.map

package/bin/domain/usecases/isWaitingForOwnerApproval.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isWaitingForOwnerApproval.js","sourceRoot":"","sources":["../../../src/domain/usecases/isWaitingForOwnerApproval.ts"],"names":[],"mappings":";;;AAAA,uEAAoE;AAE7D,MAAM,yBAAyB,GAAG,CAAC,aAAqB,EAAW,EAAE;IAC1E,MAAM,MAAM,GAAG,IAAA,iDAAuB,EACpC,aAAa,EACb,yBAAyB,CAC1B,CAAC;IACF,MAAM,UAAU,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IAC7B,IAAI,OAAO,UAAU,KAAK,QAAQ,IAAI,UAAU,KAAK,IAAI,EAAE,CAAC;QAC1D,OAAO,KAAK,CAAC;IACf,CAAC;IACD,MAAM,MAAM,GAA4B,EAAE,GAAG,UAAU,EAAE,CAAC;IAC1D,OAAO,CACL,MAAM,CAAC,mBAAmB,KAAK,KAAK;QACpC,MAAM,CAAC,uBAAuB,KAAK,IAAI,CACxC,CAAC;AACJ,CAAC,CAAC;AAdW,QAAA,yBAAyB,6BAcpC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "github-issue-tower-defence-management",
-  "version": "1.190.0",
+  "version": "1.191.0",
   "description": "",
   "main": "bin/index.js",
   "scripts": {

package/src/adapter/entry-points/cli/index.test.ts

@@ -1522,6 +1522,7 @@ mysteryKey: 'value'
         manager: 'test-manager',
         developerAgentName: null,
         deferPreparation: null,
+        ownerApprovalTimeoutCycles: 12,
       });
     });
 
@@ -1566,6 +1567,7 @@ mysteryKey: 'value'
         manager: 'test-manager',
         developerAgentName: null,
         deferPreparation: null,
+        ownerApprovalTimeoutCycles: 12,
       });
     });
 

package/src/adapter/entry-points/cli/index.ts

@@ -118,6 +118,7 @@ type NotifyFinishedOptions = {
   missingAgentName?: string;
   sessionErrorLine?: string;
   deferPreparation?: boolean;
+  ownerApprovalTimeoutCycles?: string;
 };
 
 type CheckIssueReviewReadinessOptions = {
@@ -440,6 +441,7 @@ program
         labelsAsLlmAgentName: config.labelsAsLlmAgentName ?? null,
         labelsNotRequiringPullRequest:
           config.labelsNotRequiringPullRequest ?? null,
+        ownerApprovalTimeoutCycles: config.ownerApprovalTimeoutCycles ?? 12,
       });
     }
 
@@ -539,6 +541,10 @@ program
     '--deferPreparation',
     'Defer the item via the Reactivation Trigger fields (sets nextActionDate to tomorrow) without creating any issue; use for transient upstream failures',
   )
+  .option(
+    '--ownerApprovalTimeoutCycles <count>',
+    'Number of owner-approval wait cycles before escalating to Failed Preparation (default: 12)',
+  )
   .action(async (options: NotifyFinishedOptions) => {
     const token = process.env.GH_TOKEN;
     if (!token) {
@@ -675,6 +681,9 @@ program
       manager: config.manager ?? null,
       developerAgentName: config.developerAgentName ?? null,
       deferPreparation: options.deferPreparation ?? null,
+      ownerApprovalTimeoutCycles: options.ownerApprovalTimeoutCycles
+        ? Number(options.ownerApprovalTimeoutCycles)
+        : (config.ownerApprovalTimeoutCycles ?? 12),
     });
   });
 

package/src/adapter/entry-points/cli/projectConfig.ts

@@ -32,6 +32,7 @@ export type ConfigFile = {
   consoleProjects?: Record<string, string>;
   consoleGithubTokenFileDir?: string;
   disks?: DiskConfig[];
+  ownerApprovalTimeoutCycles?: number;
 };
 
 export type DiskConfig = {
@@ -206,6 +207,10 @@ export const loadConfigFile = (configFilePath: string): ConfigFile => {
         'consoleGithubTokenFileDir',
       ),
       disks: getDisksValue(parsed, 'disks'),
+      ownerApprovalTimeoutCycles: getNumberValue(
+        parsed,
+        'ownerApprovalTimeoutCycles',
+      ),
     };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -395,6 +400,9 @@ export const mergeConfigs = (
     cliOverrides.consoleGithubTokenFileDir ??
     configFile.consoleGithubTokenFileDir,
   disks: cliOverrides.disks ?? configFile.disks,
+  ownerApprovalTimeoutCycles:
+    cliOverrides.ownerApprovalTimeoutCycles ??
+    configFile.ownerApprovalTimeoutCycles,
 });
 
 type GraphqlProjectV2ReadmeResponse = {

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}`;
         }

package/src/domain/usecases/awaitingOwnerApprovalMessage.ts

@@ -0,0 +1,5 @@
+export const AWAITING_OWNER_APPROVAL_MESSAGE_HEAD =
+  'Auto Status Check: AWAITING_OWNER_APPROVAL';
+
+export const AWAITING_OWNER_APPROVAL_MESSAGE = `${AWAITING_OWNER_APPROVAL_MESSAGE_HEAD}
+The last report declared that this task is waiting for owner approval. Returning to Awaiting Workspace for the next cycle.`;