paperlint 6.3.0 → 7.1.0

package/src/adapters/latex/conditionals.ts

@@ -0,0 +1,130 @@
+/**
+ * `\iffalse … \fi`: text TeX never reads. Authors park old titles, sections and paragraphs there,
+ * and every reader of the tree — the outline, the rendered text, the headings the case judge reads,
+ * the includes — would otherwise take them for the paper. So the branch is cut out of the tree once,
+ * when the source is parsed (`parseLatex`), rather than pruned per walk like `hidden.ts` prunes: a
+ * walk can skip a node, but the rendered text reads the strings of a node list directly, and they
+ * would come back.
+ *
+ * What is cut: from `\iffalse` to its matching `\fi`, both included, counting the conditionals
+ * nested in between. An `\else` at the same depth ends the dead part: what follows it is read, and
+ * the matching `\fi` is cut. A conditional is a macro whose name starts with `if`, except
+ * `\ifthenelse` (the `ifthen` package's command, which takes arguments and has no `\fi`). An
+ * `\iffalse` with no `\fi` cuts to the end of its list, as TeX would read to the end of the file.
+ *
+ * Only `\iffalse` is decided. `\iftrue`, `\if\venue1` and every switch made with `\newif` depend on
+ * a value this reader does not compute, so both of their branches stay.
+ */
+import type * as Ast from "@unified-latex/unified-latex-types";
+
+type Node = Readonly<Ast.Node>;
+
+/** Where the scan of one node list stands: reading, inside a dead branch, or in its `\else`. */
+type Mode =
+  | { readonly kind: "live" }
+  | { readonly kind: "dead"; readonly depth: number }
+  | { readonly kind: "else"; readonly depth: number };
+
+/** One node against the mode before it: the mode after it, and whether the node is kept. */
+interface Step {
+  readonly mode: Mode;
+  readonly keep: boolean;
+}
+
+const LIVE: Mode = { kind: "live" };
+
+const isMacro = (n: Node, name: string): boolean =>
+  n.type === "macro" && n.content === name;
+
+/** A macro that opens a conditional TeX closes with `\fi`. */
+const opensConditional = (n: Node): boolean =>
+  n.type === "macro" &&
+  n.content.startsWith("if") &&
+  n.content !== "ifthenelse";
+
+/** Inside the dead branch: everything is cut; nesting is counted, `\else` at depth 1 ends it. */
+function stepDead(depth: number, n: Node): Step {
+  if (opensConditional(n))
+    return { mode: { kind: "dead", depth: depth + 1 }, keep: false };
+  if (isMacro(n, "fi"))
+    return {
+      mode: depth === 1 ? LIVE : { kind: "dead", depth: depth - 1 },
+      keep: false,
+    };
+  if (isMacro(n, "else") && depth === 1)
+    return { mode: { kind: "else", depth }, keep: false };
+  return { mode: { kind: "dead", depth }, keep: false };
+}
+
+/** In the `\else` branch: everything is kept but the `\fi` that closes the `\iffalse`. */
+function stepElse(depth: number, n: Node): Step {
+  if (opensConditional(n))
+    return { mode: { kind: "else", depth: depth + 1 }, keep: true };
+  if (isMacro(n, "fi"))
+    return depth === 1
+      ? { mode: LIVE, keep: false }
+      : { mode: { kind: "else", depth: depth - 1 }, keep: true };
+  return { mode: { kind: "else", depth }, keep: true };
+}
+
+function step(mode: Mode, n: Node): Step {
+  switch (mode.kind) {
+    case "live":
+      return isMacro(n, "iffalse")
+        ? { mode: { kind: "dead", depth: 1 }, keep: false }
+        : { mode, keep: true };
+    case "dead":
+      return stepDead(mode.depth, n);
+    case "else":
+      return stepElse(mode.depth, n);
+  }
+}
+
+/** A node list without its `\iffalse` branches, each kept node cleaned the same way. */
+// eslint-disable-next-line functional/prefer-immutable-types -- the tree's own content type is a mutable array
+function liveList(nodes: readonly Node[]): Ast.Node[] {
+  const { kept } = nodes.reduce<{
+    readonly mode: Mode;
+    readonly kept: readonly Ast.Node[];
+  }>(
+    (acc, n) => {
+      const next = step(acc.mode, n);
+      return {
+        mode: next.mode,
+        kept: next.keep ? [...acc.kept, liveNode(n)] : acc.kept,
+      };
+    },
+    { mode: LIVE, kept: [] },
+  );
+  return [...kept];
+}
+
+// eslint-disable-next-line functional/prefer-immutable-types -- the tree's own argument type is mutable
+const liveArgs = (args: readonly Readonly<Ast.Argument>[]): Ast.Argument[] =>
+  args.map((a) => ({ ...a, content: liveList(a.content) }));
+
+/** A node with its content and its arguments' content cleaned; a node with neither, as it is. */
+// eslint-disable-next-line functional/prefer-immutable-types -- the tree's own node type is mutable
+function liveNode(n: Node): Ast.Node {
+  if (n.type === "macro")
+    return n.args === undefined ? n : { ...n, args: liveArgs(n.args) };
+  if (n.type === "environment" || n.type === "mathenv")
+    return {
+      ...n,
+      content: liveList(n.content),
+      ...(n.args === undefined ? {} : { args: liveArgs(n.args) }),
+    };
+  if (n.type === "group" || n.type === "inlinemath" || n.type === "displaymath")
+    return { ...n, content: liveList(n.content) };
+  return n;
+}
+
+/** The tree without what `\iffalse … \fi` hides; the same tree when the source has no `\iffalse`. */
+export const withoutFalseBranches = (
+  src: string,
+  root: Readonly<Ast.Root>,
+  // eslint-disable-next-line functional/prefer-immutable-types -- `ParsedTex.root` is the tree's own mutable type
+): Ast.Root =>
+  src.includes("\\iffalse")
+    ? { ...root, content: liveList(root.content) }
+    : root;

