paperlint 7.1.0 → 8.0.0

package/src/new-paper.harness.mjs

@@ -36,7 +36,6 @@ const ROOT = dirname(HERE);
 const {
   newPaper,
   nameProblem,
-  wantedFiles,
   PACKAGE_TEMPLATES,
   OVERRIDE_DIR,
   STATUS_FILE,
@@ -63,7 +62,7 @@ async function lint(dir) {
 
 try {
   // ── the templates are FILES in the package, one per required file ──────────────────────
-  for (const f of [STATUS_FILE, SOURCE_FILE.tex, SOURCE_FILE.md])
+  for (const f of [STATUS_FILE, SOURCE_FILE])
     check(
       `the package ships templates/paper/${f}`,
       existsSync(join(PACKAGE_TEMPLATES, f)),
@@ -85,13 +84,13 @@ try {
     );
   check(
     "a refused name creates nothing",
-    newPaper(work, "Bad", "tex", { venues: [] }).ok === false &&
+    newPaper(work, "Bad", { venues: [] }).ok === false &&
       !existsSync(join(work, "Bad")),
   );
 
   // ── a fresh LaTeX paper ─────────────────────────────────────────────────────────────
   const papers = join(work, "papers");
-  const r = newPaper(papers, "demo", "tex", { venues: [] });
+  const r = newPaper(papers, "demo", { venues: [] });
   check(
     "a fresh folder gets the scorecard, a .tex source and paperlint.json, all from the package",
     r.ok &&
@@ -129,36 +128,18 @@ try {
 
   // ── never overwrite; on an existing folder only the missing files ─────────────────────
   writeFileSync(join(papers, "demo", STATUS_FILE), "mine\n");
-  const again = newPaper(papers, "demo", "md", { venues: [] });
+  const again = newPaper(papers, "demo", { venues: [] });
   check(
-    "🔴 a second run overwrites nothing and adds no second source",
+    "🔴 a second run overwrites nothing",
     again.ok &&
       !again.fresh &&
       read(papers, "demo", STATUS_FILE) === "mine\n" &&
-      !existsSync(join(papers, "demo", "paper.md")) &&
       again.files.every((f) => f.status === "kept"),
   );
-  mkdirSync(join(papers, "old"), { recursive: true });
-  writeFileSync(join(papers, "old", "paper.md"), "# Old\n");
-  const migrated = newPaper(papers, "old", "tex", { venues: [] });
-  check(
-    "an old folder with only paper.md gets ONLY the scorecard — that is the migration",
-    migrated.ok &&
-      existsSync(join(papers, "old", STATUS_FILE)) &&
-      !existsSync(join(papers, "old", "paper.tex")) &&
-      read(papers, "old", "paper.md") === "# Old\n",
-  );
-  check(
-    "wantedFiles asks for a source only when neither format is there",
-    wantedFiles(join(papers, "old"), "tex").join() ===
-      `${STATUS_FILE},paperlint.json` &&
-      wantedFiles(join(papers, "nowhere"), "md").join() ===
-        `${STATUS_FILE},paper.md,paperlint.json`,
-  );
   writeFileSync(join(papers, "afile"), "x");
   check(
     "a name taken by a FILE is refused, not written through",
-    newPaper(papers, "afile", "tex", { venues: [] }).ok === false,
+    newPaper(papers, "afile", { venues: [] }).ok === false,
   );
 
   // ── the project's template wins, file by file ─────────────────────────────────────────
@@ -167,7 +148,7 @@ try {
     join(papers, OVERRIDE_DIR, STATUS_FILE),
     "---\n---\n# House scorecard for {{name}}\n",
   );
-  const own = newPaper(papers, "house", "md", { venues: [] });
+  const own = newPaper(papers, "house", { venues: [] });
   // Guards: the override slot — `fromTemplate` in new-paper.ts reads `<papers>/.template/<file>`
   // before the package's copy. Replace that lookup with the package's alone and this goes red.
   check(
@@ -176,11 +157,11 @@ try {
       read(papers, "house", STATUS_FILE) ===
         "---\n---\n# House scorecard for house\n" &&
       own.files.find((f) => f.file === STATUS_FILE)?.from === "project" &&
-      own.files.find((f) => f.file === "paper.md")?.from === "package",
+      own.files.find((f) => f.file === SOURCE_FILE)?.from === "package",
   );
 
   // ── a missing template is a broken install, not an empty file ─────────────────────────
-  const broken = newPaper(join(work, "b"), "x", "tex", {
+  const broken = newPaper(join(work, "b"), "x", {
     venues: [],
     packageTemplates: join(work, "no-such-dir"),
   });

package/src/new-paper.test.ts

@@ -41,7 +41,7 @@ const settingsOf = (dir: string) =>
 describe("paperlint new — paperlint.json", () => {
   it("is always written, from the package template: no venue chosen yet, and valid", () => {
     const papers = join(tmp(), "papers");
-    const r = newPaper(papers, "demo", "tex", { venues: [] });
+    const r = newPaper(papers, "demo", { venues: [] });
     expect(r.ok && r.files.find((f) => f.file === "paperlint.json")).toEqual({
       file: "paperlint.json",
       status: "created",
@@ -60,6 +60,7 @@ describe("paperlint new — paperlint.json", () => {
         identity: null,
         talk: null,
         submission: null,
+        cycles: null,
       },
     });
   });
@@ -71,7 +72,7 @@ describe("paperlint new — paperlint.json", () => {
       join(papers, OVERRIDE_DIR, "paperlint.json"),
       '{ "extends": "paperlint:aisec", "kind": "research" }\n',
     );
-    const r = newPaper(papers, "house", "tex", { venues: [] });
+    const r = newPaper(papers, "house", { venues: [] });
     expect(r.ok && r.files.find((f) => f.file === "paperlint.json")?.from).toBe(
       "project",
     );
@@ -88,7 +89,7 @@ describe("paperlint new — paperlint.json", () => {
       join(papers, "p", "paperlint.json"),
       '{"extends":"paperlint:aisec"}',
     );
-    const r = newPaper(papers, "p", "tex", { venues: [] });
+    const r = newPaper(papers, "p", { venues: [] });
     expect(
       r.ok && r.files.find((f) => f.file === "paperlint.json")?.status,
     ).toBe("kept");
@@ -105,7 +106,7 @@ describe("paperlint lint — a paper with no venue preset chosen", () => {
       join(root, "package.json"),
       JSON.stringify({ name: "c", private: true }),
     );
-    newPaper(join(root, "papers"), "demo", "tex", { venues: [] });
+    newPaper(join(root, "papers"), "demo", { venues: [] });
     if (extendsValue !== null)
       writeFileSync(
         join(root, "papers", "demo", "paperlint.json"),
@@ -487,7 +488,7 @@ describe("a project's own template", () => {
     mkdirSync(join(papers, OVERRIDE_DIR), { recursive: true });
     const src = join(papers, OVERRIDE_DIR, "paperlint.json");
     writeFileSync(src, '{\n  // our house venue\n  "extends": null\n}\n');
-    const r = newPaper(papers, "p", "tex", {
+    const r = newPaper(papers, "p", {
       venues: [],
       venue: { extends: "paperlint:aisec", kind: null },
     });
@@ -503,7 +504,7 @@ describe("a project's own template", () => {
     mkdirSync(join(papers, OVERRIDE_DIR), { recursive: true });
     writeFileSync(join(papers, OVERRIDE_DIR, "paperlint.json"), "{}\n");
     const lines = reportNewPaper(
-      newPaper(papers, "p", "tex", { venues: [] }),
+      newPaper(papers, "p", { venues: [] }),
       (p) => p,
     );
     expect(lines).toContain(

package/src/new-paper.ts

@@ -8,8 +8,7 @@
  * Every rule below is taken from a tool that already solved it (docs/prior-art/paper-folder-scaffolding.md):
  *   - the template is a FILE with a lookup order — the project's `<papers>/.template/<file>` first,
  *     the package's `templates/paper/<file>` second (Hugo's archetypes);
- *   - it NEVER overwrites: on an existing folder it adds only the missing required files, which is
- *     also the migration for an old folder that has only `paper.md` (`cargo init`);
+ *   - it NEVER overwrites: on an existing folder it adds only the missing required files (`cargo init`);
  *   - the name is validated, because it becomes a path and, through the hooks, a shell argument.
  *
  * The only substitution is `{{name}}` → the folder name. Nothing else in a template is touched.
@@ -33,10 +32,6 @@ import {
   type NamedVenue,
 } from "./domain/venue-name.ts";
 
-export type PaperFormat = "tex" | "md";
-export const FORMATS: readonly PaperFormat[] = ["tex", "md"];
-export const DEFAULT_FORMAT: PaperFormat = "tex";
-
 /** The package's default templates. Read from disk, so they ship in the tarball (`files`). */
 export const PACKAGE_TEMPLATES = fileURLToPath(
   new URL("../templates/paper/", import.meta.url),
@@ -50,17 +45,12 @@ export const PACKAGE_TEMPLATES = fileURLToPath(
 export const OVERRIDE_DIR = ".template";
 
 export const STATUS_FILE = "PIPELINE-STATUS.md";
-export const SOURCE_FILE: Readonly<Record<PaperFormat, string>> = {
-  tex: "paper.tex",
-  md: "paper.md",
-};
+/** A paper's source: LaTeX, one file at the paper's root. */
+export const SOURCE_FILE = "paper.tex";
 
 /** The flag that lets `paperlint new` create a folder whose name names a venue. */
 export const ALLOW_VENUE_NAME = "--allow-venue-name";
 
-export const isFormat = (v: unknown): v is PaperFormat =>
-  FORMATS.some((f) => f === v);
-
 /**
  * Why a name is refused, or null. `[a-z0-9._-]+` is the charset; a LEADING dot is refused on top
  * of it, because discovery skips dot-directories — a paper named `.x` would be created and then
@@ -109,20 +99,12 @@ export type NewPaperResult =
     }
   | { readonly ok: false; readonly reason: string };
 
-/**
- * The files a paper folder must end up with: the scorecard, a source in `format` — unless it
- * already has a source in EITHER format, in which case that one stands — and `paperlint.json`.
- */
-export function wantedFiles(dir: string, format: PaperFormat): string[] {
-  return [...scorecardAndSource(dir, format), CONFIG_FILE];
-}
-
-function scorecardAndSource(dir: string, format: PaperFormat): string[] {
-  const hasSource = Object.values(SOURCE_FILE).some((f) =>
-    existsSync(join(dir, f)),
-  );
-  return hasSource ? [STATUS_FILE] : [STATUS_FILE, SOURCE_FILE[format]];
-}
+/** The files a paper folder must end up with: the scorecard, the source and `paperlint.json`. */
+export const WANTED_FILES: readonly string[] = [
+  STATUS_FILE,
+  SOURCE_FILE,
+  CONFIG_FILE,
+];
 
 /** The venue `paperlint new --venue` chose: what goes into the new paper's `paperlint.json`. */
 export interface VenueSetting {
@@ -195,7 +177,7 @@ function fromTemplate(
     return { ok: false, reason: `no template for ${file}: ${src} is missing` };
   const text = readFileSync(src, "utf8").split("{{name}}").join(name);
   const setClass = venue?.setClass ?? null;
-  if (file === SOURCE_FILE.tex && setClass !== null)
+  if (file === SOURCE_FILE && setClass !== null)
     return { ok: true, value: { file, text: setClass(text), from } };
   if (file !== CONFIG_FILE || venue === null)
     return { ok: true, value: { file, text, from } };
@@ -217,7 +199,6 @@ export interface NewPaperOptions {
 export function newPaper(
   papersRoot: string,
   name: string,
-  format: PaperFormat,
   opts: NewPaperOptions,
 ): NewPaperResult {
   const { packageTemplates = PACKAGE_TEMPLATES, venue = null } = opts;
@@ -230,7 +211,7 @@ export function newPaper(
 
   const files: FileOutcome[] = [];
   const toWrite: Planned[] = [];
-  for (const file of wantedFiles(dir, format)) {
+  for (const file of WANTED_FILES) {
     if (existsSync(join(dir, file))) {
       files.push({ file, status: "kept" });
       continue;

package/src/paper-files.test.ts

@@ -20,6 +20,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, describe, expect, it } from "vitest";
 import { buildConfig, eslintConfig, run } from "./cli.ts";
+import { texLanguage } from "#eslint-rules/latex-language";
 import {
   narrowToOwners,
   ownedPatterns,
@@ -247,7 +248,7 @@ describe("`rules` blocks — where the rule lands", () => {
               },
             ],
           },
-          null,
+          texLanguage,
         ),
       ),
     });
@@ -257,9 +258,9 @@ describe("`rules` blocks — where the rule lands", () => {
     const status = await on("papers/a/PIPELINE-STATUS.md");
     expect(status["paper/source"]).toEqual([1]);
     expect(status["paper/section-word"]).toBeUndefined();
-    const draft = await on("papers/a/paper.md");
-    expect(draft["paper/section-word"]).toEqual([0]);
-    expect(draft["paper/source"]).toBeUndefined();
+    const source = await on("papers/a/paper.tex");
+    expect(source["paper/section-word"]).toEqual([0]);
+    expect(source["paper/source"]).toBeUndefined();
   });
 });
 

package/src/paper-files.ts

@@ -1,8 +1,8 @@
 /**
  * THE FILES PAPERLINT OWNS — read off its own config, and made the only thing ESLint may reach.
  *
- * paperlint's blocks name the files they lint (`PIPELINE-STATUS.md`, `paper.md`, `paper.tex`,
- * `reviews/*.md`, …). That list is the whole scope of `paperlint lint`, and this module turns it
+ * paperlint's blocks name the files they lint (`PIPELINE-STATUS.md`, `paper.tex`, `reviews/*.md`,
+ * …). That list is the whole scope of `paperlint lint`, and this module turns it
  * into two things ESLint understands:
  *
  * 1. **A global ignore of everything else** (`scopeToOwned`). Handing ESLint a directory is not
@@ -17,7 +17,7 @@
  * 2. **Each rule scoped to the files it was written for** (`ruleOwners` + `narrowToOwners`).
  *    One plugin NAME is bound to different plugin objects in different blocks: `paper` holds
  *    `stages`/`source`/`author-list` beside `PIPELINE-STATUS.md` and `typography` beside
- *    `paper.md`/`paper.tex`. So a consumer block that named `paper/source`
+ *    `paper.tex`. So a consumer block that named `paper/source`
  *    for every file under the papers directory reached `paper.tex`, where `paper` has no `source`
  *    — and ESLint threw `Could not find "source" in plugin "paper"` from inside `lintFiles`,
  *    after paperlint's own validation had (correctly) accepted the id. A block is therefore split
@@ -36,7 +36,7 @@
  * - a global-ignore pattern that matches a DIRECTORY hides everything inside it, so directories
  *   must be un-ignored (`!` + a pattern ending in a slash) before owned files can be;
  * - that un-ignores `node_modules/` and `.git/` too — ESLint's own defaults — so they are
- *   re-ignored after, or a `paper.md` inside a dependency would be linted;
+ *   re-ignored after, or a `paper.tex` inside a dependency would be linted;
  * - later global-ignore patterns win, across blocks, in config order;
  * - `files: [["a", "b"]]` matches a file only when BOTH patterns match.
  */

package/src/paper-prose.test.ts

@@ -0,0 +1,49 @@
+import { expect, it } from "vitest";
+import { latexReader } from "./adapters/latex/index.ts";
+import { memoryFiles } from "./adapters/memory/index.ts";
+import { paperProse } from "./paper-prose.ts";
+
+const SRC = [
+  "\\documentclass{article}",
+  "\\usepackage{amsmath} % a preamble word count of its own",
+  "\\title{A Title}",
+  "\\begin{document}",
+  "\\maketitle",
+  "\\section{Introduction}",
+  "We measure it~\\cite{a}. % a comment",
+  "",
+  "A second paragraph \\input{body}",
+  "\\begin{filecontents*}{refs.bib}",
+  "@misc{a, author = {Ada Lovelace}, title = {Never Prose}}",
+  "\\end{filecontents*}",
+  "\\end{document}",
+].join("\n");
+
+it("the body's prose, a blank line between passages, includes spliced; the preamble, comments, the inline .bib and the title stay out", () => {
+  const files = memoryFiles({
+    "/p/paper.tex": SRC,
+    "/p/body.tex": "\\subsection{Method}\nends here.",
+  });
+  expect(
+    paperProse("/p/paper.tex", SRC, { files, latex: latexReader }),
+  ).toEqual({
+    // A citation stands as `[1]`, where it is set; a heading — here an included one — ends a passage.
+    body: "We measure it [1].\n\nA second paragraph\n\nends here.",
+    headings: ["Introduction", "Method"],
+    files: [
+      { file: "paper.tex", text: SRC },
+      { file: "body.tex", text: "\\subsection{Method}\nends here." },
+    ],
+  });
+});
+
+it("a citation stands as `[1]` and a cross-reference as `1`, so the sentence still ends on them", () => {
+  const src =
+    "\\documentclass{article}\n\\begin{document}\nIt holds~\\cite{a}. It is shown (Section~\\ref{s}).\n\\end{document}\n";
+  expect(
+    paperProse("/p/paper.tex", src, {
+      files: memoryFiles({ "/p/paper.tex": src }),
+      latex: latexReader,
+    }).body,
+  ).toBe("It holds [1]. It is shown (Section 1).");
+});

package/src/paper-prose.ts

@@ -0,0 +1,67 @@
+/**
+ * THE PROSE OF A paper.tex AS PLAIN TEXT — what `grade-paper-writing/prose-lint.mjs` measures.
+ *
+ * prose-lint counts sentences and words, and every metric it prints is a fraction of the word
+ * count. Read as raw text, a `.tex` puts the preamble, the `%` comments and an inline `filecontents`
+ * bibliography into that count (8127 "words" against about 4636 real ones on one paper), so every
+ * rate comes out roughly halved. This reads the paper the way the `tex/register` rule does: the
+ * includes spliced in (`readPaper`), then the body's prose as passages (`bodyProse` — the abstract
+ * to the back matter, without headings, captions, floats or code), each passage's sentences
+ * (`bodySentences`). A blank line separates two passages, so no sentence runs across them.
+ *
+ * A citation stands as `[1]` and a cross-reference as `1`, where they are set — not left out:
+ * prose-lint judges a sentence that ENDS on one (a wasted stress position) and counts references
+ * to other parts of the paper (`(Section 1)`), and both are invisible in a sentence the marks
+ * were cut out of. Math is left out; prose-lint counts no formula.
+ */
+import { bodySentences } from "./domain/register.ts";
+import { CITATION, MATH, REFERENCE } from "./domain/sentences.ts";
+import { runText } from "./domain/tex-document.ts";
+import { readPaper, type PaperDeps } from "./tex-paper.ts";
+
+/** A sentence's text with each mark as a reader would see it set, and math left out. */
+const rendered = (raw: string): string =>
+  raw
+    .replaceAll(CITATION, "[1]")
+    .replaceAll(REFERENCE, "1")
+    .replaceAll(MATH, "")
+    .replace(/\s+/gu, " ")
+    .trim();
+
+/**
+ * A paper's body prose, one passage per paragraph, its section titles in document order, and the
+ * text of each file it is made of — `paper.tex` and every file it includes, once, named as the
+ * include names it — for what the body leaves out, such as captions.
+ */
+export interface PaperProse {
+  readonly body: string;
+  readonly headings: readonly string[];
+  readonly files: readonly { readonly file: string; readonly text: string }[];
+}
+
+/** The prose and the headings of the paper whose main file is `filename` with the text `src`. */
+export function paperProse(
+  filename: string,
+  src: string,
+  deps: PaperDeps,
+): PaperProse {
+  const { text, segments } = readPaper(filename, src, deps);
+  const passages = deps.latex
+    .bodyProse(text)
+    .map((p) =>
+      bodySentences([p])
+        .map((s) => rendered(s.raw))
+        .join(" "),
+    )
+    .filter((p) => p !== "");
+  return {
+    body: passages.join("\n\n"),
+    headings: deps.latex
+      .headings(text)
+      .filter((h) => h.command.kind === "heading" && h.argument === "title")
+      .map((h) => runText(h.title).replace(/\s+/g, " ").trim()),
+    files: [...new Map(segments.map((s) => [s.file, s.source])).entries()].map(
+      ([file, text]) => ({ file, text }),
+    ),
+  };
+}

package/src/paper-settings.test.ts

@@ -33,6 +33,7 @@ describe("parsePaperSettings", () => {
         identity: null,
         talk: null,
         submission: null,
+        cycles: null,
       },
     });
     expect(parsePaperSettings({})).toEqual({
@@ -45,6 +46,7 @@ describe("parsePaperSettings", () => {
         identity: null,
         talk: null,
         submission: null,
+        cycles: null,
       },
     });
   });
@@ -60,6 +62,7 @@ describe("parsePaperSettings", () => {
         identity: null,
         talk: null,
         submission: null,
+        cycles: null,
       },
     });
   });
@@ -164,6 +167,7 @@ const UNSET = {
   identity: null,
   talk: null,
   submission: null,
+  cycles: null,
 };
 
 describe("readPaperSettings — the root paperlint.json's defaults, the paper's file over them", () => {
@@ -220,8 +224,14 @@ describe("readPaperSettings — the root paperlint.json's defaults, the paper's
       identity: null,
       talk: null,
       submission: null,
+      cycles: null,
     });
   });
+});
+
+describe("readPaperSettings — a project key in a paper's file", () => {
+  const withFiles = (f: Record<string, string>) =>
+    memoryFiles({ "/work/package.json": "{}", ...f });
 
   it("papersDir in a paper's file: broken, naming the root file as its place", () => {
     const r = readPaperSettings(
@@ -264,6 +274,7 @@ describe("paperRules — `rules` in paperlint.json", () => {
     identity: null,
     talk: null,
     submission: null,
+    cycles: null,
   });
 
   it("no rules: none", () => {
@@ -352,3 +363,159 @@ describe("talk in a paper's paperlint.json", () => {
     expect(r.ok ? "" : r.error).toMatch(/"talk.mode"/);
   });
 });
+
+describe("parsePaperSettings — `cycles`: the current attempt supplies extends, kind and submission", () => {
+  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.md",
+    },
+  };
+  const open = {
+    id: "beta-2027",
+    venue: { kind: "preset", extends: "paperlint:ieee-conference" },
+    kind: "technical",
+    opened: "2026-09-09",
+    submission: { id: 52 },
+    outcome: { kind: "open" },
+  };
+  const settingsOf = (json: unknown) => {
+    const r = parsePaperSettings(json);
+    if (!r.ok) throw new Error(r.error);
+    return r.value;
+  };
+
+  it("an open cycle: its venue, kind and submission are the paper's", () => {
+    const s = settingsOf({ cycles: [closed, open] });
+    expect(s.extends).toBe("paperlint:ieee-conference");
+    expect(s.kind).toBe("technical");
+    expect(s.submission).toEqual({ id: 52 });
+    expect(s.cycles?.current.kind).toBe("cycle");
+    expect(s.cycles?.list.map((c) => c.id)).toEqual([
+      "alpha-2026",
+      "beta-2027",
+    ]);
+  });
+
+  it("parked (the last cycle closed) and none (`cycles: []`): no venue, as `extends: null` reads", () => {
+    const parked = settingsOf({ cycles: [closed] });
+    expect([parked.extends, parked.kind, parked.submission]).toEqual([
+      null,
+      null,
+      null,
+    ]);
+    expect(parked.cycles?.current.kind).toBe("parked");
+    expect(settingsOf({ cycles: [] }).cycles?.current).toEqual({
+      kind: "none",
+    });
+  });
+});
+
+describe("parsePaperSettings — `cycles`, closed and named", () => {
+  const closed = {
+    id: "alpha-2026",
+    venue: { kind: "preset", extends: "paperlint:acm-sigconf" },
+    kind: "short",
+    opened: "2026-07-01",
+    outcome: { kind: "withdrawn", date: "2026-09-08", evidence: "n.md" },
+  };
+  const open = {
+    id: "beta-2027",
+    venue: { kind: "preset", extends: "paperlint:ieee-conference" },
+    kind: "technical",
+    opened: "2026-09-09",
+  };
+  const settingsOf = (json: unknown) => {
+    const r = parsePaperSettings(json);
+    if (!r.ok) throw new Error(r.error);
+    return r.value;
+  };
+
+  it("an accepted last cycle keeps its venue and kind: camera-ready and talk are judged against it", () => {
+    const accepted = { kind: "accepted", date: "2026-08-21", evidence: "r.md" };
+    const s = settingsOf({ cycles: [{ ...closed, outcome: accepted }] });
+    expect([s.extends, s.kind, s.cycles?.current.kind]).toEqual([
+      "paperlint:acm-sigconf",
+      "short",
+      "accepted",
+    ]);
+  });
+
+  it("a named venue (no preset yet) resolves no preset: extends is null, the record stays", () => {
+    const venue = {
+      kind: "named",
+      name: "X '27",
+      url: "https://example.org/c",
+    };
+    const s = settingsOf({ cycles: [{ ...open, venue }] });
+    expect([s.extends, s.kind]).toEqual([null, "technical"]);
+  });
+});
+
+describe("parsePaperSettings — `cycles` refused", () => {
+  const open = {
+    id: "beta-2027",
+    venue: { kind: "preset", extends: "paperlint:ieee-conference" },
+    opened: "2026-09-09",
+  };
+  const alsoOpen = {
+    id: "alpha-2026",
+    venue: { kind: "preset", extends: "paperlint:acm-sigconf" },
+    opened: "2026-07-01",
+  };
+
+  it("one derived key beside `cycles` is refused in the singular", () => {
+    const error: unknown = expect.stringMatching(
+      /^"kind" beside "cycles": with cycles, it is the current attempt's/,
+    );
+    expect(parsePaperSettings({ kind: "short", cycles: [open] })).toEqual({
+      ok: false,
+      error,
+    });
+  });
+
+  it("a derived key written beside `cycles` is refused, naming it — two sources for one fact", () => {
+    const error: unknown = expect.stringMatching(
+      /^"extends", "kind" beside "cycles": with cycles, they are the current attempt's/,
+    );
+    expect(
+      parsePaperSettings({
+        extends: "paperlint:acm-sigconf",
+        kind: "short",
+        cycles: [open],
+      }),
+    ).toEqual({ ok: false, error });
+  });
+
+  it("two open cycles is refused as the file's problem: dual submission has no current venue", () => {
+    const error: unknown = expect.stringMatching(
+      /are both open — a paper is on one attempt/,
+    );
+    expect(parsePaperSettings({ cycles: [alsoOpen, open] })).toEqual({
+      ok: false,
+      error,
+    });
+  });
+
+  it("a malformed cycle is refused with the entry and key, through readPaperSettings as `broken`", () => {
+    const files = memoryFiles({
+      "/work/package.json": "{}",
+      [`${PAPER}/paperlint.json`]: JSON.stringify({
+        cycles: [{ ...open, opened: "soon" }],
+      }),
+    });
+    const why: unknown = expect.stringMatching(
+      /^cycles\[0\]: "opened" must be a date/,
+    );
+    expect(readPaperSettings(files, PAPER)).toEqual({
+      ok: false,
+      error: { kind: "broken", why },
+    });
+  });
+});