paperlint 2.0.0 → 2.0.1

package/src/hooks-settings.ts

@@ -27,6 +27,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, posix } from "node:path";
 import { fileURLToPath } from "node:url";
 import {
+  BIN_FILE,
   LEGACY_PACKAGE_NAME,
   PACKAGE_NAME,
 } from "../skills/paper-pipeline/scripts/consumer.mjs";
@@ -44,13 +45,7 @@ export const WIRING_FILE = fileURLToPath(
  * and `${CLAUDE_PROJECT_DIR}/` before comparing, so this is the same file as the spelling in
  * `hooks.json`, and nothing machine-specific lands in a committed file.
  */
-export const MANAGED_BY = `node_modules/${PACKAGE_NAME}/bin/rpp.mjs`;
-
-/**
- * The same token as an install under the package's old name wrote it. A command spelled this way
- * is ours from before the rename: `init` removes it and writes the current one, `doctor` names it.
- */
-export const LEGACY_MANAGED_BY = `node_modules/${LEGACY_PACKAGE_NAME}/bin/rpp.mjs`;
+export const MANAGED_BY = `node_modules/${PACKAGE_NAME}/${BIN_FILE}`;
 
 /** The names the package's directory under `node_modules` has had. */
 const PKG_DIRS: readonly string[] = [PACKAGE_NAME, LEGACY_PACKAGE_NAME];
@@ -81,50 +76,91 @@ function bare(token: string): string {
   return unquoted.replace(/^\$\{?CLAUDE_PROJECT_DIR\}?[/\\]/, "");
 }
 
+/** A hook command reduced to what it runs: the hook, and the path token that runs it. */
+interface Run {
+  readonly name: string;
+  readonly ours: boolean;
+  readonly legacy: boolean;
+  readonly path: string;
+}
+
 /**
  * Which paperlint hook a command runs, if any, and whether it is spelled the way `init` writes it.
  *
  * Recognised spellings — each is ONE lexeme of a shell command, which is what a command is:
- *   `node <…>/node_modules/paperlint/bin/rpp.mjs hook <name>`   ours when the path is exactly
- *                                                              MANAGED_BY
- *   the same under `node_modules/research-paper-pipeline/`     `legacy`: ours before the rename
- *   `npx paperlint hook <name>`, `node_modules/.bin/paperlint hook <name>` (or the old bin names)
- *                                                              another spelling
+ *   `node <…>/node_modules/paperlint/bin/paperlint.mjs hook <name>`
+ *                          ours when the path is exactly MANAGED_BY
+ *   `node node_modules/<pkg>/bin/<any other file> hook <name>`, <pkg> this name or the old one
+ *                          `legacy`: the project-relative form `init` writes, pointing at a file
+ *                          this version does not install — what an older `init` left behind
+ *                          (1.x: `research-paper-pipeline/bin/rpp.mjs`; 2.0.0: `paperlint/bin/rpp.mjs`)
+ *   `npx paperlint hook <name>`, `node_modules/.bin/paperlint hook <name>` (or under the old package name),
+ *   an absolute path into the package's `bin/`
+ *                          another spelling
  *   `vigiles … run-program <…>/node_modules/<pkg>/hooks/<name>.hook.mjs`
- *                                                              another spelling
+ *                          another spelling
  * The last is how the one real consumer wired all three by hand before `init` could.
+ *
+ * `legacy` is decided by the SHAPE `init` writes, not by a list of past file names: any file in
+ * our `bin/` other than BIN_FILE is one that no longer ships, so a future rename is covered too.
  */
+function parseRun(command: string): Run | null {
+  const tokens = command.trim().split(/\s+/).map(bare);
+  for (let i = 0; i < tokens.length; i++) {
+    const run = runAt(tokens, i);
+    if (run) return run;
+  }
+  return null;
+}
+
+/** The path segments after `node_modules/<pkg>/`, and whether the token starts there. */
+function insidePackage(parts: readonly string[]): {
+  readonly inside: readonly string[];
+  readonly relative: boolean;
+} {
+  const at = parts.findIndex(
+    (p, j) => p === "node_modules" && PKG_DIRS.includes(parts[j + 1] ?? ""),
+  );
+  return {
+    inside: at === -1 ? [] : parts.slice(at + 2),
+    relative: at === 0,
+  };
+}
+
+/** The run token `i` starts, if it names a paperlint hook. */
+function runAt(tokens: readonly string[], i: number): Run | null {
+  const t = posix.normalize(tokens[i] ?? "");
+  const { inside, relative } = insidePackage(t.split("/"));
+  const inBin = inside[0] === "bin" && inside.length === 2;
+  const name = tokens[i + 2];
+  if (
+    (inBin || PKG_DIRS.includes(basename(t))) &&
+    tokens[i + 1] === "hook" &&
+    name
+  )
+    return {
+      name,
+      ours: t === MANAGED_BY,
+      legacy: inBin && relative && t !== MANAGED_BY,
+      path: t,
+    };
+  if (inside[0] === "hooks" && inside[1]?.endsWith(".hook.mjs"))
+    return {
+      name: basename(inside[1], ".hook.mjs"),
+      ours: false,
+      legacy: false,
+      path: t,
+    };
+  return null;
+}
+
 export function hookRun(command: string): {
   readonly name: string;
   readonly ours: boolean;
   readonly legacy: boolean;
 } | null {
-  const tokens = command.trim().split(/\s+/).map(bare);
-  for (let i = 0; i < tokens.length; i++) {
-    const t = posix.normalize(tokens[i] ?? "");
-    const parts = t.split("/");
-    const at = parts.findIndex(
-      (p, j) => p === "node_modules" && PKG_DIRS.includes(parts[j + 1] ?? ""),
-    );
-    const inside = at === -1 ? [] : parts.slice(at + 2);
-    const isBin =
-      (inside[0] === "bin" && inside[1] === "rpp.mjs") ||
-      ["rpp", ...PKG_DIRS].includes(basename(t));
-    const name = tokens[i + 2];
-    if (isBin && tokens[i + 1] === "hook" && name)
-      return {
-        name,
-        ours: t === MANAGED_BY,
-        legacy: t === LEGACY_MANAGED_BY,
-      };
-    if (inside[0] === "hooks" && inside[1]?.endsWith(".hook.mjs"))
-      return {
-        name: basename(inside[1], ".hook.mjs"),
-        ours: false,
-        legacy: false,
-      };
-  }
-  return null;
+  const run = parseRun(command);
+  return run && { name: run.name, ours: run.ours, legacy: run.legacy };
 }
 
 /** Every command in a settings object, with the event it hangs off. */
@@ -356,16 +392,23 @@ export const FRESH_CLONE_NOTE = `the commands point into node_modules/${PACKAGE_
 /** The instruction for a project that also enables the plugin (it only ever existed under the old name). */
 export const UNINSTALL_PLUGIN = `/plugin uninstall ${LEGACY_PACKAGE_NAME}@${LEGACY_PACKAGE_NAME}`;
 
-/** The doctor lines for hook commands an install under the old package name left behind. */
-function legacyLines(
-  counts: ReadonlyMap<string, { readonly legacy: number }>,
-): string[] {
-  let legacy = 0;
-  for (const c of counts.values()) legacy += c.legacy;
-  return legacy === 0
+/**
+ * The doctor lines for hook commands an older install left behind: each names the file it runs,
+ * which this version does not install, so the hook silently does nothing.
+ */
+function legacyLines(settings: Settings): string[] {
+  const stale = new Map<string, number>();
+  for (const { command } of commandsIn(settings)) {
+    const run = parseRun(command);
+    if (run?.legacy) stale.set(run.path, (stale.get(run.path) ?? 0) + 1);
+  }
+  return stale.size === 0
     ? []
     : [
-        `  ⚠ ${String(legacy)} hook command(s) still point into node_modules/${LEGACY_PACKAGE_NAME}/, the package's old name — they no longer run.`,
+        ...[...stale].map(
+          ([path, n]) =>
+            `  ⚠ ${String(n)} hook command(s) run ${path}, which this version does not install — they no longer run.`,
+        ),
         `      \`npx ${PACKAGE_NAME} init\` replaces them`,
       ];
 }
