@elench/testkit 0.1.52 → 0.1.54

package/lib/runner/formatting.mjs

@@ -49,6 +49,56 @@ export function formatSuiteFramework(framework) {
 }
 
 export function buildRunSummaryLines(results, durationMs, knownFailureIssueValidation = null) {
+  return buildCompactRunSummaryLines(results, durationMs, knownFailureIssueValidation);
+}
+
+export function buildCompactRunSummaryLines(
+  results,
+  durationMs,
+  knownFailureIssueValidation = null
+) {
+  const totals = summarizeResults(results);
+  const lines = [
+    "",
+    `Summary: ${totals.passedFiles} passed, ${totals.failedFiles} failed, ${totals.skippedFiles} skipped, ${totals.notRunFiles} not run across ${totals.totalFiles} ${pluralize(totals.totalFiles, "file", "files")} in ${formatDuration(durationMs)}`,
+  ];
+
+  const failures = collectFailedFiles(results);
+  if (failures.length > 0) {
+    lines.push("", "Failures:");
+    for (const failure of failures) {
+      lines.push(`  ${failure.file.path}`);
+      lines.push(`    ${failure.primaryMessage}`);
+      for (const detail of failure.extraLines.slice(0, 3)) {
+        lines.push(`    ${detail}`);
+      }
+    }
+  }
+
+  const serviceErrors = collectServiceErrors(results);
+  if (serviceErrors.length > 0) {
+    lines.push("", "Runtime Errors:");
+    for (const item of serviceErrors) {
+      lines.push(`  ${item.service}`);
+      lines.push(`    ${item.message}`);
+    }
+  }
+
+  const knownFailureIssueLines = buildKnownFailureIssueValidationSummaryLines(
+    knownFailureIssueValidation
+  );
+  if (knownFailureIssueLines.length > 0) {
+    lines.push(...knownFailureIssueLines);
+  }
+
+  lines.push("");
+  lines.push(
+    totals.failedServices > 0 ? `Result: FAILED (${totals.failedServices}/${totals.totalServices} services failed)` : "Result: PASSED"
+  );
+  return lines;
+}
+
+export function buildDebugRunSummaryLines(results, durationMs, knownFailureIssueValidation = null) {
   const totalServices = results.length;
   const executedServices = results.filter((result) => !result.skipped);
   const skippedServices = results.filter((result) => result.skipped);
@@ -140,6 +190,163 @@ function sanitizeErrorMessage(message) {
     .replace(/[\\/]vendor[\\/]k6\b/g, "default-runtime");
 }
 
+function summarizeResults(results) {
+  const executedServices = results.filter((result) => !result.skipped);
+  return {
+    totalServices: results.length,
+    failedServices: executedServices.filter((result) => result.failed).length,
+    totalFiles: executedServices.reduce((sum, result) => sum + (result.totalFileCount || 0), 0),
+    passedFiles: executedServices.reduce((sum, result) => sum + (result.passedFileCount || 0), 0),
+    failedFiles: executedServices.reduce((sum, result) => sum + (result.failedFileCount || 0), 0),
+    skippedFiles: executedServices.reduce((sum, result) => sum + (result.skippedFileCount || 0), 0),
+    notRunFiles: executedServices.reduce((sum, result) => sum + (result.notRunFileCount || 0), 0),
+  };
+}
+
+function collectFailedFiles(results) {
+  const failures = [];
+  for (const result of results) {
+    for (const suite of result.suites || []) {
+      for (const file of suite.files || []) {
+        if (file.status !== "failed") continue;
+        const rankedDetails = rankFailureDetails(file.failureDetails || []);
+        const primaryDetail = rankedDetails[0] || null;
+        const fallbackMessages = rankedDetails
+          .map((detail) => detail.message || detail.title)
+          .filter(Boolean)
+          .map((message) => sanitizeErrorMessage(String(message).trim()));
+        const extraLines = [];
+        if (primaryDetail) {
+          const responseLine = formatFailureResponsePreview(primaryDetail);
+          if (responseLine) extraLines.push(responseLine);
+          const triageLine = formatTriageLine(file.triage || null);
+          if (triageLine) extraLines.push(triageLine);
+          const requestLine = formatFailureRequestHint(primaryDetail);
+          if (requestLine) extraLines.push(requestLine);
+        } else {
+          const triageLine = formatTriageLine(file.triage || null);
+          if (triageLine) extraLines.push(triageLine);
+        }
+
+        for (const detail of rankedDetails.slice(primaryDetail ? 1 : 0)) {
+          const line = sanitizeErrorMessage(String(detail.message || detail.title || "").trim());
+          if (line && !extraLines.includes(line)) extraLines.push(line);
+        }
+        failures.push({
+          file,
+          primaryMessage: resolvePrimaryFailureMessage(file, suite, primaryDetail, fallbackMessages),
+          extraLines,
+        });
+      }
+    }
+  }
+  return failures.sort((left, right) => left.file.path.localeCompare(right.file.path));
+}
+
+function resolvePrimaryFailureMessage(file, suite, primaryDetail, fallbackMessages) {
+  if (primaryDetail?.message) {
+    return sanitizeErrorMessage(String(primaryDetail.message).trim());
+  }
+
+  const fileError = sanitizeErrorMessage(file.error || "");
+  if (fileError && !isThresholdWrapperMessage(fileError)) {
+    return fileError;
+  }
+
+  if (fallbackMessages.length > 0) {
+    return fallbackMessages[0];
+  }
+
+  if (fileError) {
+    return fileError;
+  }
+
+  return sanitizeErrorMessage(suite.error || "Failed");
+}
+
+function rankFailureDetails(details) {
+  return [...(Array.isArray(details) ? details : [])].sort((left, right) => {
+    return failureDetailRank(left) - failureDetailRank(right) || String(left?.key || "").localeCompare(String(right?.key || ""));
+  });
+}
+
+function failureDetailRank(detail) {
+  if (detail?.kind === "http-assertion") return 1;
+  if (detail?.request && detail?.response) return 2;
+  if (detail?.location || detail?.stack) return 3;
+  if (detail?.message) return 4;
+  return 5;
+}
+
+function formatFailureResponsePreview(detail) {
+  const bodyPreview = detail?.response?.bodyPreview;
+  if (!bodyPreview) return null;
+  return `response: ${sanitizeInline(bodyPreview, 220)}`;
+}
+
+function formatFailureRequestHint(detail) {
+  const method = detail?.request?.method;
+  const path = detail?.request?.path;
+  if (!method || !path) return null;
+  const requestId = detail?.request?.requestId;
+  if (requestId) {
+    return `logs: requestId=${requestId}`;
+  }
+  return `request: ${method} ${path}`;
+}
+
+function formatTriageLine(triage) {
+  if (!triage) return null;
+  if (triage.status === "untriaged") return "triage: untriaged";
+
+  const entry = triage.entries?.[0];
+  if (!entry?.issue) {
+    if (triage.status === "validation_unavailable") {
+      const reason = triage.availability?.reason ? ` (${triage.availability.reason})` : "";
+      return `triage: validation unavailable${reason}`;
+    }
+    return null;
+  }
+
+  const issueLabel = `#${entry.issue.number}`;
+  const validationStatus = entry.validationStatus || null;
+  if (validationStatus === "closed_but_failing") {
+    return `triage: known issue ${issueLabel} closed but still failing`;
+  }
+  if (validationStatus === "validation_unavailable") {
+    const reason = triage.availability?.mode === "cache" ? "cache" : "validation unavailable";
+    return `triage: known issue ${issueLabel} (${reason})`;
+  }
+  if (entry.github?.state === "open" || entry.state === "open") {
+    return `triage: known issue ${issueLabel} open`;
+  }
+  if (entry.github?.state === "closed" || entry.state === "closed") {
+    return `triage: known issue ${issueLabel} closed`;
+  }
+  return `triage: known issue ${issueLabel}`;
+}
+
+function isThresholdWrapperMessage(message) {
+  return /Default runtime thresholds failed:/.test(String(message || ""));
+}
+
+function sanitizeInline(message, maxLength = 180) {
+  return String(message || "").replace(/\s+/g, " ").trim().slice(0, maxLength);
+}
+
+function collectServiceErrors(results) {
+  const items = [];
+  for (const result of results) {
+    for (const error of result.errors || []) {
+      items.push({
+        service: result.name,
+        message: sanitizeErrorMessage(error),
+      });
+    }
+  }
+  return items;
+}
+
 function pluralize(value, singular, plural) {
   return value === 1 ? singular : plural;
 }

package/lib/runner/formatting.test.mjs

@@ -94,9 +94,9 @@ describe("runner formatting", () => {
       20_000
     );
 
-    expect(lines.join("\n")).toContain("services 0/1 passed");
-    expect(lines.join("\n")).toContain("FAIL frontend");
-    expect(lines.join("\n")).toContain("worker error: worker broke");
+    expect(lines.join("\n")).toContain("Summary: 2 passed, 0 failed, 0 skipped, 0 not run across 3 files");
+    expect(lines.join("\n")).toContain("Runtime Errors:");
+    expect(lines.join("\n")).toContain("worker broke");
     expect(lines.at(-1)).toBe("Result: FAILED (1/1 services failed)");
   });
 
