Fix for work app MM tester flow

Author: jmgasper

ECS_RUNNER_LIFETIME.md

@@ -41,7 +41,7 @@ This is the normal path for `EXAMPLE` and `PROVISIONAL` scoring during the Submi
 
 ### Validation submission scoring
 
-`POST /v6/marathon-match/challenge/:challengeId/test-submission` stores the uploaded ZIP as an isolated Marathon Match validation run, then launches one ECS runner for the requested `configType` (default `PROVISIONAL`). The runner downloads the ZIP from Marathon Match API using `VALIDATION_SUBMISSION_DOWNLOAD_URL`, includes `VALIDATION_RUN_ID` in progress/final callbacks, skips Submission API artifact uploads, and `ScoringResultService` stores progress/final score details on the validation run instead of creating Review API summations. The response includes `testSubmissionId`, `submissionId` (same validation-run id for runner compatibility), `status`, `taskArn`, `taskId`, and usually `cloudWatchLogsConsoleUrl`.
+`POST /v6/marathon-match/challenge/:challengeId/test-submission` stores the uploaded ZIP as an isolated Marathon Match validation run, then launches one ECS runner for the requested `configType` (default `PROVISIONAL`). The runner downloads the ZIP from Marathon Match API using `VALIDATION_SUBMISSION_DOWNLOAD_URL`, which is resolved against the normalized `/v6/marathon-match` API base, includes `VALIDATION_RUN_ID` in progress/final callbacks, skips Submission API artifact uploads, and `ScoringResultService` stores progress/final score details on the validation run instead of creating Review API summations. The response includes `testSubmissionId`, `submissionId` (same validation-run id for runner compatibility), `status`, `taskArn`, `taskId`, and usually `cloudWatchLogsConsoleUrl`.
 
 Use `GET /v6/marathon-match/challenge/:challengeId/test-submission/:testSubmissionId` to poll for completion and display the score/metadata. We do this to support admins / copilots having the ability to test the scorer before the challenge launches without adding a real submission or review to the challenge.
 

docs/submission-phase-scoring.md

@@ -101,7 +101,7 @@ Runner task logs are written to CloudWatch using the submission runner log strea
 
 For `PROVISIONAL` and `SYSTEM` scoring, the runner writes progress to the phase review summation metadata through `POST /v6/marathon-match/internal/scoring-progress`. Review API exposes this as `reviewSummation.metadata.testProcess` (`provisional` or `system`), `reviewSummation.metadata.testProgress` (`0` to `1`), and `reviewSummation.metadata.testStatus` (`IN PROGRESS`, `SUCCESS`, or `FAILED`) when metadata is included in the response. In-progress summations keep a neutral placeholder score and must be rendered as unavailable based on `testStatus`; only `FAILED` progress uses the failed-score sentinel. SYSTEM timeout failures also include `reviewSummation.metadata.timed_out = true`.
 
-For generic runner artifacts, only EXAMPLE scoring uploads the member-visible public artifact. Its public `output.txt` includes each testcase ordinal, actual seed, seed score, runtime, runner/tester errors, and submitted-solution stderr, while submitted-solution stdout stays private. Every generic scoring phase uploads private internal artifacts: per-test score details remain in `reviews.json` with testcase ordinals and actual seeds, callback metadata keeps member-visible testcase ordinals only, compile and execution logs are preserved as `compile_log.txt`, `execution-{submissionId}.log`, and optional `error-{submissionId}.log`, and captured submitted-solution output is split into `stdout/{seed}.txt` and `stderr/{seed}.txt` files for each actual seed. PROVISIONAL and SYSTEM scoring do not publish competitor-visible artifacts.
+For generic runner artifacts, only EXAMPLE scoring uploads the member-visible public artifact. Its public `output.txt` starts with the captured compilation output, then includes each testcase ordinal, actual seed, seed score, runtime, runner/tester errors, and submitted-solution stderr, while submitted-solution stdout stays private. Every generic scoring phase uploads private internal artifacts: `reviews.json` includes `compilationOutput`, per-test score details with testcase ordinals and actual seeds, and top-level `testScores`; callback metadata keeps member-visible testcase ordinals only, compile and execution logs are preserved as `compile_log.txt`, `execution-{submissionId}.log`, and optional `error-{submissionId}.log`, and captured submitted-solution output is split into `stdout/{seed}.txt` and `stderr/{seed}.txt` files for each actual seed. PROVISIONAL and SYSTEM scoring do not publish competitor-visible artifacts.
 
 When more than one phase config matches the currently open challenge phases, the handler launches one scorer task per match. This is the supported way to run both `EXAMPLE` and `PROVISIONAL` scoring from the same Submission phase.
 

