agentic-qe 3.15.13 → 3.15.15

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

@@ -16,6 +16,7 @@
  * Either one makes the evidence insufficient: no verdict may pass on it.
  */
 import type { FileCoverage } from '../../domains/coverage-analysis/interfaces';
+import type { ExcludedCoverageEntry } from '../../domains/coverage-analysis/collected-metrics.js';
 /** The report is older than these source files. */
 export interface StaleReport {
     reportPath: string;
@@ -35,6 +36,17 @@ export interface CoverageEvidence {
         source: string;
         readable: boolean;
     };
+    /**
+     * #1219: report entries left out of the figures because they are not a
+     * measurement of a project file (outside the root, a Windows path on POSIX,
+     * or one file under two spellings).
+     */
+    excludedEntries?: ExcludedCoverageEntry[];
+    /**
+     * #1219: project files the report lists under two spellings. Which entry is
+     * right is unknown, so they are UNMEASURED and the evidence is insufficient.
+     */
+    conflictingFiles?: string[];
 }
 /**
  * Production source files under a directory `target` that the report has no
@@ -66,10 +78,17 @@ export declare function assessCoverageEvidence(report: {
 }, measuredFiles: FileCoverage[], projectRoot: string, target: string, options?: {
     reportPath?: string;
     checkCompleteness?: boolean;
+    excluded?: ExcludedCoverageEntry[];
 }): CoverageEvidence;
 /**
  * Why the evidence is insufficient, one sentence per problem; empty when it is
  * complete. Shared by MCP and CLI so the wording cannot drift.
  */
 export declare function describeEvidence(evidence: CoverageEvidence | undefined, projectRoot: string): string[];
+/**
+ * #1219: one line naming the report entries left out of the figures as not
+ * project files (empty when none were). A note, not an evidence gap: those
+ * entries never were the project's coverage. Shared by MCP and CLI.
+ */
+export declare function describeExcludedEntries(evidence: CoverageEvidence | undefined): string[];
 //# sourceMappingURL=coverage-evidence.d.ts.map

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

@@ -115,12 +115,16 @@ export function assessCoverageEvidence(report, measuredFiles, projectRoot, targe
     const stale = options.reportPath
         ? findStaleness(options.reportPath, [...sources].filter(file => fs.existsSync(file)))
         : undefined;
+    const excluded = options.excluded ?? [];
+    const conflicting = [...new Set(excluded.flatMap(e => (e.file ? [e.file] : [])))].sort();
     return {
-        status: unmeasured.length > 0 || stale ? 'insufficient-evidence' : 'complete',
+        status: unmeasured.length > 0 || stale || conflicting.length > 0 ? 'insufficient-evidence' : 'complete',
         unmeasuredFiles: unmeasured,
-        targetFiles: sources.size,
+        targetFiles: sources.size + conflicting.filter(file => !sources.has(file)).length,
         ...(stale ? { stale } : {}),
         ...(coverageScope ? { coverageScope } : {}),
+        ...(excluded.length > 0 ? { excludedEntries: excluded } : {}),
+        ...(conflicting.length > 0 ? { conflictingFiles: conflicting } : {}),
     };
 }
 const MAX_LISTED = 5;
@@ -148,6 +152,12 @@ export function describeEvidence(evidence, projectRoot) {
             'the report with coverage for the whole target, or exclude files that are not meant to be measured in the ' +
             `coverage tool's include/exclude config.${scopeNote}`);
     }
