paperlint 11.1.2 → 12.0.0

package/src/latex-log.harness.ts

@@ -6,7 +6,7 @@
  * marker that TeX broke at column 79.
  */
 import { createChecker } from "../lib/check.ts";
-import type { LogMarker } from "./latex-log.ts";
+import type { FailingWarningId, LogMarker } from "./latex-log.ts";
 
 const {
   unwrapLog,
@@ -16,6 +16,8 @@ const {
   bibtexExcerpt,
   auxBib,
   MAX_PRINT_LINE,
+  FAILING_WARNINGS,
+  failingWarnings,
 } = await import("./latex-log.ts");
 
 const check = createChecker();
@@ -75,16 +77,14 @@ const firstPass = [
 ];
 const m = logMarkers(firstPass);
 check(
-  "every documented marker is recognised",
-  (
-    [
+  "every documented marker is recognised, and the end-of-run summaries are not markers (they fail the build: FAILING_WARNINGS)",
+  JSON.stringify(m) ===
+    JSON.stringify([
       "rerun-requested",
       "labels-changed",
       "rerunfilecheck",
-      "undefined-references",
-      "undefined-citations",
-    ] satisfies LogMarker[]
-  ).every((k) => m.includes(k)),
+    ] satisfies LogMarker[]),
+  m,
 );
 check(
   "a clean log carries no markers",
@@ -93,11 +93,6 @@ check(
     "Output written on paper.pdf (1 page, 1234 bytes).",
   ]).length === 0,
 );
-// Guards: matching the documented summary line rather than the word 'undefined'.
-check(
-  "a single reference warning is not the end-of-run summary",
-  !logMarkers(firstPass.slice(0, 1)).includes("undefined-references"),
-);
 
 // ── error excerpt ───────────────────────────────────────────────────────────────────────
 const undefinedCs = [
@@ -246,6 +241,142 @@ check(
   );
 }
 