package/src/adapters/latex/headings.ts

@@ -0,0 +1,163 @@
+/**
+ * The paper's `\title` and the titles of its headings as the case judge reads them: each as one run
+ * of text, every character with the source offset it came from.
+ *
+ * What a title says is its strings and spaces, and the words a formatting command wraps
+ * (`\emph{very}` says "very"). A label, a footnote or an index entry says nothing in the title and
+ * is left out. Anything else — math, `\texttt`, `\cite`, `\textsc`, an accent, an environment — is
+ * something the reader sees and the judge does not read, so it stands as `OPAQUE`, one character,
+ * where it is: the judge then knows a word is first or last only when nothing stands before or
+ * after it, and never reads a word that touches one.
+ */
+import { hasAtLeast } from "remeda";
+import type {
+  HeadingLevel,
+  Segment,
+  TitleArgument,
+  TitledCommand,
+  TitledHeading,
+} from "../../domain/tex-document.ts";
+import { LINE_BREAK, OPAQUE } from "../../domain/tex-document.ts";
+import { isDefinition, isUnrendered } from "./hidden.ts";
+import {
+  inPlace,
+  isNode,
+  mandatory,
+  optional,
+  placeOf,
+  stringText,
+  visited,
+  type Macro,
+  type Node,
+} from "./nodes.ts";
+import type { ParsedTex } from "./parse.ts";
+
+const LEVELS: ReadonlyMap<string, HeadingLevel> = new Map<string, HeadingLevel>(
+  [
+    ["section", "section"],
+    ["subsection", "subsection"],
+    ["subsubsection", "subsubsection"],
+    ["paragraph", "paragraph"],
+    ["subparagraph", "subparagraph"],
+  ],
+);
+
+/** Formatting commands: they say what their argument says. */
+const TRANSPARENT: ReadonlySet<string> = new Set([
+  "emph",
+  "textit",
+  "textbf",
+  "textsl",
+  "textup",
+  "textmd",
+  "textnormal",
+  "textsf",
+  "textrm",
+]);
+
+/** Commands that break the line: the title goes on as a second part, a subtitle. */
+const LINE_BREAKS: ReadonlySet<string> = new Set([
+  "\\\\",
+  "newline",
+  "linebreak",
+]);
+
+/** Commands that put nothing in the title's words: a label, a footnote, an index entry. */
+const INVISIBLE: ReadonlySet<string> = new Set([
+  "label",
+  "footnote",
+  "thanks",
+  "index",
+]);
+
+/**
+ * The command a macro is, for the case judge: the paper's `\title`, a heading at its level, or none.
+ * `\title` is read wherever it stands — in the preamble, where acmart and IEEEtran put it, or in a
+ * file the paper includes.
+ */
+const commandOf = (m: Macro): readonly TitledCommand[] => {
+  if (m.content === "title") return [{ kind: "title" }];
+  const level = LEVELS.get(m.content);
+  return level === undefined ? [] : [{ kind: "heading", level }];
+};
+
+/** A macro that is neither left out of the title nor read as the words it wraps. */
+const isOpaqueMacro = (m: Macro): boolean =>
+  !INVISIBLE.has(m.content) &&
+  !TRANSPARENT.has(m.content) &&
+  !LINE_BREAKS.has(m.content);
+
+/** What one macro says in a title. */
+function macroSegments(m: Macro): readonly Segment[] {
+  if (INVISIBLE.has(m.content)) return [];
+  if (LINE_BREAKS.has(m.content)) return textAt(m, LINE_BREAK);
+  if (TRANSPARENT.has(m.content))
+    return segmentsOf(mandatory(m).at(-1)?.content);
+  return textAt(m, OPAQUE);
+}
+
+/** A piece of text at the start of a node. */
+const textAt = (n: Node, text: string): readonly Segment[] =>
+  inPlace(placeOf(n), (s) => [{ text, at: s.start }]);
+
+/** What one node says in a title: text as itself, a formatting command's words, anything else opaque. */
+function nodeSegments(n: Node): readonly Segment[] {
+  if (n.type === "string") return textAt(n, stringText(n.content));
+  if (n.type === "whitespace" || n.type === "parbreak") return textAt(n, " ");
+  // A comment ends its line: the words on either side of it are two words.
+  if (n.type === "comment") return textAt(n, " ");
+  if (n.type === "group") return segmentsOf(n.content);
+  if (n.type === "macro") return macroSegments(n);
+  return textAt(n, OPAQUE);
+}
+
+/**
+ * A group that is the very next node after a command the parser has no signature for (`\ours{…}`, a macro of the
+ * author's own): the parser leaves such a group beside the macro, but TeX hands it to the macro as an
+ * argument, so it is part of what the macro prints and not words of the title. A chain of groups
+ * (`\findingdes{label}{a sentence}`) is all argument.
+ */
+function isArgumentGroup(nodes: readonly Node[], n: Node, i: number): boolean {
+  const prev = nodes[i - 1];
+  if (prev === undefined || n.type !== "group") return false;
+  return prev.type === "macro"
+    ? isOpaqueMacro(prev)
+    : isArgumentGroup(nodes, prev, i - 1);
+}
+
+const segmentsOf = (nodes: readonly Node[] | undefined): readonly Segment[] => {
+  const list = nodes ?? [];
+  return list.flatMap((n, i) =>
+    isArgumentGroup(list, n, i) ? [] : nodeSegments(n),
+  );
+};
+
+/** One argument's contents → the heading it makes, or none when it says nothing. */
+function titled(
+  command: TitledCommand,
+  argument: TitleArgument,
+  nodes: readonly Node[] | undefined,
+): readonly TitledHeading[] {
+  const segments = segmentsOf(nodes);
+  return hasAtLeast(segments, 1)
+    ? [{ command, argument, title: { segments } }]
+    : [];
+}
+
+/** One titled command → the short title (`[…]`) and the title (the last `{…}`), each judged. */
+const headingsOfMacro = (m: Macro): readonly TitledHeading[] =>
+  commandOf(m).flatMap((command) => [
+    ...titled(command, "short", optional(m)?.content),
+    ...titled(command, "title", mandatory(m).at(-1)?.content),
+  ]);
+
+/**
+ * The paper's `\title` and every `\section`, `\subsection`, `\subsubsection`, `\paragraph` and
+ * `\subparagraph`, starred or not, each with its optional short title, in document order. What the
+ * PDF never shows is pruned (`isUnrendered`), and so is a macro definition's body: a heading in a
+ * comment environment or in a definition is not a heading where it is written.
+ */
+export const headingsOf = (t: ParsedTex): readonly TitledHeading[] =>
+  visited(t.root, (v, parent) => isUnrendered(v, parent) || isDefinition(v))
+    .filter(isNode)
+    .flatMap((n) => (n.type === "macro" ? headingsOfMacro(n) : []));

