paperlint 7.1.0 → 8.0.0

package/src/paper-settings.ts

@@ -4,7 +4,9 @@
  * One file name at two levels, one schema (lib/paper-config.mjs → SETTINGS_KEYS):
  *
  *   paperlint.json                 the project (optional): papersDir, rules, defaults
- *   <paper>/paperlint.json         this paper: { extends, kind, pdf, rules, identity, talk, submission }
+ *   <paper>/paperlint.json         this paper: { extends, kind, pdf, rules, identity, talk, submission } —
+ *                                  or `cycles`, from whose current attempt extends, kind and submission
+ *                                  are DERIVED (src/domain/cycle.ts); the two forms do not mix
  *   a venue preset                 `paperlint:<name>` (shipped) or `./x.jsonc` (src/presets.ts)
  *
  * The paper's `extends`, `kind` and `pdf` win over the root's; with no own value, the root's is
@@ -36,6 +38,13 @@ import {
   parsePaperSubmission,
   type PaperSubmission,
 } from "./domain/submission.ts";
+import {
+  cycleProblemText,
+  cyclesOf,
+  parseCycles,
+  venueCycleOf,
+  type Cycles,
+} from "./domain/cycle.ts";
 
 /** What one paper declares. Every absent field is null. */
 export interface PaperSettings {
@@ -60,6 +69,12 @@ export interface PaperSettings {
   readonly talk: PaperTalk | null;
   /** Which submission on the venue's portal is this paper's; null when it says none. Never the root's. */
   readonly submission: PaperSubmission | null;
+  /**
+   * The paper's attempts at venues and the current one, when the file declares `cycles`; null for a
+   * file in the flat form. With cycles, `extends`, `kind` and `submission` above are the current
+   * attempt's — derived, never written beside it. Never the root's.
+   */
+  readonly cycles: Cycles | null;
 }
 
 /** Why a paper's settings cannot be read. */
@@ -139,28 +154,85 @@ function rulesAndTalk(
     : submission;
 }
 
-/** The parsed JSON of `paperlint.json` → the settings, or one line saying what is wrong. Pure. */
-export function parsePaperSettings(
-  json: unknown,
-): Result<PaperSettings, string> {
-  if (!isObject(json)) return err("must be a JSON object");
+/** The keys the current cycle supplies: writing one beside `cycles` is a second source for it. */
+const DERIVED_FROM_CYCLE = ["extends", "kind", "submission"] as const;
+
+/**
+ * `cycles`, parsed with its current attempt, or null when the file is in the flat form. A file that
+ * has both `cycles` and a derived key is refused: two sources for one fact drift apart.
+ */
+function cyclesField(
+  json: Readonly<Record<string, unknown>>,
+): Result<Cycles | null, string> {
+  const list = parseCycles(json["cycles"]);
+  if (!list.ok) return list;
+  if (list.value === null) return ok(null);
+  const beside = DERIVED_FROM_CYCLE.filter((k) => k in json);
+  if (beside.length > 0)
+    return err(
+      `"${beside.join('", "')}" beside "cycles": with cycles, ${beside.length === 1 ? "it is" : "they are"} the current attempt's and cannot be set here — move the value into the open cycle`,
+    );
+  const cycles = cyclesOf(list.value);
+  return cycles.ok ? cycles : err(cycleProblemText(cycles.error));
+}
+
+/**
+ * The current attempt's venue, kind and submission, as the flat keys every reader takes. An accepted
+ * attempt keeps them: the camera-ready and the talk are judged against the venue that accepted.
+ */
+function derived(
+  cycles: Cycles,
+): Pick<PaperSettings, (typeof DERIVED_FROM_CYCLE)[number]> {
+  const c = venueCycleOf(cycles.current);
+  if (c === null) return { extends: null, kind: null, submission: null };
+  return {
+    extends: c.venue.kind === "preset" ? c.venue.extends : null,
+    kind: c.kind,
+    submission: c.submission,
+  };
+}
+
+/** The keys that may not be in a paper's file: unknown ones, and the project's. */
+function refusedKeys(
+  json: Readonly<Record<string, unknown>>,
+): Result<Readonly<Record<string, unknown>>, string> {
   const unknown = Object.keys(json).filter((k) => !KNOWN.includes(k));
   if (unknown.length > 0)
     return err(
       `unknown key "${String(unknown[0])}" — known keys: ${KNOWN.join(", ")}`,
     );
   const project = Object.keys(json).filter((k) => ROOT_ONLY_KEYS.includes(k));
-  if (project.length > 0)
-    return err(
-      `"${String(project[0])}" is a project setting — set it in the root ${CONFIG_FILE}, not in a paper's`,
-    );
+  return project.length > 0
+    ? err(
+        `"${String(project[0])}" is a project setting — set it in the root ${CONFIG_FILE}, not in a paper's`,
+      )
+    : ok(json);
+}
+
+/** The parsed JSON of `paperlint.json` → the settings, or one line saying what is wrong. Pure. */
+export function parsePaperSettings(
+  json: unknown,
+): Result<PaperSettings, string> {
+  if (!isObject(json)) return err("must be a JSON object");
+  const keys = refusedKeys(json);
+  if (!keys.ok) return keys;
   const fields = stringFields(json);
   if (!fields.ok) return fields;
   const identity = identityField(json);
   if (!identity.ok) return identity;
   const rest = rulesAndTalk(json);
   if (!rest.ok) return rest;
-  return ok({ ...fields.value, ...rest.value, identity: identity.value });
+  const cycles = cyclesField(json);
+  if (!cycles.ok) return cycles;
+  const flat = {
+    ...fields.value,
+    ...rest.value,
+    identity: identity.value,
+    cycles: cycles.value,
+  };
+  return ok(
+    cycles.value === null ? flat : { ...flat, ...derived(cycles.value) },
+  );
 }
 
 /** A JSON file through `files`: undefined when absent, the problem when it does not parse. */
@@ -251,6 +323,7 @@ function merge(
     rules: null,
     talk: null,
     submission: null,
+    cycles: null,
   };
   const merged: PaperSettings = {
     extends: p.extends ?? r.extends,
@@ -260,6 +333,7 @@ function merge(
     identity: joined(r.identity, p.identity),
     talk: p.talk,
     submission: p.submission,
+    cycles: p.cycles,
   };
   return paper === null && Object.values(merged).every((v) => v === null)
     ? null

package/src/parse-args.test.ts

@@ -22,7 +22,6 @@ describe("parseArgs — `--flag=value` is the same as `--flag value`", () => {
     ["--config=o.json", "config", "o.json"],
     ["--venue=agenticdev", "venue", "agenticdev"],
     ["--kind=short", "kind", "short"],
-    ["--format=md", "format", "md"],
     ["--paper=p", "paper", "p"],
   ] as const)("%s", (flag, key, value) => {
     const a = parseArgs(["new", "x", flag]);

package/src/ports/venue-deadlines.ts

@@ -0,0 +1,14 @@
+/**
+ * A venue's deadlines as its portal publishes them — the port the scheduled refresh of the shipped
+ * presets reads through (`scripts/refresh-deadlines.ts`). Shaped by what the refresh needs (the
+ * portal's deadlines, once), not by any portal's page; one adapter per portal kind
+ * (`src/adapters/hotcrp/`).
+ */
+import type { Result } from "../domain/result.ts";
+import type { PortalDeadlines } from "../domain/deadline.ts";
+import type { PortalFailure } from "../domain/submission.ts";
+
+export interface VenueDeadlines {
+  /** The deadlines the portal publishes now. Needs no account: the page is public. */
+  read(): Promise<Result<PortalDeadlines, PortalFailure>>;
+}

package/src/presets.test.ts

@@ -103,6 +103,23 @@ describe("shipped presets: paperlint:msr", () => {
       kind: "hotcrp",
       url: "https://msr2027.hotcrp.com",
     });
+    // The portal's deadlines, read 2026-10-05 off cassette/deadlines-msr2027.html's page.
+    expect(r.value.deadlines).toEqual([
+      {
+        what: "submission",
+        at: "2026-10-20T04:00:00Z",
+        source: "portal",
+        url: "https://msr2027.hotcrp.com/deadlines",
+        read: "2026-10-05",
+      },
+      {
+        what: "resubmission",
+        at: "2026-10-23T04:00:00Z",
+        source: "portal",
+        url: "https://msr2027.hotcrp.com/deadlines",
+        read: "2026-10-05",
+      },
+    ]);
     // No rule turned on: the IEEE capitalization rule has not been read and quoted.
     expect(r.value.rules).toEqual({});
     expect(r.value.registerAnchors).toEqual([]);
@@ -326,6 +343,94 @@ describe("a project's own preset: what its children replace", () => {
   });
 });
 
+describe("a project's own preset: its deadlines", () => {
+  const reading = (what: string, at: string, source = "portal") => ({
+    what,
+    at,
+    source,
+    url: "https://example.org/deadlines",
+    read: "2026-10-05",
+  });
+
+  it("a child's deadlines replace its parent's whole; none named keeps the parent's", () => {
+    const own = resolve("./mine.jsonc", {
+      "/work/papers/p/mine.jsonc": venue({
+        extends: "paperlint:msr",
+        deadlines: [reading("submission", "2026-10-21T04:00:00Z")],
+      }),
+    });
+    expect(own.ok && own.value.deadlines).toEqual([
+      reading("submission", "2026-10-21T04:00:00Z"),
+    ]);
+    const inherited = resolve("./mine.jsonc", {
+      "/work/papers/p/mine.jsonc": venue({ extends: "paperlint:msr" }),
+    });
+    expect(inherited.ok && inherited.value.deadlines.length).toBe(2);
+    const none = resolve("./mine.jsonc", {
+      "/work/papers/p/mine.jsonc": venue({ extends: "paperlint:aisec" }),
+    });
+    expect(none.ok && none.value.deadlines).toEqual([]);
+  });
+
+  it("the portal's and the call's reading of one kind may stand side by side", () => {
+    const r = resolve("./mine.jsonc", {
+      "/work/papers/p/mine.jsonc": venue({
+        extends: "paperlint:aisec",
+        deadlines: [
+          reading("submission", "2026-10-20T04:00:00Z"),
+          reading("submission", "2026-10-21T11:59:59Z", "call"),
+        ],
+      }),
+    });
+    expect(r.ok && r.value.deadlines.map((d) => d.source)).toEqual([
+      "portal",
+      "call",
+    ]);
+  });
+});
+
+describe("a project's own preset: deadlines it refuses", () => {
+  const reading = (what: string, at: string, source = "portal") => ({
+    what,
+    at,
+    source,
+    url: "https://example.org/deadlines",
+    read: "2026-10-05",
+  });
+
+  it.each([
+    [
+      "two readings of one kind from one source",
+      [
+        reading("submission", "2026-10-20T04:00:00Z"),
+        reading("submission", "2026-10-21T04:00:00Z"),
+      ],
+      /"deadlines" holds two "portal" readings of "submission" — keep one, the latest/,
+    ],
+    [
+      "an instant that is not UTC as a portal publishes it",
+      [reading("submission", "2026-10-20 AoE")],
+      /deadlines/,
+    ],
+    [
+      "a reading without the day it was read",
+      [{ ...reading("submission", "2026-10-20T04:00:00Z"), read: undefined }],
+      /deadlines/,
+    ],
+  ])("refuses %s, naming the file", (_what, deadlines, re) => {
+    const r = resolve("./mine.jsonc", {
+      "/work/papers/p/mine.jsonc": venue({
+        extends: "paperlint:aisec",
+        deadlines,
+      }),
+    });
+    expect(r.ok).toBe(false);
+    if (r.ok) return;
+    expect(presetProblemText(r.error)).toMatch(/mine\.jsonc/);
+    expect(presetProblemText(r.error)).toMatch(re);
+  });
+});
+
 describe("what does not resolve, and says why", () => {
   it.each([
     [

package/src/presets.ts

@@ -25,8 +25,8 @@
  *   tex        union — a child never removes a package its parent needs
  *   format     per key, the child wins; `kinds` by kind name, a child's kind replaces that kind
  *   rules      per rule id, the child wins; `ruleOrigins` keeps which file set each
- *   template   the child wins, with its `template_forbids`; so does `name`, and `required_sections`, `register`, `talk` and
- *              `portal` (each whole)
+ *   template   the child wins, with its `template_forbids`; so does `name`, and `required_sections`, `register`, `talk`,
+ *              `portal` and `deadlines` (each whole)
  *   aliases    union, with every `name` — what the venue is called along the chain
  *
  * ── THE ID AND THE LABEL ──────────────────────────────────────────────────────────
@@ -63,6 +63,7 @@ import { messageOf } from "./domain/text.ts";
 import type { RegisterAnchor } from "./domain/register.ts";
 import type { VenueTalk } from "./domain/talk.ts";
 import type { VenuePortal } from "./domain/submission.ts";
+import type { Reading } from "./domain/deadline.ts";
 
 /** The prefix of a shipped preset's spec. */
 export const SHIPPED_PREFIX = "paperlint:";
@@ -123,6 +124,11 @@ export interface Preset {
   readonly talk: VenueTalk | null;
   /** Where the venue takes submissions (`paperlint submission`); null when no file of the chain says. */
   readonly portal: VenuePortal | null;
+  /**
+   * The edition's deadlines as they were read (the portal's, refreshed by paperlint's scheduled
+   * workflow); empty when no file of the chain names any. A paper's current cycle derives them.
+   */
+  readonly deadlines: readonly Reading[];
 }
 
 /** Why a spec does not resolve. */
@@ -293,8 +299,24 @@ const NOTHING_MERGED: Merging = {
   registerAnchors: [],
   talk: null,
   portal: null,
+  deadlines: [],
 };
 
+/** The blocks a child replaces whole: the child's when it names one, else its parents'. Pure. */
+const wholeBlocks = (
+  acc: Merging,
+  p: PresetFile,
+): Pick<
+  Merging,
+  "requiredSections" | "registerAnchors" | "talk" | "portal" | "deadlines"
+> => ({
+  requiredSections: p.requiredSections ?? acc.requiredSections,
+  registerAnchors: p.registerAnchors ?? acc.registerAnchors,
+  talk: p.talk ?? acc.talk,
+  portal: p.portal ?? acc.portal,
+  deadlines: p.deadlines ?? acc.deadlines,
+});
+
 /** One file of the chain, `file`, merged over what its parents gave. Pure. */
 const mergeOne = (
   acc: Merging,
@@ -308,7 +330,6 @@ const mergeOne = (
   aliases: [...new Set([...acc.aliases, ...namesOf(p.identity), ...p.aliases])],
   blind: p.blind ?? acc.blind,
   mentions: p.mentions ?? acc.mentions,
-  requiredSections: p.requiredSections ?? acc.requiredSections,
   tex: p.tex ? mergeRequirements(acc.tex, p.tex) : acc.tex,
   format: mergeFormat(acc.format, p.format),
   rules: { ...acc.rules, ...p.rules },
@@ -316,9 +337,7 @@ const mergeOne = (
     ...acc.ruleOrigins,
     ...Object.fromEntries(Object.keys(p.rules).map((id) => [id, file])),
   },
-  registerAnchors: p.registerAnchors ?? acc.registerAnchors,
-  talk: p.talk ?? acc.talk,
-  portal: p.portal ?? acc.portal,
+  ...wholeBlocks(acc, p),
 });
 
 /** The chain, root first, merged into one preset. Pure. */
@@ -457,15 +476,29 @@ export function paperPreset(paperDir: string, deps: PresetDeps): PaperPreset {
     : { kind: "preset-problem", settings, problem: r.error };
 }
 
+/** A paper's settings or preset that cannot be used. */
+export type UnusablePreset = Extract<
+  PaperPreset,
+  { readonly kind: "settings-problem" | "preset-problem" }
+>;
+
+/** The one-line reason a paper's settings or preset cannot be used. */
+export const unusablePresetLine = (
+  paperDir: string,
+  p: UnusablePreset,
+): string =>
+  p.kind === "preset-problem"
+    ? `${join(paperDir, CONFIG_FILE)}: ${presetProblemText(p.problem)}`
+    : settingsProblemLine(paperDir, p.problem);
+
 /** The one-line reason a paper's settings or preset cannot be used, or null when they can. */
 export function paperPresetProblem(
   paperDir: string,
   p: PaperPreset,
 ): string | null {
-  if (p.kind === "preset-problem")
-    return `${join(paperDir, CONFIG_FILE)}: ${presetProblemText(p.problem)}`;
-  if (p.kind !== "settings-problem") return null;
-  return settingsProblemLine(paperDir, p.problem);
+  return p.kind === "preset-problem" || p.kind === "settings-problem"
+    ? unusablePresetLine(paperDir, p)
+    : null;
 }
 
 /** The one line naming a paper's `paperlint.json` that does not parse, and why. */

package/src/rule-cases.test.ts

@@ -316,6 +316,88 @@ const onPdf = (tree: Record<string, string>, line = 1) => ({
   line,
 });
 
+/** One open cycle on the ACM family: what a flat `{ "extends": "paperlint:acm-sigconf" }` says, as a record. */
+const OPEN_CYCLE = JSON.stringify({
+  cycles: [
+    {
+      id: "open-2027",
+      venue: { kind: "preset", extends: "paperlint:acm-sigconf" },
+      opened: "2026-09-09",
+    },
+  ],
+});
+/**
+ * One open cycle whose registration deadline is after its submission deadline: a date typed wrong.
+ * The record's STRUCTURAL problems — two open cycles, a bare date, an unknown key — never reach a
+ * rule: `paperRuleBlocks` refuses the settings file before lint runs (measured 2026-10-05: one line
+ * naming the file and both ids, exit 2), as it refuses any unreadable `paperlint.json`. The order of
+ * the deadlines is what the record parses with and the rule still judges.
+ */
+const DISORDERED = JSON.stringify({
+  cycles: [
+    {
+      id: "open-2027",
+      venue: { kind: "preset", extends: "paperlint:acm-sigconf" },
+      opened: "2026-09-09",
+      // The call's own abstract day after its paper day: a date typed wrong. (The portal's and the
+      // call's readings disagreeing is not a finding: the earlier binds.)
+      deadlines: [
+        {
+          what: "registration",
+          observed: [
+            {
+              at: "2026-10-25 AoE",
+              source: "call",
+              url: "https://conf.example/cfp",
+              read: "2026-09-09",
+            },
+          ],
+        },
+        {
+          what: "submission",
+          observed: [
+            {
+              at: "2026-10-20T04:00:00Z",
+              source: "portal",
+              url: "https://conf.example/deadlines",
+              read: "2026-09-09",
+            },
+            {
+              at: "2026-10-23 AoE",
+              source: "call",
+              url: "https://conf.example/cfp",
+              read: "2026-09-09",
+            },
+          ],
+        },
+      ],
+    },
+  ],
+});
+/** One closed cycle whose evidence is `reviews/decision.md`. */
+const CLOSED_CYCLE = JSON.stringify({
+  cycles: [
+    {
+      id: "first-2026",
+      venue: { kind: "preset", extends: "paperlint:acm-sigconf" },
+      opened: "2026-07-01",
+      outcome: {
+        kind: "rejected",
+        date: "2026-09-08",
+        evidence: "reviews/decision.md",
+      },
+    },
+  ],
+});
+/** A BlindConf cycle still declared porting — on a paper whose class line is already BlindConf's. */
+const BLIND_PORTING = {
+  id: "blindconf-2027",
+  venue: { kind: "preset", extends: "./blindconf.jsonc" },
+  opened: "2026-09-09",
+  phase: "porting",
+  // What `blind()` declares flat; with cycles it moves into the record's siblings, not the cycle.
+};
+
 const CASES: Readonly<Record<string, RuleCases>> = {
   "paper/stages": {
     reports: {
@@ -326,6 +408,68 @@ const CASES: Readonly<Record<string, RuleCases>> = {
     },
     silent: paper(tex("x")),
   },
+  // ── the cycle rules: the paper's attempts in paperlint.json, judged on PIPELINE-STATUS.md ──────
+  "cycle/record": {
+    reports: {
+      tree: { ...paper(tex("x")), [`${P}/paperlint.json`]: DISORDERED },
+      file: STATUS_FILE,
+      severity: 2,
+      line: 1,
+    },
+    silent: paper(tex("x")),
+  },
+  "cycle/evidence": {
+    reports: {
+      tree: { ...paper(tex("x")), [`${P}/paperlint.json`]: CLOSED_CYCLE },
+      file: STATUS_FILE,
+      severity: 2,
+      line: 1,
+    },
+    silent: {
+      ...paper(tex("x")),
+      [`${P}/paperlint.json`]: CLOSED_CYCLE,
+      [`${P}/reviews/decision.md`]: "# decision\n",
+    },
+  },
+  "cycle/stage": {
+    reports: {
+      tree: {
+        ...paper(tex("x")),
+        [STATUS_FILE]: SHIPPED_STATUS,
+        [`${P}/paperlint.json`]: OPEN_CYCLE,
+        [`${P}/versions/a.pdf`]: "x",
+      },
+      file: STATUS_FILE,
+      severity: 2,
+      line: 1,
+    },
+    silent: {
+      ...paper(tex("x")),
+      [STATUS_FILE]: SHIPPED_STATUS.replace(
+        "date: 2026-07-22",
+        "cycle: open-2027\n    date: 2026-07-22",
+      ),
+      [`${P}/paperlint.json`]: OPEN_CYCLE,
+      [`${P}/versions/a.pdf`]: "x",
+    },
+  },
+  "cycle/port-done": {
+    reports: {
+      tree: {
+        ...blind("Text."),
+        [`${P}/paperlint.json`]: JSON.stringify({ cycles: [BLIND_PORTING] }),
+      },
+      file: TEX_FILE,
+      severity: 2,
+      line: 1,
+    },
+    silent: {
+      ...blind("Text."),
+      [`${P}/paperlint.json`]: JSON.stringify({
+        cycles: [{ ...BLIND_PORTING, phase: "prepared" }],
+      }),
+    },
+  },
   "paper/source": {
     reports: {
       tree: { ...paper(tex("x")), [STATUS_FILE]: SHIPPED_STATUS },

package/src/structure.harness.ts

@@ -47,7 +47,6 @@ const paper = (name: string, files: readonly string[]) => {
 
 try {
   paper("complete", ["PIPELINE-STATUS.md", "paper.tex", "refs.bib"]);
-  paper("complete-md", ["PIPELINE-STATUS.md", "paper.md"]);
   // the marker is present (paper.tex), the scorecard is not — the directory is linted by ZERO
   // rules and reports clean
   paper("no-scorecard", ["paper.tex", "refs.bib"]);
@@ -65,10 +64,6 @@ try {
     "a complete paper directory — NOT A SINGLE finding",
     at("complete").length === 0,
   );
-  check(
-    "and `paper.md` counts on equal footing with `paper.tex` — the corpus holds both forms",
-    at("complete-md").length === 0,
-  );
   check(
     "a missing scorecard — a finding",
     at("no-scorecard").length === 1 &&
@@ -86,10 +81,11 @@ try {
     /no-scorecard/.test(at("no-scorecard")[0]?.message ?? ""),
   );
   check(
-    "a directory with no source — a finding, and BOTH accepted forms are listed",
+    "a directory with no source — a finding naming `paper.tex`",
     at("no-source").length === 1 &&
-      /`paper\.tex`/.test(at("no-source")[0]?.message ?? "") &&
-      /`paper\.md`/.test(at("no-source")[0]?.message ?? ""),
+      /`paper\.tex` — a paper directory with no source/.test(
+        at("no-source")[0]?.message ?? "",
+      ),
   );
 
   // 🔴 THE PAIRED HALF: detection is GENEROUS. Without this the check would scream about every
@@ -124,9 +120,7 @@ try {
       {
         cwd: root,
       },
-    ).some(
-      (x) => x.file.endsWith("complete-md") && /refs\.bib/.test(x.message),
-    ),
+    ).some((x) => x.file.endsWith("no-source") && /refs\.bib/.test(x.message)),
   );
   check(
     "a nonexistent root does not crash it — that's the empty-set guard talking",

package/src/structure.ts

@@ -26,6 +26,7 @@ import { readdirSync, existsSync } from "node:fs";
 import { join, relative, basename, isAbsolute, sep } from "node:path";
 import type { StructureConfig, StructureFinding } from "./types.ts";
 import { CONFIG_FILE } from "#lib/paper-config";
+import { SOURCE_FILE } from "./new-paper.ts";
 
 /** The requirements after the consumer's config is laid over the defaults. */
 type Rules = Required<StructureConfig>;
@@ -38,9 +39,9 @@ type Rules = Required<StructureConfig>;
  * byte-compared by the `paper/stages` rule anyway.
  */
 export const STRUCTURE_DEFAULTS = {
-  markers: ["PIPELINE-STATUS.md", "paper.tex", "paper.md", CONFIG_FILE],
+  markers: ["PIPELINE-STATUS.md", SOURCE_FILE, CONFIG_FILE],
   require: ["PIPELINE-STATUS.md"],
-  requireOneOf: [["paper.tex", "paper.md"]],
+  requireOneOf: [[SOURCE_FILE]],
   ignore: [],
 };
 
@@ -118,7 +119,7 @@ export function checkStructure(
  * The message NAMES THE CONSEQUENCE rather than restating the condition. "missing
  * PIPELINE-STATUS.md" without the second half reads as nitpicking about formatting; with it you
  * can see which checks the directory silently loses — the rules that read the scorecard; the rules
- * over `paper.md` / `paper.tex` still run.
+ * over `paper.tex` still run.
  */
 function whyMissingMatters(file: string, dirName: string): string {
   if (file === "PIPELINE-STATUS.md")