@elench/testkit 0.1.52 → 0.1.53

package/lib/cli/index.mjs

@@ -1,119 +1,9 @@
-import { cac } from "cac";
-import { loadConfigs } from "../config/index.mjs";
-import {
-  runKnownFailuresRenderCommand,
-  runKnownFailuresValidateCommand,
-} from "./known-failures.mjs";
-import { runDatabaseSnapshotCaptureCommand } from "./db.mjs";
-import {
-  parseFileTimeoutOption,
-  parseShardOption,
-  parseSuiteOption,
-  parseTypeOption,
-  parseWorkersOption,
-  resolveRequestedFiles,
-  resolveCliSelection,
-} from "./args.mjs";
-import * as runner from "../runner/index.mjs";
+import { execute } from "@oclif/core";
+import { normalizeCliArgs } from "./entrypoint.mjs";
 
 export async function run(argv = process.argv) {
-  const cli = cac("testkit");
-
-  cli
-    .command("[first] [second] [third]", "Run test suites")
-    .option("--service <name>", "Run only one service")
-    .option("-t, --type <name>", "Run specific suite type(s): int, e2e, dal, load, pw, all", {
-      default: [],
-    })
-    .option("-s, --suite <name>", "Run specific suite(s)", { default: [] })
-    .option("-f, --file <path>", "Run specific file(s)", { default: [] })
-    .option("--dir <path>", "Explicit product directory")
-    .option("--workers <n>", "Number of test executors for the whole run")
-    .option("--file-timeout-seconds <n>", "Per-file wall-clock timeout in seconds")
-    .option("--shard <i/n>", "Run only shard i of n at suite granularity")
-    .option("--write-status", "Write a deterministic testkit.status.json snapshot")
-    .option("--allow-partial-status", "Allow --write-status for filtered runs")
-    .option("--input <path>", "Known failures JSON path (repo-relative)")
-    .option("--output <path>", "Output path for render/snapshot commands")
-    .option("--status <path>", "Status artifact path for validation commands")
-    .option("--issue-mode <mode>", "Issue validation mode override: off, warn, error")
-    .option(
-      "--ignore-skip-rules",
-      "Run files even if testkit.setup.ts marks them skipped"
-    )
-    .action(async (first, second, third, options) => {
-      const { lifecycle, positionalType, knownFailuresAction, dbAction } = resolveCliSelection({
-        first,
-        second,
-        third,
-      });
-      if (knownFailuresAction === "render") {
-        await runKnownFailuresRenderCommand(options);
-        return;
-      }
-      if (knownFailuresAction === "validate") {
-        await runKnownFailuresValidateCommand(options);
-        return;
-      }
-      if (dbAction === "snapshot-capture") {
-        await runDatabaseSnapshotCaptureCommand(options);
-        return;
-      }
-
-      const allConfigs = await loadConfigs({ dir: options.dir });
-      const configs = options.service
-        ? allConfigs.filter((config) => config.name === options.service)
-        : allConfigs;
-      if (options.service && configs.length === 0) {
-        const available = allConfigs.map((config) => config.name).join(", ");
-        throw new Error(`Service "${options.service}" not found. Available: ${available}`);
-      }
-
-      // Lifecycle commands
-      if (lifecycle === "cleanup") {
-        await runner.cleanup(allConfigs[0]?.productDir || process.cwd());
-        return;
-      }
-
-      if (lifecycle === "status" || lifecycle === "destroy") {
-        for (const config of configs) {
-          if (configs.length > 1) console.log(`\n── ${config.name} ──`);
-          if (lifecycle === "status") runner.showStatus(config);
-          else await runner.destroy(config);
-        }
-        return;
-      }
-
-      const workers = options.workers == null ? null : parseWorkersOption(options.workers);
-      const fileTimeoutSeconds =
-        options.fileTimeoutSeconds == null
-          ? null
-          : parseFileTimeoutOption(options.fileTimeoutSeconds);
-      const shard = parseShardOption(options.shard);
-      const typeValues = parseTypeOption(options.type, positionalType);
-      const suiteSelectors = parseSuiteOption(options.suite);
-      const rawFileNames = Array.isArray(options.file) ? options.file : [options.file].filter(Boolean);
-      const productDir = allConfigs[0]?.productDir || process.cwd();
-      const fileNames = resolveRequestedFiles(rawFileNames, productDir, process.cwd());
-      await runner.runAll(
-        configs,
-        typeValues,
-        suiteSelectors,
-        {
-          ...options,
-          typeValues,
-          fileNames,
-          workers,
-          fileTimeoutSeconds,
-          shard,
-          serviceFilter: options.service || null,
-        },
-        allConfigs
-      );
-    });
-
-  cli.help();
-  const parsed = cli.parse(argv, { run: false });
-  await cli.runMatchedCommand();
-  return parsed;
+  return execute({
+    args: normalizeCliArgs(argv.slice(2)),
+    dir: import.meta.url,
+  });
 }

