paperlint 6.2.3 → 6.3.0

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"),
@@ -286,6 +292,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 +457,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 +471,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)",
     );

package/src/new-paper.ts

@@ -27,6 +27,11 @@ import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { CONFIG_FILE } from "#lib/paper-config";
 import { isRecord } from "./domain/record.ts";
+import {
+  venuesNamedBy,
+  withoutVenues,
+  type NamedVenue,
+} from "./domain/venue-name.ts";
 
 export type PaperFormat = "tex" | "md";
 export const FORMATS: readonly PaperFormat[] = ["tex", "md"];
@@ -50,6 +55,9 @@ export const SOURCE_FILE: Readonly<Record<PaperFormat, string>> = {
   md: "paper.md",
 };
 
+/** The flag that lets `paperlint new` create a folder whose name names a venue. */
+export const ALLOW_VENUE_NAME = "--allow-venue-name";
+
 export const isFormat = (v: unknown): v is PaperFormat =>
   FORMATS.some((f) => f === v);
 
@@ -57,13 +65,30 @@ export const isFormat = (v: unknown): v is PaperFormat =>
  * Why a name is refused, or null. `[a-z0-9._-]+` is the charset; a LEADING dot is refused on top
  * of it, because discovery skips dot-directories — a paper named `.x` would be created and then
  * never linted, which is worse than a refusal.
+ *
+ * A name that names a venue — one of `venues`' names as whole words (`aisec-2026`) — is refused
+ * too, the paper's own venue included: a paper that is rejected goes to another venue and keeps its
+ * folder, so the name goes stale, and nothing at creation time knows the paper will not move. A
+ * folder made by hand, and one made with `--allow-venue-name` (a whole word can be the work's own:
+ * a paper about realms), is what `paper/folder-venue-leftover` judges once the venue changes. The
+ * flag passes no `venues`, so it skips this refusal and no other.
  */
-export function nameProblem(name: string): string | null {
+export function nameProblem(
+  name: string,
+  venues: readonly NamedVenue[],
+): string | null {
   if (!/^[a-z0-9._-]+$/.test(name))
     return `\`${name}\` — a paper name may hold only a-z, 0-9, dot, underscore and hyphen (it becomes a path and a shell argument)`;
   if (name.startsWith("."))
     return `\`${name}\` — a name starting with a dot is skipped by paper discovery, so it would never be linted`;
-  return null;
+  const named = venuesNamedBy(name, venues);
+  if (named.length === 0) return null;
+  const which = named.map((n) => `"${n.name}"`).join(", ");
+  const instead = withoutVenues(name, venues);
+  return [
+    `\`${name}\` — the paper folder names a venue (${which}); venues change on resubmission, so name it after the work${instead === null ? "" : ` (e.g. "${instead}")`}`,
+    `    if the venue really belongs in the name, rerun \`paperlint new\` with ${ALLOW_VENUE_NAME}`,
+  ].join("\n");
 }
 
 export interface FileOutcome {
@@ -180,17 +205,23 @@ function fromTemplate(
     : edited;
 }
 
+/** What `newPaper` is told besides the name: the venues a name may not name, and what to write. */
+export interface NewPaperOptions {
+  readonly packageTemplates?: string;
+  readonly venue?: VenueSetting | null;
+  /** Every venue paperlint knows (`shippedVenueNames`): a name naming one is refused. */
+  readonly venues: readonly NamedVenue[];
+}
+
 // Documented in README.md#getting-started — update it when this changes.
 export function newPaper(
   papersRoot: string,
   name: string,
   format: PaperFormat,
-  {
-    packageTemplates = PACKAGE_TEMPLATES,
-    venue = null,
-  }: { packageTemplates?: string; venue?: VenueSetting | null } = {},
+  opts: NewPaperOptions,
 ): NewPaperResult {
-  const problem = nameProblem(name);
+  const { packageTemplates = PACKAGE_TEMPLATES, venue = null } = opts;
+  const problem = nameProblem(name, opts.venues);
   if (problem) return { ok: false, reason: problem };
   const dir = join(papersRoot, name);
   const fresh = !existsSync(dir);

package/src/paper-settings.test.ts

@@ -32,6 +32,7 @@ describe("parsePaperSettings", () => {
         rules: null,
         identity: null,
         talk: null,
+        submission: null,
       },
     });
     expect(parsePaperSettings({})).toEqual({
@@ -43,6 +44,7 @@ describe("parsePaperSettings", () => {
         rules: null,
         identity: null,
         talk: null,
+        submission: null,
       },
     });
   });
@@ -57,6 +59,7 @@ describe("parsePaperSettings", () => {
         rules: null,
         identity: null,
         talk: null,
+        submission: null,
       },
     });
   });
