paperlint 7.1.0 → 7.2.0

package/src/submission.ts

@@ -30,7 +30,19 @@ import {
 } from "./domain/submission.ts";
 import type { Files } from "./ports/files.ts";
 import type { SubmissionPortal } from "./ports/submission-portal.ts";
-import { paperPreset, paperPresetProblem, type PresetDeps } from "./presets.ts";
+import {
+  paperPreset,
+  unusablePresetLine,
+  type PaperPreset,
+  type PresetDeps,
+} from "./presets.ts";
+import type { PaperSettings } from "./paper-settings.ts";
+import { currentDeadlines } from "./domain/cycle.ts";
+import {
+  deadlinesInForce,
+  type InForce,
+  type Observation,
+} from "./domain/deadline.ts";
 import { CONFIG_FILE } from "#lib/paper-config";
 
 /** The environment variable each portal kind's token is read from. */
@@ -82,22 +94,29 @@ export interface SubmissionTarget {
   readonly pdf: string;
   /** The venue's call for papers (the preset's `url`); null when the preset names no venue. */
   readonly call: string | null;
+  /**
+   * The deadlines in force for the current attempt: the paper's own entries (with `cycles`) over the
+   * venue preset's readings. Instants and where each came from — never how long is left.
+   */
+  readonly deadlines: readonly InForce[];
 }
 
 const configOf = (dir: string): string => join(dir, CONFIG_FILE);
 
