paperlint 2.0.0 → 2.0.1

package/src/cli.ts

@@ -10,13 +10,13 @@
  *
  * Two entry points into the tool, and both are whole now:
  *     npx paperlint lint              ← here
- *     uses: zernie/research-paper-pipeline@<sha>    ← action.yml
+ *     uses: zernie/paperlint@<sha>    ← action.yml
  *
  * ⚠️ THE BOUNDARY THIS UTILITY HAS NO RIGHT TO ERASE: the consumer's data stays with the consumer.
  * The typography debt, the marker of the author-list check run, the field dictionary — all of that
  * is about ONE corpus, and wiring it into the package would repeat the defect that put the path
  * `.claude/skills/verify-citations/...` into a rule's message. So they live in the consumer's
- * `rpp.json`.
+ * `package.json`, under the `paperlint` key.
  *
  * 🔴 WHY THE COMMAND IS CALLED `lint` AND NOT `check`. It does exactly what everyone else calls by
  * that word: reads files, changes nothing, prints findings, exits non-zero. `check` is taken in the
@@ -35,7 +35,7 @@ import markdown from "@eslint/markdown";
 // Types come from consumer.d.mts beside it, the same arrangement as lib/paper-config.d.mts.
 import { isMain } from "../skills/paper-pipeline/scripts/consumer.mjs";
 export { isMain };
