paperlint 10.3.0 → 10.4.1

package/src/domain/study-registry.ts

@@ -10,12 +10,22 @@
  * ── JSON, NEVER MARKDOWN ─────────────────────────────────────────────────────────
  * The registry is data: its text is parsed once, where it enters, against the schema in
  * `src/adapters/study-registry/` (`StudyRegistryCodec`). The index in `repro/README.md` is OUTPUT: it is
- * generated from the registry and compared as a string, between two fixed markers. Nothing parses it.
+ * generated from the registry, the plans' modes and git's history (src/domain/index-columns.ts), and
+ * compared cell by cell between two fixed markers, the two columns read from git left out. Nothing
+ * else parses it.
  *
  * Pure: the caller lists `repro/`, reads the registry and the README, and says which result files exist.
  */
 import { isAbsolute, posix, win32 } from "node:path";
 import { STUDIES_FILE, STUDY_SLUG } from "./repro-layout.ts";
+import { needsMode, type StudyMode } from "./study-mode.ts";
+import {
+  decisionCell,
+  firstOutputCell,
+  modeCell,
+  type IndexFacts,
+  type IndexHistory,
+} from "./index-columns.ts";
 
 /** The registry, at the top of the paper's `repro/`; the layout allows it there. */
 export { STUDIES_FILE };
@@ -172,6 +182,11 @@ export interface StudyPlan {
   readonly author_check: AuthorCheck | null;
   /** The paper's own keys: hypotheses, models, budget … Kept, never read; none is a plan field. */
   readonly extra?: Readonly<Record<string, unknown>> | undefined;
+  /**
+   * How the outcomes are kept from the decisions on the inputs: decided before the run, or
+   * exploratory (src/domain/study-mode.ts). A measurement study's plan is not ready without it.
+   */
+  readonly mode?: StudyMode | undefined;
 }
 
 /**
@@ -200,6 +215,7 @@ export const PLAN_FIELDS = [
   "primary_outcome",
   "author_check",
   "extra",
+  "mode",
 ] as const;
 
 /** A plan with empty required texts: the author has not approved it. */
@@ -211,6 +227,11 @@ export const PLAN_TEXT_FIELDS = [
   "population.source",
   "population.draw.method",
   "primary_outcome",
+  "mode",
+  "mode.outputs",
+  "mode.decision.file",
+  "mode.decision.note",
+  "mode.reason",
 ] as const;
 export type PlanTextField = (typeof PLAN_TEXT_FIELDS)[number];
 
@@ -227,19 +248,51 @@ export type ParsedPlan =
     }
   | { readonly kind: "unreadable"; readonly why: string };
 
+/**
+ * What a path inside a study's folder is, found without reading it or following a link: a regular
+ * file, nothing, or a path that passes through a symbolic link (`link`: the first one, relative to
+ * the folder).
+ */
+export type Located =
+  | { readonly kind: "file" }
+  | { readonly kind: "absent" }
+  | { readonly kind: "linked"; readonly link: string };
+
 /** What a study's folder holds of the plan its row names: absent, or what its text parsed to. */
-export type PlanState = { readonly kind: "absent" } | ParsedPlan;
+export type PlanState =
+  | { readonly kind: "absent" }
+  /** The plan's path passes through a symbolic link, `link` (relative to the folder); never read. */
+  | { readonly kind: "linked"; readonly link: string }
+  | ParsedPlan;
+
+/** The decision file `paperlint studies new` names for a study in `folder`, relative to the paper. */
+export const decisionPath = (folder: string): string =>
+  `repro/${folder}/${DECISION_FILE}`;
+
+/** The decision file's name, beside the plan. */
+export const DECISION_FILE = "decision.md";
 
 /**
- * The plan `paperlint studies new` writes: every field present, its value to fill. Its draw is of
- * all the population (a census); a sampled study changes it to `{ "kind": "seeded", "method", "seed" }`.
+ * The plan `paperlint studies new` writes for a study of `kind` in `folder`: every field present, its
+ * value to fill. Its draw is of all the population (a census); a sampled study changes it to
+ * `{ "kind": "seeded", "method", "seed" }`. A study that must declare its mode gets the default one,
+ * decided before the run, its decision file named and its outputs and note to fill.
  */
