@drkmttr/adhere 0.9.3 → 0.9.5

package/README.md

@@ -66,7 +66,10 @@ Found 1 error.
 42 files, 3 judged, 39 cached.
 ```
 
-The header is the rule id, Jev's probability, and the rule's description.
+The header is the rule id, Jev's probability, and the rule's description. A
+preset's rule has the preset's name first, as in
+`effect/basics/external-calls-are-resilient`, so a report that mixes presets
+with a repo's own rules says where each came from.
 Under it is the line Jev points at, underlined, with the code around it: the
 largest statement around the line that is 30 lines or fewer, usually the whole
 function, and up to 3 lines of whole statements on either side. The
@@ -101,15 +104,27 @@ prints a completion script.
 
 ### Before and during a run
 
-Before it sends anything, `lint` says on stderr what it found and what judging
-takes:
+Until it knows what judging takes, a status line on stderr says what `lint` is
+doing: looking for `.adhere/` rules, listing and reading the files, then
+planning, each with a count, such as `Planning: 5,120 of 10,333 files`. The
+line is drawn only on a terminal, and not at `--log-level debug` or below,
+whose log lines would land in it. Then `lint` says on stderr what it found and
+what judging takes:
 
 ```text
 200 files and 14 rules: 2800 checks, 1400 cached.
 Judging the other 1400 takes 200 requests to Jev, plus 1 or more for each file with a finding.
-? Send 200 requests to Jev? › (Y/n)
+Those carry about 1.9 million input tokens: about $0.08 at $0.042 per million, and more for locating findings.
+? Send 200 requests to Jev, about $0.08? › (Y/n)
 ```
 
+The cost is adhere's estimate of the input tokens times the model's price.
+Jev charges only for input tokens: $0.042 a million for `jev-latest`, per
+[TypeSafe AI's models page](https://docs.typesafe.ai/models) in September 2026.
+The estimate runs about a tenth high, and locating findings, which depends on
+what judging finds, comes on top. For a model adhere has no price for, the plan
+gives the tokens alone.
+
 It asks only with a terminal on stdin and stdout, and never when the cache
 answers every check; `--yes` sends without asking. While it runs, a counter on
 stderr shows the files done, the requests sent, and the findings so far, and
@@ -370,8 +385,11 @@ each rule worded otherwise.
 ### Presets
 
 A preset has the shape of a config without `presets`: `rules`, and optionally
-`model` and `threshold`. Name one in the config, or on the command line with
-`--preset`, in which case the config file is optional. There are two:
+`model` and `threshold`. Name presets in the config's `presets`, or on the
+command line with `--preset`, repeated or separated by commas, as in
+`--preset effect,alchemy`, in which case the config file is optional. Presets
+named in both places apply together. Reports name a preset's rule with the
+preset first, as in `alchemy/secrets/…`. There are two:
 
 - `effect`: Markdown rules in [`presets/effect/`](./presets/effect/), lifted
   from the [effect-solutions](https://github.com/kitlangton/effect-solutions)
@@ -489,8 +507,11 @@ A cache file is written once and never changed: it is also named for the hash
 of its own text. Two branches that judge the same code add files rather than
 edit them, so git merges the cache without a conflict. After a run that reads
 every file, adhere prunes the cache: it deletes answers about content no file
-has and answers to rule texts no rule asks, and folds what is left into one
-file per content. A run narrowed by `--filter` does not prune. To keep the
+has, and folds what is left into one file per content. Answers to rules the
+run left out stay, so a run with other presets or rules, or with one topic,
+loses nothing another run still asks; answers to a rule's old texts stay too,
+until the content they are about is gone. A run narrowed by `--filter` does not
+prune. To keep the
 cache out of diffs, mark it as generated in `.gitattributes`:
 
 ```text

package/bin/adhere.js

@@ -8,6 +8,7 @@
 import { spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { createRequire } from "node:module";
+import { constants } from "node:os";
 import { fileURLToPath } from "node:url";
 
 const platform = `${process.platform}-${process.arch}`;
@@ -26,6 +27,14 @@ const resolveExecutable = () => {
 const run = (command, commandArgs) => {
   const result = spawnSync(command, commandArgs, { stdio: "inherit" });
   if (result.error) throw result.error;
+  if (result.signal) {
+    // A killed process says nothing itself, so say what killed it.
+    const memory =
+      result.signal === "SIGKILL" ? ", usually the system ending it for running out of memory" : "";
+    console.error(`adhere: the executable was killed by ${result.signal}${memory}.`);
+    process.exitCode = 128 + (constants.signals[result.signal] ?? 0);
+    return;
+  }
   process.exitCode = result.status ?? 1;
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drkmttr/adhere",
-  "version": "0.9.3",
+  "version": "0.9.5",
   "private": false,
   "description": "Lints a repository against the rules in .adhere/, judged by Jev.",
   "license": "MIT",
@@ -68,10 +68,10 @@
     }
   },
   "optionalDependencies": {
-    "@drkmttr/adhere-darwin-arm64": "0.9.3",
-    "@drkmttr/adhere-darwin-x64": "0.9.3",
-    "@drkmttr/adhere-linux-arm64": "0.9.3",
-    "@drkmttr/adhere-linux-x64": "0.9.3",
-    "@drkmttr/adhere-win32-x64": "0.9.3"
+    "@drkmttr/adhere-darwin-arm64": "0.9.5",
+    "@drkmttr/adhere-darwin-x64": "0.9.5",
+    "@drkmttr/adhere-linux-arm64": "0.9.5",
+    "@drkmttr/adhere-linux-x64": "0.9.5",
+    "@drkmttr/adhere-win32-x64": "0.9.5"
   }
 }

package/src/cli.ts

@@ -3,6 +3,7 @@ import { AuditCacheLive } from "#services/AuditCache.ts";
 import { Credentials, CredentialsLive, CredentialsUnavailable } from "#services/Credentials.ts";
 import { JevLive } from "#services/Jev.http.ts";
 import { SourceWalkerLive } from "#services/SourceWalker.ts";
