paperlint 2.1.0 → 3.0.0

package/eslint-rules/review-frontmatter.test.mjs

@@ -0,0 +1,118 @@
+/**
+ * review/frontmatter — a review's findings are records in its frontmatter, validated by JSON
+ * Schema — and sibling cards, the same mechanism with the package's sibling-card schema.
+ */
+import { describe, expect, it } from "vitest";
+import { ESLint } from "eslint";
+import markdown from "@eslint/markdown";
+import review from "./review-frontmatter.mjs";
+import sibling from "./sibling-frontmatter.mjs";
+
+async function lint(text) {
+  const eslint = new ESLint({
+    overrideConfigFile: true,
+    overrideConfig: [
+      {
+        files: ["**/*.md"],
+        plugins: { markdown, review },
+        language: "markdown/gfm",
+        languageOptions: { frontmatter: "yaml" },
+        rules: {
+          "review/frontmatter": "error",
+        },
+      },
+    ],
+  });
+  const [res] = await eslint.lintText(text, { filePath: "reviews/r1.md" });
+  expect(res.messages.filter((m) => m.fatal)).toEqual([]);
+  return res.messages.map((m) => m.message);
+}
+const fm = (yaml) => `---\n${yaml}\n---\n# Review\n\nProse.\n`;
+
+describe("review/frontmatter — the findings record", () => {
+  it("silent on a valid record: open with a cause, fixed and wontfix without", async () => {
+    expect(
+      await lint(
+        fm(
+          "findings:\n  - id: 1\n    status: open\n    cause: missing-skill\n  - id: 2\n    status: fixed\n  - id: 3\n    status: wontfix",
+        ),
+      ),
+    ).toEqual([]);
+  });
+
+  it("🔴 an OPEN finding without a cause is a finding — the schema's if/then, not code", async () => {
+    const msgs = await lint(fm("findings:\n  - id: 1\n    status: open"));
+    expect(msgs).toEqual([
+      "`findings[0]` should have required property 'cause'",
+    ]);
+  });
+
+  it("a cause or status outside the list names the allowed values", async () => {
+    const msgs = await lint(
+      fm(
+        "findings:\n  - id: 1\n    status: done\n  - id: 2\n    status: open\n    cause: typo",
+      ),
+    );
+    expect(msgs).toEqual([
+      "`findings[0].status` must be one of: open, fixed, wontfix",
+      "`findings[1].cause` must be one of: skill-defect, missing-skill, hook, rule",
+    ]);
+  });
+
+  it("a misspelt field is named, not silently accepted", async () => {
+    expect(
+      await lint(
+        fm("findings:\n  - id: 1\n    status: fixed\n    casue: hook"),
+      ),
+    ).toEqual(["`findings[0]` has an unknown field `casue`"]);
+  });
+
+  it("a review with no `findings` key is not a findings record — no date needed", async () => {
+    expect(await lint(fm("created: 2020-01-01\ntitle: old review"))).toEqual(
+      [],
+    );
+    expect(await lint("# An old review with no frontmatter\n")).toEqual([]);
+  });
+
+  it("YAML that does not parse is reported, not crashed on", async () => {
+    expect(await lint(fm("findings: [unclosed"))).toEqual([
+      expect.stringMatching(/does not parse as YAML/),
+    ]);
+  });
+});
+
+describe("sibling/frontmatter — the same mechanism, the package's own sibling-card schema", () => {
+  async function card(text) {
+    const eslint = new ESLint({
+      overrideConfigFile: true,
+      overrideConfig: [
+        {
+          files: ["**/*.md"],
+          plugins: { markdown, sibling },
+          language: "markdown/gfm",
+          languageOptions: { frontmatter: "yaml" },
+          rules: { "sibling/frontmatter": "warn" },
+        },
+      ],
+    });
+    const [res] = await eslint.lintText(text, { filePath: "siblings/x.md" });
+    return res.messages.map((m) => m.message);
+  }
+  it("read: full | abstract | none — silent", async () => {
+    for (const v of ["full", "abstract", "none"])
+      expect(await card(fm(`read: ${v}`))).toEqual([]);
+  });
+  it("🔴 a card without the field — or without any frontmatter — is a finding", async () => {
+    expect(await card(fm("title: x"))).toEqual([
+      "the frontmatter should have required property 'read'",
+    ]);
+    expect(await card("# no header\n")).toEqual([
+      "the frontmatter should have required property 'read'",
+    ]);
+  });
+  it("a value outside the three names them", async () => {
+    expect(await card(fm("read: skimmed"))).toEqual([
+      "`read` must be one of: full, abstract, none",
+    ]);
+  });
+});