ecs-runner/README.md

@@ -142,7 +142,7 @@ Once this is saved and the config is active, new scoring launches use the new EC
 
 The runner rejects output once generated public `output.txt` content or a public/private artifact archive would exceed `MM_RUNNER_MAX_OUTPUT_BYTES`. The default is `10000000` bytes. The trusted parent runner passes the resolved limit into the isolated tester child, so generated generic-runner output and uploaded artifact zips use the same cap.
 
-Generic runner member-visible artifacts are uploaded only for EXAMPLE scoring. Their public `output.txt` entries show testcase ordinal, actual seed, seed score, runtime, runner/tester errors, and submitted-solution stderr, while intentionally omitting submitted-solution stdout. Every generic scoring phase uploads private internal artifacts in the `*-internal` zip: `reviews.json` carries per-test `metadata.testScores` and top-level `testScores` with testcase ordinals and actual seeds, `compile_log.txt` and `execution-{submissionId}.log` preserve runner diagnostics, `error-{submissionId}.log` is included when present, and `stdout/{seed}.txt` plus `stderr/{seed}.txt` carry captured submitted-solution output for each actual seed. PROVISIONAL and SYSTEM scoring do not publish competitor-visible artifacts.
+Generic runner member-visible artifacts are uploaded only for EXAMPLE scoring. Their public `output.txt` starts with the captured compilation output, then shows testcase ordinal, actual seed, seed score, runtime, runner/tester errors, and submitted-solution stderr, while intentionally omitting submitted-solution stdout. Every generic scoring phase uploads private internal artifacts in the `*-internal` zip: `reviews.json` carries `compilationOutput`, per-test `metadata.testScores`, and top-level `testScores` with testcase ordinals and actual seeds, `compile_log.txt` and `execution-{submissionId}.log` preserve runner diagnostics, `error-{submissionId}.log` is included when present, and `stdout/{seed}.txt` plus `stderr/{seed}.txt` carry captured submitted-solution output for each actual seed. PROVISIONAL and SYSTEM scoring do not publish competitor-visible artifacts.
 
 ## Local smoke test
 

ecs-runner/src/main/java/com/topcoder/runner/EcsRunnerMain.java

