@elench/testkit 0.1.53 → 0.1.55

package/lib/cli/commands/artifacts.mjs

@@ -1,6 +1,6 @@
 import { Args, Command } from "@oclif/core";
 import { sharedFlags } from "../command-helpers.mjs";
-import { collectArtifactEntries, loadLatestRunArtifact } from "../viewer.mjs";
+import { collectArtifactEntries, loadCurrentRunArtifact } from "../viewer.mjs";
 
 export default class ArtifactsCommand extends Command {
   static summary = "List persisted artifacts from the latest run";
@@ -19,7 +19,7 @@ export default class ArtifactsCommand extends Command {
   async run() {
     const { args, flags } = await this.parse(ArtifactsCommand);
     const productDir = flags.dir || process.cwd();
-    const runArtifact = loadLatestRunArtifact(productDir);
+    const runArtifact = loadCurrentRunArtifact(productDir);
     const entries = collectArtifactEntries(productDir, runArtifact, args.file || null, flags.service || null)
       .map((entry) => ({
         service: entry.service.name,

package/lib/cli/commands/logs.mjs

@@ -1,7 +1,7 @@
 import { Args, Command, Flags } from "@oclif/core";
 import { sharedFlags } from "../command-helpers.mjs";
 import { readLogTail } from "../../runner/logs.mjs";
-import { getServiceLogRefs, loadLatestRunArtifact, resolveFileSubject } from "../viewer.mjs";
+import { getServiceLogRefs, loadCurrentRunArtifact, resolveFileSubject } from "../viewer.mjs";
 import path from "path";
 
 export default class LogsCommand extends Command {
@@ -27,7 +27,7 @@ export default class LogsCommand extends Command {
   async run() {
     const { args, flags } = await this.parse(LogsCommand);
     const productDir = flags.dir || process.cwd();
-    const runArtifact = loadLatestRunArtifact(productDir);
+    const runArtifact = loadCurrentRunArtifact(productDir);
     const subject = resolveFileSubject(runArtifact, args.file || null, flags.service || null);
     const logs = getServiceLogRefs(runArtifact, subject.service.name).map((entry) => ({
       ...entry,

package/lib/cli/commands/show.mjs

@@ -1,6 +1,6 @@
 import { Args, Command, Flags } from "@oclif/core";
 import { sharedFlags } from "../command-helpers.mjs";
-import { formatFileDetail, loadLatestRunArtifact, resolveFileSubject } from "../viewer.mjs";
+import { formatFileDetail, loadCurrentRunArtifact, resolveFileSubject } from "../viewer.mjs";
 
 export default class ShowCommand extends Command {
   static summary = "Show the most useful details for one file from the latest run";
@@ -25,7 +25,7 @@ export default class ShowCommand extends Command {
   async run() {
     const { args, flags } = await this.parse(ShowCommand);
     const productDir = flags.dir || process.cwd();
-    const runArtifact = loadLatestRunArtifact(productDir);
+    const runArtifact = loadCurrentRunArtifact(productDir);
     const subject = resolveFileSubject(runArtifact, args.file || null, flags.service || null);
     const result = {
       file: subject.file,

package/lib/cli/db.mjs

@@ -3,6 +3,9 @@ import os from "os";
 import path from "path";
 import { loadConfigs, resolveProductDir } from "../config/index.mjs";
 import { captureDatabaseTemplateSnapshot, prepareDatabaseRuntime } from "../database/index.mjs";
+import { createRunReporter } from "./presentation/run-reporter.mjs";
+import { createRunLogRegistry } from "../runner/logs.mjs";
+import { createSetupOperationRegistry } from "../runner/setup-operations.mjs";
 import { resolveRuntimeInstanceConfigs } from "../runner/template.mjs";
 
 export async function runDatabaseSnapshotCaptureCommand(options = {}) {
@@ -28,16 +31,28 @@ export async function runDatabaseSnapshotCaptureCommand(options = {}) {
   }
 
   const absoluteOutputPath = path.resolve(productDir, outputPath);
+  const reporter = createRunReporter({ outputMode: options.debug ? "debug" : "compact" });
+  const logRegistry = createRunLogRegistry(productDir);
+  const setupRegistry = createSetupOperationRegistry({ logRegistry });
   try {
     for (const config of topologicallySortConfigs(resolvedConfigs)) {
       if (config.name === resolvedTarget.name) continue;
       if (config.testkit.database?.provider === "local") {
-        await prepareDatabaseRuntime(config);
+        await prepareDatabaseRuntime(config, {
+          reporter,
+          logRegistry,
+          setupRegistry,
+        });
       }
     }
-    await captureDatabaseTemplateSnapshot(resolvedTarget, absoluteOutputPath);
+    await captureDatabaseTemplateSnapshot(resolvedTarget, absoluteOutputPath, {
+      reporter,
+      logRegistry,
+      setupRegistry,
+    });
     console.log(`Wrote ${path.relative(productDir, absoluteOutputPath)}`);
   } finally {
+    logRegistry.closeAll();
     fs.rmSync(runtimeRoot, { recursive: true, force: true });
   }
 }

package/lib/cli/presentation/code-frames.mjs

@@ -0,0 +1,57 @@
+import fs from "fs";
+import path from "path";
+import { codeFrameColumns } from "@babel/code-frame";
+import { createColors } from "picocolors";
+
+const pc = createColors(Boolean(process.stdout?.isTTY || process.env.FORCE_COLOR));
+
+export function findFailureLocation(detail = {}, fallbackError = "") {
+  if (detail?.location?.path && Number.isFinite(detail?.location?.line)) {
+    return detail.location;
+  }
+
+  const stack = detail?.stack || fallbackError;
+  if (!stack) return null;
+  const match = String(stack).match(/(\/[^\s:()]+):(\d+):(\d+)/);
+  if (!match) return null;
+  return {
+    path: match[1],
+    line: Number(match[2]),
+    column: Number(match[3]),
+  };
+}
+
+export function renderCodeFrame(location, options = {}) {
+  if (!location?.path || !Number.isFinite(location.line)) return [];
+  if (!fs.existsSync(location.path)) return [];
+
+  try {
+    const source = fs.readFileSync(location.path, "utf8");
+    const frame = codeFrameColumns(
+      source,
+      {
+        start: {
+          line: location.line,
+          column: Math.max(1, Number(location.column) || 1),
+        },
+      },
+      {
+        highlightCode: Boolean(process.stdout?.isTTY || process.env.FORCE_COLOR),
+        linesAbove: options.linesAbove ?? 2,
+        linesBelow: options.linesBelow ?? 2,
+      }
+    );
+    const label = `${options.label || "code"}: ${formatLocation(location, options.cwd)}`;
+    return [pc.bold(label), ...frame.split(/\r?\n/)];
+  } catch {
+    return [];
+  }
+}
+
+export function formatLocation(location, cwd = process.cwd()) {
+  if (!location?.path || !Number.isFinite(location.line)) return null;
+  const relativePath = path.isAbsolute(location.path)
+    ? path.relative(cwd, location.path) || path.basename(location.path)
+    : location.path;
+  return `${relativePath}:${location.line}:${location.column || 1}`;
+}

package/lib/cli/presentation/code-frames.test.mjs

@@ -0,0 +1,71 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { afterEach, describe, expect, it } from "vitest";
+import { findFailureLocation, formatLocation, renderCodeFrame } from "./code-frames.mjs";
+
+const cleanups = [];
+
+afterEach(() => {
+  while (cleanups.length > 0) {
+    cleanups.pop()();
+  }
+});
+
+describe("code frame presentation", () => {
+  it("finds a location from structured failure metadata", () => {
+    expect(
+      findFailureLocation({
+        location: {
+          path: "/tmp/example.ts",
+          line: 10,
+          column: 2,
+        },
+      })
+    ).toEqual({
+      path: "/tmp/example.ts",
+      line: 10,
+      column: 2,
+    });
+  });
+
+  it("renders a code frame for a local file", () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-code-frame-"));
+    cleanups.push(() => fs.rmSync(tempDir, { recursive: true, force: true }));
+    const filePath = path.join(tempDir, "example.ts");
+    fs.writeFileSync(
+      filePath,
+      [
+        "export function run() {",
+        "  const value = 1;",
+        "  return value + missing;",
+        "}",
+      ].join("\n")
+    );
+
+    const lines = renderCodeFrame(
+      {
+        path: filePath,
+        line: 3,
+        column: 18,
+      },
+      { cwd: tempDir }
+    );
+
+    expect(lines.join("\n")).toContain("example.ts:3:18");
+    expect(lines.join("\n")).toContain("return value + missing;");
+  });
+
+  it("formats locations relative to the cwd", () => {
+    expect(
+      formatLocation(
+        {
+          path: "/tmp/example.ts",
+          line: 7,
+          column: 3,
+        },
+        "/tmp"
+      )
+    ).toBe("example.ts:7:3");
+  });
+});

package/lib/cli/presentation/colors.mjs

@@ -0,0 +1,29 @@
+import { createColors } from "picocolors";
+
+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);
+  return status;
+}
+
+export function dim(text) {
+  return pc.dim(text);
+}
+
+export function colorResultLine(line) {
+  if (/^Result: PASSED\b/.test(line)) return line.replace("PASSED", pc.green("PASSED"));
+  if (/^Result: FAILED\b/.test(line)) return line.replace("FAILED", pc.red("FAILED"));
+  return line;
+}
+
+export function colorSectionLine(line) {
+  if (line === "Failures:" || line === "Runtime Errors:" || line === "Known-failure issues:" || line === "Triage:") {
+    return pc.bold(line);
+  }
+  if (/^Summary: /.test(line)) return line.replace("Summary:", `${pc.bold("Summary:")}`);
+  return colorResultLine(line);
+}

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

@@ -4,6 +4,7 @@ import {
   buildDebugRunSummaryLines,
   formatDuration,
 } from "../../runner/formatting.mjs";
+import { colorSectionLine, colorStatus, dim } from "./colors.mjs";
 
 export function createRunReporter({ outputMode = "compact", stdout = process.stdout, stderr = process.stderr } = {}) {
   const mode = outputMode || "compact";
@@ -25,34 +26,58 @@ export function createRunReporter({ outputMode = "compact", stdout = process.std
         `[testkit] ${config.runtimeLabel || config.name}:${config.name} toolchain ${resolvedToolchain.summary}\n`
       );
     },
+    setupOperationFinished(operation) {
+      if (!operation) return;
+      if (mode === "json") return;
+      if (operation.status === "cached") return;
+      const duration = formatDuration(operation.durationMs || 0);
+      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`
+        );
+        return;
+      }
+      if (
+        mode === "compact" &&
+        isHighLevelSetupOperation(operation) &&
+        (operation.durationMs || 0) >= 5_000
+      ) {
+        const summary = shortenMessage(operation.summary || operation.stage);
+        stdout.write(`${colorStatus("RUN")} ${"SETUP"} ${operation.serviceName} ${summary} ${dim(duration)}\n`);
+      }
+    },
     localServiceStarting(config, command) {
       if (mode !== "debug") return;
       stdout.write(`Starting ${config.runtimeLabel}:${config.name}: ${command}\n`);
     },
     serviceSkipped(config, reason) {
-      stdout.write(`SKIP ${config.name} ${reason}\n`);
+      stdout.write(`${colorStatus("SKIP")} ${config.name} ${reason}\n`);
     },
     plannedSkip(entry) {
       stdout.write(
-        `SKIP ${entry.serviceName} ${entry.type} ${normalizePath(entry.file)} 0s ${shortenMessage(entry.reason || "skipped")}\n`
+        `${colorStatus("SKIP")} ${entry.serviceName} ${entry.type} ${normalizePath(entry.file)} ${dim("0s")} ${shortenMessage(entry.reason || "skipped")}\n`
       );
     },
     taskStarted(task, targetConfig) {
       if (mode !== "debug") return;
-      stdout.write(`RUN  ${targetConfig.name} ${task.type} ${task.file}\n`);
+      stdout.write(`${colorStatus("RUN").padEnd(12)} ${targetConfig.name} ${task.type} ${task.file}\n`);
     },
     taskFinished(task, outcome) {
       if (mode === "json") return;
       const status = outcome.status === "skipped" ? "SKIP" : outcome.failed ? "FAIL" : "PASS";
       const duration = formatDuration(outcome.durationMs || 0);
+      const primaryFailure = firstFailureDetail(outcome);
+      const preferredFailure =
+        primaryFailure && isThresholdWrapperMessage(outcome.error) ? primaryFailure : outcome.error || primaryFailure;
       const detail =
         status === "FAIL"
-          ? ` ${shortenMessage(outcome.error || firstFailureDetail(outcome) || "failed")}`
+          ? ` ${shortenMessage(preferredFailure || "failed")}`
           : outcome.status === "not_run"
             ? ` ${shortenMessage(outcome.reason || "not run")}`
             : "";
       stdout.write(
-        `${status} ${task.serviceName} ${displayTaskType(task)} ${normalizePath(task.file)} ${duration}${detail}\n`
+        `${colorStatus(status)} ${task.serviceName} ${displayTaskType(task)} ${normalizePath(task.file)} ${dim(duration)}${detail}\n`
       );
     },
     telemetry(message) {
@@ -64,7 +89,7 @@ export function createRunReporter({ outputMode = "compact", stdout = process.std
         mode === "debug"
           ? buildDebugRunSummaryLines(results, durationMs, knownFailureIssueValidation)
           : buildCompactRunSummaryLines(results, durationMs, knownFailureIssueValidation);
-      for (const line of lines) stdout.write(`${line}\n`);
+      for (const line of lines) stdout.write(`${colorSectionLine(line)}\n`);
     },
     error(message) {
       stderr.write(`${message}\n`);
@@ -83,9 +108,18 @@ function shortenMessage(message) {
 }
 
 function firstFailureDetail(outcome) {
-  return outcome.failureDetails?.[0]?.message || outcome.failureDetails?.[0]?.title || null;
+  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("/");
 }
+
+function isHighLevelSetupOperation(operation) {
+  return operation.kind === "database-template" || operation.kind === "runtime-prepare";
+}

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

@@ -0,0 +1,80 @@
+import { Writable } from "stream";
+import { describe, expect, it } from "vitest";
+import { createRunReporter } from "./run-reporter.mjs";
+
+describe("run reporter setup output", () => {
+  it("prints concise high-level setup summaries in compact mode", () => {
+    let stdout = "";
+    const reporter = createRunReporter({
+      outputMode: "compact",
+      stdout: new Writable({
+        write(chunk, _encoding, callback) {
+          stdout += chunk.toString();
+          callback();
+        },
+      }),
+    });
+
+    reporter.setupOperationFinished({
+      serviceName: "api",
+      stage: "template",
+      kind: "database-template",
+      summary: "template rebuild",
+      status: "passed",
+      durationMs: 8_000,
+    });
+
+    expect(stdout).toContain("RUN SETUP api template rebuild");
+    expect(stdout).toContain("8s");
+  });
+
+  it("does not print low-level setup steps in compact mode", () => {
+    let stdout = "";
+    const reporter = createRunReporter({
+      outputMode: "compact",
+      stdout: new Writable({
+        write(chunk, _encoding, callback) {
+          stdout += chunk.toString();
+          callback();
+        },
+      }),
+    });
+
+    reporter.setupOperationFinished({
+      serviceName: "api",
+      stage: "template:migrate:api:1",
+      kind: "setup-step",
+      summary: "sql-file: db/schema.sql",
+      status: "passed",
+      durationMs: 8_000,
+    });
+
+    expect(stdout).toBe("");
+  });
+
+  it("prints concise setup failures", () => {
+    let stdout = "";
+    const reporter = createRunReporter({
+      outputMode: "compact",
+      stdout: new Writable({
+        write(chunk, _encoding, callback) {
+          stdout += chunk.toString();
+          callback();
+        },
+      }),
+    });
+
+    reporter.setupOperationFinished({
+      serviceName: "api",
+      stage: "runtime:prepare",
+      kind: "runtime-prepare",
+      summary: "runtime prepare",
+      status: "failed",
+      durationMs: 1_200,
+      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");
+  });
+});

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

@@ -1,15 +1,25 @@
+import fs from "fs";
+import path from "path";
 import React, { createElement, useEffect, useMemo, useState } from "react";
 import { Box, Text, useApp, useInput } from "ink";
 import { formatDuration } from "../../runner/formatting.mjs";
-import { formatFileDetail, loadLatestRunArtifact, resolveFileSubject } from "../viewer.mjs";
+import { formatFileDetail, loadCurrentRunArtifact } from "../viewer.mjs";
 
 export function WatchApp({ productDir, serviceFilter = null }) {
   const { exit } = useApp();
   const [artifact, setArtifact] = useState(() => safeLoadArtifact(productDir));
-  const [selectedIndex, setSelectedIndex] = useState(0);
+  const [view, setView] = useState("files");
+  const [selectedFileIndex, setSelectedFileIndex] = useState(0);
+  const [selectedSetupIndex, setSelectedSetupIndex] = useState(0);
 
   const files = useMemo(() => collectFiles(artifact, serviceFilter), [artifact, serviceFilter]);
-  const selected = files[Math.min(selectedIndex, Math.max(0, files.length - 1))] || null;
+  const setupOperations = useMemo(
+    () => collectSetupOperations(artifact, serviceFilter),
+    [artifact, serviceFilter]
+  );
+  const selectedFile = files[Math.min(selectedFileIndex, Math.max(0, files.length - 1))] || null;
+  const selectedSetup =
+    setupOperations[Math.min(selectedSetupIndex, Math.max(0, setupOperations.length - 1))] || null;
 
   useEffect(() => {
     const timer = setInterval(() => {
@@ -18,6 +28,14 @@ export function WatchApp({ productDir, serviceFilter = null }) {
     return () => clearInterval(timer);
   }, [productDir]);
 
+  useEffect(() => {
+    setSelectedFileIndex((current) => Math.min(current, Math.max(0, files.length - 1)));
+  }, [files.length]);
+
+  useEffect(() => {
+    setSelectedSetupIndex((current) => Math.min(current, Math.max(0, setupOperations.length - 1)));
+  }, [setupOperations.length]);
+
   useInput((input, key) => {
     if (input === "q") {
       exit();
@@ -27,12 +45,27 @@ export function WatchApp({ productDir, serviceFilter = null }) {
       setArtifact(safeLoadArtifact(productDir));
       return;
     }
+    if (key.tab || input === "s") {
+      setView((current) => {
+        if (current === "files" && setupOperations.length > 0) return "setup";
+        return "files";
+      });
+      return;
+    }
     if (key.downArrow) {
-      setSelectedIndex((current) => Math.min(current + 1, Math.max(0, files.length - 1)));
+      if (view === "setup") {
+        setSelectedSetupIndex((current) => Math.min(current + 1, Math.max(0, setupOperations.length - 1)));
+      } else {
+        setSelectedFileIndex((current) => Math.min(current + 1, Math.max(0, files.length - 1)));
+      }
       return;
     }
     if (key.upArrow) {
-      setSelectedIndex((current) => Math.max(0, current - 1));
+      if (view === "setup") {
+        setSelectedSetupIndex((current) => Math.max(0, current - 1));
+      } else {
+        setSelectedFileIndex((current) => Math.max(0, current - 1));
+      }
     }
   });
 
@@ -46,7 +79,7 @@ export function WatchApp({ productDir, serviceFilter = null }) {
     createElement(
       Text,
       null,
-      `testkit watch · q quit · r reload · ${artifact.run.status} · ${formatDuration(artifact.run.durationMs)}`
+      `testkit watch · q quit · r reload · tab toggle · ${artifact.run.status} · ${formatDuration(artifact.run.durationMs)}`
     ),
     createElement(
       Box,
@@ -54,22 +87,21 @@ export function WatchApp({ productDir, serviceFilter = null }) {
       createElement(
         Box,
         { width: "40%", flexDirection: "column", marginRight: 2 },
-        createElement(Text, null, "Files"),
-        ...files.map((entry, index) => {
-          const prefix = index === selectedIndex ? ">" : " ";
-          return createElement(
-            Text,
-            { key: `${entry.service.name}:${entry.file.path}` },
-            `${prefix} ${entry.file.status.toUpperCase().padEnd(7)} ${entry.file.path}`
-          );
-        })
+        createElement(Text, null, view === "setup" ? "Setup" : "Files"),
+        ...(view === "setup"
+          ? renderSetupEntries(setupOperations, selectedSetupIndex)
+          : renderFileEntries(files, selectedFileIndex))
       ),
       createElement(
         Box,
         { width: "60%", flexDirection: "column" },
         createElement(Text, null, "Details"),
-        ...(selected
-          ? formatFileDetail(productDir, artifact, selected, { logTail: 8 })
+        ...(view === "setup"
+          ? formatSetupDetail(productDir, selectedSetup)
+              .slice(0, 28)
+              .map((line, index) => createElement(Text, { key: `${index}:${line}` }, line))
+          : selectedFile
+          ? formatFileDetail(productDir, artifact, selectedFile, { logTail: 8 })
               .slice(0, 28)
               .map((line, index) => createElement(Text, { key: `${index}:${line}` }, line))
           : [createElement(Text, { key: "empty" }, "No file results")])
@@ -80,7 +112,7 @@ export function WatchApp({ productDir, serviceFilter = null }) {
 
 function safeLoadArtifact(productDir) {
   try {
-    return loadLatestRunArtifact(productDir);
+    return loadCurrentRunArtifact(productDir);
   } catch {
     return null;
   }
@@ -102,3 +134,87 @@ function collectFiles(runArtifact, serviceFilter) {
     left.file.path.localeCompare(right.file.path)
   );
 }
+
+function renderFileEntries(files, selectedIndex) {
+  return files.map((entry, index) => {
+    const prefix = index === selectedIndex ? ">" : " ";
+    return createElement(
+      Text,
+      { key: `${entry.service.name}:${entry.file.path}` },
+      `${prefix} ${entry.file.status.toUpperCase().padEnd(7)} ${entry.file.path}`
+    );
+  });
+}
+
+function collectSetupOperations(runArtifact, serviceFilter) {
+  if (!runArtifact) return [];
+  return [...(runArtifact.setup?.operations || [])]
+    .filter((entry) => !serviceFilter || entry.serviceName === serviceFilter)
+    .sort((left, right) => {
+      return (
+        setupStatusRank(left.status) - setupStatusRank(right.status) ||
+        String(left.serviceName || "").localeCompare(String(right.serviceName || "")) ||
+        String(left.startedAt || "").localeCompare(String(right.startedAt || "")) ||
+        String(left.stage || "").localeCompare(String(right.stage || ""))
+      );
+    });
+}
+
+function renderSetupEntries(operations, selectedIndex) {
+  return operations.map((entry, index) => {
+    const prefix = index === selectedIndex ? ">" : " ";
+    const duration = entry.durationMs == null ? "" : ` ${formatDuration(entry.durationMs)}`;
+    return createElement(
+      Text,
+      { key: entry.id },
+      `${prefix} ${String(entry.status || "").toUpperCase().padEnd(7)} ${entry.serviceName} ${entry.stage}${duration}`
+    );
+  });
+}
+
+function formatSetupDetail(productDir, operation) {
+  if (!operation) return ["No setup operations"];
+  const lines = [
+    `Service: ${operation.serviceName}`,
+    `Stage: ${operation.stage}`,
+    `Status: ${operation.status}`,
+  ];
+  if (operation.durationMs != null) {
+    lines.push(`Duration: ${formatDuration(operation.durationMs)}`);
+  }
+  if (operation.summary) {
+    lines.push(`Summary: ${operation.summary}`);
+  }
+  if (operation.error) {
+    lines.push(`Error: ${operation.error}`);
+  }
+  if (operation.logRef?.path) {
+    lines.push("");
+    lines.push("Log:");
+    lines.push(`  ${operation.logRef.path}`);
+    const absolutePath = path.join(productDir, operation.logRef.path);
+    for (const line of readTailSafe(absolutePath, 12)) {
+      lines.push(`  ${line}`);
+    }
+  }
+  return lines;
+}
+
+function readTailSafe(absolutePath, maxLines) {
+  try {
+    return fs.readFileSync(absolutePath, "utf8")
+      .split(/\r?\n/)
+      .filter(Boolean)
+      .slice(-maxLines);
+  } catch {
+    return [];
+  }
+}
+
+function setupStatusRank(status) {
+  if (status === "failed") return 1;
+  if (status === "running") return 2;
+  if (status === "passed") return 3;
+  if (status === "cached") return 4;
+  return 5;
+}