paperlint 9.0.1 → 10.1.0

package/src/folder-layout-hook.test.ts

@@ -0,0 +1,214 @@
+/**
+ * The `paper-folder-layout` hook (`src/folder-layout-hook.ts`): a PreToolUse payload in, Claude Code's
+ * refusal out. Both halves: it denies creating a new entry the layout does not allow — at a paper
+ * folder's root or at the top of its `repro/`, and a study folder whose first file is not its
+ * README.md — with the rule's own text; it allows every existing file, every new file inside an
+ * existing entry, every allowed new entry, and anything outside a paper folder.
+ */
+import { describe, expect, it } from "vitest";
+import { memoryFiles, memoryListDir } from "./adapters/memory/index.ts";
+import {
+  folderLayoutHook,
+  paperFolderOf,
+  writtenPath,
+} from "./folder-layout-hook.ts";
+import { folderLayoutRules } from "./folder-layout-rule.ts";
+import { reproLayoutRules } from "./repro-layout-rule.ts";
+
+const DIR = "/work/papers/p";
+const PAPER = {
+  [`${DIR}/PIPELINE-STATUS.md`]: "# status\n",
+  [`${DIR}/paper.tex`]: "\\documentclass{article}\n",
+  [`${DIR}/paperlint.json`]: "{}\n",
+};
+
+/** A Write of `file`, which does not exist unless `tree` holds it, into the paper. */
+const writing = (
+  file: string,
+  tree: Record<string, string> = {},
+  tool = "Write",
+) => {
+  const files = memoryFiles({ ...PAPER, ...tree });
+  return folderLayoutHook(
+    {
+      hook_event_name: "PreToolUse",
+      tool_name: tool,
+      tool_input: { file_path: file },
+      cwd: "/work",
+    },
+    { files, listDir: memoryListDir(files) },
+  );
+};
+
+/** The reason a refusal gives, or null when the write is allowed. */
+const reason = (
+  file: string,
+  tree: Record<string, string> = {},
+  tool = "Write",
+): string | null =>
+  writing(file, tree, tool)?.hookSpecificOutput.permissionDecisionReason ??
+  null;
+
+/** What both rules report once `tree` is on disk, as message text. */
+function ruleSays(tree: Record<string, string>): string[] {
+  const files = memoryFiles({ ...PAPER, ...tree });
+  const deps = { files, listDir: memoryListDir(files) };
+  const out: string[] = [];
+  const report = (d: { readonly data: Record<string, unknown> }) =>
+    out.push(String(d.data["text"]));
+  const at = { getLocFromIndex: () => ({ line: 1, column: 0 }) };
+  const filename = `${DIR}/PIPELINE-STATUS.md`;
+  folderLayoutRules(deps)
+    ["allowed-files-only"].create({ filename, sourceCode: at, report })
+    .root?.();
+  reproLayoutRules(deps)
+    ["allowed-files-only"].create({ filename, sourceCode: at, report })
+    .root?.();
+  return out;
+}
+
+describe("paper-folder-layout hook — denies a new stray entry", () => {
+  it("a new PLAN.md at the root: a PreToolUse deny, the rule's text exactly", () => {
+    const out = writing(`${DIR}/PLAN.md`);
+    expect(out).toEqual({
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        permissionDecision: "deny",
+        permissionDecisionReason: ruleSays({ [`${DIR}/PLAN.md`]: "x" })[0],
+      },
+    });
+    expect(out?.hookSpecificOutput.permissionDecisionReason).toMatch(
+      /^`PLAN\.md` is at the root of a paper folder.*\n<paper>\/\n/su,
+    );
+  });
+
+  it("a file that would create a root folder the layout does not allow, naming the folder", () => {
+    expect(reason(`${DIR}/archive/2026/old.pdf`)).toBe(
+      ruleSays({ [`${DIR}/archive/2026/old.pdf`]: "x" })[0],
+    );
+  });
+
+  it("a loose script at the top of repro/, and an undated folder there", () => {
+    expect(reason(`${DIR}/repro/run.py`)).toBe(
+      ruleSays({ [`${DIR}/repro/run.py`]: "x" })[0],
+    );
+    expect(reason(`${DIR}/repro/run.py`)).toMatch(
+      /Where it goes: repro\/tools\//,
+    );
+    expect(
+      reason(`${DIR}/repro/baseline/run.py`, {
+        [`${DIR}/repro/README.md`]: "x",
+      }),
+    ).toMatch(/^`repro\/baseline\/` is loose at the top/);
+  });
+
+  it("a new study folder whose first file is not its README.md", () => {
+    expect(reason(`${DIR}/repro/ablation-2026-10-12/run.py`)).toMatch(
+      /^`repro\/ablation-2026-10-12\/` is a study folder without a README\.md/,
+    );
+  });
+
+  it("through an Edit and a MultiEdit too, and a path relative to the session's cwd", () => {
+    expect(reason(`${DIR}/NOTES-2.md`, {}, "Edit")).not.toBeNull();
+    expect(reason(`${DIR}/NOTES-2.md`, {}, "MultiEdit")).not.toBeNull();
+    const files = memoryFiles(PAPER);
+    expect(
+      folderLayoutHook(
+        { tool_input: { file_path: "papers/p/x.py" }, cwd: "/work" },
+        { files, listDir: memoryListDir(files) },
+      ),
+    ).not.toBeNull();
+  });
+});
+
+describe("paper-folder-layout hook — allows", () => {
+  it("🔴 any file that already exists, even one out of place: editing is never blocked", () => {
+    expect(reason(`${DIR}/PLAN.md`, { [`${DIR}/PLAN.md`]: "x" })).toBeNull();
+    expect(
+      reason(`${DIR}/repro/run.py`, { [`${DIR}/repro/run.py`]: "x" }),
+    ).toBeNull();
+  });
+
+  it("a new file inside an entry that already exists, even a stray one — the rule reports the entry", () => {
+    expect(
+      reason(`${DIR}/archive/new.pdf`, { [`${DIR}/archive/old.pdf`]: "x" }),
+    ).toBeNull();
+    expect(
+      reason(`${DIR}/repro/baseline/new.py`, {
+        [`${DIR}/repro/baseline/old.py`]: "x",
+      }),
+    ).toBeNull();
+  });
+
+  it("a new allowed entry: at the root, in an allowed folder, and in repro/'s layout", () => {
+    expect(reason(`${DIR}/NOTES.md`)).toBeNull();
+    expect(reason(`${DIR}/reviews/2026-10-12-x.md`)).toBeNull();
+    expect(reason(`${DIR}/extra/anything.bin`)).toBeNull();
+    expect(reason(`${DIR}/repro/README.md`)).toBeNull();
+    expect(reason(`${DIR}/repro/tools/paper_numbers.py`)).toBeNull();
+    expect(reason(`${DIR}/repro/data/numbers.tsv`)).toBeNull();
+  });
+
+  it("a new study folder started with its README.md, then any file in it", () => {
+    expect(reason(`${DIR}/repro/ablation-2026-10-12/README.md`)).toBeNull();
+    expect(
+      reason(`${DIR}/repro/ablation-2026-10-12/run.py`, {
+        [`${DIR}/repro/ablation-2026-10-12/README.md`]: "x",
+      }),
+    ).toBeNull();
+  });
+
+  it("🔴 anything under extra/, an archived paper with its own PIPELINE-STATUS.md included: lint never reads it", () => {
+    const snapshot = { [`${DIR}/extra/old/PIPELINE-STATUS.md`]: "# old\n" };
+    expect(reason(`${DIR}/extra/old/notes.txt`, snapshot)).toBeNull();
+    expect(
+      paperFolderOf(
+        `${DIR}/extra/old/notes.txt`,
+        memoryFiles({ ...PAPER, ...snapshot }),
+      ),
+    ).toBeNull();
+  });
+
+  it("a file outside every paper folder", () => {
+    expect(reason("/work/README.md")).toBeNull();
+    expect(reason("/work/papers/notes.md")).toBeNull();
+    expect(reason("/elsewhere/PLAN.md")).toBeNull();
+  });
+
+  it("a payload with no path it can read", () => {
+    const files = memoryFiles(PAPER);
+    const deps = { files, listDir: memoryListDir(files) };
+    expect(folderLayoutHook({}, deps)).toBeNull();
+    expect(folderLayoutHook({ tool_input: { file_path: 7 } }, deps)).toBeNull();
+    expect(folderLayoutHook(null, deps)).toBeNull();
+  });
+});
+
+describe("the cheap first step: the nearest folder holding PIPELINE-STATUS.md", () => {
+  const files = memoryFiles(PAPER);
+
+  it("is the paper folder for a file at its root or anywhere below", () => {
+    expect(paperFolderOf(`${DIR}/x.md`, files)).toBe(DIR);
+    expect(paperFolderOf(`${DIR}/a/b/c.md`, files)).toBe(DIR);
+  });
+
+  it("is null outside a paper folder, up to the file system's root", () => {
+    expect(paperFolderOf("/work/papers/x.md", files)).toBeNull();
+    expect(paperFolderOf("/x.md", files)).toBeNull();
+  });
+
+  it("reads the path from file_path, or notebook_path, made absolute against cwd", () => {
+    expect(writtenPath({ tool_input: { file_path: "/a/b.md" } })).toBe(
+      "/a/b.md",
+    );
+    expect(
+      writtenPath({ tool_input: { notebook_path: "n.ipynb" }, cwd: "/w" }),
+    ).toBe("/w/n.ipynb");
+    expect(writtenPath({ tool_input: {} })).toBeNull();
+    // A relative path needs an absolute cwd to mean anything: never the process's own.
+    expect(writtenPath({ tool_input: { file_path: "a.md" } })).toBeNull();
+    expect(
+      writtenPath({ tool_input: { file_path: "a.md" }, cwd: "w" }),
+    ).toBeNull();
+  });
+});

