@drkmttr/adhere 0.18.0 → 0.21.2

package/src/rules.ts

@@ -60,11 +60,9 @@ interface RuleFile {
 
 /**
  * The rules among `leaves`, the paths in `directory`, whose rules sit under
- * `prefix` one to a directory: `<id>/RULE.md` or `<id>/RULE.ts`. Anything else
- * in a rule's directory, such as a helper its RULE.ts imports, is not a rule.
- * A directory with both files refuses, and so does a Markdown file outside
- * every rule's directory, but a README.md: before rule directories, it was a
- * rule, and the refusal says where it goes now to keep its id.
+ * `prefix` one to a directory: `<id>/RULE.md` or `<id>/RULE.ts`. Any other
+ * file, such as a helper a RULE.ts imports, is not a rule. A directory with
+ * both files refuses.
  */
 const ruleFilesIn = (
   directory: string,
@@ -85,29 +83,6 @@ const ruleFilesIn = (
       }),
     );
   }
-  const homes = files.map(({ leaf }) => leaf.slice(0, leaf.lastIndexOf("/") + 1));
-  const flat = leaves.filter((leaf) => {
-    const name = segmentsOf(leaf).at(-1) ?? "";
-    return (
-      leaf.endsWith(".md") &&
-      !RULE_FILES.has(name) &&
-      name !== "README.md" &&
-      !homes.some((home) => leaf.startsWith(home))
-    );
-  });
-  if (flat.length > 0) {
-    return Effect.fail(
-      ConfigUnavailable.make({
-        message: [
-          `Rules now live one to a directory, as ${directory}/${prefix}<id>/RULE.md or RULE.ts. Move each of these to keep its id:`,
-          ...flat.map(
-            (leaf) =>
-              `  ${directory}/${leaf} → ${directory}/${prefix}${leaf.slice(0, -".md".length)}/RULE.md`,
-          ),
-        ].join("\n"),
-      }),
-    );
-  }
   return Effect.succeed(files);
 };
 
@@ -161,7 +136,7 @@ const moreSpecific = (a: RuleEntry, b: RuleEntry): RuleEntry =>
  * config's inline rule is, so a hook such as `appendState` comes with it.
  * Like a config, the file is imported, so its code runs.
  */