+    const conflicting = evidence.conflictingFiles ?? [];
+    if (conflicting.length > 0) {
+        reasons.push(`${conflicting.length} source file${conflicting.length === 1 ? ' is' : 's are'} listed in the coverage ` +
+            'report under two spellings (e.g. `./src/a.ts` and `src/a.ts`), so which entry is right is unknown; ' +
+            `they are UNMEASURED and left out of the figures: ${listFiles(conflicting, projectRoot)}`);
+    }
     if (evidence.stale) {
         const m = evidence.stale.newerFiles.length;
         reasons.push(`the coverage report ${path.relative(projectRoot, evidence.stale.reportPath) || evidence.stale.reportPath} ` +
@@ -156,4 +166,23 @@ export function describeEvidence(evidence, projectRoot) {
     }
     return reasons;
 }
+const EXCLUDED_WHY = {
+    'outside-project': 'outside the project root',
+    'windows-path': 'a Windows path, which cannot name a file here',
+    'duplicate-spelling': 'a second spelling of a file the report already lists',
+};
+/**
+ * #1219: one line naming the report entries left out of the figures as not
+ * project files (empty when none were). A note, not an evidence gap: those
+ * entries never were the project's coverage. Shared by MCP and CLI.
+ */
+export function describeExcludedEntries(evidence) {
+    const outside = (evidence?.excludedEntries ?? []).filter(e => e.reason !== 'duplicate-spelling');
+    if (outside.length === 0)
+        return [];
+    const shown = outside.slice(0, MAX_LISTED).map(e => `${e.path} (${EXCLUDED_WHY[e.reason]})`);
+    const more = outside.length > MAX_LISTED ? `, … ${outside.length - MAX_LISTED} more` : '';
+    return [`${outside.length} coverage report entr${outside.length === 1 ? 'y is' : 'ies are'} not a project file and ` +
+            `${outside.length === 1 ? 'is' : 'are'} left out of the figures: ${shown.join(', ')}${more}.`];
+}
 //# sourceMappingURL=coverage-evidence.js.map

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

@@ -9,7 +9,7 @@ import { toError } from '../../shared/error-utils.js';
 import { requirePayloadPath } from '../../shared/io/payload-path-guard.js';
 import { buildEstimatedCoverage, collectRustCoverage, findCargoRoot, isCoverageExecDisabled, isRustProject, } from './coverage-collection.js';
 import { describeNoData, evaluateCoverageForTarget, isUnmeasured, packageFilterForTarget, resolveExistingCoverage, scopeCoverageToTarget, reconcileRecommendations, thresholdVerdict, } from './coverage-target.js';
-import { describeEvidence } from './coverage-evidence.js';
+import { describeEvidence, describeExcludedEntries } from './coverage-evidence.js';
 import { randomUUID } from 'crypto';
 import * as path from 'path';
 import { describeRunFailure, runJsCoverage, testRunStatus } from './coverage-runner.js';
@@ -289,6 +289,8 @@ export function registerCoverageHandlers(ctx) {
             if (evidenceReasons.length > 0) {
                 warnings.push(`INSUFFICIENT EVIDENCE — the threshold is not met on this report: ${evidenceReasons.join('; ').replace(/\.?$/, '.')}`);
             }
+            // #1219: entries that are not project files are named, not silently dropped.
+            warnings.push(...describeExcludedEntries(evidence));
             // #569: the analyzer generates recommendations from the summary numbers.
             // When branch or function data was never collected, those numbers are 0
             // by construction, and the resulting advice ("Branch coverage is
@@ -325,6 +327,8 @@ export function registerCoverageHandlers(ctx) {
                     evidenceStatus: evidence.status,
                     unmeasuredFiles: evidence.unmeasuredFiles,
                     ...(evidence.stale ? { staleReport: evidence.stale } : {}),
+                    ...(evidence.conflictingFiles ? { conflictingFiles: evidence.conflictingFiles } : {}),
+                    ...(evidence.excludedEntries ? { excludedReportEntries: evidence.excludedEntries } : {}),
                 } : {}),
                 delta: report.delta,
                 recommendations,

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

@@ -26,6 +26,7 @@ import { loadCoverageReport, parseCoberturaXml, parseCoverageJson, parseCoverage
 import { isTestPath } from './coverage-collection.js';
 import { assessCoverageEvidence } from './coverage-evidence.js';
 import { findProjectRoot } from '../../kernel/project-root.js';
+import { classifyProjectCoveragePaths } from '../../domains/coverage-analysis/collected-metrics.js';
 // ============================================================================
 // Project root
 // ============================================================================
@@ -428,7 +429,12 @@ export function scopeCoverageToTarget(data, root, target) {
 export function evaluateCoverageForTarget(report, projectRoot, target, options = {}) {
     if (options.numTotalTests === 0)
         return { status: 'no-data', reason: 'no-tests-ran' };
-    const scoped = scopeCoverageToTarget(report, projectRoot, target);
+    // #1219: an entry that is not a measurement of a project file (outside the
+    // root, a Windows path on POSIX, one file under two spellings) is not part
+    // of the figures — the same rule as the per-file records (#1030).
+    const inTarget = scopeCoverageToTarget(report, projectRoot, target);
+    const { keys, excluded } = classifyProjectCoveragePaths(inTarget.map(f => f.path), projectRoot);
+    const scoped = inTarget.filter(f => keys.has(f.path));
     if (scoped.length === 0)
         return { status: 'no-data', reason: 'target-not-covered' };
     // Coverage OF a test file is not production coverage (#569). A report with
@@ -438,6 +444,7 @@ export function evaluateCoverageForTarget(report, projectRoot, target, options =
         return { status: 'no-data', reason: 'test-only-report' };
     const evidence = assessCoverageEvidence(report, production, projectRoot, target, {
         reportPath: options.reportPath, checkCompleteness: options.checkCompleteness,
+        excluded: excluded.filter(e => !e.file || !isTestPath(e.file, projectRoot)),
     });
     return { status: 'measured', files: production, evidence };
 }

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

@@ -222,8 +222,16 @@ export function registerQualityHandlers(ctx) {
             const insufficient = sufficiency.evidenceStatus !== 'measured';
             const passed = !insufficient && measuredFailures.length === 0 && report.score.overall >= threshold;
             const recommendations = report.recommendations.map(r => `[${r.type}] ${r.title}: ${r.description}`);
+            // A score that leaves out unmeasured metrics is not the overall score:
+            // -1 with the reason, as the gate's overallScore since #1223. The score
+            // over the measured metrics stays available, labelled as a subset.
+            const subsetScore = report.subsetScore ?? report.score.overall;
             return ok({
-                qualityScore: report.score.overall,
+                qualityScore: insufficient ? UNMEASURED : report.score.overall,
+                ...(insufficient ? {
+                    qualityScoreReason: `not computed: ${sufficiency.unmeasured.join(', ')} unmeasured`,
+                    ...(subsetScore >= 0 ? { subsetScore } : {}),
+                } : {}),
                 passed,
                 threshold,
                 metrics: {

package/dist/coordination/result-saver-adapters.js

@@ -37,6 +37,7 @@ function qualityReport(result) {
         : [];
     return {
         ...(typeof score.overall === 'number' ? { qualityScore: score.overall } : {}),
+        ...(typeof data.subsetScore === 'number' ? { subsetScore: data.subsetScore } : {}),
         passed: false,
         gateEvaluated: false,
         metrics: Object.fromEntries(metrics.filter(m => m.name && typeof m.value === 'number').map(m => [m.name, m.value])),

package/dist/coordination/result-saver.js

@@ -501,11 +501,15 @@ ${data.recommendations.map((r, i) => `${i + 1}. ${r}`).join('\n')}
 ## Quality Score
 
 ${typeof data.qualityScore !== 'number' ? 'N/A — measured gate uses individual checks.'
-            : data.qualityScore < 0 ? 'Not measured — no requested metric had measured data (#1011).'
-                : data.evidenceStatus === 'insufficient-evidence'
-                    ? `Subset score over measured metrics: ${data.qualityScore.toFixed(1)} (not a verdict)`
-                        + (data.scoreBasis?.length ? `\nBased on: ${data.scoreBasis.join(', ')}` : '')
-                    : `**${data.qualityScore.toFixed(1)}** / 100`}
+            : data.qualityScore < 0 && typeof data.subsetScore === 'number'
+                ? `Not computed — unmeasured: ${data.unmeasured?.join(', ') || 'unknown'}.\n`
+                    + `Subset score over measured metrics: ${data.subsetScore.toFixed(1)} (not a verdict)`
+                    + (data.scoreBasis?.length ? `\nBased on: ${data.scoreBasis.join(', ')}` : '')
+                : data.qualityScore < 0 ? 'Not measured — no requested metric had measured data (#1011).'
+                    : data.evidenceStatus === 'insufficient-evidence'
+                        ? `Subset score over measured metrics: ${data.qualityScore.toFixed(1)} (not a verdict)`
+                            + (data.scoreBasis?.length ? `\nBased on: ${data.scoreBasis.join(', ')}` : '')
+                        : `**${data.qualityScore.toFixed(1)}** / 100`}
 
 ## Metrics
 

package/dist/domains/chaos-resilience/services/chaos-engineer.d.ts

@@ -89,6 +89,7 @@ export declare class ChaosEngineerService implements IChaosEngineeringService {
     private executeCommandProbe;
     private executeMetricProbe;
     private performFaultInjection;
+    private notInjected;
     private injectLatency;
     private injectError;
     private injectTimeout;

package/dist/domains/chaos-resilience/services/chaos-engineer.js

@@ -609,32 +609,25 @@ Provide:
         }
         return err(new Error(`Unknown fault type: ${fault.type}`));
     }
+    // #1258: these fault types need infrastructure this process does not control
+    // (a network proxy, service mesh, firewall or DNS server). They used to log a
+    // note and return ok(1), so an experiment reported a fault that never ran.
+    // They now fail with the reason, and injectFault() records injected: false.
+    notInjected(fault, requirement) {
+        return err(new Error(`${fault.type} fault not injected into ${fault.target.selector}: requires ${requirement}, ` +
+            'which this process does not control. Nothing was changed on the target.'));
+    }
     async injectLatency(fault) {
-        // Latency injection is typically done at proxy/network level
-        // For simulation, we store the config and check during probe execution
-        const latencyMs = fault.parameters.latencyMs ?? 100;
-        logger.info(`Latency injection configured: ${latencyMs}ms for ${fault.target.selector}`);
-        logger.info(`Note: Actual latency injection requires network proxy (e.g., Toxiproxy, tc)`);
-        return ok(1);
+        return this.notInjected(fault, 'a network proxy (e.g., Toxiproxy, tc)');
     }
     async injectError(fault) {
-        // Error injection typically requires proxy/service mesh
-        const errorCode = fault.parameters.errorCode ?? 500;
-        logger.info(`Error injection configured: ${errorCode} for ${fault.target.selector}`);
-        logger.info(`Note: Actual error injection requires service mesh (e.g., Istio, Linkerd)`);
-        return ok(1);
+        return this.notInjected(fault, 'a service mesh or proxy (e.g., Istio, Linkerd, Toxiproxy)');
     }
     async injectTimeout(fault) {
-        // Timeout injection via proxy configuration
-        logger.info(`Timeout injection configured for ${fault.target.selector}`);
-        logger.info(`Note: Actual timeout injection requires network proxy configuration`);
-        return ok(1);
+        return this.notInjected(fault, 'a network proxy (e.g., Toxiproxy)');
     }
     async injectPacketLoss(fault) {
-        const lossPercent = fault.parameters.packetLossPercent ?? 10;
-        logger.info(`Packet loss configured: ${lossPercent}% for ${fault.target.selector}`);
-        logger.info(`Note: Actual packet loss requires tc/iptables (Linux) or similar`);
-        return ok(1);
+        return this.notInjected(fault, 'tc/iptables (Linux) or a network proxy');
     }
     async injectCpuStress(fault) {
         // Real CPU stress implementation using busy loops
@@ -689,34 +682,18 @@ Provide:
         }
     }
     async injectDiskStress(fault) {
-        // Disk stress would require file system operations
-        logger.info(`Disk stress configured for ${fault.target.selector}`);
-        logger.info(`Note: Actual disk stress requires file system write permissions`);
-        return ok(1);
+        return this.notInjected(fault, 'file system stress tooling (e.g., stress-ng)');
     }
     async injectNetworkPartition(fault) {
-        // Network partition typically requires iptables or similar
-        logger.info(`Network partition configured for ${fault.target.selector}`);
-        logger.info(`Note: Actual network partition requires iptables/firewall rules`);
-        return ok(1);
+        return this.notInjected(fault, 'iptables/firewall rules');
     }
     async injectDnsFailure(fault) {
-        // DNS failure injection via /etc/hosts or DNS server configuration
-        logger.info(`DNS failure configured for ${fault.target.selector}`);
-        logger.info(`Note: Actual DNS failure requires DNS server or /etc/hosts modification`);
-        return ok(1);
+        return this.notInjected(fault, 'a DNS server or /etc/hosts modification');
     }
     async injectProcessKill(fault) {
-        // Process kill via system commands
-        const processPattern = fault.target.selector;
-        logger.info(`Process kill configured for pattern: ${processPattern}`);
-        logger.info(`Note: Actual process kill requires appropriate permissions`);
-        // In dry-run mode or without permissions, just log
-        if (this.config.enableDryRun) {
-            logger.info(`Would kill processes matching: ${processPattern}`);
-            return ok(0);
-        }
-        return ok(1);
+        // No process is signalled here, so a dry run and a real run both report
+        // the fault as not injected rather than counting a target as affected.
+        return this.notInjected(fault, 'process signalling with appropriate permissions (e.g., Chaos Monkey, Litmus)');
     }
     async performFaultRemoval(fault) {
         logger.info(`Removing fault: ${fault.id} (${fault.type})`);
@@ -817,14 +794,15 @@ Provide:
         if (!finalSteadyState) {
             return 'failed';
         }
-        if (execution.result.hypothesisValidated) {
-            return 'completed';
-        }
-        // Check if any faults failed to inject
+        // #1258: a fault that was not injected means the experiment did not run as
+        // designed, so a hypothesis "validated" without it is not a completed run.
         const failedFaults = execution.result.faultResults.filter((f) => !f.injected);
         if (failedFaults.length > 0) {
             return 'failed';
         }
+        if (execution.result.hypothesisValidated) {
+            return 'completed';
+        }
         return 'completed';
     }
     async rollbackExperiment(experiment) {

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

@@ -14,15 +14,31 @@ import type { CoverageSummary, FileCoverage } from './interfaces';
  * (or the cwd when none is known), so one file never has two records.
  */
 export declare function fileCoverageKey(filePath: string, projectRoot?: string): string;
+/** Why a report entry is not a measurement of a project file (#1030, #1219). */
+export type ExcludedCoverageReason = 'outside-project' | 'windows-path' | 'duplicate-spelling';
+/** A report entry left out of per-file records and of the report's summary. */
+export interface ExcludedCoverageEntry {
+    /** The path as the report wrote it. */
+    path: string;
+    reason: ExcludedCoverageReason;
+    /** For `duplicate-spelling`: the project file both spellings name. */
+    file?: string;
+}
 /**
- * #1030: the per-file record key of each path in ONE report, keyed by the
- * path as the report wrote it. A path is left out when its record would not
- * be a measurement of a project file: it resolves outside the project root
- * (lcov `SF:../../outside.ts`), it is a Windows absolute path read on POSIX
- * (it would resolve to a junk key), or the report lists the same file under
+ * #1030, #1219: sort the paths of ONE report into project files (with their
+ * per-file record key, keyed by the path as the report wrote it) and entries
+ * that are not a measurement of a project file: a path that resolves outside
+ * the project root (lcov `SF:../../outside.ts`), a Windows absolute path read
+ * on POSIX (it would resolve to a junk key), or a file the report lists under
  * two spellings (`./src/a.ts` and `src/a.ts`), so which entry is right is
- * unknown.
+ * unknown. A path under the root's realpath (macOS `/private/var` for
+ * `/var`) is inside.
  */
+export declare function classifyProjectCoveragePaths(paths: readonly string[], projectRoot?: string): {
+    keys: Map<string, string>;
+    excluded: ExcludedCoverageEntry[];
+};
+/** #1030: the per-file record key of each project file in ONE report (see `classifyProjectCoveragePaths`). */
 export declare function projectFileCoverageKeys(paths: readonly string[], projectRoot?: string): Map<string, string>;
 /** Read the canonical key first, then a measured legacy relative key if present. */
 export declare function fileCoverageLookupKeys(filePath: string, projectRoot?: string): string[];

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

@@ -6,6 +6,7 @@
  * 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 fs from 'fs';
 import * as path from 'path';
 import { findProjectRoot } from '../../kernel/project-root.js';
 /**
@@ -17,34 +18,58 @@ import { findProjectRoot } from '../../kernel/project-root.js';
 export function fileCoverageKey(filePath, projectRoot) {
     return path.isAbsolute(filePath) ? path.normalize(filePath) : path.resolve(projectRoot ?? findProjectRoot(), filePath);
 }
+function isInside(root, key) {
+    const relative = path.relative(root, key);
+    return relative !== '' && relative !== '..' && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}
+function realRoot(root) {
+    try {
+        return fs.realpathSync(root);
+    }
+    catch {
+        return root;
+    }
+}
 /**
- * #1030: the per-file record key of each path in ONE report, keyed by the
- * path as the report wrote it. A path is left out when its record would not
- * be a measurement of a project file: it resolves outside the project root
- * (lcov `SF:../../outside.ts`), it is a Windows absolute path read on POSIX
- * (it would resolve to a junk key), or the report lists the same file under
+ * #1030, #1219: sort the paths of ONE report into project files (with their
+ * per-file record key, keyed by the path as the report wrote it) and entries
+ * that are not a measurement of a project file: a path that resolves outside
+ * the project root (lcov `SF:../../outside.ts`), a Windows absolute path read
+ * on POSIX (it would resolve to a junk key), or a file the report lists under
  * two spellings (`./src/a.ts` and `src/a.ts`), so which entry is right is
- * unknown.
+ * unknown. A path under the root's realpath (macOS `/private/var` for
+ * `/var`) is inside.
  */
-export function projectFileCoverageKeys(paths, projectRoot) {
+export function classifyProjectCoveragePaths(paths, projectRoot) {
     const root = path.resolve(projectRoot ?? findProjectRoot());
+    const canonicalRoot = realRoot(root);
     const keys = new Map();
+    const excluded = [];
     const spellings = new Map();
     for (const filePath of paths) {
-        if (!path.isAbsolute(filePath) && path.win32.isAbsolute(filePath))
+        if (!path.isAbsolute(filePath) && path.win32.isAbsolute(filePath)) {
+            excluded.push({ path: filePath, reason: 'windows-path' });
             continue;
+        }
         const key = fileCoverageKey(filePath, root);
-        const relative = path.relative(root, key);
-        if (relative === '' || relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative))
+        if (!isInside(root, key) && !isInside(canonicalRoot, key)) {
+            excluded.push({ path: filePath, reason: 'outside-project' });
             continue;
+        }
         keys.set(filePath, key);
         spellings.set(key, (spellings.get(key) ?? 0) + 1);
     }
     for (const [filePath, key] of keys) {
-        if ((spellings.get(key) ?? 0) > 1)
+        if ((spellings.get(key) ?? 0) > 1) {
             keys.delete(filePath);
+            excluded.push({ path: filePath, reason: 'duplicate-spelling', file: key });
+        }
     }
-    return keys;
+    return { keys, excluded };
+}
+/** #1030: the per-file record key of each project file in ONE report (see `classifyProjectCoveragePaths`). */
+export function projectFileCoverageKeys(paths, projectRoot) {
+    return classifyProjectCoveragePaths(paths, projectRoot).keys;
 }
 /** Read the canonical key first, then a measured legacy relative key if present. */
 export function fileCoverageLookupKeys(filePath, projectRoot) {

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

@@ -528,6 +528,8 @@ Provide thoughtful, specific analysis based on the coverage data. Do not include
                     function: pct(file.functions),
                     statement: pct(file.statements),
                     measured: true,
+                    // #1219: the counts behind `line`, so several files can be line-weighted.
+                    lines: { covered: file.lines.covered, total: file.lines.total },
                     ...(runStatus ? { runStatus } : {}),
                 }, { persist: true });
             }

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

@@ -16,7 +16,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';
+import { measuredFileCoverage } from '../../quality-assessment/coverage-report-event.js';
 import { fileCoverageLookupKeys } from '../../coverage-analysis/collected-metrics.js';
 // LLMDefectAnalysis is imported from ../interfaces
 const DEFAULT_CONFIG = {
@@ -616,11 +616,8 @@ Be specific and actionable. Focus on concrete issues, not generic advice.`,
                     return 1 - fileCoverage.line / 100;
                 }
             }
-            // Fall back to project-wide coverage
-            const summary = measuredCoverageSummary(await this.memory.get('coverage:latest'));
-            if (summary) {
-                return 1 - summary.line / 100;
-            }
+            // #1219: no fallback to the project-wide summary — it is not this
+            // file's coverage. A file with no record of its own gets the prior below.
         }
         catch {
             // Non-critical lookup

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

@@ -34,6 +34,14 @@ export interface MeasuredFileCoverage {
     function: number | null;
     statement: number | null;
     measured: true;
+    /**
+     * #1219: the line counts behind `line`, so a reader can weight several
+     * files by size. Absent on records written before 3.15.13.
+     */
+    lines?: {
+        covered: number;
+        total: number;
+    };
 }
 /**
  * Return the measured summary to store, or `null` when the payload is not

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

@@ -53,6 +53,27 @@ export function measuredFileCoverage(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 };
+    const lines = lineCounts(r.lines, r.line);
+    return {
+        line: r.line, branch: opt(r.branch), function: opt(r.function), statement: opt(r.statement), measured: true,
+        ...(lines ? { lines } : {}),
+    };
+}
+/**
+ * #1219: whole, consistent line counts (`covered / total` within rounding of
+ * the stored percentage), or `undefined` when the record has none or they do
+ * not describe its own percentage.
+ */
+function lineCounts(value, line) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const { covered, total } = value;
+    if (!Number.isSafeInteger(covered) || !Number.isSafeInteger(total))
+        return undefined;
+    const c = covered;
+    const t = total;
+    if (t <= 0 || c < 0 || c > t || Math.abs((c / t) * 100 - line) > 0.01)
+        return undefined;
+    return { covered: c, total: t };
 }
 //# sourceMappingURL=coverage-report-event.js.map

package/dist/domains/quality-assessment/interfaces.d.ts

@@ -103,6 +103,12 @@ export interface QualityReport {
      * value covers `analysedFiles` of `totalFiles`; `failed` lists the gaps.
      */
     partial?: PartialQualityMetric[];
+    /**
+     * The weighted score over the measured metrics only, present when a
+     * requested metric is unmeasured. `score.overall` is then -1: a score that
+     * leaves out unmeasured metrics is not the overall score (#1223 convention).
+     */
+    subsetScore?: number;
 }
 /** #1021: a file excluded from static analysis, with the reason. */
 export interface ExcludedQualityFile {

package/dist/domains/quality-assessment/services/quality-analyzer.d.ts

@@ -126,6 +126,10 @@ export declare class QualityAnalyzerService implements IQualityAnalyzerService {
      * Never a fixed fallback value.
      */
     private collectFileMetrics;
+    /**
+     * The file's own measured coverage record, or `null`. #1219: never the
+     * project-wide `coverage:latest` summary — that is not this file's coverage.
+     */
     private getStoredCoverage;
     private aggregateMetrics;
     private calculateQualityScore;