package/eslint-rules/sibling-frontmatter.mjs

@@ -0,0 +1,19 @@
+/**
+ * `sibling/frontmatter` — a sibling card (`<paper>/siblings/*.md`, written by the
+ * `analyze-sibling-paper` skill) says in its frontmatter how much of the competing paper was READ:
+ * `read: full | abstract | none`. A verdict like "not a scoop" means something different when only
+ * the abstract was read, and a card that does not say is a finding.
+ *
+ * The package writes the cards, so it ships the schema: `sibling-frontmatter.schema.json`. Same
+ * mechanism as `review/frontmatter`.
+ */
+import { frontmatterRule } from "./review-frontmatter.mjs";
+
+export default {
+  rules: {
+    frontmatter: frontmatterRule(
+      new URL("./sibling-frontmatter.schema.json", import.meta.url),
+      "a sibling card's frontmatter records how much of the competing paper was read (`read: full | abstract | none`)",
+    ),
+  },
+};

package/eslint-rules/sibling-frontmatter.schema.json

@@ -0,0 +1,14 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "urn:paperlint:sibling-frontmatter",
+  "title": "paperlint sibling-card frontmatter",
+  "description": "The YAML frontmatter of a sibling card under <paper>/siblings/ (written by the analyze-sibling-paper skill): how much of the competing paper was actually read. A verdict about a paper read only at the abstract is a different claim from one read in full, and the card must say which.",
+  "type": "object",
+  "required": ["read"],
+  "properties": {
+    "read": {
+      "description": "full: the whole paper was read. abstract: only the abstract (and maybe the figures). none: the card is from citations or a summary alone.",
+      "enum": ["full", "abstract", "none"]
+    }
+  }
+}

package/eslint.config.mjs

@@ -14,7 +14,6 @@
 import { texLanguage } from "./eslint-rules/latex-language.mjs";
 import texBuild from "./eslint-rules/tex-build.mjs";
 import markdown from "@eslint/markdown";
-import reviewRules from "./eslint-rules/review-findings-cause.mjs";
 import localRules from "./eslint-rules/temp-root-realpath.mjs";
 import portRules from "./eslint-rules/install-path-literals.mjs";
 import n from "eslint-plugin-n";
@@ -453,20 +452,6 @@ export default [
     plugins: { n },
     rules: { "n/no-missing-import": "error" },
   },
-  /**
-   * The package's first markdown rule — unit 1 of step 9 (moved from the consumer).
-   * The block targets OWN fixtures: in the consumer the same plugin is applied to its
-   * review report directory. `warn` for the same reason as .tex below: fixtures
-   * are DELIBERATELY defective, and `error` would mean `npx eslint .` reds on a healthy
-   * checkout. The signal lives in `npm test`, not in the warning count.
-   */
-  {
-    files: ["fixtures/review-findings-cause/**/*.md"],
-    plugins: { markdown, review: reviewRules },
-    language: "markdown/gfm",
-    languageOptions: { frontmatter: "yaml" },
-    rules: { "review/findings-cause": "warn" },
-  },
   /**
    * Rule 10's mechanical half, prose side — and this is where the debt actually is: 76
    * findings across 29 skills on a healthy checkout, every one of them a command that

package/fixtures/real-markdown-paper/baseline.json

@@ -7,18 +7,17 @@
     "this file names the rule. That is not expressible on an eleven-line stub, where every line was",
     "written by someone who already knew which rule would read it.",
     "",
-    "Recorded 2026-09-19. Three of the five are about the scorecard being deliberately thin",
-    "(no pdf, no frozen source) rather than about the prose; paper/typography's single entry is",
-    "the 18 p-values of paperlint#44. They are real findings against IEEE / ISO 80000-1 style, which",
-    "requires the leading zero, in a blog post written for a general audience rather than for an",
-    "IEEE venue. All 18 sit in prose and table cells, so the count from the parsed tree keeps them.",
+    "Recorded 2026-09-19, re-recorded 2026-09-26 for 3.0.0. Three of the four rules are about the",
+    "scorecard being deliberately thin (no pdf, no frozen source) rather than about the prose.",
+    "paper/leading-zero reports each of the 18 p-values of paperlint#44 where it is (one finding per",
+    "occurrence since 3.0.0; before, paper/typography reported them as one count). They are real",
+    "findings against IEEE / ISO 80000-1 style, in a blog post written for a general audience.",
     "The count is expected to stay. A drop is never a failure here, only growth is."
   ],
   "findings": {
     "paper/stages": 2,
     "paper/source": 1,
-    "paper/author-list": 1,
     "paper/research-question": 1,
-    "paper/typography": 1
+    "paper/leading-zero": 18
   }
 }

package/hooks/hooks.harness.mjs

@@ -39,10 +39,7 @@ import {
 import { tmpdir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import {
-  OLD_PAPERS_DIR_FIELD,
-  PAPERS_DIR_FIELD,
-} from "../lib/paper-config.mjs";
+import { PAPERS_DIR_FIELD } from "../lib/paper-config.mjs";
 
 const HOOKS = dirname(fileURLToPath(import.meta.url));
 const ROOT = resolve(HOOKS, "..");
@@ -61,13 +58,14 @@ const check = (label, cond) => {
 };
 
 /**
- * A throwaway consumer repository: a `package.json` with the given block, a papers tree, and
+ * A throwaway consumer repository: a root `paperlint.json` holding the given settings (none when
+ * `null`), a `package.json`, a papers tree, and
  * `node_modules` wired so both `vigiles/hook` and `require.resolve("<this package>/…")` work
  * from inside it.
  *
  * 🔴 IT IS A REAL DIRECTORY, NOT A MOCK, because what is under test is precisely the part a
  * mock would stub out: whether the hook can READ a declaration out of the consumer's
- * `package.json` via a provider command, and whether a path resolves once this package is
+ * `paperlint.json` via a provider command, and whether a path resolves once this package is
  * installed rather than adjacent. The `node_modules/<pkg>` entry is a symlink to this very
  * checkout, which is what `npm install` of a local package does anyway.
  */
