agentic-qe 3.15.4 → 3.15.6

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

@@ -8,8 +8,21 @@ 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
+ * producer marked `instrumented: true` is measured. Anything without
+ * provenance is analyzed and returned, but never persisted as evidence.
+ */
+export function isMeasuredCoverage(request) {
+    if (typeof request.measured === 'boolean')
+        return request.measured;
+    return request.coverageData.instrumented === true;
+}
 const DEFAULT_CONFIG = {
     defaultThreshold: 80,
     enableLLMAnalysis: true, // On by default - opt-out
@@ -66,22 +79,36 @@ export class CoverageAnalyzerService {
             // Check if coverage meets threshold
             const overallCoverage = this.calculateOverallCoverage(summary);
             const meetsThreshold = overallCoverage >= threshold;
+            // #1008: only instrumented coverage is evidence. A static estimate is
+            // analyzed and returned to the caller, but never compared against or
+            // 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 = await this.calculateDelta(summary);
+            const delta = measured ? await this.calculateDelta(stored) : undefined;
             // Generate recommendations based on analysis
             const recommendations = this.generateRecommendations(coverageData, summary, threshold);
-            // Store current coverage for future delta calculations
-            await this.storeCoverageSnapshot(summary);
-            // Store coverage vectors for similarity search + KV for quality-analyzer
-            if (request.includeFileDetails) {
-                await this.indexFileCoverageVectors(coverageData.files);
-                await this.storeFileCoverageKV(coverageData.files);
+            if (measured) {
+                // Store current coverage for future delta calculations
+                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, request.projectRoot);
+                    await this.storeFileCoverageKV(coverageData.files, request.projectRoot, request.runStatus);
+                }
             }
             return ok({
                 summary,
                 meetsThreshold,
                 delta,
                 recommendations,
+                measured,
+                collected,
+                ...(request.runStatus ? { runStatus: request.runStatus } : {}),
             });
         }
         catch (error) {
@@ -402,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) {
@@ -433,22 +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
-            await this.memory.set('coverage:latest', summary, { persist: true });
-            await writeQualityEvidence(this.memory, { coverage: summary.line }, {
-                measuredAt: new Date().toISOString(),
-                source: 'coverage-analysis',
-            });
+            // Store latest snapshot, stamped with its provenance (#1008). Only
+            // measured coverage reaches this method.
+            // #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',
             });
@@ -462,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 {
@@ -485,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: {

package/dist/domains/quality-assessment/coordinator-claim-verifier.js

@@ -104,7 +104,8 @@ export function convertToQEReport(report, type) {
             },
         });
     }
