paperlint 6.2.3 → 7.0.0

package/src/heading-case.ts

@@ -0,0 +1,275 @@
+/**
+ * THE RULE THAT JUDGES THE CASE OF TITLES — `tex/heading-case`, over the paper's `\title` and the
+ * titles of `\section`, `\subsection`, `\subsubsection`, `\paragraph` and `\subparagraph`
+ * (starred or not, and each optional short title).
+ *
+ *   tex/heading-case  off unless turned on  every word of a title is in the case its scope asks:
+ *                                           { title, headings, levels? }, each a CaseStyle
+ *
+ * ── WHY IT IS AN OPTION AND NOT A DEFAULT ────────────────────────────────────────
+ * Which style a venue asks is the venue's, and venues name different authorities: Conference
+ * Publishing (AgenticDev's proceedings) quotes the Chicago Manual of Style, ACL links APA title case,
+ * IEEE's manual has its own list. So the rule is optional, like `pdf/last-page-balance`: a venue
+ * preset whose author kit was read turns it on in its `rules` — today only `presets/agenticdev.jsonc`
+ * — and a paper may turn it on in its own `paperlint.json`.
+ *
+ * ── THE OPTIONS ARE PARSED ONCE, WHEN ESLINT LOADS THE RULE ──────────────────────
+ * ESLint checks the SHAPE against `meta.schema`: `title` and `headings` required, no other key, no
+ * unknown level. The VALUES are judged by `parseOptions`, because ajv's enum message («should be
+ * equal to one of the allowed values») names none of them: a misspelt style, the retired words
+ * `headline` and `off`, and `any` for both scopes each throw from `create`, which ESLint reports as
+ * «Error while loading rule» and stops the run. The judge then gets `HeadingCaseOptions` and never
+ * looks at the raw object again. A bare severity (`"error"`, no options) passes ESLint's schema —
+ * it validates the options it is given, not their count — so it is reported once, at the top of the
+ * file, rather than passing as a rule that checked nothing.
+ *
+ * ── ONE FILE AT A TIME ───────────────────────────────────────────────────────────
+ * The rule reads the file ESLint hands it, like `paper/section-word`: it runs on `paper.tex` and on
+ * every file `paper.tex` includes from its body (the `**` block of `src/cli.ts`), so a heading in
+ * `sections/results.tex` is reported at that file and line, and `--fix` edits that file. The
+ * preamble is read too: that is where `\title` stands.
+ *
+ * What a word is asked is decided in `src/domain/heading-case.ts`.
+ */
+import {
+  CASE_STYLES,
+  HEADING_LEVELS,
+  judgeHeadingCase,
+  type CaseFinding,
+  type CaseStyle,
+  type HeadingCaseOptions,
+} from "./domain/heading-case.ts";
+import { fieldOf, isRecord } from "./domain/record.ts";
+import type { HeadingLevel } from "./domain/tex-document.ts";
+import type { LatexReader } from "./ports/latex.ts";
+import { ruleDocsUrl } from "./tex-venue-rules.ts";
+
+/** What the rule reads with: the LaTeX reader. */
+export interface HeadingCaseDeps {
+  readonly latex: LatexReader;
+}
+
+type Loc = { readonly line: number; readonly column: number };
+
+/** The slice of ESLint's rule context this rule uses. `raw` exists on the `.tex` language's. */
+export interface HeadingCaseContext {
+  readonly options: readonly unknown[];
+  readonly sourceCode: {
+    readonly text: string;
+    readonly raw?: string;
+    getLocFromIndex(index: number): Loc;
+  };
+  report(d: {
+    readonly loc: { readonly start: Loc; readonly end: Loc };
+    readonly messageId: string;
+    readonly data?: Readonly<Record<string, string>>;
+    readonly fix?: (fixer: {
+      replaceTextRange(range: readonly [number, number], text: string): unknown;
+    }) => unknown;
+  }): void;
+}
+
+export interface HeadingCaseRule {
+  readonly meta: {
+    readonly type: "suggestion";
+    readonly fixable: "code";
+    readonly docs: { readonly description: string; readonly url: string };
+    readonly schema: readonly object[];
+    readonly messages: Readonly<Record<string, string>>;
+  };
+  create(context: HeadingCaseContext): { root?: () => void };
+}
+
+const DOCS_URL = ruleDocsUrl("heading-case");
+
+/** The rule's options as ESLint gave them: a configuration, none at all, or one it refuses. */
+type Asked =
+  | { readonly kind: "options"; readonly options: HeadingCaseOptions }
+  | { readonly kind: "none" }
+  | { readonly kind: "refused"; readonly reason: string };
+
+const refused = (reason: string): Asked => ({
+  kind: "refused",
+  reason: `${reason} — ${DOCS_URL}`,
+});
+
+const quoted = (xs: readonly string[]): string =>
+  xs.map((x) => JSON.stringify(x)).join(", ");
+
+/** One style value, or why it is none; `key` is how the message names where it stands. */
+function styleOf(
+  key: string,
+  v: unknown,
+): CaseStyle | { readonly why: string } {
+  const style = CASE_STYLES.find((s) => s === v);
+  if (style !== undefined) return style;
+  if (v === "headline")
+    return {
+      why: `"${key}" is "headline", which names no single style: write "chicago-headline" for the Chicago Manual of Style headline style. Other headline variants (APA title case, IEEE, Springer) are not implemented yet, and they disagree with Chicago on words such as With, Between and From`,
+    };
+  if (v === "off")
+    return {
+      why: `"${key}" is "off", which is not a style: write "any" to leave this scope unconstrained, or turn the whole rule off with "tex/heading-case": "off"`,
+    };
+  const shown = v === undefined ? "missing" : JSON.stringify(v);
+  return {
+    why: `"${key}" is ${shown}, which is not a style: one of ${quoted(CASE_STYLES)}`,
+  };
+}
+
+type Levels = Readonly<Partial<Record<HeadingLevel, CaseStyle>>>;
+
+/** The `levels` object: the levels it names, each with its style, or why it is refused. */
+function levelsOf(v: unknown): Levels | { readonly why: string } {
+  if (v === undefined) return {};
+  if (!isRecord(v))
+    return {
+      why: `"levels" is ${JSON.stringify(v)}, not an object such as {"paragraph": "sentence"}`,
+    };
+  return HEADING_LEVELS.reduce<Levels | { readonly why: string }>(
+    (acc, level) => {
+      if ("why" in acc || !(level in v)) return acc;
+      const style = styleOf(`levels.${level}`, v[level]);
+      return typeof style === "string" ? { ...acc, [level]: style } : style;
+    },
+    {},
+  );
+}
+
+/** Whether every scope is `any`: the rule turned off, said in a second way. */
+const asksNothing = (
+  o: HeadingCaseOptions & { readonly levels: Levels },
+): boolean =>
+  o.title === "any" &&
+  o.headings === "any" &&
+  Object.values(o.levels).every((s) => s === "any");
+
+/** ESLint's options for the rule → what it is asked, parsed once. */
+function parseOptions(options: readonly unknown[]): Asked {
+  const [raw] = options;
+  if (raw === undefined) return { kind: "none" };
+  if (!isRecord(raw))
+    return refused(
+      `the options are ${JSON.stringify(raw)}, not an object such as {"title": "chicago-headline", "headings": "chicago-headline"}`,
+    );
+  const title = styleOf("title", fieldOf(raw, "title"));
+  if (typeof title !== "string") return refused(title.why);
+  const headings = styleOf("headings", fieldOf(raw, "headings"));
+  if (typeof headings !== "string") return refused(headings.why);
+  const levels = levelsOf(fieldOf(raw, "levels"));
+  if ("why" in levels) return refused(levels.why);
+  const parsed = { title, headings, levels };
+  return asksNothing(parsed)
+    ? refused(
+        `"title" and "headings" are both "any" and no level asks for more: that is the rule turned off — remove it from "rules", or set it to "off"`,
+      )
+    : { kind: "options", options: parsed };
+}
+
+const MESSAGES: Readonly<Record<string, string>> = {
+  capitalize:
+    "{{where}}: capitalize «{{word}}» → «{{expected}}» — {{why}} (chicago-headline)",
+  lowercase:
+    "{{where}}: lowercase «{{word}}» → «{{expected}}» — {{why}} (chicago-headline)",
+  sentenceFirst:
+    "{{where}}: capitalize the first word, «{{word}}» → «{{expected}}» (sentence; not fixed: a product name written in lowercase looks the same)",
+  noOptions: `tex/heading-case is on with no options, so it judged nothing: give it the styles the venue asks, e.g. ["error", {"title": "chicago-headline", "headings": "chicago-headline"}] (styles: ${quoted(CASE_STYLES)})`,
+};
+
+/** One finding reported where its word stands, with the fix when the judge is sure of it. */
+function report(context: HeadingCaseContext, f: CaseFinding): void {
+  const sc = context.sourceCode;
+  const { fix } = f;
+  context.report({
+    loc: {
+      start: sc.getLocFromIndex(f.at.start),
+      end: sc.getLocFromIndex(f.at.end),
+    },
+    messageId: f.messageId,
+    data: f.data,
+    ...(fix === null
+      ? {}
+      : {
+          fix: (fixer) =>
+            fixer.replaceTextRange([fix.span.start, fix.span.end], fix.text),
+        }),
+  });
+}
+
+/**
+ * A style value, as the schema checks it: a string. Which strings are styles is `parseOptions`'s to
+ * say, so that the refusal can name them (see the header).
+ */
+const STYLE = { type: "string" } as const;
+
+const META: HeadingCaseRule["meta"] = {
+  type: "suggestion",
+  fixable: "code",
+  docs: {
+    description:
+      "the words of the paper's title and of its headings are in the capitalization the venue asks: chicago-headline or sentence",
+    url: DOCS_URL,
+  },
+  schema: [
+    {
+      type: "object",
+      properties: {
+        title: STYLE,
+        headings: STYLE,
+        levels: {
+          type: "object",
+          properties: Object.fromEntries(
+            HEADING_LEVELS.map((level) => [level, STYLE]),
+          ),
+          additionalProperties: false,
+        },
+      },
+      required: ["title", "headings"],
+      additionalProperties: false,
+    },
+  ],
+  messages: MESSAGES,
+};
+
+/** The rule turned on with no options: said once, at the top of the file. */
+function reportNoOptions(context: HeadingCaseContext): void {
+  const start = context.sourceCode.getLocFromIndex(0);
+  context.report({ loc: { start, end: start }, messageId: "noOptions" });
+}
+
+/** One file against the options the rule was given. */
+function judgeFile(
+  context: HeadingCaseContext,
+  deps: HeadingCaseDeps,
+  options: HeadingCaseOptions,
+): void {
+  const sc = context.sourceCode;
+  const src = sc.raw ?? sc.text;
+  judgeHeadingCase(deps.latex.headings(src), options, src).forEach((f) => {
+    report(context, f);
+  });
+}
+
+/** The rule: its options are parsed when ESLint loads it, and a refused one stops the run. */
+export const headingCaseRule = (deps: HeadingCaseDeps): HeadingCaseRule => ({
+  meta: META,
+  create: (context) => {
+    const asked = parseOptions(context.options);
+    switch (asked.kind) {
+      case "refused":
+        throw new Error(asked.reason);
+      case "none":
+        return {
+          root: () => {
+            reportNoOptions(context);
+          },
+        };
+      case "options":
+        return {
+          root: () => {
+            judgeFile(context, deps, asked.options);
+          },
+        };
+    }
+  },
+});

