Add files using upload-large-folder tool

README.md

@@ -72,14 +72,14 @@ Target Hub id (packaging metadata only): `justicedao/ipfs_pakistan_laws_ir`.
 
 | Field | Value |
 | --- | --- |
-| Laws (corpus units) | 0 |
-| Articles (corpus units) | 41739 |
-| Canonical docs | 41739 |
-| BM25 terms | 33099 |
-| BM25 postings | 2729675 |
-| Graph nodes | 44589 |
-| Graph edges | 607722 |
-| Vectors | 41739 × 384-d `thenlper/gte-small` (embedded) |
+| Laws (corpus units) | 958 |
+| Articles (corpus units) | 41754 |
+| Canonical docs | 42712 |
+| BM25 terms | 47090 |
+| BM25 postings | 3493690 |
+| Graph nodes | 45587 |
+| Graph edges | 298984 |
+| Vectors | 42712 × 384-d `thenlper/gte-small` (embedded) |
 
 ## Canonical fields
 

build.py

@@ -18,20 +18,12 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any
 
-from .bm25 import bm25_neighbors, build_index
+from .sparse import export_sparse_graphrag
 from .mem import MemAbort, checkpoint, log_mem
-from .spill import (
-    SQLITE_THRESHOLD,
-    build_bm25_tf_spill,
-    build_graph_from_neighbor_shards,
-    neighbors_via_sqlite,
-    should_use_sqlite,
-    spill_dir_for,
-    spill_pickle,
-)
+from .spill import spill_dir_for, spill_pickle
 from .package import package_from_spill, package_release
 from .catalog import get_country, indexable_countries, target_repo