-import type { Args, RppConfig, ConfigRead } from "./types.ts";
+import type { Args, PaperlintConfig, ConfigRead } from "./types.ts";
 import {
   checkStructure,
   formatStructure,
@@ -123,7 +123,7 @@ const USAGE = `paperlint — machine-checkable gates for a paper kept in git
                                       package the venue declares; on a terminal it offers to install
                                       one, without a terminal it stops and names \`npx paperlint toolchain\`
   npx paperlint toolchain [--check]   install TeX Live with every package the venue profiles declare
-                                      into ~/.cache/rpp/texlive (RPP_TEXLIVE_DIR overrides); a second
+                                      into ~/.cache/paperlint/texlive (PAPERLINT_TEXLIVE_DIR overrides); a second
                                       run does nothing. --check: report what is missing, change nothing
   npx paperlint doctor                say what is actually wired — and what only LOOKS wired
   npx paperlint hook <name>           run an editor hook (.claude/settings.json calls this)
@@ -149,8 +149,8 @@ lint:
                       most findings here are advisory and a gate that fails on advice gets muted
 
 settings — the \`paperlint\` key of your package.json, found by walking up from the
-current directory, the way every other tool in the stack finds its config. \`rpp.json\` is still
-read as a deprecated fallback and the run says so. \`papersDir\` is required; the rest is optional:
+current directory, the way every other tool in the stack finds its config. \`--config\` names
+another file of the same shape. \`papersDir\` is required; the rest is optional:
 
   "paperlint": {
     "papersDir":         "papers",
@@ -164,14 +164,14 @@ read as a deprecated fallback and the run says so. \`papersDir\` is required; th
                  "rules": { "pdf/last-page-balance": "error" } } ]
   }
 
-  "rules" takes ESLint flat-config blocks (files, ignores, rules), appended after rpp's own, with
+  "rules" takes ESLint flat-config blocks (files, ignores, rules), appended after paperlint's own, with
   files relative to the file holding the settings. Optional rules (off unless turned on there):
   pdf/last-page-balance. An unknown key, anywhere in the settings, is an error.
 `;
 
 /** The config the user would otherwise write by hand. The data comes from `opts`, the mechanism is here. */
 export function buildConfig(
-  opts: RppConfig = {},
+  opts: PaperlintConfig = {},
   texLanguage: unknown,
 ): unknown[] {
   const paperRules = { ...researchQuestion.rules, ...typography.rules };
@@ -272,8 +272,8 @@ export function buildConfig(
 }
 
 /**
- * The rule ids a consumer may name in `rules`: every rule rpp's own config defines, read off that
- * config rather than listed again. `@eslint/markdown` is a dependency's plugin, not rpp's.
+ * The rule ids a consumer may name in `rules`: every rule paperlint's own config defines, read off that
+ * config rather than listed again. `@eslint/markdown` is a dependency's plugin, not paperlint's.
  */
 export const SHIPPED_RULES: ReadonlySet<string> = shippedRuleIds(
   buildConfig({}, { sentinel: "tex language" }),
@@ -288,7 +288,7 @@ const isOn = (entry: unknown): boolean => {
 
 /**
  * Rules paperlint ships and turns on for no file itself — the ones a consumer opts into with `rules`.
- * Derived: every shipped rule that no block of rpp's own config names.
+ * Derived: every shipped rule that no block of paperlint's own config names.
  */
 export const OPTIONAL_RULES: ReadonlySet<string> = new Set(
   [...SHIPPED_RULES].filter(
@@ -309,7 +309,7 @@ export const OPTIONAL_RULES: ReadonlySet<string> = new Set(
 export async function silentOptionalRules(
   eslint: ESLint,
   lintedFiles: readonly string[],
-  opts: RppConfig,
+  opts: PaperlintConfig,
 ): Promise<string[]> {
   const turnedOn = new Set(
     (opts.rules ?? []).flatMap((b) =>
@@ -333,10 +333,10 @@ export async function silentOptionalRules(
  * config blocks. Nothing after this sees the raw object.
  */
 export function parseSettings(
-  opts: RppConfig,
+  opts: PaperlintConfig,
   where: string,
   baseDir: string,
-): Parsed<RppConfig> {
+): Parsed<PaperlintConfig> {
   const raw = opts as Record<string, unknown>;
   const unknown = unknownKeys(raw);
   if (unknown.length > 0)
@@ -431,7 +431,6 @@ export function parseArgs(argv: readonly string[]): Args {
   return out;
 }
 
-export const CONFIG_NAME = "rpp.json";
 export const PKG_NAME = "package.json";
 
 /**
@@ -450,36 +449,20 @@ function ownVersion(): string | undefined {
   }
 }
 
-/** Where the consumer's settings were found, and in which of the two carriers. */
-export interface Declaration {
-  readonly path: string;
-  readonly kind: "package.json" | "rpp.json";
-}
-
 /**
- * 🔴 THE CLI HAD TO LEARN TO READ `package.json`, AND THAT IS NOT A SIDE ERRAND. `paperlint init` now
- * writes ONE declaration, into the `package.json` key that the three hooks and `eslint-rules`
- * already read. Without this walker the install it produces would not work at all: `paperlint lint`
- * would find no `rpp.json`, report "nothing to lint", and the consumer would be back to
- * declaring the same directory twice — the defect the single declaration removes (issue #33,
+ * 🔴 THE CLI READS `package.json`, THE ONE DECLARATION. `paperlint init` writes the settings under
+ * the `package.json` key that the three hooks and `eslint-rules` already read; the CLI reads the
+ * same file, so the install and the check cannot look at different files (issue #33,
  * `docs/install.md`).
  *
- * `rpp.json` stays readable as a DEPRECATED fallback, and the read says so out loud. Silently
- * dropping a file this command used to write would break working setups on upgrade.
- *
  * The walk goes up to the filesystem root, the way eslint, prettier and tsc find theirs, so a run
- * from inside one paper sees the same settings as a run from the repository root. At each level
- * `package.json` wins over `rpp.json`: it is the carrier every other reader uses, so preferring
- * it is what keeps "one declaration" true rather than merely intended.
+ * from inside one paper sees the same settings as a run from the repository root.
  */
-export function findDeclaration(startDir: string): Declaration | null {
+export function findConfig(startDir: string): string | null {
   let dir = resolve(startDir);
   for (;;) {
     const pkg = join(dir, PKG_NAME);
-    if (existsSync(pkg) && declaresSettings(pkg))
-      return { path: pkg, kind: "package.json" };
-    const rpp = join(dir, CONFIG_NAME);
-    if (existsSync(rpp)) return { path: rpp, kind: "rpp.json" };
+    if (existsSync(pkg) && declaresSettings(pkg)) return pkg;
     const up = dirname(dir);
     if (up === dir) return null;
     dir = up;
@@ -500,11 +483,6 @@ const declaresSettings = (pkgPath: string): boolean => {
   }
 };
 
-/** Kept as the one-line question "which file holds the settings" — callers that only need a path. */
-export function findConfig(startDir: string): string | null {
-  return findDeclaration(startDir)?.path ?? null;
-}
-
 /**
  * Reading the config, ONE reader for all commands. Pulled out of `run()` the moment a second
  * command needed the same config (`build`): two copies of this block would have drifted apart on
@@ -525,24 +503,17 @@ export function readConfig(
   } = {},
 ): ConfigRead {
   // 🔴 THE CONFIG FINDS ITSELF. An explicit `--config` beats the discovered one — it was named out
-  // loud, and a substitution is never silent. For an explicit path the FILE NAME decides the
-  // carrier: the path here is a value, not a text to make guesses about, and `package.json` holds
-  // the settings under a key.
-  const decl: Declaration | null = a.config
-    ? {
-        path: a.config,
-        kind: basename(a.config) === PKG_NAME ? "package.json" : "rpp.json",
-      }
-    : findDeclaration(cwd);
-  const configPath = decl?.path ?? null;
+  // loud, and a substitution is never silent. Either way the file has the shape of a
+  // `package.json`: the settings sit under the key.
+  const configPath = a.config ?? findConfig(cwd);
   if (a.config && !existsSync(a.config)) {
     err(`config file not found: ${a.config}`);
     return { code: 2 };
   }
 
-  let opts: RppConfig = {};
+  let opts: PaperlintConfig = {};
   let legacyKey = false;
-  if (decl && configPath) {
+  if (configPath) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any -- #49: replace with a real type
     let parsed: any;
     try {
@@ -551,15 +522,13 @@ export function readConfig(
       err(`${configPath} is not valid JSON: ${(e as Error).message}`);
       return { code: 2 };
     }
-    if (decl.kind === "package.json") {
-      const d = declaredSettings(parsed);
-      if (d.conflict !== null) {
-        err(d.conflict);
-        return { code: 2 };
-      }
-      opts = (d.settings ?? {}) as RppConfig;
-      legacyKey = d.legacy;
-    } else opts = parsed;
+    const d = declaredSettings(parsed);
+    if (d.conflict !== null) {
+      err(d.conflict);
+      return { code: 2 };
+    }
+    opts = (d.settings ?? {}) as PaperlintConfig;
+    legacyKey = d.legacy;
     // The discovered config is NAMED out loud. Otherwise a run from someone else's directory picks
     // up someone else's file and does not say so — and a typography-debt mismatch looks like a finding.
     //
@@ -568,30 +537,19 @@ export function readConfig(
     // test but by an attempt to wire our own action to this output; in the harness I first WORKED
     // AROUND this line (stripped the first line before JSON.parse) — that is, the workaround hid
     // the defect exactly where it should have been shouting.
-    (a.json ? err : log)(`config: ${relative(cwd, configPath) || CONFIG_NAME}`);
-    // 🔴 THE DEPRECATED CARRIER IS NAMED OUT LOUD, IT DOES NOT STOP BEING READ. The hooks read ONLY
-    // package.json, so a consumer whose settings stayed in rpp.json lints one directory and guards
-    // another — and both states look equally green.
-    if (decl.kind === "rpp.json")
-      (a.json ? err : log)(
-        `  ⚠ ${CONFIG_NAME} is deprecated — move these keys under "${CONFIG_KEY}" in ${PKG_NAME}; ` +
-          `the hooks read only that file. \`npx paperlint init\` does it for you.`,
-      );
+    (a.json ? err : log)(`config: ${relative(cwd, configPath) || PKG_NAME}`);
     if (legacyKey) (a.json ? err : log)(`  ⚠ ${LEGACY_KEY_MESSAGE}`);
   }
 
   // The old field name is refused before anything else is read from the settings: falling back
   // to it would keep it working forever, and this package has no released users to migrate.
-  const where =
-    decl?.kind === "package.json"
-      ? `${PKG_NAME} → "${legacyKey ? LEGACY_CONFIG_KEY : CONFIG_KEY}"`
-      : (decl?.path ?? CONFIG_NAME);
-  const renamed = decl ? renamedFieldMessage(opts, where) : null;
+  const where = `${configPath ? basename(configPath) : PKG_NAME} → "${legacyKey ? LEGACY_CONFIG_KEY : CONFIG_KEY}"`;
+  const renamed = configPath ? renamedFieldMessage(opts, where) : null;
   if (renamed) {
     err(renamed);
     return { code: 2 };
   }
-  if (decl && configPath) {
+  if (configPath) {
     const parsed = parseSettings(
       opts,
       where,
@@ -607,15 +565,11 @@ export function readConfig(
   // 🔴 THE PAPERS DIRECTORY IS A REQUIRED FIELD. The papers directory is the one thing without which the tool
   // does not know what it works on, and the one thing that cannot be guessed: a default of "." runs
   // the rules over the whole checkout and exits green over a scope nobody chose.
-  if (decl && !hasPapers(opts)) {
+  if (configPath && !hasPapers(opts)) {
     err(
-      decl.kind === "package.json"
-        ? `${decl.path} must declare \`${PAPERS_DIR_FIELD}\` — the directory your papers live in, e.g.\n` +
-            `  { "${CONFIG_KEY}": { "${PAPERS_DIR_FIELD}": "papers" } }\n` +
-            `It is the one thing this tool cannot guess. \`npx paperlint init\` writes it for you.`
-        : `${decl.path} must declare \`${PAPERS_DIR_FIELD}\` — the directory your papers live in, e.g.\n` +
-            `  { "${PAPERS_DIR_FIELD}": "papers" }\n` +
-            `It is the one thing this tool cannot guess.`,
+      `${configPath} must declare \`${PAPERS_DIR_FIELD}\` — the directory your papers live in, e.g.\n` +
+        `  { "${CONFIG_KEY}": { "${PAPERS_DIR_FIELD}": "papers" } }\n` +
+        `It is the one thing this tool cannot guess. \`npx paperlint init\` writes it for you.`,
     );
     return { code: 2 };
   }
@@ -623,7 +577,7 @@ export function readConfig(
 }
 
 /** The papers directory field of the settings, read by its one declared name. */
-export function papersDirOf(opts: RppConfig): unknown {
+export function papersDirOf(opts: PaperlintConfig): unknown {
   return (opts as Record<string, unknown>)[PAPERS_DIR_FIELD];
 }
 
@@ -635,7 +589,7 @@ export function toPaths(papers: unknown): string[] {
   return [];
 }
 
-const hasPapers = (opts: RppConfig): boolean =>
+const hasPapers = (opts: PaperlintConfig): boolean =>
   toPaths(papersDirOf(opts)).length > 0;
 
 /**
@@ -703,7 +657,7 @@ export function runHook(
       throw new Error(`resolved vigiles, but no cli.js beside it: ${runtime}`);
   } catch {
     err(
-      `rpp: the hook runtime (vigiles) is not resolvable from ${fileURLToPath(new URL(".", import.meta.url))}.\n` +
+      `paperlint: the hook runtime (vigiles) is not resolvable from ${fileURLToPath(new URL(".", import.meta.url))}.\n` +
         `The \`${name}\` hook is NOT running. Everything else — \`paperlint lint\`, CI — is unaffected.\n` +
         `Reinstall this package so its dependencies are present.`,
     );
@@ -1048,7 +1002,7 @@ export async function run(
         );
   if (paths.length === 0) {
     err(
-      `nothing to lint: no path was given and no ${CONFIG_NAME} was found.\n` +
+      `nothing to lint: no path was given and no "${CONFIG_KEY}" key was found in a ${PKG_NAME}.\n` +
         `Run \`npx paperlint init\` here, or pass the directory: \`paperlint lint papers\`.`,
     );
     return 2;
@@ -1133,7 +1087,7 @@ async function reportLint(
     log: typeof console.log;
     err: typeof console.error;
     where: string;
-    opts: RppConfig;
+    opts: PaperlintConfig;
   },
 ): Promise<number> {
   const silent = await silentOptionalRules(
@@ -1180,7 +1134,7 @@ async function reportLint(
 
 // 🔴 `isMain`, NOT A STRING COMPARISON. The first version wrote
 //     if (import.meta.url === `file://${process.argv[1]}`)
-// and the utility, launched via `node_modules/.bin/rpp`, SILENTLY EXITED WITH ZERO: npm puts a
+// and the utility, launched via `node_modules/.bin/paperlint`, SILENTLY EXITED WITH ZERO: npm puts a
 // SYMLINK there, `process.argv[1]` stays the symlink's path while `import.meta.url` is the real
 // path, and the condition is false. That is, the only way a real consumer launches the utility did
 // not work at all — and it looked like a clean run.

package/src/doctor.harness.mjs

@@ -41,9 +41,9 @@ const check = (label, cond) => {
   assert.ok(cond, label);
 };
 
-/** A consumer on disk: a papers directory, declarations in one or both places. */
-function consumer({ papersDir, pkgKey, rppJson, makeDir = true }) {
-  const dir = realpathSync(mkdtempSync(join(tmpdir(), "rpp-doctor-")));
+/** A consumer on disk: a papers directory, and maybe a declaration in package.json. */
+function consumer({ papersDir, pkgKey, makeDir = true }) {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "paperlint-doctor-")));
   if (makeDir && papersDir) {
     mkdirSync(join(dir, papersDir, "some-paper"), { recursive: true });
     writeFileSync(
@@ -54,11 +54,6 @@ function consumer({ papersDir, pkgKey, rppJson, makeDir = true }) {
   const pkg = { name: "consumer", version: "1.0.0" };
   if (pkgKey !== undefined) pkg["paperlint"] = { [PAPERS_DIR_FIELD]: pkgKey };
   writeFileSync(join(dir, "package.json"), JSON.stringify(pkg, null, 2));
-  if (rppJson !== undefined)
-    writeFileSync(
-      join(dir, "rpp.json"),
-      JSON.stringify({ [PAPERS_DIR_FIELD]: rppJson }, null, 2),
-    );
   return dir;
 }
 
@@ -113,13 +108,10 @@ const runDoctor = (
 }
 
 // ── II. THE VERY DEFECT: AN INSTALL FOLLOWING THE DOCS ─────────────────────────────────────
-// `paperlint init` writes rpp.json and does not touch package.json; the hook reads package.json.
+// The old `init` wrote its own config file and did not touch package.json; the hook reads package.json.
 // Measured 09-18.
 {
-  const dir = consumer({
-    papersDir: "writing/drafts",
-    rppJson: "writing/drafts",
-  });
+  const dir = consumer({ papersDir: "writing/drafts" });
   const r = runDoctor(dir, { cliPapers: "writing/drafts" });
   check(
     "an install that follows the docs — a FAILURE, not a cheerful report",
@@ -150,7 +142,7 @@ const runDoctor = (
 // It must not fail here (an error-level false positive costs more than a miss), but it must
 // not stay silent either.
 {
-  const dir = consumer({ papersDir: "papers", rppJson: "papers" });
+  const dir = consumer({ papersDir: "papers" });
   const r = runDoctor(dir, { cliPapers: "papers" });
   check("an install that works by coincidence does NOT crash", r.code === 0);
   check(
@@ -220,18 +212,10 @@ const runDoctor = (
 
 // ── III. TWO DECLARATIONS HAVE DRIFTED APART ────────────────────────────────────────────────
 {
-  const dir = consumer({
-    papersDir: "writing/drafts",
-    pkgKey: "papers",
-    rppJson: "writing/drafts",
-  });
+  const dir = consumer({ papersDir: "writing/drafts", pkgKey: "papers" });
   mkdirSync(join(dir, "papers"), { recursive: true });
   const r = runDoctor(dir, { cliPapers: "writing/drafts" });
   check("both declarations exist, but differ — a FAILURE", r.code === 2);
-  check(
-    "the stale rpp.json is called out ⚠",
-    /rpp\.json is present/.test(r.out),
-  );
   rmSync(dir, { recursive: true, force: true });
 }
 
@@ -307,7 +291,7 @@ const runDoctor = (
 
 // ── VII. DETECTING THE PAPERS DIRECTORY ─────────────────────────────────────────────────────
 {
-  const dir = realpathSync(mkdtempSync(join(tmpdir(), "rpp-detect-")));
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "paperlint-detect-")));
   mkdirSync(join(dir, "writing", "drafts", "p1"), { recursive: true });
   writeFileSync(join(dir, "writing", "drafts", "p1", "paper.tex"), "x");
   mkdirSync(join(dir, "node_modules", "pkg", "papers", "p"), {
@@ -387,7 +371,7 @@ const runDoctor = (
   check("a program that really exists is found", found("node") === true);
   check(
     "a made-up one is not (otherwise the check answers the form, not the subject)",
-    found("rpp-definitely-not-a-real-binary-xyz") === false,
+    found("paperlint-definitely-not-a-real-binary-xyz") === false,
   );
 }
 

package/src/doctor.ts

@@ -282,8 +282,6 @@ export function doctor({
     out.push(...declaration.lines);
     bad += declaration.bad;
   }
-  if (existsSync(join(root, "rpp.json")))
-    out.push(`  ⚠ rpp.json is present — deprecated; the hooks never read it`);
 
   out.push("", "papers directory");
   const hookRoot = rawPkg ? papersRoot(rawPkg) : null;

package/src/engine.harness.mjs

@@ -53,7 +53,7 @@ const facts = (o) => ({
   ...o,
 });
 const ROWS = [
-  // Guards: the order — rpp's own verified cache first, so a build does not depend on whatever TeX
+  // Guards: the order — paperlint's own verified cache first, so a build does not depend on whatever TeX
   // Live the machine happens to carry.
   [
     "a complete cache wins, even over a complete system TeX",
@@ -198,7 +198,9 @@ check(
 // to start, while `paperlint toolchain --check` reported the tree verified. Checked on disk, not
 // through an injected predicate, because the predicate is exactly what was wrong.
 {
-  const bin = realpathSync(mkdtempSync(join(tmpdir(), "rpp-engine-bin-")));
+  const bin = realpathSync(
+    mkdtempSync(join(tmpdir(), "paperlint-engine-bin-")),
+  );
   try {
     mkdirSync(join(bin, "texcount"));
     writeFileSync(join(bin, "checkcites"), "#!/bin/sh\n");

package/src/engine.ts

@@ -8,7 +8,7 @@
  * TeX Live qualifies only when `kpsewhich` finds every file the venue declares (issue #26).
  *
  * The order (the Playwright pattern, decided 2026-09-24):
- *   1. rpp's own cache (`paperlint toolchain` installs it) — when it has everything;
+ *   1. paperlint's own cache (`paperlint toolchain` installs it) — when it has everything;
  *   2. a TeX Live already on PATH — when IT has everything;
  *   3. neither: on a terminal, ask once and install; without one (CI, an agent), refuse in one line
  *      that names `npx paperlint toolchain` and the missing packages. Never a silent install without a
@@ -41,7 +41,7 @@ export interface TreeProbe {
 export interface EngineFacts {
   /** install-tl-unx runs here (Linux, macOS). */
   readonly supported: boolean;
-  /** rpp's cached TeX Live, probed — or null when there is none. */
+  /** paperlint's cached TeX Live, probed — or null when there is none. */
   readonly cache: TreeProbe | null;
   /** The `pdflatex` on PATH, probed — or null when there is none. */
   readonly system: TreeProbe | null;

package/src/hooks-settings.harness.mjs

@@ -40,7 +40,6 @@ const {
   doctorHooks,
   readSettings,
   MANAGED_BY,
-  LEGACY_MANAGED_BY,
   SETTINGS_PATH,
 } = await import(join(HERE, "hooks-settings.ts"));
 const { claudeCodeHookProtocol } = await import("vigiles/claude-code");
@@ -66,7 +65,7 @@ check(
   wiring.names.join() ===
     "paper-edit-guard,paper-skills-nudge,paper-status-gates",
 );
-const work = realpathSync(mkdtempSync(join(tmpdir(), "rpp-hooks-")));
+const work = realpathSync(mkdtempSync(join(tmpdir(), "paperlint-hooks-")));
 try {
   const empty = join(work, "empty-hooks.json");
   writeFileSync(empty, '{"hooks":{}}');
@@ -89,11 +88,16 @@ try {
       `node "$CLAUDE_PROJECT_DIR/${MANAGED_BY}" hook paper-status-gates`,
       { name: "paper-status-gates", ours: true, legacy: false },
     ],
-    // Guards: what an install under the old package name wrote is recognised as ours-but-stale.
+    // Guards: what an older install wrote is recognised as ours-but-stale. Spelled literally, not
+    // built from a constant: these are what 1.x and 2.0.0 actually put in users' settings files.
     [
-      `node "$CLAUDE_PROJECT_DIR/${LEGACY_MANAGED_BY}" hook paper-edit-guard`,
+      `node "$CLAUDE_PROJECT_DIR/node_modules/research-paper-pipeline/bin/rpp.mjs" hook paper-edit-guard`,
       { name: "paper-edit-guard", ours: false, legacy: true },
     ],
+    [
+      `node "\${CLAUDE_PROJECT_DIR}/node_modules/paperlint/bin/rpp.mjs" hook paper-status-gates`,
+      { name: "paper-status-gates", ours: false, legacy: true },
+    ],
     [
       `node "$CLAUDE_PROJECT_DIR/node_modules/vigiles/dist/cli.js" hook-runtime run-program "$CLAUDE_PROJECT_DIR/node_modules/paperlint/hooks/paper-edit-guard.hook.mjs"`,
       { name: "paper-edit-guard", ours: false, legacy: false },
@@ -107,11 +111,11 @@ try {
       { name: "paper-skills-nudge", ours: false, legacy: false },
     ],
     [
-      `node /abs/proj/node_modules/paperlint/bin/rpp.mjs hook paper-edit-guard`,
+      `node /abs/proj/node_modules/paperlint/bin/paperlint.mjs hook paper-edit-guard`,
       { name: "paper-edit-guard", ours: false, legacy: false },
     ],
     [`node my-own-lint.mjs`, null],
-    [`node node_modules/paperlint/bin/rpp.mjs lint`, null],
+    [`node node_modules/paperlint/bin/paperlint.mjs lint`, null],
   ];
   for (const [cmd, want] of cases)
     check(
@@ -154,37 +158,42 @@ try {
     );
   }
 
-  // ── an install under the old package name is migrated, the user's own command kept ─────
-  {
+  // ── what an older install wrote is migrated, the user's own command kept ─────────────────
+  // Two real histories, spelled literally: 1.x wrote the old package directory, 2.0.0 wrote the
+  // new directory with the old entry file name. Neither file exists after an upgrade.
+  for (const [release, stale] of [
+    ["1.x", "node_modules/research-paper-pipeline/bin/rpp.mjs"],
+    ["2.0.0", "node_modules/paperlint/bin/rpp.mjs"],
+  ]) {
     const legacyWired = JSON.parse(
       JSON.stringify(merge({}, wiring.compiled, MANAGED_BY)).replaceAll(
         MANAGED_BY,
-        LEGACY_MANAGED_BY,
+        stale,
       ),
     );
     legacyWired.hooks.PostToolUse[0].hooks.push({
       type: "command",
       command: "node my-own-lint.mjs",
     });
-    const dir = project("legacy", legacyWired);
+    const dir = project(`legacy-${release}`, legacyWired);
     const before = doctorHooks(dir, wiring).join("\n");
     check(
-      "🔴 doctor names hook commands left under the old package name, and the fix",
-      /still point into node_modules\/research-paper-pipeline\//.test(before) &&
+      `🔴 doctor names hook commands ${release} left behind — the missing file, and the fix`,
+      before.includes(`run ${stale}, which this version does not install`) &&
         /npx paperlint init` replaces them/.test(before),
     );
     const r = wireHooks(dir, merge, wiring);
     const s = JSON.parse(text(dir));
     const counts = [...wiredCounts(s, wiring.names).values()];
     check(
-      "🔴 init replaces them: every hook wired once under the new name, none left under the old",
+      `🔴 init replaces what ${release} wrote: every hook wired once, none left at the old path`,
       r.status === "written" &&
         r.replaced === wiring.names.length &&
         counts.every((c) => c.ours === 1 && c.legacy === 0 && c.other === 0) &&
-        !text(dir).includes("research-paper-pipeline"),
+        !text(dir).includes(stale),
     );
     check(
-      "and the user's own command in the same matcher survives the migration",
+      `and the user's own command in the same matcher survives the ${release} migration`,
       text(dir).includes("node my-own-lint.mjs"),
     );
   }

package/src/hooks-settings.mutations.mjs

@@ -27,11 +27,9 @@ process.exit(
         expect: '→ {"name":"paper-edit-guard","ours":false,"legacy":true}',
         disables:
           "the duplicate guard for every bin spelling but ours. A hook wired by hand as " +
-          "`npx paperlint hook …` or through an absolute rpp.mjs path reads as ours, init merges its own " +
+          "`npx paperlint hook …` or through an absolute path to the bin reads as ours, init merges its own " +
           "copy beside it, and the hook runs twice per event",
-        edits: [
-          [SRC, "        ours: t === MANAGED_BY,", "        ours: true,"],
-        ],
+        edits: [[SRC, "      ours: t === MANAGED_BY,", "      ours: true,"]],
       },
       {
         name: "another spelling no longer stops the write",