canary-test-cli 6.5.0 → 6.7.0

package/dist/engine/core/scaffold-templates.js

@@ -0,0 +1,123 @@
+/**
+ * Scaffold templates - the config-file bodies canary writes for each supported
+ * framework, and the derived set of frameworks it can scaffold.
+ *
+ * Extracted from `scaffolder.ts` to break a circular dependency (#543):
+ * `framework-registry` needs {@link scaffoldableFrameworks} to answer the
+ * scaffold capability question, while `scaffolder` needs the registry to
+ * degrade loudly on an unknown framework. With the data here, both depend on a
+ * leaf module and neither depends on the other. `scaffolder.ts` re-exports
+ * both names, so existing importers (the migrator, the parity suite) are
+ * unaffected.
+ *
+ * The template strings remain a **byte-exact contract** with the Python
+ * originals - see the note in `scaffolder.ts`. They were moved by line slice,
+ * not retyped, and `core-parity.test.ts` compares TEMPLATES against the golden
+ * fixture.
+ */
+// Exported so the migrator port can compute would-create / already-present sets
+// in its dry-run path (Python: `from agent.core.scaffolder import TEMPLATES`).
+export const TEMPLATES = {
+    playwright: {
+        files: {
+            'playwright.config.ts': `import { defineConfig, devices } from '@playwright/test';
+
+export default defineConfig({
+  testDir: './tests/e2e',
+  fullyParallel: true,
+  forbidOnly: !!process.env.CI,
+  retries: process.env.CI ? 2 : 0,
+  workers: process.env.CI ? 1 : undefined,
+  reporter: 'html',
+  use: {
+    trace: 'on-first-retry',
+  },
+  projects: [
+    {
+      name: 'chromium',
+      use: { ...devices['Desktop Chrome'] },
+    },
+  ],
+});
+`,
+        },
+        dirs: ['tests/e2e'],
+    },
+    vitest: {
+        files: {
+            'vitest.config.ts': `import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    environment: 'node',
+    include: ['tests/unit/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
+  },
+});
+`,
+        },
+        dirs: ['tests/unit'],
+    },
+    pytest: {
+        files: {
+            'pytest.ini': `[pytest]
+testpaths = tests
+python_files = test_*.py *_test.py
+python_classes = Test*
+python_functions = test_*
+`,
+        },
+        dirs: ['tests'],
+    },
+    k6: {
+        files: {
+            'k6.config.js': `export const options = {
+  vus: 10,
+  duration: '30s',
+};
+`,
+        },
+        dirs: ['tests/performance'],
+    },
+    wdio: {
+        files: {
+            'wdio.conf.ts': `import type { Options } from "@wdio/types";
+
+// Appium + WebdriverIO config. Fill in the capabilities stub below for the
+// device/platform under test (Android shown; add an iOS entry as needed).
+export const config: Options.Testrunner = {
+  runner: "local",
+  specs: ["./tests/**/*.spec.ts"],
+  maxInstances: 1,
+  // Appium capabilities stub \u{2014} replace deviceName / app / versions to match
+  // your emulator or real device.
+  capabilities: [
+    {
+      platformName: "Android",
+      "appium:automationName": "UiAutomator2",
+      "appium:deviceName": "Android Emulator",
+      "appium:app": "./app/build/outputs/apk/debug/app-debug.apk",
+    },
+  ],
+  framework: "mocha",
+  mochaOpts: {
+    ui: "bdd",
+    timeout: 60000,
+  },
+  reporters: ["spec"],
+  // Requires the Appium service: \`npm i -D @wdio/appium-service appium\`.
+  services: ["appium"],
+};
+`,
+        },
+        dirs: ['tests'],
+    },
+};
+/**
+ * Frameworks canary can scaffold - the single source of truth for the
+ * `scaffold` capability, derived from the templates that actually exist
+ * (Python: `scaffoldable_frameworks`).
+ */
+export function scaffoldableFrameworks() {
+    return new Set(Object.keys(TEMPLATES));
+}
+//# sourceMappingURL=scaffold-templates.js.map

package/dist/engine/core/scaffolder.js

@@ -23,6 +23,10 @@
 import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { FrameworkRegistry } from './framework-registry.js';
+import { TEMPLATES } from './scaffold-templates.js';
+// Re-exported so existing importers keep one entry point for the scaffold
+// surface (Python: `from agent.core.scaffolder import TEMPLATES`).
+export { TEMPLATES, scaffoldableFrameworks } from './scaffold-templates.js';
 // ---------------------------------------------------------------------------
 // Python-compatibility helper (copied locally per-module, matching reporter.ts)
 // ---------------------------------------------------------------------------
