paperlint 7.2.0 → 8.0.0

package/src/init.ts

@@ -63,12 +63,7 @@ import {
   type Merge,
   type WireResult,
 } from "./hooks-settings.ts";
-import {
-  DEFAULT_FORMAT,
-  isFormat,
-  nameProblem,
-  type PaperFormat,
-} from "./new-paper.ts";
+import { nameProblem } from "./new-paper.ts";
 // The one source for the consumer's config key lives in lib/ (the ESLint rules and the skill scripts
 // import it too). It is imported compiled, from dist/, the one path that resolves the same from src/
 // and from dist/ — see CONTRIBUTING.md.
@@ -572,17 +567,11 @@ export interface InitOptions {
   merge?: Merge | undefined;
   /** `--paper <name>`: create this paper, even without a terminal. */
   paper?: string | null;
-  /** `--format tex|md` for that paper. */
-  format?: PaperFormat | null;
   /**
    * Creates one paper and lints it — `paperlint new`'s own routine, passed in by the CLI so `init` and
    * `new` cannot drift into two implementations.
    */
-  createPaper?: (
-    papersRoot: string,
-    name: string,
-    format: PaperFormat,
-  ) => Promise<number>;
+  createPaper?: (papersRoot: string, name: string) => Promise<number>;
   /**
    * The venues a paper name may not name (`shippedVenueNames`), so `--paper aisec-2026` is refused
    * before anything is asked. `createPaper` refuses it again whatever this holds.
@@ -717,7 +706,6 @@ export async function init(
     hooks = true,
     merge,
     paper = null,
-    format = null,
     createPaper,
     venues = [],
     run = spawnSync,
@@ -824,18 +812,11 @@ export async function init(
   }
   if (wanted !== null && createPaper) {
     const problem = nameProblem(wanted, venues);
-    let fmt: PaperFormat = format ?? DEFAULT_FORMAT;
-    if (!problem && format === null && interactive) {
-      const f = (
-        await askOrDefault(ask, `  format: tex / md [${DEFAULT_FORMAT}] `)
-      )?.trim();
-      if (isFormat(f)) fmt = f;
-    }
     if (problem) {
       log(`  ✗ no paper created — ${problem}`);
       paperCode = 2;
     } else {
-      const code = await createPaper(papersAbs, wanted, fmt);
+      const code = await createPaper(papersAbs, wanted);
       if (code !== 0) {
         log(`  ⚠ the new paper's lint exited ${String(code)} — see above`);
         paperCode = code;

package/src/lint-fix.test.ts

@@ -20,6 +20,10 @@ afterEach(() => {
   for (const d of dirs.splice(0)) rmSync(d, { recursive: true, force: true });
 });
 
+/** A paper.tex whose whole body is `body`. */
+const PAPER = (body: string): string =>
+  `\\documentclass{article}\n\\begin{document}\n${body}\n\\end{document}\n`;
+
 function project(
   settings: Record<string, unknown>,
   files: Record<string, string> = {},
@@ -30,7 +34,7 @@ function project(
     "package.json": JSON.stringify({ name: "c", private: true }),
     "paperlint.json": JSON.stringify({ papersDir: "papers", ...settings }),
     "papers/a/PIPELINE-STATUS.md": "---\nstages: []\n---\n",
-    "papers/a/paper.md": "# Intro\n\nSee §5, §6 and §7; p < .05.\n",
+    "papers/a/paper.tex": PAPER("See §5, §6 and §7; $p < .05$."),
     ...files,
   };
   for (const [p, text] of Object.entries(all)) {
@@ -64,15 +68,17 @@ describe("paperlint lint --fix", () => {
     const fixed = await lint(root, ["--fix"]);
     expect(ruleIds(fixed.out)).not.toContain("paper/section-word");
     expect(ruleIds(fixed.out)).not.toContain("paper/leading-zero");
-    expect(readFileSync(join(root, "papers/a/paper.md"), "utf8")).toBe(
-      "# Intro\n\nSee Section 5, Section 6 and Section 7; p < 0.05.\n",
+    expect(readFileSync(join(root, "papers/a/paper.tex"), "utf8")).toBe(
+      PAPER("See Section 5, Section 6 and Section 7; $p < 0.05$."),
     );
   });
 
   it("without --fix nothing is written", async () => {
     const root = project({});
     await lint(root);
-    expect(readFileSync(join(root, "papers/a/paper.md"), "utf8")).toMatch(/§5/);
+    expect(readFileSync(join(root, "papers/a/paper.tex"), "utf8")).toMatch(
+      /§5/,
+    );
   });
 });
 

package/src/new-paper.harness.mjs

@@ -36,7 +36,6 @@ const ROOT = dirname(HERE);
 const {
   newPaper,
   nameProblem,
-  wantedFiles,
   PACKAGE_TEMPLATES,
   OVERRIDE_DIR,
   STATUS_FILE,
@@ -63,7 +62,7 @@ async function lint(dir) {
 
 try {
   // ── the templates are FILES in the package, one per required file ──────────────────────
-  for (const f of [STATUS_FILE, SOURCE_FILE.tex, SOURCE_FILE.md])
+  for (const f of [STATUS_FILE, SOURCE_FILE])
     check(
       `the package ships templates/paper/${f}`,
       existsSync(join(PACKAGE_TEMPLATES, f)),
@@ -85,13 +84,13 @@ try {
     );
   check(
     "a refused name creates nothing",
-    newPaper(work, "Bad", "tex", { venues: [] }).ok === false &&
+    newPaper(work, "Bad", { venues: [] }).ok === false &&
       !existsSync(join(work, "Bad")),
   );
 
   // ── a fresh LaTeX paper ─────────────────────────────────────────────────────────────
   const papers = join(work, "papers");
-  const r = newPaper(papers, "demo", "tex", { venues: [] });
+  const r = newPaper(papers, "demo", { venues: [] });
   check(
     "a fresh folder gets the scorecard, a .tex source and paperlint.json, all from the package",
     r.ok &&
@@ -129,36 +128,18 @@ try {
 
   // ── never overwrite; on an existing folder only the missing files ─────────────────────
   writeFileSync(join(papers, "demo", STATUS_FILE), "mine\n");
-  const again = newPaper(papers, "demo", "md", { venues: [] });
+  const again = newPaper(papers, "demo", { venues: [] });
   check(
-    "🔴 a second run overwrites nothing and adds no second source",
+    "🔴 a second run overwrites nothing",
     again.ok &&
       !again.fresh &&
       read(papers, "demo", STATUS_FILE) === "mine\n" &&
-      !existsSync(join(papers, "demo", "paper.md")) &&
       again.files.every((f) => f.status === "kept"),
   );
-  mkdirSync(join(papers, "old"), { recursive: true });
-  writeFileSync(join(papers, "old", "paper.md"), "# Old\n");
-  const migrated = newPaper(papers, "old", "tex", { venues: [] });
-  check(
-    "an old folder with only paper.md gets ONLY the scorecard — that is the migration",
-    migrated.ok &&
-      existsSync(join(papers, "old", STATUS_FILE)) &&
-      !existsSync(join(papers, "old", "paper.tex")) &&
-      read(papers, "old", "paper.md") === "# Old\n",
-  );
-  check(
-    "wantedFiles asks for a source only when neither format is there",
-    wantedFiles(join(papers, "old"), "tex").join() ===
-      `${STATUS_FILE},paperlint.json` &&
-      wantedFiles(join(papers, "nowhere"), "md").join() ===
-        `${STATUS_FILE},paper.md,paperlint.json`,
-  );
   writeFileSync(join(papers, "afile"), "x");
   check(
     "a name taken by a FILE is refused, not written through",
-    newPaper(papers, "afile", "tex", { venues: [] }).ok === false,
+    newPaper(papers, "afile", { venues: [] }).ok === false,
   );
 
   // ── the project's template wins, file by file ─────────────────────────────────────────
@@ -167,7 +148,7 @@ try {
     join(papers, OVERRIDE_DIR, STATUS_FILE),
     "---\n---\n# House scorecard for {{name}}\n",
   );
-  const own = newPaper(papers, "house", "md", { venues: [] });
+  const own = newPaper(papers, "house", { venues: [] });
   // Guards: the override slot — `fromTemplate` in new-paper.ts reads `<papers>/.template/<file>`
   // before the package's copy. Replace that lookup with the package's alone and this goes red.
   check(
@@ -176,11 +157,11 @@ try {
       read(papers, "house", STATUS_FILE) ===
         "---\n---\n# House scorecard for house\n" &&
       own.files.find((f) => f.file === STATUS_FILE)?.from === "project" &&
-      own.files.find((f) => f.file === "paper.md")?.from === "package",
+      own.files.find((f) => f.file === SOURCE_FILE)?.from === "package",
   );
 
   // ── a missing template is a broken install, not an empty file ─────────────────────────
-  const broken = newPaper(join(work, "b"), "x", "tex", {
+  const broken = newPaper(join(work, "b"), "x", {
     venues: [],
     packageTemplates: join(work, "no-such-dir"),
   });

package/src/new-paper.test.ts

@@ -41,7 +41,7 @@ const settingsOf = (dir: string) =>
 describe("paperlint new — paperlint.json", () => {
   it("is always written, from the package template: no venue chosen yet, and valid", () => {
     const papers = join(tmp(), "papers");
-    const r = newPaper(papers, "demo", "tex", { venues: [] });
+    const r = newPaper(papers, "demo", { venues: [] });
     expect(r.ok && r.files.find((f) => f.file === "paperlint.json")).toEqual({
       file: "paperlint.json",
       status: "created",
@@ -72,7 +72,7 @@ describe("paperlint new — paperlint.json", () => {
       join(papers, OVERRIDE_DIR, "paperlint.json"),
       '{ "extends": "paperlint:aisec", "kind": "research" }\n',
     );
-    const r = newPaper(papers, "house", "tex", { venues: [] });
+    const r = newPaper(papers, "house", { venues: [] });
     expect(r.ok && r.files.find((f) => f.file === "paperlint.json")?.from).toBe(
       "project",
     );
@@ -89,7 +89,7 @@ describe("paperlint new — paperlint.json", () => {
       join(papers, "p", "paperlint.json"),
       '{"extends":"paperlint:aisec"}',
     );
-    const r = newPaper(papers, "p", "tex", { venues: [] });
+    const r = newPaper(papers, "p", { venues: [] });
     expect(
       r.ok && r.files.find((f) => f.file === "paperlint.json")?.status,
     ).toBe("kept");
@@ -106,7 +106,7 @@ describe("paperlint lint — a paper with no venue preset chosen", () => {
       join(root, "package.json"),
       JSON.stringify({ name: "c", private: true }),
     );
-    newPaper(join(root, "papers"), "demo", "tex", { venues: [] });
+    newPaper(join(root, "papers"), "demo", { venues: [] });
     if (extendsValue !== null)
       writeFileSync(
         join(root, "papers", "demo", "paperlint.json"),
@@ -488,7 +488,7 @@ describe("a project's own template", () => {
     mkdirSync(join(papers, OVERRIDE_DIR), { recursive: true });
     const src = join(papers, OVERRIDE_DIR, "paperlint.json");
     writeFileSync(src, '{\n  // our house venue\n  "extends": null\n}\n');
-    const r = newPaper(papers, "p", "tex", {
+    const r = newPaper(papers, "p", {
       venues: [],
       venue: { extends: "paperlint:aisec", kind: null },
     });
@@ -504,7 +504,7 @@ describe("a project's own template", () => {
     mkdirSync(join(papers, OVERRIDE_DIR), { recursive: true });
     writeFileSync(join(papers, OVERRIDE_DIR, "paperlint.json"), "{}\n");
     const lines = reportNewPaper(
-      newPaper(papers, "p", "tex", { venues: [] }),
+      newPaper(papers, "p", { venues: [] }),
       (p) => p,
     );
     expect(lines).toContain(

package/src/new-paper.ts

@@ -8,8 +8,7 @@
  * Every rule below is taken from a tool that already solved it (docs/prior-art/paper-folder-scaffolding.md):
  *   - the template is a FILE with a lookup order — the project's `<papers>/.template/<file>` first,
  *     the package's `templates/paper/<file>` second (Hugo's archetypes);
- *   - it NEVER overwrites: on an existing folder it adds only the missing required files, which is
- *     also the migration for an old folder that has only `paper.md` (`cargo init`);
+ *   - it NEVER overwrites: on an existing folder it adds only the missing required files (`cargo init`);
  *   - the name is validated, because it becomes a path and, through the hooks, a shell argument.
  *
  * The only substitution is `{{name}}` → the folder name. Nothing else in a template is touched.
@@ -33,10 +32,6 @@ import {
   type NamedVenue,
 } from "./domain/venue-name.ts";
 
-export type PaperFormat = "tex" | "md";
-export const FORMATS: readonly PaperFormat[] = ["tex", "md"];
-export const DEFAULT_FORMAT: PaperFormat = "tex";
-
 /** The package's default templates. Read from disk, so they ship in the tarball (`files`). */
 export const PACKAGE_TEMPLATES = fileURLToPath(
   new URL("../templates/paper/", import.meta.url),
@@ -50,17 +45,12 @@ export const PACKAGE_TEMPLATES = fileURLToPath(
 export const OVERRIDE_DIR = ".template";
 
 export const STATUS_FILE = "PIPELINE-STATUS.md";
-export const SOURCE_FILE: Readonly<Record<PaperFormat, string>> = {
-  tex: "paper.tex",
-  md: "paper.md",
-};
+/** A paper's source: LaTeX, one file at the paper's root. */
+export const SOURCE_FILE = "paper.tex";
 
 /** The flag that lets `paperlint new` create a folder whose name names a venue. */
 export const ALLOW_VENUE_NAME = "--allow-venue-name";
 
-export const isFormat = (v: unknown): v is PaperFormat =>
-  FORMATS.some((f) => f === v);
-
 /**
  * Why a name is refused, or null. `[a-z0-9._-]+` is the charset; a LEADING dot is refused on top
  * of it, because discovery skips dot-directories — a paper named `.x` would be created and then
@@ -109,20 +99,12 @@ export type NewPaperResult =
     }
   | { readonly ok: false; readonly reason: string };
 
-/**
- * The files a paper folder must end up with: the scorecard, a source in `format` — unless it
- * already has a source in EITHER format, in which case that one stands — and `paperlint.json`.
- */
-export function wantedFiles(dir: string, format: PaperFormat): string[] {
-  return [...scorecardAndSource(dir, format), CONFIG_FILE];
-}
-
-function scorecardAndSource(dir: string, format: PaperFormat): string[] {
-  const hasSource = Object.values(SOURCE_FILE).some((f) =>
-    existsSync(join(dir, f)),
-  );
-  return hasSource ? [STATUS_FILE] : [STATUS_FILE, SOURCE_FILE[format]];
-}
+/** The files a paper folder must end up with: the scorecard, the source and `paperlint.json`. */
+export const WANTED_FILES: readonly string[] = [
+  STATUS_FILE,
+  SOURCE_FILE,
+  CONFIG_FILE,
+];
 
 /** The venue `paperlint new --venue` chose: what goes into the new paper's `paperlint.json`. */
 export interface VenueSetting {
@@ -195,7 +177,7 @@ function fromTemplate(
     return { ok: false, reason: `no template for ${file}: ${src} is missing` };
   const text = readFileSync(src, "utf8").split("{{name}}").join(name);
   const setClass = venue?.setClass ?? null;
-  if (file === SOURCE_FILE.tex && setClass !== null)
+  if (file === SOURCE_FILE && setClass !== null)
     return { ok: true, value: { file, text: setClass(text), from } };
   if (file !== CONFIG_FILE || venue === null)
     return { ok: true, value: { file, text, from } };
@@ -217,7 +199,6 @@ export interface NewPaperOptions {
 export function newPaper(
   papersRoot: string,
   name: string,
-  format: PaperFormat,
   opts: NewPaperOptions,
 ): NewPaperResult {
   const { packageTemplates = PACKAGE_TEMPLATES, venue = null } = opts;
@@ -230,7 +211,7 @@ export function newPaper(
 
   const files: FileOutcome[] = [];
   const toWrite: Planned[] = [];
-  for (const file of wantedFiles(dir, format)) {
+  for (const file of WANTED_FILES) {
     if (existsSync(join(dir, file))) {
       files.push({ file, status: "kept" });
       continue;

package/src/paper-files.test.ts

@@ -20,6 +20,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, describe, expect, it } from "vitest";
 import { buildConfig, eslintConfig, run } from "./cli.ts";
+import { texLanguage } from "#eslint-rules/latex-language";
 import {
   narrowToOwners,
   ownedPatterns,
@@ -247,7 +248,7 @@ describe("`rules` blocks — where the rule lands", () => {
               },
             ],
           },
-          null,
+          texLanguage,
         ),
       ),
     });
@@ -257,9 +258,9 @@ describe("`rules` blocks — where the rule lands", () => {
     const status = await on("papers/a/PIPELINE-STATUS.md");
     expect(status["paper/source"]).toEqual([1]);
     expect(status["paper/section-word"]).toBeUndefined();
-    const draft = await on("papers/a/paper.md");
-    expect(draft["paper/section-word"]).toEqual([0]);
-    expect(draft["paper/source"]).toBeUndefined();
+    const source = await on("papers/a/paper.tex");
+    expect(source["paper/section-word"]).toEqual([0]);
+    expect(source["paper/source"]).toBeUndefined();
   });
 });
 

package/src/paper-files.ts

@@ -1,8 +1,8 @@
 /**
  * THE FILES PAPERLINT OWNS — read off its own config, and made the only thing ESLint may reach.
  *
- * paperlint's blocks name the files they lint (`PIPELINE-STATUS.md`, `paper.md`, `paper.tex`,
- * `reviews/*.md`, …). That list is the whole scope of `paperlint lint`, and this module turns it
+ * paperlint's blocks name the files they lint (`PIPELINE-STATUS.md`, `paper.tex`, `reviews/*.md`,
+ * …). That list is the whole scope of `paperlint lint`, and this module turns it
  * into two things ESLint understands:
  *
  * 1. **A global ignore of everything else** (`scopeToOwned`). Handing ESLint a directory is not
@@ -17,7 +17,7 @@
  * 2. **Each rule scoped to the files it was written for** (`ruleOwners` + `narrowToOwners`).
  *    One plugin NAME is bound to different plugin objects in different blocks: `paper` holds
  *    `stages`/`source`/`author-list` beside `PIPELINE-STATUS.md` and `typography` beside
- *    `paper.md`/`paper.tex`. So a consumer block that named `paper/source`
+ *    `paper.tex`. So a consumer block that named `paper/source`
  *    for every file under the papers directory reached `paper.tex`, where `paper` has no `source`
  *    — and ESLint threw `Could not find "source" in plugin "paper"` from inside `lintFiles`,
  *    after paperlint's own validation had (correctly) accepted the id. A block is therefore split
@@ -36,7 +36,7 @@
  * - a global-ignore pattern that matches a DIRECTORY hides everything inside it, so directories
  *   must be un-ignored (`!` + a pattern ending in a slash) before owned files can be;
  * - that un-ignores `node_modules/` and `.git/` too — ESLint's own defaults — so they are
- *   re-ignored after, or a `paper.md` inside a dependency would be linted;
+ *   re-ignored after, or a `paper.tex` inside a dependency would be linted;
  * - later global-ignore patterns win, across blocks, in config order;
  * - `files: [["a", "b"]]` matches a file only when BOTH patterns match.
  */

package/src/paper-prose.test.ts

@@ -0,0 +1,49 @@
+import { expect, it } from "vitest";
+import { latexReader } from "./adapters/latex/index.ts";
+import { memoryFiles } from "./adapters/memory/index.ts";
+import { paperProse } from "./paper-prose.ts";
+
+const SRC = [
+  "\\documentclass{article}",
+  "\\usepackage{amsmath} % a preamble word count of its own",
+  "\\title{A Title}",
+  "\\begin{document}",
+  "\\maketitle",
+  "\\section{Introduction}",
+  "We measure it~\\cite{a}. % a comment",
+  "",
+  "A second paragraph \\input{body}",
+  "\\begin{filecontents*}{refs.bib}",
+  "@misc{a, author = {Ada Lovelace}, title = {Never Prose}}",
+  "\\end{filecontents*}",
+  "\\end{document}",
+].join("\n");
+
+it("the body's prose, a blank line between passages, includes spliced; the preamble, comments, the inline .bib and the title stay out", () => {
+  const files = memoryFiles({
+    "/p/paper.tex": SRC,
+    "/p/body.tex": "\\subsection{Method}\nends here.",
+  });
+  expect(
+    paperProse("/p/paper.tex", SRC, { files, latex: latexReader }),
+  ).toEqual({
+    // A citation stands as `[1]`, where it is set; a heading — here an included one — ends a passage.
+    body: "We measure it [1].\n\nA second paragraph\n\nends here.",
+    headings: ["Introduction", "Method"],
+    files: [
+      { file: "paper.tex", text: SRC },
+      { file: "body.tex", text: "\\subsection{Method}\nends here." },
+    ],
+  });
+});
+
+it("a citation stands as `[1]` and a cross-reference as `1`, so the sentence still ends on them", () => {
+  const src =
+    "\\documentclass{article}\n\\begin{document}\nIt holds~\\cite{a}. It is shown (Section~\\ref{s}).\n\\end{document}\n";
+  expect(
+    paperProse("/p/paper.tex", src, {
+      files: memoryFiles({ "/p/paper.tex": src }),
+      latex: latexReader,
+    }).body,
+  ).toBe("It holds [1]. It is shown (Section 1).");
+});

package/src/paper-prose.ts

@@ -0,0 +1,67 @@
+/**
+ * THE PROSE OF A paper.tex AS PLAIN TEXT — what `grade-paper-writing/prose-lint.mjs` measures.
+ *
+ * prose-lint counts sentences and words, and every metric it prints is a fraction of the word
+ * count. Read as raw text, a `.tex` puts the preamble, the `%` comments and an inline `filecontents`
+ * bibliography into that count (8127 "words" against about 4636 real ones on one paper), so every
+ * rate comes out roughly halved. This reads the paper the way the `tex/register` rule does: the
+ * includes spliced in (`readPaper`), then the body's prose as passages (`bodyProse` — the abstract
+ * to the back matter, without headings, captions, floats or code), each passage's sentences
+ * (`bodySentences`). A blank line separates two passages, so no sentence runs across them.
+ *
+ * A citation stands as `[1]` and a cross-reference as `1`, where they are set — not left out:
+ * prose-lint judges a sentence that ENDS on one (a wasted stress position) and counts references
+ * to other parts of the paper (`(Section 1)`), and both are invisible in a sentence the marks
+ * were cut out of. Math is left out; prose-lint counts no formula.
+ */
+import { bodySentences } from "./domain/register.ts";
+import { CITATION, MATH, REFERENCE } from "./domain/sentences.ts";
+import { runText } from "./domain/tex-document.ts";
+import { readPaper, type PaperDeps } from "./tex-paper.ts";
+
+/** A sentence's text with each mark as a reader would see it set, and math left out. */
+const rendered = (raw: string): string =>
+  raw
+    .replaceAll(CITATION, "[1]")
+    .replaceAll(REFERENCE, "1")
+    .replaceAll(MATH, "")
+    .replace(/\s+/gu, " ")
+    .trim();
+
+/**
+ * A paper's body prose, one passage per paragraph, its section titles in document order, and the
+ * text of each file it is made of — `paper.tex` and every file it includes, once, named as the
+ * include names it — for what the body leaves out, such as captions.
+ */
+export interface PaperProse {
+  readonly body: string;
+  readonly headings: readonly string[];
+  readonly files: readonly { readonly file: string; readonly text: string }[];
+}
+
+/** The prose and the headings of the paper whose main file is `filename` with the text `src`. */
+export function paperProse(
+  filename: string,
+  src: string,
+  deps: PaperDeps,
+): PaperProse {
+  const { text, segments } = readPaper(filename, src, deps);
+  const passages = deps.latex
+    .bodyProse(text)
+    .map((p) =>
+      bodySentences([p])
+        .map((s) => rendered(s.raw))
+        .join(" "),
+    )
+    .filter((p) => p !== "");
+  return {
+    body: passages.join("\n\n"),
+    headings: deps.latex
+      .headings(text)
+      .filter((h) => h.command.kind === "heading" && h.argument === "title")
+      .map((h) => runText(h.title).replace(/\s+/g, " ").trim()),
+    files: [...new Map(segments.map((s) => [s.file, s.source])).entries()].map(
+      ([file, text]) => ({ file, text }),
+    ),
+  };
+}

package/src/parse-args.test.ts

@@ -22,7 +22,6 @@ describe("parseArgs — `--flag=value` is the same as `--flag value`", () => {
     ["--config=o.json", "config", "o.json"],
     ["--venue=agenticdev", "venue", "agenticdev"],
     ["--kind=short", "kind", "short"],
-    ["--format=md", "format", "md"],
     ["--paper=p", "paper", "p"],
   ] as const)("%s", (flag, key, value) => {
     const a = parseArgs(["new", "x", flag]);

package/src/structure.harness.ts

@@ -47,7 +47,6 @@ const paper = (name: string, files: readonly string[]) => {
 
 try {
   paper("complete", ["PIPELINE-STATUS.md", "paper.tex", "refs.bib"]);
-  paper("complete-md", ["PIPELINE-STATUS.md", "paper.md"]);
   // the marker is present (paper.tex), the scorecard is not — the directory is linted by ZERO
   // rules and reports clean
   paper("no-scorecard", ["paper.tex", "refs.bib"]);
@@ -65,10 +64,6 @@ try {
     "a complete paper directory — NOT A SINGLE finding",
     at("complete").length === 0,
   );
-  check(
-    "and `paper.md` counts on equal footing with `paper.tex` — the corpus holds both forms",
-    at("complete-md").length === 0,
-  );
   check(
     "a missing scorecard — a finding",
     at("no-scorecard").length === 1 &&
@@ -86,10 +81,11 @@ try {
     /no-scorecard/.test(at("no-scorecard")[0]?.message ?? ""),
   );
   check(
-    "a directory with no source — a finding, and BOTH accepted forms are listed",
+    "a directory with no source — a finding naming `paper.tex`",
     at("no-source").length === 1 &&
-      /`paper\.tex`/.test(at("no-source")[0]?.message ?? "") &&
-      /`paper\.md`/.test(at("no-source")[0]?.message ?? ""),
+      /`paper\.tex` — a paper directory with no source/.test(
+        at("no-source")[0]?.message ?? "",
+      ),
   );
 
   // 🔴 THE PAIRED HALF: detection is GENEROUS. Without this the check would scream about every
@@ -124,9 +120,7 @@ try {
       {
         cwd: root,
       },
-    ).some(
-      (x) => x.file.endsWith("complete-md") && /refs\.bib/.test(x.message),
-    ),
+    ).some((x) => x.file.endsWith("no-source") && /refs\.bib/.test(x.message)),
   );
   check(
     "a nonexistent root does not crash it — that's the empty-set guard talking",

package/src/structure.ts

@@ -26,6 +26,7 @@ import { readdirSync, existsSync } from "node:fs";
 import { join, relative, basename, isAbsolute, sep } from "node:path";
 import type { StructureConfig, StructureFinding } from "./types.ts";
 import { CONFIG_FILE } from "#lib/paper-config";
+import { SOURCE_FILE } from "./new-paper.ts";
 
 /** The requirements after the consumer's config is laid over the defaults. */
 type Rules = Required<StructureConfig>;
@@ -38,9 +39,9 @@ type Rules = Required<StructureConfig>;
  * byte-compared by the `paper/stages` rule anyway.
  */
 export const STRUCTURE_DEFAULTS = {
-  markers: ["PIPELINE-STATUS.md", "paper.tex", "paper.md", CONFIG_FILE],
+  markers: ["PIPELINE-STATUS.md", SOURCE_FILE, CONFIG_FILE],
   require: ["PIPELINE-STATUS.md"],
-  requireOneOf: [["paper.tex", "paper.md"]],
+  requireOneOf: [[SOURCE_FILE]],
   ignore: [],
 };
 
@@ -118,7 +119,7 @@ export function checkStructure(
  * The message NAMES THE CONSEQUENCE rather than restating the condition. "missing
  * PIPELINE-STATUS.md" without the second half reads as nitpicking about formatting; with it you
  * can see which checks the directory silently loses — the rules that read the scorecard; the rules
- * over `paper.md` / `paper.tex` still run.
+ * over `paper.tex` still run.
  */
 function whyMissingMatters(file: string, dirName: string): string {
   if (file === "PIPELINE-STATUS.md")

package/src/types.ts

@@ -62,8 +62,6 @@ export interface Args {
   noHooks: boolean;
   /** `--paper <name>`: `init` creates this paper. */
   paper: string | null;
-  /** `--format tex|md` for `new` and `init --paper`. Validated by the command, not here. */
-  format: string | null;
   /** `--venue <preset>` for `new`: a shipped preset name, or a path to the project's own. */
   venue: string | null;
   /** `--kind <kind>` for `new`: one of the venue preset's kinds. */

package/fixtures/real-markdown-paper/baseline.json

@@ -1,22 +0,0 @@
-{
-  "$comment": [
-    "What the rules say about this article TODAY, as data rather than as a sentence in a docblock.",
-    "It is not a target and not a clean bill of health — the fixture's README says findings here",
-    "are measurements. Its job is the SILENCE half: a rule that starts reporting something new on",
-    "225 lines of real prose has almost certainly gained a false positive, and the harness beside",
-    "this file names the rule. That is not expressible on an eleven-line stub, where every line was",
-    "written by someone who already knew which rule would read it.",
-    "",
-    "Recorded 2026-09-19, re-recorded 2026-09-26 for 3.0.0. Two of the three rules are about the",
-    "scorecard being deliberately thin (no pdf, no frozen source) rather than about the prose.",
-    "paper/leading-zero reports each of the 18 p-values of paperlint#44 where it is (one finding per",
-    "occurrence since 3.0.0; before, paper/typography reported them as one count). They are real",
-    "findings against IEEE / ISO 80000-1 style, in a blog post written for a general audience.",
-    "The count is expected to stay. A drop is never a failure here, only growth is."
-  ],
-  "findings": {
-    "paper/stages": 2,
-    "paper/source": 1,
-    "paper/leading-zero": 18
-  }
-}