+// ── warnings that fail the build ────────────────────────────────────────────────────────
+// Every entry of FAILING_WARNINGS has its two halves here — log lines it must find, and lines it
+// must not — and `satisfies Record<FailingWarningId, …>` makes a table entry without a row here a
+// type error; the first check below makes it a red run as well.
+// The lost-character line is copied from a real TeX Live 2026 run (2026-10-26): `\char"FF` in
+// cmr10 under `\documentclass{article}`, which sets `\tracinglostchars=2`; pdflatex exited 0.
+// The log is read as latin1, so the byte 0xFF is the one character "\xff".
+const LOST = "Missing character: There is no \xff in font cmr10!";
+const FAILING_CASES = {
+  "lost-character": {
+    fires: [
+      LOST,
+      "Missing character: There is no \xe2 in font LinLibertineT-tlf-ot1!",
+    ],
+    quiet: [
+      "Overfull \\hbox (1.2pt too wide) in paragraph at lines 4--5",
+      "LaTeX Font Warning: Font shape `OT1/cmr/bx/sc' undefined",
+      "LaTeX Warning: Label(s) may have changed. Rerun to get cross-references right.",
+      "LaTeX Warning: There were undefined references.",
+      // The words inside an unrelated longer line — an overfull box quoting the text it set.
+      "[]\\OT1/cmr/m/n/10 Missing character: There is no x in font cmr10!",
+    ],
+  },
+  // The three end-of-run summaries, worded as latex.ltx and natbib.sty print them (TeX Live 2026);
+  // LaTeX core has no "undefined citations" summary — an undefined \cite counts as a reference. Guards: matching the
+  // summary, not the word "undefined" — one reference warning per \ref is printed on EVERY pass
+  // before the rerun, and is not the summary.
+  "undefined-references": {
+    fires: ["LaTeX Warning: There were undefined references."],
+    quiet: [
+      "LaTeX Warning: Reference `sec:intro' on page 1 undefined on input line 4.",
+      "Package natbib Warning: There were undefined citations.",
+      "LaTeX Warning: Label(s) may have changed. Rerun to get cross-references right.",
+    ],
+  },
+  "undefined-citations": {
+    fires: ["Package natbib Warning: There were undefined citations."],
+    quiet: [
+      "LaTeX Warning: Citation `knuth84' on page 1 undefined on input line 7.",
+      "Package natbib Warning: Citation `knuth84' on page 1 undefined on input line 7.",
+      "LaTeX Warning: There were undefined references.",
+    ],
+  },
+  "multiply-defined-labels": {
+    fires: ["LaTeX Warning: There were multiply-defined labels."],
+    quiet: [
+      "LaTeX Warning: Label `sec:intro' multiply defined.",
+      "LaTeX Warning: There were undefined references.",
+    ],
+  },
+} satisfies Record<
+  FailingWarningId,
+  { readonly fires: readonly string[]; readonly quiet: readonly string[] }
+>;
+check(
+  "every failing warning in the table has a row of cases, and every row is in the table",
+  JSON.stringify(FAILING_WARNINGS.map((w) => w.id).sort()) ===
+    JSON.stringify(Object.keys(FAILING_CASES).sort()),
+);
+for (const [id, c] of Object.entries(FAILING_CASES)) {
+  for (const line of c.fires)
+    check(
+      `${id}: fires on ${JSON.stringify(line)}`,
+      failingWarnings(["(./paper.aux)", line, ""]).some((h) => h.id === id),
+      () => failingWarnings(["(./paper.aux)", line, ""]),
+    );
+  for (const line of c.quiet)
+    check(
+      `${id}: quiet on ${JSON.stringify(line)}`,
+      !failingWarnings(["(./paper.aux)", line, ""]).some((h) => h.id === id),
+      () => failingWarnings(["(./paper.aux)", line, ""]),
+    );
+}
+check(
+  "a clean log carries no failing warning",
+  failingWarnings([
+    "This is pdfTeX",
+    "Output written on paper.pdf (1 page, 1234 bytes).",
+  ]).length === 0,
+);
+{
+  const log = [
+    LOST,
+    "(./paper.aux)",
+    LOST,
+    "Missing character: There is no \xfe in font cmtt10!",
+    LOST,
+  ];
+  const hits = failingWarnings(log);
+  check(
+    "a lost character quotes each distinct line once, in order, with how many times TeX printed it",
+    JSON.stringify(hits) ===
+      JSON.stringify([
+        {
+          id: "lost-character",
+          reason: FAILING_WARNINGS[0].reason,
+          quotes: [
+            { text: LOST, times: 3 },
+            {
+              text: "Missing character: There is no \xfe in font cmtt10!",
+              times: 1,
+            },
+          ],
+        },
+      ]),
+    hits,
+  );
+}
+{
+  // A long font name pushes the line past column 79: TeX breaks it, and unwrapLog rejoins it.
+  const long =
+    "Missing character: There is no \xff in font LinLibertineT-tlf-ts1-scaled-1000-extended!";
+  const split = [long.slice(0, MAX_PRINT_LINE), long.slice(MAX_PRINT_LINE)];
+  check(
+    "a lost-character line TeX split at column 79 is rejoined and found, quoted whole",
+    split[0]?.length === 79 &&
+      JSON.stringify(
+        failingWarnings(unwrapLog(split.join("\n")))[0]?.quotes,
+      ) === JSON.stringify([{ text: long, times: 1 }]),
+  );
+}
+{
+  // A line of exactly 79 bytes by itself is joined to the next one (unwrapLog's documented false
+  // join): the marker then starts at byte 79 of the joined line, where the physical line began.
+  const before = "x".repeat(MAX_PRINT_LINE);
+  const joined = unwrapLog([before, LOST, ""].join("\n"));
+  check(
+    "a lost-character line glued by a false join to a 79-byte line before it is still found",
+    joined[0] === before + LOST && failingWarnings(joined).length === 1,
+  );
+  check(
+    "the marker words NOT at a physical line start (byte 78) are not read as one",
+    failingWarnings(["y".repeat(MAX_PRINT_LINE - 1) + LOST]).length === 0,
+  );
+}
+
 console.log(
-  `✓ ${String(check.count)} assertions passed — latex-log: markers across the 79-column wrap, both error spellings, aux`,
+  `✓ ${String(check.count)} assertions passed — latex-log: markers across the 79-column wrap, both error spellings, aux, warnings that fail the build`,
 );

