@elench/testkit 0.1.52 → 0.1.54

package/lib/cli/viewer.mjs

@@ -0,0 +1,268 @@
+import fs from "fs";
+import path from "path";
+import { formatDuration } from "../runner/formatting.mjs";
+import { findLogSliceByRequestId, readLogTail } from "../runner/logs.mjs";
+import {
+  findFailureLocation,
+  formatLocation,
+  renderCodeFrame,
+} from "./presentation/code-frames.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 = [];
+  const failureDetails = subject.file.failureDetails || [];
+  const primaryDetail = rankFailureDetails(failureDetails)[0] || null;
+  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 (failureDetails.length > 0) {
+    lines.push("");
+    lines.push("Failure Details:");
+    for (const detail of rankFailureDetails(failureDetails).slice(0, options.failureLimit || 5)) {
+      lines.push(`  ${detail.title}`);
+      if (detail.message) lines.push(`    ${detail.message}`);
+      const requestLine = formatRequestLine(detail);
+      if (requestLine) lines.push(`    ${requestLine}`);
+      const responseLine = formatResponseLine(detail);
+      if (responseLine) lines.push(`    ${responseLine}`);
+      const location = findFailureLocation(detail, subject.file.error || "");
+      if (location) lines.push(`    at ${formatLocation(location, productDir)}`);
+    }
+  }
+
+  const codeFrame = renderCodeFrame(findFailureLocation(primaryDetail, subject.file.error || ""), {
+    cwd: productDir,
+  });
+  if (codeFrame.length > 0) {
+    lines.push("");
+    lines.push("Code Frame:");
+    for (const line of codeFrame) lines.push(`  ${line}`);
+  }
+
+  if (subject.file.triage) {
+    lines.push("");
+    lines.push("Triage:");
+    const triageLines = formatTriage(subject.file.triage);
+    for (const line of triageLines) lines.push(`  ${line}`);
+  }
+
+  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 logPath = path.join(productDir, logRef.path);
+      const requestId = primaryDetail?.request?.requestId || null;
+      const tail =
+        requestId && findLogSliceByRequestId(logPath, requestId, 2).length > 0
+          ? findLogSliceByRequestId(logPath, requestId, 2)
+          : readLogTail(logPath, 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.kind === "testkit.http-traces") {
+    return formatHttpTraceArtifact(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 formatHttpTraceArtifact(payload, maxLines) {
+  const traces = Array.isArray(payload.data?.traces) ? payload.data.traces : [];
+  const lines = [];
+  for (const trace of traces.slice(0, maxLines)) {
+    lines.push(
+      `${trace.method} ${trace.path} -> ${trace.response?.status ?? "?"}${trace.requestId ? ` [${trace.requestId}]` : ""}`
+    );
+  }
+  return lines;
+}
+
+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 formatRequestLine(detail) {
+  const method = detail?.request?.method;
+  const path = detail?.request?.path;
+  if (!method || !path) return null;
+  const requestId = detail?.request?.requestId;
+  return requestId ? `request: ${method} ${path} [${requestId}]` : `request: ${method} ${path}`;
+}
+
+function formatResponseLine(detail) {
+  if (!detail?.response) return null;
+  const parts = [`response: ${detail.response.status ?? "?"}`];
+  if (detail.response.contentType) parts.push(detail.response.contentType);
+  if (detail.response.bodyPreview) parts.push(detail.response.bodyPreview);
+  return parts.join(" ");
+}
+
+function formatTriage(triage) {
+  const lines = [`status: ${triage.status}`];
+  if (triage.classifications?.length) {
+    lines.push(`classification: ${triage.classifications.join(", ")}`);
+  }
+  if (triage.availability?.mode) {
+    lines.push(
+      `validation: ${triage.availability.mode}${triage.availability.reason ? ` (${triage.availability.reason})` : ""}`
+    );
+  }
+  for (const entry of triage.entries || []) {
+    lines.push(`issue: ${entry.issue.repo}#${entry.issue.number}`);
+    if (entry.issue.url) lines.push(`url: ${entry.issue.url}`);
+    if (entry.github?.state) {
+      lines.push(`github state: ${entry.github.state}${entry.github.cached ? " (cache)" : ""}`);
+    }
+    if (entry.validationStatus) lines.push(`validation status: ${entry.validationStatus}`);
+    if (entry.findings?.length) {
+      for (const finding of entry.findings.slice(0, 3)) {
+        lines.push(`finding: ${finding.message}`);
+      }
+    }
+    break;
+  }
+  return lines;
+}
+
+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/known-failures/index.mjs

@@ -194,7 +194,7 @@ export function matchesKnownFailureMatch(match, fileSummary) {
   if (match.path !== fileSummary.path) return false;
   if (match.failureKey) {
     const failureKeys = Array.isArray(fileSummary.failureDetails)
-      ? fileSummary.failureDetails.map((detail) => detail?.key)
+      ? fileSummary.failureDetails.flatMap((detail) => [detail?.key, detail?.title].filter(Boolean))
       : [];
     if (!failureKeys.includes(match.failureKey)) return false;
   }

package/lib/known-failures/index.test.mjs

@@ -59,6 +59,52 @@ describe("known failures core", () => {
     expect(matches[0].id).toBe("bad-message");
   });
 
+  it("matches failureKey against a detail title when the key becomes richer", () => {
+    const document = normalizeKnownFailuresDocument({
+      schemaVersion: 1,
+      entries: [
+        {
+          id: "missing-route",
+          title: "Missing route bug",
+          classification: "product_bug",
+          state: "open",
+          issue: {
+            repo: "acme/repo",
+            number: 13,
+            url: "https://github.com/acme/repo/issues/13",
+          },
+          description: "Wrong status code",
+          whyFailing: "The route returns 404",
+          lastReviewedAt: "2026-04-28",
+          matches: [
+            {
+              service: "api",
+              type: "int",
+              path: "__testkit__/health/http-failure.int.testkit.ts",
+              failureKey: "GET /missing returns 200",
+            },
+          ],
+        },
+      ],
+    });
+
+    const matches = findMatchingKnownFailureEntries(document, {
+      service: "api",
+      type: "int",
+      path: "__testkit__/health/http-failure.int.testkit.ts",
+      error: "Default runtime thresholds failed: checks(rate==1.0)",
+      failureDetails: [
+        {
+          key: "GET /missing > GET /missing returns 200",
+          title: "GET /missing returns 200",
+        },
+      ],
+    });
+
+    expect(matches).toHaveLength(1);
+    expect(matches[0].id).toBe("missing-route");
+  });
+
   it("validates status coverage and filesystem matches", () => {
     const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-known-failures-"));
     tempDirs.push(tempDir);

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-errors.mjs

@@ -1,3 +1,6 @@
+import path from "path";
+import { fileURLToPath } from "url";
+
 export function determineDefaultRuntimeFailure(result, summary, firstLine) {
   const fatalRuntimeError = extractDefaultRuntimeFatalError(result.stderr || "", firstLine);
   if (fatalRuntimeError) {
@@ -26,6 +29,22 @@ export function extractDefaultRuntimeFatalError(stderr, firstLine) {
   return matched?.[1]?.trim() || firstLine(stderr);
 }
 
+export function extractDefaultRuntimeFatalDetail(stderr, firstLine) {
+  if (!stderr || !/source=stacktrace/.test(stderr)) return null;
+  const message = extractDefaultRuntimeFatalError(stderr, firstLine);
+  if (!message) return null;
+
+  const location = extractFirstLocation(stderr);
+  return {
+    kind: "runtime-exception",
+    key: location ? `${location.path}:${location.line}:${location.column}` : message,
+    title: "Uncaught runtime exception",
+    message: `Uncaught testkit suite error: ${message}`,
+    location,
+    stack: sanitizeStack(stderr),
+  };
+}
+
 export function extractDefaultRuntimeThresholdFailures(summary) {
   const metrics = summary?.metrics;
   if (!metrics || typeof metrics !== "object") return [];
@@ -51,3 +70,50 @@ export function sanitizeDefaultRuntimeExitError(exitCode, output, firstLine) {
   }
   return `Default runtime failed with exit code ${exitCode}`;
 }
+
+function extractFirstLocation(stderr) {
+  const locations = [...String(stderr).matchAll(/(file:\/\/[^\s)]+|\/[^\s):]+):(\d+):(\d+)/g)].map((match) => ({
+    path: normalizeLocationPath(match[1]),
+    line: Number(match[2]),
+    column: Number(match[3]),
+  }));
+  if (locations.length === 0) return null;
+
+  return (
+    locations.find((location) => isPreferredLocation(location.path)) ||
+    locations.find((location) => !isRuntimeInternalLocation(location.path)) ||
+    locations[0]
+  );
+}
+
+function normalizeLocationPath(rawPath) {
+  if (!rawPath) return rawPath;
+  if (rawPath.startsWith("file://")) {
+    try {
+      return fileURLToPath(rawPath);
+    } catch {
+      return rawPath;
+    }
+  }
+  return rawPath;
+}
+
+function sanitizeStack(stderr) {
+  return String(stderr)
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .join("\n");
+}
+
+function isPreferredLocation(filePath) {
+  if (typeof filePath !== "string") return false;
+  const normalized = filePath.split(path.sep).join("/");
+  return normalized.includes("/.testkit/_bundles/") || normalized.includes("/__testkit__/");
+}
+
+function isRuntimeInternalLocation(filePath) {
+  if (typeof filePath !== "string") return false;
+  const normalized = filePath.split(path.sep).join("/");
+  return normalized.includes("/testkit/lib/runtime-src/k6/") || normalized.includes("/vendor/k6");
+}

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

@@ -7,15 +7,18 @@ import {
   buildFileTimeoutEnv,
   formatFileTimeoutBudgetError,
 } from "../shared/file-timeout.mjs";
-import { persistTaskArtifacts } from "./artifacts.mjs";
-import { determineDefaultRuntimeFailure } from "./default-runtime-errors.mjs";
+import { persistTaskArtifacts, persistTaskOutputArtifacts } from "./artifacts.mjs";
+import {
+  determineDefaultRuntimeFailure,
+  extractDefaultRuntimeFatalDetail,
+} from "./default-runtime-errors.mjs";
 import { collectFailureDetailsFromRuntimeArtifacts } from "./failure-details.mjs";
 import { RUNTIME_ARTIFACT_MARKER } from "../runtime-src/k6/artifacts.js";
 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 +37,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 +61,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 +110,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 +121,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,7 +129,31 @@ 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 fatalRuntimeDetail = extractDefaultRuntimeFatalDetail(result.stderr || "", getFirstLine);
+  if (fatalRuntimeDetail && !failureDetails.some((detail) => detail?.kind === "runtime-exception")) {
+    failureDetails.unshift(fatalRuntimeDetail);
+  }
   const runtimeError = timedOut
     ? formatFileTimeoutBudgetError(fileTimeoutSeconds)
     : determineDefaultRuntimeFailure(result, summary, getFirstLine);
@@ -125,7 +166,7 @@ export async function runDefaultRuntimeTask(targetConfig, task, lease, args, lif
     durationMs: finishedAt - startedAt,
     startedAt,
     finishedAt,
-    artifacts: runtimeArtifacts,
+    artifacts: [...runtimeArtifacts, ...outputArtifacts],
     failureDetails,
   };
 }

package/lib/runner/failure-details.mjs

@@ -28,6 +28,24 @@ export function normalizeFailureDetail(detail) {
   const message = normalizeNonEmptyString(detail.message);
   if (message) normalized.message = message;
 
+  if (detail.expected !== undefined) normalized.expected = cloneJsonValue(detail.expected);
+  if (detail.actual !== undefined) normalized.actual = cloneJsonValue(detail.actual);
+
+  const traceId = normalizeNonEmptyString(detail.traceId);
+  if (traceId) normalized.traceId = traceId;
+
+  const request = normalizeRecord(detail.request);
+  if (request) normalized.request = request;
+
+  const response = normalizeRecord(detail.response);
+  if (response) normalized.response = response;
+
+  const location = normalizeRecord(detail.location);
+  if (location) normalized.location = location;
+
+  const stack = normalizeNonEmptyString(detail.stack);
+  if (stack) normalized.stack = stack;
+
   return normalized;
 }
 
@@ -89,3 +107,16 @@ function normalizePositiveInteger(value) {
   if (!Number.isInteger(value) || value <= 0) return null;
   return value;
 }
+
+function normalizeRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  return cloneJsonValue(value);
+}
+
+function cloneJsonValue(value) {
+  try {
+    return JSON.parse(JSON.stringify(value));
+  } catch {
+    return String(value);
+  }
+}

package/lib/runner/failure-details.test.mjs

@@ -60,4 +60,55 @@ describe("runner failure details", () => {
       },
     ]);
   });
+
+  it("preserves rich assertion metadata", () => {
+    expect(
+      mergeFailureDetails([
+        {
+          kind: "http-assertion",
+          key: "GET /health > status is 200",
+          title: "status is 200",
+          expected: 200,
+          actual: 404,
+          request: {
+            method: "GET",
+            path: "/health",
+            requestId: "req-1",
+          },
+          response: {
+            status: 404,
+            bodyPreview: '{"error":"nope"}',
+          },
+          location: {
+            path: "/tmp/example.ts",
+            line: 12,
+            column: 4,
+          },
+        },
+      ])
+    ).toEqual([
+      {
+        kind: "http-assertion",
+        key: "GET /health > status is 200",
+        title: "status is 200",
+        count: 1,
+        expected: 200,
+        actual: 404,
+        request: {
+          method: "GET",
+          path: "/health",
+          requestId: "req-1",
+        },
+        response: {
+          status: 404,
+          bodyPreview: '{"error":"nope"}',
+        },
+        location: {
+          path: "/tmp/example.ts",
+          line: 12,
+          column: 4,
+        },
+      },
+    ]);
+  });
 });