agentic-qe 3.15.4 → 3.15.6

package/dist/coordination/handlers/coverage-handlers.js

@@ -4,143 +4,159 @@
  * Extracted from task-executor.ts registerHandlers().
  * Covers: analyze-coverage
  */
-import * as fs from 'fs/promises';
-import * as path from 'path';
 import { ok, err } from '../../shared/types/index.js';
 import { toError } from '../../shared/error-utils.js';
-import { safeJsonParse } from '../../shared/safe-json.js';
-import { loadCoverageData } from './handler-utils.js';
-import { buildEstimatedCoverage, collectRustCoverage, isCoverageExecDisabled, isRustProject, isTestPath, } from './coverage-collection.js';
+import { buildEstimatedCoverage, collectRustCoverage, findCargoRoot, isCoverageExecDisabled, isRustProject, } from './coverage-collection.js';
+import { describeNoData, evaluateCoverageForTarget, isUnmeasured, resolveExistingCoverage, scopeCoverageToTarget, reconcileRecommendations, thresholdVerdict, } from './coverage-target.js';
+import { randomUUID } from 'crypto';
+import { describeRunFailure, runJsCoverage, testRunStatus } from './coverage-runner.js';
+import { collectedMetrics } from '../../domains/coverage-analysis/collected-metrics.js';
 /**
- * Try to produce a JS/TS coverage report by running the project's test runner.
- * Returns true if the runner completed (which does not guarantee a report was
- * written — the caller re-checks disk).
+ * How long the project's test runner may take before its process tree is
+ * killed. `AQE_COVERAGE_TIMEOUT_MS` overrides the 120s default.
  */