@@ -123,9 +123,7 @@ describe("runner formatting", () => {
       0
     );
 
-    expect(lines.join("\n")).toContain("suites 1 skipped");
-    expect(lines.join("\n")).toContain("files 1 skipped");
-    expect(lines.join("\n")).toContain("SKIP api");
+    expect(lines.join("\n")).toContain("Summary: 0 passed, 0 failed, 1 skipped, 0 not run across 1 file");
     expect(lines.at(-1)).toBe("Result: PASSED");
   });
 
@@ -164,4 +162,81 @@ describe("runner formatting", () => {
     expect(lines.join("\n")).toContain("2 closed issues still failing");
     expect(lines.join("\n")).toContain("1 title mismatch");
   });
+
+  it("prefers structured HTTP assertion details over threshold wrapper text", () => {
+    const lines = buildRunSummaryLines(
+      [
+        {
+          name: "api",
+          skipped: false,
+          failed: true,
+          suiteCount: 1,
+          completedSuiteCount: 1,
+          skippedSuiteCount: 0,
+          failedSuiteCount: 1,
+          totalFileCount: 1,
+          passedFileCount: 0,
+          failedFileCount: 1,
+          skippedFileCount: 0,
+          notRunFileCount: 0,
+          durationMs: 500,
+          suites: [
+            {
+              failed: true,
+              type: "int",
+              name: "default",
+              framework: "k6",
+              failedFiles: ["__testkit__/health/health.int.testkit.ts"],
+              durationMs: 500,
+              files: [
+                {
+                  path: "__testkit__/health/health.int.testkit.ts",
+                  status: "failed",
+                  error: "Default runtime thresholds failed: checks(rate==1.0)",
+                  failureDetails: [
+                    {
+                      kind: "http-assertion",
+                      key: "GET /health > status is 200",
+                      title: "status is 200",
+                      message: "GET /health expected 200, got 404",
+                      request: {
+                        method: "GET",
+                        path: "/health",
+                        requestId: "req-1",
+                      },
+                      response: {
+                        status: 404,
+                        bodyPreview: '{"error":"nope"}',
+                      },
+                    },
+                  ],
+                  triage: {
+                    status: "known_failure",
+                    entries: [
+                      {
+                        id: "health-is-bad",
+                        state: "open",
+                        issue: {
+                          repo: "acme/example",
+                          number: 42,
+                        },
+                      },
+                    ],
+                  },
+                },
+              ],
+              error: null,
+            },
+          ],
+          errors: [],
+        },
+      ],
+      500
+    );
+
+    expect(lines.join("\n")).toContain("GET /health expected 200, got 404");
+    expect(lines.join("\n")).toContain('response: {"error":"nope"}');
+    expect(lines.join("\n")).toContain("triage: known issue #42 open");
+    expect(lines.join("\n")).not.toContain("Default runtime thresholds failed: checks(rate==1.0)\n    response:");
+  });
 });

