canary-test-cli 6.8.0 → 6.8.1

package/dist/engine/guardian/coverage.js

@@ -612,48 +612,56 @@ function readReportText(reportPath) {
  * blocks).
  */
 export function resolveFromReport(units, reportPath) {
-    const { index } = readReportIndex(reportPath);
+    const { index, absence } = readReportIndex(reportPath);
     if (index === null)
         return null;
-    return matchUnitsToIndex(units, index);
+    return matchUnitsToIndex(units, index, absence);
 }
 /** Read + parse a coverage report, reporting each step's outcome separately. */
 function readReportIndex(reportPath) {
+    const unusable = (found) => ({
+        found,
+        index: null,
+        absence: 'not-coverable',
+    });
     if (!existsSync(reportPath))
-        return { found: false, index: null };
+        return unusable(false);
     const text = readReportText(reportPath);
     // Present but unreadable/non-UTF-8 counts as found-and-unusable, not absent.
     if (text === null)
-        return { found: true, index: null };
+        return unusable(true);
     const name = basename(reportPath).toLowerCase();
     let index;
+    let absence;
     if (name.endsWith('.json')) {
         let parsed;
         try {
             parsed = JSON.parse(text);
         }
         catch {
-            return { found: true, index: null };
+            return unusable(true);
         }
         index = parseCoverageJson(parsed);
+        absence = 'uncovered';
     }
     else if (name.endsWith('.info') || name.includes('lcov')) {
         index = parseLcov(text);
+        absence = 'not-coverable';
     }
     else if (name.endsWith('.xml')) {
         index = parseCobertura(text);
+        absence = 'not-coverable';
     }
     else {
         // Unrecognized format → fall through to a lower fidelity tier.
-        return { found: true, index: null };
+        return unusable(true);
     }
-    if (index === null || Object.keys(index).length === 0) {
-        return { found: true, index: null };
-    }
-    return { found: true, index };
+    if (index === null || Object.keys(index).length === 0)
+        return unusable(true);
+    return { found: true, index, absence };
 }
 /** Resolve every unit the report index can speak to (COVERAGE_VERIFIED). */
-function matchUnitsToIndex(units, index) {
+function matchUnitsToIndex(units, index, absence) {
     const results = [];
     for (const unit of units) {
         const hits = matchHits(unit.path, index);
@@ -665,17 +673,30 @@ function matchUnitsToIndex(units, index) {
             continue;
         }
         const added = expandRanges(unit.added_ranges);
-        const uncovered = added.filter((ln) => (hits[ln] ?? 0) <= 0);
+        // The per-line form of the check above (#655): under a format that
+        // enumerates instrumented lines, a changed line with no record could not
+        // have been executed and is scored by neither side.
+        const coverable = absence === 'not-coverable' ? added.filter((ln) => ln in hits) : added;
+        if (coverable.length === 0) {
+            // Every changed line is non-coverable, so this report has nothing to say
+            // about the unit. An abstention — never a clean pass, never a finding.
+            // Falls through to the graph/heuristic tier exactly as an absent path does.
+            continue;
+        }
+        const uncovered = coverable.filter((ln) => (hits[ln] ?? 0) <= 0);
         const covered = uncovered.length === 0;
+        // State the denominator: "all covered" over 20 changed lines and over the 3
+        // of them that were coverable are very different claims (#508).
         const evidence = covered
-            ? `lines ${rangesStr(unit.added_ranges)}: all covered`
-            : `lines ${rangesStr(unit.added_ranges)}: ${uncovered.length} uncovered`;
+            ? `lines ${rangesStr(unit.added_ranges)}: all ${coverable.length} coverable line(s) covered`
+            : `lines ${rangesStr(unit.added_ranges)}: ${uncovered.length} of ${coverable.length} coverable line(s) uncovered`;
         results.push(makeResult({
             unit,
             covered,
             fidelity: Fidelity.CoverageVerified,
             evidence,
             uncovered_lines: uncovered,
+            coverable_lines: coverable.length,
         }));
     }
     return results;
@@ -1399,7 +1420,9 @@ export function resolveCoverageWithInput(units, options = {}) {
         coverage.parsed = read.index !== null;
         coverage.filesInReport =
             read.index === null ? 0 : Object.keys(read.index).length;
-        const report = read.index === null ? null : matchUnitsToIndex(remaining, read.index);
+        const report = read.index === null
+            ? null
+            : matchUnitsToIndex(remaining, read.index, read.absence);
         // An empty array (no unit matched the report) is falsy-equivalent in the
         // Python `if report:` guard — fall through rather than lock in nothing.
         if (report !== null && report.length > 0) {

package/dist/engine/guardian/pr-check.js

@@ -565,6 +565,22 @@ const HIGH_UNCOVERED_SHARE = 0.5;
 function addedLineCount(ranges) {
     return ranges.reduce((total, [start, end]) => total + (end - start + 1), 0);
 }
+/**
+ * The fraction of what the report could speak to that came back unhit (#655).
+ *
+ * The denominator is the unit's **coverable** lines — added lines overstate it,
+ * because on a new file that is largely imports, types and blanks most changed
+ * lines were never instrumented at all, and dividing by them drives every share
+ * toward zero. Where the count is unknown (the graph and heuristic tiers, which
+ * are not graded by share anyway) it falls back to the added-line count, so
+ * grades predating that field are unchanged. An unknown denominator yields a
+ * full share rather than a low one — an absent measurement must never read as a
+ * good score (ADR 0010).
+ */
+function uncoveredShare(result, uncovered) {
+    const denominator = result.coverable_lines ?? addedLineCount(result.unit.added_ranges);
+    return denominator > 0 ? uncovered / denominator : 1;
+}
 /**
  * Severity for an uncovered **coverage-verified** result (#553).
  *
@@ -589,8 +605,7 @@ function coverageVerifiedSeverity(result) {
     const uncovered = result.uncovered_lines?.length ?? 0;
     if (uncovered === 0)
         return Severity.HIGH;
-    const added = addedLineCount(result.unit.added_ranges);
-    const share = added > 0 ? uncovered / added : 1;
+    const share = uncoveredShare(result, uncovered);
     if (uncovered >= CRITICAL_UNCOVERED_LINES &&
         share >= CRITICAL_UNCOVERED_SHARE)
         return Severity.CRITICAL;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "canary-test-cli",
-  "version": "6.8.0",
+  "version": "6.8.1",
   "description": "Canary — AI-powered test automation agent",
   "license": "MIT",
   "repository": {