paperlint 4.0.0 → 4.1.0

package/scripts/check.ts

@@ -34,9 +34,11 @@
  * (no TeX, no network), and the tail names every skip. "I ran check" then means one thing.
  */
 import { spawnSync } from "node:child_process";
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
 import { delimiter, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { z } from "zod";
 import { isMain } from "../skills/paper-pipeline/scripts/consumer.mjs";
 
 const ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
@@ -72,11 +74,17 @@ type GateCommand =
       readonly script: string;
       readonly run?: undefined;
       readonly inCi?: RunInCi;
+      /**
+       * The script is a vitest run, so its JSON report says how many tests were SKIPPED: a run
+       * whose exit is 0 and whose report counts a skip is a skip, not a pass.
+       */
+      readonly vitest?: true;
     }
   | {
       readonly run: readonly [string, ...string[]];
       readonly script?: undefined;
       readonly inCi?: undefined;
+      readonly vitest?: undefined;
     };
 
 /**
@@ -160,22 +168,14 @@ export const GATES: readonly Gate[] = [
   {
     name: "install e2e — pack, install under npm and pnpm, run the binary",
     job: "gates",
-    run: ["node", "test/e2e/install.ts"],
+    script: "test:e2e:install",
+    vitest: true,
   },
   {
-    name: "build e2e — a real pdflatex, and the PDF's fonts are measured",
+    name: "TeX e2e — real TeX Live: paperlint toolchain, a real pdflatex build of every fixture, the real banal",
     job: "build-e2e",
-    run: ["node", "test/e2e/build.ts"],
-  },
-  {
-    name: "banal e2e — the real banal on pdf.js-written XML gives banal-on-pdftohtml's numbers",
-    job: "build-e2e",
-    run: ["node", "test/e2e/banal.ts"],
-  },
-  {
-    name: "toolchain e2e — real TeX Live into $PAPERLINT_TEXLIVE_DIR, then a build with only it on PATH",
-    job: "build-e2e",
-    run: ["node", "test/e2e/toolchain.ts"],
+    script: "test:e2e:tex",
+    vitest: true,
   },
 ];
 
@@ -205,18 +205,41 @@ export const NOT_COVERED: Readonly<Record<string, string>> = {
 };
 
 /**
- * Exit 77 means "declared skip" — the same code vigiles' runner uses (`SKIP_EXIT_CODE`). The e2e steps exit 77 when a tool they need is
- * absent and --strict is off. Anything else nonzero is a failure.
+ * vitest's JSON report, as far as the verdict reads it: skipped (`pending`) and `todo` tests.
  *
- * 🔴 A SKIP IS A THIRD OUTCOME. Until the Codex review on #45 the e2e steps exited 0 on a skip,
- * this loop counted that as a pass, and `skipped` below was declared and never filled: a machine
- * without pnpm or TeX printed "all gates passed" for runs that never happened.
+ * 🔴 A SKIP IS A THIRD OUTCOME. Until the Codex review on #45 the e2e runs exited 0 on a skip and
+ * this loop counted that as a pass: a machine without pnpm or TeX printed "all gates passed" for
+ * runs that never happened. The count comes from the runner's own report, not from an exit code
+ * the tests would have to agree on.
  */