package/lib/cli/presentation/run-reporter.mjs

@@ -0,0 +1,91 @@
+import path from "path";
+import {
+  buildCompactRunSummaryLines,
+  buildDebugRunSummaryLines,
+  formatDuration,
+} from "../../runner/formatting.mjs";
+
+export function createRunReporter({ outputMode = "compact", stdout = process.stdout, stderr = process.stderr } = {}) {
+  const mode = outputMode || "compact";
+  return {
+    outputMode: mode,
+    writeLine(line = "") {
+      stdout.write(`${line}\n`);
+    },
+    writeDebugLine(line = "") {
+      stdout.write(`${line}\n`);
+    },
+    phaseStarted(label) {
+      if (mode !== "debug") return;
+      stdout.write(`\n── ${label} ──\n`);
+    },
+    toolchainResolved(config, resolvedToolchain) {
+      if (mode !== "debug") return;
+      stdout.write(
+        `[testkit] ${config.runtimeLabel || config.name}:${config.name} toolchain ${resolvedToolchain.summary}\n`
+      );
+    },
+    localServiceStarting(config, command) {
+      if (mode !== "debug") return;
+      stdout.write(`Starting ${config.runtimeLabel}:${config.name}: ${command}\n`);
+    },
+    serviceSkipped(config, reason) {
+      stdout.write(`SKIP ${config.name} ${reason}\n`);
+    },
+    plannedSkip(entry) {
+      stdout.write(
+        `SKIP ${entry.serviceName} ${entry.type} ${normalizePath(entry.file)} 0s ${shortenMessage(entry.reason || "skipped")}\n`
+      );
+    },
+    taskStarted(task, targetConfig) {
+      if (mode !== "debug") return;
+      stdout.write(`RUN  ${targetConfig.name} ${task.type} ${task.file}\n`);
+    },
+    taskFinished(task, outcome) {
+      if (mode === "json") return;
+      const status = outcome.status === "skipped" ? "SKIP" : outcome.failed ? "FAIL" : "PASS";
+      const duration = formatDuration(outcome.durationMs || 0);
+      const detail =
+        status === "FAIL"
+          ? ` ${shortenMessage(outcome.error || firstFailureDetail(outcome) || "failed")}`
+          : outcome.status === "not_run"
+            ? ` ${shortenMessage(outcome.reason || "not run")}`
+            : "";
+      stdout.write(
+        `${status} ${task.serviceName} ${displayTaskType(task)} ${normalizePath(task.file)} ${duration}${detail}\n`
+      );
+    },
+    telemetry(message) {
+      if (mode === "json") return;
+      stdout.write(`${message}\n`);
+    },
+    runSummary(results, durationMs, knownFailureIssueValidation = null) {
+      const lines =
+        mode === "debug"
+          ? buildDebugRunSummaryLines(results, durationMs, knownFailureIssueValidation)
+          : buildCompactRunSummaryLines(results, durationMs, knownFailureIssueValidation);
+      for (const line of lines) stdout.write(`${line}\n`);
+    },
+    error(message) {
+      stderr.write(`${message}\n`);
+    },
+  };
+}
+
+function displayTaskType(task) {
+  if (task.framework === "playwright") return "pw";
+  if (task.type === "integration") return "int";
+  return task.type;
+}
+
+function shortenMessage(message) {
+  return String(message).replace(/\s+/g, " ").trim().slice(0, 180);
+}
+
+function firstFailureDetail(outcome) {
+  return outcome.failureDetails?.[0]?.message || outcome.failureDetails?.[0]?.title || null;
+}
+
+function normalizePath(filePath) {
+  return String(filePath).split(path.sep).join("/");
+}

package/lib/cli/tui/watch-app.mjs