+import { Status } from "#services/Status.ts";
 import {
   type AuditPlan,
   executeAudit,
@@ -61,10 +62,31 @@ class ContradictionsReported extends Schema.TaggedError<ContradictionsReported>(
   readonly [Runtime.errorReported] = false;
 }
 
-const preset = Flag.choice("preset", presetNames).pipe(
-  Flag.optional,
+/** The names each `--preset` gives, split at commas: `--preset effect,alchemy` gives two. */
+const presetsIn = (values: ReadonlyArray<string>): ReadonlyArray<string> =>
+  values
+    .flatMap((value) => value.split(","))
+    .map((name) => name.trim())
+    .filter((name) => name.length > 0);
+
+const isPresetName = (name: string): name is PresetName =>
+  (presetNames as ReadonlyArray<string>).includes(name);
+
+const preset = Flag.string("preset").pipe(
+  Flag.atLeast(0),
+  Flag.filterMap(
+    (values): Option.Option<ReadonlyArray<PresetName>> => {
+      const names = presetsIn(values);
+      return names.every(isPresetName) ? Option.some([...new Set(names)]) : Option.none();
+    },
+    // The CLI puts this after "Expected:".
+    (values) => {
+      const unknown = presetsIn(values).filter((name) => !isPresetName(name));
+      return `one of ${presetNames.join(", ")}, or several separated by commas (not ${unknown.join(", ")})`;
+    },
+  ),
   Flag.withDescription(
-    "Add a built-in rule set, or one of its topics, such as effect/basics. With a preset, .adhere/config.ts is optional.",
+    `Add built-in rule sets, or their topics, such as effect/basics. Repeat the flag or separate names with commas, as in --preset effect,alchemy. With a preset, .adhere/config.ts is optional. (choices: ${presetNames.join(", ")})`,
   ),
 );
 
@@ -141,20 +163,51 @@ const counterFor = (plan: AuditPlan, logging: LogLevel.LogLevel) => {
   };
 };
 
+/**
+ * The status line for what a run does before its plan: walking the checkout,
+ * reading files, planning. On a terminal it is one line of stderr, redrawn at
+ * most every 100 ms and cut to the terminal's width; anywhere else, and at
+ * debug or below, whose log lines would land in it, it shows nothing.
+ */
+const statusLayer = Layer.effect(Status)(
+  Effect.gen(function* () {
+    const logging = yield* References.MinimumLogLevel;
+    if (process.stderr.isTTY !== true || !LogLevel.isGreaterThan(logging, "Debug")) {
+      return Status.defaultValue();
+    }
+    let drawn = 0;
+    let shown = false;
+    return {
+      show: (text: string) =>
+        Effect.sync(() => {
+          const now = Date.now();
+          if (now - drawn < 100) return;
+          drawn = now;
+          shown = true;
+          // A terminal that reports no width, as some report 0, gets 80 columns.
+          const width = (process.stderr.columns || 80) - 1;
+          process.stderr.write(`\r\u001b[2K${text.slice(0, width)}`);
+        }),
+      clear: Effect.sync(() => {
+        if (shown) process.stderr.write("\r\u001b[2K");
+        shown = false;
+        drawn = 0;
+      }),
+    };
+  }),
+);
+
 const force = Flag.boolean("force").pipe(
   Flag.withDefault(false),
   Flag.withDescription("Overwrite existing scaffold files."),
 );
 
-const chosenPresets = (flag: Option.Option<PresetName>): ReadonlyArray<PresetName> =>
-  Option.isSome(flag) ? [flag.value] : [];
-
 export const auditLayer = (overrides: Overrides, filter: ReadonlyArray<string> = []) =>
   Layer.mergeAll(
     SourceWalkerLive(filter),
     AuditCacheLive,
     JevLive.pipe(Layer.provide([FetchHttpClient.layer, CredentialsLive])),
-  ).pipe(Layer.provideMerge(AdhereConfigLive(overrides)));
+  ).pipe(Layer.provideMerge(AdhereConfigLive(overrides)), Layer.provideMerge(statusLayer));
 
 /** `adhere lint`: the audit. */
 export const lintCommand = Command.make(
@@ -200,7 +253,7 @@ export const lintCommand = Command.make(
   Command.provide((input) =>
     auditLayer(
       {
-        presets: chosenPresets(input.preset),
+        presets: input.preset,
         threshold: Option.getOrUndefined(input.threshold),
         rpm: Option.getOrUndefined(input.rpm),
       },
@@ -214,7 +267,7 @@ export const validateLayer = (overrides: Overrides) =>
   Layer.merge(
     JevLive.pipe(Layer.provide([FetchHttpClient.layer, CredentialsLive])),
     AuditCacheLive,
-  ).pipe(Layer.provideMerge(AdhereConfigLive(overrides)));
+  ).pipe(Layer.provideMerge(AdhereConfigLive(overrides)), Layer.provideMerge(statusLayer));
 
 /**
  * `adhere validate`: everything `lint` loads, then how each rule's wording
@@ -250,7 +303,7 @@ export const validateCommand = Command.make("validate", { preset }, () =>
   Command.withDescription(
     "Load the config, rule files, and presets the way lint does, check each rule's wording against the README's rule writing tips, report the rules lint's linter check flags, then ask Jev whether any two rules that apply to the same files contradict each other.",
   ),
-  Command.provide((input) => validateLayer({ presets: chosenPresets(input.preset) })),
+  Command.provide((input) => validateLayer({ presets: input.preset })),
 );
 
 /** `adhere init`: the scaffold. */

package/src/contradictions.ts

@@ -1,4 +1,4 @@
-import type { RuleEntry } from "#rules.ts";
+import { type RuleEntry, shownId } from "#rules.ts";
 import { Jev, type Pair } from "#services/Jev.ts";
 import { Effect } from "effect";
 
@@ -69,7 +69,9 @@ export const findContradictions = Effect.fn("findContradictions")(function* (
   });
 });
 
-const locationOf = (entry: RuleEntry): string => `${entry.id} (${entry.file ?? entry.scope})`;
+/** Where a rule lives: a preset's names the preset in its id; the project's own rule names its file. */
+const locationOf = (entry: RuleEntry): string =>
+  entry.preset === undefined ? `${entry.id} (${entry.file ?? entry.scope})` : shownId(entry);
 
 export const formatContradictions = (contradictions: ReadonlyArray<Contradiction>): string => {
   if (contradictions.length === 0) {

package/src/mechanical.ts

@@ -1,5 +1,5 @@
 import type { Rule } from "#config.ts";
-import type { RuleEntry } from "#rules.ts";
+import { type RuleEntry, shownId } from "#rules.ts";
 import { AuditCache, sha256, type Tally } from "#services/AuditCache.ts";
 import { linterQuestion } from "#services/Jev.ts";
 import { Effect } from "effect";
@@ -76,7 +76,7 @@ export const formatLinterCheck = (
       : [
           `${flagged.length} ${flagged.length === 1 ? "rule" : "rules"} flagged by the linter check:`,
           ...flagged.flatMap((one) => [
-            `  ${one.entry.id}${one.entry.file === undefined ? "" : ` (${displayPath(one.entry.file, root)})`}`,
+            `  ${shownId(one.entry)}${one.entry.file === undefined ? "" : ` (${displayPath(one.entry.file, root)})`}`,
             `    ${adviceOf(one)}`,
           ]),
         ]),

package/src/presets.ts

@@ -57,4 +57,7 @@ export const presets: Readonly<Record<WholePreset, BuiltInPreset>> = {
 };
 
 /** The directory each whole preset reads, for checking `topics` against it. */
+/** The whole preset a name belongs to: effect, for effect and for effect/basics alike. */
+export const wholePresetOf = (name: PresetName): string => name.split("/")[0] ?? name;
+
 export const topicsOf = (preset: WholePreset): ReadonlyArray<string> => topics[preset];

package/src/pricing.ts

@@ -0,0 +1,14 @@
+/**
+ * Jev's price for input tokens, in dollars per million, by the name a config
+ * sends as its model. Output tokens are free. From TypeSafe AI's models page,
+ * https://docs.typesafe.ai/models, on 2026-09-25, when jev-latest and
+ * jev-preview both pointed to jev-1.13.0.
+ */
+const DOLLARS_PER_MILLION: Readonly<Record<string, number>> = {
+  "jev-1.13.0": 0.042,
+  "jev-latest": 0.042,
+  "jev-preview": 0.042,
+};
+
+/** The model's price per million input tokens, when adhere knows it. */
+export const priceOf = (model: string): number | undefined => DOLLARS_PER_MILLION[model];

package/src/rules.ts

@@ -6,6 +6,8 @@ import {
   SKIPPED_DIRECTORIES,
 } from "#config.ts";
 import { parseRuleMarkdown } from "#markdown.ts";
+import { walkFiles } from "#walk.ts";
+import { clearingStatus, countOf, Status } from "#services/Status.ts";
 import { Effect, FileSystem, Path, Record } from "effect";
 
 const refused = (directory: string) => (problem: { readonly message: string }) =>
@@ -18,10 +20,19 @@ export interface RuleEntry {
   readonly rule: Rule;
   readonly scope: string;
   readonly file?: string;
-  /** The built-in rule set the rule came from, when it is not the project's own. */
+  /** The built-in preset the rule came from, by its whole name (effect for effect/basics), when it is not the project's own. */
   readonly preset?: string;
 }
 
+/**
+ * A rule's id as output shows it: a preset's rule with the preset's name
+ * first, as in effect/basics/external-calls-are-resilient, so a report that
+ * mixes presets with the project's own rules says where each came from. The
+ * project's own rules show their `.adhere/` ids as they are.
+ */
+export const shownId = (entry: { readonly id: RuleId; readonly preset?: string }): string =>
+  entry.preset === undefined ? entry.id : `${entry.preset}/${entry.id}`;
+
 export type RuleSet = ReadonlyArray<RuleEntry>;
 
 const ADHERE_SEGMENT = ".adhere";
@@ -36,6 +47,21 @@ const segmentsOf = (relative: string): ReadonlyArray<string> =>
 
 const isMarkdown = (path: string): boolean => path.endsWith(".md");
 
+/**
+ * Whether the rule walk reads into a directory: on the way to a `.adhere/`,
+ * not a skipped tree or `.git`; inside one, anything but its cache, since a
+ * directory there such as `.adhere/e2e/` is a rule topic.
+ */
+const entersForRules = (relative: string): boolean => {
+  const segments = segmentsOf(relative);
+  const name = segments.at(-1) ?? "";
+  const adhere = segments.lastIndexOf(ADHERE_SEGMENT);
+  if (adhere >= 0 && adhere < segments.length - 1) {
+    return !(adhere === segments.length - 2 && name === CACHE_SEGMENT);
+  }
+  return name === ADHERE_SEGMENT || !(SKIPPED_DIRECTORIES.has(name) || name === ".git");
+};
+
 const isNestedRuleFile = (relative: string): boolean => {
   const segments = segmentsOf(relative);
   const adhere = segments.lastIndexOf(ADHERE_SEGMENT);
@@ -108,10 +134,15 @@ export const loadRules = Effect.fn("loadRules")(function* (directory: string) {
 export const loadAdhereRuleSet = Effect.fn("loadAdhereRuleSet")(function* (root: string) {
   const fs = yield* FileSystem.FileSystem;
   const path = yield* Path.Path;
-  const entries = yield* fs
-    .readDirectory(root, { recursive: true })
-    .pipe(Effect.mapError(refused(root)));
-  const files = entries.filter(isNestedRuleFile).sort();
+  const status = yield* Status;
+  const entries = yield* clearingStatus(
+    walkFiles(fs, path, root, entersForRules, (directories) =>
+      status.show(
+        `Looking for .adhere/ rules: ${countOf(directories, "directory", "directories")} read`,
+      ),
+    ),
+  ).pipe(Effect.mapError(refused(root)));
+  const files = entries.filter(isNestedRuleFile);
   return yield* Effect.forEach(files, (relative) =>
     Effect.gen(function* () {
       const file = joinPath(path, root, segmentsOf(relative));

package/src/services/AdhereConfig.ts

@@ -11,7 +11,7 @@ import {
   type ResolvedConfig,
   resolveConfig,
 } from "#config.ts";
-import { type PresetName, presetOf } from "#presets.ts";
+import { type PresetName, presetOf, wholePresetOf } from "#presets.ts";
 import {
   applicableRules,
   globalRuleSet,
@@ -95,7 +95,10 @@ export const AdhereConfigLive = (overrides: Overrides) =>
       ).pipe(Effect.map(Record.fromEntries));
       const resolved = resolveConfig({ ...config, rules }, overrides, registry);
       const presetEntries = Object.entries(registry).flatMap(([name, preset]) =>
-        globalRuleSet(preset.rules, cwd).map((entry) => ({ ...entry, preset: name })),
+        globalRuleSet(preset.rules, cwd).map((entry) => ({
+          ...entry,
+          preset: wholePresetOf(name as PresetName),
+        })),
       );
       yield* Effect.logDebug(
         `config: ${configFile ?? "no config file"}; presets ${Object.keys(registry).join(", ") || "none"}; ${presetEntries.length} preset and ${projectEntries.length} project rules; model ${resolved.model}, threshold ${resolved.threshold}${resolved.rpm === undefined ? "" : `, at most ${resolved.rpm} requests a minute`}`,

package/src/services/AuditCache.ts

@@ -45,13 +45,11 @@ export const Tally = Schema.Struct({
 export interface Tally extends Schema.Schema.Type<typeof Tally> {}
 const decodeTally = Schema.decodeUnknownOption(Schema.fromJsonString(Tally));
 
-/** What a run that read every file still needs from the cache. */
+/** What a run that read every file tells the cache. */
 export interface Live {
-  /** The hash of each file's content. */
+  /** The hash of each file's content, too long to judge or not. */
   readonly hashes: ReadonlySet<string>;
-  /** The fingerprint of each rule text asked about a file. */
-  readonly fingerprints: ReadonlySet<string>;
-  /** The key of each rule's tally. */
+  /** The key of each of the run's rules' tallies, to carry over from the layout before content keys. */
   readonly tallies: ReadonlySet<string>;
 }
 
@@ -84,9 +82,11 @@ export class AuditCache extends Context.Service<
     readonly tally: (key: string) => Effect.Effect<Tally | undefined>;
     readonly putTally: (key: string, tally: Tally) => Effect.Effect<void>;
     /**
-     * Deletes what `live` does not need, and folds the rest into one file per
-     * content and per tally. Only after a run that read every file: it cannot
-     * tell what the files it did not read need. Succeeds with the files deleted.
+     * Deletes the answers about content no file has, and folds the rest into
+     * one file per content and per tally. Answers to rules the run left out
+     * stay, as do their tallies: a run with other presets or rules asks them.
+     * Only after a run that read every file: it cannot tell what content the
+     * files it did not read have. Succeeds with the files deleted.
      */
     readonly prune: (live: Live) => Effect.Effect<number>;
   }
@@ -275,10 +275,7 @@ export const AuditCacheLive = Layer.effect(AuditCache)(
       // Folding replaces or removes the group being visited, which a Map's iteration allows.
       for (const group of (yield* indexes.files).keys()) {
         const entries = live.hashes.has(group) ? yield* readGroup("files", group, decodeEntry) : [];
-        const answers = Record.filter(
-          unionOf(entries.map((entry) => entry.answers)),
-          (_, fingerprint) => live.fingerprints.has(fingerprint),
-        );
+        const answers = unionOf(entries.map((entry) => entry.answers));
         deleted += yield* fold(
           "files",
           group,
@@ -286,7 +283,7 @@ export const AuditCacheLive = Layer.effect(AuditCache)(
         );
       }
       for (const key of (yield* indexes.tallies).keys()) {
-        const tallies = live.tallies.has(key) ? yield* readGroup("tallies", key, decodeTally) : [];
+        const tallies = yield* readGroup("tallies", key, decodeTally);
         deleted += yield* fold(
           "tallies",
           key,

package/src/services/Jev.ts

@@ -344,6 +344,23 @@ export const requestsOf = (body: Body): ReadonlyArray<Body> => {
   return requests.map(({ questions }) => ({ ...body, questions }));
 };
 
+/**
+ * The requests judging `rules` over a file takes, and about how many input
+ * tokens they carry, by `tokensOf`: the judge body, split to fit, as `judge`
+ * sends it, each request with the file again.
+ */
+export const judgeLoad = (
+  lines: Lines,
+  rules: Rules,
+  sampled: ReadonlyArray<RuleId> = [],
+): { readonly requests: number; readonly tokens: number } => {
+  const requests = requestsOf(judgeBody("", lines, rules, sampled));
+  return {
+    requests: requests.length,
+    tokens: requests.reduce((sum, request) => sum + tokensOf(request), 0),
+  };
+};
+
 /** The requests judging `rules` over a file takes: the judge body, split to fit, as `judge` sends it. */
 export const judgeRequests = (
   lines: Lines,

package/src/services/SourceWalker.ts

@@ -3,6 +3,8 @@ import { Context, Effect, FileSystem, Layer, Path } from "effect";
 import { ADHERE_DIRECTORY, SKIPPED_DIRECTORIES } from "#config.ts";
 import type { ScannedFile } from "#models/Audit.ts";
 import { WalkUnavailable } from "#models/Audit.ts";
+import { walkFiles } from "#walk.ts";
+import { clearingStatus, counted, countOf, Status } from "#services/Status.ts";
 
 /** Walks the repository's TypeScript source, skipping what is not ours to read. */
 export class SourceWalker extends Context.Service<
@@ -63,9 +65,15 @@ const isScannable = (file: string, self: string): boolean =>
 const refused = (problem: { readonly message: string }): WalkUnavailable =>
   WalkUnavailable.make({ message: problem.message });
 
-/** `readdir(recursive)` yields paths relative to the root it read: root them. */
+/** The walk yields paths relative to the root it read: root them. */
 const rooted = (root: string, paths: ReadonlyArray<string>) => paths.map((rel) => `${root}/${rel}`);
 
+/** Whether the walk reads into a directory: never a skipped tree, `.adhere/`, or `.git`. */
+const entersForSource = (relative: string): boolean => {
+  const name = relative.split("/").at(-1) ?? "";
+  return !(SKIPPED_DIRECTORIES.has(name) || name === ADHERE_DIRECTORY || name === ".git");
+};
+
 /** A test on a path relative to the root being read: whether the run wants it. */
 type Keep = (relative: string) => boolean;
 
@@ -76,20 +84,27 @@ const scannable = (root: string, paths: ReadonlyArray<string>, self: string, kee
     paths.filter((relative) => !isInSkippedTree(relative) && keep(relative)),
   ).filter((file) => isScannable(file, self));
 
-/** One root's paths, filtered to what the audit reads. */
-const listRoot = Effect.fn("SourceWalker.listRoot")(
-  (fs: FileSystem.FileSystem, root: string, self: string, keep: Keep) =>
-    Effect.flatMap(fs.readDirectory(root, { recursive: true }), (paths) => {
-      const files = scannable(root, paths, self, keep);
-      // The paths listed against the files kept: node_modules shows as the difference.
-      return Effect.as(
-        Effect.logDebug(
-          `listed ${root}: ${paths.length} paths, ${files.length} source files to read`,
-        ),
-        files,
-      );
-    }),
-);
+/** One root's files, filtered to what the audit reads. `label` names the root on the status line. */
+const listRoot = Effect.fn("SourceWalker.listRoot")(function* (
+  fs: FileSystem.FileSystem,
+  path: Path.Path,
+  root: string,
+  label: string,
+  self: string,
+  keep: Keep,
+) {
+  const status = yield* Status;
+  const paths = yield* walkFiles(fs, path, root, entersForSource, (directories, found) =>
+    status.show(
+      `Listing ${label}: ${countOf(directories, "directory", "directories")}, ${countOf(found, "file", "files")}`,
+    ),
+  );
+  const files = scannable(root, paths, self, keep);
+  yield* Effect.logDebug(
+    `listed ${root}: ${paths.length} files, ${files.length} source files to read`,
+  );
+  return files;
+});
 
 /** One scannable path, read into lines. */
 const readFile = Effect.fn("SourceWalker.readFile")((fs: FileSystem.FileSystem, path: string) =>
@@ -99,14 +114,42 @@ const readFile = Effect.fn("SourceWalker.readFile")((fs: FileSystem.FileSystem,
   })).pipe(Effect.tap((file) => Effect.logTrace(`read ${path}: ${file.lines.length} lines`))),
 );
 
-/** Read a batch of paths; the inner loop hoisted out of `forEach`. */
-const readEach = (fs: FileSystem.FileSystem, paths: ReadonlyArray<string>) =>
-  Effect.forEach(paths, (path: string) => readFile(fs, path));
+/** Reads a root's paths, several at a time, keeping their order, and counts them on the status line. */
+const readEach = Effect.fn("SourceWalker.readEach")(function* (
+  fs: FileSystem.FileSystem,
+  label: string,
+  paths: ReadonlyArray<string>,
+) {
+  const status = yield* Status;
+  let read = 0;
+  return yield* Effect.forEach(
+    paths,
+    (path: string) =>
+      readFile(fs, path).pipe(
+        Effect.tap(() => {
+          read += 1;
+          return status.show(
+            `Reading ${label}: ${counted(read)} of ${countOf(paths.length, "file", "files")}`,
+          );
+        }),
+      ),
+    { concurrency: 16 },
+  );
+});
 
-/** One root's files, in directory order: read every scannable path. */
+/** One root's files, in path order: read every scannable path. */
 const readRoot = Effect.fn("SourceWalker.readRoot")(
-  (fs: FileSystem.FileSystem, root: string, self: string, keep: Keep) =>
-    Effect.flatMap(listRoot(fs, root, self, keep), (paths) => readEach(fs, paths)),
+  (
+    fs: FileSystem.FileSystem,
+    path: Path.Path,
+    root: string,
+    label: string,
+    self: string,
+    keep: Keep,
+  ) =>
+    Effect.flatMap(listRoot(fs, path, root, label, self, keep), (paths) =>
+      readEach(fs, label, paths),
+    ),
 );
 
 /**
@@ -125,8 +168,9 @@ const scanDirs = Effect.fn("SourceWalker.scanDirs")(function* (
 });
 
 /**
- * The real walker: `FileSystem.readDirectory` recursively over the roots,
- * each file read and split into lines. Tests substitute their own tree.
+ * The real walker: the roots walked a directory at a time, skipped trees
+ * left unread, each file read and split into lines. Tests substitute their
+ * own tree.
  * The scan root is the current working directory, so the audit reads the
  * repository it is run in.
  */
@@ -140,11 +184,19 @@ export const SourceWalkerLive = (filter: ReadonlyArray<string> = []) =>
       const self = yield* path.fromFileUrl(new URL("../../", import.meta.url)).pipe(Effect.orDie);
       const walk = Effect.fn("SourceWalker.files")(function* () {
         const dirs = yield* scanDirs(fs, root).pipe(Effect.mapError(refused));
-        const trees = yield* Effect.forEach(dirs, (dir) =>
-          readRoot(fs, path.join(root, dir), self, (relative) =>
-            // Filter patterns are relative to the working directory, not the tree read.
-            passesFilter(dir === "." ? relative : `${dir}/${relative}`, filter),
-          ).pipe(Effect.mapError(refused)),
+        const trees = yield* clearingStatus(
+          Effect.forEach(dirs, (dir) =>
+            readRoot(
+              fs,
+              path,
+              path.join(root, dir),
+              dir === "." ? "the working directory" : `${dir}/`,
+              self,
+              (relative) =>
+                // Filter patterns are relative to the working directory, not the tree read.
+                passesFilter(dir === "." ? relative : `${dir}/${relative}`, filter),
+            ).pipe(Effect.mapError(refused)),
+          ),
         );
         return trees.flat();
       });

package/src/services/Status.ts

@@ -0,0 +1,31 @@
+import { Context, Effect } from "effect";
+
+export interface StatusLine {
+  /** Shows what the run is doing now, in place of what was shown before. */
+  readonly show: (text: string) => Effect.Effect<void>;
+  /** Takes the line away, before anything else is written. */
+  readonly clear: Effect.Effect<void>;
+}
+
+/**
+ * What a run is doing before it has anything to report: walking the
+ * checkout, reading files, planning. The CLI draws it as one line on
+ * stderr; wherever nothing provides it, as in tests, it shows nothing.
+ */
+export const Status = Context.Reference<StatusLine>("@drkmttr/adhere/services/Status", {
+  defaultValue: () => ({ show: () => Effect.void, clear: Effect.void }),
+});
+
+/** `effect`, with the status line cleared when it ends, however it ends. */
+export const clearingStatus = <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+  Effect.gen(function* () {
+    const status = yield* Status;
+    return yield* Effect.ensuring(effect, status.clear);
+  });
+
+/** A count as the status line shows it: 10,333. */
+export const counted = (n: number): string => n.toLocaleString("en-US");
+
+/** A count and its noun: 1 directory, 2,679 directories. */
+export const countOf = (n: number, one: string, many: string): string =>
+  `${counted(n)} ${n === 1 ? one : many}`;

package/src/walk.ts

@@ -0,0 +1,85 @@
+import { Effect, type FileSystem, type Path, type PlatformError } from "effect";
+
+/** A directory entry, as the walk sorts it: a file to list, a directory to read, or neither. */
+type Entry =
+  | { readonly kind: "file"; readonly relative: string }
+  | { readonly kind: "directory"; readonly relative: string }
+  | { readonly kind: "skipped" };
+
+const skipped: Entry = { kind: "skipped" };
+
+/**
+ * Every file under `root`, each as a path relative to it with `/` between
+ * segments, sorted. `enter` says, of each directory below the root by its
+ * relative path, whether to read into it, so a walk never lists what it would
+ * throw away.
+ *
+ * A directory reached through a symbolic link is never entered: pnpm's
+ * `node_modules` links packages into one another, and following the links
+ * lists every path through the dependency graph. A recursive `readdir` does
+ * follow them; on alchemy's checkout it passed 160 GB before the kernel
+ * killed it. A symbolic link to a file is listed like the file, and a link
+ * to nothing is left out.
+ *
+ * `progress` hears, as each directory is read, how many have been and how
+ * many files they held.
+ */
+export const walkFiles = Effect.fn("walkFiles")(function* (
+  fs: FileSystem.FileSystem,
+  path: Path.Path,
+  root: string,
+  enter: (relative: string) => boolean,
+  progress: (directories: number, files: number) => Effect.Effect<void> = () => Effect.void,
+) {
+  const entryOf = (relative: string): Effect.Effect<Entry, PlatformError.PlatformError> => {
+    const full = path.join(root, relative);
+    return fs.stat(full).pipe(
+      Effect.flatMap((info): Effect.Effect<Entry> => {
+        if (info.type !== "Directory") return Effect.succeed({ kind: "file", relative });
+        if (!enter(relative)) return Effect.succeed(skipped);
+        // Only a link can be read as one, so a failed read is a real directory.
+        return fs.readLink(full).pipe(
+          Effect.match({
+            onFailure: (): Entry => ({ kind: "directory", relative }),
+            onSuccess: (): Entry => skipped,
+          }),
+        );
+      }),
+      Effect.catchIf(
+        (problem) => problem.reason._tag === "NotFound",
+        () => Effect.succeed(skipped),
+      ),
+    );
+  };
+
+  const files: Array<string> = [];
+  let directories = 0;
+  let level: ReadonlyArray<string> = [""];
+  while (level.length > 0) {
+    const next: Array<string> = [];
+    yield* Effect.forEach(
+      level,
+      (directory) =>
+        fs.readDirectory(directory === "" ? root : path.join(root, directory)).pipe(
+          Effect.flatMap((names) =>
+            Effect.forEach(
+              names,
+              (name) => entryOf(directory === "" ? name : `${directory}/${name}`),
+              { concurrency: 16 },
+            ),
+          ),
+          Effect.flatMap((entries) => {
+            for (const entry of entries) {
+              if (entry.kind === "file") files.push(entry.relative);
+              else if (entry.kind === "directory") next.push(entry.relative);
+            }
+            directories += 1;
+            return progress(directories, files.length);
+          }),
+        ),
+      { concurrency: 8, discard: true },
+    );
+    level = next;
+  }
+  return files.sort();
+});

package/src/wording.ts

@@ -1,5 +1,5 @@
 import { type Example, examplesOf, type Rule } from "#config.ts";
-import type { RuleEntry } from "#rules.ts";
+import { type RuleEntry, shownId } from "#rules.ts";
 
 type Word = Example["word"];
 
@@ -83,7 +83,7 @@ export const formatStrays = (strays: ReadonlyArray<Stray>, root: string): Readon
     : [
         `${strays.length} ${strays.length === 1 ? "rule is" : "rules are"} not worded as the rule writing tips recommend:`,
         ...strays.flatMap(({ entry, straying }) => [
-          `  ${entry.id}${entry.file === undefined ? "" : ` (${displayPath(entry.file, root)})`}`,
+          `  ${shownId(entry)}${entry.file === undefined ? "" : ` (${displayPath(entry.file, root)})`}`,
           ...straying.map((one) => `    ${sentenceOf(one)}`),
         ]),
         `Rule writing tips: ${TIPS_URL}`,

package/src/workflows/audit.ts

@@ -9,6 +9,7 @@ import {
   JevUnavailable,
   type Judged,
   judgeQuestion,
+  judgeLoad,
   judgeRequests,
   linterQuestion,
   locateRequests,
@@ -16,12 +17,16 @@ import {
   tokensOf,
 } from "#services/Jev.ts";
 import { SourceWalker } from "#services/SourceWalker.ts";
+import { clearingStatus, counted, countOf, Status } from "#services/Status.ts";
 import { SAMPLE, tallyKeyOf } from "#mechanical.ts";
+import { priceOf } from "#pricing.ts";
 import { applicableRules } from "#rules.ts";
 import { type Crypto, Duration, Effect, Record, Result, Semaphore } from "effect";
 
 export interface Finding {
   readonly rule: RuleId;
+  /** The preset the rule came from, when it is not the project's own. */
+  readonly preset?: string;
   readonly description: string;
   readonly examples: Examples;
   readonly file: string;
@@ -59,6 +64,8 @@ interface PreparedRule {
   readonly rule: Rule;
   readonly fingerprint: string;
   readonly threshold: number;
+  /** The preset the rule came from, when it is not the project's own. */
+  readonly preset?: string;
 }
 
 const fileResult = (
@@ -107,6 +114,10 @@ export interface AuditPlan {
   readonly deferred: number;
   /** Requests to Jev that judging the other checks takes. Locating findings adds 1 or more per file. */
   readonly requests: number;
+  /** About how many input tokens those requests carry, which Jev charges for. */
+  readonly tokens: number;
+  /** The model's price per million input tokens, in dollars, when adhere knows it. */
+  readonly price?: number;
 }
 
 /** A file finished, for a progress counter: the requests it took and the findings it has. */
@@ -174,13 +185,15 @@ export const planAudit = (
 
     const planFile = Effect.fn("audit.plan")(function* (file: ScannedFile) {
       const rules = configuredRules(file.path);
+      // Hashed even when skipped, so a prune keeps what other runs know of its content.
+      const hash = yield* sha256(file.lines.join("\n"));
       // Too long for Jev's context: skipped and counted, rather than refused mid-run.
       if (!fits(file.lines, rules)) {
         yield* Effect.logTrace(`plan ${file.path}: too long for Jev's context, skipped`);
         return {
           file,
           skipped: true,
-          hash: "",
+          hash,
           prepared: {},
           kept: {},
           pending: {},
@@ -191,13 +204,19 @@ export const planAudit = (
       const prepared: Record<RuleId, PreparedRule> = yield* Effect.forEach(
         Object.entries(rules),
         ([id, rule]) =>
-          Effect.map(
-            fingerprintOf(config.model, rule),
-            (fingerprint) =>
-              [id, { rule, fingerprint, threshold: rule.threshold ?? config.threshold }] as const,
-          ),
+          Effect.map(fingerprintOf(config.model, rule), (fingerprint) => {
+            const preset = presetOfRule.get(rule);
+            return [
+              id,
+              {
+                rule,
+                fingerprint,
+                threshold: rule.threshold ?? config.threshold,
+                ...(preset === undefined ? {} : { preset }),
+              },
+            ] as const;
+          }),
       ).pipe(Effect.map(Record.fromEntries));
-      const hash = yield* sha256(file.lines.join("\n"));
       const answers = yield* cache.get(hash, file.path);
       const kept: Record<RuleId, Judgment> = Record.filterMap(prepared, ({ fingerprint }) => {
         const answer = answers[fingerprint];
@@ -219,6 +238,12 @@ export const planAudit = (
       } satisfies FilePlan;
     });
 
+    // Each preset's rule, with the preset it came from, for its findings to name.
+    const presetOfRule = new Map(
+      (config.scopedRules ?? []).flatMap((entry) =>
+        entry.preset === undefined ? [] : [[entry.rule, entry.preset] as const],
+      ),
+    );
     // Preset rules are not the project's to change, so the linter check leaves them out.
     const presetRules = new Set(
       (config.scopedRules ?? []).flatMap((entry) =>
@@ -281,13 +306,33 @@ export const planAudit = (
     });
 
     const sorted = [...files].sort((a, b) => a.path.localeCompare(b.path));
-    const everything: ReadonlyArray<FilePlan> = yield* Effect.forEach(sorted, planFile, {
-      concurrency: 8,
-    });
+    const status = yield* Status;
+    let done = 0;
+    const everything: ReadonlyArray<FilePlan> = yield* clearingStatus(
+      Effect.forEach(
+        sorted,
+        (file) =>
+          planFile(file).pipe(
+            Effect.tap(() => {
+              done += 1;
+              return status.show(
+                `Planning: ${counted(done)} of ${countOf(sorted.length, "file", "files")}`,
+              );
+            }),
+          ),
+        { concurrency: 8 },
+      ),
+    );
     const limited =
       options.limit === undefined ? everything : withinLimit(everything, options.limit);
     const planned = yield* withSamples(limited);
     const judged = planned.filter((plan) => !plan.skipped);
+    const loads = judged.map((plan) =>
+      isEmpty(plan.pending)
+        ? { requests: 0, tokens: 0 }
+        : judgeLoad(plan.file.lines, rulesOf(plan.pending), Object.keys(plan.sampled)),
+    );
+    const price = priceOf(config.model);
     const total = (count: (plan: FilePlan) => number) =>
       judged.reduce((sum, plan) => sum + count(plan), 0);
     return {
@@ -297,11 +342,9 @@ export const planAudit = (
       cached: total((plan) => sizeOf(plan.kept)),
       skipped: planned.length - judged.length,
       deferred: total((plan) => plan.deferred),
-      requests: total((plan) =>
-        isEmpty(plan.pending)
-          ? 0
-          : judgeRequests(plan.file.lines, rulesOf(plan.pending), Object.keys(plan.sampled)),
-      ),
+      requests: loads.reduce((sum, load) => sum + load.requests, 0),
+      tokens: loads.reduce((sum, load) => sum + load.tokens, 0),
+      ...(price === undefined ? {} : { price }),
     };
   });
 
@@ -401,6 +444,7 @@ export const executeAudit = (
             ? [
                 {
                   rule: id,
+                  ...(k.preset === undefined ? {} : { preset: k.preset }),
                   description: k.rule.description,
                   examples: examplesOf(k.rule),
                   file: file.path,
@@ -486,22 +530,21 @@ export const executeAudit = (
   });
 
 /**
- * Deletes from the cache what the files and rules of a run no longer need:
- * answers about content no file has, answers to rule texts no rule asks, and
- * tallies of rules gone. Only after a run that read every file; a run narrowed
- * by `--filter` cannot tell what the files it left out need.
+ * Deletes from the cache the answers about content no file has anymore.
+ * Answers to rules the run left out stay, since a run with other presets or
+ * rules asks them. Only after a run that read every file; a run narrowed by
+ * `--filter` cannot tell what content the files it left out have.
  */
 export const pruneCache = Effect.fn("audit.prune")(function* (plan: AuditPlan) {
   const config = yield* AdhereConfig;
   const cache = yield* AuditCache;
-  const read = plan.files.filter((file) => !file.skipped);
-  const prepared = read.flatMap((file) => Object.values(file.prepared));
+  const prepared = plan.files.flatMap((file) => Object.values(file.prepared));
   const tallies = yield* Effect.forEach(new Set(prepared.map(({ rule }) => rule)), (rule) =>
     tallyKeyOf(config.model, rule),
   );
   const deleted = yield* cache.prune({
-    hashes: new Set(read.map((file) => file.hash)),
-    fingerprints: new Set(prepared.map(({ fingerprint }) => fingerprint)),
+    // A file too long to judge counts: a run with shorter questions judges it.
+    hashes: new Set(plan.files.map((file) => file.hash)),
     tallies: new Set(tallies),
   });
   yield* Effect.logDebug(`cache pruned: ${deleted} ${deleted === 1 ? "file" : "files"} deleted`);

package/src/workflows/format.ts

@@ -1,4 +1,5 @@
 import { type Kind, tokenize } from "#highlight.ts";
+import { shownId } from "#rules.ts";
 import type { AuditPlan, AuditResult, FileDone, Finding } from "#workflows/audit.ts";
 
 /**
@@ -91,7 +92,7 @@ const header = (finding: Finding): Line => [
   span("  "),
   span("×", "error"),
   span(" "),
-  span(finding.rule, "error"),
+  span(shownId({ id: finding.rule, preset: finding.preset }), "error"),
   span(" ("),
   span(finding.probability.toFixed(2), "probability"),
   span("): "),
@@ -224,6 +225,41 @@ const durationAt = (requests: number, rpm: number): string => {
     : counted(Math.round(seconds / 60), "minute", "minutes");
 };
 
+/** A number to one decimal place, without a trailing .0: 3.2, 43. */
+const tenths = (n: number): string => Number(n.toFixed(1)).toLocaleString("en-US");
+
+/** A token count as the plan says it: 612, 41,000, 3.2 million, 43 million, 1.1 billion. */
+const tokensSaid = (tokens: number): string =>
+  tokens >= 1e9
+    ? `${tenths(tokens / 1e9)} billion`
+    : tokens >= 1e6
+      ? `${tenths(tokens / 1e6)} million`
+      : tokens >= 1e3
+        ? (Math.round(tokens / 1e3) * 1e3).toLocaleString("en-US")
+        : tokens.toLocaleString("en-US");
+
+/** An estimated cost as the plan says it: under $0.01, about $0.14, about $1,234. */
+const dollars = (amount: number): string =>
+  amount < 0.01
+    ? "under $0.01"
+    : amount < 100
+      ? `about $${amount.toFixed(2)}`
+      : `about $${Math.round(amount).toLocaleString("en-US")}`;
+
+/** What judging the plan costs at the model's price, when adhere knows it. */
+const costOf = (plan: AuditPlan): number | undefined =>
+  plan.price === undefined ? undefined : (plan.tokens / 1e6) * plan.price;
+
+/** The plan's input tokens and their cost; locating findings comes on top, since it depends on the findings. */
+const costLine = (plan: AuditPlan): string => {
+  const cost = costOf(plan);
+  const priced =
+    cost === undefined || plan.price === undefined
+      ? ""
+      : `: ${dollars(cost)} at $${plan.price} per million`;
+  return `Those carry about ${tokensSaid(plan.tokens)} input tokens${priced}, and more for locating findings.`;
+};
+
 export const describePlan = (plan: AuditPlan, limits: RunLimits = {}): ReadonlyArray<string> => {
   const cached = plan.cached > 0 ? `, ${plan.cached} cached` : "";
   const skipped =
@@ -260,12 +296,16 @@ export const describePlan = (plan: AuditPlan, limits: RunLimits = {}): ReadonlyA
   return [
     found,
     `Judging ${rest} takes ${counted(plan.requests, "request", "requests")} to Jev, plus 1 or more for each file with a finding.${pace}${waiting}`,
+    ...(plan.tokens > 0 ? [costLine(plan)] : []),
   ];
 };
 
 /** The question before a run sends anything. */
-export const sendQuestion = (plan: AuditPlan): string =>
-  `Send ${counted(plan.requests, "request", "requests")} to Jev?`;
+export const sendQuestion = (plan: AuditPlan): string => {
+  const cost = costOf(plan);
+  const priced = cost === undefined || plan.tokens === 0 ? "" : `, ${dollars(cost)}`;
+  return `Send ${counted(plan.requests, "request", "requests")} to Jev${priced}?`;
+};
 
 /** A run's progress so far: every file it finished, with the requests and findings they added up to. */
 export interface Progress {