paperlint 7.1.0 → 8.0.0

package/src/cli.ts

@@ -74,6 +74,8 @@ import {
 import {
   FORMAT_RULE_LEVELS,
   formatRules,
+  CYCLE_PORT_RULE_LEVELS,
+  cyclePortRules,
   TEX_VENUE_RULE_LEVELS,
   texVenueRules,
 } from "./tex-venue-rules.ts";
@@ -130,15 +132,7 @@ import {
   init,
   processInteractivity,
 } from "./init.ts";
-import {
-  DEFAULT_FORMAT,
-  FORMATS,
-  isFormat,
-  newPaper,
-  reportNewPaper,
-  type PaperFormat,
-  type VenueSetting,
-} from "./new-paper.ts";
+import { newPaper, reportNewPaper, type VenueSetting } from "./new-paper.ts";
 // The one source for the consumer's config key lives in lib/ (the ESLint rules and the skill scripts
 // import it too). It is imported compiled, from dist/, the one path that resolves the same from src/
 // and from dist/ — see CONTRIBUTING.md.
@@ -164,6 +158,8 @@ export { init };
 export { nextSteps } from "./init.ts";
 
 import paperStages from "#eslint-rules/paper-stages";
+import cycleStage from "#eslint-rules/cycle-stage";
+import { CYCLE_RULE_LEVELS, cycleRules } from "./cycle-rules.ts";
 import {
   FOLDER_VENUE_RULE_LEVELS,
   folderVenueRules,
@@ -185,7 +181,7 @@ const USAGE = `paperlint — machine-checkable gates for a paper kept in git
   npx paperlint init [dir]            set the project up: detect the papers directory, declare it
                                       in package.json, link the skills, wire the hooks into
                                       .claude/settings.json, offer the CI step, report what is missing
-  npx paperlint new <name> [--venue <preset>] [--kind <kind>] [--format tex|md]
+  npx paperlint new <name> [--venue <preset>] [--kind <kind>]
                                       create <papers>/<name>/ from the template; never overwrites,
                                       on an existing folder adds only the missing files, then lints it.
                                       A <name> that names a venue (aisec-2026) is refused: name the
@@ -221,7 +217,6 @@ init:
                       or with CI set, nothing is asked either
   --no-hooks          do not wire the hooks (the default without a human is to wire them)
   --paper <name>      create this paper too (without a human, the only way init creates one)
-  --format tex|md     the new paper's source format; default tex
 
 new:
   --venue <preset>    the venue preset, written as "extends" into the paper's paperlint.json:
@@ -230,7 +225,6 @@ new:
                       On a terminal without --venue, new asks; "none" leaves it unset
   --kind <kind>       the paper's kind at that venue (its page limit), e.g. short — one of the
                       preset's kinds; needs --venue
-  --format tex|md     the paper's source format; default tex
   --allow-venue-name  create the folder even though its name names a venue (a whole word such as
                       "realm" can be the work's own). Without it such a name is refused: a rejected
                       paper moves to another venue and keeps its folder
@@ -280,6 +274,24 @@ settings — paperlint.json, at two levels, one schema. Both are optional.
   "extends" names a venue preset: paperlint:<name> (shipped: ${SHIPPED_VENUES().join(", ")})
   or ./path.jsonc, relative to the paperlint.json. npm presets are not supported yet.
 
+  cycles and deadlines — a paper's attempts at venues, oldest first, instead of "extends",
+  "kind" and "submission" (those are then the current attempt's, and refused beside "cycles"):
+
+    { "cycles": [ { "id": "msr-2027", "venue": { "kind": "preset", "extends": "paperlint:msr" },
+                    "kind": "technical", "opened": "2026-10-05",
+                    "deadlines": [ { "what": "submission",
+                                     "observed": [ { "at": "2026-10-23 AoE", "source": "call",
+                                                     "url": "<the call>", "read": "2026-10-05" } ] } ] } ] }
+
+  A venue preset carries the portal's deadlines, read and dated; the package updates them and
+  your dependency update brings them. A paper adds what the call says ("source": "call") and,
+  for a deadline moved by the chairs, "override": { "at", "reason", "evidence" } — evidence a
+  file in the paper folder. The override wins; otherwise the earlier reading binds. "what":
+  registration (the call's abstract), submission (the full paper), resubmission, notification,
+  camera-ready. A venue without a preset: "venue": { "kind": "named", "name", "url" }, every
+  deadline typed from its call. Lint never reads the clock: it checks the record, not the time
+  left. docs/configuration.md#the-papers-cycles
+
   "rules" is { "<rule>": "<severity>" } for every paper file in scope, or ESLint flat-config
   blocks (files, ignores, rules) with globs relative to that file. Order, later wins: paperlint's
   own, the venue preset's, the root file's, the paper's. Optional rules (off unless turned on):
@@ -303,6 +315,22 @@ const REGISTER_AND_CASE_RULES = {
   "heading-case": headingCaseRule(TEX_RULE_DEPS),
 };
 
+/**
+ * The paper's attempts (`cycles` in paperlint.json), judged on `PIPELINE-STATUS.md`: the record itself
+ * and its evidence (src/cycle-rules.ts), and the stages that name a cycle (eslint-rules/cycle-stage.ts).
+ * The `cycle` plugin's other rule, `port-done`, reads `paper.tex` (src/tex-venue-rules.ts).
+ */
+/** The markdown language with YAML frontmatter: what every markdown block of the config lints as. */
+const MARKDOWN_WITH_FRONTMATTER = {
+  language: "markdown/gfm",
+  languageOptions: { frontmatter: "yaml" },
+};
+
+const CYCLE_STATUS_RULES = {
+  ...cycleRules({ files: nodeFiles, venuesDir: presetsDir() }),
+  ...cycleStage.rules,
+};
+
 /** The rules of the files `paper.tex` includes, each read on its own as a fragment (#144). */
 const FRAGMENT_RULES = {
   "future-promise": texBuild["future-promise"],
@@ -333,10 +361,7 @@ export function buildConfig(
     "paper/section-word": "warn",
     "paper/leading-zero": "warn",
   };
-  const md = {
-    language: "markdown/gfm",
-    languageOptions: { frontmatter: "yaml" },
-  };
+  const md = MARKDOWN_WITH_FRONTMATTER;
 
   const cfg: ConfigBlock[] = [
     // 🔴 THE PROJECT'S PAPER TEMPLATE IS NOT A PAPER. `paperlint new` reads `<papers>/.template/`, and
@@ -364,8 +389,8 @@ export function buildConfig(
     },
     {
       files: ["**/PIPELINE-STATUS.md"],
-      // Every paper folder has one, whatever its source format: the rules about the folder itself
-      // (its stages, its frozen sources, its name) are judged here, once per paper.
+      // Every paper folder has one: the rules about the folder itself (its stages, its frozen
+      // sources, its name) are judged here, once per paper.
       plugins: {
         markdown,
         paper: {
@@ -374,20 +399,16 @@ export function buildConfig(
             ...folderVenueRules({ files: nodeFiles, venuesDir: presetsDir() }),
           },
         },
+        cycle: { rules: CYCLE_STATUS_RULES },
       },
       ...md,
       rules: {
         "paper/stages": "error",
         "paper/source": "error",
         ...FOLDER_VENUE_RULE_LEVELS,
+        ...CYCLE_RULE_LEVELS,
       },
     },
-    {
-      files: ["**/paper.md", "**/draft.md"],
-      plugins: { markdown, paper: { rules: paperRules } },
-      ...md,
-      rules: prose,
-    },
     {
       files: ["**/reviews/*.md"],
       plugins: { markdown, review: reviewFrontmatter },
@@ -432,6 +453,7 @@ export function buildConfig(
             ...pageLimitRules({ files: nodeFiles, venuesDir: presetsDir() }),
           },
         },
+        cycle: { rules: cyclePortRules(TEX_RULE_DEPS) },
       },
       language: "tex/latex",
       rules: {
@@ -454,6 +476,7 @@ export function buildConfig(
         ...TEX_VENUE_RULE_LEVELS,
         ...FORMAT_RULE_LEVELS,
         ...PAGE_LIMIT_RULE_LEVELS,
+        ...CYCLE_PORT_RULE_LEVELS,
         // Silent for a paper that declares no `talk` (src/talk-rules.ts), but talk/undeclared.
         ...TALK_RULE_LEVELS,
       },
@@ -546,8 +569,7 @@ export interface RulePlugin {
  * file knows every rule id. `@eslint/markdown` is a dependency's plugin and is left out. The LaTeX
  * language rides on `tex` when `texLanguage` is given, and that is how a consumer registers it: a
  * second `tex` plugin of its own is refused by ESLint ("Cannot redefine plugin "tex"", measured
- * with and without the language here). Without it, `tex` carries rules only — for a config that
- * lints markdown papers alone.
+ * with and without the language here). Without it, `tex` carries rules only.
  */
 export function rulePlugins(texLanguage?: unknown): Record<string, RulePlugin> {
   const out: Record<string, { rules: Record<string, unknown> }> = {};
@@ -849,7 +871,6 @@ export function parseArgs(argv: readonly string[]): Args {
     noHooks: false,
     allowVenueName: false,
     paper: null,
-    format: null,
     venue: null,
     kind: null,
     pdf: null,
@@ -948,10 +969,9 @@ const SWITCHES: ReadonlyMap<
 /** The flags whose value is one string field of `Args`. */
 const STRING_FLAGS: ReadonlyMap<
   string,
-  "paper" | "format" | "venue" | "kind" | "pdf" | "abstract"
+  "paper" | "venue" | "kind" | "pdf" | "abstract"
 > = new Map([
   ["--paper", "paper"],
-  ["--format", "format"],
   ["--venue", "venue"],
   ["--kind", "kind"],
   ["--pdf", "pdf"],
@@ -1145,7 +1165,6 @@ export function runHook(
 export async function createPaperAt(
   papersRoot: string,
   name: string,
-  format: PaperFormat,
   {
     log,
     err,
@@ -1162,7 +1181,7 @@ export async function createPaperAt(
     allowVenueName?: boolean;
   },
 ): Promise<number> {
-  const result = newPaper(papersRoot, name, format, {
+  const result = newPaper(papersRoot, name, {
     venue,
     venues: allowVenueName ? [] : shippedVenueNames(PRESET_DEPS),
   });
@@ -1327,25 +1346,10 @@ async function runNew(
   const [name, ...extra] = a.paths;
   if (!name || extra.length > 0) {
     err(
-      `\`new\` takes exactly one paper name: \`paperlint new my-paper [--venue <preset>] [--kind <kind>] [--format tex|md]\``,
+      `\`new\` takes exactly one paper name: \`paperlint new my-paper [--venue <preset>] [--kind <kind>]\``,
     );
     return 2;
   }
