docs(front-page): the gate numbers the gate actually prints, and a breaking point that was measured

Four claims on the front page were false on this commit, and one of them was a
number no division ever produced.

**The retrieval gate.** README reported it RED on rows 3, 4, 5, 7, 8 and 9,
with row 3 at 2 of 5 and row 4 at 3 of 6. Run on this commit it is RED on rows
5, 7, 8 and 9, with row 3 at 5 of 5 and row 4 at 6 of 6: `f81683e` made a
withheld concept carry the rule that actually decided it, and `05cb190` gave
the payload a `coverage` block, and neither updated the table. Row 8 is `0 of 3
| NOT RUN` on the default run and was published as `44 of 64 questions`, which
is what it scores the day all three private sets are handed to it -- now
labelled with the day and the machine rather than printed as a row. The same
four figures were stale in `CLAUDE.md`.

**The breaking point in a generated skill.** `int(LIMIT / per_withheld) if
per_withheld else 0` printed `At roughly 0 concepts the bookkeeping alone
reaches the 120000-byte limit` whenever the generation run withheld nothing --
the absence of a measurement, rendered as one, and read as a bundle that breaks
before it holds anything. A run with no withheld entry has no slope to
extrapolate from, so the sentence is withheld with its reason. The shipped
`skills/okf-consume/SKILL.md` is generated with the question its
`references/README.md` names, withholds nothing, and carried exactly that `0`;
it is regenerated. Two arms in the test, because one would pass on an empty
set: the bundles that withhold something must still state a positive figure.

The sentence for that arm also stopped saying `**4 bytes** for 3 concepts`
where the 4 bytes were the cost of 0 withheld entries. It is now `for N of M
concepts`, which moves two generated skills' line counts and therefore the
published comparison: 280 of 312 and 310 -> 281 of 313 and 311, re-measured,
with the 62 differing lines unchanged.

**Four tools.** A single-bundle server exposes three: `okf_list` is absent
where there is nothing to list. README's table already said so in a cell; the
heading and the CHANGELOG did not.

**What `--accounting` accounts for.** The account is over the element classes
each format's vocabulary names, verified against `accounting._READERS` rather
than against the report: a file whose suffix has no reader is accounted at file
level only, `.docx` reads `document.xml` and `footnotes.xml` (so headers,
footers, endnotes and comments are outside), `.pptx` reads the slides (so
speaker notes are outside), `.xlsx` reads the worksheets (so cell comments are
outside and a cell contributes its cached value, never its formula), and `.rtf`
skips its header and footer groups. A hidden slide or sheet IS counted -- it
lives in the same part as a visible one. Nothing is built for this; the list is
what `0 unaccounted` does not claim.

Gates re-run on the commit: retrieval `GATE RED: rows 5, 7, 8, 9` (exit 1),
MCP `GATE RED: rows 2` (exit 1), both matching what is now written.

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

src/llm_ingestion_okf/skill.py

@@ -376,6 +376,11 @@ def render(
     assert isinstance(withheld, list)
     bookkeeping = okf_consume.measure(json.dumps(withheld, ensure_ascii=False))
     per_withheld = bookkeeping / len(withheld) if withheld else 0.0
+    # `0` is what this was until 2026-09-20, and it was not a small number: it
+    # was the absence of a measurement printed as one. A bundle small enough to
+    # deliver everything withholds nothing, so there is no per-entry cost to
+    # extrapolate from -- and `int(LIMIT / 0.0)` was written as `0 concepts`,
+    # which reads as a bundle that breaks before it holds anything.
     breaking = int(okf_consume.DEFAULT_LIMIT / per_withheld) if per_withheld else 0
 
     name = f"{slug(bundle_id)}-consume"
@@ -399,6 +404,7 @@ def render(
         delivered=int(denominators["delivered"]),
         bookkeeping=bookkeeping,
         breaking=breaking,
+        withheld_count=len(withheld),
     )
     # Claude Code reads this header with a YAML reader, and `description`
     # carries the root index's `bundle_id` raw -- a bundle this library did not
@@ -449,6 +455,7 @@ def _rewrite(
     delivered: int,
     bookkeeping: int,
     breaking: int,
+    withheld_count: int,
 ) -> str:
     replacements: list[tuple[str, str]] = [
         (
@@ -508,6 +515,7 @@ def _rewrite(
                 delivered=delivered,
                 bookkeeping=bookkeeping,
                 breaking=breaking,
+                withheld_count=withheld_count,
             ),
         ),
         (
@@ -573,6 +581,7 @@ def _scaling(
     delivered: int,
     bookkeeping: int,
     breaking: int,
+    withheld_count: int,
 ) -> str:
     share = (spent / cost * 100) if cost else 0.0
     return (
@@ -583,11 +592,40 @@ def _scaling(
         f"one answer delivered all {total} concepts — so that answer was about\n"
         f"**{share:.1f} %** of the corpus. One question is one measurement: a\n"
         "different question moves `spent` and this figure with it.\n\n"
+        + _breaking_point(
+            total=total, bookkeeping=bookkeeping, breaking=breaking, withheld_count=withheld_count
+        )
+    )
+
+
+def _breaking_point(*, total: int, bookkeeping: int, breaking: int, withheld_count: int) -> str:
+    """The concept count at which the bookkeeping alone fills the budget.
+
+    It is EXTRAPOLATED from the cost of one `withheld` entry, so a generation
+    run that withheld nothing has no slope to extrapolate from. That case used
+    to print `0 concepts` -- a division that never happened, rendered as a
+    measurement, and the one number in this document that said the bundle
+    breaks before it holds anything. The sentence is withheld instead, with the
+    reason and the two facts that are measured.
+    """
+    if withheld_count == 0:
+        return (
+            "**The breaking point could not be measured on this bundle.** The\n"
+            "`withheld` list carries one entry per considered concept, and on this\n"
+            f"bundle at generation time nothing was withheld: all {total} concepts\n"
+            "were delivered. There is therefore no per-entry cost to extrapolate\n"
+            "from, and no concept count is stated here — a bundle large enough to\n"
+            "withhold something states one. What does hold either way: the\n"
+            "bookkeeping is not counted against `spent`, and the pre-pass reads\n"
+            "every concept body on every run, so growth is a wall-clock cost with\n"
+            "no precomputed index behind it."
+        )
+    return (
         "**The breaking point, stated so it can be observed to have been passed.**\n"
         "The `withheld` list carries one entry per considered concept and grows\n"
-        f"linearly: here it is **{bookkeeping} bytes** for {total} concepts. At roughly\n"
-        f"**{breaking} concepts** the bookkeeping alone reaches the "
-        f"{okf_consume.DEFAULT_LIMIT}-byte\n"
+        f"linearly: here it is **{bookkeeping} bytes** for {withheld_count} of\n"
+        f"{total} concepts. At roughly **{breaking} concepts** the bookkeeping alone\n"
+        f"reaches the {okf_consume.DEFAULT_LIMIT}-byte\n"
         "limit, and although it is not counted against `spent`, a payload whose\n"
         "bookkeeping dwarfs its content has stopped being a cut. The pre-pass also\n"
         "reads every concept body on every run, so the same growth is a wall-clock\n"