agentic-qe 3.15.4 → 3.15.6

package/dist/shared/metrics/code-metrics.js

@@ -3,10 +3,53 @@
  * Real code analysis for complexity, maintainability, and quality metrics
  */
 import { TypeScriptParser } from '../parsers/index.js';
-import { FileReader } from '../io/index.js';
+import { FileReader, PathTraversalError } from '../io/index.js';
 import { treeSitterRegistry } from '../parsers/multi-language-parser.js';
 import { getLanguageFromExtension } from '../types/test-frameworks.js';
 import { calculateCognitiveComplexity } from './cognitive-complexity.js';
+import { findProjectRoot } from '../../kernel/project-root.js';
+/** git-style binary sniff: a NUL within the first 8 KB. */
+const BINARY_SNIFF_CHARS = 8192;
+/** How far into a file the generated-file conventions are looked for. */
+const GENERATED_SNIFF_CHARS = 1024;
+/** Go's convention (golang.org/s/generatedcode), one full line. */
+const GO_GENERATED_LINE = /^\/\/ Code generated .* DO NOT EDIT\.$/m;
+/** `@generated` used as a tag (not part of a word, e.g. not `@generatedAt`). */
+const GENERATED_TAG = /(?:^|[\s*/])@generated(?![\w-])/;
+/** The file's first comment block: a leading block comment or run of line comments. */
+function firstCommentBlock(content) {
+    const text = content.replace(/^\uFEFF/, '').replace(/^#![^\n]*\n/, '').trimStart();
+    if (text.startsWith('/*')) {
+        const close = text.indexOf('*/');
+        return close >= 0 ? text.slice(0, close + 2) : text;
+    }
+    const lines = [];
+    for (const line of text.split('\n')) {
+        if (!line.trimStart().startsWith('//'))
+            break;
+        lines.push(line);
+    }
+    return lines.join('\n');
+}
+/**
+ * #1021 round 2b: generated only by convention — Go's
+ * "// Code generated … DO NOT EDIT." line near the top, or an `@generated`
+ * tag in the first comment block. Prose such as "DO NOT EDIT the retry
+ * constants", or `@generated` mentioned later in the file, is handwritten.
+ */
+function isGeneratedSource(content) {
+    const head = content.slice(0, GENERATED_SNIFF_CHARS).replace(/\r\n/g, '\n');
+    return GO_GENERATED_LINE.test(head) || GENERATED_TAG.test(firstCommentBlock(head));
+}
+/** Exclusion decided from the file name alone. */
+function excludedByName(filePath) {
+    const name = filePath.split(/[\\/]/).pop() ?? filePath;
+    if (/\.d\.(ts|mts|cts)$/i.test(name))
+        return 'type declaration file';
+    if (/\.min\.(js|mjs|cjs)$/i.test(name))
+        return 'minified bundle';
+    return undefined;
+}
 // ============================================================================
 // Code Metrics Analyzer
 // ============================================================================
@@ -15,17 +58,55 @@ export class CodeMetricsAnalyzer {
     fileReader;
     constructor() {
         this.parser = new TypeScriptParser();
-        this.fileReader = new FileReader();
+        // #1021: reads inside the AQE project root (AQE_PROJECT_ROOT, else the
+        // detected root — not merely the process cwd) are contained by realpath,
+        // so in-root names like `[...slug].tsx`, dot-dirs and deep paths are
+        // readable; anything outside keeps the legacy path validation.
+        this.fileReader = new FileReader({ projectRoot: findProjectRoot() });
     }
     /**
      * Analyze a single file for all metrics
      */
     async analyzeFile(filePath) {
+        return (await this.analyzeWithDiagnostics(filePath)).metrics;
+    }
+    /**
+     * #1011 / #1021: analyse a file and say whether its metrics are evidence.
+     * Binary, generated, minified and declaration files — and files the reader
+     * refuses by policy — are `excluded`; unreadable or unparseable source is
+     * `failed`. Callers must not treat either as a measurement.
+     */
+    async analyzeFileDetailed(filePath) {
+        const byName = excludedByName(filePath);
+        if (byName)
+            return { status: 'excluded', metrics: null, reason: `${filePath}: ${byName}` };
+        const { metrics, content, readError, parseFailure, parsedAsSource } = await this.analyzeWithDiagnostics(filePath);
+        if (readError) {
+            return readError instanceof PathTraversalError
+                ? { status: 'excluded', metrics: null, reason: `${filePath} was refused by the file reader (${readError.message})` }
+                : { status: 'failed', metrics: null, reason: `${filePath} could not be read (${readError.message})` };
+        }
+        // git-style sniff, except that TS/JS which parses cleanly is source even
+        // with a raw NUL inside a string literal (seen in real repos).
+        const sourceDespiteNul = parsedAsSource && !parseFailure;
+        if (content !== undefined && !sourceDespiteNul && content.slice(0, BINARY_SNIFF_CHARS).includes('\u0000')) {
+            return { status: 'excluded', metrics: null, reason: `${filePath} has binary content` };
+        }
+        if (content !== undefined && isGeneratedSource(content)) {
+            return { status: 'excluded', metrics: null, reason: `${filePath} is a generated file` };
+        }
+        if (parseFailure)
+            return { status: 'failed', metrics, reason: `${filePath} could not be parsed (${parseFailure})` };
+        return { status: 'measured', metrics };
+    }
+    /** Compute metrics, reporting read errors and parse failures separately. */
+    async analyzeWithDiagnostics(filePath) {
         const contentResult = await this.fileReader.readFile(filePath);
         if (!contentResult.success) {
-            return null;
+            return { metrics: null, readError: contentResult.error };
         }
         const content = contentResult.value;
+        let parseFailure;
         const lines = content.split('\n');
         // Count different types of lines
         const { codeLines, commentLines, blankLines } = this.countLines(lines);
@@ -41,6 +122,10 @@ export class CodeMetricsAnalyzer {
         if (['ts', 'tsx', 'js', 'jsx'].includes(ext)) {
             try {
                 const ast = this.parser.parseFile(fileName, content);
+                const syntaxErrors = ast.parseDiagnostics?.length ?? 0;
+                if (syntaxErrors > 0) {
+                    parseFailure = `${syntaxErrors} syntax error${syntaxErrors === 1 ? '' : 's'}`;
+                }
                 // Extract functions and calculate complexity
                 const functions = this.parser.extractFunctions(ast);
                 functionCount = functions.length;
@@ -62,8 +147,9 @@ export class CodeMetricsAnalyzer {
                     }
                 }
             }
-            catch {
-                // If parsing fails, use heuristic analysis
+            catch (error) {
+                // If parsing fails, use heuristic analysis — an estimate, not a measurement (#1011)
+                parseFailure ??= error instanceof Error ? error.message : String(error);
                 cyclomaticComplexity = this.estimateCyclomaticComplexity(content);
                 cognitiveComplexity = this.estimateCognitiveComplexity(content);
             }
@@ -98,7 +184,7 @@ export class CodeMetricsAnalyzer {
         const halsteadMetrics = this.calculateHalsteadMetrics(content);
         // Calculate maintainability index
         const maintainabilityIndex = this.calculateMaintainabilityIndex(halsteadMetrics.volume, cyclomaticComplexity, codeLines);
-        return {
+        const metrics = {
             path: filePath,
             linesOfCode: codeLines,
             linesOfComments: commentLines,
@@ -111,6 +197,7 @@ export class CodeMetricsAnalyzer {
             classCount,
             maxNestingDepth,
         };
+        return { metrics, content, parseFailure, parsedAsSource: ['ts', 'tsx', 'js', 'jsx'].includes(ext) };
     }
     /**
      * Analyze function-level metrics

package/dist/shared/metrics/index.d.ts

@@ -3,7 +3,7 @@
  * Exports for code quality and system metrics analysis
  */
 export { CodeMetricsAnalyzer, getCodeMetricsAnalyzer } from './code-metrics';
-export type { FileMetrics, FunctionMetrics, HalsteadMetrics, DuplicationResult, DuplicateBlock, } from './code-metrics';
+export type { FileMetrics, FileAnalysisOutcome, FileAnalysisStatus, FunctionMetrics, HalsteadMetrics, DuplicationResult, DuplicateBlock, } from './code-metrics';
 export { SystemMetricsCollector, getSystemMetricsCollector } from './system-metrics';
 export type { SystemMetrics, CpuMetrics, MemoryMetrics, ProcessMetrics, MetricSample, HttpMetrics, } from './system-metrics';
 //# sourceMappingURL=index.d.ts.map

package/dist/workers/interfaces.d.ts

@@ -152,8 +152,16 @@ export interface WorkerEvent {
     readonly timestamp: Date;
     readonly payload: unknown;
 }
+/** Read options; `namespace` reads another domain's records (e.g. quality evidence). */
+export interface WorkerMemoryReadOptions {
+    namespace?: string;
+}
 export interface WorkerMemory {
-    get<T>(key: string): Promise<T | undefined>;
+    /**
+     * Read a key. Without `namespace` the worker's own namespace is used; a
+     * backend without namespaces ignores it.
+     */
+    get<T>(key: string, options?: WorkerMemoryReadOptions): Promise<T | undefined>;
     set<T>(key: string, value: T): Promise<void>;
     search(pattern: string): Promise<string[]>;
 }

package/dist/workers/quality-daemon/coverage-delta.d.ts

@@ -17,9 +17,10 @@ export interface CoverageSnapshot {
 }
 export interface CoverageMetrics {
     readonly line: number;
-    readonly branch: number;
-    readonly function: number;
-    readonly statement: number;
+    /** `null` = not collected in that snapshot (#1027 B2) — never a fake 0. */
+    readonly branch: number | null;
+    readonly function: number | null;
+    readonly statement: number | null;
 }
 export interface FileCoverage {
     readonly line: number;

package/dist/workers/quality-daemon/coverage-delta.js

@@ -8,6 +8,11 @@
  *
  * Enqueues test suggestion tasks when gaps exceed threshold.
  */
+import { measuredCoverageSummary } from '../../domains/quality-assessment/coverage-report-event.js';
+/** Delta of a metric; 0 when either side did not collect it (#1027 B2). */
+function metricDelta(now, before) {
+    return now === null || before === null ? 0 : now - before;
+}
 const DEFAULTS = {
     regressionThreshold: 2,
     gapThreshold: 60,
@@ -39,12 +44,12 @@ export class CoverageDeltaAnalyzer {
         const previous = previousRaw;
         const overallDelta = {
             line: current.overall.line - previous.overall.line,
-            branch: current.overall.branch - previous.overall.branch,
-            function: current.overall.function - previous.overall.function,
-            statement: current.overall.statement - previous.overall.statement,
+            branch: metricDelta(current.overall.branch, previous.overall.branch ?? null),
+            function: metricDelta(current.overall.function, previous.overall.function ?? null),
+            statement: metricDelta(current.overall.statement, previous.overall.statement ?? null),
         };
         const regressionDetected = overallDelta.line < -this.options.regressionThreshold ||
-            overallDelta.branch < -this.options.regressionThreshold;
+            (overallDelta.branch ?? 0) < -this.options.regressionThreshold;
         // Compute per-file deltas
         const filesToCheck = changedFiles ?? Object.keys(current.files);
         const affectedFiles = [];
@@ -90,7 +95,9 @@ export class CoverageDeltaAnalyzer {
      * Build a CoverageSnapshot from raw lcov/istanbul data stored in memory.
      */
     async buildSnapshot(memory) {
-        const latest = await memory.get('coverage:latest');
+        const raw = await memory.get('coverage:latest');
+        // #1014: only a measured record is a snapshot; legacy/estimated records are not.
+        const latest = measuredCoverageSummary(raw);
         if (!latest)
             return undefined;
         return {
@@ -101,7 +108,7 @@ export class CoverageDeltaAnalyzer {
                 function: latest.function,
                 statement: latest.statement,
             },
-            files: latest.files ?? {},
+            files: raw && typeof raw.files === 'object' ? raw.files : {},
         };
     }
     // ============================================================================

package/dist/workers/quality-daemon/index.js

@@ -306,11 +306,12 @@ export class QualityDaemon {
             try {
                 const snapshot = await this.coverageDelta.buildSnapshot(memory);
                 if (snapshot) {
-                    this._coverageHealth = Math.round((snapshot.overall.line +
-                        snapshot.overall.branch +
-                        snapshot.overall.function +
-                        snapshot.overall.statement) /
-                        4);
+                    // #1027 B2: average the metrics that were collected; an uncollected
+                    // one (null) is left out rather than dragging health down as 0.
+                    const collected = [snapshot.overall.line, snapshot.overall.branch,
+                        snapshot.overall.function, snapshot.overall.statement]
+                        .filter((v) => typeof v === 'number');
+                    this._coverageHealth = Math.round(collected.reduce((a, v) => a + v, 0) / collected.length);
                     this._lastCoverageCheck = now;
                 }
             }

package/dist/workers/quality-daemon/notification-service.js

@@ -8,9 +8,9 @@
  * Notification types: gate_failure, coverage_drop, flaky_detected, suggestion_available
  */
 import { writeFileSync, mkdirSync, readdirSync, readFileSync, unlinkSync } from 'fs';
-import { join, resolve } from 'path';
+import { join } from 'path';
+import { getProjectStorePath } from '../../kernel/project-root.js';
 const DEFAULTS = {
-    notificationsDir: resolve(process.cwd(), '.agentic-qe', 'notifications'),
     maxNotifications: 200,
 };
 export class NotificationService {
@@ -20,7 +20,7 @@ export class NotificationService {
     urlValidator;
     _sentCount = 0;
     constructor(options) {
-        this.notificationsDir = options?.notificationsDir ?? DEFAULTS.notificationsDir;
+        this.notificationsDir = options?.notificationsDir ?? getProjectStorePath('notifications');
         this.maxNotifications = options?.maxNotifications ?? DEFAULTS.maxNotifications;
         this.webhookUrl = options?.webhookUrl;
         this.urlValidator = options?.urlValidator;

package/dist/workers/quality-daemon/persistent-memory.d.ts

@@ -7,7 +7,7 @@
  *
  * Resolves Finding 2: CLI daemon previously used throwaway in-memory Map.
  */
-import type { WorkerMemory } from '../interfaces';
+import type { WorkerMemory, WorkerMemoryReadOptions } from '../interfaces';
 /**
  * Interface matching the subset of UnifiedMemoryManager we need,
  * to avoid circular dependency on the full kernel module.
@@ -24,7 +24,7 @@ export interface KVBackend {
 export declare class PersistentWorkerMemory implements WorkerMemory {
     private readonly backend;
     constructor(backend: KVBackend);
-    get<T>(key: string): Promise<T | undefined>;
+    get<T>(key: string, options?: WorkerMemoryReadOptions): Promise<T | undefined>;
     set<T>(key: string, value: T): Promise<void>;
     search(pattern: string): Promise<string[]>;
 }

package/dist/workers/quality-daemon/persistent-memory.js

@@ -17,8 +17,8 @@ export class PersistentWorkerMemory {
     constructor(backend) {
         this.backend = backend;
     }
-    async get(key) {
-        return this.backend.kvGet(key, NAMESPACE);
+    async get(key, options) {
+        return this.backend.kvGet(key, options?.namespace ?? NAMESPACE);
     }
     async set(key, value) {
         await this.backend.kvSet(key, value, NAMESPACE);

package/dist/workers/worker-manager.js

@@ -48,7 +48,11 @@ class InMemoryWorkerEventBus {
  */
 class InMemoryWorkerMemory {
     store = new Map();
-    async get(key) {
+    async get(key, options) {
+        // This process-local store holds only worker keys: no other domain's
+        // namespace (e.g. quality evidence) lives here.
+        if (options?.namespace)
+            return undefined;
         return this.store.get(key);
     }
     async set(key, value) {

package/dist/workers/workers/coverage-tracker.js

@@ -9,6 +9,7 @@
  * - Uncovered critical paths
  */
 import { BaseWorker } from '../base-worker.js';
+import { measuredCoverageSummary } from '../../domains/quality-assessment/coverage-report-event.js';
 const CONFIG = {
     id: 'coverage-tracker',
     name: 'Coverage Tracker',
@@ -33,46 +34,69 @@ export class CoverageTrackerWorker extends BaseWorker {
         // Collect coverage metrics
         const trend = await this.collectCoverageTrend(context);
         const gaps = await this.identifyCoverageGaps(context);
-        // Analyze coverage thresholds
-        this.analyzeCoverageThresholds(trend.current, findings, recommendations);
         // Analyze coverage gaps
         this.analyzeCoverageGaps(gaps, findings, recommendations);
-        // Analyze trends
-        this.analyzeCoverageTrends(trend, findings, recommendations);
-        // Store current metrics
-        await context.memory.set('coverage:current', trend.current);
+        // #1018: with no measured coverage there is nothing to compare, nothing
+        // to store, and no figure to report — never a fake 0% record.
+        const current = trend.current;
+        if (current) {
+            this.analyzeCoverageThresholds(current, findings, recommendations);
+            this.analyzeCoverageTrends({ ...trend, current }, findings, recommendations);
+            await context.memory.set('coverage:current', current);
+        }
+        else {
+            findings.push({
+                type: 'coverage-unmeasured',
+                severity: 'info',
+                domain: 'coverage-analysis',
+                title: 'Coverage Unmeasured',
+                description: 'No measured coverage exists yet (no instrumented coverage:latest). Nothing was ' +
+                    'tracked; this is not 0% coverage. Run tests with coverage or coverage_analyze_sublinear.',
+            });
+        }
         await context.memory.set('coverage:gaps', gaps);
-        const healthScore = this.calculateHealthScore(trend.current, gaps);
+        const healthScore = this.calculateHealthScore(current, gaps);
         context.logger.info('Coverage tracking complete', {
             healthScore,
+            measured: current !== null,
             findingsCount: findings.length,
             gapsFound: gaps.length,
         });
+        const pct = (v) => (v === null || v === undefined ? 'n/a' : `${v}%`);
         return this.createResult(Date.now() - startTime, {
-            itemsAnalyzed: gaps.length + 4, // 4 coverage types + gaps
-            issuesFound: findings.length,
+            itemsAnalyzed: gaps.length + (current ? 4 : 0), // 4 coverage types + gaps
+            issuesFound: findings.filter(f => f.severity !== 'info').length,
             healthScore,
-            trend: this.determineTrend(trend),
+            trend: current ? this.determineTrend({ ...trend, current }) : 'stable',
             domainMetrics: {
-                lineCoverage: `${trend.current.line}%`,
-                branchCoverage: `${trend.current.branch}%`,
-                functionCoverage: `${trend.current.function}%`,
-                statementCoverage: `${trend.current.statement}%`,
+                coverageMeasured: current ? 'true' : 'false',
+                lineCoverage: current ? pct(current.line) : 'unmeasured',
+                branchCoverage: current ? pct(current.branch) : 'unmeasured',
+                functionCoverage: current ? pct(current.function) : 'unmeasured',
+                statementCoverage: current ? pct(current.statement) : 'unmeasured',
                 gapsCount: gaps.length,
             },
         }, findings, recommendations);
     }
     async collectCoverageTrend(context) {
-        const previous = await context.memory.get('coverage:current');
-        // Read real coverage data from coverage:latest (written by coverage-analyzer
-        // and test-executor). Fall back to zeros when no data is available.
-        const latest = await context.memory.get('coverage:latest');
+        // A previous record is a baseline only if it was measured (#1018): older
+        // versions wrote an all-zero coverage:current when nothing was measured.
+        const stored = await context.memory.get('coverage:current');
+        const previous = stored && stored.measured === true && Number.isFinite(stored.line) ? stored : undefined;
+        // Real coverage comes from coverage:latest (written by coverage-analyzer,
+        // test-executor and the quality-assessment listener). Only a record
+        // stamped measured:true with finite figures counts (#1008/#1018); a
+        // missing, legacy or estimated record means "unmeasured" — never zeros.
+        const latest = measuredCoverageSummary(await context.memory.get('coverage:latest'));
+        if (!latest)
+            return { current: null, previous };
         const current = {
-            line: latest?.line ?? 0,
-            branch: latest?.branch ?? 0,
-            function: latest?.function ?? 0,
-            statement: latest?.statement ?? 0,
+            line: latest.line,
+            branch: latest.branch,
+            function: latest.function,
+            statement: latest.statement,
             timestamp: new Date(),
+            measured: true,
         };
         return { current, previous };
     }
@@ -112,7 +136,7 @@ export class CoverageTrackerWorker extends BaseWorker {
                 context: { current: coverage.line, target: thresholds.line },
             });
         }
-        if (coverage.branch < thresholds.branch) {
+        if (coverage.branch !== null && coverage.branch < thresholds.branch) {
             findings.push({
                 type: 'low-branch-coverage',
                 severity: coverage.branch < 50 ? 'high' : 'medium',
@@ -131,7 +155,7 @@ export class CoverageTrackerWorker extends BaseWorker {
                 autoFixable: true,
             });
         }
-        if (coverage.function < thresholds.function) {
+        if (coverage.function !== null && coverage.function < thresholds.function) {
             findings.push({
                 type: 'low-function-coverage',
                 severity: 'medium',
@@ -195,7 +219,8 @@ export class CoverageTrackerWorker extends BaseWorker {
         if (!trend.previous)
             return;
         const lineChange = trend.current.line - trend.previous.line;
-        const branchChange = trend.current.branch - trend.previous.branch;
+        const branchChange = trend.current.branch !== null && trend.previous.branch !== null
+            ? trend.current.branch - trend.previous.branch : 0;
         if (lineChange < -2) {
             findings.push({
                 type: 'coverage-regression',
@@ -235,21 +260,32 @@ export class CoverageTrackerWorker extends BaseWorker {
         }
     }
     calculateHealthScore(coverage, gaps) {
-        // Weight: line 25%, branch 25%, function 20%, statement 20%, gaps 10%
-        const lineScore = (coverage.line / 100) * 25;
-        const branchScore = (coverage.branch / 100) * 25;
-        const functionScore = (coverage.function / 100) * 20;
-        const statementScore = (coverage.statement / 100) * 20;
         // Gaps penalty
         const highRiskGaps = gaps.filter((g) => g.riskScore > 0.8).length;
         const gapsScore = Math.max(0, 10 - highRiskGaps * 2);
-        return Math.round(lineScore + branchScore + functionScore + statementScore + gapsScore);
+        // #1018: with no measurement, only the gap component is known; it is
+        // scaled to 0-100 rather than mixed with invented 0% coverage.
+        if (!coverage)
+            return gapsScore * 10;
+        // Weight: line 25%, branch 25%, function 20%, statement 20%, gaps 10%.
+        // An uncollected metric is left out and the rest are re-weighted.
+        const parts = [
+            [coverage.line, 25], [coverage.branch, 25], [coverage.function, 20], [coverage.statement, 20],
+        ];
+        const present = parts.filter((p) => p[0] !== null);
+        const weight = present.reduce((a, [, w]) => a + w, 0);
+        const coverageScore = present.reduce((a, [v, w]) => a + (v / 100) * w, 0) * (90 / weight);
+        return Math.round(coverageScore + gapsScore);
     }
     determineTrend(trend) {
         if (!trend.previous)
             return 'stable';
-        const avgCurrent = (trend.current.line + trend.current.branch + trend.current.function + trend.current.statement) / 4;
-        const avgPrevious = (trend.previous.line + trend.previous.branch + trend.previous.function + trend.previous.statement) / 4;
+        const avg = (c) => {
+            const values = [c.line, c.branch, c.function, c.statement].filter((v) => v !== null);
+            return values.reduce((a, v) => a + v, 0) / values.length;
+        };
+        const avgCurrent = avg(trend.current);
+        const avgPrevious = avg(trend.previous);
         if (avgCurrent > avgPrevious + 1)
             return 'improving';
         if (avgCurrent < avgPrevious - 1)

package/dist/workers/workers/regression-monitor.d.ts

@@ -6,14 +6,31 @@
  * - Test result regressions
  * - Performance regressions
  * - Coverage regressions
- * - Quality metric regressions
+ *
+ * #1028: every figure comes from measured evidence — the stamped
+ * `coverage:latest` record and the latest testsPassing quality evidence (with
+ * its run's recorded result). Nothing measured → nothing stored or compared.
  */
 import { BaseWorker } from '../base-worker';
 import { WorkerContext, WorkerResult } from '../interfaces';
 export declare class RegressionMonitorWorker extends BaseWorker {
     constructor();
     protected doExecute(context: WorkerContext): Promise<WorkerResult>;
+    /** Why a stored baseline is (not) used: absent, legacy (unstamped), stamped but malformed, or measured. */
+    private baselineStatus;
+    /**
+     * #1028: the current snapshot from measured sources only — the stamped
+     * `coverage:latest` (same validator as the coverage tracker and the quality
+     * gate) and the latest usable testsPassing evidence (same validation as the
+     * gate) with that run's recorded `test-run:<runId>` result. `null` when
+     * nothing is measured.
+     */
     private collectCurrentSnapshot;
+    private collectMeasuredTests;
+    /**
+     * Compare two measured snapshots. A metric is compared only when both sides
+     * measured it; an uncollected (`null`) metric is never compared (#1028).
+     */
     private detectRegressions;
     private analyzeRegressions;
     private getDomainForType;