Add restart endpoint for system tests.

Author: jmgasper

docs/Marathon Match Setup and Management.md

@@ -285,22 +285,35 @@ Use this flow when the tester source changes after the challenge is active.
 3. Create the new version with the updated Java source.
 4. Wait until compilation reaches `SUCCESS`.
 5. Save the scorer config so the challenge points at the new tester ID.
-6. Trigger a rerun of latest submissions using the `Rerun scores` button on the UI.
-7. Monitor the rerun ECS tasks, runner logs, artifacts, and review scores.
+6. Trigger a rerun of latest submissions for the open Submission/Provisional phase using the Work app rerun control or `POST /v6/marathon-match/challenge/:challengeId/rerun`.
+7. If Review/System scores also need to be regenerated, call `POST /v6/marathon-match/challenge/:challengeId/rerun/system`.
+8. Monitor the rerun ECS tasks, runner logs, artifacts, and review scores.
 
 
-Rerun behavior:
+Submission/Provisional rerun behavior:
 
 - Requires the challenge to be `ACTIVE`.
 - Requires at least one open challenge phase.
 - Requires the scorer config to be active.
 - Requires the selected tester to be compiled successfully.
-- Requires a `PROVISIONAL` phase config.
+- Requires a phase config that matches the currently open challenge phase.
 - Fetches `isLatest=true` submissions from Submission API.
 - Queues one ECS task for the latest submission per member.
-- Uses the current `PROVISIONAL` seeds and test count.
+- Uses the current open phase's scorer seeds and test count. During Submission this is normally the `PROVISIONAL` config.
 
-The response includes the queued submission IDs and ECS task IDs or per-submission errors. Because the standard rerun endpoint is provisional-oriented, coordinate separately if a late tester change also needs Review/System scores regenerated.
+The response includes the queued submission IDs and ECS task IDs or per-submission errors.
+
+System rerun behavior:
+
+- Requires the challenge to be `ACTIVE`.
+- Requires the scorer config to be active.
+- Requires the selected tester to be compiled successfully.
+- Requires a `SYSTEM` phase config.
+- Fetches existing non-cancelled Review API reviews for the challenge that match the configured Marathon Match review scorecard.
+- Queues one SYSTEM scorer task per matching review and passes the existing `reviewId` to the runner.
+- Uses the current `SYSTEM` seeds, test count, per-test timeout, and `systemTestTimeout`.
+
+Use the SYSTEM rerun endpoint after lowering timings or changing a tester while Review is open. It restarts the existing review records instead of creating duplicate reviews.
 
 ## Monitoring Submissions
 

docs/marathon-match-setup.md

@@ -160,7 +160,13 @@ To switch an active challenge to a newer tester:
 3. Update the challenge config with `PUT /v6/marathon-match/challenge/:challengeId` and the new `testerId`
 4. Trigger a rescore of current competitors with `POST /v6/marathon-match/challenge/:challengeId/rerun`
 
-The rerun endpoint selects `isLatest` submissions for the challenge in received order and launches ECS scorer tasks for them in parallel. This does not happen automatically when `testerId` changes, so the rerun call is the operational step that recalculates scores.
+The standard rerun endpoint selects `isLatest` submissions for the challenge in received order and launches ECS scorer tasks for them in parallel using the scorer config for the currently open challenge phase. This does not happen automatically when `testerId` changes, so the rerun call is the operational step that recalculates Submission/Provisional scores.
+
+To restart Review/System tests, call:
+
+`POST /v6/marathon-match/challenge/:challengeId/rerun/system`
+
+The SYSTEM rerun endpoint reuses existing non-cancelled Review API review records that match the challenge's configured Marathon Match scorecard and dispatches each one through SYSTEM scoring with its existing `reviewId`.
 
 Reruns can be requested by admins, M2M tokens with `update:marathon-match`, or the `Copilot` resource assigned to the challenge.
 

docs/marathon-processor-specification-and-scoring-terminology.md

@@ -110,6 +110,7 @@ Compile and test timeouts are configured per Marathon Match challenge.
   initializer checks performed after `javac`.
 - `testTimeout` controls per-seed tester execution timeout.
 - `systemTestTimeout` controls the total SYSTEM scoring timeout per submission. It defaults to 24 hours and causes the API to stop a still-active ECS runner and write a failed SYSTEM summation with `metadata.timed_out = true`.
+- `POST /v6/marathon-match/challenge/:challengeId/rerun/system` restarts existing non-cancelled SYSTEM reviews with the current `testTimeout`, `systemTestTimeout`, SYSTEM seed, and SYSTEM test count settings.
 
 The default values supplied by `marathon-match-api-v6` are environment-configurable. If not overridden in service configuration, the API defaults are:
 

docs/review-phase-scoring.md

