paperlint 10.2.0 → 10.4.0

package/src/study-registry-rule.test.ts

@@ -6,14 +6,22 @@
  * on the first line of `PIPELINE-STATUS.md`, with the domain's text.
  */
 import { describe, expect, it } from "vitest";
-import { memoryFiles, memoryListDir } from "./adapters/memory/index.ts";
+import {
+  memoryFiles,
+  memoryListDir,
+  memoryListEntries,
+} from "./adapters/memory/index.ts";
 import { studyRegistryCodec } from "./adapters/study-registry/index.ts";
 import {
+  planTemplate,
+  planText,
   registryText,
   studyMessage,
   withIndex,
   type Study,
+  type StudyPlan,
   type StudyRegistry,
+  type IndexInput,
 } from "./domain/study-registry.ts";
 import {
   registryOf,
@@ -22,6 +30,9 @@ import {
   studyRegistryRules,
 } from "./study-registry-rule.ts";
 
+/** No plan and no history: the index with every mode column `—`. */
+const NO_FACTS: IndexInput = { plans: new Map(), history: new Map() };
+
 const DIR = "/work/papers/example";
 const SCAFFOLD = {
   [`${DIR}/PIPELINE-STATUS.md`]: "# status\n",
@@ -43,7 +54,7 @@ const study = (over: Partial<Study> = {}): Study => ({
 /** A registered `repro/`: the registry, its index, and a README.md in each row's folder. */
 const registered = (
   r: StudyRegistry,
-  readme: string | null = withIndex("# Reproduction index\n", r),
+  readme: string | null = withIndex("# Reproduction index\n", r, NO_FACTS),
 ): Record<string, string> => ({
   ...SCAFFOLD,
   [`${DIR}/repro/studies.json`]: registryText(r),
@@ -65,13 +76,15 @@ interface Reported {
 function lint(
   tree: Readonly<Record<string, string>>,
   file = `${DIR}/PIPELINE-STATUS.md`,
+  name: "study-registered" | "study-plan-name" = "study-registered",
 ): Reported[] {
   const files = memoryFiles(tree);
   const rule = studyRegistryRules({
     files,
     listDir: memoryListDir(files),
+    entries: memoryListEntries(files),
     codec: studyRegistryCodec,
-  })["study-registered"];
+  })[name];
   const out: Reported[] = [];
   const visitor = rule.create({
     filename: file,
@@ -219,9 +232,9 @@ describe("repro/study-registered — reports a row's status and the index", () =
 
   it("a stale index", () => {
     const r = P1(study());
-    expect(messages(registered(r, withIndex("# x\n", P1())))).toEqual([
-      studyMessage({ problem: "stale-index", why: "differs" }),
-    ]);
+    expect(messages(registered(r, withIndex("# x\n", P1(), NO_FACTS)))).toEqual(
+      [studyMessage({ problem: "stale-index", why: "differs" })],
+    );
   });
 });
 
@@ -271,6 +284,7 @@ describe("repro/study-registered — level", () => {
   it("is an error from the start", () => {
     expect(STUDY_REGISTRY_RULE_LEVELS).toEqual({
       "repro/study-registered": "error",
+      "repro/study-plan-name": "warn",
     });
   });
 });
@@ -296,7 +310,7 @@ describe("repro/study-registered — a result_file the disk cannot hold", () =>
     const files = memoryFiles({
       ...SCAFFOLD,
       [`${DIR}/repro/studies.json`]: registryText(r),
-      [`${DIR}/repro/README.md`]: withIndex("# index\n", r),
+      [`${DIR}/repro/README.md`]: withIndex("# index\n", r, NO_FACTS),
       [`${DIR}/repro/P1-S01-baseline/README.md`]: "# s\n",
     });
     const probe = {
@@ -310,8 +324,320 @@ describe("repro/study-registered — a result_file the disk cannot hold", () =>
       studyFindings(DIR, {
         files: probe,
         listDir: memoryListDir(files),
+        entries: memoryListEntries(files),
         codec: studyRegistryCodec,
       }).map((f) => f.problem),
     ).toEqual(["result-file"]);
   });
 });
+
+describe("repro/study-registered — a study folder that is a symbolic link", () => {
+  it("never reads a plan or a result through it", () => {
+    const r = P1(
+      study({
+        status: "done",
+        result: "41 of 60",
+        result_file: "r.txt",
+        plan: "plan.json",
+      }),
+    );
+    const files = memoryFiles({
+      ...registered(r),
+      [`${DIR}/repro/P1-S01-baseline/plan.json`]: "not JSON",
+      [`${DIR}/repro/P1-S01-baseline/r.txt`]: "41 of 60\n",
+    });
+    const found = studyFindings(DIR, {
+      files,
+      listDir: memoryListDir(files),
+      entries: (dir) =>
+        memoryListEntries(files)(dir).map((e) =>
+          e.name === "P1-S01-baseline" ? { ...e, kind: "symlink" as const } : e,
+        ),
+      codec: studyRegistryCodec,
+    });
+    // Guards: the files behind the link are not read — the plan and the result read as missing.
+    expect(
+      found.map((f) =>
+        f.problem === "bad-plan" || f.problem === "result-file"
+          ? `${f.problem}:${f.why}`
+          : f.problem,
+      ),
+    ).toEqual(["result-file:missing", "bad-plan:missing"]);
+  });
+});
+
+describe("repro/study-registered — a row whose folder leads outside repro/", () => {
+  it("is reported by name, and nothing is read through it: its plan and result read as missing", () => {
+    const r = P1(
+      study({
+        folder: "../outside",
+        status: "done",
+        result: "41 of 60",
+        result_file: "r.txt",
+        plan: "plan.json",
+      }),
+    );
+    const files = memoryFiles({
+      ...SCAFFOLD,
+      [`${DIR}/repro/studies.json`]: registryText(r),
+      [`${DIR}/repro/README.md`]: withIndex("# index\n", r, NO_FACTS),
+      [`${DIR}/outside/plan.json`]: "not JSON",
+      [`${DIR}/outside/r.txt`]: "41 of 60\n",
+    });
+    const read: string[] = [];
+    const spy = {
+      ...files,
+      readBytes: (p: Parameters<typeof files.readBytes>[0]) => {
+        read.push(p);
+        return files.readBytes(p);
+      },
+      isFile: (p: Parameters<typeof files.isFile>[0]): boolean => {
+        read.push(p);
+        return files.isFile(p);
+      },
+    };
+    const found = studyFindings(DIR, {
+      files: spy,
+      listDir: memoryListDir(files),
+      entries: memoryListEntries(files),
+      codec: studyRegistryCodec,
+    });
+    // Guards: a row naming `../outside` never has a file outside `repro/` read for it.
+    expect([
+      found.map((f) =>
+        f.problem === "bad-plan" || f.problem === "result-file"
+          ? `${f.problem}:${f.why}`
+          : f.problem,
+      ),
+      read.filter((p) => p.includes("/outside/")),
+    ]).toEqual([
+      ["folder-name", "no-folder", "result-file:missing", "bad-plan:missing"],
+      [],
+    ]);
+  });
+});
+
+/** A plan as a study would hold it once the author has checked its drawn units. */
+const FILLED_PLAN: StudyPlan = {
+  question: "How many rules can a linter check?",
+  population: {
+    source: "the crawl of 2026-10-01",
+    draw: { kind: "all", method: "census" },
+  },
+  arms: [],
+  primary_outcome: "the share of rules a linter can check",
+  author_check: { by: "A. Author", date: "2026-10-14", quote: "Go." },
+  mode: {
+    kind: "decide_before_run",
+    outputs: ["results.tsv"],
+    decision: {
+      file: "repro/P1-S01-baseline/decision.md",
+      note: "the sample approved",
+    },
+  },
+};
+const FILLED = planText(FILLED_PLAN);
+
+/** The index of `r` as `studies index` writes it, FILLED_PLAN as its study's plan and `history` read. */
+const FILLED_INDEX = (
+  r: StudyRegistry,
+  history: IndexInput["history"] = new Map(),
+): string =>
+  withIndex("# Reproduction index\n", r, {
+    plans: new Map([
+      ["P1-S01-baseline/plan.json", { kind: "ready", plan: FILLED_PLAN }],
+    ]),
+    history,
+  });
+
+/** A registry with a headline measurement of one running study whose row names `plan`. */
+const HEADLINE = (plan: string): StudyRegistry => ({
+  prefix: "P1",
+  author: "A. Author",
+  measurements: [
+    {
+      id: "M1",
+      title: "Rule census",
+      role: "headline",
+      approval: { by: "A. Author", date: "2026-10-12", quote: "Yes." },
+    },
+  ],
+  studies: [study({ status: "running", measurement: "M1", plan })],
+});
+
+describe("repro/study-registered — the plan a row names, read from its folder", () => {
+  it("is silent on a plan.json the author checked, its mode in the index", () => {
+    const r = HEADLINE("plan.json");
+    expect(
+      lint({
+        ...registered(r, FILLED_INDEX(r)),
+        [`${DIR}/repro/P1-S01-baseline/plan.json`]: FILLED,
+      }),
+    ).toEqual([]);
+  });
+
+  it("reports a plan that is not there", () => {
+    expect(messages(registered(HEADLINE("plan.json")))).toEqual([
+      studyMessage({
+        problem: "bad-plan",
+        id: "P1-S01",
+        path: "plan.json",
+        why: "missing",
+      }),
+    ]);
+  });
+
+  it("reports a plan that is not JSON, with the reason", () => {
+    expect(
+      messages({
+        ...registered(HEADLINE("plan.json")),
+        [`${DIR}/repro/P1-S01-baseline/plan.json`]: "{",
+      }),
+    ).toEqual([
+      studyMessage({
+        problem: "bad-plan",
+        id: "P1-S01",
+        path: "plan.json",
+        why: "unreadable",
+        reasons: "not JSON",
+      }),
+    ]);
+  });
+
+  it("reports a running study of the headline whose plan is still the template", () => {
+    expect(
+      lint({
+        ...registered(HEADLINE("plan.json")),
+        [`${DIR}/repro/P1-S01-baseline/plan.json`]: planText(
+          planTemplate("spike", "x"),
+        ),
+      }).map((r) => [r.messageId, r.line]),
+    ).toEqual([
+      ["bad-plan", 1],
+      ["author-check", 1],
+    ]);
+  });
+});
+
+describe("repro/study-registered — a plan the disk cannot hold", () => {
+  it("reads as missing, and the disk is never asked", () => {
+    const r = HEADLINE("a\u0000.json");
+    const files = memoryFiles(registered(r));
+    const probe = {
+      ...files,
+      isFile: (p: Parameters<typeof files.isFile>[0]): boolean => {
+        if (p.includes("\0")) throw new Error("ERR_INVALID_ARG_VALUE");
+        return files.isFile(p);
+      },
+    };
+    expect(
+      studyFindings(DIR, {
+        files: probe,
+        listDir: memoryListDir(files),
+        entries: memoryListEntries(files),
+        codec: studyRegistryCodec,
+      }).map((f) => f.problem),
+    ).toEqual(["bad-plan"]);
+  });
+});
+
+describe("repro/study-plan-name — a plan under its old name", () => {
+  const OLD = {
+    ...registered(HEADLINE("prereg.json")),
+    [`${DIR}/repro/P1-S01-baseline/prereg.json`]: FILLED,
+  };
+
+  it("is read as the plan: repro/study-registered is silent", () => {
+    expect(lint(OLD)).toEqual([]);
+  });
+
+  it("is reported by repro/study-plan-name, naming plan.json", () => {
+    expect(lint(OLD, `${DIR}/PIPELINE-STATUS.md`, "study-plan-name")).toEqual([
+      {
+        messageId: "legacy-plan",
+        message: studyMessage({
+          problem: "legacy-plan",
+          id: "P1-S01",
+          path: "prereg.json",
+        }),
+        line: 1,
+      },
+    ]);
+  });
+
+  it("is silent on plan.json, and on any file but PIPELINE-STATUS.md", () => {
+    const tree = {
+      ...registered(HEADLINE("plan.json")),
+      [`${DIR}/repro/P1-S01-baseline/plan.json`]: FILLED,
+    };
+    expect([
+      lint(tree, `${DIR}/PIPELINE-STATUS.md`, "study-plan-name"),
+      lint(OLD, `${DIR}/paper.tex`, "study-plan-name"),
+    ]).toEqual([[], []]);
+  });
+});
+
+/** A plan whose texts are filled and which declares no mode; checked by the author when `check`. */
+const noMode = (check: boolean): string =>
+  planText({
+    question: "q",
+    population: { source: "s", draw: { kind: "all", method: "census" } },
+    arms: [],
+    primary_outcome: "o",
+    author_check: check
+      ? { by: "A. Author", date: "2026-10-14", quote: "Go." }
+      : null,
+  });
+
+/** The first line of each finding over the headline study with `plan` as its plan.json. */
+const firstLines = (plan: string): readonly string[] =>
+  lint({
+    ...registered(HEADLINE("plan.json")),
+    [`${DIR}/repro/P1-S01-baseline/plan.json`]: plan,
+  }).map((r) => r.message.split("\n")[0] ?? "");
+
+it("repro/study-registered — a measurement's plan that has run without a mode is reported; approved without one, it is no plan", () => {
+  // Guards: decide-first is the default — a measurement that ran with no mode is reported, never silent.
+  expect([firstLines(noMode(false)), firstLines(noMode(true))]).toEqual([
+    [
+      "The plan of `P1-S01`, `plan.json` in its folder, leaves `mode` empty, and the study is `running`: a plan is written before the runs. What to do: fill them in, or set the study back to `designing`.",
+      "`P1-S01` is `running` in the headline measurement `M1`, and its plan has no `author_check`. What to do: show the author the drawn units, then record their answer in the plan's `author_check` — `by`, `date`, and their words in `quote`.",
+    ],
+    [
+      "The plan of `P1-S01`, `plan.json` in its folder, is not a study plan: author_check: is set, and the plan leaves `mode` empty — the author approves a complete plan: fill them, or set author_check to null. What to do: give it the fields on the rule's page — `question`, `population`, `arms`, `primary_outcome`, and for a measurement its `mode`.",
+    ],
+  ]);
+});
+
+describe("repro/study-registered — the index's mode columns", () => {
+  it("reports an index whose mode column is not the plan's, and never compares the two read from git", () => {
+    const r = HEADLINE("plan.json");
+    const at = { commit: "a".repeat(40), date: "2026-10-14T09:00:00+05:00" };
+    const lintWith = (readme: string): string[] =>
+      lint({
+        ...registered(r, readme),
+        [`${DIR}/repro/P1-S01-baseline/plan.json`]: FILLED,
+      }).map((x) => x.messageId);
+    // Guards: the mode is in the tree, so a stale one is reported; the commits are what git said when
+    // `studies index` ran — a squash merge renames them — so whatever they say is in sync.
+    expect([
+      lintWith(withIndex("# Reproduction index\n", r, NO_FACTS)),
+      lintWith(
+        FILLED_INDEX(
+          r,
+          new Map([
+            [
+              "P1-S01",
+              {
+                kind: "read",
+                decision: at,
+                decisionDeleted: false,
+                firstOutput: at,
+              },
+            ],
+          ]),
+        ),
+      ),
+    ]).toEqual([["stale-index"], []]);
+  });
+});

package/src/study-registry-rule.ts

@@ -1,10 +1,11 @@
 /**
  * `repro/study-registered` — every study folder at the top of a paper's `repro/` has exactly one row in
- * `repro/studies.json`, every row names a folder that exists, and the index in `repro/README.md` is the
- * one the registry generates.
+ * `repro/studies.json`, every row names a folder that exists, a row's measurement and plan hold
+ * together, and the index in `repro/README.md` is the one the registry generates. Beside it,
+ * `repro/study-plan-name`, a warning: a plan still named `prereg.json`.
  *
  * What is judged, and why, is `src/domain/study-registry.ts` and docs/rules/repro/study-registered.md.
- * This file lists `repro/`, reads the registry, the README and the result files, and reports.
+ * This file lists `repro/`, reads the registry, the README, the result files and the plans, and reports.
  *
  * ── WHY A RULE OF ITS OWN, NOT MORE OF `repro/allowed-files-only` ─────────────────────
  * `repro/allowed-files-only` judges what may stand at the top of `repro/`, by name, and accepts the
@@ -16,7 +17,7 @@
  * `PIPELINE-STATUS.md`, first line, like the layout rules: every paper has it, and ESLint lints no
  * file in `repro/`.
  */
-import { basename, dirname, join } from "node:path";
+import { basename, dirname, join, posix } from "node:path";
 import { callerPath } from "./caller-path.ts";
 import {
   README,
@@ -25,9 +26,14 @@ import {
   REPRO_DIRS,
 } from "./domain/repro-layout.ts";
 import {
+  LEGACY_PLAN_FILE,
+  PLAN_NAME_PROBLEMS,
   STUDIES_FILE,
+  isFolderName,
   judgeStudies,
+  planRefs,
   studyMessage,
+  type PlanState,
   type RegistryState,
   type StudyFinding,
 } from "./domain/study-registry.ts";
@@ -37,6 +43,7 @@ import type {
   FolderRuleModule,
 } from "./folder-venue-rule.ts";
 import type { Files } from "./ports/files.ts";
+import type { ListEntries } from "./ports/list-entries.ts";
 import type { StudyRegistryCodec } from "./ports/study-registry-codec.ts";
 import { reproEntriesOf } from "./repro-layout-rule.ts";
 import { rulePageUrl } from "./venue-rules.ts";
@@ -46,10 +53,36 @@ const STATUS_FILE = "PIPELINE-STATUS.md";
 /** What the rule reads with: the disk, its listings, and the registry's parser. */
 export interface StudyRegistryDeps extends FolderLayoutDeps {
   readonly codec: StudyRegistryCodec;
+  /** `repro/`'s entries, links not followed: a study folder that is a link is never read through. */
+  readonly entries: ListEntries;
 }
 
+/** The names at the top of `<dir>/repro/` that are symbolic links. */
+const linksIn = (
+  dir: string,
+  deps: Pick<StudyRegistryDeps, "entries">,
+): ReadonlySet<string> =>
+  new Set(
+    deps
+      .entries(callerPath(join(dir, REPRO_DIR)))
+      .filter((e) => e.kind === "symlink")
+      .map((e) => e.name),
+  );
+
+/**
+ * The test every reader of a study's folder passes a row through: its folder is one folder name
+ * inside `repro/` (`isFolderName`) and not a symbolic link, which would lead the reads anywhere.
+ */
+export const readableFolders = (
+  dir: string,
+  deps: Pick<StudyRegistryDeps, "entries">,
+): ((folder: string) => boolean) => {
+  const links = linksIn(dir, deps);
+  return (folder) => isFolderName(folder) && !links.has(folder);
+};
+
 /** The text of the file at `p`; null when there is none, or a directory sits there. */
-const textAt = (files: Files, p: string): string | null => {
+export const textAt = (files: Files, p: string): string | null => {
   const b = files.isFile(callerPath(p)) ? files.readBytes(callerPath(p)) : null;
   return b === null ? null : new TextDecoder().decode(b);
 };
@@ -83,9 +116,12 @@ const existingResults = (
   dir: string,
   r: RegistryState,
   files: Files,
+  readable: (folder: string) => boolean,
 ): ReadonlySet<string> =>
   new Set(
     (r.kind === "read" ? r.registry.studies : [])
+      // A row whose folder is not one inside `repro/`, or is a link, is never read through.
+      .filter((s) => readable(s.folder))
       .flatMap((s) =>
         s.result_file === undefined ? [] : [`${s.folder}/${s.result_file}`],
       )
@@ -97,21 +133,52 @@ const existingResults = (
       ),
   );
 
-/** Every finding of the paper folder `dir`'s study registry — THE function behind the rule. */
+/**
+ * The plan each row of `r` names, read and parsed, by `<folder>/<plan>`; a plan not there is left out.
+ * A plan still named `prereg.json` is parsed by the loose schema of its old name.
+ */
+export const plansOf = (
+  dir: string,
+  r: RegistryState,
+  deps: Pick<StudyRegistryDeps, "files" | "codec">,
+  readable: (folder: string) => boolean,
+): ReadonlyMap<string, PlanState> =>
+  new Map(
+    (r.kind === "read" ? planRefs(r.registry) : [])
+      // A NUL is no path the disk can hold, and probing one throws: such a plan reads as missing. A
+      // folder that is a link is never read through.
+      .filter(({ key, folder }) => !key.includes("\0") && readable(folder))
+      .flatMap(({ key, kind }): readonly (readonly [string, PlanState])[] => {
+        const text = textAt(deps.files, join(dir, REPRO_DIR, key));
+        if (text === null) return [];
+        return [
+          [
+            key,
+            posix.basename(key) === LEGACY_PLAN_FILE
+              ? deps.codec.parseLegacyPlan(text)
+              : deps.codec.parsePlan(text, kind),
+          ],
+        ];
+      }),
+  );
+
+/** Every finding of the paper folder `dir`'s study registry — THE function behind both rules. */
 export function studyFindings(
   dir: string,
   deps: StudyRegistryDeps,
 ): readonly StudyFinding[] {
+  const readable = readableFolders(dir, deps);
   const registry = registryOf(dir, deps);
   return judgeStudies({
     folders: studyFolders(dir, deps),
     registry,
     readme: textAt(deps.files, join(dir, REPRO_DIR, README)),
-    existingResults: existingResults(dir, registry, deps.files),
+    existingResults: existingResults(dir, registry, deps.files, readable),
+    plans: plansOf(dir, registry, deps, readable),
   });
 }
 
-/** The problems a finding can be, each its own message id; the text is `studyMessage`. */
+/** The problems `repro/study-registered` reports, each its own message id; the text is `studyMessage`. */
 const PROBLEMS: readonly StudyFinding["problem"][] = [
   "no-registry",
   "unreadable",
@@ -126,47 +193,84 @@ const PROBLEMS: readonly StudyFinding["problem"][] = [
   "result-file",
   "no-successor",
   "stale-index",
+  "unknown-measurement",
+  "empty-measurement",
+  "unknown-requirement",
+  "headline-approval",
+  "bad-plan",
+  "author-check",
 ];
 
-const META: FolderRuleModule["meta"] = {
+/** A rule's meta: its page, and a message id per problem, the whole text being `studyMessage`. */
+const metaOf = (
+  name: string,
+  description: string,
+  problems: readonly StudyFinding["problem"][],
+): FolderRuleModule["meta"] => ({
   type: "suggestion",
-  docs: {
-    description:
-      "every study folder at the top of a paper's repro/ has exactly one row in repro/studies.json, every row names a folder that exists, and repro/README.md's index is the one the registry generates",
-    url: rulePageUrl("repro/study-registered"),
-  },
+  docs: { description, url: rulePageUrl(name) },
   schema: [],
-  // The whole text is `studyMessage` (src/domain/study-registry.ts).
-  messages: Object.fromEntries(PROBLEMS.map((p) => [p, "{{text}}"])),
-};
+  messages: Object.fromEntries(problems.map((p) => [p, "{{text}}"])),
+});
 
-/** The rule, reading the folder through `deps`. */
-export function studyRegistryRules(
+/** A rule that reports the findings of `problems`, reading the folder through `deps`. */
+const ruleOf = (
+  meta: FolderRuleModule["meta"],
+  problems: readonly StudyFinding["problem"][],
   deps: StudyRegistryDeps,
-): Readonly<Record<"study-registered", FolderRuleModule>> {
-  return {
-    "study-registered": {
-      meta: META,
-      create(context: FolderRuleContext) {
-        if (basename(context.filename) !== STATUS_FILE) return {};
-        return {
-          root() {
-            const at = context.sourceCode.getLocFromIndex(0);
-            studyFindings(dirname(context.filename), deps).forEach((f) => {
-              context.report({
-                loc: { start: at, end: at },
-                messageId: f.problem,
-                data: { text: studyMessage(f) },
-              });
+): FolderRuleModule => ({
+  meta,
+  create(context: FolderRuleContext) {
+    if (basename(context.filename) !== STATUS_FILE) return {};
+    return {
+      root() {
+        const at = context.sourceCode.getLocFromIndex(0);
+        studyFindings(dirname(context.filename), deps)
+          .filter((f) => problems.includes(f.problem))
+          .forEach((f) => {
+            context.report({
+              loc: { start: at, end: at },
+              messageId: f.problem,
+              data: { text: studyMessage(f) },
             });
-          },
-        };
+          });
       },
-    },
+    };
+  },
+});
+
+/**
+ * The two rules, reading the folder through `deps`: `study-registered`, the registry's errors, and
+ * `study-plan-name`, a warning for a plan still named `prereg.json` — read as the plan, so a paper
+ * that wrote one before `plan.json` existed is not broken, and told the name to move to.
+ */
+export function studyRegistryRules(
+  deps: StudyRegistryDeps,
+): Readonly<Record<"study-registered" | "study-plan-name", FolderRuleModule>> {
+  return {
+    "study-registered": ruleOf(
+      metaOf(
+        "repro/study-registered",
+        "every study folder at the top of a paper's repro/ has exactly one row in repro/studies.json, every row names a folder that exists, its measurement and its plan hold together, and repro/README.md's index is the one the registry generates",
+        PROBLEMS,
+      ),
+      PROBLEMS,
+      deps,
+    ),
+    "study-plan-name": ruleOf(
+      metaOf(
+        "repro/study-plan-name",
+        "a study's plan is named plan.json, not prereg.json",
+        PLAN_NAME_PROBLEMS,
+      ),
+      PLAN_NAME_PROBLEMS,
+      deps,
+    ),
   };
 }
 
-/** The level it is on at in paperlint's own config, for every paper's `PIPELINE-STATUS.md`. */
-export const STUDY_REGISTRY_RULE_LEVELS: Readonly<
-  Record<"repro/study-registered", "error">
-> = { "repro/study-registered": "error" };
+/** The levels they are on at in paperlint's own config, for every paper's `PIPELINE-STATUS.md`. */
+export const STUDY_REGISTRY_RULE_LEVELS: Readonly<{
+  "repro/study-registered": "error";
+  "repro/study-plan-name": "warn";
+}> = { "repro/study-registered": "error", "repro/study-plan-name": "warn" };