paperlint 7.1.0 → 8.0.0

package/eslint-rules/latex-language.ts

@@ -1,7 +1,7 @@
 /**
- * AN ESLint LANGUAGE FOR `.tex` — so that the ~30 prose rules of a paper pipeline read papers
- * written in LaTeX, and not only papers written in markdown. The spike it grew out of lives in
- * the source corpus as a coverage measurement plus an executable prototype kept as history.
+ * AN ESLint LANGUAGE FOR `.tex` — so that prose rules read a paper's LaTeX source. The spike it
+ * grew out of lives in the source corpus as a coverage measurement plus an executable prototype
+ * kept as history.
  *
  * ── CONSTRUCTION: two legs ──────────────────────────────────────────────────
  *  1. AST — a flat mdast-like root (heading / code / html / strong) with REAL positions taken
@@ -9,9 +9,8 @@
  *  2. TEXT — a projection of `.tex` into a markdown-like view THAT PRESERVES LENGTHS AND
  *     OFFSETS: comments, the preamble, math, service macros and code environments are blanked
  *     with spaces; `\section{X}` projects to `##      X `, `\texttt{X}` to `` `X` ``.
- *     The point: a rule receives what it used to see in markdown and KNOWS NOTHING about
- *     LaTeX, while the position of a finding points into the real `.tex`. Not one rule was
- *     rewritten for LaTeX.
+ *     The point: a rule reads a plain, heading-marked text and KNOWS NOTHING about LaTeX, while
+ *     the position of a finding points into the real `.tex`.
  *
  * ── HEADING SYNTHESIS: not decoration, but the repair of seven silent rules ──
  * Measured 2026-08-26 across three real papers: NONE of them has a `Limitations` /
@@ -47,10 +46,8 @@
  *     `95   of it, costing   5 and A  B`. This matters: a word splitter counts `%` as part of
  *     a word, and a plain-language rule counts NUMBERS — so the percent sign detaches from
  *     its number. Not fixed: three exceptions would have to be written and pinned.
- *  3. THRESHOLDS WERE CALIBRATED ON MARKDOWN. 60 / 350 / 700 words were taken from a markdown
- *     paper. The projection counts differently: the same place gave 1239 words before macro
- *     blanking and 1208 after — a 2.5% discrepancy. The discrepancy is ACCEPTED deliberately;
- *     the thresholds were not recalibrated.
+ *  3. MACRO BLANKING SHIFTS WORD COUNTS. The same place gave 1239 words before macro blanking
+ *     and 1208 after — a 2.5% discrepancy, ACCEPTED deliberately.
  *  4. ONE FILE AT A TIME. `\input` / `\include` are in OPAQUE: the projection of `paper.tex`
  *     does not hold what they pull in. `paperlint lint` hands ESLint each file the paper includes
  *     from its body as a file of its own (src/paper-includes.ts), and a file with no `document`
@@ -546,9 +543,9 @@ export function texToMdast(
       // 🔴 AND SYMMETRICALLY ON THE LEFT (found by a run on 2026-08-27, not by reading). A
       // comment that follows a line of text directly, rather than a blank line, comes back from
       // unified-latex with a position starting at the PREVIOUS newline instead of at `%`.
-      // Consumers recognise a comment by its first character (`<!--` in markdown, `%` in
-      // LaTeX), so such a node was not a comment to them: notes above bold appendix lead-ins
-      // never bound, and the block-note / block-verdict rules could NEVER fire. Measured:
+      // Consumers recognise a comment by its first character (`%`), so such a node was not a
+      // comment to them: notes above bold appendix lead-ins never bound, and the block-note /
+      // block-verdict rules could NEVER fire. Measured:
       // 2 out of 2 blocks were reported as "no note AT ALL" while the notes were right there.
       let cs = pos.start.offset;
       while (cs < ce && src[cs] !== "%") cs++;

package/eslint-rules/paper-context.ts

@@ -8,8 +8,8 @@
  * them under `settings.paperlint.paper`
  * for `paper.tex` and for every file it includes. A rule reads the other files from disk.
  *
- * No setting — a file linted outside `paperlint lint`, or a markdown paper — means a paper of one
- * file: every rule decides on the file it was handed, as it did before.
+ * No setting — a file linted outside `paperlint lint` — means a paper of one file: every rule
+ * decides on the file it was handed, as it did before.
  */
 import { readFileSync } from "node:fs";
 import { z } from "zod";

