vigiles 38.2.0 → 39.0.0

package/dist/core/eslint-inventory.js

@@ -0,0 +1,251 @@
+"use strict";
+/**
+ * The ONE answer to "which ESLint rules exist in this repo, which are enabled
+ * where, and did the config load" — read from ESLint itself.
+ *
+ * Three callers used to ask ESLint three different ways, and each saw a
+ * different repo: `generate types` probed one representative path per
+ * (directory, extension) (#352), `enforce()` verification probed one path per
+ * config block `files` glob (#351), and the routing catalog asked about
+ * `src/index.ts` alone. The same rule could be enabled for one caller and
+ * absent for another. This module owns the probe; every caller reads the same
+ * {@link EslintInventory}.
+ *
+ * This module is the pure half (the probe's script, its wire schema, and every
+ * question asked of the answer); `eslintInventory` in `linters.ts` runs the
+ * probe beside the other linter subprocesses, cached per project.
+ *
+ * HOW: a child `node -e` process runs in the project's directory, so `eslint`
+ * and the config's own imports resolve from the project exactly as `npx eslint`
+ * would, and nothing of the project's config loads into our process. The child
+ * lists the config's blocks (plugins they register, rules they mention, a probe
+ * path synthesized from each `files` glob), adds one representative path per
+ * (directory, name shape) of the project's files, and asks
+ * `calculateConfigForFile` for each. A rule is `enabled` if any probe has it on,
+ * `disabled` if every probe that sets it has it off.
+ *
+ * LIMITS, named: a block naming one exact file that shares directory and
+ * extension with siblings is reached only if its glob synthesizes that path; a
+ * config in a SUBDIRECTORY (v10 looks configs up per file) is not listed; a
+ * `files` entry given as a function is not probed. A rule that a block mentions
+ * but no probe reached reads `unknown`, never `unconfigured`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ESLINT_PROBE_SCRIPT = exports.PROJECT_FILES_GLOB = void 0;
+exports.representativePaths = representativePaths;
+exports.parseEslintInventory = parseEslintInventory;
+exports.configView = configView;
+exports.enabledRuleIds = enabledRuleIds;
+exports.eslintRuleState = eslintRuleState;
+exports.registeredPluginHasRule = registeredPluginHasRule;
+const node_path_1 = require("node:path");
+const zod_1 = require("zod");
+/** Upper bound on the (directory, name-shape) probes handed to ESLint. */
+const PROBE_CAP = 2000;
+/** `src/a.test.ts` → `.test.ts`; a name with no extension (`Makefile`) is its own shape. */
+function nameShape(file) {
+    const name = (0, node_path_1.basename)(file);
+    const dot = name.indexOf(".", 1);
+    return dot === -1 ? name : name.slice(dot);
+}
+/**
+ * One representative path per distinct (directory, name shape) pair of the
+ * project's files. A flat-config `files` glob selects on the directory and the
+ * name's extension chain, so one file per pair sees every block any file of
+ * that pair could match — without linting a single file.
+ */
+function representativePaths(files) {
+    // A later duplicate key replaces an earlier one: one representative per pair.
+    const byPair = new Map(files.map((f) => [`${(0, node_path_1.dirname)(f)}\0${nameShape(f)}`, f]));
+    return [...byPair.values()].slice(0, PROBE_CAP);
+}
+/** The files `representativePaths` picks from: everything but dependencies and git. */
+exports.PROJECT_FILES_GLOB = {
+    pattern: "**/*",
+    ignore: ["**/node_modules/**", "**/.git/**"],
+};
+// Plain CommonJS for `node -e`, run with cwd = the project. Reads the
+// representative paths as JSON on stdin; prints one JSON object (the wire
+// schema below). `messageTemplate` is ESLint's own error id, so "no config" is
+// read from a field, not from the wording of a message.
+exports.ESLINT_PROBE_SCRIPT = String.raw `
+const { pathToFileURL } = require("node:url");
+const path = require("node:path");
+const PROBE = "__vigiles_probe__";
+const NO_CONFIG = new Set(["no-config-found", "config-file-missing"]);
+function probeFor(pattern, base) {
+  if (Array.isArray(pattern)) pattern = pattern[0];
+  if (typeof pattern !== "string" || pattern.startsWith("!")) return null;
+  let p = pattern
+    .replace(/\{([^,}]*)[^}]*\}/g, "$1")
+    .replace(/\[!?\^?([^\]])[^\]]*\]/g, "$1")
+    .replace(/(^|\/)\*\*\//g, "$1")
+    .replace(/\/\*\*$/, "/" + PROBE + ".js")
+    .replace(/\*\*/g, PROBE)
+    .replace(/\*/g, PROBE)
+    .replace(/\?/g, "x");
+  if (p.startsWith("./")) p = p.slice(2);
+  if (p === "" || path.isAbsolute(p)) return null;
+  if (p.endsWith("/")) p += PROBE + ".js";
+  return typeof base === "string" ? path.posix.join(base, p) : p;
+}
+function severityOn(v) {
+  const sev = Array.isArray(v) ? v[0] : v;
+  return !(sev === 0 || sev === "off");
+}
+const print = (o) => console.log(JSON.stringify(o));
+let input = "";
+process.stdin.on("data", (c) => (input += c));
+process.stdin.on("end", async () => {
+  let api;
+  try { api = require("eslint"); } catch (e) { return print({ kind: "not-installed" }); }
+  const plugins = new Map();
+  const addPlugins = (map) => {
+    if (!map || typeof map !== "object" || Array.isArray(map)) return;
+    for (const [ns, plugin] of Object.entries(map)) {
+      if (ns === "@" || !plugin || typeof plugin !== "object") continue;
+      const set = plugins.get(ns) || new Set();
+      for (const r of Object.keys(plugin.rules || {})) set.add(r);
+      plugins.set(ns, set);
+    }
+  };
+  try {
+    const ESLint = await api.loadESLint();
+    const eslint = new ESLint({ cwd: process.cwd() });
+    const probes = new Set(["dummy.js", "dummy.mjs", "dummy.cjs", ...JSON.parse(input || "[]")]);
+    const mentioned = new Set();
+    let complete = false;
+    if (typeof eslint.findConfigFile === "function") {
+      const file = await eslint.findConfigFile();
+      if (!file) return print({ kind: "no-config" });
+      const mod = await import(pathToFileURL(file).href);
+      const blocks = [];
+      const walk = (x) => { if (Array.isArray(x)) x.forEach(walk); else if (x && typeof x === "object") blocks.push(x); };
+      walk(await mod.default);
+      for (const b of blocks) {
+        addPlugins(b.plugins);
+        for (const id of Object.keys(b.rules || {})) mentioned.add(id);
+        for (const f of Array.isArray(b.files) ? b.files : []) {
+          const probe = probeFor(f, b.basePath);
+          if (probe) probes.add(probe);
+        }
+      }
+      complete = true;
+    }
+    const rules = {};
+    for (const probe of probes) {
+      const cfg = await eslint.calculateConfigForFile(probe);
+      // undefined: the config ignores this path.
+      if (!cfg) continue;
+      addPlugins(cfg.plugins);
+      for (const [id, v] of Object.entries(cfg.rules || {})) {
+        rules[id] = rules[id] === "enabled" || severityOn(v) ? "enabled" : "disabled";
+      }
+    }
+    let core = [];
+    try { core = [...require("eslint/use-at-your-own-risk").builtinRules.keys()]; } catch (e) {}
+    const pluginsOut = {};
+    for (const [ns, set] of plugins) pluginsOut[ns] = [...set];
+    print({ kind: "loaded", core, plugins: pluginsOut, rules, mentioned: [...mentioned], complete });
+  } catch (e) {
+    if (e && NO_CONFIG.has(e.messageTemplate)) return print({ kind: "no-config" });
+    print({ kind: "failed", error: String((e && e.message) || e).split("\n")[0] });
+  }
+});
+`;
+const ruleStateSchema = zod_1.z.enum(["enabled", "disabled"]);
+/** The child's answer. Parsed, never cast: a malformed answer is a failure. */
+const wireSchema = zod_1.z.discriminatedUnion("kind", [
+    zod_1.z.object({ kind: zod_1.z.literal("not-installed") }),
+    zod_1.z.object({ kind: zod_1.z.literal("no-config") }),
+    zod_1.z.object({ kind: zod_1.z.literal("failed"), error: zod_1.z.string() }),
+    zod_1.z.object({
+        kind: zod_1.z.literal("loaded"),
+        core: zod_1.z.array(zod_1.z.string()),
+        plugins: zod_1.z.record(zod_1.z.string(), zod_1.z.array(zod_1.z.string())),
+        rules: zod_1.z.record(zod_1.z.string(), ruleStateSchema),
+        mentioned: zod_1.z.array(zod_1.z.string()),
+        complete: zod_1.z.boolean(),
+    }),
+]);
+/**
+ * Turn the child's stdout into an inventory. Pure, so every shape of answer is
+ * testable without spawning ESLint. @internal
+ */
+function parseEslintInventory(stdout) {
+    const line = stdout.trim().split("\n").at(-1) ?? "";
+    const json = (() => {
+        try {
+            return JSON.parse(line);
+        }
+        catch {
+            return undefined;
+        }
+    })();
+    const parsed = wireSchema.safeParse(json);
+    if (!parsed.success) {
+        return { kind: "failed", error: `unreadable ESLint probe output: ${line}` };
+    }
+    const wire = parsed.data;
+    if (wire.kind !== "loaded")
+        return wire;
+    const view = {
+        core: new Set(wire.core),
+        plugins: new Map(Object.entries(wire.plugins).map(([ns, r]) => [ns, new Set(r)])),
+        rules: new Map(Object.entries(wire.rules)),
+        mentioned: new Set(wire.mentioned),
+        complete: wire.complete,
+    };
+    const anyEnabled = [...view.rules.values()].includes("enabled");
+    return anyEnabled ? { kind: "loaded", view } : { kind: "empty", view };
+}
+/** The view, when the config loaded (with or without enabled rules). */
+function configView(inv) {
+    return inv.kind === "loaded" || inv.kind === "empty" ? inv.view : null;
+}
+/** Ids of every rule the config switches on somewhere, sorted. */
+function enabledRuleIds(view) {
+    return [...view.rules]
+        .filter(([, state]) => state === "enabled")
+        .map(([id]) => id)
+        .sort();
+}
+/** Enabled state of one rule id across every block of the config. */
+function eslintRuleState(inv, ruleId) {
+    switch (inv.kind) {
+        // No config: ESLint runs no rule anywhere.
+        case "no-config":
+            return "unconfigured";
+        case "not-installed":
+        case "failed":
+            return "unknown";
+        case "empty":
+        case "loaded": {
+            const state = inv.view.rules.get(ruleId);
+            if (state)
+                return state;
+            // Set somewhere we could not reach, or the block list was never read: we
+            // do not know. Set nowhere in a config we read whole: it runs nowhere.
+            if (inv.view.mentioned.has(ruleId) || !inv.view.complete) {
+                return "unknown";
+            }
+            return "unconfigured";
+        }
+    }
+}
+/**
+ * Does the plugin the config REGISTERS under `ruleId`'s namespace define the
+ * rule? null when the config registers no plugin under that namespace (or did
+ * not load). The namespace is everything before the LAST slash — ESLint's own
+ * split, so `@scope/plugin/rule` works.
+ */
+function registeredPluginHasRule(inv, ruleId) {
+    const slash = ruleId.lastIndexOf("/");
+    if (slash <= 0)
+        return null;
+    const rules = configView(inv)?.plugins.get(ruleId.substring(0, slash));
+    if (!rules)
+        return null;
+    return rules.has(ruleId.substring(slash + 1));
+}
+//# sourceMappingURL=eslint-inventory.js.map

