paperlint 9.0.0 → 10.0.0

package/docs/rules/paper/allowed-files-only.md

@@ -0,0 +1,192 @@
+# paper/allowed-files-only
+
+**Level:** error · **Reads:** the paper folder's root (a directory listing), its `paperlint.json` ·
+**Reported on:** the first line of the paper's `PIPELINE-STATUS.md`, once per stray entry
+
+## What it catches
+
+A file or folder at the root of a paper folder that is not part of paperlint's layout. The root
+holds a small, known set; every kind of material has one folder; anything else goes into `extra/`,
+which is never judged.
+
+It runs on every `paperlint lint` and in CI, from the moment `paperlint new` creates the folder; a
+hook refuses a new stray entry before it is written. Which stage writes each place, and what checks
+it: [the map](../../layout.md).
+
+<!-- layout:begin — drawn from src/domain/paper-layout.ts (PAPER_LAYOUT_TREE); src/layout-docs.test.ts fails when this block differs -->
+
+```text
+<paper>/
+├── PIPELINE-STATUS.md             ← the paper's one live-state file: stages, plan, scorecard
+├── paper.tex                      ← the source; `paperlint build` compiles it
+├── paperlint.json                 ← the paper's settings
+├── README.md                      ← what the paper is
+├── CLAUDE.md                      ← the paper's agent rules
+├── CLAIMS.md                      ← the claims ledger
+├── NOTES.md                       ← each number in the paper → the data it comes from
+├── SUBMIT-CHECKLIST.md            ← the venue's format and submission mechanics
+├── .gitignore                     ← keeps the build's byproducts out of git
+├── paper.pdf                      ← the built PDF
+├── *.tex *.bib *.cls *.sty *.bst  ← what TeX and bibtex look up beside paper.tex
+├── _build/                        ← the facts `paperlint build` writes
+├── versions/                      ← each stage's frozen PDF and source
+├── reviews/                       ← dated reviews and pass reports
+├── siblings/                      ← the cards of competing papers
+├── research/                      ← dated research and decision records
+├── repro/                         ← the reproduction artifact
+│   ├── README.md                  ← the index: one line per study
+│   ├── .gitignore                 ← keeps the scripts' byproducts out of git
+│   ├── tools/                     ← scripts used across the paper (numbers, figures, anonymity check, harnesses)
+│   ├── data/                      ← shared data (tables, caches)
+│   └── <slug>-YYYY-MM-DD/         ← one folder per study or spike (<slug>-YYYY-MM for one that ran over weeks)
+│       └── README.md              ← required: what it asks, how to run it, what it found
+├── figures/                       ← graphics and their sources
+├── sections/                      ← the body, when it is split
+├── talk/                          ← the talk's files
+├── submission/                    ← forms, portal records, mail with the venue, the anonymized upload
+└── extra/                         ← anything; never judged
+```
+
+<!-- layout:end -->
+
+`paperlint new` makes the folders a paper uses from its first day: `versions/`, `reviews/`, `research/`,
+`repro/` (with its index, `tools/` and `data/`), `figures/` and `submission/`, each empty one with a
+`.gitkeep` so the layout is in the first commit. It leaves out `siblings/` (made with the first
+competitor's card), `sections/` (when the body is split), `talk/` (when the paper declares a talk),
+`extra/` (never judged) and `_build/` (the build's). No rule reports a `.gitkeep` inside these folders.
+
+`extra/` is never judged by any rule, not only this one: `paperlint lint` does not read a folder named
+`extra/`, wherever it is. An archived snapshot of an older paper kept there, with its own
+`PIPELINE-STATUS.md`, is not taken for a second paper.
+
+Never reported: the byproducts a TeX run leaves beside `paper.tex` (`paper.aux`, `.log`, `.out`,
+`.toc`, `.lof`, `.lot`, `.lol`, `.loa`, `.fls`, `.xdv`, `.dvi`, `.synctex.gz`; bibtex's `.bbl`, `.blg`;
+makeindex's `.idx`, `.ind`, `.ilg`; glossaries' `.glo`, `.gls`, `.glg`, `.acn`, `.acr`, `.alg`, `.ist`,
+`.nlo`, `.nls`; biber's `.bcf`, `.run.xml`; beamer's `.nav`, `.snm`, `.vrb`; latexmk's `.fdb_latexmk`;
+the list follows latexmk's clean lists; only under the job name `paper`), the `.aux` that
+`\include{chapter}` writes beside a root `chapter.tex`, and the operating system's `.DS_Store` and
+`Thumbs.db`.
+
+A venue's corpus of accepted papers is not in the paper folder at all: it is shared by every paper
+that targets the venue, in `<papers-root>/venues/<venue>/` ([what it holds](../../venues.md)).
+
+The paper's settings can move three entries, and what they name at the root is allowed while they
+name it: `pdf` (the built PDF under another path), `talk.dir` (another talk folder), and a preset
+file of the paper's own (`extends`, or the `extends` of any of its `cycles`).
+
+## Why
+
+A paper folder collects files the way a desk does: a plan, mails, three drafts of the PDF, an old
+attempt's checklist, a corpus. After a few months nobody can say which file is current, where the
+evidence for a decision is, or where a new thing goes, and an agent asked to continue the work reads
+the wrong one. A fixed root is what build tools settled on long ago (Cargo, Maven): a known set, one
+folder per kind of material, and one place for the rest.
+
+A structure linter over file names cannot do this from inside ESLint: ESLint is handed only the files
+paperlint lints, so a stray `.pdf`, `.py` or `.md` is never one of them. The rule lists the folder
+itself.
+
+## Examples
+
+Failing: a plan beside the paper.
+
+```text
+papers/agent-rule-drift/PIPELINE-STATUS.md
+  1:1  error  `PLAN.md` is at the root of a paper folder (the folder holding PIPELINE-STATUS.md),
+              and that root holds only paperlint's layout. Where it goes: a section of
+              PIPELINE-STATUS.md — the paper's one live-state file holds its stages, its plan
+              ("Plan / now") and its scorecard; move what is still live there and delete the file.
+The layout (extra/ takes anything and is never judged; the build's paper.* byproducts are never reported):
+<paper>/
+├── PIPELINE-STATUS.md             ← the paper's one live-state file: stages, plan, scorecard
+…
+└── extra/                         ← anything; never judged
+Rule paper/allowed-files-only: https://github.com/zernie/paperlint/blob/main/docs/rules/paper/allowed-files-only.md  paper/allowed-files-only
+```
+
+Each message names the entry and where it goes, and draws the whole layout above, so it reads on its own. A
+name met in real paper folders has one destination:
+
+| entry                      | where it goes                                                                                              |
+| -------------------------- | ---------------------------------------------------------------------------------------------------------- |
+| `PLAN.md`, `plans/`        | a section of `PIPELINE-STATUS.md` ("Plan / now")                                                           |
+| `DECISION-LOG.md`          | `research/`                                                                                                |
+| `EMAILS.md`                | `submission/`                                                                                              |
+| `data/`                    | `repro/data/`                                                                                              |
+| `artifact/`                | `repro/` (scripts in `repro/tools/`, data in `repro/data/`); the anonymized upload copy in `submission/`   |
+| `archive/`                 | `versions/` for frozen PDFs, `submission/` for an earlier attempt's forms and mails, `extra/` for the rest |
+| `venue-corpus/`, `venues/` | `<papers-root>/venues/<venue>/`, outside the paper folder                                                  |
+
+Any other name gets the choice by what it is: a record or research → `research/`; about submitting
+→ `submission/`; the paper's live state → a section of `PIPELINE-STATUS.md`; reproduction → `repro/`;
+a frozen PDF of a stage → `versions/`; unclear → `extra/`.
+
+Passing: the folder `paperlint new` writes (`PIPELINE-STATUS.md`, `paper.tex`, `paperlint.json`),
+and any folder holding only the entries above.
+
+## Options / preset fields
+
+No rule options. The paper's `pdf`, `talk.dir` and own preset files add what they name (above).
+
+## What it does not check
+
+- What is inside the allowed folders. `reviews/`, `siblings/` and `repro/` have their own rules
+  ([`repro/allowed-files-only`](../repro/allowed-files-only.md) for `repro/`); the rest are free.
+- Whether a `.tex` at the root is included by anything: a fragment the body no longer `\input`s
+  passes. Old versions of the source belong in `versions/`.
+- A folder without `PIPELINE-STATUS.md`: it is not a paper to paperlint.
+
+## The hook: a new stray entry is refused before it is written
+
+`paperlint init` also wires the hook `paper-folder-layout` (PreToolUse on `Edit|Write|MultiEdit`,
+`plugin/hooks/hooks.json`). When an agent is about to create a file that would add an entry the
+layout does not allow — at a paper folder's root, or at the top of its `repro/`
+([`repro/allowed-files-only`](../repro/allowed-files-only.md)) — the hook denies the call, and the reason it gives is the
+rule's own message: where the entry goes, and the layout drawn. The agent writes the file where it
+belongs instead, in the same turn. The text comes from the functions the rules report with
+(`strayTexts`, `reproTexts`); there is no second list.
+
+What it never refuses:
+
+- **a file that already exists** — editing is never blocked, wherever the file is, so a paper whose
+  folder predates the layout keeps working and the rule reports what is out of place;
+- a new file inside an entry that already exists, even a stray one: the entry is not new, and the
+  rule names it once;
+- anything outside a paper folder.
+
+A new study folder in `repro/` is started with its `README.md`; any other first file in it is
+refused with `repro/allowed-files-only`'s "without a README.md" message.
+
+🔴 **What it cannot see: the shell.** `mv`, `cp`, `git mv`, or a script that writes files are not an
+Edit or a Write, so the hook never sees them. The guarantee is the lint: both rules fail `paperlint
+lint`, and CI, whatever wrote the entry. The hook only saves the round trip. It does not read the
+paper's `rules` either: a paper that switched a layout rule off is still refused a new stray entry
+(an existing one is never refused).
+
+Its first step is cheap: it looks for the nearest folder above the target file that holds
+`PIPELINE-STATUS.md`, one file check per ancestor, and allows the call when there is none — no git,
+no settings, no lint before that. Measured on 2026-10-12: that step takes about 19 µs. The process
+around it is what every `paperlint hook` costs, the CLI's import: about 650 ms per write on the
+measuring machine, with or without a paper folder (`paper-skills-nudge`, a vigiles hook, measured 730
+to 850 ms on the same machine). The hook fails open: a payload it cannot read is reported on stderr
+and the call goes ahead.
+
+A project whose papers all live under one folder can skip the process for every other write by
+giving the hook's entry in its own `.claude/settings.json` an `if`, Claude Code's permission-rule
+filter, for example `"if": "Write(**/papers/**)"`. paperlint does not write one: where papers live is
+a project's choice, and a filter that misses a papers folder would make the hook silently dead there.
+
+## How to fix
+
+Move the entry where its message says, and update whatever names its path:
+
+```sh
+git mv papers/agent-rule-drift/EMAILS.md papers/agent-rule-drift/submission/EMAILS.md
+```
+
+To keep something as it is, move it under `extra/`. To switch the rule off for one paper, set it in
+that paper's `paperlint.json`:
+
+```json
+{ "rules": { "paper/allowed-files-only": "off" } }
+```

package/docs/rules/repro/allowed-files-only.md

@@ -0,0 +1,128 @@
+# repro/allowed-files-only
+
+**Level:** error · **Reads:** the listing of the paper's `repro/`, and whether each study folder in
+it holds a `README.md` · **Reported on:** the first line of the paper's `PIPELINE-STATUS.md`, once
+per misplaced entry
+
+## What it catches
+
+An entry at the top of a paper's `repro/` that is not part of its layout, and a study folder there
+without a `README.md`. `repro/` holds an index, the tools and data the whole paper shares, and one
+dated folder per study. Stage 3 of the pipeline, the study, writes here; the rule runs on every
+`paperlint lint` and in CI, and a hook refuses a new loose entry before it is written. The whole map:
+[`layout.md`](../../layout.md).
+
+<!-- layout:begin — drawn from src/domain/repro-layout.ts (REPRO_LAYOUT_TREE); src/layout-docs.test.ts fails when this block differs -->
+
+```text
+repro/
+├── README.md           ← the index: one line per study
+├── .gitignore          ← keeps the scripts' byproducts out of git
+├── tools/              ← scripts used across the paper (numbers, figures, anonymity check, harnesses)
+├── data/               ← shared data (tables, caches)
+└── <slug>-YYYY-MM-DD/  ← one folder per study or spike (<slug>-YYYY-MM for one that ran over weeks)
+    └── README.md       ← required: what it asks, how to run it, what it found
+```
+
+<!-- layout:end -->
+
+`paperlint new` makes `repro/README.md` (a stub index), `repro/tools/` and `repro/data/` (each with a
+`.gitkeep` until it holds a file). `repro/` itself gets no `.gitkeep`: its top allows only the entries
+above, and it already holds the index.
+
+A loose note belongs in the folder of the study it is about, or in the paper's `research/` when it is
+research or a decision rather than the record of a run.
+
+**The date in a study's name** is the day the study began: `ablation-2026-10-12`. A month is
+accepted too, `human-labels-2026-10`: a study that ran over weeks (labelling, reading a corpus) has a
+month as its honest date, and both forms sort by time. The date must be a real one — no month 13, no
+30 February. The slug is lowercase letters and digits, words joined by single hyphens.
+
+Never reported: what interpreters, package managers, test runners and the operating system leave in
+the folder they run in — `__pycache__/`, `.pytest_cache/`, `.mypy_cache/`, `.ruff_cache/`,
+`.ipynb_checkpoints/`, `node_modules/`, `.venv/`, `.DS_Store`, `Thumbs.db`.
+
+## Why
+
+`repro/` is where the evidence for every number lives, and it fills up like a desk. One real paper
+had 120 entries at its top: about 70 study folders, some with no date, and about 50 loose scripts,
+data files and notes. Nobody could say which script produces which number, which study is current,
+or where a new run goes. Each kind of material now has one place, and each study says, in its
+`README.md`, what it is.
+
+## Examples
+
+Failing: a script loose at the top.
+
+```text
+papers/agent-rule-drift/PIPELINE-STATUS.md
+  1:1  error  `repro/paper_numbers.py` is loose at the top of the paper's repro/ folder, which holds
+              only an index, the shared tools and data, and one dated folder per study. Where it
+              goes: repro/tools/ — the scripts used across the paper (numbers, figures, the anonymity
+              check, harnesses); a script only one study runs goes in that study's folder instead.
+What repro/ holds (what interpreters and package managers leave there, like __pycache__/ and node_modules/, is never reported):
+repro/
+├── README.md           ← the index: one line per study
+…
+Rule repro/allowed-files-only: https://github.com/zernie/paperlint/blob/main/docs/rules/repro/allowed-files-only.md  repro/allowed-files-only
+```
+
+Each message names the entry and where it goes, and draws the layout above, so it reads on its own. Where
+an entry goes depends on what it is:
+
+| entry                                                                                                                          | where it goes                                                                                         |
+| ------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------- |
+| a script (`.py`, `.ipynb`, `.sh`, `.js`, `.mjs`, `.ts`, `.r`, `.jl`, `.sql` …), `Makefile`, `requirements.txt`, `package.json` | `repro/tools/`, or the folder of the one study that runs it                                           |
+| data (`.tsv`, `.csv`, `.json`, `.jsonl`, `.yaml`, `.txt`, `.log`, `.parquet`, `.zip` …)                                        | `repro/data/`, or the folder of the one study that produced it                                        |
+| a note (`.md`)                                                                                                                 | the dated folder of the study it is about, or the paper's `research/`                                 |
+| a folder whose name is not `<slug>-YYYY-MM-DD`                                                                                 | rename it to `<slug>-YYYY-MM-DD` and give it a `README.md`; its first commit's date is a fine default |
+| a study folder without `README.md`                                                                                             | add one: what the study asks, how to run it, what it found; and a line in `repro/README.md`           |
+| anything else                                                                                                                  | by what it is, as above                                                                               |
+
+Three files paperlint itself once kept at the top of `repro/` are named with their new place and the
+command that moves them: `references-cache.json` → `repro/data/` (read by `paperlint build`),
+`refs-cache.json` → `repro/data/`, `generated-code-grandfathered.txt` → `repro/tools/`.
+
+To date a folder by its first commit, run in the paper folder:
+
+```sh
+git log --reverse --format=%as -- repro/old-baseline | head -1
+```
+
+Passing: a paper with no `repro/`, and a `repro/` holding only the entries above.
+
+## Options / preset fields
+
+No rule options.
+
+## What it does not check
+
+- What is inside `tools/`, `data/` and the study folders.
+- Whether `repro/README.md` exists, or has a line for every study.
+- What a study's `README.md` says.
+- `repro/` itself: whether the paper has one is `paper/allowed-files-only`'s concern, and that rule never
+  looks inside it. Each entry is judged by exactly one of the two rules.
+
+## The hook
+
+The hook `paper-folder-layout` refuses, before it is written, a new file that would add an entry
+this rule reports — a loose file at the top of `repro/`, an undated folder, or a study folder whose
+first file is not its `README.md` — with this rule's message as the reason. It never refuses a file
+that already exists, and it cannot see a shell `mv` or `cp`: the lint is the guarantee. What it does
+and does not do is on [`paper/allowed-files-only`'s page](../paper/allowed-files-only.md#the-hook-a-new-stray-entry-is-refused-before-it-is-written).
+
+## How to fix
+
+Move or rename the entry where its message says, and update whatever names its path:
+
+```sh
+git mv papers/agent-rule-drift/repro/paper_numbers.py papers/agent-rule-drift/repro/tools/
+git mv papers/agent-rule-drift/repro/baseline papers/agent-rule-drift/repro/baseline-2026-08-05
+```
+
+To switch the rule off for one paper — say, one whose `repro/` predates the layout — set it in that
+paper's `paperlint.json`; `paper/allowed-files-only` still judges the paper's root:
+
+```json
+{ "rules": { "repro/allowed-files-only": "off" } }
+```

package/docs/rules/study/declare-sample.md

@@ -0,0 +1,146 @@
+# study/declare-sample
+
+> Experimental, off by default. Whether this belongs in a lint rule or in the study skills is open:
+> see [#214](https://github.com/zernie/paperlint/issues/214).
+
+**Level:** off unless turned on; a paper turns it on with `"rules": { "study/declare-sample": "error" }`
+in its `paperlint.json` · **Reads:** `repro/<study>/prereg.json`, for every study folder at the top of the
+paper's `repro/` that holds one (every folder there but the shared `tools/` and `data/`, whatever
+its name) · **Reported on:** the first line of the paper's
+`PIPELINE-STATUS.md`, once per problem
+
+## What it catches
+
+A study's pre-registration that does not say how its sample relates to the population the paper
+talks about. Every `prereg.json` in a study folder (`repro/<slug>-YYYY-MM-DD/`) must carry five
+fields; every other key in the file is the author's and is not read.
+
+| field          | holds                                                                                                                                                                                                                                                                             |
+| -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `population`   | `about`: what the paper's claim is about, in its own words · `source`: where the units come from (census, crawl, registry, with its date) · `size`: how many units, a whole number above 0 (an estimate is fine; say how in `source`)                                             |
+| `strata`       | `by`: the property the screens are counted by (rule type, language, …) · `values`: its values, at least one, each once                                                                                                                                                            |
+| `screens`      | one entry per screen applied between the population and the sample: `name` (what it keeps, as applied) and `removed`, an object with a count for **every** declared stratum value (0 where it removed none) and no other key. `[]` when no screen was applied                     |
+| `coverage`     | `share`: the share of the population the sample can represent, 0 to 1, or `null` with a `reason` · `unreachable`: the strata or kinds of units the sample cannot reach (`[]` only when it reaches them all; a `share` of 1 with a non-empty list is refused)                      |
+| `author_check` | `who` looked at the drawn units before the run, `when` (YYYY-MM-DD), `units_seen` of `units_drawn` (the units drawn — rules, cases — not the items made from them), and the `verdict` to "is this what you meet in practice?": `representative`, `partly` or `not-representative` |
+
+A verdict other than `representative` needs `author_check.decision`: `proceed` (true or false), `by`
+whom, and `why`. A doubtful verdict with no recorded decision is an error; with one, either way, it
+passes: the rule asks that the decision be made and written down, not which way it goes.
+
+A study folder without a `prereg.json` owes nothing here.
+
+**When it acts.** Inside stage 3, the study: `build-benchmark` writes the `prereg.json` before the
+sample is drawn, the author checks the drawn units, and only then the run and any labelling
+(`build-label-page`) follow. Once a paper turns the rule on, it runs on every `paperlint lint` and in CI, so a study whose
+pre-registration lacks a field fails from the moment the file exists. The flow and the map:
+[`layout.md`](../../layout.md).
+
+## Why
+
+A measurement study of how language models read coding rules drew its rules from three pools, kept
+only the rules judgeable from one code excerpt of at most 40 lines, restricted one pool to a
+classifier's "enforceable" lane, and let a model pick short excerpts. Each screen was reasonable
+alone; together they left a sample of crisp rules. The labeller found 93 % of the items designed as
+borderline clear-cut, and the rules looked nothing like the ones met in practice. A spot-check of
+ten items flagged it (seven of ten clear-cut), and the run went ahead.
+
+Nothing in that design forced anyone to state what share of the real population the sample covered,
+or which screens removed which kinds of rules. Those are the statements this rule requires, before
+the sample is frozen, in the file that freezes it. The counts per stratum are what make the drift
+visible: a screen that removes 120 crisp rules and 1,630 vague ones is a screen on the construct.
+The author's check is on the drawn **units**, because ten items made from crisp rules look fine one
+by one.
+
+## Examples
+
+Failing, with the rule turned on: a pre-registration with hypotheses and arms, and none of the five fields.
+
+```text
+papers/rule-reading/PIPELINE-STATUS.md
+  1:1  error  `repro/draw-2026-10-12/prereg.json`: `population` is missing — add `population`: what
+              the paper's claim is about (`about`), where its units come from (`source`) and how many
+              there are (`size`). Why: a study once screened its sample down to rules that are easy
+              to judge — its labeller found 93 % of the items designed as borderline clear-cut — and
+              nothing in its design made anyone state what share of the real population the sample
+              covered or which screens removed which kinds of units. Rule study/declare-sample: …
+              study/declare-sample
+  1:1  error  … `strata` is missing …
+  1:1  error  … `screens` is missing …
+  1:1  error  … `coverage` is missing …
+  1:1  error  … `author_check` is missing …
+```
+
+Failing: a screen counted under a value `strata` does not declare, and a doubtful check with no
+decision.
+
+```text
+  1:1  error  `repro/draw-2026-10-12/prereg.json`: `screens[0].removed.procedural` is not a declared
+              stratum value — `strata.values` declares crisp, parameterised, vague; add it there or
+              count it under one of them. …
+  1:1  error  `repro/draw-2026-10-12/prereg.json`: `author_check.decision` is missing — the verdict
+              is «partly», and a doubtful verdict with no recorded decision is how a sample the author
+              doubted gets run anyway: add `proceed` (true or false), `by` whom and `why`. …
+```
+
+Passing:
+
+```json
+{
+  "hypotheses": ["…the author's own keys, not read…"],
+  "population": {
+    "about": "rules written in agent instruction files of public repositories",
+    "source": "a census of instruction files, crawled 2026-07-28",
+    "size": 4210
+  },
+  "strata": {
+    "by": "rule type",
+    "values": ["crisp", "parameterised", "vague"]
+  },
+  "screens": [
+    {
+      "name": "judgeable from one code excerpt of at most 40 lines",
+      "removed": { "crisp": 120, "parameterised": 410, "vague": 1630 }
+    }
+  ],
+  "coverage": {
+    "share": 0.31,
+    "unreachable": ["vague", "rules about process rather than code"]
+  },
+  "author_check": {
+    "who": "first author",
+    "when": "2026-10-12",
+    "units_seen": 24,
+    "units_drawn": 24,
+    "verdict": "partly",
+    "decision": {
+      "proceed": true,
+      "by": "first author",
+      "why": "the claim is narrowed to crisp and parameterised rules; vague rules are named as out of reach"
+    }
+  }
+}
+```
+
+## Options / preset fields
+
+No rule options.
+
+## What it does not check
+
+- Whether the numbers are true: that `removed` adds up to what the pools held, that `share` follows
+  from them, or that the author really looked. It checks that each was stated, in a shape a reader
+  and a script can use.
+- That the paper's text matches `population.about` or names what `coverage.unreachable` lists. That
+  is reading, and the paper skills do it (`build-benchmark`, `draft-paper`'s threats section).
+- A `prereg.json` deeper than a study folder's top (`repro/<study>/sub/prereg.json`), at the top of
+  `repro/` itself, or under any other name. The study's folder and its name are `repro/allowed-files-only`'s.
+- A study without a `prereg.json`.
+
+## How to fix
+
+Add the five fields to the study's `prereg.json` before the sample is frozen: count what each screen
+removed per stratum value from the screening script's own output, and show the author the drawn
+units with the question "is this what you meet in practice?". A pre-registration already frozen and
+run gets the fields as a dated addendum, with the values measured now; a paper that cannot give them
+leaves the rule off, which is the default; one that turned it on and cannot give them sets it back
+to `"off"` in its `paperlint.json`, which says so in the record.