@@ -77,12 +75,9 @@ const consumer = (block, { papers = "docs/papers", paper = "alpha" } = {}) => {
   mkdirSync(nm, { recursive: true });
   symlinkSync(join(ROOT, "node_modules", "vigiles"), join(nm, "vigiles"));
   symlinkSync(ROOT, join(nm, "paperlint"));
-  writeFileSync(
-    join(dir, "package.json"),
-    block === null
-      ? '{"name":"c","type":"module"}\n'
-      : JSON.stringify({ name: "c", type: "module", ...block }) + "\n",
-  );
+  writeFileSync(join(dir, "package.json"), '{"name":"c","type":"module"}\n');
+  if (block !== null)
+    writeFileSync(join(dir, "paperlint.json"), JSON.stringify(block) + "\n");
   if (papers !== null) {
     mkdirSync(join(dir, papers, paper), { recursive: true });
     writeFileSync(
@@ -183,9 +178,7 @@ try {
   // failure, so a diagnostic written at the END only ever prints when nothing else is broken,
   // which is when it diagnoses nothing.
   {
-    const dir = fixture({
-      paperlint: { [PAPERS_DIR_FIELD]: "docs/papers" },
-    });
+    const dir = fixture({ [PAPERS_DIR_FIELD]: "docs/papers" });
     for (const f of SHIPPED) {
       const name = f.replace(/\.hook\.mjs$/, "");
       const r = at(dir, name, STOP);
@@ -200,9 +193,7 @@ try {
   // III. paper-edit-guard — the blocking half and the allowing half
   // ═══════════════════════════════════════════════════════════════════════════
   {
-    const dir = fixture({
-      paperlint: { [PAPERS_DIR_FIELD]: "docs/papers" },
-    });
+    const dir = fixture({ [PAPERS_DIR_FIELD]: "docs/papers" });
     const P = "docs/papers/alpha/paper.md";
     const T = "docs/papers/alpha/paper.tex";
     const deny = (label, cmd) => {
@@ -279,7 +270,7 @@ try {
   // III-b. CWD DRIFT — every hook reads its manifest from the PROJECT ROOT
   // ═══════════════════════════════════════════════════════════════════════════
   // 🔴 Reported live 2026-09-16 by a consumer session: after a `cd` into a subdirectory with no
-  // `package.json`, `paper-edit-guard` denied EVERY Bash command — `pwd` included — and the wedge
+  // manifest, `paper-edit-guard` denied EVERY Bash command — `pwd` included — and the wedge
   // could not be escaped from the shell, because a PreToolUse hook fires before the command that
   // would fix it. The cause is one character of scope: the provider read `package.json`
   // relatively, and vigiles runs providers «via execSync in the hook's cwd».
@@ -289,15 +280,19 @@ try {
   // block anything — it turns them OFF. Silence is a nudge's success state, so a dead nudge and a
   // working one produce identical output. The lockout announces itself; this does not.
   {
-    const dir = fixture({
-      paperlint: { [PAPERS_DIR_FIELD]: "docs/papers" },
-    });
+    // A root the DEFAULT would miss: under drift, a provider that read relatively would fall back
+    // to `papers`, and a guard whose test is depth-agnostic still matches `docs/papers/…` — so
+    // only a root with no `papers` segment shows whether the declaration was actually read.
+    const dir = fixture(
+      { [PAPERS_DIR_FIELD]: "writing/drafts" },
+      { papers: "writing/drafts" },
+    );
 
     // paper-edit-guard: still GUARDS from a foreign cwd, rather than denying everything.
     const write = at(
       dir,
       "paper-edit-guard",
-      onBash(`sed -i s/a/b/ docs/papers/alpha/paper.tex`),
+      onBash(`sed -i s/a/b/ writing/drafts/alpha/paper.tex`),
     );
     check("drift · guard still blocks a paper write", write.exitCode === 2);
     const idle = adrift(dir, "paper-edit-guard", onBash("echo hi"));
@@ -308,7 +303,7 @@ try {
     const guarded = adrift(
       dir,
       "paper-edit-guard",
-      onBash(`sed -i s/a/b/ docs/papers/alpha/paper.tex`),
+      onBash(`sed -i s/a/b/ writing/drafts/alpha/paper.tex`),
     );
     check(
       "drift · guard STILL blocks the paper write it exists for",
@@ -319,13 +314,13 @@ try {
     const nudge = adrift(
       dir,
       "paper-skills-nudge",
-      onEdit(`${dir}/docs/papers/alpha/paper.tex`),
+      onEdit(`${dir}/writing/drafts/alpha/paper.tex`),
     );
     check("drift · the skills nudge still fires", injected(nudge).length > 0);
     const gates = adrift(
       dir,
       "paper-status-gates",
-      onEdit(`${dir}/docs/papers/alpha/PIPELINE-STATUS.md`),
+      onEdit(`${dir}/writing/drafts/alpha/PIPELINE-STATUS.md`),
     );
     check(
       `drift · the status-gates hook still runs (rc=${gates.exitCode})`,
@@ -357,7 +352,7 @@ try {
     // (a) a declared root is used AS DECLARED — and the default is NOT.
     {
       const dir = fixture(
-        { paperlint: { [PAPERS_DIR_FIELD]: DECLARED } },
+        { [PAPERS_DIR_FIELD]: DECLARED },
         { papers: DECLARED },
       );
       check(
@@ -373,36 +368,7 @@ try {
         at(dir, "paper-edit-guard", harmless).exitCode === 0,
       );
     }
-    // (a½) the key's OLD name (before 2.0.0) is still read — an upgrade must not unguard papers.
-    {
-      const dir = fixture(
-        { "research-paper-pipeline": { [PAPERS_DIR_FIELD]: DECLARED } },
-        { papers: DECLARED },
-      );
-      check(
-        "carrier: 🔴 a root declared under the OLD key is still guarded",
-        at(dir, "paper-edit-guard", declaredWrite).exitCode === 2 &&
-          at(dir, "paper-edit-guard", defaultWrite).exitCode === 0,
-      );
-    }
-    {
-      const dir = fixture(
-        {
-          paperlint: { [PAPERS_DIR_FIELD]: DECLARED },
-          "research-paper-pipeline": { [PAPERS_DIR_FIELD]: "papers" },
-        },
-        { papers: DECLARED },
-      );
-      const r = at(dir, "paper-edit-guard", harmless);
-      check(
-        "carrier: both keys with different contents — the gate refuses and names both",
-        r.exitCode === 2 &&
-          /has both "paperlint" and "research-paper-pipeline"/.test(
-            r.stderr + r.stdout,
-          ),
-      );
-    }
-    // (b) no key at all → the documented default, and the converse of (a).
+    // (b) no paperlint.json at all → the documented default, and the converse of (a).
     {
       const dir = fixture(null, { papers: "papers" });
       check(
@@ -417,9 +383,7 @@ try {
     // (c) an explicit `null` is a KEYSTROKE, not an absence. `??` would read it as "undeclared"
     //     and silently substitute the default.
     {
-      const dir = fixture({
-        paperlint: { [PAPERS_DIR_FIELD]: null },
-      });
+      const dir = fixture({ [PAPERS_DIR_FIELD]: null });
       const r = at(dir, "paper-edit-guard", harmless);
       check(
         `carrier: "${PAPERS_DIR_FIELD}": null REFUSES (rc=${r.exitCode})`,
@@ -432,9 +396,7 @@ try {
     }
     // (d) the empty string — the value that makes every prefix test vacuously true.
     {
-      const dir = fixture({
-        paperlint: { [PAPERS_DIR_FIELD]: "" },
-      });
+      const dir = fixture({ [PAPERS_DIR_FIELD]: "" });
       const r = at(dir, "paper-edit-guard", harmless);
       check(
         `carrier: "${PAPERS_DIR_FIELD}": "" REFUSES (rc=${r.exitCode})`,
@@ -445,34 +407,19 @@ try {
         /matches nothing/.test(r.stderr),
       );
     }
-    // (d2) the field's OLD name is refused and named — never read as a fallback, never ignored
-    //      in favour of the default directory.
-    {
-      const dir = fixture({
-        paperlint: { [OLD_PAPERS_DIR_FIELD]: "writing/drafts" },
-      });
-      const r = at(dir, "paper-edit-guard", harmless);
-      check(
-        `carrier: the old field name "${OLD_PAPERS_DIR_FIELD}" REFUSES (rc=${r.exitCode})`,
-        r.exitCode === 2,
-      );
-      check(
-        "carrier: …and the refusal says what it was renamed to",
-        r.stderr.includes(
-          `"${OLD_PAPERS_DIR_FIELD}" was renamed to "${PAPERS_DIR_FIELD}" in package.json → "paperlint"`,
-        ),
-      );
-    }
-    // (e) an unreadable package.json — the case that arrives by itself, mid-merge.
+    // (e) an unreadable paperlint.json — the case that arrives by itself, mid-merge.
     {
       const dir = fixture(
-        { paperlint: { [PAPERS_DIR_FIELD]: DECLARED } },
+        { [PAPERS_DIR_FIELD]: DECLARED },
         { papers: DECLARED },
       );
-      writeFileSync(join(dir, "package.json"), '{ "name": "c" <<<<<<< HEAD\n');
+      writeFileSync(
+        join(dir, "paperlint.json"),
+        '{ "papersDir": "x" <<<<<<< HEAD\n',
+      );
       const r = at(dir, "paper-edit-guard", harmless);
       check(
-        `carrier: an unparseable package.json REFUSES (rc=${r.exitCode})`,
+        `carrier: an unparseable paperlint.json REFUSES (rc=${r.exitCode})`,
         r.exitCode === 2,
       );
       check(
@@ -485,7 +432,7 @@ try {
     //     nothing. This defect made an earlier version of the guard a silent no-op.
     {
       const dir = fixture(
-        { paperlint: { [PAPERS_DIR_FIELD]: DECLARED + "/" } },
+        { [PAPERS_DIR_FIELD]: DECLARED + "/" },
         { papers: DECLARED },
       );
       check(
@@ -499,9 +446,7 @@ try {
   // V. paper-skills-nudge — it must LAND, not merely fire
   // ═══════════════════════════════════════════════════════════════════════════
   {
-    const dir = fixture({
-      paperlint: { [PAPERS_DIR_FIELD]: "docs/papers" },
-    });
+    const dir = fixture({ [PAPERS_DIR_FIELD]: "docs/papers" });
     const lands = (label, p) => {
       const r = at(dir, "paper-skills-nudge", onEdit(p));
       const ctx = injected(r);
@@ -532,7 +477,7 @@ try {
     // The advisory's own asymmetry: it goes quiet where the gate refuses.
     {
       const broken = fixture(
-        { paperlint: { [PAPERS_DIR_FIELD]: null } },
+        { [PAPERS_DIR_FIELD]: null },
         { papers: "papers" },
       );
       const r = at(
@@ -564,9 +509,7 @@ try {
   // VI. paper-status-gates — the tool runs, and only for a validated directory
   // ═══════════════════════════════════════════════════════════════════════════
   {
-    const dir = fixture({
-      paperlint: { [PAPERS_DIR_FIELD]: "docs/papers" },
-    });
+    const dir = fixture({ [PAPERS_DIR_FIELD]: "docs/papers" });
     const fires = (label, p) => {
       const r = at(dir, "paper-status-gates", onEdit(p));
       check(
@@ -600,7 +543,7 @@ try {
     // 🔴 The `??` discriminator again, for this hook's own copy of the carrier.
     {
       const broken = fixture(
-        { paperlint: { [PAPERS_DIR_FIELD]: null } },
+        { [PAPERS_DIR_FIELD]: null },
         { papers: "papers" },
       );
       check(
@@ -612,7 +555,7 @@ try {
     // The declared root is regex-ESCAPED: `.` in a root must not act as a wildcard.
     {
       const dotted = fixture(
-        { paperlint: { [PAPERS_DIR_FIELD]: "docs.v2/papers" } },
+        { [PAPERS_DIR_FIELD]: "docs.v2/papers" },
         { papers: "docs.v2/papers" },
       );
       check(
@@ -654,9 +597,7 @@ try {
   // VIII. paper-status-gates.sh — a TOOL, and it must refuse to be a hook
   // ═══════════════════════════════════════════════════════════════════════════
   {
-    const dir = fixture({
-      paperlint: { [PAPERS_DIR_FIELD]: "docs/papers" },
-    });
+    const dir = fixture({ [PAPERS_DIR_FIELD]: "docs/papers" });
     const sh = (args) =>
       runHook(
         `bash ${JSON.stringify(join(HOOKS, "paper-status-gates.sh"))} ${args}`,

package/hooks/hooks.mutations.mjs

@@ -75,10 +75,10 @@ const M = [
   [
     GUARD,
     "guard carrier/parse failure DEFAULTS instead of denying",
-    "treat an unreadable package.json as «nothing declared» — the measured failure: the provider " +
+    "treat an unreadable paperlint.json as «nothing declared» — the measured failure: the provider " +
       "hands back the EMPTY STRING in silence, so the gate quietly re-roots at the default",
     "  } catch {\n    return deny(\n      `${CONFIG_KEY}: this gate could not read",
-    "  } catch {\n    pkg = {};\n    void deny(\n      `${CONFIG_KEY}: this gate could not read",
+    "  } catch {\n    config = {};\n    void deny(\n      `${CONFIG_KEY}: this gate could not read",
   ],
   [
     GUARD,
@@ -131,8 +131,8 @@ const M = [
     "drop the anchor to the project root — the read fails once cwd drifts, and under the rule " +
       '"an unreadable declaration denies" the guard blocks ANY Bash command, including the one ' +
       "that would fix it",
-    'needs: [provide("pkg", \'cat "${CLAUDE_PROJECT_DIR:-.}/package.json"\')],',
-    'needs: [provide("pkg", "cat package.json")],',
+    'const READ_CONFIG = `f="\\${CLAUDE_PROJECT_DIR:-.}/${CONFIG_FILE}";',
+    'const READ_CONFIG = `f="${CONFIG_FILE}";',
   ],
   [
     "hooks/paper-skills-nudge.hook.mjs",
@@ -141,8 +141,8 @@ const M = [
       "hook does not deny, it returns `nothing()` — i.e. it just quietly stops firing. Silence " +
       "is exactly what a nudge's success state looks like, so a dead hook is indistinguishable " +
       "from a working one except by this mutation",
-    'needs: [provide("pkg", \'cat "${CLAUDE_PROJECT_DIR:-.}/package.json"\')],',
-    'needs: [provide("pkg", "cat package.json")],',
+    'const READ_CONFIG = `f="\\${CLAUDE_PROJECT_DIR:-.}/${CONFIG_FILE}";',
+    'const READ_CONFIG = `f="${CONFIG_FILE}";',
   ],
   [
     GUARD,

package/hooks/paper-edit-guard.hook.d.mts

@@ -4,10 +4,9 @@
 // silently stopped covering the import once a formatter wrapped it across five.
 
 export declare const CONFIG_KEY: "paperlint";
-export declare const LEGACY_CONFIG_KEY: "research-paper-pipeline";
+export declare const CONFIG_FILE: "paperlint.json";
 export declare const DEFAULT_PAPERS_ROOT: "papers";
 export declare const PAPERS_DIR_FIELD: string;
-export declare const OLD_PAPERS_DIR_FIELD: string;
 
 /** The declared papers root, or the hook's rejection object; callers tell them apart by `typeof`. */
-export declare const papersRoot: (rawPkg: string) => string | object;
+export declare const papersRoot: (rawConfig: string) => string | object;