package/src/latex-log.ts

@@ -19,25 +19,19 @@
  * must therefore read the log as `latin1`, so one character is one byte and `length` counts what
  * TeX counted.
  */
+import { filter, map, pipe, range, unique } from "remeda";
 
 /** TeX Live's `max_print_line`. A physical log line of exactly this many bytes was broken by TeX. */
 export const MAX_PRINT_LINE = 79;
 
 /**
- * Log lines that ask for another pass, or report on references. Each is a documented message,
- * not a guess about wording:
+ * Log lines that ask for another pass. Each is a documented message, not a guess about wording:
  *   - `rerun-requested`   — any "Rerun to get …" (LaTeX core, natbib, hyperref's outlines, …)
  *   - `labels-changed`    — "LaTeX Warning: Label(s) may have changed."
  *   - `rerunfilecheck`    — "Package rerunfilecheck Warning: File `…' has changed."
- *   - `undefined-references` / `undefined-citations` — the end-of-run summaries. These do NOT
- *     request a rerun by themselves: on a converged document they mean a genuinely undefined key.
+ * The end-of-run summaries about references are not markers: they fail the build (`FAILING_WARNINGS`).
  */
-export type LogMarker =
-  | "rerun-requested"
-  | "labels-changed"
-  | "rerunfilecheck"
-  | "undefined-references"
-  | "undefined-citations";
+export type LogMarker = "rerun-requested" | "labels-changed" | "rerunfilecheck";
 
 /**
  * Rejoin the lines TeX broke at column 79. A line of exactly 79 bytes continues on the next one.
@@ -71,21 +65,116 @@ export function logMarkers(lines: readonly string[]): LogMarker[] {
       found.add("labels-changed");
     if (line.startsWith("Package rerunfilecheck Warning:"))
       found.add("rerunfilecheck");
-    if (line.includes("There were undefined references"))
-      found.add("undefined-references");
-    if (line.includes("There were undefined citations"))
-      found.add("undefined-citations");
   }
   const order: LogMarker[] = [
     "rerun-requested",
     "labels-changed",
     "rerunfilecheck",
-    "undefined-references",
-    "undefined-citations",
   ];
   return order.filter((m) => found.has(m));
 }
 
+/** A log warning that fails the build: what it is called, why it fails, and the lines that carry it. */
+export interface FailingWarning {
+  readonly id: string;
+  /** One line a human reads before the quoted log lines. */
+  readonly reason: string;
+  /** Whether this logical line (after `unwrapLog`) carries it. */
+  readonly matches: (line: string) => boolean;
+}
+
+/**
+ * Does `prefix` start one of the PHYSICAL lines this logical line was joined from? `unwrapLog` joins
+ * only lines of exactly 79 bytes, so every physical line starts at a multiple of 79. That keeps a
+ * marker found after unwrapLog's false join (a 79-byte line by itself, then the marker) and still
+ * ignores the same words in the middle of a line — an overfull box quoting the text it set.
+ */
+const startsPhysicalLine = (line: string, prefix: string): boolean =>
+  range(0, Math.floor(line.length / MAX_PRINT_LINE) + 1).some((k) =>
+    line.startsWith(prefix, k * MAX_PRINT_LINE),
+  );
+
+/**
+ * 🔴 THE WARNINGS THAT FAIL THE BUILD — like an ESLint rule at "error". pdflatex exits 0 on each of
+ * them and writes a PDF that is wrong: a character missing, `??` or `[?]` in the text, a reference
+ * that may point at the wrong place. Only the log of the FINAL pass is judged (`latex-loop.ts`):
+ * before the rerun every reference is undefined by construction.
+ *
+ * WHY THESE FOUR. Each makes the PDF wrong for a reader, and turning all four on was measured on four
+ * real papers (their final logs of 2026-10-26): 0 hits each, so no correct paper turns red. Left out: overfull boxes (cosmetic,
+ * nearly every paper has some, and the pdf/* rules check the margins), font shape substitution
+ * (usually harmless), "Rerun to get" (the loop already reruns). Those never fail a build.
+ *
+ * Adding one is one entry here, plus its row of cases in `latex-log.harness.ts` (the harness does
+ * not type-check without it).
+ *
+ * `lost-character`: TeX prints "Missing character: There is no X in font F!" when
+ * `\tracinglostchars` > 0; LaTeX's format sets it to 2 (TeX Live 2026, `latex.ltx`), and pdflatex
+ * still exits 0. A paper that sets it to 0 silences the line, and this check with it. At 3 or more
+ * TeX makes it an error, and the build fails on the exit code instead.
+ */
+export const FAILING_WARNINGS = [
+  {
+    id: "lost-character",
+    reason:
+      "the font has no glyph for this character, so pdflatex left it out of the PDF",
+    matches: (l: string) =>
+      startsPhysicalLine(l, "Missing character: There is no "),
+  },
+  {
+    id: "undefined-references",
+    reason:
+      "a \\ref — or, without natbib, a \\cite — names what no pass defined, so the PDF prints ?? or [?] in its place",
+    matches: (l: string) => l.includes("There were undefined references"),
+  },
+  {
+    id: "undefined-citations",
+    reason:
+      "a \\cite names a key the bibliography does not hold, so the PDF prints [?] in its place (natbib's summary)",
+    matches: (l: string) => l.includes("There were undefined citations"),
+  },
+  {
+    id: "multiply-defined-labels",
+    reason: "two \\label share a name, so a \\ref may point at the wrong one",
+    matches: (l: string) => l.includes("There were multiply-defined labels"),
+  },
+] as const satisfies readonly FailingWarning[];
+
+export type FailingWarningId = (typeof FAILING_WARNINGS)[number]["id"];
+
+/** One distinct log line, quoted as TeX wrote it, and how many times the log carries it. */
+export interface Quote {
+  readonly text: string;
+  readonly times: number;
+}
+
+/** A failing warning the log carries, with the lines that carry it. */
+export interface FailingHit {
+  readonly id: FailingWarningId;
+  readonly reason: string;
+  readonly quotes: readonly Quote[];
+}
+
+const quotesOf = (matched: readonly string[]): readonly Quote[] =>
+  map(unique(matched), (text) => ({
+    text,
+    times: matched.filter((l) => l === text).length,
+  }));
+
+/** Which of `FAILING_WARNINGS` the log carries, in table order, each line quoted once with a count. */
+export const failingWarnings = (
+  lines: readonly string[],
+): readonly FailingHit[] =>
+  pipe(
+    FAILING_WARNINGS,
+    map((w) => ({
+      id: w.id,
+      reason: w.reason,
+      quotes: quotesOf(lines.filter((l) => w.matches(l))),
+    })),
+    filter((h) => h.quotes.length > 0),
+  );
+
 /**
  * Is this the line a TeX error starts on? Two spellings exist and `-file-line-error` produces
  * both: most errors become `./paper.tex:4: Undefined control sequence.`, while some keep the

package/src/latex-loop.harness.ts

@@ -12,6 +12,7 @@ import { createChecker } from "../lib/check.ts";
 import type {
   BibInput,
   Hashes,
+  LogFailure,
   Observation,
   State,
   Step,
@@ -52,6 +53,7 @@ const latex = (o: Partial<LatexPass> = {}): LatexPass => ({
   bib: NO_BIB,
   errorLines: [],
   fls: null,
+  failing: [],
   ...o,
 });
 const bibtex = (o: Partial<BibtexPass> = {}): BibtexPass => ({
@@ -63,6 +65,14 @@ const bibtex = (o: Partial<BibtexPass> = {}): BibtexPass => ({
   errorLines: [],
   ...o,
 });
+/** What latex-log reports for the end-of-run "There were undefined references." */
+const undefRefs: LogFailure = {
+  id: "undefined-references",
+  reason: "a \\ref names a label no pass defined",
+  quotes: [
+    { text: "LaTeX Warning: There were undefined references.", times: 1 },
+  ],
+};
 const kind = (s: Step) =>
   s.kind === "latex" ? `latex${s.final ? "-final" : ""}` : s.kind;
 
