@mmerterden/multi-agent-pipeline 20.2.1 → 20.3.1

package/pipeline/scripts/test-summary.mjs

@@ -0,0 +1,651 @@
+#!/usr/bin/env node
+/**
+ * test-summary.mjs  -  how many tests ran, read from the runner's own output.
+ *
+ * A green exit or a "TEST SUCCEEDED" line says nothing about how many tests it
+ * covers: xcodebuild prints it for a target with no tests, Gradle prints BUILD
+ * SUCCESSFUL for a NO-SOURCE test task, `go test` prints `ok` with
+ * `[no tests to run]`. This reads the counts instead, per runner, and reports
+ * what it could not read as unread rather than guessing.
+ *
+ * Every parser returns null when the text is not its runner's, a result with
+ * counts when it is, or a result with `executed: null` and a reason when the
+ * runner is recognised but its output carries no counts (Gradle on success,
+ * `go test` without -v, a build that failed before any test ran).
+ *
+ * Counting rules, the same for every runner:
+ *   executed = tests that ran to a verdict (passed + failed); skipped tests are
+ *              not executed, so a run that skipped everything is a zero run
+ *   failed   = failures + errors
+ *   skipped  = skipped + ignored + todo
+ *   status   = passed | failed | no-tests | unparsed
+ *
+ * Usage:
+ *   node test-summary.mjs --log <file|-> [--parser <id>] [--stack <id>] [--json]
+ *   node test-summary.mjs --junit <file|dir> [--json]
+ *   node test-summary.mjs --xcresult <bundle> [--json]        (needs xcrun)
+ *   node test-summary.mjs --xcresult-json <file> [--json]     (a captured summary)
+ *
+ * While the quality gates are active (lib/unattended.mjs, gatesActive:
+ * MULTI_AGENT_UNATTENDED=1 or a run in autopilot mode) the result is appended to state.gates[] as
+ * `test-summary` (gate-ledger.mjs, `--state` or the run's own state): passed is
+ * a pass, failed and no-tests are failures, unparsed is not-applicable because
+ * the evidence gate's markers still decide that case.
+ *
+ * Exit: 0 passed · 1 failed · 2 usage · 3 no tests executed · 4 unparsed
+ *
+ * @module pipeline/scripts/test-summary
+ */
+
+import { spawnSync } from "node:child_process";
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+
+import { invokedDirectly } from "../lib/invoked-directly.mjs";
+
+const EMPTY = { executed: null, passed: null, failed: null, skipped: null };
+
+function status(r) {
+  if (r.executed === null) return "unparsed";
+  if (r.failed > 0) return "failed";
+  if (r.executed === 0) return "no-tests";
+  return "passed";
+}
+
+function counted(parser, { passed, failed, skipped = 0 }) {
+  return { executed: passed + failed, passed, failed, skipped, parser };
+}
+
+function uncountable(parser, reason) {
+  return { ...EMPTY, parser, reason };
+}
+
+const int = (s) => (s === undefined ? 0 : Number.parseInt(s, 10));
+
+// ---------------------------------------------------------------------------
+// xcodebuild: XCTest lines, Swift Testing lines, or the "Executed" summary.
+
+function parseXcodebuild(text) {
+  const xctest = new Map();
+  for (const m of text.matchAll(/^Test [Cc]ase '([^']+)' (passed|failed|skipped)\b/gm)) {
+    xctest.set(m[1], m[2]);
+  }
+  const swift = new Map();
+  for (const m of text.matchAll(
+    /^\S+ Test (?!run with )(.+?) (passed|failed|skipped)(?: after|\.|$)/gm,
+  )) {
+    swift.set(m[1], m[2]);
+  }
+  const executedLines = [
+    ...text.matchAll(
+      /Executed (\d+) tests?, with (?:(\d+) tests? skipped and )?(\d+) failures? \(\d+ unexpected\)/g,
+    ),
+  ];
+  const buildFailed =
+    /Testing cancelled because the build failed/.test(text) ||
+    (/\*\* (?:TEST|BUILD) FAILED \*\*/.test(text) &&
+      /\berror: /.test(text) &&
+      xctest.size + swift.size === 0);
+  const recognised =
+    xctest.size > 0 ||
+    swift.size > 0 ||
+    executedLines.length > 0 ||
+    /\*\* TEST (?:SUCCEEDED|FAILED) \*\*/.test(text);
+  if (!recognised) return null;
+
+  if (xctest.size + swift.size > 0) {
+    const tally = { passed: 0, failed: 0, skipped: 0 };
+    for (const v of [...xctest.values(), ...swift.values()]) tally[v]++;
+    return counted("xcodebuild", tally);
+  }
+  if (executedLines.length > 0) {
+    const last = executedLines[executedLines.length - 1];
+    const total = int(last[1]);
+    const skipped = int(last[2]);
+    const ran = total - skipped;
+    const failed = Math.min(int(last[3]), ran);
+    return counted("xcodebuild", { passed: ran - failed, failed, skipped });
+  }
+  if (buildFailed) return uncountable("xcodebuild", "the build failed before any test ran");
+  return uncountable("xcodebuild", "xcodebuild printed a verdict but no test counts");
+}
+
+// ---------------------------------------------------------------------------
+// Gradle console: the "N tests completed" line on failure, per-test event lines
+// when testLogging enables them, or every test task NO-SOURCE or SKIPPED.
+
+function parseGradle(text) {
+  if (!/^> Task :|^BUILD (?:SUCCESSFUL|FAILED)\b/m.test(text)) return null;
+  const summary = [
+    ...text.matchAll(/(\d+) tests? completed, (\d+) failed(?:, (\d+) skipped)?/g),
+  ].pop();
+  if (summary) {
+    const skipped = int(summary[3]);
+    const failed = int(summary[2]);
+    return counted("gradle", { passed: int(summary[1]) - skipped - failed, failed, skipped });
+  }
+  // Gradle logs FAILED events by default and PASSED ones only when testLogging
+  // asks for them, so the event lines are a full count only when a PASSED is
+  // among them.
+  const events = new Map();
+  for (const m of text.matchAll(/^(\S.*) > (.+?) (PASSED|FAILED|SKIPPED)$/gm)) {
+    events.set(`${m[1]} > ${m[2]}`, m[3]);
+  }
+  if ([...events.values()].includes("PASSED")) {
+    const tally = { passed: 0, failed: 0, skipped: 0 };
+    for (const v of events.values()) {
+      tally[{ PASSED: "passed", FAILED: "failed", SKIPPED: "skipped" }[v]]++;
+    }
+    return counted("gradle", tally);
+  }
+  const testTasks = [...text.matchAll(/^> Task :\S*[tT]est\S*(?: (\S+))?$/gm)];
+  if (testTasks.length > 0 && testTasks.every((m) => m[1] === "NO-SOURCE" || m[1] === "SKIPPED")) {
+    return counted("gradle", { passed: 0, failed: 0 });
+  }
+  return uncountable(
+    "gradle",
+    "Gradle prints test counts only when a test fails; read the JUnit XML under build/test-results",
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Maven Surefire: the aggregate "Tests run" line after "Results:", else the
+// per-class lines summed.
+
+function parseMaven(text) {
+  if (/No tests to run\./.test(text)) return counted("maven", { passed: 0, failed: 0 });
+  const lines = [
+    ...text.matchAll(/^.*Tests run: (\d+), Failures: (\d+), Errors: (\d+), Skipped: (\d+)(.*)$/gm),
+  ];
+  if (lines.length === 0) {
+    return /Tests are skipped\./.test(text) ? counted("maven", { passed: 0, failed: 0 }) : null;
+  }
+  const aggregate = lines.filter((m) => !/Time elapsed/.test(m[5])).pop();
+  const t = { run: 0, f: 0, e: 0, s: 0 };
+  for (const m of aggregate ? [aggregate] : lines) {
+    t.run += int(m[1]);
+    t.f += int(m[2]);
+    t.e += int(m[3]);
+    t.s += int(m[4]);
+  }
+  return counted("maven", { passed: t.run - t.s - t.f - t.e, failed: t.f + t.e, skipped: t.s });
+}
+
+// ---------------------------------------------------------------------------
+// pytest: the last "=== ... in 0.12s ===" line, or the -q form without rules.
+
+const PYTEST_LINE =
+  /^(?:=+ )?((?:\d+ (?:passed|failed|skipped|xfailed|xpassed|errors?|deselected|warnings?|rerun)(?:, )?)+|no tests ran) in [\d.]+s(?: \([^)]*\))?(?: =+)?$/gm;
+
+function parsePytest(text) {
+  const last = [...text.matchAll(PYTEST_LINE)].pop();
+  if (!last) return null;
+  if (last[1] === "no tests ran") return counted("pytest", { passed: 0, failed: 0 });
+  const n = {};
+  for (const m of last[1].matchAll(/(\d+) (\w+)/g)) n[m[2].replace(/s$/, "")] = int(m[1]);
+  const g = (k) => n[k] ?? 0;
+  return counted("pytest", {
+    passed: g("passed") + g("xfailed") + g("xpassed"),
+    failed: g("failed") + g("error"),
+    skipped: g("skipped"),
+  });
+}
+
+// ---------------------------------------------------------------------------
+// jest: "Tests:  1 failed, 1 skipped, 3 passed, 6 total".
+
+function parseJest(text) {
+  if (/^No tests found, exiting with code \d/m.test(text)) {
+    return counted("jest", { passed: 0, failed: 0 });
+  }
+  const last = [...text.matchAll(/^Tests:\s+(.+)$/gm)].pop();
+  if (!last) return null;
+  const n = {};
+  for (const m of last[1].matchAll(/(\d+) (failed|skipped|todo|passed|total)/g)) {
+    n[m[2]] = int(m[1]);
+  }
+  return counted("jest", {
+    passed: n.passed ?? 0,
+    failed: n.failed ?? 0,
+    skipped: (n.skipped ?? 0) + (n.todo ?? 0),
+  });
+}
+
+// ---------------------------------------------------------------------------
+// vitest: "      Tests  1 failed | 3 passed | 1 skipped (5)".
+
+function parseVitest(text) {
+  if (/^No test files found, exiting with code \d/m.test(text)) {
+    return counted("vitest", { passed: 0, failed: 0 });
+  }
+  const last = [...text.matchAll(/^\s*Tests\s{2,}(.+?)\s*\((\d+)\)\s*$/gm)].pop();
+  if (!last) return null;
+  const n = {};
+  for (const m of last[1].matchAll(/(\d+) (failed|passed|skipped|todo)/g)) n[m[2]] = int(m[1]);
+  return counted("vitest", {
+    passed: n.passed ?? 0,
+    failed: n.failed ?? 0,
+    skipped: (n.skipped ?? 0) + (n.todo ?? 0),
+  });
+}
+
+// ---------------------------------------------------------------------------
+// node --test: the trailing "# pass N" block (TAP) or "ℹ pass N" (spec).
+
+function parseNodeTest(text) {
+  const n = {};
+  for (const m of text.matchAll(/^[#ℹ] (tests|pass|fail|cancelled|skipped|todo) (\d+)$/gm)) {
+    n[m[1]] = int(m[2]);
+  }
+  if (n.pass === undefined || n.fail === undefined) return null;
+  return counted("node-test", {
+    passed: n.pass,
+    failed: n.fail + (n.cancelled ?? 0),
+    skipped: (n.skipped ?? 0) + (n.todo ?? 0),
+  });
+}
+
+// ---------------------------------------------------------------------------
+// go test. A parent whose subtests reported is not counted again: its verdict
+// is the sum of theirs.
+
+function leafTally(verdicts) {
+  const names = [...verdicts.keys()];
+  const tally = { passed: 0, failed: 0, skipped: 0 };
+  for (const [name, v] of verdicts) {
+    if (names.some((other) => other.startsWith(`${name}/`))) continue;
+    tally[v]++;
+  }
+  return tally;
+}
+
+const GO_VERDICT = { PASS: "passed", FAIL: "failed", SKIP: "skipped" };
+
+function parseGoTest(text) {
+  const verdicts = new Map();
+  for (const m of text.matchAll(/^\s*--- (PASS|FAIL|SKIP): (\S+) \(/gm)) {
+    verdicts.set(m[2], GO_VERDICT[m[1]]);
+  }
+  const pkgLines = [...text.matchAll(/^(ok|FAIL|\?)\s+\S+(?:\s+(.*))?$/gm)];
+  if (verdicts.size > 0) return counted("go-test", leafTally(verdicts));
+  if (pkgLines.length === 0) return null;
+  if (pkgLines.some((m) => /\[build failed\]|\[setup failed\]/.test(m[2] ?? ""))) {
+    return uncountable("go-test", "the package failed to build before any test ran");
+  }
+  if (pkgLines.every((m) => /\[no test files\]|\[no tests to run\]/.test(m[2] ?? ""))) {
+    return counted("go-test", { passed: 0, failed: 0 });
+  }
+  return uncountable(
+    "go-test",
+    "go test without -v prints no per-test results; run it with -v or -json",
+  );
+}
+
+function parseGoTestJson(text) {
+  const verdicts = new Map();
+  let events = 0;
+  let pkgFail = false;
+  for (const line of text.split("\n")) {
+    if (!line.startsWith("{")) continue;
+    let ev;
+    try {
+      ev = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (typeof ev.Action !== "string" || typeof ev.Package !== "string") continue;
+    events++;
+    const v = { pass: "passed", fail: "failed", skip: "skipped" }[ev.Action];
+    if (!v) continue;
+    if (ev.Test) verdicts.set(`${ev.Package} ${ev.Test}`, v);
+    else if (v === "failed") pkgFail = true;
+  }
+  if (events === 0) return null;
+  if (verdicts.size > 0) return counted("go-test-json", leafTally(verdicts));
+  if (pkgFail) return uncountable("go-test-json", "the package failed before any test reported");
+  return counted("go-test-json", { passed: 0, failed: 0 });
+}
+
+// ---------------------------------------------------------------------------
+// cargo test: one "test result:" line per test binary, summed.
+
+function parseCargo(text) {
+  const lines = [
+    ...text.matchAll(
+      /test result: (?:ok|FAILED)\. (\d+) passed; (\d+) failed; (\d+) ignored; \d+ measured; \d+ filtered out/g,
+    ),
+  ];
+  if (lines.length === 0) return null;
+  const t = { passed: 0, failed: 0, skipped: 0 };
+  for (const m of lines) {
+    t.passed += int(m[1]);
+    t.failed += int(m[2]);
+    t.skipped += int(m[3]);
+  }
+  return counted("cargo-test", t);
+}
+
+// ---------------------------------------------------------------------------
+// JUnit XML (Gradle, Surefire, pytest --junitxml). Counted from <testcase>
+// elements rather than suite attributes, so a wrapper <testsuites> or a nested
+// suite is never counted twice.
+
+export function parseJunitXml(xml) {
+  if (!/<testsuites?\b/.test(xml)) return null;
+  const tally = { passed: 0, failed: 0, skipped: 0 };
+  let cases = 0;
+  for (const m of xml.matchAll(/<testcase\b[^>]*?(?:\/>|>([\s\S]*?)<\/testcase>)/g)) {
+    cases++;
+    const body = m[1] ?? "";
+    if (/<(?:failure|error)\b/.test(body)) tally.failed++;
+    else if (/<skipped\b/.test(body)) tally.skipped++;
+    else tally.passed++;
+  }
+  if (cases === 0) {
+    const declared = [...xml.matchAll(/<testsuite\b[^>]*\btests="(\d+)"/g)].reduce(
+      (sum, m) => sum + int(m[1]),
+      0,
+    );
+    if (declared > 0) {
+      return uncountable("junit-xml", "suites declare tests but list no testcase elements");
+    }
+  }
+  return counted("junit-xml", tally);
+}
+
+function xmlFiles(path) {
+  let st;
+  try {
+    st = statSync(path);
+  } catch {
+    return [];
+  }
+  if (st.isFile()) return [path];
+  const out = [];
+  const walk = (dir, depth) => {
+    if (depth > 6) return;
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      const full = join(dir, e.name);
+      if (e.isDirectory()) walk(full, depth + 1);
+      else if (e.name.endsWith(".xml")) out.push(full);
+    }
+  };
+  walk(path, 0);
+  return out.sort();
+}
+
+/** Sum the JUnit XML at a file or under a directory. */
+export function summarizeJunit(path) {
+  const files = xmlFiles(path);
+  const total = { passed: 0, failed: 0, skipped: 0 };
+  let read = 0;
+  for (const f of files) {
+    let r;
+    try {
+      r = parseJunitXml(readFileSync(f, "utf8"));
+    } catch {
+      continue;
+    }
+    if (!r || r.executed === null) continue;
+    read++;
+    total.passed += r.passed;
+    total.failed += r.failed;
+    total.skipped += r.skipped;
+  }
+  if (read === 0) {
+    return finish({ ...uncountable("junit-xml", `no JUnit XML results at ${path}`) }, path);
+  }
+  return finish(counted("junit-xml", total), path);
+}
+
+// ---------------------------------------------------------------------------
+// xcresult: `xcrun xcresulttool get test-results summary` (Xcode 16+), or the
+// legacy `get --format json` metrics shape.
+
+export function fromXcresultJson(obj, source = "xcresult") {
+  if (obj && typeof obj.totalTestCount === "number") {
+    const failed = obj.failedTests ?? 0;
+    const skipped = obj.skippedTests ?? 0;
+    const passed = (obj.passedTests ?? 0) + (obj.expectedFailures ?? 0);
+    return finish(counted("xcresult", { passed, failed, skipped }), source);
+  }
+  const m = obj?.metrics;
+  if (m && m.testsCount) {
+    const v = (k) => int(m[k]?._value);
+    const total = v("testsCount");
+    const failed = v("testsFailedCount");
+    const skipped = v("testsSkippedCount");
+    return finish(
+      counted("xcresult", { passed: total - failed - skipped, failed, skipped }),
+      source,
+    );
+  }
+  return finish(uncountable("xcresult", "xcresult JSON carries no test counts"), source);
+}
+
+export function summarizeXcresult(bundle, { xcrun = "xcrun", timeoutMs = 60000 } = {}) {
+  const res = spawnSync(
+    xcrun,
+    ["xcresulttool", "get", "test-results", "summary", "--path", bundle, "--compact"],
+    {
+      encoding: "utf8",
+      timeout: timeoutMs,
+    },
+  );
+  if (res.error) {
+    return finish(
+      uncountable("xcresult", `xcrun unavailable: ${res.error.code || res.error.message}`),
+      bundle,
+    );
+  }
+  if (res.status !== 0) {
+    return finish(
+      uncountable(
+        "xcresult",
+        `xcrun xcresulttool exited ${res.status}: ${res.stderr.trim().slice(0, 200)}`,
+      ),
+      bundle,
+    );
+  }
+  try {
+    return fromXcresultJson(JSON.parse(res.stdout), bundle);
+  } catch {
+    return finish(uncountable("xcresult", "xcresulttool printed no JSON"), bundle);
+  }
+}
+
+// ---------------------------------------------------------------------------
+
+export const PARSERS = {
+  xcodebuild: parseXcodebuild,
+  "cargo-test": parseCargo,
+  "go-test-json": parseGoTestJson,
+  "go-test": parseGoTest,
+  pytest: parsePytest,
+  vitest: parseVitest,
+  jest: parseJest,
+  "node-test": parseNodeTest,
+  maven: parseMaven,
+  gradle: parseGradle,
+  "junit-xml": parseJunitXml,
+  xcresult: (text) => {
+    try {
+      const obj = JSON.parse(text);
+      return fromXcresultJson(obj);
+    } catch {
+      return null;
+    }
+  },
+};
+
+export const PARSER_IDS = Object.keys(PARSERS);
+
+// Auto-detection order. Each parser is specific enough that the order only
+// matters where one log could carry two runners, and then the more specific
+// signature is tried first.
+const AUTO = [
+  "xcodebuild",
+  "cargo-test",
+  "go-test-json",
+  "go-test",
+  "pytest",
+  "vitest",
+  "jest",
+  "node-test",
+  "maven",
+  "gradle",
+  "junit-xml",
+];
+
+function finish(r, source) {
+  const out = {
+    executed: r.executed,
+    passed: r.passed,
+    failed: r.failed,
+    skipped: r.skipped,
+    parser: r.parser ?? null,
+    source: source ?? null,
+  };
+  out.status = status(out);
+  if (r.reason) out.reason = r.reason;
+  return out;
+}
+
+/**
+ * Summarise runner output.
+ *
+ * @param {string} text
+ * @param {{parsers?: string[], source?: string}} [opts]
+ * @returns {{executed: number|null, passed: number|null, failed: number|null,
+ *            skipped: number|null, parser: string|null, source: string|null,
+ *            status: string, reason?: string}}
+ */
+export function summarize(text, { parsers, source = null } = {}) {
+  const order = parsers?.length ? parsers : AUTO;
+  for (const id of order) {
+    if (!PARSERS[id]) throw new Error(`unknown test-summary parser: ${id}`);
+  }
+  let firstUncountable = null;
+  for (const id of order) {
+    const r = PARSERS[id](text);
+    if (!r) continue;
+    if (r.executed !== null) return finish(r, source);
+    firstUncountable ??= r;
+  }
+  if (firstUncountable) return finish(firstUncountable, source);
+  return finish(
+    {
+      ...EMPTY,
+      parser: null,
+      reason: `no parser recognised the output (tried ${order.join(", ")})`,
+    },
+    source,
+  );
+}
+
+// ---------------------------------------------------------------------------
+// CLI
+
+function usage(msg) {
+  if (msg) process.stderr.write(`test-summary: ${msg}\n`);
+  process.stderr.write(
+    "usage: test-summary.mjs --log <file|-> [--parser id] [--stack id] | --junit <path> | --xcresult <bundle> | --xcresult-json <file>  [--json]\n",
+  );
+  process.exit(2);
+}
+
+const EXIT = { passed: 0, failed: 1, "no-tests": 3, unparsed: 4 };
+
+async function main(argv) {
+  const opts = {};
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    const val = () => {
+      const v = argv[++i];
+      if (v === undefined) usage(`${a} needs a value`);
+      return v;
+    };
+    if (a === "--log") opts.log = val();
+    else if (a === "--parser") opts.parser = val();
+    else if (a === "--stack") opts.stack = val();
+    else if (a === "--junit") opts.junit = val();
+    else if (a === "--xcresult") opts.xcresult = val();
+    else if (a === "--xcresult-json") opts.xcresultJson = val();
+    else if (a === "--state") opts.state = val();
+    else if (a === "--json") opts.json = true;
+    else usage(`unexpected argument ${a}`);
+  }
+  let result;
+  if (opts.junit) result = summarizeJunit(opts.junit);
+  else if (opts.xcresult) result = summarizeXcresult(opts.xcresult);
+  else if (opts.xcresultJson) {
+    try {
+      result = fromXcresultJson(
+        JSON.parse(readFileSync(opts.xcresultJson, "utf8")),
+        opts.xcresultJson,
+      );
+    } catch (err) {
+      usage(`cannot read ${opts.xcresultJson}: ${err.message}`);
+    }
+  } else if (opts.log) {
+    let text;
+    try {
+      text = readFileSync(opts.log === "-" ? 0 : opts.log, "utf8");
+    } catch (err) {
+      usage(`cannot read ${opts.log}: ${err.message}`);
+    }
+    let parsers;
+    if (opts.parser) parsers = [opts.parser];
+    else if (opts.stack) {
+      const { getAdapter } = await import("./_stack-adapter.mjs");
+      try {
+        parsers = getAdapter(opts.stack, { strict: true }).testSummary.parsers;
+      } catch (err) {
+        usage(err.message);
+      }
+    }
+    try {
+      result = summarize(text, { parsers, source: opts.log === "-" ? "stdin" : opts.log });
+    } catch (err) {
+      usage(err.message);
+    }
+  } else usage("one of --log, --junit, --xcresult, --xcresult-json is required");
+
+  if (opts.json) process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+  else {
+    const counts =
+      result.executed === null
+        ? `unparsed: ${result.reason}`
+        : `executed=${result.executed} passed=${result.passed} failed=${result.failed} skipped=${result.skipped}`;
+    process.stdout.write(`${result.status} (${result.parser ?? "none"}) ${counts}\n`);
+  }
+  const { gateContext, recordQuietly } = await import("./gate-ledger.mjs");
+  const ctx = gateContext({ statePath: opts.state ?? null });
+  if (ctx.active) {
+    const verdict = { passed: "pass", unparsed: "not-applicable" }[result.status] ?? "fail";
+    await recordQuietly(
+      "test-summary",
+      verdict,
+      {
+        status: result.status,
+        executed: result.executed,
+        failed: result.failed,
+        parser: result.parser ?? null,
+        source: result.source ?? null,
+        ...(result.reason ? { reason: result.reason } : {}),
+      },
+      { statePath: ctx.statePath },
+    );
+  }
+  return EXIT[result.status];
+}
+
+if (invokedDirectly(import.meta.url)) {
+  main(process.argv.slice(2)).then((code) => process.exit(code));
+}