@@ -41,103 +45,6 @@ function pyTruthy(value) {
         return Object.keys(value).length > 0;
     return Boolean(value);
 }
-// Exported so the migrator port can compute would-create / already-present sets
-// in its dry-run path (Python: `from agent.core.scaffolder import TEMPLATES`).
-export const TEMPLATES = {
-    playwright: {
-        files: {
-            'playwright.config.ts': `import { defineConfig, devices } from '@playwright/test';
-
-export default defineConfig({
-  testDir: './tests/e2e',
-  fullyParallel: true,
-  forbidOnly: !!process.env.CI,
-  retries: process.env.CI ? 2 : 0,
-  workers: process.env.CI ? 1 : undefined,
-  reporter: 'html',
-  use: {
-    trace: 'on-first-retry',
-  },
-  projects: [
-    {
-      name: 'chromium',
-      use: { ...devices['Desktop Chrome'] },
-    },
-  ],
-});
-`,
-        },
-        dirs: ['tests/e2e'],
-    },
-    vitest: {
-        files: {
-            'vitest.config.ts': `import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    environment: 'node',
-    include: ['tests/unit/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
-  },
-});
-`,
-        },
-        dirs: ['tests/unit'],
-    },
-    pytest: {
-        files: {
-            'pytest.ini': `[pytest]
-testpaths = tests
-python_files = test_*.py *_test.py
-python_classes = Test*
-python_functions = test_*
-`,
-        },
-        dirs: ['tests'],
-    },
-    k6: {
-        files: {
-            'k6.config.js': `export const options = {
-  vus: 10,
-  duration: '30s',
-};
-`,
-        },
-        dirs: ['tests/performance'],
-    },
-    wdio: {
-        files: {
-            'wdio.conf.ts': `import type { Options } from "@wdio/types";
-
-// Appium + WebdriverIO config. Fill in the capabilities stub below for the
-// device/platform under test (Android shown; add an iOS entry as needed).
-export const config: Options.Testrunner = {
-  runner: "local",
-  specs: ["./tests/**/*.spec.ts"],
-  maxInstances: 1,
-  // Appium capabilities stub \u{2014} replace deviceName / app / versions to match
-  // your emulator or real device.
-  capabilities: [
-    {
-      platformName: "Android",
-      "appium:automationName": "UiAutomator2",
-      "appium:deviceName": "Android Emulator",
-      "appium:app": "./app/build/outputs/apk/debug/app-debug.apk",
-    },
-  ],
-  framework: "mocha",
-  mochaOpts: {
-    ui: "bdd",
-    timeout: 60000,
-  },
-  reporters: ["spec"],
-  // Requires the Appium service: \`npm i -D @wdio/appium-service appium\`.
-  services: ["appium"],
-};
-`,
-        },
-        dirs: ['tests'],
-    },
-};
 /**
  * Handles initialization and scaffolding of test suites.
  *
@@ -225,12 +132,4 @@ export class Scaffolder {
         };
     }
 }
-/**
- * Frameworks canary can scaffold - the single source of truth for the
- * `scaffold` capability, derived from the templates that actually exist
- * (Python: `scaffoldable_frameworks`).
- */
-export function scaffoldableFrameworks() {
-    return new Set(Object.keys(TEMPLATES));
-}
 //# sourceMappingURL=scaffolder.js.map

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

