canary-test-cli 6.7.1 → 6.8.1

package/dist/doctor-manifest.d.ts

@@ -1,5 +1,5 @@
 import type { CheckResult } from './doctor.js';
-export declare const CHECK_TYPES: readonly ["file-exists", "url-reachable", "command-succeeds"];
+declare const CHECK_TYPES: readonly ["file-exists", "url-reachable", "command-succeeds"];
 export type CheckType = (typeof CHECK_TYPES)[number];
 /** A single validated check from an overlay's `doctor.json`. */
 export interface ManifestCheck {
@@ -60,8 +60,6 @@ export declare function collectAudiences(checks: ManifestCheck[]): string[];
  * contains the tag (case-insensitive).
  */
 export declare function filterByAudience(checks: ManifestCheck[], audience: string | null): ManifestCheck[];
-/** Default per-check timeout for url and command checks. */
-export declare const DEFAULT_CHECK_TIMEOUT_MS = 10000;
 /** Probe a URL for reachability (injectable). Resolves true on a 2xx/3xx. */
 export type UrlProbe = (url: string, timeoutMs: number) => Promise<boolean>;
 /** Run a command (injectable). `ok` = exit 0; `timedOut` = killed at the timeout. */
@@ -92,3 +90,4 @@ export interface RunContext {
  * granted. Never throws.
  */
 export declare function runCheck(check: ManifestCheck, ctx: RunContext): Promise<CheckResult>;
+export {};

package/dist/doctor-manifest.js

@@ -33,7 +33,6 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_CHECK_TIMEOUT_MS = exports.CHECK_TYPES = void 0;
 exports.manifestPath = manifestPath;
 exports.commandSucceedsHash = commandSucceedsHash;
 exports.loadManifest = loadManifest;
@@ -54,7 +53,7 @@ const http = __importStar(require("node:http"));
 const https = __importStar(require("node:https"));
 const path = __importStar(require("node:path"));
 const node_child_process_1 = require("node:child_process");
-exports.CHECK_TYPES = [
+const CHECK_TYPES = [
     'file-exists',
     'url-reachable',
     'command-succeeds',
@@ -109,8 +108,8 @@ function validateCommonFields(c, index) {
         return `check[${index}] is missing a string "id"`;
     }
     if (typeof c.type !== 'string' ||
-        !exports.CHECK_TYPES.includes(c.type)) {
-        return `check "${c.id}" has an unknown type (expected one of: ${exports.CHECK_TYPES.join(', ')})`;
+        !CHECK_TYPES.includes(c.type)) {
+        return `check "${c.id}" has an unknown type (expected one of: ${CHECK_TYPES.join(', ')})`;
     }
     if (typeof c.remedy !== 'string' || c.remedy === '') {
         return `check "${c.id}" is missing a string "remedy"`;
@@ -233,7 +232,7 @@ function filterByAudience(checks, audience) {
         c.audience.some((p) => p.toLowerCase() === want));
 }
 /** Default per-check timeout for url and command checks. */
-exports.DEFAULT_CHECK_TIMEOUT_MS = 10000;
+const DEFAULT_CHECK_TIMEOUT_MS = 10000;
 function defaultProbeUrl(url, timeoutMs) {
     return new Promise((resolve) => {
         let mod;
@@ -336,7 +335,7 @@ function runCommandSucceeds(check, ctx, timeoutMs) {
  * granted. Never throws.
  */
 async function runCheck(check, ctx) {
-    const timeoutMs = ctx.timeoutMs ?? exports.DEFAULT_CHECK_TIMEOUT_MS;
+    const timeoutMs = ctx.timeoutMs ?? DEFAULT_CHECK_TIMEOUT_MS;
     if (check.type === 'file-exists') {
         return runFileExists(check, ctx.cloneDir);
     }

package/dist/engine/core/feedback.js

@@ -24,7 +24,7 @@
  */
 import { release, type } from 'node:os';
 /** The public issue tracker (from npm/package.json `repository`). */
-export const TRACKER_URL = 'https://github.com/bop-clocktower/canary';
+const TRACKER_URL = 'https://github.com/bop-clocktower/canary';
 export const VALID_CATEGORIES = ['bug', 'ux', 'docs', 'idea'];
 /** Best-effort install-method label — never fails, never inspects secrets. */
 function installMethod() {

package/dist/engine/core/fs-glob.js

@@ -26,7 +26,7 @@ export function isFile(path) {
     }
 }
 /** Compile a single glob segment (with `*` -> `[^/]*`) to an anchored regex. */
-export function segGlobRegex(seg) {
+function segGlobRegex(seg) {
     const body = seg
         .replace(/[.+^${}()|[\]\\?]/g, '\\$&')
         .replace(/\*/g, '[^/]*');
@@ -75,7 +75,7 @@ export function globFiles(root, pattern) {
     visit(root, 0);
     return out;
 }
-export function subDirs(dir) {
+function subDirs(dir) {
     try {
         return readdirSync(dir, { withFileTypes: true })
             .filter((e) => e.isDirectory())

package/dist/engine/core/static-linter.js

@@ -7,6 +7,7 @@
  */
 import { readFileSync } from 'node:fs';
 import { basename, extname } from 'node:path';
+import { blankStringContent } from './string-literals.js';
 export function formatFinding(f) {
     return `[${f.severity.toUpperCase()}] ${f.file}:${f.line} (${f.rule})\n  ${f.message}\n  → ${f.suggestion}`;
 }
@@ -23,8 +24,19 @@ const LOCATOR_METHODS = /\.(locator|querySelector)\s*\(/;
 // Missing await
 const BARE_PLAYWRIGHT_CALL = /(?<!await\s)(?<!return\s)(?<!\w)(?:page|frame|locator)\.(?:click|fill|type|check|uncheck|selectOption|hover|focus|press|tap|dblclick)\s*\(/;
 // Assertion detection
-const TEST_FN_PY = /^(\s*)def (test_\w+)\s*\(/gm;
-const TEST_FN_JS = /(?:^|\s)(?:it|test)\s*\(\s*['"]([^'"]*)['"]/gm;
+// Indentation is `[ \t]*`, NOT `\s*`: `\s` matches a newline, so a `^`-anchored
+// `\s*` starts the match at the FIRST of any run of blank lines above the `def`
+// and counts those newlines as indentation. PEP 8 mandates blank lines between
+// defs, so that was the normal case, and it broke two things at once -- the
+// reported line landed above the test, and the inflated indent made the
+// "next def at the same indent" body boundary un-matchable, so the body ran to
+// end-of-file and could borrow a later test's assert (#633).
+const TEST_FN_PY = /^([ \t]*)def (test_\w+)\s*\(/gm;
+// `d` (hasIndices) so the NAME can be read back out of the ORIGINAL source.
+// The scanner matches against string-blanked source, where the name itself has
+// been blanked away; blanking is length-preserving precisely so these offsets
+// still address the untouched text (#590).
+const TEST_FN_JS = /(?:^|\s)(?:it|test)\s*\(\s*['"]([^'"]*)['"]/dgm;
 const ASSERT_PY = /\bassert\b|\bpytest\.raises\b/;
 // Assertion styles a JS/TS test may use. `expect()` (jest/vitest/playwright)
 // was the only one recognized until canary was pointed at its own suites and
@@ -276,7 +288,7 @@ function scanAssertionFreePy(code, file) {
     }
     return out;
 }
-function scanAssertionFreeJs(code, file) {
+function scanAssertionFreeJs(code, file, source) {
     const out = [];
     // The test declarations, in source order, so each body can be bounded by the
     // NEXT one -- the JS analogue of what the pytest scanner already does with
@@ -296,7 +308,16 @@ function scanAssertionFreeJs(code, file) {
         const bodyEnd = decls[i + 1]?.index ?? code.length;
         const rest = code.slice(bodyStart, bodyEnd);
         if (!ASSERT_JS.test(rest)) {
-            out.push(mk(file, lineOf(code, start), 'LINT-006', 'warning', `Test "${m[1]}" contains no assertions.`, 'Add an expect() call; a test that never asserts always passes.'));
+            const name = m.indices?.[1]
+                ? source.slice(m.indices[1][0], m.indices[1][1])
+                : m[1];
+            // The reported coordinate comes from the NAME's offset, not the match's.
+            // `TEST_FN_JS` opens with `(?:^|\s)`, which CONSUMES the character before
+            // `it`/`test` -- for any test not on line 1 that is the newline ending the
+            // previous line, so `m.index` sits one line early (#633). `start` is still
+            // the right anchor for the body bounds; only the line moves.
+            const nameStart = m.indices?.[1]?.[0] ?? start;
+            out.push(mk(file, lineOf(code, nameStart), 'LINT-006', 'warning', `Test "${name}" contains no assertions.`, 'Add an expect() call; a test that never asserts always passes.'));
         }
     }
     return out;
@@ -356,13 +377,16 @@ export class StaticLinter {
     /** Full quality audit — all rules. */
     lint(path, framework) {
         const code = readFileSync(path, 'utf-8');
-        // No rule may read the interior of a multi-line string as code. Blanking
-        // preserves line count, so `scanned` re-joins to the same line numbers the
-        // per-line scanners report -- both halves must use it, or the assertion
-        // scanners go on mining `it(...)` declarations out of diff fixtures.
+        // No rule may read the interior of a string as code. The per-line rules
+        // keep the line-oriented blanking they were written against; the assertion
+        // scanners take a whole-source pass instead, because they are the only
+        // rules that bound one match by the offset of the NEXT one -- so a phantom
+        // declaration inside a fixture does not just add a finding, it truncates a
+        // real test's body and attributes its assertion past the end (#590).
+        // Both blankers preserve line numbering, so findings agree on line numbers.
         const lines = blankMultilineStrings(code.split('\n'));
-        const scanned = lines.join('\n');
         const fw = requireFramework(path, framework);
+        const scanned = blankStringContent(code, { python: fw === 'pytest' });
         const findings = [
             ...scanFlakiness(lines, path),
             ...scanSelectors(lines, path),
@@ -370,7 +394,7 @@ export class StaticLinter {
             ...scanMagicNumbers(lines, path),
             ...(fw === 'pytest'
                 ? scanAssertionFreePy(scanned, path)
-                : scanAssertionFreeJs(scanned, path)),
+                : scanAssertionFreeJs(scanned, path, code)),
         ];
         findings.sort((a, b) => a.line - b.line || cmp(a.rule, b.rule));
         return findings;

package/dist/engine/core/string-literals.js

@@ -0,0 +1,202 @@
+/**
+ * Offset-preserving string-literal blanking for the static linter. #590.
+ *
+ * The linter regexes over raw source, so a `test(...)` written inside a STRING
+ * is indistinguishable from one written in code. That is not a hypothetical:
+ * the files most likely to embed test source in a fixture are the linters,
+ * scanners and codemods -- exactly the tooling whose own tests you most want
+ * read. A downstream overlay on 6.7.0 got four LINT-006 findings on one suite
+ * and all four were data, not tests.
+ *
+ * Two narrower mechanisms already existed and #590 fell through the seam
+ * between them:
+ *
+ * - `blankMultilineStrings` toggles state on an ODD count of a delimiter per
+ *   line, so a template literal that opens AND closes on the same physical
+ *   line is skipped entirely. A `\n`-escaped fixture is one physical line.
+ * - The single-line `STRING_LITERAL` stripper has no backtick in its character
+ *   class, and was never applied to the assertion scanners at all.
+ *
+ * This scanner reads the WHOLE source with a small state machine instead, so a
+ * literal is handled the same way whether it spans one line or twenty.
+ *
+ * ## Why blanking rather than rejecting matches
+ *
+ * The sibling helper in canary-blackhawk / canary-savant
+ * (`scripts/string-literals.mjs`) rejects a match whose start index falls
+ * inside a literal, because those scanners need the anchor token to stay
+ * visible -- blackhawk's BH003 matches `strftime('..%Z')` with the `%Z` inside
+ * the quotes on purpose. LINT-006 has the opposite need: it bounds each test
+ * body by the NEXT declaration's offset, so a phantom declaration inside a
+ * string truncates a real test's body and its assertion is attributed past the
+ * end. Suppressing the match is not enough; the text has to stop looking like
+ * a declaration. Hence blanking, and hence a separate implementation rather
+ * than a third copy of the `.mjs` helper.
+ *
+ * ## Invariants
+ *
+ * - Output has the SAME length and the SAME newline positions as the input, so
+ *   every byte offset and computed line number stays valid.
+ * - Only literal CONTENT is replaced (with spaces); the quote characters stay,
+ *   so a rule keying off the delimiter still sees that a string was there.
+ * - An UNTERMINATED literal is discarded, never applied. Blanking an unclosed
+ *   run to end-of-file would silently disable every downstream rule from that
+ *   point on -- the abstention shape, one layer inside the linter. This
+ *   matches the deliberate choice already made in `blankMultilineStrings`.
+ *
+ * Fidelity limits (a state machine, not a parser):
+ * - A regex literal containing a quote (`/['"]/`) can open a phantom string.
+ *   Because an unterminated run is discarded, the usual outcome is a no-op;
+ *   the residual risk is a suppressed finding, never a fabricated one.
+ * - JSX text and Python f-string nesting beyond `${...}` are not modelled.
+ */
+const SPACE = ' ';
+/**
+ * Replace the content of every CLOSED string literal in `code` with spaces,
+ * preserving length, newline positions, and the quote characters themselves.
+ */
+export function blankStringContent(code, options = {}) {
+    const spans = literalContentSpans(code, options.python === true);
+    if (spans.length === 0)
+        return code;
+    const out = [...code];
+    for (const [start, end] of spans) {
+        for (let i = start; i < end; i += 1) {
+            // Newlines survive so line numbering is unchanged; everything else goes.
+            if (out[i] !== '\n')
+                out[i] = SPACE;
+        }
+    }
+    return out.join('');
+}
+/**
+ * Walk `code` once and collect the content spans of every literal that closes.
+ *
+ * The stack holds two frame kinds: a string frame (`quote` set) whose content
+ * accumulates, and an interpolation frame (`interp`) for a template's
+ * `${...}`, which is CODE and may itself contain strings.
+ */
+function literalContentSpans(code, python) {
+    const spans = [];
+    const stack = [];
+    const top = () => stack[stack.length - 1];
+    for (let i = 0; i < code.length; i += 1) {
+        const ch = code[i];
+        const frame = top();
+        if (frame?.kind === 'string') {
+            i = advanceInsideString(code, i, frame, spans, stack);
+            continue;
+        }
+        // Code context: top level, or inside a `${ ... }` interpolation.
+        const commentEnd = skipComment(code, i, python);
+        if (commentEnd !== null) {
+            i = commentEnd;
+            continue;
+        }
+        const opener = readOpener(code, i, python);
+        if (opener !== null) {
+            stack.push({ kind: 'string', quote: opener, start: i + opener.length });
+            i += opener.length - 1;
+            continue;
+        }
+        if (frame?.kind === 'interp')
+            advanceInsideInterp(ch, i, frame, stack);
+    }
+    // Anything still open never closed. Discard it -- see the header.
+    return spans;
+}
+/**
+ * Handle one character of a template's `${ ... }`. Only braces matter here:
+ * everything else in an interpolation is code the main loop already handles.
+ * Lives apart from the walk so brace bookkeeping cannot leak into it.
+ */
+function advanceInsideInterp(ch, i, frame, stack) {
+    if (ch === '{') {
+        frame.depth += 1;
+        return;
+    }
+    if (ch !== '}')
+        return;
+    if (frame.depth > 0) {
+        frame.depth -= 1;
+        return;
+    }
+    stack.pop();
+    // The enclosing template resumes its content after the `}`.
+    const enclosing = stack[stack.length - 1];
+    if (enclosing?.kind === 'string')
+        enclosing.start = i + 1;
+}
+/**
+ * Handle one character while inside a string frame. Returns the index the main
+ * loop should continue FROM (it will be incremented), so escape pairs and
+ * multi-character delimiters are consumed atomically.
+ */
+function advanceInsideString(code, i, frame, spans, stack) {
+    const ch = code[i];
+    // An escaped character is content and can never close the literal. Python
+    // raw strings are not modelled; treating `\` as an escape there costs at
+    // most a suppressed match, never a fabricated one.
+    if (ch === '\\')
+        return i + 1;
+    if (code.startsWith(frame.quote, i)) {
+        pushSpan(spans, frame.start, i);
+        stack.pop();
+        return i + frame.quote.length - 1;
+    }
+    // Template interpolation closes the current content run and opens code.
+    if (frame.quote === '`' && ch === '$' && code[i + 1] === '{') {
+        pushSpan(spans, frame.start, i);
+        stack.push({ kind: 'interp', depth: 0 });
+        return i + 1;
+    }
+    return i;
+}
+/** Record a content span, skipping empty ones. */
+function pushSpan(spans, start, end) {
+    if (end > start)
+        spans.push([start, end]);
+}
+/**
+ * If a comment starts at `i`, return the index of its last character so the
+ * caller can skip it. Quotes inside a comment are prose, not delimiters: an
+ * apostrophe in "don't" would otherwise open a phantom literal.
+ */
+function skipComment(code, i, python) {
+    if (python && code[i] === '#')
+        return endOfLine(code, i);
+    if (code[i] !== '/')
+        return null;
+    if (code[i + 1] === '/')
+        return endOfLine(code, i);
+    if (code[i + 1] === '*') {
+        const close = code.indexOf('*/', i + 2);
+        // An unterminated block comment runs to EOF; that IS how the language
+        // reads it, so unlike an unclosed string there is nothing to discard.
+        return close === -1 ? code.length - 1 : close + 1;
+    }
+    return null;
+}
+function endOfLine(code, i) {
+    const nl = code.indexOf('\n', i);
+    return nl === -1 ? code.length - 1 : nl - 1;
+}
+/**
+ * Return the delimiter opening at `i`, longest first so a Python triple quote
+ * is never mistaken for an empty string followed by an opener.
+ */
+function readOpener(code, i, python) {
+    if (python) {
+        if (code.startsWith('"""', i))
+            return '"""';
+        if (code.startsWith("'''", i))
+            return "'''";
+    }
+    const ch = code[i];
+    if (ch === "'" || ch === '"')
+        return ch;
+    if (!python && ch === '`')
+        return '`';
+    return null;
+}
+//# sourceMappingURL=string-literals.js.map

package/dist/engine/guardian/adjudication.js

@@ -35,7 +35,7 @@ import { dirname, join } from 'node:path';
 import { STICKY_MARKER, findSticky } from './pr-comment.js';
 import { readAllPages, restPageReader } from './github-paging.js';
 /** Schema tag for adjudication records (independent of the findings schema). */
-export const ADJUDICATION_SCHEMA_VERSION = '1.0';
+const ADJUDICATION_SCHEMA_VERSION = '1.0';
 /**
  * Record `source` + filename prefix. Deliberately namespaced UNDER the
  * `canary-pr-guardian-` prefix, because harness's `AnalysisArchive` reads every

package/dist/engine/guardian/agent-tier.js

@@ -28,7 +28,7 @@ import { existsSync } from 'node:fs';
 import { Severity } from './impact-mapper.js';
 import { Finding } from './pr-check.js';
 /** Construct a {@link ReviewRequest} (a frozen dataclass in Python). */
-export function reviewRequest(test_paths) {
+function reviewRequest(test_paths) {
     return { test_paths };
 }
 /**
@@ -86,7 +86,7 @@ const SEVERITY_BY_NAME = new Map(Object.values(Severity).map((s) => [s, s]));
  * RecordingInvoker} default) yields `[]` -- the SKILL reports its review
  * directly in-session.
  */
-export function parseReviewFindings(transcript) {
+function parseReviewFindings(transcript) {
     const findings = [];
     for (const raw of transcript.split(/\r\n|\r|\n/)) {
         const match = REVIEW_LINE_RE.exec(raw);

package/dist/engine/guardian/analysis-emit.js

@@ -37,7 +37,11 @@ import { dirname, join } from 'node:path';
 import { coverageDegradedNotice, coverageStatus, } from './coverage.js';
 import { combineNotices, render } from './pr-check.js';
 // 1.1 adds the additive `coverage` block (#554); readers of 1.0 are unaffected.
-export const SCHEMA_VERSION = '1.1';
+// 1.2 adds the additive `skipped` list (#582). Additive again, and bumped again
+// for the reason recorded in #572: a reader that pins a version must be able to
+// tell which fields it can rely on being present, and silence about a new field
+// is indistinguishable from the field being absent for a real reason.
+export const SCHEMA_VERSION = '1.2';
 export const SOURCE = 'canary-pr-guardian';
 const REF_SAFE = /[^A-Za-z0-9._-]/g;
 const REF_MAX = 100; // cap the sanitized ref so a long branch never hits ENAMETOOLONG
@@ -120,6 +124,7 @@ export function buildAnalysisRecord(findings, args) {
         coverage: coverage === null
             ? null
             : { status: coverageStatus(coverage), ...coverage },
+        skipped: args.skipped ?? [],
         summary: {
             total: findings.length,
             unaddressed: active.length,

package/dist/engine/guardian/cli.js

@@ -853,7 +853,7 @@ async function postStickyComment(findings, resolution, deps, gateMeta = null) {
 // D7: every filtered path stays visible as a SkipEntry, never folded
 // into "passed". One entry per path so the rendered count still equals
 // the path count the old `N path(s) skipped` line reported.
-function prCheckSkipEntries(skipped, testUnits, barrelUnits, supportUnits = [], noisePaths = [], typeOnlyUnits = []) {
+function prCheckSkipEntries(skipped, testUnits, barrelUnits, supportUnits = [], typeOnlyUnits = []) {
     return [
         ...skipped.map((u) => ({ name: u.path, reason: 'skipGlobs' })),
         ...testUnits.map((u) => ({ name: u.path, reason: 'test path' })),
@@ -868,12 +868,17 @@ function prCheckSkipEntries(skipped, testUnits, barrelUnits, supportUnits = [],
             name: u.path,
             reason: 're-export barrel',
         })),
-        ...noisePaths.map((p) => ({
-            name: p,
-            reason: 'heuristic-ineligible',
-        })),
     ];
 }
+/**
+ * The heuristic-noise skip class (#413), which is only knowable AFTER the
+ * coverage ladder has scored each unit — so it cannot join
+ * {@link prCheckSkipEntries}, which must be built before the abstain exit.
+ * Kept a named function so the reason token has exactly one definition.
+ */
+function heuristicSkipEntries(noisePaths) {
+    return noisePaths.map((p) => ({ name: p, reason: 'heuristic-ineligible' }));
+}
 // Remediation is required copy (#508): say WHY the denominator
 // collapsed and the first fix step. The #456 class, now loud.
 const PR_CHECK_ABSTAIN_REMEDIATION = [
@@ -998,13 +1003,17 @@ async function prCheckCmd(opts, deps) {
     const weakFindings = config.weak_tests
         ? buildWeakTestFindings(testUnits, diffText)
         : [];
-    const preFilterSkipped = skipped.length +
-        testUnits.length +
-        barrelUnits.length +
-        supportUnits.length +
-        typeOnlyUnits.length;
+    // #582: build the skip list ONCE, above the abstain exit, so the surviving
+    // (non-abstain) path carries the same denominator the abstain payload has
+    // carried since #579. The heuristic-noise class is not known until the
+    // coverage ladder has run, so it is appended below rather than passed here.
+    //
+    // This supersedes a `preFilterSkipped` count that was computed at this point
+    // and read by nothing — the fossil of an earlier attempt to surface the same
+    // number on this path.
+    const preCoverageSkips = prCheckSkipEntries(skipped, testUnits, barrelUnits, supportUnits, typeOnlyUnits);
     if (kept.length === 0 && weakFindings.length === 0) {
-        abstainPrCheck(prCheckSkipEntries(skipped, testUnits, barrelUnits, supportUnits, [], typeOnlyUnits), opts.format, deps);
+        abstainPrCheck(preCoverageSkips, opts.format, deps);
     }
     const { results, coverage } = resolveCoverageWithInput(kept, {
         coveragePath: opts.coverage ?? null,
@@ -1020,11 +1029,17 @@ async function prCheckCmd(opts, deps) {
         ...applySuppressions(buildFindings(scoredResults)),
         ...weakFindings,
     ];
+    // The complete skip list for this run: the pre-coverage filters plus the
+    // heuristic-noise class the ladder just revealed.
+    const allSkips = [
+        ...preCoverageSkips,
+        ...heuristicSkipEntries(noiseResults.map((r) => r.unit.path)),
+    ];
     // #413: if the heuristic filter consumed every scorable unit, report it as a
     // SKIP rather than rendering an empty "0 unaddressed" report -- an adopter
     // must be able to tell "nothing was judgeable" from "everything passed".
     if (scoredResults.length === 0 && findings.length === 0) {
-        abstainPrCheck(prCheckSkipEntries(skipped, testUnits, barrelUnits, supportUnits, noiseResults.map((r) => r.unit.path), typeOnlyUnits), opts.format, deps);
+        abstainPrCheck(allSkips, opts.format, deps);
     }
     // SC-5 (PR half): resolve the requested tier against actual capability. No
     // agent runtime exists (default NoAgentProbe), so any `pr.tier > 0` drops to
@@ -1043,6 +1058,9 @@ async function prCheckCmd(opts, deps) {
         checked: scoredResults.length,
         abstained: false,
         coverage,
+        // #582: `checked` is the numerator of a fraction whose denominator was
+        // never printed. This is the rest of it.
+        skipped: allSkips,
     };
     const coverageNotice = coverageDegradedNotice(coverage);
     if (coverageNotice) {
@@ -1069,6 +1087,7 @@ async function prCheckCmd(opts, deps) {
             checked: scoredResults.length,
             abstained: false, // an abstained run exits before emit (see plan)
             coverage,
+            skipped: allSkips,
         });
         if (res.action === 'emitted') {
             deps.out(`guardian: wrote analysis record ${RIGHT_ARROW} ${res.path}`);

package/dist/engine/guardian/coverage.js

@@ -171,7 +171,7 @@ function parseLcov(text) {
 // The coverage-json contract version this build understands. Bumped only on a
 // breaking change; the shape evolves additively (see
 // docs/specs/coverage-json-contract.md).
-export const COVERAGE_JSON_SCHEMA_VERSION = 1;
+const COVERAGE_JSON_SCHEMA_VERSION = 1;
 /**
  * Parse the canary coverage-json shape into `{path: {line: hits}}`.
  *
@@ -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/impact-mapper.js

@@ -21,10 +21,11 @@ export var Severity;
     Severity["LOW"] = "low";
 })(Severity || (Severity = {}));
 /**
- * Python: `Severity.sort_key` (ascending — CRITICAL sorts first). Imported by
- * other guardian modules as the canonical severity ordering.
+ * Python: `Severity.sort_key` (ascending — CRITICAL sorts first). The canonical
+ * severity ordering; reached from outside this module through
+ * {@link severitySortKey} rather than directly (#544).
  */
-export const SEVERITY_SORT_KEY = {
+const SEVERITY_SORT_KEY = {
     [Severity.CRITICAL]: 0,
     [Severity.HIGH]: 1,
     [Severity.MEDIUM]: 2,

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;
@@ -914,7 +929,7 @@ export function combineNotices(...notices) {
     return kept.length > 0 ? kept.join('; ') : null;
 }
 /** The `coverage` block the json/analysis surfaces carry (#554). */
-export function coverageBlock(state) {
+function coverageBlock(state) {
     return { status: coverageStatus(state), ...state };
 }
 /**
@@ -958,6 +973,11 @@ export function render(findings, fmt, tier = 0, degradedNotice = null, gateMeta
         if (gateMeta !== null) {
             payload['checked'] = gateMeta.checked;
             payload['abstained'] = gateMeta.abstained;
+            // #582: unconditional, and `[]` when nothing was dropped. An omitted key
+            // would make "this run skipped nothing" indistinguishable from "this
+            // producer predates #582", leaving a consumer to guess exactly the thing
+            // the field exists to state.
+            payload['skipped'] = gateMeta.skipped ?? [];
             if (coverageState)
                 payload['coverage'] = coverageBlock(coverageState);
         }

package/dist/engine/history/cli.js

@@ -104,7 +104,7 @@ function pick(src, fields) {
     return out;
 }
 /** Process-backed defaults for production. */
-export function defaultHistoryDeps() {
+function defaultHistoryDeps() {
     return {
         out: (s) => process.stdout.write(`${s}\n`),
         err: (s) => process.stderr.write(`${s}\n`),

package/dist/overlay-commands.d.ts

@@ -33,8 +33,6 @@ export declare function classifyCloneFailure(res: GitResult): string;
 export declare function add(source: string, options?: {
     ref?: string | null;
 }, deps?: CommandDeps): number;
-/** Count `.canary/skills/<name>/SKILL.md` entries in a clone. */
-export declare function skillCount(dest: string): number;
 /** Working-tree cleanliness of a clone. */
 export type CleanStatus = 'clean' | 'dirty' | 'unreadable';
 /**

package/dist/overlay-commands.js

@@ -35,7 +35,6 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.classifyCloneFailure = classifyCloneFailure;
 exports.add = add;
-exports.skillCount = skillCount;
 exports.workingTreeStatus = workingTreeStatus;
 exports.freshness = freshness;
 exports.list = list;

package/dist/overlay-lint.d.ts

@@ -1,10 +1,3 @@
-/**
- * The BUNDLED migration target shapes, plus the `all` sentinel. Not a closed
- * set: `migrate` matches `deploy_to` against the consuming repo's resolved
- * `canary_shape` by plain string comparison, so downstream overlays may use
- * custom shapes. Lint warns (never errors) on a value outside this set (#501).
- */
-export declare const VALID_DEPLOY_TARGETS: ReadonlySet<string>;
 export interface LintFinding {
     /** Skill name, or `(overlay)` for an overlay-level finding. */
     skill: string;

package/dist/overlay-lint.js

@@ -33,7 +33,6 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VALID_DEPLOY_TARGETS = void 0;
 exports.lintOverlay = lintOverlay;
 /**
  * `canary overlay lint` — validate an overlay against the authoring contract
@@ -65,7 +64,7 @@ const skill_frontmatter_js_1 = require("./skill-frontmatter.js");
  * `canary_shape` by plain string comparison, so downstream overlays may use
  * custom shapes. Lint warns (never errors) on a value outside this set (#501).
  */
-exports.VALID_DEPLOY_TARGETS = new Set([
+const VALID_DEPLOY_TARGETS = new Set([
     'api',
     'e2e_ui',
     'frontend_unit',
@@ -116,11 +115,11 @@ function frontmatterFindings(skill, fm, parseErrors) {
         }
     }
     for (const target of (0, skill_frontmatter_js_1.listField)(fm, 'deploy_to')) {
-        if (!exports.VALID_DEPLOY_TARGETS.has(target)) {
+        if (!VALID_DEPLOY_TARGETS.has(target)) {
             findings.push({
                 skill,
                 level: 'warning',
-                message: `deploy_to value "${target}" is not a bundled target (${[...exports.VALID_DEPLOY_TARGETS].join(', ')}); fine if it matches a consuming repo's custom canary_shape, otherwise a typo`,
+                message: `deploy_to value "${target}" is not a bundled target (${[...VALID_DEPLOY_TARGETS].join(', ')}); fine if it matches a consuming repo's custom canary_shape, otherwise a typo`,
             });
         }
     }

package/dist/overlays-registry.d.ts

@@ -48,7 +48,6 @@ export interface OverlayRegistry {
 export declare class RegistryError extends Error {
     constructor(message: string);
 }
-export declare function canaryHome(homeDir?: string): string;
 export declare function registryPath(homeDir?: string): string;
 export declare function overlaysDir(homeDir?: string): string;
 export declare function clonePath(name: string, homeDir?: string): string;

package/dist/overlays-registry.js

@@ -34,7 +34,6 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RegistryError = exports.SCHEMA_VERSION = void 0;
-exports.canaryHome = canaryHome;
 exports.registryPath = registryPath;
 exports.overlaysDir = overlaysDir;
 exports.clonePath = clonePath;

package/package.json

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