PM-5231: Allow validation uploads to queue by phase

What was broken
Uploading a second Marathon Match validation submission for another phase while a prior validation task was still active returned HTTP 500 from the Work app flow.

Root cause
The shared ECS launcher always attempted to stop older active tasks for the same challenge and member before launching a new task. PM-5231 validation uploads reuse the manager/copilot member id for each phase, so a phase-by-phase validation upload tried to stop the previous phase's active validation task before queueing the next one.

What was changed
Added a launch option to skip superseded member task cancellation. The validation-upload endpoint now uses that option so Example, Provisional, and System validation runs can be queued independently while existing rerun/submission scoring keeps the original cancellation behavior.

Any added/updated tests
Added ECS service coverage for disabled superseded-task stopping and updated validation-upload service coverage to assert the non-cancelling launch mode.

Author: jmgasper

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

@@ -812,6 +812,7 @@ describe('MarathonMatchConfigService', () => {
       undefined,
       {
         memberId: '40051399',
+        stopSupersededMemberTasks: false,
       },
     );
   });

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

@@ -1368,6 +1368,7 @@ export class MarathonMatchConfigService {
         undefined,
         {
           memberId,
+          stopSupersededMemberTasks: false,
         },
       );
 

src/shared/modules/global/ecs.service.spec.ts

@@ -264,6 +264,69 @@ describe('EcsService', () => {
     );
   });
 
+  it('keeps older active tasks when superseded task stopping is disabled', async () => {
+    const { service, send } = createService();
+    send.mockImplementation((command) => {
+      if (command instanceof ListTasksCommand) {
+        return Promise.resolve(
+          command.input.desiredStatus === 'RUNNING'
+            ? {
+                taskArns: [
+                  'arn:aws:ecs:us-east-1:123456789012:task/cluster/old-task',
+                ],
+              }
+            : { taskArns: [] },
+        );
+      }
+      if (command instanceof DescribeTasksCommand) {
+        return Promise.resolve({
+          tasks: [
+            activeTask({
+              taskArn:
+                'arn:aws:ecs:us-east-1:123456789012:task/cluster/old-task',
+              submissionId: 'old-submission',
+            }),
+          ],
+        });
+      }
+      if (command instanceof RunTaskCommand) {
+        return Promise.resolve({
+          tasks: [
+            {
+              taskArn:
+                'arn:aws:ecs:us-east-1:123456789012:task/cluster/new-task',
+            },
+          ],
+        });
+      }
+      if (command instanceof DescribeTaskDefinitionCommand) {
+        return Promise.resolve({ taskDefinition: {} });
+      }
+
+      throw new Error(`Unexpected command ${command.constructor.name}`);
+    });
+
+    await service.launchScorerTask(
+      'challenge-1',
+      'new-submission',
+      baseTaskConfig,
+      basePhaseConfig,
+      undefined,
+      {
+        memberId: 'member-1',
+        stopSupersededMemberTasks: false,
+      },
+    );
+
+    const sentCommands = send.mock.calls.map((call) => call[0] as unknown);
+    expect(
+      sentCommands.some((command) => command instanceof StopTaskCommand),
+    ).toBe(false);
+    expect(
+      sentCommands.some((command) => command instanceof RunTaskCommand),
+    ).toBe(true);
+  });
+
   it('blocks new launches when the global scorer task cap is reached', async () => {
     process.env.ECS_SCORER_MAX_CONCURRENT_TASKS = '1';
     const { service, m2mService, send } = createService();

src/shared/modules/global/ecs.service.ts

@@ -39,6 +39,7 @@ export interface MarathonMatchScorerTaskLaunchResult {
 
 export interface MarathonMatchScorerTaskLaunchOptions {
   memberId?: string;
+  stopSupersededMemberTasks?: boolean;
 }
 
 interface ActiveScorerTask {
@@ -89,7 +90,7 @@ export class EcsService {
    * @param mmConfig Task definition name and version from the marathonMatchConfig record.
    * @param scoringPhase Active phase settings used by the runner for flags and seed range.
    * @param reviewId Optional review-api review id that should be marked completed after callback processing.
-   * @param launchOptions Optional submission owner metadata used for per-member in-flight task cancellation.
+   * @param launchOptions Optional submission owner metadata and cancellation controls for in-flight member tasks.
    * @returns ECS task launch details with task/log mapping metadata.
    * Required env vars: ECS_CLUSTER, ECS_CONTAINER_NAME, ECS_SUBNETS, ECS_SECURITY_GROUPS,
    * AWS_REGION, MARATHON_MATCH_API_URL, REVIEW_TYPE_ID, and Auth0 M2M settings
@@ -117,6 +118,8 @@ export class EcsService {
     const taskDefinitionVersion = mmConfig.taskDefinitionVersion?.trim();
     const testPhase = this.mapConfigTypeToTestPhase(scoringPhase.configType);
     const memberId = launchOptions.memberId?.trim();
+    const shouldStopSupersededMemberTasks =
+      launchOptions.stopSupersededMemberTasks !== false;
 
     if (!taskDefinitionName) {
       throw new Error('Missing required task definition name in mmConfig.');
@@ -136,11 +139,13 @@ export class EcsService {
           containerName,
         );
         const launchableActiveTasks = activeTasks
-          ? await this.stopSupersededMemberScorerTasks(cluster, activeTasks, {
-              challengeId,
-              submissionId,
-              memberId,
-            })
+          ? shouldStopSupersededMemberTasks
+            ? await this.stopSupersededMemberScorerTasks(cluster, activeTasks, {
+                challengeId,
+                submissionId,
+                memberId,
+              })
+            : activeTasks
           : null;
         let maxConcurrentScorerTasks: number | null = null;