@@ -73,7 +83,6 @@ const S = (o: Partial<State> = {}): State => ({
   unsettled: [],
   latexPasses: 1,
   finalDone: false,
-  warnings: [],
   ...o,
 });
 const exitFail: NonNullable<State["failed"]> = {
@@ -144,15 +153,6 @@ check(
     q3cap.cause.kind === "no-convergence" &&
     (q3cap.lines[0] ?? "").includes("paper.aux, labels-changed"),
 );
-check(
-  "done carries the state's warnings",
-  (() => {
-    const done = nextStep(
-      S({ finalDone: true, warnings: ["undefined-citations"] }),
-    );
-    return done.kind === "done" && done.warnings[0] === "undefined-citations";
-  })(),
-);
 
 // ── 2. summarize over histories ─────────────────────────────────────────────────────────
 const sum = summarize;
@@ -165,7 +165,6 @@ check(
       unsettled: ["paper.aux"],
       latexPasses: 0,
       finalDone: false,
-      warnings: [],
     }),
 );
 // Guards: failing on a failed pass — -halt-on-error stops pdflatex at the first error, and a loop
@@ -222,7 +221,7 @@ check(
 // never resolves, so rerunning for it burns the cap and reports no-convergence for a typo.
 check(
   "summarize: undefined references ALONE leave nothing unsettled — on stable files they are a real bad key",
-  sum([latex({ markers: ["undefined-references"] })]).unsettled.length === 0,
+  sum([latex({ failing: [undefRefs] })]).unsettled.length === 0,
 );
 check(
   "summarize: bibtex that rewrote the .bbl leaves paper.bbl unsettled",
@@ -241,20 +240,8 @@ check(
   sum([latex(), bibtex(), latex(), latex({ final: true })]).latexPasses === 2,
 );
 check(
-  "summarize: finalDone and the undefined-reference warnings of the final log, nothing else",
-  (() => {
-    const s = sum([
-      latex(),
-      latex({
-        final: true,
-        markers: ["undefined-citations", "rerun-requested"],
-      }),
-    ]);
-    return (
-      s.finalDone &&
-      JSON.stringify(s.warnings) === JSON.stringify(["undefined-citations"])
-    );
-  })(),
+  "summarize: finalDone after a clean final pass",
+  sum([latex(), latex({ final: true })]).finalDone,
 );
 
 // ── 3. composed: nextStep(summarize(history)) ───────────────────────────────────────────
@@ -301,7 +288,7 @@ const TABLE: [string, Observation[], string][] = [
   ],
   [
     "undefined references ALONE do not request a rerun — on stable files they are a real bad key",
-    [latex({ markers: ["undefined-references"] })],
+    [latex({ failing: [undefRefs] })],
     "latex-final",
   ],
   [
@@ -445,16 +432,65 @@ check(
   kind(step(convergedAtCap)) === "latex-final",
 );
 
-// ── done carries the undefined-reference summaries ─────────────────────────────────────
-const doneWarn = step([
+// ── a warning on the list of failing ones (latex-log's FAILING_WARNINGS) fails the build ──
+const lost: LogFailure = {
+  id: "lost-character",
+  reason: "pdflatex dropped a character its font has no glyph for",
+  quotes: [
+    { text: "Missing character: There is no \u207b in font cmr10!", times: 1 },
+    { text: "Missing character: There is no \ufffd in font cmtt10!", times: 3 },
+  ],
+};
+const lostFinal = step([latex(), latex({ final: true, failing: [lost] })]);
+check(
+  "🔴 a failing warning in the FINAL log is a fail: latex, the ids, the reason and every quoted line",
+  lostFinal.kind === "fail" &&
+    lostFinal.step === "latex" &&
+    JSON.stringify(lostFinal.cause) ===
+      JSON.stringify({ kind: "log-warnings", ids: ["lost-character"] }) &&
+    JSON.stringify(lostFinal.lines) ===
+      JSON.stringify([
+        "lost-character — pdflatex dropped a character its font has no glyph for:",
+        "  Missing character: There is no \u207b in font cmr10!",
+        "  Missing character: There is no \ufffd in font cmtt10! (3 times)",
+      ]),
+  lostFinal,
+);
+check(
+  "a failing warning in a NON-final log decides nothing: the loop goes on to the final pass",
+  kind(step([latex({ failing: [lost] })])) === "latex-final",
+);
+const lostAndExit = step([
   latex(),
-  latex({ final: true, markers: ["undefined-citations", "rerun-requested"] }),
+  latex({
+    final: true,
+    exitCode: 1,
+    errorLines: ["! Emergency stop."],
+    failing: [lost],
+  }),
 ]);
 check(
-  "done reports undefined citations still in the final log, and nothing else",
-  doneWarn.kind === "done" &&
-    doneWarn.warnings.length === 1 &&
-    doneWarn.warnings[0] === "undefined-citations",
+  "a final pass that also exited non-zero fails on its exit code, quoting the error",
+  lostAndExit.kind === "fail" &&
+    lostAndExit.cause.kind === "exit" &&
+    lostAndExit.lines[0] === "! Emergency stop.",
+);
+check(
+  "an undefined-references summary in the final log fails too — the same path, its own id",
+  (() => {
+    const s = step([latex(), latex({ final: true, failing: [undefRefs] })]);
+    return (
+      s.kind === "fail" &&
+      JSON.stringify(s.cause) ===
+        JSON.stringify({ kind: "log-warnings", ids: ["undefined-references"] })
+    );
+  })(),
+);
+check(
+  "a final log whose only marker is off the list (a rerun request) is done",
+  kind(
+    step([latex(), latex({ final: true, markers: ["rerun-requested"] })]),
+  ) === "done",
 );
 
 // ── helpers ─────────────────────────────────────────────────────────────────────────────

package/src/latex-loop.ts

@@ -6,7 +6,9 @@
  * Both halves are table tests (`latex-loop.harness.ts`), not scenarios that need TeX.
  *
  * ── THE LOOP: `summarize` reduces the history to a `State`, and `nextStep` asks four questions ──
- *   1. did the last program fail?                          → fail, with its error lines
+ *   1. did the last program fail — a non-zero exit, or a
+ *      final log carrying a warning on latex-log's list of
+ *      failing ones (`FAILING_WARNINGS`)?                  → fail, with its lines
  *   2. did the citations, a .bib or the style change since
  *      bibtex last ran?                                    → bibtex
  *   3. did the last pass change a tracked file, or did the
@@ -43,12 +45,17 @@ export const TRACKED: readonly Tracked[] = ["aux", "toc", "out", "bbl"];
 export type Hashes = { readonly [K in Tracked]: string | null };
 
 /** Log markers, as `latex-log.ts` reads them. Re-declared as a type so this module has no imports. */
-export type LogMarker =
-  | "rerun-requested"
-  | "labels-changed"
-  | "rerunfilecheck"
-  | "undefined-references"
-  | "undefined-citations";
+export type LogMarker = "rerun-requested" | "labels-changed" | "rerunfilecheck";
+
+/**
+ * A warning on `latex-log.ts`'s list of those that fail the build, as the log of one pass carries it:
+ * its id, why it fails, and each distinct line quoted once with how many times it appeared.
+ */
+export interface LogFailure {
+  readonly id: string;
+  readonly reason: string;
+  readonly quotes: readonly { readonly text: string; readonly times: number }[];
+}
 
 const RERUN: readonly LogMarker[] = [
   "rerun-requested",
@@ -88,6 +95,8 @@ export type Observation =
       readonly errorLines: readonly string[];
       /** What `-recorder` wrote after this pass (`paper.fls`), or null when pdflatex wrote none. */
       readonly fls: string | null;
+      /** The failing warnings this pass's log carries. Only the final pass's are judged. */
+      readonly failing: readonly LogFailure[];
     }
   | {
       readonly step: "bibtex";
@@ -101,16 +110,13 @@ export type Observation =
 
 export type FailCause =
   | { readonly kind: "exit"; readonly code: number }
-  | { readonly kind: "no-convergence"; readonly unsettled: readonly string[] };
+  | { readonly kind: "no-convergence"; readonly unsettled: readonly string[] }
+  | { readonly kind: "log-warnings"; readonly ids: readonly string[] };
 
 export type Step =
   | { readonly kind: "latex"; readonly final: boolean }
   | { readonly kind: "bibtex" }
-  | {
-      readonly kind: "done";
-      /** Undefined-reference summaries still in the final log — a converged doc with a bad key. */
-      readonly warnings: readonly LogMarker[];
-    }
+  | { readonly kind: "done" }
   | {
       readonly kind: "fail";
       readonly step: "latex" | "bibtex";
@@ -136,13 +142,11 @@ export type State = {
   /** Non-final pdflatex passes so far. */
   readonly latexPasses: number;
   readonly finalDone: boolean;
-  /** Undefined-reference summaries in the log of the final pass. */
-  readonly warnings: readonly LogMarker[];
 };
 
 export function nextStep(s: State): Step {
   if (s.failed) return { kind: "fail", ...s.failed };
-  if (s.finalDone) return { kind: "done", warnings: s.warnings };
+  if (s.finalDone) return { kind: "done" };
   if (s.bibOutdated) return { kind: "bibtex" };
   if (s.unsettled.length === 0) return { kind: "latex", final: true };
   if (s.latexPasses < MAX_PASSES) return { kind: "latex", final: false };
@@ -183,31 +187,48 @@ function unsettledBy(history: readonly Observation[]): string[] {
   return [];
 }
 
+/** A failing warning as the human reads it: the id and reason, then each quoted line. */
+const failureLines = (f: LogFailure): readonly string[] => [
+  `${f.id} — ${f.reason}:`,
+  ...f.quotes.map(
+    (q) => `  ${q.text}${q.times > 1 ? ` (${String(q.times)} times)` : ""}`,
+  ),
+];
+
+/**
+ * Did the last run fail? A non-zero exit, whichever program; or a FINAL pass whose log carries a
+ * failing warning. An earlier pass's log is not judged: before the rerun every reference is
+ * undefined by construction.
+ */
+function failureOf(last: Observation | undefined): State["failed"] {
+  if (last === undefined) return null;
+  if (last.exitCode !== 0)
+    return {
+      step: last.step,
+      cause: { kind: "exit", code: last.exitCode },
+      lines: last.errorLines,
+    };
+  if (last.step !== "latex" || !last.final || last.failing.length === 0)
+    return null;
+  return {
+    step: "latex",
+    cause: { kind: "log-warnings", ids: last.failing.map((f) => f.id) },
+    lines: last.failing.flatMap(failureLines),
+  };
+}
+
 export function summarize(history: readonly Observation[]): State {
   const last = history.at(-1);
   const latexRuns = history.filter((o) => o.step === "latex");
   const lastLatex = latexRuns.at(-1);
   const lastBibtex = history.filter((o) => o.step === "bibtex").at(-1);
   return {
-    failed:
-      last && last.exitCode !== 0
-        ? {
-            step: last.step,
-            cause: { kind: "exit", code: last.exitCode },
-            lines: last.errorLines,
-          }
-        : null,
+    failed: failureOf(last),
     bibOutdated:
       lastLatex?.bib.kind === "needed" &&
       !(lastBibtex && sameBib(lastBibtex.bib, lastLatex.bib)),
     unsettled: unsettledBy(history),
     latexPasses: latexRuns.filter((o) => !o.final).length,
     finalDone: last?.step === "latex" && last.final,
-    warnings:
-      last?.step === "latex"
-        ? last.markers.filter(
-            (m) => m === "undefined-references" || m === "undefined-citations",
-          )
-        : [],
   };
 }