package/eslint-rules/paper-typography.test.mjs

@@ -11,7 +11,6 @@
  */
 import { describe, expect, it } from "vitest";
 import { ESLint } from "eslint";
-import markdown from "@eslint/markdown";
 import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -49,16 +48,6 @@ const eslint = (fix = false) =>
         linterOptions: { reportUnusedDisableDirectives: "error" },
         rules: RULES,
       },
-      {
-        files: ["**/*.md"],
-        plugins: { markdown, paper: typography },
-        language: "markdown/gfm",
-        languageOptions: { frontmatter: "yaml" },
-        rules: {
-          "paper/section-word": "warn",
-          "paper/leading-zero": "warn",
-        },
-      },
     ],
   });
 
@@ -164,14 +153,6 @@ describe("paper/section-word", () => {
       "\\documentclass{article}\n\\crefname{section}{§}{§§}\n\\begin{document}\nSee §5.\n\\end{document}\n";
     expect(ids(await lint(src), "paper/section-word")).toHaveLength(1);
   });
-
-  it("markdown: `§5` → `Section 5`, code untouched", async () => {
-    const src = "See §5 and `§3` here.\n";
-    expect(ids(await lint(src, "paper.md"), "paper/section-word")).toHaveLength(
-      1,
-    );
-    expect(await fixed(src, "paper.md")).toBe("See Section 5 and `§3` here.\n");
-  });
 });
 
 describe("paper/leading-zero", () => {
@@ -237,17 +218,6 @@ describe("paper/leading-zero", () => {
       doc("At $p < 0.05$ and $d=0.21$; cell & 0.037 \\\\ and .5 or 0.25."),
     );
   });
-
-  it("markdown: prose and a table cell are fixed, code is not", async () => {
-    const src =
-      "Significant at p<.05.\n\n| task | p |\n| --- | --- |\n| bugfix | .002 |\n\nRun `.25`.\n";
-    expect(ids(await lint(src, "paper.md"), "paper/leading-zero")).toHaveLength(
-      2,
-    );
-    expect(await fixed(src, "paper.md")).toBe(
-      "Significant at p<0.05.\n\n| task | p |\n| --- | --- |\n| bugfix | 0.002 |\n\nRun `.25`.\n",
-    );
-  });
 });
 
 describe("a finding after a heading written over several lines", () => {
@@ -290,15 +260,11 @@ describe("paper/leading-zero — a number after ¶ or § is not a decimal (#102)
     expect(await fixed(doc(CITE))).toBe(doc(CITE));
   });
 
-  it("…while a real decimal still fixes, in markdown too, even beside a cited paragraph", async () => {
+  it("…while a real decimal still fixes, even beside a cited paragraph", async () => {
     const body = `${CITE}\n\nWe use a threshold of .05 throughout.`;
     expect(await fixed(doc(body))).toBe(
       doc(`${CITE}\n\nWe use a threshold of 0.05 throughout.`),
     );
-    const md = "See ¶¶.42 and .44.\n\nSignificant at p<.05.\n";
-    expect(await fixed(md, "paper.md")).toBe(
-      "See ¶¶.42 and .44.\n\nSignificant at p<0.05.\n",
-    );
   });
 });
 
@@ -467,48 +433,6 @@ describe("where visible text comes from — the walk's other paths", () => {
   });
 });
 
