github-issue-tower-defence-management 1.122.9 → 1.122.11

package/src/adapter/repositories/TranscriptRefusalTailStatusProvider.ts

@@ -0,0 +1,80 @@
+import * as fs from 'fs';
+import { RefusalTailStatusProvider } from '../../domain/usecases/adapter-interfaces/RefusalTailStatusProvider';
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null;
+
+const readString = (
+  value: Record<string, unknown>,
+  key: string,
+): string | null => {
+  const candidate = value[key];
+  return typeof candidate === 'string' ? candidate : null;
+};
+
+// A model refusal is durably recorded in the session transcript JSONL as an
+// assistant entry whose stop reason is `refusal` (a system entry with
+// `subtype: 'model_refusal_no_fallback'` precedes it). The stop reason lives
+// on the embedded API message (`message.stop_reason`); the top-level field is
+// also checked for robustness against transcript format variations.
+const isRefusalAssistantEntry = (parsed: Record<string, unknown>): boolean => {
+  if (readString(parsed, 'type') !== 'assistant') {
+    return false;
+  }
+  if (readString(parsed, 'stop_reason') === 'refusal') {
+    return true;
+  }
+  const message = parsed.message;
+  return isRecord(message) && readString(message, 'stop_reason') === 'refusal';
+};
+
+export class TranscriptRefusalTailStatusProvider implements RefusalTailStatusProvider {
+  // A session is refusal-tailed when the most recent assistant entry in its
+  // transcript is a model refusal. Sending a reminder to such a session is
+  // guaranteed to burn a full-context API call and produce another refusal,
+  // so the monitor excludes it from reminder candidates. The gate is purely
+  // state-based: as soon as any non-refusal assistant entry appears after the
+  // refusal (manual nudge, restart, compaction), the session is no longer
+  // refusal-tailed and reminders resume.
+  listRefusalTailedSessionNames = async (
+    transcriptPathBySessionName: Map<string, string>,
+  ): Promise<Set<string>> => {
+    const refusalTailedSessionNames = new Set<string>();
+    for (const [sessionName, transcriptPath] of transcriptPathBySessionName) {
+      if (this.isTranscriptRefusalTailed(transcriptPath)) {
+        refusalTailedSessionNames.add(sessionName);
+      }
+    }
+    return refusalTailedSessionNames;
+  };
+
+  private isTranscriptRefusalTailed = (transcriptPath: string): boolean => {
+    let content: string;
+    try {
+      content = fs.readFileSync(transcriptPath, 'utf8');
+    } catch {
+      return false;
+    }
+    let lastAssistantEntryIsRefusal = false;
+    for (const line of content.split('\n')) {
+      const trimmed = line.trim();
+      if (trimmed.length === 0) {
+        continue;
+      }
+      let parsed: unknown;
+      try {
+        parsed = JSON.parse(trimmed);
+      } catch {
+        continue;
+      }
+      if (!isRecord(parsed)) {
+        continue;
+      }
+      if (readString(parsed, 'type') !== 'assistant') {
+        continue;
+      }
+      lastAssistantEntryIsRefusal = isRefusalAssistantEntry(parsed);
+    }
+    return lastAssistantEntryIsRefusal;
+  };
+}

package/src/domain/entities/Project.ts

