paperlint 7.1.0 → 8.0.0

package/src/submission.test.ts

@@ -22,6 +22,7 @@ import type { SubmissionPortal } from "./ports/submission-portal.ts";
 import {
   failureText,
   runSubmission,
+  deadlineLine,
   submissionTarget,
   tokenFor,
   usageProblem,
@@ -41,8 +42,11 @@ const withPresets = (fs: Files): Files => ({
   readBytes: (p) => fs.readBytes(p) ?? nodeFiles.readBytes(p),
 });
 
+/** A venue over aidc's format with a portal of its own — so none of aidc's deadline readings. */
 const venue = (portal: unknown): string =>
-  JSON.stringify(venuePreset("venue", { extends: "paperlint:aidc", portal }));
+  JSON.stringify(
+    venuePreset("venue", { extends: "paperlint:aidc", portal, deadlines: [] }),
+  );
 const files = (o: {
   readonly portal?: unknown;
   readonly paper?: Readonly<Record<string, unknown>>;
@@ -476,6 +480,28 @@ test("🔴 the file and key to set: no portal in the preset, no submission in th
   const noExtends = files({ paper: { submission: { id: 7 } } });
   const t3 = submissionTarget(PAPER, deps(noExtends));
   assert.match(!t3.ok ? t3.error : "", /paperlint\.json: no "extends"/);
+  // With cycles, `extends` beside them is refused: the message names the cycle, not the key.
+  const named = files({
+    paper: {
+      cycles: [
+        {
+          id: "secdev-2027",
+          venue: {
+            kind: "named",
+            name: "SecDev 2027",
+            url: "https://x.example",
+          },
+          opened: "2027-01-10",
+          submission: { id: 3 },
+        },
+      ],
+    },
+  });
+  const t5 = submissionTarget(PAPER, deps(named));
+  assert.equal(
+    !t5.ok ? t5.error : "",
+    `${PAPER}/paperlint.json: 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`,
+  );
   const broken = files({
     paper: { extends: "../../venue.jsonc", submission: { id: "7" } },
   });
@@ -534,3 +560,81 @@ test("usage: a subcommand is required, one paper folder, update-only flags refus
   );
   assert.equal(usageProblem({ ...ARGS, sub: "update", save: true }), null);
 });
+
+test("show prints the current attempt's deadlines in force: the preset's portal readings, the paper's call readings and override over them", () => {
+  const fs = memoryFiles({
+    "/w/package.json": "{}",
+    [`${PAPER}/paperlint.json`]: JSON.stringify({
+      cycles: [
+        {
+          id: "msr-2027",
+          venue: { kind: "preset", extends: "paperlint:msr" },
+          kind: "technical",
+          opened: "2026-10-05",
+          submission: { id: 7 },
+          deadlines: [
+            {
+              what: "registration",
+              observed: [
+                {
+                  at: "2026-10-20 AoE",
+                  source: "call",
+                  url: "https://2027.msrconf.org/cfp",
+                  read: "2026-10-05",
+                },
+              ],
+            },
+            {
+              what: "submission",
+              observed: [
+                {
+                  at: "2026-10-23 AoE",
+                  source: "call",
+                  url: "https://2027.msrconf.org/cfp",
+                  read: "2026-10-05",
+                },
+              ],
+            },
+            {
+              what: "resubmission",
+              override: {
+                at: "2026-10-27T04:00:00Z",
+                reason: "the chairs extended updates by mail",
+                evidence: "mail/extension.eml",
+              },
+            },
+          ],
+        },
+      ],
+    }),
+  });
+  const t = submissionTarget(PAPER, {
+    files: withPresets(fs),
+    venuesDir: presetsDir(),
+  });
+  assert.ok(t.ok, JSON.stringify(t));
+  assert.deepEqual(t.value.deadlines.map(deadlineLine), [
+    "deadline      registration 2026-10-21T11:59:59Z — call, read 2026-10-05",
+    "deadline      submission 2026-10-20T04:00:00Z — portal, read 2026-10-05; also call 2026-10-24T11:59:59Z, read 2026-10-05",
+    "deadline      resubmission 2026-10-27T04:00:00Z — override: the chairs extended updates by mail (mail/extension.eml); also portal 2026-10-23T04:00:00Z, read 2026-10-05",
+  ]);
+});
+
+test("show, in the flat form: the deadlines in force are the preset's readings alone", () => {
+  const flat = memoryFiles({
+    "/w/package.json": "{}",
+    [`${PAPER}/paperlint.json`]: JSON.stringify({
+      extends: "paperlint:msr",
+      kind: "technical",
+      submission: { id: 7 },
+    }),
+  });
+  const f = submissionTarget(PAPER, {
+    files: withPresets(flat),
+    venuesDir: presetsDir(),
+  });
+  assert.deepEqual(f.ok ? f.value.deadlines.map((d) => [d.what, d.at]) : f, [
+    ["submission", "2026-10-20T04:00:00Z"],
+    ["resubmission", "2026-10-23T04:00:00Z"],
+  ]);
+});

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/types.ts

@@ -62,8 +62,6 @@ export interface Args {
   noHooks: boolean;
   /** `--paper <name>`: `init` creates this paper. */
   paper: string | null;
-  /** `--format tex|md` for `new` and `init --paper`. Validated by the command, not here. */
-  format: string | null;
   /** `--venue <preset>` for `new`: a shipped preset name, or a path to the project's own. */
   venue: string | null;
   /** `--kind <kind>` for `new`: one of the venue preset's kinds. */

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([]);
+  });
+});