@elench/testkit 0.1.78 → 0.1.80

package/lib/cli/presentation/colors.mjs

@@ -1,12 +1,21 @@
 import { createColors } from "picocolors";
+import figures from "figures";
 
 const pc = createColors(Boolean(process.stdout?.isTTY || process.env.FORCE_COLOR));
 
 export function colorStatus(status) {
-  if (status === "PASS") return pc.green(status);
-  if (status === "FAIL") return pc.red(status);
-  if (status === "SKIP") return pc.yellow(status);
-  if (status === "RUN") return pc.cyan(status);
+  if (status === "PASS") return pc.green(figures.tick);
+  if (status === "FAIL") return pc.red(figures.cross);
+  if (status === "SKIP") return pc.yellow(figures.arrowDown);
+  if (status === "RUN") return pc.cyan(figures.play);
+  return status;
+}
+
+export function statusLabel(status) {
+  if (status === "PASS") return pc.green(`${figures.tick} PASS`);
+  if (status === "FAIL") return pc.red(`${figures.cross} FAIL`);
+  if (status === "SKIP") return pc.yellow(`${figures.arrowDown} SKIP`);
+  if (status === "RUN") return pc.cyan(`${figures.play} RUN`);
   return status;
 }
 
@@ -18,6 +27,14 @@ export function bold(text) {
   return pc.bold(text);
 }
 
+export function boldRed(text) {
+  return pc.bold(pc.red(text));
+}
+
+export function red(text) {
+  return pc.red(text);
+}
+
 export function muted(text) {
   return pc.dim(text);
 }
@@ -53,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/discovery-reporter.mjs

@@ -5,13 +5,18 @@ import {
   colorDiagnosticSeverity,
   colorHeading,
   colorService,
-  colorStatus,
   colorTypeBadge,
   muted,
+  statusLabel,
 } from "./colors.mjs";
 
 const TYPE_ORDER = ["int", "e2e", "scenario", "dal", "load", "pw"];
 
