agentic-qe 3.15.5 → 3.15.7

package/dist/domains/test-execution/services/test-executor.js

@@ -7,13 +7,16 @@ import { spawn } from 'node:child_process';
 import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { isDeepStrictEqual } from 'node:util';
 import { v4 as uuidv4 } from 'uuid';
 import { ok, err } from '../../../shared/types/index.js';
 import { TEST_EXECUTION_CONSTANTS, LLM_ANALYSIS_CONSTANTS } from '../../constants.js';
 import { toErrorMessage, toError } from '../../../shared/error-utils.js';
 import { safeJsonParse } from '../../../shared/safe-json.js';
 import { secureRandom, secureRandomInt } from '../../../shared/utils/crypto-random.js';
-import { writeQualityEvidence } from '../../quality-assessment/quality-evidence.js';
+import { writeTestRunEvidence } from '../../quality-assessment/quality-evidence.js';
+import { istanbulLineHits } from '../../../coordination/handlers/handler-utils.js';
+import { fileCoverageKey } from '../../coverage-analysis/collected-metrics.js';
 import { getTestRunnerExecutionError, TestRunnerExecutionError } from '../../../shared/test-runner-verdict.js';
 import { createVitestJsonReport } from '../../../shared/vitest-json-report.js';
 import { jestExactPathPattern, runnerFilePath } from '../../../shared/test-runner-args.js';
@@ -78,7 +81,7 @@ export class TestExecutorService {
             };
             // Store results
             this.runResults.set(runId, runResult);
-            await this.storeResults(runId, runResult);
+            await this.storeResults(runId, runResult, request.testFiles);
             // Create and store stats
             const stats = {
                 runId,
@@ -133,7 +136,7 @@ export class TestExecutorService {
             };
             // Store results
             this.runResults.set(runId, runResult);
-            await this.storeResults(runId, runResult);
+            await this.storeResults(runId, runResult, request.testFiles);
             // Create and store stats
             const stats = {
                 runId,
@@ -303,11 +306,13 @@ Provide:
         const failedTests = [];
         const coverages = [];
         const allFileCoverages = [];
+        const executionResults = [];
         let passed = 0;
         let failed = 0;
         let skipped = 0;
         for (const file of testFiles) {
             const result = await this.executeTestFile(file, framework, timeout);
+            executionResults.push(result);
             passed += result.passed;
             failed += result.failed;
             skipped += result.skipped;
@@ -319,16 +324,61 @@ Provide:
                 allFileCoverages.push(...result.fileCoverages);
             }
         }
+        // Separate runner invocations each have their own coverage map. Averaging
+        // percentages double-counts source files and misses disjoint hits (#1030).
+        // If any run lacks raw counters, there is no honest combined measurement.
+        const merged = testFiles.length > 1 && !this.config.simulateForTesting
+            ? this.mergeSequentialCoverage(executionResults)
+            : undefined;
+        const separateRuns = testFiles.length > 1 && !this.config.simulateForTesting;
         return {
             total: passed + failed + skipped,
             passed,
             failed,
             skipped,
             failedTests,
-            coverage: this.aggregateCoverage(coverages),
-            fileCoverages: allFileCoverages.length > 0 ? allFileCoverages : undefined,
+            coverage: separateRuns ? merged?.summary : this.aggregateCoverage(coverages),
+            fileCoverages: separateRuns ? merged?.perFile
+                : allFileCoverages.length > 0 ? allFileCoverages : undefined,
         };
     }