-export const SKIP_EXIT: number = 77;
-export function outcome(status: number | null): Outcome {
-  if (status === 0) return "pass";
-  if (status === SKIP_EXIT) return "skip";
-  return "fail";
+const VitestReport = z.looseObject({
+  numPendingTests: z.number().int().nonnegative(),
+  numTodoTests: z.number().int().nonnegative(),
+});
+
+/** How many tests a vitest JSON report says were not run, or null when it is not one. */
+export function skippedIn(report: string | null): number | null {
+  if (report === null) return null;
+  try {
+    const r = VitestReport.safeParse(JSON.parse(report));
+    return r.success ? r.data.numPendingTests + r.data.numTodoTests : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * A gate's outcome from its exit status and, for a vitest gate, the skip count its report gave
+ * (`null`: the report is missing or unreadable, which cannot be read as a pass).
+ */
+export function outcome(
+  status: number | null,
+  vitest?: { readonly skipped: number | null },
+): Outcome {
+  if (status !== 0) return "fail";
+  if (vitest === undefined) return "pass";
+  if (vitest.skipped === null) return "fail";
+  return vitest.skipped > 0 ? "skip" : "pass";
 }
 
 /** The gates that did not pass, each as the line the verdict prints, split by outcome. */
@@ -225,11 +248,29 @@ interface NotPassed {
   skipped: string[];
 }
 
+/** A report file's text, read once and removed; null when the run wrote none. */
+export type ReadReport = (file: string) => string | null;
+const readReport: ReadReport = (file) => {
+  if (!existsSync(file)) return null;
+  const text = readFileSync(file, "utf8");
+  rmSync(file, { force: true });
+  return text;
+};
+
+/** The arguments that make a vitest gate write its JSON report to `file`, beside the usual output. */
+export const reportArgs = (file: string): string[] => [
+  "--",
+  "--reporter=default",
+  "--reporter=json",
+  `--outputFile.json=${file}`,
+];
+
 /** Run each gate in order; `write` announces it before it starts. */
 function runEach(
   gates: readonly Gate[],
   spawn: Spawn,
   write: (text: string) => unknown,
+  reportOf: ReadReport,
 ): NotPassed {
   const BIN_FIRST_PATH = [join(ROOT, "node_modules", ".bin"), process.env.PATH]
     .filter(Boolean)
@@ -237,10 +278,14 @@ function runEach(
   const failed: string[] = [];
   const skipped: string[] = [];
 
-  for (const g of gates) {
+  for (const [i, g] of gates.entries()) {
     write(`── ${g.name}\n`);
     const [cmd, ...args] = commandOf(g);
-    const r = spawn(cmd, args, {
+    const file = join(
+      tmpdir(),
+      `paperlint-check-${String(process.pid)}-${String(i)}.json`,
+    );
+    const r = spawn(cmd, g.vitest ? [...args, ...reportArgs(file)] : args, {
       cwd: ROOT,
       stdio: "inherit",
       encoding: "utf8",
@@ -249,12 +294,18 @@ function runEach(
     // 🔴 The exit code is read from the command itself, never from a pipe. `cmd | tail && …`
     // reports the FILTER's status, which is almost always zero — that is how a red harness
     // shipped on 2026-09-16.
-    const o = outcome(r.status);
+    const skips = g.vitest ? { skipped: skippedIn(reportOf(file)) } : undefined;
+    const o = outcome(r.status, skips);
     if (o === "pass") continue;
     const shown = commandOf(g).join(" ");
     if (o === "skip")
-      skipped.push(`${g.name}  (${shown} → ${String(SKIP_EXIT)})`);
-    else failed.push(`${g.name}  (${shown} → ${String(r.status)})`);
+      skipped.push(
+        `${g.name}  (${shown} → ${String(skips?.skipped)} test(s) skipped)`,
+      );
+    else
+      failed.push(
+        `${g.name}  (${shown} → ${r.status === 0 ? "exit 0, but no vitest JSON report to read skips from" : String(r.status)})`,
+      );
   }
   return { failed, skipped };
 }
@@ -299,14 +350,16 @@ export function runGates({
   log = console.log,
   err = console.error,
   write = (s: string) => process.stdout.write(s),
+  reportOf = readReport,
 }: {
   gates?: readonly Gate[];
   spawn?: Spawn;
   log?: (line: string) => void;
   err?: (line: string) => void;
   write?: (text: string) => unknown;
+  reportOf?: ReadReport;
 } = {}): number {
-  const notPassed = runEach(gates, spawn, write);
+  const notPassed = runEach(gates, spawn, write, reportOf);
   report(gates, notPassed, { log, err });
   return notPassed.failed.length ? 1 : 0;
 }

package/scripts/test.test.ts

@@ -24,7 +24,7 @@ test("a failing vitest does not skip the harnesses, and is named as the failure"
     1,
   );
   assert.deepEqual(calls, [
-    ["vitest", "run"],
+    ["vitest", "run", "--project", "unit"],
     ["vigiles", "test", "--min=1", "--no-skip"],
   ]);
   assert.deepEqual(said, [

package/scripts/test.ts

@@ -46,7 +46,7 @@ export function withSources(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv {
 }
 
 export const SUITES: readonly Suite[] = [
-  { name: "vitest", command: ["vitest", "run"] },
+  { name: "vitest", command: ["vitest", "run", "--project", "unit"] },
   { name: "harnesses", command: ["vigiles", "test", "--min=1"] },
 ];
 

package/skills/paper-pipeline/PIPELINE-MAP.md

@@ -200,7 +200,7 @@ format.
 ## 3. Venue constants belong in a card, not in code
 
 > **Done (#79, 2.1.0), in a different shape than planned below.** The constants live in **venue
-> presets**, JSONC files in `submit-paper/references/venues/`: `acm-sigconf.jsonc` is the ACM
+> presets**, JSONC files in the package's `presets/`: `acm-sigconf.jsonc` is the ACM
 > family (the `format` block — page size, columns, fonts, font sizes — plus the `tex` packages),
 > `agenticdev.jsonc` and `aisec.jsonc` extend it and add their `kinds` (page limits) and `rules`,
 > `realm.jsonc` stands alone. A paper picks one in `<paper>/paperlint.json`
@@ -332,7 +332,7 @@ point. Nothing to check.
 | page limit           | **4**           | `venues/realm.md` 8 · `build-submission.sh` 8 · `PIPELINE-STATUS` "8/8" · the build prints **9**                                      |
 | the TeX package list | **5**           | `ensure-toolchain.sh` (executable) · `SKILL.md` · `render-paper.harness.mjs` (pins it ✅) · `build-submission.sh` · `PIPELINE-STATUS` |
 
-The canonical source is the venue preset (`venues/<name>.jsonc`, resolved through its `extends`
+The canonical source is the venue preset (`presets/<name>.jsonc`, resolved through its `extends`
 chain): its `format` block for the numbers (page size, columns, fonts, font sizes, and `kinds` for
 page limits), its `tex` block (plus `tex-base.jsonc`) for packages — since 2026-09-24;
 `ensure-toolchain.sh` held them until then — and its `rules` block for the checks the venue

package/skills/paper-pipeline/SKILL.md

@@ -4,7 +4,7 @@ description: The orchestrator for writing a research paper end-to-end, from idea
 allowed-tools: [Read, Write, Edit, Grep, Glob, Bash, WebSearch, WebFetch, Agent, Skill]
 ---
 
-<!-- vigiles:sha256:a15a3fcf5fdfedf7 compiled from skills/paper-pipeline/SKILL.md.spec.ts -->
+<!-- vigiles:sha256:c3eea3ac60e9c816 compiled from skills/paper-pipeline/SKILL.md.spec.ts -->
 
 # paper-pipeline — the conductor for the whole organism
 
@@ -30,7 +30,7 @@ of that — who is filing what, and when — stays in the author's own private n
   space, anonymity, OpenReview mechanics. Fetch once, not per paper. Venue-specific facts stay in
   `submit-paper/references/venues/<venue>.md`. (No prose equivalent yet for ACM or IEEE — write one
   when the next paper goes there. ACM's machine-checked format already exists: the
-  `paperlint:acm-sigconf` preset, `submit-paper/references/venues/acm-sigconf.jsonc`.)
+  `paperlint:acm-sigconf` preset, `presets/acm-sigconf.jsonc` in the package.)
 
 ## The readiness scorecard (which boxes are checked)
 Stages run in subagents and report into chat, which evaporates — so "did everything run?" becomes

package/skills/paper-pipeline/SKILL.md.spec.ts

@@ -47,7 +47,7 @@ of that — who is filing what, and when — stays in the author's own private n
   space, anonymity, OpenReview mechanics. Fetch once, not per paper. Venue-specific facts stay in
   \`submit-paper/references/venues/<venue>.md\`. (No prose equivalent yet for ACM or IEEE — write one
   when the next paper goes there. ACM's machine-checked format already exists: the
-  \`paperlint:acm-sigconf\` preset, \`submit-paper/references/venues/acm-sigconf.jsonc\`.)
+  \`paperlint:acm-sigconf\` preset, \`presets/acm-sigconf.jsonc\` in the package.)
 
 ## The readiness scorecard (which boxes are checked)
 Stages run in subagents and report into chat, which evaporates — so "did everything run?" becomes

package/skills/paper-pipeline/scripts/consumer.d.mts

@@ -32,8 +32,6 @@ export interface SkillsFs {
 }
 export declare function installedSkills(dir: string, fs?: SkillsFs): string[];
 
-/** The directory of venue TeX files this package ships; `paperlint build` prepends it to TEXINPUTS. */
-export declare function packageVenuesDir(): string;
 export declare const SHIPPED_SKILLS_DIR: string;
 export declare const PACKAGE_NAME: "paperlint";
 export declare const BIN_FILE: "bin/paperlint.mjs";

package/skills/paper-pipeline/scripts/consumer.mjs

@@ -57,7 +57,7 @@ import {
   statSync,
 } from "node:fs";
 import { join, resolve, sep } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
+import { pathToFileURL } from "node:url";
 
 // Re-exported, not re-declared — see the note in `lib/paper-config.mjs`. This file is not a hook
 // and never needed its own copy.
@@ -98,20 +98,6 @@ export function consumerRoot({ env = process.env, cwd = process.cwd() } = {}) {
   return env.CLAUDE_PROJECT_DIR || cwd;
 }
 
-/**
- * The directory of venue TeX files THIS PACKAGE ships — `paper-guards.tex` and each venue's
- * `<venue>.tex` — which a paper's preamble `\input`s and `paperlint build` puts on `TEXINPUTS`.
- *
- * Resolved from this file's own location, never from the caller's cwd: the directory travels
- * with the package, wherever the package is installed (own checkout, `node_modules`, a plugin
- * cache). `import.meta.url` is the realpath, so a symlinked skills directory changes nothing.
- */
-export function packageVenuesDir() {
-  return fileURLToPath(
-    new URL("../../submit-paper/references/venues", import.meta.url),
-  );
-}
-
 /**
  * The package's npm name — the directory it lands in under `node_modules`, and the name Node
  * resolves it by. Every path into the installed package is built from this, never re-spelled;

package/skills/render-paper/SKILL.md

@@ -4,7 +4,7 @@ description: Compile a LaTeX paper (ACM/IEEE/arXiv) to PDF and render its pages
 allowed-tools: [Read, Write, Edit, Grep, Glob, Bash, SendUserFile]
 ---
 
-<!-- vigiles:sha256:a1ec1d392f144c80 compiled from skills/render-paper/SKILL.md.spec.ts -->
+<!-- vigiles:sha256:5e2ee8850c098375 compiled from skills/render-paper/SKILL.md.spec.ts -->
 
 # render-paper — .tex → PDF → readable page PNGs
 
@@ -34,7 +34,7 @@ That list was replaced on 2026-08-03; nothing about the toolchain below changed.
   by `kpsewhich` against the files each profile names. The last line it prints is `bin: <dir>` —
   put that directory first on PATH before calling `pdflatex` or `check-render.sh` by hand.
 
-  🔴 The package list lives in the venue profiles (`submit-paper/references/venues/*.jsonc`, the
+  🔴 The package list lives in the venue profiles (`presets/*.jsonc` in the package, the
   `tex` block; `tex-base.jsonc` for every paper) and nowhere else. A new venue that needs a new
   package gets it there — never in a script, never here. A TeX Live without `libertine` builds an
   acmart paper GREEN in Computer Modern; that is why the files are checked, not the exit code.

package/skills/render-paper/SKILL.md.spec.ts

@@ -40,7 +40,7 @@ That list was replaced on 2026-08-03; nothing about the toolchain below changed.
   by \`kpsewhich\` against the files each profile names. The last line it prints is \`bin: <dir>\` —
   put that directory first on PATH before calling \`pdflatex\` or \`check-render.sh\` by hand.
 
-  🔴 The package list lives in the venue profiles (\`submit-paper/references/venues/*.jsonc\`, the
+  🔴 The package list lives in the venue profiles (\`presets/*.jsonc\` in the package, the
   \`tex\` block; \`tex-base.jsonc\` for every paper) and nowhere else. A new venue that needs a new
   package gets it there — never in a script, never here. A TeX Live without \`libertine\` builds an
   acmart paper GREEN in Computer Modern; that is why the files are checked, not the exit code.

package/skills/render-paper/check-render.sh

@@ -25,75 +25,28 @@ set -uo pipefail
 # check — that is, the defect the guard was set up for comes back together with a green report.
 # A broken `import` in JS fails loudly; here we have to fail on our own.
 #
-# A ladder of THREE candidates, because the directory MOVED (12.09): `venues/` is now carried by the
-# `paperlint` package, and at the consumer's old location there is a symlink into it.
-# The order "the declared package → a sibling inside the package → the consumer's directory" is
-# deliberate: the package must win silently. It only gets loud when there is NOT A SINGLE ONE.
-# 🔴 THE SCRIPT'S OWN DIRECTORY — TAKEN ABSOLUTE AND BEFORE ANY `cd` (12.09.2026, evening).
-# Found by a RED HARNESS, `gates.harness.mjs`, not by proofreading, and it is my own regression from
-# the same day: below, the script does `cd "$DIR"` into the paper directory, and the venues resolve
-# stood AFTER that `cd`. So `git rev-parse --show-toplevel` was already running in the fixture's
-# temporary directory, the root was not found, and the build honestly stopped — on a test that had
-# been passing until then.
+# TWO candidates, in this order: the package by its NAME, from the current directory (a consumer's
+# installed paperlint wins), then the package THIS script ships in. Loud only when neither holds it.
 #
-# ⚠️ The previous version was wrong THE SAME WAY, but silently: it did not check the result and built
-# the PDF without the reference guard. That is, going red is not a new breakage but a manifestation
-# of an old one; still, a test that was green yesterday and is red today is mine to fix.
-#
-# The neighbouring `build.sh` already carries this same lesson in a comment ("The script directory is
-# taken ONCE and ABSOLUTE, before cd") — CI failed on it there on 30.08. A second instance of the same
-# class in a file right next door.
+# 🔴 THE SCRIPT'S OWN DIRECTORY IS TAKEN ABSOLUTE AND BEFORE ANY `cd`: below, the script `cd`s into
+# the paper directory, and a lookup after that would start from the paper, not from here.
 SELF_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
 
 resolve_venues() {
-  local root pkg
-  # Three sources for the root, from the most explicit to the most reliable. The last one is the
-  # SCRIPT's location (`.claude/skills/render-paper/` ⇒ three levels up), and it is the only one that
-  # depends neither on the current directory nor on whether the caller sits inside a git tree.
-  # ⚠️ THE PARENTHESES ARE MANDATORY, and the harness caught this a minute after I wrote the line
-  # without them. In bash `A || B && C` parses as `(A || B) && C`, so on a SUCCESSFUL `git rev-parse`
-  # the `pwd` ran as well, and the substitution returned TWO lines — the repository root plus the
-  # current directory. By hand from a directory outside git this did not reproduce: there git failed,
-  # and only one branch ran.
-  # ⚠️ THE LAST RUNG SEARCHES, IT DOES NOT COUNT LEVELS. `cd "$SELF_DIR/../../.."` used to stand here
-  # — correct for `.claude/skills/render-paper/` (three levels to the root) and silently wrong after
-  # the skill moved into the package, where it lies in `skills/render-paper/` (two): the climb
-  # overshot ABOVE the repository, and rung 2 looked for venues in someone else's directory. Climbing
-  # up to the directory that holds `.claude` does not depend on the depth.
-  local probe="$SELF_DIR" fallback=""
-  while [ "$probe" != "/" ]; do
-    if [ -d "$probe/.claude" ]; then fallback="$probe"; break; fi
-    probe=$(dirname "$probe")
-  done
-  root="${CLAUDE_PROJECT_DIR:-$(git rev-parse --show-toplevel 2>/dev/null || printf '%s' "$fallback")}"
-
-  # 1) the package, if it already carries venues/ (after step 5)
-  pkg=$(node -e 'try{process.stdout.write(require.resolve("paperlint/venues/paper-guards.tex"))}catch{}' 2>/dev/null || true)
+  local pkg own
+  # 1) the package by its name. `node -e` resolves from the current directory.
+  pkg=$(node -e 'try{process.stdout.write(require.resolve("paperlint/presets/tex/paper-guards.tex"))}catch{}' 2>/dev/null || true)
   if [ -n "$pkg" ] && [ -f "$pkg" ]; then
     dirname "$pkg"
     return 0
   fi
 
-  # 2) THE SIBLING SKILL, from THIS script's directory. Added 12.09 together with the move of
-  # `submit-paper` into the package, and it is the only one of the three that works in BOTH worlds at
-  # once:
-  #   • package checkout   `skills/render-paper/..` → `skills/submit-paper/references/venues`
-  #   • consumer           `.claude/skills/render-paper/..` → `.claude/skills/submit-paper/...`
-  #     (both directories are symlinks into the package, `-f` goes through them, and `cd`+`pwd`
-  #     leaves the logical path)
-  # Rung 1 depends on cwd (`node -e` resolves from the current directory), rung 3 depends on the
-  # consumer's root having been found at all. This one depends on neither — exactly the anchor whose
-  # absence had `gates.harness.mjs` red on 12.09.
-  local sibling="$SELF_DIR/../submit-paper/references/venues"
-  if [ -f "$sibling/paper-guards.tex" ]; then
-    (cd "$sibling" && pwd)
-    return 0
-  fi
-
-  # 3) the skill directory in the consumer — for a consumer that mounted the skills differently
-  local local_dir="$root/.claude/skills/submit-paper/references/venues"
-  if [ -f "$local_dir/paper-guards.tex" ]; then
-    printf '%s\n' "$local_dir"
+  # 2) the package this script is part of: `skills/render-paper/` → `presets/tex/`. `cd -P` follows
+  # the symlinks a consumer's `.claude/skills/render-paper` is made of, so `../..` is the PACKAGE's
+  # root, not the consumer's `.claude/`. Depends neither on the cwd nor on a git tree.
+  own="$(cd -P "$SELF_DIR" && pwd)/../../presets/tex"
+  if [ -f "$own/paper-guards.tex" ]; then
+    (cd "$own" && pwd)
     return 0
   fi
 
@@ -107,8 +60,8 @@ if [ "${1:-}" = "--print-venues" ]; then
     printf '%s\n' "$VD"
     exit 0
   fi
-  echo "✗ paper-guards.tex not found: not under the package name paperlint, not beside the script" >&2
-  echo "  (skills/submit-paper/references/venues), not at the consumer (.claude/skills/submit-paper/references/venues)." >&2
+  echo "✗ paper-guards.tex not found: not under the package name paperlint (paperlint/presets/tex)," >&2
+  echo "  not in the package this script ships in (../../presets/tex from it)." >&2
   echo "  Building the paper without it is not allowed: \\input{paper-guards} will not fail, it will vanish silently," >&2
   echo "  and the PDF will be built WITHOUT the check for dangling \\ref and \\cite." >&2
   exit 2
@@ -135,7 +88,7 @@ if [ "${NO_COMPILE:-0}" != "1" ] && [ -f "$BASE.tex" ]; then
   # Two passes: overfull boxes surface on every pass; a second pass settles refs
   # so Reference/Citation-undefined warnings are accurate.
   # 🔴 TEXINPUTS is mandatory, and that was found by a crash on 26.08. Papers pull in their venue's
-  # numbers via `\input{<venue>}`, and the file lies in `.claude/skills/submit-paper/references/venues/`.
+  # numbers via `\input{<venue>}`, and the file lies in the package's `presets/tex/`.
   # Without that path the build fails with `File \`agenticdev.tex' not found` — and the `|| true`
   # below swallows it, after which the script reads a log of UNKNOWN origin and reports on it. That
   # is, compiling this paper here silently did not work, and it only became visible once a pass

package/skills/render-paper/render-paper.harness.mjs

@@ -68,34 +68,11 @@ await checkSkill("render-paper");
   const run = (args, opts = {}) =>
     spawnSync("bash", [CHECK, ...args], { encoding: "utf8", ...opts });
 
-  // First half — on TODAY's tree, resolution must succeed IF THERE IS ANYTHING TO
-  // resolve.
-  //
-  // 🔴 THERE USED TO BE AN UNCONDITIONAL `assert.equal(status, 0)` HERE, AND THE MOVE BROKE IT —
-  // for a real reason, not by accident. It relied on the SURROUNDING tree: while the skill lived
-  // at the consumer, the second rung of the ladder won
-  // (`.claude/skills/submit-paper/references/venues/`). The package checkout has neither that nor
-  // the first rung — `venues/` arrives together with `submit-paper`, which hasn't moved yet. So
-  // the assertion wasn't checking resolution, it was checking for the presence of an unrelated
-  // directory nearby.
-  //
-  // The form now is: resolution must succeed IF AND ONLY IF at least one candidate exists on
-  // disk. This is still a real assertion — it fails if a candidate exists and the script didn't
-  // find it — but it stops requiring the existence of something this repository doesn't have yet.
-  // The absence of both candidates gets PRINTED, not swallowed: "the check found nothing to
-  // check" and "the check passed" have to look different.
+  // First half — on this tree, resolution must succeed IF AND ONLY IF a candidate exists on disk:
+  // the package's own `presets/tex/`. The absence of it is PRINTED, not swallowed: "the check found
+  // nothing to check" and "the check passed" have to look different.
   const candidates = [
-    // rung 1 — the package
-    join(HERE, "..", "..", "venues", "paper-guards.tex"),
-    // rung 2 — the skill directory at the consumer
-    join(
-      HERE,
-      "..",
-      "submit-paper",
-      "references",
-      "venues",
-      "paper-guards.tex",
-    ),
+    join(HERE, "..", "..", "presets", "tex", "paper-guards.tex"),
   ].filter((c) => existsSync(c));
 
   const ok = run(["--print-venues"]);
@@ -108,9 +85,8 @@ await checkSkill("render-paper");
         `silent success this whole block was written to catch.`,
     );
     console.log(
-      `  --print-venues: NOT VERIFIED on the live tree — paper-guards.tex is absent from both ` +
-        `the package (venues/) and next to it (submit-paper/references/venues/). It arrives with ` +
-        `\`submit-paper\`; until then only the fixtures below hold this half.`,
+      `  --print-venues: NOT VERIFIED on the live tree — paper-guards.tex is absent from the ` +
+        `package's presets/tex/; only the fixtures below hold this half.`,
     );
   } else {
     assert.equal(
@@ -159,18 +135,9 @@ await checkSkill("render-paper");
   // When the file is NOWHERE, the script must exit with code 2 and say why. A silent success here
   // is exactly the defect the whole ladder was written for.
   //
-  // 🔴 RUN AGAINST A COPY OF THE SCRIPT, AND THIS IS NOT A TEST WORKAROUND, IT'S A CONSEQUENCE OF
-  // THE MOVE (09-12, wave ③). Before `submit-paper` moved, "nowhere" was reproduced by an empty
-  // consumer root: both former rungs looked outward (the package name from cwd · `.claude/` under
-  // the root), and an empty directory found nothing at either. Now the script has a rung anchored
-  // to ITS OWN directory (`$SELF_DIR/../submit-paper/references/venues`) — added for
-  // cwd-independence — so as long as the script sits inside the package, venues next to it exist
-  // ALWAYS, and "nowhere" can no longer be reached through the environment. The only honest way to
-  // demonstrate that state is to move the script itself out of the package. The property being
-  // checked is otherwise identical, word for word: nothing resolved ⇒ exit 2 + the name of the
-  // missing file. ⚠️ What this form no longer checks: that an empty consumer root won't make the
-  // script lie — and it shouldn't, because such a root is now legitimately shadowed by the copy in
-  // the package.
+  // 🔴 RUN AGAINST A COPY OF THE SCRIPT. Inside the package its second rung (the package it ships
+  // in) always holds the file, so "nowhere" is reachable only by moving the script out of the
+  // package: nothing resolved ⇒ exit 2 + the name of the missing file.
   const empty = realpathSync(mkdtempSync(join(tmpdir(), "venues-none-")));
   const lonely = join(empty, "check-render.sh");
   copyFileSync(CHECK, lonely);
@@ -190,30 +157,21 @@ await checkSkill("render-paper");
     "the failure message must name the missing file",
   );
 
-  // Third half — the ORDER of the rungs. Not cosmetic: on the day of the move, both rungs will be
-  // true at once, and the package has to win, otherwise the consumer silently keeps building with
-  // their old copy. Plant BOTH candidates and see which one is chosen.
+  // Third half — the ORDER of the rungs. The package the consumer installed, found by its name,
+  // must win over the copy this script ships in; otherwise a consumer silently builds with a stale
+  // copy. Plant a package by name beside the real script and see which one is chosen.
   const both = realpathSync(mkdtempSync(join(tmpdir(), "venues-both-")));
-  const pkgVenues = join(both, "node_modules", "paperlint", "venues");
-  const skillVenues = join(
-    both,
-    ".claude",
-    "skills",
-    "submit-paper",
-    "references",
-    "venues",
-  );
-  for (const d of [pkgVenues, skillVenues]) mkdirSync(d, { recursive: true });
+  const pkgVenues = join(both, "node_modules", "paperlint", "presets", "tex");
+  mkdirSync(pkgVenues, { recursive: true });
   writeFileSync(
     join(both, "node_modules", "paperlint", "package.json"),
     JSON.stringify({
       name: "paperlint",
       version: "0.0.0",
-      exports: { "./venues/*": "./venues/*" },
+      exports: { "./*": "./*" },
     }),
   );
   writeFileSync(join(pkgVenues, "paper-guards.tex"), "% from package\n");
-  writeFileSync(join(skillVenues, "paper-guards.tex"), "% from skill dir\n");
   const race = run(["--print-venues"], {
     cwd: both,
     env: { ...process.env, CLAUDE_PROJECT_DIR: both },
@@ -226,7 +184,7 @@ await checkSkill("render-paper");
   assert.equal(
     race.stdout.trim(),
     pkgVenues,
-    "with both candidates present, the PACKAGE wins, not the skill directory",
+    "with both candidates present, the INSTALLED package wins, not the copy the script ships in",
   );
 }
 
@@ -276,7 +234,7 @@ await checkSkill("render-paper");
     );
     assert.match(
       build,
-      /require\.resolve\("paperlint\/venues\/paper-guards\.tex"\)/,
+      /require\.resolve\("paperlint\/presets\/tex\/paper-guards\.tex"\)/,
       `${where}: the ladder's first rung (the package) must remain`,
     );
     assert.match(

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

@@ -2,7 +2,7 @@
  * `adapters/banal/index.ts` — banal as the two ports the app sees. What `run.test.ts` checks in
  * banal's own terms is checked here as the domain receives it: a `Geometry` whose provenance names
  * banal and the rule that found it, a reason that is one line of text, a `Ready` that says what was
- * verified. In-memory ports throughout; the real banal is `test/e2e/banal.ts`.
+ * verified. In-memory ports throughout; the real banal is `test/e2e/tex/banal.e2e.ts`.
  */
 import assert from "node:assert/strict";
 import { test } from "vitest";

package/src/adapters/banal/invocation.ts

@@ -7,7 +7,7 @@
  * (`Error: Failed to run pdftohtml`, measured); told a version below 0.85 it applies a larger
  * correction and every font size moves. So `$PDFTOHTML` (banal's own override, line 166) points at a
  * stub that answers `-v` with `XML_DIALECT.version` — the pdftohtml whose XML `xml.ts` writes — and
- * refuses anything else. `test/e2e/banal.ts` shows both failures with the real banal.
+ * refuses anything else. `test/e2e/tex/banal.e2e.ts` shows both failures with the real banal.
  */
 import type { Opaque } from "ts-essentials";
 import type { AbsolutePath } from "../../domain/paths.ts";

package/src/adapters/banal/output.test.ts

@@ -1,6 +1,6 @@
 /**
  * `output.ts` — every way a banal run can end, as a table of `ProcessExit` → `Result`, and the
- * measurement → geometry projection. Pure: no perl, no disk. The real banal is `test/e2e/banal.ts`.
+ * measurement → geometry projection. Pure: no perl, no disk. The real banal is `test/e2e/tex/banal.e2e.ts`.
  */
 import assert from "node:assert/strict";
 import { test } from "vitest";

package/src/adapters/banal/run.test.ts

@@ -1,7 +1,7 @@
 /**
  * `adapters/banal/run.ts` — running and installing banal, on in-memory ports: which `Command` it builds, what it stages,
  * what it downloads and writes, and what it concludes. No perl, no disk, no network: the adapters
- * record, and each assertion reads the record. Real perl and the real banal are `test/e2e/banal.ts`;
+ * record, and each assertion reads the record. Real perl and the real banal are `test/e2e/tex/banal.e2e.ts`;
  * the adapters' own behaviour is `src/adapters/node/*.test.ts`.
  */
 import assert from "node:assert/strict";

package/src/adapters/banal/xml.test.ts

@@ -4,7 +4,7 @@
  *
  * Every page here is written by hand. The real-PDF half — pdf.js boxes of a committed fixture,
  * written as XML, measured by the real banal and compared with banal on real pdftohtml — is
- * `test/e2e/banal.ts`, which runs where `paperlint toolchain` has installed banal.
+ * `test/e2e/tex/banal.e2e.ts`, which runs where `paperlint toolchain` has installed banal.
  */
 import assert from "node:assert/strict";
 import { test } from "vitest";