agentic-qe 3.15.5 → 3.15.6

package/dist/domains/code-intelligence/services/metric-collector/loc-counter.js

@@ -14,6 +14,7 @@
 import { spawnSync } from 'child_process';
 import { existsSync, readdirSync, readFileSync, statSync } from 'fs';
 import { join, extname } from 'path';
+import { AQE_CLAUDE_DIR, AQE_STATE_DIR, findAqeClaudeDirs } from '../../../../shared/aqe-managed-dirs.js';
 import { DEFAULT_METRIC_CONFIG, } from './interfaces.js';
 import { safeJsonParse } from '../../../../shared/safe-json.js';
 // ============================================================================
@@ -77,6 +78,43 @@ export function checkLOCTools() {
     }
     return tools;
 }
+/**
+ * cloc `--not-match-f` regex matching any of `names` exactly (basename), or
+ * null when there is nothing to exclude.
+ */
+export function excludedFileNamesRegex(names) {
+    if (!names || names.length === 0)
+        return null;
+    // Matches a bare name and, under cloc --fullpath, a full path ending in it
+    // (either separator, so Windows paths match too).
+    return `(^|[\\\\/])(${names.map(escapeRegex).join('|')})$`;
+}
+/**
+ * cloc `--not-match-d` regex (with --fullpath) matching the given
+ * project-relative directories ('/'-separated) and everything below them, but
+ * no other directory of the same name (#999 review N4 / round 2b). Either
+ * path separator matches. Null when there are none.
+ */
+export function rootAnchoredDirsRegex(projectPath, relDirs) {
+    if (!relDirs || relDirs.length === 0)
+        return null;
+    const SEP = '[\\\\/]';
+    const toPattern = (path) => path.split(/[\\/]+/).filter(Boolean).map(escapeRegex).join(SEP);
+    const root = toPattern(projectPath);
+    const rootPrefix = /^[\\/]/.test(projectPath) ? SEP : '';
+    return `^${rootPrefix}${root}${SEP}(${relDirs.map(toPattern).join('|')})(${SEP}|$)`;
+}
+/** Project-relative AQE-managed `.claude` dirs to exclude, if `.claude` is a root exclude. */
+function aqeClaudeDirsToExclude(projectPath, config) {
+    const rootDirs = config.excludeRootDirs ?? [];
+    if (!rootDirs.includes(AQE_CLAUDE_DIR))
+        return rootDirs.filter((d) => existsSync(join(projectPath, d)));
+    const others = rootDirs.filter((d) => d !== AQE_CLAUDE_DIR && existsSync(join(projectPath, d)));
+    return [...findAqeClaudeDirs(projectPath, config.excludeDirs), ...others];
+}
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
 // ============================================================================
 // Tool-Specific Implementations
 // ============================================================================