-export const planTemplate = (): DraftPlan => ({
+export const planTemplate = (kind: StudyKind, folder: string): DraftPlan => ({
   question: "",
   population: { source: "", draw: { kind: "all", method: "" } },
   arms: [],
   primary_outcome: "",
   author_check: null,
+  ...(needsMode(kind)
+    ? {
+        mode: {
+          kind: "decide_before_run",
+          outputs: [],
+          decision: { file: decisionPath(folder), note: "" },
+        },
+      }
+    : {}),
 });
 
 /** A plan's text as `paperlint studies new` writes it: JSON, two-space indented, a final newline. */
@@ -264,8 +317,8 @@ export interface StudyInput {
   readonly registry: RegistryState;
   /** `repro/README.md`'s text; null when there is none. */
   readonly readme: string | null;
-  /** Each `<folder>/<result_file>` of the registry that is a file. */
-  readonly existingResults: ReadonlySet<string>;
+  /** What each `<folder>/<result_file>` of the registry is, as `locate` found it; one not listed is absent. */
+  readonly results: ReadonlyMap<string, Located>;
   /** The plan each row names, by `<folder>/<plan>`; one not listed is absent. */
   readonly plans: ReadonlyMap<string, PlanState>;
 }
@@ -312,6 +365,13 @@ export type StudyFinding =
       readonly path: string;
       readonly why: "missing" | "outside";
     }
+  | {
+      readonly problem: "result-file";
+      readonly id: string;
+      readonly path: string;
+      readonly why: "linked";
+      readonly link: string;
+    }
   | {
       readonly problem: "no-successor";
       readonly id: string;
@@ -351,6 +411,13 @@ export type StudyFinding =
       readonly path: string;
       readonly why: "missing" | "outside";
     }
+  | {
+      readonly problem: "bad-plan";
+      readonly id: string;
+      readonly path: string;
+      readonly why: "linked";
+      readonly link: string;
+    }
   | {
       readonly problem: "bad-plan";
       readonly id: string;
@@ -425,20 +492,82 @@ export const titleWords = (title: string): number =>
  * Whether `path` stays inside the folder it is relative to. A backslash or a Windows absolute path
  * is refused outright: `posix.normalize` does not resolve `..\\`, while the host's `join` may.
  */
-const isInside = (path: string): boolean => {
+export const isInside = (path: string): boolean => {
   if (path.includes("\\") || isAbsolute(path) || win32.isAbsolute(path))
     return false;
   const n = posix.normalize(path);
   return n !== ".." && !n.startsWith("../");
 };
 
+/**
+ * Whether `folder` names one folder directly inside `repro/`: not empty, not `.` or `..`, and no
+ * separator or NUL. Every command and rule that reads a study's folder reads only such a one: a row
+ * naming `../x` would have them read and write outside the paper.
+ */
+export const isFolderName = (folder: string): boolean =>
+  folder !== "." && folder !== ".." && /^[^/\\\0]+$/u.test(folder);
+
+/**
+ * The rows of a registry that carry an id: exactly one, none, or several. The one way to address a
+ * study by its id — a caller that wants "the study P1-S01" gets a row only when there is exactly one,
+ * so no command can act on the first of two rows by accident. A registry may still hold two rows of
+ * one id (`repro/study-registered` reports it); this says so instead of choosing.
+ */
+export type StudyLookup =
+  | { readonly kind: "one"; readonly row: Study }
+  | { readonly kind: "none" }
+  | { readonly kind: "ambiguous"; readonly rows: readonly Study[] };
+
+/** The rows of a registry that was read; none when there is no registry, or it does not parse. */
+export const studiesOf = (state: RegistryState): readonly Study[] =>
+  state.kind === "read" ? state.registry.studies : [];
+
+/** The rows of `studies` whose id is `id`, as a `StudyLookup`. */
+export const studyById = (
+  studies: readonly Study[],
+  id: string,
+): StudyLookup => {
+  const [first, ...rest] = studies.filter((s) => s.id === id);
+  if (first === undefined) return { kind: "none" };
+  return rest.length === 0
+    ? { kind: "one", row: first }
+    : { kind: "ambiguous", rows: [first, ...rest] };
+};
+
+/**
+ * The key a path inside a study's folder is held under: `<folder>/<path>`. A plan (`StudyInput.plans`,
+ * `IndexInput.plans`), the history of its study (`IndexInput.history`) and a result file
+ * (`StudyInput.results`) are all found by it.
+ */
+export const folderKey = (folder: string, path: string): string =>
+  `${folder}/${path}`;
+
 /**
  * The `<folder>/<plan>` of each row whose plan lies inside its folder: the files the judge needs read
  * (`StudyInput.plans`). A plan outside its folder is reported without being read.
  */
 export const planKeys = (r: StudyRegistry): readonly string[] =>
+  planRefs(r).map((p) => folderKey(p.folder, p.plan));
+
+/** A plan a row names: where it is read from, and the kind of the study — what its parser needs. */
+export interface PlanRef {
+  readonly folder: string;
+  readonly plan: string;
+  readonly kind: StudyKind;
+}
+
+/** Each plan `planKeys` names. */
+export const planRefs = (r: StudyRegistry): readonly PlanRef[] =>
   r.studies.flatMap((s) =>
-    s.plan !== undefined && isInside(s.plan) ? [`${s.folder}/${s.plan}`] : [],
+    s.plan !== undefined && isInside(s.plan) && isFolderName(s.folder)
+      ? [
+          {
+            folder: s.folder,
+            plan: s.plan,
+            kind: s.kind,
+          },
+        ]
+      : [],
   );
 
 /** One row of a registry, with what the judge read beside it. */
@@ -463,7 +592,7 @@ const badId: RowCheck = ({ r, s }) =>
 
 /** Reported once, on the first row that holds the id. */
 const duplicateId: RowCheck = (row) =>
-  row.r.studies.filter((o) => o.id === row.s.id).length > 1 &&
+  studyById(row.r.studies, row.s.id).kind === "ambiguous" &&
   isFirst(row, (o) => o.id)
     ? { problem: "duplicate-id", id: row.s.id }
     : null;
@@ -513,9 +642,23 @@ const resultFile: RowCheck = ({ s, input }) => {
   if (path === undefined) return null;
   if (!isInside(path))
     return { problem: "result-file", id: s.id, path, why: "outside" };
-  return input.existingResults.has(`${s.folder}/${path}`)
-    ? null
-    : { problem: "result-file", id: s.id, path, why: "missing" };
+  const found = input.results.get(folderKey(s.folder, path)) ?? {
+    kind: "absent",
+  };
+  switch (found.kind) {
+    case "file":
+      return null;
+    case "linked":
+      return {
+        problem: "result-file",
+        id: s.id,
+        path,
+        why: "linked",
+        link: found.link,
+      };
+    case "absent":
+      return { problem: "result-file", id: s.id, path, why: "missing" };
+  }
 };
 
 const noSuccessor: RowCheck = ({ r, s }) => {
@@ -534,13 +677,15 @@ const unknownMeasurement: RowCheck = ({ r, s }) =>
     ? null
     : { problem: "unknown-measurement", id: s.id, measurement: s.measurement };
 
-/** The state of the plan the row names (absent when outside its folder); null when it names none. */
-const planOf = ({ s, input }: Row): PlanState | null => {
-  if (s.plan === undefined) return null;
-  return isInside(s.plan)
-    ? (input.plans.get(`${s.folder}/${s.plan}`) ?? { kind: "absent" })
+/** The state of the plan `plan` of the row `s` (absent when outside its folder): the one place a plan is looked up. */
+const planStateOf = (input: StudyInput, s: Study, plan: string): PlanState =>
+  isInside(plan)
+    ? (input.plans.get(folderKey(s.folder, plan)) ?? { kind: "absent" })
     : { kind: "absent" };
-};
+
+/** The state of the plan the row names; null when it names none. */
+const planOf = ({ s, input }: Row): PlanState | null =>
+  s.plan === undefined ? null : planStateOf(input, s, s.plan);
 
 const hasRun = (s: Study): boolean => RAN_STATUSES.includes(s.status);
 
@@ -554,6 +699,8 @@ const planFinding = (
   switch (state.kind) {
     case "absent":
       return { ...at, why: "missing" };
+    case "linked":
+      return { ...at, why: "linked", link: state.link };
     case "unreadable":
       return { ...at, why: "unreadable", reasons: state.why };
     case "draft":
@@ -571,11 +718,7 @@ const badPlan: RowCheck = ({ s, input }) => {
   if (path === undefined) return null;
   if (!isInside(path))
     return { problem: "bad-plan", id: s.id, path, why: "outside" };
-  return planFinding(
-    s,
-    path,
-    input.plans.get(`${s.folder}/${path}`) ?? { kind: "absent" },
-  );
+  return planFinding(s, path, planStateOf(input, s, path));
 };
 
 /** A plan under its old name: read, and named for renaming. */
@@ -695,11 +838,12 @@ const judgeRow = (row: Row): readonly StudyFinding[] =>
 function judgeIndex(
   r: StudyRegistry,
   readme: string | null,
+  plans: ReadonlyMap<string, PlanState>,
 ): StudyFinding | null {
   if (readme === null) return { problem: "stale-index", why: "no-readme" };
   const block = embeddedIndex(readme);
   if (block === null) return { problem: "stale-index", why: "no-markers" };
-  return indexInSync(readme, r)
+  return indexInSync(readme, r, { plans, history: new Map() })
     ? null
     : { problem: "stale-index", why: "differs" };
 }
@@ -718,7 +862,7 @@ export function judgeStudies(input: StudyInput): readonly StudyFinding[] {
     return [{ problem: "unreadable", why: state.why }];
   const r = state.registry;
   const next = nextStudyId(r);
-  const index = judgeIndex(r, input.readme);
+  const index = judgeIndex(r, input.readme, input.plans);
   return [
     ...input.folders
       .filter((f) => !r.studies.some((s) => s.folder === f))
@@ -739,19 +883,69 @@ export function judgeStudies(input: StudyInput): readonly StudyFinding[] {
 const cell = (s: string): string =>
   s.replace(/\r?\n/gu, " ").replace(/\\/gu, "\\\\").replace(/\|/gu, "\\|");
 
-/** The columns of the index: each one's header, and its cell for a study. */
+/**
+ * What the index is generated from beyond the registry: the plans by `<folder>/<plan>` (as
+ * `StudyInput.plans`), and the history of each decide-first study by the same key. A study with no
+ * history listed shows `not read` — the lint, which never compares those columns, asks none.
+ */
+export interface IndexInput {
+  readonly plans: ReadonlyMap<string, PlanState>;
+  readonly history: ReadonlyMap<string, IndexHistory>;
+}
+
+/** The mode the plan of `s` declares; null when it names none, or the plan is absent or unreadable. */
+const declaredMode = (
+  s: Study,
+  plans: ReadonlyMap<string, PlanState>,
+): StudyMode | null => {
+  const state =
+    s.plan !== undefined && isInside(s.plan)
+      ? plans.get(folderKey(s.folder, s.plan))
+      : undefined;
+  return state === undefined ||
+    state.kind === "absent" ||
+    state.kind === "linked" ||
+    state.kind === "unreadable"
+    ? null
+    : (state.plan.mode ?? null);
+};
+
+/** What the index shows of `s` beyond its row. */
+const factsOf = (s: Study, at: IndexInput): IndexFacts => ({
+  mode: declaredMode(s, at.plans),
+  history:
+    (s.plan === undefined
+      ? undefined
+      : at.history.get(folderKey(s.folder, s.plan))) ?? null,
+});
+
+/**
+ * The columns of the index: each one's header, its cell for a study, and whether git's history is
+ * where the cell comes from — those two are never compared (src/domain/index-columns.ts).
+ */
 const COLUMNS: readonly {
   readonly head: string;
-  readonly of: (s: Study) => string;
+  readonly of: (s: Study, f: IndexFacts) => string;
+  readonly fromGit: boolean;
 }[] = [
-  { head: "id", of: (s) => s.id },
-  { head: "title", of: (s) => cell(s.title) },
-  { head: "status", of: (s) => s.status },
-  { head: "result", of: (s) => cell(s.result ?? "—") },
-  { head: "in paper", of: (s) => s.in_paper },
-  { head: "folder", of: (s) => `[${s.folder}/](${s.folder}/)` },
+  { head: "id", of: (s) => s.id, fromGit: false },
+  { head: "title", of: (s) => cell(s.title), fromGit: false },
+  { head: "status", of: (s) => s.status, fromGit: false },
+  { head: "result", of: (s) => cell(s.result ?? "—"), fromGit: false },
+  { head: "in paper", of: (s) => s.in_paper, fromGit: false },
+  { head: "mode", of: (_, f) => cell(modeCell(f)), fromGit: false },
+  { head: "decision", of: (_, f) => decisionCell(f), fromGit: true },
+  { head: "first output", of: (_, f) => firstOutputCell(f), fromGit: true },
+  {
+    head: "folder",
+    of: (s) => `[${s.folder}/](${s.folder}/)`,
+    fromGit: false,
+  },
 ];
 
+/** The positions of the columns read from git: left out when an index is compared. */
+const FROM_GIT = COLUMNS.flatMap((c, i) => (c.fromGit ? [i] : []));
+
 /** The width a cell takes: its code points. */
 const widthOf = (s: string): number => Array.from(s).length;
 
@@ -764,20 +958,23 @@ const padded = (t: string, width: number): string =>
  * widest cell (at least 3), the way prettier writes a table — so formatting the README leaves it as
  * it is.
  */
-export function studyIndex(r: StudyRegistry): string {
+export function studyIndex(r: StudyRegistry, at: IndexInput): string {
+  const studies = r.studies.map((s) => ({ s, f: factsOf(s, at) }));
   const sized = COLUMNS.map((c) => ({
     ...c,
     width: Math.max(
       3,
       widthOf(c.head),
-      ...r.studies.map((s) => widthOf(c.of(s))),
+      ...studies.map(({ s, f }) => widthOf(c.of(s, f))),
     ),
   }));
   const line = (cells: readonly string[]): string => `| ${cells.join(" | ")} |`;
   return [
     line(sized.map((c) => padded(c.head, c.width))),
     line(sized.map((c) => "-".repeat(c.width))),
-    ...r.studies.map((s) => line(sized.map((c) => padded(c.of(s), c.width)))),
+    ...studies.map(({ s, f }) =>
+      line(sized.map((c) => padded(c.of(s, f), c.width))),
+    ),
   ].join("\n");
 }
 
@@ -786,7 +983,7 @@ export function studyIndex(r: StudyRegistry): string {
  * `---`. The index is judged on this, because the padding belongs to the formatter: prettier sizes a
  * column by display width, so a wide character pads differently from a code-point count.
  */
-const cellsOf = (table: string): string =>
+const cellsOf = (table: string, skip: readonly number[]): string =>
   table
     .trim()
     .split("\n")
@@ -796,19 +993,44 @@ const cellsOf = (table: string): string =>
         .replace(/^\||\|$/gu, "")
         .split(/(?<!\\)\|/u)
         .map((c) => c.trim().replace(/^:?-{3,}:?$/u, "---"))
+        .filter((_, i) => !skip.includes(i))
         .join("|"),
     )
     .join("\n");
 
-/** Whether `readme` holds the index of `r`, whatever padding a formatter gave its table. */
-export function indexInSync(readme: string | null, r: StudyRegistry): boolean {
+/** Whether `readme` holds the index of `r` in every column but those at `skip`, whatever its padding. */
+const sameCells = (
+  readme: string | null,
+  index: string,
+  skip: readonly number[],
+): boolean => {
   const block = readme === null ? null : embeddedIndex(readme);
-  return block !== null && cellsOf(block) === cellsOf(studyIndex(r));
-}
+  return block !== null && cellsOf(block, skip) === cellsOf(index, skip);
+};
+
+/**
+ * Whether `readme` holds the index of `r`, whatever padding a formatter gave its table and whatever
+ * its two columns read from git say: what `repro/study-registered` checks.
+ */
+export const indexInSync = (
+  readme: string | null,
+  r: StudyRegistry,
+  at: IndexInput,
+): boolean => sameCells(readme, studyIndex(r, at), FROM_GIT);
+
+/**
+ * Whether `readme` holds the index of `r` in every column, whatever its padding: when it does,
+ * `studies index` leaves the README as it is, so the padding a formatter gave the table stays.
+ */
+export const indexCurrent = (
+  readme: string | null,
+  r: StudyRegistry,
+  at: IndexInput,
+): boolean => sameCells(readme, studyIndex(r, at), []);
 
 /** The index between its markers, a blank line on each side. */
-export const indexBlock = (r: StudyRegistry): string =>
-  `${INDEX_BEGIN}\n\n${studyIndex(r)}\n\n${INDEX_END}`;
+export const indexBlock = (r: StudyRegistry, at: IndexInput): string =>
+  `${INDEX_BEGIN}\n\n${studyIndex(r, at)}\n\n${INDEX_END}`;
 
 /**
  * Where `marker` stands alone on a line of `text`, at or after `from`; -1 when it does not. A marker
@@ -832,13 +1054,18 @@ export function embeddedIndex(readme: string): string | null {
  * `readme` with its index regenerated from `r`: the block replaced in place, appended when the README
  * has none, a README of its own when there is none.
  */
-export function withIndex(readme: string | null, r: StudyRegistry): string {
-  if (readme === null) return `${INDEX_HEADING}\n\n${indexBlock(r)}\n`;
+export function withIndex(
+  readme: string | null,
+  r: StudyRegistry,
+  at: IndexInput,
+): string {
+  const fresh = indexBlock(r, at);
+  if (readme === null) return `${INDEX_HEADING}\n\n${fresh}\n`;
   const block = embeddedIndex(readme);
-  if (block === null) return `${readme.trimEnd()}\n\n${indexBlock(r)}\n`;
+  if (block === null) return `${readme.trimEnd()}\n\n${fresh}\n`;
   const begin = markerAt(readme, INDEX_BEGIN);
   const after = begin + INDEX_BEGIN.length + block.length + INDEX_END.length;
-  return `${readme.slice(0, begin)}${indexBlock(r)}${readme.slice(after)}`;
+  return `${readme.slice(0, begin)}${fresh}${readme.slice(after)}`;
 }
 
 /** The registry's text as `paperlint studies new` writes it: JSON, two-space indented, a final newline. */
@@ -900,7 +1127,9 @@ const HEADS: { readonly [P in Problem]: (f: FindingOf[P]) => string } = {
   "no-result": (f) =>
     `${REGISTRY}: ${tick(f.id)} is \`done\` without ${f.missing.map(tick).join(" and ")}. What to do: write the one-line result and the file it is read from (\`result\`, \`result_file\`), or set the status it really has.`,
   "result-file": (f) =>
-    `${REGISTRY}: the \`result_file\` of ${tick(f.id)}, ${tick(f.path)}, ${f.why === "missing" ? "is not a file in its folder" : "is outside its folder"}. What to do: name a file that exists, relative to the study's folder.`,
+    f.why === "linked"
+      ? `${REGISTRY}: the \`result_file\` of ${tick(f.id)}, ${tick(f.path)}, passes through the symbolic link ${tick(f.link)} in its folder; nothing is read through a link. What to do: name a regular file inside the study's folder, or replace the link with the file itself.`
+      : `${REGISTRY}: the \`result_file\` of ${tick(f.id)}, ${tick(f.path)}, ${f.why === "missing" ? "is not a file in its folder" : "is outside its folder"}. What to do: name a file that exists, relative to the study's folder.`,
   "no-successor": (f) =>
     `${REGISTRY}: ${tick(f.id)} is \`superseded\` ${f.superseded_by === null ? "without `superseded_by`" : `by ${tick(f.superseded_by)}, which is no study in the registry`}. What to do: name the id of the study that replaced it.`,
   "stale-index": (f) => `${STALE_HEAD[f.why]} ${RUN_INDEX}`,
@@ -920,10 +1149,12 @@ const HEADS: { readonly [P in Problem]: (f: FindingOf[P]) => string } = {
     switch (f.why) {
       case "missing":
         return `${REGISTRY}: ${of} is not a file in its folder. What to do: write the plan there (its fields are on the rule's page), or correct the row's \`plan\`.`;
+      case "linked":
+        return `${REGISTRY}: ${of} passes through the symbolic link ${tick(f.link)} in its folder; nothing is read through a link. What to do: replace the link with the plan file itself.`;
       case "outside":
         return `${REGISTRY}: ${of} is outside its folder. What to do: keep the plan in the study's folder, as \`${PLAN_FILE}\`, and name it relative to the folder.`;
       case "unreadable":
-        return `${plan} is not a study plan: ${f.reasons}. What to do: give it the fields on the rule's page — \`question\`, \`population\`, \`arms\`, \`primary_outcome\`.`;
+        return `${plan} is not a study plan: ${f.reasons}. What to do: give it the fields on the rule's page — \`question\`, \`population\`, \`arms\`, \`primary_outcome\`, and for a measurement its \`mode\`.`;
       case "unfilled":
         return `${plan} leaves ${listed(f.fields)} empty, and the study is ${tick(f.status)}: a plan is written before the runs. What to do: fill them in, or set the study back to \`designing\`.`;
     }

package/src/new-paper.test.ts

@@ -42,9 +42,13 @@ import {
   registryText,
   withIndex,
   type StudyRegistry,
+  type IndexInput,
 } from "./domain/study-registry.ts";
 import { statSync } from "node:fs";
 
+/** No plan and no history: the index with every mode column `—`. */
+const NO_FACTS: IndexInput = { plans: new Map(), history: new Map() };
+
 const dirs: string[] = [];
 afterEach(() => {
   for (const d of dirs.splice(0)) rmSync(d, { recursive: true, force: true });
@@ -813,7 +817,7 @@ describe("paperlint lint — a scaffolded paper has no layout finding", () => {
       "talk/.gitkeep": "",
       "sections/.gitkeep": "",
       "repro/studies.json": registryText(SOME_STUDY),
-      "repro/README.md": withIndex(REPRO_INDEX_STUB, SOME_STUDY),
+      "repro/README.md": withIndex(REPRO_INDEX_STUB, SOME_STUDY, NO_FACTS),
       "repro/P1-S01-some-study/README.md": "# s\n",
       "repro/P1-S01-some-study/.gitkeep": "",
     });