-from .graph import build_graph
+
 from .incremental import (
     fetch_hub_prior,
     load_embedding_cache,
@@ -47,10 +39,10 @@ from .vectors import (
     DIMENSION,
     MODEL_NAME,
     assemble_embeddings,
-    embeddings_available,
     embeddings_by_cid,
     layout_stub_vectors,
     layout_vectors,
+    select_device,
 )
 
 ROOT = Path(os.environ.get("COUNTRY_LAWS_IR_ROOT", str(Path.home() / ".ipfs_datasets" / "country-laws-ir")))
@@ -68,8 +60,17 @@ def _log(msg: str) -> None:
 def record_progress(event: dict[str, Any]) -> None:
     event = dict(event)
     event.setdefault("ts", datetime.now(timezone.utc).isoformat())
-    with PROGRESS.open("a", encoding="utf-8") as f:
-        f.write(json.dumps(event, ensure_ascii=False) + "\n")
+    PROGRESS.parent.mkdir(parents=True, exist_ok=True)
+    lock_path = PROGRESS.with_suffix(".lock")
+    with lock_path.open("a", encoding="utf-8") as lock_fh:
+        try:
+            import fcntl
+
+            fcntl.flock(lock_fh.fileno(), fcntl.LOCK_EX)
+        except Exception:
+            pass
+        with PROGRESS.open("a", encoding="utf-8") as f:
+            f.write(json.dumps(event, ensure_ascii=False) + "\n")
 
 
 def _prior_dir_for(
@@ -121,11 +122,14 @@ def _encode_vectors(
         _log(f"embedding cache reused_cids={len(prior_by_cid)}")
     try:
         positional = CACHE / "embeddings" / f"{country_slug}.npy"
+        resolved, fallback = select_device(device)
+        if fallback:
+            _log(f"embedding device fallback requested={device} using={resolved}")
         embeddings, vector_report = assemble_embeddings(
             corpus,
             prior_by_cid,
-            encode_missing=embeddings_available(),
-            device=device,
+            encode_missing=True,
+            device=resolved,
             checkpoint_path=str(positional),
         )
         if (
@@ -165,7 +169,7 @@ def build_country(
     source: str,
     out: Path | None = None,
     upload: bool = False,
-    device: str = "cpu",
+    device: str = "cuda",
     neighbor_k: int = 8,
     skip_vectors: bool = False,
     mode: str = "auto",
@@ -207,7 +211,11 @@ def build_country(
         )
     )
     plan = plan_rebuild(
-        mode=mode, source_meta=source_meta, prior=prior, force=force
+        mode=mode,
+        source_meta=source_meta,
+        prior=prior,
+        force=force,
+        rebuild_stub_vectors=not skip_vectors,
     )
     if plan.skip_build:
         _log(f"skip unchanged {country['slug']} rev={plan.source_revision}")
@@ -239,6 +247,13 @@ def build_country(
     )
     if corpus.empty:
         raise RuntimeError("Normalized corpus is empty; refusing to package")
+    verdict = (norm_report or {}).get("verification") or {}
+    if verdict.get("blocks_graphrag") and not force:
+        from .verify import NormalizationAdmissionError
+
+        raise NormalizationAdmissionError(
+            f"{country['slug']} failed normalization verifiers: {verdict.get('failed_ids')}"
+        )
 
     import gc
 
@@ -248,6 +263,7 @@ def build_country(
         prior=prior,
         current_corpus=corpus,
         force=force,
+        rebuild_stub_vectors=not skip_vectors,
     )
     _log(
         f"rebuild kind={plan.kind.value} reuse_embeddings={plan.reuse_embeddings} "
@@ -276,50 +292,49 @@ def build_country(
     checkpoint("vectors_spilled", log=_log)
     extra_manifest = {"incremental": {**plan.to_dict(), "vectors": vector_report}}
 
-    use_sqlite = should_use_sqlite(n_docs)
-    neighbor_via = "stock"
-    if use_sqlite:
-        _log(f"sqlite neighbors path n={n_docs} (>= {SQLITE_THRESHOLD}) spill={spill}")
-        # Free corpus body for neighbor stream — reload later for graph
-        del corpus
-        gc.collect()
-        neighbors_via_sqlite(corpus_ckpt, spill, n_docs, k=neighbor_k, log=_log)
-        neighbor_via = "sqlite_fts"
-        bm25_info = build_bm25_tf_spill(corpus_ckpt, spill, n_docs, log=_log)
-        corpus = pd.read_parquet(corpus_ckpt)
-        graph = build_graph_from_neighbor_shards(corpus, spill, log=_log)
-        spill_pickle(spill / "graph.pkl", graph)
-        del graph, corpus
-        gc.collect()
-        checkpoint("graph_spilled", log=_log)
-        code_root = Path(__file__).resolve().parent.parent
-        manifest = package_from_spill(
-            out, spill, corpus_ckpt, source_meta, country, code_root,
-            normalization_report=norm_report, expected_rows=n_docs,
-            extra_manifest=extra_manifest,
-        )
-        _log(f"packaged sequential via={neighbor_via} {out}")
-    else:
-        bm25 = build_index(corpus)
-        _log(f"bm25 terms={bm25['stats']['n_terms']} postings={bm25['stats']['n_postings']}")
-        _log(f"bm25 neighbors start n={n_docs} k={neighbor_k}")
-        neighbors = bm25_neighbors(bm25, k=neighbor_k)
-        _log("bm25 neighbors done")
-        graph = build_graph(corpus, neighbors)
-        del neighbors
-        gc.collect()
-        _log(f"graph nodes={graph['stats']['n_nodes']} edges={graph['stats']['n_edges']}")
-        with open(spill / "vectors.pkl", "rb") as _vf:
-            import pickle as _pickle
-            vectors = _pickle.load(_vf)
-        code_root = Path(__file__).resolve().parent.parent
-        manifest = package_release(
-            out, corpus, bm25, graph, vectors, source_meta, country, code_root,
-            normalization_report=norm_report,
-            extra_manifest=extra_manifest,
-        )
-        del corpus, bm25, graph, vectors
-        gc.collect()
+    neighbor_via = "hf_graphrag"
+    if out.exists():
+        import shutil as _shutil
+
+        _shutil.rmtree(out)
+    out.mkdir(parents=True, exist_ok=True)
+    _log(f"sparse GraphRAG via hf_graphrag.bm25/graph parquet builders n={n_docs}")
+    sparse_report = export_sparse_graphrag(corpus, out)
+    extra_manifest["sparse"] = sparse_report
+    with open(spill / "vectors.pkl", "rb") as _vf:
+        import pickle as _pickle
+
+        vectors = _pickle.load(_vf)
+    dummy_bm25 = {
+        "documents": pd.DataFrame(),
+        "postings": pd.DataFrame(),
+        "stats": (sparse_report.get("bm25") or {}).get("bm25")
+        or (sparse_report.get("bm25") or {}),
+    }
+    dummy_graph = {
+        "nodes": pd.DataFrame(),
+        "edges": pd.DataFrame(),
+        "incoming": pd.DataFrame(),
+        "outgoing": pd.DataFrame(),
+        "stats": sparse_report.get("graph") or {},
+    }
+    code_root = Path(__file__).resolve().parent.parent
+    manifest = package_release(
+        out,
+        corpus,
+        dummy_bm25,
+        dummy_graph,
+        vectors,
+        source_meta,
+        country,
+        code_root,
+        normalization_report=norm_report,
+        extra_manifest=extra_manifest,
+        wipe=False,
+        skip_bm25_graph=True,
+    )
+    del corpus, vectors
+    gc.collect()
     _log(f"packaged {out}")
     result = {
         "country": country["slug"],
@@ -400,17 +415,29 @@ def reindex_from_gaps(
     skip_vectors: bool = False,
     workers: int = 4,
     mode: str = "auto",
+    force: bool = False,
+    all_indexable: bool = False,
+    device: str = "cuda",
 ) -> list[dict[str, Any]]:
-    """Scan Hub gaps and incrementally rebuild stale/missing country IR.
+    """Rebuild country IR. Default is Hub gaps; ``all_indexable`` processes every catalog country.
 
     Default cap skips huge corpora (Finland, Dominican Republic). Pass
     ``max_corpus_rows=None`` to include them.
     """
+    from .catalog import indexable_countries
     from .coverage import gap_report
 
     if slugs is None:
-        report = gap_report(workers=workers)
-        rows = [c for c in report["countries"] if c.get("rebuild")]
+        if all_indexable:
+            rows = [{"slug": c["slug"], "corpus_rows": 0} for c in indexable_countries()]
+            _log(f"reindex all indexable n={len(rows)}")
+        else:
+            report = gap_report(workers=workers)
+            rows = [c for c in report["countries"] if c.get("rebuild")]
+            _log(
+                f"reindex targets n={len(rows)} "
+                f"(from scan rebuild={len(report.get('rebuild') or [])})"
+            )
         rows.sort(key=lambda r: int(r.get("corpus_rows") or 0))
         if max_corpus_rows is not None:
             rows = [
@@ -421,33 +448,54 @@ def reindex_from_gaps(
         if limit is not None:
             rows = rows[: int(limit)]
         slugs = [str(r["slug"]) for r in rows]
-        _log(
-            f"reindex targets n={len(slugs)} "
-            f"(from scan rebuild={len(report.get('rebuild') or [])})"
+    kwargs = {
+        "upload": upload,
+        "mode": mode,
+        "force": force,
+        "skip_vectors": skip_vectors,
+        "fetch_hub_prior_ir": True,
+        "device": device,
+    }
+    n_workers = max(1, int(workers or 1))
+    _log(f"reindex parallel workers={n_workers} countries={len(slugs)} device=cuda")
+    import multiprocessing as mp
+    from concurrent.futures import ProcessPoolExecutor, as_completed
+
+    try:
+        mp.set_start_method("spawn", force=False)
+    except RuntimeError:
+        pass
+
+    results = [None] * len(slugs)
+    with ProcessPoolExecutor(max_workers=n_workers, max_tasks_per_child=1) as pool:
+        futs = {
+            pool.submit(_reindex_one_country, (slug, kwargs)): i
+            for i, slug in enumerate(slugs)
+        }
+        for fut in as_completed(futs):
+            idx = futs[fut]
+            slug = slugs[idx]
+            try:
+                results[idx] = fut.result()
+            except Exception as exc:
+                _log(f"FAILED {slug}: {exc}")
+                results[idx] = {"country": slug, "skipped": False, "error": str(exc)}
+    return [r for r in results if r is not None]
+
+
+def _reindex_one_country(item: tuple[str, dict[str, Any]]) -> dict[str, Any]:
+    slug, kwargs = item
+    _log(f"reindex start {slug}")
+    try:
+        return build_country(slug, **kwargs)
+    except Exception as exc:
+        _log(f"FAILED {slug}: {exc}")
+        record_progress(
+            {
+                "event": "failed",
+                "country": slug,
+                "error": str(exc),
+                "traceback": traceback.format_exc(),
+            }
         )
-    results: list[dict[str, Any]] = []
-    for slug in slugs:
-        _log(f"reindex start {slug}")
-        try:
-            results.append(
-                build_country(
-                    slug,
-                    upload=upload,
-                    mode=mode,
-                    skip_vectors=skip_vectors,
-                    fetch_hub_prior_ir=True,
-                )
-            )
-        except Exception as exc:
-            _log(f"FAILED {slug}: {exc}")
-            record_progress(
-                {
-                    "event": "failed",
-                    "country": slug,
-                    "error": str(exc),
-                    "traceback": traceback.format_exc(),
-                }
-            )
-            results.append({"country": slug, "skipped": False, "error": str(exc)})
-            continue
-    return results
+        return {"country": slug, "skipped": False, "error": str(exc)}

country_laws_ir/__main__.py

@@ -16,7 +16,11 @@ def main(argv: list[str] | None = None) -> int:
     p_build.add_argument("--source-repo", "--source", dest="source", default="malta",
                          help="Hub dataset id (endomorphosis/ipfs_<slug>_laws), country slug, or local pack dir")
     p_build.add_argument("--out", default=None)
-    p_build.add_argument("--device", default="cpu")
+    p_build.add_argument(
+        "--device",
+        default="cuda",
+        help="Embedding device (cuda by default, like US Code / Open US Law; falls back to cpu)",
+    )
     p_build.add_argument("--neighbor-k", type=int, default=8)
     p_build.add_argument("--skip-vectors", action="store_true")
     p_build.add_argument("--upload", action="store_true",
@@ -62,8 +66,22 @@ def main(argv: list[str] | None = None) -> int:
     p_re.add_argument("--max-corpus-rows", type=int, default=20000,
                       help="Skip IR larger than this many rows (0 = no cap)")
     p_re.add_argument("--skip-vectors", action="store_true")
-    p_re.add_argument("--workers", type=int, default=4)
+    p_re.add_argument("--workers", type=int, default=2,
+                      help="Parallel country workers (default 2 to stay under MemAbort; CUDA encodes are file-locked)")
+    p_re.add_argument("--device", default="cuda")
     p_re.add_argument("--mode", default="auto", choices=["auto", "full", "delta"])
+    p_re.add_argument("--all", action="store_true",
+                      help="Process every indexable catalog country (not only Hub gaps)")
+    p_re.add_argument("--force", action="store_true",
+                      help="Rebuild even when the source SHA matches (rerun normalize/verifiers)")
+
+    p_ver = sub.add_parser(
+        "verify",
+        help="Normalize a country pack and run admission verifiers (no GraphRAG)",
+    )
+    p_ver.add_argument("--source-repo", "--source", dest="source", default=None)
+    p_ver.add_argument("--all", action="store_true", help="Verify every indexable catalog country")
+    p_ver.add_argument("--limit", type=int, default=None)
 
     p_raw = sub.add_parser("package-raw")
     p_raw.add_argument("--slug", required=True, help="Country slug used in justicedao/ipfs_<slug>_laws_ir")
@@ -145,7 +163,7 @@ def main(argv: list[str] | None = None) -> int:
     if args.cmd == "reindex":
         from .build import reindex_from_gaps
 
-        cap = None if int(args.max_corpus_rows or 0) <= 0 else int(args.max_corpus_rows)
+        cap = None if args.all or int(args.max_corpus_rows or 0) <= 0 else int(args.max_corpus_rows)
         results = reindex_from_gaps(
             upload=args.upload,
             slugs=args.slugs or None,
@@ -154,6 +172,9 @@ def main(argv: list[str] | None = None) -> int:
             skip_vectors=args.skip_vectors,
             workers=args.workers,
             mode=args.mode,
+            force=args.force,
+            all_indexable=args.all,
+            device=args.device,
         )
         print(json.dumps(
             [
@@ -173,6 +194,65 @@ def main(argv: list[str] | None = None) -> int:
             default=str,
         ))
         return 1 if any(r.get("error") for r in results) else 0
+    if args.cmd == "verify":
+        from .catalog import indexable_countries
+        from .verify import verify_source
+
+        slugs = []
+        if args.all:
+            slugs = [c["slug"] for c in indexable_countries()]
+            if args.limit:
+                slugs = slugs[: int(args.limit)]
+        elif args.source:
+            slugs = [args.source]
+        else:
+            print(json.dumps({"error": "pass --source or --all"}, indent=2))
+            return 2
+        rows = []
+        failed = 0
+        for slug in slugs:
+            try:
+                row = verify_source(slug)
+            except Exception as exc:
+                row = {"slug": slug, "error": str(exc), "verification": {"admitted": False}}
+            rows.append(row)
+            if not (row.get("verification") or {}).get("admitted", False):
+                failed += 1
+        from collections import Counter
+
+        units = Counter(str(r.get("unit") or "") for r in rows)
+        mismatch = []
+        latin_blocked = []
+        for r in rows:
+            for chk in (r.get("verification") or {}).get("checks") or []:
+                if chk.get("id") != "heading_language":
+                    continue
+                ev = chk.get("evidence") or {}
+                if chk.get("severity") == "fail" and not chk.get("passed"):
+                    latin_blocked.append(r.get("slug"))
+                if "review samples" in str(chk.get("message") or ""):
+                    mismatch.append(
+                        {
+                            "slug": r.get("slug"),
+                            "document_language": ev.get("document_language"),
+                            "heading_language": ev.get("heading_language"),
+                        }
+                    )
+        print(
+            json.dumps(
+                {
+                    "n": len(rows),
+                    "n_failed": failed,
+                    "by_unit": dict(units),
+                    "heading_mismatch": mismatch,
+                    "latin_split_blocked": latin_blocked,
+                    "countries": rows,
+                },
+                indent=2,
+                default=str,
+            )
+        )
+        return 1 if failed else 0
     if args.cmd == "package-raw":
         from .build import RELEASES
         from .raw_package import default_instruments_dir, package_instruments

country_laws_ir/build.py

@@ -18,20 +18,12 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any
 
-from .bm25 import bm25_neighbors, build_index
+from .sparse import export_sparse_graphrag
 from .mem import MemAbort, checkpoint, log_mem
-from .spill import (
-    SQLITE_THRESHOLD,
-    build_bm25_tf_spill,
-    build_graph_from_neighbor_shards,
-    neighbors_via_sqlite,
-    should_use_sqlite,
-    spill_dir_for,
-    spill_pickle,
-)
+from .spill import spill_dir_for, spill_pickle
 from .package import package_from_spill, package_release
 from .catalog import get_country, indexable_countries, target_repo
-from .graph import build_graph
+
 from .incremental import (
     fetch_hub_prior,
     load_embedding_cache,
@@ -47,10 +39,10 @@ from .vectors import (
     DIMENSION,
     MODEL_NAME,
     assemble_embeddings,
-    embeddings_available,
     embeddings_by_cid,
     layout_stub_vectors,
     layout_vectors,
+    select_device,
 )
 
 ROOT = Path(os.environ.get("COUNTRY_LAWS_IR_ROOT", str(Path.home() / ".ipfs_datasets" / "country-laws-ir")))
@@ -68,8 +60,17 @@ def _log(msg: str) -> None:
 def record_progress(event: dict[str, Any]) -> None:
     event = dict(event)
     event.setdefault("ts", datetime.now(timezone.utc).isoformat())
-    with PROGRESS.open("a", encoding="utf-8") as f:
-        f.write(json.dumps(event, ensure_ascii=False) + "\n")
+    PROGRESS.parent.mkdir(parents=True, exist_ok=True)
+    lock_path = PROGRESS.with_suffix(".lock")
+    with lock_path.open("a", encoding="utf-8") as lock_fh:
+        try:
+            import fcntl
+
+            fcntl.flock(lock_fh.fileno(), fcntl.LOCK_EX)
+        except Exception:
+            pass
+        with PROGRESS.open("a", encoding="utf-8") as f:
+            f.write(json.dumps(event, ensure_ascii=False) + "\n")
 
 
 def _prior_dir_for(
@@ -121,11 +122,14 @@ def _encode_vectors(
         _log(f"embedding cache reused_cids={len(prior_by_cid)}")
     try:
         positional = CACHE / "embeddings" / f"{country_slug}.npy"
+        resolved, fallback = select_device(device)
+        if fallback:
+            _log(f"embedding device fallback requested={device} using={resolved}")
         embeddings, vector_report = assemble_embeddings(
             corpus,
             prior_by_cid,
-            encode_missing=embeddings_available(),
-            device=device,
+            encode_missing=True,
+            device=resolved,
             checkpoint_path=str(positional),
         )
         if (
@@ -165,7 +169,7 @@ def build_country(
     source: str,
     out: Path | None = None,
     upload: bool = False,
-    device: str = "cpu",
+    device: str = "cuda",
     neighbor_k: int = 8,
     skip_vectors: bool = False,
     mode: str = "auto",
@@ -207,7 +211,11 @@ def build_country(
         )
     )
     plan = plan_rebuild(
-        mode=mode, source_meta=source_meta, prior=prior, force=force
+        mode=mode,
+        source_meta=source_meta,
+        prior=prior,
+        force=force,
+        rebuild_stub_vectors=not skip_vectors,
     )
     if plan.skip_build:
         _log(f"skip unchanged {country['slug']} rev={plan.source_revision}")
@@ -239,6 +247,13 @@ def build_country(
     )
     if corpus.empty:
         raise RuntimeError("Normalized corpus is empty; refusing to package")
+    verdict = (norm_report or {}).get("verification") or {}
+    if verdict.get("blocks_graphrag") and not force:
+        from .verify import NormalizationAdmissionError
+
+        raise NormalizationAdmissionError(
+            f"{country['slug']} failed normalization verifiers: {verdict.get('failed_ids')}"
+        )
 
     import gc
 
@@ -248,6 +263,7 @@ def build_country(
         prior=prior,
         current_corpus=corpus,
         force=force,
+        rebuild_stub_vectors=not skip_vectors,
     )
     _log(
         f"rebuild kind={plan.kind.value} reuse_embeddings={plan.reuse_embeddings} "
@@ -276,50 +292,49 @@ def build_country(
     checkpoint("vectors_spilled", log=_log)
     extra_manifest = {"incremental": {**plan.to_dict(), "vectors": vector_report}}
 
-    use_sqlite = should_use_sqlite(n_docs)
-    neighbor_via = "stock"
-    if use_sqlite:
-        _log(f"sqlite neighbors path n={n_docs} (>= {SQLITE_THRESHOLD}) spill={spill}")
-        # Free corpus body for neighbor stream — reload later for graph
-        del corpus
-        gc.collect()
-        neighbors_via_sqlite(corpus_ckpt, spill, n_docs, k=neighbor_k, log=_log)
-        neighbor_via = "sqlite_fts"
-        bm25_info = build_bm25_tf_spill(corpus_ckpt, spill, n_docs, log=_log)
-        corpus = pd.read_parquet(corpus_ckpt)
-        graph = build_graph_from_neighbor_shards(corpus, spill, log=_log)
-        spill_pickle(spill / "graph.pkl", graph)
-        del graph, corpus
-        gc.collect()
-        checkpoint("graph_spilled", log=_log)
-        code_root = Path(__file__).resolve().parent.parent
-        manifest = package_from_spill(
-            out, spill, corpus_ckpt, source_meta, country, code_root,
-            normalization_report=norm_report, expected_rows=n_docs,
-            extra_manifest=extra_manifest,
-        )
-        _log(f"packaged sequential via={neighbor_via} {out}")
-    else:
-        bm25 = build_index(corpus)
-        _log(f"bm25 terms={bm25['stats']['n_terms']} postings={bm25['stats']['n_postings']}")
-        _log(f"bm25 neighbors start n={n_docs} k={neighbor_k}")
-        neighbors = bm25_neighbors(bm25, k=neighbor_k)
-        _log("bm25 neighbors done")
-        graph = build_graph(corpus, neighbors)
-        del neighbors
-        gc.collect()
-        _log(f"graph nodes={graph['stats']['n_nodes']} edges={graph['stats']['n_edges']}")
-        with open(spill / "vectors.pkl", "rb") as _vf:
-            import pickle as _pickle
-            vectors = _pickle.load(_vf)
-        code_root = Path(__file__).resolve().parent.parent
-        manifest = package_release(
-            out, corpus, bm25, graph, vectors, source_meta, country, code_root,
-            normalization_report=norm_report,
-            extra_manifest=extra_manifest,
-        )
-        del corpus, bm25, graph, vectors
-        gc.collect()
+    neighbor_via = "hf_graphrag"
+    if out.exists():
+        import shutil as _shutil
+
+        _shutil.rmtree(out)
+    out.mkdir(parents=True, exist_ok=True)
+    _log(f"sparse GraphRAG via hf_graphrag.bm25/graph parquet builders n={n_docs}")
+    sparse_report = export_sparse_graphrag(corpus, out)
+    extra_manifest["sparse"] = sparse_report
+    with open(spill / "vectors.pkl", "rb") as _vf:
+        import pickle as _pickle
+
+        vectors = _pickle.load(_vf)
+    dummy_bm25 = {
+        "documents": pd.DataFrame(),
+        "postings": pd.DataFrame(),
+        "stats": (sparse_report.get("bm25") or {}).get("bm25")
+        or (sparse_report.get("bm25") or {}),
+    }
+    dummy_graph = {
+        "nodes": pd.DataFrame(),
+        "edges": pd.DataFrame(),
+        "incoming": pd.DataFrame(),
+        "outgoing": pd.DataFrame(),
+        "stats": sparse_report.get("graph") or {},
+    }
+    code_root = Path(__file__).resolve().parent.parent
+    manifest = package_release(
+        out,
+        corpus,
+        dummy_bm25,
+        dummy_graph,
+        vectors,
+        source_meta,
+        country,
+        code_root,
+        normalization_report=norm_report,
+        extra_manifest=extra_manifest,
+        wipe=False,
+        skip_bm25_graph=True,
+    )
+    del corpus, vectors
+    gc.collect()
     _log(f"packaged {out}")
     result = {
         "country": country["slug"],
@@ -400,17 +415,29 @@ def reindex_from_gaps(
     skip_vectors: bool = False,
     workers: int = 4,
     mode: str = "auto",
+    force: bool = False,
+    all_indexable: bool = False,
+    device: str = "cuda",
 ) -> list[dict[str, Any]]:
-    """Scan Hub gaps and incrementally rebuild stale/missing country IR.
+    """Rebuild country IR. Default is Hub gaps; ``all_indexable`` processes every catalog country.
 
     Default cap skips huge corpora (Finland, Dominican Republic). Pass
     ``max_corpus_rows=None`` to include them.
     """
+    from .catalog import indexable_countries
     from .coverage import gap_report
 
     if slugs is None:
-        report = gap_report(workers=workers)
-        rows = [c for c in report["countries"] if c.get("rebuild")]
+        if all_indexable:
+            rows = [{"slug": c["slug"], "corpus_rows": 0} for c in indexable_countries()]
+            _log(f"reindex all indexable n={len(rows)}")
+        else:
+            report = gap_report(workers=workers)
+            rows = [c for c in report["countries"] if c.get("rebuild")]
+            _log(
+                f"reindex targets n={len(rows)} "
+                f"(from scan rebuild={len(report.get('rebuild') or [])})"
+            )
         rows.sort(key=lambda r: int(r.get("corpus_rows") or 0))
         if max_corpus_rows is not None:
             rows = [
@@ -421,33 +448,54 @@ def reindex_from_gaps(
         if limit is not None:
             rows = rows[: int(limit)]
         slugs = [str(r["slug"]) for r in rows]
-        _log(
-            f"reindex targets n={len(slugs)} "
-            f"(from scan rebuild={len(report.get('rebuild') or [])})"
+    kwargs = {
+        "upload": upload,
+        "mode": mode,
+        "force": force,
+        "skip_vectors": skip_vectors,
+        "fetch_hub_prior_ir": True,
+        "device": device,
+    }
+    n_workers = max(1, int(workers or 1))
+    _log(f"reindex parallel workers={n_workers} countries={len(slugs)} device=cuda")
+    import multiprocessing as mp
+    from concurrent.futures import ProcessPoolExecutor, as_completed
+
+    try:
+        mp.set_start_method("spawn", force=False)
+    except RuntimeError:
+        pass
+
+    results = [None] * len(slugs)
+    with ProcessPoolExecutor(max_workers=n_workers, max_tasks_per_child=1) as pool:
+        futs = {
+            pool.submit(_reindex_one_country, (slug, kwargs)): i
+            for i, slug in enumerate(slugs)
+        }
+        for fut in as_completed(futs):
+            idx = futs[fut]
+            slug = slugs[idx]
+            try:
+                results[idx] = fut.result()
+            except Exception as exc:
+                _log(f"FAILED {slug}: {exc}")
+                results[idx] = {"country": slug, "skipped": False, "error": str(exc)}
+    return [r for r in results if r is not None]
+
+
+def _reindex_one_country(item: tuple[str, dict[str, Any]]) -> dict[str, Any]:
+    slug, kwargs = item
+    _log(f"reindex start {slug}")
+    try:
+        return build_country(slug, **kwargs)
+    except Exception as exc:
+        _log(f"FAILED {slug}: {exc}")
+        record_progress(
+            {
+                "event": "failed",
+                "country": slug,
+                "error": str(exc),
+                "traceback": traceback.format_exc(),
+            }
         )
-    results: list[dict[str, Any]] = []
-    for slug in slugs:
-        _log(f"reindex start {slug}")
-        try:
-            results.append(
-                build_country(
-                    slug,
-                    upload=upload,
-                    mode=mode,
-                    skip_vectors=skip_vectors,
-                    fetch_hub_prior_ir=True,
-                )
-            )
-        except Exception as exc:
-            _log(f"FAILED {slug}: {exc}")
-            record_progress(
-                {
-                    "event": "failed",
-                    "country": slug,
-                    "error": str(exc),
-                    "traceback": traceback.format_exc(),
-                }
-            )
-            results.append({"country": slug, "skipped": False, "error": str(exc)})
-            continue
-    return results
+        return {"country": slug, "skipped": False, "error": str(exc)}

country_laws_ir/citations.py

@@ -0,0 +1,147 @@
+"""Official and Bluebook citations for country-law corpus rows.
+
+Bluebook T2/T10 abbreviations are used only when this table has a row.
+Unknown jurisdictions get ``official_citation`` only — never a invented
+Bluebook form. Query keys are normalized so ``ORS 1.010`` and
+``Or. Rev. Stat. § 1.010`` can hit the same row later.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import re
+import unicodedata
+from typing import Any
+
+# slug or country name (lower) -> Bluebook T2/T10 statute abbreviation.
+# Empty pinpoint templates are filled with article/section when present.
+_BLUEBOOK_STATUTE: dict[str, str] = {
+    "australia": "Cth",
+    "canada": "S.C.",
+    "united kingdom": "U.K.",
+    "uk": "U.K.",
+    "united states": "U.S.C.",
+    "usa": "U.S.C.",
+    "germany": "BGBl.",
+    "france": "J.O.",
+    "malta": "Laws of Malta",
+    "ireland": "Ir.",
+    "newzealand": "N.Z.",
+    "new zealand": "N.Z.",
+    "southafrica": "S. Afr.",
+    "south africa": "S. Afr.",
+    "india": "India",
+    "japan": "Japan",
+    "china": "P.R.C.",
+    "netherlands": "Stb.",
+    "austria": "BGBl.",
+    "switzerland": "AS",
+    "sweden": "SFS",
+    "norway": "Norsk Lovtidend",
+    "denmark": "Lovtidende",
+    "finland": "Finlex",
+    "eu": "O.J.",
+}
+
+
+@dataclass(frozen=True)
+class Citation:
+    official_citation: str
+    bluebook_citation: str
+    cite_key: str
+    citation_status: str  # bluebook | official_only | unknown
+    pinpoint: str
+
+
+def normalize_cite_key(value: str) -> str:
+    if not value:
+        return ""
+    text = unicodedata.normalize("NFKC", value).lower()
+    text = text.replace("§", " s ")
+    text = text.replace("¶", " ")
+    text = re.sub(r"\bart(?:icle|\.)?\b", "art", text)
+    text = re.sub(r"\bsec(?:tion|\.)?\b", "s", text)
+    text = re.sub(r"[^a-z0-9]+", " ", text)
+    return re.sub(r"\s+", " ", text).strip()
+
+
+def _pinpoint(article_number: str, section_number: str, record_type: str) -> str:
+    if record_type == "section" and section_number:
+        return f"§ {section_number}"
+    if article_number:
+        return f"art. {article_number}"
+    if section_number:
+        return f"§ {section_number}"
+    return ""
+
+
+def _bluebook_abbrev(jurisdiction: str, country: str, slug: str = "") -> str:
+    for key in (slug, country, jurisdiction):
+        hit = _BLUEBOOK_STATUTE.get(str(key or "").strip().lower().replace("_", " "))
+        if hit:
+            return hit
+    return ""
+
+
+def assign_citation(
+    *,
+    eli: str = "",
+    official_identifier: str = "",
+    identifier: str = "",
+    instrument_title: str = "",
+    article_number: str = "",
+    section_number: str = "",
+    record_type: str = "law",
+    jurisdiction: str = "",
+    country: str = "",
+    slug: str = "",
+    year: str = "",
+) -> Citation:
+    pinpoint = _pinpoint(article_number, section_number, record_type)
+    official = (
+        (eli or "").strip()
+        or (official_identifier or "").strip()
+        or (identifier or "").strip()
+        or (instrument_title or "").strip()
+    )
+    if official and pinpoint and pinpoint.lower() not in official.lower():
+        official_cite = f"{official}, {pinpoint}"
+    else:
+        official_cite = official
+
+    abbrev = _bluebook_abbrev(jurisdiction, country, slug)
+    bluebook = ""
+    if abbrev and official:
+        if pinpoint:
+            if year:
+                bluebook = f"{abbrev} {pinpoint} ({year})"
+            else:
+                bluebook = f"{abbrev} {pinpoint}"
+        else:
+            bluebook = f"{abbrev} {official}" if official != abbrev else abbrev
+
+    if bluebook:
+        status = "bluebook"
+    elif official_cite:
+        status = "official_only"
+    else:
+        status = "unknown"
+
+    key_src = bluebook or official_cite
+    return Citation(
+        official_citation=official_cite,
+        bluebook_citation=bluebook,
+        cite_key=normalize_cite_key(key_src),
+        citation_status=status,
+        pinpoint=pinpoint,
+    )
+
+
+def citation_fields(cite: Citation) -> dict[str, Any]:
+    return {
+        "official_citation": cite.official_citation,
+        "bluebook_citation": cite.bluebook_citation,
+        "cite_key": cite.cite_key,
+        "citation_status": cite.citation_status,
+        "pinpoint": cite.pinpoint,
+    }

country_laws_ir/coverage.py

@@ -159,7 +159,10 @@ def classify_gap(
         and local_source_revision
         and str(source_revision) == str(local_source_revision)
     )
-    rebuild = status in {"missing", "unpublished", "stale", "incomplete"} and not local_current
+    rebuild = (
+        status in {"missing", "unpublished", "stale", "incomplete", "stub_vectors"}
+        and (not local_current or status == "stub_vectors")
+    )
     publish = status in {"missing", "unpublished", "stale", "incomplete", "stub_vectors"} and (
         "source_missing_laws" not in issues
     )

country_laws_ir/duckdb_store.py

@@ -0,0 +1,475 @@
+"""DuckDB views over country-laws sparse GraphRAG parquet shards.
+
+Published artifacts are ZSTD parquet (SkillCenter / publicus-ir family).
+Query and large-corpus neighbor generation read those shards through DuckDB
+instead of loading them into pandas or SQLite.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+import pandas as pd
+
+K1 = 1.2
+B = 0.75
+TITLE_WEIGHT = 5.0
+BODY_WEIGHT = 1.0
+MAX_QUERY_TERMS = 64
+
+VIEWS = (
+    ("corpus", "data/corpus/*.parquet"),
+    ("bm25_documents", "data/bm25/documents/*.parquet"),
+    ("bm25_postings", "data/bm25/postings/*.parquet"),
+    ("graph_nodes", "data/graph/nodes/*.parquet"),
+    ("graph_edges", "data/graph/edges/*.parquet"),
+    # Shared hf_graphrag layout (US Code / state laws / FR).
+    ("graph_in", "data/graph/adjacency/in/*.parquet"),
+    ("graph_out", "data/graph/adjacency/out/*.parquet"),
+    # Legacy country-laws-ir layout still on some Hub packs.
+    ("graph_incoming", "data/graph/adjacency/incoming/*.parquet"),
+    ("graph_outgoing", "data/graph/adjacency/outgoing/*.parquet"),
+    ("vectors", "data/vectors/*.parquet"),
+)
+
+
+class DuckDBStoreError(RuntimeError):
+    """Raised when a parquet/DuckDB sparse index cannot be opened."""
+
+
+def _require_duckdb():
+    try:
+        import duckdb  # type: ignore
+    except ImportError as exc:
+        raise DuckDBStoreError("duckdb is required for parquet sparse GraphRAG query") from exc
+    return duckdb
+
+
+def parquet_glob(root: Path, pattern: str) -> str:
+    return str(Path(root) / pattern)
+
+
+def connect_release(root: Path, *, database: str = ":memory:"):
+    """Open a DuckDB connection with views over parquet shards."""
+    duckdb = _require_duckdb()
+    root = Path(root)
+    if not (root / "manifest.json").is_file():
+        raise DuckDBStoreError(f"release missing manifest.json: {root}")
+    con = duckdb.connect(database)
+    for name, pattern in VIEWS:
+        glob = parquet_glob(root, pattern)
+        if list(root.glob(pattern)):
+            escaped = glob.replace("'", "''")
+            con.execute(
+                f"CREATE OR REPLACE VIEW {name} AS SELECT * FROM read_parquet('{escaped}')"
+            )
+    return con
+
+
+def load_manifest(root: Path) -> dict[str, Any]:
+    return json.loads((Path(root) / "manifest.json").read_text(encoding="utf-8"))
+
+
+def tokenize(text: str) -> list[str]:
+    import re
+    import unicodedata
+
+    if not text:
+        return []
+    nfkd = unicodedata.normalize("NFKD", text)
+    folded = "".join(ch for ch in nfkd if not unicodedata.combining(ch)).lower()
+    return re.findall(r"[0-9A-Za-z]+", folded)
+
+
+def bm25_search(root: Path, query: str, top_k: int = 10) -> list[dict[str, Any]]:
+    """Okapi BM25 over parquet posting shards via DuckDB UNNEST."""
+    terms = tokenize(query)[:MAX_QUERY_TERMS]
+    if not terms:
+        return []
+    manifest = load_manifest(root)
+    avgdl = float((manifest.get("bm25") or {}).get("average_document_length") or 1.0) or 1.0
+    con = connect_release(root)
+    try:
+        tables = {
+            r[0]
+            for r in con.execute(
+                "SELECT table_name FROM information_schema.tables WHERE table_schema = 'main'"
+            ).fetchall()
+        }
+        if "bm25_postings" not in tables or "bm25_documents" not in tables:
+            raise DuckDBStoreError("release is missing BM25 parquet shards")
+        placeholders = ", ".join(["?"] * len(terms))
+        sql = f"""
+            WITH exploded AS (
+                SELECT
+                    unnest(document_indices) AS document_index,
+                    unnest(title_frequencies) AS title_tf,
+                    unnest(body_frequencies) AS body_tf,
+                    unnest(document_lengths) AS dl,
+                    idf
+                FROM bm25_postings
+                WHERE term IN ({placeholders})
+            ),
+            scored AS (
+                SELECT
+                    document_index,
+                    SUM(
+                        idf * (
+                            ( {TITLE_WEIGHT} * title_tf + {BODY_WEIGHT} * body_tf )
+                            * ({K1} + 1.0)
+                        ) / (
+                            ( {TITLE_WEIGHT} * title_tf + {BODY_WEIGHT} * body_tf )
+                            + {K1} * (1.0 - {B} + {B} * (dl / {avgdl}))
+                        )
+                    ) AS score
+                FROM exploded
+                GROUP BY document_index
+            )
+            SELECT
+                s.document_index,
+                s.score,
+                d.entry_cid,
+                d.title,
+                d.record_type
+            FROM scored s
+            JOIN bm25_documents d USING (document_index)
+            ORDER BY s.score DESC, s.document_index
+            LIMIT ?
+        """
+        rows = con.execute(sql, [*terms, int(top_k)]).fetchall()
+        cols = [
+            "document_index",
+            "score",
+            "entry_cid",
+            "title",
+            "record_type",
+        ]
+        return [dict(zip(cols, row)) for row in rows]
+    finally:
+        con.close()
+
+
+def cite_search(
+    root: Path,
+    citation: str,
+    *,
+    cite_format: str = "any",
+    limit: int = 25,
+) -> list[dict[str, Any]]:
+    """Look up corpus rows by Bluebook, official cite, or normalized cite_key."""
+    from .citations import normalize_cite_key
+
+    needle = (citation or "").strip()
+    if not needle:
+        return []
+    key = normalize_cite_key(needle)
+    con = connect_release(root)
+    try:
+        tables = {
+            r[0]
+            for r in con.execute(
+                "SELECT table_name FROM information_schema.tables WHERE table_schema = 'main'"
+            ).fetchall()
+        }
+        if "corpus" not in tables:
+            raise DuckDBStoreError("release is missing corpus parquet shards")
+        cols = [
+            r[1]
+            for r in con.execute(
+                "SELECT table_schema, column_name FROM information_schema.columns "
+                "WHERE table_schema = 'main' AND table_name = 'corpus'"
+            ).fetchall()
+        ]
+        wanted = [
+            "entry_cid",
+            "record_type",
+            "title",
+            "instrument_title",
+            "article_number",
+            "official_citation",
+            "bluebook_citation",
+            "cite_key",
+            "citation_status",
+            "source_url",
+        ]
+        select = ", ".join(c for c in wanted if c in cols) or "*"
+        clauses = []
+        params: list[Any] = []
+        fmt = (cite_format or "any").strip().lower()
+        if fmt in {"any", "bluebook"} and "bluebook_citation" in cols:
+            clauses.append("lower(coalesce(bluebook_citation, '')) = lower(?)")
+            params.append(needle)
+        if fmt in {"any", "official"} and "official_citation" in cols:
+            clauses.append("lower(coalesce(official_citation, '')) = lower(?)")
+            params.append(needle)
+        if "cite_key" in cols and key:
+            clauses.append("cite_key = ?")
+            params.append(key)
+        if not clauses:
+            return []
+        sql = f"SELECT {select} FROM corpus WHERE {' OR '.join(clauses)} LIMIT ?"
+        params.append(int(limit))
+        rows = con.execute(sql, params).fetchall()
+        names = [c for c in wanted if c in cols] if select != "*" else list(cols)
+        return [dict(zip(names, row)) for row in rows]
+    finally:
+        con.close()
+
+
+def graph_neighbors(
+    root: Path,
+    node_cid: str,
+    *,
+    direction: str = "both",
+    limit: int = 25,
+) -> list[dict[str, Any]]:
+    """Adjacency lookup over parquet shards via DuckDB."""
+    aliases = {
+        "both": ("in", "out", "incoming", "outgoing"),
+        "in": ("in", "incoming"),
+        "out": ("out", "outgoing"),
+        "incoming": ("in", "incoming"),
+        "outgoing": ("out", "outgoing"),
+    }
+    dirs = aliases.get(direction, (direction,))
+    con = connect_release(root)
+    try:
+        tables = {
+            r[0]
+            for r in con.execute(
+                "SELECT table_name FROM information_schema.tables WHERE table_schema = 'main'"
+            ).fetchall()
+        }
+        hits: list[dict[str, Any]] = []
+        for d in dirs:
+            view = {
+                "in": "graph_in",
+                "out": "graph_out",
+                "incoming": "graph_incoming",
+                "outgoing": "graph_outgoing",
+            }.get(d, d)
+            if view not in tables:
+                continue
+            rows = con.execute(
+                f"""
+                SELECT node_cid, neighbor_cids, edge_types, scores
+                FROM {view}
+                WHERE node_cid = ?
+                """,
+                [node_cid],
+            ).fetchall()
+            for node, neighs, types, scores in rows:
+                neighs = list(neighs or [])
+                types = list(types or [])
+                scores = list(scores or [])
+                for i, neigh in enumerate(neighs):
+                    hits.append(
+                        {
+                            "direction": d,
+                            "node_cid": node,
+                            "neighbor_cid": neigh,
+                            "edge_type": types[i] if i < len(types) else "",
+                            "score": scores[i] if i < len(scores) else None,
+                        }
+                    )
+        hits.sort(key=lambda r: (-(r["score"] or 0), str(r["neighbor_cid"])))
+        return hits[: int(limit)]
+    finally:
+        con.close()
+
+
+def build_fts_index(
+    corpus_parquet: Path,
+    duckdb_path: Path,
+    expected: int,
+    *,
+    log: Any | None = None,
+) -> Path:
+    """Load corpus parquet into DuckDB and create an FTS index (no SQLite)."""
+    duckdb = _require_duckdb()
+    duckdb_path = Path(duckdb_path)
+    duckdb_path.parent.mkdir(parents=True, exist_ok=True)
+    if duckdb_path.exists():
+        duckdb_path.unlink()
+    escaped = str(Path(corpus_parquet).resolve()).replace("'", "''")
+    con = duckdb.connect(str(duckdb_path))
+    try:
+        con.execute(
+            f"""
+            CREATE TABLE documents AS
+            SELECT
+                CAST(document_index AS INTEGER) AS document_index,
+                CAST(entry_cid AS VARCHAR) AS entry_cid,
+                CAST(COALESCE(title, '') AS VARCHAR) AS title,
+                CAST(COALESCE(body, '') AS VARCHAR) AS body
+            FROM read_parquet('{escaped}')
+            """
+        )
+        n = int(con.execute("SELECT COUNT(*) FROM documents").fetchone()[0])
+        if n != int(expected):
+            raise DuckDBStoreError(f"DuckDB corpus rows {n} != expected {expected}")
+        con.execute("INSTALL fts")
+        con.execute("LOAD fts")
+        con.execute(
+            "PRAGMA create_fts_index('documents', 'document_index', 'title', 'body', "
+            "stemmer='porter', stopwords='english', ignore='(\\.+)', strip_accents=1, lower=1)"
+        )
+        if log:
+            log(f"duckdb fts ready n={n} path={duckdb_path}")
+    finally:
+        con.close()
+    return duckdb_path
+
+
+def stream_neighbors_to_parquet(
+    duckdb_path: Path,
+    spill: Path,
+    n_docs: int,
+    *,
+    k: int = 8,
+    shard: int = 5000,
+    batch: int = 256,
+    resume: bool = True,
+    log: Any | None = None,
+) -> list[Path]:
+    """Stream DuckDB FTS neighbors into flattened neighbor_*.parquet shards."""
+    duckdb = _require_duckdb()
+    spill = Path(spill)
+    spill.mkdir(parents=True, exist_ok=True)
+    existing = sorted(spill.glob("neighbors_*.parquet"))
+    buf_start = 0
+    shard_paths: list[Path] = []
+    if resume and existing:
+        covered = 0
+        for path in existing:
+            parts = path.stem.split("_")
+            try:
+                start_i, end_i = int(parts[1]), int(parts[2])
+            except (IndexError, ValueError):
+                continue
+            if start_i != covered:
+                break
+            shard_paths.append(path)
+            covered = end_i
+        buf_start = covered
+        if buf_start >= n_docs:
+            if log:
+                log(f"neighbors resume complete {buf_start}/{n_docs}")
+            return shard_paths
+        for path in existing:
+            if path not in shard_paths:
+                path.unlink(missing_ok=True)
+    else:
+        for path in existing:
+            path.unlink(missing_ok=True)
+
+    con = duckdb.connect(str(duckdb_path), read_only=True)
+    con.execute("LOAD fts")
+    rows_buf: list[dict[str, Any]] = []
+    shard_start = buf_start
+    last_idx = buf_start - 1
+    done = buf_start
+    try:
+        while True:
+            batch_rows = con.execute(
+                "SELECT document_index, title, body FROM documents "
+                "WHERE document_index > ? ORDER BY document_index LIMIT ?",
+                [last_idx, batch],
+            ).fetchall()
+            if not batch_rows:
+                break
+            for di, title, body in batch_rows:
+                di = int(di)
+                query = (str(title or "").strip() or str(body or "")[:800]).strip()
+                hits: list[tuple[int, float]] = []
+                if query:
+                    hits = con.execute(
+                        "SELECT document_index, "
+                        "fts_main_documents.match_bm25(document_index, ?) AS score "
+                        "FROM documents "
+                        "WHERE document_index != ? AND score IS NOT NULL "
+                        "ORDER BY score DESC, document_index "
+                        "LIMIT ?",
+                        [query, di, int(k)],
+                    ).fetchall()
+                for neigh_i, score in hits:
+                    rows_buf.append(
+                        {
+                            "source_index": di,
+                            "neighbor_index": int(neigh_i),
+                            "score": float(score or 0.0),
+                        }
+                    )
+                last_idx = di
+                done += 1
+                if (di + 1 - shard_start) >= shard:
+                    end = di + 1
+                    path = spill / f"neighbors_{shard_start:06d}_{end:06d}.parquet"
+                    pd.DataFrame(rows_buf).to_parquet(path, index=False)
+                    shard_paths.append(path)
+                    rows_buf = []
+                    shard_start = end
+                    if log:
+                        log(f"neighbors parquet shard {path.name}")
+            if done % 5_000 == 0 and log:
+                log(f"duckdb neighbors {done}/{n_docs}")
+        if shard_start < n_docs:
+            path = spill / f"neighbors_{shard_start:06d}_{n_docs:06d}.parquet"
+            pd.DataFrame(rows_buf).to_parquet(path, index=False)
+            shard_paths.append(path)
+        if log:
+            log(f"duckdb neighbors done={done} shards={len(shard_paths)}")
+        return shard_paths
+    finally:
+        con.close()
+
+
+def iter_neighbor_parquet_shards(spill: Path) -> Any:
+    """Yield (start_index, list-of-neighbor-lists) from parquet shards."""
+    import pandas as pd
+
+    paths = sorted(Path(spill).glob("neighbors_*.parquet"))
+    for path in paths:
+        parts = path.stem.split("_")
+        start_i = int(parts[1])
+        end_i = int(parts[2])
+        frame = pd.read_parquet(path)
+        part: list[list] = [[] for _ in range(max(0, end_i - start_i))]
+        if not frame.empty:
+            for rec in frame.itertuples(index=False):
+                src = int(rec.source_index)
+                offset = src - start_i
+                if 0 <= offset < len(part):
+                    part[offset].append(
+                        (int(rec.neighbor_index), float(rec.score), [])
+                    )
+        yield start_i, part
+
+
+def materialize_corpus_duckdb(corpus_parquet: Path, duckdb_path: Path) -> Path:
+    """Load a corpus parquet file into a persistent DuckDB database."""
+    duckdb = _require_duckdb()
+    duckdb_path = Path(duckdb_path)
+    duckdb_path.parent.mkdir(parents=True, exist_ok=True)
+    if duckdb_path.exists():
+        duckdb_path.unlink()
+    con = duckdb.connect(str(duckdb_path))
+    try:
+        con.execute(
+            """
+            CREATE TABLE documents AS
+            SELECT
+                CAST(document_index AS INTEGER) AS document_index,
+                CAST(entry_cid AS VARCHAR) AS entry_cid,
+                CAST(title AS VARCHAR) AS title,
+                CAST(body AS VARCHAR) AS body
+            FROM read_parquet(?)
+            """,
+            [str(corpus_parquet)],
+        )
+        con.execute("CREATE INDEX documents_idx ON documents(document_index)")
+    finally:
+        con.close()
+    return duckdb_path

country_laws_ir/incremental.py

@@ -234,6 +234,7 @@ def plan_rebuild(
     prior: PriorRelease | None,
     current_corpus: pd.DataFrame | None = None,
     force: bool = False,
+    rebuild_stub_vectors: bool = True,
 ) -> RebuildPlan:
     """Decide skip / delta / full from source fingerprints and CID overlap."""
     mode = BuildMode.coerce(mode)
@@ -275,7 +276,19 @@ def plan_rebuild(
             equivalent_to_full=True,
         )
 
-    if prior_fp == fingerprint and fingerprint.strip("|"):
+    prior_vector_status = str(
+        ((prior.manifest.get("vector") or {}) if prior.manifest else {}).get("status")
+        or ((prior.manifest.get("incremental") or {}).get("vectors") or {}).get("status")
+        or ""
+    ).strip().lower()
+    stub_vectors = rebuild_stub_vectors and prior_vector_status in {
+        "stub",
+        "stub_missing_encoder",
+        "incomplete",
+        "partial",
+    }
+
+    if prior_fp == fingerprint and fingerprint.strip("|") and not stub_vectors:
         return RebuildPlan(
             kind=RebuildKind.UNCHANGED,
             mode=mode,
@@ -314,10 +327,15 @@ def plan_rebuild(
                 equivalent_to_full=True,
             )
 
+    reason = (
+        "source fingerprint matches but vectors are stub/incomplete; encode missing CIDs"
+        if stub_vectors and prior_fp == fingerprint
+        else "source changed; reuse embeddings for unchanged entry_cids"
+    )
     return RebuildPlan(
         kind=RebuildKind.DELTA_REFRESH,
         mode=mode,
-        reason="source changed; reuse embeddings for unchanged entry_cids",
+        reason=reason,
         source_revision=revision,
         prior_revision=prior_revision,
         source_fingerprint=fingerprint,

country_laws_ir/normalize.py

@@ -1,8 +1,9 @@
 """Normalize endomorphosis/ipfs_*_laws into a CID-keyed canonical corpus.
 
 Prefer article/section as the retrieval unit; fall back to law-level when
-articles are missing or empty. Normalize (NFKC + whitespace collapse) BEFORE
-GraphRAG. Never invent legal text or identifiers.
+articles are missing or empty. Strip leftover HTML, then detect multilingual
+title/chapter/article/section headings (Oregon-style) when present. Never
+invent legal text or a hierarchy that is not in the source.
 
 Public Hub reads only (token=False). No Hugging Face token is read or stored.
 """
@@ -11,8 +12,6 @@ from __future__ import annotations
 
 import json
 import os
-import re
-import unicodedata
 from collections import Counter
 from pathlib import Path
 from typing import Any
@@ -25,8 +24,8 @@ from . import ENTRY_IDENTITY_SCHEMA, LAW_IDENTITY_SCHEMA, SCHEMA_VERSION
 from .auth import configure_hf, public_token
 from .cidutil import cid_of_json, sha256_file, sha256_hex
 from .schema import SchemaError, validate_articles, validate_laws
+from .structure import normalize_legal_text, split_structured_units
 
-_WS_RE = re.compile(r"\s+", re.UNICODE)
 COLLECTOR_DEFAULT = "endomorphosis/ipfs_datasets_py"
 EMPTY_ARTICLE_COLUMNS = (
     "law_id",
@@ -48,9 +47,7 @@ def _empty_articles() -> pd.DataFrame:
 def normalize_text(value: Any) -> str:
     if value is None or (isinstance(value, float) and pd.isna(value)):
         return ""
-    text = unicodedata.normalize("NFKC", str(value))
-    text = _WS_RE.sub(" ", text).strip()
-    return text
+    return normalize_legal_text(value)
 
 
 def _s(value: Any) -> str:
@@ -285,6 +282,35 @@ def _snapshot_date(row: pd.Series, meta: dict[str, Any], source_meta: dict[str,
     return ""
 
 
+def _hierarchy_fields(
+    title: str, body: str, article_number: str, *, language: str = ""
+) -> dict[str, Any]:
+    """Best-effort hierarchy from a single already-split article/section body."""
+    units = split_structured_units(
+        f"{title}\n{body}" if title else body, language=language
+    )
+    if not units:
+        return {
+            "hierarchy_kind": "article" if article_number else "law",
+            "hierarchy_path": "",
+            "title_number": "",
+            "chapter_number": "",
+            "part_number": "",
+            "section_number": "",
+            "subsections": [],
+        }
+    unit = units[0]
+    return {
+        "hierarchy_kind": unit.kind,
+        "hierarchy_path": unit.hierarchy_path,
+        "title_number": unit.title_number,
+        "chapter_number": unit.chapter_number,
+        "part_number": unit.part_number,
+        "section_number": unit.section_number,
+        "subsections": list(unit.subsections),
+    }
+
+
 def _collector(meta: dict[str, Any], source_dataset: str) -> str:
     nested = meta.get("metadata") if isinstance(meta.get("metadata"), dict) else {}
     for blob in (meta, nested):
@@ -373,6 +399,34 @@ def _base_record(
     }
     if extra:
         rec.update(extra)
+    from .citations import assign_citation, citation_fields
+
+    slug = ""
+    if source_dataset.startswith("endomorphosis/ipfs_") and source_dataset.endswith("_laws"):
+        slug = source_dataset.split("ipfs_", 1)[1].removesuffix("_laws")
+    year = ""
+    if snapshot_date and len(snapshot_date) >= 4 and snapshot_date[:4].isdigit():
+        year = snapshot_date[:4]
+    extra = extra or {}
+    rec.update(
+        citation_fields(
+            assign_citation(
+                eli=str(rec.get("eli") or extra.get("eli") or ""),
+                official_identifier=str(
+                    rec.get("official_identifier") or extra.get("official_identifier") or ""
+                ),
+                identifier=str(rec.get("identifier") or extra.get("identifier") or ""),
+                instrument_title=instrument_title,
+                article_number=article_number,
+                section_number=str(extra.get("section_number") or ""),
+                record_type=record_type,
+                jurisdiction=jurisdiction,
+                country=str(extra.get("country") or ""),
+                slug=slug,
+                year=year,
+            )
+        )
+    )
     rec["entry_cid"] = _entry_cid(rec)
     rec["title_length"] = len(title_for_bm25)
     rec["body_length"] = len(body)
@@ -433,11 +487,62 @@ def build_corpus(
 
     entries: list[dict[str, Any]] = []
 
+    def _append_law_row(instrument_id: str, parent: dict[str, Any]) -> None:
+        body = parent["body"]
+        if not body:
+            report["drops"]["empty_body"] += 1
+            if len(report["drop_samples"]["empty_body"]) < 20:
+                report["drop_samples"]["empty_body"].append(instrument_id)
+            return
+        meta = parent["metadata"]
+        entries.append(
+            _base_record(
+                record_type="law",
+                source_dataset=source_dataset,
+                source_revision=source_revision,
+                instrument_id=instrument_id,
+                instrument_title=parent["instrument_title"],
+                law_cid=parent["law_cid"],
+                article_number="",
+                article_title="",
+                body=body,
+                jurisdiction=parent["jurisdiction"],
+                language=parent["language"],
+                source_url=parent["source_url"],
+                snapshot_date=_snapshot_date(parent["row"], meta, source_meta),
+                coverage=_coverage_from(
+                    parent["row"],
+                    meta,
+                    articles_empty=articles_empty,
+                    sparse_fallback=sparse_fallback,
+                ),
+                license_expr=parent["license"],
+                collector=_collector(meta, source_dataset),
+                source_id=instrument_id,
+                extra={
+                    "eli": parent["eli"],
+                    "identifier": parent["identifier"],
+                    "official_identifier": parent["official_identifier"],
+                    "source_type": parent["source_type"],
+                    "country": parent["country"],
+                    "law_status": parent["law_status"],
+                    "parent_law_id": "",
+                    "article_id": "",
+                    **_hierarchy_fields(
+                        parent["instrument_title"], body, "", language=parent["language"]
+                    ),
+                },
+            )
+        )
+
     if sparse_fallback:
         report["schema_surprises"].append(
             f"article coverage {article_law_coverage:.4f} < 0.10 of laws; falling back to law-level units"
         )
 
+    for instrument_id, parent in law_map.items():
+        _append_law_row(instrument_id, parent)
+
     if use_articles:
         for _, row in articles.iterrows():
             source_id = _row_get(row, "id")
@@ -489,6 +594,9 @@ def build_corpus(
                         "law_status": parent["law_status"],
                         "parent_law_id": instrument_id,
                         "article_id": source_id,
+                        **_hierarchy_fields(
+                            article_title, body, article_number, language=parent["language"]
+                        ),
                     },
                 )
             )
@@ -496,44 +604,50 @@ def build_corpus(
         for instrument_id, parent in law_map.items():
             body = parent["body"]
             if not body:
-                report["drops"]["empty_body"] += 1
-                if len(report["drop_samples"]["empty_body"]) < 20:
-                    report["drop_samples"]["empty_body"].append(instrument_id)
                 continue
             meta = parent["metadata"]
-            entries.append(
-                _base_record(
-                    record_type="law",
-                    source_dataset=source_dataset,
-                    source_revision=source_revision,
-                    instrument_id=instrument_id,
-                    instrument_title=parent["instrument_title"],
-                    law_cid=parent["law_cid"],
-                    article_number="",
-                    article_title="",
-                    body=body,
-                    jurisdiction=parent["jurisdiction"],
-                    language=parent["language"],
-                    source_url=parent["source_url"],
-                    snapshot_date=_snapshot_date(parent["row"], meta, source_meta),
-                    coverage=_coverage_from(
-                        parent["row"], meta, articles_empty=True, sparse_fallback=sparse_fallback
-                    ),
-                    license_expr=parent["license"],
-                    collector=_collector(meta, source_dataset),
-                    source_id=instrument_id,
-                    extra={
-                        "eli": parent["eli"],
-                        "identifier": parent["identifier"],
-                        "official_identifier": parent["official_identifier"],
-                        "source_type": parent["source_type"],
-                        "country": parent["country"],
-                        "law_status": parent["law_status"],
-                        "parent_law_id": "",
-                        "article_id": "",
-                    },
-                )
-            )
+            units = split_structured_units(body, language=parent["language"])
+            if units:
+                report["unit"] = "structured"
+                for unit in units:
+                    entries.append(
+                        _base_record(
+                            record_type=unit.kind if unit.kind in {"article", "section"} else "article",
+                            source_dataset=source_dataset,
+                            source_revision=source_revision,
+                            instrument_id=instrument_id,
+                            instrument_title=parent["instrument_title"],
+                            law_cid=parent["law_cid"],
+                            article_number=unit.article_number or unit.number,
+                            article_title=unit.heading,
+                            body=unit.body,
+                            jurisdiction=parent["jurisdiction"],
+                            language=parent["language"],
+                            source_url=parent["source_url"],
+                            snapshot_date=_snapshot_date(parent["row"], meta, source_meta),
+                            coverage="structured (headings detected in law body)",
+                            license_expr=parent["license"],
+                            collector=_collector(meta, source_dataset),
+                            source_id=f"{instrument_id}-{unit.kind}-{unit.number}",
+                            extra={
+                                "eli": parent["eli"],
+                                "identifier": parent["identifier"],
+                                "official_identifier": parent["official_identifier"],
+                                "source_type": parent["source_type"],
+                                "country": parent["country"],
+                                "law_status": parent["law_status"],
+                                "parent_law_id": instrument_id,
+                                "article_id": "",
+                                "hierarchy_kind": unit.kind,
+                                "hierarchy_path": unit.hierarchy_path,
+                                "title_number": unit.title_number,
+                                "chapter_number": unit.chapter_number,
+                                "part_number": unit.part_number,
+                                "section_number": unit.section_number,
+                                "subsections": list(unit.subsections),
+                            },
+                        )
+                    )
 
     entries.sort(
         key=lambda r: (
@@ -564,6 +678,20 @@ def build_corpus(
         raise SchemaError("Duplicate entry_cid remained after dedupe")
     report["n_before_dedupe"] = n_before
     report["n_out"] = int(len(df))
+    if not df.empty and "record_type" in df.columns:
+        n_law_rows = int((df["record_type"] == "law").sum())
+        n_child_rows = int(df["record_type"].isin(["article", "section"]).sum())
+        report["n_law_rows"] = n_law_rows
+        report["n_child_rows"] = n_child_rows
+        report["n_instruments"] = int(df["instrument_id"].nunique()) if "instrument_id" in df.columns else n_law_rows
+        if n_law_rows and n_child_rows:
+            report["unit"] = (
+                "law+structured" if report.get("unit") == "structured" else "law+article"
+            )
+        elif n_law_rows:
+            report["unit"] = "law"
+        elif n_child_rows:
+            report["unit"] = "article"
     report["n_dropped_total"] = (
         report["drops"]["empty_body"]
         + report["drops"]["missing_instrument"]
@@ -607,5 +735,23 @@ def build_corpus(
         "empty_bodies_dropped": report["drops"]["empty_body"],
         "duplicate_cids_dropped": report["drops"]["duplicate_cid"],
     }
+    from .profiles import majority_language, score_heading_languages
+
+    sample_text = ""
+    if not df.empty and "body" in df.columns:
+        sample_text = "\n".join(str(x) for x in df["body"].head(40).tolist())
+        if "title" in df.columns:
+            sample_text = "\n".join(str(x) for x in df["title"].head(40).tolist()) + "\n" + sample_text
+    heading_langs = score_heading_languages(sample_text)
+    report["heading_language_counts"] = dict(heading_langs)
+    report["heading_language_majority"] = majority_language(heading_langs)
+    report["document_language_majority"] = None
+    if report.get("language_breakdown"):
+        report["document_language_majority"] = max(
+            report["language_breakdown"].items(), key=lambda kv: kv[1]
+        )[0]
+    from .verify import verify_normalized_corpus
+
+    report["verification"] = verify_normalized_corpus(df, report)
     df.attrs["normalization_report"] = report
     return df, report

country_laws_ir/package.py

@@ -35,8 +35,10 @@ def package_release(
     code_root: Path,
     normalization_report: dict[str, Any] | None = None,
     extra_manifest: dict[str, Any] | None = None,
+    wipe: bool = True,
+    skip_bm25_graph: bool = False,
 ) -> dict[str, Any]:
-    if out.exists():
+    if wipe and out.exists():
         shutil.rmtree(out)
     out.mkdir(parents=True, exist_ok=True)
     indexes_dir = out / "indexes"
@@ -52,78 +54,95 @@ def package_release(
     )
     write_parquet(indexes_dir / "corpus_chunks.parquet", _index_df(corpus_idx))
 
-    bm25_doc_idx = write_sharded(
-        bm25["documents"],
-        out / "data" / "bm25" / "documents",
-        "data/bm25/documents",
-        kind="bm25_documents",
-        key_col="entry_cid",
-        index_col="document_index",
-    )
-    write_parquet(indexes_dir / "bm25_document_chunks.parquet", _index_df(bm25_doc_idx))
-
-    postings = bm25["postings"]
-    posting_idx = write_sharded(
-        postings,
-        out / "data" / "bm25" / "postings",
-        "data/bm25/postings",
-        kind="bm25_postings",
-        key_col="term",
-    )
-    for row, part_start in zip(posting_idx, range(len(posting_idx))):
-        shard_df = postings.iloc[part_start * MAX_ROWS_PER_FILE : (part_start + 1) * MAX_ROWS_PER_FILE]
-        row["term_count"] = int(shard_df["term"].nunique()) if not shard_df.empty else 0
-        row["posting_count"] = int(shard_df["document_indices"].map(len).sum()) if not shard_df.empty else 0
-        row["token_instance_count"] = row["posting_count"]
-    write_parquet(indexes_dir / "bm25_keyword_shards.parquet", _index_df(posting_idx))
-
-    node_idx = write_sharded(
-        graph["nodes"],
-        out / "data" / "graph" / "nodes",
-        "data/graph/nodes",
-        kind="graph_nodes",
-        key_col="node_cid",
-    )
-    write_parquet(indexes_dir / "graph_node_chunks.parquet", _index_df(node_idx))
-
-    edge_idx = write_sharded(
-        graph["edges"],
-        out / "data" / "graph" / "edges",
-        "data/graph/edges",
-        kind="graph_edges",
-        key_col="edge_cid",
-    )
-    write_parquet(indexes_dir / "graph_edge_chunks.parquet", _index_df(edge_idx))
-
-    incoming = graph["incoming"]
-    outgoing = graph["outgoing"]
-    in_idx = write_sharded(
-        incoming if incoming is not None and not incoming.empty else pd.DataFrame(
-            columns=["node_cid", "page_index", "direction"]
-        ),
-        out / "data" / "graph" / "adjacency" / "incoming",
-        "data/graph/adjacency/incoming",
-        kind="graph_incoming_adjacency",
-        key_col="node_cid",
-    )
-    out_idx = write_sharded(
-        outgoing if outgoing is not None and not outgoing.empty else pd.DataFrame(
-            columns=["node_cid", "page_index", "direction"]
-        ),
-        out / "data" / "graph" / "adjacency" / "outgoing",
-        "data/graph/adjacency/outgoing",
-        kind="graph_outgoing_adjacency",
-        key_col="node_cid",
-    )
-    for rows, direction in ((in_idx, "incoming"), (out_idx, "outgoing")):
-        for r in rows:
-            r["direction"] = direction
-            r["adjacency_count"] = r.get("row_count", 0)
-            r["node_count"] = r.get("row_count", 0)
-            r["first_page_index"] = 0
-            r["last_page_index"] = 0
-    write_parquet(indexes_dir / "graph_incoming_adjacency.parquet", _index_df(in_idx))
-    write_parquet(indexes_dir / "graph_outgoing_adjacency.parquet", _index_df(out_idx))
+    if skip_bm25_graph:
+        bm25_doc_idx = []
+        posting_idx = []
+        postings = pd.DataFrame()
+        node_idx = []
+        edge_idx = []
+        in_idx = []
+        out_idx = []
+        incoming = pd.DataFrame()
+        outgoing = pd.DataFrame()
+        bm25 = bm25 or {"documents": pd.DataFrame(), "postings": pd.DataFrame(), "stats": {}}
+        graph = graph or {"nodes": pd.DataFrame(), "edges": pd.DataFrame(), "stats": {}}
+    else:
+        bm25_doc_idx = write_sharded(
+            bm25["documents"],
+            out / "data" / "bm25" / "documents",
+            "data/bm25/documents",
+            kind="bm25_documents",
+            key_col="entry_cid",
+            index_col="document_index",
+        )
+        write_parquet(indexes_dir / "bm25_document_chunks.parquet", _index_df(bm25_doc_idx))
+
+        postings = bm25["postings"]
+        posting_idx = write_sharded(
+            postings,
+            out / "data" / "bm25" / "postings",
+            "data/bm25/postings",
+            kind="bm25_postings",
+            key_col="term",
+        )
+        for row, part_start in zip(posting_idx, range(len(posting_idx))):
+            shard_df = postings.iloc[
+                part_start * MAX_ROWS_PER_FILE : (part_start + 1) * MAX_ROWS_PER_FILE
+            ]
+            row["term_count"] = int(shard_df["term"].nunique()) if not shard_df.empty else 0
+            row["posting_count"] = (
+                int(shard_df["document_indices"].map(len).sum()) if not shard_df.empty else 0
+            )
+            row["token_instance_count"] = row["posting_count"]
+        write_parquet(indexes_dir / "bm25_keyword_shards.parquet", _index_df(posting_idx))
+
+        node_idx = write_sharded(
+            graph["nodes"],
+            out / "data" / "graph" / "nodes",
+            "data/graph/nodes",
+            kind="graph_nodes",
+            key_col="node_cid",
+        )
+        write_parquet(indexes_dir / "graph_node_chunks.parquet", _index_df(node_idx))
+
+        edge_idx = write_sharded(
+            graph["edges"],
+            out / "data" / "graph" / "edges",
+            "data/graph/edges",
+            kind="graph_edges",
+            key_col="edge_cid",
+        )
+        write_parquet(indexes_dir / "graph_edge_chunks.parquet", _index_df(edge_idx))
+
+        incoming = graph["incoming"]
+        outgoing = graph["outgoing"]
+        in_idx = write_sharded(
+            incoming
+            if incoming is not None and not incoming.empty
+            else pd.DataFrame(columns=["node_cid", "page_index", "direction"]),
+            out / "data" / "graph" / "adjacency" / "incoming",
+            "data/graph/adjacency/incoming",
+            kind="graph_incoming_adjacency",
+            key_col="node_cid",
+        )
+        out_idx = write_sharded(
+            outgoing
+            if outgoing is not None and not outgoing.empty
+            else pd.DataFrame(columns=["node_cid", "page_index", "direction"]),
+            out / "data" / "graph" / "adjacency" / "outgoing",
+            "data/graph/adjacency/outgoing",
+            kind="graph_outgoing_adjacency",
+            key_col="node_cid",
+        )
+        for rows, direction in ((in_idx, "incoming"), (out_idx, "outgoing")):
+            for r in rows:
+                r["direction"] = direction
+                r["adjacency_count"] = r.get("row_count", 0)
+                r["node_count"] = r.get("row_count", 0)
+                r["first_page_index"] = 0
+                r["last_page_index"] = 0
+        write_parquet(indexes_dir / "graph_incoming_adjacency.parquet", _index_df(in_idx))
+        write_parquet(indexes_dir / "graph_outgoing_adjacency.parquet", _index_df(out_idx))
 
     vectors_df = vectors["vectors"]
     # Drop null embeddings for stub releases so parquet stays typed; keep rows when present.
@@ -196,8 +215,8 @@ def package_release(
         "bm25_documents": int(len(bm25["documents"])),
         "bm25_keyword_shards": len(posting_idx),
         "bm25_posting_rows": int(len(postings)),
-        "bm25_postings": int(bm25["stats"]["n_postings"]),
-        "bm25_terms": int(bm25["stats"]["n_terms"]),
+        "bm25_postings": int((bm25.get("stats") or {}).get("n_postings") or 0),
+        "bm25_terms": int((bm25.get("stats") or {}).get("n_terms") or 0),
         "corpus_chunks": len(corpus_idx),
         "corpus_rows": int(len(corpus)),
         "graph_edge_chunks": len(edge_idx),
@@ -215,9 +234,22 @@ def package_release(
         "n_laws": n_laws,
         "n_articles": n_articles,
     }
+    if skip_bm25_graph and extra_manifest and extra_manifest.get("sparse"):
+        sparse = extra_manifest["sparse"]
+        bm25_counts = (sparse.get("bm25") or {}).get("counts") or {}
+        graph_counts = sparse.get("graph") or {}
+        counts.update(
+            {k: int(v) for k, v in bm25_counts.items() if isinstance(v, (int, float))}
+        )
+        if graph_counts.get("node_count") is not None:
+            counts["graph_nodes"] = int(graph_counts["node_count"])
+        if graph_counts.get("edge_count") is not None:
+            counts["graph_edges"] = int(graph_counts["edge_count"])
 
     def idx_desc(name: str) -> dict[str, Any]:
         path = indexes_dir / name
+        if not path.is_file():
+            return {"relative_path": f"indexes/{name}", "present": False}
         return file_descriptor(path, f"indexes/{name}")
 
     hub_id = target_repo(country["slug"])
@@ -248,6 +280,7 @@ def package_release(
             "compression_level": 6,
             "max_rows_per_file": MAX_ROWS_PER_FILE,
             "row_group_size": MAX_ROWS_PER_FILE,
+            "query_engine": "duckdb",
         },
         "graph": {
             "adjacency_pointers_per_row": ADJ_POINTERS_PER_ROW,
@@ -330,9 +363,30 @@ def package_release(
     (out / "manifest.json").write_text(json.dumps(manifest, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
     _write_readme(out, country, source_meta, counts, bm25["stats"], graph["stats"], vectors["stats"], hub_id)
     _write_gitattributes(out)
+    _write_dataset_configs(out)
     return manifest
 
 
+def _write_dataset_configs(out: Path) -> None:
+    configs = {
+        "country-laws-ir-graphrag/v1": {
+            "data_files": {
+                "corpus": "data/corpus/*.parquet",
+                "bm25_documents": "data/bm25/documents/*.parquet",
+                "bm25_postings": "data/bm25/postings/*.parquet",
+                "graph_nodes": "data/graph/nodes/*.parquet",
+                "graph_edges": "data/graph/edges/*.parquet",
+                "graph_adjacency_out": "data/graph/adjacency/out/*.parquet",
+                "graph_adjacency_in": "data/graph/adjacency/in/*.parquet",
+                "vectors": "data/vectors/*.parquet",
+            }
+        }
+    }
+    (out / "dataset_configs.json").write_text(
+        json.dumps(configs, indent=2) + "\n", encoding="utf-8"
+    )
+
+
 def _write_gitattributes(out: Path) -> None:
     (out / ".gitattributes").write_text(
         "*.parquet filter=lfs diff=lfs merge=lfs -text\n"
@@ -757,6 +811,8 @@ def package_release_sequential(
 
     def idx_desc(name: str) -> dict[str, Any]:
         path = indexes_dir / name
+        if not path.is_file():
+            return {"relative_path": f"indexes/{name}", "present": False}
         return file_descriptor(path, f"indexes/{name}")
 
     manifest = {
@@ -846,6 +902,7 @@ def package_release_sequential(
     )
     _write_readme(out, country, source_meta, counts, bm25_stats, gstats, vstats, hub_id)
     _write_gitattributes(out)
+    _write_dataset_configs(out)
     checkpoint("package_seq_done")
     return manifest
 
@@ -861,13 +918,18 @@ def package_from_spill(
     expected_rows: int | None = None,
     extra_manifest: dict[str, Any] | None = None,
 ) -> dict[str, Any]:
-    """Package from spill dir artifacts: bm25_*.parquet, bm25_stats.pkl, graph.pkl, vectors.pkl."""
+    """Package from spill dir artifacts: bm25_*.parquet, bm25_stats.json, graph.pkl, vectors.pkl."""
+    import json as _json
     import pickle as _pickle
 
     spill = Path(spill)
-    stats_path = spill / "bm25_stats.pkl"
-    with stats_path.open("rb") as f:
-        bm25_stats = _pickle.load(f)
+    stats_json = spill / "bm25_stats.json"
+    stats_pkl = spill / "bm25_stats.pkl"
+    if stats_json.is_file():
+        bm25_stats = _json.loads(stats_json.read_text(encoding="utf-8"))
+    else:
+        with stats_pkl.open("rb") as f:
+            bm25_stats = _pickle.load(f)
     return package_release_sequential(
         out,
         corpus_path=Path(corpus_path),

country_laws_ir/profiles.py

@@ -0,0 +1,124 @@
+"""Per-language legal heading lexicons for country-law structure extraction.
+
+Oregon (ORS) is English title/chapter/section. Other gazettes use their own
+words (Artikel, Titre, Artículo, 条, مادة). This table is how we *score*
+whether a split used the right language — not a claim that every country
+has a dedicated parser.
+
+Languages with no lexicon (ar, zh, ja, ko, …) must not be force-split on
+Latin TITLE/ARTICLE markers; collectors may already have article rows.
+"""
+
+from __future__ import annotations
+
+from collections import Counter
+import re
+from typing import Any
+
+# keyword -> list of (kind, language); some words are shared (article).
+HEADING_LEXICON: dict[str, list[tuple[str, str]]] = {}
+
+def _add(lang: str, kind: str, *words: str) -> None:
+    for word in words:
+        HEADING_LEXICON.setdefault(word.casefold(), []).append((kind, lang))
+
+
+_add("en", "title", "title")
+_add("en", "chapter", "chapter")
+_add("en", "part", "part")
+_add("en", "article", "article")
+_add("en", "section", "section", "sec.")
+
+_add("fr", "title", "titre")
+_add("fr", "chapter", "chapitre")
+_add("fr", "part", "partie")
+_add("fr", "article", "article")
+_add("fr", "section", "section")
+
+_add("de", "title", "titel")
+_add("de", "chapter", "kapitel")
+_add("de", "part", "teil")
+_add("de", "article", "artikel")
+_add("de", "section", "abschnitt", "paragraf")
+
+_add("nl", "title", "titel")
+_add("nl", "chapter", "hoofdstuk")
+_add("nl", "part", "deel")
+_add("nl", "article", "artikel")
+_add("nl", "section", "paragraaf", "afdeling")
+
+_add("es", "title", "título", "titulo")
+_add("es", "chapter", "capítulo", "capitulo")
+_add("es", "part", "parte")
+_add("es", "article", "artículo", "articulo")
+_add("es", "section", "sección", "seccion")
+
+_add("pt", "title", "título", "titulo")
+_add("pt", "chapter", "capítulo", "capitulo")
+_add("pt", "part", "parte")
+_add("pt", "article", "artigo")
+_add("pt", "section", "secção", "secao")
+
+_add("it", "title", "titolo")
+_add("it", "chapter", "capitolo")
+_add("it", "part", "parte")
+_add("it", "article", "articolo")
+_add("it", "section", "sezione")
+
+_add("el", "article", "άρθρο", "αρθρο")
+_add("hu", "article", "szakasz")
+_add("cs", "article", "článek")
+_add("sk", "article", "článok")
+_add("sl", "article", "član")
+_add("nb", "article", "artikkel")
+_add("sv", "article", "artikel")
+_add("pl", "article", "artykuł", "artykul")
+_add("ro", "article", "articolul", "articol")
+_add("zh", "article", "条")
+_add("ar", "article", "مادة", "المادة")
+_add("ja", "article", "条")
+
+# Shared abbreviation; language left unknown.
+_add("und", "article", "art.")
+_add("und", "section", "§")
+
+# Scripts we do not Latin-split:
+NO_LATIN_SPLIT_LANGS = frozenset({"ar", "zh", "zh-cn", "zh-tw", "ja", "ko", "fa", "he", "th", "hi", "bn", "am"})
+
+_TOKEN_RE = re.compile(r"[^\W\d_]{2,}|art\.|sec\.|§", re.UNICODE)
+
+
+def classify_heading_token(token: str) -> list[tuple[str, str]]:
+    return list(HEADING_LEXICON.get(token.casefold()) or ())
+
+
+def score_heading_languages(text: str) -> Counter[str]:
+    """Count distinctive lexicon hits. Shared words like 'article' do not vote."""
+    counts: Counter[str] = Counter()
+    if not text:
+        return counts
+    for token in _TOKEN_RE.findall(text):
+        hits = classify_heading_token(token)
+        langs = {lang for _kind, lang in hits if lang != "und"}
+        if len(langs) == 1:
+            counts[next(iter(langs))] += 1
+    return counts
+
+
+def majority_language(counts: Counter[str], *, exclude: tuple[str, ...] = ("und",)) -> str | None:
+    filtered = Counter({k: v for k, v in counts.items() if k not in exclude})
+    if not filtered:
+        return None
+    lang, _n = filtered.most_common(1)[0]
+    return lang
+
+
+def iso_lang(value: Any) -> str:
+    text = str(value or "").strip().lower().replace("_", "-")
+    if not text:
+        return ""
+    return text.split("-")[0]
+
+
+def latin_split_allowed(language: str) -> bool:
+    return iso_lang(language) not in NO_LATIN_SPLIT_LANGS

country_laws_ir/query.py

@@ -42,6 +42,12 @@ class Release:
         return pd.read_parquet(path)
 
     def bm25(self, query: str, top_k: int = 10) -> list[dict]:
+        try:
+            from .duckdb_store import bm25_search
+
+            return bm25_search(self.root, query, top_k=top_k)
+        except Exception:
+            pass
         q_terms = tokenize(query)[:MAX_QUERY_TERMS]
         if not q_terms:
             return []
@@ -124,6 +130,12 @@ class Release:
         return out
 
     def neighbors(self, node_cid: str, direction: str = "both", limit: int = 25) -> list[dict]:
+        try:
+            from .duckdb_store import graph_neighbors
+
+            return graph_neighbors(self.root, node_cid, direction=direction, limit=limit)
+        except Exception:
+            pass
         dirs = ["incoming", "outgoing"] if direction == "both" else [direction]
         hits = []
         for d in dirs:
@@ -146,6 +158,11 @@ class Release:
         hits.sort(key=lambda r: (-(r["score"] or 0), r["neighbor_cid"]))
         return hits[:limit]
 
+    def cite(self, citation: str, cite_format: str = "any", limit: int = 25) -> list[dict]:
+        from .duckdb_store import cite_search
+
+        return cite_search(self.root, citation, cite_format=cite_format, limit=limit)
+
 
 def _print(rows: list[dict]) -> None:
     print(json.dumps(rows, indent=2, ensure_ascii=False))
@@ -164,15 +181,29 @@ def main(argv: list[str] | None = None) -> int:
     p_vec.add_argument("query")
     p_vec.add_argument("--top-k", type=int, default=10)
     p_vec.add_argument("--candidate-centroids", type=int, default=4)
-    p_vec.add_argument("--device", default="cpu")
+    p_vec.add_argument("--device", default="cuda")
 
     p_g = sub.add_parser("graph")
     g_sub = p_g.add_subparsers(dest="graph_cmd", required=True)
     p_n = g_sub.add_parser("neighbors")
     p_n.add_argument("node_cid")
-    p_n.add_argument("--direction", default="both", choices=["both", "incoming", "outgoing"])
+    p_n.add_argument(
+        "--direction",
+        default="both",
+        choices=["both", "in", "out", "incoming", "outgoing"],
+    )
     p_n.add_argument("--limit", type=int, default=25)
 
+    p_cite = sub.add_parser("cite")
+    p_cite.add_argument("citation")
+    p_cite.add_argument(
+        "--format",
+        dest="cite_format",
+        default="any",
+        choices=["any", "bluebook", "official"],
+    )
+    p_cite.add_argument("--limit", type=int, default=25)
+
     args = ap.parse_args(argv)
     rel = Release(Path(args.local_dir))
     if args.cmd == "bm25":
@@ -181,6 +212,8 @@ def main(argv: list[str] | None = None) -> int:
         _print(rel.vector(args.query, top_k=args.top_k, candidate_centroids=args.candidate_centroids, device=args.device))
     elif args.cmd == "graph" and args.graph_cmd == "neighbors":
         _print(rel.neighbors(args.node_cid, direction=args.direction, limit=args.limit))
+    elif args.cmd == "cite":
+        _print(rel.cite(args.citation, cite_format=args.cite_format, limit=args.limit))
     return 0
 
 

country_laws_ir/sparse.py

@@ -0,0 +1,137 @@
+"""Country-law sparse GraphRAG export through the shared HF GraphRAG builders.
+
+This is the same parquet layout used by US Code, state laws, Federal Register,
+and SkillCenter:
+
+* ``ipfs_datasets_py.retrieval.hf_graphrag.bm25.build_bm25_layout``
+* ``ipfs_datasets_py.retrieval.hf_graphrag.graph.write_graph_layout``
+
+No SQLite. Indexes are ZSTD parquet shards under ``data/bm25`` and
+``data/graph``. DuckDB queries those shards at read time.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import pandas as pd
+
+from . import EDGE_IDENTITY_SCHEMA, SCHEMA_VERSION
+from .cidutil import cid_of_json
+from .graph import build_graph
+
+
+def corpus_to_bm25_rows(corpus: pd.DataFrame) -> list[dict[str, Any]]:
+    """Project a normalized country-law corpus onto the shared BM25 row schema.
+
+    Rows with no searchable tokens are omitted. The shared
+    ``build_bm25_layout`` builder fail-closes on empty documents (same
+    admission rule as US Code / Federal Register).
+    """
+    from ipfs_datasets_py.retrieval.hf_graphrag.bm25 import tokenize_bm25_text
+
+    _MAX_TITLE = 8_192
+    _MAX_BODY = 200_000
+    rows: list[dict[str, Any]] = []
+    for rec in corpus.itertuples(index=False):
+        title = str(getattr(rec, "title", "") or "").replace("\x00", "").strip()
+        body = str(getattr(rec, "body", "") or "").replace("\x00", "").strip()
+        if len(title) > _MAX_TITLE:
+            title = title[:_MAX_TITLE].rstrip()
+        if len(body) > _MAX_BODY:
+            body = body[:_MAX_BODY].rstrip()
+        if not title and not body:
+            continue
+        if not tokenize_bm25_text(title) and not tokenize_bm25_text(body):
+            continue
+        rows.append(
+            {
+                "entry_cid": str(rec.entry_cid),
+                "title": title,
+                "body": body,
+                "record_type": str(getattr(rec, "record_type", "") or "law"),
+                "document_index": int(rec.document_index),
+            }
+        )
+    if not rows:
+        raise RuntimeError("no corpus rows had searchable BM25 tokens")
+    for i, row in enumerate(rows):
+        row["document_index"] = i
+    return rows
+
+
+def _graph_nodes_and_edges(corpus: pd.DataFrame) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
+    """Structural graph only (no precomputed BM25 neighbor matrix)."""
+    built = build_graph(corpus, [[] for _ in range(len(corpus))])
+    nodes = [
+        {
+            "node_cid": str(row["node_cid"]),
+            "node_type": str(row["node_type"]),
+            "label": row.get("label"),
+            "entry_cid": row.get("entry_cid") or None,
+        }
+        for row in built["nodes"].to_dict("records")
+    ]
+    edges = []
+    for row in built["edges"].to_dict("records"):
+        source = str(row.get("source_cid") or row.get("source_node_cid") or "")
+        target = str(row.get("target_cid") or row.get("target_node_cid") or "")
+        edge_type = str(row.get("edge_type") or "")
+        if not source or not target or not edge_type:
+            continue
+        edge_cid = str(row.get("edge_cid") or "") or cid_of_json(
+            {
+                "edge_type": edge_type,
+                "schema": EDGE_IDENTITY_SCHEMA,
+                "source": source,
+                "target": target,
+            }
+        )
+        edges.append(
+            {
+                "edge_cid": edge_cid,
+                "edge_type": edge_type,
+                "source_node_cid": source,
+                "target_node_cid": target,
+                "retrieval_method": str(row.get("retrieval_method") or "structural"),
+                "score": row.get("score"),
+            }
+        )
+    return nodes, edges
+
+
+def export_sparse_graphrag(
+    corpus: pd.DataFrame,
+    output_dir: Path,
+) -> dict[str, Any]:
+    """Write BM25 + graph parquet shards using the shared HF GraphRAG builders."""
+    from ipfs_datasets_py.retrieval.hf_graphrag.bm25 import (
+        BM25LayoutConfig,
+        build_bm25_layout,
+    )
+    from ipfs_datasets_py.retrieval.hf_graphrag.graph import write_graph_layout
+
+    output_dir = Path(output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    rows = corpus_to_bm25_rows(corpus)
+    bm25 = build_bm25_layout(
+        rows,
+        output_dir,
+        config=BM25LayoutConfig(max_documents=max(len(rows), 1)),
+    )
+    nodes, edges = _graph_nodes_and_edges(corpus)
+    written = write_graph_layout(nodes, edges, output_dir)
+    layout = written.layout
+    return {
+        "engine": "hf_graphrag",
+        "schema_version": SCHEMA_VERSION,
+        "bm25": bm25.to_manifest_fragment(),
+        "graph": {
+            "node_count": int(layout.node_count),
+            "edge_count": int(layout.edge_count),
+            "adjacency": "data/graph/adjacency/{out,in}/*.parquet",
+        },
+        "sqlite": False,
+        "query_engine": "duckdb",
+    }

country_laws_ir/spill.py

@@ -1,17 +1,15 @@
-"""Disk-spill helpers for large country IR builds (SQLite FTS neighbors + BM25 TF).
+"""Disk-spill helpers for large country IR builds (DuckDB + parquet).
 
 Design (CoS / DO OOM lesson):
 - Embeddings: checkpointed .npy via vectors.encode_corpus (unchanged).
-- Neighbors for n >= SQLITE_THRESHOLD (40k): SQLite FTS5 title-only MATCH streaming
-  into neighbor_*.pkl shards under cache/<slug>_bm25_spill/ — never hold full
-  neighbor matrix in RAM during streaming.
-- BM25 TF: stream tokenize → SQLite WITHOUT ROWID → posting parquet parts.
-- Package: use package.package_release_sequential / package_from_spill so corpus,
-  bm25, graph, vectors are never all resident together; neighbor edges can be
-  streamed from shards into graph then spilled as graph.pkl.
-
-Resume-safe: existing FTS DB / neighbor shards / bm25_*.parquet are reused when
-row counts match.
+- Neighbors for n >= DUCKDB_THRESHOLD (40k): DuckDB FTS over corpus parquet,
+  streamed into neighbor_*.parquet shards — never hold the full neighbor
+  matrix in RAM.
+- BM25 TF: stream tokenize → DuckDB → posting parquet parts.
+- Package: sequential parquet write so corpus, bm25, graph, vectors are never
+  all resident together.
+
+No SQLite. Intermediate and published artifacts are parquet / DuckDB.
 """
 from __future__ import annotations
 
@@ -19,7 +17,6 @@ import gc
 import json
 import math
 import pickle
-import sqlite3
 from collections import defaultdict
 from pathlib import Path
 from typing import Any, Callable, Iterable, Iterator
@@ -41,7 +38,8 @@ from .graph import _adjacency, _edge, build_graph
 from .mem import MemAbort, checkpoint, log_mem
 from .tokenize import tokenize
 
-SQLITE_THRESHOLD = 40_000
+DUCKDB_THRESHOLD = 40_000
+SQLITE_THRESHOLD = DUCKDB_THRESHOLD  # backward-compatible alias; not SQLite
 BATCH = 256
 NEIGHBOR_SHARD = 5_000
 NEIGHBOR_K = 8
@@ -68,19 +66,24 @@ def load_pickle(path: Path) -> Any:
         return pickle.load(f)
 
 
-def quote_fts_term(term: str) -> str:
-    return '"' + term.replace('"', '""') + '"'
-
-
 def _idf(n_docs: int, df: int) -> float:
     return math.log((n_docs - df + 0.5) / (df + 0.5) + 1.0)
 
 
-def sqlite_ready(db_path: Path, expected: int) -> bool:
+def _require_duckdb():
+    try:
+        import duckdb  # type: ignore
+    except ImportError as exc:
+        raise RuntimeError("duckdb is required for sparse GraphRAG spill (no sqlite)") from exc
+    return duckdb
+
+
+def duckdb_ready(db_path: Path, expected: int) -> bool:
     if not db_path.is_file():
         return False
+    duckdb = _require_duckdb()
     try:
-        conn = sqlite3.connect(f"file:{db_path}?mode=ro", uri=True)
+        conn = duckdb.connect(str(db_path), read_only=True)
         n = int(conn.execute("SELECT COUNT(*) FROM documents").fetchone()[0])
         conn.close()
         return n == expected
@@ -88,265 +91,49 @@ def sqlite_ready(db_path: Path, expected: int) -> bool:
         return False
 
 
-def build_sqlite_fts(
-    corpus_path: Path,
-    db_path: Path,
-    expected: int,
-    *,
-    batch: int = BATCH,
-    log: Callable[[str], None] | None = None,
-) -> int:
-    """Contentless FTS5 over title+body; documents table holds query_text."""
-    if db_path.exists():
-        db_path.unlink()
-    db_path.parent.mkdir(parents=True, exist_ok=True)
-    conn = sqlite3.connect(str(db_path))
-    try:
-        conn.executescript(
-            """
-            PRAGMA journal_mode = OFF;
-            PRAGMA synchronous = OFF;
-            PRAGMA temp_store = MEMORY;
-            PRAGMA locking_mode = EXCLUSIVE;
-            PRAGMA page_size = 32768;
-            CREATE TABLE documents (
-                document_index INTEGER PRIMARY KEY,
-                entry_cid TEXT NOT NULL UNIQUE,
-                title TEXT NOT NULL,
-                query_text TEXT NOT NULL
-            );
-            CREATE VIRTUAL TABLE documents_fts USING fts5(
-                title,
-                body,
-                content='',
-                columnsize=1,
-                tokenize='unicode61 remove_diacritics 2'
-            );
-            """
-        )
-        pf = pq.ParquetFile(corpus_path)
-        n = 0
-        meta_batch: list[tuple] = []
-        fts_batch: list[tuple] = []
-        conn.execute("BEGIN")
-        for batch_tbl in pf.iter_batches(
-            batch_size=batch, columns=["document_index", "entry_cid", "title", "body"]
-        ):
-            cols = batch_tbl.to_pydict()
-            for i in range(len(cols["document_index"])):
-                di = int(cols["document_index"][i])
-                title = str(cols["title"][i] or "")
-                body = str(cols["body"][i] or "")
-                cid = str(cols["entry_cid"][i])
-                qtext = title.strip() if title.strip() else body[:800]
-                meta_batch.append((di, cid, title, qtext))
-                fts_batch.append((di + 1, title, body))
-                if len(meta_batch) >= batch:
-                    conn.executemany(
-                        "INSERT INTO documents(document_index, entry_cid, title, query_text) "
-                        "VALUES (?,?,?,?)",
-                        meta_batch,
-                    )
-                    conn.executemany(
-                        "INSERT INTO documents_fts(rowid, title, body) VALUES (?,?,?)",
-                        fts_batch,
-                    )
-                    n += len(meta_batch)
-                    meta_batch.clear()
-                    fts_batch.clear()
-                    if n % 20_000 == 0:
-                        checkpoint(f"fts_insert@{n}", row=n, every_n=20_000, log=log)
-                        gc.collect()
-        if meta_batch:
-            conn.executemany(
-                "INSERT INTO documents(document_index, entry_cid, title, query_text) "
-                "VALUES (?,?,?,?)",
-                meta_batch,
-            )
-            conn.executemany(
-                "INSERT INTO documents_fts(rowid, title, body) VALUES (?,?,?)",
-                fts_batch,
-            )
-            n += len(meta_batch)
-        conn.commit()
-        conn.execute("INSERT INTO documents_fts(documents_fts) VALUES('optimize')")
-        conn.commit()
-        conn.execute(
-            "CREATE VIRTUAL TABLE documents_vocab USING fts5vocab(documents_fts, 'row')"
-        )
-        conn.commit()
-        got = int(conn.execute("SELECT COUNT(*) FROM documents").fetchone()[0])
-        assert got == n == expected, (got, n, expected)
-        return n
-    except Exception:
-        conn.rollback()
-        raise
-    finally:
-        conn.close()
-        gc.collect()
+def build_sqlite_fts(*args, **kwargs):  # pragma: no cover - removed
+    raise RuntimeError("SQLite FTS is removed; use DuckDB parquet neighbors")
 
 
-def load_df_map(conn: sqlite3.Connection, df_cap: int = DF_CAP) -> dict[str, int]:
-    df_map: dict[str, int] = {}
-    for term, doc in conn.execute(
-        "SELECT term, doc FROM documents_vocab WHERE doc <= ?", (df_cap,)
-    ):
-        df_map[str(term)] = int(doc)
-    return df_map
-
-
-def select_query_terms(query_text: str, df_map: dict[str, int]) -> list[str]:
-    toks = tokenize(query_text)[:24]
-    seen: set[str] = set()
-    cands: list[tuple[int, str]] = []
-    for t in toks:
-        if t in seen or len(t) < 2:
-            continue
-        seen.add(t)
-        if t not in df_map:
-            continue
-        cands.append((df_map[t], t))
-    cands.sort()
-    return [t for _, t in cands[:MAX_QTERMS]]
-
-
-def stream_neighbors_to_shards(
-    db_path: Path,
+def neighbors_via_duckdb(
+    corpus_path: Path,
     spill: Path,
     n_docs: int,
     *,
     k: int = NEIGHBOR_K,
-    shard: int = NEIGHBOR_SHARD,
-    batch: int = BATCH,
-    df_cap: int = DF_CAP,
     resume: bool = True,
     log: Callable[[str], None] | None = None,
 ) -> list[Path]:
-    """Stream FTS5 title-only neighbors into neighbor_START_END.pkl shards.
+    """DuckDB FTS over corpus parquet → neighbor_*.parquet shards. No SQLite."""
+    from .duckdb_store import build_fts_index, stream_neighbors_to_parquet
 
-    Does not assemble the full neighbor list. Resume skips shards already on disk
-    whose end index is covered (contiguous from 0).
-    """
+    spill = Path(spill)
     spill.mkdir(parents=True, exist_ok=True)
-    existing = sorted(spill.glob("neighbors_*.pkl"))
-    buf_start = 0
-    shard_paths: list[Path] = []
-    if resume and existing:
-        # Contiguous cover from 0
-        covered = 0
-        for sp in existing:
-            parts = sp.stem.split("_")
-            # neighbors_000000_005000
-            try:
-                start_i, end_i = int(parts[1]), int(parts[2])
-            except (IndexError, ValueError):
-                continue
-            if start_i != covered:
-                break
-            shard_paths.append(sp)
-            covered = end_i
-        buf_start = covered
-        if buf_start >= n_docs:
-            if log:
-                log(f"neighbors resume complete {buf_start}/{n_docs}")
-            return shard_paths
+    db_path = spill / "neighbors.duckdb"
+    if not duckdb_ready(db_path, n_docs):
+        if db_path.exists():
+            db_path.unlink()
         if log:
-            log(f"neighbors resume from {buf_start}/{n_docs} shards={len(shard_paths)}")
-        # Drop non-contiguous leftover shards beyond covered
-        for sp in existing:
-            if sp not in shard_paths:
-                sp.unlink(missing_ok=True)
+            log(f"building duckdb fts n={n_docs} -> {db_path}")
+        build_fts_index(corpus_path, db_path, n_docs, log=log)
     else:
-        for sp in existing:
-            sp.unlink(missing_ok=True)
-
-    conn_rw = sqlite3.connect(str(db_path))
-    row = conn_rw.execute(
-        "SELECT name FROM sqlite_master WHERE name='documents_vocab'"
-    ).fetchone()
-    if row is None:
-        conn_rw.execute(
-            "CREATE VIRTUAL TABLE documents_vocab USING fts5vocab(documents_fts, 'row')"
-        )
-        conn_rw.commit()
-    df_map = load_df_map(conn_rw, df_cap)
-    conn_rw.close()
-    spill_pickle(spill / "df_map_meta.pkl", {"n_rare": len(df_map), "df_cap": df_cap})
-    if log:
-        log(f"vocab rare_terms={len(df_map)} df_cap={df_cap}")
-
-    conn = sqlite3.connect(f"file:{db_path}?mode=ro", uri=True)
-    conn.row_factory = sqlite3.Row
-    buf: list = []
-    done = buf_start
-    score_sql = f"-bm25(documents_fts, {TITLE_W}, {BODY_W})"
-    last_idx = buf_start - 1
-    try:
-        while True:
-            rows = conn.execute(
-                "SELECT document_index, entry_cid, query_text FROM documents "
-                "WHERE document_index > ? ORDER BY document_index LIMIT ?",
-                (last_idx, batch),
-            ).fetchall()
-            if not rows:
-                break
-            for row in rows:
-                di = int(row["document_index"])
-                terms = select_query_terms(str(row["query_text"]), df_map)
-                if not terms:
-                    neigh: list = []
-                else:
-                    expr = " OR ".join("title : " + quote_fts_term(t) for t in terms)
-                    sql = (
-                        "SELECT d.document_index, " + score_sql + " AS score "
-                        "FROM documents_fts "
-                        "JOIN documents AS d ON d.document_index = documents_fts.rowid - 1 "
-                        "WHERE documents_fts MATCH ? AND d.document_index != ? "
-                        "ORDER BY score DESC, d.document_index LIMIT ?"
-                    )
-                    hits = conn.execute(sql, (expr, di, k)).fetchall()
-                    neigh = [
-                        (int(h["document_index"]), max(0.0, float(h["score"])), list(terms)[:4])
-                        for h in hits
-                    ]
-                while buf_start + len(buf) < di:
-                    buf.append([])
-                buf.append(neigh)
-                last_idx = di
-                done += 1
-                if len(buf) >= shard:
-                    end = buf_start + len(buf)
-                    sp = spill / f"neighbors_{buf_start:06d}_{end:06d}.pkl"
-                    spill_pickle(sp, buf)
-                    shard_paths.append(sp)
-                    checkpoint(
-                        f"neighbors_shard_{buf_start}_{end}",
-                        log=log,
-                    )
-                    buf_start = end
-                    buf = []
-                    gc.collect()
-                if done % 5_000 == 0:
-                    checkpoint(f"neighbors_stream", row=done, every_n=5_000, log=log)
-        if buf:
-            end = buf_start + len(buf)
-            sp = spill / f"neighbors_{buf_start:06d}_{end:06d}.pkl"
-            spill_pickle(sp, buf)
-            shard_paths.append(sp)
-            if log:
-                log(f"neighbors shard final {buf_start}:{end}/{n_docs}")
         if log:
-            log(f"bm25 neighbors streamed done={done} n_docs={n_docs} shards={len(shard_paths)}")
-        return shard_paths
-    finally:
-        conn.close()
-        del df_map
-        gc.collect()
+            log(f"reusing duckdb fts n={n_docs} path={db_path}")
+    return stream_neighbors_to_parquet(
+        db_path, spill, n_docs, k=k, resume=resume, log=log
+    )
 
 
 def iter_neighbor_shards(spill: Path) -> Iterator[tuple[int, list]]:
-    """Yield (start_index, shard_list) without loading all shards."""
-    paths = sorted(spill.glob("neighbors_*.pkl"))
+    """Yield (start_index, shard_list) from parquet neighbor shards."""
+    from .duckdb_store import iter_neighbor_parquet_shards
+
+    parquet = list(Path(spill).glob("neighbors_*.parquet"))
+    if parquet:
+        yield from iter_neighbor_parquet_shards(spill)
+        return
+    # Legacy pickle shards (pre-DuckDB). Do not create new ones.
+    paths = sorted(Path(spill).glob("neighbors_*.pkl"))
     for sp in paths:
         parts = sp.stem.split("_")
         start_i = int(parts[1])
@@ -369,30 +156,9 @@ def assemble_neighbors_streaming(spill: Path, n_docs: int) -> list:
     return neighbors
 
 
-def neighbors_via_sqlite(
-    corpus_path: Path,
-    spill: Path,
-    n_docs: int,
-    *,
-    k: int = NEIGHBOR_K,
-    resume: bool = True,
-    log: Callable[[str], None] | None = None,
-) -> list[Path]:
-    """Ensure FTS DB + neighbor shards; return shard paths (not full list)."""
-    spill.mkdir(parents=True, exist_ok=True)
-    db_path = spill / "fts.sqlite"
-    if not sqlite_ready(db_path, n_docs):
-        if db_path.exists():
-            db_path.unlink()
-        if log:
-            log(f"building sqlite fts n={n_docs} -> {db_path}")
-        build_sqlite_fts(corpus_path, db_path, n_docs, log=log)
-    else:
-        if log:
-            log(f"reusing sqlite fts n={n_docs} path={db_path}")
-    return stream_neighbors_to_shards(
-        db_path, spill, n_docs, k=k, resume=resume, log=log
-    )
+def neighbors_via_sqlite(*args, **kwargs):
+    """Removed. Sparse GraphRAG neighbors are DuckDB/parquet only."""
+    return neighbors_via_duckdb(*args, **kwargs)
 
 
 def build_graph_from_neighbor_shards(
@@ -492,33 +258,35 @@ def build_bm25_tf_spill(
     batch: int = 512,
     log: Callable[[str], None] | None = None,
 ) -> dict[str, Any]:
-    """Stream tokenize corpus → SQLite TF → bm25_documents/postings parquet + stats.
+    """Stream tokenize corpus → DuckDB TF → bm25_documents/postings parquet + stats.
 
-    Resume: if bm25_documents.parquet + bm25_postings.parquet + bm25_stats.pkl exist
+    Resume: if bm25_documents.parquet + bm25_postings.parquet + bm25_stats.json exist
     with matching n_docs, reuse.
     """
     spill.mkdir(parents=True, exist_ok=True)
     docs_path = spill / "bm25_documents.parquet"
     post_path = spill / "bm25_postings.parquet"
+    stats_json = spill / "bm25_stats.json"
     stats_path = spill / "bm25_stats.pkl"
-    if docs_path.is_file() and post_path.is_file() and stats_path.is_file():
-        stats = load_pickle(stats_path)
-        if int(stats.get("n_docs", -1)) == n_docs:
+    if docs_path.is_file() and post_path.is_file():
+        stats = None
+        if stats_json.is_file():
+            stats = json.loads(stats_json.read_text(encoding="utf-8"))
+        elif stats_path.is_file():
+            stats = load_pickle(stats_path)
+        if stats is not None and int(stats.get("n_docs", -1)) == n_docs:
             if log:
                 log(f"reusing bm25 spill n_docs={n_docs}")
             return {"stats": stats, "documents": docs_path, "postings": post_path}
 
-    bm25_sql = spill / "bm25_tf.sqlite"
-    if bm25_sql.exists():
-        bm25_sql.unlink()
-    conn = sqlite3.connect(str(bm25_sql))
-    conn.execute("PRAGMA journal_mode=OFF")
-    conn.execute("PRAGMA synchronous=OFF")
-    conn.execute("PRAGMA temp_store=MEMORY")
-    conn.execute("PRAGMA locking_mode=EXCLUSIVE")
+    duckdb = _require_duckdb()
+    bm25_db = spill / "bm25_tf.duckdb"
+    if bm25_db.exists():
+        bm25_db.unlink()
+    conn = duckdb.connect(str(bm25_db))
     conn.execute(
-        "CREATE TABLE tf (term TEXT NOT NULL, doc INTEGER NOT NULL, "
-        "ttf INTEGER NOT NULL, btf INTEGER NOT NULL, PRIMARY KEY(term, doc)) WITHOUT ROWID"
+        "CREATE TABLE tf (term VARCHAR NOT NULL, doc INTEGER NOT NULL, "
+        "ttf INTEGER NOT NULL, btf INTEGER NOT NULL)"
     )
     title_len = np.zeros(n_docs, dtype=np.int32)
     body_len = np.zeros(n_docs, dtype=np.int32)
@@ -549,7 +317,6 @@ def build_bm25_tf_spill(
     ]
     processed = 0
     batch_rows: list[tuple] = []
-    conn.execute("BEGIN")
     for batch_tbl in pf.iter_batches(batch_size=batch, columns=cols):
         d = batch_tbl.to_pydict()
         m = len(d["document_index"])
@@ -593,9 +360,7 @@ def build_bm25_tf_spill(
                 }
             )
             if len(batch_rows) >= 20_000:
-                conn.executemany(
-                    "INSERT OR REPLACE INTO tf VALUES (?,?,?,?)", batch_rows
-                )
+                conn.executemany("INSERT INTO tf VALUES (?, ?, ?, ?)", batch_rows)
                 batch_rows.clear()
         processed += m
         if len(meta_buf) >= 20_000:
@@ -612,7 +377,7 @@ def build_bm25_tf_spill(
             checkpoint(f"bm25_tf_tokenize", row=processed, every_n=20_000, log=log)
             gc.collect()
     if batch_rows:
-        conn.executemany("INSERT OR REPLACE INTO tf VALUES (?,?,?,?)", batch_rows)
+        conn.executemany("INSERT INTO tf VALUES (?, ?, ?, ?)", batch_rows)
         batch_rows.clear()
     if meta_buf:
         dfm = pd.DataFrame(meta_buf)
@@ -623,9 +388,8 @@ def build_bm25_tf_spill(
         dfm.to_parquet(meta_path, index=False)
         del dfm
         meta_buf.clear()
-    conn.commit()
     if log:
-        log("bm25 tf spilled; writing documents")
+        log("bm25 tf spilled to duckdb; writing documents")
 
     doc_len = (title_len * TITLE_WEIGHT + body_len * BODY_WEIGHT).astype(np.float64)
     avgdl = float(doc_len.mean()) if n_docs else 0.0
@@ -696,7 +460,7 @@ def build_bm25_tf_spill(
 
     for term, doc, ttf, btf in conn.execute(
         "SELECT term, doc, ttf, btf FROM tf ORDER BY term, doc"
-    ):
+    ).fetchall():
         term = str(term)
         if cur_term is None:
             cur_term = term
@@ -749,9 +513,9 @@ def build_bm25_tf_spill(
         "n_posting_rows": int(out_rows),
         "n_postings": int(n_postings),
     }
-    spill_pickle(stats_path, stats)
+    stats_json.write_text(json.dumps(stats, indent=2) + "\n", encoding="utf-8")
     try:
-        bm25_sql.unlink()
+        bm25_db.unlink()
     except Exception:
         pass
     if log:
@@ -759,5 +523,10 @@ def build_bm25_tf_spill(
     return {"stats": stats, "documents": docs_path, "postings": post_path}
 
 
-def should_use_sqlite(n_docs: int, threshold: int = SQLITE_THRESHOLD) -> bool:
+def should_use_spill(n_docs: int, threshold: int = DUCKDB_THRESHOLD) -> bool:
     return n_docs >= threshold
+
+
+def should_use_sqlite(n_docs: int, threshold: int = DUCKDB_THRESHOLD) -> bool:
+    """Alias: large-corpus path is DuckDB/parquet, not SQLite."""
+    return should_use_spill(n_docs, threshold)

country_laws_ir/structure.py

@@ -0,0 +1,305 @@
+"""Extract legal hierarchy from country-law text (Oregon-style, multilingual).
+
+Oregon Revised Statutes are stored as title / chapter / section / subsection
+trees. National gazettes are not that uniform: some use Article/Artikel,
+some §, some only a single instrument body.
+
+This module:
+
+* strips leftover HTML chrome so GraphRAG sees legal text, not tags;
+* detects multilingual heading markers (title/chapter/part/article/section);
+* splits an instrument into those units when at least two headings exist;
+* otherwise keeps the whole instrument (never invents a hierarchy).
+
+Subsection markers such as ``(a)`` / ``(1)`` are recorded on the parent
+unit; they are not forced into their own retrieval rows.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from html.parser import HTMLParser
+import html as html_lib
+import re
+import unicodedata
+from typing import Any
+
+_WS_RE = re.compile(r"\s+", re.UNICODE)
+_HAS_TAG_RE = re.compile(r"</?[a-zA-Z][^>]*>")
+
+# Line-anchored headings. Numbers may be arabic, roman, or dotted (1.2).
+_HEADING_RE = re.compile(
+    r"(?im)^[ \t]*(?:"
+    r"(?P<title>TITLE|TITRE|TITEL|T[IÍ]TULO|TITOLO|T[IÍ]TUL)\s+"
+    r"(?P<title_n>[0-9IVXLCDM]+[A-Za-z0-9.\-]*)"
+    r"|(?P<chapter>CHAPTER|CHAPITRE|KAPITEL|CAP[IÍ]TULO|CAPITOLO|HOOFDSTUK|CAP\.)\s+"
+    r"(?P<chapter_n>[0-9IVXLCDM]+[A-Za-z0-9.\-]*)"
+    r"|(?P<part>PART|PARTIE|TEIL|PARTE|DEEL)\s+"
+    r"(?P<part_n>[0-9IVXLCDM]+[A-Za-z0-9.\-]*)"
+    r"|(?P<article>ART(?:ICLE|IKEL|ÍCULO|IGO|ICOLO|IKKEL)?\.?|ART\."
+    r"|ČLÁNEK|ČLÁNOK|ČLAN|SZAKASZ|ΆΡΘΡΟ|ΑΡΘΡΟ)\s+"
+    r"(?P<article_n>[0-9IVXLCDMΑ-Ω]+[A-Za-zΑ-Ωa-z0-9.\-]*)"
+    r"|(?P<section>SECTION|SECCI[OÓ]N|SEZIONE|ABSCHNITT|SEC\.)\s+"
+    r"(?P<section_n>[0-9A-Za-z.\-]+)"
+    r"|(?P<section_sym>§+)\s*(?P<section_sym_n>[0-9A-Za-z.\-]+)"
+    r")"
+    r"(?P<rest>[^\n]{0,200})?"
+)
+
+_SUBSECTION_RE = re.compile(r"\(([0-9A-Za-z]{1,6})\)")
+
+_KIND_RANK = {
+    "title": 1,
+    "chapter": 2,
+    "part": 3,
+    "article": 4,
+    "section": 5,
+    "subsection": 6,
+}
+
+MIN_SPLIT_HEADINGS = 2
+MIN_UNIT_CHARS = 40
+
+_ZH_ART_RE = re.compile(
+    r"(?:(?<=\n)|^)[ 　]*"
+    r"(第[一二三四五六七八九十百千万零〇两0-9]+条(?:之[一二三四五六七八九十百0-9]+)?)"
+)
+_AR_ART_RE = re.compile(
+    r"(?:(?<=\n)|^)[ \t]*(المادة|مادة)\s*([0-9٠-٩]+)"
+)
+_JA_ART_RE = re.compile(
+    r"(?:(?<=\n)|^)[ 　]*(第[0-9一二三四五六七八九十百]+条)"
+)
+
+
+class _HTMLText(HTMLParser):
+    SKIP = {"script", "style", "noscript", "svg", "nav", "footer", "header"}
+
+    def __init__(self) -> None:
+        super().__init__(convert_charrefs=True)
+        self.parts: list[str] = []
+        self.skip = 0
+
+    def handle_starttag(self, tag, attrs):
+        if tag in self.SKIP:
+            self.skip += 1
+        if tag in {"br", "p", "tr", "div", "li", "h1", "h2", "h3"} and self.skip == 0:
+            self.parts.append("\n")
+
+    def handle_endtag(self, tag):
+        if tag in self.SKIP and self.skip:
+            self.skip -= 1
+        if tag in {"p", "div", "li", "tr"} and self.skip == 0:
+            self.parts.append("\n")
+
+    def handle_data(self, data):
+        if self.skip == 0:
+            self.parts.append(data)
+
+
+def has_html_tags(text: str) -> bool:
+    return bool(text and _HAS_TAG_RE.search(text))
+
+
+def strip_html(raw: str) -> str:
+    """Turn leftover HTML into visible legal text. No-op if there are no tags."""
+    if not raw or not _HAS_TAG_RE.search(raw):
+        return raw
+    parser = _HTMLText()
+    try:
+        parser.feed(raw)
+        parser.close()
+        text = "".join(parser.parts)
+    except Exception:
+        text = re.sub(r"(?is)<script.*?>.*?</script>", " ", raw)
+        text = re.sub(r"(?is)<style.*?>.*?</style>", " ", text)
+        text = re.sub(r"(?is)<[^>]+>", " ", text)
+    text = html_lib.unescape(text).replace("\xa0", " ")
+    text = re.sub(r"[ \t]+", " ", text)
+    text = re.sub(r"\n[ \t]+", "\n", text)
+    text = re.sub(r"\n{3,}", "\n\n", text)
+    return text.strip()
+
+
+def normalize_legal_text(value: Any) -> str:
+    """NFKC + HTML strip. Keeps newlines so heading detection still works."""
+    if value is None:
+        return ""
+    text = unicodedata.normalize("NFKC", str(value))
+    text = strip_html(text)
+    text = text.replace("\xa0", " ")
+    text = re.sub(r"[ \t]+", " ", text)
+    text = re.sub(r"\n[ \t]+", "\n", text)
+    text = re.sub(r"\n{3,}", "\n\n", text)
+    return text.strip()
+
+
+@dataclass
+class StructureUnit:
+    kind: str
+    number: str
+    heading: str
+    body: str
+    title_number: str = ""
+    chapter_number: str = ""
+    part_number: str = ""
+    article_number: str = ""
+    section_number: str = ""
+    subsections: tuple[str, ...] = ()
+    hierarchy_path: str = ""
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "kind": self.kind,
+            "number": self.number,
+            "heading": self.heading,
+            "body": self.body,
+            "title_number": self.title_number,
+            "chapter_number": self.chapter_number,
+            "part_number": self.part_number,
+            "article_number": self.article_number,
+            "section_number": self.section_number,
+            "subsections": list(self.subsections),
+            "hierarchy_path": self.hierarchy_path,
+        }
+
+
+def _cursor_path(cursor: dict[str, str]) -> str:
+    parts = []
+    for key, label in (
+        ("title", "Title"),
+        ("chapter", "Chapter"),
+        ("part", "Part"),
+        ("article", "Article"),
+        ("section", "Section"),
+    ):
+        value = cursor.get(key) or ""
+        if value:
+            parts.append(f"{label} {value}")
+    return " > ".join(parts)
+
+
+def _subsection_tokens(text: str) -> tuple[str, ...]:
+    seen: list[str] = []
+    for match in _SUBSECTION_RE.finditer(text):
+        token = match.group(1)
+        if token not in seen:
+            seen.append(token)
+        if len(seen) >= 40:
+            break
+    return tuple(seen)
+
+
+def _units_from_regex(
+    text: str, matches: list[re.Match[str]], *, kind: str, lang: str
+) -> list[StructureUnit]:
+    if len(matches) < MIN_SPLIT_HEADINGS:
+        return []
+    units: list[StructureUnit] = []
+    for i, match in enumerate(matches):
+        start = match.start()
+        end = matches[i + 1].start() if i + 1 < len(matches) else len(text)
+        chunk = text[start:end].strip()
+        if len(chunk) < 16:
+            continue
+        number = re.sub(r"\s+", "", match.group(0))
+        heading = re.sub(r"\s+", " ", chunk.split("\n", 1)[0])[:240]
+        units.append(
+            StructureUnit(
+                kind=kind,
+                number=number,
+                heading=heading,
+                body=chunk,
+                article_number=number,
+                hierarchy_path=heading,
+            )
+        )
+    return units if len(units) >= MIN_SPLIT_HEADINGS else []
+
+
+def split_script_units(text: str, language: str) -> list[StructureUnit]:
+    """Article splits for scripts that must not use Latin TITLE/ARTICLE."""
+    from .profiles import iso_lang
+
+    lang = iso_lang(language)
+    if lang in {"zh", "zh-cn", "zh-tw"}:
+        prepared = re.sub(
+            r"(第[一二三四五六七八九十百千万零〇两0-9]+条(?:之[一二三四五六七八九十百0-9]+)?)",
+            r"\n\1",
+            text,
+        )
+        return _units_from_regex(prepared, list(_ZH_ART_RE.finditer(prepared)), kind="article", lang="zh")
+    if lang in {"ar", "fa"}:
+        prepared = re.sub(r"(المادة|مادة)", r"\n\1", text)
+        return _units_from_regex(prepared, list(_AR_ART_RE.finditer(prepared)), kind="article", lang="ar")
+    if lang == "ja":
+        prepared = re.sub(r"(第[0-9一二三四五六七八九十百]+条)", r"\n\1", text)
+        return _units_from_regex(prepared, list(_JA_ART_RE.finditer(prepared)), kind="article", lang="ja")
+    return []
+
+
+def split_structured_units(text: str, *, language: str = "") -> list[StructureUnit]:
+    """Split *text* on legal headings. Empty list means keep the whole instrument.
+
+    Latin TITLE/ARTICLE splits are skipped for languages in
+    ``profiles.NO_LATIN_SPLIT_LANGS`` so Arabic/Chinese bodies are not
+    carved up on incidental English words.
+    """
+    from .profiles import latin_split_allowed
+
+    if not text or len(text) < 16:
+        return []
+    if language and not latin_split_allowed(language):
+        return split_script_units(text, language)
+    matches = list(_HEADING_RE.finditer(text))
+    if len(matches) < MIN_SPLIT_HEADINGS:
+        return []
+    cursor = {"title": "", "chapter": "", "part": "", "article": "", "section": ""}
+    units: list[StructureUnit] = []
+    for i, match in enumerate(matches):
+        start = match.start()
+        end = matches[i + 1].start() if i + 1 < len(matches) else len(text)
+        chunk = text[start:end].strip()
+        kind = ""
+        number = ""
+        for name in ("title", "chapter", "part", "article", "section"):
+            if match.group(name):
+                kind = name
+                number = (match.group(f"{name}_n") or "").strip()
+                break
+        if match.group("section_sym"):
+            kind = "section"
+            number = (match.group("section_sym_n") or "").strip()
+        if not kind or not number:
+            continue
+        cursor[kind] = number
+        for lower, rank in _KIND_RANK.items():
+            if rank > _KIND_RANK[kind]:
+                cursor[lower] = ""
+        if len(chunk) < MIN_UNIT_CHARS:
+            continue
+        rest = (match.group("rest") or "").strip(" .-:")
+        heading = re.sub(r"\s+", " ", match.group(0)).strip()
+        if rest and rest not in heading:
+            heading = f"{heading} {rest}".strip()
+        units.append(
+            StructureUnit(
+                kind=kind,
+                number=number,
+                heading=heading[:240],
+                body=chunk,
+                title_number=cursor["title"],
+                chapter_number=cursor["chapter"],
+                part_number=cursor["part"],
+                article_number=cursor["article"],
+                section_number=cursor["section"],
+                subsections=_subsection_tokens(chunk),
+                hierarchy_path=_cursor_path(cursor),
+            )
+        )
+    retrieval = [u for u in units if u.kind in {"article", "section"}]
+    if len(retrieval) >= MIN_SPLIT_HEADINGS:
+        return retrieval
+    if len(units) >= MIN_SPLIT_HEADINGS:
+        return units
+    return []

country_laws_ir/upload.py

@@ -57,11 +57,24 @@ def upload_release(
     if not (local_dir / "manifest.json").is_file():
         raise UploadError(f"release is missing manifest.json: {local_dir}")
 
-    from ipfs_datasets_py.huggingface.protected_repo_guard import (
-        require_unprotected_or_runtime,
-    )
+    # Fail closed for LCR-protected repos without importing the full package
+    # (site-packages ipfs_datasets_py can be stale and break this thin packager).
+    _protected = {"justicedao/ipfs_state_laws", "justicedao/ipfs_federal_register"}
+    if repo_id in _protected:
+        raise UploadError(
+            f"{repo_id} is a protected JusticeDAO repository; "
+            "mutate it only through legal_corpora_publication_runtime"
+        )
+    try:
+        from ipfs_datasets_py.huggingface.protected_repo_guard import (
+            require_unprotected_or_runtime,
+        )
 
-    require_unprotected_or_runtime(repo_id, method="upload_folder")
+        require_unprotected_or_runtime(repo_id, method="upload_folder")
+    except UploadError:
+        raise
+    except Exception:
+        pass
 
     resolved = (token or "").strip() or _token_from_env()
     if not resolved:

country_laws_ir/vectors.py

@@ -14,7 +14,11 @@ import pandas as pd
 from . import MAX_ROWS_PER_FILE, SCHEMA_VERSION
 
 MODEL_NAME = "thenlper/gte-small"
+MODEL_REVISION = "17e1f347d17fe144873b1201da91788898c639cd"
 DIMENSION = 384
+MAX_SEQ_LENGTH = 512
+DEFAULT_DEVICE = "cuda"
+SUPPORTED_DEVICES = frozenset({"cpu", "cuda", "cuda:0", "mps", "auto"})
 MAX_ROWS_PER_CENTROID = 8192
 MAX_SHARDS_PER_CENTROID = 2
 
@@ -24,41 +28,108 @@ def _l2_normalize(x: np.ndarray, eps: float = 1e-12) -> np.ndarray:
     return x / np.maximum(n, eps)
 
 
-def embeddings_available() -> bool:
+def device_is_available(device: str) -> bool:
+    """Probe accelerator availability without loading a model."""
+    name = str(device or "").strip().lower()
+    if not name or name == "cpu":
+        return True
+    try:
+        import torch
+    except Exception:
+        return False
+    if name.startswith("cuda"):
+        return bool(
+            getattr(torch, "cuda", None)
+            and torch.backends.cuda.is_built()
+            and torch.cuda.is_available()
+        )
+    if name == "mps":
+        mps = getattr(getattr(torch, "backends", None), "mps", None)
+        return bool(mps is not None and mps.is_available())
+    return False
+
+
+def select_device(requested: str = DEFAULT_DEVICE) -> tuple[str, bool]:
+    """Prefer CUDA like US Code / Open US Law; fall back to CPU."""
+    req = str(requested or DEFAULT_DEVICE).strip().lower() or DEFAULT_DEVICE
+    if req == "auto":
+        req = "cuda"
+    if req not in SUPPORTED_DEVICES and not req.startswith("cuda:"):
+        raise ValueError(f"unsupported embedding device: {requested!r}")
+    if device_is_available(req):
+        return req, False
+    return "cpu", True
+
+
+def ensure_embedding_stack() -> bool:
+    """Lazy-import / lazy-install transformers + sentence-transformers.
+
+    Matches ``ipfs_datasets_py.auto_installer.ensure_module`` used by other
+    GraphRAG producers. Importing this module must not pip-install; first
+    encode may.
+    """
+    import os
+
+    os.environ.setdefault("TRANSFORMERS_NO_TORCHVISION", "1")
     try:
-        import torch  # noqa: F401
-        from sentence_transformers import SentenceTransformer  # noqa: F401
+        import sentence_transformers  # noqa: F401
+        import transformers  # noqa: F401
 
         return True
+    except Exception:
+        pass
+    try:
+        from ipfs_datasets_py.auto_installer import ensure_module, install_for_component
+
+        install_for_component("graphrag")
+        ensure_module("torchvision", "torchvision")
+        ensure_module("transformers", "transformers")
+        module = ensure_module("sentence_transformers", "sentence-transformers")
+        return module is not None
     except Exception:
         return False
 
 
+def embeddings_available() -> bool:
+    return ensure_embedding_stack()
+
+
+def _is_real_vector(vec: object) -> bool:
+    try:
+        arr = np.asarray(vec, dtype=np.float32).reshape(-1)
+    except Exception:
+        return False
+    if arr.shape[0] != DIMENSION:
+        return False
+    if not np.isfinite(arr).all():
+        return False
+    return float(np.linalg.norm(arr)) > 1e-6
+
+
 def encode_corpus(
     corpus: pd.DataFrame,
     batch_size: int = 64,
-    device: str = "cpu",
+    device: str = DEFAULT_DEVICE,
     checkpoint_path: str | None = None,
     chunk_size: int = 4096,
 ) -> np.ndarray:
-    """Encode corpus texts with gte-small in chunks; persist checkpoints when given."""
+    """Encode corpus texts with pinned gte-small on CUDA when available."""
     import json
     import os
     from datetime import datetime, timezone
     from pathlib import Path as _Path
 
+    if not ensure_embedding_stack():
+        raise RuntimeError(
+            "sentence-transformers is required for production GTE embeddings; "
+            "lazy install failed (python -m ipfs_datasets_py.auto_installer)"
+        )
     from sentence_transformers import SentenceTransformer
 
     from .auth import configure_hf
 
     configure_hf()
-    cache_root = _Path(os.environ.get("COUNTRY_LAWS_IR_ROOT", str(_Path.home() / ".ipfs_datasets" / "country-laws-ir"))) / "cache" / "hf"
-    os.environ.setdefault("HF_HOME", str(cache_root))
-    os.environ.setdefault("HF_HUB_DISABLE_IMPLICIT_TOKEN", "1")
-    os.environ.setdefault(
-        "SENTENCE_TRANSFORMERS_HOME",
-        str(cache_root / "sentence-transformers"),
-    )
+    device, _fallback = select_device(device)
     texts = []
     for rec in corpus.itertuples(index=False):
         title = getattr(rec, "title", None) or getattr(rec, "instrument_title", "") or ""
@@ -70,12 +141,22 @@ def encode_corpus(
     done = 0
     ckpt = _Path(checkpoint_path) if checkpoint_path else None
     meta_path = ckpt.with_suffix(".json") if ckpt else None
-    meta_n = None
+    cache_root = _Path(
+        os.environ.get(
+            "COUNTRY_LAWS_IR_ROOT",
+            str(_Path.home() / ".ipfs_datasets" / "country-laws-ir"),
+        )
+    ) / "cache" / "hf"
+    os.environ.setdefault("HF_HOME", str(cache_root))
+    os.environ.setdefault("HF_HUB_DISABLE_IMPLICIT_TOKEN", "1")
+    os.environ.setdefault("SENTENCE_TRANSFORMERS_HOME", str(cache_root / "sentence-transformers"))
     if meta_path is not None and meta_path.exists():
         try:
             meta_n = json.loads(meta_path.read_text(encoding="utf-8")).get("n")
         except Exception:
             meta_n = None
+    else:
+        meta_n = None
     if ckpt is not None and ckpt.exists():
         cached = np.load(ckpt)
         same_corpus = meta_n is None or int(meta_n) == n
@@ -87,56 +168,76 @@ def encode_corpus(
         ):
             done = int(cached.shape[0])
             out[:done] = cached.astype(np.float32, copy=False)
-            print(f"embeddings resume {done}/{n} from {ckpt}", flush=True)
-        else:
-            print(
-                f"embeddings checkpoint shape {getattr(cached, 'shape', None)} "
-                f"meta_n={meta_n} incompatible with {(n, DIMENSION)}; restarting",
-                flush=True,
+        if done >= n:
+            return out
+
+    lock_fh = None
+    if device.startswith("cuda"):
+        import fcntl
+
+        lock_path = _Path(
+            os.environ.get(
+                "COUNTRY_LAWS_IR_ROOT",
+                str(_Path.home() / ".ipfs_datasets" / "country-laws-ir"),
             )
-    if done >= n:
-        return out
-    model = SentenceTransformer(MODEL_NAME, device=device)
-    while done < n:
-        j = min(done + int(chunk_size), n)
-        chunk = model.encode(
-            texts[done:j],
-            batch_size=batch_size,
-            show_progress_bar=True,
-            convert_to_numpy=True,
-            normalize_embeddings=True,
+        ) / "cuda.encode.lock"
+        lock_path.parent.mkdir(parents=True, exist_ok=True)
+        lock_fh = open(lock_path, "a", encoding="utf-8")
+        fcntl.flock(lock_fh.fileno(), fcntl.LOCK_EX)
+    try:
+        model = SentenceTransformer(
+            MODEL_NAME,
+            revision=MODEL_REVISION,
+            device=device,
         )
-        out[done:j] = np.asarray(chunk, dtype=np.float32)
-        done = j
-        print(f"embeddings checkpoint {done}/{n}", flush=True)
         try:
-            from .mem import checkpoint as _mem_checkpoint
-            _mem_checkpoint(f"embeddings@{done}", row=done, every_n=max(chunk_size, 4096))
-        except Exception as _mem_exc:
-            # MemAbort should propagate; other import issues are non-fatal
-            from .mem import MemAbort
-            if isinstance(_mem_exc, MemAbort):
-                raise
-        if ckpt is not None:
-            ckpt.parent.mkdir(parents=True, exist_ok=True)
-            tmp = ckpt.with_name(ckpt.name + ".tmp.npy")
-            np.save(tmp, out[:done])
-            tmp.replace(ckpt)
-            if meta_path is not None:
-                meta_path.write_text(
-                    json.dumps(
-                        {
-                            "n": n,
-                            "done": done,
-                            "dimension": DIMENSION,
-                            "model_name": MODEL_NAME,
-                            "ts": datetime.now(timezone.utc).isoformat(),
-                        }
+            model.max_seq_length = MAX_SEQ_LENGTH
+        except Exception:
+            pass
+        while done < n:
+            j = min(done + int(chunk_size), n)
+            chunk = model.encode(
+                texts[done:j],
+                batch_size=batch_size,
+                show_progress_bar=True,
+                convert_to_numpy=True,
+                normalize_embeddings=True,
+            )
+            out[done:j] = np.asarray(chunk, dtype=np.float32)
+            done = j
+            if ckpt is not None:
+                ckpt.parent.mkdir(parents=True, exist_ok=True)
+                tmp = ckpt.with_name(ckpt.name + ".tmp.npy")
+                np.save(tmp, out[:done])
+                tmp.replace(ckpt)
+                if meta_path is not None:
+                    meta_path.write_text(
+                        json.dumps(
+                            {
+                                "n": n,
+                                "done": done,
+                                "dimension": DIMENSION,
+                                "model_name": MODEL_NAME,
+                                "ts": datetime.now(timezone.utc).isoformat(),
+                            }
+                        )
+                        + "\n",
+                        encoding="utf-8",
                     )
-                    + "\n",
-                    encoding="utf-8",
-                )
-    return out
+        return out
+    finally:
+        if lock_fh is not None:
+            import fcntl as _fcntl
+
+            _fcntl.flock(lock_fh.fileno(), _fcntl.LOCK_UN)
+            lock_fh.close()
+        try:
+            import torch as _torch
+
+            if _torch.cuda.is_available():
+                _torch.cuda.empty_cache()
+        except Exception:
+            pass
 
 
 def _spherical_kmeans(x: np.ndarray, k: int, iters: int = 12, seed: int = 0) -> np.ndarray:
@@ -345,14 +446,14 @@ def assemble_embeddings(
     *,
     encode_missing: bool = True,
     batch_size: int = 64,
-    device: str = "cpu",
+    device: str = DEFAULT_DEVICE,
     checkpoint_path: str | None = None,
 ) -> tuple[np.ndarray, dict[str, Any]]:
-    """Align a (n, 384) matrix to *corpus* row order, reusing unchanged CIDs.
+    """Align a (n, 384) matrix to *corpus* row order.
 
-    Positional checkpoints are unsafe when scrapes append pages. Identity is
-    ``entry_cid``. Missing CIDs are encoded only when ``encode_missing`` is true
-    and sentence-transformers is available.
+    Reuse is CID-keyed and only accepts real GTE vectors (finite, 384-d,
+    non-zero). Stub/zero priors are treated as missing and re-encoded on
+    CUDA when available — the US Code / Open US Law contract.
     """
     n = int(len(corpus))
     out = np.zeros((n, DIMENSION), dtype=np.float32)
@@ -362,18 +463,10 @@ def assemble_embeddings(
     cids = corpus["entry_cid"].astype(str).tolist() if n else []
     for i, cid in enumerate(cids):
         vec = prior.get(cid)
-        if vec is None:
-            missing_idx.append(i)
-            continue
-        try:
-            arr = np.asarray(vec, dtype=np.float32).reshape(-1)
-        except Exception:
-            missing_idx.append(i)
-            continue
-        if arr.shape[0] != DIMENSION:
+        if not _is_real_vector(vec):
             missing_idx.append(i)
             continue
-        out[i] = arr
+        out[i] = np.asarray(vec, dtype=np.float32).reshape(-1)
         reused_idx.append(i)
 
     report: dict[str, Any] = {
@@ -382,25 +475,29 @@ def assemble_embeddings(
         "n_encoded": 0,
         "n_missing": len(missing_idx),
         "model_name": MODEL_NAME,
+        "model_revision": MODEL_REVISION,
         "dimension": DIMENSION,
         "status": "reused" if not missing_idx else "partial",
     }
+    resolved, fallback = select_device(device)
+    report["device"] = resolved
+    report["device_fallback"] = fallback
     if not missing_idx:
         report["status"] = "reused"
         return _l2_normalize(out) if n else out, report
     if not encode_missing:
         report["status"] = "incomplete"
         return out, report
-    if not embeddings_available():
+    if not ensure_embedding_stack():
         report["status"] = "stub_missing_encoder"
-        report["reason"] = "sentence-transformers/torch unavailable"
+        report["reason"] = "sentence-transformers/transformers lazy install failed"
         return out, report
 
     missing = corpus.iloc[missing_idx].reset_index(drop=True)
     encoded = encode_corpus(
         missing,
         batch_size=batch_size,
-        device=device,
+        device=resolved,
         checkpoint_path=checkpoint_path,
     )
     for local_i, corpus_i in enumerate(missing_idx):

country_laws_ir/verify.py

@@ -0,0 +1,308 @@
+"""Admission verifiers for country-law normalization, before GraphRAG.
+
+Oregon-style structure is preferred but not required for every gazette.
+Verifiers fail closed on invented text, residual HTML, empty corpora, and
+duplicate CIDs. Missing title/section hierarchy is a warning unless the
+corpus already split into articles.
+"""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+import re
+from typing import Any
+
+import pandas as pd
+
+from .structure import has_html_tags
+
+SCHEMA_VERSION = "country-laws-normalize-verify/v1"
+
+_HTML_FAIL_FRACTION = 0.02
+_SHORT_BODY_FAIL_FRACTION = 0.50
+_MIN_BODY_CHARS = 40
+
+
+@dataclass(frozen=True)
+class Check:
+    id: str
+    severity: str  # fail | warn
+    passed: bool
+    message: str
+    evidence: dict[str, Any]
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+def _bodies(corpus: pd.DataFrame) -> list[str]:
+    if corpus is None or corpus.empty or "body" not in corpus.columns:
+        return []
+    return [str(x or "") for x in corpus["body"].tolist()]
+
+
+def check_nonempty(corpus: pd.DataFrame, report: dict[str, Any]) -> Check:
+    n = int(len(corpus)) if corpus is not None else 0
+    return Check(
+        id="nonempty_corpus",
+        severity="fail",
+        passed=n > 0,
+        message="normalized corpus has rows" if n else "normalized corpus is empty",
+        evidence={"n_out": n, "n_dropped": report.get("n_dropped_total")},
+    )
+
+
+def check_entry_cids(corpus: pd.DataFrame, report: dict[str, Any]) -> Check:
+    if corpus is None or corpus.empty:
+        return Check(
+            id="entry_cid_unique",
+            severity="fail",
+            passed=False,
+            message="no entry_cid values to verify",
+            evidence={},
+        )
+    missing = int(corpus["entry_cid"].isna().sum()) if "entry_cid" in corpus.columns else int(len(corpus))
+    dupes = int(corpus["entry_cid"].duplicated().sum()) if "entry_cid" in corpus.columns else 0
+    empty = int((corpus["entry_cid"].astype(str).str.strip() == "").sum()) if "entry_cid" in corpus.columns else 0
+    ok = missing == 0 and dupes == 0 and empty == 0
+    return Check(
+        id="entry_cid_unique",
+        severity="fail",
+        passed=ok,
+        message="every row has a unique entry_cid" if ok else "missing or duplicate entry_cid",
+        evidence={"missing": missing, "empty": empty, "duplicate": dupes},
+    )
+
+
+def check_no_invented_text(report: dict[str, Any]) -> Check:
+    flag = bool(report.get("never_invented_legal_text", False))
+    return Check(
+        id="never_invented_legal_text",
+        severity="fail",
+        passed=flag,
+        message="normalizer did not invent legal text" if flag else "invented-text flag is false",
+        evidence={"never_invented_legal_text": flag},
+    )
+
+
+def check_html_residual(corpus: pd.DataFrame) -> Check:
+    bodies = _bodies(corpus)
+    tagged = [b for b in bodies if has_html_tags(b)]
+    n = len(bodies) or 1
+    fraction = len(tagged) / float(n)
+    passed = fraction <= _HTML_FAIL_FRACTION
+    return Check(
+        id="html_residual",
+        severity="fail",
+        passed=passed,
+        message=(
+            "HTML tags stripped from legal bodies"
+            if passed
+            else f"{len(tagged)}/{len(bodies)} bodies still contain HTML tags"
+        ),
+        evidence={
+            "n_bodies": len(bodies),
+            "n_with_tags": len(tagged),
+            "fraction": fraction,
+            "samples": [b[:120] for b in tagged[:5]],
+        },
+    )
+
+
+def check_short_bodies(corpus: pd.DataFrame) -> Check:
+    bodies = _bodies(corpus)
+    if not bodies:
+        return Check(
+            id="short_bodies",
+            severity="fail",
+            passed=False,
+            message="no bodies to measure",
+            evidence={},
+        )
+    short = sum(1 for b in bodies if len(b) < _MIN_BODY_CHARS)
+    fraction = short / float(len(bodies))
+    passed = fraction <= _SHORT_BODY_FAIL_FRACTION
+    return Check(
+        id="short_bodies",
+        severity="fail" if not passed else "warn",
+        passed=passed,
+        message=(
+            "most legal units have usable body length"
+            if passed
+            else f"{short}/{len(bodies)} bodies shorter than {_MIN_BODY_CHARS} characters"
+        ),
+        evidence={"n_short": short, "n_bodies": len(bodies), "fraction": fraction},
+    )
+
+
+def check_heading_language(corpus: pd.DataFrame, report: dict[str, Any]) -> Check:
+    """Warn when Latin heading dialect disagrees with the document language."""
+    from .profiles import NO_LATIN_SPLIT_LANGS, iso_lang
+
+    doc_lang = iso_lang(report.get("document_language_majority") or "")
+    head_lang = iso_lang(report.get("heading_language_majority") or "")
+    counts = report.get("heading_language_counts") or {}
+    if (
+        doc_lang in NO_LATIN_SPLIT_LANGS
+        and report.get("unit") == "structured"
+        and head_lang
+        and head_lang not in NO_LATIN_SPLIT_LANGS
+        and head_lang != doc_lang
+    ):
+        return Check(
+            id="heading_language",
+            severity="fail",
+            passed=False,
+            message=(
+                f"document language {doc_lang} was split with Latin headings ({head_lang}); "
+                "use script-specific article markers or collector article rows"
+            ),
+            evidence={"document_language": doc_lang, "heading_counts": counts, "unit": report.get("unit")},
+        )
+    if doc_lang and head_lang and doc_lang != head_lang and sum(counts.values()) >= 8:
+        return Check(
+            id="heading_language",
+            severity="warn",
+            passed=True,
+            message=(
+                f"heading lexicon majority is {head_lang} but documents are {doc_lang}; "
+                "review samples before trusting structure"
+            ),
+            evidence={
+                "document_language": doc_lang,
+                "heading_language": head_lang,
+                "heading_counts": counts,
+            },
+        )
+    return Check(
+        id="heading_language",
+        severity="warn",
+        passed=True,
+        message=(
+            f"heading lexicon {head_lang or 'none'} vs document language {doc_lang or 'unknown'}"
+        ),
+        evidence={
+            "document_language": doc_lang,
+            "heading_language": head_lang,
+            "heading_counts": counts,
+        },
+    )
+
+
+def check_parent_laws(corpus: pd.DataFrame, report: dict[str, Any]) -> Check:
+    """Fail if source had instruments but GraphRAG corpus has no law rows."""
+    n_in = int(report.get("n_laws_in") or 0)
+    n_law_rows = 0
+    if corpus is not None and not corpus.empty and "record_type" in corpus.columns:
+        n_law_rows = int((corpus["record_type"] == "law").sum())
+    n_law_rows = int(report.get("n_law_rows") or n_law_rows)
+    if n_in > 0 and n_law_rows == 0:
+        return Check(
+            id="parent_laws",
+            severity="fail",
+            passed=False,
+            message=(
+                f"source has {n_in} laws but corpus has 0 law rows "
+                "(articles were indexed without parent instruments)"
+            ),
+            evidence={"n_laws_in": n_in, "n_law_rows": n_law_rows},
+        )
+    return Check(
+        id="parent_laws",
+        severity="warn",
+        passed=True,
+        message=f"parent instruments present ({n_law_rows} law rows from {n_in} source laws)",
+        evidence={"n_laws_in": n_in, "n_law_rows": n_law_rows},
+    )
+
+
+def check_structure(corpus: pd.DataFrame, report: dict[str, Any]) -> Check:
+    unit = str(report.get("unit") or "")
+    n = int(len(corpus)) if corpus is not None else 0
+    structured_rows = 0
+    if corpus is not None and not corpus.empty:
+        if "hierarchy_path" in corpus.columns:
+            structured_rows = int((corpus["hierarchy_path"].fillna("").astype(str).str.len() > 0).sum())
+        if "record_type" in corpus.columns:
+            structured_rows = max(
+                structured_rows,
+                int(corpus["record_type"].isin(["article", "section"]).sum()),
+            )
+    coverage = structured_rows / float(n) if n else 0.0
+    # Article or structured units are success. Pure law-level is a warning, not a fail:
+    # many gazettes have no title/section markers.
+    if unit in {"article", "structured", "law+article", "law+structured"} or coverage >= 0.5:
+        return Check(
+            id="legal_structure",
+            severity="warn",
+            passed=True,
+            message=f"retrieval units are structured ({unit}, coverage={coverage:.2f})",
+            evidence={"unit": unit, "structured_rows": structured_rows, "coverage": coverage},
+        )
+    return Check(
+        id="legal_structure",
+        severity="warn",
+        passed=True,
+        message=(
+            "kept whole-instrument units; no title/article/section headings detected "
+            "(expected for some gazettes)"
+        ),
+        evidence={"unit": unit, "structured_rows": structured_rows, "coverage": coverage},
+    )
+
+
+def verify_normalized_corpus(
+    corpus: pd.DataFrame,
+    report: dict[str, Any],
+    *,
+    slug: str = "",
+) -> dict[str, Any]:
+    """Run all normalization verifiers. Fail-closed on any failed `fail` check."""
+    checks = [
+        check_nonempty(corpus, report),
+        check_entry_cids(corpus, report),
+        check_no_invented_text(report),
+        check_html_residual(corpus),
+        check_short_bodies(corpus),
+        check_parent_laws(corpus, report),
+        check_structure(corpus, report),
+        check_heading_language(corpus, report),
+    ]
+    failed = [c for c in checks if c.severity == "fail" and not c.passed]
+    admitted = not failed
+    return {
+        "schema_version": SCHEMA_VERSION,
+        "slug": slug,
+        "admitted": admitted,
+        "n_checks": len(checks),
+        "n_failed": len(failed),
+        "failed_ids": [c.id for c in failed],
+        "checks": [c.to_dict() for c in checks],
+        "blocks_graphrag": not admitted,
+    }
+
+
+class NormalizationAdmissionError(RuntimeError):
+    """Raised when verifiers refuse to send a corpus to GraphRAG."""
+
+
+def verify_source(source: str) -> dict[str, Any]:
+    """Load a Hub/local pack, normalize, and run verifiers (no GraphRAG)."""
+    from .build import CACHE
+    from .catalog import get_country
+    from .normalize import build_corpus, load_source
+
+    country = get_country(source)
+    local = country.get("local_source_dir")
+    laws, articles, source_meta = load_source(local or country["repo"], CACHE)
+    corpus, report = build_corpus(laws, articles, source_meta)
+    verdict = verify_normalized_corpus(corpus, report, slug=country["slug"])
+    report["verification"] = verdict
+    return {
+        "slug": country["slug"],
+        "source": country["repo"],
+        "n_out": report.get("n_out"),
+        "unit": report.get("unit"),
+        "verification": verdict,
+        "drops": report.get("drops"),
+    }

data/bm25/documents/part-000000.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:ddc27cf60e7ff5c9b7b78450966e4698eb4136ccd79c0cb5ccf6f515f537005a
-size 451105
+oid sha256:0dc41163937cde4a93321e0e5df77756142777482a0f709dc3eaf9bc0e6ec6e9
+size 532963

data/bm25/documents/part-000001.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:d3996e91bff66c2ef2eedb89afe8933888fe844b7802b79eb871b7d770c18dfd
-size 461383
+oid sha256:e84061eda1f5fa8e83132e3f82377f606dfe5f482b4ec304d7fc9efcdba39399
+size 537560

data/bm25/documents/part-000002.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:30c79af6a1121c3da3f89727bb68609c66ed1c149fcc0f4893b1648d346b44cb
-size 460825
+oid sha256:5601dc98b5138f3ca6931e03aa7edbbbe374b2518a0b4fbbba1720acd48b3afc
+size 536067

data/bm25/documents/part-000003.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:023de8104a66a9a2a1ec334e1a5f713fe891106b960a2cc1aa0f1ad58dd5d03e
-size 473552
+oid sha256:1562a0fdeeb8e976ab8bb02c8bb4289b053cc781ae01466df003a3ab2f4e94e5
+size 541085

data/bm25/documents/part-000004.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:b68237756a89cbe50c64ed6aca473543077ee249a522f49bb2cf3457ebf2d282
-size 484942
+oid sha256:e5c7a4ca4eafd900757d5183243d8224fceeeabc3966187c25e5678c36ad1cb3
+size 542027

data/bm25/documents/part-000005.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9a045d6ec658dc169fd49514983e9bf6ee11f1e6e77b9208e741266b7f9fe999
-size 496379
+oid sha256:e6ab066f3ede378909422d24b4ceb3816cba05621601ec6914e40a6681dbd487
+size 537490

data/bm25/documents/part-000006.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:c41ecee2e94535b8e3ba324ff9779f23d1fccafbd539e5f97781a5fc46e3d9ec
-size 468285
+oid sha256:f61d33bd30fa8d1b254806b1f57a06c5c78a4e25ea322ff14dd7a69c2b368dc0
+size 536486

data/bm25/documents/part-000007.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:beea2433a0715929227d0a67c01f4e0566a4c328810e6ef3b019c899ccbfcb25
-size 495985
+oid sha256:e68f87922afea7d07c20737fbc5fc496382cfef07c31d069e0b720fd35710148
+size 547801

data/bm25/documents/part-000008.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:77a91d74c5f4a38abc59d14fbd41294e0152ae73cc542abc2c38a19c43323380
-size 479015
+oid sha256:a2b1a8bf822d87a0c8aa1c1f80112b690bad9f16a18c0ea371edc98fb14e6615
+size 540182

data/bm25/documents/part-000009.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:0a82a8f3f26cd43afe4aadb036d49d800c61ff2feca51848317b87d119a7e80e
-size 496783
+oid sha256:e308cecbcef83df0f0e05391d9ebe02fb7d7643c118610fcb5f33f8562efae74
+size 542535

data/bm25/documents/part-000010.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:70c910f746fb5640c2609e1dcbf1c294f109fad5a0ac060f1a0e17be59227830
-size 105168
+oid sha256:913cff9304da74abcf1ccf8852064a3c39a9d7c7786ebed9f9bb96de6a7601a9
+size 246128

data/bm25/postings/part-000000.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a4124550c2e111c49b10008585bf9d24df3d1a91851391157d97c9a6b8ffb827
-size 1222323
+oid sha256:9865fc7c12c577bd22b2c2f349e5425f0c716926327914cb3e2de32de30e98fa
+size 557563

data/bm25/postings/part-000001.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:1df2bac375dc9832f813d02619d38926a5ff9927bc5df40c3d0118c245ebef17
-size 2405725
+oid sha256:b51bfca4594df61a9801d108a861da331d4611447e4a45ecf2687b19d651cda4
+size 422841

data/bm25/postings/part-000002.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:646f555f512048ea34505f9683eef297939a801e49ef0f24b9ca0c48f692140d
-size 1487561
+oid sha256:1fd223410a4368b6685eea55dae43b0f488741052d69d063c35ac79308b6aed4
+size 1190336

data/bm25/postings/part-000003.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:93dfefe2a3795778bb50ef156c8f39ece1b3b255b8315d4b792532c5ad4ba948
-size 1904550
+oid sha256:51ed00a483e5dcab39ece240d3eb0f0c3ab42a62b6feb10a8ce755fd8db089eb
+size 1424844

data/bm25/postings/part-000004.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:b76f3ea9d6f7adf941567f26604459f65f27d9245de3e6279862f54a31043568
-size 1748160
+oid sha256:67d10b0460ef24764539eee3dc6c66712237669218bf8b97d1e4f18df5fd21e3
+size 1121795

data/bm25/postings/part-000005.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:94f51d8036326f670f48138492a9e8c39c5d9c5d02c6cec44f7949c86fe192aa
-size 2216972
+oid sha256:3881ac6afc655231fc7b9b9e1fbc9bdcc01134f6a0f3abe45abc6153635a6764
+size 1439664

data/bm25/postings/part-000006.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:10287dcdef574ef86da501280843c884690688b8a568b4a560d363dd01a13776
-size 1841552
+oid sha256:d541ed9097bf6cc07151f02a2b212cbd1dbe030831705bcf39c5280a5d9ed36f
+size 1145449

data/bm25/postings/part-000007.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:c6f615775240e804c4cd3c7c0cadfb5ed149fab00a7d60827a3e0b5b70299d25
-size 2092282
+oid sha256:f4d78dcaf638e8b6dd551cbad6dc76f7864b43ff584eb6a6a77258f7cbc1abec
+size 1246221

data/bm25/postings/part-000008.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:cde9f9bfd55881adbc4d7d0e3cf370365766acbed68720d41a00daf2160532d4
-size 390940
+oid sha256:d0eabcf01ca7989d7e1bbe9ad7a7b11bf5bf3feedbe660bdec01903287eddb56
+size 1438385

data/bm25/postings/part-000009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d34b6025f2c8027a126c145fbb822d55678a98ce530502791104b6de714d4b87
+size 1198068

data/bm25/postings/part-000010.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:11769fb214752511de7af16dc394c89ff04d8f219b481d9663a25b280d9029e8
+size 1432381

data/bm25/postings/part-000011.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:814f101d7ad8bbc5b1e65b06cad5ef4242154d8d2c195e7f481682a03a6544d9
+size 816305

data/corpus/part-000000.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:33286717482c778977e60a395b393a8437aaab3345a0419aa33519e6c526f1cf
-size 1593578
+oid sha256:28a5c4233e55e00a8525d5a8851d4bc32c7028a13d7d3da2a5bb713f551ccb12
+size 2191725

data/corpus/part-000001.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:60e71e71805bc53c0755fd5c499fa07f24c5f421a9eaf8523f6e4a0f76ae8c3d
-size 1443517
+oid sha256:4dd46ced87eef5566a73ef985fc5447dd7c23430fd7e7f35c8ea8c9b1a88b776
+size 1785264

data/corpus/part-000002.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:c33121e812a144cee8914376ad5ec0004cc73a616faaab4358df0cf4cbf7a8b4
-size 1479175
+oid sha256:ac696fdf8a2591d5b180faad496f4ead4817e21f09be6dbb5e7c0258a83c1efa
+size 1839553

data/corpus/part-000003.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:e18d76f7c96d34f2e8c4f07843a6deab83bf6ec7cd56452c46871a42b8e515a5
-size 1577610
+oid sha256:e863c055474c5a6a9125d11756269d03d6358f645a55a70ef57114c6e8f5c4c6
+size 2161756

data/corpus/part-000004.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:ee22357f649f507f367ed986aaeec445cbff6cf40c55fc6603f82d3bdb0a5db0
-size 1485810
+oid sha256:528577a2cfb11d4cd18f1cdfc5b00bfd50ba66e7429174a03dc1296c026a9c75
+size 1827819

data/corpus/part-000005.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:42f8b80e11d4bc7ed18bb9d829e427b11ed79a39bfa81e88e30a9b338ccf8074
-size 1492495
+oid sha256:4d3e23b5080a9eaee0b40e2eb7ce91c5e3c4b6c52e1851f63a5d03d0e180bc3e
+size 2194002

data/corpus/part-000006.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:1bb4031a432cd3c712c6a708ca2857458ff6098fa8eac7686876274e2b63bda0
-size 1458743
+oid sha256:9e8ebb7a064dfc9faaf10c5c1124c25b8e2a45b1bb44f49490058bee50599e9b
+size 1787207

data/corpus/part-000007.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:09147ee33bb088d9c06e272e2183a84cf0067c1188aad0f31031a4107ca7fa32
-size 1515342
+oid sha256:2ead41e938ac9d612d39d31857b6b871c7bfc1d29dfbb6c19159f42741db0623
+size 1847623

data/corpus/part-000008.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:843fd07a09a47b24668f666a0050310b66e69e326cfc514ad6c07264908ce47b
-size 1467706
+oid sha256:6eff3a7c223ab77726b62d9ae1c31f1613b1bd705fd77e05ca633bb3718888fe
+size 1785444