@@ -0,0 +1,104 @@
+import React, { createElement, useEffect, useMemo, useState } from "react";
+import { Box, Text, useApp, useInput } from "ink";
+import { formatDuration } from "../../runner/formatting.mjs";
+import { formatFileDetail, loadLatestRunArtifact, resolveFileSubject } from "../viewer.mjs";
+
+export function WatchApp({ productDir, serviceFilter = null }) {
+  const { exit } = useApp();
+  const [artifact, setArtifact] = useState(() => safeLoadArtifact(productDir));
+  const [selectedIndex, setSelectedIndex] = useState(0);
+
+  const files = useMemo(() => collectFiles(artifact, serviceFilter), [artifact, serviceFilter]);
+  const selected = files[Math.min(selectedIndex, Math.max(0, files.length - 1))] || null;
+
+  useEffect(() => {
+    const timer = setInterval(() => {
+      setArtifact(safeLoadArtifact(productDir));
+    }, 1_000);
+    return () => clearInterval(timer);
+  }, [productDir]);
+
+  useInput((input, key) => {
+    if (input === "q") {
+      exit();
+      return;
+    }
+    if (input === "r") {
+      setArtifact(safeLoadArtifact(productDir));
+      return;
+    }
+    if (key.downArrow) {
+      setSelectedIndex((current) => Math.min(current + 1, Math.max(0, files.length - 1)));
+      return;
+    }
+    if (key.upArrow) {
+      setSelectedIndex((current) => Math.max(0, current - 1));
+    }
+  });
+
+  if (!artifact) {
+    return createElement(Text, null, `No run artifact found in ${productDir}`);
+  }
+
+  return createElement(
+    Box,
+    { flexDirection: "column" },
+    createElement(
+      Text,
+      null,
+      `testkit watch · q quit · r reload · ${artifact.run.status} · ${formatDuration(artifact.run.durationMs)}`
+    ),
+    createElement(
+      Box,
+      { marginTop: 1 },
+      createElement(
+        Box,
+        { width: "40%", flexDirection: "column", marginRight: 2 },
+        createElement(Text, null, "Files"),
+        ...files.map((entry, index) => {
+          const prefix = index === selectedIndex ? ">" : " ";
+          return createElement(
+            Text,
+            { key: `${entry.service.name}:${entry.file.path}` },
+            `${prefix} ${entry.file.status.toUpperCase().padEnd(7)} ${entry.file.path}`
+          );
+        })
+      ),
+      createElement(
+        Box,
+        { width: "60%", flexDirection: "column" },
+        createElement(Text, null, "Details"),
+        ...(selected
+          ? formatFileDetail(productDir, artifact, selected, { logTail: 8 })
+              .slice(0, 28)
+              .map((line, index) => createElement(Text, { key: `${index}:${line}` }, line))
+          : [createElement(Text, { key: "empty" }, "No file results")])
+      )
+    )
+  );
+}
+
+function safeLoadArtifact(productDir) {
+  try {
+    return loadLatestRunArtifact(productDir);
+  } catch {
+    return null;
+  }
+}
+
+function collectFiles(runArtifact, serviceFilter) {
+  if (!runArtifact) return [];
+  const entries = [];
+  for (const service of runArtifact.services || []) {
+    if (serviceFilter && service.name !== serviceFilter) continue;
+    for (const suite of service.suites || []) {
+      for (const file of suite.files || []) {
+        entries.push({ service, suite, file });
+      }
+    }
+  }
+  const failed = entries.filter((entry) => entry.file.status === "failed");
+  return (failed.length > 0 ? failed : entries).sort((left, right) =>
+    left.file.path.localeCompare(right.file.path)
+  );
+}

package/lib/cli/viewer.mjs

