supercov 2.0.0 → 3.0.0

package/docs/workspace-isolation.md

@@ -27,6 +27,19 @@ snapshots, calls a service, or changes a database, wrapping it does not remove
 that behavior. The isolation guarantee applies to Supercov's instrumentation
 and evidence work.
 
+## Tools that judge the code
+
+Some tools a test command runs read or measure the code instead of running it,
+and the instrumented copy is not what you wrote:
+
+- Linters, formatters and `tsc --noEmit` (ESLint, Prettier, standard, xo and
+  the like) read each file as you wrote it, and don't see `.supercov`.
+- Coverage tools the command runs itself (tap, c8, nyc, Jest's and Vitest's
+  `--coverage`) still collect and report coverage. They measure the
+  instrumented copy, and report close to what they report without Supercov,
+  but not always exactly, so their thresholds are not checked, and the run
+  prints a line saying so. Supercov's own report has the run's coverage.
+
 Files the wrapped command creates or changes inside the isolated workspace are
 synced back to the project after the run, so `supercov -- npm test -- -u`
 updates snapshots in the repository exactly as `npm test -- -u` would. Two
@@ -87,8 +100,16 @@ project lock, and does not scan for similarly named directories.
 ## Containers and remote workspaces
 
 When a suite launches a container or VM from a mounted workspace, Supercov uses
-the isolated workspace as the source presented to that environment. The runtime
-must be able to cross the launch boundary and return evidence.
+the isolated workspace as the source presented to that environment. Where it
+sees the launch call -- a command and its environment passed as an `env`,
+`environment` or `envs` option, as a plain map after the command, or to a
+builder method such as Testcontainers' `withEnvironment` -- it hands the guest
+its settings with paths moved to the guest's mount, and the guest's coverage is
+credited to the test that launched it. A guest started any other way, with none
+of those settings, still runs the instrumented code: it reads the run's
+settings from the mounted workspace itself, and its coverage counts for the run
+as background coverage, credited to no test. The run summary's `Guests` line
+says how many processes did that.
 
 Dependencies stay out of the instrumented copy. The root `node_modules` is
 linked entry by entry to the project's own, so an environment that mounts the

package/package.json