+    mergeSequentialCoverage(results) {
+        if (results.some(result => !result.rawCoverageMap))
+            return undefined;
+        const merged = {};
+        for (const result of results) {
+            for (const [rawPath, entry] of Object.entries(result.rawCoverageMap)) {
+                if (!isRecord(entry) || !isRecord(entry.statementMap) || !isRecord(entry.fnMap)
+                    || !isRecord(entry.branchMap) || !isRecord(entry.s) || !isRecord(entry.f)
+                    || !isRecord(entry.b))
+                    return undefined;
+                const file = fileCoverageKey(rawPath);
+                const prior = merged[file];
+                if (prior) {
+                    if (!isDeepStrictEqual(prior.statementMap, entry.statementMap)
+                        || !isDeepStrictEqual(prior.fnMap, entry.fnMap)
+                        || !isDeepStrictEqual(prior.branchMap, entry.branchMap))
+                        return undefined;
+                    for (const counter of ['s', 'f', 'b']) {
+                        const hits = mergeHitCounts(prior[counter], entry[counter]);
+                        if (!hits)
+                            return undefined;
+                        prior[counter] = hits;
+                    }
+                }
+                else {
+                    const s = mergeHitCounts(entry.s, entry.s);
+                    const f = mergeHitCounts(entry.f, entry.f);
+                    const b = mergeHitCounts(entry.b, entry.b);
+                    if (!s || !f || !b)
+                        return undefined;
+                    merged[file] = { ...entry, path: file, s, f, b };
+                }
+            }
+        }
+        const coverage = this.extractCoverageFromJson({ coverageMap: merged });
+        return coverage.summary ? { summary: coverage.summary, perFile: coverage.perFile } : undefined;
+    }
     async executeTestFile(file, framework, timeout) {
         return this.executeTestFiles([file], framework, timeout);
     }
@@ -458,13 +508,14 @@ Provide:
                 const parseResult = this.parseTestOutput(reportText, stderr, fileLabel, framework, code);
                 // Read only this invocation's coverage artifacts. A previous or
                 // concurrent run's project coverage directory is not evidence.