-const importRule = Effect.fn("importRule")(function* (file: string) {
+export const importRule = Effect.fn("importRule")(function* (file: string) {
   const path = yield* Path.Path;
   const url = yield* path.toFileUrl(file).pipe(Effect.orDie);
   const loaded = yield* Effect.tryPromise({
@@ -255,25 +230,47 @@ export const globalRuleSet = (rules: Readonly<Record<RuleId, Rule>>, root: strin
 /**
  * The rules as a config's overrides leave them, each found by the id a report
  * names it with: a rule set `off` gone, and any other with the level and
- * threshold its override gives, over its own.
+ * threshold its override gives, over its own, and its `options` decoded by
+ * the rule's schema, `{}` when unset. Options a rule does not take, or that
+ * do not decode, refuse the run.
  */
-export const withOverrides = (
+export const withOverrides = Effect.fn("withOverrides")(function* (
   entries: RuleSet,
   overrides: Readonly<Record<string, Override>>,
-): RuleSet =>
-  entries.flatMap((entry) => {
-    const override = overrides[shownId(entry)];
-    if (override === undefined) return [entry];
-    const { level, threshold }: Exclude<Override, string> =
-      typeof override === "string" ? { level: override } : override;
-    if (level === "off") return [];
-    const rule: Rule = {
-      ...entry.rule,
-      ...(level === undefined ? {} : { level }),
-      ...(threshold === undefined ? {} : { threshold }),
-    };
-    return [{ ...entry, rule }];
-  });
+) {
+  const kept = yield* Effect.forEach(entries, (entry) =>
+    Effect.gen(function* () {
+      const id = shownId(entry);
+      const override = overrides[id];
+      const { level, threshold, options }: Exclude<Override, string> =
+        typeof override === "string" ? { level: override } : (override ?? {});
+      if (level === "off") return [];
+      if (entry.rule.options === undefined && options !== undefined) {
+        return yield* ConfigUnavailable.make({
+          message: `overrides sets options for ${id}, which takes none.`,
+        });
+      }
+      const optionValues =
+        entry.rule.options === undefined
+          ? undefined
+          : yield* Schema.decodeUnknownEffect(entry.rule.options)(options ?? {}).pipe(
+              Effect.mapError((problem) =>
+                ConfigUnavailable.make({
+                  message: `The options of ${id}, set in overrides, did not decode: ${problem.message}`,
+                }),
+              ),
+            );
+      const rule: Rule = {
+        ...entry.rule,
+        ...(level === undefined ? {} : { level }),
+        ...(threshold === undefined ? {} : { threshold }),
+        ...(optionValues === undefined ? {} : { optionValues }),
+      };
+      return [{ ...entry, rule }];
+    }),
+  );
+  return kept.flat();
+});
 
 /**
  * Whether a rule judges a file: a test file only when the rule says `tests`,

package/src/services/AdhereConfig.ts

@@ -21,14 +21,14 @@ import {
   shownId,
   withOverrides,
 } from "#rules.ts";
-import { workspacePackagesOf } from "#workspaces.ts";
+import { workspaceDependentsOf, workspacePackagesOf } from "#workspaces.ts";
 import { Context, Effect, FileSystem, Layer, Path, Record } from "effect";
 
 export class AdhereConfig extends Context.Service<AdhereConfig, ResolvedConfig>()(
   "@drkmttr/adhere/services/AdhereConfig",
 ) {}
 
-const loadConfigFile = Effect.fn("AdhereConfig.load")(function* (file: string) {
+export const loadConfigFile = Effect.fn("AdhereConfig.load")(function* (file: string) {
   const path = yield* Path.Path;
   const url = yield* path.toFileUrl(file).pipe(Effect.orDie);
   const loaded = yield* Effect.tryPromise({
@@ -53,6 +53,23 @@ const loadPreset = Effect.fn("AdhereConfig.loadPreset")(function* (name: PresetN
   return [name, { ...preset, rules } satisfies Loaded<Preset>] as const;
 });
 
+/** Locate the optional config without loading rules or presets. */
+export const findConfigFile = Effect.fn("AdhereConfig.find")(function* (cwd: string) {
+  const path = yield* Path.Path;
+  const fs = yield* FileSystem.FileSystem;
+  const found = yield* Effect.filter(CONFIG_FILES, (file) =>
+    fs
+      .exists(path.join(cwd, file))
+      .pipe(Effect.mapError((problem) => ConfigUnavailable.make({ message: problem.message }))),
+  );
+  if (found.length > 1) {
+    return yield* ConfigUnavailable.make({
+      message: `More than one config file: ${found.join(", ")}. Keep one.`,
+    });
+  }
+  return found[0];
+});
+
 /** Every rule of every built-in preset, by the id a report names it with. */
 const everyPresetRule = Effect.fn("AdhereConfig.everyPresetRule")(function* (base: string) {
   const loaded = yield* Effect.forEach(Object.entries(presets), ([name, preset]) =>
@@ -73,19 +90,8 @@ export const AdhereConfigLive = (flags: Flags) =>
   Layer.effect(AdhereConfig)(
     Effect.gen(function* () {
       const path = yield* Path.Path;
-      const fs = yield* FileSystem.FileSystem;
       const cwd = path.resolve();
-      const present = (target: string) =>
-        fs
-          .exists(path.join(cwd, target))
-          .pipe(Effect.mapError((problem) => ConfigUnavailable.make({ message: problem.message })));
-      const found = yield* Effect.filter(CONFIG_FILES, present);
-      if (found.length > 1) {
-        return yield* ConfigUnavailable.make({
-          message: `More than one config file: ${found.join(", ")}. Keep one.`,
-        });
-      }
-      const configFile = found[0];
+      const configFile = yield* findConfigFile(cwd);
       const hasPreset = flags.presets !== undefined && flags.presets.length > 0;
       const config: typeof AdhereConfigSchema.Type =
         configFile === undefined
@@ -130,15 +136,22 @@ export const AdhereConfigLive = (flags: Flags) =>
           });
         }
       }
-      const scopedRules = withOverrides(entries, overrides);
+      const scopedRules = yield* withOverrides(entries, overrides);
       // Read on every run so workspace edits are seen, but only when the config enables this context.
-      const workspacePackages = resolved.reads.includes("workspacePackages")
-        ? yield* workspacePackagesOf(cwd)
-        : undefined;
+      const dependents = resolved.reads.includes("dependents");
+      const workspacePackages =
+        dependents || resolved.reads.includes("workspacePackages")
+          ? yield* workspacePackagesOf(cwd)
+          : undefined;
+      const workspaceDependents =
+        dependents && workspacePackages !== undefined
+          ? yield* workspaceDependentsOf(cwd, workspacePackages)
+          : undefined;
       return AdhereConfig.of({
         ...resolved,
         scopedRules,
         ...(workspacePackages === undefined ? {} : { workspacePackages }),
+        ...(workspaceDependents === undefined ? {} : { workspaceDependents }),
       });
     }),
   );

package/src/services/Credentials.ts

@@ -66,6 +66,18 @@ export class Credentials extends Context.Service<
 
 const refused = (message: string) => CredentialsUnavailable.make({ message });
 
+/** `$XDG_CONFIG_HOME/adhere`, or `~/.config/adhere` without it, on every platform: where adhere keeps a user's own files. */
+export const adhereConfigDirectory = (path: Path.Path) =>
+  Config.NonEmptyString("XDG_CONFIG_HOME").pipe(
+    Config.orElse(() =>
+      Config.NonEmptyString("HOME").pipe(
+        Config.orElse(() => Config.NonEmptyString("USERPROFILE")),
+        Config.map((home) => path.join(home, ".config")),
+      ),
+    ),
+    Config.map((configHome) => path.join(configHome, "adhere")),
+  );
+
 /**
  * The keys live in `$XDG_CONFIG_HOME/adhere/credentials.json`, or under
  * `~/.config` without it, on every platform. The file is written whole to a
@@ -77,14 +89,8 @@ export const CredentialsLive = Layer.effect(Credentials)(
     const fs = yield* FileSystem.FileSystem;
     const path = yield* Path.Path;
 
-    const file = Config.NonEmptyString("XDG_CONFIG_HOME").pipe(
-      Config.orElse(() =>
-        Config.NonEmptyString("HOME").pipe(
-          Config.orElse(() => Config.NonEmptyString("USERPROFILE")),
-          Config.map((home) => path.join(home, ".config")),
-        ),
-      ),
-      Config.map((configHome) => path.join(configHome, "adhere", "credentials.json")),
+    const file = adhereConfigDirectory(path).pipe(
+      Config.map((directory) => path.join(directory, "credentials.json")),
       Effect.mapError(() =>
         refused("No home directory to keep the API key in: set HOME or XDG_CONFIG_HOME."),
       ),

package/src/services/Jev.reads.test.ts

@@ -76,6 +76,7 @@ const recordedJev = (
     Layer.provide([
       Layer.succeed(FetchHttpClient.Fetch, fetch),
       Layer.succeed(AdhereConfig, {
+        typeAware: false,
         model: "jev-latest",
         threshold: 0.8,
         sufficiencyThreshold: 0.6,
@@ -193,6 +194,28 @@ describe("prepared shared Jev reads", () => {
     expect(locateRequests(lines, rules, readState)).toBe(3);
   });
 
+  it("sends a rule's options in requests of its own, under `options`", () => {
+    const optioned = { ...plain, optionValues: { edgePaths: ["src/edge"] } };
+    const rules = { plain, optioned, alsoPlain: plain };
+    const readState: ReadState = { workspacePackages: { orders: "packages/orders" } };
+    const groups = requestGroups(rules);
+    expect(groups.map((group) => Object.keys(group))).toEqual([
+      ["plain", "alsoPlain"],
+      ["optioned"],
+    ]);
+    const [shared, own] = groups.map((group) => locateBody("", lines, group, readState).state);
+    expect(shared?.options).toBeUndefined();
+    expect(own?.options).toEqual({
+      edgePaths: ["src/edge"],
+      __comment: expect.stringMatching(/options\./),
+    });
+    expect(judgeBody("", lines, { optioned }, [], readState).state).toEqual(own);
+    expect(own?.workspacePackages).toEqual(shared?.workspacePackages);
+    const huge = { ...plain, optionValues: { edgePaths: ["p".repeat(120_000)] } };
+    expect(fits(lines, { plain, optioned }, readState)).toBe(true);
+    expect(fits(lines, { plain, huge }, readState)).toBe(false);
+  });
+
   it("preserves caller comments and raw context through judge, locate, and appended maps", async () => {
     const readState = {
       __comment: "User context: only target code is audited.",
@@ -493,9 +516,10 @@ describe("prepared shared Jev reads", () => {
     expect(readState.code).toEqual({});
   });
 
-  it("does not prepare context in HTTP even with resolved default reads and omitted or partial shared state", async () => {
+  it("uses only caller-prepared context in HTTP with workspace-only defaults", async () => {
     const config = resolveConfig({ presets: [], rules: { plain } });
-    expect(config.reads).toEqual(["workspacePackages", "symbols", "references"]);
+    expect(config.reads).toEqual(["workspacePackages"]);
+    expect(config.typeAware).toBe(false);
     const { sent, layer } = recordedJev({ unused: "packages/unused" }, config.reads);
     await Effect.runPromise(
       Effect.gen(function* () {

package/src/services/Jev.ts

@@ -141,11 +141,15 @@ export const tokensOf = (value: unknown): number => Math.ceil(bytesOf(value) / 3
 
 const READ_COMMENTS: Readonly<Record<string, string>> = {
   symbols:
-    "Compiler-inferred types, documentation, and JSDoc for symbols in `code`; keys are symbol names.",
+    "Compiler-rendered types and documentation for symbols used in `code`; keys are symbol names. A declared type, assertion, or type predicate is only a compile-time claim, not proof of runtime validation. When `references` show an implementation, inspect its actual checks. A predicate that returns true, tests only truthiness, or checks only whether a value is an object does not validate the fields it claims.",
   references:
     "Declarations of symbols used in `code`. Each key is `symbol:pathname`: the symbol name as used in `code` followed by its repository-relative declaration path. Each value is a complete declaration excerpt.",
   workspacePackages:
     "Workspace packages imported by `code`; keys are package names and values are repository-relative package directories. Only packages imported by this file are listed.",
+  dependents:
+    "What depends on the file `code` holds. `packages` maps workspace packages whose package.json depends on this file's package to their repository-relative directories. `files` lists repository-relative paths of files that import this file by a relative path; `omittedFiles`, when present, counts more that are not listed. Package-name imports of this file are not in `files`.",
+  options:
+    "Settings this project gives the rule the questions ask about, which the rule names as `options.<key>`.",
 };
 
 /** Explain the known context maps while preserving caller-provided descriptions and target code. */
@@ -347,11 +351,21 @@ export const matcherQuestions = (id: RuleId, rule: Rule) =>
         [matcherKey(kind, id, index), matcherQuestion(rule, kind, matcher)] as const,
     ),
   );
-
-/** The room for one question beside the file and its shared prepared context. Hooks are not predicted. */
+/** The room for one question beside the file and the prepared context of its request. Hooks are not predicted. */
 export const questionRoom = (lines: Lines, readState: ReadState = {}): number =>
   QUESTION_CONTEXT - WRAPPER - tokensOf(stateOf(lines, readState));
 
+/**
+ * The shared context, with the options of the rule in `rules` that has them
+ * under `options`: `requestGroups` gives such a rule a body of its own.
+ */
+const withOptions = (rules: Rules, readState: ReadState): ReadState => {
+  const options = Object.values(rules).find(
+    (rule) => rule.optionValues !== undefined,
+  )?.optionValues;
+  return options === undefined ? readState : { ...readState, options };
+};
+
 /**
  * One question per rule, one per matcher of each rule, and the linter
  * question beside each rule in `sampled`.
@@ -364,7 +378,7 @@ export const judgeBody = (
   readState: ReadState = {},
 ) => ({
   model,
-  state: stateOf(lines, readState),
+  state: stateOf(lines, withOptions(rules, readState)),
   questions: {
     ...Record.map(rules, (rule): ReturnType<typeof judgeQuestion> => judgeQuestion(rule)),
     ...Object.fromEntries(
@@ -482,7 +496,7 @@ export const locateBody = (
   readState: ReadState = {},
 ) => {
   const sections = sectionsOf(lines);
-  const state = stateOf(lines, readState, sections);
+  const state = stateOf(lines, withOptions(rules, readState), sections);
   const criteria = Record.map(state.code, () => null);
   const choosing = sections.length > 1;
   const withCode = sections.map((section) => lineCriteria(lines, section));
@@ -513,10 +527,16 @@ export const locateBody = (
 };
 
 /**
- * Whether Jev can take every request a file may need: its sections within
- * one choice, and the shared state beside its longest question. Hooks are not predicted.
+ * Whether Jev can take every request a file may need: each request group's
+ * sections within one choice, and its state, options and all, beside its
+ * longest question. Hooks are not predicted.
  */
-export const fits = (lines: Lines, rules: Rules, readState: ReadState = {}): boolean => {
+export const fits = (lines: Lines, rules: Rules, readState: ReadState = {}): boolean =>
+  Record.isEmptyRecord(rules)
+    ? groupFits(lines, rules, readState)
+    : requestGroups(rules).every((group) => groupFits(lines, group, withOptions(group, readState)));
+
+const groupFits = (lines: Lines, rules: Rules, readState: ReadState): boolean => {
   const sections = sectionsOf(lines);
   if (sections.length > CHOICE_LIMIT) return false;
   const state = stateOf(lines, readState, sections);
@@ -633,16 +653,18 @@ export const requestsOf = <Q>(body: Body<Q>): ReadonlyArray<Body<Q>> => {
 };
 
 /**
- * All rules share one body except those with `appendState`, each in a body
- * of its own so only its questions read what its hook adds to the shared state.
+ * All rules share one body except those with `appendState` or options, each
+ * in a body of its own so only its questions read what it adds to the shared state.
  */
 export const requestGroups = (rules: Rules): ReadonlyArray<Rules> => {
-  const shared = Record.filter(rules, (rule) => rule.appendState === undefined);
+  const alone = Record.filter(
+    rules,
+    (rule) => rule.appendState !== undefined || rule.optionValues !== undefined,
+  );
+  const shared = Record.filter(rules, (_, id) => !(id in alone));
   return [
     ...(Record.isEmptyRecord(shared) ? [] : [shared]),
-    ...Object.entries(rules).flatMap(([id, rule]) =>
-      rule.appendState === undefined ? [] : [{ [id]: rule }],
-    ),
+    ...Object.entries(alone).map(([id, rule]) => ({ [id]: rule })),
   ];
 };
 

package/src/wording.ts

@@ -60,7 +60,7 @@ export const straysAmong = (entries: ReadonlyArray<RuleEntry>): ReadonlyArray<St
   });
 
 /** One way a rule strays, as a sentence. */
-const sentenceOf = (straying: Straying): string => {
+export const sentenceOf = (straying: Straying): string => {
   switch (straying._tag) {
     case "Unsaid":
       return `The description does not say "${straying.word}", though the rule has a ${straying.word} example.`;

package/src/workflows/audit.ts

@@ -40,7 +40,13 @@ import { SAMPLE, tallyKeyOf } from "#mechanical.ts";
 import { priceOf } from "#pricing.ts";
 import { applicableRules, judgesFile, shownId } from "#rules.ts";
 import { suppresses, type Suppressions, suppressionsOf } from "#suppress.ts";
-import { workspacePackagesIn } from "#workspaces.ts";
+import {
+  dependentFilesIn,
+  importSpecifiersIn,
+  packageOf,
+  workspacePackagesIn,
+} from "#workspaces.ts";
+import { relative, sep } from "node:path";
 import { type Crypto, Duration, Effect, Option, Record, Result, Semaphore, Stream } from "effect";
 
 export interface Finding {
@@ -125,19 +131,24 @@ const LAYOUT = "sections";
 
 /**
  * What a judgment depends on besides the file: the model, how the file is
- * laid out, and the questions asked for the rule, which carry the rule: its
- * judge question, and its matchers' when it has any. An edited rule or
- * matcher re-judges the rule, and a question asked differently re-judges
- * every rule. So does an edited `appendState`, by its source; what the hook
- * reads outside the file is not known until it runs, so a change there does
- * not. Shared read context and related files do not invalidate judgments.
+ * laid out, what the config has Jev read, and the questions asked for the
+ * rule, which carry the rule: its judge question, and its matchers' when it
+ * has any. An edited rule or matcher re-judges the rule, and a question asked
+ * differently, or other reads, re-judge every rule. So does an edited
+ * `appendState`, by its source; what the hook reads outside the file is not
+ * known until it runs, so a change there does not. Options set differently
+ * re-judge their rule: decoded, a struct's keys come in its schema's order,
+ * however the config writes them. What the reads find, such as related
+ * files, does not invalidate judgments.
  */
-const fingerprintOf = (model: string, rule: Rule) => {
+const fingerprintOf = (model: string, reads: string, rule: Rule) => {
   const matchers = matcherQuestions("", rule).map(([, question]) => question);
   const scope = matchers.length === 0 ? "" : `\u0000${JSON.stringify(matchers)}`;
   const hook = rule.appendState === undefined ? "" : `\u0000${rule.appendState.toString()}`;
+  const options =
+    rule.optionValues === undefined ? "" : `\u0000${JSON.stringify(rule.optionValues)}`;
   return sha256(
-    `${model}\u0000${LAYOUT}\u0000${JSON.stringify(judgeQuestion(rule))}${scope}${hook}`,
+    `${model}\u0000${LAYOUT}${reads}\u0000${JSON.stringify(judgeQuestion(rule))}${scope}${hook}${options}`,
   );
 };
 
@@ -368,6 +379,9 @@ const hasLocatedFindings = (plan: FilePlan): boolean =>
     );
   });
 
+/** At most this many of a file's dependent files are listed; the rest are counted. */
+const MAX_DEPENDENT_FILES = 50;
+
 export interface PlanOptions {
   /** Select at most this many files needing judge or cached-locate requests; zero plans only. */
   readonly limit?: number | undefined;
@@ -386,15 +400,49 @@ export const planAudit = (
     const workspacePackages = config.reads.includes("workspacePackages")
       ? (config.workspacePackages ?? {})
       : undefined;
+    const catalog = config.workspacePackages ?? {};
     const nativeReads: SourceReadRequest = {
-      symbols: config.reads.includes("symbols"),
-      references: config.reads.includes("references"),
+      symbols: config.typeAware,
+      references: config.typeAware,
       includeComments: config.includeComments === true,
       maxSymbolLength: config.maxSymbolLength,
       maxSymbolDocumentationLength: config.maxSymbolDocumentationLength,
     };
     const walker = yield* SourceWalker;
     const files = yield* walker.files;
+    // Each file's path from the working directory, `/`-separated, as Jev reads it.
+    const fromRoot = new Map(
+      files.map((file) => [file.path, relative(process.cwd(), file.path).split(sep).join("/")]),
+    );
+    // Only the specifiers stay in memory: each file is read again when it is planned.
+    const dependentFiles = config.reads.includes("dependents")
+      ? dependentFilesIn(
+          new Map(
+            yield* Effect.forEach(
+              files,
+              (file) =>
+                Effect.map(
+                  walker.read(file),
+                  ({ lines }) =>
+                    [fromRoot.get(file.path)!, importSpecifiersIn(lines.join("\n"))] as const,
+                ),
+              { concurrency: 8 },
+            ),
+          ),
+        )
+      : undefined;
+    const dependentsOf = (file: SourceFile) => {
+      const at = fromRoot.get(file.path)!;
+      const name = packageOf(at, catalog);
+      const importers = dependentFiles?.get(at) ?? [];
+      return {
+        packages: (name === undefined ? undefined : config.workspaceDependents?.[name]) ?? {},
+        files: importers.slice(0, MAX_DEPENDENT_FILES),
+        ...(importers.length > MAX_DEPENDENT_FILES
+          ? { omittedFiles: importers.length - MAX_DEPENDENT_FILES }
+          : {}),
+      };
+    };
 
     // Each preset's rule, with the preset it came from, for its findings to name.
     const presetOfRule = new Map(
@@ -416,11 +464,23 @@ export const planAudit = (
       );
 
     // Model, thresholds, and presets are fixed per plan; share immutable descriptors by Rule identity.
+    // The reads that take effect key every judgment; code-only keeps the key it always had.
+    // includeComments shapes other files' `references` excerpts, which the target's hash misses.
+    const reads = [
+      ...(workspacePackages === undefined ? [] : ["workspacePackages"]),
+      ...(dependentFiles === undefined ? [] : ["dependents"]),
+      ...(config.typeAware
+        ? [
+            `symbols:${config.maxSymbolLength}:${config.maxSymbolDocumentationLength}:${config.includeComments === true}`,
+          ]
+        : []),
+    ];
+    const readsKey = reads.length === 0 ? "" : `\u0000${reads.join(",")}`;
     const preparedRules = new Map<Rule, PreparedRule>(
       yield* Effect.forEach(
         new Set(config.scopedRules?.map(({ rule }) => rule) ?? Object.values(config.rules)),
         (rule) =>
-          Effect.map(fingerprintOf(config.model, rule), (fingerprint) => {
+          Effect.map(fingerprintOf(config.model, readsKey, rule), (fingerprint) => {
             const preset = presetOfRule.get(rule);
             return [
               rule,
@@ -440,10 +500,12 @@ export const planAudit = (
       const { lines, suppressions } = normalized(original.lines, config.includeComments === true);
       const rules = configuredRules(file, suppressions);
       const code = lines.join("\n");
-      const readState: ReadState =
-        workspacePackages === undefined
+      const readState: ReadState = {
+        ...(workspacePackages === undefined
           ? {}
-          : { workspacePackages: workspacePackagesIn(code, workspacePackages) };
+          : { workspacePackages: workspacePackagesIn(code, workspacePackages) }),
+        ...(dependentFiles === undefined ? {} : { dependents: dependentsOf(file) }),
+      };
       // Hashed even when unjudged or skipped, so a prune keeps what other runs know of its content.
       const hash = yield* sha256(code);
       const prepared = Record.map(rules, (rule) => preparedRules.get(rule)!);
@@ -802,7 +864,13 @@ export const executeAudit = (
       const room = questionRoom(file.lines, readState);
       const sentSamples = Record.filter(sampled, (_, id) => {
         const k = pending[id];
-        return k !== undefined && tokensOf(linterQuestion(k.rule)) <= room;
+        if (k === undefined) return false;
+        // A rule with options asks beside them, in a request of its own.
+        const left =
+          k.rule.optionValues === undefined
+            ? room
+            : questionRoom(file.lines, { ...readState, options: k.rule.optionValues });
+        return tokensOf(linterQuestion(k.rule)) <= left;
       });
       const sampleIds = Object.keys(sentSamples);
       const { probabilities, linter, matchers }: Judged = isEmpty(pending)