plumbbob 0.9.3 → 0.10.0

package/node_modules/checkride/dist/artifacts/summary.d.ts

@@ -0,0 +1,69 @@
+/**
+ * The `.check/summary.json` read — the one place either reader parses it.
+ *
+ * The summary is checkride's promised index: `schema_version`-ed, additive-only,
+ * deterministically ordered and crash-consistent. This module turns it into a
+ * five-state result rather than a value-or-throw, because every failure mode is
+ * something a reader has to *report* — a missing summary means the gate never
+ * wrote one, and a `schema_version` this reader does not understand means stop,
+ * not guess.
+ *
+ * `foreign` and `schema-mismatch` are deliberately separate states even though
+ * both end in "this reader cannot use the file". An absent `schema_version` is
+ * evidence the file was not written by checkride at all — a repo whose gate is
+ * a homegrown script that happens to write `.check/` — and the honest report
+ * there is "your gate is not checkride", not "STOP, version boundary". A
+ * `schema_version` of 2 is the opposite case: checkride wrote it, and a newer
+ * one, so guessing across the boundary is what has to stop.
+ *
+ * Validation here is deliberately structural, not schematic: the full JSON
+ * Schema lives in `schema/checkride.summary.schema.json` and is the engine's
+ * job. All this needs is enough narrowing that the fields the readers touch are
+ * the types they claim to be, with no cast onto unvalidated bytes.
+ *
+ * The `../artifacts` barrel is this module's only public surface.
+ */
+import type { Summary } from '../orchestrator.js';
+/** The gitignored directory every run writes its artifacts into. */
+export declare const CHECK_DIR = ".check";
+/**
+ * The only `schema_version` these readers understand.
+ *
+ * Deliberately a literal, not the engine's `SCHEMA_VERSION` import: the
+ * additive-only guarantee holds *within* a version and promises nothing across
+ * one, so a bump has to stop the reader loudly rather than be silently
+ * followed. `artifacts.test.ts` asserts this equals the engine's constant, so a
+ * future bump turns a test red — a deliberate update, never a quiet change of
+ * behavior.
+ */
+export declare const SUPPORTED_SCHEMA_VERSION = 1;
+/** The outcome of reading `.check/summary.json`. Every state is reportable. */
+export type SummaryRead = {
+    state: 'ok';
+    path: string;
+    mtimeMs: number;
+    summary: Summary;
+}
+/** A JSON object with no `schema_version` at all — not checkride's file. */
+ | {
+    state: 'foreign';
+    path: string;
+    mtimeMs: number;
+} | {
+    state: 'schema-mismatch';
+    path: string;
+    mtimeMs: number;
+    found: unknown;
+} | {
+    state: 'unreadable';
+    path: string;
+    detail: string;
+} | {
+    state: 'missing';
+    path: string;
+};
+/** Classify already-read bytes. Split out so tests can drive every state. */
+export declare function parseSummary(raw: string, path: string, mtimeMs: number): SummaryRead;
+/** Read and classify `<cwd>/.check/summary.json`. Never throws. */
+export declare function readSummary(cwd: string): Promise<SummaryRead>;
+//# sourceMappingURL=summary.d.ts.map

package/node_modules/checkride/dist/artifacts/summary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"summary.d.ts","sourceRoot":"","sources":["../../src/artifacts/summary.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAKH,OAAO,KAAK,EAAE,OAAO,EAAgB,MAAM,oBAAoB,CAAC;AAIhE,oEAAoE;AACpE,eAAO,MAAM,SAAS,WAAW,CAAC;AAKlC;;;;;;;;;GASG;AACH,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAE1C,+EAA+E;AAC/E,MAAM,MAAM,WAAW,GACnB;IAAE,KAAK,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE;AAClE,4EAA4E;GAC1E;IAAE,KAAK,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACnD;IAAE,KAAK,EAAE,iBAAiB,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,GAC3E;IAAE,KAAK,EAAE,YAAY,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACrD;IAAE,KAAK,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AA8CvC,6EAA6E;AAC7E,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,WAAW,CAcpF;AAED,mEAAmE;AACnE,wBAAsB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAQnE"}

package/node_modules/checkride/dist/artifacts/summary.js

