supercov 0.0.3 → 0.0.4

package/README.md

@@ -36,8 +36,8 @@ The coverage engine has seven independent release gates:
 - release CI shards the pinned TC39 Test262 corpus across 16 workers, runs the
   official Test262 harness on original and instrumented sources, and rejects
   any scenario that passes originally but fails after transformation; and
-- checked performance budgets cover transform latency, output expansion, and
-  runtime probe overhead.
+- checked performance budgets cover transform latency, transactional workspace
+  preparation, output expansion, and runtime probe overhead.
 
 ```sh
 npm test
@@ -51,7 +51,9 @@ computed logical assignments, defaults, `try`/`catch`/`finally`, iterator
 closing, switch fallthrough, labeled loops, async functions, and generators.
 The compatibility workflow additionally runs Node 22/24/25, Playwright
 1.55/current, Vite 5/current, Vitest 2/current, Chromium, Firefox, WebKit, and
-modern JavaScript/JSX/TypeScript/TSX syntax fixtures. Test262's module, async,
+modern JavaScript/JSX/TypeScript/TSX syntax fixtures. Filesystem publication,
+symlink, copy fallback, ENOSPC, failed rename, and forced-termination recovery
+also run on Ubuntu, macOS, and Windows. Test262's module, async,
 raw, parse/resolution-negative, Annex B sloppy-script extension, and explicit
 `Function.prototype.toString`/function-source-coercion tests are intentionally
 excluded from the source-rewrite comparison, with reason counts printed for
@@ -66,11 +68,14 @@ blocks the trusted-publishing workflow.
 
 ## Agent query workflow
 
-Each run is stored locally as a compressed, immutable report under
-`.supercov/runs/<run-id>/`. Its `report.json.gz`, `run.json`, and
-`report.html` keep the machine report, run metadata, and human report together.
-Agents should use bounded CLI queries instead of loading the complete report
-into context.
+Each run is stored locally as two immutable files under
+`.supercov/runs/<run-id>/`: `evidence.raw.gz` and `run.json`. The archive
+contains the exact coverage denominator manifest plus raw per-worker and
+background evidence. Every query reconstructs its requested coverage view
+directly from that archive; no derived report or query cache is retained.
+Loose evidence is removed only after the whole run directory is atomically
+visible. HTML is not generated during a test run; agents should use bounded
+CLI queries instead of loading the complete derived model into context.
 
 ```sh
 # Orient using only a few lines.
@@ -102,8 +107,8 @@ Use `--filter passed` for verified coverage from successful attempts of
 ultimately passing tests, or `--filter failed` to inspect only execution from
 failed attempts (including failed retries of flaky tests). Reports record
 attempt status and classify each test as passed, failed, flaky, skipped, timed
-out, interrupted, or unknown. The HTML equivalents are `report.html`,
-`report-passed.html`, and `report-failed.html`.
+out, interrupted, or unknown. The passed and failed subsets are stored inside
+the same compressed report rather than duplicated into presentation files.
 
 The run ID is positional because all coverage queries operate on one immutable
 run. `latest` is a convenience selector for interactive use. Every query
@@ -120,8 +125,12 @@ CLI:
 1. refreshes a stable isolated source namespace under
    `.supercov/cache/instrumented-workspace/<project>/`, links the existing
    dependency tree, and creates all Vite, Vitest, Playwright, and build output
-   only there; the stable path lets VM/container snapshot systems reuse a
-   coverage build without touching the application's ordinary build;
+   only there; file data uses copy-on-write reflinks where the filesystem
+   supports them, and falls back to copying where it does not; the stable path
+   lets VM/container snapshot systems reuse a coverage build without touching
+   the application's ordinary build; when the complete source/config/toolchain
+   fingerprint is unchanged, the prior instrumented output and manifest are
+   carried into the refreshed source snapshot and the build is skipped;
 2. inventories every `app/**/*.ts(x)` and `src/**/*.ts(x)` file for the
    denominator, then instruments modules loaded by Vite without changing the
    project's config; when no build script exists, it instruments only the
@@ -136,30 +145,55 @@ CLI:
 5. attributes every source hit and decision vector to its individual test,
    automatically wraps Playwright actions and assertions, and records the
    action/assertion phase responsible for each correlated hit; then merges