@@ -155,7 +158,13 @@ describe("readPaperSettings — a root paperlint.json that cannot be used", () =
 });
 
 /** The fields a case does not set. */
-const UNSET = { pdf: null, rules: null, identity: null, talk: null };
+const UNSET = {
+  pdf: null,
+  rules: null,
+  identity: null,
+  talk: null,
+  submission: null,
+};
 
 describe("readPaperSettings — the root paperlint.json's defaults, the paper's file over them", () => {
   const ROOT = "/work";
@@ -210,6 +219,7 @@ describe("readPaperSettings — the root paperlint.json's defaults, the paper's
       rules: { "pdf/fonts": "off" },
       identity: null,
       talk: null,
+      submission: null,
     });
   });
 
@@ -253,6 +263,7 @@ describe("paperRules — `rules` in paperlint.json", () => {
     rules,
     identity: null,
     talk: null,
+    submission: null,
   });
 
   it("no rules: none", () => {

package/src/paper-settings.ts

@@ -4,7 +4,7 @@
  * One file name at two levels, one schema (lib/paper-config.mjs → SETTINGS_KEYS):
  *
  *   paperlint.json                 the project (optional): papersDir, rules, defaults
- *   <paper>/paperlint.json         this paper: { extends, kind, pdf, rules }
+ *   <paper>/paperlint.json         this paper: { extends, kind, pdf, rules, identity, talk, submission }
  *   a venue preset                 `paperlint:<name>` (shipped) or `./x.jsonc` (src/presets.ts)
  *
  * The paper's `extends`, `kind` and `pdf` win over the root's; with no own value, the root's is
@@ -32,6 +32,10 @@ import {
 } from "./rules-config.ts";
 import { messageOf } from "./domain/text.ts";
 import { parsePaperTalk, type PaperTalk } from "./domain/talk.ts";
+import {
+  parsePaperSubmission,
+  type PaperSubmission,
+} from "./domain/submission.ts";
 
 /** What one paper declares. Every absent field is null. */
 export interface PaperSettings {
@@ -54,6 +58,8 @@ export interface PaperSettings {
   readonly identity: readonly string[] | null;
   /** How this paper is presented (`talk/*`); null when it declares no talk. Never the root's. */
   readonly talk: PaperTalk | null;
+  /** Which submission on the venue's portal is this paper's; null when it says none. Never the root's. */
+  readonly submission: PaperSubmission | null;
 }
 
 /** Why a paper's settings cannot be read. */
@@ -112,17 +118,25 @@ export function identityField(
       );
 }
 
-/** `rules` (checked for shape only) and `talk`, each null when absent. */
+/** `rules` (checked for shape only), `talk` and `submission`, each null when absent. */
 function rulesAndTalk(
   json: Readonly<Record<string, unknown>>,
-): Result<Pick<PaperSettings, "rules" | "talk">, string> {
+): Result<Pick<PaperSettings, "rules" | "talk" | "submission">, string> {
   const rules = json["rules"];
   if (rules !== undefined && !isObject(rules) && !Array.isArray(rules))
     return err(
       `"rules" must be an object of rule id → severity, or a list of ESLint blocks`,
     );
   const talk = parsePaperTalk(json["talk"]);
-  return talk.ok ? ok({ rules: rules ?? null, talk: talk.value }) : talk;
+  if (!talk.ok) return talk;
+  const submission = parsePaperSubmission(json["submission"]);
+  return submission.ok
+    ? ok({
+        rules: rules ?? null,
+        talk: talk.value,
+        submission: submission.value,
+      })
+    : submission;
 }
 
 /** The parsed JSON of `paperlint.json` → the settings, or one line saying what is wrong. Pure. */
@@ -232,7 +246,12 @@ function merge(
   paper: PaperSettings | null,
 ): PaperSettings | null {
   const r = root ?? NO_DEFAULTS;
-  const p = paper ?? { ...NO_DEFAULTS, rules: null, talk: null };
+  const p = paper ?? {
+    ...NO_DEFAULTS,
+    rules: null,
+    talk: null,
+    submission: null,
+  };
   const merged: PaperSettings = {
     extends: p.extends ?? r.extends,
     kind: p.kind ?? r.kind,
@@ -240,6 +259,7 @@ function merge(
     rules: p.rules,
     identity: joined(r.identity, p.identity),
     talk: p.talk,
+    submission: p.submission,
   };
   return paper === null && Object.values(merged).every((v) => v === null)
     ? null

package/src/parse-args.test.ts

@@ -35,6 +35,25 @@ describe("parseArgs — `--flag=value` is the same as `--flag value`", () => {
   });
 });
 
+describe("parseArgs — the switches, each turning one field on", () => {
+  it.each([
+    ["--json", "json"],
+    ["--fix", "fix"],
+    ["--all", "all"],
+    ["--dry-run", "dryRun"],
+    ["--check", "check"],
+    ["--yes", "yes"],
+    ["-y", "yes"],
+    ["--no-hooks", "noHooks"],
+    ["--allow-venue-name", "allowVenueName"],
+  ] as const)("%s → %s", (flag, key) => {
+    const off = parseArgs(["new", "x"]);
+    const on = parseArgs(["new", "x", flag]);
+    expect(off[key]).toBe(false);
+    expect(on).toEqual({ ...off, [key]: true });
+  });
+});
+
 describe("an unknown flag is refused, not read as a path", () => {
   it("exits 2 and names the flag", async () => {
     const err: string[] = [];

package/src/ports/submission-portal.ts

@@ -0,0 +1,26 @@
+/**
+ * A conference portal holding a paper's submission — the port `paperlint submission` talks through.
+ * Shaped by what the command needs (read one submission, send one change), not by any portal's API;
+ * one adapter per portal kind (`src/adapters/hotcrp/`).
+ */
+import type { Result } from "../domain/result.ts";
+import type {
+  PortalFailure,
+  SubmissionChange,
+  SubmissionView,
+  UpdateOutcome,
+} from "../domain/submission.ts";
+
+export interface SubmissionPortal {
+  /** The submission as the portal holds it now. */
+  show(id: number): Promise<Result<SubmissionView, PortalFailure>>;
+  /**
+   * Send a change. Without `save` the portal only checks it (a dry run) and keeps nothing; an
+   * answer the portal gave — valid or not — is an outcome, not a failure.
+   */
+  update(
+    id: number,
+    change: SubmissionChange,
+    o: { readonly save: boolean },
+  ): Promise<Result<UpdateOutcome, PortalFailure>>;
+}

package/src/presets.test.ts

@@ -16,6 +16,7 @@ import {
   MAX_PRESET_DEPTH,
   SHIPPED_PREFIX,
   shippedPresets,
+  shippedVenueNames,
   labelOf,
   presetProblemText,
   resolvePreset,
@@ -297,3 +298,24 @@ describe("labelOf — display only, never used to resolve", () => {
     expect(labelOf(spec)).toBe(label);
   });
 });
+
+describe("shippedVenueNames — what each shipped venue is called", () => {
+  it("every shipped preset, by its label and the names along its chain", () => {
+    const names = shippedVenueNames(deps());
+    expect(names.map((n) => n.label)).toEqual(shippedPresets(VENUES));
+    expect(names.find((n) => n.label === "aisec")?.aliases).toEqual(
+      expect.arrayContaining(["AISec", "ACM CCS"]),
+    );
+  });
+
+  it("a preset that does not resolve is left out", () => {
+    const files = memoryFiles(
+      Object.fromEntries(
+        Object.entries(shipped).filter(([f]) => !f.endsWith("realm.jsonc")),
+      ),
+    );
+    expect(
+      shippedVenueNames({ files, venuesDir: VENUES }).map((n) => n.label),
+    ).toEqual(shippedPresets(VENUES).filter((n) => n !== "realm"));
+  });
+});