package/lib/runner/logs.mjs

@@ -0,0 +1,89 @@
+import fs from "fs";
+import path from "path";
+
+const RESULT_LOGS_DIRNAME = "logs";
+
+export function createRunLogRegistry(productDir) {
+  const records = new Map();
+
+  return {
+    ensureServiceLogRecord(config) {
+      const key = `${config.runtimeLabel || config.name}:${config.name}`;
+      const existing = records.get(key);
+      if (existing) return existing;
+
+      const fileName = `${sanitizePathSegment(config.runtimeLabel || config.name)}__${sanitizePathSegment(config.name)}.log`;
+      const relativePath = path.join(".testkit", "results", RESULT_LOGS_DIRNAME, fileName);
+      const absolutePath = path.join(productDir, relativePath);
+      fs.mkdirSync(path.dirname(absolutePath), { recursive: true });
+      const stream = fs.createWriteStream(absolutePath, { flags: "a" });
+      const record = {
+        key,
+        serviceName: config.name,
+        runtimeLabel: config.runtimeLabel || config.name,
+        path: normalizePath(relativePath),
+        absolutePath,
+        stream,
+      };
+      records.set(key, record);
+      return record;
+    },
+    append(record, streamName, line) {
+      if (!record || typeof line !== "string") return;
+      record.stream.write(`${new Date().toISOString()} [${streamName}] ${line}\n`);
+    },
+    listServiceLogs() {
+      return [...records.values()]
+        .map((record) => ({
+          serviceName: record.serviceName,
+          runtimeLabel: record.runtimeLabel,
+          path: record.path,
+        }))
+        .sort(
+          (left, right) =>
+            left.serviceName.localeCompare(right.serviceName) ||
+            left.runtimeLabel.localeCompare(right.runtimeLabel)
+        );
+    },
+    closeAll() {
+      for (const record of records.values()) {
+        record.stream.end();
+      }
+    },
+  };
+}
+
+export function readLogTail(absolutePath, lineCount = 80) {
+  if (!absolutePath || !fs.existsSync(absolutePath)) return [];
+  const lines = fs.readFileSync(absolutePath, "utf8").split(/\r?\n/).filter(Boolean);
+  return lines.slice(Math.max(0, lines.length - lineCount));
+}
+
+export function findLogSliceByRequestId(absolutePath, requestId, contextLines = 2) {
+  if (!absolutePath || !requestId || !fs.existsSync(absolutePath)) return [];
+  const lines = fs.readFileSync(absolutePath, "utf8").split(/\r?\n/).filter(Boolean);
+  const matches = [];
+
+  for (let index = 0; index < lines.length; index += 1) {
+    if (!lines[index].includes(requestId)) continue;
+    const start = Math.max(0, index - contextLines);
+    const end = Math.min(lines.length, index + contextLines + 1);
+    for (let cursor = start; cursor < end; cursor += 1) {
+      if (!matches.includes(lines[cursor])) matches.push(lines[cursor]);
+    }
+  }
+
+  return matches;
+}
+
+function sanitizePathSegment(value) {
+  return String(value)
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9._-]+/g, "-")
+    .replace(/^-+|-+$/g, "") || "log";
+}
+
+function normalizePath(filePath) {
+  return filePath.split(path.sep).join("/");
+}