-   server and browser evidence into HTML and JSON reports; and
-6. atomically publishes the evidence/report into `.supercov/` and retains only
-   the disposable isolated build namespace as a provider snapshot cache. The
+   server and browser evidence into one compressed JSON report; and
+6. atomically publishes the compressed evidence/report into `.supercov/`, then
+   removes loose evidence and terminal per-run work state, retaining only the
+   immutable run and disposable isolated build namespace. The
    ordinary application build is never read as an input, overwritten, or
    rebuilt afterward.
 
 Only `.supercov/` is modified in the user's checkout. A per-project lock
 rejects overlapping runs before either can build. Run state is durably written
-through preparing/building/testing/reporting/terminal phases; SIGINT, SIGTERM,
+through preparing/building/testing/reporting phases; SIGINT, SIGTERM,
 and SIGHUP are forwarded to the entire child process group. If the process is
 killed without a cleanup opportunity, the next invocation marks the dead PID's
-run abandoned and refreshes the isolated namespace before using it. Report,
-evidence, and state writes use sibling-temp files, fsync, and atomic rename;
-lock acquisition uses exclusive creation and fsync.
+run abandoned and refreshes the isolated namespace before using it. Cache
+refresh is transactional: a new sibling generation is prepared completely,
+the stable name is switched only at publication, and the prior complete
+generation is retained until that switch succeeds. The next invocation
+discards orphan staging trees or restores the prior generation if a host crash
+landed between the two same-filesystem renames. Report, evidence archive, and
+state writes use sibling-temp files, fsync, and atomic rename; lock acquisition
+uses exclusive creation and fsync. Published `run.json` is the durable terminal
+record, so terminal work state is not retained.
 
 Retention is deterministic because UTC run IDs sort chronologically:
 
 ```sh
-npx supercov clean --keep 20
-npx supercov clean --keep 20 --dry-run
+npx supercov prune --keep 20
+npx supercov prune --keep 20 --dry-run
+npx supercov clean --keep 20   # also removes the shared build cache
 ```
 
-The cleanup command never removes an active workspace and never touches files
-outside `.supercov/`.
+Neither operation runs automatically. `prune` removes explicit history beyond
+the requested retention and orphan/terminal transient data while preserving
+the shared cache. `clean` also removes that cache. Both acquire the same lock
+as a coverage run, refuse to race an active run, and never touch files outside
+`.supercov/`.
+
+The complete ownership, crash-recovery, symlink, and future copy-free design is
+documented in [Workspace isolation](docs/workspace-isolation.md).
+
+Every run prints and stores monotonic phase timings for initialization,
+workspace preparation, adapter setup, the instrumented build, the unchanged
+test command, and report preparation. They are available in
+`.supercov/runs/<run-id>/run.json` and in the JSON form of `supercov runs`.
+These phase timings do not pretend to be end-to-end overhead: that percentage
+requires an explicit comparison with the same command run without Supercov,
+which Supercov never executes automatically because an arbitrary test command
+may have side effects or external cost. See
+[Performance and storage](docs/performance.md) for the comparison methodology,
+strategy trade-offs, and a measured real-suite reference.
 
 The automatic adapters currently support standard Playwright suites (ESM and
 CommonJS specs in arbitrary project directories), project-owned Playwright
@@ -242,7 +276,7 @@ phase travels on browser requests into automatically wrapped Remix loaders,
 actions, and the server document renderer. Node async context preserves that
 ID through awaited helpers. An assertion also retains the preceding action ID,
 making chains such as “click -> application lines/decisions -> visible
-assertion” queryable in JSON and visible in HTML.
+assertion” queryable in JSON.
 
 Server evidence is safe when Playwright uses multiple workers against one
 application server. Every routed request carries a run/worker/test/retry scope;

package/dist/buildCache.d.ts

@@ -0,0 +1,14 @@
+import type { CoverageRunIntegrity } from "./types.ts";
+import type { CoverageProject } from "./project.ts";
+export declare const INSTRUMENTED_BUILD_CACHE_SCHEMA_VERSION = 1;
+export interface InstrumentedBuildCache {
+    schemaVersion: typeof INSTRUMENTED_BUILD_CACHE_SCHEMA_VERSION;
+    key: string;
+    createdAt: string;
+    artifactPaths: string[];
+}
+export declare function instrumentedBuildCacheKey(integrity: CoverageRunIntegrity, project: CoverageProject): string;
+export declare function readInstrumentedBuildCache(workspace: string, key: string): InstrumentedBuildCache | undefined;
+export declare function writeInstrumentedBuildCache(workspace: string, key: string): InstrumentedBuildCache | undefined;
+export declare function buildCacheReusePaths(metadata: InstrumentedBuildCache): string[];
+//# sourceMappingURL=buildCache.d.ts.map