@@ -10,6 +10,8 @@ When the Review phase opens for a Marathon Match challenge, `autopilot-v6` route
 
 Manual phase changes are supported through the same path. If Review is opened directly in challenge-api, autopilot's challenge-update handling replays the phase-open work; startup recovery also replays already-open Review phases so missed update events still create and dispatch SYSTEM reviews.
 
+Existing SYSTEM reviews can be restarted through `POST /v6/marathon-match/challenge/:challengeId/rerun/system`. This endpoint is intended for operator reruns after lowering timing settings or changing the tester while Review is open. It finds non-cancelled Review API reviews matching the challenge's configured Marathon Match scorecard, then dispatches SYSTEM scorer tasks with each existing `reviewId`.
+
 ## Flow
 
 ```mermaid

docs/submission-phase-scoring.md

@@ -118,6 +118,12 @@ Use:
 
 `POST /v6/marathon-match/challenge/:challengeId/rerun`
 
-This endpoint selects the latest submission for each member in received order and launches ECS scorer tasks in parallel using the challenge's `PROVISIONAL` phase config. Use it after changing the tester or when current latest submissions need to be rescored without waiting for new submission events.
+This endpoint selects the latest submission for each member in received order and launches ECS scorer tasks in parallel using the scorer config that matches the currently open challenge phase. During Submission this is normally the challenge's `PROVISIONAL` phase config. Use it after changing the tester or when current latest submissions need to be rescored without waiting for new submission events.
+
+For Review/System scoring reruns, use:
+
+`POST /v6/marathon-match/challenge/:challengeId/rerun/system`
+
+The SYSTEM rerun endpoint restarts existing non-cancelled Review API reviews that match the challenge's configured Marathon Match review scorecard and passes each existing `reviewId` into the SYSTEM scorer.
 
 Rerun access is limited to admins, M2M tokens with `update:marathon-match`, and the `Copilot` resource assigned to the challenge.

src/api/marathon-match-config/marathon-match-config.controller.ts

@@ -30,6 +30,7 @@ import {
   MarathonMatchDefaultsResponseDto,
   RerunResponseDto,
   SearchMarathonMatchConfigQueryDto,
+  SystemRerunResponseDto,
   UpdateMarathonMatchConfigDto,
 } from 'src/dto/marathon-match-config.dto';
 import { PaginationHeaderInterceptor } from 'src/interceptors/PaginationHeaderInterceptor';
@@ -148,6 +149,50 @@ export class MarathonMatchConfigController {
     );
   }
 
+  /**
+   * Reruns existing SYSTEM review tests for a marathon match configuration.
+   * @param challengeId Challenge ID.
+   * @param user Authenticated user for audit context.
+   * @returns Accepted SYSTEM rerun dispatch summary.
+   */
+  @Post('/:challengeId/rerun/system')
+  @Roles(UserRole.Admin, UserRole.Copilot, UserRole.User)
+  @Scopes(Scope.UpdateMarathonMatch)
+  @UseGuards(ChallengeCopilotResourceGuard)
+  @ApiOperation({
+    summary: 'Rerun existing SYSTEM tests for a Marathon Match challenge',
+    description:
+      'Roles: Admin or challenge Copilot resource | Scopes: update:marathon-match',
+  })
+  @ApiParam({
+    name: 'challengeId',
+    description: 'The challenge ID for the marathon match SYSTEM rerun request',
+    example: '30000123',
+  })
+  @HttpCode(HttpStatus.ACCEPTED)
+  @ApiResponse({
+    status: 202,
+    description:
+      'Existing SYSTEM reviews queued for asynchronous rerun dispatch.',
+    type: SystemRerunResponseDto,
+  })
+  @ApiResponse({
+    status: 400,
+    description:
+      'Challenge/config inactive, tester is not compiled successfully, or SYSTEM phase config is missing.',
+  })
+  @ApiResponse({ status: 403, description: 'Forbidden.' })
+  @ApiResponse({ status: 404, description: 'Marathon match config not found.' })
+  async rerunSystemTests(
+    @Param('challengeId') challengeId: string,
+    @User() user: JwtUser,
+  ): Promise<SystemRerunResponseDto> {
+    return await this.marathonMatchConfigService.rerunSystemTests(
+      challengeId,
+      user,
+    );
+  }
+
   /**
    * Lists marathon match configurations with optional filters and pagination.
    * @param query Search and pagination query parameters.

src/api/marathon-match-config/marathon-match-config.service.spec.ts

@@ -52,6 +52,9 @@ describe('MarathonMatchConfigService', () => {
     const prismaErrorService = {
       handleError: jest.fn(),
     };
+    const scoringResultService = {
+      triggerSystemScore: jest.fn(),
+    };
 
     jest.spyOn(LoggerService, 'forRoot').mockReturnValue(mockLogger as never);
 
@@ -61,6 +64,7 @@ describe('MarathonMatchConfigService', () => {
       m2mService as never,
       prisma as never,
       prismaErrorService as never,
+      scoringResultService as never,
     );
 
     return {
@@ -70,6 +74,7 @@ describe('MarathonMatchConfigService', () => {
       m2mService,
       prisma,
       prismaErrorService,
+      scoringResultService,
     };
   };
 
@@ -597,6 +602,146 @@ describe('MarathonMatchConfigService', () => {
     expect(ecsService.launchScorerTask).not.toHaveBeenCalled();
   });
 
+  it('reruns all matching existing system reviews', async () => {
+    const { service, httpService, m2mService, prisma, scoringResultService } =
+      createService();
+    const user = {
+      isMachine: false,
+      userId: '40051399',
+    } as never;
+
+    prisma.marathonMatchConfig.findUnique.mockResolvedValue({
+      id: 'config-1',
+      challengeId: '30000123',
+      active: true,
+      reviewScorecardId: 'legacy-scorecard-1',
+      testerId: 'tester-1',
+      tester: {
+        compilationStatus: CompilationStatus.SUCCESS,
+      },
+      phaseConfigs: [
+        {
+          id: 'phase-system',
+          configType: PhaseConfigType.SYSTEM,
+          phaseId: 'system-phase',
+          startSeed: BigInt(1000),
+          numberOfTests: 5000,
+        },
+      ],
+    });
+    m2mService.getM2MToken.mockResolvedValue('m2m-token');
+    httpService.get
+      .mockReturnValueOnce(
+        of({
+          data: {
+            status: 'ACTIVE',
+          },
+        }),
+      )
+      .mockReturnValueOnce(
+        of({
+          data: {
+            id: 'canonical-scorecard-1',
+          },
+        }),
+      )
+      .mockReturnValueOnce(
+        of({
+          data: {
+            result: {
+              content: [
+                {
+                  id: 'review-2',
+                  submissionId: 'submission-2',
+                  scorecardId: 'canonical-scorecard-1',
+                  status: 'COMPLETED',
+                },
+                {
+                  id: 'review-1',
+                  submissionId: 'submission-1',
+                  scoreCardId: 'legacy-scorecard-1',
+                  status: 'IN_PROGRESS',
+                },
+                {
+                  id: 'review-cancelled',
+                  submissionId: 'submission-cancelled',
+                  scorecardId: 'canonical-scorecard-1',
+                  status: 'CANCELLED',
+                },
+                {
+                  id: 'review-other',
+                  submissionId: 'submission-other',
+                  scorecardId: 'scorecard-other',
+                  status: 'PENDING',
+                },
+              ],
+            },
+          },
+          headers: {
+            'x-total-pages': '1',
+          },
+        }),
+      );
+    scoringResultService.triggerSystemScore
+      .mockResolvedValueOnce({
+        taskArn: 'arn:aws:ecs:task/task-1',
+        taskId: 'task-1',
+      })
+      .mockResolvedValueOnce({
+        taskArn: 'arn:aws:ecs:task/task-2',
+        taskId: 'task-2',
+      });
+
+    const result = await service.rerunSystemTests('30000123', user);
+
+    expect(result).toEqual({
+      challengeId: '30000123',
+      reviewsQueued: 2,
+      results: [
+        {
+          reviewId: 'review-1',
+          submissionId: 'submission-1',
+          taskArn: 'arn:aws:ecs:task/task-1',
+          taskId: 'task-1',
+        },
+        {
+          reviewId: 'review-2',
+          submissionId: 'submission-2',
+          taskArn: 'arn:aws:ecs:task/task-2',
+          taskId: 'task-2',
+        },
+      ],
+    });
+    expect(scoringResultService.triggerSystemScore).toHaveBeenCalledTimes(2);
+    expect(scoringResultService.triggerSystemScore).toHaveBeenNthCalledWith(
+      1,
+      'review-1',
+      'submission-1',
+      '30000123',
+    );
+    expect(scoringResultService.triggerSystemScore).toHaveBeenNthCalledWith(
+      2,
+      'review-2',
+      'submission-2',
+      '30000123',
+    );
+    expect(httpService.get).toHaveBeenNthCalledWith(
+      3,
+      'https://api.topcoder-dev.com/v6/reviews',
+      {
+        headers: {
+          Authorization: 'Bearer m2m-token',
+        },
+        params: {
+          challengeId: '30000123',
+          page: 1,
+          perPage: 100,
+          thin: 'true',
+        },
+      },
+    );
+  });
+
   it('normalizes large startSeed strings to BigInt when creating phase configs', async () => {
     const { service, httpService, m2mService, prisma } = createService();
     const maxRangeStartSeed = '9223372036854775800';