-  let format: PaperFormat = DEFAULT_FORMAT;
-  if (a.format !== null) {
-    if (!isFormat(a.format)) {
-      err(
-        `--format must be one of ${FORMATS.join(", ")} — got \`${a.format}\``,
-      );
-      return 2;
-    }
-    format = a.format;
-  } else if (processInteractivity(a.yes).interactive) {
-    const f = (
-      await askOrDefault(ask, `format: tex / md [${DEFAULT_FORMAT}] `)
-    )?.trim();
-    if (isFormat(f)) format = f;
-  }
   const cfg = readConfig({ ...a, json: false }, { log: () => {}, err, cwd });
   if (cfg.code !== undefined) return cfg.code;
   const roots = papersRoots(cfg);
@@ -1378,7 +1382,7 @@ async function runNew(
         ask,
       });
   if (!venue.ok) return (err(venue.error), 2);
-  return createPaperAt(papersRoot, name, format, {
+  return createPaperAt(papersRoot, name, {
     log,
     err,
     cwd,
@@ -1629,10 +1633,6 @@ async function runInit(
     );
     return 2;
   }
-  if (a.format !== null && !isFormat(a.format)) {
-    err(`--format must be one of ${FORMATS.join(", ")} — got \`${a.format}\``);
-    return 2;
-  }
   return await init(a.paths[0] ?? ".", {
     log,
     err,
@@ -1640,9 +1640,8 @@ async function runInit(
     yes: a.yes,
     hooks: !a.noHooks,
     paper: a.paper,
-    format: isFormat(a.format) ? a.format : null,
-    createPaper: (papersRoot, name, format) =>
-      createPaperAt(papersRoot, name, format, { log, err, cwd }),
+    createPaper: (papersRoot, name) =>
+      createPaperAt(papersRoot, name, { log, err, cwd }),
     venues: shippedVenueNames(PRESET_DEPS),
     tex: initTexLive(a, { log, err, cwd }),
     resolveCliPapers: (root: string): string | null =>
@@ -1764,8 +1763,8 @@ export async function run(
   };
 
   // Loaded lazily because only `lint` needs it. If the module cannot be loaded (a broken install:
-  // the file missing from the package), lint still runs over the markdown papers rather than
-  // failing outright — the LaTeX rules simply have no language to run in.
+  // the file missing from the package), lint still runs over the scorecards and the review notes
+  // rather than failing outright — the LaTeX rules simply have no language to run in.
   let texLanguage: unknown = null;
   try {
     ({ texLanguage } = await import("#eslint-rules/latex-language"));
@@ -1831,7 +1830,7 @@ export async function run(
   // is not invoked — and, not being invoked, it physically cannot report that.
   if (results.length === 0) {
     err(
-      `nothing was linted under ${paths.map((x) => shown(cwd, x)).join(", ")} — no PIPELINE-STATUS.md, paper.md/tex or reviews/ found there. A clean report over zero files is not a clean report.`,
+      `nothing was linted under ${paths.map((x) => shown(cwd, x)).join(", ")} — no PIPELINE-STATUS.md, paper.tex or reviews/ found there. A clean report over zero files is not a clean report.`,
     );
     return 1;
   }

package/src/cycle-rules.test.ts

@@ -0,0 +1,278 @@
+/**
+ * `cycle/record` and `cycle/evidence` on a paper folder's settings file: both halves of each — the
+ * finding on a planted defect, silence on a consistent record and on the flat form.
+ */
+import { readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { memoryFiles } from "./adapters/memory/index.ts";
+import { presetsDir } from "./package-dirs.ts";
+import { cycleRules } from "./cycle-rules.ts";
+
+const VENUES = presetsDir();
+const DIR = "/work/papers/p";
+/** The shipped presets, so a cycle naming `paperlint:msr` resolves through the memory files. */
+const SHIPPED = Object.fromEntries(
+  readdirSync(VENUES)
+    .filter((f) => f.endsWith(".jsonc"))
+    .map((f) => [join(VENUES, f), readFileSync(join(VENUES, f), "utf8")]),
+);
+
+interface Reported {
+  readonly rule: string;
+  readonly messageId: string;
+  readonly message: string;
+}
+
+const closed = {
+  id: "alpha-2026",
+  venue: { kind: "preset", extends: "paperlint:acm-sigconf" },
+  kind: "short",
+  opened: "2026-07-01",
+  outcome: {
+    kind: "rejected",
+    date: "2026-09-08",
+    desk: true,
+    evidence: "reviews/alpha-decision.md",
+  },
+};
+const open = {
+  id: "beta-2027",
+  venue: { kind: "preset", extends: "paperlint:ieee-conference" },
+  kind: "technical",
+  opened: "2026-09-09",
+  deadlines: [
+    {
+      what: "submission",
+      observed: [
+        {
+          at: "2026-10-20T04:00:00Z",
+          source: "portal",
+          url: "https://beta2027.example.org/deadlines",
+          read: "2026-09-09",
+        },
+      ],
+    },
+  ],
+};
+const CALL = {
+  source: "call",
+  url: "https://2027.msrconf.org/track/msr-2027-technical-papers",
+  read: "2026-10-05",
+};
+/** A cycle at the shipped `paperlint:msr`, whose preset carries the portal's readings. */
+const msr = (deadlines: readonly object[]) => ({
+  id: "msr-2027",
+  venue: { kind: "preset", extends: "paperlint:msr" },
+  kind: "technical",
+  opened: "2026-10-05",
+  deadlines,
+});
+const OVERRIDE = {
+  at: "2026-10-27T04:00:00Z",
+  reason: "the chairs extended the deadline by mail",
+  evidence: "mail/extension.eml",
+};
+
+/** Every cycle rule over the paper folder holding `settings` (a string: the raw file) and `extra` files. */
+function lint(
+  settings: object | string | undefined,
+  extra: Readonly<Record<string, string>> = {},
+  file = "PIPELINE-STATUS.md",
+): Reported[] {
+  const files = memoryFiles({
+    ...(settings === undefined
+      ? {}
+      : {
+          [`${DIR}/paperlint.json`]:
+            typeof settings === "string" ? settings : JSON.stringify(settings),
+        }),
+    ...SHIPPED,
+    ...extra,
+  });
+  const out: Reported[] = [];
+  Object.entries(cycleRules({ files, venuesDir: VENUES })).forEach(
+    ([name, rule]) => {
+      rule
+        .create({
+          filename: `${DIR}/${file}`,
+          sourceCode: { getLocFromIndex: () => ({ line: 1, column: 0 }) },
+          report: (d) => {
+            const template = rule.meta.messages[d.messageId] ?? "";
+            out.push({
+              rule: `cycle/${name}`,
+              messageId: d.messageId,
+              message: Object.entries(d.data).reduce(
+                (m, [k, v]) => m.split(`{{${k}}}`).join(String(v)),
+                template,
+              ),
+            });
+          },
+        })
+        .root?.();
+    },
+  );
+  return out;
+}
+
+const EVIDENCE = { [`${DIR}/reviews/alpha-decision.md`]: "# decision\n" };
+
+describe("cycle/record", () => {
+  it("reports on PIPELINE-STATUS.md only — any other file in the folder gets nothing", () => {
+    expect(lint({ cycles: [open, open] }, {}, "paper.tex")).toEqual([]);
+  });
+
+  it("a consistent record with its evidence on disk: every cycle rule is silent", () => {
+    expect(lint({ cycles: [closed, open] }, EVIDENCE)).toEqual([]);
+  });
+
+  it("the flat form, no settings file, or a file that is not JSON: silent — not this rule's to say", () => {
+    expect(lint({ extends: "paperlint:aidc", kind: "regular" })).toEqual([]);
+    expect(lint(undefined)).toEqual([]);
+    expect(lint("{ not json")).toEqual([]);
+  });
+
+  it("two open cycles: `broken`, naming both and the cure", () => {
+    const [f] = lint({
+      cycles: [{ ...closed, outcome: { kind: "open" } }, open],
+    });
+    expect(f?.messageId).toBe("broken");
+    expect(f?.message).toMatch(
+      /^paperlint\.json: cycles «alpha-2026» and «beta-2027» are both open/,
+    );
+  });
+
+  it("a deadline without its zone: `broken`, naming the entry and the key", () => {
+    const bad = msr([
+      { what: "submission", observed: [{ ...CALL, at: "2026-10-23" }] },
+    ]);
+    const m: unknown = expect.stringMatching(
+      /^paperlint\.json: cycles\[0\]\.deadlines\[0\]\.observed\[0\]: "at" must be an instant with its zone/,
+    );
+    expect(lint({ cycles: [bad] }).map((f) => f.message)).toEqual([m]);
+  });
+});
+
+describe("cycle/record — the deadlines, over the venue preset's readings", () => {
+  it("MSR 2027 as a newcomer records the call: abstract → registration, paper → submission; the preset's portal readings are derived — silent", () => {
+    // The portal's submission (2026-10-20T04:00Z, from the preset) is earlier than the call's
+    // registration (the end of 2026-10-20 AoE): two sources disagreeing, not a typo.
+    const fs = lint({
+      cycles: [
+        msr([
+          {
+            what: "registration",
+            observed: [{ ...CALL, at: "2026-10-20 AoE" }],
+          },
+          { what: "submission", observed: [{ ...CALL, at: "2026-10-23 AoE" }] },
+        ]),
+      ],
+    });
+    expect(fs).toEqual([]);
+  });
+
+  it("the call's own dates out of order: `order`, naming the cycle and the source", () => {
+    const fs = lint({
+      cycles: [
+        msr([
+          {
+            what: "registration",
+            observed: [{ ...CALL, at: "2026-10-25 AoE" }],
+          },
+          { what: "submission", observed: [{ ...CALL, at: "2026-10-23 AoE" }] },
+        ]),
+      ],
+    });
+    expect(fs.map((f) => f.messageId)).toEqual(["order"]);
+    expect(fs[0]?.message).toBe(
+      'paperlint.json, cycle «msr-2027»: the call\'s "registration" (2026-10-26T11:59:59Z) is after its "submission" (2026-10-24T11:59:59Z) — a date typed wrong, or an AoE day miscounted (write a call\'s date as "YYYY-MM-DD AoE" and paperlint converts it)',
+    );
+  });
+});
+
+describe("cycle/record — a portal reading beside the preset's", () => {
+  it("a portal reading of a deadline the venue's preset already carries: `presetCopy`, naming the preset's reading", () => {
+    const fs = lint({
+      cycles: [
+        msr([
+          {
+            what: "submission",
+            observed: [
+              {
+                at: "2026-10-20T04:00:00Z",
+                source: "portal",
+                url: "https://msr2027.hotcrp.com/deadlines",
+                read: "2026-10-01",
+              },
+            ],
+          },
+        ]),
+      ],
+    });
+    expect(fs.map((f) => f.message)).toEqual([
+      "paperlint.json, cycle «msr-2027»: the \"submission\" deadline records a portal reading, and the preset paperlint:msr carries the portal's reading of it (2026-10-20T04:00:00Z, read 2026-10-05) — a second copy drifts when paperlint updates the preset: delete this one (the call's reading and an override stay)",
+    ]);
+  });
+
+  it("a portal reading of a venue whose preset carries none, or a named venue: the paper's to record — silent", () => {
+    expect(lint({ cycles: [open] })).toEqual([]);
+    expect(
+      lint({
+        cycles: [
+          {
+            ...open,
+            venue: {
+              kind: "named",
+              name: "Beta '27",
+              url: "https://beta.example.org",
+            },
+          },
+        ],
+      }),
+    ).toEqual([]);
+  });
+
+  it("a cycle whose preset does not resolve: its readings are judged alone (pdf/profile names the preset)", () => {
+    expect(
+      lint({
+        cycles: [
+          { ...open, venue: { kind: "preset", extends: "paperlint:nosuch" } },
+        ],
+      }),
+    ).toEqual([]);
+  });
+});
+
+describe("cycle/evidence", () => {
+  it("a closed cycle whose evidence file is not in the folder: `missing`, with the path", () => {
+    const fs = lint({ cycles: [closed, open] });
+    expect(fs.map((f) => f.rule)).toEqual(["cycle/evidence"]);
+    expect(fs[0]?.message).toMatch(
+      /^cycle «alpha-2026» is rejected \(2026-09-08\) with evidence `reviews\/alpha-decision\.md`, which is not in the paper folder/,
+    );
+  });
+
+  it("an override whose evidence is not in the folder: `overrideMissing`; on disk: silent", () => {
+    const settings = {
+      cycles: [msr([{ what: "submission", override: OVERRIDE }])],
+    };
+    expect(lint(settings).map((f) => [f.rule, f.message])).toEqual([
+      [
+        "cycle/evidence",
+        'cycle «msr-2027»: the override of the "submission" deadline (2026-10-27T04:00:00Z) rests on `mail/extension.eml`, which is not in the paper folder — save the mail or the page that grants it there, or correct the path',
+      ],
+    ]);
+    expect(
+      lint(settings, { [`${DIR}/mail/extension.eml`]: "From: chairs\n" }),
+    ).toEqual([]);
+  });
+
+  it("an open cycle owes no evidence; a broken record is `cycle/record`'s alone", () => {
+    expect(lint({ cycles: [open] })).toEqual([]);
+    expect(
+      lint({ cycles: [{ ...closed, outcome: { kind: "open" } }, open] }).map(
+        (f) => f.rule,
+      ),
+    ).toEqual(["cycle/record"]);
+  });
+});