github-issue-tower-defence-management 1.180.0 → 1.181.0

package/src/adapter/entry-points/console/ui-dist/index.html

@@ -4,7 +4,7 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>TDPM Console</title>
-    <script type="module" crossorigin src="/assets/index-I_2Yu8fM.js"></script>
+    <script type="module" crossorigin src="/assets/index-BUFcVUVD.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-DeZcPNCr.css">
   </head>
   <body>

package/src/adapter/repositories/GoogleSpreadsheetRepository.test.ts

@@ -215,6 +215,53 @@ describe('GoogleSpreadsheetRepository', () => {
 
       expect(result).toEqual([['1', 'true', 'text']]);
     });
+
+    test('retries once after a quota error and returns the value on success', async () => {
+      mockSpreadsheetsGet
+        .mockRejectedValueOnce(
+          new Error('Quota exceeded for quota metric Read requests'),
+        )
+        .mockResolvedValueOnce({
+          status: 200,
+          data: {
+            sheets: [{ properties: { title: 'RetrySheet' } }],
+          },
+        });
+      mockSpreadsheetsValuesGet.mockResolvedValue({
+        status: 200,
+        data: { values: [['retried']] },
+      });
+      const repositoryWithFastSleep = new GoogleSpreadsheetRepository(
+        localStorageRepository,
+        'dummy-service-account-key',
+        () => mockSheetsClient,
+        () => Promise.resolve(),
+      );
+
+      const result = await repositoryWithFastSleep.getSheet(
+        spreadsheetUrl,
+        'RetrySheet',
+      );
+
+      expect(result).toEqual([['retried']]);
+      expect(mockSpreadsheetsGet).toHaveBeenCalledTimes(2);
+    });
+
+    test('throws after exhausting all retries', async () => {
+      mockSpreadsheetsGet.mockRejectedValue(
+        new Error('Quota exceeded for quota metric Read requests'),
+      );
+      const repositoryWithFastSleep = new GoogleSpreadsheetRepository(
+        localStorageRepository,
+        'dummy-service-account-key',
+        () => mockSheetsClient,
+        () => Promise.resolve(),
+      );
+
+      await expect(
+        repositoryWithFastSleep.getSheet(spreadsheetUrl, 'AnySheet'),
+      ).rejects.toThrow('Quota exceeded');
+    });
   });
 
   describe('updateCell', () => {

package/src/adapter/repositories/GoogleSpreadsheetRepository.ts

@@ -44,13 +44,17 @@ interface SheetsApiClient {
 export class GoogleSpreadsheetRepository implements SpreadsheetRepository {
   keyFile = './tmp/service-account-key.json';
   private readonly sheetsClient: SheetsApiClient;
+  private readonly sleepFn: (ms: number) => Promise<void>;
 
   constructor(
     readonly localStorageRepository: LocalStorageRepository,
     serviceAccountKey: string = process.env.GOOGLE_SERVICE_ACCOUNT_KEY ||
       'dummy',
     sheetsClientFactory?: () => SheetsApiClient,
+    sleepFn: (ms: number) => Promise<void> = (ms) =>
+      new Promise((resolve) => setTimeout(resolve, ms)),
   ) {
+    this.sleepFn = sleepFn;
     this.localStorageRepository.write(this.keyFile, serviceAccountKey);
     this.sheetsClient = sheetsClientFactory
       ? sheetsClientFactory()
@@ -93,6 +97,30 @@ export class GoogleSpreadsheetRepository implements SpreadsheetRepository {
         })();
   }
 
+  private callWithRetry = async <T>(fn: () => Promise<T>): Promise<T> => {
+    const backoffMs = [1000, 2000, 4000];
+    let lastError: unknown;
+    for (let attempt = 0; attempt <= backoffMs.length; attempt++) {
+      try {
+        return await fn();
+      } catch (error) {
+        lastError = error;
+        const isQuotaError = (() => {
+          if (!(error instanceof Error)) return false;
+          if (error.message.includes('Quota exceeded')) return true;
+          if ('status' in error && error.status === 429) return true;
+          if ('code' in error && error.code === 429) return true;
+          return false;
+        })();
+        if (!isQuotaError || attempt === backoffMs.length) {
+          throw error;
+        }
+        await this.sleepFn(backoffMs[attempt]);
+      }
+    }
+    throw lastError;
+  };
+
   getSpreadsheetId = (spreadsheetUrl: string): string => {
     const url = new URL(spreadsheetUrl);
     return url.pathname.split('/')[3];
@@ -103,9 +131,11 @@ export class GoogleSpreadsheetRepository implements SpreadsheetRepository {
   ): Promise<string[][] | null> => {
     const sheets = this.sheetsClient;
     const spreadsheetId = this.getSpreadsheetId(spreadsheetUrl);
-    const responseSheet = await sheets.spreadsheets.get({
-      spreadsheetId,
-    });
+    const responseSheet = await this.callWithRetry(() =>
+      sheets.spreadsheets.get({
+        spreadsheetId,
+      }),
+    );
     if (responseSheet.status !== 200) {
       throw new Error(
         `Failed to get sheet: ${responseSheet.status}. ${JSON.stringify(responseSheet.data)}`,
@@ -117,10 +147,12 @@ export class GoogleSpreadsheetRepository implements SpreadsheetRepository {
     if (!sheet) {
       return null;
     }
-    const response = await sheets.spreadsheets.values.get({
-      spreadsheetId,
-      range: sheetName,
-    });
+    const response = await this.callWithRetry(() =>
+      sheets.spreadsheets.values.get({
+        spreadsheetId,
+        range: sheetName,
+      }),
+    );
     if (response.status !== 200) {
       throw new Error(
         `Failed to get sheet: ${response.status}. ${JSON.stringify(response.data)}`,
@@ -141,14 +173,16 @@ export class GoogleSpreadsheetRepository implements SpreadsheetRepository {
     const sheets = this.sheetsClient;
     const spreadsheetId = this.getSpreadsheetId(spreadsheetUrl);
     await this.createNewSheetIfNotExists(spreadsheetUrl, sheetName);
-    const response = await sheets.spreadsheets.values.update({
-      spreadsheetId,
-      range: `${sheetName}!${String.fromCharCode(65 + column)}${row + 1}`,
-      valueInputOption: 'RAW',
-      requestBody: {
-        values: [[value]],
-      },
-    });
+    const response = await this.callWithRetry(() =>
+      sheets.spreadsheets.values.update({
+        spreadsheetId,
+        range: `${sheetName}!${String.fromCharCode(65 + column)}${row + 1}`,
+        valueInputOption: 'RAW',
+        requestBody: {
+          values: [[value]],
+        },
+      }),
+    );
     if (response.status !== 200) {
       throw new Error(
         `Failed to update cell: ${response.status}. ${JSON.stringify(response.data)}`,
@@ -161,7 +195,9 @@ export class GoogleSpreadsheetRepository implements SpreadsheetRepository {
   ): Promise<boolean> => {
     const sheets = this.sheetsClient;
     const spreadsheetId = this.getSpreadsheetId(spreadsheetUrl);
-    const response = await sheets.spreadsheets.get({ spreadsheetId });
+    const response = await this.callWithRetry(() =>
+      sheets.spreadsheets.get({ spreadsheetId }),
+    );
     if (response.status !== 200) {
       throw new Error(
         `Failed to get sheet: ${response.status}. ${JSON.stringify(response.data)}`,
@@ -180,20 +216,22 @@ export class GoogleSpreadsheetRepository implements SpreadsheetRepository {
     if (await this.sheetExists(spreadsheetUrl, sheetName)) {
       return;
     }
-    const response = await sheets.spreadsheets.batchUpdate({
-      spreadsheetId,
-      requestBody: {
-        requests: [
-          {
-            addSheet: {
-              properties: {
-                title: sheetName,
+    const response = await this.callWithRetry(() =>
+      sheets.spreadsheets.batchUpdate({
+        spreadsheetId,
+        requestBody: {
+          requests: [
+            {
+              addSheet: {
+                properties: {
+                  title: sheetName,
+                },
               },
             },
-          },
-        ],
-      },
-    });
+          ],
+        },
+      }),
+    );
     if (response.status !== 200) {
       throw new Error(
         `Failed to create sheet: ${response.status}. ${JSON.stringify(response.data)}`,
@@ -211,14 +249,16 @@ export class GoogleSpreadsheetRepository implements SpreadsheetRepository {
     await this.createNewSheetIfNotExists(spreadsheetUrl, sheetName);
     const sheet = await this.getSheet(spreadsheetUrl, sheetName);
     const range = `${sheetName}!A${sheet ? sheet.length + 1 : 1}:A`;
-    const response = await sheets.spreadsheets.values.append({
-      spreadsheetId,
-      range: range,
-      valueInputOption: 'RAW',
-      requestBody: {
-        values,
-      },
-    });
+    const response = await this.callWithRetry(() =>
+      sheets.spreadsheets.values.append({
+        spreadsheetId,
+        range: range,
+        valueInputOption: 'RAW',
+        requestBody: {
+          values,
+        },
+      }),
+    );
     if (response.status !== 200) {
       throw new Error(
         `Failed to append values: ${response.status}. ${JSON.stringify(response.data)}`,

package/src/domain/usecases/CheckIssueReviewReadinessUseCase.ts

@@ -7,6 +7,7 @@ import {
 import { resolveLabelsNotRequiringPullRequest } from './resolveLabelsNotRequiringPullRequest';
 import { isPullRequestDeclaredUnnecessary } from './isPullRequestDeclaredUnnecessary';
 import { normalizeReportBody } from './normalizeReportBody';
+import { isAgentReportBody } from './isAgentReportBody';
 
 type RejectedReasonType =
   | 'ISSUE_NOT_FOUND'
@@ -72,7 +73,7 @@ export class CheckIssueReviewReadinessUseCase {
     if (
       !lastComment ||
       !isTrustedAuthor(lastComment.author) ||
-      !lastComment.content.startsWith('From: :robot:')
+      !isAgentReportBody(lastComment.content)
     ) {
       rejections.push({
         type: 'NO_REPORT_FROM_AGENT_BOT',

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

@@ -984,6 +984,56 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     );
   });
 
+  it('should end the dispatch loop when the dispatched agent reports with the prefix behind a leading fenced json block', async () => {
+    const issue = createMockIssue({
+      url: 'https://github.com/user/repo/issues/1',
+      status: 'Preparation',
+      agent: 'accounting',
+    });
+
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.get.mockResolvedValue(issue);
+    mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+      createMockComment({
+        content:
+          'From: :robot: triager\n```json\n{"nextStepAgent": "accounting", "nextStep": null}\n```',
+      }),
+      createMockComment({
+        content:
+          'Auto Status Check: RETURNED_TO_AWAITING_WORKSPACE\nThe report declared that this task needs no pull request.',
+      }),
+      createMockComment({
+        content:
+          '```json\n{ "pullRequestRequired": false, "nextStep": null }\n```\n\nFrom: :robot: accounting (model)\n\n## Result\nDone.',
+      }),
+    ]);
+    mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/users/user/projects/1',
+      issueUrl: 'https://github.com/user/repo/issues/1',
+      thresholdForAutoReject: 3,
+      workflowBlockerResolvedWebhookUrl: null,
+      allowedIssueAuthors: null,
+    });
+
+    expect(mockIssueRepository.update).toHaveBeenCalledWith(
+      expect.objectContaining({
+        status: 'Awaiting Quality Check',
+      }),
+      mockProject,
+    );
+    expect(mockIssueRepository.updateStatus).not.toHaveBeenCalledWith(
+      mockProject,
+      expect.anything(),
+      'awaiting-workspace-id',
+    );
+    expect(mockIssueCommentRepository.createComment).not.toHaveBeenCalledWith(
+      expect.anything(),
+      expect.stringContaining('Next step agent dispatch repeated: accounting'),
+    );
+  });
+
   it('should escalate to Failed Preparation when the declared nextStepAgent was already dispatched up to the threshold without a report', async () => {
     const issue = createMockIssue({
       url: 'https://github.com/user/repo/issues/1',

package/src/domain/usecases/NotifyFinishedIssuePreparationUseCase.ts

@@ -29,6 +29,7 @@ import { Project } from '../entities/Project';
 import { ensureAgentOptionAndGetId } from './ensureAgentOptionAndGetId';
 import { extractNextStepAgent } from './extractNextStepAgent';
 import { findLastAgentReport } from './findLastAgentReport';
+import { isAgentReportBody } from './isAgentReportBody';
 import {
   issueReactivationTriggerIsPending,
   issueReactivationTriggerStartOfTomorrow,
@@ -559,7 +560,7 @@ export class NotifyFinishedIssuePreparationUseCase {
     if (
       !lastComment ||
       !isTrustedAuthor(lastComment.author) ||
-      !lastComment.content.startsWith('From: :robot:')
+      !isAgentReportBody(lastComment.content)
     ) {
       rejections.push({
         type: 'NO_REPORT_FROM_AGENT_BOT',

package/src/domain/usecases/RevertOrphanedPreparationUseCase.ts

@@ -24,6 +24,7 @@ import {
 } from './returnedToAwaitingWorkspaceMessage';
 import { extractNextStepAgent } from './extractNextStepAgent';
 import { findLastAgentReport } from './findLastAgentReport';
+import { isAgentReportBody } from './isAgentReportBody';
 import { ensureAgentOptionAndGetId } from './ensureAgentOptionAndGetId';
 import { normalizeReportBody } from './normalizeReportBody';
 import { resolveNextStepAgentDispatchRepetition } from './resolveNextStepAgentDispatchRepetition';
@@ -334,7 +335,7 @@ export class RevertOrphanedPreparationUseCase {
     }
 
     const lastComment = comments[comments.length - 1];
-    if (!lastComment || !lastComment.content.startsWith('From: :robot:')) {
+    if (!lastComment || !isAgentReportBody(lastComment.content)) {
       return { outcome: 'reject', comments };
     }
     if (this.reportBodyHasNextStep(lastComment.content)) {

package/src/domain/usecases/TriagerApprovalDispatchUseCase.ts

@@ -1,7 +1,10 @@
 import { IssueCommentRepository } from './adapter-interfaces/IssueCommentRepository';
 import { IssueRepository } from './adapter-interfaces/IssueRepository';
 import { ProjectRepository } from './adapter-interfaces/ProjectRepository';
-import { AGENT_REPORT_PREFIX } from './agentReportPrefix';
+import {
+  isAgentReportBody,
+  isAgentReportBodyFromAgent,
+} from './isAgentReportBody';
 import { ensureAgentOptionAndGetId } from './ensureAgentOptionAndGetId';
 import { isAuthorAuthorizedForAutoStatusCheck } from './isAuthorAuthorizedForAutoStatusCheck';
 import { isRecord } from './isRecord';
@@ -23,9 +26,7 @@ type TriagerProposal = {
 const parseTriagerProposalBlock = (
   commentContent: string,
 ): TriagerProposal | null => {
-  if (
-    !commentContent.startsWith(`${AGENT_REPORT_PREFIX} ${TRIAGER_AGENT_NAME}`)
-  ) {
+  if (!isAgentReportBodyFromAgent(commentContent, TRIAGER_AGENT_NAME)) {
     return null;
   }
   const jsonBlockMatches = [
@@ -75,7 +76,7 @@ const isApprovalComment = (
   if (!isAuthorAuthorizedForAutoStatusCheck(author, allowedIssueAuthors)) {
     return false;
   }
-  if (content.startsWith(AGENT_REPORT_PREFIX)) {
+  if (isAgentReportBody(content)) {
     return false;
   }
   return /^(ok|オーケー|はい[\s\S]*)$/i.test(content.trim());

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

@@ -0,0 +1,40 @@
+import { extractFencedJsonBlocks } from './extractFencedJsonBlocks';
+
+describe('extractFencedJsonBlocks', () => {
+  it('returns every fenced json block in the order they appear', () => {
+    expect(
+      extractFencedJsonBlocks(
+        'From: :robot: agent (model)\n\n```json\n{ "pullRequestRequired": false }\n```\n\ntext\n\n```json\n{ "nextStepAgent": "developer" }\n```\n',
+        'test',
+      ),
+    ).toEqual([{ pullRequestRequired: false }, { nextStepAgent: 'developer' }]);
+  });
+
+  it('returns an empty list when the body carries no fenced json block', () => {
+    expect(extractFencedJsonBlocks('Please go ahead.', 'test')).toEqual([]);
+  });
+
+  it('skips an unparseable block, reports it, and still returns the parseable ones', () => {
+    const consoleWarn = jest.spyOn(console, 'warn').mockImplementation();
+    expect(
+      extractFencedJsonBlocks(
+        'From: :robot: agent (model)\n\n```json\n{ "broken": \n```\n\n```json\n{ "ok": true }\n```\n',
+        'test',
+      ),
+    ).toEqual([{ ok: true }]);
+    expect(consoleWarn).toHaveBeenCalledWith(
+      'Invalid JSON in report body while checking test:',
+      expect.anything(),
+    );
+    consoleWarn.mockRestore();
+  });
+
+  it('reads blocks whose code fence backticks are backslash escaped', () => {
+    expect(
+      extractFencedJsonBlocks(
+        'From: :robot: agent (model)\n\n\\`\\`\\`json\n{ "nextStepAgent": "developer" }\n\\`\\`\\`\n',
+        'test',
+      ),
+    ).toEqual([{ nextStepAgent: 'developer' }]);
+  });
+});

package/src/domain/usecases/extractFencedJsonBlocks.ts

@@ -0,0 +1,21 @@
+import { normalizeReportBody } from './normalizeReportBody';
+
+export const extractFencedJsonBlocks = (
+  body: string,
+  context: string,
+): unknown[] => {
+  const blocks: unknown[] = [];
+  for (const match of normalizeReportBody(body).matchAll(
+    /```json\n([\s\S]*?)\n```/g,
+  )) {
+    try {
+      blocks.push(JSON.parse(match[1]));
+    } catch (error) {
+      console.warn(
+        `Invalid JSON in report body while checking ${context}:`,
+        error,
+      );
+    }
+  }
+  return blocks;
+};

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

@@ -36,4 +36,23 @@ describe('extractNextStepAgent', () => {
   it('returns null when the body carries no fenced json block', () => {
     expect(extractNextStepAgent('Please go ahead with that.')).toBeNull();
   });
+
+  it('returns the declared agent when the routing block is not the first fenced json block', () => {
+    expect(
+      extractNextStepAgent(
+        'From: :robot: agent (model)\n\n```json\n{ "pullRequestRequired": false }\n```\n\n## review result\n\n```json\n{ "pullRequestRequired": false, "nextStepAgent": "systems-analyst" }\n```\n',
+      ),
+    ).toBe('systems-analyst');
+  });
+
+  it('returns the declared agent from a later block and reports the earlier unparseable block', () => {
+    const consoleWarn = jest.spyOn(console, 'warn').mockImplementation();
+    expect(
+      extractNextStepAgent(
+        'From: :robot: agent (model)\n\n```json\n{ "pullRequestRequired": false,\n```\n\n```json\n{ "nextStepAgent": "developer" }\n```\n',
+      ),
+    ).toBe('developer');
+    expect(consoleWarn).toHaveBeenCalled();
+    consoleWarn.mockRestore();
+  });
 });

package/src/domain/usecases/extractNextStepAgent.ts

@@ -1,30 +1,18 @@
-import { normalizeReportBody } from './normalizeReportBody';
+import { extractFencedJsonBlocks } from './extractFencedJsonBlocks';
+
 export const extractNextStepAgent = (body: string): string | null => {
-  const reportMatch = normalizeReportBody(body).match(
-    /```json\n([\s\S]*?)\n```/,
-  );
-  if (!reportMatch || reportMatch.length < 2) {
-    return null;
+  for (const block of extractFencedJsonBlocks(body, 'nextStepAgent')) {
+    if (typeof block !== 'object' || block === null) {
+      continue;
+    }
+    if (!('nextStepAgent' in block)) {
+      continue;
+    }
+    const value = Reflect.get(block, 'nextStepAgent');
+    if (typeof value !== 'string' || value.trim() === '') {
+      continue;
+    }
+    return value.trim();
   }
-  let reportJson: unknown;
-  try {
-    reportJson = JSON.parse(reportMatch[1]);
-  } catch (error) {
-    console.warn(
-      'Invalid JSON in report body while checking nextStepAgent:',
-      error,
-    );
-    return null;
-  }
-  if (typeof reportJson !== 'object' || reportJson === null) {
-    return null;
-  }
-  if (!('nextStepAgent' in reportJson)) {
-    return null;
-  }
-  const value = Reflect.get(reportJson, 'nextStepAgent');
-  if (typeof value !== 'string' || value.trim() === '') {
-    return null;
-  }
-  return value.trim();
+  return null;
 };

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

@@ -55,6 +55,34 @@ describe('findLastAgentReport', () => {
     ).toBe(withoutReportJson);
   });
 
+  it('returns the most recent agent report whose prefix follows a leading fenced json block', () => {
+    const fencedBeforePrefix =
+      '```json\n{ "pullRequestRequired": false }\n```\n\nFrom: :robot: agent (model)\n\n## Result\nDone.';
+    expect(
+      findLastAgentReport(
+        [
+          { author: 'bot', content: report('impl') },
+          { author: 'bot', content: fencedBeforePrefix },
+        ],
+        trustEveryAuthor,
+      )?.content,
+    ).toBe(fencedBeforePrefix);
+  });
+
+  it('skips a later comment whose only agent report prefix sits inside a fenced block', () => {
+    const prefixInsideFence =
+      '```\nFrom: :robot: agent (model)\n```\n\nQuoted for reference.';
+    expect(
+      findLastAgentReport(
+        [
+          { author: 'bot', content: report('impl') },
+          { author: 'bot', content: prefixInsideFence },
+        ],
+        trustEveryAuthor,
+      )?.content,
+    ).toBe(report('impl'));
+  });
+
   it('skips a later comment that does not carry the agent report prefix', () => {
     expect(
       findLastAgentReport(

package/src/domain/usecases/findLastAgentReport.ts

@@ -1,4 +1,4 @@
-import { AGENT_REPORT_PREFIX } from './agentReportPrefix';
+import { isAgentReportBody } from './isAgentReportBody';
 
 export const findLastAgentReport = <
   Comment extends { author: string; content: string },
@@ -10,6 +10,5 @@ export const findLastAgentReport = <
     .reverse()
     .find(
       (comment) =>
-        isTrustedAuthor(comment.author) &&
-        comment.content.startsWith(AGENT_REPORT_PREFIX),
+        isTrustedAuthor(comment.author) && isAgentReportBody(comment.content),
     ) ?? null;

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

@@ -0,0 +1,108 @@
+import {
+  isAgentReportBody,
+  isAgentReportBodyFromAgent,
+  stripLeadingFencedBlocks,
+} from './isAgentReportBody';
+
+describe('isAgentReportBody', () => {
+  it('accepts a body that opens with the report prefix', () => {
+    expect(isAgentReportBody('From: :robot: agent (model)\n\n## Result')).toBe(
+      true,
+    );
+  });
+
+  it('accepts a body whose report prefix follows a leading fenced json block', () => {
+    expect(
+      isAgentReportBody(
+        '```json\n{ "pullRequestRequired": false }\n```\n\nFrom: :robot: agent (model)\n\n## Result',
+      ),
+    ).toBe(true);
+  });
+
+  it('accepts a body whose report prefix follows two leading fenced blocks', () => {
+    expect(
+      isAgentReportBody(
+        '```json\n{ "pullRequestRequired": false }\n```\n~~~\nplain\n~~~\nFrom: :robot: agent (model)',
+      ),
+    ).toBe(true);
+  });
+
+  it('accepts a body whose leading fence carries a longer marker than three backticks', () => {
+    expect(
+      isAgentReportBody(
+        '````json\n```\n{ "pullRequestRequired": false }\n```\n````\nFrom: :robot: agent (model)',
+      ),
+    ).toBe(true);
+  });
+
+  it('accepts a body whose report prefix follows blank lines', () => {
+    expect(isAgentReportBody('\n\nFrom: :robot: agent (model)')).toBe(true);
+  });
+
+  it('accepts a body written with carriage returns and escaped backticks', () => {
+    expect(
+      isAgentReportBody(
+        '\\`\\`\\`json\r\n{ "pullRequestRequired": false }\r\n\\`\\`\\`\r\nFrom: :robot: agent (model)',
+      ),
+    ).toBe(true);
+  });
+
+  it('rejects a body whose only report prefix sits inside a fenced block', () => {
+    expect(
+      isAgentReportBody('```\nFrom: :robot: agent (model)\n```\n\nQuoted.'),
+    ).toBe(false);
+  });
+
+  it('rejects a body whose report prefix follows prose', () => {
+    expect(
+      isAgentReportBody('Note about the task.\n\nFrom: :robot: agent (model)'),
+    ).toBe(false);
+  });
+
+  it('rejects a body whose leading fence is never closed', () => {
+    expect(
+      isAgentReportBody(
+        '```json\n{ "pullRequestRequired": false }\nFrom: :robot: agent (model)',
+      ),
+    ).toBe(false);
+  });
+
+  it('rejects a body that carries no report prefix', () => {
+    expect(isAgentReportBody('Auto Status Check: RETURNED')).toBe(false);
+  });
+
+  it('rejects an empty body', () => {
+    expect(isAgentReportBody('')).toBe(false);
+  });
+});
+
+describe('isAgentReportBodyFromAgent', () => {
+  it('accepts a report from the named agent behind a leading fenced block', () => {
+    expect(
+      isAgentReportBodyFromAgent(
+        '```json\n{ "triagerProposal": {} }\n```\nFrom: :robot: triager (model)',
+        'triager',
+      ),
+    ).toBe(true);
+  });
+
+  it('rejects a report from another agent', () => {
+    expect(
+      isAgentReportBodyFromAgent('From: :robot: developer (model)', 'triager'),
+    ).toBe(false);
+  });
+});
+
+describe('stripLeadingFencedBlocks', () => {
+  it('keeps a body that opens with prose unchanged', () => {
+    expect(stripLeadingFencedBlocks('one\n```\ntwo\n```')).toBe(
+      'one\n```\ntwo\n```',
+    );
+  });
+
+  it('removes only the leading fenced blocks', () => {
+    expect(stripLeadingFencedBlocks('```\none\n```\nbody\n```\ntwo\n```')).toBe(
+      'body\n```\ntwo\n```',
+    );
+  });
+});