paperlint 3.0.0 → 3.1.1

package/scripts/layer-legacy-frozen.test.ts

@@ -4,8 +4,18 @@
  * tally is tested on what the linter reports, not on source text.
  */
 import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
 import { test } from "vitest";
-import { judge, tally, type Suppressed } from "./layer-legacy-frozen.mjs";
+import {
+  checkFrozen,
+  FROZEN_FILE,
+  judge,
+  main,
+  tally,
+  type Suppressed,
+} from "./layer-legacy-frozen.mjs";
+import { useTempDir, writeTree } from "../test/support.mjs";
 
 const IO = "legacy I/O, moves behind a port in #76";
 const LAYER = "legacy layer, moves behind a port in #76";
@@ -113,3 +123,135 @@ test("a layer finding silenced without naming #76 is reported; other rules' supp
     /src\/build\.ts:4: boundaries\/dependencies is silenced with "temporary"/,
   );
 });
+
+test("main: problems are listed and fail; a clean count passes", async () => {
+  const run = async (r: {
+    problems: string[];
+    counts: Record<string, Record<string, number>>;
+  }) => {
+    const out: string[] = [];
+    const code = await main({
+      check: async () => ({ ...r, frozen: {} }),
+      log: (s: string) => out.push(s),
+      err: (s: string) => out.push(`E ${s}`),
+    });
+    return { code, out };
+  };
+  assert.deepEqual(
+    [
+      await run({ problems: ["a.ts: grew", "b.ts: new"], counts: {} }),
+      await run({
+        problems: [],
+        counts: { "a.ts": { r: 2 }, "b.ts": { r: 1, s: 1 } },
+      }),
+    ],
+    [
+      {
+        code: 1,
+        out: [
+          "E 🔴 legacy layer exemptions are frozen and may only shrink (#76) — 2 problem(s):",
+          "E    a.ts: grew",
+          "E    b.ts: new",
+        ],
+      },
+      {
+        code: 0,
+        out: [
+          "✓ 2 legacy files, 4 frozen layer exemptions, none new, none grown (#76)",
+        ],
+      },
+    ],
+  );
+});
+
+// Lints the whole of src/ with the real config: ~3 s alone, 5.6 s measured under c8 with the
+// suite running in parallel — past vitest's 5 s default, so the budget is stated here.
+test(
+  "checkFrozen on this repository: nothing new, nothing grown — and on a tree with no src/, ESLint refuses loudly",
+  {
+    timeout: 30_000,
+  },
+  async () => {
+    const root = useTempDir("layer-frozen-");
+    writeTree(root, {
+      [FROZEN_FILE]: JSON.stringify({ files: {} }),
+      "eslint.config.mjs": "export default [];\n",
+    });
+    const here = await checkFrozen();
+    await assert.rejects(checkFrozen(root), {
+      message: "No files matching 'src/**/*.ts' were found.",
+    });
+    assert.deepEqual(here.problems, []);
+    assert.deepEqual(here.counts, here.frozen);
+  },
+);
+
+test("checkFrozen: a lint that returns no result reports that nothing was counted", async () => {
+  const root = useTempDir("layer-frozen-empty-");
+  writeTree(root, {
+    [FROZEN_FILE]: JSON.stringify({ files: { "src/a.ts": { x: 1 } } }),
+  });
+  assert.deepEqual(await checkFrozen(root, { lint: async () => [] }), {
+    problems: ["src/**/*.ts matched no file — nothing was counted."],
+    frozen: { "src/a.ts": { x: 1 } },
+    counts: {},
+  });
+});
+
+test("tally: optional parts of ESLint's result shape are read as absent", () => {
+  const t = tally([
+    { filePath: "src/a.ts" },
+    {
+      filePath: "src/b.ts",
+      suppressedMessages: [
+        { ruleId: null, line: 1, suppressions: [{ justification: IO }] },
+        { ruleId: "boundaries/dependencies", line: 2 },
+        { ruleId: "boundaries/dependencies", line: 3, suppressions: [{}] },
+      ],
+    },
+  ]);
+  assert.deepEqual(t.counts, {});
+  assert.deepEqual(t.unexplained, [
+    'src/b.ts:2: boundaries/dependencies is silenced with "" — a layer exemption must say "legacy I/O|layer, moves behind a port in #76", or the site must be fixed.',
+    'src/b.ts:3: boundaries/dependencies is silenced with "" — a layer exemption must say "legacy I/O|layer, moves behind a port in #76", or the site must be fixed.',
+  ]);
+});
+
+test("checkFrozen: a frozen file with no `files` freezes nothing", async () => {
+  const root = useTempDir("layer-frozen-nofiles-");
+  writeTree(root, { [FROZEN_FILE]: "{}\n" });
+  const r = await checkFrozen(root, {
+    lint: async () => [
+      { filePath: `${root}/src/a.ts`, suppressedMessages: [] },
+    ],
+  });
+  assert.deepEqual(r, { problems: [], frozen: {}, counts: {} });
+});
+
+test("run as a program: the gate's verdict is the exit code", () => {
+  // ESLint is replaced by one whose lint answers nothing, so the real script runs end to end in
+  // well under a second and takes its refusal path.
+  const fake = encodeURIComponent(
+    "export class ESLint { async lintFiles() { return []; } }",
+  );
+  const hook = encodeURIComponent(
+    `export async function resolve(s, c, next) { return s === "eslint" ? { url: "data:text/javascript,${fake}", shortCircuit: true } : next(s, c); }`,
+  );
+  const preload = `data:text/javascript,${encodeURIComponent(
+    `import { register } from "node:module"; register("data:text/javascript,${hook}");`,
+  )}`;
+  const r = spawnSync(
+    process.execPath,
+    [
+      "--import",
+      preload,
+      fileURLToPath(new URL("./layer-legacy-frozen.mjs", import.meta.url)),
+    ],
+    { encoding: "utf8" },
+  );
+  assert.equal(r.status, 1, r.stderr);
+  assert.match(
+    r.stderr,
+    /1 problem\(s\):\n {3}src\/\*\*\/\*\.ts matched no file — nothing was counted\./,
+  );
+});

