feat(ingest): adopt llm-ingestion-okf as Door A implementation (first consumer)

Replace the local 391-line ingest implementation with a thin adapter over
the shared llm-ingestion-okf library (git-pinned dae0bd1a via Forgejo,
tool.uv.sources). The materialize() signature is preserved; error types are
now the library's typed hierarchy rooted in IngestError, re-exported from
the consumer seam.

- tests/test_ingest_adoption.py: new load-bearing seam tests (delegation,
  offline invariant — allow_network is never passed, error contract),
  detach-proven red twice.
- Golden suites (file + sql) pass UNCHANGED — byte-exact behaviour proven
  against the repo-local fixtures.
- 6 test files migrated to the library error hierarchy; escaping/typed-cell
  unit tests dropped (byte-bound by the ingest-edge.md golden, unit-owned by
  the library's own 189-test suite). Provenance stamp now asserted
  independently from the §5 rule.
- mypy override follow_untyped_imports for llm_ingestion_okf (no py.typed
  upstream yet — reported as a finding).

Suite: 386 passed; ruff + format + mypy --strict clean; shared/, examples/,
runs/s10/ and run_s10.py byte-untouched.

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

tests/test_ingest_loadbearing.py

@@ -1,7 +1,9 @@
 """Load-bearing ingest seams (ingest-spec §11) — D7 mirror of MAF I2's set.
 
 Each test must go RED when its seam is detached (the method-spec §11 regime): a
-grønn-men-død test is the failure mode the rule exists for. The seams mirrored here:
+grønn-men-død test is the failure mode the rule exists for. The seams mirrored here,
+proven through the consumer seam (``portfolio_optimiser_claude.ingest``, backed by
+llm-ingestion-okf since the adoption):
 
 - Provenance stamping — a generated file carries the §7 provenance layer, in order.
 - Navigability — the generated bundle is consumable by the UNCHANGED ``okf`` navigation
@@ -14,15 +16,15 @@ grønn-men-død test is the failure mode the rule exists for. The seams mirrored
 
 from __future__ import annotations
 
+import hashlib
 import json
 import shutil
 from pathlib import Path
 
 import pytest
-from pydantic import ValidationError
 
 from portfolio_optimiser_claude import okf
-from portfolio_optimiser_claude.ingest import ManifestContract, load_manifest, materialize
+from portfolio_optimiser_claude.ingest import ManifestError, load_manifest, materialize
 
 GOLDEN = Path(__file__).resolve().parents[1] / "examples" / "ingest-golden-file"
 INGESTED_AT = (GOLDEN / "ingested-at.txt").read_text(encoding="utf-8").strip()
@@ -30,6 +32,13 @@ INGESTED_AT = (GOLDEN / "ingested-at.txt").read_text(encoding="utf-8").strip()
 _PROVENANCE_KEYS = ("source_system", "source_query", "ingested_at", "ingest_manifest", "generated")
 
 
+def _expected_stamp(manifest_path: Path) -> str:
+    # The §5 stamp rule, recomputed INDEPENDENTLY of the implementation:
+    # ``{manifest stem}@{sha256(raw bytes)[:16]}`` — RED if the stamping detaches.
+    digest = hashlib.sha256(manifest_path.read_bytes()).hexdigest()[:16]
+    return f"{manifest_path.stem}@{digest}"
+
+
 def _materialized(tmp_path: Path) -> Path:
     bundle = tmp_path / "bundle"
     bundle.mkdir()
@@ -48,8 +57,7 @@ class TestProvenanceStamping:
         assert concept.frontmatter["source_system"] == "prosjekt-arkiv"
         assert concept.frontmatter["ingested_at"] == INGESTED_AT
         assert concept.frontmatter["generated"] == "true"
-        stamp = load_manifest(GOLDEN / "manifest.json").stamp
-        assert concept.frontmatter["ingest_manifest"] == stamp
+        assert concept.frontmatter["ingest_manifest"] == _expected_stamp(GOLDEN / "manifest.json")
 
     def test_provenance_keys_are_in_the_spec_order(self, tmp_path: Path) -> None:
         # §5: exactly these keys, in exactly this order — the chain is a contract.
@@ -103,20 +111,24 @@ class TestVerdictReservation:
             ],
         }
 
-    def test_verdict_okf_type_is_rejected(self) -> None:
-        with pytest.raises(ValidationError):
-            ManifestContract(**self._manifest("verdict"))
+    def _write(self, tmp_path: Path, okf_type: str) -> Path:
+        manifest = tmp_path / "manifest.json"
+        manifest.write_text(json.dumps(self._manifest(okf_type)), encoding="utf-8")
+        return manifest
 
-    def test_verdict_reservation_is_case_insensitive(self) -> None:
-        with pytest.raises(ValidationError):
-            ManifestContract(**self._manifest("Verdict"))
+    def test_verdict_okf_type_is_rejected(self, tmp_path: Path) -> None:
+        with pytest.raises(ManifestError):
+            load_manifest(self._write(tmp_path, "verdict"))
+
+    def test_verdict_reservation_is_case_insensitive(self, tmp_path: Path) -> None:
+        with pytest.raises(ManifestError):
+            load_manifest(self._write(tmp_path, "Verdict"))
 
     def test_rejection_is_fail_fast_before_any_source_call(self, tmp_path: Path) -> None:
         # A verdict manifest never touches the source: no bundle is written.
-        manifest = tmp_path / "manifest.json"
-        manifest.write_text(json.dumps(self._manifest("verdict")), encoding="utf-8")
+        manifest = self._write(tmp_path, "verdict")
         bundle = tmp_path / "bundle"
-        with pytest.raises(ValidationError):
+        with pytest.raises(ManifestError):
             materialize(manifest, bundle, INGESTED_AT)
         assert not bundle.exists() or not any(bundle.iterdir())