-describe("markdown: offsets that cannot be followed, and rules that are LaTeX-only", () => {
-  const mdLint = async (text, rules) => {
-    const [res] = await new ESLint({
-      cwd: FIX,
-      overrideConfigFile: true,
-      overrideConfig: [
-        {
-          files: ["**/*.md"],
-          plugins: { markdown, paper: typography },
-          language: "markdown/gfm",
-          rules,
-        },
-      ],
-    }).lintText(text, { filePath: join(FIX, "inline", "paper.md") });
-    expect(res.messages.filter((m) => m.fatal)).toEqual([]);
-    return res;
-  };
-
-  it("`§` before prose is reported without a fix", async () => {
-    const src = "As § above.\n";
-    const res = await mdLint(src, { "paper/section-word": "warn" });
-    expect(res.messages.map((m) => [m.ruleId, m.column, m.fix])).toEqual([
-      ["paper/section-word", 4, undefined],
-    ]);
-  });
-
-  it("a sign or a dot written as a character reference has no source offset: nothing is reported", async () => {
-    const res = await mdLint("See &#167; 5 and &#46;25.\n", {
-      "paper/section-word": "warn",
-      "paper/leading-zero": "warn",
-    });
-    expect(res.messages).toEqual([]);
-  });
-
-  it("figure-ref-style is LaTeX-only: silent on markdown", async () => {
-    const res = await mdLint("Figure~\\ref{a} and Fig.~\\ref{b}.\n", {
-      "paper/figure-ref-style": "warn",
-    });
-    expect(res.messages).toEqual([]);
-  });
-});
-
 describe("a source code the rules did not expect — the defaults hold", () => {
   const reports = (ruleId, sourceCode) => {
     const out = [];
@@ -530,12 +454,20 @@ describe("a source code the rules did not expect — the defaults hold", () => {
     ]);
   });
 
-  it("markdown text nodes without positions: seen, never reported at a guessed place", () => {
-    const ast = {
-      type: "root",
-      children: [{ type: "text", value: "§5 and .25" }],
-    };
-    expect(reports("section-word", { text: "§5 and .25", ast })).toEqual([]);
-    expect(reports("leading-zero", { text: "§5 and .25", ast })).toEqual([]);
-  });
+  it.each(["section-word", "leading-zero", "figure-ref-style"])(
+    "%s reads LaTeX only: a source without `raw` (any other language) is not reported",
+    (ruleId) => {
+      const ast = {
+        type: "root",
+        children: [
+          {
+            type: "text",
+            value: "§5 and .25",
+            position: { start: { offset: 0 }, end: { offset: 10 } },
+          },
+        ],
+      };
+      expect(reports(ruleId, { text: "§5 and .25", ast })).toEqual([]);
+    },
+  );
 });

package/eslint-rules/paper-typography.ts

@@ -41,11 +41,9 @@
  * IEEE Editorial Style Manual ("0.25, not .25") require the zero. A regex over the raw source
  * found 22 decimals on a real corpus and none was a defect: every one sat in markup (an option,
  * a column spec, a comment, a listing, a tikz coordinate). So this walks the TREE and keeps only
- * what the reader sees as a number:
- *   LaTeX     prose, inline and display math, table cells, and the text arguments of a known
- *             set of text macros. Not: any other macro's arguments, environment arguments,
- *             comments, verbatim/listings/`\lstinline`, tikz, the preamble, the bibliography.
- *   Markdown  text nodes, table cells included. Not: code, inline code, html, front matter.
+ * what the reader sees as a number: prose, inline and display math, table cells, and the text
+ * arguments of a known set of text macros. Not: any other macro's arguments, environment
+ * arguments, comments, verbatim/listings/`\lstinline`, tikz, the preamble, the bibliography.
  * Each character of a run keeps its source offset, so the finding points at the dot and the fix
  * inserts the zero there. The arXiv lookbehind stays: in `2310.05736` the dot follows a digit.
  * A text macro outside the known set (`\hl{.05}`) is read as a parameter and NOT reported — a
@@ -62,7 +60,6 @@
 import assert from "node:assert/strict";
 import { getParser } from "@unified-latex/unified-latex-util-parse";
 import { takeWhile } from "remeda";