package/src/adapters/latex/index.test.ts

@@ -324,6 +324,71 @@ describe("outlineOf — a heading that is never rendered is not in the outline",
   });
 });
 
+describe("\\iffalse … \\fi — a branch TeX never reads is not in the tree any reader walks", () => {
+  const dead = [
+    "A",
+    "\\iffalse",
+    "\\section{Old Title}",
+    "dead words",
+    "\\ifx\\a\\b nested\\fi",
+    "still dead",
+    "\\fi",
+    "B",
+  ].join("\n");
+  const doc = (body: string) => `\\begin{document}\n${body}\n\\end{document}`;
+
+  it("🔴 outline, headings and rendered text skip it, nested conditionals included", () => {
+    const t = parseLatex(doc(dead));
+    expect(outlineOf(t).sections).toEqual([]);
+    expect(latexReader.headings(doc(dead))).toEqual([]);
+    // Guards: the dead strings are gone from the list itself, so A and B are one run.
+    expect(
+      renderedRuns(t).map((r) => runText(r).replace(/\s+/gu, " ").trim()),
+    ).toEqual(["A B"]);
+  });
+
+  it("the \\else branch of an \\iffalse is read, and the text after its \\fi", () => {
+    const src = doc(
+      "\\iffalse\n\\section{Old}\n\\else\n\\section{New}\n\\fi\n\\section{After}",
+    );
+    expect(outlineOf(parseLatex(src)).sections.map((h) => h.title)).toEqual([
+      "New",
+      "After",
+    ]);
+  });
+
+  it("inside a group too, and `\\ifthenelse` (which has no \\fi) does not swallow the rest", () => {
+    const src = doc(
+      "{\\iffalse\\section{Old}\\ifthenelse{x}{y}{z}\\fi}\\section{Real}",
+    );
+    expect(outlineOf(parseLatex(src)).sections.map((h) => h.title)).toEqual([
+      "Real",
+    ]);
+  });
+
+  it("inside an environment with arguments, in math, and an \\else holding its own conditional", () => {
+    const src = doc(
+      [
+        "\\begin{minipage}{4cm}\\iffalse\\section{Old}\\fi\\section{Kept}\\end{minipage}",
+        "$x \\iffalse y \\fi$ \\[ z \\] \\begin{align*} a \\end{align*}",
+        "\\iffalse\\section{Old}\\else\\ifx\\a\\b\\section{Inner}\\fi\\section{New}\\fi",
+      ].join("\n"),
+    );
+    expect(outlineOf(parseLatex(src)).sections.map((h) => h.title)).toEqual([
+      "Kept",
+      "Inner",
+      "New",
+    ]);
+  });
+
+  it("an \\iffalse that is never closed leaves out everything after it, as TeX does", () => {
+    const src = doc("\\section{Real}\n\\iffalse\n\\section{Old}");
+    expect(outlineOf(parseLatex(src)).sections.map((h) => h.title)).toEqual([
+      "Real",
+    ]);
+  });
+});
+
 describe("renderedRuns", () => {
   it("runs of strings and spaces, each character mapped to its source offset", () => {
     const src = "A~B \\emph{C D}\n\n E";

package/src/adapters/latex/index.ts

@@ -26,6 +26,7 @@ import {
   parseTemplate,
   replaceDocumentClass,
 } from "./document-class.ts";
+import { headingsOf } from "./headings.ts";
 import { documentBodyOf, includesOf } from "./includes.ts";
 import { outlineOf } from "./outline.ts";
 import { parseLatex } from "./parse.ts";
@@ -48,6 +49,7 @@ export {
   textOf,
 } from "./nodes.ts";
 export { documentBodyOf, includesOf } from "./includes.ts";
+export { headingsOf } from "./headings.ts";
 export { outlineOf } from "./outline.ts";
 export { parseLatex, type ParsedTex } from "./parse.ts";
 export { bodyEmphasis, bodyProse } from "./prose.ts";
@@ -58,6 +60,7 @@ export { layoutOverridesOf } from "./layout.ts";
 export const latexReader: LatexReader = {
   documentClass: (src) => documentClassOf(parseLatex(src)),
   outline: (src) => outlineOf(parseLatex(src)),
+  headings: (src) => headingsOf(parseLatex(src)),
   renderedRuns: (src) => renderedRuns(parseLatex(src)),
   bodyProse: (src) => bodyProse(parseLatex(src)),
   bodyEmphasis: (src) => bodyEmphasis(parseLatex(src)),

package/src/adapters/latex/parse.ts

@@ -12,6 +12,7 @@
 import type * as Ast from "@unified-latex/unified-latex-types";
 import { getParser } from "@unified-latex/unified-latex-util-parse";
 import { once } from "remeda";
+import { withoutFalseBranches } from "./conditionals.ts";
 
 const signed = (
   names: readonly string[],
@@ -133,9 +134,9 @@ const parser = once(() =>
   }),
 );
 
-/** A LaTeX source → its tree. */
+/** A LaTeX source → its tree, without the branches `\iffalse … \fi` hides (`conditionals.ts`). */
 export const parseLatex = (src: string): ParsedTex => ({
   src,
-  root: parser().parse(src),
+  root: withoutFalseBranches(src, parser().parse(src)),
   [PARSED]: true,
 });

package/src/build.ts

@@ -121,7 +121,7 @@ export interface PaperFacts {
     readonly name: string;
     readonly options: readonly string[];
   } | null;
-  /** The label of the venue preset `paperlint.json` extends, or null. */
+  /** The id of the venue preset `paperlint.json` extends (`agenticdev`), or null. */
   readonly venue: string | null;
   /** Paper-supplied build scripts found on disk — reported as ignored. */
   readonly ignoredScripts: readonly string[];
@@ -239,7 +239,7 @@ export function readFacts(paperDir: string): PaperFacts {
   return {
     main,
     documentclass: documentclassOf(ast),
-    venue: venue?.label ?? null,
+    venue: venue?.id ?? null,
     ignoredScripts: IGNORED_SCRIPTS.filter((s) =>
       existsSync(join(paperDir, s)),
     ),

package/src/cli.test.ts

@@ -10,7 +10,12 @@ import { existsSync } from "node:fs";
 import { createServer } from "node:http";
 import { dirname, join } from "node:path";
 import { test } from "vitest";
-import { runNode, useTempDir, writeTree } from "../test/support.ts";
+import {
+  runNode,
+  useTempDir,
+  venuePreset,
+  writeTree,
+} from "../test/support.ts";
 import type { runToolchain } from "./toolchain.ts";
 import {
   chooseVenue,
@@ -195,8 +200,12 @@ test("runHook: a runtime with no cli.js beside it, and a hook killed by a signal
 test("chooseVenue: a preset by path (inside and outside the paper), by prefixed name, and a broken one", async () => {
   const dir = join(root, "venues");
   writeTree(dir, {
-    "papers/p/mine.jsonc": JSON.stringify({ extends: "paperlint:agenticdev" }),
-    "shared/ours.jsonc": JSON.stringify({ extends: "paperlint:agenticdev" }),
+    "papers/p/mine.jsonc": JSON.stringify(
+      venuePreset("mine", { extends: "paperlint:agenticdev" }),
+    ),
+    "shared/ours.jsonc": JSON.stringify(
+      venuePreset("ours", { extends: "paperlint:agenticdev" }),
+    ),
     "shared/broken.jsonc": "{ nope",
   });
   const paperDir = join(dir, "papers", "p");
@@ -394,6 +403,38 @@ test("silentOptionalRules: a config with no rules turns nothing on", async () =>
   assert.deepEqual(await silentOptionalRules(eslint, [], {}), []);
 });
 
+const lastPageOn = {
+  rules: [
+    { basePath: ".", rules: { "pdf/last-page-balance": "error" as const } },
+  ],
+};
+const eslintWith = (rules: Record<string, unknown>) => ({
+  calculateConfigForFile: () => Promise.resolve({ rules }),
+});
+
+test("silentOptionalRules: a rule on for a paper is reached", async () => {
+  const eslint = eslintWith({ "pdf/last-page-balance": [2, {}] });
+  assert.deepEqual(
+    await silentOptionalRules(eslint, ["p/paper.tex"], lastPageOn),
+    [],
+  );
+});
+
+test("silentOptionalRules: a rule a paper's own block turns off is reached — the way out of a preset's", async () => {
+  const eslint = eslintWith({ "pdf/last-page-balance": [0] });
+  assert.deepEqual(
+    await silentOptionalRules(eslint, ["p/paper.tex"], lastPageOn),
+    [],
+  );
+});
+
+test("silentOptionalRules: a rule no block names for any paper is silent — a glob that matched nothing", async () => {
+  assert.deepEqual(
+    await silentOptionalRules(eslintWith({}), ["p/paper.tex"], lastPageOn),
+    ["pdf/last-page-balance"],
+  );
+});
+
 test("init with no path and --format md sets up the current directory", async () => {
   const dir = writeTree(join(root, "init-here"), { "package.json": "{}" });
   const r = await cli(
@@ -645,10 +686,12 @@ test("parseArgs: submission's flags — two values and two switches", () => {
 const submissionPaper = (dir: string, site: string): void => {
   writeTree(dir, {
     "package.json": "{}",
-    "venue.jsonc": JSON.stringify({
-      extends: "paperlint:aidc",
-      portal: { kind: "hotcrp", url: site },
-    }),
+    "venue.jsonc": JSON.stringify(
+      venuePreset("venue", {
+        extends: "paperlint:aidc",
+        portal: { kind: "hotcrp", url: site },
+      }),
+    ),
     "papers/p/paperlint.json": JSON.stringify({
       extends: "../../venue.jsonc",
       submission: { id: 7 },

package/src/cli.ts

@@ -42,7 +42,12 @@ import {
   asEslintResults,
 } from "./structure.ts";
 import { buildPapers, papersIn, anyFailed, remedyFor, MAIN } from "./build.ts";
-import { includeBlocks, paperBodies, unreadLines } from "./paper-includes.ts";
+import {
+  FRAGMENT_FILES,
+  includeBlocks,
+  paperBodies,
+  unreadLines,
+} from "./paper-includes.ts";
 import { prepareEngine } from "./build-engine.ts";
 import { cacheRoot, cachedTree, runToolchain } from "./toolchain.ts";
 import { banalInstaller, parseBanalSettings } from "./adapters/banal/index.ts";
@@ -78,6 +83,7 @@ import {
   REGISTER_BAND_RULE_LEVELS,
   registerBandRules,
 } from "./register-bands.ts";
+import { headingCaseRule } from "./heading-case.ts";
 import {
   paperRules,
   identityField,
@@ -291,6 +297,18 @@ const TEX_RULE_DEPS = {
   latex: latexReader,
 };
 
+/** The register band rules and `tex/heading-case`: the rules of the `tex` plugin that read a paper's words. */
+const REGISTER_AND_CASE_RULES = {
+  ...registerBandRules(TEX_RULE_DEPS),
+  "heading-case": headingCaseRule(TEX_RULE_DEPS),
+};
+
+/** The rules of the files `paper.tex` includes, each read on its own as a fragment (#144). */
+const FRAGMENT_RULES = {
+  "future-promise": texBuild["future-promise"],
+  "heading-case": REGISTER_AND_CASE_RULES["heading-case"],
+};
+
 /** What the talk rules read with: the disk, the shipped presets, and the three media readers. */
 const TALK_RULE_DEPS = {
   files: nodeFiles,
@@ -402,7 +420,7 @@ export function buildConfig(
             ...texVenueRules(TEX_RULE_DEPS),
             "claim-provenance": claimProvenanceRule(TEX_RULE_DEPS),
             register: registerRule(TEX_RULE_DEPS),
-            ...registerBandRules(TEX_RULE_DEPS),
+            ...REGISTER_AND_CASE_RULES,
           },
         },
         paper: { rules: texPaperRules },
@@ -449,12 +467,12 @@ export function buildConfig(
   const fragments: readonly ConfigBlock[] = texLanguage
     ? [
         {
-          files: ["**/*.tex"],
+          files: [...FRAGMENT_FILES],
           ignores: ["**/paper.tex"],
           plugins: {
             tex: {
               languages: { latex: texLanguage },
-              rules: { "future-promise": texBuild["future-promise"] },
+              rules: FRAGMENT_RULES,
             },
             paper: {
               rules: {
@@ -623,7 +641,11 @@ export async function silentOptionalRules(
   for (const f of new Set(files.filter((p) => basename(p) === MAIN))) {
     // Undefined for a file outside ESLint's cwd or scope: it reaches nothing.
     const cfg = ComputedConfig.parse(await eslint.calculateConfigForFile(f));
-    for (const id of turnedOn) if (isOn(cfg?.rules?.[id])) reached.add(id);
+    // Reached is "some block names the rule for this paper", on OR off: a paper that turns off what
+    // its venue preset turned on is the documented way out, and reads the same as a glob that missed
+    // only if "off" is counted as "not there" — which refused every such paper.
+    for (const id of turnedOn)
+      if (cfg?.rules?.[id] !== undefined) reached.add(id);
   }
   return [...turnedOn].filter((id) => !reached.has(id));
 }
@@ -1162,7 +1184,7 @@ export async function createPaperAt(
 
 /** A venue `paperlint new` will write, with what the messages need to say about it. */
 export interface VenueChoice extends VenueSetting {
-  /** The preset's word in messages (`agenticdev`, `my-workshop`). */
+  /** The preset's word in messages: the venue's name (`AgenticDev`), else the file name (`my-workshop`). */
   readonly label: string;
   /** The preset's kinds; empty when it sets no page limit. */
   readonly kinds: readonly string[];