-                if (parseResult.success && !parseResult.value.coverage && coverageDirectory) {
+                if (parseResult.success && coverageDirectory) {
                     const diskCoverage = this.readCoverageFromDisk(coverageDirectory);
                     if (diskCoverage) {
-                        parseResult.value.coverage = diskCoverage.summary;
-                        if (diskCoverage.perFile.length > 0) {
+                        parseResult.value.coverage ??= diskCoverage.summary;
+                        if (!parseResult.value.fileCoverages && diskCoverage.perFile.length > 0) {
                             parseResult.value.fileCoverages = diskCoverage.perFile;
                         }
+                        parseResult.value.rawCoverageMap ??= diskCoverage.rawMap;
                     }
                 }
                 finish(parseResult);
@@ -659,6 +710,7 @@ Provide:
                     failedTests,
                     coverage: covData.summary,
                     fileCoverages: covData.perFile.length > 0 ? covData.perFile : undefined,
+                    rawCoverageMap: isRecord(json.coverageMap) && !json.coverageMap.total ? json.coverageMap : undefined,
                 });
             }
             catch {
@@ -713,6 +765,7 @@ Provide:
                 failedTests,
                 coverage: covData.summary,
                 fileCoverages: covData.perFile.length > 0 ? covData.perFile : undefined,
+                rawCoverageMap: isRecord(json.coverageMap) && !json.coverageMap.total ? json.coverageMap : undefined,
             });
         }
         catch {
@@ -958,17 +1011,22 @@ Provide:
         if (coverages.length === 0) {
             return undefined;
         }
-        const sum = coverages.reduce((acc, cov) => ({
-            line: acc.line + cov.line,
-            branch: acc.branch + cov.branch,
-            function: acc.function + cov.function,
-            statement: acc.statement + cov.statement,
-        }), { line: 0, branch: 0, function: 0, statement: 0 });
+        // #1015: average each metric over the entries that collected it; a
+        // metric nobody collected stays null.
+        const mean = (values) => {
+            const present = values.filter((v) => typeof v === 'number' && Number.isFinite(v));
+            return present.length > 0
+                ? Math.round((present.reduce((a, v) => a + v, 0) / present.length) * 100) / 100
+                : null;
+        };
+        const line = mean(coverages.map(c => c.line));
+        if (line === null)
+            return undefined;
         return {
-            line: Math.round((sum.line / coverages.length) * 100) / 100,
-            branch: Math.round((sum.branch / coverages.length) * 100) / 100,
-            function: Math.round((sum.function / coverages.length) * 100) / 100,
-            statement: Math.round((sum.statement / coverages.length) * 100) / 100,
+            line,
+            branch: mean(coverages.map(c => c.branch)),
+            function: mean(coverages.map(c => c.function)),
+            statement: mean(coverages.map(c => c.statement)),
         };
     }
     /**
@@ -989,59 +1047,61 @@ Provide:
             // Jest shape: { coverageSummary: { total: { lines: { pct }, branches: { pct }, ... } } }
             const total = json?.coverageSummary?.total ?? json?.coverageMap?.total;
             if (total?.lines?.pct !== undefined) {
+                const line = summaryPct(total.lines);
                 return {
-                    summary: {
-                        line: typeof total.lines?.pct === 'number' ? total.lines.pct : 0,
-                        branch: typeof total.branches?.pct === 'number' ? total.branches.pct : 0,
-                        function: typeof total.functions?.pct === 'number' ? total.functions.pct : 0,
-                        statement: typeof total.statements?.pct === 'number' ? total.statements.pct : 0,
+                    summary: line === null ? undefined : {
+                        line,
+                        branch: summaryPct(total.branches),
+                        function: summaryPct(total.functions),
+                        statement: summaryPct(total.statements),
                     },
                     perFile,
                 };
             }
-            // Vitest v8 shape: coverageMap is keyed by file path
+            // Vitest v8 shape: coverageMap is keyed by file path (istanbul entries)
             const coverageMap = json?.coverageMap;
             if (coverageMap && typeof coverageMap === 'object') {
                 const files = Object.keys(coverageMap).filter(k => k !== 'total');
-                if (files.length > 0) {
-                    let lines = 0, branches = 0, functions = 0, statements = 0;
-                    let count = 0;
-                    for (const filePath of files) {
-                        const entry = coverageMap[filePath];
-                        const s = entry?.s ?? {};
-                        const f = entry?.f ?? {};
-                        const b = entry?.b ?? {};
-                        const stmtTotal = Object.keys(s).length;
-                        const stmtCovered = Object.values(s).filter((v) => v > 0).length;
-                        const fnTotal = Object.keys(f).length;
-                        const fnCovered = Object.values(f).filter((v) => v > 0).length;
-                        const brTotal = Object.keys(b).length;
-                        const brCovered = Object.values(b).filter((v) => Array.isArray(v) ? v.every(c => c > 0) : v > 0).length;
-                        if (stmtTotal > 0) {
-                            const fileLine = Math.round((stmtCovered / stmtTotal) * 10000) / 100;
-                            const fileFn = fnTotal > 0 ? Math.round((fnCovered / fnTotal) * 10000) / 100 : 100;
-                            const fileBr = brTotal > 0 ? Math.round((brCovered / brTotal) * 10000) / 100 : 100;
-                            const fileStmt = fileLine;
-                            perFile.push({ path: filePath, line: fileLine, branch: fileBr, function: fileFn, statement: fileStmt });
-                            statements += fileStmt;
-                            lines += fileLine;
-                            functions += fileFn;
-                            branches += fileBr;
-                            count++;
-                        }
-                    }
-                    if (count > 0) {
-                        return {
-                            summary: {
-                                line: Math.round((lines / count) * 100) / 100,
-                                branch: Math.round((branches / count) * 100) / 100,
-                                function: Math.round((functions / count) * 100) / 100,
-                                statement: Math.round((statements / count) * 100) / 100,
-                            },
-                            perFile,
-                        };
+                const totals = { line: [0, 0], branch: [0, 0], function: [0, 0], statement: [0, 0] };
+                for (const filePath of files) {
+                    const entry = coverageMap[filePath];
+                    const s = entry?.s ?? {};
+                    const f = entry?.f ?? {};
+                    const b = entry?.b ?? {};
+                    // #1012: line coverage per SOURCE LINE (istanbul's own rule), not per statement.
+                    const lineHits = istanbulLineHits({ statementMap: entry?.statementMap ?? {}, s });
+                    const lines = [[...lineHits.values()].filter(v => v > 0).length, lineHits.size];
+                    const statements = [Object.values(s).filter(v => v > 0).length, Object.keys(s).length];
+                    const fns = [Object.values(f).filter(v => v > 0).length, Object.keys(f).length];
+                    const branchCounts = Object.values(b).flatMap(v => (Array.isArray(v) ? v : [v]));
+                    const branches = [branchCounts.filter(c => c > 0).length, branchCounts.length];
+                    if (lines[1] === 0)
+                        continue;
+                    // #1015: istanbul's 0/0 (no branches / no functions) is "not
+                    // collected" — null — not 100%.
+                    perFile.push({
+                        path: filePath,
+                        line: ratio(lines),
+                        branch: ratio(branches),
+                        function: ratio(fns),
+                        statement: ratio(statements),
+                    });
+                    for (const [key, [covered, count]] of [['line', lines], ['branch', branches], ['function', fns], ['statement', statements]]) {
+                        totals[key][0] += covered;
+                        totals[key][1] += count;
                     }
                 }
+                if (perFile.length > 0) {
+                    return {
+                        summary: {
+                            line: ratio(totals.line),
+                            branch: ratio(totals.branch),
+                            function: ratio(totals.function),
+                            statement: ratio(totals.statement),
+                        },
+                        perFile,
+                    };
+                }
             }
         }
         catch {
@@ -1058,8 +1118,8 @@ Provide:
         try {
             // Check common coverage output paths
             const candidates = [
-                join(coverageDirectory, 'coverage-summary.json'),
                 join(coverageDirectory, 'coverage-final.json'),
+                join(coverageDirectory, 'coverage-summary.json'),
             ];
             for (const filePath of candidates) {
                 if (!existsSync(filePath))
@@ -1073,26 +1133,33 @@ Provide:
                         if (key === 'total')
                             continue;
                         // Normalize path: strip cwd prefix, reject traversal sequences
-                        const normalizedPath = key.replace(process.cwd() + '/', '').replace(process.cwd() + '\\', '');
-                        if (normalizedPath.includes('..'))
+                        // Reject traversal; keep the key absolute (#1027 N7: one key form).
+                        const relative = key.replace(process.cwd() + '/', '').replace(process.cwd() + '\\', '');
+                        if (relative.includes('..'))
                             continue;
+                        const normalizedPath = fileCoverageKey(key);
                         const entry = value;
-                        if (entry?.lines?.pct !== undefined) {
+                        const line = summaryPct(entry?.lines);
+                        if (line !== null) {
+                            // #1015: a metric with total 0 is not collected (null), not its 100 pct.
                             perFile.push({
                                 path: normalizedPath,
-                                line: entry.lines.pct,
-                                branch: entry.branches?.pct ?? 0,
-                                function: entry.functions?.pct ?? 0,
-                                statement: entry.statements?.pct ?? 0,
+                                line,
+                                branch: summaryPct(entry.branches),
+                                function: summaryPct(entry.functions),
+                                statement: summaryPct(entry.statements),
                             });
                         }
                     }
+                    const line = summaryPct(json.total.lines);
+                    if (line === null)
+                        continue;
                     return {
                         summary: {
-                            line: json.total.lines.pct,
-                            branch: json.total.branches?.pct ?? 0,
-                            function: json.total.functions?.pct ?? 0,
-                            statement: json.total.statements?.pct ?? 0,
+                            line,
+                            branch: summaryPct(json.total.branches),
+                            function: summaryPct(json.total.functions),
+                            statement: summaryPct(json.total.statements),
                         },
                         perFile,
                     };
@@ -1101,7 +1168,7 @@ Provide:
                 if (typeof json === 'object' && !json.total) {
                     const result = this.extractCoverageFromJson({ coverageMap: json });
                     if (result.summary) {
-                        return { summary: result.summary, perFile: result.perFile };
+                        return { summary: result.summary, perFile: result.perFile, rawMap: json };
                     }
                 }
             }
@@ -1111,50 +1178,69 @@ Provide:
         }
         return undefined;
     }
-    async storeResults(runId, result) {
-        await this.memory.set(`test-run:${runId}`, result, {
+    async storeResults(runId, result, testFiles) {
+        // #1028 N1: the record names the test files it ran, so per-test duration
+        // is compared only between runs of the same test set.
+        const files = testFiles && testFiles.length > 0 ? [...new Set(testFiles)].sort() : undefined;
+        await this.memory.set(`test-run:${runId}`, files ? { ...result, testFiles: files } : result, {
             namespace: 'test-execution',
             persist: true,
         });
+        // A runner ERROR has no trustworthy result: it persists no evidence.
+        if (result.status === 'error')
+            return;
+        const runStatus = result.failed > 0 || result.status !== 'passed' ? 'failed' : 'passed';
+        const coverage = result.coverage && Number.isFinite(result.coverage.line) ? result.coverage : undefined;
+        try {
+            // #1027 NB1: this run's testsPassing and (when measured) its coverage,
+            // written together under this runId — the same writer as
+            // `aqe test execute`. Coverage from a run whose tests FAILED (N4) is
+            // then never read next to a stale testsPassing from an earlier run.
+            await writeTestRunEvidence(this.memory, {
+                runId, passed: result.passed, failed: result.failed, skipped: result.skipped,
+            }, { source: 'test-execution', ...(coverage ? { coverage: coverage.line } : {}) });
+        }
+        catch {
+            // Non-critical — don't break test storage if evidence storage fails
+        }
         // Store coverage data so quality-assess and quality-gate can read it.
         // Note: coverage:previous rotation is owned by coverage-analyzer (the
         // canonical coverage service) to avoid double-rotation race conditions.
-        if (result.coverage) {
-            try {
-                // Write project-level summary using the same CoverageSummary shape
-                // as coverage-analyzer to avoid type mismatches
-                await this.memory.set('coverage:latest', {
-                    line: result.coverage.line ?? 0,
-                    branch: result.coverage.branch ?? 0,
-                    function: result.coverage.function ?? 0,
-                    statement: result.coverage.statement ?? 0,
-                    files: result.fileCoverages?.length ?? 0,
+        if (!coverage)
+            return;
+        try {
+            // Same CoverageSummary shape as coverage-analyzer, stamped with its
+            // provenance (#1008/#1015) so readers can trust it. An uncollected
+            // metric stays null — never 0, never istanbul's 0/0 = 100%.
+            await this.memory.set('coverage:latest', {
+                line: coverage.line,
+                branch: coverage.branch ?? null,
+                function: coverage.function ?? null,
+                statement: coverage.statement ?? null,
+                files: result.fileCoverages?.length ?? 0,
+                measured: true,
+                runStatus,
+                runId,
+            }, { persist: true });
+            // Store per-file coverage via memory.set() (not storeVector) so that
+            // quality-analyzer's getStoredCoverage() can read it with memory.get()
+            for (const fc of result.fileCoverages ?? []) {
+                if (!Number.isFinite(fc.line))
+                    continue;
+                // #1027 N7: one key form — the absolute path.
+                await this.memory.set(`coverage:file:${fileCoverageKey(fc.path)}`, {
+                    line: fc.line,
+                    branch: fc.branch ?? null,
+                    function: fc.function ?? null,
+                    statement: fc.statement ?? null,
+                    measured: true,
+                    runStatus,
                 }, { persist: true });
-                if (Number.isFinite(result.coverage.line)) {
-                    await writeQualityEvidence(this.memory, {
-                        coverage: result.coverage.line,
-                    }, {
-                        measuredAt: new Date().toISOString(),
-                        source: 'test-execution coverage',
-                    });
-                }
-                // Store per-file coverage via memory.set() (not storeVector) so that
-                // quality-analyzer's getStoredCoverage() can read it with memory.get()
-                if (result.fileCoverages) {
-                    for (const fc of result.fileCoverages) {
-                        await this.memory.set(`coverage:file:${fc.path}`, {
-                            line: fc.line,
-                            branch: fc.branch,
-                            function: fc.function,
-                            statement: fc.statement,
-                        }, { persist: true });
-                    }
-                }
-            }
-            catch {
-                // Non-critical — don't break test storage if coverage store fails
             }
         }
+        catch {
+            // Non-critical — don't break test storage if coverage store fails
+        }
     }
 }
 // ============================================================================
@@ -1166,4 +1252,48 @@ Provide:
 export function createTestExecutorService(dependencies, config) {
     return new TestExecutorService(dependencies, config);
 }
+/** covered/total as a 2-decimal percentage, or null when there is nothing to cover. */
+function ratio([covered, total]) {
+    return total > 0 ? Math.round((covered / total) * 10000) / 100 : null;
+}
+/**
+ * A coverage-summary metric's percentage. istanbul writes `pct: 100` for a
+ * metric with `total: 0`; that is "not collected" — null (#1015).
+ */
+function summaryPct(metric) {
+    if (!metric || typeof metric.pct !== 'number' || !Number.isFinite(metric.pct))
+        return null;
+    if (typeof metric.total === 'number' && metric.total === 0)
+        return null;
+    return metric.pct;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/** A test covers a counter if any invocation hit it. Reject incompatible maps. */
+function mergeHitCounts(left, right) {
+    if (!isRecord(left) || !isRecord(right))
+        return undefined;
+    const keys = Object.keys(left);
+    if (!isDeepStrictEqual(keys.sort(), Object.keys(right).sort()))
+        return undefined;
+    const merged = {};
+    for (const key of keys) {
+        const a = left[key];
+        const b = right[key];
+        if (typeof a === 'number' && Number.isFinite(a) && a >= 0
+            && typeof b === 'number' && Number.isFinite(b) && b >= 0) {
+            merged[key] = Math.max(a, b);
+        }
+        else if (Array.isArray(a) && Array.isArray(b) && a.length === b.length
+            && a.every(v => typeof v === 'number' && Number.isFinite(v) && v >= 0)
+            && b.every(v => typeof v === 'number' && Number.isFinite(v) && v >= 0)) {
+            merged[key] = a.map((v, i) => Math.max(v, b[i]));
+        }
+        else {
+            return undefined;
+        }
+    }
+    return merged;
+}
 //# sourceMappingURL=test-executor.js.map

package/dist/domains/test-generation/coordinator.js

@@ -31,6 +31,7 @@ import { DecisionTransformerAlgorithm, } from '../../integrations/rl-suite/algor
 import { isSONAThreeLoopEnabled } from '../../integrations/ruvector/feature-flags.js';
 // Coherence Gate Integration (ADR-052)
 import { createTestGenerationCoherenceGate, } from './services/coherence-gate-service.js';
+import { isMeasuredGapPayload } from '../../shared/events/domain-events.js';
 const DEFAULT_CONFIG = {
     maxConcurrentWorkflows: 5,
     defaultTimeout: 60000, // 60 seconds
@@ -871,6 +872,9 @@ export class TestGenerationCoordinator extends BaseDomainCoordinator {
         return features.slice(0, 384);
     }
     async handleCoverageGapDetected(event) {
+        // #1014: only a gap found in MEASURED coverage is acted on / learned from.
+        if (!isMeasuredGapPayload(event.payload))
+            return;
         // Auto-generate tests for detected coverage gaps
         const payload = event.payload;
         const result = await this.testGenerator.generateForCoverageGap(payload.file, payload.uncoveredLines, 'jest' // Default framework

package/dist/domains/test-generation/plugin.js

@@ -10,6 +10,7 @@ import { RoutingFeedbackCollector } from '../../routing/routing-feedback.js';
 import { createTestGeneratorServiceWithDependencies, } from './services/test-generator.js';
 import { toError } from '../../shared/error-utils.js';
 import { PatternMatcherService, } from './services/pattern-matcher.js';
+import { isMeasuredGapPayload } from '../../shared/events/domain-events.js';
 /**
  * Test Generation Domain Plugin
  * Provides AI-powered test generation capabilities
@@ -277,6 +278,9 @@ export class TestGenerationPlugin extends BaseDomainPlugin {
     // Event Handlers
     // ============================================================================
     async handleCoverageGap(event) {
+        // #1014: only a gap found in MEASURED coverage is acted on / learned from.
+        if (!isMeasuredGapPayload(event.payload))
+            return;
         // Coverage gap detected - could auto-generate tests
         const payload = event.payload;
         // Only auto-generate for high-risk gaps

package/dist/feedback/coverage-learner.js

@@ -9,6 +9,7 @@ import { DEFAULT_FEEDBACK_CONFIG } from './types.js';
 import { getUnifiedMemory } from '../kernel/unified-memory.js';
 import { toErrorMessage } from '../shared/error-utils.js';
 import { safeJsonParse } from '../shared/safe-json.js';
+import { MEASURED_COVERAGE_SESSION_SQL } from './coverage-session-provenance.js';
 // ============================================================================
 // Coverage Session Store
 // ============================================================================
@@ -101,8 +102,10 @@ export class CoverageLearner {
         if (!this.db)
             return;
         const database = this.db.getDatabase();
+        // #1014: legacy MCP rows without provenance (estimates, 0.0 for
+        // unmeasured runs) are not loaded as sessions or learned as strategies.
         const rows = database.prepare(`
-      SELECT * FROM coverage_sessions ORDER BY created_at DESC LIMIT ?
+      SELECT * FROM coverage_sessions WHERE ${MEASURED_COVERAGE_SESSION_SQL} ORDER BY created_at DESC LIMIT ?
     `).all(this.config.maxOutcomesInMemory);
         for (const row of rows.reverse()) {
             const session = {

package/dist/feedback/coverage-session-provenance.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Agentic QE v3 - Provenance of coverage_sessions rows (#1014)
+ *
+ * Up to 3.15.5 the MCP handler factory (agent `qe-coverage-analysis`) wrote a
+ * coverage_sessions row for EVERY coverage_analyze_sublinear call: a static
+ * estimate's figure, or 0.0 for an UNMEASURED target. Those rows have no
+ * provenance and never expire. Rows written from now on carry
+ * `context_json.measured = true`.
+ *
+ * Readers ignore legacy rows of that agent instead of deleting them (no data
+ * is destroyed; the coverage-learner's own retention ages them out). Rows of
+ * other writers (e.g. the post-command hook, which records a real istanbul
+ * coverage-summary.json) are unaffected.
+ */
+/** The agent id of the MCP handler factory's coverage sessions. */
+export declare const MCP_COVERAGE_AGENT_ID = "qe-coverage-analysis";
+/**
+ * SQL predicate (no parameters) selecting coverage_sessions rows that are
+ * evidence. `CASE` keeps `json_extract` from running on malformed JSON.
+ */
+export declare const MEASURED_COVERAGE_SESSION_SQL: string;
+/** JS form of {@link MEASURED_COVERAGE_SESSION_SQL} for rows already loaded. */
+export declare function isMeasuredCoverageSession(row: {
+    agent_id?: string;
+    agentId?: string;
+    context?: unknown;
+    context_json?: string | null;
+}): boolean;
+//# sourceMappingURL=coverage-session-provenance.d.ts.map

package/dist/feedback/coverage-session-provenance.js

@@ -0,0 +1,39 @@
+/**
+ * Agentic QE v3 - Provenance of coverage_sessions rows (#1014)
+ *
+ * Up to 3.15.5 the MCP handler factory (agent `qe-coverage-analysis`) wrote a
+ * coverage_sessions row for EVERY coverage_analyze_sublinear call: a static
+ * estimate's figure, or 0.0 for an UNMEASURED target. Those rows have no
+ * provenance and never expire. Rows written from now on carry
+ * `context_json.measured = true`.
+ *
+ * Readers ignore legacy rows of that agent instead of deleting them (no data
+ * is destroyed; the coverage-learner's own retention ages them out). Rows of
+ * other writers (e.g. the post-command hook, which records a real istanbul
+ * coverage-summary.json) are unaffected.
+ */
+/** The agent id of the MCP handler factory's coverage sessions. */
+export const MCP_COVERAGE_AGENT_ID = 'qe-coverage-analysis';
+/**
+ * SQL predicate (no parameters) selecting coverage_sessions rows that are
+ * evidence. `CASE` keeps `json_extract` from running on malformed JSON.
+ */
+export const MEASURED_COVERAGE_SESSION_SQL = `(agent_id != '${MCP_COVERAGE_AGENT_ID}' OR ` +
+    `(CASE WHEN json_valid(context_json) THEN json_extract(context_json, '$.measured') END) = 1)`;
+/** JS form of {@link MEASURED_COVERAGE_SESSION_SQL} for rows already loaded. */
+export function isMeasuredCoverageSession(row) {
+    const agent = row.agent_id ?? row.agentId;
+    if (agent !== MCP_COVERAGE_AGENT_ID)
+        return true;
+    let context = row.context;
+    if (context === undefined && typeof row.context_json === 'string') {
+        try {
+            context = JSON.parse(row.context_json);
+        }
+        catch {
+            return false;
+        }
+    }
+    return !!context && typeof context === 'object' && context.measured === true;
+}
+//# sourceMappingURL=coverage-session-provenance.js.map

package/dist/init/orchestrator.js

@@ -161,6 +161,8 @@ export class ModularInitOrchestrator {
                 workersStarted: workersResult?.data?.workersConfigured ?? 0,
                 codexGuidance: assetsResult?.data?.codexGuidance,
                 codexComponents: assetsResult?.data?.codexComponents,
+                retiredAssetsRemoved: assetsResult?.data?.retiredAssetsRemoved,
+                retiredAssetsKept: assetsResult?.data?.retiredAssetsKept,
             },
             totalDurationMs: Date.now() - startTime,
             timestamp: new Date(),