@elench/testkit 0.1.79 → 0.1.80

package/lib/cli/presentation/colors.mjs

@@ -70,7 +70,7 @@ export function colorResultLine(line) {
 }
 
 export function colorSectionLine(line) {
-  if (line === "Failures:" || line === "Runtime Errors:" || line === "Known-failure issues:" || line === "Triage:") {
+  if (line === "Known-failure issues:" || line === "Triage:") {
     return pc.bold(line);
   }
   if (/^Summary: /.test(line)) return line.replace("Summary:", `${pc.bold("Summary:")}`);

package/lib/cli/presentation/failure-presentation.mjs

@@ -0,0 +1,31 @@
+import { buildFailurePresentation } from "../../runner/formatting.mjs";
+import { renderIndentedBlock } from "./terminal-layout.mjs";
+
+export function renderFailureBlock(task, outcome, { width, knownFailures } = {}) {
+  const presentation = buildFailurePresentation(
+    {
+      service: task.serviceName,
+      type: normalizeKnownFailureType(task),
+      path: task.file,
+      error: outcome.error || null,
+      failureDetails: Array.isArray(outcome.failureDetails) ? outcome.failureDetails : [],
+      suiteError: null,
+    },
+    knownFailures
+  );
+
+  const lines = [];
+  if (presentation.primary) {
+    lines.push(...renderIndentedBlock(presentation.primary, { width, indent: "    " }));
+  }
+  for (const detail of presentation.details) {
+    lines.push(...renderIndentedBlock(detail, { width, indent: "    " }));
+  }
+  return lines;
+}
+
+function normalizeKnownFailureType(task) {
+  if (task.framework === "playwright") return "pw";
+  if (task.type === "integration") return "int";
+  return task.type;
+}

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

@@ -1,89 +1,28 @@
 import path from "path";
-import figures from "figures";
 import {
-  buildCompactRunSummaryLines,
+  buildRunSummaryData,
   buildDebugRunSummaryLines,
   formatDuration,
 } from "../../runner/formatting.mjs";
-import { boldRed, colorSectionLine, dim, red, statusLabel } from "./colors.mjs";
-
-const ANSI_RE = /\x1b\[[0-9;]*m/g;
-const DURATION_RE = /\b(\d+m\s+\d+s|\d+s)\b/g;
-
-function stripAnsi(text) {
-  return text.replace(ANSI_RE, "");
-}
-
-function boxLines(lines) {
-  const nonEmpty = lines.filter((l) => stripAnsi(l).trim().length > 0);
-  if (nonEmpty.length === 0) return lines;
-  const maxWidth = lines.reduce((max, l) => Math.max(max, stripAnsi(l).length), 0);
-  const pad = 1;
-  const innerWidth = maxWidth + pad * 2;
-  const top = `${figures.lineDownRight}${figures.line.repeat(innerWidth)}${figures.lineDownLeft}`;
-  const bottom = `${figures.lineUpRight}${figures.line.repeat(innerWidth)}${figures.lineUpLeft}`;
-  const boxed = [top];
-  for (const line of lines) {
-    const visible = stripAnsi(line).length;
-    const right = innerWidth - pad - visible;
-    boxed.push(`${figures.lineVertical}${" ".repeat(pad)}${line}${" ".repeat(Math.max(0, right))}${figures.lineVertical}`);
-  }
-  boxed.push(bottom);
-  return boxed;
-}
-
-function colorFailureSummaryLines(lines) {
-  const result = [];
-  let inFailuresSection = false;
-  let lastWasFilePath = false;
-  for (const line of lines) {
-    const raw = stripAnsi(line);
-    if (raw === "Failures:" || raw === "Runtime Errors:") {
-      inFailuresSection = true;
-      lastWasFilePath = false;
-      result.push(line);
-      continue;
-    }
-    if (/^(Summary:|Result:|Known-failure|Triage:)/.test(raw) || raw === "") {
-      inFailuresSection = false;
-      lastWasFilePath = false;
-    }
-    if (inFailuresSection) {
-      if (/^ {2}\S/.test(raw)) {
-        lastWasFilePath = true;
-        result.push(boldRed(raw));
-        continue;
-      }
-      if (/^ {4}\S/.test(raw)) {
-        if (lastWasFilePath) {
-          lastWasFilePath = false;
-          result.push(boldRed(raw));
-        } else {
-          result.push(red(raw));
-        }
-        continue;
-      }
-    }
-    lastWasFilePath = false;
-    result.push(line);
-  }
-  return result;
-}
-
-function dimDurations(line) {
-  return line.replace(DURATION_RE, (match) => dim(match));
-}
+import { boldRed, colorSectionLine, dim, statusLabel } from "./colors.mjs";
+import { renderFailureBlock } from "./failure-presentation.mjs";
+import { renderSummaryBox } from "./summary-box.mjs";
+import { getTerminalWidth } from "./terminal-layout.mjs";
 
 export function createRunReporter({ outputMode = "compact", stdout = process.stdout, stderr = process.stderr } = {}) {
   const mode = outputMode || "compact";
   let completedCount = 0;
   let totalFileCount = 0;
+  let knownFailures = null;
 
   return {
     outputMode: mode,
     setTotalFileCount(count) {
       totalFileCount = count;
     },
+    setKnownFailures(document) {
+      knownFailures = document;
+    },
     writeLine(line = "") {
       stdout.write(`${line}\n`);
     },
@@ -142,32 +81,58 @@ export function createRunReporter({ outputMode = "compact", stdout = process.std
       completedCount += 1;
       const status = outcome.status === "skipped" ? "SKIP" : outcome.failed ? "FAIL" : "PASS";
       const duration = formatDuration(outcome.durationMs || 0);
-      const primaryFailure = firstFailureDetail(outcome);
-      const preferredFailure =
-        primaryFailure && isThresholdWrapperMessage(outcome.error) ? primaryFailure : outcome.error || primaryFailure;
       const detail =
-        status === "FAIL"
-          ? ` ${boldRed(shortenMessage(preferredFailure || "failed"))}`
-          : outcome.status === "not_run"
+        outcome.status === "not_run"
             ? ` ${dim(shortenMessage(outcome.reason || "not run"))}`
             : "";
       const progress = mode === "compact" && totalFileCount > 0 ? `${dim(`[${completedCount}/${totalFileCount}]`)} ` : "";
       stdout.write(
         `${progress}${statusLabel(status)} ${task.serviceName} ${displayTaskType(task)} ${normalizePath(task.file)} ${dim(duration)}${detail}\n`
       );
+      if (status === "FAIL") {
+        const detailLines = renderFailureBlock(task, outcome, {
+          width: getTerminalWidth(stdout, 100),
+          knownFailures,
+        });
+        for (const line of detailLines) {
+          stdout.write(`${line}\n`);
+        }
+      }
+    },
+    runtimeError(task, message) {
+      if (mode === "json") return;
+      stdout.write(`${statusLabel("FAIL")} ${task.serviceName} runtime error\n`);
+      stdout.write(`    ${boldRed(shortenMessage(message || "runtime error"))}\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);
-      const colored = colorFailureSummaryLines(lines.map((line) => colorSectionLine(line)));
-      const dimmed = colored.map((line) => dimDurations(line));
-      const boxed = boxLines(dimmed);
+      if (mode === "debug") {
+        const lines = buildDebugRunSummaryLines(results, durationMs, knownFailureIssueValidation);
+        stdout.write("\n");
+        for (const line of lines) stdout.write(`${colorSectionLine(line)}\n`);
+        return;
+      }
+
+      const summary = buildRunSummaryData(results, durationMs, knownFailureIssueValidation);
+      const rows = [
+        ["Result", summary.result],
+        ["Passed", String(summary.passed)],
+        ["Failed", String(summary.failed)],
+        ["Skipped", String(summary.skipped)],
+        ["Not run", String(summary.notRun)],
+        ["Files", String(summary.files)],
+        ["Duration", summary.duration],
+      ];
+      if (summary.serviceErrors > 0) {
+        rows.push(["Runtime errors", String(summary.serviceErrors)]);
+      }
+      if (summary.knownFailureIssues.length > 0) {
+        rows.push(["Known issues", summary.knownFailureIssues.join(", ")]);
+      }
+      const boxed = renderSummaryBox(rows, { stdout });
       stdout.write("\n");
       for (const line of boxed) stdout.write(`${line}\n`);
     },
@@ -187,15 +152,6 @@ function shortenMessage(message) {
   return String(message).replace(/\s+/g, " ").trim().slice(0, 180);
 }
 
-function firstFailureDetail(outcome) {
-  const detail = outcome.failureDetails?.[0];
-  return detail?.message || detail?.title || null;
-}
-
-function isThresholdWrapperMessage(message) {
-  return /Default runtime thresholds failed:/.test(String(message || ""));
-}
-
 function normalizePath(filePath) {
   return String(filePath).split(path.sep).join("/");
 }

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

@@ -3,17 +3,29 @@ import figures from "figures";
 import { describe, expect, it } from "vitest";
 import { createRunReporter } from "./run-reporter.mjs";
 
+function createCapture(columns = 100) {
+  let stdout = "";
+  const stream = new Writable({
+    write(chunk, _encoding, callback) {
+      stdout += chunk.toString();
+      callback();
+    },
+  });
+  stream.columns = columns;
+  return {
+    stream,
+    read() {
+      return stdout;
+    },
+  };
+}
+
 describe("run reporter setup output", () => {
   it("prints concise high-level setup summaries in compact mode", () => {
-    let stdout = "";
+    const capture = createCapture();
     const reporter = createRunReporter({
       outputMode: "compact",
-      stdout: new Writable({
-        write(chunk, _encoding, callback) {
-          stdout += chunk.toString();
-          callback();
-        },
-      }),
+      stdout: capture.stream,
     });
 
     reporter.setupOperationFinished({
@@ -25,20 +37,15 @@ describe("run reporter setup output", () => {
       durationMs: 8_000,
     });
 
-    expect(stdout).toContain(`${figures.play} RUN SETUP api template rebuild`);
-    expect(stdout).toContain("8s");
+    expect(capture.read()).toContain(`${figures.play} RUN SETUP api template rebuild`);
+    expect(capture.read()).toContain("8s");
   });
 
   it("does not print low-level setup steps in compact mode", () => {
-    let stdout = "";
+    const capture = createCapture();
     const reporter = createRunReporter({
       outputMode: "compact",
-      stdout: new Writable({
-        write(chunk, _encoding, callback) {
-          stdout += chunk.toString();
-          callback();
-        },
-      }),
+      stdout: capture.stream,
     });
 
     reporter.setupOperationFinished({
@@ -50,19 +57,14 @@ describe("run reporter setup output", () => {
       durationMs: 8_000,
     });
 
-    expect(stdout).toBe("");
+    expect(capture.read()).toBe("");
   });
 
   it("prints concise setup failures", () => {
-    let stdout = "";
+    const capture = createCapture();
     const reporter = createRunReporter({
       outputMode: "compact",
-      stdout: new Writable({
-        write(chunk, _encoding, callback) {
-          stdout += chunk.toString();
-          callback();
-        },
-      }),
+      stdout: capture.stream,
     });
 
     reporter.setupOperationFinished({
@@ -75,7 +77,110 @@ describe("run reporter setup output", () => {
       error: "Command failed with exit code 1: node scripts/fail-prepare.mjs",
     });
 
-    expect(stdout).toContain(`${figures.cross} FAIL SETUP api runtime:prepare`);
-    expect(stdout).toContain("Command failed with exit code 1");
+    expect(capture.read()).toContain(`${figures.cross} FAIL SETUP api runtime:prepare`);
+    expect(capture.read()).toContain("Command failed with exit code 1");
+  });
+});
+
+describe("run reporter task output", () => {
+  it("prints failure details on lines beneath the failed file result", () => {
+    const capture = createCapture(88);
+    const reporter = createRunReporter({
+      outputMode: "compact",
+      stdout: capture.stream,
+    });
+
+    reporter.setTotalFileCount(3);
+    reporter.taskFinished(
+      {
+        serviceName: "api",
+        type: "integration",
+        framework: "k6",
+        file: "__testkit__/health/health.int.testkit.ts",
+      },
+      {
+        status: "failed",
+        failed: true,
+        durationMs: 4_000,
+        error: "Default runtime thresholds failed: checks(rate==1.0)",
+        failureDetails: [
+          {
+            kind: "http-assertion",
+            title: "status is 200",
+            message: "GET /health expected 200, got 404",
+            request: {
+              method: "GET",
+              path: "/health",
+              requestId: "req-1",
+            },
+            response: {
+              status: 404,
+              bodyPreview: '{"error":"route not found"}',
+            },
+          },
+        ],
+      }
+    );
+
+    const lines = capture.read().trimEnd().split("\n");
+    expect(lines[0]).toContain("[1/3]");
+    expect(lines[0]).toContain(`${figures.cross} FAIL api int __testkit__/health/health.int.testkit.ts 4s`);
+    expect(lines[1]).toBe("    GET /health expected 200, got 404");
+    expect(lines[2]).toContain('    response: {"error":"route not found"}');
+    expect(lines[3]).toBe("    triage: untriaged");
+    expect(lines[4]).toBe("    logs: requestId=req-1");
+  });
+
+  it("renders a compact aggregate summary box", () => {
+    const capture = createCapture(72);
+    const reporter = createRunReporter({
+      outputMode: "compact",
+      stdout: capture.stream,
+    });
+
+    reporter.runSummary(
+      [
+        {
+          name: "api",
+          skipped: false,
+          failed: true,
+          suiteCount: 1,
+          completedSuiteCount: 1,
+          skippedSuiteCount: 0,
+          failedSuiteCount: 1,
+          totalFileCount: 3,
+          passedFileCount: 2,
+          failedFileCount: 1,
+          skippedFileCount: 0,
+          notRunFileCount: 0,
+          durationMs: 10_000,
+          suites: [],
+          errors: [],
+        },
+      ],
+      20_000,
+      {
+        summary: {
+          byCode: {
+            closed_but_failing: 2,
+            state_mismatch: 1,
+          },
+        },
+      }
+    );
+
+    const output = capture.read();
+    expect(output).toContain("┌");
+    expect(output).toContain("│ Result");
+    expect(output).toContain("FAILED");
+    expect(output).toContain("│ Passed");
+    expect(output).toContain("│ Failed");
+    expect(output).toContain("│ Skipped");
+    expect(output).toContain("│ Not run");
+    expect(output).toContain("│ Files");
+    expect(output).toContain("│ Duration");
+    expect(output).toContain("│ Known issues");
+    expect(output).not.toContain("Failures:");
+    expect(output).not.toContain("Runtime Errors:");
   });
 });

package/lib/cli/presentation/summary-box.mjs

@@ -0,0 +1,45 @@
+import figures from "figures";
+import { clamp, getTerminalWidth, measureWidth, padEndVisible, wrapText } from "./terminal-layout.mjs";
+
+export function renderSummaryBox(
+  rows,
+  {
+    stdout = process.stdout,
+    widthRatio = 0.55,
+    minWidth = 30,
+    maxWidth = 56,
+    minValueWidth = 8,
+    maxKeyWidth = 12,
+  } = {}
+) {
+  if (!Array.isArray(rows) || rows.length === 0) return [];
+
+  const terminalWidth = getTerminalWidth(stdout, 100);
+  const preferredWidth = clamp(Math.floor(terminalWidth * widthRatio), minWidth, maxWidth);
+  const maxRenderableWidth = Math.max(minWidth, Math.min(preferredWidth, terminalWidth - 1));
+  const keyWidth = Math.min(
+    maxKeyWidth,
+    Math.max(...rows.map(([label]) => measureWidth(label)), 6)
+  );
+  const minBoxWidth = keyWidth + minValueWidth + 7;
+  const boxWidth = Math.max(minBoxWidth, maxRenderableWidth);
+  const valueWidth = Math.max(minValueWidth, boxWidth - keyWidth - 7);
+
+  const top = `${figures.lineDownRight}${figures.line.repeat(boxWidth - 2)}${figures.lineDownLeft}`;
+  const bottom = `${figures.lineUpRight}${figures.line.repeat(boxWidth - 2)}${figures.lineUpLeft}`;
+  const rendered = [top];
+
+  for (const [label, value] of rows) {
+    const wrappedValueLines = wrapText(value, valueWidth);
+    for (let index = 0; index < wrappedValueLines.length; index += 1) {
+      const keyCell = index === 0 ? padEndVisible(label, keyWidth) : " ".repeat(keyWidth);
+      const valueCell = padEndVisible(wrappedValueLines[index], valueWidth);
+      rendered.push(
+        `${figures.lineVertical} ${keyCell} ${figures.lineVertical} ${valueCell} ${figures.lineVertical}`
+      );
+    }
+  }
+
+  rendered.push(bottom);
+  return rendered;
+}

package/lib/cli/presentation/summary-box.test.mjs

@@ -0,0 +1,43 @@
+import { Writable } from "stream";
+import { describe, expect, it } from "vitest";
+import { renderSummaryBox } from "./summary-box.mjs";
+
+function createStream(columns) {
+  const stream = new Writable({
+    write(_chunk, _encoding, callback) {
+      callback();
+    },
+  });
+  stream.columns = columns;
+  return stream;
+}
+
+describe("summary box", () => {
+  it("renders key/value rows inside a bounded box", () => {
+    const lines = renderSummaryBox(
+      [
+        ["Result", "FAILED"],
+        ["Passed", "203"],
+        ["Duration", "8m 56s"],
+      ],
+      { stdout: createStream(80) }
+    );
+
+    expect(lines[0]).toMatch(/^┌/);
+    expect(lines.at(-1)).toMatch(/^└/);
+    expect(lines.join("\n")).toContain("Result");
+    expect(lines.join("\n")).toContain("FAILED");
+  });
+
+  it("wraps long values instead of widening to content length", () => {
+    const lines = renderSummaryBox(
+      [["Known issues", "2 closed issues still failing, 6 state mismatches, used stale GitHub cache"]],
+      { stdout: createStream(40) }
+    );
+
+    expect(lines.length).toBeGreaterThan(4);
+    expect(lines.join("\n")).toContain("Known issues");
+    expect(lines.join("\n")).toContain("state");
+    expect(lines.join("\n")).toContain("mismatches");
+  });
+});

package/lib/cli/presentation/terminal-layout.mjs

@@ -0,0 +1,43 @@
+import stringWidth from "string-width";
+import stripAnsi from "strip-ansi";
+import wrapAnsi from "wrap-ansi";
+
+export function getTerminalWidth(stream = process.stdout, fallback = 100) {
+  const columns = Number(stream?.columns);
+  if (Number.isFinite(columns) && columns > 0) return columns;
+  return fallback;
+}
+
+export function measureWidth(text) {
+  return stringWidth(String(text ?? ""));
+}
+
+export function stripTerminalFormatting(text) {
+  return stripAnsi(String(text ?? ""));
+}
+
+export function padEndVisible(text, width) {
+  const normalized = String(text ?? "");
+  const padding = Math.max(0, width - measureWidth(normalized));
+  return `${normalized}${" ".repeat(padding)}`;
+}
+
+export function wrapText(text, width) {
+  const normalized = String(text ?? "");
+  if (width <= 0) return [normalized];
+  return wrapAnsi(normalized, width, {
+    hard: true,
+    trim: false,
+    wordWrap: true,
+  }).split("\n");
+}
+
+export function renderIndentedBlock(text, { width, indent = "    " } = {}) {
+  const visibleIndent = measureWidth(indent);
+  const contentWidth = Math.max(12, width - visibleIndent);
+  return wrapText(text, contentWidth).map((line) => `${indent}${line}`);
+}
+
+export function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}

package/lib/cli/presentation/terminal-layout.test.mjs

@@ -0,0 +1,23 @@
+import { describe, expect, it } from "vitest";
+import { getTerminalWidth, renderIndentedBlock, wrapText } from "./terminal-layout.mjs";
+
+describe("terminal layout", () => {
+  it("falls back to a default width when stream columns are unavailable", () => {
+    expect(getTerminalWidth({}, 91)).toBe(91);
+  });
+
+  it("wraps indented blocks to the provided width", () => {
+    const lines = renderIndentedBlock("response: abcdefghijklmnopqrstuvwxyz", {
+      width: 20,
+      indent: "    ",
+    });
+
+    expect(lines[0].startsWith("    ")).toBe(true);
+    expect(lines.length).toBeGreaterThan(1);
+  });
+
+  it("hard-wraps long unbroken values", () => {
+    const lines = wrapText("abcdefghijklmnopqrstuvwxyz", 8);
+    expect(lines.length).toBeGreaterThan(1);
+  });
+});

package/lib/known-failures/github.mjs

@@ -157,9 +157,8 @@ export function shouldFailKnownFailureIssueValidation(result) {
   return (result.summary?.errors || 0) > 0;
 }
 
-export function buildKnownFailureIssueValidationSummaryLines(result) {
+export function buildKnownFailureIssueValidationSummaryParts(result) {
   if (!result) return [];
-
   const parts = [];
   const byCode = result.summary?.byCode || {};
   if (byCode.closed_but_failing) {
@@ -190,6 +189,11 @@ export function buildKnownFailureIssueValidationSummaryLines(result) {
     parts.push("used stale GitHub cache");
   }
 
+  return parts;
+}
+
+export function buildKnownFailureIssueValidationSummaryLines(result) {
+  const parts = buildKnownFailureIssueValidationSummaryParts(result);
   if (parts.length === 0) return [];
 
   return [

package/lib/runner/formatting.mjs

@@ -1,4 +1,8 @@
-import { buildKnownFailureIssueValidationSummaryLines } from "../known-failures/github.mjs";
+import { findMatchingKnownFailureEntries } from "../known-failures/index.mjs";
+import {
+  buildKnownFailureIssueValidationSummaryLines,
+  buildKnownFailureIssueValidationSummaryParts,
+} from "../known-failures/github.mjs";
 
 export function formatDuration(durationMs) {
   const totalSeconds = Math.max(0, Math.round(durationMs / 1000));
@@ -52,48 +56,49 @@ export function buildRunSummaryLines(results, durationMs, knownFailureIssueValid
   return buildCompactRunSummaryLines(results, durationMs, knownFailureIssueValidation);
 }
 
+export function buildRunSummaryData(results, durationMs, knownFailureIssueValidation = null) {
+  const totals = summarizeResults(results);
+  const serviceErrors = collectServiceErrors(results);
+  const knownFailureParts = buildKnownFailureIssueValidationSummaryParts(knownFailureIssueValidation);
+  return {
+    result: totals.failedServices > 0 ? "FAILED" : "PASSED",
+    totalServices: totals.totalServices,
+    failedServices: totals.failedServices,
+    passed: totals.passedFiles,
+    failed: totals.failedFiles,
+    skipped: totals.skippedFiles,
+    notRun: totals.notRunFiles,
+    files: totals.totalFiles,
+    duration: formatDuration(durationMs),
+    serviceErrors: serviceErrors.length,
+    knownFailureIssues: knownFailureParts,
+  };
+}
+
 export function buildCompactRunSummaryLines(
   results,
   durationMs,
   knownFailureIssueValidation = null
 ) {
-  const totals = summarizeResults(results);
+  const summary = buildRunSummaryData(results, durationMs, knownFailureIssueValidation);
   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)}`,
+    `Summary: ${summary.passed} passed, ${summary.failed} failed, ${summary.skipped} skipped, ${summary.notRun} not run across ${summary.files} ${pluralize(summary.files, "file", "files")} in ${summary.duration}`,
   ];
 
-  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}`);
-    }
+  if (summary.serviceErrors > 0) {
+    lines.push(`Runtime errors: ${summary.serviceErrors}`);
   }
 
-  const knownFailureIssueLines = buildKnownFailureIssueValidationSummaryLines(
-    knownFailureIssueValidation
-  );
-  if (knownFailureIssueLines.length > 0) {
-    lines.push(...knownFailureIssueLines);
+  if (summary.knownFailureIssues.length > 0) {
+    lines.push(`Known-failure issues: ${summary.knownFailureIssues.join(", ")}`);
   }
 
   lines.push("");
   lines.push(
-    totals.failedServices > 0 ? `Result: FAILED (${totals.failedServices}/${totals.totalServices} services failed)` : "Result: PASSED"
+    summary.result === "FAILED"
+      ? `Result: FAILED (${summary.failedServices}/${summary.totalServices} services failed)`
+      : "Result: PASSED"
   );
   return lines;
 }
@@ -183,6 +188,43 @@ export function buildDebugRunSummaryLines(results, durationMs, knownFailureIssue
   return lines;
 }
 
+export function buildFailurePresentation(fileSummary, knownFailures = null) {
+  const rankedDetails = rankFailureDetails(fileSummary.failureDetails || []);
+  const primaryDetail = rankedDetails[0] || null;
+  const fallbackMessages = rankedDetails
+    .map((detail) => detail.message || detail.title)
+    .filter(Boolean)
+    .map((message) => sanitizeErrorMessage(String(message).trim()));
+  const details = [];
+
+  const responseLine = formatFailureResponsePreview(primaryDetail);
+  if (responseLine) details.push(responseLine);
+
+  const triageLine = formatInlineKnownFailureLine(fileSummary, knownFailures);
+  if (triageLine) details.push(triageLine);
+
+  const requestLine = formatFailureRequestHint(primaryDetail);
+  if (requestLine) details.push(requestLine);
+
+  for (const detail of rankedDetails.slice(primaryDetail ? 1 : 0)) {
+    const line = sanitizeInline(String(detail.message || detail.title || ""), 220);
+    if (line && !details.includes(line)) details.push(line);
+  }
+
+  return {
+    primary: sanitizeInline(
+      resolvePrimaryFailureMessage(
+        fileSummary,
+        { error: fileSummary.suiteError || null },
+        primaryDetail,
+        fallbackMessages
+      ),
+      240
+    ),
+    details,
+  };
+}
+
 function sanitizeErrorMessage(message) {
   return message
     .replace(/Command failed with exit code (\d+): .*?[\\/]vendor[\\/]k6 run\b/g, "Default runtime failed with exit code $1:")
@@ -203,46 +245,6 @@ function summarizeResults(results) {
   };
 }
 
-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());
@@ -295,32 +297,17 @@ function formatFailureRequestHint(detail) {
   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;
-  }
+function formatInlineKnownFailureLine(fileSummary, knownFailures) {
+  if (!knownFailures) return "triage: untriaged";
+  const matches = findMatchingKnownFailureEntries(knownFailures, fileSummary);
+  if (matches.length === 0) return "triage: untriaged";
 
+  const entry = matches[0];
   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") {
+  if (entry.state === "open") {
     return `triage: known issue ${issueLabel} open`;
   }
-  if (entry.github?.state === "closed" || entry.state === "closed") {
+  if (entry.state === "closed") {
     return `triage: known issue ${issueLabel} closed`;
   }
   return `triage: known issue ${issueLabel}`;

package/lib/runner/formatting.test.mjs

@@ -1,5 +1,7 @@
 import { describe, expect, it } from "vitest";
 import {
+  buildFailurePresentation,
+  buildRunSummaryData,
   buildRunSummaryLines,
   formatDuration,
   formatError,
@@ -61,8 +63,8 @@ describe("runner formatting", () => {
     expect(longestServiceName([{ name: "api" }, { name: "frontend" }])).toBe(8);
   });
 
-  it("builds printable summary lines", () => {
-    const lines = buildRunSummaryLines(
+  it("builds aggregate summary data without failure dumps", () => {
+    const summary = buildRunSummaryData(
       [
         {
           name: "frontend",
@@ -74,96 +76,42 @@ describe("runner formatting", () => {
           failedSuiteCount: 1,
           totalFileCount: 3,
           passedFileCount: 2,
+          failedFileCount: 1,
           skippedFileCount: 0,
           notRunFileCount: 0,
           durationMs: 20_000,
-          suites: [
-            {
-              failed: true,
-              type: "e2e",
-              name: "auth",
-              framework: "playwright",
-              failedFiles: ["a.pw.testkit.ts"],
-              durationMs: 12_000,
-              error: "boom",
-            },
-          ],
-          errors: ["worker broke"],
-        },
-      ],
-      20_000
-    );
-
-    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)");
-  });
-
-  it("marks services with only skipped suites as SKIP", () => {
-    const lines = buildRunSummaryLines(
-      [
-        {
-          name: "api",
-          skipped: false,
-          failed: false,
-          suiteCount: 1,
-          completedSuiteCount: 1,
-          skippedSuiteCount: 1,
-          failedSuiteCount: 0,
-          totalFileCount: 1,
-          passedFileCount: 0,
-          skippedFileCount: 1,
-          notRunFileCount: 0,
-          durationMs: 0,
-          suites: [],
-          errors: [],
-        },
-      ],
-      0
-    );
-
-    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");
-  });
-
-  it("appends known-failure issue validation summary lines", () => {
-    const lines = buildRunSummaryLines(
-      [
-        {
-          name: "api",
-          skipped: false,
-          failed: false,
-          suiteCount: 1,
-          completedSuiteCount: 1,
-          skippedSuiteCount: 0,
-          failedSuiteCount: 0,
-          totalFileCount: 1,
-          passedFileCount: 1,
-          skippedFileCount: 0,
-          notRunFileCount: 0,
-          durationMs: 1_000,
           suites: [],
-          errors: [],
+          errors: ["worker broke"],
         },
       ],
-      1_000,
+      20_000,
       {
         summary: {
           byCode: {
             closed_but_failing: 2,
-            title_mismatch: 1,
+            state_mismatch: 1,
           },
         },
       }
     );
 
-    expect(lines.join("\n")).toContain("Known-failure issues:");
-    expect(lines.join("\n")).toContain("2 closed issues still failing");
-    expect(lines.join("\n")).toContain("1 title mismatch");
+    expect(summary).toMatchObject({
+      result: "FAILED",
+      passed: 2,
+      failed: 1,
+      skipped: 0,
+      notRun: 0,
+      files: 3,
+      duration: "20s",
+      serviceErrors: 1,
+    });
+    expect(summary.knownFailureIssues).toEqual([
+      "2 closed issues still failing",
+      "1 state mismatch",
+    ]);
   });
 
-  it("prefers structured HTTP assertion details over threshold wrapper text", () => {
+  it("builds compact summary lines without failure and runtime dump sections", () => {
     const lines = buildRunSummaryLines(
       [
         {
@@ -180,63 +128,77 @@ describe("runner formatting", () => {
           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: [],
+          suites: [],
+          errors: ["worker broke"],
         },
       ],
       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:");
+    expect(lines.join("\n")).toContain("Summary: 0 passed, 1 failed, 0 skipped, 0 not run across 1 file");
+    expect(lines.join("\n")).toContain("Runtime errors: 1");
+    expect(lines.join("\n")).not.toContain("Failures:");
+    expect(lines.join("\n")).not.toContain("Runtime Errors:");
+  });
+
+  it("builds inline failure presentations from structured HTTP assertion details", () => {
+    const presentation = buildFailurePresentation(
+      {
+        service: "api",
+        type: "int",
+        path: "__testkit__/health/health.int.testkit.ts",
+        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"}',
+            },
+          },
+        ],
+      },
+      {
+        schemaVersion: 1,
+        issueRepo: "acme/example",
+        entries: [
+          {
+            id: "health-is-bad",
+            title: "Health is bad",
+            classification: "product_bug",
+            state: "open",
+            issue: {
+              repo: "acme/example",
+              number: 42,
+              url: "https://github.com/acme/example/issues/42",
+            },
+            description: "desc",
+            whyFailing: "because",
+            lastReviewedAt: "2026-01-01",
+            matches: [
+              {
+                service: "api",
+                type: "int",
+                path: "__testkit__/health/health.int.testkit.ts",
+                failureKey: "GET /health > status is 200",
+              },
+            ],
+          },
+        ],
+      }
+    );
+
+    expect(presentation.primary).toBe("GET /health expected 200, got 404");
+    expect(presentation.details).toContain('response: {"error":"nope"}');
+    expect(presentation.details).toContain("triage: known issue #42 open");
+    expect(presentation.details).toContain("logs: requestId=req-1");
   });
 });

package/lib/runner/orchestrator.mjs

@@ -61,6 +61,7 @@ export async function runAll(configs, typeValues, suiteSelectors, opts, allConfi
     configs[0]?.testkit?.reporting || null
   );
   const reporter = opts.reporter || null;
+  reporter?.setKnownFailures?.(knownFailures);
   const logRegistry = createRunLogRegistry(productDir);
   const workerState = {
     workerCount: 0,

package/lib/runner/worker-loop.mjs

@@ -81,6 +81,7 @@ export async function runWorker(
       } catch (error) {
         const message = formatError(error);
         errors.push(message);
+        reporter?.runtimeError?.(task, message);
         recordGraphError(trackers, { targetNames: lease?.context?.targetNames || [task.targetName] }, message);
         await runtimeManager.release(lease, {
           invalidate: lease !== null,

package/node_modules/@elench/next-analysis/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/next-analysis",
-  "version": "0.1.79",
+  "version": "0.1.80",
   "description": "SWC-backed Next.js source analysis primitives for Erench tools",
   "type": "module",
   "exports": {

package/node_modules/@elench/testkit-bridge/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/testkit-bridge",
-  "version": "0.1.79",
+  "version": "0.1.80",
   "description": "Browser bridge helpers for testkit",
   "type": "module",
   "main": "./dist/index.js",
@@ -22,7 +22,7 @@
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
-    "@elench/testkit-protocol": "0.1.79"
+    "@elench/testkit-protocol": "0.1.80"
   },
   "private": false
 }

package/node_modules/@elench/testkit-protocol/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/testkit-protocol",
-  "version": "0.1.79",
+  "version": "0.1.80",
   "description": "Shared browser protocol for testkit bridge and extension consumers",
   "type": "module",
   "main": "./dist/index.js",

package/node_modules/@elench/ts-analysis/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/ts-analysis",
-  "version": "0.1.79",
+  "version": "0.1.80",
   "description": "TypeScript compiler-backed source analysis primitives for Erench tools",
   "type": "module",
   "exports": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/testkit",
-  "version": "0.1.79",
+  "version": "0.1.80",
   "description": "CLI for discovering and running local HTTP, DAL, and Playwright test suites",
   "type": "module",
   "workspaces": [
@@ -81,10 +81,10 @@
   },
   "dependencies": {
     "@babel/code-frame": "^7.29.0",
-    "@elench/next-analysis": "0.1.79",
-    "@elench/testkit-bridge": "0.1.79",
-    "@elench/testkit-protocol": "0.1.79",
-    "@elench/ts-analysis": "0.1.79",
+    "@elench/next-analysis": "0.1.80",
+    "@elench/testkit-bridge": "0.1.80",
+    "@elench/testkit-protocol": "0.1.80",
+    "@elench/ts-analysis": "0.1.80",
     "@oclif/core": "^4.10.6",
     "esbuild": "^0.25.11",
     "execa": "^9.5.0",
@@ -92,7 +92,10 @@
     "ink": "^7.0.1",
     "picocolors": "^1.1.1",
     "react": "^19.2.5",
-    "typescript": "^5.9.3"
+    "string-width": "^8.1.0",
+    "strip-ansi": "^7.1.2",
+    "typescript": "^5.9.3",
+    "wrap-ansi": "^10.0.0"
   },
   "engines": {
     "node": ">=18"