@davesheffer/hunch 1.45.1 → 1.46.0

package/dist/core/procstart.d.ts

@@ -69,9 +69,9 @@ export declare const heldLockNonces: Set<string>;
  *  - `stale`    — provably not the owner's process any more: take it over.
  *  - `live`     — authoritative, however old the file looks: never steal it.
  *  - `unproven` — a live pid whose process instance no token can compare (macOS,
- *                 Windows, a legacy record). Treated as live; a caller with a
- *                 better probe may still disprove it (src/serve/writelock.ts
- *                 asks the OS when that process was created, issue #287).
+ *                 Windows, a legacy record). Treated as live unless
+ *                 `createdAfterLock` proves the pid reused (both locks ask the
+ *                 OS when that process was created, issues #287, #457).
  *  - `age`      — nothing is proven; fall back to the caller's own age rule. */
 export type SameHostVerdict = "stale" | "live" | "unproven" | "age";
 /** The parts of a lock record this decision reads. Both lock formats supply it. */
@@ -102,4 +102,18 @@ export declare function judgeSameHostOwner(owner: SameHostOwner, env: SameHostEn
  *  other platform: linux derives `lstart` from boot time, which a forward clock
  *  step shifts for live processes too (see the header). */
 export declare function processStartedAt(pid: number): number | null;
+/** How much later than the lock's recorded `at` the pid's current process must
+ *  have been created before it is proven not to be the owner. A genuine owner
+ *  started BEFORE it took the lock; the slack only absorbs clock granularity. */
+export declare const CREATED_AFTER_SLACK_MS = 5000;
+/** Is the process now holding the owner's pid provably newer than the lock?
+ *  The one rule both `src/serve/writelock.ts` and jsonStore's `.rmw-lock` apply
+ *  to an "unproven" verdict (issues #287, #457). Unreadable either way — no `at`
+ *  recorded (a legacy record), or no creation time from the OS — means not
+ *  proven, and a live pid keeps its lock. SPAWNS through `processStartedAt`, so
+ *  callers consult it only for a lock that already looks stale by age. */
+export declare function createdAfterLock(owner: {
+    pid: number;
+    at?: string;
+}, startedAt?: (pid: number) => number | null): boolean;
 export {};

package/dist/core/procstart.js

@@ -26,8 +26,9 @@
  * OFF LINUX (issue #287). Only linux exposes a spawn-free, stable process-instance
  * id (`/proc/<pid>/stat` field 22 plus the boot id and the pid/time namespaces), so
  * on macOS and Windows a DIFFERENT live process that recycled the owner's pid is
- * "unproven" here, which this table treats as live. The write lock closes that
- * forever-deadlock on its own rare path, once a lock already looks stale: it asks
+ * "unproven" here, which this table treats as live. Both locks close that
+ * forever-deadlock on their own rare path, once a lock already looks stale
+ * (`createdAfterLock`; the `.rmw-lock` since issue #457): they ask
  * the OS when the process now holding the pid was CREATED (`processStartedAt`, a
  * spawn) and compares that with the `at` the owner recorded when it took the lock.
  * A process created after the lock was taken cannot have taken it. Both instants
@@ -56,7 +57,7 @@
  * holder may judge itself against a token that no longer describes it. Tokenless
  * records (a legacy pre-token hunch, any non-linux writer, an unreadable /proc)
  * get main's unchanged pid rule — a live same-host pid keeps its lock (unless the
- * write lock's creation-time check above proves the pid reused), a dead one is
+ * creation-time check above proves the pid reused), a dead one is
  * stealable — with exactly one exception, the own-pid + foreign-nonce row
  * described in `judgeSameHostOwner`, which gets the AGE rule instead of main's
  * "live forever".
@@ -245,8 +246,9 @@ export function judgeSameHostOwner(owner, env) {
         return "age";
     // 7. A live pid no token can compare — another process's, or a nonce-less
     //    record of our own pid. Never stolen on a guess: "unproven" is "live" to a
-    //    caller that has nothing better. The write lock asks the OS for that
-    //    process's creation time, which can prove the pid was reused (issue #287).
+    //    caller that has nothing better. Both locks ask the OS for that process's
+    //    creation time (`createdAfterLock`), which can prove the pid was reused
+    //    (issues #287, #457).
     return "unproven";
 }
 /** Wall-clock ms at which the process now holding `pid` was created, from the
@@ -279,4 +281,23 @@ export function processStartedAt(pid) {
         return null;
     }
 }
+/** How much later than the lock's recorded `at` the pid's current process must
+ *  have been created before it is proven not to be the owner. A genuine owner
+ *  started BEFORE it took the lock; the slack only absorbs clock granularity. */
+export const CREATED_AFTER_SLACK_MS = 5_000;
+/** Is the process now holding the owner's pid provably newer than the lock?
+ *  The one rule both `src/serve/writelock.ts` and jsonStore's `.rmw-lock` apply
+ *  to an "unproven" verdict (issues #287, #457). Unreadable either way — no `at`
+ *  recorded (a legacy record), or no creation time from the OS — means not
+ *  proven, and a live pid keeps its lock. SPAWNS through `processStartedAt`, so
+ *  callers consult it only for a lock that already looks stale by age. */
+export function createdAfterLock(owner, startedAt = processStartedAt) {
+    if (owner.at === undefined)
+        return false;
+    const at = Date.parse(owner.at);
+    if (!Number.isFinite(at))
+        return false;
+    const started = startedAt(owner.pid);
+    return started !== null && started > at + CREATED_AFTER_SLACK_MS;
+}
 //# sourceMappingURL=procstart.js.map

package/dist/core/projectDna.js

@@ -81,7 +81,17 @@ function gitText(root, args) {
 function exactCommit(root, ref) {
     if (!ref.trim() || /[\0\r\n]/.test(ref) || ref.length > 1_024)
         throw new Error("Git revision is invalid");
-    const revision = gitText(root, ["rev-parse", "--verify", "--end-of-options", `${ref}^{commit}`]);
+    let revision;
+    try {
+        revision = gitText(root, ["rev-parse", "--verify", "--end-of-options", `${ref}^{commit}`]);
+    }
+    catch (error) {
+        // Git's own text ("fatal: Needed a single revision") never names the ref (#493);
+        // any other failure keeps its original message.
+        if (!/Needed a single revision|unknown revision|bad revision/i.test(error.message))
+            throw error;
+        throw new Error(`Git revision ${JSON.stringify(ref)} does not name a commit in this repository`);
+    }
     if (!GIT_OBJECT.test(revision))
         throw new Error("Git did not return an exact commit object");
     return revision;

package/dist/core/relativeImports.js

@@ -26,8 +26,12 @@ export function relativeImportCandidates(fromFile, specifier) {
  * indexer compatibility; callers that need ambiguity metadata can inspect the
  * returned matches instead of guessing a different target. */
 export function resolveRelativeImport(fromFile, specifier, availableFiles) {
-    const available = new Set(availableFiles);
-    const matches = relativeImportCandidates(fromFile, specifier).filter((candidate) => available.has(candidate));
+    // Bare/non-relative specifiers have no candidates: skip the O(N) file-set copy.
+    const candidates = relativeImportCandidates(fromFile, specifier);
+    if (candidates.length === 0)
+        return { path: null, matches: [] };
+    const available = availableFiles instanceof Set ? availableFiles : new Set(availableFiles);
+    const matches = candidates.filter((candidate) => available.has(candidate));
     return { path: matches[0] ?? null, matches };
 }
 //# sourceMappingURL=relativeImports.js.map

package/dist/core/taskSelection.d.ts

@@ -59,6 +59,7 @@ export declare function liveSelectionRecords(all: TaskSelectionRecords): TaskSel
  *  or `:start-end` and a possessive `'s`, forward-slashed, repo-relative. A drive-letter root compares
  *  case-insensitively (Windows paths are case-insensitive on every host). */
 export declare function promptPaths(prompt: string, root?: string): string[];
+export declare function identifierTokens(text: string): Set<string>;
 /** Score live records against one prompt. Text fields per kind (title + rationale):
  *  decision title/context/decision; bug title/symptom/root_cause; constraint
  *  statement/rationale; finding title/observation. Path anchors: decision

package/dist/core/taskSelection.js

@@ -142,6 +142,88 @@ export function promptPaths(prompt, root) {
     }
     return [...out];
 }
+const ID_PREFIX = "id:";
+const MIN_IDENTIFIER_CHARS = 5;
+const IDENTIFIER_WEIGHT = 2;
+const CAMEL_IDENTIFIER = /(?<![A-Za-z0-9])[A-Za-z0-9]*(?:[a-z][A-Z]|[A-Z]{2,}[a-z])[A-Za-z0-9]*/g;
+const SEPARATED_IDENTIFIER = /(?<![A-Za-z0-9])[A-Za-z][A-Za-z0-9]*(?:[_.\-][A-Za-z0-9]+)+/g;
+const isCompound = (word) => /[a-z][A-Z]|[A-Z]{2,}[a-z]|_/.test(word);
+const camelParts = (word) => word.split(/(?<=[a-z0-9])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])/).length;
+/** Compound identifiers in raw text (camel/Pascal, snake, dotted, kebab), lowercased with
+ *  separators removed and marked `id:` so they never collide with word tokens. A dotted
+ *  name also yields its last segment when that is itself compound (`dbo.ShowInForms` ->
+ *  `id:dboshowinforms`, `id:showinforms`). `lexicalTokens` splits these into common words
+ *  that the rare-term filter discards; the whole identifier is the rare, discriminating term.
+ *  STRONG identifiers (3+ camel parts, or `_`/`.` between alphanumerics) may qualify a record
+ *  alone; two-part camel words (GitHub, useEffect) are common prose and count as one word. */
+function scanIdentifiers(text) {
+    const out = new Map();
+    const add = (raw, strong) => {
+        const id = raw.replace(/[_.\-]/g, "").toLowerCase();
+        if (id.length >= MIN_IDENTIFIER_CHARS)
+            out.set(ID_PREFIX + id, (out.get(ID_PREFIX + id) ?? false) || strong);
+    };
+    for (const m of text.match(CAMEL_IDENTIFIER) ?? [])
+        add(m, camelParts(m) >= 3);
+    for (const m of text.match(SEPARATED_IDENTIFIER) ?? []) {
+        if (/^v?\d+(?:\.\d+)+/i.test(m))
+            continue; // version numbers
+        if (m.includes(".")) {
+            const last = m.slice(m.lastIndexOf(".") + 1);
+            if (/^[a-z0-9]{1,8}$/.test(last))
+                continue; // file extension: paths own those
+            add(m, true);
+            if (isCompound(last))
+                add(last, true);
+        }
+        else if (m.includes("_")) {
+            const parts = m.split(/[_\-]/);
+            if (m.replace(/[_\-]/g, "").length >= 6 && parts.some((part) => part.length >= 3))
+                add(m, true);
+        }
+        else if (/(?<!^|-)[A-Z0-9]/.test(m)) {
+            add(m, false); // kebab: a capital/digit past the first letter of a part; plain prose ("Pre-commit") is not an identifier
+        }
+    }
+    return out;
+}
+export function identifierTokens(text) {
+    return new Set(scanIdentifiers(text).keys());
+}
+/** Word -> the `id:` terms of the camel compounds the prompt splits it out of (PowerShell ->
+ *  power, shell; GitHubActions -> git, hub, actions), sorted so prompt word order never matters.
+ *  A word the prompt also uses on its own belongs to no compound. */
+function camelCompoundGroups(text) {
+    const groups = new Map();
+    const compounds = text.match(CAMEL_IDENTIFIER) ?? [];
+    if (!compounds.length)
+        return groups;
+    const standalone = lexicalTokens(text.replace(CAMEL_IDENTIFIER, " "));
+    for (const m of compounds) {
+        const key = ID_PREFIX + m.toLowerCase();
+        for (const word of lexicalTokens(m)) {
+            if (standalone.has(word))
+                continue;
+            const keys = groups.get(word) ?? [];
+            if (!keys.includes(key))
+                keys.push(key);
+            groups.set(word, keys.sort());
+        }
+    }
+    return groups;
+}
+/** A pasted stack frame: `at fn (file:line:col)`, `at file:line:col`, `at X (<anonymous>)`, `at X (node:...)`.
+ *  Prose that merely starts with "at" ("at startup the lock goes stale") has no such tail. */
+const FRAME_LINE = /^\s*at\s+\S+.*(?::\d+:\d+\)?|\(<anonymous>\)|\(node:[^)]*\))\s*$/;
+/** Text whose words count: every line, unless the prompt holds an actual trace (2+ frame
+ *  lines), whose frames name library internals (process, tick, sync), not the task. A Node
+ *  warning's `(node:<pid>)` prefix is noise either way; the words after it stay. */
+function promptWordText(prompt) {
+    const lines = prompt.split(/\r?\n/);
+    const trace = lines.filter((line) => FRAME_LINE.test(line)).length >= 2;
+    return (trace ? lines.filter((line) => !FRAME_LINE.test(line)) : lines).join("\n").replace(/\(node:\d+\)/g, " ");
+}
+const termTokens = (text) => new Set([...lexicalTokens(text), ...identifierTokens(text)]);
 /** Score live records against one prompt. Text fields per kind (title + rationale):
  *  decision title/context/decision; bug title/symptom/root_cause; constraint
  *  statement/rationale; finding title/observation. Path anchors: decision
@@ -149,7 +231,10 @@ export function promptPaths(prompt, root) {
  *  ties break on the builder profile's kind/severity score in delivery.ts. */
 export function selectForTask(records, promptText, opts = {}) {
     const k = Math.max(0, opts.k ?? DEFAULT_K);
-    const taskTerms = lexicalTokens(promptText ?? "");
+    // Stack-frame lines name library APIs (writeFileSync, processTicksAndRejections), not the task:
+    // when the prompt holds a real trace, neither their words nor their identifiers count.
+    const promptIdentifiers = promptWordText(promptText ?? "");
+    const taskTerms = new Set([...lexicalTokens(promptIdentifiers), ...identifierTokens(promptIdentifiers)]);
     // Without an existence check (pure/offline) only a slashed token is trusted as a
     // path: "e.g.", "Node.js" or "v1.2" would otherwise match a broad glob.
     const paths = promptPaths(promptText ?? "", opts.root).filter((p) => opts.pathExists ? opts.pathExists(p) : p.includes("/"));
@@ -159,7 +244,7 @@ export function selectForTask(records, promptText, opts = {}) {
     // Tokenize every record once: the same tokens feed the document frequency and the score.
     const candidates = [];
     const consider = (id, kind, title, text, anchors, priority, listable) => {
-        candidates.push({ id, kind, title, tokens: lexicalTokens(text.join(" ")), anchors, priority, listable });
+        candidates.push({ id, kind, title, tokens: termTokens(text.join(" ")), anchors, priority, listable });
     };
     for (const c of records.constraints) {
         consider(c.id, "constraint", c.statement, [c.statement, c.rationale], c.scope, base.constraints + SEVERITY[c.severity] * 10 + (c.provenance.confidence ?? 0), c.severity !== "blocking");
@@ -174,20 +259,56 @@ export function selectForTask(records, promptText, opts = {}) {
         consider(f.id, "finding", f.title, [f.title, f.observation], f.affected_files, base.findings + SEVERITY[f.severity] * 10, true);
     }
     const dfCap = Math.max(MIN_DF_CAP, Math.ceil(DF_CAP_RATIO * candidates.length));
-    const rareTerms = [...taskTerms].filter((term) => candidates.filter((c) => c.tokens.has(term)).length <= dfCap);
+    const df = new Map();
+    for (const c of candidates)
+        for (const term of c.tokens)
+            df.set(term, (df.get(term) ?? 0) + 1);
+    // A camel compound in many records is a brand (GitHub, PowerShell, GitHubActions): in a record
+    // holding it, its parts count as one word. A near-unique one (df <= MIN_DF_CAP, e.g. QuotaReaper)
+    // names this project, and in a record without the compound a part is an ordinary word.
+    const wordGroups = new Map();
+    for (const [word, keys] of camelCompoundGroups(promptIdentifiers)) {
+        const common = keys.filter((key) => (df.get(key) ?? 0) > MIN_DF_CAP);
+        if (common.length)
+            wordGroups.set(word, common);
+    }
+    const strongIds = new Set([...scanIdentifiers(promptIdentifiers)].filter(([, strong]) => strong).map(([term]) => term));
+    const rareTerms = new Map();
+    for (const term of taskTerms) {
+        const n = df.get(term) ?? 0;
+        if (n > dfCap)
+            continue;
+        // Integer weights so equal sums tie exactly and fall through to the priority tiebreak.
+        const idf = Math.round(Math.log(1 + candidates.length / Math.max(1, n)) * 1000);
+        // Only a strong identifier that is near-unique (df <= MIN_DF_CAP) counts, at x2, and qualifies alone.
+        // Weak ones (GitHub, useEffect) add nothing: their parts are already counted as words.
+        const strong = strongIds.has(term) && n <= MIN_DF_CAP;
+        if (term.startsWith(ID_PREFIX) && !strong)
+            continue;
+        rareTerms.set(term, { weight: strong ? idf * IDENTIFIER_WEIGHT : idf, strong });
+    }
     const scored = [];
     for (const { tokens, anchors, ...rest } of candidates) {
-        let terms = 0;
-        for (const term of rareTerms)
-            if (tokens.has(term))
-                terms++;
+        const words = new Set();
+        let identifiers = 0;
+        let termScore = 0;
+        for (const [term, { weight, strong }] of rareTerms) {
+            if (!tokens.has(term))
+                continue;
+            if (strong)
+                identifiers++;
+            else
+                words.add(wordGroups.get(term)?.find((key) => tokens.has(key)) ?? term);
+            termScore += weight;
+        }
         const pathHits = paths.filter((p) => anchors.some((anchor) => pathMatchesGlob(p, anchor))).length;
-        if (pathHits > 0 || terms >= MIN_DISTINCT_TERMS)
-            scored.push({ ...rest, pathHits, terms });
+        // One rare identifier alone qualifies (it counts double); a lone rare word does not.
+        if (pathHits > 0 || words.size + IDENTIFIER_WEIGHT * identifiers >= MIN_DISTINCT_TERMS)
+            scored.push({ ...rest, pathHits, termScore });
     }
     // A record anchored to more of the files the prompt names outranks one that
-    // shares a single (often hub) file with it; rare terms break the remaining ties.
-    scored.sort((a, b) => b.pathHits - a.pathHits || b.terms - a.terms || b.priority - a.priority || a.id.localeCompare(b.id));
+    // shares a single (often hub) file with it; idf-weighted rare terms break the remaining ties.
+    scored.sort((a, b) => b.pathHits - a.pathHits || b.termScore - a.termScore || b.priority - a.priority || a.id.localeCompare(b.id));
     return {
         qualifying: scored.map((s) => s.id),
         top: scored.filter((s) => s.listable).slice(0, k).map(({ id, kind, title }) => ({ id, kind, title })),

package/dist/core/testSelection.d.ts

@@ -0,0 +1,122 @@
+/** One test's coverage record. `complete` = the test file passed (ran to the
+ *  end, so its coverage is whole); `closureHash` = the entry-closure hash at
+ *  refresh time; `commit` = HEAD when this entry was recorded. */
+export interface ImpactEntry {
+    files: string[];
+    complete: boolean;
+    commit: string;
+    closureHash: string;
+}
+export interface ImpactMap {
+    version: number;
+    commit: string;
+    generatedAt?: string;
+    closureHash?: string;
+    /** test file → coverage entry (repo-relative posix). */
+    map: Record<string, ImpactEntry>;
+}
+export interface SelectionInput {
+    changedFiles: string[];
+    allTests: string[];
+    impactMap?: ImpactMap;
+    /** Static dependencies of a test: transitive imports plus the closures of
+     *  repo paths its text names (see `testDependencyModel`). */
+    importGraph: (testFile: string) => Set<string>;
+    fullTriggers?: string[];
+    /** Extra per-test globs: a changed file matching one selects that test. */
+    gateMaps?: Record<string, string[]>;
+    /** Source text of a test (and its non-src helpers), for path/basename mentions. */
+    testText?: (testFile: string) => string;
+    /** Does the test start a child process (directly or through a helper)? */
+    spawning?: (testFile: string) => boolean;
+    /** Every file a spawned child could execute (all src/ plus tooling closures). */
+    wholeProgram?: Iterable<string>;
+    /** Entry-closure hash computed now; a map entry is trusted only if it matches. */
+    closureHash?: string;
+    /** src/ and tooling/ files whose text names a test file by repo path. */
+    testNamers?: (testFile: string) => string[];
+}
+export interface Selection {
+    mode: "selected" | "full" | "none";
+    tests: string[];
+    reasons: Record<string, string[]>;
+    fullReason?: string;
+    unattributed: string[];
+    /** Tests whose impact-map entry attributed a change or narrowed a spawning test. */
+    mapUsed: string[];
+}
+export declare const DEFAULT_FULL_TRIGGERS: readonly string[];
+/** Repo-root markdown (README.md, CHANGELOG.md, ...) is the only non-code change
+ *  that can skip the full suite: it selects tests that mention it, else nothing. */
+export declare function isDocsOnly(file: string): boolean;
+/** Selected tests above this share of the suite run the full suite instead. */
+export declare const MAX_SELECTED_SHARE = 0.6;
+export declare const isMetaTest: (text: string) => boolean;
+/** A map entry may narrow a spawning test only when it is complete and was
+ *  recorded against the same entry closure as now. */
+export declare function entryTrusted(entry: ImpactEntry | undefined, closureHash: string | undefined): boolean;
+export declare function selectTests(input: SelectionInput): Selection;
+/** Tracked + untracked (non-ignored) repo files, repo-relative posix, sorted. */
+export declare function listRepoFiles(root: string): string[];
+export declare function discoverTests(files: string[], glob?: string): string[];
+/** Static imports, re-exports, `import()`/`require()` with literal specifiers. */
+export declare function importSpecifiers(source: string): string[];
+/** Transitive relative-import closure per file, memoized for this call. An
+ *  unresolvable relative specifier (e.g. a deleted file) records every
+ *  candidate path, so the deletion stays attributable to its importers. */
+export declare function buildImportGraph(root: string, files?: string[]): (file: string) => Set<string>;
+/** Entries whose import closure (edges included) keys map-entry trust. */
+export declare const CLOSURE_ROOTS: readonly string[];
+/** String-literal arguments of each `join(`/`resolve(` call, found with a
+ *  balanced-paren scan so nested calls (`join(process.cwd(), "src")`) parse. */
+export declare function joinSegmentRuns(text: string): string[][];
+/** Repo files a test's text names: path-like tokens anywhere (string literals,
+ *  `--eval` import specifiers, template strings) and `join(…, "src", "x.ts")`
+ *  segment runs, resolved against the REPO ROOT (and the test's own dir for
+ *  `./`/`../` tokens), with `.js`→`.ts` mapping. */
+export declare function literalRepoPaths(text: string, fromFile: string, available: Set<string>): string[];
+/** Arguments of each `join(`/`resolve(` call: a plain string literal's value, or
+ *  `null` for anything computed (identifiers, calls, `${}` templates). */
+export declare function joinCallArgs(text: string): (string | null)[][];
+/** Top-level repo dirs a text reaches through a COMPUTED path: `` `../src/${p}` ``,
+ *  `"src/" + p`, `join(root, "src", p)`, or a later use of an alias like
+ *  `const SRC = join(ROOT, "src")`. A test doing that may read any file under
+ *  the dir, so it depends on all of them. A computed segment right after the
+ *  root (`` `../${dir}/x` ``, `"../" + dir`, `resolve(__dirname, "..", dir)`,
+ *  `` `${ROOT}/${dir}` ``) may be ANY top-level dir (fail closed). */
+export declare function templatedRepoDirs(text: string, topDirs: Set<string>): string[];
+export interface TestDependencyModel {
+    /** Static imports ∪ closures of repo paths named in the test or its helpers. */
+    dependencies: (testFile: string) => Set<string>;
+    spawning: (testFile: string) => boolean;
+    /** Text of the test plus its non-src static closure (helpers). */
+    testText: (testFile: string) => string;
+    /** All src/ files plus the closures of every tooling/*.mjs. */
+    wholeProgram: Set<string>;
+    /** Hash of the import closures (edges) of CLOSURE_ROOTS and tooling/*.mjs. */
+    closureHash: string;
+    /** src/ and tooling/ code files whose text names a test file by repo path. */
+    testNamers: (testFile: string) => string[];
+}
+export declare function testDependencyModel(root: string, files: string[], graph?: (file: string) => Set<string>): TestDependencyModel;
+/** Structural hash of the entry closures: every reachable file and its direct
+ *  edges. Content edits don't change it; a new import or file in the closure does. */
+export declare function closureHash(root: string, files: string[], graph?: (file: string) => Set<string>): string;
+/** Repo files with any executed range in V8 coverage reports
+ *  (`NODE_V8_COVERAGE` JSON: `{ result: [{ url, functions: [{ ranges }] }] }`). */
+export declare function coverageFiles(reports: unknown[], root: string, repoFiles: Set<string>): string[];
+export type ChangeMode = {
+    kind: "worktree";
+} | {
+    kind: "staged";
+} | {
+    kind: "base";
+    ref: string;
+};
+/** Changed files for a verify run. `worktree` (default): staged + unstaged +
+ *  untracked; `staged`: the index only; `base`: merge-base(ref, HEAD)..HEAD
+ *  plus the working tree. */
+export declare function changedFiles(root: string, mode?: ChangeMode): string[];
+/** Load an impact map; a missing file is `null`, a malformed one throws. A
+ *  legacy `test: string[]` entry loads as incomplete (never trusted). */
+export declare function loadImpactMap(path: string): ImpactMap | null;