package/scripts/rules-are-content-only.harness.mjs

@@ -12,20 +12,16 @@
  *   III. QUIET on sources that merely TALK about the banned module — a comment and a string
  *        literal. This is the half a grep cannot have, and the reason the check parses.
  */
-import assert from "node:assert/strict";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { createChecker } from "../lib/check.mjs";
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 const { rulesAreContentOnly, processImports } = await import(
   join(HERE, "rules-are-content-only.mjs")
 );
 
-let n = 0;
-const check = (label, ok) => {
-  n++;
-  assert.equal(ok, true, label);
-};
+const check = createChecker();
 
 // ── I. quiet on the real corpus, and it actually looked ───────────────────────
 {
@@ -38,10 +34,6 @@ const check = (label, ok) => {
     `quiet on the real corpus (${findings.length} findings)`,
     findings.length === 0,
   );
-  check(
-    "mutation files are not scanned as rules",
-    !checked.some((f) => f.endsWith(".mutations.mjs")),
-  );
 }
 
 // ── II. fires on every form the defect has taken ────────────────────────────
@@ -110,4 +102,4 @@ for (const [label, src] of [
   check(`quiet on ${label}`, processImports(src).length === 0);
 }
 
-console.log(`rules-are-content-only.harness: ${n} assertions passed`);
+console.log(`rules-are-content-only.harness: ${check.count} assertions passed`);

package/scripts/rules-are-content-only.mjs

@@ -28,7 +28,7 @@
  * Tested by: `scripts/rules-are-content-only.harness.mjs` — quiet on the real corpus, firing on
  * a planted rule.
  */
-import { readdirSync, readFileSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { parse } from "espree";
 import { isMain } from "../skills/paper-pipeline/scripts/consumer.mjs";
@@ -59,11 +59,8 @@ const SPAWNERS = new Set([
 const isGit = (v) =>
   typeof v === "string" && (v === "git" || v.startsWith("git "));
 
-/** Rule sources only: a mutation file plants defects on purpose, a harness asserts about them. */
-const isRuleSource = (f) =>
-  f.endsWith(".mjs") &&
-  !f.endsWith(".mutations.mjs") &&
-  !f.endsWith(".harness.mjs");
+/** Rule sources only: a harness plants defects on purpose and asserts about them. */
+const isRuleSource = (f) => f.endsWith(".mjs") && !f.endsWith(".harness.mjs");
 
 /** @param {string} src @returns {string[]} the git invocations this source makes */
 export function processImports(src) {
@@ -98,7 +95,10 @@ export function rulesAreContentOnly({ cwd }) {
   const dir = join(cwd, "eslint-rules");
   const checked = [];
   const findings = [];
-  for (const f of readdirSync(dir).filter(isRuleSource)) {
+  // A repository with no `eslint-rules/` has no rule sources: `checked` stays empty and the gate
+  // says so by name. `readdirSync` would throw ENOENT instead — a stack trace, not the refusal.
+  const names = existsSync(dir) ? readdirSync(dir) : [];
+  for (const f of names.filter(isRuleSource)) {
     const hits = processImports(readFileSync(join(dir, f), "utf8"));
     // 🔴 The counter increments WITH the verdict, not before it: a `checked` that keeps
     // counting while the verdict stops being reached is the failure recorded in the consumer's
@@ -109,30 +109,40 @@ export function rulesAreContentOnly({ cwd }) {
   return { checked, findings };
 }
 
-if (isMain(import.meta.url)) {
-  // 🔴 `process.cwd()`, NOT the package root. A consumer installs this package and runs the
-  // script from its own repository, where the rules that matter are ITS `eslint-rules/` — the
-  // package's own are already checked by the package's own gate. Anchored to the package root
-  // the consumer's gate would re-check the same eight files and report a confident zero about
-  // rules it never opened: a counter that counts what it ignores.
-  const cwd = process.cwd();
+/**
+ * The gate over `cwd`'s `eslint-rules/`: exit 1 on no rule sources (a silent zero would read as
+ * clean) or on any rule asking git; 0 otherwise.
+ *
+ * 🔴 `cwd` is `process.cwd()`, NOT the package root. A consumer installs this package and runs the
+ * script from its own repository, where the rules that matter are ITS `eslint-rules/` — the
+ * package's own are already checked by the package's own gate. Anchored to the package root the
+ * consumer's gate would re-check the same eight files and report a confident zero about rules it
+ * never opened: a counter that counts what it ignores.
+ */
+export function main({
+  cwd = process.cwd(),
+  log = console.log,
+  err = console.error,
+} = {}) {
   const { checked, findings } = rulesAreContentOnly({ cwd });
   if (checked.length === 0) {
-    console.error(
+    err(
       `${join(cwd, "eslint-rules")}: no rule sources. Either this is not a repository with ` +
         `ESLint rules, or the directory moved — a silent zero here would read as a clean run.`,
     );
-    process.exit(1);
+    return 1;
   }
   for (const { file, specifier } of findings) {
-    console.error(
+    err(
       `${file}: imports \`${specifier}\`. A rule may not ask git: history is rewritten by ` +
         `routine maintenance and CI clones one commit deep, so the fact does not survive where ` +
         `the rule has to hold. Put the fact on disk and check it by bytes.`,
     );
   }
-  console.log(
+  log(
     `rules-are-content-only: ${checked.length} rule sources under ${cwd}, ${findings.length} findings`,
   );
-  process.exit(findings.length === 0 ? 0 : 1);
+  return findings.length === 0 ? 0 : 1;
 }
+
+if (isMain(import.meta.url)) process.exit(main());

package/scripts/rules-are-content-only.test.mjs

@@ -0,0 +1,61 @@
+/**
+ * rules-are-content-only's gate over a consumer's `eslint-rules/`: temp trees with planted rules.
+ */
+import assert from "node:assert/strict";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+import { test } from "vitest";
+import { useTempDir, writeTree } from "../test/support.mjs";
+import { main as contentMain } from "./rules-are-content-only.mjs";
+
+const capture = () => {
+  const out = [];
+  const io = { log: (s) => out.push(s), err: (s) => out.push(`E ${s}`) };
+  return { out, io };
+};
+
+const root = useTempDir("content-only-");
+
+test("rules-are-content-only: no rules is a failure, a rule asking git is a finding, clean rules pass", () => {
+  writeTree(root, {
+    "empty/.keep": "",
+    "dirty/eslint-rules/asks-git.mjs":
+      'import { execFileSync } from "node:child_process";\nexecFileSync("git", ["log"]);\n',
+    "dirty/eslint-rules/clean.mjs": "export default {};\n",
+    "clean/eslint-rules/clean.mjs": "export default {};\n",
+  });
+  const runs = ["empty", "dirty", "clean"].map((d) => {
+    const { out, io } = capture();
+    return [
+      contentMain({ cwd: `${root}/${d}`, ...io }),
+      out.map((l) => l.replace(root, "<root>").split(". ")[0]),
+    ];
+  });
+  assert.deepEqual(runs, [
+    [1, ["E <root>/empty/eslint-rules: no rule sources"]],
+    [
+      1,
+      [
+        "E asks-git.mjs: imports `git`",
+        "rules-are-content-only: 2 rule sources under <root>/dirty, 1 findings",
+      ],
+    ],
+    [
+      0,
+      ["rules-are-content-only: 1 rule sources under <root>/clean, 0 findings"],
+    ],
+  ]);
+});
+
+test("run as a program over this repository: every rule source is content-only, exit 0", () => {
+  const r = spawnSync(
+    process.execPath,
+    [fileURLToPath(new URL("./rules-are-content-only.mjs", import.meta.url))],
+    { cwd: fileURLToPath(new URL("..", import.meta.url)), encoding: "utf8" },
+  );
+  assert.equal(r.status, 0, r.stderr);
+  assert.match(
+    r.stdout,
+    /^rules-are-content-only: \d+ rule sources under .*, 0 findings\n$/,
+  );
+});

package/scripts/rules-see-files.mjs

@@ -79,21 +79,23 @@ export async function rulesSeeFiles({ cwd }) {
 // a symlink the two are not equal and the CLI silently does not run — the process exits 0 having
 // done nothing. The consumer reaches these scripts through exactly such a symlink. Observed 14.09
 // on run 34784079821: `extract-pdf-facts.mjs --strict` returned RC=0 and created no facts file.
-if (isMain(import.meta.url)) {
-  const { rules, linted, blind } = await rulesSeeFiles({ cwd: process.cwd() });
+/** The gate: every declared rule listed with the files it saw; exit 1 when one saw none. */
+export async function main({ cwd = process.cwd(), log = console.log } = {}) {
+  const { rules, linted, blind } = await rulesSeeFiles({ cwd });
   for (const { rule, files } of rules)
-    console.log(`${String(files).padStart(4)}  ${rule}`);
-  console.log(`\n${rules.length} rule(s) declared, ${linted} file(s) linted.`);
+    log(`${String(files).padStart(4)}  ${rule}`);
+  log(`\n${rules.length} rule(s) declared, ${linted} file(s) linted.`);
   if (blind.length) {
-    console.log(
+    log(
       `\n✗ ${blind.length} rule(s) saw NO file and were never invoked:\n` +
         blind.map((r) => `    ${r}`).join("\n") +
         "\n\n  A rule that is never invoked reports exactly what a rule that passed reports.\n" +
         "  Fix the glob it is declared on, or delete the declaration — do not leave it green.",
     );
-    process.exit(1);
+    return 1;
   }
-  console.log(
-    "✓ every declared rule was enabled for at least one file on disk.",
-  );
+  log("✓ every declared rule was enabled for at least one file on disk.");
+  return 0;
 }
+
+if (isMain(import.meta.url)) process.exit(await main());

package/scripts/rules-see-files.test.mjs

@@ -0,0 +1,71 @@
+/**
+ * rules-see-files' gate: a temp repository whose config declares a rule on a glob matching nothing.
+ */
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { test } from "vitest";
+import { useTempDir, writeTree } from "../test/support.mjs";
+import { main as seeMain } from "./rules-see-files.mjs";
+
+const capture = () => {
+  const out = [];
+  const io = { log: (s) => out.push(s), err: (s) => out.push(`E ${s}`) };
+  return { out, io };
+};
+
+const root = useTempDir("rules-see-files-");
+
+test("rules-see-files: a rule declared on a glob that matches nothing is named and fails", async () => {
+  writeTree(root, {
+    "see/eslint.config.mjs":
+      'export default [{ files: ["**/*.js"], rules: { "no-debugger": "error" } }, { files: ["**/*.nothing"], rules: { "no-undef": "error", "eqeqeq": "off" } }];\n',
+    "see/a.js": "export const a = 1;\n",
+    "see/package.json": '{ "type": "module" }\n',
+  });
+  const { out, io } = capture();
+  const code = await seeMain({ cwd: `${root}/see`, ...io });
+  assert.deepEqual(
+    { code, out },
+    {
+      code: 1,
+      out: [
+        "   1  no-debugger",
+        "   0  no-undef",
+        "\n2 rule(s) declared, 2 file(s) linted.",
+        "\n✗ 1 rule(s) saw NO file and were never invoked:\n    no-undef\n\n" +
+          "  A rule that is never invoked reports exactly what a rule that passed reports.\n" +
+          "  Fix the glob it is declared on, or delete the declaration — do not leave it green.",
+      ],
+    },
+  );
+});
+
+test("rules-see-files: every rule seeing a file passes — asked with a trailing slash, and as a program", async () => {
+  writeTree(root, {
+    "ok/eslint.config.mjs":
+      'export default [{ files: ["**/*.js"], rules: { "no-debugger": ["error"] } }];\n',
+    "ok/a.js": "export const a = 1;\n",
+    "ok/package.json": '{ "type": "module" }\n',
+  });
+  const { out, io } = capture();
+  const code = await seeMain({ cwd: `${root}/ok/`, ...io });
+  assert.deepEqual(
+    { code, out },
+    {
+      code: 0,
+      out: [
+        "   1  no-debugger",
+        "\n1 rule(s) declared, 2 file(s) linted.",
+        "✓ every declared rule was enabled for at least one file on disk.",
+      ],
+    },
+  );
+  const run = spawnSync(
+    process.execPath,
+    [fileURLToPath(new URL("./rules-see-files.mjs", import.meta.url))],
+    { cwd: `${root}/ok`, encoding: "utf8" },
+  );
+  assert.equal(run.status, 0, run.stderr);
+  assert.match(run.stdout, /✓ every declared rule was enabled/);
+});

package/scripts/test.mjs

@@ -0,0 +1,44 @@
+/**
+ * `npm test`: the unit tests (vitest), then the harnesses (`vigiles test`). BOTH always run.
+ *
+ * Until #52 this was `vitest run && vigiles test --min=1`. Under `npm run coverage` a single
+ * failing vitest test then skipped every harness, and what the run printed last was c8's summary:
+ * lines, branches and functions each some six points below the floor. The one failing test sat
+ * above that, looking like a consequence rather than the cause. Running both suites keeps the
+ * coverage report whole, so a failing test is reported as itself and the coverage figures still
+ * mean what they say.
+ *
+ * Arguments are the harness runner's (`npm test -- --no-skip`), as they were before.
+ */
+import { spawnSync } from "node:child_process";
+import { isMain } from "../skills/paper-pipeline/scripts/consumer.mjs";
+
+/** The two suites, in order: what a failure is named as, and the command. */
+export const SUITES = [
+  { name: "vitest", command: ["vitest", "run"] },
+  { name: "harnesses", command: ["vigiles", "test", "--min=1"] },
+];
+
+/**
+ * Run every suite, whatever the one before it returned, and name the ones that failed.
+ * @returns 0 when every suite passed; otherwise the first failing suite's exit code (1 for a signal).
+ */
+export function runSuites(
+  args,
+  { spawn = spawnSync, err = console.error, suites = SUITES } = {},
+) {
+  const failed = suites.flatMap(({ name, command }) => {
+    const [file, ...rest] = command;
+    const r = spawn(file, [...rest, ...(name === "harnesses" ? args : [])], {
+      stdio: "inherit",
+    });
+    return r.status === 0 ? [] : [{ name, code: r.status ?? 1 }];
+  });
+  for (const f of failed)
+    err(
+      `✗ ${f.name} failed (exit ${String(f.code)}) — its own report is above`,
+    );
+  return failed.length === 0 ? 0 : failed[0].code;
+}
+
+if (isMain(import.meta.url)) process.exit(runSuites(process.argv.slice(2)));

package/scripts/test.test.mjs

@@ -0,0 +1,52 @@
+/**
+ * `npm test`'s runner: both suites run whatever the first returned, each failure is named, and
+ * the harness arguments reach the harness runner only.
+ */
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { runSuites, SUITES } from "./test.mjs";
+
+const fake = (status) => {
+  const calls = [];
+  return {
+    calls,
+    spawn: (file, args) => {
+      calls.push([file, ...args]);
+      return { status: status[file] };
+    },
+  };
+};
+
+test("a failing vitest does not skip the harnesses, and is named as the failure", () => {
+  const { calls, spawn } = fake({ vitest: 1, vigiles: 0 });
+  const said = [];
+  assert.equal(
+    runSuites(["--no-skip"], { spawn, err: (s) => said.push(s) }),
+    1,
+  );
+  assert.deepEqual(calls, [
+    ["vitest", "run"],
+    ["vigiles", "test", "--min=1", "--no-skip"],
+  ]);
+  assert.deepEqual(said, [
+    "✗ vitest failed (exit 1) — its own report is above",
+  ]);
+});
+
+test("both passing is 0 and silent; a harness killed by a signal is exit 1, named", () => {
+  const ok = fake({ vitest: 0, vigiles: 0 });
+  assert.equal(runSuites([], { spawn: ok.spawn, err: assert.fail }), 0);
+  const killed = fake({ vitest: 0, vigiles: null });
+  const said = [];
+  assert.equal(
+    runSuites([], { spawn: killed.spawn, err: (s) => said.push(s) }),
+    1,
+  );
+  assert.deepEqual(said, [
+    "✗ harnesses failed (exit 1) — its own report is above",
+  ]);
+  assert.deepEqual(
+    SUITES.map((s) => s.name),
+    ["vitest", "harnesses"],
+  );
+});

package/skills/grade-paper-writing/__snapshots__/prose-lint.test.mjs.snap

@@ -0,0 +1,57 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`--flags-only: an over-long caption flags and exits 1 1`] = `
+"✍️  prose-lint — paper.md — 2 finding(s):
+   figures/fig1.tex: caption sentence of 46 words (warn >40) — "Big. word0 word1 word2 word3 word4 word5 word6 word7 word8 word9 word10 word11 word12 word13 word14 word15 wor…"
+   figures/fig1.tex: caption is 106 words (warn >100) — a caption this long is a section under a picture
+   run \`node .claude/skills/grade-paper-writing/prose-lint.mjs <file>\` for the sentences
+"
+`;
+
+exports[`--headings lists every heading from level 2 to 4, in order 1`] = `
+"
+=== paper.md — every heading, in order ===
+  1. Introduction
+  2. Method
+
+Read these as a stranger who will read nothing else. Each should name a thing:
+a linter, a configuration, a repository, a rule — not "answers", "kinds", "moves".
+
+(thresholds and their sources are in THRESHOLDS at the top of this file)
+"
+`;
+
+exports[`a .tex file is refused with exit 2, and nothing is measured 1`] = `
+"prose-lint reads markdown, not LaTeX: <root>/paper.tex
+There is no .tex stripping here — the word count would include the preamble and the .bib,
+and every metric (they are all fractions of the word count) would be understated by roughly half.
+What to cover prose in .tex with — papers/research/2026-08-26-proza-v-latex-zanyatost.md
+"
+`;
+
+exports[`the full report over markdown and rendered text 1`] = `
+"
+=== paper.md — 82 words, 9 sentences ===
+sentence lengths [7,10,8,6,19,6,8,8,6]  mean 8.7  sd 3.9  CV 0.45
+FLAG all metadiscourse/1000w  195.1   (Hyland RA baseline 64.9, warn >90)
+     nominalisations/1000w    12.2
+FLAG "rather than"/instead-of/10,000w  243.9   (warn >25; not epanorthosis, no published baseline)
+FLAG sentences ending on a cross-ref/citation/hedge (wasted stress position): 3
+       > …Clearly the first result matters (Section 3).
+       > …Prior work agrees [1, 2].
+       > … full suite of papers, which suggests the method might hold generally.
+ok   sentences whose main claim is a negation: 22%
+     topic positions (whose story is this?): "in this paper we present" | "it might possibly help, but" | "clearly the first result matters" | "prior work agrees [1, 2]." | "the speedup was 40% on" | "- the first item is" | "- the second item is" | "we believe that rather than" | "instead of prose, the numbers"
+
+=== page.txt — 13 words, 3 sentences ===
+sentence lengths [3,6,4]  mean 4.3  sd 1.2  CV 0.29
+ok   all metadiscourse/1000w  0   (Hyland RA baseline 64.9, warn >90)
+     nominalisations/1000w    0
+ok   "rather than"/instead-of/10,000w  0   (warn >25; not epanorthosis, no published baseline)
+ok   sentences ending on a cross-ref/citation/hedge (wasted stress position): 0
+ok   sentences whose main claim is a negation: 0%
+     topic positions (whose story is this?): "a rendered page." | "it was hyphenated across a" | "next page text here."
+
+(thresholds and their sources are in THRESHOLDS at the top of this file)
+"
+`;