feat(examples): SEGMENTED_V1 golden fixture and decision record

tests/test_segmented_golden.py

@@ -0,0 +1,154 @@
+"""The SEGMENTED_V1 golden: bytes, pinned.
+
+A NEW golden directory, never an edit to the four that exist. That is how
+`2504011` shipped `OKF_V0_2`'s golden -- zero bytes changed in the three that
+were already there -- and it is what makes "additive" a measured claim rather
+than an intention. The second test below is the measurement.
+
+The fixture is synthetic throughout. No consumer content, no real N500 or
+procurement prose: this repository is public, and a golden is the most durable
+place a leak could land.
+
+Door B shaped, unlike the four Door A goldens: the inputs are an inbox, a
+segmentation plan and a `bundle_id`, because those are exactly what a rebuild
+replays. Re-materializing them into an empty directory must reproduce the
+shipped tree file for file -- which is S7 stated as a fixture instead of as a
+property test.
+"""
+
+from __future__ import annotations
+
+import json
+import subprocess
+from pathlib import Path
+
+from llm_ingestion_okf.inbox import GateDecision, process_inbox
+from llm_ingestion_okf.profiles import SEGMENTED_V1
+from llm_ingestion_okf.segmentation import parse_segmentation_plan
+
+EXAMPLES = Path(__file__).resolve().parents[1] / "examples"
+CASE = EXAMPLES / "ingest-golden-segmented"
+
+EXISTING_GOLDENS = (
+    "ingest-golden-file",
+    "ingest-golden-sql",
+    "ingest-golden-http",
+    "ingest-golden-okf-v0-2",
+)
+
+
+def gate(text: str) -> GateDecision:
+    return GateDecision(sanitized_text=text, disposition="warn")
+
+
+def materialize(out_dir: Path) -> None:
+    plan = parse_segmentation_plan(json.loads((CASE / "segmentation-plan.json").read_text("utf-8")))
+    process_inbox(
+        CASE / "fixture" / "inbox",
+        out_dir,
+        (CASE / "ingested-at.txt").read_text(encoding="utf-8").strip(),
+        okf_type="reference",
+        gate=gate,
+        profile=SEGMENTED_V1,
+        root_frontmatter_values={
+            "bundle_id": (CASE / "bundle-id.txt").read_text(encoding="utf-8").strip()
+        },
+        segmentation=plan,
+    )
+
+
+def tree(root: Path) -> dict[str, bytes]:
+    return {
+        path.relative_to(root).as_posix(): path.read_bytes()
+        for path in sorted(root.rglob("*"))
+        if path.is_file()
+    }
+
+
+def test_the_golden_rematerializes_byte_for_byte(tmp_path: Path) -> None:
+    out_dir = tmp_path / "bundle"
+    materialize(out_dir)
+    expected = tree(CASE / "expected-bundle")
+    actual = tree(out_dir)
+    assert sorted(actual) == sorted(expected)
+    for name in sorted(expected):
+        assert actual[name] == expected[name], f"{name} diverges from the golden bytes"
+
+
+def test_the_golden_covers_the_shape_the_profile_exists_for(tmp_path: Path) -> None:
+    # A golden that happened to be flat would pin nothing this profile adds.
+    expected = tree(CASE / "expected-bundle")
+    concepts = [name for name in expected if not name.endswith(SEGMENTED_V1.index.name)]
+    assert len(concepts) >= 3
+    assert any("/" in name for name in concepts)
+    assert len([name for name in expected if name.endswith(SEGMENTED_V1.index.name)]) >= 3
+    assert expected["index.md"].startswith(b"---\nbundle_id: ")
+
+
+def test_the_four_existing_goldens_are_untouched() -> None:
+    # Measured against the baseline commit, not asserted. `git status` covers
+    # an uncommitted edit; `git diff` against the baseline covers a committed
+    # one -- and this voyage makes commits, so the second is the one that bites.
+    baseline = (
+        Path(__file__).resolve().parents[1]
+        / ".claude/projects/2026-08-30-door-b-concept-granularity/baseline/sha"
+    )
+    if not baseline.is_file():
+        # The baseline is LOCAL-ONLY and gitignored, so a fresh clone has none.
+        # Skipping silently would make this test vacuous where it matters most,
+        # so the weaker check still runs.
+        result = subprocess.run(
+            [
+                "git",
+                "status",
+                "--porcelain",
+                "--",
+                *(f"examples/{name}" for name in EXISTING_GOLDENS),
+            ],
+            cwd=Path(__file__).resolve().parents[1],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        assert result.stdout == ""
+        return
+
+    result = subprocess.run(
+        [
+            "git",
+            "diff",
+            "--exit-code",
+            baseline.read_text(encoding="utf-8").strip(),
+            "--",
+            *(f"examples/{name}" for name in EXISTING_GOLDENS),
+        ],
+        cwd=Path(__file__).resolve().parents[1],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    assert result.returncode == 0, f"an existing golden moved:\n{result.stdout}"
+
+
+def test_the_new_golden_was_absent_at_the_baseline() -> None:
+    # Without this, the exclusion above could be hiding churn inside an
+    # existing golden that had been renamed into the new directory.
+    baseline = (
+        Path(__file__).resolve().parents[1]
+        / ".claude/projects/2026-08-30-door-b-concept-granularity/baseline/sha"
+    )
+    if not baseline.is_file():
+        return
+    result = subprocess.run(
+        [
+            "git",
+            "cat-file",
+            "-e",
+            f"{baseline.read_text(encoding='utf-8').strip()}:examples/ingest-golden-segmented",
+        ],
+        cwd=Path(__file__).resolve().parents[1],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    assert result.returncode != 0, "the new golden already existed at the baseline"