+const TREE_BRANCH = "\u251C\u2500\u2500 ";
+const TREE_LAST = "\u2514\u2500\u2500 ";
+const TREE_PIPE = "\u2502   ";
+const TREE_SPACE = "    ";
+
 export function buildDiscoveryReportLines(result, options = {}) {
   const mode = options.outputMode || "compact";
   return mode === "verbose" ? buildVerboseLines(result) : buildCompactLines(result);
@@ -20,7 +25,7 @@ export function buildDiscoveryReportLines(result, options = {}) {
 function buildCompactLines(result) {
   const lines = [];
   lines.push(
-    `${colorHeading("Summary")} ${result.summary.files} files · ${result.summary.activeFiles} active · ${result.summary.skippedFiles} skipped · ${result.summary.suites} suites · ${result.summary.services} services`
+    `${colorHeading("Summary")} ${result.summary.files} files \u00B7 ${result.summary.activeFiles} active \u00B7 ${result.summary.skippedFiles} skipped \u00B7 ${result.summary.suites} suites \u00B7 ${result.summary.services} services`
   );
 
   if (result.history?.available) {
@@ -35,17 +40,33 @@ function buildCompactLines(result) {
   for (const service of result.services) {
     lines.push("");
     lines.push(
-      `${colorService(service.name)} ${muted(`(${service.fileCount} files${service.dependsOn.length > 0 ? ` · depends on ${service.dependsOn.join(", ")}` : ""})`)}`
+      `${colorService(service.name)} ${muted(`(${service.fileCount} files${service.dependsOn.length > 0 ? ` \u00B7 depends on ${service.dependsOn.join(", ")}` : ""})`)}`
     );
     const typeGroups = suitesByService.get(service.name) || new Map();
-    for (const type of orderedTypes([...typeGroups.keys()])) {
+    const types = orderedTypes([...typeGroups.keys()]);
+
+    for (let ti = 0; ti < types.length; ti++) {
+      const type = types[ti];
+      const isLastType = ti === types.length - 1;
+      const typeConnector = isLastType ? TREE_LAST : TREE_BRANCH;
+      const typePrefix = isLastType ? TREE_SPACE : TREE_PIPE;
       const suites = typeGroups.get(type) || [];
-      lines.push(`  ${colorTypeBadge(type.toUpperCase())} ${formatSelectionTypeLabel(type)}`);
-      for (const suite of suites) {
-        lines.push(`    ${bold(suite.groupLabel)} ${muted(`(${suite.fileCount} files)`)}`);
-        for (const file of filesBySuite.get(suite.id) || []) {
-          const status = file.skipped ? `${colorStatus("SKIP")} ${file.skipReason}` : muted(buildHistoryHint(file));
-          lines.push(`      ${file.displayName}${status ? `  ${status}` : ""}`);
+      lines.push(`${typeConnector}${colorTypeBadge(type.toUpperCase())} ${formatSelectionTypeLabel(type)}`);
+
+      for (let si = 0; si < suites.length; si++) {
+        const suite = suites[si];
+        const isLastSuite = si === suites.length - 1;
+        const suiteConnector = isLastSuite ? TREE_LAST : TREE_BRANCH;
+        const suitePrefix = isLastSuite ? TREE_SPACE : TREE_PIPE;
+        lines.push(`${typePrefix}${suiteConnector}${bold(suite.groupLabel)} ${muted(`(${suite.fileCount} files)`)}`);
+
+        const files = filesBySuite.get(suite.id) || [];
+        for (let fi = 0; fi < files.length; fi++) {
+          const file = files[fi];
+          const isLastFile = fi === files.length - 1;
+          const fileConnector = isLastFile ? TREE_LAST : TREE_BRANCH;
+          const status = file.skipped ? `${statusLabel("SKIP")} ${file.skipReason}` : muted(buildHistoryHint(file));
+          lines.push(`${typePrefix}${suitePrefix}${fileConnector}${file.displayName}${status ? `  ${status}` : ""}`);
         }
       }
     }
@@ -73,7 +94,7 @@ function buildVerboseLines(result) {
     if (service.dependsOn.length > 0) {
       lines.push(`  dependsOn ${service.dependsOn.join(", ")}`);
     }
-    lines.push(`  files ${service.fileCount} · active ${service.activeFileCount} · skipped ${service.skippedFileCount}`);
+    lines.push(`  files ${service.fileCount} \u00B7 active ${service.activeFileCount} \u00B7 skipped ${service.skippedFileCount}`);
 
     const suites = result.suites.filter((suite) => suite.service === service.name).sort(compareSuites);
     for (const suite of suites) {
@@ -162,5 +183,5 @@ function buildHistoryHint(file) {
     file.history.firstSeenAt ? `seen ${file.history.firstSeenAt.slice(0, 10)}` : null,
   ]
     .filter(Boolean)
-    .join(" · ");
+    .join(" \u00B7 ");
 }

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,15 +1,28 @@
 import path from "path";
 import {
-  buildCompactRunSummaryLines,
+  buildRunSummaryData,
   buildDebugRunSummaryLines,
   formatDuration,
 } from "../../runner/formatting.mjs";
-import { colorSectionLine, colorStatus, dim } from "./colors.mjs";
+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`);
     },
@@ -34,7 +47,7 @@ export function createRunReporter({ outputMode = "compact", stdout = process.std
       if (operation.status === "failed") {
         const detail = shortenMessage(operation.error || operation.summary || operation.stage);
         stdout.write(
-          `${colorStatus("FAIL")} ${"SETUP"} ${operation.serviceName} ${operation.stage} ${dim(duration)} ${detail}\n`
+          `${statusLabel("FAIL")} ${"SETUP"} ${operation.serviceName} ${operation.stage} ${dim(duration)} ${boldRed(detail)}\n`
         );
         return;
       }
@@ -44,7 +57,7 @@ export function createRunReporter({ outputMode = "compact", stdout = process.std
         (operation.durationMs || 0) >= 5_000
       ) {
         const summary = shortenMessage(operation.summary || operation.stage);
-        stdout.write(`${colorStatus("RUN")} ${"SETUP"} ${operation.serviceName} ${summary} ${dim(duration)}\n`);
+        stdout.write(`${statusLabel("RUN")} ${"SETUP"} ${operation.serviceName} ${summary} ${dim(duration)}\n`);
       }
     },
     localServiceStarting(config, command) {
@@ -52,44 +65,76 @@ export function createRunReporter({ outputMode = "compact", stdout = process.std
       stdout.write(`Starting ${config.runtimeLabel}:${config.name}: ${command}\n`);
     },
     serviceSkipped(config, reason) {
-      stdout.write(`${colorStatus("SKIP")} ${config.name} ${reason}\n`);
+      stdout.write(`${statusLabel("SKIP")} ${config.name} ${reason}\n`);
     },
     plannedSkip(entry) {
       stdout.write(
-        `${colorStatus("SKIP")} ${entry.serviceName} ${entry.type} ${normalizePath(entry.file)} ${dim("0s")} ${shortenMessage(entry.reason || "skipped")}\n`
+        `${statusLabel("SKIP")} ${entry.serviceName} ${entry.type} ${normalizePath(entry.file)} ${dim("0s")} ${shortenMessage(entry.reason || "skipped")}\n`
       );
     },
     taskStarted(task, targetConfig) {
       if (mode !== "debug") return;
-      stdout.write(`${colorStatus("RUN").padEnd(12)} ${targetConfig.name} ${task.type} ${task.file}\n`);
+      stdout.write(`${statusLabel("RUN")} ${targetConfig.name} ${task.type} ${task.file}\n`);
     },
     taskFinished(task, outcome) {
       if (mode === "json") return;
+      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"
-          ? ` ${shortenMessage(preferredFailure || "failed")}`
-          : outcome.status === "not_run"
-            ? ` ${shortenMessage(outcome.reason || "not run")}`
+        outcome.status === "not_run"
+            ? ` ${dim(shortenMessage(outcome.reason || "not run"))}`
             : "";
+      const progress = mode === "compact" && totalFileCount > 0 ? `${dim(`[${completedCount}/${totalFileCount}]`)} ` : "";
       stdout.write(
-        `${colorStatus(status)} ${task.serviceName} ${displayTaskType(task)} ${normalizePath(task.file)} ${dim(duration)}${detail}\n`
+        `${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);
-      for (const line of lines) stdout.write(`${colorSectionLine(line)}\n`);
+      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`);
     },
     error(message) {
       stderr.write(`${message}\n`);
@@ -107,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

@@ -1,18 +1,31 @@
 import { Writable } from "stream";
+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({
@@ -24,20 +37,15 @@ describe("run reporter setup output", () => {
       durationMs: 8_000,
     });
 
-    expect(stdout).toContain("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({
@@ -49,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({
@@ -74,7 +77,110 @@ describe("run reporter setup output", () => {
       error: "Command failed with exit code 1: node scripts/fail-prepare.mjs",
     });
 
-    expect(stdout).toContain("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,
@@ -121,6 +122,7 @@ export async function runAll(configs, typeValues, suiteSelectors, opts, allConfi
       const timings = loadTimings(productDir);
       const graphs = buildRuntimeGraphs(executedPlans);
       const queue = buildTaskQueue(executedPlans, graphs, timings);
+      reporter?.setTotalFileCount?.(queue.length);
       for (const task of queue) {
         task.scenarioSeed = opts.scenarioSeed || null;
       }

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.78",
+  "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.78",
+  "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.78"
+    "@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.78",
+  "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.78",
+  "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.78",
+  "version": "0.1.80",
   "description": "CLI for discovering and running local HTTP, DAL, and Playwright test suites",
   "type": "module",
   "workspaces": [
@@ -81,17 +81,21 @@
   },
   "dependencies": {
     "@babel/code-frame": "^7.29.0",
-    "@elench/next-analysis": "0.1.78",
-    "@elench/testkit-bridge": "0.1.78",
-    "@elench/testkit-protocol": "0.1.78",
-    "@elench/ts-analysis": "0.1.78",
+    "@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",
+    "figures": "^6.1.0",
     "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"