paperlint 6.2.3 → 6.3.0

package/src/domain/venue-name.test.ts

@@ -0,0 +1,115 @@
+import { describe, expect, it } from "vitest";
+import { cpSync, mkdtempSync, realpathSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { nodeFiles } from "../adapters/node/index.ts";
+import { presetsDir } from "../package-dirs.ts";
+import { shippedVenueNames } from "../presets.ts";
+import {
+  nameTokens,
+  venuesNamedBy,
+  withoutVenues,
+  type NamedVenue,
+} from "./venue-name.ts";
+
+describe("nameTokens — a name as the words it is made of", () => {
+  it.each<[string, readonly string[]]>([
+    ["aisec-2026", ["aisec", "2026"]],
+    ["my_paper.v2", ["my", "paper", "v", "2"]],
+    ["ACM CCS", ["acm", "ccs"]],
+    ["acm-sigconf", ["acm", "sigconf"]],
+    // Letters and digits glued together are two words: `aisec2026` names AISec as much as `aisec-2026`.
+    ["aisec2026", ["aisec", "2026"]],
+    ["--x--", ["x"]],
+    ["", []],
+  ])("%s", (name, want) => {
+    expect(nameTokens(name)).toEqual(want);
+  });
+});
+
+/**
+ * The venues are the SHIPPED presets, read through the one source of venue names
+ * (`shippedVenueNames`) — never a list of names written here. A case below depends on what a preset
+ * says (`aidc`'s alias ACSAC, `aisec`'s ACM CCS); a preset edit that changes it shows here.
+ */
+const VENUES: readonly NamedVenue[] = shippedVenueNames({
+  files: nodeFiles,
+  venuesDir: presetsDir(),
+});
+
+describe("venuesNamedBy — which venues a folder name names", () => {
+  it.each<[string, string, readonly { venue: string; name: string }[]]>([
+    ["the label", "aisec-2026", [{ venue: "aisec", name: "aisec" }]],
+    ["an alias", "acsac-2026", [{ venue: "aidc", name: "ACSAC" }]],
+    [
+      "a two-word alias, as two tokens in a row",
+      "acm-ccs-agents",
+      [{ venue: "aisec", name: "ACM CCS" }],
+    ],
+    ["the two words of an alias apart are not it", "acm-agents-ccs", []],
+    ["glued to a year", "realm2026", [{ venue: "realm", name: "realm" }]],
+    [
+      "two venues, each once, in the order they are listed",
+      "realm-aisec-aisec",
+      [
+        { venue: "aisec", name: "aisec" },
+        { venue: "realm", name: "realm" },
+      ],
+    ],
+    // Whole tokens only: a venue's name inside another word is that other word.
+    ["inside a word: overrealm", "overrealm-study", []],
+    ["inside a word: realms", "realms-of-agents", []],
+    ["inside a word: aisecure", "aisecure", []],
+    ["no venue at all", "agent-rule-drift", []],
+  ])("%s: %s", (_, folder, want) => {
+    expect(venuesNamedBy(folder, VENUES)).toEqual(want);
+  });
+
+  it("a name that is also the paper's own is not reported, whichever venue declares it", () => {
+    // A paper at a venue whose own chain also says "ACM CCS" (two workshops of one conference).
+    expect(venuesNamedBy("ccs-acm-ccs", VENUES, ["ACM CCS"])).toEqual([]);
+    expect(venuesNamedBy("aisec-2026", VENUES, ["aisec"])).toEqual([]);
+  });
+
+  it("own names compare by their words, not their spelling", () => {
+    expect(venuesNamedBy("acsac-2026", VENUES, ["ACSAC"])).toEqual([]);
+    expect(venuesNamedBy("acm-ccs-x", VENUES, ["acm-ccs"])).toEqual([]);
+  });
+
+  it("a preset whose alias has no words names nothing by it", () => {
+    // A fixture preset in a copy of the presets directory: alias "—" has no letter or digit, and a
+    // name of no words must not stand everywhere.
+    const dir = realpathSync(
+      mkdtempSync(join(tmpdir(), "paperlint-venue-name-")),
+    );
+    cpSync(presetsDir(), dir, { recursive: true });
+    writeFileSync(
+      join(dir, "dash.jsonc"),
+      JSON.stringify({ extends: "paperlint:acm-sigconf", aliases: ["—"] }),
+    );
+    const venues = shippedVenueNames({ files: nodeFiles, venuesDir: dir });
+    expect(venues.find((v) => v.label === "dash")?.aliases).toContain("—");
+    expect(venuesNamedBy("agent-rule-drift", venues)).toEqual([]);
+    expect(venuesNamedBy("dash-2026", venues)).toEqual([
+      { venue: "dash", name: "dash" },
+    ]);
+  });
+});
+
+describe("withoutVenues — the name with its venues taken out, when that is a name for the work", () => {
+  it.each<[string, string | null]>([
+    ["aisec-agent-drift", "agent-drift"],
+    ["agent_drift.aisec", "agent-drift"],
+    ["acm-ccs-agents", "agents"],
+    ["realm-rules-aisec-2026", "rules-2026"],
+    ["--aisec--agents", "agents"],
+    // Only numbers left: `2026` names no work.
+    ["aisec-2026", null],
+    ["aisec", null],
+    // A venue glued to other words in one part is not cleanly taken out.
+    ["aisec2026-agents", null],
+    ["agent-rule-drift", "agent-rule-drift"],
+  ])("%s → %s", (name, want) => {
+    expect(withoutVenues(name, VENUES)).toBe(want);
+  });
+});

package/src/domain/venue-name.ts

@@ -0,0 +1,129 @@
+/**
+ * WHICH VENUE A NAME NAMES — a paper folder's name read as words, against what each venue is
+ * called (a preset's label and its `aliases`).
+ *
+ * A name is compared by its WORDS, never by substring: `overrealm` and `realms` do not name REALM,
+ * `aisec-2026` and `aisec2026` name AISec. A word is a run of letters or a run of digits; anything
+ * else separates words, and case is ignored. A venue name of several words (`ACM CCS`) names the
+ * venue only when those words stand in a row.
+ *
+ * Read by `paper/folder-venue-leftover` (a folder naming a venue other than the one the paper
+ * extends) and by `paperlint new`, which refuses a new folder naming any venue at all.
+ */
+
+/** A venue as names know it: the word for it in messages, and the other names it goes by. */
+export interface NamedVenue {
+  readonly label: string;
+  readonly aliases: readonly string[];
+}
+
+/** A venue a name names, and which of its names it used, as the venue spells it. */
+export interface NamedIn {
+  readonly venue: string;
+  readonly name: string;
+}
+
+/** A name's words, lowercased: runs of letters and runs of digits; everything else separates. */
+export const nameTokens = (name: string): readonly string[] =>
+  name.toLowerCase().match(/\p{L}+|\p{N}+/gu) ?? [];
+
+/** Where `words` stand in a row in `tokens`: the index of each first word. None for empty `words`. */
+const placesIn = (
+  tokens: readonly string[],
+  words: readonly string[],
+): readonly number[] =>
+  words.length === 0
+    ? []
+    : tokens.flatMap((_, i) =>
+        words.every((w, j) => tokens[i + j] === w) ? [i] : [],
+      );
+
+/** A name's words as one key, to compare two spellings of a name. */
+const keyOf = (name: string): string => nameTokens(name).join(" ");
+
+/** Every name of every venue that is not one of `own`, with its words. */
+const candidates = (
+  venues: readonly NamedVenue[],
+  own: readonly string[],
+): readonly (NamedIn & { readonly words: readonly string[] })[] => {
+  const ownKeys = new Set(own.map(keyOf));
+  return venues.flatMap((v) =>
+    [v.label, ...v.aliases]
+      .filter((n) => !ownKeys.has(keyOf(n)))
+      .map((name) => ({ venue: v.label, name, words: nameTokens(name) })),
+  );
+};
+
+/**
+ * Each venue `name` names by one of its names (the label first, then its aliases), once per venue,
+ * in the order `venues` lists them. A name that is also one of `own` — the paper's own venue's,
+ * compared by words — is never counted: two workshops of one conference share its name.
+ */
+export function venuesNamedBy(
+  name: string,
+  venues: readonly NamedVenue[],
+  own: readonly string[] = [],
+): readonly NamedIn[] {
+  const tokens = nameTokens(name);
+  const hits = candidates(venues, own).filter(
+    (c) => placesIn(tokens, c.words).length > 0,
+  );
+  return hits
+    .filter((c, i) => hits.findIndex((d) => d.venue === c.venue) === i)
+    .map(({ venue, name: n }) => ({ venue, name: n }));
+}
+
+/** A part of a name between separators, with the indices of its words in the whole name's words. */
+interface Part {
+  readonly text: string;
+  readonly at: readonly number[];
+}
+
+/** A name's hyphen-, underscore- or dot-separated parts, each with where its words stand. */
+const partsOf = (name: string): readonly Part[] =>
+  name
+    .split(/[^\p{L}\p{N}]+/u)
+    .filter((text) => text.length > 0)
+    .reduce<{ readonly next: number; readonly out: readonly Part[] }>(
+      (acc, text) => {
+        const n = nameTokens(text).length;
+        const at = Array.from({ length: n }, (_, j) => acc.next + j);
+        return { next: acc.next + n, out: [...acc.out, { text, at }] };
+      },
+      { next: 0, out: [] },
+    ).out;
+
+/** The indices of the words of `name` that belong to a venue's name. */
+const venueWordsIn = (
+  name: string,
+  venues: readonly NamedVenue[],
+): ReadonlySet<number> => {
+  const tokens = nameTokens(name);
+  return new Set(
+    candidates(venues, []).flatMap((c) =>
+      placesIn(tokens, c.words).flatMap((at) => c.words.map((_, j) => at + j)),
+    ),
+  );
+};
+
+/**
+ * `name` with every venue name taken out, as a name for the work — or null when that is not clean:
+ * a venue's words glued to other words in one hyphen-, underscore- or dot-separated part
+ * (`aisec2026`), or nothing but numbers left (`aisec-2026` → `2026` names no work). The parts left
+ * are joined by `-`.
+ */
+export function withoutVenues(
+  name: string,
+  venues: readonly NamedVenue[],
+): string | null {
+  const venueWord = venueWordsIn(name, venues);
+  const inVenue = (p: Part): number =>
+    p.at.filter((i) => venueWord.has(i)).length;
+  const parts = partsOf(name);
+  if (parts.some((p) => inVenue(p) > 0 && inVenue(p) < p.at.length))
+    return null;
+  const left = parts.filter((p) => inVenue(p) === 0);
+  return left.some((p) => /\p{L}/u.test(p.text))
+    ? left.map((p) => p.text).join("-")
+    : null;
+}

package/src/folder-venue-rule.test.ts

@@ -0,0 +1,182 @@
+/**
+ * `paper/folder-venue-leftover` (`src/folder-venue-rule.ts`) on papers held in memory beside the
+ * SHIPPED presets, so the venue names come from the registry a user gets. Both halves: a folder
+ * named after another venue than the paper's `extends` is reported once, on the scorecard's first
+ * line; a folder named after the paper's own venue, or after no venue, is not.
+ */
+import { readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { memoryFiles } from "./adapters/memory/index.ts";
+import { presetsDir } from "./package-dirs.ts";
+import {
+  FOLDER_VENUE_RULE_LEVELS,
+  folderVenueRules,
+} from "./folder-venue-rule.ts";
+
+const VENUES = presetsDir();
+const PAPERS = "/work/papers";
+const shipped = Object.fromEntries(
+  readdirSync(VENUES)
+    .filter((f) => f.endsWith(".jsonc") || f.endsWith(".json"))
+    .map((f) => [join(VENUES, f), readFileSync(join(VENUES, f))]),
+);
+
+interface Reported {
+  readonly messageId: string;
+  readonly message: string;
+  readonly line: number;
+}
+
+/**
+ * The rule over one paper folder's file, the way ESLint runs it: `create`, then `root`. `settings`
+ * is the paper's paperlint.json (absent: no file); `extra` more files, by absolute path.
+ */
+function lint(
+  folder: string,
+  settings: object | undefined,
+  {
+    file = "PIPELINE-STATUS.md",
+    extra = {},
+  }: { file?: string; extra?: Record<string, string> } = {},
+): Reported[] {
+  const dir = `${PAPERS}/${folder}`;
+  const files = memoryFiles({
+    ...shipped,
+    ...(settings === undefined
+      ? {}
+      : { [`${dir}/paperlint.json`]: JSON.stringify(settings) }),
+    ...extra,
+  });
+  const rule = folderVenueRules({ files, venuesDir: VENUES })[
+    "folder-venue-leftover"
+  ];
+  const out: Reported[] = [];
+  const visitor = rule.create({
+    filename: `${dir}/${file}`,
+    sourceCode: { getLocFromIndex: () => ({ line: 1, column: 0 }) },
+    report: (d) => {
+      const template = rule.meta.messages[d.messageId] ?? "";
+      const message = Object.entries(d.data).reduce(
+        (m, [k, v]) => m.split(`{{${k}}}`).join(String(v)),
+        template,
+      );
+      out.push({ messageId: d.messageId, message, line: d.loc.start.line });
+    },
+  });
+  visitor.root?.();
+  return out;
+}
+
+const AIDC = { extends: "paperlint:aidc", kind: "regular" };
+
+describe("paper/folder-venue-leftover — the folder names another venue", () => {
+  it("a folder named after the venue the paper left is reported, naming both and the cure", () => {
+    expect(lint("aisec-2026", AIDC)).toEqual([
+      {
+        messageId: "leftover",
+        line: 1,
+        message:
+          "the folder name «aisec-2026» names the venue aisec, and this paper extends aidc — the name went stale when the venue changed, and venues change on every resubmission. Name the folder after the work (what the paper shows), not the venue",
+      },
+    ]);
+  });
+
+  it("a venue named by an alias says which alias", () => {
+    expect(
+      lint("acm-ccs-agents", AIDC).map(
+        (r) => /names the venue (.*?), and/u.exec(r.message)?.[1],
+      ),
+    ).toEqual(["aisec («ACM CCS»)"]);
+  });
+
+  it("two other venues are two findings", () => {
+    expect(
+      lint("realm-then-aisec", AIDC).map(
+        (r) => /names the venue (\w+)/u.exec(r.message)?.[1],
+      ),
+    ).toEqual(["aisec", "realm"]);
+  });
+
+  it("a project's own preset is judged like a shipped one: its label and aliases are its own", () => {
+    const extra = {
+      [`${PAPERS}/aidc-redux/venue.jsonc`]: JSON.stringify({
+        extends: "paperlint:aisec",
+        name: "AISec 2027",
+      }),
+    };
+    // Its chain is AISec's, so aisec is its own; aidc is another venue.
+    expect(
+      lint(
+        "aidc-redux",
+        { extends: "./venue.jsonc", kind: "short" },
+        { extra },
+      ),
+    ).toHaveLength(1);
+    expect(
+      lint(
+        "aisec-redux",
+        { extends: "./venue.jsonc", kind: "short" },
+        {
+          extra: {
+            [`${PAPERS}/aisec-redux/venue.jsonc`]: JSON.stringify({
+              extends: "paperlint:aisec",
+            }),
+          },
+        },
+      ),
+    ).toEqual([]);
+  });
+});
+
+describe("paper/folder-venue-leftover — silent", () => {
+  it.each<[string, string, object | undefined]>([
+    [
+      "the folder names the paper's own venue",
+      "agenticdev-2026",
+      { extends: "paperlint:agenticdev", kind: "short" },
+    ],
+    ["by its alias", "acsac-2026", AIDC],
+    ["the folder names no venue", "agent-rule-drift", AIDC],
+    // Whole words only: REALM is not inside these.
+    ["a venue's name inside another word", "overrealm-realms", AIDC],
+    ["no paperlint.json: no venue to compare with", "aisec-2026", undefined],
+    ["no extends yet", "aisec-2026", { extends: null }],
+    [
+      "an extends that does not resolve — pdf/profile says so",
+      "aisec-2026",
+      { extends: "paperlint:nope" },
+    ],
+  ])("%s", (_, folder, settings) => {
+    expect(lint(folder, settings)).toEqual([]);
+  });
+
+  it("a paperlint.json that does not parse — pdf/profile says so", () => {
+    expect(
+      lint("aisec-2026", undefined, {
+        extra: { [`${PAPERS}/aisec-2026/paperlint.json`]: "{ not json" },
+      }),
+    ).toEqual([]);
+  });
+
+  it("judged once per paper, on PIPELINE-STATUS.md only", () => {
+    expect(lint("aisec-2026", AIDC, { file: "paper.md" })).toEqual([]);
+  });
+
+  it("a paper on a bare template family declares no venue: a venue in its folder may be its own", () => {
+    // The accepted ACSAC papers in fixtures/accepted-papers/ are exactly this: `…-acsac24` folders
+    // extending ieee-conference, while `aidc` names ACSAC, its parent conference, as an alias.
+    expect(
+      lint("secure-acsac24", { extends: "paperlint:ieee-conference" }),
+    ).toEqual([]);
+    expect(lint("aisec-2026", { extends: "paperlint:acm-sigconf" })).toEqual(
+      [],
+    );
+  });
+});
+
+it("the level: a warning — a rename is the author's call", () => {
+  expect(FOLDER_VENUE_RULE_LEVELS).toEqual({
+    "paper/folder-venue-leftover": "warn",
+  });
+});

package/src/folder-venue-rule.ts

@@ -0,0 +1,141 @@
+/**
+ * `paper/folder-venue-leftover` — a paper folder named after a venue the paper no longer targets.
+ *
+ * A folder named `aisec-2026` reads as "the AISec paper" for as long as it exists; once the paper is
+ * rejected and goes to another venue, the name is wrong and nothing says so. paperlint already knows
+ * the venue a paper targets — its `paperlint.json` `extends` — and the names of every venue it ships
+ * a preset for, so the stale case costs one comparison. The sibling of `tex/venue-leftover`, which
+ * does the same for the text of the paper.
+ *
+ * ── WHAT IT READS ────────────────────────────────────────────────────────────────
+ * The folder's name, as the path module gives it (the directory of the linted file), its words
+ * against each shipped venue's label and `aliases` (`src/domain/venue-name.ts`). The venues are
+ * `otherVenues` — the presets not on this paper's own chain, the same list `tex/venue-leftover`
+ * reads — and the paper's own label and aliases are never reported.
+ *
+ * ── WHICH FILE IT REPORTS ON ─────────────────────────────────────────────────────
+ * The folder itself is not a file ESLint lints. `PIPELINE-STATUS.md` is: every paper folder has one
+ * (`paperlint lint` requires it, `paperlint new` writes it), whatever the paper's source format, so
+ * the finding is made once per paper, on that file's first line, where a disable directive can
+ * also sit.
+ *
+ * ── WHO SPEAKS WHEN THERE IS NOTHING TO JUDGE ───────────────────────────────────
+ * No `paperlint.json`, no `extends`, or one that does not resolve: silent. With no venue chosen
+ * there is no "other" venue, and `pdf/measured` and `pdf/profile` already speak about the rest. An
+ * `extends` that names only a template family is silent too (`isFamily`).
+ */
+import { basename, dirname } from "node:path";
+import { venuesNamedBy, type NamedIn } from "./domain/venue-name.ts";
+import { paperPreset, type Preset } from "./presets.ts";
+import { otherVenues, type OtherVenue } from "./tex-venue-rules.ts";
+import type { Finding, VenueRuleDeps } from "./venue-rules.ts";
+
+/** The file the rule reports on: one per paper folder. */
+const STATUS_FILE = "PIPELINE-STATUS.md";
+
+/** The slice of ESLint's rule context this rule uses: the file, its first line, and `report`. */
+export interface FolderRuleContext {
+  readonly filename: string;
+  readonly sourceCode: {
+    getLocFromIndex(index: number): Readonly<{ line: number; column: number }>;
+  };
+  report(d: {
+    readonly loc: {
+      readonly start: { line: number; column: number };
+      readonly end: { line: number; column: number };
+    };
+    readonly messageId: string;
+    readonly data: Readonly<Record<string, string | number>>;
+  }): void;
+}
+
+export interface FolderRuleModule {
+  readonly meta: {
+    readonly type: "suggestion";
+    readonly docs: { readonly description: string; readonly url: string };
+    readonly schema: readonly object[];
+    readonly messages: Readonly<Record<string, string>>;
+  };
+  create(context: FolderRuleContext): { root?: () => void };
+}
+
+/** A venue as the message names it: its label, and the alias when the folder used another name. */
+const shown = (n: NamedIn): string =>
+  n.name.toLowerCase() === n.venue.toLowerCase()
+    ? n.venue
+    : `${n.venue} («${n.name}»)`;
+
+/**
+ * Each other venue the folder name names, as a finding. Pure: the folder's name, the paper's
+ * resolved preset, and the other shipped venues.
+ */
+export function judgeFolder(
+  folder: string,
+  preset: Pick<Preset, "label" | "aliases">,
+  others: readonly OtherVenue[],
+): readonly Finding[] {
+  return venuesNamedBy(folder, others, [preset.label, ...preset.aliases]).map(
+    (n) => ({
+      messageId: "leftover",
+      data: { folder, other: shown(n), venue: preset.label },
+    }),
+  );
+}
+
+/**
+ * A template family (`acm-sigconf`, `ieee-conference`): a preset with no kinds, which a paper for a
+ * venue paperlint has no preset for extends directly (`src/venue-rules.ts` reads it the same way).
+ * Such a paper declares a format, not a venue, so a venue in its folder name may be its own: the
+ * accepted ACSAC papers in `fixtures/accepted-papers/` extend `ieee-conference` from folders named
+ * `…-acsac24`, and ACSAC is the parent conference `aidc` names as an alias.
+ */
+const isFamily = (preset: Preset): boolean => preset.format.kinds.size === 0;
+
+/** The findings for the paper folder `dir`; none when it has no resolved venue, or only a family. */
+function findingsFor(dir: string, deps: VenueRuleDeps): readonly Finding[] {
+  const p = paperPreset(dir, deps);
+  if (p.kind !== "resolved" || isFamily(p.preset)) return [];
+  const others = otherVenues(p.preset, deps);
+  return judgeFolder(basename(dir), p.preset, others);
+}
+
+const META: FolderRuleModule["meta"] = {
+  type: "suggestion",
+  docs: {
+    description:
+      "the paper folder's name names a shipped venue other than the one the paper extends — a name left from an earlier submission",
+    url: "https://github.com/zernie/paperlint/blob/main/docs/rules/paper/folder-venue-leftover.md",
+  },
+  schema: [],
+  messages: {
+    leftover:
+      "the folder name «{{folder}}» names the venue {{other}}, and this paper extends {{venue}} — the name went stale when the venue changed, and venues change on every resubmission. Name the folder after the work (what the paper shows), not the venue",
+  },
+};
+
+/** The rule, reading the paper's settings and the shipped presets through `deps`. */
+export function folderVenueRules(
+  deps: VenueRuleDeps,
+): Readonly<Record<"folder-venue-leftover", FolderRuleModule>> {
+  return {
+    "folder-venue-leftover": {
+      meta: META,
+      create(context) {
+        if (basename(context.filename) !== STATUS_FILE) return {};
+        return {
+          root() {
+            const at = context.sourceCode.getLocFromIndex(0);
+            findingsFor(dirname(context.filename), deps).forEach((f) => {
+              context.report({ loc: { start: at, end: at }, ...f });
+            });
+          },
+        };
+      },
+    },
+  };
+}
+
+/** The level it is on at in paperlint's own config, for every paper's `PIPELINE-STATUS.md`. */
+export const FOLDER_VENUE_RULE_LEVELS: Readonly<
+  Record<"paper/folder-venue-leftover", "warn">
+> = { "paper/folder-venue-leftover": "warn" };

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);