-async function tryRunJsCoverage(targetPath) {
-    // Running the project's test suite executes code from the analyzed repository
-    // (the tests themselves, plus npm lifecycle scripts via npx). Honor the
-    // opt-out before doing that.
-    if (isCoverageExecDisabled())
-        return false;
-    try {
-        const { execSync } = await import('child_process');
-        let coverageCmd = 'npx vitest run --coverage --reporter=json 2>/dev/null';
-        try {
-            const pkgContent = await fs.readFile(path.join(targetPath, 'package.json'), 'utf-8');
-            const pkg = safeJsonParse(pkgContent);
-            const deps = {
-                ...(pkg.devDependencies || {}),
-                ...(pkg.dependencies || {}),
-            };
-            if (deps['jest'] || deps['@jest/core']) {
-                coverageCmd = 'npx jest --coverage --json 2>/dev/null';
-            }
-            else if (deps['mocha'] || deps['nyc']) {
-                coverageCmd = 'npx nyc mocha 2>/dev/null';
-            }
-            // vitest is the default — covers vitest, @vitest/coverage-v8, etc.
-        }
-        catch {
-            // No package.json — use default vitest
-        }
-        execSync(coverageCmd, {
-            cwd: targetPath,
-            timeout: 120000,
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        return true;
-    }
-    catch {
-        // Test runner failed or not available.
-        return false;
-    }
+function coverageTimeoutMs(env = process.env) {
+    const parsed = Number.parseInt(env.AQE_COVERAGE_TIMEOUT_MS ?? '', 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : 120000;
 }
-/**
- * Narrow an instrumented report to production files only, recomputing the
- * aggregate from what survives.
- *
- * Returns `null` when the report contains no production files at all — the
- * caller must NOT fall back to the unfiltered set, because that reports the test
- * files' own coverage as the project's (#569's third contradiction).
- */
-function productionOnly(report, targetPath) {
-    const files = report.files.filter(f => !isTestPath(f.path, targetPath));
-    if (files.length === 0)
-        return null;
-    // Recompute rather than carrying the original summary: it was computed over
-    // the unfiltered set, so keeping it would blend test-file coverage into the
-    // production headline figure.
+/** Aggregate a file list into whole-number percentages. */
+function recomputeSummary(files) {
     const sum = (pick) => files.reduce((acc, f) => acc + pick(f), 0);
-    const pct = (covered, total) => total > 0 ? Math.round((covered / total) * 100) : 0;
+    const pct = (covered, total) => (total > 0 ? Math.round((covered / total) * 100) : 0);
     const totalLines = sum(f => f.lines.total);
     const coveredLines = sum(f => f.lines.covered);
-    const branchDataCollected = files.some(f => f.branches.total > 0);
-    const functionDataCollected = files.some(f => f.functions.total > 0);
+    // #1012: statements are statements (lcov carries its line figures there).
+    const totalStatements = sum(f => f.statements.total);
     return {
-        data: {
-            files,
-            summary: {
-                line: pct(coveredLines, totalLines),
-                branch: pct(sum(f => f.branches.covered), sum(f => f.branches.total)),
-                function: pct(sum(f => f.functions.covered), sum(f => f.functions.total)),
-                statement: pct(coveredLines, totalLines),
-                files: files.length,
-            },
-        },
+        line: pct(coveredLines, totalLines),
+        branch: pct(sum(f => f.branches.covered), sum(f => f.branches.total)),
+        function: pct(sum(f => f.functions.covered), sum(f => f.functions.total)),
+        statement: totalStatements > 0
+            ? pct(sum(f => f.statements.covered), totalStatements)
+            : pct(coveredLines, totalLines),
+        files: files.length,
+    };
+}
+/** An instrumented verdict as a collected result with honest provenance. */
+function instrumented(files) {
+    return {
+        data: { files, summary: recomputeSummary(files) },
         provenance: {
             method: 'instrumented-report',
             estimated: false,
-            branchDataCollected,
-            functionDataCollected,
+            branchDataCollected: files.some(f => f.branches.total > 0),
+            functionDataCollected: files.some(f => f.functions.total > 0),
             notes: [],
         },
     };
 }
+function fromEvaluation(evaluation, ranTests, projectRoot) {
+    return evaluation.status === 'measured'
+        ? { collected: instrumented(evaluation.files), ranTests, projectRoot }
+        : { collected: null, ranTests, noData: evaluation.reason, projectRoot };
+}
 /**
  * Collect coverage for a target, preferring real measurement over estimation
  * and always reporting which one happened (#569).
  *
+ * The target may be the project root, a subfolder or file inside it, or an
+ * existing coverage report (#995). Tooling always runs from the project root
+ * and the result is scoped back down to the target. The decision about what
+ * a report says for a target is shared with the CLI (`resolveExistingCoverage`
+ * / `evaluateCoverageForTarget`).
+ *
  * Cascade:
- *   1. an instrumented report already on disk (istanbul/lcov/cobertura)
+ *   0. the target IS a coverage report — parse it, run nothing
+ *   1. an instrumented report already on disk at the project root
  *   2. language-specific instrumentation we can run — `cargo llvm-cov` for Rust,
- *      the project's test runner for JS/TS
+ *      the project's test runner for JS/TS — writing to a temp dir
  *   3. static estimation, explicitly labelled `estimated: true`
  */
 async function collectCoverage(targetPath) {
-    const existing = await loadCoverageData(targetPath);
-    if (existing) {
-        const fromReport = productionOnly(existing, targetPath);
-        // A report whose only entries are test files yields NO production coverage.
-        // Falling back to the unfiltered set here would report the test files'
-        // own coverage as the project's — recreating #569's third contradiction
-        // (`tests/verifier_matrix.rs` analysed at 79.2% as if it were a target).
-        if (!fromReport)
-            return { collected: null, ranTests: false, testOnlyReport: true };
-        return { collected: fromReport, ranTests: false };
+    const existing = await resolveExistingCoverage(targetPath);
+    if (existing.status === 'target-missing') {
+        return { collected: null, ranTests: false, noData: 'target-missing', projectRoot: null };
+    }
+    if (existing.status === 'evaluated') {
+        return fromEvaluation(existing.evaluation, false, existing.projectRoot);
     }
+    const { target, projectRoot } = existing;
     // #569 work item 1: delegate to real instrumentation where available.
-    const rustProject = isRustProject(targetPath);
-    if (rustProject) {
-        const rust = await collectRustCoverage(targetPath);
-        if (rust)
-            return { collected: rust, ranTests: true };
+    if (isRustProject(target)) {
+        const rust = await collectRustCoverage(target);
+        if (rust) {
+            // cargo ran from the crate root; scope its crate-wide output to the target.
+            const crateRoot = findCargoRoot(target) ?? projectRoot;
+            const scoped = scopeCoverageToTarget(rust.data, crateRoot, target);
+            if (scoped.length === 0) {
+                return { collected: null, ranTests: true, noData: 'target-not-covered', projectRoot: crateRoot };
+            }
+            const collected = scoped.length === rust.data.files.length
+                ? rust
+                : { data: { files: scoped, summary: recomputeSummary(scoped) }, provenance: rust.provenance };
+            return { collected, ranTests: true, projectRoot: crateRoot };
+        }
         // This target is a Rust crate. Do not continue into the JS/TS runner:
         // `npx vitest --coverage` can still be available through the parent
         // process PATH and will write an empty report even though the crate has no
         // JavaScript tests. Treating that artifact as coverage hides the intended
         // Rust static-estimation fallback and mislabels the result.
-        return { collected: buildEstimatedCoverage(targetPath), ranTests: false };
+        return { collected: buildEstimatedCoverage(target), ranTests: false, projectRoot };
     }
-    const ranTests = await tryRunJsCoverage(targetPath);
-    const afterRun = await loadCoverageData(targetPath);
-    if (afterRun) {
-        const fromRun = productionOnly(afterRun, targetPath);
-        if (!fromRun)
-            return { collected: null, ranTests, testOnlyReport: true };
-        return { collected: fromRun, ranTests };
+    // Running the project's test suite executes code from the analyzed repository
+    // (the tests themselves, plus npm lifecycle scripts via npx). Honor the
+    // opt-out before doing that.
+    if (isCoverageExecDisabled()) {
+        return { collected: buildEstimatedCoverage(target), ranTests: false, projectRoot };
     }
-    return { collected: buildEstimatedCoverage(targetPath), ranTests };
+    const run = await runJsCoverage(projectRoot, { timeoutMs: coverageTimeoutMs() });
+    // An EMPTY report (`{}`) from a run that reported its tests means "the run
+    // instrumented nothing under the target" → unmeasured, never an estimate
+    // (#995 review BL2). An empty report from a run that crashed before
+    // reporting any tests is a crash, handled below.
+    const crashedEmpty = run.data !== null && run.data.files.length === 0 &&
+        run.numTotalTests === null && !run.exitedCleanly;
+    if ((run.data && !crashedEmpty) || run.numTotalTests === 0) {
+        const evaluation = run.data
+            ? evaluateCoverageForTarget(run.data, projectRoot, target, { numTotalTests: run.numTotalTests })
+            : { status: 'no-data', reason: 'no-tests-ran' };
+        const result = fromEvaluation(evaluation, run.exitedCleanly || run.data !== null, projectRoot);
+        if (result.collected) {
+            // #1027 N4/NB2: a run with failing tests still measured coverage; the
+            // failure is decided from the runner's counts, not its exit code.
+            result.runStatus = testRunStatus(run);
+            // #1027 NB1: the run's own testsPassing is recorded with its coverage.
+            if (typeof run.numPassedTests === 'number' && typeof run.numFailedTests === 'number') {
+                result.testRun = {
+                    runId: randomUUID(), passed: run.numPassedTests, failed: run.numFailedTests, skipped: run.numPendingTests ?? 0,
+                };
+            }
+        }
+        return result;
+    }
+    // No report at all: say exactly what happened to the run (not installed,
+    // timed out, crashed with stderr), then fall back to a labelled estimate.
+    const estimate = buildEstimatedCoverage(target);
+    const runNote = describeRunFailure(run, projectRoot);
+    if (estimate) {
+        estimate.provenance.notes = [
+            `${runNote} These numbers are a STATIC ESTIMATE derived from source shape — ` +
+                'not measured coverage, and must not be reported as such.',
+            ...estimate.provenance.notes.filter(n => !/^No instrumentation ran/.test(n)),
+        ];
+    }
+    return {
+        collected: estimate, ranTests: run.exitedCleanly, projectRoot,
+        notes: estimate ? [] : [runNote],
+    };
+}
+/** Caller-facing explanation for a result with no coverage figures. */
+function noDataWarning(reason, ranTests, targetPath, projectRoot) {
+    if (reason)
+        return describeNoData(reason, targetPath, projectRoot);
+    return ranTests
+        ? 'Tests ran but no coverage output was generated. Ensure a coverage provider is configured (e.g., @vitest/coverage-v8, istanbul).'
+        : 'No coverage data found and could not run tests automatically. ' + estimationGuidance(targetPath);
 }
 /**
  * Build the guidance string shown when a result is an estimate rather than a
@@ -169,8 +185,13 @@ export function registerCoverageHandlers(ctx) {
             const analyzer = ctx.getCoverageAnalyzer();
             const targetPath = payload.target || process.cwd();
             const threshold = payload.threshold || 80;
-            const { collected, ranTests, testOnlyReport } = await collectCoverage(targetPath);
+            const { collected, ranTests, noData, projectRoot, notes, runStatus, testRun } = await collectCoverage(targetPath);
+            // #995 review N5: say so plainly instead of "no coverage data found".
+            if (noData === 'target-missing') {
+                return err(new Error(describeNoData('target-missing', targetPath, null)));
+            }
             if (!collected) {
+                const unmeasured = noData !== undefined && isUnmeasured(noData);
                 return ok({
                     lineCoverage: null,
                     branchCoverage: null,
@@ -182,22 +203,25 @@ export function registerCoverageHandlers(ctx) {
                     estimated: false,
                     measured: false,
                     coverageMethod: 'none',
+                    // #995(d): "no measurement exists for this target", distinct from 0%.
+                    ...(unmeasured ? { unmeasured: true } : {}),
                     algorithm: 'sublinear-O(log n)',
-                    warning: testOnlyReport
-                        ? 'The coverage report contains only test files, so there is no production ' +
-                            'coverage to report. Coverage OF a test file is not a meaningful metric. ' +
-                            'Check that your coverage tool is instrumenting your source directory.'
-                        : ranTests
-                            ? 'Tests ran but no coverage output was generated. Ensure a coverage provider is configured (e.g., @vitest/coverage-v8, istanbul).'
-                            : 'No coverage data found and could not run tests automatically. ' + estimationGuidance(targetPath),
+                    warning: notes?.length ? notes.join(' ') : noDataWarning(noData, ranTests, targetPath, projectRoot),
                 });
             }
             const { data: coverageData, provenance } = collected;
             // Analyze coverage using the real CoverageAnalyzerService
+            // #1008: the analyzer persists only measured coverage; a static estimate
+            // is returned below, labelled, but never stored as evidence.
             const analysisResult = await analyzer.analyze({
                 coverageData,
                 threshold,
                 includeFileDetails: payload.detectGaps,
+                measured: !provenance.estimated,
+                // #1027 N7: per-file records use absolute keys; N4: failing-suite coverage is labelled.
+                ...(projectRoot ? { projectRoot } : {}),
+                ...(runStatus && !provenance.estimated ? { runStatus } : {}),
+                ...(testRun && !provenance.estimated ? { testRun } : {}),
             });
             if (!analysisResult.success) {
                 return analysisResult;
@@ -227,7 +251,7 @@ export function registerCoverageHandlers(ctx) {
             }
             const round = (n) => Math.round(n * 10) / 10;
             const pct = (covered, total) => total > 0 ? Math.round((covered / total) * 1000) / 10 : null;
-            const warnings = [...provenance.notes];
+            const warnings = [...provenance.notes, ...(notes ?? [])];
             if (provenance.estimated)
                 warnings.push(estimationGuidance(targetPath));
             // #569: the analyzer generates recommendations from the summary numbers.
@@ -236,20 +260,22 @@ export function registerCoverageHandlers(ctx) {
             // significantly lower than line coverage", "Function coverage is below
             // 70%") is a statement about a metric nobody measured. Drop it rather
             // than send a developer to fix a number that doesn't exist.
-            const recommendations = report.recommendations.filter(rec => {
-                if (!provenance.branchDataCollected && /branch coverage/i.test(rec))
-                    return false;
-                if (!provenance.functionDataCollected && /function coverage/i.test(rec))
-                    return false;
-                return true;
-            });
+            // #995 NB5/NB-A: the verdict and the shortfall advice come from the same
+            // collected-metrics computation (shared with the CLI), so they can't disagree.
+            // #1027 N7: lcov / Cobertura carry no statement data — n/a, out of the verdict.
+            const statementCollected = provenance.estimated || collectedMetrics(coverageData.files).statement;
+            const metricsCollected = {
+                branch: provenance.branchDataCollected, function: provenance.functionDataCollected, statement: statementCollected,
+            };
+            const verdict = thresholdVerdict(report.summary, threshold, metricsCollected);
+            const recommendations = reconcileRecommendations(report.recommendations, verdict, threshold, metricsCollected);
             return ok({
                 lineCoverage: round(report.summary.line),
                 // #569 work item 4: never report a branch percentage — least of all
                 // 100% — when no branch data was collected.
                 branchCoverage: provenance.branchDataCollected ? round(report.summary.branch) : null,
                 functionCoverage: provenance.functionDataCollected ? round(report.summary.function) : null,
-                statementCoverage: round(report.summary.statement),
+                statementCoverage: statementCollected ? round(report.summary.statement) : null,
                 totalFiles: report.summary.files,
                 coverageByFile: coverageData.files.map(f => ({
                     file: f.path,
@@ -258,7 +284,8 @@ export function registerCoverageHandlers(ctx) {
                     functionCoverage: provenance.functionDataCollected ? pct(f.functions.covered, f.functions.total) : null,
                 })),
                 gaps,
-                meetsThreshold: report.meetsThreshold,
+                // NB5: judged only on the metrics that were collected (shared with the CLI).
+                meetsThreshold: verdict.meetsThreshold,
                 delta: report.delta,
                 recommendations,
                 algorithm: 'sublinear-O(log n)',
@@ -268,6 +295,8 @@ export function registerCoverageHandlers(ctx) {
                 coverageMethod: provenance.method,
                 branchDataCollected: provenance.branchDataCollected,
                 functionDataCollected: provenance.functionDataCollected,
+                statementDataCollected: statementCollected,
+                ...(runStatus && !provenance.estimated ? { runStatus } : {}),
                 ...(warnings.length > 0 ? { warning: warnings.join(' ') } : {}),
             });
         }

package/dist/coordination/handlers/coverage-runner.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Run a JS/TS project's test runner with coverage — safely (issue #995).
+ *
+ * Properties, each learned the hard way:
+ *
+ *   1. **Run from the project root, write to a private temp dir.** The coverage
+ *      report and the runner's JSON result go to `reportDir`, never into the
+ *      project tree (#995 wrote `src/coverage/`). The result file is set with
+ *      plain `--outputFile=` — vitest ignores `--outputFile.json=` when the
+ *      user's config sets `outputFile` as a string.
+ *   2. **No shell, no download.** The runner's own JS entry point is resolved
+ *      from the project's `node_modules` and started with `process.execPath`.
+ *      Arguments are an array, so `$(…)`, spaces, `& ^ %` in a path are data on
+ *      every platform. A runner that isn't installed is reported, never fetched
+ *      (`npx` would silently download one).
+ *   3. **Kill the whole process tree.** Runner → workers is several levels deep.
+ *      The child is started in its own process group (POSIX) and the group is
+ *      killed on timeout (`taskkill /T /F` on Windows).
+ *   4. **Die with the host.** Every live run is registered; a synchronous
+ *      `process.on('exit')` hook kills each group and removes its temp dir. That
+ *      covers every path that ends in `process.exit()` or a natural exit — the
+ *      MCP server's shutdown on SIGTERM/SIGINT/stdin EOF routes there. It cannot
+ *      cover SIGKILL of the host (or a signal with no handler installed): no
+ *      code runs in that case, and the group is left to its own timeout-less
+ *      fate. Hosts should shut down via a handled signal.
+ */
+import type { CoverageData } from '../../domains/coverage-analysis/interfaces';
+export type JsRunnerName = 'vitest' | 'jest' | 'nyc';
+export interface JsCoverageInvocation {
+    runner: JsRunnerName;
+    /** `process.execPath`, or null when the runner is not installed. */
+    command: string | null;
+    /** `[<runner JS entry>, ...runner args]`. */
+    args: string[];
+    /** Where the runner writes its own JSON result (tests run / passed), if supported. */
+    resultsFile: string | null;
+}
+export interface JsCoverageRun {
+    runner: JsRunnerName;
+    /** The runner package was not found in the project's node_modules. Nothing ran. */
+    missing: boolean;
+    exitCode: number | null;
+    exitedCleanly: boolean;
+    timedOut: boolean;
+    timeoutMs: number;
+    /**
+     * Parsed istanbul report, or null when none was written. A report that was
+     * written but lists no files is `{ files: [] }` — NOT null: "the run covered
+     * nothing" is different from "the run produced no report".
+     */
+    data: CoverageData | null;
+    /**
+     * Number of tests the runner reports having run, from its own JSON result.
+     * `null` when the runner gives no machine-readable result (nyc) or it could
+     * not be read — "unknown", which callers must not treat as 0.
+     */
+    numTotalTests: number | null;
+    /**
+     * Per-outcome counts from the runner's JSON result (#1027 NB1/NB2), null
+     * when unknown. A failing suite is decided from these, not the exit code:
+     * vitest also exits non-zero for a coverage-threshold failure.
+     */
+    numPassedTests?: number | null;
+    numFailedTests?: number | null;
+    numPendingTests?: number | null;
+    numFailedTestSuites?: number | null;
+    /** The runner's first error line plus the last ~2 KB of its stderr, for diagnosing a crash. */
+    stderrTail: string;
+}
+/**
+ * Outcome of a coverage run's tests (#1027 NB2): 'failed' when the runner's
+ * own result reports a failed test or test suite, 'passed' when it reports
+ * none — whatever the exit code (a coverage-threshold failure exits 1 with
+ * every test passing). Without counts (nyc), the exit code decides.
+ */
+export declare function testRunStatus(run: JsCoverageRun): 'passed' | 'failed';
+/**
+ * Summarise a runner's stderr for a caller: the FIRST error-looking line (or
+ * the first ~512 bytes) plus the last ~2 KB (#995 review NB-C). A tail alone
+ * loses the cause when a long stack follows it — a vitest config syntax error
+ * prints `[PARSE_ERROR] …` first and then kilobytes of frames.
+ */
+export declare function summarizeStderr(head: string, tail: string, totalBytes: number): string;
+/**
+ * Find an installed package's bin script, walking up `node_modules` from the
+ * project root (hoisted monorepo installs live above the package).
+ */
+export declare function findPackageBin(projectRoot: string, pkg: string, binName?: string, maxDepth?: number): string | null;
+/**
+ * Every `node_modules/.bin` from the project up to the workspace root,
+ * nearest first. Runners that shell out to sibling tools (nyc → mocha) need
+ * the hoisted ones too (#1012).
+ */
+export declare function runnerBinDirs(projectRoot: string): string[];
+/**
+ * Pick the runner and its argv. No shell is involved: `command` is the Node
+ * binary and `args[0]` the runner's JS entry, so paths are passed verbatim.
+ */
+export declare function buildJsCoverageInvocation(projectRoot: string, reportDir: string): JsCoverageInvocation;
+/**
+ * Synchronously kill every live coverage run and remove its temp dir. Runs from
+ * `process.on('exit')`, where only synchronous work is possible.
+ */
+export declare function killAllLiveRunsSync(): void;
+/** Number of runs currently registered (for tests and diagnostics). */
+export declare function liveRunCount(): number;
+export interface ProcessTreeResult {
+    exitCode: number | null;
+    timedOut: boolean;
+    spawnError: boolean;
+    pid: number | undefined;
+    stderrTail: string;
+}
+/**
+ * Spawn `command args` in `cwd` (no shell) as the leader of a new process
+ * group, wait for it, and on timeout kill the entire group. Resolves only once
+ * no process of the group remains (bounded), so the caller can safely delete
+ * its temp dir. While running, the group and `cleanupDir` are registered with
+ * the exit hook so they never outlive the host process.
+ */
+export declare function runProcessTree(command: string, args: string[], options: {
+    cwd: string;
+    timeoutMs: number;
+    graceMs?: number;
+    cleanupDir?: string;
+    env?: NodeJS.ProcessEnv;
+}): Promise<ProcessTreeResult>;
+/**
+ * Run the project's test runner with coverage from `projectRoot`.
+ *
+ * Everything the runner writes goes to a fresh temp dir that is removed before
+ * this returns — after the whole process group is gone — or by the exit hook if
+ * the host exits first.
+ */
+export declare function runJsCoverage(projectRoot: string, options?: {
+    timeoutMs?: number;
+}): Promise<JsCoverageRun>;
+/**
+ * One-line, caller-facing explanation of why a run produced no usable report.
+ * Never "No instrumentation ran" when the runner did run and failed.
+ */
+export declare function describeRunFailure(run: JsCoverageRun, projectRoot: string): string;
+//# sourceMappingURL=coverage-runner.d.ts.map