-/** The paper directory → its portal and submission, or the line naming the file and key to set. */
-export function submissionTarget(
+/** Why a paper without a venue preset has no portal: the key to set, or — with cycles — where. */
+const noPresetLine = (
   paperDir: string,
-  deps: PresetDeps,
+  settings: PaperSettings | null,
+): string =>
+  settings === null || settings.cycles === null
+    ? `${configOf(paperDir)}: no "extends" — the venue preset it names declares the portal ("portal": { "kind": …, "url": … })`
+    : `${configOf(paperDir)}: the current cycle names no venue preset, and the preset is what declares the portal — set the venue in the current cycle ("venue": { "kind": "preset", "extends": "paperlint:…" }), or upload by hand`;
+
+/** A resolved paper → its portal and submission, or the line naming the file and key to set. */
+function targetOf(
+  paperDir: string,
+  p: Extract<PaperPreset, { readonly kind: "resolved" }>,
 ): Result<SubmissionTarget, string> {
-  const p = paperPreset(paperDir, deps);
-  const problem = paperPresetProblem(paperDir, p);
-  if (problem !== null) return err(problem);
-  if (p.kind !== "resolved")
-    return err(
-      `${configOf(paperDir)}: no "extends" — the venue preset it names declares the portal ("portal": { "kind": …, "url": … })`,
-    );
   const declared = p.preset.portal;
   if (declared === null)
     return err(
@@ -113,7 +132,29 @@ export function submissionTarget(
   const pdf = join(paperDir, p.settings.pdf ?? "paper.pdf");
   const identity = p.preset.identity;
   const call = identity.type === "venue" ? identity.url : null;
-  return ok({ portal: portal.value, id: sub.id, pdf, call });
+  const own =
+    p.settings.cycles === null
+      ? []
+      : currentDeadlines(p.settings.cycles.current);
+  const deadlines = deadlinesInForce(own, p.preset.deadlines);
+  return ok({ portal: portal.value, id: sub.id, pdf, call, deadlines });
+}
+
+/** The paper directory → its portal and submission, or the line naming the file and key to set. */
+export function submissionTarget(
+  paperDir: string,
+  deps: PresetDeps,
+): Result<SubmissionTarget, string> {
+  const p = paperPreset(paperDir, deps);
+  switch (p.kind) {
+    case "none":
+      return err(noPresetLine(paperDir, p.settings));
+    case "settings-problem":
+    case "preset-problem":
+      return err(unusablePresetLine(paperDir, p));
+    case "resolved":
+      return targetOf(paperDir, p);
+  }
 }
 
 /** The token from the environment, or the line naming the variable and where to get one. */
@@ -166,6 +207,25 @@ const pdfLine = (view: SubmissionView): string =>
     ? "portal PDF    none"
     : `portal PDF    ${view.pdf.hash}, ${view.pdf.size === null ? "?" : String(view.pdf.size)} bytes, uploaded ${iso(view.pdf.uploadedAt)}`;
 
+const readingText = (o: Observation): string =>
+  `${o.source} ${o.at}, read ${o.read}`;
+
+/** One deadline in force, what set it, and the other readings of it. Pure. */
+export function deadlineLine(d: InForce): string {
+  const by = d.by;
+  const why =
+    by.kind === "override"
+      ? `override: ${by.override.reason} (${by.override.evidence})`
+      : `${by.reading.source}, read ${by.reading.read}`;
+  const others = d.readings.filter(
+    (r) => by.kind === "override" || r !== by.reading,
+  );
+  const also = others.length
+    ? `; also ${others.map(readingText).join("; ")}`
+    : "";
+  return `deadline      ${d.what} ${d.at} — ${why}${also}`;
+}
+
 /** `show`'s report. Pure. */
 export function showLines(
   t: SubmissionTarget,
@@ -182,6 +242,7 @@ export function showLines(
     pdfLine(view),
     `local PDF     ${local.shown} ${local.sha256 === null ? "(missing)" : `sha2-${local.sha256}`}`,
     matchLine(view, local.sha256),
+    ...t.deadlines.map(deadlineLine),
     ...view.messages.map(messageLine),
   ];
 }

package/src/tex-requirements.ts

@@ -35,6 +35,7 @@ import {
   type VenueTalkJson,
 } from "./domain/talk.ts";
 import type { VenuePortal } from "./domain/submission.ts";
+import type { Reading } from "./domain/deadline.ts";
 
 /** CTAN package name → the names that prove it is installed. */
 export type PackageProofs = Readonly<Record<string, readonly string[]>>;
@@ -219,6 +220,8 @@ export interface PresetFile {
   readonly talk: VenueTalk | null;
   /** Where the venue takes submissions (`paperlint submission`); null when the file does not say. */
   readonly portal: VenuePortal | null;
+  /** The edition's deadlines as they were read; null when the file names none (a child's list replaces its parent's). */
+  readonly deadlines: readonly Reading[] | null;
 }
 
 type KindsJson = Readonly<
@@ -276,6 +279,7 @@ interface PresetBodyJson {
   };
   readonly talk?: VenueTalkJson;
   readonly portal?: VenuePortal;
+  readonly deadlines?: readonly Reading[];
 }
 
 /** An optional field as the typed preset holds it: absent is null. */
@@ -394,6 +398,32 @@ const anchorsOf = (
 const portalOf = (p: PresetJson["portal"]): Readonly<VenuePortal> | null =>
   p === undefined ? null : { kind: p.kind, url: p.url };
 
+/**
+ * A preset's `deadlines`, or null when it names none. Two readings of one kind from one source are
+ * refused: the schema cannot say it, and a paper could not tell which binds.
+ */
+function deadlinesOf(
+  d: PresetJson["deadlines"],
+  file: string,
+): readonly Reading[] | null {
+  if (d === undefined) return null;
+  const twice = d.find(
+    (r, i) =>
+      d.findIndex((x) => x.what === r.what && x.source === r.source) !== i,
+  );
+  if (twice !== undefined)
+    throw new Error(
+      `${file}: "deadlines" holds two "${twice.source}" readings of "${twice.what}" — keep one, the latest`,
+    );
+  return d.map(({ what, at, source, url, read }) => ({
+    what,
+    at,
+    source,
+    url,
+    read,
+  }));
+}
+
 /**
  * The text of one preset file → the typed file, or an Error naming every problem. The ONE parser
  * of a preset: the toolchain reads its `tex`, the venue rules its `format`, the config its `rules`.
@@ -429,6 +459,7 @@ export function parsePreset(
     registerAnchors: anchorsOf(j.register),
     talk: j.talk === undefined ? null : venueTalkOf(j.talk),
     portal: portalOf(j.portal),
+    deadlines: deadlinesOf(j.deadlines, file),
   };
 }
 

package/src/tex-venue-rules.test.ts

@@ -10,6 +10,7 @@ import { memoryFiles } from "./adapters/memory/index.ts";
 import { presetsDir } from "./package-dirs.ts";
 import { latexReader } from "./adapters/latex/index.ts";
 import {
+  cyclePortRules,
   judgeRequiredSections,
   judgeTemplate,
   otherVenues,
@@ -77,6 +78,9 @@ function lint(
     ...Object.entries(formatRules(deps)).map(
       ([n, r]) => [`format/${n}`, r] as const,
     ),
+    ...Object.entries(cyclePortRules(deps)).map(
+      ([n, r]) => [`cycle/${n}`, r] as const,
+    ),
   ]) {
     const visitor = rule.create({
       filename,
@@ -302,6 +306,78 @@ describe("tex/template — the shipped ACM and ACL templates", () => {
   });
 });
 
+const PORTING = {
+  id: "aidc-2026",
+  venue: { kind: "preset", extends: "paperlint:aidc" },
+  kind: "regular",
+  opened: "2026-09-26",
+  phase: "porting",
+};
+
+describe("tex/template — a cycle in `porting`", () => {
+  it("the class line is the previous venue's by declaration: silent, where the flat form reports", () => {
+    const src = paper("\\documentclass[sigconf]{acmart}");
+    expect(lint(src, AIDC).map((f) => f.messageId)).toEqual(["wrongClass"]);
+    expect(lint(src, { cycles: [PORTING] })).toEqual([]);
+    expect(
+      lint(src, { cycles: [{ ...PORTING, phase: "prepared" }] }).map(
+        (f) => f.messageId,
+      ),
+    ).toEqual(["wrongClass"]);
+  });
+});
+
+describe("cycle/port-done — the declared port is finished", () => {
+  it("porting declared and the class line already the venue's: the one finding, naming the cycle", () => {
+    const fs = lint(OFFICIAL, { cycles: [PORTING] });
+    expect(fs.map((f) => `${f.rule}:${f.messageId}`)).toEqual([
+      "cycle/port-done:done",
+    ]);
+    expect(fs[0]?.message).toMatch(
+      /already `\\documentclass\[conference,compsoc\]\{IEEEtran\}`, which AIDC requires, and the cycle «aidc-2026» still declares "phase": "porting"/,
+    );
+  });
+
+  it("silent while the class line is still the old venue's, once the phase is dropped, and on the flat form", () => {
+    const old = paper("\\documentclass[sigconf]{acmart}");
+    expect(lint(old, { cycles: [PORTING] })).toEqual([]);
+    expect(
+      lint(OFFICIAL, { cycles: [{ ...PORTING, phase: "prepared" }] }),
+    ).toEqual([]);
+    expect(lint(OFFICIAL, AIDC)).toEqual([]);
+  });
+
+  it("judges the text when the source carries no `raw`", () => {
+    expect(
+      lint(OFFICIAL, { cycles: [PORTING] }, { raw: false }).map(
+        (f) => `${f.rule}:${f.messageId}`,
+      ),
+    ).toContain("cycle/port-done:done");
+  });
+
+  it("silent when the venue names no template, and when the preset does not resolve", () => {
+    const own = `${PAPER}/own.jsonc`;
+    const porting = (ext: string) => ({
+      cycles: [{ ...PORTING, venue: { kind: "preset", extends: ext } }],
+    });
+    expect(
+      lint(OFFICIAL, porting("./own.jsonc"), {
+        extra: {
+          [own]: JSON.stringify({
+            type: "family",
+            tex: { packages: { x: ["x"] } },
+          }),
+        },
+      }).filter((f) => f.rule === "cycle/port-done"),
+    ).toEqual([]);
+    expect(
+      lint(OFFICIAL, porting("./missing.jsonc")).filter(
+        (f) => f.rule === "cycle/port-done",
+      ),
+    ).toEqual([]);
+  });
+});
+
 describe("tex/template — a project's own preset, and nothing to judge", () => {
   it("a preset with no template: nothing to compare, no finding", () => {
     const own = `${PAPER}/own.jsonc`;

package/src/tex-venue-rules.ts

@@ -52,6 +52,7 @@ import type { PaperSource } from "./domain/paper-source.ts";
 import { readPaper, reportInPaper } from "./tex-paper.ts";
 import type { RequiredSection } from "./tex-requirements.ts";
 import type { Finding, VenueRuleDeps } from "./venue-rules.ts";
+import { isPorting } from "./domain/cycle.ts";
 
 /** A finding and where it points; null points at the top of the file. */
 export interface Located extends Finding {
@@ -493,6 +494,10 @@ function readingOf(
   const dir = dirname(filename);
   const p = paperPreset(dir, deps);
   if (p.kind !== "resolved") return null;
+  // The port to this venue's template is declared open work: the class line is the previous
+  // venue's by declaration, and `cycle/port-done` watches that declaration.
+  if (p.settings.cycles !== null && isPorting(p.settings.cycles.current))
+    return null;
   const preset = p.preset;
   const others = () => otherVenues(preset, deps);
   const paper = readPaper(filename, src, deps);
@@ -538,3 +543,83 @@ export function formatRules(
 ): Readonly<Record<"layout-override", TexRuleModule>> {
   return { "layout-override": rule("layout-override", deps) };
 }
+
+// ── cycle/port-done: the declared port is finished ───────────────────────────────────────
+
+/**
+ * `cycle/port-done` (error): the current cycle declares `"phase": "porting"`, and the paper's
+ * `\documentclass` is already the venue's template. The declaration silences every venue rule
+ * (`src/venue-rules.ts`, `readingOf` above); once the class line is the venue's, the port is done
+ * and the declaration is stale — this is the other half that keeps `porting` from being a mute
+ * button. Silent when the preset names no template: there is nothing to compare, as for `tex/template`.
+ */
+export function judgePortDone(
+  r: Pick<Reading, "src" | "latex" | "preset">,
+  cycleId: string,
+): readonly Located[] {
+  if (r.preset.template === null) return [];
+  const mismatch = judgeTemplate(
+    r.latex.documentClass(r.src),
+    r.preset,
+    r.latex,
+  );
+  return mismatch.length > 0
+    ? []
+    : [
+        {
+          messageId: "done",
+          data: {
+            venue: r.preset.label,
+            template: r.preset.template.text,
+            id: cycleId,
+          },
+          at: null,
+        },
+      ];
+}
+
+const PORT_DONE_META: TexRuleModule["meta"] = {
+  type: "problem",
+  docs: {
+    description:
+      "the current cycle still says `porting` while the \\documentclass is already the venue's template — the port is done, drop the phase",
+    url: "https://github.com/zernie/paperlint/blob/main/docs/rules/cycle/port-done.md",
+  },
+  schema: [],
+  messages: {
+    done: 'the \\documentclass is already `{{template}}`, which {{venue}} requires, and the cycle «{{id}}» still declares "phase": "porting" — the port is done: remove the phase, so the venue\'s format rules judge this paper again',
+  },
+};
+
+/** The `cycle` plugin's rule over the source, for every `paper.tex`. */
+export function cyclePortRules(
+  deps: TexVenueRuleDeps,
+): Readonly<Record<"port-done", TexRuleModule>> {
+  return {
+    "port-done": {
+      meta: PORT_DONE_META,
+      create(context) {
+        if (basename(context.filename) !== "paper.tex") return {};
+        return {
+          root() {
+            const p = paperPreset(dirname(context.filename), deps);
+            if (p.kind !== "resolved") return;
+            const current = p.settings.cycles?.current;
+            if (current?.kind !== "cycle" || !isPorting(current)) return;
+            const sc = context.sourceCode;
+            const paper = readPaper(context.filename, sc.raw ?? sc.text, deps);
+            const found = judgePortDone(
+              { src: paper.text, latex: deps.latex, preset: p.preset },
+              current.cycle.id,
+            );
+            reportInPaper(context, PORT_DONE_META.messages, paper, found);
+          },
+        };
+      },
+    },
+  };
+}
+
+export const CYCLE_PORT_RULE_LEVELS: Readonly<
+  Record<"cycle/port-done", "error">
+> = { "cycle/port-done": "error" };

package/src/venue-rules.test.ts

@@ -231,6 +231,36 @@ describe("a paper that names no venue", () => {
       lint({ venue: DECL, facts: null }, `${PAPER}/PIPELINE-STATUS.md`),
     ).toEqual([]);
   });
+
+  it.each([
+    [
+      "a named venue",
+      {
+        id: "secdev-2027",
+        venue: { kind: "named", name: "SecDev 2027", url: "https://x.example" },
+        opened: "2027-01-10",
+      },
+    ],
+    [
+      "the last cycle closed, none open",
+      {
+        id: "first-2026",
+        venue: { kind: "preset", extends: "paperlint:aisec" },
+        opened: "2026-07-01",
+        outcome: { kind: "withdrawn", date: "2026-07-18", evidence: "n.md" },
+      },
+    ],
+  ])(
+    "with `cycles` and %s: the warning says to set the venue IN THE CYCLE — `extends` beside `cycles` is refused",
+    (_, cycle) => {
+      const fs = lint({ venue: { cycles: [cycle] }, facts: null, pdf: null });
+      expect(ids(fs)).toEqual(["pdf/measured:noPresetCycle"]);
+      expect(fs[0]?.message).toMatch(
+        /^this paper's current cycle names no venue preset, so its page limit, fonts and format are not checked — set the venue in the current cycle in .*paperlint\.json \("venue": \{ "kind": "preset", "extends": "paperlint:…" \}\), or open a new cycle when the last one has ended$/,
+      );
+      expect(fs[0]?.message).not.toMatch(/set "extends"/);
+    },
+  );
 });
 
 describe("pdf/profile — the declaration must resolve, or nothing is judged", () => {
@@ -1193,3 +1223,55 @@ describe("judgeBodyEnd, on a venue it does not apply to", () => {
     expect(judgeBodyEnd(NO_TEXT, venue(null))).toEqual([]);
   });
 });
+
+/** A paper on AIDC through `cycles`: one attempt, open unless `outcome` says otherwise. */
+const onCycle = (cycle: Record<string, unknown>) => ({
+  identity: ["Ada Example"],
+  cycles: [
+    {
+      id: "aidc-2026",
+      venue: { kind: "preset", extends: "paperlint:aidc" },
+      kind: "regular",
+      opened: "2026-09-26",
+      ...cycle,
+    },
+  ],
+});
+
+describe("the cycle decides what applies", () => {
+  it("an open cycle reads as the flat form: the same findings on the same facts", () => {
+    const facts = said((f) => (f.columns = 1));
+    expect(ids(lint({ venue: onCycle({}), facts }))).toEqual(
+      ids(lint({ venue: BLIND, facts })),
+    );
+    expect(ids(lint({ venue: onCycle({}), facts }))).toContain(
+      "pdf/geometry:columns",
+    );
+  });
+
+  it("`phase: porting` — the source is in the previous venue's template by declaration: every venue rule is silent", () => {
+    const facts = said(
+      (f) => ((f.columns = 1), (f.pages_text = ["Ada Example\n"])),
+    );
+    expect(lint({ venue: onCycle({ phase: "porting" }), facts })).toEqual([]);
+    expect(lint({ venue: onCycle({ phase: "porting" }), facts: null })).toEqual(
+      [],
+    );
+  });
+
+  it("an ACCEPTED cycle at a blind venue: the camera-ready carries the authors, anonymity/identity is silent", () => {
+    const facts = said(
+      (f) =>
+        (f.pages_text = ["Ada Example\n", ...bodyPages(11), "References\n"]),
+    );
+    const accepted = {
+      kind: "accepted",
+      date: "2026-10-16",
+      evidence: "reviews/decision.md",
+    };
+    expect(ids(lint({ venue: onCycle({}), facts }))).toContain(
+      "anonymity/identity:leak",
+    );
+    expect(lint({ venue: onCycle({ outcome: accepted }), facts })).toEqual([]);
+  });
+});

package/src/venue-rules.ts

@@ -37,6 +37,8 @@
  *   no geometry (no banal)  pdf/measured (warn); geometry and body-size silent, page-limit judges
  *                           only a body counted before the references; fonts still judge
  *   kind does not resolve   pdf/profile (error); page-limit silent; everything else still judges
+ *   cycle phase `porting`   every rule silent — the source is in the previous venue's template by
+ *                           declaration (src/domain/cycle.ts); cycle/port-done watches the declaration
  */
 import { dirname, isAbsolute, join, basename, relative } from "node:path";
 import {
@@ -65,6 +67,7 @@ import {
   type PageSplit,
 } from "./domain/body-pages.ts";
 import type { TextFacts } from "./facts-file.ts";
+import { effectiveBlind, isPorting } from "./domain/cycle.ts";
 
 // ── the verdict's vocabulary ─────────────────────────────────────────────────────────
 
@@ -96,8 +99,19 @@ export interface Resolved {
 export type Assessment =
   | { readonly kind: "no-venue" }
   /** A `paperlint.json` that extends no preset yet — `pdf/measured` names the file to set. */
-  | { readonly kind: "no-preset"; readonly file: string }
+  | {
+      readonly kind: "no-preset";
+      readonly file: string;
+      /** The paper keeps `cycles`: its venue is the current cycle's, and `extends` beside them is refused. */
+      readonly cycles: boolean;
+    }
   | { readonly kind: "unresolved"; readonly finding: Finding }
+  /**
+   * The current cycle declares its port to the venue's template as open work (`"phase": "porting"`):
+   * a PDF built with the previous venue's template says nothing about this venue's limits, so every
+   * venue rule is silent, and `cycle/port-done` speaks when the port is done and the phase still says so.
+   */
+  | { readonly kind: "porting" }
   | { readonly kind: "unbuilt"; readonly venue: Resolved }
   | { readonly kind: "stale"; readonly finding: Finding }
   | {
@@ -147,9 +161,13 @@ function kindOf(
 /** How the venue reviews, and who the paper says wrote it: what `anonymity/*` judges by. */
 const reviewOf = (
   preset: Pick<Preset, "blind">,
-  settings: Pick<PaperSettings, "identity">,
+  settings: Pick<PaperSettings, "identity" | "cycles">,
 ): Pick<Resolved, "blind" | "identity"> => ({
-  blind: preset.blind,
+  // An accepted attempt's camera-ready carries the authors: no longer blind.
+  blind: effectiveBlind(
+    preset.blind,
+    settings.cycles?.current ?? { kind: "none" },
+  ),
   identity: settings.identity,
 });
 
@@ -174,13 +192,25 @@ function freshFacts(
 
 const isFinding = (v: object): v is Finding => "messageId" in v;
 
+/** The paper's declared venue and kind, resolved: what the judges compare the facts against. */
+const resolvedOf = (preset: Preset, settings: PaperSettings): Resolved => ({
+  venue: preset.label,
+  format: preset.format,
+  ...kindOf(preset.label, preset.format, settings.kind),
+  ...reviewOf(preset, settings),
+});
+
 /** One paper, assessed. Reads through `deps.files` only; never throws on a paper's files. */
 export function assessPaper(paperDir: string, deps: VenueRuleDeps): Assessment {
   const p = paperPreset(paperDir, deps);
   if (p.kind === "none")
     return p.settings === null
       ? { kind: "no-venue" }
-      : { kind: "no-preset", file: join(paperDir, CONFIG_FILE) };
+      : {
+          kind: "no-preset",
+          file: join(paperDir, CONFIG_FILE),
+          cycles: p.settings.cycles !== null,
+        };
   if (p.kind === "settings-problem")
     return {
       kind: "unresolved",
@@ -191,13 +221,9 @@ export function assessPaper(paperDir: string, deps: VenueRuleDeps): Assessment {
       kind: "unresolved",
       finding: finding("preset", { why: presetProblemText(p.problem) }),
     };
-  const label = p.preset.label;
-  const venue: Resolved = {
-    venue: label,
-    format: p.preset.format,
-    ...kindOf(label, p.preset.format, p.settings.kind),
-    ...reviewOf(p.preset, p.settings),
-  };
+  if (p.settings.cycles !== null && isPorting(p.settings.cycles.current))
+    return { kind: "porting" };
+  const venue = resolvedOf(p.preset, p.settings);
   const factsText = text(deps.files, factsPath(paperDir));
   if (factsText === null) return { kind: "unbuilt", venue };
   const facts = freshFacts(deps.files, paperDir, factsText);
@@ -558,7 +584,11 @@ const JUDGES: Readonly<Record<VenueRuleName, Judge>> = {
   fresh: (a) => (a.kind === "stale" ? [a.finding] : []),
   measured: (a, { shown }) =>
     a.kind === "no-preset"
-      ? [finding("noPreset", { file: shown(a.file) })]
+      ? [
+          finding(a.cycles ? "noPresetCycle" : "noPreset", {
+            file: shown(a.file),
+          }),
+        ]
       : a.kind === "unbuilt"
         ? [
             finding("unbuilt", {
@@ -655,6 +685,8 @@ const META: Readonly<Record<VenueRuleName, Meta>> = {
         "not built yet, so `{{venue}}`'s page limit, fonts and format are not checked — run `paperlint build`",
       noPreset:
         'this paper names no venue preset yet, so its page limit, fonts and format are not checked — set "extends" in {{file}} (e.g. "paperlint:agenticdev"; see docs/rules.md)',
+      noPresetCycle:
+        'this paper\'s current cycle names no venue preset, so its page limit, fonts and format are not checked — set the venue in the current cycle in {{file}} ("venue": { "kind": "preset", "extends": "paperlint:…" }), or open a new cycle when the last one has ended',
       noGeometry:
         "the build measured no page geometry (banal was not found or failed), so page size, columns, page limits and font sizes were NOT checked — run `paperlint toolchain`, then `paperlint build`",
     },