feat(explore): stigen faar sitt manglende trinn - read_bundle gir ETT nivaa, read_dir det neste

S7a-3 pkt. 2. MAJOR-3 bygde read_bundle om fra HELE basen til en oppfoering per
konseptfil. Saa kom det foerste ekte korpuset: K2 navigerer til 629 konsepter bak
478 nestede indekser, og en listing av 629 koster 42 761 o200k-tokens som rir i
7 av 12 prompter = 89 % av alle prompt-tokens. Bindingen holdt asymptotisk og
priset likevel hele korpuset. De 478 indeksene ble bygget, konsumert og flatet ut
- agenten saa 629 soesken og fikk aldri vite at korpuset hadde en form.

MAALT (BEFORE og AFTER i samme oekt, samme kode, BEFORE som mutasjon):
  read_bundle-nyttelast  110 581 tegn / 42 761 tok  ->  3 954 tegn / 1 495 tok
  listing-tokens totalt         307 573 (89 %)      ->  12 595 (26 %)
  prompt-tokens i kjoeringen         343 826        ->  49 225   (-86 %)
BEFORE reproduserer S7a-2s publiserte tall til 0,03 % - kjent-positiv kontroll
paa instrumentet, som ogsaa maatte rettes (resultatet baerer name=None, saa en
sonde nøklet paa verktoeynavn rapporterer 0 kopier og leses som en ekte null).

- okf.directory_listing er ENESTE renderer; begge verktoey ER den paa hvert sitt
  nivaa. Kataloger utledes av STIER, aldri av index.md. Bygget av context_files,
  ALDRI files. Hver sti er bundle-relativ, brukbar ordrett i neste kall.
- Ukjent sti NEKTES ved navn (BundlePathNotFound) - en tom listing er umulig aa
  skille fra en katalog som finnes og er tom.
- Verktoeybeskrivelsene og navigatoerinstruksjonen flyttet i SAMME commit.

PREMISS FELT FOER BYGGING: context_files har aldri holdt hierarkiet tilbake -
navnene er fulle bundle-relative stier; det var RENDERINGEN som flatet det ut.
Derfor er bundle_context og begge nav-goldenene byte-identiske, gratis.

AVVIK fra ordren, uttalt: K2 kan ikke vaere testavhengighet (utenfor repoet), og
1 500 tegn er ikke oppnaaelig for en rot med 39 identifiserbare oppfoeringer
(maalt 3 954). Gaten binder 1 500 tegn per listing over basene den KAN se, pluss
egenskapen, med en FLAT kontroll over 5x taket.

Load-bearing MAALT: 9 mutasjoner alle roede mot HELE suiten, groenn kontroll
1252 passed / 5 skipped, golden byte-uendret. N1 4 / N2 7 / N3 12 / N4 5 / N5 1 /
N6 6 / N7 1 / N8 2 / N9 1.

Maaling: docs/2026-09-03-hierarkisk-navigasjon-k2.md

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

tests/test_read_bundle_cost_loadbearing.py

@@ -39,6 +39,14 @@ o200k tokens** (2.89 chars/token for this Norwegian markdown), so 1 500 characte
 growth does not force a rewrite. The order's own criterion is verified directly, once, by the
 instrument in the measurement doc.
 
+**AMENDED 2026-09-03 (S7a-3 pkt. 2), and the amendment is one level, not a rewrite.** The listing
+this file bounds is now the base's TOP LEVEL rather than every document in it: on K2 the flat form
+still cost 42 761 o200k tokens across 629 documents, because O(documents in the base) is only cheap
+while the base is small. ``read_dir`` is the rung that was missing. Every arm below still holds over
+the flat example bases -- a flat base has no subdirectories, so its document list is unchanged, byte
+for byte -- and the hierarchy's own gate is ``tests/test_hierarchical_navigation_loadbearing.py``.
+``_documents()`` exists because ``len()`` of the payload is now the number of KEYS.
+
 What the arms pin, and what each one refuses:
 
 (a) the bound itself, over the REAL base the order names — refuses the unbounded form. A synthetic
@@ -82,10 +90,18 @@ def _tools(bundle_dir: Path) -> dict[str, Any]:
     return {t.name: t for t in navigator_tools((str(bundle_dir),))}
 
 
-def _listing(bundle_dir: Path) -> list[dict[str, Any]]:
+def _listing(bundle_dir: Path) -> dict[str, Any]:
+    """The WHOLE payload one ``read_bundle`` costs — since S7a-3 that is one LEVEL of the base
+    (subdirectories plus the documents at this one), not every document in it."""
     return _tools(bundle_dir)["read_bundle"].func(bundle_id=bundle_dir.name)
 
 
+def _documents(bundle_dir: Path) -> list[dict[str, Any]]:
+    """The document half alone. A separate helper because ``len()`` of the payload is the number of
+    KEYS — three, always — and an arm counting entries through it would be vacuously green."""
+    return list(_listing(bundle_dir)["documents"])
+
+
 def _blob(payload: object) -> str:
     return json.dumps(payload, ensure_ascii=False)
 
@@ -129,7 +145,7 @@ def test_read_bundle_cost_does_not_track_document_size(tmp_path: Path) -> None:
     small = _write_base(tmp_path, "small", body_chars=500)
     large = _write_base(tmp_path, "large", body_chars=5_000)
 
-    small_entries, large_entries = _listing(small), _listing(large)
+    small_entries, large_entries = _documents(small), _documents(large)
 
     # Same document COUNT, same number of entries — and the only field that grew is the honest,
     # logarithmic ``chars`` digit, so the payloads differ by a handful of characters at most.
@@ -149,7 +165,7 @@ def test_the_listing_still_identifies_every_document(tmp_path: Path) -> None:
     context files rather than to a number written here.
     """
     bundle = okf.navigate_bundle(str(_TUNNEL))
-    entries = _listing(_TUNNEL)
+    entries = _documents(_TUNNEL)
 
     assert len(entries) == len(bundle.context_files) > 0, (
         "a listing that omits documents is a base the navigator cannot fully see"
@@ -172,7 +188,7 @@ def test_the_verdict_layer_is_still_excluded(tmp_path: Path) -> None:
     """
     base = _write_base(tmp_path, "med-dommer", body_chars=200, concepts=2, verdicts=2)
 
-    entries = _listing(base)
+    entries = _documents(base)
 
     assert len(entries) == 2, f"the verdict layer must not be listed as context: {entries!r}"
     assert not [e for e in entries if e["type"] == "verdict"]
@@ -184,7 +200,7 @@ def test_the_verdict_layer_is_still_excluded(tmp_path: Path) -> None:
 
 def test_the_whole_document_is_still_one_call_away() -> None:
     """(e) The bound is a disclosure LEVEL, not data loss."""
-    entries = _listing(_TUNNEL)
+    entries = _documents(_TUNNEL)
     biggest = max(entries, key=lambda e: int(e["chars"]))
 
     whole = _tools(_TUNNEL)["read_file"].func(bundle_id=_TUNNEL.name, path=str(biggest["name"]))