-import type { Nodes } from "mdast";
 import {
   texToMdast,
   type TexArg,
@@ -108,7 +105,7 @@ export function bibRange(text: string): BibRange | null {
   return { start: m.index, end: m.index + whole.length, bodyStart, body };
 }
 
-/** A node of a file's projection, as far as its place goes: mdast's, or the `.tex` language's. */
+/** A node of the `.tex` language's projection, as far as its place goes. */
 interface ProjectedNode {
   readonly type: string;
   readonly position?:
@@ -372,66 +369,6 @@ export function texVisibleRuns(
   return texRuns(document ? document.content : root, false, raw, []);
 }
 
-// Markdown node types that are not prose.
-const MD_HIDDEN = new Set([
-  "code",
-  "inlineCode",
-  "html",
-  "yaml",
-  "toml",
-  "math",
-  "inlineMath",
-]);
-/**
- * The source offset of each character of a text node's value. The value is the source with
- * markdown's escapes (`\*`) and character references (`<`) resolved, so the two are walked
- * side by side; a character whose source cannot be followed gets null (reported, not fixed).
- */
-function mdOffsets(value: string, src: string, start: number) {
-  const offs: (number | null)[] = [];
-  let j = start;
-  for (const ch of value) {
-    if (src[j] === ch) offs.push(j++);
-    else if (src[j] === "\\" && src[j + 1] === ch) {
-      offs.push(j + 1);
-      j += 2;
-    } else if (src[j] === "&" && /^&#?\w{1,8};/.test(src.slice(j, j + 10))) {
-      offs.push(null);
-      j = src.indexOf(";", j) + 1;
-    } else {
-      offs.push(null);
-      j++;
-    }
-  }
-  return offs;
-}
-
-function mdVisibleRuns(
-  node: Nodes | undefined,
-  src: string,
-  out: Run[] = [],
-): Run[] {
-  if (!node || MD_HIDDEN.has(node.type)) return out;
-  if (node.type === "text") {
-    const start = node.position?.start.offset;
-    out.push({
-      text: node.value,
-      offs:
-        typeof start === "number"
-          ? mdOffsets(node.value, src, start)
-          : Array.from(node.value, () => null),
-    });
-  }
-  for (const c of "children" in node ? node.children : [])
-    mdVisibleRuns(c, src, out);
-  return out;
-}
-
-const visibleRuns = (sourceCode: RuleSourceCode): Run[] =>
-  isTex(sourceCode)
-    ? texVisibleRuns(sourceCode.raw)
-    : mdVisibleRuns(sourceCode.ast, sourceCode.text);
-
 /** A report at `[from, to)` of the file. */
 const at = (
   context: RuleContext,
@@ -455,36 +392,22 @@ const SECTION_GLYPH = /§/g;
 
 function sectionWord(context: RuleContext) {
   const sc = context.sourceCode;
-  if (isTex(sc)) {
-    const seen = new Set();
-    for (const m of markupMatches(sc, SECTION_TEX)) {
-      seen.add(m.index);
-      const word = m[3] ? "Section~" : "Section ";
-      const range: [number, number] = [m.index, m.index + m[0].length];
-      at(context, range[0], range[1], {
-        messageId: "sign",
-        fix: (f) => f.replaceTextRange(range, word),
-      });
-    }
-    // A glyph before neither a reference nor a number: reported, not rewritten — there is no
-    // single right word for a doubled sign or a sign before prose.
-    for (const m of markupMatches(sc, SECTION_GLYPH))
-      if (!seen.has(m.index))
-        at(context, m.index, m.index + 1, { messageId: "sign" });
-    return;
+  if (!isTex(sc)) return;
+  const seen = new Set();
+  for (const m of markupMatches(sc, SECTION_TEX)) {
+    seen.add(m.index);
+    const word = m[3] ? "Section~" : "Section ";
+    const range: [number, number] = [m.index, m.index + m[0].length];
+    at(context, range[0], range[1], {
+      messageId: "sign",
+      fix: (f) => f.replaceTextRange(range, word),
+    });
   }
-  for (const r of visibleRuns(sc))
-    for (const m of r.text.matchAll(/§([ \t]*)(\d)?/g)) {
-      const from = r.offs[m.index];
-      if (from === null || from === undefined) continue;
-      // The sign and the space after it; the number stays.
-      const [, gap = ""] = m;
-      const range: [number, number] = [from, from + 1 + gap.length];
-      at(context, range[0], range[1], {
-        messageId: "sign",
-        ...(m[2] ? { fix: (f) => f.replaceTextRange(range, "Section ") } : {}),
-      });
-    }
+  // A glyph before neither a reference nor a number: reported, not rewritten — there is no
+  // single right word for a doubled sign or a sign before prose.
+  for (const m of markupMatches(sc, SECTION_GLYPH))
+    if (!seen.has(m.index))
+      at(context, m.index, m.index + 1, { messageId: "sign" });
 }
 
 // ── paper/leading-zero ─────────────────────────────────────────────────────────────────
@@ -508,8 +431,9 @@ const paragraphBefore = (src: string, i: number) => {
 
 function leadingZero(context: RuleContext) {
   const sc = context.sourceCode;
-  const src = isTex(sc) ? sc.raw : sc.text;
-  for (const r of visibleRuns(sc))
+  if (!isTex(sc)) return;
+  const src = sc.raw;
+  for (const r of texVisibleRuns(src))
     for (const m of r.text.matchAll(BARE_DECIMAL)) {
       const dot = r.offs[m.index];
       if (dot === null || dot === undefined) continue;

package/eslint-rules/papers.harness.mjs

@@ -170,7 +170,7 @@ for (const bad of ["", null, 0, false, [], {}, 42])
   const names = Object.keys(sets).sort();
   assert.deepEqual(
     names,
-    ["all", "md", "pdfFacts", "refFacts", "status", "tex", "venue"],
+    ["all", "pdfFacts", "refFacts", "status", "tex", "venue"],
     "the glob set changed — a consumer's config enumerates these by name, and a renamed or " +
       "dropped key is a block that silently lints nothing",
   );

package/eslint-rules/papers.ts

@@ -41,7 +41,7 @@
  *
  *   A FILENAME MARKER, no root at all (`**\/paper.tex`).
  *     Measured on the first consumer: `paper.tex` ×4 with one outside the corpus,
- *     `PIPELINE-STATUS.md` ×6 with two of them test fixtures, `paper.md` ×3 with two outside.
+ *     `PIPELINE-STATUS.md` ×6 with two of them test fixtures.
  *     The guard that would consume this is a `deny` at `error` severity; a denial on writing
  *     a fixture gets the hook switched off the same day.
  *
@@ -134,15 +134,13 @@ export function papersRoot(
  * The glob sets a consumer declares its blocks on, derived from one root.
  *
  * 🔴 THE SHAPES LIVE HERE, NOT IN THE CONSUMER, and that is the half that keeps a rule from
- * going blind later. `paper.md` + `draft.md`, `_build/*.facts.json`, `PIPELINE-STATUS.md` are
+ * going blind later. `paper.tex`, `_build/*.facts.json`, `PIPELINE-STATUS.md` are
  * this pipeline's CONVENTION; if a rule starts reading a new file, the glob for it must arrive
  * with the rule, in the same package, rather than as a line every consumer has to add by hand
  * to keep up. A hand-maintained list of paths is the thing that rots, and rots silently.
  */
 export function paperFiles(root: string) {
   return {
-    /** Markdown drafts — the two names a paper's prose is allowed to have. */
-    md: [`${root}/*/paper.md`, `${root}/*/draft.md`],
     /** The LaTeX source of a paper (not its figures, not its vendored drafts). */
     tex: [`${root}/*/paper.tex`],
     /** The per-paper stage ledger. */

package/eslint-rules/tex-build.harness.mjs

@@ -35,8 +35,8 @@
  *   (`284:will be released`, `284:Upon acceptance` + `285:will be made publicly available`).
  *
  * 🔴 AND ONE DISAGREEMENT, WHICH IS NOT IN THE LOGIC BUT IN THE INPUT — and it is the whole
- * gain. The old implementation picked its file by looking for `paper.md` / `draft.md` and
- * otherwise taking the FIRST `.tex` in `readdirSync` order. Measured 2026-09-07:
+ * gain. The old implementation picked its file by taking the FIRST `.tex` in `readdirSync`
+ * order. Measured 2026-09-07:
  *   paper A → a 536-BYTE file of nine `\def`s with venue numbers. The check, added
  *             specifically BECAUSE of paper A, was not reading paper A;
  *   paper B → a four-month-old draft, one of seven `.tex` files in that directory;

package/eslint-rules/tex-build.ts

@@ -3,27 +3,11 @@
  * how the prose is written.
  *
  * ── WHY ITS OWN NAMESPACE, AND NOT `paper/*` ────────────────────────────────
- * In the source corpus the `paper/*` family is declared on BOTH `paper.md` and `paper.tex`,
- * and that parity is pinned by an assertion: "a rule added for markdown must not silently
- * fail to reach LaTeX (or the other way round)". The subject here is the BUILD MODE
- * (`\documentclass[review]`, `printacmref=false`), and in markdown it does not exist: a draft
- * has no mechanical sign saying "this build is the final one". Writing
- * `paper/future-promise: "off"` on markdown would be an exemption justified by "there is no
- * subject", and that same parity assertion requires the rule to be ALIVE on the other side —
- * i.e. the machinery exists but is built for the opposite direction (off on `.tex`, alive on
- * `.md`).
- *
- * Hence a namespace of its own, the same way an external word-counter gets one: it has a word
- * count markdown does not have, we have a preamble markdown does not have. Where the config
- * enumerates non-`paper/*` rules on `.tex`, the list is CLOSED and `tex/future-promise` is
- * named explicitly, so that a new namespace arrives by decision rather than as a side effect
- * of editing a config.
- *
- * ⚠️ THE MEASUREMENT THIS DECISION RESTS ON (source corpus, 2026-09-06 → 2026-09-07): had the
- * rule been declared on `paper.md` it would produce ZERO there TODAY — not one match of
- * `FUTURE_PROMISE_RE` in the markdown draft of the one paper that has one. So the choice is
- * about semantics, not noise: markdown has no input distinguishing a draft from a shipped
- * build, and the rule would fire on a draft's honest promise.
+ * The subject here is the BUILD MODE (`\documentclass[review]`, `printacmref=false`), not the
+ * prose the `paper/*` rules read. Hence a namespace of its own, the same way an external
+ * word-counter gets one. Where the config enumerates non-`paper/*` rules on `.tex`, the list is
+ * CLOSED and `tex/future-promise` is named explicitly, so that a new namespace arrives by
+ * decision rather than as a side effect of editing a config.
  *
  * ── THE RULE READS THE FILE FROM DISK, NOT THE PROJECTION. This is load-bearing ──
  * The LaTeX language in `latex-language.mjs` hands rules a PROJECTION of `.tex` into a
@@ -37,9 +21,8 @@
  * run (and in CI) there is no such difference.
  *
  * ── WHAT THE MOVE TO A LINT RULE FIXED BESIDES THE FORM (measured 2026-09-07) ──
- * 🔴 The previous implementation, a script, picked its input like this: look for `paper.md` /
- * `draft.md`, and failing that take `readdirSync(dir).find((f) => f.endsWith(".tex"))` — the
- * FIRST `.tex` in directory order. Measured across the three papers of the source corpus:
+ * 🔴 The previous implementation, a script, picked its input like this:
+ * `readdirSync(dir).find((f) => f.endsWith(".tex"))` — the FIRST `.tex` in directory order. Measured across the three papers of the source corpus:
  *   paper A → a 536-BYTE file holding nine `\def`s with venue numbers. The check, added
  *             specifically BECAUSE of paper A, was not reading paper A;
  *   paper B → a four-month-old draft, one of SEVEN `.tex` files in that directory (the real
@@ -121,7 +104,7 @@ const FRONTMATTER_OVERRIDES = [
 // is looking.
 //
 // The scope is DELIBERATELY NARROW, because a noisy gate is a silenced gate:
-//   - `.tex` only (see the file header: markdown has no sign of "this build is final");
+//   - `.tex` only: the build mode is read from the preamble;
 //   - a review-mode build is EXEMPT, and that is the whole point: during peer review
 //     "at camera-ready" is a true and ordinary promise. The defect is only a promise that
 //     outlived its own delivery;

package/eslint.config.mjs

@@ -413,6 +413,40 @@ export const IO_GLOBALS = {
   },
 };
 
+/**
+ * `paperlint lint` NEVER READS THE CLOCK. Its findings are a function of the files and the installed
+ * package: the same checkout lints the same tomorrow, and a deadline's distance belongs to a status
+ * view or a calendar, not to a gate (a lint that turns red on an untouched tree gets muted). The
+ * clock is an effect like the disk, so it is read where effects are — an adapter's `*.io.ts` and the
+ * root, `src/cli.ts` — and passed in. Matched on the AST: `Date.now` (called or passed along),
+ * `new Date()` and `Date()` without an argument. `new Date(ms)` converts a given time and passes.
+ * `toolchain.ts` and `build-engine.ts` keep `Date.now` as a default for their own timing (build and
+ * install only, neither runs under `lint`); that legacy I/O moves behind a port in #76.
+ */
+const READS_THE_CLOCK = [
+  "MemberExpression[object.name='Date'][property.name='now']",
+  "NewExpression[callee.name='Date'][arguments.length=0]",
+  "CallExpression[callee.name='Date']",
+].map((selector) => ({
+  selector,
+  message:
+    "Lint never reads the clock: its findings are a function of the files. Take the time as an argument; read it in an adapter's *.io.ts or src/cli.ts.",
+}));
+
+/** Every source file the checks are made of, but the places effects are allowed. Same scope as axis B. */
+export const NO_CLOCK = {
+  files: ["src/**/*.ts"],
+  ignores: [
+    ...IO_GLOBALS.ignores,
+    // Legacy I/O, moves behind a port in #76 (see READS_THE_CLOCK).
+    "src/toolchain.ts",
+    "src/build-engine.ts",
+  ],
+  rules: {
+    "no-restricted-syntax": ["error", AS_UNKNOWN_AS, ...READS_THE_CLOCK],
+  },
+};
+
 /**
  * EVERY PRESET HAS A CARD, AND EVERY CARD'S RULES TABLE IS THE PRESET'S. Two checks, one block each:
  *
@@ -486,7 +520,6 @@ const TYPESCRIPT_ONLY = [
   "test/e2e/**/*.{js,mjs,cjs}",
   "test/fixtures/layers/src/**/*.{js,mjs,cjs}",
   "fixtures/accepted-papers/**/*.{js,mjs,cjs}",
-  "fixtures/real-markdown-paper/**/*.{js,mjs,cjs}",
   "skills/paper-pipeline/scripts/fixtures/**/*.{js,mjs,cjs}",
   "skills/plan-paper-timeline/fixtures/**/*.{js,mjs,cjs}",
 ];
@@ -608,6 +641,7 @@ export default [
   },
   // Hexagonal layers, both axes (src/CLAUDE.md): knowledge by element, purity by file category.
   IO_GLOBALS,
+  NO_CLOCK,
   layerBoundaries(dirname(fileURLToPath(import.meta.url))),
   // The ratchet: per-file ceilings for the files written before the limits existed. See RATCHET.
   ...Object.entries(RATCHET).map(([file, max]) => ({
@@ -805,7 +839,12 @@ export default [
     files: ["eslint-rules/*.ts", "eslint-rules/*.mjs"],
     ignores: ["eslint-rules/*.test.*", "eslint-rules/*.harness.*"],
     rules: {
-      "no-restricted-syntax": ["error", AS_UNKNOWN_AS, ...GIT_IN_A_RULE],
+      "no-restricted-syntax": [
+        "error",
+        AS_UNKNOWN_AS,
+        ...GIT_IN_A_RULE,
+        ...READS_THE_CLOCK,
+      ],
     },
   },
   // LAST, so no block above can replace its `no-restricted-syntax` options for these files (none