package/dist/core/event-capability.d.ts

@@ -44,8 +44,12 @@
  * - `inject` — `additionalContext` reaches the MODEL.
  * - `feedback` — a non-zero exit reaches the model as text, but stops nothing.
  * - `halt` — the whole turn can be ended (Claude Code's `continue: false`).
+ * - `stdout-context` — PLAIN (non-JSON) stdout at exit 0 reaches the model as
+ *   context. Distinct from `inject`: on most events plain stdout goes to the
+ *   debug log while `additionalContext` still lands, so the two are separate
+ *   facts (read by `core/hook-delivery.ts`).
  */
-export type HookChannel = "veto" | "ask" | "inject" | "feedback" | "halt";
+export type HookChannel = "veto" | "ask" | "inject" | "feedback" | "halt" | "stdout-context";
 /** What the event hands the hook — and therefore what a decide() can read. */
 export type EventPayload = "tool" | "prompt" | "stop" | "session" | "none";
 /**

package/dist/core/frame.d.ts

@@ -75,8 +75,8 @@ export interface Frame {
 /**
  * The frame for a command run from `cwd` against `target` (absolute).
  *
- * The root is `cwd` — where `loadConfig()` read `.vigilesrc.json` (it does not
- * walk up; measured 2026-09-23) — UNLESS the target lies outside it. A foreign
+ * The root is `cwd` — the project root the CLI resolved once with
+ * {@link findProjectRoot} and runs from — UNLESS the target lies outside it. A foreign
  * target (`vigiles lint ../other`) is somebody else's repository, and its paths
  * mean something from ITS root; relative to `cwd` they would all start with
  * `../`, and a foreign lint must never let the caller's own files satisfy the
@@ -87,4 +87,45 @@ export interface Frame {
 export declare function frameFor(cwd: string, target: string): Frame;
 /** The frame rooted at an absolute directory. */
 export declare function frameAt(root: string): Frame;
+/**
+ * The target of a markdown link written INTO the file `from` that points at
+ * `to`; both are repo-relative. A link resolves from the directory of the file
+ * it sits in, so a compiled `plugin/CLAUDE.md` must link `../docs/x.md`, not
+ * `docs/x.md` (#371). The ONE place a repo path becomes a link: every renderer
+ * that writes a path as a link calls this.
+ */
+export declare function linkFrom(from: string, to: string): string;
+/**
+ * The repo path of a spec's secondary target `target`, which the spec names
+ * relative to its primary output `primary`'s directory: `docs/CLAUDE.md` with
+ * `../AGENTS.md` is `AGENTS.md`.
+ */
+export declare function targetBeside(primary: string, target: string): string;
+/**
+ * The project root for a command started in `start` (absolute): the ONE answer
+ * to "relative to which directory", resolved once by the CLI, so running
+ * `vigiles lint` from `src/` gives the same findings as from the root (#371).
+ *
+ * From `start` upward:
+ *   1. the nearest directory holding `.vigilesrc.json` — a package in a
+ *      monorepo that has its own config is its own project;
+ *   2. else the git work-tree top (the nearest directory holding `.git`, a
+ *      directory or a worktree's file);
+ *   3. else `start` itself.
+ *
+ * Inside a git checkout the config search stops at the work-tree top, so a
+ * config ABOVE the checkout (a home directory) is never read. Outside any
+ * checkout it climbs to the filesystem root. `exists` is the filesystem port;
+ * the caller passes `existsSync`.
+ */
+export declare function findProjectRoot(start: string, exists: (abs: string) => boolean): string;
+/**
+ * A path argument typed in `from`, re-anchored for a command that runs at
+ * `root` (both absolute) — so `vigiles lint CLAUDE.md` typed in `pkg/` reads
+ * `pkg/CLAUDE.md`. Typed AT the root it is returned exactly as typed, so a
+ * message quotes what the user wrote. Absolute (a Windows drive-letter or UNC
+ * path included), or leaving the root, it is absolute: `../../etc/passwd`
+ * names the same file and reads as a different one.
+ */
+export declare function rebaseArg(typed: string, from: string, root: string): string;
 //# sourceMappingURL=frame.d.ts.map

package/dist/core/frame.js

@@ -2,6 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.frameFor = frameFor;
 exports.frameAt = frameAt;
+exports.linkFrom = linkFrom;
+exports.targetBeside = targetBeside;
+exports.findProjectRoot = findProjectRoot;
+exports.rebaseArg = rebaseArg;
+const config_schema_js_1 = require("./config-schema.js");
 const posix_path_js_1 = require("../posix-path.js");
 /**
  * Node on Windows hands out `C:\\repo`, and `../posix-path.js` recognises only a leading `/`
@@ -21,8 +26,8 @@ function isBelow(rel) {
 /**
  * The frame for a command run from `cwd` against `target` (absolute).
  *
- * The root is `cwd` — where `loadConfig()` read `.vigilesrc.json` (it does not
- * walk up; measured 2026-09-23) — UNLESS the target lies outside it. A foreign
+ * The root is `cwd` — the project root the CLI resolved once with
+ * {@link findProjectRoot} and runs from — UNLESS the target lies outside it. A foreign
  * target (`vigiles lint ../other`) is somebody else's repository, and its paths
  * mean something from ITS root; relative to `cwd` they would all start with
  * `../`, and a foreign lint must never let the caller's own files satisfy the
@@ -55,4 +60,82 @@ function frameAt(root) {
     };
     return { root: base, repo, bundle };
 }
+/**
+ * The target of a markdown link written INTO the file `from` that points at
+ * `to`; both are repo-relative. A link resolves from the directory of the file
+ * it sits in, so a compiled `plugin/CLAUDE.md` must link `../docs/x.md`, not
+ * `docs/x.md` (#371). The ONE place a repo path becomes a link: every renderer
+ * that writes a path as a link calls this.
+ */
+function linkFrom(from, to) {
+    const dir = (0, posix_path_js_1.dirname)((0, posix_path_js_1.normalize)(slashed(from)));
+    return (0, posix_path_js_1.relative)((0, posix_path_js_1.join)("/", dir), (0, posix_path_js_1.join)("/", (0, posix_path_js_1.normalize)(slashed(to)))) || ".";
+}
+/**
+ * The repo path of a spec's secondary target `target`, which the spec names
+ * relative to its primary output `primary`'s directory: `docs/CLAUDE.md` with
+ * `../AGENTS.md` is `AGENTS.md`.
+ */
+function targetBeside(primary, target) {
+    return (0, posix_path_js_1.join)((0, posix_path_js_1.dirname)((0, posix_path_js_1.normalize)(slashed(primary))), slashed(target));
+}
+/**
+ * The project root for a command started in `start` (absolute): the ONE answer
+ * to "relative to which directory", resolved once by the CLI, so running
+ * `vigiles lint` from `src/` gives the same findings as from the root (#371).
+ *
+ * From `start` upward:
+ *   1. the nearest directory holding `.vigilesrc.json` — a package in a
+ *      monorepo that has its own config is its own project;
+ *   2. else the git work-tree top (the nearest directory holding `.git`, a
+ *      directory or a worktree's file);
+ *   3. else `start` itself.
+ *
+ * Inside a git checkout the config search stops at the work-tree top, so a
+ * config ABOVE the checkout (a home directory) is never read. Outside any
+ * checkout it climbs to the filesystem root. `exists` is the filesystem port;
+ * the caller passes `existsSync`.
+ */
+function findProjectRoot(start, exists) {
+    const from = (0, posix_path_js_1.normalize)(slashed(start));
+    const ancestors = [from, ...ancestorsOf(from)];
+    const top = ancestors.findIndex((d) => exists((0, posix_path_js_1.join)(d, ".git")));
+    const searched = top === -1 ? ancestors : ancestors.slice(0, top + 1);
+    const configured = searched.find((d) => exists((0, posix_path_js_1.join)(d, config_schema_js_1.PROJECT_CONFIG_FILE)));
+    return configured ?? (top === -1 ? from : searched[top]) ?? from;
+}
+/**
+ * A path argument typed in `from`, re-anchored for a command that runs at
+ * `root` (both absolute) — so `vigiles lint CLAUDE.md` typed in `pkg/` reads
+ * `pkg/CLAUDE.md`. Typed AT the root it is returned exactly as typed, so a
+ * message quotes what the user wrote. Absolute (a Windows drive-letter or UNC
+ * path included), or leaving the root, it is absolute: `../../etc/passwd`
+ * names the same file and reads as a different one.
+ */
+function rebaseArg(typed, from, root) {
+    if (isAbs(slashed(typed)))
+        return typed;
+    const [volume, here] = splitVolume(slashed(from));
+    const [, top] = splitVolume(slashed(root));
+    if ((0, posix_path_js_1.normalize)(here) === (0, posix_path_js_1.normalize)(top))
+        return typed;
+    const abs = (0, posix_path_js_1.resolve)(here, slashed(typed));
+    const rel = (0, posix_path_js_1.relative)(top, abs) || ".";
+    return isBelow(rel) ? rel : `${volume}${abs}`;
+}
+/**
+ * A `/`-separated absolute path split into its Windows volume (`C:`, or
+ * `//server/share`; `""` on POSIX) and the rooted path below it, which the
+ * POSIX ops can climb without eating the volume. `from` and `root` share one:
+ * the root is an ancestor of where the command was typed.
+ */
+function splitVolume(abs) {
+    const volume = /^(?:[A-Za-z]:|\/\/[^/]+\/[^/]+)(?=\/|$)/.exec(abs)?.[0] ?? "";
+    return [volume, abs.slice(volume.length) || "/"];
+}
+/** Every proper ancestor of an absolute directory, nearest first. */
+function ancestorsOf(dir) {
+    const parent = (0, posix_path_js_1.dirname)(dir);
+    return parent === dir ? [] : [parent, ...ancestorsOf(parent)];
+}
 //# sourceMappingURL=frame.js.map

package/dist/core/generate-schema.d.ts

@@ -17,7 +17,8 @@
  * what is really enforceable, not a static catalog.
  */
 export interface GenerateSchemaOptions {
-    basePath?: string;
+    /** The repo root. Required: no cwd fallback. */
+    readonly basePath: string;
     /**
      * Custom linters from `.vigilesrc.json` (`rulesDir`-backed). These aren't
      * auto-discovered by `generate-types`, but `vigiles lint` resolves their
@@ -47,5 +48,5 @@ export interface GenerateSchemaResult {
  * `rule` field falls back to a freeform string so the schema never
  * false-flags a valid reference.
  */
-export declare function generateSchema(options?: GenerateSchemaOptions): GenerateSchemaResult;
+export declare function generateSchema(options: Readonly<GenerateSchemaOptions>): GenerateSchemaResult;
 //# sourceMappingURL=generate-schema.d.ts.map

package/dist/core/generate-schema.js

@@ -51,8 +51,8 @@ function customRuleRefs(basePath, linters) {
  * `rule` field falls back to a freeform string so the schema never
  * false-flags a valid reference.
  */
-function generateSchema(options = {}) {
-    const basePath = options.basePath ?? process.cwd();
+function generateSchema(options) {
+    const basePath = options.basePath;
     const { linters } = (0, generate_types_js_1.generateTypes)({ basePath });
     const ruleNames = new Set();
     for (const { linter, rules } of linters) {

package/dist/core/generate-types.d.ts

@@ -11,12 +11,21 @@
  */
 import type { DiscoveredRules } from "./linter-adapter.js";
 export interface GenerateTypesOptions {
-    basePath?: string;
+    /** The repo root. Required: no cwd fallback. */
+    readonly basePath: string;
     fileGlobs?: string[];
 }
 export interface GenerateTypesResult {
     dts: string;
     linters: DiscoveredRules[];
+    /**
+     * Linters that are set up here but whose config could not be read: their
+     * rules are missing from `dts`, and the caller must say so (#371).
+     */
+    unreadable: readonly {
+        readonly linter: string;
+        readonly reason: string;
+    }[];
     scripts: string[];
     files: string[];
 }
@@ -25,5 +34,5 @@ export interface GenerateTypesResult {
  *
  * Scans all available linters, package.json scripts, and project files.
  */
-export declare function generateTypes(options?: GenerateTypesOptions): GenerateTypesResult;
+export declare function generateTypes(options: Readonly<GenerateTypesOptions>): GenerateTypesResult;
 //# sourceMappingURL=generate-types.d.ts.map

package/dist/core/generate-types.js

@@ -60,20 +60,26 @@ function formatUnion(items, indent = "  ") {
     }
     return ("\n" + items.map((i) => `${indent}| "${escapeForUnion(i)}"`).join("\n"));
 }
+/** Every linter's enabled rules, and the linters whose config could not be read. */
+function discoverLinters(basePath) {
+    const discoveries = Object.values(linters_js_1.LINTERS).flatMap((adapter) => adapter.discoverEnabled ? [adapter.discoverEnabled(basePath)] : []);
+    return {
+        linters: discoveries.flatMap((d) => (d.kind === "found" ? [d.rules] : [])),
+        unreadable: discoveries.flatMap((d) => d.kind === "unreadable" ? [{ linter: d.linter, reason: d.reason }] : []),
+    };
+}
 /**
  * Generate .d.ts content with type unions from actual project state.
  *
  * Scans all available linters, package.json scripts, and project files.
  */
-function generateTypes(options = {}) {
-    const basePath = options.basePath ?? process.cwd();
+function generateTypes(options) {
+    const basePath = options.basePath;
     const fileGlobs = options.fileGlobs ?? ["src/**/*"];
     // Discover every linter's enabled rules through the single LINTERS registry
     // (each adapter's discoverEnabled) — no separate discoverers list to keep in
     // step with the registry.
-    const linters = Object.values(linters_js_1.LINTERS)
-        .map((adapter) => adapter.discoverEnabled?.(basePath))
-        .filter((found) => found != null);
+    const { linters, unreadable } = discoverLinters(basePath);
     const scripts = discoverNpmScripts(basePath);
     const files = discoverProjectFiles(basePath, fileGlobs);
     // Generate .d.ts
@@ -148,6 +154,7 @@ function generateTypes(options = {}) {
     return {
         dts: sections.join("\n"),
         linters,
+        unreadable,
         scripts,
         files,
     };