@drkmttr/adhere 0.7.3 → 0.9.0

package/src/mechanical.ts

@@ -0,0 +1,89 @@
+import type { Rule } from "#config.ts";
+import type { RuleEntry } from "#rules.ts";
+import { AuditCache, sha256, type Tally } from "#services/AuditCache.ts";
+import { linterQuestion } from "#services/Jev.ts";
+import { Effect } from "effect";
+
+/**
+ * The linter check asks, beside a rule's judge question, whether a regular
+ * linter could have decided the file against the rule. The answer is about
+ * the rule, so lint asks it on this many files per rule and then stops.
+ */
+export const SAMPLE = 10;
+
+/** A tally's key: the model and the question, which carries the rule, so an edited rule starts over. */
+export const tallyKeyOf = (model: string, rule: Rule) =>
+  sha256(`${model}\u0000${JSON.stringify(linterQuestion(rule))}`);
+
+/** A rule and its linter check so far: the files lint asked on, and how many Jev said a linter could check. */
+export interface Tallied {
+  readonly entry: RuleEntry;
+  readonly asked: number;
+  readonly flagged: number;
+}
+
+export const talliedOf = (entry: RuleEntry, tally: Tally | undefined): Tallied => {
+  const answers = Object.values(tally?.files ?? {});
+  return { entry, asked: answers.length, flagged: answers.filter((p) => p > 0.5).length };
+};
+
+/** The project's rules with their tallies. A preset's rules are left out: they are not the user's to change. */
+export const tallyProjectRules = Effect.fn("mechanical.tally")(function* (
+  entries: ReadonlyArray<RuleEntry>,
+  model: string,
+) {
+  const cache = yield* AuditCache;
+  return yield* Effect.forEach(
+    entries.filter((entry) => entry.preset === undefined),
+    (entry) =>
+      Effect.map(Effect.flatMap(tallyKeyOf(model, entry.rule), cache.tally), (tally) =>
+        talliedOf(entry, tally),
+      ),
+  );
+});
+
+/**
+ * Of a full sample, the share Jev said a linter could check: from 0.7 a
+ * linter should probably check the rule, and from 0.3 the rule reads
+ * differently from file to file.
+ */
+const LINTER = 0.7;
+const MIXED = 0.3;
+
+const displayPath = (file: string, root: string): string =>
+  file.startsWith(`${root}/`) ? file.slice(root.length + 1) : file;
+
+/** One flagged rule's advice, from its tally. */
+const adviceOf = ({ asked, flagged }: Tallied): string =>
+  flagged >= LINTER * asked
+    ? `Flagged on ${flagged} of ${asked} files: a regular linter should probably check this rule.`
+    : `Flagged on ${flagged} of ${asked} files: say more precisely what the rule applies to.`;
+
+/** The linter check's part of `adhere validate`'s report: each rule it flags, then any it has too few answers for. */
+export const formatLinterCheck = (
+  tallied: ReadonlyArray<Tallied>,
+  root: string,
+): ReadonlyArray<string> => {
+  if (tallied.length === 0) return [];
+  const sampled = tallied.filter((one) => one.asked >= SAMPLE);
+  const flagged = sampled.filter((one) => one.flagged >= MIXED * one.asked);
+  const waiting = tallied.length - sampled.length;
+  return [
+    ...(flagged.length === 0
+      ? sampled.length === 0
+        ? []
+        : ["The linter check flags no rule."]
+      : [
+          `${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)})`}`,
+            `    ${adviceOf(one)}`,
+          ]),
+        ]),
+    ...(waiting === 0
+      ? []
+      : [
+          `${waiting} ${waiting === 1 ? "rule has" : "rules have"} fewer than ${SAMPLE} answers from lint yet, which asks as it judges files.`,
+        ]),
+  ];
+};

package/src/presets.ts

@@ -7,17 +7,54 @@ import type { Preset } from "#config.ts";
  * is the check Bun's docs give for this. Measured on Bun 1.4. The `typeof`
  * guard is for Vitest, which imports this module on Node.
  */
-const isStandaloneExecutable =
-  typeof Bun !== "undefined" && Bun.isStandaloneExecutable;
+const isStandaloneExecutable = typeof Bun !== "undefined" && Bun.isStandaloneExecutable;
 
 const presetsRoot = isStandaloneExecutable
   ? new URL("./presets/", import.meta.url)
   : new URL("../presets/", import.meta.url);
 
-/** Built-in rule sets, each a directory of Markdown rule files in `presets/`. */
-export const presets = {
-  effect: { rules: new URL("effect/", presetsRoot) },
-} as const satisfies Record<string, Preset>;
+/**
+ * Built-in rule sets, each a directory of Markdown rule files in `presets/`,
+ * and the topics each divides into: its subdirectories.
+ */
+const topics = {
+  effect: ["basics", "config", "data", "errors", "services", "testing"],
+  alchemy: ["apis", "data", "durable", "providers", "resources", "runtime", "secrets", "security"],
+} as const;
+
+type Topics = typeof topics;
+type WholePreset = keyof Topics;
+
+/** A whole preset, `effect`, or one of its topics, `effect/basics`. */
+export type PresetName = { [P in WholePreset]: P | `${P}/${Topics[P][number]}` }[WholePreset];
+
+export const presetNames: ReadonlyArray<PresetName> = Object.entries(topics).flatMap(
+  ([preset, names]) => [preset, ...names.map((topic) => `${preset}/${topic}`)],
+) as ReadonlyArray<PresetName>;
+
+/** A built-in preset. With `topic`, only the rules under that subdirectory apply. */
+export interface BuiltInPreset extends Preset {
+  readonly rules: URL;
+  readonly topic?: string;
+}
+
+/**
+ * A topic's rules keep the ids they have in the whole preset, so
+ * `effect/basics` and `effect` judge `basics/gen-for-sequencing` alike and
+ * share its cached answers.
+ */
+export const presetOf = (name: PresetName): BuiltInPreset => {
+  const [preset = name, topic] = name.split("/");
+  return {
+    rules: new URL(`${preset}/`, presetsRoot),
+    ...(topic === undefined ? {} : { topic }),
+  };
+};
+
+export const presets: Readonly<Record<WholePreset, BuiltInPreset>> = {
+  effect: presetOf("effect"),
+  alchemy: presetOf("alchemy"),
+};
 
-export const presetNames = ["effect"] as const satisfies ReadonlyArray<keyof typeof presets>;
-export type PresetName = (typeof presetNames)[number];
+/** The directory each whole preset reads, for checking `topics` against it. */
+export const topicsOf = (preset: WholePreset): ReadonlyArray<string> => topics[preset];

package/src/rules.ts

@@ -18,6 +18,8 @@ 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. */
+  readonly preset?: string;
 }
 
 export type RuleSet = ReadonlyArray<RuleEntry>;

package/src/services/AdhereConfig.ts

@@ -11,7 +11,7 @@ import {
   type ResolvedConfig,
   resolveConfig,
 } from "#config.ts";
-import { type PresetName, presets } from "#presets.ts";
+import { type PresetName, presetOf } from "#presets.ts";
 import {
   applicableRules,
   globalRuleSet,
@@ -21,10 +21,9 @@ import {
 } from "#rules.ts";
 import { Context, Effect, FileSystem, Layer, Path, Record } from "effect";
 
-export class AdhereConfig extends Context.Service<
-  AdhereConfig,
-  ResolvedConfig
->()("@drkmttr/adhere/services/AdhereConfig") {}
+export class AdhereConfig extends Context.Service<AdhereConfig, ResolvedConfig>()(
+  "@drkmttr/adhere/services/AdhereConfig",
+) {}
 
 const loadConfigFile = Effect.fn("AdhereConfig.load")(function* (file: string) {
   const path = yield* Path.Path;
@@ -44,8 +43,10 @@ const loadConfigFile = Effect.fn("AdhereConfig.load")(function* (file: string) {
 });
 
 const loadPreset = Effect.fn("AdhereConfig.loadPreset")(function* (name: PresetName, base: string) {
-  const preset: Preset = presets[name];
-  const rules = yield* materializeRules(preset.rules, base);
+  const { topic, ...preset } = presetOf(name);
+  const all = yield* materializeRules(preset.rules, base);
+  const rules =
+    topic === undefined ? all : Record.filter(all, (_, id) => id.startsWith(`${topic}/`));
   return [name, { ...preset, rules } satisfies Loaded<Preset>] as const;
 });
 
@@ -72,14 +73,12 @@ export const AdhereConfigLive = (overrides: Overrides) =>
         });
       }
       const configFile = found[0];
-      const hasPreset =
-        overrides.presets !== undefined && overrides.presets.length > 0;
+      const hasPreset = overrides.presets !== undefined && overrides.presets.length > 0;
       const config: Decoded =
         configFile === undefined
           ? yield* decodeConfig({})
           : yield* loadConfigFile(path.join(cwd, configFile));
-      const discoveredEntries =
-        config.rules === undefined ? yield* loadAdhereRuleSet(cwd) : [];
+      const discoveredEntries = config.rules === undefined ? yield* loadAdhereRuleSet(cwd) : [];
       const hasProjectRules = discoveredEntries.length > 0;
       if (configFile === undefined && !hasProjectRules && !hasPreset) {
         return yield* ConfigUnavailable.make({
@@ -89,18 +88,17 @@ export const AdhereConfigLive = (overrides: Overrides) =>
       const projectEntries: RuleSet =
         config.rules === undefined
           ? discoveredEntries
-          : globalRuleSet(
-              yield* materializeRules(config.rules ?? {}, cwd),
-              cwd,
-            );
+          : globalRuleSet(yield* materializeRules(config.rules ?? {}, cwd), cwd);
       const rules = applicableRules(cwd, projectEntries);
-      const registry = yield* Effect.forEach(
-        presetsOf(config, overrides),
-        (name) => loadPreset(name, cwd),
+      const registry = yield* Effect.forEach(presetsOf(config, overrides), (name) =>
+        loadPreset(name, cwd),
       ).pipe(Effect.map(Record.fromEntries));
       const resolved = resolveConfig({ ...config, rules }, overrides, registry);
-      const presetEntries = Object.entries(registry).flatMap(([, preset]) =>
-        globalRuleSet(preset.rules, cwd),
+      const presetEntries = Object.entries(registry).flatMap(([name, preset]) =>
+        globalRuleSet(preset.rules, cwd).map((entry) => ({ ...entry, preset: name })),
+      );
+      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`}`,
       );
       return AdhereConfig.of({
         ...resolved,

package/src/services/AuditCache.ts

@@ -1,21 +1,60 @@
 import { CACHE_DIRECTORY } from "#config.ts";
-import { Context, Crypto, Effect, Layer, Option, Path, Schema } from "effect";
-import * as KeyValueStore from "effect/unstable/persistence/KeyValueStore";
+import { Context, Crypto, Effect, FileSystem, Layer, Option, Path, Record, Schema } from "effect";
 
+/** A rule's judgment as a run holds it: Jev's answer, with the fingerprint of the rule's text. */
 export const Judgment = Schema.Struct({
   fingerprint: Schema.String,
   probability: Schema.Finite,
   line: Schema.optionalKey(Schema.Finite),
-  snippet: Schema.optionalKey(Schema.String),
 });
 export interface Judgment extends Schema.Schema.Type<typeof Judgment> {}
 
+/**
+ * An entry as adhere wrote it before the cache was keyed by content: one per
+ * file, under the hash of the file's absolute path. Read only to carry its
+ * judgments over. Entries written before the report read its excerpt from the
+ * file also hold the line's text, as `snippet`; decoding drops it.
+ */
 export const CacheEntry = Schema.Struct({
   hash: Schema.String,
   judgments: Schema.Record(Schema.String, Judgment),
 });
 export interface CacheEntry extends Schema.Schema.Type<typeof CacheEntry> {}
 
+/** Jev's answer about some code for one rule text: the probability, and the line once located. */
+export const Answer = Schema.Struct({
+  probability: Schema.Finite,
+  line: Schema.optionalKey(Schema.Finite),
+});
+export interface Answer extends Schema.Schema.Type<typeof Answer> {}
+
+/** Answers about one file's content, each under the fingerprint of the rule text it answers. */
+export type Answers = Readonly<Record<string, Answer>>;
+
+const Entry = Schema.Struct({ answers: Schema.Record(Schema.String, Answer) });
+const decodeEntry = Schema.decodeUnknownOption(Schema.fromJsonString(Entry));
+const decodeOldEntry = Schema.decodeUnknownOption(Schema.fromJsonString(CacheEntry));
+
+/**
+ * A rule's linter check so far: per file lint asked it on, Jev's probability
+ * that a regular linter could have decided the file against the rule.
+ */
+export const Tally = Schema.Struct({
+  files: Schema.Record(Schema.String, Schema.Finite),
+});
+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. */
+export interface Live {
+  /** The hash of each file's content. */
+  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. */
+  readonly tallies: ReadonlySet<string>;
+}
+
 const hexOf = (bytes: Uint8Array): string =>
   Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
 
@@ -25,38 +64,248 @@ export const sha256 = Effect.fn("AuditCache.sha256")(function* (text: string) {
   return hexOf(digest);
 });
 
+/** Judgments by rule, as the answers the cache keeps: by the fingerprint of each rule's text. */
+export const answersOf = (judgments: Readonly<Record<string, Judgment>>): Answers =>
+  Object.fromEntries(
+    Object.values(judgments).map(({ fingerprint, ...answer }) => [fingerprint, answer]),
+  );
+
 export class AuditCache extends Context.Service<
   AuditCache,
   {
-    readonly get: (path: string) => Effect.Effect<CacheEntry | undefined>;
-    readonly put: (path: string, entry: CacheEntry) => Effect.Effect<void>;
+    /**
+     * Answers about content with this hash. `path` is where that content is
+     * now, to carry over an entry written before the cache was keyed by content.
+     */
+    readonly get: (hash: string, path: string) => Effect.Effect<Answers>;
+    /** Keeps answers about content with this hash, beside the ones already kept. */
+    readonly put: (hash: string, answers: Answers) => Effect.Effect<void>;
+    /** A rule's tally, under a key that changes with the rule's text. */
+    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.
+     */
+    readonly prune: (live: Live) => Effect.Effect<number>;
   }
 >()("@drkmttr/adhere/services/AuditCache") {}
 
-const openStore = Effect.fn("AuditCache.openStore")(function* (directory: string) {
-  const context = yield* Layer.build(KeyValueStore.layerFileSystem(directory)).pipe(
-    Effect.catchCause(() => Layer.build(KeyValueStore.layerMemory)),
-  );
-  return Context.get(context, KeyValueStore.KeyValueStore);
-});
+/** Keys in order, so the same content always writes the same text. */
+const sorted = <A>(record: Readonly<Record<string, A>>): Record<string, A> =>
+  Object.fromEntries(Object.entries(record).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)));
+
+const textOf = (value: unknown): string => `${JSON.stringify(value, null, 2)}\n`;
+
+/** One answer per rule text: one that has its line over one that has not, otherwise the first. */
+const unionOf = (entries: ReadonlyArray<Answers>): Answers => {
+  const union: Record<string, Answer> = {};
+  for (const answers of entries) {
+    for (const [fingerprint, answer] of Object.entries(answers)) {
+      const held = union[fingerprint];
+      if (held === undefined || (held.line === undefined && answer.line !== undefined)) {
+        union[fingerprint] = answer;
+      }
+    }
+  }
+  return union;
+};
 
+/** One answer per file, the first. */
+const tallyUnionOf = (tallies: ReadonlyArray<Tally>): Tally => {
+  const files: Record<string, number> = {};
+  for (const tally of tallies) {
+    for (const [file, probability] of Object.entries(tally.files)) files[file] ??= probability;
+  }
+  return { files };
+};
+
+/** A group's file: the group, then the hash of the file's text. */
+const NAME = /^([^.]+)\.[0-9a-f]{16}\.json$/;
+/** A file from the layout before content keys: the hash of a path or of a tally's key. */
+const OLD_NAME = /^[0-9a-f]{64}$/;
+
+/**
+ * `.adhere/cache/`, which is meant to be committed. `files/` holds answers by
+ * the content they are about, and `tallies/` the linter check's tallies, with
+ * paths from the working directory. A file is written once and never
+ * rewritten: it is named for its group, a content hash or a tally key, and for
+ * the hash of its own text. Two branches that add to a group add different
+ * files, or the same one, so git merges them without a conflict. Reading a
+ * group takes the union of its files, and pruning folds them back into one.
+ *
+ * A cache must never fail a run: whatever cannot be read counts as missing,
+ * and whatever cannot be written is left unwritten.
+ */
 export const AuditCacheLive = Layer.effect(AuditCache)(
   Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
     const path = yield* Path.Path;
-    const store = yield* openStore(path.join(path.resolve(), CACHE_DIRECTORY));
-    const entries = KeyValueStore.toSchemaStore(store, CacheEntry);
     const crypto = yield* Crypto.Crypto;
-    // Hashed keys: a raw path would name the cache file like a source file.
-    const keyOf = (filePath: string) =>
-      sha256(filePath).pipe(Effect.provideService(Crypto.Crypto, crypto));
-    return AuditCache.of({
-      get: (filePath) =>
-        Effect.flatMap(keyOf(filePath), (key) => entries.get(key)).pipe(
-          Effect.map(Option.getOrUndefined),
-          Effect.orElseSucceed(() => undefined),
+    const root = path.resolve();
+    const directory = path.join(root, CACHE_DIRECTORY);
+    const hash = (text: string) => sha256(text).pipe(Effect.provideService(Crypto.Crypto, crypto));
+
+    /** Each group's file names in one folder, listed once and kept current as files come and go. */
+    const indexOf = (folder: string) =>
+      Effect.cached(
+        fs.readDirectory(path.join(directory, folder)).pipe(
+          Effect.orElseSucceed((): ReadonlyArray<string> => []),
+          Effect.map((names) => {
+            const groups = new Map<string, Set<string>>();
+            for (const name of names) {
+              const group = NAME.exec(name)?.[1];
+              if (group !== undefined)
+                groups.set(group, (groups.get(group) ?? new Set()).add(name));
+            }
+            return groups;
+          }),
         ),
-      put: (filePath, entry) =>
-        Effect.flatMap(keyOf(filePath), (key) => entries.set(key, entry)).pipe(Effect.ignore),
+      );
+    const indexes = { files: yield* indexOf("files"), tallies: yield* indexOf("tallies") };
+    type Folder = keyof typeof indexes;
+
+    const read = <A>(decode: (text: string) => Option.Option<A>, file: string) =>
+      fs.readFileString(file).pipe(
+        Effect.map((text) => Option.getOrUndefined(decode(text))),
+        Effect.orElseSucceed(() => undefined),
+      );
+
+    /** A group's files that decode, in name order. */
+    const readGroup = Effect.fn("AuditCache.readGroup")(function* <A>(
+      folder: Folder,
+      group: string,
+      decode: (text: string) => Option.Option<A>,
+    ) {
+      const names = [...((yield* indexes[folder]).get(group) ?? [])].sort();
+      const decoded = yield* Effect.forEach(names, (name) =>
+        read(decode, path.join(directory, folder, name)),
+      );
+      return decoded.filter((value): value is A => value !== undefined);
+    });
+
+    const nameOf = (group: string, text: string) =>
+      Effect.map(hash(text), (digest) => `${group}.${digest.slice(0, 16)}.json`);
+
+    /** Adds `value` to a group as a new file, unless the group has that file already. */
+    const add = Effect.fn("AuditCache.add")(function* (
+      folder: Folder,
+      group: string,
+      value: unknown,
+    ) {
+      const text = textOf(value);
+      const name = yield* nameOf(group, text);
+      const index = yield* indexes[folder];
+      const names = index.get(group) ?? new Set<string>();
+      if (names.has(name)) return;
+      const written = yield* fs
+        .makeDirectory(path.join(directory, folder), { recursive: true })
+        .pipe(
+          Effect.andThen(fs.writeFileString(path.join(directory, folder, name), text)),
+          Effect.as(true),
+          Effect.orElseSucceed(() => false),
+        );
+      if (written) index.set(group, names.add(name));
+    });
+
+    const remove = (file: string) =>
+      fs.remove(file).pipe(
+        Effect.as(1),
+        Effect.orElseSucceed(() => 0),
+      );
+
+    /** Replaces a group's files with one holding `value`, or with none. Succeeds with the files deleted. */
+    const fold = Effect.fn("AuditCache.fold")(function* (
+      folder: Folder,
+      group: string,
+      value: unknown,
+    ) {
+      const index = yield* indexes[folder];
+      const names = [...(index.get(group) ?? [])];
+      const keep = value === undefined ? undefined : yield* nameOf(group, textOf(value));
+      if (value !== undefined) yield* add(folder, group, value);
+      let deleted = 0;
+      for (const name of names) {
+        if (name !== keep) deleted += yield* remove(path.join(directory, folder, name));
+      }
+      if (keep === undefined) index.delete(group);
+      else index.set(group, new Set([keep]));
+      return deleted;
+    });
+
+    const relativeOf = (tally: Tally): Tally => ({
+      files: sorted(
+        Record.mapKeys(tally.files, (file) =>
+          path.isAbsolute(file) ? path.relative(root, file) : file,
+        ),
+      ),
+    });
+
+    const get = Effect.fn("AuditCache.get")(function* (contentHash: string, filePath: string) {
+      const entries = yield* readGroup("files", contentHash, decodeEntry);
+      if (entries.length > 0) return unionOf(entries.map((entry) => entry.answers));
+      // Before content keys, a file's entry sat under the hash of its absolute path.
+      const old = yield* read(decodeOldEntry, path.join(directory, yield* hash(filePath)));
+      if (old === undefined || old.hash !== contentHash) return {};
+      const answers = answersOf(old.judgments);
+      yield* add("files", contentHash, { answers: sorted(answers) });
+      return answers;
+    });
+
+    const tally = Effect.fn("AuditCache.tally")(function* (key: string) {
+      const tallies = yield* readGroup("tallies", key, decodeTally);
+      if (tallies.length > 0) {
+        const { files } = tallyUnionOf(tallies);
+        return { files: Record.mapKeys(files, (file) => path.resolve(root, file)) };
+      }
+      // Before, a tally sat under the hash of its key, with absolute paths.
+      const old = yield* read(
+        decodeTally,
+        path.join(directory, yield* hash(`\u0000tally\u0000${key}`)),
+      );
+      if (old !== undefined) yield* add("tallies", key, relativeOf(old));
+      return old;
+    });
+
+    const prune = Effect.fn("AuditCache.prune")(function* (live: Live) {
+      // Tallies still in the layout before content keys move first, so deleting what is left of it loses nothing.
+      yield* Effect.forEach(live.tallies, tally, { discard: true });
+      let deleted = 0;
+      // 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),
+        );
+        deleted += yield* fold(
+          "files",
+          group,
+          Object.keys(answers).length === 0 ? undefined : { answers: sorted(answers) },
+        );
+      }
+      for (const key of (yield* indexes.tallies).keys()) {
+        const tallies = live.tallies.has(key) ? yield* readGroup("tallies", key, decodeTally) : [];
+        deleted += yield* fold(
+          "tallies",
+          key,
+          tallies.length === 0 ? undefined : relativeOf(tallyUnionOf(tallies)),
+        );
+      }
+      const old = yield* fs.readDirectory(directory).pipe(Effect.orElseSucceed(() => []));
+      for (const name of old) {
+        if (OLD_NAME.test(name)) deleted += yield* remove(path.join(directory, name));
+      }
+      return deleted;
+    });
+
+    return AuditCache.of({
+      get,
+      put: (contentHash, answers) => add("files", contentHash, { answers: sorted(answers) }),
+      tally,
+      putTally: (key, value) => add("tallies", key, relativeOf(value)),
+      prune,
     });
   }),
 );