@@ -3,14 +3,7 @@ export type FieldOption = {
   id: string;
   name: string;
   color:
-    | 'GRAY'
-    | 'BLUE'
-    | 'GREEN'
-    | 'YELLOW'
-    | 'ORANGE'
-    | 'RED'
-    | 'PINK'
-    | 'PURPLE';
+    'GRAY' | 'BLUE' | 'GREEN' | 'YELLOW' | 'ORANGE' | 'RED' | 'PINK' | 'PURPLE';
   description: string;
 };
 export type Project = {

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

@@ -185,9 +185,9 @@ describe('AssignNoAssigneeIssueToManagerUseCase', () => {
         ...basicIssue,
         url: 'https://github.com/testOrg/testRepo/issues/44',
       };
+      const nonErrorValue: unknown = 'string-failure';
       mockIssueRepository.updateAssigneeList.mockImplementationOnce(() => {
-        const nonError: unknown = 'string-failure';
-        throw nonError;
+        throw nonErrorValue;
       });
 
       await expect(

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

@@ -48,7 +48,9 @@ describe('DefaultSilentSessionMessageComposer', () => {
         'Keep a monitor in place that notices when a sub-agent has produced no output for about 5 minutes.',
       ),
     ).toBe(1);
-    expect(occurrences('share it through a new owner-call')).toBe(1);
+    expect(
+      occurrences('work the owner asked for has been completed or answered'),
+    ).toBe(1);
   });
 
   it('requests a remaining-minutes estimate in the next output', () => {
@@ -63,40 +65,38 @@ describe('DefaultSilentSessionMessageComposer', () => {
     expect(section).toContain('No output has been observed for 10 minutes.');
   });
 
-  it('states the owner-call tag format exactly once: complete pair on one line, content starting with the red-circle emoji, self-contained', () => {
+  it('states the owner-call format guidance exactly once, deferring to the session-documented format', () => {
     const section = composer.composeMainStalledSection(600);
     const formatOccurrences =
-      section.split('complete opening and closing pair on one line').length - 1;
+      section.split('in the format documented for this session').length - 1;
     expect(formatOccurrences).toBe(1);
-    expect(section).toContain('🔴');
+    expect(section).toContain('written to be self-contained');
     expect(section).toContain(
-      'with the content starting immediately with the 🔴 emoji',
+      'so the owner can understand the situation from that single message',
     );
-    expect(section).toContain('written to be self-contained');
   });
 
   it('explains that the owner is notified only when an owner-call is raised', () => {
     const section = composer.composeMainStalledSection(600);
-    expect(section).toContain('the owner is notified only when one is raised');
-  });
-
-  it('interpolates the configured owner-call marker into the format guidance when provided', () => {
-    const markedComposer = new DefaultSilentSessionMessageComposer(
-      '<<OWNER_CALL>>',
-    );
-    const section = markedComposer.composeMainStalledSection(600);
     expect(section).toContain(
-      'owner-call marker tag "<<OWNER_CALL>>" as a complete opening and closing pair on one line',
+      'The owner is notified only when an owner-call is raised.',
     );
-    expect(section).toContain('🔴');
   });
 
-  it('falls back to generic owner-call format guidance when no marker is configured', () => {
+  it('frames a completed owner request as awaiting acknowledgment rather than a no-action case', () => {
     const section = composer.composeMainStalledSection(600);
     expect(section).toContain(
-      'owner-call marker tag as a complete opening and closing pair on one line',
+      "a completion still awaits the owner's acknowledgment",
     );
-    expect(section).not.toContain('""');
+    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('embeds the reminder sentinel in the stale-owner-call main-stalled section', () => {
@@ -166,22 +166,19 @@ describe('DefaultSilentSessionMessageComposer', () => {
       3600,
     );
     const formatOccurrences =
-      section.split('complete opening and closing pair on one line').length - 1;
+      section.split('in the format documented for this session').length - 1;
     expect(formatOccurrences).toBe(1);
   });
 
-  it('interpolates the configured owner-call marker into the stale-owner-call format guidance', () => {
-    const markedComposer = new DefaultSilentSessionMessageComposer(
-      '<<OWNER_CALL>>',
-    );
-    const section = markedComposer.composeMainStalledWithStaleOwnerCallSection(
+  it('contains no marker-tag example, tag name, or angle bracket in the stale-owner-call section', () => {
+    const section = composer.composeMainStalledWithStaleOwnerCallSection(
       600,
       3600,
     );
-    expect(section).toContain(
-      'owner-call marker tag "<<OWNER_CALL>>" as a complete opening and closing pair on one line',
-    );
-    expect(section).toContain('🔴');
+    expect(section).not.toContain('marker tag');
+    expect(section).not.toContain('opening and closing pair');
+    expect(section).not.toContain('<');
+    expect(section).not.toContain('>');
   });
 
   it('composes the stale-owner-call section distinctly from the plain main-stalled section', () => {
@@ -350,9 +347,6 @@ describe('DefaultSilentSessionMessageComposer', () => {
       /do not wait passively/i,
       /is prohibited/i,
     ];
-    const markedComposer = new DefaultSilentSessionMessageComposer(
-      '<<OWNER_CALL>>',
-    );
     const subAgent = {
       label: 'sub-process-1',
       silentSeconds: 360,
@@ -361,9 +355,7 @@ describe('DefaultSilentSessionMessageComposer', () => {
     };
     const composedDefaultTexts = [
       composer.composeMainStalledSection(600),
-      markedComposer.composeMainStalledSection(600),
       composer.composeMainStalledWithStaleOwnerCallSection(600, 3600),
-      markedComposer.composeMainStalledWithStaleOwnerCallSection(600, 3600),
       composer.composeSubAgentSection({
         idleSubAgents: [subAgent],
         longRunningSubAgents: [subAgent],
@@ -376,6 +368,34 @@ describe('DefaultSilentSessionMessageComposer', () => {
     }
   });
 
+  it('composes default texts free of angle-bracket tag examples and emoji characters', () => {
+    const emojiPattern =
+      /[\u{1F000}-\u{1FAFF}\u{2190}-\u{21FF}\u{2300}-\u{23FF}\u{2600}-\u{27BF}\u{2B00}-\u{2BFF}]/u;
+    const subAgent = {
+      label: 'sub-process-1',
+      silentSeconds: 360,
+      runningSeconds: 1200,
+      waitingOnExternalProcess: false,
+    };
+    const composedDefaultTexts = [
+      composer.composeMainStalledSection(600),
+      composer.composeMainStalledWithStaleOwnerCallSection(600, 3600),
+      composer.composeSubAgentSection({
+        idleSubAgents: [subAgent],
+        longRunningSubAgents: [subAgent],
+      }),
+    ];
+    for (const text of composedDefaultTexts) {
+      expect(text).not.toContain('<');
+      expect(text).not.toContain('>');
+      expect(text).not.toMatch(emojiPattern);
+      expect(text).not.toContain('\u{FE0F}');
+      expect(text).not.toContain('\u{200D}');
+      // The bracketed reminder sentinel remains allowed.
+      expect(text).toContain(SILENT_SESSION_REMINDER_SENTINEL);
+    }
+  });
+
   it('does not contain any host-specific or internal identifiers', () => {
     const mainSection = composer.composeMainStalledSection(600);
     const subAgent = {

package/src/domain/usecases/DefaultSilentSessionMessageComposer.ts

@@ -42,29 +42,18 @@ const composeLongRunningSubAgentSection = (
   ].join('\n');
 };
 
-export const composeOwnerCallFormatGuidance = (
-  ownerCallMarker: string | null,
-): string => {
-  const tagLabel =
-    ownerCallMarker !== null && ownerCallMarker.length > 0
-      ? ` "${ownerCallMarker}"`
-      : '';
-  return `Format reminder: write the owner-call marker tag${tagLabel} as a complete opening and closing pair on one line, with the content starting immediately with the 🔴 emoji and written to be self-contained, so the owner can understand the situation, the ask, and any decision needed from that single message.`;
+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.';
 };
 
-const composeMainStalledMessage = (
-  mainSilentSeconds: number,
-  ownerCallMarker: string | null,
-): string => {
+const composeMainStalledMessage = (mainSilentSeconds: number): string => {
   const minutes = Math.floor(mainSilentSeconds / 60);
   return [
     `${SILENT_SESSION_REMINDER_SENTINEL} This is an automated status check. No output has been observed for ${minutes} minutes. If you are waiting on an external process, no action is needed — please log one line explaining the wait. Otherwise please continue with the next step, with these points in mind:`,
     `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 an owner request has been completed or answered, please share it through a new owner-call — the owner is notified only when one is raised. ${composeOwnerCallFormatGuidance(
-      ownerCallMarker,
-    )}`,
+    `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()}`,
     `Please also include in your next output an estimate of the remaining minutes to finish all tasks.`,
   ].join('\n');
 };
@@ -72,24 +61,19 @@ const composeMainStalledMessage = (
 const composeMainStalledWithStaleOwnerCallMessage = (
   mainSilentSeconds: number,
   unansweredOwnerCallAgeSeconds: number,
-  ownerCallMarker: string | null,
 ): string => {
   const silentMinutes = Math.floor(mainSilentSeconds / 60);
   const ownerCallAgeMinutes = Math.floor(unansweredOwnerCallAgeSeconds / 60);
   return [
     `${SILENT_SESSION_REMINDER_SENTINEL} This is an automated status check. No output has been observed for ${silentMinutes} minutes, and the owner call raised ${ownerCallAgeMinutes} minutes ago has not yet been acknowledged by the owner.`,
-    `An owner call without an acknowledgment — whether it carried a completion report, a question, or a decision request — is still awaiting the owner's acknowledgment, and the earlier message may have been missed. Please re-raise its content as a fresh, self-contained owner call. ${composeOwnerCallFormatGuidance(
-      ownerCallMarker,
-    )}`,
+    `An owner call without an acknowledgment — whether it carried a completion report, a question, or a decision request — is still awaiting the owner's acknowledgment, and the earlier message may have been missed. Please re-raise its content as a fresh, self-contained owner call. ${composeOwnerCallFormatGuidance()}`,
     `Please also include in your next output an estimate of the remaining minutes to finish all tasks.`,
   ].join('\n');
 };
 
 export class DefaultSilentSessionMessageComposer implements SilentSessionMessageComposer {
-  constructor(private readonly ownerCallMarker: string | null = null) {}
-
   composeMainStalledSection = (mainSilentSeconds: number): string => {
-    return composeMainStalledMessage(mainSilentSeconds, this.ownerCallMarker);
+    return composeMainStalledMessage(mainSilentSeconds);
   };
 
   composeMainStalledWithStaleOwnerCallSection = (
@@ -99,7 +83,6 @@ export class DefaultSilentSessionMessageComposer implements SilentSessionMessage
     return composeMainStalledWithStaleOwnerCallMessage(
       mainSilentSeconds,
       unansweredOwnerCallAgeSeconds,
-      this.ownerCallMarker,
     );
   };
 

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

@@ -388,6 +388,160 @@ describe('IssueRejectionEvaluator', () => {
       });
     });
 
+    describe('transient getOpenPullRequest failure containment', () => {
+      let warnSpy: jest.SpyInstance;
+
+      beforeEach(() => {
+        warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+      });
+
+      afterEach(() => {
+        warnSpy.mockRestore();
+      });
+
+      it('should not throw and should return no rejections when getOpenPullRequest rejects for a PR item (isPr=true)', async () => {
+        mockIssueRepository.getOpenPullRequest.mockRejectedValue(
+          new Error(
+            'GraphQL errors: [{"message":"Something went wrong while executing your query"}]',
+          ),
+        );
+
+        const result = await evaluator.evaluate({
+          url: 'https://github.com/user/repo/pull/10',
+          labels: [],
+          isPr: true,
+        });
+
+        expect(result.rejections).toHaveLength(0);
+        expect(result.approvedPrUrl).toBeNull();
+      });
+
+      it('should log one warning line containing the PR URL and error message when getOpenPullRequest rejects for a PR item', async () => {
+        mockIssueRepository.getOpenPullRequest.mockRejectedValue(
+          new Error('Something went wrong while executing your query'),
+        );
+
+        await evaluator.evaluate({
+          url: 'https://github.com/user/repo/pull/10',
+          labels: [],
+          isPr: true,
+        });
+
+        expect(warnSpy).toHaveBeenCalledTimes(1);
+        expect(warnSpy).toHaveBeenCalledWith(
+          expect.stringContaining('https://github.com/user/repo/pull/10'),
+        );
+        expect(warnSpy).toHaveBeenCalledWith(
+          expect.stringContaining(
+            'Something went wrong while executing your query',
+          ),
+        );
+      });
+
+      it('should skip the failing URL, log a warning, and still evaluate the healthy PR in the same batch (prebuilt path)', async () => {
+        mockIssueRepository.getOpenPullRequest.mockImplementation(
+          (prUrl: string) =>
+            prUrl === 'https://github.com/user/repo/pull/8'
+              ? Promise.reject(
+                  new Error('Something went wrong while executing your query'),
+                )
+              : Promise.resolve(createReadyPr(prUrl)),
+        );
+
+        const result = await evaluator.evaluate(
+          {
+            url: 'https://github.com/user/repo/issues/1',
+            labels: [],
+            isPr: false,
+          },
+          [],
+          {
+            relatedOpenPrUrls: [
+              'https://github.com/user/repo/pull/8',
+              'https://github.com/user/repo/pull/9',
+            ],
+          },
+        );
+
+        expect(warnSpy).toHaveBeenCalledTimes(1);
+        expect(warnSpy).toHaveBeenCalledWith(
+          expect.stringContaining('https://github.com/user/repo/pull/8'),
+        );
+        expect(result.rejections).toHaveLength(0);
+        expect(result.approvedPrUrl).toBe(
+          'https://github.com/user/repo/pull/9',
+        );
+      });
+
+      it('should not reject with PULL_REQUEST_NOT_FOUND when the only related URL fails transiently (state unknown, skipped)', async () => {
+        mockIssueRepository.getOpenPullRequest.mockRejectedValue(
+          new Error('Something went wrong while executing your query'),
+        );
+
+        const result = await evaluator.evaluate(
+          {
+            url: 'https://github.com/user/repo/issues/1',
+            labels: [],
+            isPr: false,
+          },
+          [],
+          { relatedOpenPrUrls: ['https://github.com/user/repo/pull/8'] },
+        );
+
+        expect(warnSpy).toHaveBeenCalledTimes(1);
+        expect(result.rejections).toHaveLength(0);
+        expect(result.approvedPrUrl).toBeNull();
+      });
+
+      it('should still evaluate the healthy remaining PR normally when it has a rejection reason (draft) after another URL fails', async () => {
+        mockIssueRepository.getOpenPullRequest.mockImplementation(
+          (prUrl: string) =>
+            prUrl === 'https://github.com/user/repo/pull/8'
+              ? Promise.reject(
+                  new Error('Something went wrong while executing your query'),
+                )
+              : Promise.resolve(createReadyPr(prUrl, { isDraft: true })),
+        );
+
+        const result = await evaluator.evaluate(
+          {
+            url: 'https://github.com/user/repo/issues/1',
+            labels: [],
+            isPr: false,
+          },
+          [],
+          {
+            relatedOpenPrUrls: [
+              'https://github.com/user/repo/pull/8',
+              'https://github.com/user/repo/pull/9',
+            ],
+          },
+        );
+
+        expect(result.rejections).toHaveLength(1);
+        expect(result.rejections[0].type).toBe('PULL_REQUEST_IS_DRAFT');
+        expect(result.approvedPrUrl).toBeNull();
+      });
+
+      it('should handle a non-Error rejection value without throwing', async () => {
+        mockIssueRepository.getOpenPullRequest.mockRejectedValue(
+          'string failure',
+        );
+
+        const result = await evaluator.evaluate({
+          url: 'https://github.com/user/repo/pull/10',
+          labels: [],
+          isPr: true,
+        });
+
+        expect(warnSpy).toHaveBeenCalledTimes(1);
+        expect(warnSpy).toHaveBeenCalledWith(
+          expect.stringContaining('string failure'),
+        );
+        expect(result.rejections).toHaveLength(0);
+      });
+    });
+
     describe('change-target-must: label behavior', () => {
       const prUrl = 'https://github.com/user/repo/pull/1';
 

package/src/domain/usecases/IssueRejectionEvaluator.ts

@@ -67,17 +67,36 @@ export class IssueRejectionEvaluator {
       !hasLabelAsLlmAgentName &&
       (categoryLabels.length <= 0 || categoryLabels.includes('category:e2e'))
     ) {
-      const prsToCheck = issue.isPr
-        ? await this.resolveOpenPrsForPrItem(issue.url)
-        : options.relatedOpenPrUrls != null
-          ? await this.resolveOpenPrsFromUrls(options.relatedOpenPrUrls)
-          : await this.issueRepository.findRelatedOpenPRs(issue.url);
+      let prsToCheck: RelatedPullRequest[];
+      let anyPrResolutionFailed = false;
+      if (issue.isPr) {
+        const resolved = await this.resolveOpenPrsForPrItem(issue.url);
+        if (resolved === null) {
+          // getOpenPullRequest failed transiently: the PR's state is unknown
+          // for this cycle, so skip it without emitting any rejection.
+          return { rejections, approvedPrUrl };
+        }
+        prsToCheck = resolved;
+      } else if (options.relatedOpenPrUrls != null) {
+        const resolved = await this.resolveOpenPrsFromUrls(
+          options.relatedOpenPrUrls,
+        );
+        prsToCheck = resolved.prs;
+        anyPrResolutionFailed = resolved.anyResolutionFailed;
+      } else {
+        prsToCheck = await this.issueRepository.findRelatedOpenPRs(issue.url);
+      }
 
       if (prsToCheck.length <= 0) {
-        rejections.push({
-          type: 'PULL_REQUEST_NOT_FOUND',
-          detail: 'PULL_REQUEST_NOT_FOUND',
-        });
+        if (!anyPrResolutionFailed) {
+          rejections.push({
+            type: 'PULL_REQUEST_NOT_FOUND',
+            detail: 'PULL_REQUEST_NOT_FOUND',
+          });
+        }
+        // When a resolution failed and no PR resolved, the related PR state is
+        // unknown for this cycle; emit no rejection so a transient GraphQL
+        // error cannot cause a false PULL_REQUEST_NOT_FOUND revert.
       } else if (prsToCheck.length > 1) {
         rejections.push({
           type: 'MULTIPLE_PULL_REQUESTS_FOUND',
@@ -164,10 +183,21 @@ export class IssueRejectionEvaluator {
     return { rejections, approvedPrUrl };
   };
 
+  // Returns null when getOpenPullRequest throws (e.g. a transient GitHub
+  // GraphQL server error): the PR's state is unknown for this cycle and the
+  // caller skips it instead of letting the error abort the schedule cycle.
   private resolveOpenPrsForPrItem = async (
     prUrl: string,
-  ): Promise<RelatedPullRequest[]> => {
-    const pr = await this.issueRepository.getOpenPullRequest(prUrl);
+  ): Promise<RelatedPullRequest[] | null> => {
+    let pr: RelatedPullRequest | null;
+    try {
+      pr = await this.issueRepository.getOpenPullRequest(prUrl);
+    } catch (error) {
+      console.warn(
+        `IssueRejectionEvaluator: getOpenPullRequest failed, skipping PR for this cycle. prUrl: ${prUrl} error: ${error instanceof Error ? error.message : String(error)}`,
+      );
+      return null;
+    }
     if (pr === null) {
       return [];
     }
@@ -180,18 +210,34 @@ export class IssueRejectionEvaluator {
   // so the resulting set is equivalent while avoiding the per-issue timeline
   // query. Duplicate URLs are de-duplicated to mirror findRelatedOpenPRs, which
   // collapses duplicates via its internal Map keyed by PR URL.
+  //
+  // When getOpenPullRequest throws for a URL (e.g. a transient GitHub GraphQL
+  // server error), that PR is logged and skipped for this cycle while the
+  // remaining URLs are still resolved; anyResolutionFailed reports whether at
+  // least one URL failed so the caller can avoid treating an unknown state as
+  // PULL_REQUEST_NOT_FOUND.
   private resolveOpenPrsFromUrls = async (
     prUrls: string[],
-  ): Promise<RelatedPullRequest[]> => {
+  ): Promise<{ prs: RelatedPullRequest[]; anyResolutionFailed: boolean }> => {
     const uniquePrUrls = Array.from(new Set(prUrls));
     const resolvedPrs: RelatedPullRequest[] = [];
+    let anyResolutionFailed = false;
     for (const prUrl of uniquePrUrls) {
-      const pr = await this.issueRepository.getOpenPullRequest(prUrl);
+      let pr: RelatedPullRequest | null;
+      try {
+        pr = await this.issueRepository.getOpenPullRequest(prUrl);
+      } catch (error) {
+        console.warn(
+          `IssueRejectionEvaluator: getOpenPullRequest failed, skipping PR for this cycle. prUrl: ${prUrl} error: ${error instanceof Error ? error.message : String(error)}`,
+        );
+        anyResolutionFailed = true;
+        continue;
+      }
       if (pr !== null) {
         resolvedPrs.push(pr);
       }
     }
-    return resolvedPrs;
+    return { prs: resolvedPrs, anyResolutionFailed };
   };
 
   private extractChangeTargetMustPaths = (labels: string[]): string[] => {

package/src/domain/usecases/NotifyFinishedIssuePreparationUseCase.ts

@@ -33,9 +33,7 @@ export class IllegalIssueStatusError extends Error {
   }
 }
 type RejectedReasonType =
-  | 'NO_REPORT_FROM_AGENT_BOT'
-  | 'REPORT_HAS_NEXT_STEP'
-  | PrRejectedReasonType;
+  'NO_REPORT_FROM_AGENT_BOT' | 'REPORT_HAS_NEXT_STEP' | PrRejectedReasonType;
 
 export class NotifyFinishedIssuePreparationUseCase {
   private readonly issueRejectionEvaluator: IssueRejectionEvaluator;