@@ -400,7 +443,7 @@ export function doctorHooks(
     out.push(`  ⚠ wired TWICE — each of these runs more than once per event:`);
     for (const n of twice) out.push(`      ${n} ×${String(total(n))}`);
     out.push(
-      `      keep one command per hook; \`npx paperlint init\` writes the rpp.mjs form`,
+      `      keep one command per hook; \`npx paperlint init\` writes the ${MANAGED_BY} form`,
     );
   }
   if (missing.length === wiring.names.length)
@@ -418,7 +461,7 @@ export function doctorHooks(
       `  ✓ wired — ${wiring.names.join(", ")}, once each`,
       `      ${FRESH_CLONE_NOTE}`,
     );
-  out.push(...legacyLines(counts));
+  out.push(...legacyLines(read.settings));
   const plugin = pluginEnabledHere(read.settings);
   if (plugin.length > 0) {
     out.push(

package/src/init.ts

@@ -2,7 +2,7 @@
  * `paperlint init` — the whole install, in the terminal it was typed in.
  *
  * 🔴 WHAT THIS COMMAND USED TO DO, AND WHY THAT WAS A DEFECT RATHER THAN A SHORTFALL. It wrote
- * `rpp.json` with a GUESSED `"papers": "papers"` and never touched `package.json`. The three hooks
+ * a separate config file with a GUESSED `"papers": "papers"` and never touched `package.json`. The three hooks
  * read the papers directory out of `package.json` and nothing else, so a consumer who followed the
  * documented install got a `paper-edit-guard` watching a directory that did not exist — and a guard
  * watching nothing is byte-identical, from outside, to a guard that is working (issue #33).
@@ -15,7 +15,7 @@
  *                      carry a paper marker. Several hits is the only case a human is asked about.
  *   declaration        WRITTEN into `package.json`, merged, never overwriting a value that is
  *                      already there. Prior art: husky's `init` edits the consumer's package.json
- *                      to add `prepare`. `rpp.json` is no longer created at all.
+ *                      to add `prepare`. No second config file is created.
  *   skills             LINKED — one relative symlink per shipped skill into `.claude/skills/`, the
  *                      only place Claude Code looks for project skills (`link-skills.ts`). An
  *                      entry of the same name that paperlint did not make is reported, never replaced.
@@ -204,8 +204,8 @@ export type DeclarationResult =
  *
  * 🔴 A HOOK CANNOT IMPORT CODE AND CANNOT WALK UP A TREE LOOKING FOR A CONFIG. It can read a path
  * it is able to spell, and the only path it can always spell is the project's own `package.json`.
- * That asymmetry is the whole reason the declaration moved here rather than the readers moving to
- * `rpp.json`: many readers against one (`docs/install.md`, "One declaration").
+ * That asymmetry is the whole reason the declaration lives here rather than in a file of its own:
+ * many readers against one (`docs/install.md`, "One declaration").
  *
  * ⚠️ Merged, not rewritten, and never over a value the consumer set — an `init` that silently
  * replaces a setting is worse than an `init` that does nothing, because the consumer keeps
@@ -259,35 +259,6 @@ function renameKey(
   );
 }
 
-export type RppJsonResult = "absent" | "kept" | "filled" | "unparsable";
-
-/**
- * `rpp.json` is no longer CREATED — but a consumer who already has one keeps it working, and it
- * gets the same `papers` value rather than being left to disagree with `package.json` in silence.
- * Two declarations that disagree is the defect `paperlint doctor` was written to catch; writing the
- * second one on purpose would be handing it new work.
- */
-export function syncRppJson(root: string, papers: string): RppJsonResult {
-  const path = join(root, "rpp.json");
-  if (!existsSync(path)) return "absent";
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- #49: replace with a real type
-  let cfg: Record<string, any>;
-  const raw = readFileSync(path, "utf8");
-  try {
-    cfg = JSON.parse(raw);
-  } catch {
-    return "unparsable";
-  }
-  if (cfg?.[PAPERS_DIR_FIELD] !== undefined) return "kept";
-  cfg[PAPERS_DIR_FIELD] = papers;
-  writeFileSync(
-    path,
-    JSON.stringify(cfg, null, 2) + (raw.endsWith("\n") ? "\n" : ""),
-    "utf8",
-  );
-  return "filled";
-}
-
 export const WORKFLOW_PATH = join(".github", "workflows", "papers.yml");
 
 /** Where the action is pinned when no release tag is known — obviously a placeholder. */
@@ -310,7 +281,7 @@ export function workflowYaml(papers: string, ref: string | null): string {
     `    runs-on: ubuntu-latest`,
     `    steps:`,
     `      - uses: actions/checkout@v4`,
-    `      - uses: zernie/research-paper-pipeline@${ref ?? UNPINNED_REF}`,
+    `      - uses: zernie/paperlint@${ref ?? UNPINNED_REF}`,
     `        with:`,
     `          paths: ${papers}`,
     ``,
@@ -380,7 +351,7 @@ export function reportWorkflow(
   if (wf !== "written" && wf !== "kept")
     out.push(
       `      to run the same checks in CI, add this step to a workflow:`,
-      `        - uses: zernie/research-paper-pipeline@${ref ?? UNPINNED_REF}`,
+      `        - uses: zernie/paperlint@${ref ?? UNPINNED_REF}`,
       `          with:`,
       `            paths: ${papersDir}`,
     );
@@ -772,23 +743,10 @@ export async function init(
     `      one declaration — the hooks, the rules and the CLI all read this one key`,
   );
   // Every step below uses the DECLARED directory. A kept declaration outranks what init
-  // measured or guessed: otherwise the first paper, the workflow and rpp.json would land in the
+  // measured or guessed: otherwise the first paper and the workflow would land in the
   // guessed directory while lint and the hooks keep reading the declared one.
   const papersDir =
     decl.status === "kept" ? (decl.papers as string) : choice.papers;
-  const rpp = syncRppJson(root, papersDir);
-  if (rpp === "filled")
-    log(
-      `  ⚠ rpp.json was already here — gave it the same ${PAPERS_DIR_FIELD} value; it is deprecated`,
-    );
-  else if (rpp === "kept")
-    log(
-      `  ⚠ rpp.json was already here and already declares ${PAPERS_DIR_FIELD} — left untouched; it is deprecated`,
-    );
-  else if (rpp === "unparsable")
-    log(
-      `  ⚠ rpp.json is here and does not parse — left untouched; it is deprecated, delete it`,
-    );
 
   // ── 3. the skills, linked where Claude Code looks for them ─────────────────────────────
   for (const line of reportSkillLinks(link(root), here)) log(line);

package/src/latex-log.harness.mjs

@@ -112,7 +112,7 @@ const undefinedCs = [
   "Here is how much of TeX's memory you used:",
 ];
 const ex = errorExcerpt(undefinedCs);
-// Guards: the spelling rpp's own flags produce for most errors — with only the `!` form recognised,
+// Guards: the spelling paperlint's own flags produce for most errors — with only the `!` form recognised,
 // an undefined control sequence fails with no error line quoted.
 check(
   "-file-line-error form: the error line, the l.NNN line and the rest of the source line",

package/src/link-skills.harness.mjs

@@ -50,7 +50,9 @@ const check = (label, cond) => {
 };
 
 const SKILLS = ["alpha", "beta", "gamma"];
-const work = realpathSync(mkdtempSync(join(tmpdir(), "rpp-link-skills-")));
+const work = realpathSync(
+  mkdtempSync(join(tmpdir(), "paperlint-link-skills-")),
+);
 
 /** A package as a manager would unpack it: manifest, skills, one non-skill. */
 function writePackage(dir) {

package/src/link-skills.mutations.mjs

@@ -27,7 +27,7 @@ process.exit(
     runner: "node",
     cases: [
       {
-        // The definition lives in the port since rpp#62 (`installedSkills` in consumer.mjs), so
+        // The definition lives in the port since paperlint#62 (`installedSkills` in consumer.mjs), so
         // the defect is planted THERE and must still die in THIS harness — the evidence that the
         // linker reads it through the shared function rather than through a copy of its own.
         name: "any directory counts as a skill",

package/src/link-skills.ts

@@ -66,7 +66,7 @@ export function locatePackage(project: string): Located {
   let manifest: string;
   try {
     const req = createRequire(
-      pathToFileURL(join(project, "__rpp_locate__.js")).href,
+      pathToFileURL(join(project, "__paperlint_locate__.js")).href,
     );
     manifest = req.resolve(`${PACKAGE_NAME}/package.json`);
   } catch (e) {
@@ -100,7 +100,7 @@ export function shippedSkills(
   // clean run.
   if (!existsSync(skillsDir))
     return { error: `the package's skills directory is missing: ${skillsDir}` };
-  // The same function every reader of an installed skills directory calls (rpp#62): the writer
+  // The same function every reader of an installed skills directory calls (paperlint#62): the writer
   // and the readers of this fact share one definition of "a skill is here", links included.
   try {
     return { skillsDir, names: installedSkills(skillsDir) };

package/src/new-paper.harness.mjs

@@ -52,7 +52,7 @@ const check = (label, cond) => {
   assert.ok(cond, label);
 };
 
-const work = realpathSync(mkdtempSync(join(tmpdir(), "rpp-new-")));
+const work = realpathSync(mkdtempSync(join(tmpdir(), "paperlint-new-")));
 const read = (...p) => readFileSync(join(...p), "utf8");
 const front = (text) => load(frontmatterBlock(text) ?? "") ?? {};
 

package/src/pdf-facts.harness.mjs

@@ -116,7 +116,7 @@ const named = (facts, name) =>
     JSON.stringify(r),
   );
 }
-const tmp = realpathSync(mkdtempSync(join(tmpdir(), "rpp-pdf-facts-")));
+const tmp = realpathSync(mkdtempSync(join(tmpdir(), "paperlint-pdf-facts-")));
 try {
   const notPdf = join(tmp, "paper.pdf");
   writeFileSync(notPdf, "%PDF-stale\n");

package/src/rules-config.ts

@@ -9,7 +9,7 @@
  *   "rules": [ { "files": ["papers/agenticdev-2026/**"],
  *                "rules": { "pdf/last-page-balance": ["error", { "tolerancePt": 120 }] } } ]
  *
- * The blocks are appended AFTER rpp's built-in config, so a later block wins, exactly as in ESLint.
+ * The blocks are appended AFTER paperlint's built-in config, so a later block wins, exactly as in ESLint.
  * `files` and `ignores` are resolved relative to the directory of the file that holds the settings,
  * as ESLint resolves them relative to its config file: each block gets that directory as ESLint's
  * own `basePath`, so paperlint matches nothing itself.
@@ -159,7 +159,7 @@ export function parseRuleBlocks(
 
 /**
  * The rule ids a config defines through its own plugins, as `<plugin>/<rule>`. Plugins passed in
- * `foreign` (a dependency's plugin, such as `@eslint/markdown`) are not rpp's and are skipped.
+ * `foreign` (a dependency's plugin, such as `@eslint/markdown`) are not paperlint's and are skipped.
  */
 export function shippedRuleIds(
   config: readonly unknown[],

package/src/structure.harness.mjs

@@ -28,7 +28,7 @@ const check = (label, cond) => {
   n++;
 };
 
-const root = realpathSync(mkdtempSync(join(tmpdir(), "rpp-struct-")));
+const root = realpathSync(mkdtempSync(join(tmpdir(), "paperlint-struct-")));
 const papers = join(root, "papers");
 const paper = (name, files) => {
   const dir = join(papers, name);

package/src/tex-requirements.harness.mjs

@@ -116,7 +116,7 @@ for (const [t, vs] of byTemplate)
   );
 
 // ── 2. the schema rejects ───────────────────────────────────────────────────────────────
-const tmp = realpathSync(mkdtempSync(join(tmpdir(), "rpp-texreq-h-")));
+const tmp = realpathSync(mkdtempSync(join(tmpdir(), "paperlint-texreq-h-")));
 copyFileSync(join(VENUES, R.SCHEMA_FILE), join(tmp, R.SCHEMA_FILE));
 const bad = (text) => throws(() => R.parseProfile(text, "bad.jsonc", tmp));
 const BAD = [

package/src/toolchain.harness.mjs

@@ -4,7 +4,7 @@
  * 🔴 NOT ONE BYTE OF TeX LIVE IS DOWNLOADED HERE. The mirror is a directory served by `file://`
  * URLs: the real `curl` fetches from it, the real `tar` lists and unpacks it, and the installer
  * inside is `fixtures/toolchain-mirror/install-tl`, which lays out a tree whose `kpsewhich` and
- * `tlmgr` answer from two text files. So what runs is rpp's own download, fallback, unpack,
+ * `tlmgr` answer from two text files. So what runs is paperlint's own download, fallback, unpack,
  * install and verify logic — the part that decides success — and what is faked is only TeX.
  * The real TeX Live half is `test/e2e/toolchain.mjs`.
  *
@@ -78,22 +78,25 @@ check(
   ) === '["urw-base35"]',
 );
 check(
-  "cacheRoot: RPP_TEXLIVE_DIR wins",
-  T.cacheRoot({ RPP_TEXLIVE_DIR: "/ci/tl", XDG_CACHE_HOME: "/x" }, "/h") ===
-    "/ci/tl",
+  "cacheRoot: PAPERLINT_TEXLIVE_DIR wins",
+  T.cacheRoot(
+    { PAPERLINT_TEXLIVE_DIR: "/ci/tl", XDG_CACHE_HOME: "/x" },
+    "/h",
+  ) === "/ci/tl",
 );
 check(
   "cacheRoot: then XDG_CACHE_HOME",
-  T.cacheRoot({ XDG_CACHE_HOME: "/x" }, "/h") === "/x/rpp/texlive",
+  T.cacheRoot({ XDG_CACHE_HOME: "/x" }, "/h") === "/x/paperlint/texlive",
 );
 check(
   "cacheRoot: then ~/.cache",
-  T.cacheRoot({}, "/h") === "/h/.cache/rpp/texlive",
+  T.cacheRoot({}, "/h") === "/h/.cache/paperlint/texlive",
 );
 check(
-  "mirrorsFrom: RPP_CTAN_MIRROR is the ONLY mirror, trailing slash dropped",
-  JSON.stringify(T.mirrorsFrom({ RPP_CTAN_MIRROR: "https://m/tlnet/" })) ===
-    '["https://m/tlnet"]',
+  "mirrorsFrom: PAPERLINT_CTAN_MIRROR is the ONLY mirror, trailing slash dropped",
+  JSON.stringify(
+    T.mirrorsFrom({ PAPERLINT_CTAN_MIRROR: "https://m/tlnet/" }),
+  ) === '["https://m/tlnet"]',
 );
 check(
   "mirrorsFrom: several defaults, every one https",
@@ -146,7 +149,9 @@ check(
 check("usableTree: an empty cache", T.usableTree([], () => true) === null);
 
 // ── the fake mirror ────────────────────────────────────────────────────────────────────
-const work = realpathSync(mkdtempSync(join(tmpdir(), "rpp-toolchain-h-")));
+const work = realpathSync(
+  mkdtempSync(join(tmpdir(), "paperlint-toolchain-h-")),
+);
 const good = join(work, "good");
 const garbage = join(work, "garbage");
 const staging = join(work, "staging", "install-tl-20260924");
@@ -259,14 +264,14 @@ const TEX = {
   tools: { texcount: ["texcount"] },
 };
 const root = join(work, "cache");
-// 🔴 banal goes into the work directory, never the developer's cache: without RPP_BANAL_DIR the
-// command installs into ~/.cache/rpp/banal, and a harness must not leave files in a home.
+// 🔴 banal goes into the work directory, never the developer's cache: without PAPERLINT_BANAL_DIR the
+// command installs into ~/.cache/paperlint/banal, and a harness must not leave files in a home.
 const banalDir = join(work, "banal");
 const env = {
   ...process.env,
-  RPP_TEXLIVE_DIR: root,
-  RPP_CTAN_MIRROR: url(good),
-  RPP_BANAL_DIR: banalDir,
+  PAPERLINT_TEXLIVE_DIR: root,
+  PAPERLINT_CTAN_MIRROR: url(good),
+  PAPERLINT_BANAL_DIR: banalDir,
 };
 // A stand-in banal: a Perl script that prints what banal prints for a one-page, 10 pt probe.
 const fakeBanal = join(work, "fake-banal");
@@ -446,7 +451,7 @@ const cmd = ({ banal = BANAL, ...over } = {}) => {
   const r = cmd({
     env: {
       ...env,
-      RPP_TEXLIVE_DIR: fresh,
+      PAPERLINT_TEXLIVE_DIR: fresh,
       FAKE_INSTALL_TL_FAIL: "1",
     },
   });
@@ -462,15 +467,15 @@ const cmd = ({ banal = BANAL, ...over } = {}) => {
   const r = cmd({
     env: {
       ...env,
-      RPP_TEXLIVE_DIR: join(work, "cache-nomirror"),
-      RPP_CTAN_MIRROR: MISSING,
+      PAPERLINT_TEXLIVE_DIR: join(work, "cache-nomirror"),
+      PAPERLINT_CTAN_MIRROR: MISSING,
     },
   });
   check(
     "no mirror answers: exit 1, names the mirrors and the override",
     r.code === 1 &&
       r.err.includes("no CTAN mirror returned install-tl") &&
-      r.err.includes("RPP_CTAN_MIRROR"),
+      r.err.includes("PAPERLINT_CTAN_MIRROR"),
     r.err,
   );
 }
@@ -520,7 +525,11 @@ const withLibertine = {
 };
 const inYears = (mirror, over = {}) =>
   cmd({
-    env: { ...env, RPP_TEXLIVE_DIR: years, RPP_CTAN_MIRROR: mirror },
+    env: {
+      ...env,
+      PAPERLINT_TEXLIVE_DIR: years,
+      PAPERLINT_CTAN_MIRROR: mirror,
+    },
     ...over,
   });
 check(
@@ -583,12 +592,12 @@ check(
 {
   // tlmgr says 2027, but the installer the mirrors hand out is still 2026.
   const split = join(work, "cache-split");
-  cmd({ env: { ...env, RPP_TEXLIVE_DIR: split } });
+  cmd({ env: { ...env, PAPERLINT_TEXLIVE_DIR: split } });
   const r = cmd({
     env: {
       ...env,
-      RPP_TEXLIVE_DIR: split,
-      RPP_CTAN_MIRROR: mirrorFor("split2027", "2027", "2026"),
+      PAPERLINT_TEXLIVE_DIR: split,
+      PAPERLINT_CTAN_MIRROR: mirrorFor("split2027", "2027", "2026"),
     },
     tex: withLibertine,
   });
@@ -606,7 +615,7 @@ check(
 // ── 4. banal, the second half of the command ───────────────────────────────────────────
 {
   const dir = join(work, "banal-4");
-  const e = { ...env, RPP_BANAL_DIR: dir };
+  const e = { ...env, PAPERLINT_BANAL_DIR: dir };
   const before = cmd({ env: e, check: true });
   // Guards: --check covers banal — a complete TeX Live alone must not read as a ready toolchain.
   check(
@@ -633,7 +642,7 @@ check(
 }
 {
   const r = cmd({
-    env: { ...env, RPP_BANAL_DIR: join(work, "banal-bad") },
+    env: { ...env, PAPERLINT_BANAL_DIR: join(work, "banal-bad") },
     banal: { ...BANAL, sha256: "0".repeat(64) },
   });
   // Guards: the two halves are independent — a banal failure fails the command, and TeX Live still

package/src/toolchain.ts

@@ -1,6 +1,6 @@
 /**
  * `paperlint toolchain` — install upstream TeX Live, with exactly the packages the venue profiles
- * declare, into rpp's own cache, and banal (the page-geometry script HotCRP runs) at its pinned
+ * declare, into paperlint's own cache, and banal (the page-geometry script HotCRP runs) at its pinned
  * commit (`adapters/banal/`). `paperlint build` offers the TeX Live install on a terminal.
  *
  * 🔴 WHY paperlint INSTALLS TeX AT ALL (rule 11). "Install TeX Live yourself" was a manual step with a
@@ -19,8 +19,8 @@
  *      once reported success having installed nothing: installers' exit codes are not evidence.)
  * A second run with everything present does nothing and says so; `--check` only reports.
  *
- * Where: `$RPP_TEXLIVE_DIR` when set (CI points its cache there), else
- * `$XDG_CACHE_HOME/rpp/texlive`, else `~/.cache/rpp/texlive` — one tree per TeX Live year inside.
+ * Where: `$PAPERLINT_TEXLIVE_DIR` when set (CI points its cache there), else
+ * `$XDG_CACHE_HOME/paperlint/texlive`, else `~/.cache/paperlint/texlive` — one tree per TeX Live year inside.
  * Processes run through the injected `run` (the port `build.ts` uses), so the harness drives the
  * real download/unpack/verify logic against a fake mirror on disk, never the network.
  */
@@ -56,8 +56,8 @@ import {
   type TexRequirements,
 } from "./tex-requirements.ts";
 
-export const CACHE_ENV = "RPP_TEXLIVE_DIR";
-export const MIRROR_ENV = "RPP_CTAN_MIRROR";
+export const CACHE_ENV = "PAPERLINT_TEXLIVE_DIR";
+export const MIRROR_ENV = "PAPERLINT_CTAN_MIRROR";
 
 /**
  * The CTAN mirrors, redirector first. 🔴 SEVERAL, AND THAT IS A MEASUREMENT: run 33650803245 died
@@ -99,7 +99,11 @@ export function cacheRoot(
   home: string = homedir(),
 ): string {
   if (env[CACHE_ENV]) return env[CACHE_ENV];
-  return join(env["XDG_CACHE_HOME"] || join(home, ".cache"), "rpp", "texlive");
+  return join(
+    env["XDG_CACHE_HOME"] || join(home, ".cache"),
+    "paperlint",
+    "texlive",
+  );
 }
 
 /**
@@ -353,7 +357,9 @@ export function installBase(
   mirrors: readonly string[],
   newerThan: string | null = null,
 ): Step<{ tree: CachedTree; mirror: string }> {
-  const work = realpathSync(mkdtempSync(join(tmpdir(), "rpp-install-tl-")));
+  const work = realpathSync(
+    mkdtempSync(join(tmpdir(), "paperlint-install-tl-")),
+  );
   try {
     io.log(`  downloading install-tl…`);
     const mirror = downloadInstaller(
@@ -409,7 +415,7 @@ function runInstallTl(
 ): Step<{ tree: CachedTree; mirror: string }> {
   const dir = join(a.root, a.year);
   mkdirSync(dir, { recursive: true });
-  const profile = join(a.work, "rpp.profile");
+  const profile = join(a.work, "paperlint.profile");
   writeFileSync(profile, tlProfile(dir));
   io.log(
     `  install-tl: TeX Live ${a.year} scheme-basic from ${a.mirror} (~150 MB, about a minute)…`,

package/src/types.ts

@@ -5,8 +5,8 @@ import type { RuleBlock } from "./rules-config.ts";
  * in someone's head: a typo in a config key read as "field not set", not as an error.
  */
 
-/** The contents of the consumer's `rpp.json`. */
-export interface RppConfig {
+/** The consumer's settings — the `paperlint` key of its `package.json`. */
+export interface PaperlintConfig {
   /** 🔴 REQUIRED. The paper director(ies), relative to the config file ITSELF. The field name is
    * `PAPERS_DIR_FIELD` in lib/paper-config.mjs; code reads it through `papersDirOf()` in cli.ts. */
   papersDir?: string | string[];
@@ -26,7 +26,7 @@ export interface RppConfig {
   structure?: StructureConfig | false;
   /** REMOVED — `paperlint build` compiles the paper itself. Still typed so a leftover key can be named. */
   buildScripts?: unknown;
-  /** ESLint config blocks appended after rpp's own — PARSED by `parseSettings` in cli.ts. */
+  /** ESLint config blocks appended after paperlint's own — PARSED by `parseSettings` in cli.ts. */
   rules?: readonly RuleBlock[];
 }
 
@@ -102,5 +102,5 @@ export interface BuildResult {
 
 /** The result of reading the config: either data, or the exit code the caller exits with. */
 export type ConfigRead =
-  | { opts: RppConfig; configPath: string | null; code?: undefined }
+  | { opts: PaperlintConfig; configPath: string | null; code?: undefined }
   | { code: number; opts?: undefined; configPath?: undefined };