@@ -0,0 +1,163 @@
+import fs from "fs";
+import path from "path";
+import { formatDuration } from "../runner/formatting.mjs";
+import { readLogTail } from "../runner/logs.mjs";
+
+export function loadLatestRunArtifact(productDir) {
+  const artifactPath = path.join(productDir, ".testkit", "results", "latest.json");
+  if (!fs.existsSync(artifactPath)) {
+    throw new Error(`No run artifact found at ${path.relative(productDir, artifactPath)}`);
+  }
+  return JSON.parse(fs.readFileSync(artifactPath, "utf8"));
+}
+
+export function resolveFileSubject(runArtifact, selector = null, serviceFilter = null) {
+  const files = collectFiles(runArtifact, serviceFilter);
+  if (files.length === 0) {
+    throw new Error("No file results were found in the latest run artifact.");
+  }
+
+  if (!selector) {
+    return files.find((entry) => entry.file.status === "failed") || files[0];
+  }
+
+  const normalizedSelector = normalizePath(selector);
+  const exact = files.filter((entry) => entry.file.path === normalizedSelector);
+  if (exact.length === 1) return exact[0];
+  if (exact.length > 1) {
+    throw new Error(`Multiple files matched "${selector}". Re-run with --service to disambiguate.`);
+  }
+
+  const suffixMatches = files.filter((entry) => entry.file.path.endsWith(normalizedSelector));
+  if (suffixMatches.length === 1) return suffixMatches[0];
+  if (suffixMatches.length > 1) {
+    throw new Error(`Multiple files matched "${selector}". Re-run with --service to disambiguate.`);
+  }
+
+  throw new Error(`No file matched "${selector}".`);
+}
+
+export function collectArtifactEntries(productDir, runArtifact, selector = null, serviceFilter = null) {
+  const files = selector
+    ? [resolveFileSubject(runArtifact, selector, serviceFilter)]
+    : collectFiles(runArtifact, serviceFilter);
+  const entries = [];
+
+  for (const entry of files) {
+    for (const artifactRef of entry.file.artifacts || []) {
+      const absolutePath = path.join(productDir, artifactRef.path);
+      const payload = fs.existsSync(absolutePath)
+        ? JSON.parse(fs.readFileSync(absolutePath, "utf8"))
+        : null;
+      entries.push({
+        ...entry,
+        artifactRef,
+        absolutePath,
+        payload,
+      });
+    }
+  }
+
+  return entries;
+}
+
+export function formatFileDetail(productDir, runArtifact, subject, options = {}) {
+  const lines = [];
+  lines.push(`File: ${subject.file.path}`);
+  lines.push(`Service: ${subject.service.name}`);
+  lines.push(`Suite: ${subject.suite.type}:${subject.suite.name}`);
+  lines.push(`Status: ${subject.file.status}`);
+  lines.push(`Duration: ${formatDuration(subject.file.durationMs || 0)}`);
+  if (subject.file.error) lines.push(`Error: ${subject.file.error}`);
+
+  if ((subject.file.failureDetails || []).length > 0) {
+    lines.push("");
+    lines.push("Failure Details:");
+    for (const detail of subject.file.failureDetails.slice(0, options.failureLimit || 5)) {
+      lines.push(`  ${detail.title}`);
+      if (detail.message) lines.push(`    ${detail.message}`);
+    }
+  }
+
+  const artifacts = collectArtifactEntries(productDir, runArtifact, subject.file.path, subject.service.name);
+  if (artifacts.length > 0) {
+    lines.push("");
+    lines.push("Artifacts:");
+    for (const entry of artifacts) {
+      lines.push(`  ${entry.artifactRef.name}${entry.artifactRef.kind ? ` [${entry.artifactRef.kind}]` : ""}`);
+      if (entry.artifactRef.summary) lines.push(`    ${entry.artifactRef.summary}`);
+      for (const previewLine of formatArtifactPreview(entry.payload, options.previewLength || 6)) {
+        lines.push(`    ${previewLine}`);
+      }
+      lines.push(`    ${entry.artifactRef.path}`);
+    }
+  }
+
+  const logRefs = getServiceLogRefs(runArtifact, subject.service.name);
+  if (logRefs.length > 0) {
+    lines.push("");
+    lines.push("Backend Logs:");
+    for (const logRef of logRefs) {
+      lines.push(`  ${logRef.runtimeLabel}`);
+      lines.push(`    ${logRef.path}`);
+      const tail = readLogTail(path.join(productDir, logRef.path), options.logTail || 12);
+      for (const line of tail.slice(-Math.max(0, options.logTail || 12))) {
+        lines.push(`    ${line}`);
+      }
+    }
+  }
+
+  return lines;
+}
+
+export function getServiceLogRefs(runArtifact, serviceName) {
+  return (runArtifact.logs?.services || []).filter((entry) => entry.serviceName === serviceName);
+}
+
+export function formatArtifactPreview(payload, maxLines = 6) {
+  if (!payload) return ["artifact payload missing"];
+  if (payload.kind === "agentic-query") {
+    return formatAgenticArtifact(payload, maxLines);
+  }
+  if (payload.contentType === "text/plain" && typeof payload.data?.text === "string") {
+    return payload.data.text
+      .split(/\r?\n/)
+      .filter((line) => line.trim().length > 0)
+      .slice(0, maxLines);
+  }
+  const preview = JSON.stringify(payload.data, null, 2)
+    .split(/\r?\n/)
+    .slice(0, maxLines);
+  return preview;
+}
+
+function formatAgenticArtifact(payload, maxLines) {
+  const artifact = payload.data || {};
+  const lines = [];
+  if (artifact.query?.text) lines.push(`Query: ${artifact.query.text}`);
+  if (artifact.ui?.latestAssistantMessage?.content) {
+    lines.push(`Answer: ${String(artifact.ui.latestAssistantMessage.content).replace(/\s+/g, " ").trim()}`);
+  }
+  if (Array.isArray(artifact.ui?.resultTables) && artifact.ui.resultTables.length > 0) {
+    const table = artifact.ui.resultTables[0];
+    lines.push(`Table: ${table.rowCount} rows · columns ${table.columns.join(", ")}`);
+  }
+  return lines.slice(0, maxLines);
+}
+
+function collectFiles(runArtifact, serviceFilter = null) {
+  const files = [];
+  for (const service of runArtifact.services || []) {
+    if (serviceFilter && service.name !== serviceFilter) continue;
+    for (const suite of service.suites || []) {
+      for (const file of suite.files || []) {
+        files.push({ service, suite, file });
+      }
+    }
+  }
+  return files;
+}
+
+function normalizePath(filePath) {
+  return String(filePath).split(path.sep).join("/");
+}