@@ -0,0 +1,108 @@
+/**
+ * The `.check/summary.json` read — the one place either reader parses it.
+ *
+ * The summary is checkride's promised index: `schema_version`-ed, additive-only,
+ * deterministically ordered and crash-consistent. This module turns it into a
+ * five-state result rather than a value-or-throw, because every failure mode is
+ * something a reader has to *report* — a missing summary means the gate never
+ * wrote one, and a `schema_version` this reader does not understand means stop,
+ * not guess.
+ *
+ * `foreign` and `schema-mismatch` are deliberately separate states even though
+ * both end in "this reader cannot use the file". An absent `schema_version` is
+ * evidence the file was not written by checkride at all — a repo whose gate is
+ * a homegrown script that happens to write `.check/` — and the honest report
+ * there is "your gate is not checkride", not "STOP, version boundary". A
+ * `schema_version` of 2 is the opposite case: checkride wrote it, and a newer
+ * one, so guessing across the boundary is what has to stop.
+ *
+ * Validation here is deliberately structural, not schematic: the full JSON
+ * Schema lives in `schema/checkride.summary.schema.json` and is the engine's
+ * job. All this needs is enough narrowing that the fields the readers touch are
+ * the types they claim to be, with no cast onto unvalidated bytes.
+ *
+ * The `../artifacts` barrel is this module's only public surface.
+ */
+import { readFile, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { isRecord, parseJson } from './json.js';
+/** The gitignored directory every run writes its artifacts into. */
+export const CHECK_DIR = '.check';
+/** The aggregate report, beside the raw artifacts under {@link CHECK_DIR}. */
+const SUMMARY_FILE = 'summary.json';
+/**
+ * The only `schema_version` these readers understand.
+ *
+ * Deliberately a literal, not the engine's `SCHEMA_VERSION` import: the
+ * additive-only guarantee holds *within* a version and promises nothing across
+ * one, so a bump has to stop the reader loudly rather than be silently
+ * followed. `artifacts.test.ts` asserts this equals the engine's constant, so a
+ * future bump turns a test red — a deliberate update, never a quiet change of
+ * behavior.
+ */
+export const SUPPORTED_SCHEMA_VERSION = 1;
+/**
+ * Name, adapter and description are present and the right type. Bracket access
+ * throughout: these are unvalidated bytes, and reading them as a dynamic record
+ * is what they are.
+ */
+function hasCheckIdentity(value) {
+    return (typeof value['name'] === 'string' &&
+        typeof value['description'] === 'string' &&
+        (typeof value['adapter'] === 'string' || value['adapter'] === null));
+}
+/** The result fields the readers render are present and the right type. */
+function hasCheckOutcome(value) {
+    return (typeof value['ok'] === 'boolean' &&
+        typeof value['duration_ms'] === 'number' &&
+        (typeof value['exit_code'] === 'number' || value['exit_code'] === null) &&
+        (typeof value['output_file'] === 'string' || value['output_file'] === null));
+}
+/**
+ * One `checks[]` entry. The optional additive fields (`skipped`, `reason`,
+ * `baselined`) are read through `??` at the point of use, so they need no guard.
+ */
+function isCheck(value) {
+    return isRecord(value) && hasCheckIdentity(value) && hasCheckOutcome(value);
+}
+/** Every required top-level field, and a well-formed `checks[]`. */
+function isSummary(value) {
+    const checks = value['checks'];
+    return (typeof value['timestamp'] === 'string' &&
+        typeof value['ok'] === 'boolean' &&
+        typeof value['checks_run'] === 'number' &&
+        typeof value['total_duration_ms'] === 'number' &&
+        Array.isArray(checks) &&
+        checks.every(isCheck));
+}
+/** Classify already-read bytes. Split out so tests can drive every state. */
+export function parseSummary(raw, path, mtimeMs) {
+    const value = parseJson(raw);
+    if (!isRecord(value))
+        return { state: 'unreadable', path, detail: 'not a JSON object' };
+    // Provenance first, then version: a summary this reader cannot read is a
+    // whose-file-is-this problem or a version problem, not a shape problem, even
+    // when its other fields also fail to narrow. Key presence rather than value,
+    // so an explicit `"schema_version": null` stays a mismatch — a malformed
+    // checkride summary — instead of being read as a stranger's file.
+    if (!('schema_version' in value))
+        return { state: 'foreign', path, mtimeMs };
+    if (value['schema_version'] !== SUPPORTED_SCHEMA_VERSION) {
+        return { state: 'schema-mismatch', path, mtimeMs, found: value['schema_version'] };
+    }
+    if (!isSummary(value))
+        return { state: 'unreadable', path, detail: 'missing or mistyped required field(s)' };
+    return { state: 'ok', path, mtimeMs, summary: value };
+}
+/** Read and classify `<cwd>/.check/summary.json`. Never throws. */
+export async function readSummary(cwd) {
+    const path = join(cwd, CHECK_DIR, SUMMARY_FILE);
+    try {
+        const [stats, raw] = await Promise.all([stat(path), readFile(path, 'utf8')]);
+        return parseSummary(raw, path, stats.mtimeMs);
+    }
+    catch {
+        return { state: 'missing', path };
+    }
+}
+//# sourceMappingURL=summary.js.map

package/node_modules/checkride/dist/artifacts/summary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"summary.js","sourceRoot":"","sources":["../../src/artifacts/summary.ts"],"names":[],"mappings":"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"}