package/src/folder-layout-hook.ts

@@ -0,0 +1,141 @@
+/**
+ * The `paper-folder-layout` hook — `paper/allowed-files-only` and `repro/allowed-files-only` BEFORE a file is
+ * created, not at the next lint. PreToolUse on `Edit|Write|MultiEdit` (`plugin/hooks/hooks.json`):
+ * when the file about to be written does not exist yet and would add an entry the layout does not
+ * allow — at a paper folder's root, or at the top of its `repro/` — the call is denied, and the
+ * reason is the rule's own message: where the entry goes, and the layout drawn. The agent writes it
+ * where it belongs instead, in the same turn.
+ *
+ * ── WHAT IT NEVER BLOCKS ─────────────────────────────────────────────────────────
+ * - A file that already exists. Editing is never refused, wherever the file is: a paper whose
+ *   folder predates the layout keeps working, and the rule reports what is out of place.
+ * - A new file inside an entry that already exists, even one the layout does not allow: the entry is
+ *   not new, and the rule reports it once, by name. Only a NEW entry is refused.
+ * - Anything outside a paper folder (no `PIPELINE-STATUS.md` above it).
+ * A new study folder in `repro/` is created with its `README.md` first: any other first file in it
+ * is refused with `repro/allowed-files-only`'s "without a README.md" message.
+ *
+ * ── WHAT IT CANNOT SEE ───────────────────────────────────────────────────────────
+ * A shell command (`mv`, `cp`, a script writing files) is not an Edit or a Write, and this hook never
+ * sees it. The guarantee is the lint: both rules fail `paperlint lint`, in CI, whatever wrote the
+ * entry. The hook only saves the round trip. It does not read the paper's `rules` either: a paper
+ * that switched a layout rule off is still refused a new stray entry.
+ *
+ * ── ONE FUNCTION PER RULE, NOT TWO LISTS ─────────────────────────────────────────
+ * The texts are `strayTexts` (`src/folder-layout-rule.ts`) and `reproTexts`
+ * (`src/repro-layout-rule.ts`), the functions the rules report with.
+ *
+ * ── WHY IT IS NOT A VIGILES PROGRAM LIKE ITS NEIGHBOURS (measured 2026-10-12, vigiles 38) ──────
+ * A shipped `.hook.mjs` may import nothing but `vigiles/hook` (`checkHookImports`), so it cannot call
+ * this package's function; its only way to a tool is `run()`, whose output reaches stderr and never
+ * the hook's answer (`paper-status-gates.hook.mjs` measured that); and a `provide()` command runs
+ * before the reaction without the event, so it cannot know which file is written. Each of the three
+ * would mean a second copy of the layout. So `paperlint hook paper-folder-layout` runs this module
+ * in-process (`runHook`, src/cli.ts), behind the same wiring command as the other hooks, which is
+ * what `paperlint init` merges and `paperlint doctor` reads.
+ *
+ * ── THE CHEAP FIRST STEP ─────────────────────────────────────────────────────────
+ * Before reading any settings or listing any folder, the hook looks for the nearest folder above the
+ * file that holds `PIPELINE-STATUS.md` — the file every paper has and the rules are reported on — with
+ * one `isFile` per ancestor and nothing else: no git, no lint. No such folder: no output.
+ */
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { callerPath } from "./caller-path.ts";
+import { ESCAPE_HATCH } from "./domain/paper-layout.ts";
+import { README, REPRO_DIR, isStudyName } from "./domain/repro-layout.ts";
+import { fieldOf } from "./domain/record.ts";
+import { strayTexts, type FolderLayoutDeps } from "./folder-layout-rule.ts";
+import type { Files } from "./ports/files.ts";
+import { reproTexts } from "./repro-layout-rule.ts";
+
+/** The file every paper folder has, and the rules are reported on. */
+const STATUS_FILE = "PIPELINE-STATUS.md";
+
+/** What Claude Code reads from a PreToolUse hook's stdout to refuse the call, with the reason. */
+export interface HookOutput {
+  readonly hookSpecificOutput: {
+    readonly hookEventName: "PreToolUse";
+    readonly permissionDecision: "deny";
+    readonly permissionDecisionReason: string;
+  };
+}
+
+/** The target file's absolute path from the payload; null when there is none to read. */
+export function writtenPath(payload: unknown): string | null {
+  const input = fieldOf(payload, "tool_input");
+  const raw = fieldOf(input, "file_path") ?? fieldOf(input, "notebook_path");
+  if (typeof raw !== "string" || raw === "") return null;
+  if (isAbsolute(raw)) return resolve(raw);
+  const cwd = fieldOf(payload, "cwd");
+  return typeof cwd === "string" && isAbsolute(cwd) ? resolve(cwd, raw) : null;
+}
+
+/**
+ * The nearest folder above `file` holding `PIPELINE-STATUS.md`, up to the root; null when none, and
+ * null for anything under a folder named `extra/`, which lint never reads: an archived paper kept
+ * there carries its own status file and is not a paper to hold to the layout.
+ */
+export function paperFolderOf(file: string, files: Files): string | null {
+  // The same reach as lint's `**/extra/` ignore: a folder named extra/ anywhere above the file.
+  if (dirname(file).split(sep).includes(ESCAPE_HATCH)) return null;
+  const up = (dir: string): string | null => {
+    if (files.isFile(callerPath(join(dir, STATUS_FILE)))) return dir;
+    const parent = dirname(dir);
+    return parent === dir ? null : up(parent);
+  };
+  return up(dirname(file));
+}
+
+/** The entry `segments` would add under `dir`, as the layout judges it; null when it exists. */
+const newEntry = (
+  dir: string,
+  [name = "", ...below]: readonly string[],
+  deps: FolderLayoutDeps,
+): { readonly name: string; readonly kind: "file" | "dir" } | null =>
+  deps.listDir(callerPath(dir)).includes(name)
+    ? null
+    : { name, kind: below.length > 0 ? "dir" : "file" };
+
+/** Why creating `segments` (relative to the paper folder `dir`) breaks the layout; null when not. */
+function refusal(
+  dir: string,
+  segments: readonly string[],
+  deps: FolderLayoutDeps,
+): string | null {
+  const atRoot = newEntry(dir, segments, deps);
+  const [rootText] =
+    atRoot === null ? [] : strayTexts(dir, [atRoot], deps.files);
+  if (rootText !== undefined) return rootText;
+  const [top, ...inRepro] = segments;
+  if (top !== REPRO_DIR || inRepro.length === 0) return null;
+  const entry = newEntry(join(dir, REPRO_DIR), inRepro, deps);
+  // A new study folder starts with its README.md: that write is what makes it complete.
+  if (
+    entry === null ||
+    (isStudyName(entry.name) && inRepro.slice(1).join("/") === README)
+  )
+    return null;
+  const [text] = reproTexts(dir, [entry], deps.files);
+  return text ?? null;
+}
+
+/** The hook: the payload of an Edit or a Write in, Claude Code's refusal out, or null to allow. */
+export function folderLayoutHook(
+  payload: unknown,
+  deps: FolderLayoutDeps,
+): HookOutput | null {
+  const file = writtenPath(payload);
+  const dir = file === null ? null : paperFolderOf(file, deps.files);
+  if (file === null || dir === null || deps.files.isFile(callerPath(file)))
+    return null;
+  const reason = refusal(dir, relative(dir, file).split(/[\\/]/), deps);
+  return reason === null
+    ? null
+    : {
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          permissionDecision: "deny",
+          permissionDecisionReason: reason,
+        },
+      };
+}

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