package/src/init.test.ts

@@ -37,6 +37,9 @@ import {
   workflowYaml,
 } from "./init.ts";
 import { runNode } from "../test/support.ts";
+import { nodeFiles } from "./adapters/node/index.ts";
+import { presetsDir } from "./package-dirs.ts";
+import { shippedVenueNames } from "./presets.ts";
 
 const dirs: string[] = [];
 afterEach(() => {
@@ -515,6 +518,25 @@ describe("paperlint init — a first paper", () => {
   });
 });
 
+describe("paperlint init — a first paper named after a venue", () => {
+  it("--paper aisec-2026 is refused before anything is asked, and createPaper is not called", async () => {
+    const made: string[] = [];
+    const asked: string[] = [];
+    const r = await initRun(tree({}), {
+      interactive: true,
+      paper: "aisec-2026",
+      venues: shippedVenueNames({ files: nodeFiles, venuesDir: presetsDir() }),
+      ask: (q) => Promise.resolve((asked.push(q), "")),
+      createPaper: (_root, name) => Promise.resolve((made.push(name), 0)),
+    });
+    expect(made).toEqual([]);
+    expect(asked.filter((q) => /format/.test(q))).toEqual([]);
+    expect(r.out[r.out.indexOf("first paper") + 1]).toBe(
+      '  ✗ no paper created — `aisec-2026` — the paper folder names a venue ("AISec"); venues change on resubmission, so name it after the work\n    if the venue really belongs in the name, rerun `paperlint new` with --allow-venue-name',
+    );
+  });
+});
+
 describe("paperlint init — paths are shown relative to where it was run", () => {
   it("a path that IS the working directory is shown whole, not as an empty string", async () => {
     const root = tree({ "papers/a/paper.md": "# a\n" });

package/src/init.ts

@@ -79,6 +79,7 @@ import {
 } from "#lib/paper-config";
 import { messageOf } from "./domain/text.ts";
 import { isRecord } from "./domain/record.ts";
+import type { NamedVenue } from "./domain/venue-name.ts";
 
 /** How the papers directory was arrived at. Printed, because a guess must not read as a fact. */
 export type PapersHow =
@@ -582,6 +583,11 @@ export interface InitOptions {
     name: string,
     format: PaperFormat,
   ) => Promise<number>;
+  /**
+   * The venues a paper name may not name (`shippedVenueNames`), so `--paper aisec-2026` is refused
+   * before anything is asked. `createPaper` refuses it again whatever this holds.
+   */
+  venues?: readonly NamedVenue[];
   run?: ProgramProbe;
   /**
    * What `paperlint lint` would resolve from the declaration, asked of the CLI's OWN reader. A second
@@ -713,6 +719,7 @@ export async function init(
     paper = null,
     format = null,
     createPaper,
+    venues = [],
     run = spawnSync,
     resolveCliPapers,
     link = (r: string) => linkSkills(r),
@@ -816,7 +823,7 @@ export async function init(
     wanted = answer ? answer : null;
   }
   if (wanted !== null && createPaper) {
-    const problem = nameProblem(wanted);
+    const problem = nameProblem(wanted, venues);
     let fmt: PaperFormat = format ?? DEFAULT_FORMAT;
     if (!problem && format === null && interactive) {
       const f = (
@@ -825,7 +832,7 @@ export async function init(
       if (isFormat(f)) fmt = f;
     }
     if (problem) {
-      log(`  ✗ ${problem} — no paper created`);
+      log(`  ✗ no paper created — ${problem}`);
       paperCode = 2;
     } else {
       const code = await createPaper(papersAbs, wanted, fmt);

package/src/new-paper.harness.mjs

@@ -75,22 +75,23 @@ try {
 
   // ── names ───────────────────────────────────────────────────────────────────────────
   for (const ok of ["demo", "aisec-2026", "v1.2_final"])
-    check(`\`${ok}\` is a valid name`, nameProblem(ok) === null);
+    check(`\`${ok}\` is a valid name`, nameProblem(ok, []) === null);
   for (const bad of ["Demo", "my paper", "a/b", "../x", "", "ÿ"])
-    check(`\`${bad}\` is refused`, typeof nameProblem(bad) === "string");
+    check(`\`${bad}\` is refused`, typeof nameProblem(bad, []) === "string");
   for (const dot of [".template", ".x", ".."])
     check(
       `\`${dot}\` is refused — discovery skips dot-directories, so it would never be linted`,
-      /starting with a dot/.test(nameProblem(dot) ?? ""),
+      /starting with a dot/.test(nameProblem(dot, []) ?? ""),
     );
   check(
     "a refused name creates nothing",
-    newPaper(work, "Bad", "tex").ok === false && !existsSync(join(work, "Bad")),
+    newPaper(work, "Bad", "tex", { venues: [] }).ok === false &&
+      !existsSync(join(work, "Bad")),
   );
 
   // ── a fresh LaTeX paper ─────────────────────────────────────────────────────────────
   const papers = join(work, "papers");
-  const r = newPaper(papers, "demo", "tex");
+  const r = newPaper(papers, "demo", "tex", { venues: [] });
   check(
     "a fresh folder gets the scorecard, a .tex source and paperlint.json, all from the package",
     r.ok &&
@@ -128,7 +129,7 @@ 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");
+  const again = newPaper(papers, "demo", "md", { venues: [] });
   check(
     "🔴 a second run overwrites nothing and adds no second source",
     again.ok &&
@@ -139,7 +140,7 @@ try {
   );
   mkdirSync(join(papers, "old"), { recursive: true });
   writeFileSync(join(papers, "old", "paper.md"), "# Old\n");
-  const migrated = newPaper(papers, "old", "tex");
+  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 &&
@@ -157,7 +158,7 @@ try {
   writeFileSync(join(papers, "afile"), "x");
   check(
     "a name taken by a FILE is refused, not written through",
-    newPaper(papers, "afile", "tex").ok === false,
+    newPaper(papers, "afile", "tex", { venues: [] }).ok === false,
   );
 
   // ── the project's template wins, file by file ─────────────────────────────────────────
@@ -166,7 +167,7 @@ try {
     join(papers, OVERRIDE_DIR, STATUS_FILE),
     "---\n---\n# House scorecard for {{name}}\n",
   );
-  const own = newPaper(papers, "house", "md");
+  const own = newPaper(papers, "house", "md", { 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(
@@ -180,6 +181,7 @@ try {
 
   // ── a missing template is a broken install, not an empty file ─────────────────────────
   const broken = newPaper(join(work, "b"), "x", "tex", {
+    venues: [],
     packageTemplates: join(work, "no-such-dir"),
   });
   check(

package/src/new-paper.test.ts

@@ -6,6 +6,7 @@
 import {
   mkdirSync,
   mkdtempSync,
+  readdirSync,
   readFileSync,
   realpathSync,
   rmSync,
@@ -40,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");
+    const r = newPaper(papers, "demo", "tex", { venues: [] });
     expect(r.ok && r.files.find((f) => f.file === "paperlint.json")).toEqual({
       file: "paperlint.json",
       status: "created",
@@ -58,6 +59,7 @@ describe("paperlint new — paperlint.json", () => {
         rules: null,
         identity: null,
         talk: null,
+        submission: null,
       },
     });
   });
@@ -69,7 +71,7 @@ describe("paperlint new — paperlint.json", () => {
       join(papers, OVERRIDE_DIR, "paperlint.json"),
       '{ "extends": "paperlint:aisec", "kind": "research" }\n',
     );
-    const r = newPaper(papers, "house", "tex");
+    const r = newPaper(papers, "house", "tex", { venues: [] });
     expect(r.ok && r.files.find((f) => f.file === "paperlint.json")?.from).toBe(
       "project",
     );
@@ -86,7 +88,7 @@ describe("paperlint new — paperlint.json", () => {
       join(papers, "p", "paperlint.json"),
       '{"extends":"paperlint:aisec"}',
     );
-    const r = newPaper(papers, "p", "tex");
+    const r = newPaper(papers, "p", "tex", { venues: [] });
     expect(
       r.ok && r.files.find((f) => f.file === "paperlint.json")?.status,
     ).toBe("kept");
@@ -103,7 +105,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");
+    newPaper(join(root, "papers"), "demo", "tex", { venues: [] });
     if (extendsValue !== null)
       writeFileSync(
         join(root, "papers", "demo", "paperlint.json"),
@@ -140,7 +142,11 @@ describe("paperlint lint — a paper with no venue preset chosen", () => {
 });
 
 /** `paperlint new <args>` in a fresh project (not a terminal: vitest's stdin is not a TTY). */
-async function newIn(args: string[], files: Record<string, string> = {}) {
+async function newIn(
+  args: string[],
+  files: Record<string, string> = {},
+  name = "demo",
+) {
   const root = tmp();
   const all = {
     "package.json": JSON.stringify({ name: "c", private: true }),
@@ -152,12 +158,12 @@ async function newIn(args: string[], files: Record<string, string> = {}) {
   }
   const out: string[] = [];
   const err: string[] = [];
-  const code = await run(["new", "demo", ...args], {
+  const code = await run(["new", name, ...args], {
     cwd: root,
     log: (s: string) => out.push(s),
     err: (s: string) => err.push(s),
   });
-  const dir = join(root, "papers", "demo");
+  const dir = join(root, "papers", name);
   return {
     code,
     out: out.join("\n"),
@@ -169,6 +175,7 @@ async function newIn(args: string[], files: Record<string, string> = {}) {
 
 describe("paperlint new --venue / --kind", () => {
   const PRESET = `{
+  "type": "venue", "name": "my-workshop", "url": "https://example.org/cfp",
   "extends": "paperlint:acm-sigconf",
   "format": { "kinds": { "short": { "body_pages_max": 4 } } },
 }
@@ -199,6 +206,7 @@ describe("paperlint new --venue / --kind", () => {
     for (const template of [undefined, "\\documentclass[a]{}"]) {
       const r = await newIn(["--venue", "./venues/bare.jsonc"], {
         "venues/bare.jsonc": JSON.stringify({
+          type: "family",
           ...(template === undefined ? {} : { template }),
           tex: { packages: { x: ["x.sty"] } },
         }),
@@ -224,7 +232,9 @@ describe("paperlint new --venue / --kind", () => {
     expect(r.out).not.toMatch(/pdf\/profile/);
     expect(r.code).toBe(0);
   });
+});
 
+describe("paperlint new --venue — a venue it cannot use", () => {
   it("an unknown venue exits 2, lists the shipped presets, and creates nothing", async () => {
     const r = await newIn(["--venue", "icse"]);
     expect(r.code).toBe(2);
@@ -240,7 +250,7 @@ describe("paperlint new --venue / --kind — refusals and defaults", () => {
     [
       "a kind the preset lacks",
       ["--venue", "agenticdev", "--kind", "long"],
-      /`agenticdev` has no kind `long`; its kinds: short, full, demo/,
+      /`AgenticDev` has no kind `long`; its kinds: short, full, demo/,
     ],
     ["a kind without a venue", ["--kind", "short"], /--kind needs --venue/],
     [
@@ -264,7 +274,7 @@ describe("paperlint new --venue / --kind — refusals and defaults", () => {
     const r = await newIn(["--venue", "agenticdev"]);
     expect(r.settings()).toEqual({ extends: "paperlint:agenticdev" });
     expect(r.out).toMatch(
-      /kind: not set — `agenticdev` sets a page limit per kind/,
+      /kind: not set — `AgenticDev` sets a page limit per kind/,
     );
     expect(r.out).toMatch(/pdf\/profile/);
   });
@@ -286,6 +296,117 @@ describe("paperlint new --venue / --kind — refusals and defaults", () => {
   });
 });
 
+describe("paperlint new — a name that names a venue is refused", () => {
+  it.each<[string, string, string[], string]>([
+    [
+      "a venue's label, with the work's name left to suggest",
+      "aisec-agent-drift",
+      [],
+      '`aisec-agent-drift` — the paper folder names a venue ("AISec"); venues change on resubmission, so name it after the work (e.g. "agent-drift")',
+    ],
+    [
+      "nothing but a year left: no example",
+      "aisec-2026",
+      [],
+      '`aisec-2026` — the paper folder names a venue ("AISec"); venues change on resubmission, so name it after the work',
+    ],
+    [
+      "its own venue too: right today, stale on the next resubmission",
+      "aidc-2026",
+      ["--venue", "aidc"],
+      '`aidc-2026` — the paper folder names a venue ("AIDC"); venues change on resubmission, so name it after the work',
+    ],
+    [
+      "by an alias, glued to a year",
+      "acsac2026-rules",
+      [],
+      '`acsac2026-rules` — the paper folder names a venue ("ACSAC"); venues change on resubmission, so name it after the work',
+    ],
+    [
+      "two venues",
+      "realm-aisec-rules",
+      [],
+      '`realm-aisec-rules` — the paper folder names a venue ("AISec", "REALM"); venues change on resubmission, so name it after the work (e.g. "rules")',
+    ],
+  ])("%s: exit 2, nothing written", async (_, name, args, reason) => {
+    const r = await newIn(args, {}, name);
+    expect(r.code).toBe(2);
+    expect(r.out).toBe(
+      `  ✗ ${reason}\n    if the venue really belongs in the name, rerun \`paperlint new\` with --allow-venue-name`,
+    );
+    expect(existsSync(r.dir)).toBe(false);
+  });
+
+  it("an existing folder that names a venue gets no missing files either", async () => {
+    const r = await newIn(
+      [],
+      { "papers/aisec-2026/paper.tex": "x" },
+      "aisec-2026",
+    );
+    expect(r.code).toBe(2);
+    expect(readdirSync(r.dir)).toEqual(["paper.tex"]);
+  });
+
+  it.each(["agent-rule-drift", "overrealm-realms"])(
+    "%s names no venue: created, as before",
+    async (name) => {
+      const r = await newIn([], {}, name);
+      expect(r.out).not.toMatch(/names a venue/);
+      expect(existsSync(join(r.dir, "PIPELINE-STATUS.md"))).toBe(true);
+      expect(r.code).toBe(0);
+    },
+  );
+});
+
+describe("paperlint new --allow-venue-name", () => {
+  it("the folder is created as any other, and nothing is said about the venue", async () => {
+    const r = await newIn(["--allow-venue-name"], {}, "realm-of-agents");
+    expect(r.code).toBe(0);
+    expect(r.out).not.toMatch(/venue really belongs|names a venue/);
+    expect(readdirSync(r.dir).sort()).toEqual([
+      "PIPELINE-STATUS.md",
+      "paper.tex",
+      "paperlint.json",
+    ]);
+  });
+
+  it.each<{
+    readonly what: string;
+    readonly name: string;
+    readonly args: readonly string[];
+    readonly files: Record<string, string>;
+    readonly says: RegExp;
+  }>([
+    {
+      what: "an invalid name",
+      name: "Realm",
+      args: [],
+      files: {},
+      says: /may hold only a-z/,
+    },
+    {
+      what: "an unknown preset",
+      name: "realm-of-agents",
+      args: ["--venue", "nope"],
+      files: {},
+      says: /no such venue preset/,
+    },
+    {
+      what: "an existing paperlint.json with --venue",
+      name: "realm-of-agents",
+      args: ["--venue", "aisec"],
+      files: {
+        "papers/realm-of-agents/paperlint.json": '{ "extends": null }\n',
+      },
+      says: /already exists and is never overwritten/,
+    },
+  ])("skips no other refusal: $what", async ({ name, args, files, says }) => {
+    const r = await newIn(["--allow-venue-name", ...args], files, name);
+    expect(r.code).toBe(2);
+    expect(`${r.out}\n${r.err}`).toMatch(says);
+  });
+});
+
 describe("chooseVenue — on a terminal", () => {
   const at = (answers: string[]) => {
     const asked: string[] = [];
@@ -340,6 +461,7 @@ describe("a project's own template", () => {
     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", {
+      venues: [],
       venue: { extends: "paperlint:aisec", kind: null },
     });
     expect(r).toEqual({
@@ -353,7 +475,10 @@ describe("a project's own template", () => {
     const papers = join(tmp(), "papers");
     mkdirSync(join(papers, OVERRIDE_DIR), { recursive: true });
     writeFileSync(join(papers, OVERRIDE_DIR, "paperlint.json"), "{}\n");
-    const lines = reportNewPaper(newPaper(papers, "p", "tex"), (p) => p);
+    const lines = reportNewPaper(
+      newPaper(papers, "p", "tex", { venues: [] }),
+      (p) => p,
+    );
     expect(lines).toContain(
       "      + paperlint.json  (from the project's .template/ template)",
     );