@@ -26,10 +26,36 @@ const BARE_PLAYWRIGHT_CALL = /(?<!await\s)(?<!return\s)(?<!\w)(?:page|frame|loca
 const TEST_FN_PY = /^(\s*)def (test_\w+)\s*\(/gm;
 const TEST_FN_JS = /(?:^|\s)(?:it|test)\s*\(\s*['"]([^'"]*)['"]/gm;
 const ASSERT_PY = /\bassert\b|\bpytest\.raises\b/;
-const ASSERT_JS = /\bexpect\s*\(|\bto(?:Be|Equal|Contain|Have|Match|Throw|Raise)\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
+// reported 216 assertion-free tests of which 13 were real -- the other 200 were
+// `node:test` + `node:assert`, a whole framework the linter could not see.
+// Kept as a union of shapes rather than an import-aware parse: a static linter
+// that needs to resolve imports to judge one line is the wrong trade.
+// The `expectX()/assertX()` alternative covers a test that delegates its
+// assertion to a named helper (`expectAuthoringAllowed(res)`) -- 9 of canary's
+// own 16 residual findings. A regex linter cannot follow the call, so the NAME
+// carries the signal; the `[A-Z]` keeps it to the convention rather than
+// excusing any call that merely starts with those letters.
+const ASSERT_JS = /\bexpect\s*\(|\bto(?:Be|Equal|Contain|Have|Match|Throw|Raise)\b|\bassert\s*\.\s*\w+\s*\(|\bassert\s*\(|\bshould\s*\.|\.should\b|\b(?:expect|assert)[A-Z]\w*\s*\(/;
 // Strippers
 const STRING_LITERAL = /(['"])(?:\\.|(?!\1).)*?\1/g;
-// Magic numbers
+// Magic numbers -- scoped to TIMING values only.
+//
+// "Extract the magic number to a named constant" is a production-code
+// principle, and it inverts in a test: the literal IS the specification.
+// `expect(notes.length).toBe(2048)` states the contract that
+// `expect(notes.length).toBe(MAX_NOTES)` hides behind a name the reader now has
+// to go look up. Since this linter only ever reads TEST files, the unscoped
+// rule was misapplied across its entire domain -- measured at 0-for-157
+// actionable when canary was first pointed at its own suites.
+//
+// A timing value is the one case that survives: a bare `5000` in a
+// setTimeout/retry/interval position is a duration whose units and intent are
+// genuinely unclear, and naming it genuinely helps. (Hardcoded sleeps are
+// separately flagged at CRITICAL by FLAKE-001/002; this is the softer signal
+// for the non-sleep timing values those rules do not cover.)
+const TIMING_CONTEXT = /\b(?:setTimeout|setInterval|waitForTimeout|sleep|delay|timeout|interval|retryDelay|retries|backoff|pollInterval|debounce|throttle)\b/i;
 const NUMERIC_LITERAL = /(?<![\w.])-?\d+(?:\.\d+)?(?![\w.])/g;
 const ALLOWED_NUMBERS = new Set(['0', '1', '2', '-1', '10', '100']);
 const HTTP_STATUS = new Set([
@@ -99,11 +125,33 @@ const FLAKINESS_RULES = [
         suggestion: 'Mock Date.now()/datetime.now() or use a fixed reference date.',
     },
 ];
+/**
+ * Blank single-line string literals so a rule matching CODE cannot fire on test
+ * DATA.
+ *
+ * `scanMagicNumbers` has always done this; the flakiness and missing-await
+ * rules never did, so `const src = 'const t = Date.now();'` -- a fixture string
+ * feeding a linter test -- was reported as a real timestamp dependency. Any
+ * suite that carries the patterns it tests as string data hits this, and
+ * canary's own linter tests are the worst case.
+ *
+ * The same defect shipped in `canary-blackhawk`'s pragma parser (#499) and was
+ * guarded in `canary-savant` (#495/#498): data must never act as code, nor as
+ * directive.
+ *
+ * NOT applied to the selector rules: LINT-001/002/003 match `'.btn'` / `'#id'`
+ * inside quotes by construction, because a selector IS a string. Stripping
+ * would delete those rules outright.
+ */
+function blankStrings(line) {
+    return line.replace(STRING_LITERAL, '""');
+}
 function scanFlakiness(lines, file) {
     const out = [];
-    lines.forEach((line, idx) => {
-        if (isComment(line))
+    lines.forEach((raw, idx) => {
+        if (isComment(raw))
             return;
+        const line = blankStrings(raw);
         for (const r of FLAKINESS_RULES) {
             if (r.re.test(line) && (!r.guard || r.guard(line))) {
                 out.push(mk(file, idx + 1, r.rule, r.severity, r.message, r.suggestion));
@@ -137,25 +185,70 @@ function scanSelectors(lines, file) {
 }
 function scanMissingAwait(lines, file) {
     const out = [];
-    lines.forEach((line, idx) => {
-        if (isComment(line))
+    lines.forEach((raw, idx) => {
+        if (isComment(raw))
             return;
+        // A `page.click(...)` inside a string is fixture data, not a missing await.
+        const line = blankStrings(raw);
         if (BARE_PLAYWRIGHT_CALL.test(line) && !line.includes('await')) {
             out.push(mk(file, idx + 1, 'LINT-004', 'critical', 'Playwright action called without await.', 'Add `await` before the call to ensure it completes before the next step.'));
         }
     });
     return out;
 }
+/** Multi-line string delimiters: JS template literal, Python triple quotes. */
+const MULTILINE_DELIMS = ['`', '"""', "'''"];
+/**
+ * Blank the INTERIOR of multi-line strings, preserving line count and numbering.
+ *
+ * Every per-line rule (magic numbers, selectors, flakiness) sees one line at a
+ * time, so a line inside a multi-line template literal or a Python
+ * triple-quoted block reads as bare code. Canary's own diff fixtures are
+ * template literals, so `100644` -- a git file mode sitting in test DATA -- was
+ * reported as a magic number 30 times. Any consumer with a multi-line SQL,
+ * JSON, HTML, or diff fixture has the same defect.
+ *
+ * Deliberately conservative about an UNBALANCED delimiter (a stray backtick in
+ * a comment, say): blanking to end-of-file would silently disable these rules
+ * from that point down -- the abstention shape, one layer inside the linter. An
+ * unclosed run is therefore discarded rather than applied.
+ */
+function blankMultilineStrings(lines) {
+    const out = [...lines];
+    for (const delim of MULTILINE_DELIMS) {
+        let openAt = null;
+        for (let i = 0; i < out.length; i += 1) {
+            const hits = out[i].split(delim).length - 1;
+            // An even count opens and closes on the same line, which the single-line
+            // stripper already handles; only an odd count toggles the state.
+            if (hits === 0 || hits % 2 === 0)
+                continue;
+            if (openAt === null) {
+                openAt = i;
+            }
+            else {
+                for (let j = openAt + 1; j < i; j += 1)
+                    out[j] = '';
+                openAt = null;
+            }
+        }
+    }
+    return out;
+}
 function scanMagicNumbers(lines, file) {
     const out = [];
     lines.forEach((raw, idx) => {
         if (isComment(raw))
             return;
         const scrubbed = raw.replace(STRING_LITERAL, '""');
+        // Only timing positions: everywhere else in a test file the literal is the
+        // specification, not a smell. See TIMING_CONTEXT above.
+        if (!TIMING_CONTEXT.test(scrubbed))
+            return;
         for (const m of scrubbed.matchAll(NUMERIC_LITERAL)) {
             if (isAllowedNumber(m[0]))
                 continue;
-            out.push(mk(file, idx + 1, 'LINT-005', 'info', `Magic number ${m[0]}.`, 'Extract to a named constant or derive from test data.'));
+            out.push(mk(file, idx + 1, 'LINT-005', 'info', `Magic timing value ${m[0]}.`, 'Name the duration (e.g. RETRY_DELAY_MS) so its units and intent are readable.'));
             break; // one finding per line
         }
     });
@@ -185,40 +278,99 @@ function scanAssertionFreePy(code, file) {
 }
 function scanAssertionFreeJs(code, file) {
     const out = [];
-    for (const m of code.matchAll(TEST_FN_JS)) {
+    // 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
+    // "next `def` at the same indent".
+    //
+    // This replaces a fixed 2000-character lookahead that was wrong in BOTH
+    // directions: a long test whose first assertion fell past the window was
+    // flagged (false positive), and a short empty test could borrow the next
+    // test's assertion from inside the window (false negative). Neither failure
+    // is visible without a real codebase to run it against, which is why
+    // dogfooding found them and the unit tests did not.
+    const decls = [...code.matchAll(TEST_FN_JS)];
+    for (let i = 0; i < decls.length; i += 1) {
+        const m = decls[i];
         const start = m.index;
-        const rest = code.slice(start + m[0].length, start + m[0].length + 2000);
+        const bodyStart = start + m[0].length;
+        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.'));
         }
     }
     return out;
 }
-function detectFramework(path) {
+/**
+ * Extensions whose contents the JS/TS scanners can actually read. ESM (`.mjs`)
+ * and CJS (`.cjs`) belong here as much as `.js` does -- omitting them is what
+ * made #566 possible.
+ */
+export const JS_TEST_EXTENSIONS = [
+    '.ts',
+    '.js',
+    '.mjs',
+    '.cjs',
+    '.mts',
+    '.cts',
+];
+const JS_EXT_SET = new Set(JS_TEST_EXTENSIONS);
+/**
+ * The framework whose scanners can parse `path`, or `null` when no scanner
+ * understands the extension.
+ *
+ * This deliberately has no default. The previous `return 'pytest'` fallback
+ * meant an unrecognised extension was silently handed to the Python assertion
+ * scanners: over ESM JavaScript they match nothing, so a `.mjs` file with real
+ * defects linted to zero findings and rendered a green all-clear (#566). A
+ * guess that cannot be distinguished from a clean result is a false green;
+ * `null` forces the caller to abstain instead.
+ */
+export function lintableFramework(path) {
     const suffix = extname(path).toLowerCase();
     const name = basename(path).toLowerCase();
     if (suffix === '.py')
         return 'pytest';
     if (name.includes('playwright'))
         return 'playwright';
-    if (suffix === '.ts' || suffix === '.js')
+    if (JS_EXT_SET.has(suffix))
         return 'vitest';
-    return 'pytest';
+    return null;
+}
+/** Thrown when a scanner is asked for a file no ruleset can parse. */
+export class UnsupportedTestFileError extends Error {
+    path;
+    constructor(path) {
+        super(`No linter ruleset can parse ${extname(path) || basename(path)}`);
+        this.path = path;
+        this.name = 'UnsupportedTestFileError';
+    }
+}
+function requireFramework(path, framework) {
+    const fw = framework || lintableFramework(path);
+    if (fw === null)
+        throw new UnsupportedTestFileError(path);
+    return fw;
 }
 export class StaticLinter {
     /** Full quality audit — all rules. */
     lint(path, framework) {
         const code = readFileSync(path, 'utf-8');
-        const lines = code.split('\n');
-        const fw = framework || detectFramework(path);
+        // 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.
+        const lines = blankMultilineStrings(code.split('\n'));
+        const scanned = lines.join('\n');
+        const fw = requireFramework(path, framework);
         const findings = [
             ...scanFlakiness(lines, path),
             ...scanSelectors(lines, path),
             ...scanMissingAwait(lines, path),
             ...scanMagicNumbers(lines, path),
             ...(fw === 'pytest'
-                ? scanAssertionFreePy(code, path)
-                : scanAssertionFreeJs(code, path)),
+                ? scanAssertionFreePy(scanned, path)
+                : scanAssertionFreeJs(scanned, path)),
         ];
         findings.sort((a, b) => a.line - b.line || cmp(a.rule, b.rule));
         return findings;
@@ -226,7 +378,7 @@ export class StaticLinter {
     /** Flakiness-only subset. */
     flakeCheck(path) {
         const code = readFileSync(path, 'utf-8');
-        const findings = scanFlakiness(code.split('\n'), path);
+        const findings = scanFlakiness(blankMultilineStrings(code.split('\n')), path);
         findings.sort((a, b) => a.line - b.line);
         return findings;
     }

package/dist/engine/guardian/adjudication.js

@@ -33,14 +33,21 @@ import { mkdirSync, readFileSync, readdirSync, renameSync, statSync, unlinkSync,
 import { randomBytes } from 'node:crypto';
 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';
 /**
  * Record `source` + filename prefix. Deliberately namespaced UNDER the
- * `canary-pr-guardian-` prefix (harness's `AnalysisArchive` reads every
- * `*.json` in `.harness/analyses/`) while never colliding with a pr-check
- * findings record: those are `canary-pr-guardian-<sanitized-ref>.json` and a
- * ref is sanitized from a git ref / `pr-<n>`, never `adjudication-pr-<n>`.
+ * `canary-pr-guardian-` prefix, because harness's `AnalysisArchive` reads every
+ * `*.json` in `.harness/analyses/`.
+ *
+ * The filenames are not provably distinct, though: a branch named
+ * `adjudication/pr-42` sanitizes through `analysisFilename` to exactly
+ * `canary-pr-guardian-adjudication-pr-42.json`, colliding with this prefix.
+ * What actually keeps the precision summary honest is the `source` field —
+ * `loadAdjudicationRecords` requires `source === ADJUDICATION_SOURCE` plus
+ * numeric `tp`/`fp`, so a findings record landing on that name is skipped, not
+ * mis-tallied. Read the field, never the filename.
  */
 export const ADJUDICATION_SOURCE = 'canary-pr-guardian-adjudication';
 /** GitHub reaction contents that carry an adjudication verdict. */
@@ -68,44 +75,35 @@ export class FakeReactionsClient {
 }
 /**
  * Thin real {@link ReactionsClient} over the GitHub REST API (`fetch`).
- * Network lives ONLY here; no unit test exercises this class. Both endpoints
- * are reads, so a fork's read-only token is sufficient.
+ * Network lives ONLY in the default {@link restPageReader}; both endpoints are
+ * reads, so a fork's read-only token is sufficient. The `read` seam exists so
+ * the #528 paging wiring is testable without a socket — production callers
+ * construct this with three arguments and get the real reader.
  */
 export class RestReactionsClient {
     repo;
     prNumber;
-    token;
     static API = 'https://api.github.com';
-    constructor(repo, prNumber, token) {
+    read;
+    constructor(repo, prNumber, token, read) {
         this.repo = repo;
         this.prNumber = prNumber;
-        this.token = token;
-    }
-    async get(url) {
-        const resp = await fetch(url, {
-            method: 'GET',
-            headers: {
-                Authorization: `Bearer ${this.token}`,
-                Accept: 'application/vnd.github+json',
-                'X-GitHub-Api-Version': '2022-11-28',
-                'User-Agent': 'canary-pr-guardian',
-            },
-        });
-        if (!resp.ok) {
-            throw new Error(`GitHub API ${resp.status}: ${url}`);
-        }
-        return resp.json();
+        this.read =
+            read ??
+                restPageReader({
+                    Authorization: `Bearer ${token}`,
+                    Accept: 'application/vnd.github+json',
+                    'X-GitHub-Api-Version': '2022-11-28',
+                    'User-Agent': 'canary-pr-guardian',
+                }, (status, url) => new Error(`GitHub API ${status}: ${url}`));
     }
     async listComments() {
         const url = `${RestReactionsClient.API}/repos/${this.repo}/issues/${this.prNumber}/comments`;
-        const result = await this.get(url);
-        return Array.isArray(result) ? result : [];
+        return (await readAllPages(url, this.read));
     }
     async listReactions(commentId) {
         const url = `${RestReactionsClient.API}/repos/${this.repo}/issues/comments/${commentId}/reactions`;
-        const result = await this.get(url);
-        if (!Array.isArray(result))
-            return [];
+        const result = await readAllPages(url, this.read);
         const rows = [];
         for (const raw of result) {
             if (typeof raw !== 'object' || raw === null)
@@ -155,7 +153,13 @@ export function tallyAdjudications(reactions) {
 // neither of which starts with a backtick, so anchoring on the second cell's
 // leading backtick selects exactly the finding rows. Paths never contain `|`
 // or backticks (see `fileLabel` in pr-check.ts), so the naive anchor is safe.
-const FINDING_ROW_RE = /^\|[^|]*\|\s*`([^`]+)`/;
+//
+// The optional `[` accommodates the permalinked cell — `fileLabel` wraps the
+// path as `[`path`](<blob url>)` whenever a blob base is resolvable, which is
+// the normal case in CI. Without it this regex matched nothing on every posted
+// comment and `activeFindingPaths` returned `[]`, zeroing the precision
+// denominator silently instead of failing (#490, #508).
+const FINDING_ROW_RE = /^\|[^|]*\|\s*\[?`([^`]+)`/;
 /**
  * Extract the file paths of the ACTIVE findings shown in a sticky-comment body
  * (PURE). Reads the rendered table `render(fmt='comment')` emitted — this is

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

@@ -34,8 +34,10 @@
 import { createHash, randomBytes } from 'node:crypto';
 import { mkdirSync, renameSync, statSync, unlinkSync, writeFileSync, } from 'node:fs';
 import { dirname, join } from 'node:path';
-import { render } from './pr-check.js';
-export const SCHEMA_VERSION = '1.0';
+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';
 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
@@ -94,7 +96,11 @@ function isoUtcNow() {
  */
 export function buildAnalysisRecord(findings, args) {
     const { ref, gate, effective_tier, degraded_notice, exit_code } = args;
-    const inner = JSON.parse(render(findings, 'json', effective_tier, degraded_notice));
+    // #554: the record states BOTH degradations — the tier's and the coverage
+    // input's — so "no findings" can never be read as "coverage said so".
+    const coverage = args.coverage ?? null;
+    const notice = combineNotices(degraded_notice, coverage ? coverageDegradedNotice(coverage) : null);
+    const inner = JSON.parse(render(findings, 'json', effective_tier, notice));
     const active = findings.filter((f) => !f.suppressed);
     const suppressed = findings.filter((f) => f.suppressed);
     const byFidelity = {};
@@ -110,7 +116,10 @@ export function buildAnalysisRecord(findings, args) {
         checked: args.checked ?? 0,
         abstained: args.abstained ?? false,
         tier: effective_tier,
-        degradedNotice: degraded_notice,
+        degradedNotice: notice,
+        coverage: coverage === null
+            ? null
+            : { status: coverageStatus(coverage), ...coverage },
         summary: {
             total: findings.length,
             unaddressed: active.length,