package/node_modules/checkride/dist/atomic.d.ts

@@ -8,6 +8,21 @@
  * version or the new complete version — `rename(2)` is atomic within a
  * directory — never torn.
  */
-/** Write `data` to `path` atomically: temp sibling first, then rename over. */
+/**
+ * Write `data` to `path` atomically: temp sibling, flushed to disk, then
+ * renamed over.
+ *
+ * The `fsync` before the rename is what makes the promise above true rather
+ * than nearly true. `rename(2)` is atomic for the *name*, but a write that is
+ * still sitting in the page cache when the machine loses power can leave the
+ * renamed inode holding nothing — the reader then finds a file that exists and
+ * is empty, which is the torn read this exists to prevent, just relocated.
+ *
+ * The containing directory is deliberately not synced. Without that, the
+ * rename itself may not survive a crash — but the reader then sees the
+ * *previous complete version*, which is exactly what is promised. Paying a
+ * second fsync per artifact to also guarantee which of the two you get is not
+ * worth it for a report that the next run rewrites anyway.
+ */
 export declare function writeFileAtomic(path: string, data: string): Promise<void>;
 //# sourceMappingURL=atomic.d.ts.map

package/node_modules/checkride/dist/atomic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"atomic.d.ts","sourceRoot":"","sources":["../src/atomic.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,+EAA+E;AAC/E,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAS/E"}
+{"version":3,"file":"atomic.d.ts","sourceRoot":"","sources":["../src/atomic.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAe/E"}

package/node_modules/checkride/dist/atomic.js

@@ -8,12 +8,34 @@
  * version or the new complete version — `rename(2)` is atomic within a
  * directory — never torn.
  */
-import { rename, rm, writeFile } from 'node:fs/promises';
-/** Write `data` to `path` atomically: temp sibling first, then rename over. */
+import { open, rename, rm } from 'node:fs/promises';
+/**
+ * Write `data` to `path` atomically: temp sibling, flushed to disk, then
+ * renamed over.
+ *
+ * The `fsync` before the rename is what makes the promise above true rather
+ * than nearly true. `rename(2)` is atomic for the *name*, but a write that is
+ * still sitting in the page cache when the machine loses power can leave the
+ * renamed inode holding nothing — the reader then finds a file that exists and
+ * is empty, which is the torn read this exists to prevent, just relocated.
+ *
+ * The containing directory is deliberately not synced. Without that, the
+ * rename itself may not survive a crash — but the reader then sees the
+ * *previous complete version*, which is exactly what is promised. Paying a
+ * second fsync per artifact to also guarantee which of the two you get is not
+ * worth it for a report that the next run rewrites anyway.
+ */
 export async function writeFileAtomic(path, data) {
     const tmp = `${path}.${process.pid}.tmp`;
     try {
-        await writeFile(tmp, data);
+        const handle = await open(tmp, 'w');
+        try {
+            await handle.writeFile(data);
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
         await rename(tmp, path);
     }
     catch (err) {

package/node_modules/checkride/dist/atomic.js.map

@@ -1 +1 @@
-{"version":3,"file":"atomic.js","sourceRoot":"","sources":["../src/atomic.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAEzD,+EAA+E;AAC/E,MAAM,CAAC,KAAK,UAAU,eAAe,CAAC,IAAY,EAAE,IAAY;IAC9D,MAAM,GAAG,GAAG,GAAG,IAAI,IAAI,OAAO,CAAC,GAAG,MAAM,CAAC;IACzC,IAAI,CAAC;QACH,MAAM,SAAS,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;QAC3B,MAAM,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;IAC1B,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,EAAE,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;QAC/B,MAAM,GAAG,CAAC;IACZ,CAAC;AACH,CAAC"}
+{"version":3,"file":"atomic.js","sourceRoot":"","sources":["../src/atomic.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AAEpD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CAAC,IAAY,EAAE,IAAY;IAC9D,MAAM,GAAG,GAAG,GAAG,IAAI,IAAI,OAAO,CAAC,GAAG,MAAM,CAAC;IACzC,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;QACpC,IAAI,CAAC;YACH,MAAM,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;YAC7B,MAAM,MAAM,CAAC,IAAI,EAAE,CAAC;QACtB,CAAC;gBAAS,CAAC;YACT,MAAM,MAAM,CAAC,KAAK,EAAE,CAAC;QACvB,CAAC;QACD,MAAM,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;IAC1B,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,EAAE,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;QAC/B,MAAM,GAAG,CAAC;IACZ,CAAC;AACH,CAAC"}

package/node_modules/checkride/dist/baseline/fallow.d.ts

@@ -22,7 +22,7 @@
  */
 import type { Fingerprint } from './fingerprint.js';
 /**
- * Fallow's fingerprint extractor (baseline part 1), for the extractor registry.
+ * Fallow's fingerprint extractor, for the extractor registry.
  * Returns the finding keys for a recognized, readable report and an empty set
  * for anything else — the "never throw, empty on malformed" contract every
  * extractor honours. The *gating* verdict (`fallowVerdict`) is where an
@@ -55,10 +55,14 @@ export type FallowVerdict = {
  * fallow found anything. With a baseline, findings are masked — the slot passes
  * when every current finding is grandfathered and fails on any new one.
  *
- * A report that parses to *fewer* fingerprints than its issue count has findings
- * that can't be individually grandfathered; a baseline must never mask such a
- * slot to green, so it stays at the raw findings-based verdict. Correctness over
- * precision: better to keep re-surfacing a finding than to silently pass one.
+ * A report whose keys don't map one-per-finding onto its issue count — an
+ * un-keyable finding, or a key produced for something the count doesn't include
+ * — has findings that can't be individually grandfathered; a baseline must never
+ * mask such a slot to green, so it stays at the raw findings-based verdict. A key
+ * *collision* (two findings sharing a key) is not un-keyable — both are keyed, so
+ * the baseline coarsens (grandfathering one grandfathers both) but stays active.
+ * Correctness over precision: better to keep re-surfacing a finding than to
+ * silently pass one.
  */
 export declare function fallowVerdict(raw: string, baselineKeys: readonly string[] | null): FallowVerdict;
 //# sourceMappingURL=fallow.d.ts.map

package/node_modules/checkride/dist/baseline/fallow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fallow.d.ts","sourceRoot":"","sources":["../../src/baseline/fallow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAmMpD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CAGvD;AAED,gFAAgF;AAChF,MAAM,MAAM,aAAa,GAAG;IAC1B,2CAA2C;IAC3C,EAAE,EAAE,OAAO,CAAC;IACZ,2EAA2E;IAC3E,SAAS,EAAE,MAAM,CAAC;IAClB,2DAA2D;IAC3D,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,gEAAgE;IAChE,QAAQ,EAAE,WAAW,CAAC;IACtB;;;;OAIG;IACH,QAAQ,EAAE,OAAO,CAAC;IAClB,4EAA4E;IAC5E,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,YAAY,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,GAAG,aAAa,CAuBhG"}
+{"version":3,"file":"fallow.d.ts","sourceRoot":"","sources":["../../src/baseline/fallow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAgTpD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CAGvD;AAED,gFAAgF;AAChF,MAAM,MAAM,aAAa,GAAG;IAC1B,2CAA2C;IAC3C,EAAE,EAAE,OAAO,CAAC;IACZ,2EAA2E;IAC3E,SAAS,EAAE,MAAM,CAAC;IAClB,2DAA2D;IAC3D,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,gEAAgE;IAChE,QAAQ,EAAE,WAAW,CAAC;IACtB;;;;OAIG;IACH,QAAQ,EAAE,OAAO,CAAC;IAClB,4EAA4E;IAC5E,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,YAAY,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,GAAG,aAAa,CA0BhG"}

package/node_modules/checkride/dist/baseline/fallow.js

@@ -20,12 +20,14 @@
  * schema 4 with a different layout and is no longer supported). Each analysis
  * kind has its own layout, so parsing dispatches on the top-level `kind`.
  */
+import { parseToolJson } from '../tool-json.js';
 import { applyBaseline } from './store.js';
 /**
- * Minimum fallow JSON schema version checkride understands. fallow 3.5.0 and
- * 3.6.0 both emit schema_version 7; 2.x emitted 4 with an incompatible layout.
- * A report below this floor — or one whose kind/shape we can't read — is a
- * hard failure, never a silent pass.
+ * Minimum fallow JSON schema version checkride understands. Every fallow from
+ * 3.5.0 through 3.9.1 emits schema_version 7 (verified: dead-code, dupes, and
+ * health all report 7, with identical top-level layouts); 2.x emitted 4 with an
+ * incompatible layout. A report below this floor — or one whose kind/shape we
+ * can't read — is a hard failure, never a silent pass.
  */
 const FALLOW_SCHEMA_MIN = 7;
 /** Narrow to a plain object (arrays and null excluded). */
@@ -37,32 +39,74 @@ function str(value) {
     return typeof value === 'string' ? value.trim() : '';
 }
 /**
- * Fingerprint key for one dead-code finding: `dead-code:<category>:<identity>`,
- * where identity is a file and/or symbol (never a line or column, so the key
- * survives edits that only move the code). Cross-file findings (cycles) key on
- * the sorted set of files. Returns `null` when no stable identity can be read —
- * the finding still counts toward `issueCount`, it just can't be individually
- * grandfathered (which keeps the slot conservatively red, never silently green).
+ * Fields naming the declaration that owns a member-scoped finding, in priority
+ * order. fallow reports an unused class/enum/store member as `parent_name` +
+ * `member_name`, a component binding as `component_name` + `prop_name` /
+ * `input_name` / `output_name` / `emit_name` / `event_name`, and a catalog entry
+ * as `catalog_name` + `entry_name`. Both halves are needed: the leaf alone is
+ * ambiguous (two classes in one file can each have a `render`), and the
+ * container alone collapses every member of one declaration onto one key.
  */
-/** Finding fields that carry a single stable symbol identity, in priority order. */
+const CONTAINER_FIELDS = ['parent_name', 'component_name', 'catalog_name'];
+/** Finding fields that carry a stable leaf symbol, in priority order. */
 const SYMBOL_FIELDS = [
     'export_name',
     'name',
     'type_name',
     'member',
+    'member_name',
+    'prop_name',
+    'emit_name',
+    'input_name',
+    'output_name',
+    'event_name',
+    'entry_name',
+    'action_name',
+    'key_name',
     'package_name',
     'dependency',
     'specifier',
 ];
-/** The first non-empty symbol field on a finding, or `''` when none is present. */
-function symbolIdentity(item) {
-    for (const field of SYMBOL_FIELDS) {
+/** The first non-empty field of `fields` on a finding, or `''` when none is set. */
+function firstField(item, fields) {
+    for (const field of fields) {
         const value = str(item[field]);
         if (value)
             return value;
     }
     return '';
 }
+/**
+ * A finding's stable symbol identity: `<container>.<leaf>` when it carries both
+ * (`Svc.unusedOne`), otherwise whichever half it has, otherwise `''`. Composing
+ * the two is what keeps a member-scoped finding line-free — with neither half
+ * recognized such a finding has no symbol at all and falls back to
+ * `<path>:<line>:<col>`, a key that moves whenever code above it does, so a
+ * grandfathered finding resurfaces as new on the next unrelated edit.
+ */
+function symbolIdentity(item) {
+    return [firstField(item, CONTAINER_FIELDS), firstField(item, SYMBOL_FIELDS)].filter(Boolean).join('.');
+}
+/**
+ * A finding's `line[:col]` position, or `''` when it carries neither. Only used
+ * to disambiguate findings that share every stable identity field (see
+ * {@link withPosition}); a keyable finding never falls back to this.
+ */
+function position(item) {
+    return [item['line'], item['col']].filter((n) => typeof n === 'number').join(':');
+}
+/** Append `:<line>[:<col>]` to a key when the finding has a position, else leave it. */
+function withPosition(key, item) {
+    const pos = position(item);
+    return pos ? `${key}:${pos}` : key;
+}
+/**
+ * A function name that is a real, stable identifier (kept line-free so its key
+ * survives edits above it). Fallow wraps names it can't resolve to an identity
+ * in angle brackets (`<arrow>`, `<anonymous>`); those fail this test and get a
+ * position appended, since every such placeholder in a file is otherwise equal.
+ */
+const STABLE_IDENTIFIER = /^[A-Za-z_$][\w$.]*$/;
 /**
  * Key a cross-file finding (circular_dependencies, re_export_cycles) on its
  * sorted file membership — a list of files/segments rather than one location.
@@ -82,28 +126,78 @@ function cycleKey(category, item) {
     }
     return null;
 }
+/**
+ * Fingerprint key for one dead-code finding: `dead-code:<category>:<identity>`,
+ * where identity is a file and symbol (never a line or column, so the key
+ * survives edits that only move the code). When a finding has a file but no
+ * symbol — `stale_suppressions`, `policy_violations` and the boundary
+ * categories carry only a path — the path alone would collide with its siblings
+ * in the same file, so the position is appended to keep them distinct, at the
+ * cost of a key that moves. Cross-file findings (cycles) key on the
+ * sorted set of files. Returns `null` when no stable identity can be read — the
+ * finding still counts toward `issueCount`, it just can't be individually
+ * grandfathered (which keeps the slot conservatively red, never silently green).
+ */
 function deadKey(category, item) {
     if (!isPlainObject(item))
         return null;
     const file = str(item['path']) || str(item['file']);
     const symbol = symbolIdentity(item);
-    if (file || symbol) {
-        const identity = [file, symbol].filter(Boolean).join(':');
-        return `dead-code:${category}:${identity}`;
-    }
+    if (symbol)
+        return `dead-code:${category}:${[file, symbol].filter(Boolean).join(':')}`;
+    if (file)
+        return withPosition(`dead-code:${category}:${file}`, item);
     return cycleKey(category, item);
 }
+/**
+ * Top-level arrays that are NOT counted in `total_issues`, so keying them would
+ * push the key count past the issue count and leave the two out of step: the
+ * advisory `next_steps`, the project-level `workspace_diagnostics`, and the
+ * three opt-in "health signal" rules that fallow's own `issue-registry.json`
+ * marks `counts_in_total: false`. They have to be skipped by name rather than
+ * left to {@link deadKey} — `workspace_diagnostics` carries a `path`, and
+ * `thin_wrappers` and `duplicate_prop_shapes` a `file`, so all three key
+ * readily. Verified against fallow 3.9.1's registry; every other array counts.
+ */
+const UNCOUNTED_ARRAYS = new Set([
+    'next_steps',
+    'workspace_diagnostics',
+    'prop_drilling_chains',
+    'thin_wrappers',
+    'duplicate_prop_shapes',
+]);
+/**
+ * Key every counted finding in a dead-code report. Returns the keys — duplicates
+ * intact, so a collision stays visible to the caller's tracking check — and how
+ * many items carried no stable identity to key on.
+ */
+function collectDeadKeys(j) {
+    const keys = [];
+    let unkeyed = 0;
+    for (const [category, value] of Object.entries(j)) {
+        if (!Array.isArray(value) || UNCOUNTED_ARRAYS.has(category))
+            continue;
+        for (const item of value) {
+            const key = deadKey(category, item);
+            if (key === null)
+                unkeyed += 1;
+            else
+                keys.push(key);
+        }
+    }
+    return { keys, unkeyed };
+}
 /**
  * Extract dead-code findings and the authoritative issue count (`total_issues`).
  * Findings come from the top-level detail arrays (`unused_exports`,
  * `unused_dev_dependencies`, `circular_dependencies`, …) rather than the summary
- * keys: the summary aggregates a few categories under one name (e.g. dev and
+ * keys: the summary aggregates a few categories under one name (for example dev and
  * optional deps both count as `unused_dependencies`) whose items live in
- * separately-named arrays, so keying off the summary would miss them. Iterating
- * every array and letting {@link deadKey} return `null` for non-finding arrays
- * (`next_steps`) covers whatever categories fallow reports — including ones added
- * in a future minor — without a hand-maintained list. A category whose items
- * carry no stable identity simply isn't fingerprinted; it still counts toward
+ * separately named arrays, so keying off the summary would miss them. Iterating
+ * every array except the {@link UNCOUNTED_ARRAYS} covers whatever categories
+ * fallow reports — including ones added in a future minor — without a
+ * hand-maintained list of the ones that do count. A category whose items carry
+ * no stable identity simply isn't fingerprinted; it still counts toward
  * `total_issues`, so the slot stays red (never masked) until it's fixed.
  */
 function parseDeadCode(j) {
@@ -112,17 +206,17 @@ function parseDeadCode(j) {
     if (typeof total !== 'number') {
         return { ok: false, reason: 'fallow dead-code JSON missing summary.total_issues' };
     }
-    const findings = [];
-    for (const [category, value] of Object.entries(j)) {
-        if (!Array.isArray(value))
-            continue;
-        for (const item of value) {
-            const key = deadKey(category, item);
-            if (key !== null)
-                findings.push(key);
-        }
-    }
-    return { ok: true, kind: 'dead-code', findings, issueCount: total };
+    const { keys, unkeyed } = collectDeadKeys(j);
+    // Two independent ways the keys can fail to cover the findings, both required
+    // because either alone has a blind spot. Counting the items we could not key
+    // is direct and exact. Comparing against the authoritative `total` catches
+    // findings the iteration never reached at all (nothing to count) — and cannot
+    // be substituted for the direct count, because a key produced for something
+    // `total` omits would otherwise offset a real un-keyable finding back to zero.
+    // `keys.length` is taken BEFORE the Set collapses collisions, so a collision
+    // still reads as fully tracked.
+    const fullyTracked = unkeyed === 0 && keys.length === total;
+    return { ok: true, kind: 'dead-code', findings: keys, issueCount: total, fullyTracked };
 }
 /**
  * Extract duplication findings. Each clone group carries a content-hash
@@ -142,12 +236,14 @@ function parseDupes(j) {
         if (fp)
             findings.push(`dupes:${fp}`);
     }
-    return { ok: true, kind: 'dupes', findings, issueCount: groups.length };
+    return { ok: true, kind: 'dupes', findings, issueCount: groups.length, fullyTracked: findings.length === groups.length };
 }
 /**
  * Extract health (complexity) findings — one per function over threshold, keyed
- * on file + function name (no line, so the key survives edits above it). The
- * issue count is the number of findings.
+ * on file + function name. A named function stays line-free so its key survives
+ * edits above it; an anonymous placeholder (`<arrow>`, `<anonymous>`) shares its
+ * name with every sibling in the file, so it gets a position appended to stay
+ * distinct. The issue count is the number of findings.
  */
 function parseHealth(j) {
     const findings = j['findings'];
@@ -158,16 +254,12 @@ function parseHealth(j) {
     for (const f of findings) {
         if (!isPlainObject(f))
             continue;
-        keys.push(`health:${str(f['path'])}:${str(f['name'])}`);
+        const name = str(f['name']);
+        const base = `health:${str(f['path'])}:${name}`;
+        keys.push(STABLE_IDENTIFIER.test(name) ? base : withPosition(base, f));
     }
-    return { ok: true, kind: 'health', findings: keys, issueCount: findings.length };
+    return { ok: true, kind: 'health', findings: keys, issueCount: findings.length, fullyTracked: keys.length === findings.length };
 }
-/**
- * Parse a fallow report into findings + an issue count, or the reason it could
- * not be trusted. Every failure path (bad JSON, missing/old schema, unknown
- * kind, missing count field) is a *loud* failure the caller turns into a red
- * slot — checkride never treats an unreadable fallow report as "clean".
- */
 /**
  * The reason a report's schema can't be trusted, or `null` when it is a
  * supported version. Split out so {@link parseFallow} stays a thin dispatcher.
@@ -181,16 +273,20 @@ function fallowSchemaError(j) {
     }
     return null;
 }
+/**
+ * Parse a fallow report into findings + an issue count, or the reason it could
+ * not be trusted. Every failure path (bad JSON, missing/old schema, unknown
+ * kind, missing count field) is a *loud* failure the caller turns into a red
+ * slot — checkride never treats an unreadable fallow report as "clean".
+ */
 function parseFallow(raw) {
     if (raw.trim() === '')
         return { ok: false, reason: 'fallow produced no JSON output' };
-    let j;
-    try {
-        j = JSON.parse(raw);
-    }
-    catch {
+    // Tolerant of a launcher preamble ahead of the report — see `parseToolJson`.
+    const parsed = parseToolJson(raw);
+    if (!parsed)
         return { ok: false, reason: 'fallow did not emit valid JSON' };
-    }
+    const j = parsed.value;
     if (!isPlainObject(j))
         return { ok: false, reason: 'fallow output was not a JSON object' };
     const schemaError = fallowSchemaError(j);
@@ -209,7 +305,7 @@ function parseFallow(raw) {
     }
 }
 /**
- * Fallow's fingerprint extractor (baseline part 1), for the extractor registry.
+ * Fallow's fingerprint extractor, for the extractor registry.
  * Returns the finding keys for a recognized, readable report and an empty set
  * for anything else — the "never throw, empty on malformed" contract every
  * extractor honours. The *gating* verdict (`fallowVerdict`) is where an
@@ -226,10 +322,14 @@ export function fallowFindings(raw) {
  * fallow found anything. With a baseline, findings are masked — the slot passes
  * when every current finding is grandfathered and fails on any new one.
  *
- * A report that parses to *fewer* fingerprints than its issue count has findings
- * that can't be individually grandfathered; a baseline must never mask such a
- * slot to green, so it stays at the raw findings-based verdict. Correctness over
- * precision: better to keep re-surfacing a finding than to silently pass one.
+ * A report whose keys don't map one-per-finding onto its issue count — an
+ * un-keyable finding, or a key produced for something the count doesn't include
+ * — has findings that can't be individually grandfathered; a baseline must never
+ * mask such a slot to green, so it stays at the raw findings-based verdict. A key
+ * *collision* (two findings sharing a key) is not un-keyable — both are keyed, so
+ * the baseline coarsens (grandfathering one grandfathers both) but stays active.
+ * Correctness over precision: better to keep re-surfacing a finding than to
+ * silently pass one.
  */
 export function fallowVerdict(raw, baselineKeys) {
     const parsed = parseFallow(raw);
@@ -243,9 +343,12 @@ export function fallowVerdict(raw, baselineKeys) {
         return { ok: rawOk, baselined: 0, newKeys: [], findings, observed: true, reason: issueReason };
     }
     const adj = applyBaseline(findings, baselineKeys, rawOk);
-    const fullyTracked = findings.size === parsed.issueCount;
-    // Untracked findings block masking: hold the slot at its raw verdict.
-    if (!fullyTracked) {
+    // Findings the keys don't cover block masking: hold the slot at its raw
+    // verdict. A key collision does NOT (both findings are keyed, so the report
+    // stays fully tracked), so it coarsens the baseline instead of disabling it. A
+    // *deduplicated* size comparison could not tell the two apart, which is what
+    // disabled the whole slot on any collision.
+    if (!parsed.fullyTracked) {
         return { ok: rawOk, baselined: adj.baselined, newKeys: adj.newKeys, findings, observed: true, reason: issueReason };
     }
     // Fully tracked: a masked slot (all findings grandfathered) is green; a slot