@@ -1,7 +1,24 @@
 {
   "name": "supercov",
-  "version": "2.0.0",
+  "version": "3.0.0",
   "description": "Coverage, security and code quality for coding agents",
+  "keywords": [
+    "coverage",
+    "code-coverage",
+    "test-coverage",
+    "branch-coverage",
+    "mcdc",
+    "vitest",
+    "jest",
+    "playwright",
+    "pytest",
+    "security",
+    "code-quality",
+    "coding-agents",
+    "claude-code",
+    "codex",
+    "cli"
+  ],
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -20,9 +37,6 @@
     "docs/assertions.md",
     "docs/quality.md",
     "docs/security.md",
-    "docs/assertion-evidence.md",
-    "docs/assertion-maps.md",
-    "docs/assertion-agent.md",
     "docs/troubleshooting.md",
     "docs/cli.md",
     "docs/coverage-model.md",
@@ -31,7 +45,6 @@
     "docs/verification.md",
     "docs/performance.md",
     "docs/workspace-isolation.md",
-    "schemas",
     "README.md"
   ],
   "engines": {
@@ -52,9 +65,6 @@
     "build": "cargo build -p supercov",
     "sync:rust-assets": "node scripts/sync-rust-package-assets.mjs",
     "test:rust-assets": "node scripts/sync-rust-package-assets.mjs --check",
-    "check:rustc-backend-spike": "(cd spikes/rustc-backend && RUSTC_BOOTSTRAP=1 RUSTUP_TOOLCHAIN=1.95.0 cargo fmt --check && RUSTC_BOOTSTRAP=1 RUSTUP_TOOLCHAIN=1.95.0 cargo clippy --all-targets -- -D warnings)",
-    "test:rustc-backend-spike": "node scripts/rustc-backend-spike.mjs",
-    "test:rust-compiler-spikes": "cargo build -p supercov && node scripts/rust-libtest-companion-spike.mjs && node scripts/rust-async-attribution-spike.mjs && node scripts/rust-subprocess-attribution-spike.mjs && node scripts/rust-custom-harness-spike.mjs && node scripts/rust-libtest-builder-lifecycle-spike.mjs",
     "test": "cargo test --workspace",
     "test:react": "cargo build -p supercov && node scripts/rust-vitest-projects-integration.mjs && npm --prefix examples/react-verification ci && npm --prefix examples/react-verification run demo && node scripts/react-hydration-compatibility.mjs",
     "test:release-tooling": "node --test tests/release/*.test.mjs",
@@ -67,8 +77,11 @@
     "test:html-report": "cargo build -p supercov && node scripts/html-report-integration.mjs",
     "test:engine-contract": "cargo build -p supercov && node scripts/engine-contract.mjs",
     "test:agent": "cargo build -p supercov && node scripts/agent-query-eval.mjs",
+    "test:agent-commands": "cargo build -p supercov && node scripts/check-agent-commands.mjs",
+    "eval:skill": "claude plugin eval plugins/supercov --scaffold --trust-plugin --no-publish --model claude-sonnet-5 --judge-model claude-haiku-4-5 --threshold 0.66 --tag behavior trigger --allow-tools Bash Edit Write --max-cost-usd 15",
+    "eval:skill-triggers": "claude plugin eval plugins/supercov --scaffold --trust-plugin --no-publish --model claude-sonnet-5 --judge-model claude-haiku-4-5 --threshold 0.66 --tag trigger --ablation none --max-cost-usd 5",
     "test:engine": "cargo fmt --all -- --check && cargo clippy --workspace --all-targets -- -D warnings && cargo test --workspace && npm run test:runtime && npm run test:rust-assets && npm run test:engine-integrations",
-    "test:engine-integrations": "cargo build -p supercov && node scripts/html-report-integration.mjs && node scripts/rust-process-supervision.mjs && node scripts/rust-direct-node-integration.mjs && node scripts/rust-public-run-integration.mjs && node scripts/rust-embedded-runtime-integration.mjs && node scripts/rust-direct-vitest-integration.mjs && node scripts/rust-direct-jest-integration.mjs && node scripts/rust-direct-playwright-integration.mjs && node scripts/rust-custom-browser-playwright-integration.mjs && node scripts/rust-generic-esbuild-integration.mjs && node scripts/rust-generic-tsc-integration.mjs && node scripts/rust-generic-build-matrix.mjs && node scripts/rust-vite-playwright-integration.mjs",
+    "test:engine-integrations": "cargo build -p supercov && node scripts/html-report-integration.mjs && node scripts/rust-process-supervision.mjs && node scripts/rust-direct-node-integration.mjs && node scripts/rust-public-run-integration.mjs && node scripts/rust-embedded-runtime-integration.mjs && node scripts/rust-direct-vitest-integration.mjs && node scripts/rust-direct-jest-integration.mjs && node scripts/rust-direct-playwright-integration.mjs && node scripts/rust-custom-browser-playwright-integration.mjs && node scripts/rust-classic-browser-integration.mjs && node scripts/rust-top-packages-integration.mjs && node scripts/rust-generic-esbuild-integration.mjs && node scripts/rust-generic-tsc-integration.mjs && node scripts/rust-generic-build-matrix.mjs && node scripts/rust-vite-playwright-integration.mjs",
     "test:platform": "cargo test --workspace && cargo build -p supercov && node scripts/rust-process-supervision.mjs && node scripts/workspace-crash-integration.mjs",
     "test:native-package": "cargo build --release -p supercov && node scripts/native-package-integration.mjs && node scripts/native-release-set-integration.mjs",
     "test:pypi-wheel": "node scripts/pypi-wheel-integration.mjs",
@@ -81,7 +94,7 @@
     "test:test262": "cargo build --release -p supercov && node scripts/test262-equivalence.mjs",
     "benchmark:check": "cargo build --release -p supercov && node scripts/rust-transform-benchmark.mjs",
     "benchmark:python": "cargo build -p supercov && node scripts/python-benchmark.mjs",
-    "check": "cargo fmt --all -- --check && cargo clippy --workspace --all-targets -- -D warnings && npm run test && npm run test:release-tooling && npm run test:runtime && npm run test:rust-assets && npm run test:assertion-maps && npm run test:sweep-target && npm run test:skip-guard && npm run test:windows-tls && node scripts/package-preflight.mjs && node scripts/verify-binstall-metadata.mjs --offline",
+    "check": "cargo fmt --all -- --check && cargo clippy --workspace --all-targets -- -D warnings && npm run test && npm run test:release-tooling && npm run test:runtime && npm run test:rust-assets && npm run test:agent-commands && npm run test:assertions && npm run test:sweep-target && npm run test:skip-guard && npm run test:windows-tls && node scripts/package-preflight.mjs && node scripts/verify-binstall-metadata.mjs --offline",
     "release:check": "cargo clean && node scripts/sweep-target.mjs && npm run check && npm run test:engine && npm run test:go && npm run test:jvm && npm run test:launcher && npm run test:fixture && npm run test:watchdog && npm run test:engine-contract && npm run test:agent && npm run test:child-attribution && npm run test:host-loader && npm run test:python && npm run test:ruby-coverage && npm run test:rust-public-cargo && npm run test:packed-npx && npm run test:clang-mcdc && npm run benchmark:check",
     "release:bump": "node scripts/bump-version.mjs",
     "sweep": "node scripts/sweep-target.mjs",
@@ -95,9 +108,7 @@
     "test:go": "cargo test --no-fail-fast -p supercov-engine --test go_frontend --test go_run",
     "test:jvm": "cargo test --no-fail-fast -p supercov-engine --test jvm_frontend --test jvm_run -- --include-ignored --test-threads=1",
     "test:rust-public-cargo": "cargo build -p supercov && node scripts/rust-public-cargo-integration.mjs",
-    "test:assertion-maps": "cargo build -p supercov && node scripts/assertion-map-schema.mjs --check && node scripts/assertion-map-integration.mjs && node scripts/assertion-map-js-integration.mjs && node scripts/assertion-dogfood-integration.mjs",
-    "test:assertion-maps:js": "cargo build -p supercov && node scripts/assertion-map-schema.mjs --check && node scripts/assertion-map-js-integration.mjs && node scripts/assertion-dogfood-integration.mjs",
-    "sync:assertion-schema": "cargo build -p supercov && node scripts/assertion-map-schema.mjs",
+    "test:assertions": "cargo build -p supercov && node scripts/assertions-integration.mjs",
     "docs:sync": "node scripts/sync-docs.mjs",
     "docs:check": "node scripts/sync-docs.mjs --check",
     "test:launcher": "go vet ./cmd/... && go test ./cmd/...",
@@ -107,14 +118,14 @@
     "test:windows-tls": "node scripts/windows-tls-test.mjs"
   },
   "optionalDependencies": {
-    "@supercov/cli-darwin-arm64": "2.0.0",
-    "@supercov/cli-darwin-x64": "2.0.0",
-    "@supercov/cli-linux-arm64-gnu": "2.0.0",
-    "@supercov/cli-linux-arm64-musl": "2.0.0",
-    "@supercov/cli-linux-x64-gnu": "2.0.0",
-    "@supercov/cli-linux-x64-musl": "2.0.0",
-    "@supercov/cli-win32-arm64": "2.0.0",
-    "@supercov/cli-win32-x64": "2.0.0"
+    "@supercov/cli-darwin-arm64": "3.0.0",
+    "@supercov/cli-darwin-x64": "3.0.0",
+    "@supercov/cli-linux-arm64-gnu": "3.0.0",
+    "@supercov/cli-linux-arm64-musl": "3.0.0",
+    "@supercov/cli-linux-x64-gnu": "3.0.0",
+    "@supercov/cli-linux-x64-musl": "3.0.0",
+    "@supercov/cli-win32-arm64": "3.0.0",
+    "@supercov/cli-win32-x64": "3.0.0"
   },
   "peerDependencies": {
     "@playwright/test": ">=1.55.0",
@@ -137,9 +148,13 @@
     "@swc/core": "^1.16.1",
     "@types/node": "^24.0.0",
     "@vitest/browser-playwright": "4.1.11",
+    "@vitest/coverage-v8": "4.1.11",
+    "ava": "8.0.1",
     "esbuild": "^0.28.2",
     "expect": "30.4.1",
     "jest": "30.5.1",
+    "libtap": "1.4.1",
+    "mocha": "12.0.3",
     "next": "^16.3.2",
     "react": "^19.2.4",
     "react-dom": "^19.2.4",

package/runtime/javascript/atomic.mjs

@@ -1,6 +1,7 @@
-import { appendFileSync, existsSync, mkdirSync, openSync, closeSync, fsyncSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import { appendFileSync, existsSync, mkdirSync, openSync, closeSync, fsyncSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
 import { randomUUID } from "node:crypto";
-import { dirname } from "node:path";
+import { dirname, resolve } from "node:path";
+import { Buffer } from "node:buffer";
 function fsyncDirectory(path) {
     try {
         const directory = openSync(path, "r");
@@ -64,3 +65,46 @@ export function atomicRenameSync(source, destination) {
     renameSync(source, destination);
     fsyncDirectory(dirname(destination));
 }
+/**
+ * Append one test's evidence to this writer's own journal.
+ *
+ * A file per test cost a directory, a temporary file, two fsyncs and a rename:
+ * jshttp/cookie's 63,740 tests had written 26,600 of them after seven
+ * minutes, where the suite alone takes two seconds. An append is one write the
+ * kernel keeps when the process is killed, which is the durability the rest of
+ * the workspace has; set SUPERCOV_DURABLE_EVIDENCE_EACH_TEST=1 to fsync each
+ * record as well. The reader already takes `*.mcdc.jsonl` journals, one record
+ * per line, as Playwright writes them.
+ *
+ * A journal is named by a token, never by the pid alone: worker threads share
+ * a pid, and VMs restored from one snapshot share the token too, so a journal
+ * that grew by anything but this writer's own appends is left to its other
+ * writer and a new one is started.
+ */
+const journals = new Map();
+export function appendEvidenceRecord(directory, prefix, payload) {
+    const line = `${JSON.stringify(payload)}\n`;
+    let journal = journals.get(prefix);
+    if (journal) {
+        let size = -1;
+        try {
+            size = statSync(journal.path).size;
+        }
+        catch {
+            // A missing journal is started again below.
+        }
+        if (size !== journal.size)
+            journal = undefined;
+    }
+    if (!journal) {
+        const writer = (process.env.SUPERCOV_EXECUTION_LOG_SHARD ?? `pid-${process.pid}`)
+            .replace(/[^A-Za-z0-9_-]/g, "_");
+        journal = { path: resolve(directory, `${prefix}-${writer}-${randomUUID()}.mcdc.jsonl`), size: 0 };
+        journals.set(prefix, journal);
+    }
+    const append = process.env.SUPERCOV_DURABLE_EVIDENCE_EACH_TEST === "1"
+        ? appendJsonLineDurableSync
+        : appendJsonLineSync;
+    append(journal.path, line);
+    journal.size += Buffer.byteLength(line);
+}

package/runtime/javascript/ava.mjs

@@ -0,0 +1,82 @@
+// Supercov AVA adapter. The preload imports it in each AVA worker -- a
+// worker thread, or a child process under --no-worker-threads -- and it
+// patches AVA's own Runner, so a suite runs exactly as written. AVA runs a
+// file's tests concurrently, so a test's coverage cannot be told apart by
+// time: each test, with its beforeEach and afterEach hooks, runs inside a
+// coverage carrier of its own, as node:test subtests do, and what ran under
+// it is written with the test's outcome once it settles. Loading the test
+// file and before/after hooks run outside any test and count for the run.
+// It computes no coverage.
+import { realpathSync } from "node:fs";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { beginBufferedServerEvidence, flushBufferedServerEvidence, takeNodeAssertionPhases, withCoverageCarrier, } from "./runtime.mjs";
+import { runnerExecutionScope, writeRunnerEvidence } from "./runnerEvidence.mjs";
+
+// The installed ava package the entrypoint belongs to.
+function avaRoot(entrypoint) {
+    let real;
+    try {
+        real = realpathSync(entrypoint).replaceAll("\\", "/");
+    }
+    catch {
+        return undefined;
+    }
+    const at = real.lastIndexOf("/node_modules/ava/");
+    return at < 0 ? undefined : real.slice(0, at + "/node_modules/ava".length);
+}
+
+export async function adaptAva(entrypoint) {
+    const evidenceDirectory = process.env.SUPERCOV_EVIDENCE_DIR;
+    const root = avaRoot(entrypoint);
+    if (!evidenceDirectory || !root)
+        return;
+    let loaded;
+    try {
+        loaded = await import(pathToFileURL(join(root, "lib", "runner.js")).href);
+    }
+    catch {
+        return;
+    }
+    const Runner = loaded.default ?? loaded.Runner;
+    const runTest = Runner?.prototype?.runTest;
+    if (typeof runTest !== "function" || runTest.supercovAva)
+        return;
+    Runner.prototype.runTest = function supercovAvaRunTest(task, contextRef) {
+        // AVA refuses two tests with one title in a file, so the title names
+        // the test.
+        const identity = { runner: "ava", file: this.file, name: task.title };
+        const scope = runnerExecutionScope(identity);
+        beginBufferedServerEvidence(scope);
+        const finish = (status) => writeRunnerEvidence(identity, status, scope, evidenceDirectory, takeNodeAssertionPhases(scope), flushBufferedServerEvidence(scope));
+        let settled;
+        try {
+            settled = Promise.resolve(withCoverageCarrier({ version: 1, scope }, () => Reflect.apply(runTest, this, [task, contextRef])));
+        }
+        catch (error) {
+            finish("failed");
+            throw error;
+        }
+        return settled.then((passed) => {
+            finish(passed ? "passed" : "failed");
+            return passed;
+        }, (error) => {
+            finish("failed");
+            throw error;
+        });
+    };
+    Runner.prototype.runTest.supercovAva = true;
+    // A skipped or todo test never reaches runTest; AVA announces it.
+    const start = Runner.prototype.start;
+    if (typeof start === "function")
+        Runner.prototype.start = function supercovAvaStart(...args) {
+            // AVA's emitter hands a listener { data: state }.
+            this.on("stateChange", ({ data: state } = {}) => {
+                if (state?.type !== "selected-test" || !(state.skip || state.todo))
+                    return;
+                const identity = { runner: "ava", file: this.file, name: state.title };
+                writeRunnerEvidence(identity, "skipped", runnerExecutionScope(identity), evidenceDirectory);
+            });
+            return Reflect.apply(start, this, args);
+        };
+}

package/runtime/javascript/bootstrap.cjs

@@ -0,0 +1,43 @@
+"use strict";
+// Instrumented sources load this before anything else. Under the preload it
+// finds the runtime already installed and does nothing. A process that runs
+// the workspace from somewhere else -- a container or VM the workspace is
+// mounted into, started by an SDK that passed on none of Supercov's settings,
+// or a worker the preload never reached -- has no runtime, and without one the
+// first probe would throw. Such a process installs the runtime itself, with
+// the run's settings read from beside this file and their paths moved to
+// wherever the workspace is seen from here, so its coverage lands in the
+// run's own evidence directory.
+const installed = globalThis.__SUPERCOV_DIRECT_RUNTIME__ ?? process.__SUPERCOV_DIRECT_RUNTIME__;
+if (installed) {
+    globalThis.__SUPERCOV_DIRECT_RUNTIME__ ??= installed;
+}
+else {
+    try {
+        const fs = require("node:fs");
+        const path = require("node:path");
+        // <workspace>/.supercov/node_modules/bootstrap.cjs
+        const root = path.resolve(__dirname, "..", "..");
+        const settings = JSON.parse(fs.readFileSync(path.join(__dirname, "run.json"), "utf8"));
+        const moved = (value) => typeof value === "string" && settings.root !== root
+            ? value.split(settings.root).join(root)
+            : value;
+        // Settings carried over from the host name the host's paths, which do
+        // not exist here; replace them all rather than keep a mixture.
+        const foreign = process.env.SUPERCOV_PROJECT_ROOT !== root;
+        for (const [name, value] of Object.entries(settings.environment)) {
+            if (foreign || process.env[name] === undefined)
+                process.env[name] = moved(value);
+        }
+        process.env.SUPERCOV_PROJECT_ROOT = root;
+        process.env.SUPERCOV_EXECUTION_LOG_SHARD ??= `bootstrap-${process.pid}-${Date.now()}`;
+        require("./runtime.mjs");
+        // Counted in the run's summary: coverage from here belongs to no test.
+        require("./launchSupervisor.mjs").recordExecution({ event: "guest-process", guestRoot: root });
+    }
+    catch {
+        // Without its settings or its runtime nothing can be recorded here,
+        // and the first probe fails as it did before this file existed.
+    }
+}
+module.exports = globalThis.__SUPERCOV_DIRECT_RUNTIME__;

package/runtime/javascript/jest.cjs

@@ -9,9 +9,10 @@
 //
 // CommonJS on purpose: Jest's module system loads setup files without the
 // ESM flag, and the runtime it needs is already on the sandbox global.
-const { createHash } = require("node:crypto");
-const { mkdirSync, renameSync, writeFileSync } = require("node:fs");
+const { createHash, randomUUID } = require("node:crypto");
+const { appendFileSync, closeSync, fsyncSync, mkdirSync, openSync, statSync, writeFileSync } = require("node:fs");
 const { relative, resolve, sep } = require("node:path");
+const { Buffer } = require("node:buffer");
 
 // jest-environment-node exposes the outer process's own globals to the sandbox
 // through getters, so this is the same runtime instance the instrumented
@@ -48,7 +49,11 @@ function currentDeclaration() {
                 const occurrence = names.get(name) ?? 0;
                 names.set(name, occurrence + 1);
                 if (child === state.currentlyRunningTest)
-                    found = {occurrence, retry: Math.max((child.invocations ?? 1) - 1, 0)};
+                    found = {
+                        occurrence,
+                        retry: Math.max((child.invocations ?? 1) - 1, 0),
+                        path: [...parents, child.name],
+                    };
             }
         }
     }
@@ -71,13 +76,43 @@ function provenance(testFile) {
         ? { runner: "jest", kind, source: "path" }
         : { runner: "jest", kind: "unit", source: "runner-default" };
 }
-function writeEvidence(suffix, payload) {
-    const directory = resolve(process.cwd(), evidenceDirectory, suffix);
-    mkdirSync(directory, { recursive: true });
-    const target = resolve(directory, "mcdc.json");
-    const temporary = `${target}.${process.pid}.${Date.now()}.tmp`;
-    writeFileSync(temporary, `${JSON.stringify(payload)}\n`);
-    renameSync(temporary, target);
+// One journal per writer, as atomic.mjs's appendEvidenceRecord keeps it: a
+// file per test cost a directory, a file and a rename each. Jest gives every
+// test file a fresh module registry, so a worker starts one journal per file.
+let journal;
+function writeEvidence(payload) {
+    const line = `${JSON.stringify(payload)}\n`;
+    if (journal) {
+        let size = -1;
+        try {
+            size = statSync(journal.path).size;
+        }
+        catch {
+            // A missing journal is started again below.
+        }
+        if (size !== journal.size)
+            journal = undefined;
+    }
+    if (!journal) {
+        const directory = resolve(process.cwd(), evidenceDirectory);
+        mkdirSync(directory, { recursive: true });
+        const writer = (process.env.SUPERCOV_EXECUTION_LOG_SHARD ?? `pid-${process.pid}`).replace(/[^A-Za-z0-9_-]/g, "_");
+        journal = { path: resolve(directory, `jest-worker-${writer}-${randomUUID()}.mcdc.jsonl`), size: 0 };
+    }
+    if (process.env.SUPERCOV_DURABLE_EVIDENCE_EACH_TEST === "1") {
+        const descriptor = openSync(journal.path, "a", 0o600);
+        try {
+            writeFileSync(descriptor, line);
+            fsyncSync(descriptor);
+        }
+        finally {
+            closeSync(descriptor);
+        }
+    }
+    else {
+        appendFileSync(journal.path, line, { mode: 0o600 });
+    }
+    journal.size += Buffer.byteLength(line);
 }
 
 if (runtime && evidenceDirectory && typeof beforeEach === "function" && typeof afterAll === "function") {
@@ -96,7 +131,7 @@ if (runtime && evidenceDirectory && typeof beforeEach === "function" && typeof a
             emittedSetupFiles.add(testFile);
             const setupSnapshot = runtime.coverageSnapshot();
             if (setupSnapshot.hits.length || setupSnapshot.decisions.length) {
-                writeEvidence(`jest-${digest(testFile)}-setup`, {
+                writeEvidence({
                     testId: `jest:${digest(testFile)}:setup`,
                     test: `${testFile} > module setup`,
                     testFile,
@@ -126,7 +161,9 @@ if (runtime && evidenceDirectory && typeof beforeEach === "function" && typeof a
             retry,
             attemptId: `${testKey}-${retry}`,
         };
-        active = { scope, testFile, fullName, retry };
+        // Named as the reporter names it; the id keeps Jest's full name.
+        const name = declaration?.path?.join(" > ") ?? fullName;
+        active = { scope, testFile, fullName, name, retry };
         runtime.activateCoverageScope(scope);
         runtime.resetCoverage(testId);
     });
@@ -139,12 +176,12 @@ if (runtime && evidenceDirectory && typeof beforeEach === "function" && typeof a
         if (!current)
             return;
         const { scope } = current;
-        writeEvidence(`jest-${scope.attemptId}`, {
+        writeEvidence({
             testId: scope.testId,
             scope,
-            test: current.fullName,
+            test: current.name,
             testFile: current.testFile,
-            title: current.fullName,
+            title: current.name,
             retry: current.retry,
             // The reporter's record carries the outcome.
             status: "unknown",

package/runtime/javascript/jest.config.mjs

@@ -26,8 +26,16 @@ export default async function supercovJestConfig() {
         // configuration is not read and Jest's defaults apply.
         process.emitWarning(`[supercov] the project's Jest configuration was not read (${error?.message ?? error}); Jest's defaults apply`);
     }
+    // Jest's coverage measures the instrumented copy, probes included, and a
+    // suite at 100% read 83.33% of branches: its coverageThreshold failed
+    // passing runs. Jest still collects and reports coverage.
+    const { coverageThreshold, ...own } = config;
+    const collecting = own.collectCoverage === true ||
+        process.argv.some((argument) => /^--(?:coverage|collectCoverage|collect-coverage)(?:=true)?$/.test(argument));
+    if (coverageThreshold && collecting)
+        process.__SUPERCOV_SKIPPED_COVERAGE_THRESHOLDS__?.("Jest");
     return {
-        ...config,
+        ...own,
         // Concurrent tests in one file would share the worker's scope.
         maxConcurrency: 1,
         setupFiles: [here("jestRuntime.cjs"), ...asList(config.setupFiles)],

package/runtime/javascript/jestReporter.mjs

@@ -1,8 +1,7 @@
 import { createHash } from "node:crypto";
-import { mkdirSync } from "node:fs";
 import { relative, resolve, sep } from "node:path";
 import { inferTestProvenance } from "./provenance.mjs";
-import { atomicWriteFileSync } from "./atomic.mjs";
+import { appendEvidenceRecord } from "./atomic.mjs";
 function digest(value) {
     return createHash("sha256").update(value).digest("hex").slice(0, 24);
 }
@@ -57,7 +56,9 @@ export default class SupercovJestReporter {
         const record = (attempt, attemptStatus, flaky) => {
             const payload = {
                 testId,
-                test: result.fullName,
+                // Named by its describe blocks, `small > charges`, as every
+                // JavaScript runner is; the id keeps Jest's own full name.
+                test: [...(result.ancestorTitles ?? []), result.title].join(" > "),
                 testFile,
                 title: result.title,
                 retry: attempt,
@@ -69,9 +70,7 @@ export default class SupercovJestReporter {
                 browser: [],
                 server: [],
             };
-            const directory = resolve(process.cwd(), evidenceDirectory, `jest-${digest(testId)}-${attempt}-status`);
-            mkdirSync(directory, { recursive: true });
-            atomicWriteFileSync(resolve(directory, "mcdc.json"), `${JSON.stringify(payload)}\n`);
+            appendEvidenceRecord(resolve(process.cwd(), evidenceDirectory), "jest-status", payload);
         };
         // `jest.retryTimes` reports one result after the last attempt; every
         // attempt before it failed, or there would have been no retry. The