@@ -0,0 +1,235 @@
+/**
+ * `paper/allowed-files-only` (`src/folder-layout-rule.ts`) on paper folders held in memory, run the way
+ * ESLint runs it: `create`, then `root`. Both halves: a stray file or folder at the paper's root is
+ * reported once each, on the first line of `PIPELINE-STATUS.md`; the scaffold, and what the paper's
+ * settings name at its root, are not.
+ */
+import { describe, expect, it } from "vitest";
+import { memoryFiles, memoryListDir } from "./adapters/memory/index.ts";
+import { KNOWN_CURES, strayMessage } from "./domain/paper-layout.ts";
+import {
+  FOLDER_LAYOUT_RULE_LEVELS,
+  declaredRoots,
+  folderLayoutRules,
+} from "./folder-layout-rule.ts";
+
+const DIR = "/work/papers/p";
+const SCAFFOLD = {
+  [`${DIR}/PIPELINE-STATUS.md`]: "# status\n",
+  [`${DIR}/paper.tex`]: "\\documentclass{article}\n",
+  [`${DIR}/paperlint.json`]: "{}\n",
+};
+
+interface Reported {
+  readonly messageId: string;
+  readonly message: string;
+  readonly line: number;
+}
+
+/** The rule over the folder `tree` describes, reached through `file` (default the scorecard). */
+function lint(
+  tree: Readonly<Record<string, string>>,
+  file = `${DIR}/PIPELINE-STATUS.md`,
+): Reported[] {
+  const files = memoryFiles(tree);
+  const rule = folderLayoutRules({
+    files,
+    listDir: memoryListDir(files),
+  })["allowed-files-only"];
+  const out: Reported[] = [];
+  const visitor = rule.create({
+    filename: 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;
+}
+
+describe("paper/allowed-files-only — reports", () => {
+  it("a stray file at the root, once, on the first line, with the one stray text", () => {
+    expect(lint({ ...SCAFFOLD, [`${DIR}/PLAN.md`]: "x" })).toEqual([
+      {
+        messageId: "stray",
+        message: strayMessage({
+          name: "PLAN.md",
+          kind: "file",
+          cure: KNOWN_CURES[0]?.cure ?? "",
+        }),
+        line: 1,
+      },
+    ]);
+  });
+
+  it("a stray folder, by its name with a slash, whatever it holds", () => {
+    expect(
+      lint({ ...SCAFFOLD, [`${DIR}/archive/old/x.pdf`]: "x" }).map(
+        (r) => r.message,
+      ),
+    ).toEqual([
+      expect.stringMatching(
+        /^`archive\/` is at the root of a paper folder.* Where it goes: versions\/ for frozen PDFs/,
+      ),
+    ]);
+  });
+
+  it("every stray entry, each once", () => {
+    expect(
+      lint({
+        ...SCAFFOLD,
+        [`${DIR}/a.pdf`]: "x",
+        [`${DIR}/data/x.json`]: "x",
+        [`${DIR}/run.py`]: "x",
+      }).length,
+    ).toBe(3);
+  });
+
+  it("a folder the settings name is allowed only while they name it", () => {
+    expect(
+      lint({ ...SCAFFOLD, [`${DIR}/video/talk.mp4`]: "x" }).map((r) =>
+        r.message.slice(0, 9),
+      ),
+    ).toEqual(["`video/` "]);
+  });
+});
+
+describe("paper/allowed-files-only — silent", () => {
+  it("on the scaffold `paperlint new` writes", () => {
+    expect(lint(SCAFFOLD)).toEqual([]);
+  });
+
+  it("on the allowed folders, whatever they hold, and on extra/", () => {
+    expect(
+      lint({
+        ...SCAFFOLD,
+        [`${DIR}/reviews/2026-10-12-x.md`]: "x",
+        [`${DIR}/repro/run.py`]: "x",
+        [`${DIR}/extra/anything/at/all.bin`]: "x",
+        [`${DIR}/_build/paper.facts.json`]: "{}",
+        [`${DIR}/paper.aux`]: "x",
+        [`${DIR}/refs.bib`]: "x",
+      }),
+    ).toEqual([]);
+  });
+
+  it("on what the settings name at the root: the PDF, the talk folder, the paper's own preset", () => {
+    expect(
+      lint({
+        ...SCAFFOLD,
+        [`${DIR}/paperlint.json`]: JSON.stringify({
+          extends: "./venue.jsonc",
+          pdf: "out/main.pdf",
+          talk: { mode: "remote-video", dir: "video" },
+        }),
+        [`${DIR}/venue.jsonc`]: "{}",
+        [`${DIR}/out/main.pdf`]: "x",
+        [`${DIR}/video/talk.mp4`]: "x",
+      }),
+    ).toEqual([]);
+  });
+
+  it("on any file but PIPELINE-STATUS.md: the folder is judged once per paper", () => {
+    expect(
+      lint({ ...SCAFFOLD, [`${DIR}/PLAN.md`]: "x" }, `${DIR}/paper.tex`),
+    ).toEqual([]);
+  });
+});
+
+describe("declaredRoots — what a paper's settings name at its root", () => {
+  const roots = (settings: object, tree: Record<string, string> = {}) =>
+    declaredRoots(
+      DIR,
+      memoryFiles({
+        [`${DIR}/paperlint.json`]: JSON.stringify(settings),
+        ...tree,
+      }),
+    );
+
+  it("the first segment of each path inside the folder", () => {
+    expect(
+      roots({
+        pdf: "build/out/paper.pdf",
+        talk: { mode: "remote-video", dir: "media/talk" },
+      }),
+    ).toEqual(["build", "media"]);
+  });
+
+  it("every cycle's own preset file, and none outside the folder or shipped", () => {
+    expect(
+      roots({
+        cycles: [
+          {
+            id: "a",
+            venue: { kind: "preset", extends: "./a.jsonc" },
+            opened: "2026-01-01",
+            deadlines: [],
+            outcome: {
+              kind: "rejected",
+              date: "2026-02-01",
+              evidence: "submission/a.eml",
+              desk: false,
+            },
+          },
+          {
+            id: "c",
+            venue: { kind: "named", name: "C", url: "https://c.example" },
+            opened: "2026-03-01",
+            deadlines: [],
+            outcome: {
+              kind: "withdrawn",
+              date: "2026-03-02",
+              evidence: "submission/c.eml",
+            },
+          },
+          {
+            id: "b",
+            venue: { kind: "preset", extends: "../shared/b.jsonc" },
+            opened: "2026-03-01",
+            deadlines: [],
+            outcome: { kind: "open" },
+          },
+        ],
+      }),
+    ).toEqual(["a.jsonc"]);
+  });
+});
+
+describe("declaredRoots — nothing to add", () => {
+  const roots = (settings: object) =>
+    declaredRoots(
+      DIR,
+      memoryFiles({ [`${DIR}/paperlint.json`]: JSON.stringify(settings) }),
+    );
+
+  it("nothing when the settings do not parse, or there are none", () => {
+    expect(roots({ venu: "x" })).toEqual([]);
+    expect(declaredRoots(DIR, memoryFiles({}))).toEqual([]);
+  });
+
+  it("an absolute path inside the folder counts; the folder itself, or a path outside it, does not", () => {
+    expect(
+      roots({
+        pdf: `${DIR}/out/paper.pdf`,
+        talk: { mode: "remote-video", dir: "." },
+      }),
+    ).toEqual(["out"]);
+    expect(roots({ pdf: "/elsewhere/paper.pdf" })).toEqual([]);
+  });
+
+  it("a shipped preset names no file", () => {
+    expect(roots({ extends: "paperlint:aidc" })).toEqual([]);
+  });
+});
+
+it("is on at error in paperlint's own config", () => {
+  expect(FOLDER_LAYOUT_RULE_LEVELS).toEqual({
+    "paper/allowed-files-only": "error",
+  });
+});