paperlint 2.0.0

package/lib/paper-config.harness.mjs

@@ -0,0 +1,286 @@
+/**
+ * Both halves for `lib/paper-config.mjs` — and, more broadly, for the SET of places that
+ * publish these two constants.
+ *
+ * 🔴 WHY THIS CHECK MOVED HERE FROM `hooks/hooks.harness.mjs`. There it compared three hooks
+ * against each other — and was right only as far as its COVERAGE was right. Measured
+ * 2026-09-18: there were eight declarations across five files, four per constant, and for each
+ * constant exactly one copy sat OUTSIDE the comparison (`eslint-rules/papers.mjs`,
+ * `skills/paper-pipeline/scripts/consumer.mjs`). Had they drifted, nobody would have noticed. A
+ * check that lives with the hooks could, by construction, never see the non-hooks; moving it
+ * next to the subject itself fixes that.
+ *
+ * 🔴 THE VALUES ARE IMPORTED. The previous version read them with a regex over the source, and
+ * adding `export` — an edit that changed nothing about behavior — turned it red. A pattern over
+ * code is the shadow of a declaration, and a shadow has spellings; an import gives you the
+ * value itself.
+ *
+ * ⚠️ WHERE THE RISK REMAINS, NAMED RATHER THAN HIDDEN. The carrier list below is explicit. A
+ * sixth file with its own copy will show up with nothing to compare it against. That is why a
+ * second check exists below, for COMPLETENESS: it searches the whole corpus for declarations
+ * and requires every file it finds to be on the list. Its subject is different — "is there a
+ * file I don't know about" — and a text search is legitimate for that: it looks for CANDIDATES,
+ * while the value itself is still taken by import.
+ *
+ * Run:    npx vigiles test lib/paper-config.harness.mjs
+ * Killed by: lib/paper-config.mutations.mjs
+ */
+import assert from "node:assert/strict";
+import { readFileSync, readdirSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const ROOT = resolve(HERE, "..");
+
+let n = 0;
+const check = (label, cond) => {
+  n++;
+  assert.ok(cond, label);
+};
+
+/**
+ * Every place that publishes at least one of the two constants. The three hooks duplicate them
+ * out of necessity (a compiled hook is forbidden to import anything but `vigiles/hook`); the
+ * rest re-export from `lib/paper-config.mjs` and are kept in this list for exactly one reason:
+ * so a re-export that is one day swapped back for its own declaration gets caught.
+ */
+const CARRIERS = [
+  "lib/paper-config.mjs",
+  "hooks/paper-edit-guard.hook.mjs",
+  "hooks/paper-skills-nudge.hook.mjs",
+  "hooks/paper-status-gates.hook.mjs",
+  "eslint-rules/papers.mjs",
+  "skills/paper-pipeline/scripts/consumer.mjs",
+];
+
+const loaded = await Promise.all(
+  CARRIERS.map(async (rel) => {
+    const mod = await import(pathToFileURL(join(ROOT, rel)).href);
+    return {
+      rel,
+      key: mod.CONFIG_KEY,
+      def: mod.DEFAULT_PAPERS_ROOT,
+      field: mod.PAPERS_DIR_FIELD,
+      old: mod.OLD_PAPERS_DIR_FIELD,
+      legacyKey: mod.LEGACY_CONFIG_KEY,
+    };
+  }),
+);
+
+// ── I. THE SOURCE SAYS WHAT IT SHOULD ───────────────────────────────────────────────────────
+{
+  // 🔴 THERE IS NO KEY LITERAL HERE, AND THAT IS DELIBERATE. The first version compared
+  // `src.key` against "research-paper-pipeline" right here — and by doing so made the check
+  // below, that the key equals the package name, UNKILLABLE: any corruption of the value would
+  // fail earlier, on the literal. The value is pinned in exactly one place — the one place it
+  // has a REASON to be what it is.
+  const src = loaded[0];
+  check(
+    "the source declares both constants as non-empty strings",
+    typeof src.key === "string" &&
+      src.key.length > 0 &&
+      typeof src.def === "string" &&
+      src.def.length > 0,
+  );
+  check("the default papers directory is `papers`", src.def === "papers");
+}
+
+// ── II. ALL CARRIERS AGREE WITH THE SOURCE ──────────────────────────────────────────────────
+{
+  const keys = new Set(loaded.map((c) => c.key).filter((v) => v !== undefined));
+  const defs = new Set(loaded.map((c) => c.def).filter((v) => v !== undefined));
+  check(
+    `all carriers agree on CONFIG_KEY (${[...keys].join(" / ")})`,
+    keys.size === 1,
+  );
+  check(
+    `all carriers agree on DEFAULT_PAPERS_ROOT (${[...defs].join(" / ")})`,
+    defs.size === 1,
+  );
+  // The papers-directory field name, and its old name. Only the source and the three hooks
+  // (which cannot import it) declare these; the value itself is pinned nowhere but the source,
+  // so a rename stays a one-line change there plus the hook copies this checks.
+  const fields = new Set(
+    loaded.map((c) => c.field).filter((v) => v !== undefined),
+  );
+  const olds = new Set(loaded.map((c) => c.old).filter((v) => v !== undefined));
+  check(
+    `all carriers agree on PAPERS_DIR_FIELD (${[...fields].join(" / ")})`,
+    fields.size === 1,
+  );
+  check(
+    `all carriers agree on OLD_PAPERS_DIR_FIELD (${[...olds].join(" / ")})`,
+    olds.size === 1,
+  );
+  check(
+    "every hook declares both field names — a hook without them would read an undefined field",
+    loaded
+      .filter((c) => c.rel.endsWith(".hook.mjs"))
+      .every((c) => typeof c.field === "string" && typeof c.old === "string"),
+  );
+  check(
+    "the new and the old field names differ",
+    loaded[0].field !== loaded[0].old,
+  );
+  check(
+    "and no carrier is silent about both at once — such an entry is dead weight on the list",
+    loaded.every((c) => c.key !== undefined || c.def !== undefined),
+  );
+  // The key is the PACKAGE'S NAME, not a string that merely matches it. They drift apart when
+  // the package is renamed — the consumer would declare settings under one name while a
+  // different one is read.
+  check(
+    "config key equals the package name in package.json",
+    loaded[0].key ===
+      JSON.parse(readFileSync(join(ROOT, "package.json"), "utf8")).name,
+  );
+  // The old key is still read — by the source and by each hook, which keep their own copy.
+  const legacyKeys = new Set(
+    loaded.map((c) => c.legacyKey).filter((v) => v !== undefined),
+  );
+  const { LEGACY_PACKAGE_NAME } = await import(
+    pathToFileURL(join(ROOT, "skills/paper-pipeline/scripts/consumer.mjs")).href
+  );
+  check(
+    `all carriers agree on LEGACY_CONFIG_KEY, the package's old name (${[...legacyKeys].join(" / ")})`,
+    legacyKeys.size === 1 && legacyKeys.has(LEGACY_PACKAGE_NAME),
+  );
+  check(
+    "and every hook carries it — a hook without it would ignore settings under the old key",
+    loaded
+      .filter((c) => c.rel.endsWith(".hook.mjs"))
+      .every((c) => c.legacyKey !== undefined),
+  );
+}
+
+// ── III. THE HOOKS DUPLICATE, AND THAT IS CHECKED SEPARATELY ───────────────────────────────
+// A hook that started importing the constants would compile, run, and pass the value
+// cross-check — but it would violate the `checkHookImports` contract, i.e. stop being a hook
+// with a proven capability surface. The values have nothing to do with that, so it gets its own
+// check.
+{
+  const { checkHookImports } = await import("vigiles/hook");
+  for (const rel of CARRIERS.filter((c) => c.endsWith(".hook.mjs"))) {
+    const offending = checkHookImports(
+      readFileSync(join(ROOT, rel), "utf8"),
+      rel,
+    );
+    check(
+      `${rel} pulls in nothing outside the hook vocabulary (${offending.join(", ") || "clean"})`,
+      offending.length === 0,
+    );
+  }
+}
+
+// ── IV. COMPLETENESS OF THE LIST: IS THERE A SIXTH CARRIER ─────────────────────────────────
+// The subject of this check is not the value but the EXISTENCE of a file the list doesn't know
+// about.
+{
+  const skip = new Set([
+    "node_modules",
+    ".git",
+    "dist",
+    "_build",
+    "fixtures",
+    "repro",
+  ]);
+  const declares =
+    /^(?:export )?const (?:CONFIG_KEY|DEFAULT_PAPERS_ROOT|PAPERS_DIR_FIELD|OLD_PAPERS_DIR_FIELD)\s*=/m;
+  const found = [];
+  const walk = (dir) => {
+    for (const e of readdirSync(dir, { withFileTypes: true })) {
+      if (e.name.startsWith(".") || skip.has(e.name)) continue;
+      const p = join(dir, e.name);
+      if (e.isDirectory()) walk(p);
+      else if (
+        /\.(mjs|ts)$/.test(e.name) &&
+        !/\.(harness|mutations)\.(mjs|ts)$/.test(e.name)
+      ) {
+        if (declares.test(readFileSync(p, "utf8")))
+          found.push(relative(ROOT, p));
+      }
+    }
+  };
+  walk(ROOT);
+  const unknown = found.filter((f) => !CARRIERS.includes(f));
+  check(
+    `no declaration outside the carrier list (${unknown.join(", ") || "clean"})`,
+    unknown.length === 0,
+  );
+  check(
+    "and the search itself is not empty — otherwise it is searching the wrong place, and its zero reads as all-clear",
+    found.length >= 4,
+  );
+}
+
+// ── SETTINGS_KEYS against every reader of the settings ─────────────────────────────────────
+// The settings object has readers all over the package, each reading its own keys, and the CLI
+// refuses any key not in SETTINGS_KEYS. So the list must hold every key some reader reads — or a
+// consumer's valid key is refused — and nothing no one reads. The readers are FOUND, by the AST:
+// every `[CONFIG_KEY]?.<key>` (or the literal package name in the brackets), plus every field of
+// `RppConfig`, the CLI's typed view of the same object.
+{
+  const { SETTINGS_KEYS } = await import(join(HERE, "paper-config.mjs"));
+  const ts = (await import("typescript")).default;
+  const readKeys = new Set();
+  const isConfigKey = (e) =>
+    (ts.isIdentifier(e) &&
+      (e.text === "CONFIG_KEY" || e.text === "LEGACY_CONFIG_KEY")) ||
+    (ts.isStringLiteral(e) &&
+      (e.text === "paperlint" || e.text === "research-paper-pipeline"));
+  // A read is `pkg[CONFIG_KEY]?.<key>` or `settingsOf(pkg)?.<key>` — the helper that also reads
+  // the old key.
+  const isSettings = (e) =>
+    (ts.isElementAccessExpression(e) && isConfigKey(e.argumentExpression)) ||
+    (ts.isCallExpression(e) &&
+      ts.isIdentifier(e.expression) &&
+      e.expression.text === "settingsOf");
+  const visit = (node) => {
+    if (ts.isPropertyAccessExpression(node) && isSettings(node.expression))
+      readKeys.add(node.name.text);
+    if (ts.isInterfaceDeclaration(node) && node.name.text === "RppConfig")
+      for (const m of node.members)
+        if (m.name && ts.isIdentifier(m.name)) readKeys.add(m.name.text);
+    ts.forEachChild(node, visit);
+  };
+  const skipDirs = new Set(["node_modules", "dist", "fixtures", "docs"]);
+  const scan = (dir) => {
+    for (const e of readdirSync(dir, { withFileTypes: true })) {
+      if (e.name.startsWith(".") || skipDirs.has(e.name)) continue;
+      const p = join(dir, e.name);
+      if (e.isDirectory()) scan(p);
+      else if (/\.(mjs|ts)$/.test(e.name) && !/\.harness\.mjs$/.test(e.name))
+        visit(
+          ts.createSourceFile(
+            p,
+            readFileSync(p, "utf8"),
+            ts.ScriptTarget.Latest,
+            true,
+          ),
+        );
+    }
+  };
+  scan(ROOT);
+  const listed = new Set(Object.keys(SETTINGS_KEYS));
+  const unlisted = [...readKeys].filter((k) => !listed.has(k));
+  const unread = [...listed].filter((k) => !readKeys.has(k));
+  check(
+    `🔴 every settings key some reader reads is in SETTINGS_KEYS — else a valid key is refused (${unlisted.join(", ") || "clean"})`,
+    unlisted.length === 0,
+  );
+  check(
+    `every key in SETTINGS_KEYS has a reader (${unread.join(", ") || "clean"})`,
+    unread.length === 0,
+  );
+  check(
+    "and the scan found the readers it must find — the skill scripts' keys and RppConfig's",
+    ["ledger", "citeChecks", "triggerCases", "papersDir", "rules"].every((k) =>
+      readKeys.has(k),
+    ),
+  );
+}
+
+console.log(
+  `✓ ${n} assertions passed — one source for the consumer's config key`,
+);

package/lib/paper-config.mjs

@@ -0,0 +1,142 @@
+/**
+ * Where the consumer declares its settings — the ONE SOURCE for everything that is allowed to
+ * import it.
+ *
+ * 🔴 WHY THIS MODULE DOES NOT REMOVE THE DUPLICATION COMPLETELY, AND THAT IS NOT AN OVERSIGHT.
+ * The three hooks (`hooks/*.hook.mjs`) still have to keep their own copies of these values: a
+ * compiled hook is forbidden to import anything but `vigiles/hook`, and that ban is not
+ * arbitrary — a hook's capabilities equal its API surface, so allowing imports would mean
+ * allowing a reach into `child_process`. The restriction is wider than strictly necessary
+ * (importing plain constants adds no capability), and that is discussed in zernie/vigiles#245,
+ * but until it is relaxed the hooks duplicate, and drift is caught by the cross-check in
+ * `hooks/hooks.harness.mjs`.
+ *
+ * 🔴 BUT THE REST WERE DUPLICATING FOR NO REASON AT ALL. `eslint-rules/papers.mjs` and
+ * `skills/paper-pipeline/scripts/consumer.mjs` are not hooks, carry no import restriction, and
+ * could always have taken the value from here. Worse, their copies were not covered by the
+ * cross-check at all — it compared the three hooks against each other, while these two lived
+ * next door and could drift apart silently. Found 2026-09-18 by grepping AFTER the cross-check
+ * itself had already been fixed — i.e. the check's wording was fixed, but nobody measured its
+ * COVERAGE.
+ */
+
+/** The key in the consumer's `package.json` this package's settings are read from. */
+export const CONFIG_KEY = "paperlint";
+
+/**
+ * The key's name before 2.0.0, when the package was `research-paper-pipeline`. Still READ, with a
+ * deprecation line from the CLI and `doctor`; `init` renames it. Both keys at once with different
+ * contents is refused: there is no way to know which one the author means.
+ */
+export const LEGACY_CONFIG_KEY = "research-paper-pipeline";
+
+/**
+ * Where a parsed `package.json` keeps this package's settings — the new key, else the old one.
+ *
+ * @returns `settings` (undefined when neither key is there, or on a conflict), `legacy` (read
+ *   from the old key), `conflict` (the message when both keys are there and differ, else null).
+ */
+export function declaredSettings(pkg) {
+  const has = (k) =>
+    pkg !== null && typeof pkg === "object" && Object.hasOwn(pkg, k);
+  const current = has(CONFIG_KEY);
+  const legacy = has(LEGACY_CONFIG_KEY);
+  if (
+    current &&
+    legacy &&
+    JSON.stringify(pkg[CONFIG_KEY]) !== JSON.stringify(pkg[LEGACY_CONFIG_KEY])
+  )
+    return {
+      settings: undefined,
+      legacy: false,
+      conflict:
+        `package.json has both "${CONFIG_KEY}" and "${LEGACY_CONFIG_KEY}", and they differ. ` +
+        `Keep "${CONFIG_KEY}" and delete "${LEGACY_CONFIG_KEY}" (its old name).`,
+    };
+  if (current)
+    return { settings: pkg[CONFIG_KEY], legacy: false, conflict: null };
+  if (legacy)
+    return { settings: pkg[LEGACY_CONFIG_KEY], legacy: true, conflict: null };
+  return { settings: undefined, legacy: false, conflict: null };
+}
+
+/**
+ * The settings object alone, for readers that only need a value: the new key, else the old one,
+ * and nothing on a conflict (the CLI, `doctor` and the edit guard report the conflict).
+ */
+export function settingsOf(pkg) {
+  const d = declaredSettings(pkg);
+  return d.conflict === null ? d.settings : undefined;
+}
+
+/** The deprecation line for settings read from the old key. */
+export const LEGACY_KEY_MESSAGE = `"${LEGACY_CONFIG_KEY}" in package.json is the old name of this package's key — rename it to "${CONFIG_KEY}". \`npx paperlint init\` does it for you.`;
+
+/** Default: a consumer that declares nothing is assumed to keep papers in `papers/`. */
+export const DEFAULT_PAPERS_ROOT = "papers";
+
+/**
+ * The field under CONFIG_KEY that names the papers directory:
+ * `"paperlint": { "papersDir": "papers" }`.
+ *
+ * This is the one place the name is spelled. Code reads the field as
+ * `settings[PAPERS_DIR_FIELD]`, never by a literal, so renaming it again is a one-line change
+ * here. The three hooks cannot import this module, so they keep their own copy, and
+ * `lib/paper-config.harness.mjs` checks that every copy matches this one.
+ */
+export const PAPERS_DIR_FIELD = "papersDir";
+
+/**
+ * The field's old name. A config that still has it is REFUSED with `renamedFieldMessage()`,
+ * even if it also has the new one: the package is unpublished, so there is nobody to migrate
+ * quietly, and reading the old name as a fallback would leave it working forever.
+ */
+export const OLD_PAPERS_DIR_FIELD = "papers";
+
+/**
+ * The error text for a config that still uses the old field name, or `null` when it does not.
+ *
+ * @param settings  the object under CONFIG_KEY (or the whole `rpp.json`)
+ * @param where     where that object lives, as the reader should see it in the message
+ */
+export function renamedFieldMessage(
+  settings,
+  where = `package.json → "${CONFIG_KEY}"`,
+) {
+  if (settings === null || typeof settings !== "object") return null;
+  if (!Object.hasOwn(settings, OLD_PAPERS_DIR_FIELD)) return null;
+  return `"${OLD_PAPERS_DIR_FIELD}" was renamed to "${PAPERS_DIR_FIELD}" in ${where}`;
+}
+
+/**
+ * Every key the settings object may hold, with who reads it. A key not listed here is REFUSED
+ * with its name (`paperlint lint`, `paperlint build`, `paperlint new`, `paperlint doctor` all read through the same
+ * parser), because a typo in a key otherwise reads as "not set" — the defect `src/types.ts` names
+ * in its first line.
+ *
+ * 🔴 ONE LIST, AND IT IS CHECKED AGAINST THE READERS, NOT TRUSTED. The settings object has readers
+ * all over the package (the CLI, the skill scripts, the trigger-case loader), each reading its own
+ * keys. `lib/paper-config.harness.mjs` walks the package's source, finds every
+ * `[CONFIG_KEY]?.<key>` read and every field of `RppConfig`, and requires each to be here — so a
+ * new reader that forgets this list turns the harness red before a consumer's config does.
+ */
+export const SETTINGS_KEYS = Object.freeze({
+  papersDir: "the papers directory (required) — every command, the hooks",
+  structure: "which files a paper directory must hold — paperlint lint",
+  authorListCommand: "paper/author-list — paperlint lint",
+  typographyDebt: "paper/typography — paperlint lint",
+  docFields: "doc/fields — paperlint lint",
+  reviewSince: "review/findings-cause — paperlint lint",
+  minFindings: "review/findings-cause — paperlint lint",
+  causeMarker: "review/findings-cause — paperlint lint",
+  rules:
+    "extra ESLint config blocks, appended after rpp's own — paperlint lint",
+  buildScripts: "REMOVED; still named so paperlint build can say it is ignored",
+  ledger: "the run ledger — skills/paper-pipeline/scripts/consumer.mjs",
+  scripts: "how skill prose names the scripts — consumer.mjs",
+  timezone: "dates in the ledger — consumer.mjs",
+  contactEmail: "the polite-pool address for citation lookups — consumer.mjs",
+  citeChecks: "the consumer's citation checkers — run-mechanical.mjs",
+  triggerCases:
+    "the consumer's own skill trigger cases — lib/skill-trigger-cases.mjs",
+});

package/lib/paper-config.mutations.mjs

@@ -0,0 +1,143 @@
+/**
+ * Battery for `lib/paper-config.mjs` and the cross-check of its carriers.
+ *
+ * The subject is agreement among several files about one value. The failure here is silent by
+ * construction: a drifted key breaks neither the build nor the run, it only makes one carrier
+ * read settings the consumer never wrote. Every case below reintroduces that kind of drift.
+ */
+import { fileURLToPath } from "node:url";
+import { dirname, join, resolve } from "node:path";
+import { runMutations } from "./mutation-driver.mjs";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const ROOT = resolve(HERE, "..");
+const HARNESS = join(HERE, "paper-config.harness.mjs");
+const HOOK = join(ROOT, "hooks", "paper-skills-nudge.hook.mjs");
+const RULE = join(ROOT, "eslint-rules", "papers.mjs");
+const DOCTOR = join(ROOT, "src", "doctor.ts");
+
+process.exit(
+  runMutations({
+    root: ROOT,
+    runner: "node",
+    cases: [
+      {
+        name: "the key drifts in one of the hooks",
+        harness: HARNESS,
+        expect: "all carriers agree on CONFIG_KEY",
+        disables:
+          "the whole point of the forced duplication. A hook with a mismatched key reads " +
+          "settings the consumer never wrote, falls back to the default, and guards the wrong " +
+          "directory — silently, because silence is exactly what its success looks like",
+        edits: [
+          [
+            HOOK,
+            'export const CONFIG_KEY = "paperlint";',
+            'export const CONFIG_KEY = "paperlints";',
+          ],
+        ],
+      },
+      {
+        name: "a hook's copy of the papers-directory field name drifts",
+        harness: HARNESS,
+        expect: "all carriers agree on PAPERS_DIR_FIELD",
+        disables:
+          "the check on the one value this package renamed. A hook reading a different field " +
+          "name finds nothing, falls back to the default directory, and says nothing about it",
+        edits: [
+          [
+            HOOK,
+            // Prefix the value rather than spell it, so a future rename does not touch this file.
+            'export const PAPERS_DIR_FIELD = "',
+            'export const PAPERS_DIR_FIELD = "drifted-',
+          ],
+        ],
+      },
+      {
+        name: "the ESLint rule grows its OWN copy of the default again",
+        harness: HARNESS,
+        expect: "all carriers agree on DEFAULT_PAPERS_ROOT",
+        disables:
+          "the re-export the consolidation existed for in the first place. A non-hook's own " +
+          "copy serves nothing — the import restriction does not apply to it — and exactly this " +
+          "kind of copy sat OUTSIDE the cross-check for two days, because the cross-check " +
+          "compared hooks against each other",
+        edits: [
+          [
+            RULE,
+            "import {\n  CONFIG_KEY,\n  DEFAULT_PAPERS_ROOT,\n  PAPERS_DIR_FIELD,",
+            'const DEFAULT_PAPERS_ROOT = "drafts";\nimport {\n  CONFIG_KEY,\n  PAPERS_DIR_FIELD,',
+          ],
+        ],
+      },
+      {
+        name: "the config key stops being the package name",
+        harness: HARNESS,
+        expect: "config key equals the package name",
+        disables:
+          "the link between what the package is called and the name the consumer declares its " +
+          "settings under. They drift apart when the package is renamed: the docs will say one " +
+          "thing, a different one gets read, and there will be no error at all",
+        // The PACKAGE is renamed, not the constant: the carriers stay in agreement with each
+        // other, and the only thing that drifts is the "key = package name" link. Swapping the
+        // constant itself would kill the neighboring carrier-agreement assertion first and
+        // never reach this one.
+        edits: [
+          [
+            join(ROOT, "package.json"),
+            '"name": "paperlint",',
+            '"name": "paperlint-renamed",',
+          ],
+        ],
+      },
+      {
+        name: "a hook smuggles a capability past the vocabulary",
+        harness: HARNESS,
+        expect: "pulls in nothing outside the hook vocabulary",
+        disables:
+          "the one guarantee the hooks put up with duplication for: a hook's capabilities equal " +
+          "its API surface. A hook that reaches `node:fs` still runs and passes the value " +
+          "cross-check — the violation is visible only through this check",
+        edits: [
+          [
+            HOOK,
+            "import {\n  experimental_defineReact,",
+            'import { readFileSync } from "node:fs";\nimport {\n  experimental_defineReact,',
+          ],
+        ],
+      },
+      {
+        name: "a constant is written into a sixth file instead of imported",
+        harness: HARNESS,
+        expect: "no declaration outside the carrier list",
+        disables:
+          "the COMPLETENESS check. The carrier list is explicit, so a new copy planted anywhere " +
+          "else would have nothing to compare against — which is exactly how the duplication " +
+          "spread last time",
+        edits: [
+          [
+            DOCTOR,
+            'import {\n  papersRoot,\n  CONFIG_KEY,\n  DEFAULT_PAPERS_ROOT,\n  PAPERS_DIR_FIELD,\n  OLD_PAPERS_DIR_FIELD,\n} from "../hooks/paper-edit-guard.hook.mjs";',
+            'import {\n  papersRoot,\n  DEFAULT_PAPERS_ROOT,\n  PAPERS_DIR_FIELD,\n  OLD_PAPERS_DIR_FIELD,\n} from "../hooks/paper-edit-guard.hook.mjs";\nconst CONFIG_KEY = "research-paper-pipeline";',
+          ],
+        ],
+      },
+      {
+        name: "the completeness walk stops looking into the hooks",
+        harness: HARNESS,
+        expect: "the search itself is not empty",
+        disables:
+          "the guard against a FALSE ZERO. A search that found nothing looks like a clean " +
+          "corpus; without this assertion, the completeness check, having started looking in " +
+          "the wrong place, would report all-clear",
+        edits: [
+          [
+            HARNESS,
+            'const skip = new Set([\n    "node_modules",\n    ".git",\n    "dist",\n    "_build",\n    "fixtures",\n    "repro",\n  ]);',
+            'const skip = new Set([\n    "node_modules",\n    ".git",\n    "dist",\n    "_build",\n    "fixtures",\n    "repro",\n    "hooks",\n    "lib",\n  ]);',
+          ],
+        ],
+      },
+    ],
+  }),
+);