paperlint 2.0.1 → 2.1.0

package/src/build.harness.mjs

@@ -137,6 +137,24 @@ const fakeRead = async (pdf) => {
 const CLEAN_TEX = "\\documentclass{article}\\begin{document}x\\end{document}";
 
 try {
+  // ── inputs: paperlint's own venues directory, no configuration ───────────────────────────────
+  // First: the facts below resolve a paper's venue preset in this same directory, so a wrong one
+  // must be named HERE, not as a missing venue label two checks later.
+  const venues = packageVenuesDir();
+  check(
+    "the venues directory is paperlint's own and holds paper-guards.tex",
+    existsSync(join(venues, "paper-guards.tex")),
+  );
+  check(
+    "🔴 with no TEXINPUTS set, the value ENDS in the separator — otherwise the system tree stops resolving",
+    withTexInputs({}, [venues]).TEXINPUTS === `${venues}${delimiter}`,
+  );
+  check(
+    "an existing TEXINPUTS is kept, after ours",
+    withTexInputs({ TEXINPUTS: `/mine${delimiter}` }, [venues]).TEXINPUTS ===
+      `${venues}${delimiter}/mine${delimiter}`,
+  );
+
   // ── facts: parsed from the paper, not configured ──────────────────────────────────────
   check(
     "documentclass and options come from the parser",
@@ -157,33 +175,20 @@ try {
   );
   const venued = paper("venued", {
     "paper.tex": CLEAN_TEX,
-    "venue.json": JSON.stringify({ venue: "agenticdev", kind: "short" }),
+    "paperlint.json": JSON.stringify({
+      extends: "paperlint:agenticdev",
+      kind: "short",
+    }),
     "build.sh": "exit 0\n",
   });
   const facts = readFacts(venued);
-  check("the venue comes from venue.json", facts.venue === "agenticdev");
+  check("the venue comes from paperlint.json", facts.venue === "agenticdev");
   check(
     "a leftover build.sh is a FACT (reported), not a step",
     JSON.stringify(facts.ignoredScripts) === JSON.stringify(["build.sh"]) &&
       IGNORED_SCRIPTS.includes("repro/build-submission.sh"),
   );
 
-  // ── inputs: paperlint's own venues directory, no configuration ───────────────────────────────
-  const venues = packageVenuesDir();
-  check(
-    "the venues directory is paperlint's own and holds paper-guards.tex",
-    existsSync(join(venues, "paper-guards.tex")),
-  );
-  check(
-    "🔴 with no TEXINPUTS set, the value ENDS in the separator — otherwise the system tree stops resolving",
-    withTexInputs({}, [venues]).TEXINPUTS === `${venues}${delimiter}`,
-  );
-  check(
-    "an existing TEXINPUTS is kept, after ours",
-    withTexInputs({ TEXINPUTS: `/mine${delimiter}` }, [venues]).TEXINPUTS ===
-      `${venues}${delimiter}/mine${delimiter}`,
-  );
-
   // ── the plan ──────────────────────────────────────────────────────────────────────────
   const plan = planFor(facts);
   check(

package/src/build.ts

@@ -12,7 +12,7 @@
  *
  * ── THE SHAPE: an ordered list of STEPS, composed, not configured ────────────
  * Each step says whether it applies to THIS paper and why — decided from FACTS parsed out of the
- * paper (its `\documentclass` and options, the venue named in `venue.json`), never from a config
+ * paper (its `\documentclass` and options, the venue named in `paperlint.json`), never from a config
  * flag. `paperlint build` prints that plan before running anything, and `--dry-run` prints only the
  * plan. Adding a step is one entry in `STEPS`.
  *
@@ -45,6 +45,7 @@ import { delimiter, join, relative } from "node:path";
 // eslint-disable-next-line boundaries/dependencies -- legacy layer, moves behind a port in #76
 import { getParser } from "@unified-latex/unified-latex-util-parse";
 import { packageVenuesDir } from "../skills/paper-pipeline/scripts/consumer.mjs";
+import { PAPER_SETTINGS_FILE } from "../lib/paper-config.mjs";
 import {
   declaredVenue,
   factsPath,
@@ -86,7 +87,7 @@ export const PAPER_MARKERS = [
   "PIPELINE-STATUS.md",
   "paper.tex",
   "paper.md",
-  "venue.json",
+  PAPER_SETTINGS_FILE,
 ];
 
 /** The source paperlint compiles, and the job name every output file carries. */
@@ -114,7 +115,7 @@ export interface PaperFacts {
     readonly name: string;
     readonly options: readonly string[];
   } | null;
-  /** The `venue` field of `venue.json`, or null. */
+  /** The label of the venue preset `paperlint.json` extends, or null. */
   readonly venue: string | null;
   /** Paper-supplied build scripts found on disk — reported as ignored. */
   readonly ignoredScripts: readonly string[];
@@ -222,7 +223,7 @@ export function readFacts(paperDir: string): PaperFacts {
   return {
     main,
     documentclass: documentclassOf(ast),
-    venue: venue?.venue ?? null,
+    venue: venue?.label ?? null,
     ignoredScripts: IGNORED_SCRIPTS.filter((s) =>
       existsSync(join(paperDir, s)),
     ),

package/src/cli.harness.mjs

@@ -1795,11 +1795,13 @@ console.log(
     );
     const r = await cli(["new", "demo"], root);
     check(
-      "🔴 `paperlint new demo` creates writing/demo/ and its lint is the verdict — exit 0, no findings",
+      "🔴 `paperlint new demo` creates writing/demo/ and its lint is the verdict — exit 0, and only the warning that no venue is chosen yet",
       r.code === 0 &&
         existsSync(join(root, "writing", "demo", "PIPELINE-STATUS.md")) &&
         existsSync(join(root, "writing", "demo", "paper.tex")) &&
-        /no findings/.test(r.out),
+        existsSync(join(root, "writing", "demo", "paperlint.json")) &&
+        /names no venue preset yet/.test(r.out) &&
+        /\(0 errors, 1 warning\)/.test(r.out),
     );
     const again = await cli(["new", "demo", "--format", "md"], root);
     check(

package/src/cli.ts

@@ -33,7 +33,10 @@ import { fileURLToPath } from "node:url";
 import { join, dirname, resolve, relative, basename, sep } from "node:path";
 import markdown from "@eslint/markdown";
 // Types come from consumer.d.mts beside it, the same arrangement as lib/paper-config.d.mts.
-import { isMain } from "../skills/paper-pipeline/scripts/consumer.mjs";
+import {
+  isMain,
+  packageVenuesDir,
+} from "../skills/paper-pipeline/scripts/consumer.mjs";
 export { isMain };
 import type { Args, PaperlintConfig, ConfigRead } from "./types.ts";
 import {
@@ -41,22 +44,23 @@ import {
   formatStructure,
   asEslintResults,
 } from "./structure.ts";
-import {
-  buildPapers,
-  papersIn,
-  anyFailed,
-  remedyFor,
-  readFacts,
-  MAIN,
-} from "./build.ts";
+import { buildPapers, papersIn, anyFailed, remedyFor, MAIN } from "./build.ts";
 import { prepareEngine } from "./build-engine.ts";
 import { runToolchain } from "./toolchain.ts";
 import { banalInstaller, parseBanalSettings } from "./adapters/banal/index.ts";
 import { curlDownload } from "./adapters/curl/index.ts";
-import { hostDirs, nodeAdapters } from "./adapters/node/index.ts";
+import { hostDirs, nodeAdapters, nodeFiles } from "./adapters/node/index.ts";
+import { VENUE_RULE_LEVELS, venueRules } from "./venue-rules.ts";
+import { paperRules } from "./paper-settings.ts";
+import {
+  paperPreset,
+  paperPresetProblem,
+  type PaperPreset,
+} from "./presets.ts";
 import type { ToolInstaller } from "./ports/tool-installer.ts";
 import {
   mergeRequirements,
+  declaredUnion,
   requirementsFor,
   NO_REQUIREMENTS,
   type TexRequirements,
@@ -84,9 +88,11 @@ import {
 } from "../lib/paper-config.mjs";
 import {
   parseRuleBlocks,
+  parseRuleEntries,
   shippedRuleIds,
   unknownKeys,
   type Parsed,
+  type RuleBlock,
 } from "./rules-config.ts";
 export { init };
 export { nextSteps } from "./init.ts";
@@ -122,7 +128,7 @@ const USAGE = `paperlint — machine-checkable gates for a paper kept in git
                                       Compiles with paperlint's TeX Live, else one on PATH that has every
                                       package the venue declares; on a terminal it offers to install
                                       one, without a terminal it stops and names \`npx paperlint toolchain\`
-  npx paperlint toolchain [--check]   install TeX Live with every package the venue profiles declare
+  npx paperlint toolchain [--check]   install TeX Live with every package the venue presets declare
                                       into ~/.cache/paperlint/texlive (PAPERLINT_TEXLIVE_DIR overrides); a second
                                       run does nothing. --check: report what is missing, change nothing
   npx paperlint doctor                say what is actually wired — and what only LOOKS wired
@@ -166,7 +172,19 @@ another file of the same shape. \`papersDir\` is required; the rest is optional:
 
   "rules" takes ESLint flat-config blocks (files, ignores, rules), appended after paperlint's own, with
   files relative to the file holding the settings. Optional rules (off unless turned on there):
-  pdf/last-page-balance. An unknown key, anywhere in the settings, is an error.
+  pdf/last-page-balance. The venue rules (pdf/fresh, pdf/profile, pdf/fonts, pdf/geometry,
+  pdf/limits, pdf/body-size, pdf/measured) are on for every paper whose paperlint.json names a venue;
+  set one to "off" there to skip it.
+
+per paper — <paper>/paperlint.json (it was venue.json before 2.1.0; \`npx paperlint init\` moves it):
+
+  { "extends": "paperlint:aisec", "kind": "research", "rules": { "pdf/last-page-balance": "error" } }
+
+  "extends" names a venue preset: paperlint:<name> (shipped: acm-sigconf, agenticdev, aisec, realm)
+  or ./path.jsonc, relative to the paperlint.json. npm presets are not supported yet.
+
+  "rules" there applies to that paper alone, after its preset's rules and before the project's. An unknown key,
+  anywhere in the settings or in a paperlint.json, is an error.
 `;
 
 /** The config the user would otherwise write by hand. The data comes from `opts`, the mechanism is here. */
@@ -188,11 +206,21 @@ export function buildConfig(
     // default (only `node_modules/` and `.git/`), so without this block `paperlint lint` would lint the
     // template as a paper — and a richer template with placeholder stages would fail the run.
     { ignores: ["**/.template/"] },
-    // The `pdf` plugin is registered for EVERY file, and its rule is on for none. A consumer's
-    // block (`rules`, appended below) turns it on for a glob that also matches markdown files;
-    // with the plugin defined only beside `paper.tex`, ESLint would refuse those files with
-    // "could not find plugin". The rule itself acts on `paper.tex` only.
-    { plugins: { pdf: pdfRules } },
+    // The `pdf` plugin is registered for EVERY file. A consumer's block (`rules`, appended below)
+    // may name its rules for a glob that also matches markdown files; with the plugin defined only
+    // beside `paper.tex`, ESLint would refuse those files with "could not find plugin". Every rule
+    // in it acts on `paper.tex` only. `last-page-balance` is on for no file (optional); the venue
+    // rules are on for every `paper.tex`, in the block below.
+    {
+      plugins: {
+        pdf: {
+          rules: {
+            ...pdfRules.rules,
+            ...venueRules({ files: nodeFiles, venuesDir: packageVenuesDir() }),
+          },
+        },
+      },
+    },
     {
       files: ["**/PIPELINE-STATUS.md"],
       plugins: { markdown, paper: paperStages },
@@ -263,6 +291,8 @@ export function buildConfig(
         "paper/typography": typographyOpt,
         "tex/future-promise": "warn",
         "tex/acm-frontmatter-override": "error",
+        // Silent for a paper whose paperlint.json names no venue (src/venue-rules.ts).
+        ...VENUE_RULE_LEVELS,
       },
     });
   // The consumer's own blocks, LAST, so a later block wins — ESLint's rule. Parsed by
@@ -328,6 +358,66 @@ export async function silentOptionalRules(
   return [...turnedOn].filter((id) => !reached.has(id));
 }
 
+/**
+ * Every linted paper's `rules` from its `paperlint.json`, as ESLint blocks scoped to that paper.
+ * A file that does not parse, or names a rule paperlint does not ship, stops the run with one line
+ * naming the file — the same strictness as the project's own `rules`. A leftover `venue.json` is
+ * not read here; `pdf/profile` and `paperlint doctor` name it.
+ */
+export function paperRuleBlocks(paths: readonly string[]): Parsed<RuleBlock[]> {
+  const papers = [...new Set(paths.flatMap((p) => [p, ...papersIn(p)]))];
+  const out: RuleBlock[] = [];
+  for (const dir of papers) {
+    const p = paperPreset(dir, PRESET_DEPS);
+    if (p.kind === "settings-problem" && p.problem.kind === "broken")
+      return { ok: false, error: paperPresetProblem(dir, p) ?? dir };
+    const block = rulesOfPaper(dir, p);
+    if (!block.ok) return block;
+    if (block.value) out.push(block.value);
+  }
+  return { ok: true, value: out };
+}
+
+/**
+ * One paper's block: its preset chain's `rules`, then its own — later wins per rule id. A preset
+ * that does not resolve contributes nothing here; `pdf/profile` reports it on the paper.
+ */
+function rulesOfPaper(dir: string, p: PaperPreset): Parsed<RuleBlock | null> {
+  const settings = "settings" in p ? p.settings : null;
+  if (settings === null) return { ok: true, value: null };
+  const own = paperRules(dir, settings, SHIPPED_RULES);
+  if (!own.ok) return own;
+  const fromPreset =
+    p.kind === "resolved"
+      ? parseRuleEntries(
+          p.preset.rules,
+          `the venue preset ${p.preset.chain.join(" → ")} → "rules"`,
+          SHIPPED_RULES,
+        )
+      : { ok: true as const, value: {} };
+  if (!fromPreset.ok) return fromPreset;
+  const rules = { ...fromPreset.value, ...(own.value ?? {}) };
+  return {
+    ok: true,
+    value: Object.keys(rules).length
+      ? { basePath: dir, files: PAPER_FILE_PATTERNS, rules }
+      : null,
+  };
+}
+
+/**
+ * The files a paper's block may reach: exactly the ones paperlint's own blocks lint, read off its
+ * config. A wider glob (everything under the paper) would make ESLint lint files no block gives a
+ * language — `paperlint.json` itself would be parsed as JavaScript.
+ */
+const PAPER_FILE_PATTERNS: string[] = [
+  ...new Set(
+    buildConfig({}, { sentinel: "tex language" }).flatMap(
+      (b) => (b as { files?: string[] }).files ?? [],
+    ),
+  ),
+];
+
 /**
  * The settings after the boundary: an unknown key is refused by name, and `rules` becomes parsed
  * config blocks. Nothing after this sees the raw object.
@@ -818,15 +908,40 @@ async function runBuild(
   return anyFailed(out.results) ? 1 : 0;
 }
 
-/** What one paper needs from TeX Live; a venue.json that does not parse is the build's to report. */
+/** The presets' deps, wired to the disk and the package's own venues directory. */
+const PRESET_DEPS = { files: nodeFiles, venuesDir: packageVenuesDir() };
+
+/**
+ * What one paper needs from TeX Live: the base set plus its preset chain's `tex`. A paper whose
+ * settings or preset do not resolve gets the base set; the build reports why at its facts step.
+ */
 function paperRequirements(dir: string): TexRequirements {
-  let venue: string | null = null;
-  try {
-    venue = readFacts(dir).venue;
-  } catch {
-    venue = null;
-  }
-  return requirementsFor(venue).tex;
+  const p = paperPreset(dir, PRESET_DEPS);
+  return requirementsFor(p.kind === "resolved" ? p.preset : null).tex;
+}
+
+/**
+ * What `paperlint toolchain` installs: every shipped preset's packages, plus the resolved chain of
+ * every paper under the project's papers directory — a project's own preset lives outside the
+ * package, so the shipped union alone would not see it.
+ */
+export function toolchainTex(cwd: string): TexRequirements {
+  const cfg = readConfig(parseArgs(["toolchain"]), {
+    log: () => {},
+    err: () => {},
+    cwd,
+  });
+  const roots =
+    cfg.code === undefined
+      ? toPaths(papersDirOf(cfg.opts)).map((rel) =>
+          resolve(dirname(cfg.configPath ?? cwd), rel),
+        )
+      : [];
+  const chains = roots
+    .flatMap((r) => papersIn(r))
+    .map((dir) => paperPreset(dir, PRESET_DEPS))
+    .flatMap((p) => (p.kind === "resolved" ? [p.preset.tex] : []));
+  return declaredUnion(undefined, chains).tex;
 }
 
 /**
@@ -868,8 +983,14 @@ const SIMPLE: Readonly<
   hook: (a, { err }) => runHook(a.paths[0], { err }),
   new: (a, io) => runNew(a, io),
   build: (a, io) => runBuild(a, io),
-  toolchain: (a, { log, err }) =>
-    runToolchain({ check: a.check, log, err, banal: hostBanalInstaller() }),
+  toolchain: (a, { log, err, cwd }) =>
+    runToolchain({
+      check: a.check,
+      log,
+      err,
+      banal: hostBanalInstaller(),
+      tex: toolchainTex(cwd),
+    }),
 };
 
 /** banal's installer, wired from this process's environment: the composition root's work. */
@@ -1013,6 +1134,14 @@ export async function run(
   // a directory without `PIPELINE-STATUS.md` simply gets not a single rule and reports clean. The
   // analysis of why a structure plugin for ESLint does not cure this is in `structure.mjs`.
   const structure = checkStructure(paths, opts.structure, { cwd });
+  // Each paper's own `rules` (its paperlint.json) go after paperlint's blocks and BEFORE the
+  // project's, so the project's package.json still has the last word.
+  const papers = paperRuleBlocks(paths);
+  if (!papers.ok) return (err(papers.error), 2);
+  const withPapers = {
+    ...opts,
+    rules: [...papers.value, ...(opts.rules ?? [])],
+  };
 
   let texLanguage: unknown = null;
   try {
@@ -1026,7 +1155,7 @@ export async function run(
   const eslint = new ESLint({
     cwd: lintRoot(configPath ? dirname(resolve(cwd, configPath)) : cwd, paths),
     overrideConfigFile: true,
-    overrideConfig: buildConfig(opts, texLanguage) as Linter.Config[],
+    overrideConfig: buildConfig(withPapers, texLanguage) as Linter.Config[],
   });
 
   // 🔴 ESLint THROWS on an empty set (`NoFilesFoundError`) — the guard below simply never got
@@ -1063,7 +1192,7 @@ export async function run(
     log,
     err,
     where: relative(cwd, dirname(resolve(cwd, configPath ?? "."))) || ".",
-    opts,
+    opts: withPapers,
   });
 }
 

package/src/doctor.ts

@@ -37,9 +37,11 @@ import {
 import {
   LEGACY_CONFIG_KEY,
   LEGACY_KEY_MESSAGE,
+  LEGACY_PAPER_SETTINGS_FILE,
+  PAPER_SETTINGS_FILE,
   declaredSettings,
 } from "../lib/paper-config.mjs";
-import { PAPER_MARKERS } from "./build.ts";
+import { PAPER_MARKERS, papersIn } from "./build.ts";
 import { linkSkills, SKILLS_HOME, type LinkReport } from "./link-skills.ts";
 import { doctorHooks } from "./hooks-settings.ts";
 
@@ -233,6 +235,28 @@ function papersVerdict(
   return { lines: out, bad };
 }
 
+/**
+ * A pre-2.1.0 `venue.json` left in a paper: it is no longer read, so that paper's venue checks
+ * silently would not run if nothing named it. `init` moves it.
+ */
+function leftoverSettingsVerdict(
+  root: string,
+  papersDir: string | null,
+): { lines: string[]; bad: number } {
+  if (papersDir === null) return { lines: [], bad: 0 };
+  const lines = papersIn(resolve(root, papersDir), [
+    ...PAPER_MARKERS,
+    LEGACY_PAPER_SETTINGS_FILE,
+  ])
+    .map((dir) => join(dir, LEGACY_PAPER_SETTINGS_FILE))
+    .filter((f) => existsSync(f))
+    .map(
+      (f) =>
+        `  ✗ ${relative(root, f)} is no longer read — paperlint 2.1.0 renamed it ${PAPER_SETTINGS_FILE}, so this paper's venue checks do not run. \`npx paperlint init\` moves it`,
+    );
+  return { lines, bad: lines.length };
+}
+
 export interface DoctorOptions {
   log?: typeof console.log;
   cwd?: string;
@@ -293,8 +317,9 @@ export function doctor({
     `  the hooks will guard ${hookSays ?? "(nothing — the guard refuses and says why on first use)"}`,
   );
   const verdict = papersVerdict(root, cliPapers, hookSays);
-  out.push(...verdict.lines);
-  bad += verdict.bad;
+  const leftover = leftoverSettingsVerdict(root, cliPapers ?? hookSays);
+  out.push(...verdict.lines, ...leftover.lines);
+  bad += verdict.bad + leftover.bad;
 
   // A skill that is not linked is ADVISORY, like a missing program: `paperlint lint`, the hooks and CI
   // work without it, and an entry of the same name that `init` refused to replace is the

package/src/facts-file.test.ts

@@ -8,6 +8,9 @@
  * real banal is `test/e2e/banal.mjs`.
  */
 import assert from "node:assert/strict";
+import { readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { packageVenuesDir } from "../skills/paper-pipeline/scripts/consumer.mjs";
 import { test } from "vitest";
 import { memoryFiles } from "./adapters/memory/index.ts";
 import {
@@ -147,12 +150,23 @@ const good: PdfReader = async () => ({
   ok: true,
   facts: { pages: 2, fonts: FONTS, last: lastPage(60, 60), layout: [] },
 });
-/** Options over in-memory files: the PDF and venue.json on "disk", a measurer answering `geometry`. */
+/** The shipped presets at their real paths: `extends` resolves through the same Files port. */
+const SHIPPED_PRESETS = Object.fromEntries(
+  readdirSync(packageVenuesDir())
+    .filter((f) => /\.jsonc?$/.test(f))
+    .map((f) => [
+      join(packageVenuesDir(), f),
+      readFileSync(join(packageVenuesDir(), f)),
+    ]),
+);
+
+/** Options over in-memory files: the PDF and paperlint.json on "disk", a measurer answering `geometry`. */
 function setup(geometry: Geometry = NONE) {
   const files = memoryFiles({
     [PDF]: PDF_BYTES,
-    [`${PAPER}/venue.json`]: JSON.stringify({
-      venue: "agenticdev",
+    ...SHIPPED_PRESETS,
+    [`${PAPER}/paperlint.json`]: JSON.stringify({
+      extends: "paperlint:agenticdev",
       kind: "short",
     }),
   });
@@ -170,7 +184,7 @@ function setup(geometry: Geometry = NONE) {
   return { files, measured, o };
 }
 
-test("measure: venue and kind from venue.json, pdf relative to the paper, the file's sha256", async () => {
+test("measure: venue and kind from paperlint.json, pdf relative to the paper, the file's sha256", async () => {
   const { o } = setup();
   const m = await measurePaper(PAPER, PDF, o);
   assert.ok(m.ok);
@@ -233,8 +247,41 @@ test("writeFactsFile: <paper>/_build/paper.facts.json holds exactly the document
   assert.deepEqual(JSON.parse(text), m.value.facts);
 });
 
-test("declaredVenue: none without venue.json, none when it names no venue", () => {
+test("declaredVenue: none without paperlint.json; no label when it extends no preset", () => {
   assert.equal(declaredVenue(memoryFiles(), PAPER), null);
-  const files = memoryFiles({ [`${PAPER}/venue.json`]: '{"kind":"x"}' });
-  assert.equal(declaredVenue(files, PAPER), null);
+  const files = memoryFiles({
+    [`${PAPER}/paperlint.json`]: '{"kind":"x","pdf":"b/p.pdf"}',
+  });
+  assert.deepEqual(declaredVenue(files, PAPER), {
+    label: null,
+    kind: "x",
+    pdf: "b/p.pdf",
+  });
+});
+
+test("declaredVenue: the label is the preset's, and an extends that resolves nowhere is refused", () => {
+  const ok = memoryFiles({
+    ...SHIPPED_PRESETS,
+    [`${PAPER}/paperlint.json`]: '{"extends":"paperlint:aisec"}',
+  });
+  assert.equal(declaredVenue(ok, PAPER)?.label, "aisec");
+  const typo = memoryFiles({
+    ...SHIPPED_PRESETS,
+    [`${PAPER}/paperlint.json`]: '{"extends":"paperlint:aisek"}',
+  });
+  assert.throws(() => declaredVenue(typo, PAPER), /shipped presets/);
+});
+
+test("declaredVenue: a venue.json alone is refused with the command that moves it, not read", () => {
+  const files = memoryFiles({
+    [`${PAPER}/venue.json`]: '{"venue":"agenticdev"}',
+  });
+  assert.throws(() => declaredVenue(files, PAPER), /npx paperlint init/);
+});
+
+test("declaredVenue: a paperlint.json with an unknown key is refused, naming the key", () => {
+  const files = memoryFiles({
+    [`${PAPER}/paperlint.json`]: '{"venu":"agenticdev"}',
+  });
+  assert.throws(() => declaredVenue(files, PAPER), /unknown key "venu"/);
 });