@@ -105,6 +105,7 @@ public class EcsRunnerMain {
     private static final int DEFAULT_TEST_TIMEOUT_MS = 10000;
     private static final int DEFAULT_COMPILE_TIMEOUT_MS = 30000;
     private static final String GENERIC_SOLUTION_BASE_NAME = "Solution";
+    private static final String COMPILATION_OUTPUT_METADATA_KEY = "compilationOutput";
     private static final String JAVA_SUBMISSION_RELEASE = "11";
     private static final String CXX_MARCH_FLAG = "-march=x86-64";
     private static final String CXX_MTUNE_FLAG = "-mtune=generic";
@@ -2816,8 +2817,9 @@ private static Map<String, Object> buildCallbackMetadata(
     }
 
     /**
-     * Removes configured seed values from metadata that may be persisted or rendered to members.
-     * Per-test entries keep a stable 1-based testcase ordinal so relative scoring still works.
+     * Removes configured seed values and verbose compile output from metadata that may be
+     * persisted or rendered through scoring callbacks. Per-test entries keep a stable 1-based
+     * testcase ordinal so relative scoring still works.
      *
      * @param metadata Metadata returned by tester execution.
      * @return Copy with seed-bearing fields removed or replaced, or {@code null}.
@@ -2836,6 +2838,9 @@ private static Map<String, Object> sanitizeMemberVisibleMetadata(
             if (isSensitiveSeedMetadataKey(key)) {
                 continue;
             }
+            if (COMPILATION_OUTPUT_METADATA_KEY.equals(key)) {
+                continue;
+            }
 
             Object value = entry.getValue();
             if ("testScores".equals(key) && value instanceof List) {
@@ -3203,7 +3208,8 @@ private static void writeSeedOutputArtifact(
     /**
      * Builds the JSON payload stored in the internal {@code reviews.json} artifact.
      * The payload includes sanitized top-level {@code testScores} so private
-     * consumers can inspect per-test scores for every scoring phase.
+     * consumers can inspect per-test scores for every scoring phase. Generic runner
+     * payloads also carry compiler diagnostics in {@code compilationOutput}.
      *
      * @param submissionId Submission whose review payload is archived.
      * @param testPhase Scoring phase represented by the payload.
@@ -3224,6 +3230,7 @@ private static Map<String, Object> buildInternalReviewArtifactPayload(
         Map<String, Object> internalMetadata = buildInternalArtifactMetadata(
             testerExecution.getMetadata()
         );
+        String compilationOutput = getCompilationOutputFromMetadata(internalMetadata);
         Map<String, Object> currentReview = withDefaultReviewFields(
             testerExecution.getCurrentReview(),
             submissionId,
@@ -3250,6 +3257,9 @@ private static Map<String, Object> buildInternalReviewArtifactPayload(
         payload.put("scorecardId", scorecardId);
         payload.put("score", testerExecution.getScore());
         payload.put("metadata", internalMetadata);
+        if (compilationOutput != null) {
+            payload.put(COMPILATION_OUTPUT_METADATA_KEY, compilationOutput);
+        }
         payload.put(
             "testScores",
             buildInternalArtifactScoreEntries(testerExecution.getMetadata())
@@ -3260,6 +3270,21 @@ private static Map<String, Object> buildInternalReviewArtifactPayload(
         return payload;
     }
 
+    /**
+     * Reads generic-runner compilation output from metadata for top-level private artifacts.
+     *
+     * @param metadata Internal artifact metadata, usually copied from tester execution metadata.
+     * @return Compilation output text, or {@code null} when none was produced.
+     */
+    private static String getCompilationOutputFromMetadata(Map<String, Object> metadata) {
+        if (metadata == null) {
+            return null;
+        }
+
+        Object compilationOutput = metadata.get(COMPILATION_OUTPUT_METADATA_KEY);
+        return compilationOutput instanceof String ? (String) compilationOutput : null;
+    }
+
     /**
      * Builds private review artifact metadata from raw tester execution metadata.
      *
@@ -4531,8 +4556,9 @@ private static Object invokeCustomRunTester(
      * Runs a standard Topcoder Marathon tester without requiring tester-specific ECS code.
      *
      * <p>The method creates artifact directories, selects a supported submission source file,
-     * compiles it when needed, runs the configured tester for every seed in the phase range, and
-     * returns the aggregate score plus per-test metadata used by relative scoring.
+     * compiles it when needed, writes compilation diagnostics to artifacts, runs the configured
+     * tester for every seed in the phase range, and returns the aggregate score plus per-test
+     * metadata used by relative scoring and internal diagnostics.
      *
      * @param testerClassName Fully qualified Marathon tester class name.
      * @param submissionPath Extracted submission directory.
@@ -4613,6 +4639,7 @@ private static TesterExecutionResult runGenericMarathonTester(
         Path compileWorkDir = Files.createTempDirectory("mm-submission-solution-");
         boolean cleanupDeferred = deferIsolatedChildCleanup(compileWorkDir);
         Path compileLogPath = artifactsPublicDir.resolve("compile_log.txt");
+        Path outputPath = artifactsPublicDir.resolve("output.txt");
 
         try {
             CompiledSubmission compiledSubmission = compileAndBuildExecutionCommand(
@@ -4622,14 +4649,20 @@ private static TesterExecutionResult runGenericMarathonTester(
                 expectedSolutionBaseName,
                 compileLogPath
             );
+            String compilationOutput = readCompilationOutput(compileLogPath);
+            StringBuilder outputText = new StringBuilder();
+            long outputBytes = appendLimitedOutput(
+                outputText,
+                buildMemberVisibleCompilationOutput(compilationOutput),
+                0L,
+                "artifacts/public/output.txt"
+            );
             grantScorerReadExecuteAccess(compileWorkDir);
 
             MarathonController controller = new MarathonController();
             List<Map<String, Object>> testScores = new ArrayList<Map<String, Object>>();
             double totalScore = 0.0;
             int failedTests = 0;
-            StringBuilder outputText = new StringBuilder();
-            long outputBytes = 0L;
 
             long endSeed = startSeed + numberOfTests - 1L;
             for (long seed = startSeed; seed <= endSeed; seed++) {
@@ -4717,7 +4750,7 @@ private static TesterExecutionResult runGenericMarathonTester(
             }
 
             try (BufferedWriter writer = Files.newBufferedWriter(
-                artifactsPublicDir.resolve("output.txt"),
+                outputPath,
                 StandardCharsets.UTF_8
             )) {
                 writer.write(outputText.toString());
@@ -4731,6 +4764,7 @@ private static TesterExecutionResult runGenericMarathonTester(
             metadata.put("numberOfTests", numberOfTests);
             metadata.put("timeLimitMs", timeLimitMs);
             metadata.put("compileTimeoutMs", compileTimeoutMs);
+            metadata.put(COMPILATION_OUTPUT_METADATA_KEY, compilationOutput);
             metadata.put("aggregateMode", "average");
             metadata.put("testScores", testScores);
 
@@ -4745,13 +4779,100 @@ private static TesterExecutionResult runGenericMarathonTester(
                 currentReview,
                 new ArrayList<Map<String, Object>>()
             );
+        } catch (Exception error) {
+            writePreResultMemberOutput(outputPath, compileLogPath, error);
+            throw error;
         } finally {
             if (!cleanupDeferred) {
                 deletePathRecursively(compileWorkDir);
             }
         }
     }
 
+    /**
+     * Reads the compiler log that should be embedded in member-visible and private outputs.
+     *
+     * @param compileLogPath Public compile log written by compiler commands.
+     * @return Compiler output text, or a short no-output marker when no compiler command ran.
+     * @throws IOException When an existing compile log cannot be read safely.
+     */
+    private static String readCompilationOutput(Path compileLogPath) throws IOException {
+        if (!isNonSymlinkRegularFile(compileLogPath)) {
+            return "No compilation step was run for this submission.";
+        }
+
+        String compilationOutput = new String(
+            readRegularFileBytesNoFollow(compileLogPath),
+            StandardCharsets.UTF_8
+        ).trim();
+        if (compilationOutput.isEmpty()) {
+            return "Compilation completed without output.";
+        }
+        return compilationOutput;
+    }
+
+    /**
+     * Builds the public {@code output.txt} compilation section shown before test cases.
+     *
+     * @param compilationOutput Compiler diagnostics captured for the submission.
+     * @return Member-visible compilation text block ending with a blank line.
+     */
+    private static String buildMemberVisibleCompilationOutput(
+        String compilationOutput
+    ) {
+        StringBuilder outputText = new StringBuilder();
+        outputText.append("Compilation Output:\n");
+        if (compilationOutput == null || compilationOutput.trim().isEmpty()) {
+            outputText.append("No compilation output was produced.");
+        } else {
+            outputText.append(compilationOutput.trim());
+        }
+        outputText.append("\n\n");
+        return outputText.toString();
+    }
+
+    /**
+     * Writes a partial member-visible output file when the generic runner fails
+     * before normal score output can be finalized.
+     *
+     * @param outputPath Public {@code output.txt} artifact path.
+     * @param compileLogPath Public compile log path to embed.
+     * @param error Failure that prevented normal output generation.
+     */
+    private static void writePreResultMemberOutput(
+        Path outputPath,
+        Path compileLogPath,
+        Throwable error
+    ) {
+        if (outputPath == null || isNonSymlinkRegularFile(outputPath)) {
+            return;
+        }
+
+        try {
+            StringBuilder outputText = new StringBuilder();
+            long outputBytes = appendLimitedOutput(
+                outputText,
+                buildMemberVisibleCompilationOutput(readCompilationOutput(compileLogPath)),
+                0L,
+                "artifacts/public/output.txt"
+            );
+            appendLimitedOutput(
+                outputText,
+                "Runner Error:\n" + safeLogValue(error == null ? null : error.getMessage()) + "\n",
+                outputBytes,
+                "artifacts/public/output.txt"
+            );
+
+            Files.createDirectories(outputPath.getParent());
+            Files.write(outputPath, outputText.toString().getBytes(StandardCharsets.UTF_8));
+        } catch (Exception outputError) {
+            logWarn(
+                "artifacts.public-output",
+                "Unable to write partial member output: " + outputError.getMessage()
+            );
+        }
+    }
+
     /**
      * Builds the public {@code output.txt} section for one generic Marathon test case.
      *