package/lib/runner/orchestrator.mjs

@@ -15,8 +15,12 @@ import {
   summarizeDbBackend,
 } from "./results.mjs";
 import { buildRunArtifact, buildStatusArtifact } from "./reporting.mjs";
-import { applyKnownFailuresToArtifacts, loadKnownFailuresConfig } from "./triage.mjs";
-import { buildRunSummaryLines, formatError } from "./formatting.mjs";
+import {
+  applyKnownFailureIssueValidationToArtifacts,
+  applyKnownFailuresToArtifacts,
+  loadKnownFailuresConfig,
+} from "./triage.mjs";
+import { formatError } from "./formatting.mjs";
 import {
   shouldFailKnownFailureIssueValidation,
   validateKnownFailureIssues,
@@ -28,6 +32,7 @@ import {
   writeRunArtifact,
   writeStatusArtifact,
 } from "./artifacts.mjs";
+import { createRunLogRegistry } from "./logs.mjs";
 import {
   cleanupRunById,
   cleanupRuns,
@@ -65,6 +70,8 @@ export async function runAll(configs, typeValues, suiteSelectors, opts, allConfi
     productDir,
     configs[0]?.testkit?.reporting || null
   );
+  const reporter = opts.reporter || null;
+  const logRegistry = createRunLogRegistry(productDir);
   const requestedFiles = opts.fileNames || [];
   if (requestedFiles.length > 0) {
     const unmatchedFiles = findUnmatchedRequestedFiles(
@@ -109,7 +116,8 @@ export async function runAll(configs, typeValues, suiteSelectors, opts, allConfi
     typeValues,
     suiteSelectors,
     opts,
-    execution
+    execution,
+    reporter
   );
   const trackers = buildServiceTrackers(servicePlans, startedAt);
   const executedPlans = servicePlans.filter((plan) => !plan.skipped);
@@ -138,6 +146,10 @@ export async function runAll(configs, typeValues, suiteSelectors, opts, allConfi
         productDir,
         graphs,
         lifecycle,
+        runtimeOptions: {
+          reporter,
+          logRegistry,
+        },
       });
       const timingUpdates = [];
 
@@ -153,7 +165,8 @@ export async function runAll(configs, typeValues, suiteSelectors, opts, allConfi
               lifecycle,
               claimNextTask,
               recordTaskOutcome,
-              recordGraphError
+              recordGraphError,
+              reporter
             )
           )
         );
@@ -194,6 +207,7 @@ export async function runAll(configs, typeValues, suiteSelectors, opts, allConfi
       serviceFilter: opts.serviceFilter || null,
       metadata,
       summarizeDbBackend,
+      serviceLogs: logRegistry.listServiceLogs(),
     });
     const statusArtifact = opts.writeStatus
       ? buildStatusArtifact({
@@ -220,6 +234,11 @@ export async function runAll(configs, typeValues, suiteSelectors, opts, allConfi
       config: configs[0]?.testkit?.reporting?.issueValidation || null,
       gitMetadata: metadata.git,
     });
+    applyKnownFailureIssueValidationToArtifacts(
+      enrichedArtifacts.runArtifact,
+      enrichedArtifacts.statusArtifact,
+      knownFailureIssueValidation
+    );
     attachKnownFailureIssueValidation(
       enrichedArtifacts.runArtifact,
       enrichedArtifacts.statusArtifact,
@@ -231,13 +250,19 @@ export async function runAll(configs, typeValues, suiteSelectors, opts, allConfi
       writeStatusArtifact(productDir, enrichedArtifacts.statusArtifact);
     }
 
-    printRunSummary(results, finishedAt - startedAt, knownFailureIssueValidation);
-    await reportTelemetry(telemetry, enrichedArtifacts.runArtifact);
+    reporter?.runSummary?.(results, finishedAt - startedAt, knownFailureIssueValidation);
+    await reportTelemetry(telemetry, enrichedArtifacts.runArtifact, reporter);
     if (results.some((result) => result.failed)) exitCode = 1;
     if (shouldFailKnownFailureIssueValidation(knownFailureIssueValidation)) {
       exitCode = 1;
     }
     if (lifecycle.isStopRequested()) exitCode = Math.max(exitCode, 130);
+    return {
+      runArtifact: enrichedArtifacts.runArtifact,
+      statusArtifact: enrichedArtifacts.statusArtifact,
+      results,
+      exitCode,
+    };
   } finally {
     if (lifecycle.isStopRequested()) {
       exitCode = Math.max(exitCode, 130);
@@ -250,21 +275,22 @@ export async function runAll(configs, typeValues, suiteSelectors, opts, allConfi
     await cleanupRuns(productDir, { includeActive: false });
     lifecycle.removeManifest();
     lifecycle.dispose();
+    logRegistry.closeAll();
     process.exitCode = exitCode;
   }
 }
 
-function collectServicePlans(configs, configMap, typeValues, suiteSelectors, opts, execution) {
+function collectServicePlans(configs, configMap, typeValues, suiteSelectors, opts, execution, reporter) {
   return configs.map((config) => {
-    console.log(`\n══ ${config.name} ══`);
     const suites = applyShard(
       collectSuites(config, typeValues, suiteSelectors, opts.fileNames || [], opts),
       opts.shard
     );
 
     if (suites.length === 0) {
-      console.log(
-        `No test files for ${config.name} types=${typeValues.join(",") || "all"} suites=${suiteSelectors.map((selector) => selector.raw).join(",") || "all"} files=${(opts.fileNames || []).join(",") || "all"} — skipping`
+      reporter?.serviceSkipped?.(
+        config,
+        `no matching files (types=${typeValues.join(",") || "all"} suites=${suiteSelectors.map((selector) => selector.raw).join(",") || "all"} files=${(opts.fileNames || []).join(",") || "all"})`
       );
       return {
         config,
@@ -277,6 +303,17 @@ function collectServicePlans(configs, configMap, typeValues, suiteSelectors, opt
       };
     }
 
+    for (const suite of suites) {
+      for (const skippedFile of suite.skippedFiles || []) {
+        reporter?.plannedSkip?.({
+          serviceName: config.name,
+          type: suite.displayType || suite.type,
+          file: skippedFile.path,
+          reason: skippedFile.reason,
+        });
+      }
+    }
+
     const runtimeConfigs = resolveRuntimeConfigs(config, configMap);
     return {
       config,
@@ -290,30 +327,24 @@ function collectServicePlans(configs, configMap, typeValues, suiteSelectors, opt
   });
 }
 
-function printRunSummary(results, durationMs, knownFailureIssueValidation = null) {
-  for (const line of buildRunSummaryLines(results, durationMs, knownFailureIssueValidation)) {
-    console.log(line);
-  }
-}
-
-async function reportTelemetry(telemetry, artifact) {
+async function reportTelemetry(telemetry, artifact, reporter = null) {
   if (!telemetry?.enabled) return;
 
   try {
     const outcome = await uploadTelemetryArtifact(telemetry, artifact);
     if (outcome?.ok) {
-      console.log("Telemetry: uploaded run artifact");
+      reporter?.telemetry?.("Telemetry: uploaded run artifact");
       return;
     }
     if (outcome?.reason === "missing-token") {
-      console.log(
+      reporter?.telemetry?.(
         `Telemetry: skipped upload because ${telemetry.tokenEnv || "configured token env"} is not set`
       );
       return;
     }
     if (outcome?.reason && !outcome.skipped) return;
   } catch (error) {
-    console.log(`Telemetry: upload failed (${formatError(error)})`);
+    reporter?.telemetry?.(`Telemetry: upload failed (${formatError(error)})`);
   }
 }
 

package/lib/runner/playwright-runner.mjs

@@ -3,14 +3,14 @@ import { execa } from "execa";
 import { parsePlaywrightJsonResults } from "../reporters/playwright.mjs";
 import { resolveServiceCwd } from "../config/index.mjs";
 import { formatFileTimeoutBudgetError } from "../shared/file-timeout.mjs";
+import { persistTaskOutputArtifacts } from "./artifacts.mjs";
 import { settleSubprocess } from "./default-runtime-runner.mjs";
 import { ensurePlaywrightTestConfig } from "./playwright-config.mjs";
-import { printBufferedOutput } from "./processes.mjs";
 import { normalizePathSeparators } from "./state.mjs";
 import { buildPlaywrightEnv } from "./template.mjs";
 import { killChildProcess } from "./processes.mjs";
 
-export async function runPlaywrightTask(targetConfig, task, lifecycle, lease) {
+export async function runPlaywrightTask(targetConfig, task, lifecycle, lease, reporter = null) {
   const local = targetConfig.testkit.local;
   if (!local?.baseUrl) {
     throw new Error(
@@ -44,7 +44,7 @@ export async function runPlaywrightTask(targetConfig, task, lifecycle, lease) {
     if (subprocess.pid) interruptSubprocess();
     else subprocess.once?.("spawn", interruptSubprocess);
   }
-  console.log(`\n── ${targetConfig.runtimeLabel} playwright:${targetConfig.name} (${task.file}) ──`);
+  reporter?.taskStarted?.(task, targetConfig);
   let result;
   let timedOut;
   try {
@@ -53,15 +53,22 @@ export async function runPlaywrightTask(targetConfig, task, lifecycle, lease) {
     lifecycle.unregisterProcess(subprocess.pid);
   }
 
-  if (result.stderr) {
-    printBufferedOutput(result.stderr, `[${targetConfig.runtimeLabel}:${targetConfig.name}:playwright]`);
-  }
-
   const parsed = parsePlaywrightJsonResults(result.stdout || "", cwd);
   const finishedAt = Date.now();
   const durationMs = finishedAt - startedAt;
   const relativeFile = normalizePathSeparators(requestedFile);
   const fileResult = parsed.fileResults.get(relativeFile);
+  const outputArtifacts = persistTaskOutputArtifacts(targetConfig.productDir, task, [
+    result.stderr
+      ? {
+          name: "playwright-stderr",
+          kind: "runtime.output",
+          summary: result.stderr.split(/\r?\n/).map((line) => line.trim()).find(Boolean) || "captured stderr",
+          stream: "stderr",
+          text: result.stderr,
+        }
+      : null,
+  ]);
   const genericError = timedOut
     ? formatFileTimeoutBudgetError(fileTimeoutSeconds)
     : result.exitCode === 0
@@ -76,6 +83,7 @@ export async function runPlaywrightTask(targetConfig, task, lifecycle, lease) {
     durationMs: fileResult?.durationMs > 0 ? fileResult.durationMs : durationMs,
     startedAt,
     finishedAt,
+    artifacts: outputArtifacts,
     failureDetails: timedOut ? [] : fileResult?.failureDetails || [],
   };
 }