@@ -85,7 +123,17 @@ export function checkLOCTools() {
  */
 async function tryClocCount(projectPath, config) {
     try {
-        const args = ['--json', `--exclude-dir=${config.excludeDirs.join(',')}`, projectPath];
+        const args = ['--json', `--exclude-dir=${config.excludeDirs.join(',')}`];
+        const notMatchDir = rootAnchoredDirsRegex(projectPath, aqeClaudeDirsToExclude(projectPath, config));
+        // --fullpath makes --not-match-d/-f see full paths, so the AQE-managed
+        // .claude dirs (root, or next to a nested .agentic-qe) are excluded
+        // without dropping other same-named dirs (#999 review N4 / round 2b).
+        if (notMatchDir)
+            args.push('--fullpath', `--not-match-d=${notMatchDir}`);
+        const notMatch = excludedFileNamesRegex(config.excludeFiles);
+        if (notMatch)
+            args.push(`--not-match-f=${notMatch}`);
+        args.push(projectPath);
         const result = spawnSync('cloc', args, {
             encoding: 'utf-8',
             timeout: config.timeout,
@@ -134,8 +182,19 @@ async function tryTokeiCount(projectPath, config) {
         for (const dir of config.excludeDirs) {
             args.push('-e', dir);
         }
-        args.push(projectPath);
+        // #999: lockfiles are generated, not code (tokei -e takes gitignore-style names)
+        for (const file of config.excludeFiles ?? []) {
+            args.push('-e', file);
+        }
+        // A leading '/' anchors a tokei (gitignore-style) exclude at the directory
+        // tokei walks, so run it IN the project on '.' (round 2b: with an absolute
+        // path argument the anchored patterns matched nothing).
+        for (const rel of aqeClaudeDirsToExclude(projectPath, config)) {
+            args.push('-e', `/${rel}`);
+        }
+        args.push('.');
         const result = spawnSync('tokei', args, {
+            cwd: projectPath,
             encoding: 'utf-8',
             timeout: config.timeout,
             maxBuffer: 10 * 1024 * 1024, // 10MB buffer (reduced for memory safety)
@@ -237,6 +296,8 @@ function manualLOCCount(projectPath, config) {
     const byLanguage = {};
     let total = 0;
     const excludeSet = new Set(config.excludeDirs);
+    const excludeFileSet = new Set(config.excludeFiles ?? []);
+    const rootExcludeSet = new Set(config.excludeRootDirs ?? []);
     // Max file size to read (2MB) — skip minified bundles, generated files
     const MAX_FILE_SIZE = 2 * 1024 * 1024;
     function walkDirectory(dirPath, depth) {
@@ -255,12 +316,17 @@ function manualLOCCount(projectPath, config) {
             const fullPath = join(dirPath, entry.name);
             if (entry.isDirectory()) {
                 // Skip excluded directories (exact match or glob-like suffix match)
-                if (excludeSet.has(entry.name) || entry.name.startsWith('.')) {
+                if (excludeSet.has(entry.name) || entry.name.startsWith('.') ||
+                    (rootExcludeSet.has(entry.name) &&
+                        (dirPath === projectPath || existsSync(join(dirPath, AQE_STATE_DIR))))) {
                     continue;
                 }
                 walkDirectory(fullPath, depth + 1);
             }
             else if (entry.isFile()) {
+                // #999: skip lockfiles and other generated files by exact name
+                if (excludeFileSet.has(entry.name))
+                    continue;
                 const ext = extname(entry.name);
                 const language = getLanguageForExtension(ext);
                 if (language) {

package/dist/domains/code-intelligence/services/metric-collector/test-counter.js

@@ -17,6 +17,7 @@ import { createRequire } from 'module';
 import { existsSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync } from 'fs';
 import { tmpdir } from 'os';
 import { join, extname, resolve } from 'path';
+import { AQE_STATE_DIR } from '../../../../shared/aqe-managed-dirs.js';
 import { DEFAULT_METRIC_CONFIG, } from './interfaces.js';
 import { safeJsonParse } from '../../../../shared/safe-json.js';
 import { ownListingProcess } from './listing-process-owner.js';
@@ -478,7 +479,9 @@ function countTestsByFilePattern(projectPath, config) {
             const fullPath = join(dirPath, entry.name);
             if (entry.isDirectory()) {
                 // Skip excluded directories
-                if (config.excludeDirs.includes(entry.name)) {
+                if (config.excludeDirs.includes(entry.name) ||
+                    ((config.excludeRootDirs ?? []).includes(entry.name) &&
+                        (dirPath === projectPath || existsSync(join(dirPath, AQE_STATE_DIR))))) {
                     continue;
                 }
                 walkDirectory(fullPath);

package/dist/domains/coverage-analysis/collected-metrics.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Which coverage metrics a report actually collected (#995, #1015, #1027).
+ *
+ * A metric with no data in the report (no branch entries, no functions, no
+ * statement detail — lcov and Cobertura carry none) is "not collected". Its
+ * summary figure is 0 by construction, and must be reported AND persisted as
+ * null — never as 0% (a fake low figure) nor as istanbul's 0/0 = 100%.
+ */
+import type { CoverageSummary, FileCoverage } from './interfaces';
+/**
+ * The ONE key form for per-file coverage records (#1027 N7): the absolute
+ * path. Reports write absolute (istanbul) or project-relative (lcov
+ * `SF:src/a.ts`) paths; a relative one is resolved against the project root
+ * (or the cwd when none is known), so one file never has two records.
+ */
+export declare function fileCoverageKey(filePath: string, projectRoot?: string): string;
+export interface CollectedMetrics {
+    branch: boolean;
+    function: boolean;
+    statement: boolean;
+}
+/** Which optional metrics the files carry. Line coverage is always collected. */
+export declare function collectedMetrics(files: readonly FileCoverage[]): CollectedMetrics;
+/** A summary as it is reported and persisted: uncollected metrics are null. */
+export interface CollectedSummary {
+    line: number;
+    branch: number | null;
+    function: number | null;
+    statement: number | null;
+    files: number;
+}
+export declare function collectedSummary(summary: CoverageSummary, collected: CollectedMetrics): CollectedSummary;
+//# sourceMappingURL=collected-metrics.d.ts.map

package/dist/domains/coverage-analysis/collected-metrics.js

@@ -0,0 +1,36 @@
+/**
+ * Which coverage metrics a report actually collected (#995, #1015, #1027).
+ *
+ * A metric with no data in the report (no branch entries, no functions, no
+ * statement detail — lcov and Cobertura carry none) is "not collected". Its
+ * summary figure is 0 by construction, and must be reported AND persisted as
+ * null — never as 0% (a fake low figure) nor as istanbul's 0/0 = 100%.
+ */
+import * as path from 'path';
+/**
+ * The ONE key form for per-file coverage records (#1027 N7): the absolute
+ * path. Reports write absolute (istanbul) or project-relative (lcov
+ * `SF:src/a.ts`) paths; a relative one is resolved against the project root
+ * (or the cwd when none is known), so one file never has two records.
+ */
+export function fileCoverageKey(filePath, projectRoot) {
+    return path.isAbsolute(filePath) ? path.normalize(filePath) : path.resolve(projectRoot ?? process.cwd(), filePath);
+}
+/** Which optional metrics the files carry. Line coverage is always collected. */
+export function collectedMetrics(files) {
+    return {
+        branch: files.some(f => f.branches.total > 0),
+        function: files.some(f => f.functions.total > 0),
+        statement: files.some(f => f.statements.total > 0),
+    };
+}
+export function collectedSummary(summary, collected) {
+    return {
+        line: summary.line,
+        branch: collected.branch ? summary.branch : null,
+        function: collected.function ? summary.function : null,
+        statement: collected.statement ? summary.statement : null,
+        files: summary.files,
+    };
+}
+//# sourceMappingURL=collected-metrics.js.map

package/dist/domains/coverage-analysis/coordinator.js

@@ -7,6 +7,7 @@ import { LoggerFactory } from '../../logging/index.js';
 import { ok, err } from '../../shared/types/index.js';
 import { toError } from '../../shared/error-utils.js';
 import { createEvent, CoverageAnalysisEvents, } from '../../shared/events/index.js';
+import { isMeasuredGapRequest, } from './interfaces.js';
 import { CoverageAnalyzerService, GapDetectorService, RiskScorerService, } from './services/index.js';
 import { GhostCoverageAnalyzerService } from './services/ghost-coverage-analyzer.js';
 import { createHNSWIndex } from './services/hnsw-index.js';
@@ -404,8 +405,12 @@ export class CoverageAnalysisCoordinator extends BaseDomainCoordinator {
                     }
                     verifiedGaps.push(gap);
                 }
-                // Publish gap detection events for verified high-risk gaps
-                await this.publishGapEvents(verifiedGaps);
+                // Publish gap detection events for verified high-risk gaps — only for
+                // MEASURED coverage (#1014). Consumers learn from these events
+                // (learning-optimization experiences, code/defect-intel KV).
+                if (isMeasuredGapRequest(request)) {
+                    await this.publishGapEvents(verifiedGaps);
+                }
                 // Return result with verified gaps
                 return ok({
                     ...result.value,
@@ -479,7 +484,9 @@ export class CoverageAnalysisCoordinator extends BaseDomainCoordinator {
                 const date = new Date(timestamp);
                 if (date >= timeRange.start && date <= timeRange.end) {
                     const summary = await this.memory.get(key);
-                    if (summary) {
+                    // #1014: only measured snapshots are trend points. Unstamped legacy
+                    // snapshots (estimates were written here up to 3.15.4) are skipped.
+                    if (summary && summary.measured === true && Number.isFinite(summary.line)) {
                         dataPoints.push({ date, coverage: summary });
                     }
                 }
@@ -611,11 +618,13 @@ export class CoverageAnalysisCoordinator extends BaseDomainCoordinator {
         const payload = {
             reportId: crypto.randomUUID(),
             line: report.summary.line,
-            branch: report.summary.branch,
-            function: report.summary.function,
-            statement: report.summary.statement,
+            // #1027 B2: an uncollected metric travels as null, never as its 0.
+            branch: report.collected && !report.collected.branch ? null : report.summary.branch,
+            function: report.collected && !report.collected.function ? null : report.summary.function,
+            statement: report.collected && !report.collected.statement ? null : report.summary.statement,
             files: report.summary.files,
             measured: true,
+            ...(report.runStatus ? { runStatus: report.runStatus } : {}),
         };
         const event = createEvent(CoverageAnalysisEvents.CoverageReportCreated, 'coverage-analysis', payload);
         await this.eventBus.publish(event);
@@ -630,6 +639,9 @@ export class CoverageAnalysisCoordinator extends BaseDomainCoordinator {
                 uncoveredLines: gap.lines,
                 uncoveredBranches: gap.branches,
                 riskScore: gap.riskScore,
+                // #1014: provenance — only measured gaps are ever published.
+                measured: true,
+                coverageMethod: 'instrumented-report',
             };
             const event = createEvent(CoverageAnalysisEvents.CoverageGapDetected, 'coverage-analysis', payload);
             await this.eventBus.publish(event);

package/dist/domains/coverage-analysis/interfaces.d.ts

@@ -27,6 +27,29 @@ export interface AnalyzeCoverageRequest {
      * are absent the data is treated as UNMEASURED and nothing is persisted.
      */
     measured?: boolean;
+    /**
+     * Outcome of the test run that produced `coverageData`, when one ran
+     * (#1027 N4). Coverage from a run whose tests failed is still a
+     * measurement: it is persisted, stamped `runStatus: 'failed'`; the failure
+     * itself is carried by testsPassing.
+     */
+    runStatus?: 'passed' | 'failed';
+    /**
+     * Counts of the test run behind `coverageData`, when one ran (#1027 NB1).
+     * Its testsPassing is recorded together with the coverage, under one runId,
+     * so failing-run coverage never pairs with a stale testsPassing.
+     */
+    testRun?: {
+        runId: string;
+        passed: number;
+        failed: number;
+        skipped?: number;
+    };
+    /**
+     * Project root that relative report paths (lcov `SF:src/a.ts`) resolve
+     * against, so per-file records use ONE key form: the absolute path (#1027 N7).
+     */
+    projectRoot?: string;
 }
 export interface CoverageData {
     files: FileCoverage[];
@@ -72,6 +95,18 @@ export interface CoverageReport {
      * report was not persisted and must not be published or stored as evidence.
      */
     measured?: boolean;
+    /**
+     * Which optional metrics the report collected (#1027 B2). `summary` holds 0
+     * for an uncollected metric by construction; consumers must report and
+     * persist it as null.
+     */
+    collected?: {
+        branch: boolean;
+        function: boolean;
+        statement: boolean;
+    };
+    /** Outcome of the test run behind the report, when known (#1027 N4). */
+    runStatus?: 'passed' | 'failed';
 }
 export interface CoverageDelta {
     line: number;
@@ -84,7 +119,16 @@ export interface GapDetectionRequest {
     coverageData: CoverageData;
     minCoverage?: number;
     prioritize?: 'risk' | 'size' | 'recent-changes';
+    /**
+     * Provenance of `coverageData` (#1014), as for AnalyzeCoverageRequest.
+     * Takes precedence over `coverageData.instrumented`. Fail-closed: gaps from
+     * data that is not explicitly measured are returned but never learned from
+     * (no gap-pattern vectors) nor published as CoverageGapDetected.
+     */
+    measured?: boolean;
 }
+/** Whether a gap-detection request carries measured coverage (#1014, fail-closed). */
+export declare function isMeasuredGapRequest(request: GapDetectionRequest): boolean;
 export interface CoverageGaps {
     gaps: CoverageGap[];
     totalUncoveredLines: number;

package/dist/domains/coverage-analysis/interfaces.js

@@ -2,5 +2,10 @@
  * Agentic QE v3 - Coverage Analysis Domain Interface
  * O(log n) coverage gap detection with HNSW
  */
-export {};
+/** Whether a gap-detection request carries measured coverage (#1014, fail-closed). */
+export function isMeasuredGapRequest(request) {
+    if (typeof request.measured === 'boolean')
+        return request.measured;
+    return request.coverageData.instrumented === true;
+}
 //# sourceMappingURL=interfaces.js.map

package/dist/domains/coverage-analysis/services/coverage-analyzer.js

@@ -8,8 +8,10 @@ import { LoggerFactory } from '../../../logging/index.js';
 import { ok, err } from '../../../shared/types/index.js';
 import { toError } from '../../../shared/error-utils.js';
 import { safeJsonParse } from '../../../shared/safe-json.js';
-import { writeQualityEvidence } from '../../quality-assessment/quality-evidence.js';
+import { writeQualityEvidence, writeTestRunEvidence } from '../../quality-assessment/quality-evidence.js';
+import { measuredCoverageSummary } from '../../quality-assessment/coverage-report-event.js';
 import { getClaudeModelForTier } from '../../../shared/llm/model-registry.js';
+import { collectedMetrics, collectedSummary, fileCoverageKey } from '../collected-metrics.js';
 /**
  * Whether an analyze request carries instrumented (measured) coverage (#1008).
  * Fail-closed: an explicit `request.measured` wins; otherwise only data a
@@ -82,17 +84,21 @@ export class CoverageAnalyzerService {
             // written over a measurement, and never stored where a quality gate,
             // quality_assess or another reader would take it as measured.
             const measured = isMeasuredCoverage(request);
+            // #1027 B2: a metric the report never collected is null wherever it is
+            // persisted or compared — never the 0 calculateMetrics yields for it.
+            const collected = collectedMetrics(coverageData.files);
+            const stored = collectedSummary(summary, collected);
             // Calculate delta from previous coverage (if stored)
-            const delta = measured ? await this.calculateDelta(summary) : undefined;
+            const delta = measured ? await this.calculateDelta(stored) : undefined;
             // Generate recommendations based on analysis
             const recommendations = this.generateRecommendations(coverageData, summary, threshold);
             if (measured) {
                 // Store current coverage for future delta calculations
-                await this.storeCoverageSnapshot(summary);
+                await this.storeCoverageSnapshot(stored, request.runStatus, request.testRun);
                 // Store coverage vectors for similarity search + KV for quality-analyzer
                 if (request.includeFileDetails) {
-                    await this.indexFileCoverageVectors(coverageData.files);
-                    await this.storeFileCoverageKV(coverageData.files);
+                    await this.indexFileCoverageVectors(coverageData.files, request.projectRoot);
+                    await this.storeFileCoverageKV(coverageData.files, request.projectRoot, request.runStatus);
                 }
             }
             return ok({
@@ -101,6 +107,8 @@ export class CoverageAnalyzerService {
                 delta,
                 recommendations,
                 measured,
+                collected,
+                ...(request.runStatus ? { runStatus: request.runStatus } : {}),
             });
         }
         catch (error) {
@@ -421,14 +429,20 @@ Provide thoughtful, specific analysis based on the coverage data. Do not include
     }
     async calculateDelta(current) {
         try {
-            const previous = await this.memory.get('coverage:latest');
+            // #1015: only a measured baseline with finite figures is a baseline. A
+            // legacy unstamped record (e.g. the `{"files":0}` bridge echo removed in
+            // #1013) gave a NaN delta that was reported as "stable".
+            const previous = measuredCoverageSummary(await this.memory.get('coverage:latest'));
             if (!previous) {
                 return undefined;
             }
+            // A metric not collected on EITHER side has no delta (0 — never NaN,
+            // never a fake swing against an uncollected 0, #1027 B2).
+            const diff = (now, before) => (now === null || before === null ? 0 : now - before);
             const lineDelta = current.line - previous.line;
-            const branchDelta = current.branch - previous.branch;
-            const functionDelta = current.function - previous.function;
-            const statementDelta = current.statement - previous.statement;
+            const branchDelta = diff(current.branch, previous.branch);
+            const functionDelta = diff(current.function, previous.function);
+            const statementDelta = diff(current.statement, previous.statement);
             const avgDelta = (lineDelta + branchDelta + functionDelta + statementDelta) / 4;
             let trend;
             if (avgDelta > 0.5) {
@@ -452,23 +466,36 @@ Provide thoughtful, specific analysis based on the coverage data. Do not include
             return undefined;
         }
     }
-    async storeCoverageSnapshot(summary) {
+    async storeCoverageSnapshot(summary, runStatus, testRun) {
         try {
-            // Rotate: copy current coverage:latest → coverage:previous before overwriting
-            const existing = await this.memory.get('coverage:latest');
+            // Rotate: copy current coverage:latest → coverage:previous before
+            // overwriting — only a measured record (#1015): legacy junk is dropped,
+            // never promoted to the baseline.
+            const existing = measuredCoverageSummary(await this.memory.get('coverage:latest'));
             if (existing) {
                 await this.memory.set('coverage:previous', existing, { persist: true });
             }
             // Store latest snapshot, stamped with its provenance (#1008). Only
             // measured coverage reaches this method.
-            await this.memory.set('coverage:latest', { ...summary, measured: true }, { persist: true });
-            await writeQualityEvidence(this.memory, { coverage: summary.line }, {
-                measuredAt: new Date().toISOString(),
-                source: 'coverage-analysis',
-            });
+            // #1027: uncollected metrics are null; runStatus says if tests failed (N4).
+            const record = { ...summary, measured: true, ...(runStatus ? { runStatus } : {}) };
+            await this.memory.set('coverage:latest', record, { persist: true });
+            if (testRun) {
+                // #1027 NB1: the run's testsPassing and coverage, under one runId.
+                await writeTestRunEvidence(this.memory, testRun, { source: 'coverage-analysis', coverage: summary.line });
+            }
+            else {
+                // No counts: a failing run's coverage carries runStatus but no runId,
+                // so the gate will not pair it with any testsPassing (fail-closed).
+                await writeQualityEvidence(this.memory, { coverage: summary.line }, {
+                    measuredAt: new Date().toISOString(),
+                    source: 'coverage-analysis',
+                    ...(runStatus ? { runStatus } : {}),
+                });
+            }
             // Store historical snapshot
             const timestamp = Date.now();
-            await this.memory.set(`coverage:history:${timestamp}`, summary, {
+            await this.memory.set(`coverage:history:${timestamp}`, record, {
                 persist: true,
                 namespace: 'coverage-history',
             });
@@ -482,22 +509,22 @@ Provide thoughtful, specific analysis based on the coverage data. Do not include
      * and defect-predictor can read it with memory.get().
      * (The vector index via storeVector is kept for similarity search.)
      */
-    async storeFileCoverageKV(files) {
+    async storeFileCoverageKV(files, projectRoot, runStatus) {
         for (const file of files) {
             try {
-                const linePct = file.lines.total > 0
-                    ? Math.round((file.lines.covered / file.lines.total) * 10000) / 100 : 0;
-                const branchPct = file.branches.total > 0
-                    ? Math.round((file.branches.covered / file.branches.total) * 10000) / 100 : 0;
-                const fnPct = file.functions.total > 0
-                    ? Math.round((file.functions.covered / file.functions.total) * 10000) / 100 : 0;
-                const stmtPct = file.statements.total > 0
-                    ? Math.round((file.statements.covered / file.statements.total) * 10000) / 100 : 0;
-                await this.memory.set(`coverage:file:${file.path}`, {
-                    line: linePct,
-                    branch: branchPct,
-                    function: fnPct,
-                    statement: stmtPct,
+                // #1014: a metric with no data is null (not collected), never 0%.
+                const pct = (m) => m.total > 0 ? Math.round((m.covered / m.total) * 10000) / 100 : null;
+                if (file.lines.total === 0)
+                    continue;
+                // #1014: stamped, so readers can tell it from legacy unstamped
+                // estimate records written by <= 3.15.4.
+                await this.memory.set(`coverage:file:${fileCoverageKey(file.path, projectRoot)}`, {
+                    line: pct(file.lines),
+                    branch: pct(file.branches),
+                    function: pct(file.functions),
+                    statement: pct(file.statements),
+                    measured: true,
+                    ...(runStatus ? { runStatus } : {}),
                 }, { persist: true });
             }
             catch {
@@ -505,12 +532,12 @@ Provide thoughtful, specific analysis based on the coverage data. Do not include
             }
         }
     }
-    async indexFileCoverageVectors(files) {
+    async indexFileCoverageVectors(files, projectRoot) {
         for (const file of files) {
             try {
                 // Create a vector representation of the file coverage
                 const embedding = this.createCoverageEmbedding(file);
-                await this.memory.storeVector(`coverage:file:${file.path}`, embedding, {
+                await this.memory.storeVector(`coverage:file:${fileCoverageKey(file.path, projectRoot)}`, embedding, {
                     path: file.path,
                     lineCoverage: file.lines.covered / (file.lines.total || 1),
                     branchCoverage: file.branches.covered / (file.branches.total || 1),

package/dist/domains/coverage-analysis/services/gap-detector.js

@@ -7,6 +7,7 @@
 import { LoggerFactory } from '../../../logging/index.js';
 import { ok, err } from '../../../shared/types/index.js';
 import { toError } from '../../../shared/error-utils.js';
+import { isMeasuredGapRequest, } from '../interfaces.js';
 import { safeJsonParse } from '../../../shared/safe-json.js';
 import { getClaudeModelForTier } from '../../../shared/llm/model-registry.js';
 import { createSafeRecord } from '../../../shared/utils/safe-record.js';
@@ -238,8 +239,12 @@ Return JSON in this exact format:
             const prioritizedGaps = this.prioritizeGaps(gaps, prioritize);
             // Calculate estimated effort
             const estimatedEffort = this.calculateTotalEffort(prioritizedGaps);
-            // Store gap patterns for learning
-            await this.storeGapPatterns(prioritizedGaps);
+            // Store gap patterns for learning — only gaps in MEASURED coverage
+            // (#1014). A gap from a static estimate is a hypothesis: returned to the
+            // caller, never persisted as a gap-pattern vector.
+            if (isMeasuredGapRequest(request)) {
+                await this.storeGapPatterns(prioritizedGaps);
+            }
             return ok({
                 gaps: prioritizedGaps,
                 totalUncoveredLines,

package/dist/domains/defect-intelligence/plugin.js

@@ -9,6 +9,7 @@ import { DefectPredictorService, } from './services/defect-predictor.js';
 import { PatternLearnerService, } from './services/pattern-learner.js';
 import { toError } from '../../shared/error-utils.js';
 import { RootCauseAnalyzerService, } from './services/root-cause-analyzer.js';
+import { isMeasuredGapPayload } from '../../shared/events/domain-events.js';
 /**
  * Defect Intelligence Domain Plugin
  * Provides ML-based defect prediction and analysis capabilities
@@ -307,6 +308,9 @@ export class DefectIntelligencePlugin extends BaseDomainPlugin {
         }
     }
     async handleCoverageGap(event) {
+        // #1014: only a gap found in MEASURED coverage is acted on / learned from.
+        if (!isMeasuredGapPayload(event.payload))
+            return;
         // Coverage gap detected - assess defect risk
         const payload = event.payload;
         // High risk coverage gaps indicate defect-prone areas

package/dist/domains/defect-intelligence/services/defect-predictor.js

@@ -14,6 +14,7 @@ import { TypeScriptParser } from '../../../shared/parsers/index.js';
 import { toError } from '../../../shared/error-utils.js';
 import { safeJsonParse } from '../../../shared/safe-json.js';
 import { getClaudeModelForTier } from '../../../shared/llm/model-registry.js';
+import { measuredCoverageSummary, measuredFileCoverage } from '../../quality-assessment/coverage-report-event.js';
 // LLMDefectAnalysis is imported from ../interfaces
 const DEFAULT_CONFIG = {
     defaultThreshold: 0.5,
@@ -590,14 +591,15 @@ Be specific and actionable. Focus on concrete issues, not generic advice.`,
     async getTestCoverage(file) {
         try {
             // Try per-file coverage (written by coverage-analyzer and test-executor)
-            const fileCoverage = await this.memory.get(`coverage:file:${file}`);
-            if (fileCoverage && typeof fileCoverage.line === 'number') {
+            // #1014: only measured records; legacy unstamped estimates are ignored.
+            const fileCoverage = measuredFileCoverage(await this.memory.get(`coverage:file:${file}`));
+            if (fileCoverage) {
                 // Invert: low coverage = high defect risk
                 return 1 - fileCoverage.line / 100;
             }
             // Fall back to project-wide coverage
-            const summary = await this.memory.get('coverage:latest');
-            if (summary && typeof summary.line === 'number') {
+            const summary = measuredCoverageSummary(await this.memory.get('coverage:latest'));
+            if (summary) {
                 return 1 - summary.line / 100;
             }
         }

package/dist/domains/learning-optimization/coordinator.js

@@ -18,6 +18,7 @@ import { BaseDomainCoordinator, } from '../base-domain-coordinator.js';
 // CQ-004: Extracted modules
 import * as LearningHelpers from './coordinator-helpers.js';
 import * as ConsensusHelpers from './coordinator-consensus.js';
+import { isMeasuredGapPayload } from '../../shared/events/domain-events.js';
 const DEFAULT_CONFIG = {
     maxConcurrentWorkflows: 3,
     defaultTimeout: 120000, // 2 minutes
@@ -958,6 +959,9 @@ export class LearningOptimizationCoordinator extends BaseDomainCoordinator {
         });
     }
     async handleCoverageGap(event) {
+        // #1014: only a gap found in MEASURED coverage is acted on / learned from.
+        if (!isMeasuredGapPayload(event.payload))
+            return;
         // Record as experience for learning
         const { gapId, file, riskScore } = event.payload;
         await this.learningService.recordExperience({

package/dist/domains/learning-optimization/plugin.js

@@ -7,6 +7,7 @@ import { BaseDomainPlugin } from '../domain-interface.js';
 import { LearningOptimizationCoordinator, } from './coordinator.js';
 import { toError } from '../../shared/error-utils.js';
 import { LearningCoordinatorService, TransferSpecialistService, MetricsOptimizerService, ProductionIntelService, } from './services/index.js';
+import { isMeasuredGapPayload } from '../../shared/events/domain-events.js';
 /**
  * Learning & Optimization Domain Plugin
  * Provides cross-domain learning, pattern extraction, and strategy optimization
@@ -439,6 +440,9 @@ export class LearningOptimizationPlugin extends BaseDomainPlugin {
         await this.productionIntel.recordMetric('test_success_rate', successRate, 'ratio', 'test-execution', ['automated']);
     }
     async handleCoverageGap(event) {
+        // #1014: only a gap found in MEASURED coverage is acted on / learned from.
+        if (!isMeasuredGapPayload(event.payload))
+            return;
         const payload = event.payload;
         await this.learningService.recordExperience({
             agentId: {