package/lib/runner/artifacts.mjs

@@ -8,6 +8,7 @@ import {
 
 const TIMINGS_FILENAME = "timings.json";
 const RESULT_ARTIFACTS_DIRNAME = "artifacts";
+const RESULT_LOGS_DIRNAME = "logs";
 
 export function writeRunArtifact(productDir, artifact) {
   const resultsDir = path.join(productDir, ".testkit", "results");
@@ -27,6 +28,10 @@ export function resetResultArtifacts(productDir) {
     recursive: true,
     force: true,
   });
+  fs.rmSync(path.join(productDir, ".testkit", "results", RESULT_LOGS_DIRNAME), {
+    recursive: true,
+    force: true,
+  });
 }
 
 export function persistTaskArtifacts(productDir, task, emittedArtifacts) {
@@ -81,6 +86,27 @@ export function persistTaskArtifacts(productDir, task, emittedArtifacts) {
   });
 }
 
+export function persistTaskOutputArtifacts(productDir, task, outputs) {
+  if (!Array.isArray(outputs) || outputs.length === 0) return [];
+  return persistTaskArtifacts(
+    productDir,
+    task,
+    outputs
+      .filter((entry) => typeof entry?.text === "string" && entry.text.trim().length > 0)
+      .map((entry) => ({
+        name: entry.name || "task-output",
+        kind: entry.kind || "runtime.output",
+        summary: entry.summary || summarizeOutput(entry.text),
+        contentType: entry.contentType || "text/plain",
+        emittedAt: entry.emittedAt || new Date().toISOString(),
+        data: {
+          stream: entry.stream || null,
+          text: entry.text,
+        },
+      }))
+  );
+}
+
 export function loadTimings(productDir) {
   const filePath = path.join(productDir, ".testkit", TIMINGS_FILENAME);
   if (!fs.existsSync(filePath)) {
@@ -113,3 +139,12 @@ function sanitizePathSegment(value) {
 function normalizePath(filePath) {
   return filePath.split(path.sep).join("/");
 }
+
+function summarizeOutput(text) {
+  const firstLine = String(text)
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .find(Boolean);
+  if (!firstLine) return "captured task output";
+  return firstLine.slice(0, 120);
+}

package/lib/runner/default-runtime-runner.mjs

@@ -7,7 +7,7 @@ import {
   buildFileTimeoutEnv,
   formatFileTimeoutBudgetError,
 } from "../shared/file-timeout.mjs";
-import { persistTaskArtifacts } from "./artifacts.mjs";
+import { persistTaskArtifacts, persistTaskOutputArtifacts } from "./artifacts.mjs";
 import { determineDefaultRuntimeFailure } from "./default-runtime-errors.mjs";
 import { collectFailureDetailsFromRuntimeArtifacts } from "./failure-details.mjs";
 import { RUNTIME_ARTIFACT_MARKER } from "../runtime-src/k6/artifacts.js";
@@ -15,7 +15,7 @@ import { readDatabaseUrl } from "./state-io.mjs";
 import { buildTaskExecutionEnv } from "./template.mjs";
 import { killChildProcess } from "./processes.mjs";
 
-export async function runHttpK6Task(targetConfig, task, lifecycle, lease) {
+export async function runHttpK6Task(targetConfig, task, lifecycle, lease, reporter = null) {
   const baseUrl = targetConfig.testkit.local?.baseUrl;
   if (!baseUrl) {
     throw new Error(`Service "${targetConfig.name}" requires local.baseUrl for HTTP suites`);
@@ -34,11 +34,12 @@ export async function runHttpK6Task(targetConfig, task, lifecycle, lease) {
     task,
     lease,
     ["run", "--address", "127.0.0.1:0", "-e", `BASE_URL=${baseUrl}`, bundledFile],
-    lifecycle
+    lifecycle,
+    reporter
   );
 }
 
-export async function runDalTask(targetConfig, task, lifecycle, lease) {
+export async function runDalTask(targetConfig, task, lifecycle, lease, reporter = null) {
   const databaseUrl = readDatabaseUrl(targetConfig.stateDir);
   if (!databaseUrl) {
     throw new Error(`Service "${targetConfig.name}" requires a database for DAL suites`);
@@ -57,12 +58,27 @@ export async function runDalTask(targetConfig, task, lifecycle, lease) {
     task,
     lease,
     ["run", "--address", "127.0.0.1:0", "-e", `DATABASE_URL=${databaseUrl}`, bundledFile],
-    lifecycle
+    lifecycle,
+    reporter
   );
 }
 
-export async function runDefaultRuntimeTask(targetConfig, task, lease, args, lifecycle, firstLine) {
+export async function runDefaultRuntimeTask(
+  targetConfig,
+  task,
+  lease,
+  args,
+  lifecycle,
+  reporterOrFirstLine,
+  maybeFirstLine
+) {
   const k6Binary = resolveK6Binary();
+  const reporter =
+    reporterOrFirstLine && typeof reporterOrFirstLine === "object"
+      ? reporterOrFirstLine
+      : null;
+  const firstLine =
+    typeof reporterOrFirstLine === "function" ? reporterOrFirstLine : maybeFirstLine;
   const getFirstLine = firstLine || defaultFirstLine;
   const summaryFile = buildDefaultRuntimeSummaryPath(lease, task);
   fs.mkdirSync(path.dirname(summaryFile), { recursive: true });
@@ -91,7 +107,7 @@ export async function runDefaultRuntimeTask(targetConfig, task, lease, args, lif
     if (subprocess.pid) interruptSubprocess();
     else subprocess.once?.("spawn", interruptSubprocess);
   }
-  console.log(`·· ${targetConfig.runtimeLabel}:${task.suiteName} → ${task.file}`);
+  reporter?.taskStarted?.(task, targetConfig);
   let result;
   let timedOut;
   try {
@@ -102,8 +118,6 @@ export async function runDefaultRuntimeTask(targetConfig, task, lease, args, lif
 
   const stdout = parseDefaultRuntimeOutput(result.stdout || "");
   const stderr = parseDefaultRuntimeOutput(result.stderr || "");
-  if (stdout.visibleOutput) process.stdout.write(stdout.visibleOutput);
-  if (stderr.visibleOutput) process.stderr.write(stderr.visibleOutput);
 
   const summary = readDefaultRuntimeSummary(summaryFile);
   const rawRuntimeArtifacts = [...stdout.artifacts, ...stderr.artifacts];
@@ -112,6 +126,26 @@ export async function runDefaultRuntimeTask(targetConfig, task, lease, args, lif
     task,
     rawRuntimeArtifacts
   );
+  const outputArtifacts = persistTaskOutputArtifacts(targetConfig.productDir, task, [
+    stdout.visibleOutput
+      ? {
+          name: "default-runtime-stdout",
+          kind: "runtime.output",
+          summary: defaultFirstLine(stdout.visibleOutput) || "captured stdout",
+          stream: "stdout",
+          text: stdout.visibleOutput,
+        }
+      : null,
+    stderr.visibleOutput
+      ? {
+          name: "default-runtime-stderr",
+          kind: "runtime.output",
+          summary: defaultFirstLine(stderr.visibleOutput) || "captured stderr",
+          stream: "stderr",
+          text: stderr.visibleOutput,
+        }
+      : null,
+  ]);
   const failureDetails = collectFailureDetailsFromRuntimeArtifacts(rawRuntimeArtifacts);
   const runtimeError = timedOut
     ? formatFileTimeoutBudgetError(fileTimeoutSeconds)
@@ -125,7 +159,7 @@ export async function runDefaultRuntimeTask(targetConfig, task, lease, args, lif
     durationMs: finishedAt - startedAt,
     startedAt,
     finishedAt,
-    artifacts: runtimeArtifacts,
+    artifacts: [...runtimeArtifacts, ...outputArtifacts],
     failureDetails,
   };
 }