-    if (report.score.coverage < 80) {
+    // #996: -1 means coverage was not measured; it is not a "-1%" coverage claim.
+    if (report.score.coverage >= 0 && report.score.coverage < 80) {
         claims.push({
             id: `coverage-${Date.now()}`,
             type: 'coverage-claim',

package/dist/domains/quality-assessment/coordinator-rl-integration.d.ts

@@ -11,6 +11,20 @@ import { PersistentSONAEngine } from '../../integrations/ruvector/sona-persisten
 import { QEFlashAttention } from '../../integrations/ruvector/wrappers';
 import type { GateEvaluationRequest, GateResult, QualityAnalysisRequest, QualityReport, QualityMetrics } from './interfaces';
 import type { DreamCycleCompletedPayload } from '../../shared/events/domain-events';
+import type { QualityScore } from '../../shared/types';
+/**
+ * Score features with unmeasured (-1) fields masked to 0, followed by one
+ * presence flag per field (1 = measured, 0 = not), so a learner can tell
+ * "unmeasured" apart from a measured 0.
+ */
+export declare function maskedScoreFeatures(score: QualityScore, scale?: number): number[];
+/**
+ * True when an analysis report has no verdict to learn from: a requested
+ * metric was not measured, or nothing was measured at all.
+ */
+export declare function isInsufficientQualityReport(report: QualityReport): boolean;
+/** True when a gate request carries any unmeasured (negative or non-finite) metric. */
+export declare function hasUnmeasuredGateMetrics(metrics: QualityMetrics): boolean;
 /**
  * RL-trained thresholds result
  */

package/dist/domains/quality-assessment/coordinator-rl-integration.js

@@ -9,6 +9,39 @@ import { toErrorMessage } from '../../shared/error-utils.js';
 import { ActorCriticAlgorithm } from '../../integrations/rl-suite/algorithms/actor-critic.js';
 import { createPersistentSONAEngine } from '../../integrations/ruvector/sona-persistence.js';
 import { createQEFlashAttention, } from '../../integrations/ruvector/wrappers.js';
+import { isMeasuredMetricValue } from './evidence-sufficiency.js';
+// ============================================================================
+// #1002: unmeasured values never reach a learner as numbers
+// ============================================================================
+/** Score fields in the fixed order every quality feature vector uses. */
+const SCORE_FIELDS = ['overall', 'coverage', 'complexity', 'maintainability', 'security'];
+/**
+ * Score features with unmeasured (-1) fields masked to 0, followed by one
+ * presence flag per field (1 = measured, 0 = not), so a learner can tell
+ * "unmeasured" apart from a measured 0.
+ */
+export function maskedScoreFeatures(score, scale = 1) {
+    const values = SCORE_FIELDS.map((field) => score[field]);
+    return [
+        ...values.map((value) => (isMeasuredMetricValue(value) ? value / scale : 0)),
+        ...values.map((value) => (isMeasuredMetricValue(value) ? 1 : 0)),
+    ];
+}
+/** Score fields carrying the unmeasured sentinel. */
+function unmeasuredScoreFields(score) {
+    return SCORE_FIELDS.filter((field) => !isMeasuredMetricValue(score[field]));
+}
+/**
+ * True when an analysis report has no verdict to learn from: a requested
+ * metric was not measured, or nothing was measured at all.
+ */
+export function isInsufficientQualityReport(report) {
+    return (report.unmeasured?.length ?? 0) > 0 || !isMeasuredMetricValue(report.score.overall);
+}
+/** True when a gate request carries any unmeasured (negative or non-finite) metric. */
+export function hasUnmeasuredGateMetrics(metrics) {
+    return Object.values(metrics).some((value) => !isMeasuredMetricValue(value));
+}
 /**
  * Initialize Actor-Critic RL for quality gate threshold tuning
  */
@@ -74,6 +107,9 @@ export async function initializeFlashAttention() {
  * Use Actor-Critic RL to predict optimal quality gate thresholds
  */
 export async function tuneThresholdsWithRL(actorCritic, metrics) {
+    // #1002: never predict from unmeasured inputs; keep the canonical thresholds.
+    if (hasUnmeasuredGateMetrics(metrics))
+        return null;
     try {
         const state = {
             id: `quality-state-${Date.now()}`,
@@ -129,6 +165,9 @@ export function applyActionToThresholds(thresholds, action) {
  * Train Actor-Critic with quality gate evaluation results
  */
 export async function trainActorCritic(actorCritic, request, result) {
+    // #1002: an experience built from unmeasured inputs teaches the critic fake data.
+    if (hasUnmeasuredGateMetrics(request.metrics))
+        return;
     try {
         const state = {
             id: `quality-state-${Date.now()}`,
@@ -177,6 +216,9 @@ export async function trainActorCritic(actorCritic, request, result) {
  * Store quality gate pattern in SONA for learning
  */
 export async function storeQualityPattern(qesona, request, result, domainName) {
+    // #1002: no gate pattern from unmeasured inputs.
+    if (hasUnmeasuredGateMetrics(request.metrics))
+        return;
     try {
         const state = {
             id: `quality-state-${Date.now()}`,
@@ -212,14 +254,15 @@ export async function storeQualityPattern(qesona, request, result, domainName) {
  * Store quality analysis pattern in SONA
  */
 export async function storeQualityAnalysisPattern(qesona, request, report, domainName) {
+    // #1002: an insufficient-evidence run has no verdict — neither a success
+    // nor a failure pattern may be recorded from it.
+    if (isInsufficientQualityReport(report))
+        return;
     try {
         const state = {
             id: `quality-analysis-${Date.now()}`,
             features: [
-                report.score.overall,
-                report.score.coverage,
-                report.score.complexity,
-                report.score.maintainability,
+                ...maskedScoreFeatures(report.score),
                 report.metrics.length,
                 request.sourceFiles.length,
             ],
@@ -235,6 +278,8 @@ export async function storeQualityAnalysisPattern(qesona, request, report, domai
         }, 'quality-assessment', domainName, {
             sourceFileCount: request.sourceFiles.length,
             recommendationCount: report.recommendations.length,
+            // Score fields outside the requested scope, masked to 0 in features.
+            unmeasuredScoreFields: unmeasuredScoreFields(report.score),
         });
     }
     catch (error) {
@@ -248,12 +293,8 @@ export async function enhanceWithSimilarityPatterns(report, flashAttention, qeso
     try {
         const state = {
             id: `similarity-search-${Date.now()}`,
-            features: [
-                report.score.overall,
-                report.score.coverage,
-                report.score.complexity,
-                report.score.maintainability,
-            ],
+            // #1002: -1 (unmeasured) is masked, never matched as a value.
+            features: maskedScoreFeatures(report.score),
         };
         const adaptation = await qesona.adaptPattern(state, 'quality-assessment', domainName);
         if (!adaptation.success || !adaptation.pattern) {
@@ -286,13 +327,10 @@ export async function enhanceWithSimilarityPatterns(report, flashAttention, qeso
  * Create embedding from quality metrics for similarity search
  */
 export function createMetricsEmbedding(report) {
+    // #1002: unmeasured score fields are masked (was security -1 / 100 = -0.01).
     const features = [
-        report.score.overall / 100,
-        report.score.coverage / 100,
-        report.score.complexity / 100,
-        report.score.maintainability / 100,
-        report.score.security / 100,
-        ...report.metrics.map(m => m.value / 100),
+        ...maskedScoreFeatures(report.score, 100),
+        ...report.metrics.map(m => (isMeasuredMetricValue(m.value) ? m.value / 100 : 0)),
     ];
     while (features.length < 384) {
         features.push(0);

package/dist/domains/quality-assessment/coordinator.js

@@ -33,6 +33,7 @@ import { DEFAULT_RATCHET_CONFIG, } from './coherence/types.js';
 import { getWitnessChain } from '../../audit/witness-chain.js';
 // Three-loop feature flag for instantAdapt protocol
 import { isSONAThreeLoopEnabled } from '../../integrations/ruvector/feature-flags.js';
+import { measuredCoverageSummary } from './coverage-report-event.js';
 // CQ-002: Base domain coordinator
 import { BaseDomainCoordinator, } from '../base-domain-coordinator.js';
 const DEFAULT_CONFIG = {
@@ -243,8 +244,10 @@ export class QualityAssessmentCoordinator extends BaseDomainCoordinator {
             }
             // Success path
             this.completeWorkflow(workflowId);
-            // Three-loop protocol: instantAdapt must precede recordOutcome
-            if (isSONAThreeLoopEnabled() && this.qesona?.isThreeLoopEnabled()) {
+            // Three-loop protocol: instantAdapt must precede recordOutcome.
+            // #1002: unmeasured (-1) gate inputs are never fed to the learner.
+            if (isSONAThreeLoopEnabled() && this.qesona?.isThreeLoopEnabled()
+                && !RLIntegration.hasUnmeasuredGateMetrics(effectiveRequest.metrics)) {
                 const m = effectiveRequest.metrics;
                 this.qesona.instantAdapt([
                     m.coverage / 100,
@@ -383,8 +386,10 @@ export class QualityAssessmentCoordinator extends BaseDomainCoordinator {
                     result.value = enhanced;
                 }
             }
+            // #1002: an insufficient-evidence run has no verdict to learn from.
+            const learnable = !RLIntegration.isInsufficientQualityReport(result.value);
             // Three-loop protocol: instantAdapt must precede recordOutcome
-            if (isSONAThreeLoopEnabled() && this.qesona?.isThreeLoopEnabled()) {
+            if (learnable && isSONAThreeLoopEnabled() && this.qesona?.isThreeLoopEnabled()) {
                 const score = result.value.score;
                 this.qesona.instantAdapt([
                     score.overall / 100,
@@ -404,12 +409,12 @@ export class QualityAssessmentCoordinator extends BaseDomainCoordinator {
                 }
                 catch { /* must not break main flow */ }
             }
-            // Store quality pattern in SONA
+            // Store quality pattern in SONA (skipped inside for insufficient evidence)
             if (this.config.enableSONAPatternLearning && this.qesona) {
                 await this.storeQualityAnalysisPattern(request, result.value);
             }
-            // Auto-trigger gate evaluation if enabled
-            if (this.config.enableAutoGating && result.value.score.overall < 70) {
+            // Auto-trigger gate evaluation if enabled (-1 = not measured, not a low score)
+            if (this.config.enableAutoGating && result.value.score.overall >= 0 && result.value.score.overall < 70) {
                 // Store for downstream consumption
                 await this.memory.set(`quality-assessment:auto-gate:${workflowId}`, { score: result.value.score, recommendations: result.value.recommendations }, { namespace: 'quality-assessment', ttl: 3600 });
             }
@@ -819,15 +824,14 @@ export class QualityAssessmentCoordinator extends BaseDomainCoordinator {
     }
     async handleCoverageReportCreated(event) {
         // Store coverage data for quality assessment
-        const payload = event.payload;
+        // #1008: only a report explicitly marked measured is coverage evidence.
+        // Estimates and look-alike events with no coverage figures (e.g. bridged
+        // captured experiences) must never touch `coverage:latest`.
+        const summary = measuredCoverageSummary(event.payload);
+        if (!summary)
+            return;
         // Store under the canonical coverage key so quality-analyzer can read it
-        await this.memory.set('coverage:latest', {
-            line: payload.line,
-            branch: payload.branch,
-            function: 0,
-            statement: 0,
-            files: 0,
-        }, { persist: true });
+        await this.memory.set('coverage:latest', summary, { persist: true });
     }
     async handleSecurityAuditCompleted(event) {
         // Store security findings for deployment decisions

package/dist/domains/quality-assessment/coverage-report-event.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Validation of measured coverage records (#1008, #1014, #1015).
+ *
+ * Used for `coverage-analysis.CoverageReportCreated` payloads before the
+ * quality-assessment domain stores them as `coverage:latest`, and by every
+ * reader of the stored records (`coverage:latest`, `coverage:previous`,
+ * `coverage:file:*`).
+ *
+ * Only a record its producer explicitly marked `measured: true`, carrying
+ * finite coverage figures, is coverage evidence. Anything else — a static
+ * estimate, a legacy record without provenance (written by <= 3.15.4, or the
+ * `{"files":0}` bridge echo removed in #1013), or a look-alike with no coverage
+ * figures at all — is ignored rather than read as a measurement or as zeros.
+ */
+/** The `coverage:latest` record written from a measured coverage report. */
+export interface MeasuredCoverageSummary {
+    line: number;
+    /** `null` = the report collected no branch data (not 0%, #1015). */
+    branch: number | null;
+    /** `null` = the report collected no function data (not 0%, #1015). */
+    function: number | null;
+    /** `null` = the report collected no statement data (lcov, Cobertura; #1027). */
+    statement: number | null;
+    files: number;
+    /** Provenance stamp: this record came from instrumented coverage. */
+    measured: true;
+    /** Outcome of the test run behind the record, when known (#1027 N4). */
+    runStatus?: 'passed' | 'failed';
+}
+/** A per-file `coverage:file:<path>` record written from measured coverage. */
+export interface MeasuredFileCoverage {
+    line: number;
+    branch: number | null;
+    function: number | null;
+    statement: number | null;
+    measured: true;
+}
+/**
+ * Return the measured summary to store, or `null` when the payload is not
+ * measured coverage evidence.
+ */
+export declare function measuredCoverageSummary(payload: unknown): MeasuredCoverageSummary | null;
+/**
+ * Return a stored per-file coverage record when it is measured evidence, or
+ * `null` (#1014): legacy unstamped `coverage:file:*` records — static
+ * estimates written by <= 3.15.4 never expire — must not be read as coverage.
+ */
+export declare function measuredFileCoverage(record: unknown): MeasuredFileCoverage | null;
+//# sourceMappingURL=coverage-report-event.d.ts.map

package/dist/domains/quality-assessment/coverage-report-event.js

@@ -0,0 +1,58 @@
+/**
+ * Validation of measured coverage records (#1008, #1014, #1015).
+ *
+ * Used for `coverage-analysis.CoverageReportCreated` payloads before the
+ * quality-assessment domain stores them as `coverage:latest`, and by every
+ * reader of the stored records (`coverage:latest`, `coverage:previous`,
+ * `coverage:file:*`).
+ *
+ * Only a record its producer explicitly marked `measured: true`, carrying
+ * finite coverage figures, is coverage evidence. Anything else — a static
+ * estimate, a legacy record without provenance (written by <= 3.15.4, or the
+ * `{"files":0}` bridge echo removed in #1013), or a look-alike with no coverage
+ * figures at all — is ignored rather than read as a measurement or as zeros.
+ */
+const isPercent = (v) => typeof v === 'number' && Number.isFinite(v) && v >= 0 && v <= 100;
+/** A percentage, or `null` for a metric that was not collected. */
+const isPercentOrNull = (v) => v === null || isPercent(v);
+/**
+ * Return the measured summary to store, or `null` when the payload is not
+ * measured coverage evidence.
+ */
+export function measuredCoverageSummary(payload) {
+    if (!payload || typeof payload !== 'object')
+        return null;
+    const p = payload;
+    if (p.measured !== true)
+        return null;
+    if (!isPercent(p.line) || !isPercentOrNull(p.statement) || !isPercentOrNull(p.branch) || !isPercentOrNull(p.function)) {
+        return null;
+    }
+    const files = typeof p.files === 'number' && Number.isInteger(p.files) && p.files >= 0 ? p.files : null;
+    if (files === null)
+        return null;
+    return {
+        line: p.line,
+        branch: p.branch,
+        function: p.function,
+        statement: p.statement,
+        files,
+        measured: true,
+        ...(p.runStatus === 'passed' || p.runStatus === 'failed' ? { runStatus: p.runStatus } : {}),
+    };
+}
+/**
+ * Return a stored per-file coverage record when it is measured evidence, or
+ * `null` (#1014): legacy unstamped `coverage:file:*` records — static
+ * estimates written by <= 3.15.4 never expire — must not be read as coverage.
+ */
+export function measuredFileCoverage(record) {
+    if (!record || typeof record !== 'object')
+        return null;
+    const r = record;
+    if (r.measured !== true || !isPercent(r.line))
+        return null;
+    const opt = (v) => (isPercent(v) ? v : null);
+    return { line: r.line, branch: opt(r.branch), function: opt(r.function), statement: opt(r.statement), measured: true };
+}
+//# sourceMappingURL=coverage-report-event.js.map