feat(propose,cli): typography as a reserve, and the two of our own numbers it took to measure it

K3 round 5. Three questions, three answers, and two of them correct a figure
this repository published.

RETRIEVAL FIRST, because it could have reversed a default. hit@8 over the six
questions on BOTH K2 bundles -- Arm B at 629 concepts and the shipped default
at 492 -- is 5 of 6 with ranks 1,1,1,1,1,- on each, so 0 of 6 rows lost. The
order's rule reverses `--unit-fold` at >= 2 of 6; it does not fire, and the
default stands. The gold sets shrink (49->26, 20->17, 43->36, 11->18) while
every rank holds at 1, which is the fold merging concepts rather than removing
a document from the top.

TWO PUBLISHED NUMBERS CORRECTED, both ours. The S7 candidate ranks 96 of 629
and 159 of 492 were measured with the cost vocabulary passed to
`concept_scores` and NOT to `document_scores`, while `build_payload` passes it
to both; scored the way the shipped payload scores it, the same concept is 10
of 629 and 19 of 492. And round 4 attributed its non-delivery to the default
move -- measured here, it is not delivered on the Arm B bundle either, for a
different reason (knapsack eviction at 68 046 bytes of a 120 000 budget, versus
`below_k`). That column had been inherited from round 3's own build, never
re-measured.

`--pdf-headings font-reserve`, OFF, and the hypothesis behind it is falsified
by its own condition rather than by a score: position 7, the one position the
flag exists for, has THREE outline runs, so the reserve is silent there at
every minimum. It changes 0 of 12 cells on the reference and reaches 4 of 39
corpus documents, none of them rated. Built anyway because it was authorised
and because the condition is now measured rather than assumed. The predicate
lives in one place (`propose.heading_reserve_applies`) and the door receives it
as a callable, like `gate`: a plan indexes the exact string it was proposed
against, so a reserve firing on one side only would make every document it
touches a coded rejection.

The `xlsx` re-reading is confirmed on the artifact -- 11 `rule:sheet-section`
units plus 1 `rule:table-block` ingress -- but the number alone makes the cell
worse (distance 1 -> 2), because the criterion counts that ingress as a table
that should have been merged. A hit needs both halves ratified, and the
reference is the operator's.

`--sheet-section-rows` as a default: three cells better and none worse on the
twelve positions, but the K2 control moves -- row 1's gold document splits 1 ->
12 concepts and its best concept ranks 2 instead of 1. Condition not met,
default not moved.

Default build byte-identical before and after (`diff -r`, 30 md files).
Suite 1441 -> 1449; three of the eight were red first.

Report: docs/2026-09-08-k3-runde5-hitat8-og-skriftakse.md

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

src/llm_ingestion_okf/propose.py

@@ -310,6 +310,26 @@ def outline_lines(text: str) -> list[tuple[int, int, str]]:
     return found
 
 
+def heading_reserve_applies(text: str, *, outline_run: int) -> bool:
+    """Whether this text needs a SECOND heading source, having no run of its own.
+
+    The font reader's reserve condition, and the only place it is decided. The
+    proposer and the door both call this, because a plan indexes the exact
+    string it was proposed against: a reserve that fired on one side and not
+    the other would make every document it touched a coded rejection.
+
+    It reads the gate AS CONFIGURED rather than a fixed minimum -- raising the
+    arm's threshold widens the reserve, which is the same document property
+    seen through the same threshold. At `outline_run` 0 the gate admits nothing
+    at all, so the reserve is unconditional; that combination is round 4's
+    "font instead of Arm D", measured at 1 of 8, and a caller reaching it gets
+    it deliberately.
+    """
+    if outline_run <= 0:
+        return True
+    return not outline_runs(outline_lines(text), outline_run)
+
+
 def outline_runs(
     entries: list[tuple[int, int, str]], minimum: int
 ) -> list[list[tuple[int, int, str]]]:
@@ -1119,6 +1139,7 @@ def run(
     sheet_section_rows: bool = False,
     drop_wrapped_outline: bool = False,
     pdf_headings: bool = False,
+    pdf_headings_reserve: bool = False,
     ocr: bool = False,
 ) -> int:
     if max_segment_chars < 0:
@@ -1164,6 +1185,14 @@ def run(
         # against another is refused by `assert_plan_applies`, which is the
         # right outcome and a confusing one to debug.
         text = extract_text(source.name, source_bytes, pdf_headings=pdf_headings, ocr=ocr)
+        # The reserve, and the reason it re-extracts rather than post-processes:
+        # the font reader works on the PDF's glyph geometry, which the joined
+        # text no longer carries. Skipped outright when the font reader is
+        # already on -- `font` and `font-reserve` are two values of one option,
+        # never a pair to combine.
+        if pdf_headings_reserve and not pdf_headings:
+            if heading_reserve_applies(text, outline_run=outline_run):
+                text = extract_text(source.name, source_bytes, pdf_headings=True, ocr=ocr)
     except IngestError as exc:
         raise ProposerError(f"cannot extract text from {source.name}: {exc}") from exc