package/dist/buildCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildCache.d.ts","sourceRoot":"","sources":["../src/buildCache.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AACvD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEpD,eAAO,MAAM,uCAAuC,IAAI,CAAC;AAUzD,MAAM,WAAW,sBAAsB;IACrC,aAAa,EAAE,OAAO,uCAAuC,CAAC;IAC9D,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB;AAgBD,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,oBAAoB,EAC/B,OAAO,EAAE,eAAe,GACvB,MAAM,CAeR;AAED,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,GACV,sBAAsB,GAAG,SAAS,CAqBpC;AAED,wBAAgB,2BAA2B,CACzC,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,GACV,sBAAsB,GAAG,SAAS,CAqCpC;AAED,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,sBAAsB,GAC/B,MAAM,EAAE,CAEV"}

package/dist/buildCache.js

@@ -0,0 +1,84 @@
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { isAbsolute, resolve, sep } from "node:path";
+import { atomicWriteFileSync } from "./atomic.js";
+export const INSTRUMENTED_BUILD_CACHE_SCHEMA_VERSION = 1;
+const BUILD_OUTPUT_CANDIDATES = [
+    "build",
+    "dist",
+    ".next",
+    ".nuxt",
+    ".output",
+];
+function metadataPath(workspace) {
+    return resolve(workspace, ".supercov/build-cache.json");
+}
+function safeRelativePath(path) {
+    return Boolean(path &&
+        !isAbsolute(path) &&
+        path !== ".." &&
+        !path.startsWith(`..${sep}`) &&
+        !path.split(/[\\/]/).includes(".."));
+}
+export function instrumentedBuildCacheKey(integrity, project) {
+    return createHash("sha256")
+        .update(JSON.stringify({
+        schemaVersion: INSTRUMENTED_BUILD_CACHE_SCHEMA_VERSION,
+        executionFingerprint: integrity.fingerprint.execution,
+        adapter: project.buildAdapter,
+        command: project.buildCommand,
+        environment: project.buildEnvironment,
+        node: process.versions.node,
+        platform: process.platform,
+        architecture: process.arch,
+    }))
+        .digest("hex");
+}
+export function readInstrumentedBuildCache(workspace, key) {
+    let metadata;
+    try {
+        metadata = JSON.parse(readFileSync(metadataPath(workspace), "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+    if (metadata.schemaVersion !== INSTRUMENTED_BUILD_CACHE_SCHEMA_VERSION ||
+        metadata.key !== key ||
+        !Array.isArray(metadata.artifactPaths) ||
+        metadata.artifactPaths.length === 0 ||
+        metadata.artifactPaths.some((path) => !safeRelativePath(path) || !existsSync(resolve(workspace, path)))) {
+        return undefined;
+    }
+    return metadata;
+}
+export function writeInstrumentedBuildCache(workspace, key) {
+    let declared = {};
+    try {
+        declared = JSON.parse(readFileSync(resolve(workspace, ".supercov/build-outputs.json"), "utf8"));
+    }
+    catch {
+        // Older/native Vite integrations use the conservative known outputs.
+    }
+    const existingOutputs = [
+        ...new Set([
+            ...BUILD_OUTPUT_CANDIDATES,
+            ...(declared.paths ?? []).filter(safeRelativePath),
+        ]),
+    ].filter((path) => existsSync(resolve(workspace, path)));
+    const outputs = existingOutputs.filter((path) => !existingOutputs.some((parent) => parent !== path && path.startsWith(`${parent}/`)));
+    const manifest = ".supercov/manifest.json";
+    if (outputs.length === 0 || !existsSync(resolve(workspace, manifest)))
+        return undefined;
+    const metadata = {
+        schemaVersion: INSTRUMENTED_BUILD_CACHE_SCHEMA_VERSION,
+        key,
+        createdAt: new Date().toISOString(),
+        artifactPaths: [...outputs, manifest],
+    };
+    atomicWriteFileSync(metadataPath(workspace), `${JSON.stringify(metadata, null, 2)}\n`);
+    return metadata;
+}
+export function buildCacheReusePaths(metadata) {
+    return [...metadata.artifactPaths, ".supercov/build-cache.json"];
+}
+//# sourceMappingURL=buildCache.js.map

package/dist/buildCache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildCache.js","sourceRoot":"","sources":["../src/buildCache.ts"],"names":[],"mappings":"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"}

package/dist/cli.js

@@ -1,14 +1,36 @@
 import { spawn } from "node:child_process";
 import { copyFileSync, existsSync, mkdirSync, readFileSync, rmSync, } from "node:fs";
 import { relative, resolve, sep } from "node:path";
+import { performance } from "node:perf_hooks";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { atomicRenameSync, atomicWriteFileSync } from "./atomic.js";
-import { writeMcdcReport } from "./reporter.js";
+import { printCoverageSummary } from "./reporter.js";
+import { analyzeCoverageArchive } from "./runAnalysis.js";
 import { coverageQueryCommands, runQueryCommand } from "./query.js";
 import { discoverCoverageProject } from "./project.js";
 import { createRunIntegrity } from "./integrity.js";
+import { writeEvidenceArchive } from "./evidenceArchive.js";
+import { buildCacheReusePaths, instrumentedBuildCacheKey, readInstrumentedBuildCache, writeInstrumentedBuildCache, } from "./buildCache.js";
 import { instrumentDirectWorkspace } from "./directInstrumenter.js";
-import { acquireProjectLock, cachedWorkspacePath, cleanCoverageStorage, prepareCachedWorkspace, recoverAbandonedRuns, updateRunState, writeRunState, } from "./workspace.js";
+import { acquireProjectLock, cachedWorkspacePath, cleanCoverageStorage, finalizePublishedRunStorage, prepareCachedWorkspace, pruneCoverageStorage, recoverAbandonedRuns, updateRunState, writeRunState, } from "./workspace.js";
+function roundedTimings(timings) {
+    return Object.fromEntries(Object.entries(timings).map(([phase, duration]) => [
+        phase,
+        Math.round(duration * 10) / 10,
+    ]));
+}
+function formatTimings(timings, totalMs) {
+    const rounded = roundedTimings(timings);
+    return [
+        `initialization=${rounded.initializationMs}ms`,
+        `workspace=${rounded.workspacePreparationMs}ms`,
+        `setup=${rounded.adapterSetupMs}ms`,
+        `build=${rounded.instrumentedBuildMs}ms`,
+        `tests=${rounded.testCommandMs}ms`,
+        `evidence=${rounded.evidencePublicationMs}ms`,
+        `total=${Math.round(totalMs * 10) / 10}ms`,
+    ].join(" ");
+}
 let activeChild;
 let signalEscalation;
 function terminateChild(signal) {
@@ -68,7 +90,7 @@ function signalExitCode(signal) {
         return 143;
     return 128;
 }
-function parseCleanOptions(args) {
+function parseRetentionOptions(command, args) {
     let keep = 20;
     let dryRun = false;
     for (let index = 0; index < args.length; index += 1) {
@@ -82,21 +104,37 @@ function parseCleanOptions(args) {
             keep = value;
         }
         else
-            throw new Error(`Unknown clean option: ${argument}`);
+            throw new Error(`Unknown ${command} option: ${argument}`);
     }
     return { keep, dryRun };
 }
 function cleanCommand(args) {
-    const options = parseCleanOptions(args);
+    const options = parseRetentionOptions("clean", args);
     const result = cleanCoverageStorage(process.cwd(), options);
     console.log(`[supercov] ${options.dryRun ? "would remove" : "removed"} ${result.removedRuns.length} stored run(s), ${result.removedWorkspaces.length} per-run workspace(s), and ${result.removedBuildCache ? "the" : "no"} isolated build cache; keeping ${options.keep} newest run(s)`);
     for (const id of result.removedRuns)
         console.log(id);
 }
+function pruneCommand(args) {
+    const options = parseRetentionOptions("prune", args);
+    const result = pruneCoverageStorage(process.cwd(), options);
+    console.log(`[supercov] ${options.dryRun ? "would remove" : "removed"} ${result.removedRuns.length} stored run(s), ${result.removedWorkspaces.length} terminal/orphan work director${result.removedWorkspaces.length === 1 ? "y" : "ies"}, and ${result.removedEvidence.length} loose evidence director${result.removedEvidence.length === 1 ? "y" : "ies"}; keeping ${options.keep} newest run(s) and preserving the shared cache`);
+    for (const id of result.removedRuns)
+        console.log(id);
+}
 async function createCoverageRun(command) {
     const root = process.cwd();
     const runId = new Date().toISOString().replace(/[:.]/g, "-");
     const runStartedAt = Date.now();
+    const runStartedMonotonic = performance.now();
+    const timings = {
+        initializationMs: 0,
+        workspacePreparationMs: 0,
+        adapterSetupMs: 0,
+        instrumentedBuildMs: 0,
+        testCommandMs: 0,
+        evidencePublicationMs: 0,
+    };
     const recovered = recoverAbandonedRuns(root);
     if (recovered.length > 0)
         console.error(`[supercov] recovered abandoned run(s): ${recovered.join(", ")}`);
@@ -105,7 +143,12 @@ async function createCoverageRun(command) {
     const packageSource = fileURLToPath(new URL(".", import.meta.url));
     const runIntegrity = createRunIntegrity(root, project, packageSource);
     const workspace = cachedWorkspacePath(root);
-    const reportStagingDirectory = resolve(root, ".supercov/work", runId, "report-publication");
+    const buildCacheKey = instrumentedBuildCacheKey(runIntegrity, project);
+    const reusableBuild = project.buildAdapter === "vite"
+        ? readInstrumentedBuildCache(workspace, buildCacheKey)
+        : undefined;
+    const serverEvidenceRoot = resolve(workspace, ".supercov/server-evidence");
+    const runStagingDirectory = resolve(root, ".supercov/work", runId, "run-publication");
     const storedRunDirectory = resolve(root, ".supercov/runs", runId);
     const startedAt = new Date(runStartedAt).toISOString();
     writeRunState(root, runId, {
@@ -138,11 +181,21 @@ async function createCoverageRun(command) {
     }
     let buildResult;
     let testResult;
-    let reportFailed = false;
+    let publicationFailed = false;
+    let runPublished = false;
+    let timingsPrinted = false;
+    timings.initializationMs = performance.now() - runStartedMonotonic;
     try {
-        const isolatedRoot = prepareCachedWorkspace(root);
+        let phaseStarted = performance.now();
+        const isolatedRoot = prepareCachedWorkspace(root, {
+            ...(reusableBuild
+                ? { reusePaths: buildCacheReusePaths(reusableBuild) }
+                : {}),
+        });
+        timings.workspacePreparationMs = performance.now() - phaseStarted;
         if (receivedSignal)
             throw new Error(`Interrupted by ${receivedSignal}`);
+        phaseStarted = performance.now();
         const generatedDirectory = resolve(isolatedRoot, ".supercov");
         const evidenceDirectoryRelative = `.supercov/evidence/${runId}`;
         const isolatedEvidenceDirectory = resolve(isolatedRoot, evidenceDirectoryRelative);
@@ -151,6 +204,7 @@ async function createCoverageRun(command) {
         const generatedViteConfig = resolve(generatedDirectory, "vite.config.mjs");
         const generatedVitestConfig = resolve(generatedDirectory, "vitest.config.mjs");
         const manifestPath = resolve(generatedDirectory, "manifest.json");
+        const buildOutputMetadataPath = resolve(generatedDirectory, "build-outputs.json");
         const isolatedPlaywrightConfig = project.playwrightConfig
             ? resolve(isolatedRoot, relative(root, project.playwrightConfig))
             : undefined;
@@ -258,7 +312,7 @@ async function createCoverageRun(command) {
             `  const relocateOutput = output => output ? ({ ...output, dir: output.dir ? relocate(output.dir, 'Rollup output') : output.dir, file: output.file ? relocate(output.file, 'Rollup output') : output.file }) : output;`,
             `  const rollupOutput = config.build?.rollupOptions?.output;`,
             `  const safe = { ...config, cacheDir: resolve(isolatedRoot, '.supercov/vite-cache'), build: { ...config.build, outDir: relocate(config.build?.outDir ?? 'dist', 'Vite build output'), rollupOptions: { ...config.build?.rollupOptions, output: Array.isArray(rollupOutput) ? rollupOutput.map(relocateOutput) : relocateOutput(rollupOutput) } } };`,
-            `  return mergeConfig(safe, { plugins: [mcdcVitePlugin(${JSON.stringify({ root: isolatedRoot, sourceRoots: project.sourceRoots, manifestPath })})] });`,
+            `  return mergeConfig(safe, { plugins: [mcdcVitePlugin(${JSON.stringify({ root: isolatedRoot, sourceRoots: project.sourceRoots, manifestPath, buildOutputMetadataPath })})] });`,
             `}`,
             "",
         ].join("\n"));
@@ -291,6 +345,7 @@ async function createCoverageRun(command) {
             SUPERCOV_EXECUTION_FINGERPRINT: runIntegrity.fingerprint.execution,
             SUPERCOV_EXECUTION_LOG: resolve(isolatedEvidenceDirectory, "execution.jsonl"),
             SUPERCOV_RUN_ID: runId,
+            SUPERCOV_SERVER_EVIDENCE_ROOT: serverEvidenceRoot,
             SUPERCOV_MANIFEST: manifestPath,
             SUPERCOV_PLAYWRIGHT_MODULE: project.playwrightModule,
             SUPERCOV_PLAYWRIGHT_TEST_EXPORT: project.playwrightTestExport,
@@ -311,13 +366,19 @@ async function createCoverageRun(command) {
         ]
             .filter(Boolean)
             .join(" ");
+        timings.adapterSetupMs = performance.now() - phaseStarted;
         updateRunState(root, runId, { status: "building" });
         console.error(`[supercov] instrumenting isolated workspace ${isolatedRoot}`);
         if (Object.keys(project.buildEnvironment).length > 0)
             console.error(`[supercov] inferred build mode from command/config: ${Object.entries(project.buildEnvironment)
                 .map(([key, value]) => `${key}=${value}`)
                 .join(" ")}`);
-        if (project.buildAdapter === "direct") {
+        phaseStarted = performance.now();
+        if (reusableBuild) {
+            console.error(`[supercov] reusing exact-fingerprint instrumented build ${buildCacheKey.slice(0, 12)}`);
+            buildResult = { status: 0, signal: null };
+        }
+        else if (project.buildAdapter === "direct") {
             instrumentDirectWorkspace(isolatedRoot, project.sourceRoots, manifestPath);
             buildResult = { status: 0, signal: null };
         }
@@ -336,6 +397,12 @@ async function createCoverageRun(command) {
                 },
             });
         }
+        if (buildResult.status === 0 &&
+            project.buildAdapter === "vite" &&
+            !reusableBuild) {
+            writeInstrumentedBuildCache(isolatedRoot, buildCacheKey);
+        }
+        timings.instrumentedBuildMs = performance.now() - phaseStarted;
         if (receivedSignal)
             throw new Error(`Interrupted by ${receivedSignal}`);
         if (buildResult.error)
@@ -343,6 +410,7 @@ async function createCoverageRun(command) {
         if (buildResult.status === 0) {
             updateRunState(root, runId, { status: "testing" });
             console.error(`[supercov] running in isolated workspace: ${command.join(" ")}`);
+            phaseStarted = performance.now();
             testResult = await runChild(command[0], command.slice(1), {
                 cwd: isolatedRoot,
                 env: {
@@ -351,38 +419,65 @@ async function createCoverageRun(command) {
                     SUPERCOV_CJS_INTERCEPT: "1",
                 },
             });
+            timings.testCommandMs = performance.now() - phaseStarted;
             if (receivedSignal)
                 throw new Error(`Interrupted by ${receivedSignal}`);
             if (testResult.error)
                 throw testResult.error;
-            updateRunState(root, runId, { status: "reporting" });
+            updateRunState(root, runId, { status: "publishing" });
+            phaseStarted = performance.now();
             rmSync(persistedEvidenceDirectory, { recursive: true, force: true });
             if (existsSync(isolatedEvidenceDirectory))
                 atomicRenameSync(isolatedEvidenceDirectory, persistedEvidenceDirectory);
             try {
-                rmSync(reportStagingDirectory, { recursive: true, force: true });
-                writeMcdcReport(persistedEvidenceDirectory, runId, runStartedAt, manifestPath, testResult.status, runIntegrity, {
-                    directory: reportStagingDirectory,
-                    displayDirectory: storedRunDirectory,
-                });
-                atomicWriteFileSync(resolve(reportStagingDirectory, "run.json"), `${JSON.stringify({
+                rmSync(runStagingDirectory, { recursive: true, force: true });
+                const evidenceArchivePath = resolve(runStagingDirectory, "evidence.raw.gz");
+                const rawEvidence = writeEvidenceArchive([
+                    { file: manifestPath, path: "manifest.json" },
+                    { directory: persistedEvidenceDirectory },
+                    {
+                        directory: resolve(serverEvidenceRoot, runId),
+                        prefix: "server",
+                    },
+                ], evidenceArchivePath);
+                printCoverageSummary(analyzeCoverageArchive(evidenceArchivePath, {
+                    runId,
+                    testExitCode: testResult.status,
+                    integrity: runIntegrity,
+                    generatedAt: startedAt,
+                }));
+                timings.evidencePublicationMs = performance.now() - phaseStarted;
+                atomicWriteFileSync(resolve(runStagingDirectory, "run.json"), `${JSON.stringify({
                     id: runId,
                     startedAt,
                     durationMs: Date.now() - runStartedAt,
                     command,
                     testExitCode: testResult.status,
                     integrity: runIntegrity,
+                    rawEvidence,
                     isolatedBuild: true,
+                    instrumentedBuildCache: {
+                        key: buildCacheKey,
+                        reused: Boolean(reusableBuild),
+                    },
+                    timings: roundedTimings(timings),
                 }, null, 2)}\n`);
-                atomicRenameSync(reportStagingDirectory, storedRunDirectory);
+                atomicRenameSync(runStagingDirectory, storedRunDirectory);
+                runPublished = true;
+                console.log(`[coverage] evidence: ${resolve(storedRunDirectory, "evidence.raw.gz")}`);
             }
             catch (error) {
-                reportFailed = true;
-                console.error("[supercov] failed to generate report", error);
+                timings.evidencePublicationMs = performance.now() - phaseStarted;
+                publicationFailed = true;
+                console.error("[supercov] failed to publish coverage evidence", error);
             }
         }
-        const resultCode = exitCode(buildResult) || exitCode(testResult) || (reportFailed ? 1 : 0);
+        const resultCode = exitCode(buildResult) || exitCode(testResult) || (publicationFailed ? 1 : 0);
         updateRunState(root, runId, { status: resultCode === 0 ? "complete" : "failed" });
+        if (runPublished && !finalizePublishedRunStorage(root, runId))
+            throw new Error(`Published run ${runId} is missing a durable artifact`);
+        console.error(`[supercov] timings ${formatTimings(timings, performance.now() - runStartedMonotonic)}`);
+        timingsPrinted = true;
         return resultCode;
     }
     catch (error) {
@@ -403,6 +498,8 @@ async function createCoverageRun(command) {
         return receivedSignal ? signalExitCode(receivedSignal) : 1;
     }
     finally {
+        if (!timingsPrinted)
+            console.error(`[supercov] timings ${formatTimings(timings, performance.now() - runStartedMonotonic)}`);
         if (signalEscalation) {
             clearTimeout(signalEscalation);
             signalEscalation = undefined;
@@ -410,7 +507,11 @@ async function createCoverageRun(command) {
         for (const [signal, handler] of signalHandlers)
             process.removeListener(signal, handler);
         try {
-            rmSync(reportStagingDirectory, { recursive: true, force: true });
+            rmSync(runStagingDirectory, { recursive: true, force: true });
+            rmSync(resolve(serverEvidenceRoot, runId), {
+                recursive: true,
+                force: true,
+            });
             // The stable isolated namespace is a deliberate build/snapshot cache.
             // It never overlaps the user's ordinary build and `supercov clean`
             // removes it deterministically.
@@ -426,9 +527,12 @@ const rawArgs = commandArgs[0] === "--help" || commandArgs[0] === "-h"
     ? ["help", ...commandArgs.slice(1)]
     : commandArgs;
 const queryCommand = rawArgs[0];
-if (queryCommand === "clean") {
+if (queryCommand === "clean" || queryCommand === "prune") {
     try {
-        cleanCommand(rawArgs.slice(1));
+        if (queryCommand === "clean")
+            cleanCommand(rawArgs.slice(1));
+        else
+            pruneCommand(rawArgs.slice(1));
     }
     catch (error) {
         console.error(`[supercov] ${error instanceof Error ? error.message : String(error)}`);