Add files using upload-large-folder tool

README.md

@@ -1,3 +1,132 @@
-# justicedao/ipfs_kenya_laws_ir
+---
+license: other
+task_categories:
+- text-retrieval
+tags:
+- legal
+- law
+- graphrag
+- bm25
+- research
+- not-legal-advice
+- kenya
+pretty_name: Kenya laws IR (CID-keyed GraphRAG)
+configs:
+- config_name: corpus
+  data_files:
+  - split: train
+    path: data/corpus/*.parquet
+- config_name: bm25_documents
+  data_files:
+  - split: train
+    path: data/bm25/documents/*.parquet
+- config_name: bm25_postings
+  data_files:
+  - split: train
+    path: data/bm25/postings/*.parquet
+- config_name: bm25_keyword_index
+  data_files:
+  - split: train
+    path: indexes/bm25_keyword_shards.parquet
+- config_name: vectors
+  data_files:
+  - split: train
+    path: data/vectors/*.parquet
+- config_name: vector_meta_index
+  data_files:
+  - split: train
+    path: indexes/vector_chunks.parquet
+- config_name: graph_nodes
+  data_files:
+  - split: train
+    path: data/graph/nodes/*.parquet
+- config_name: graph_edges
+  data_files:
+  - split: train
+    path: data/graph/edges/*.parquet
+- config_name: graph_outgoing_adjacency
+  data_files:
+  - split: train
+    path: data/graph/adjacency/outgoing/*.parquet
+- config_name: graph_incoming_adjacency
+  data_files:
+  - split: train
+    path: data/graph/adjacency/incoming/*.parquet
+---
 
-Kenya laws IR release.
+# Kenya legislation IR (CID-keyed sparse GraphRAG)
+
+Research retrieval release of `endomorphosis/ipfs_kenya_laws` (revision `27b81c642fec385c9123c30b9eb885d093b70f61`) packaged as
+`country-laws-ir-graphrag/v1` (layout family `skillcenter-huggingface-release/v3` / publicus-ir).
+
+**Not legal advice.** This is a research snapshot. The official gazette /
+authentic source of Kenya prevails over this corpus. Retrieved documents
+and graph edges are retrieval evidence only. No legal text was invented.
+
+Primary key: `entry_cid` (CIDv1 raw sha2-256 of a canonical identity record).
+Integer `document_index` values are compact shard pointers, not identities.
+
+Target Hub id (packaging metadata only): `justicedao/ipfs_kenya_laws_ir`.
+
+## Counts
+
+| Field | Value |
+| --- | --- |
+| Laws (corpus units) | 0 |
+| Articles (corpus units) | 9802 |
+| Canonical docs | 9802 |
+| BM25 terms | 21080 |
+| BM25 postings | 712415 |
+| Graph nodes | 10223 |
+| Graph edges | 68614 |
+| Vectors | 9802 × 384-d `thenlper/gte-small` (embedded) |
+
+## Canonical fields
+
+`entry_cid`, `law_cid`, `record_type`, `jurisdiction`, `language`,
+`instrument_id`, `instrument_title`, `article_number`, `article_title`,
+`title`, `body`, `source_url`, `snapshot_date`, `coverage`, `license`,
+`collector`, `source_dataset`, `source_revision`.
+
+Unit policy: prefer article/section rows; fall back to law-level when
+`articles.parquet` is empty.
+
+## Index layout
+
+Zstandard parquet shards with at most 4,096 rows.
+
+- `indexes/bm25_keyword_shards.parquet` — lexical term ranges → BM25 posting shards
+- `indexes/vector_chunks.parquet` — semantic routing centroids (rows sorted by cosine to shard centroid)
+- `indexes/corpus_chunks.parquet` — document ranges → corpus shards
+- `data/graph/nodes` / `data/graph/edges` — property graph
+- `data/graph/adjacency/{incoming,outgoing}` — score-ordered neighbor pages
+
+BM25: Okapi k1=1.2, b=0.75, title_weight=5, body_weight=1 (FTS5 unicode61-style tokenizer).
+
+Graph: one node per `entry_cid` plus facet nodes (`_facet_cid(kind, value)` for
+jurisdiction, language, instrument, source, status). Neighbor edges
+`BM25_NEIGHBOR_OF` (k=8) carry score and matched terms. Structural edges:
+`ARTICLE_OF` (article → parent law) when articles exist, plus `IDENTIFIED_BY_ELI`
+/ `IDENTIFIED_BY` only when those identifiers are present in the source.
+
+## Query
+
+```
+python scripts/query_country_laws_hf.py --local-dir . bm25 "constitution" --top-k 10
+python scripts/query_country_laws_hf.py --local-dir . vector "money laundering" --top-k 10
+python scripts/query_country_laws_hf.py --local-dir . graph neighbors <entry_cid>
+```
+
+## Publish later (operator)
+
+```
+export HF_TOKEN=...   # never commit
+hf upload-large-folder justicedao/ipfs_kenya_laws_ir . \
+  --repo-type dataset --no-private --num-workers 8 \
+  --exclude "**/__pycache__/**" --exclude "**/*.pyc"
+```
+
+## Provenance
+
+Packaged by country-laws-ir. Upstream collector and official license remain those
+of `endomorphosis/ipfs_kenya_laws`. CIDs identify local content; they do not prove public IPFS pinning.

build.py

@@ -1,22 +1,51 @@
-"""End-to-end build: normalize → BM25 → graph → vectors → package (no upload by default)."""
+"""End-to-end build: normalize → incremental vectors → BM25 → graph → package.
+
+Default mode is ``auto``: skip when the endomorphosis source revision is
+unchanged, otherwise delta-refresh embeddings by ``entry_cid`` and rebuild
+BM25/graph from the current corpus. Publication to ``justicedao/*`` is opt-in
+via ``upload=True``.
+"""
 
 from __future__ import annotations
 
+import os
+
 import json
+
+import pandas as pd
 import traceback
 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 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,
+    load_prior_release,
+    load_release_vectors_by_cid,
+    merge_embedding_maps,
+    plan_rebuild,
+    save_embedding_cache,
+)
 from .normalize import build_corpus, load_source
-from .package import package_release
 from .auth import configure_hf
-from .vectors import encode_corpus, embeddings_available, layout_stub_vectors, layout_vectors
+from .vectors import (
+    DIMENSION,
+    MODEL_NAME,
+    assemble_embeddings,
+    embeddings_by_cid,
+    layout_stub_vectors,
+    layout_vectors,
+    select_device,
+)
 
-ROOT = Path("/workspace/country-laws-ir")
+ROOT = Path(os.environ.get("COUNTRY_LAWS_IR_ROOT", str(Path.home() / ".ipfs_datasets" / "country-laws-ir")))
 CACHE = ROOT / "cache"
 RELEASES = ROOT / "releases"
 REPORTS = ROOT / "reports"
@@ -31,32 +60,181 @@ 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(
+    slug: str,
+    out: Path,
+    prior_dir: Path | None,
+    *,
+    fetch_hub: bool = True,
+) -> Path | None:
+    if prior_dir is not None:
+        return Path(prior_dir)
+    if out.is_dir() and (out / "manifest.json").is_file():
+        return out
+    default = RELEASES / f"ipfs_{slug}_laws_ir"
+    if default.is_dir() and (default / "manifest.json").is_file() and default.resolve() != out.resolve():
+        return default
+    if not fetch_hub:
+        return None
+    hub = fetch_hub_prior(slug, cache_root=CACHE / "hub-ir")
+    if hub is not None:
+        _log(f"using justicedao prior {hub}")
+    return hub
+
+
+def _encode_vectors(
+    *,
+    corpus: pd.DataFrame,
+    country_slug: str,
+    prior,
+    plan,
+    skip_vectors: bool,
+    device: str,
+) -> tuple[dict[str, Any], str | None, dict[str, Any]]:
+    import gc
+
+    vector_report: dict[str, Any] = {"status": "stub"}
+    vector_blocker = None
+    if skip_vectors:
+        vectors = layout_stub_vectors(corpus, reason="skip_vectors flag")
+        return vectors, "skip_vectors", {"status": "stub", "reason": "skip_vectors"}
+
+    cid_cache_path = CACHE / "embeddings" / f"{country_slug}_by_cid.parquet"
+    prior_by_cid = {}
+    if plan.reuse_embeddings:
+        prior_by_cid = merge_embedding_maps(
+            load_embedding_cache(cid_cache_path),
+            None if prior is None else load_release_vectors_by_cid(prior.directory),
+        )
+        _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=True,
+            device=resolved,
+            checkpoint_path=str(positional),
+        )
+        if (
+            vector_report.get("status") in {"stub_missing_encoder", "incomplete"}
+            and not int(vector_report.get("n_reused") or 0)
+        ):
+            vector_blocker = vector_report.get("reason") or vector_report.get("status")
+            vectors = layout_stub_vectors(corpus, reason=str(vector_blocker))
+            return vectors, vector_blocker, vector_report
+        vectors = layout_vectors(corpus, embeddings)
+        if int(vector_report.get("n_reused") or 0) and vector_report.get("status") != "reused":
+            vectors["stats"]["status"] = "partial"
+            vectors["stats"]["n_reused"] = int(vector_report.get("n_reused") or 0)
+            vectors["stats"]["n_missing"] = int(vector_report.get("n_missing") or 0)
+            vector_blocker = vector_report.get("reason") or vector_report.get("status")
+        save_embedding_cache(
+            cid_cache_path,
+            merge_embedding_maps(prior_by_cid, embeddings_by_cid(corpus, embeddings)),
+            model_name=MODEL_NAME,
+            dimension=DIMENSION,
+        )
+        del embeddings
+        gc.collect()
+        _log(
+            f"vectors n={vectors['stats']['n_vectors']} shards={vectors['stats']['shard_count']} "
+            f"reused={vector_report.get('n_reused')} encoded={vector_report.get('n_encoded')}"
+        )
+        return vectors, None, vector_report
+    except Exception as exc:
+        vector_blocker = f"embedding_failed: {exc}"
+        _log(f"vector embedding failed; writing stub ({exc})")
+        vectors = layout_stub_vectors(corpus, reason=vector_blocker)
+        return vectors, vector_blocker, {"status": "failed", "reason": str(exc)}
 
 
 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",
+    force: bool = False,
+    prior_dir: Path | None = None,
+    fetch_hub_prior_ir: bool = True,
 ) -> dict[str, Any]:
     country = get_country(source)
     if not country.get("indexable", True):
         raise RuntimeError(f"{country['repo']} is excluded: {country.get('skip_reason')}")
     repo = country["repo"]
     out = Path(out) if out else RELEASES / f"ipfs_{country['slug']}_laws_ir"
-    _log(f"build start {repo} -> {out} (upload={upload})")
+    local_dir = country.get("local_source_dir") or (
+        str(Path(source).resolve())
+        if Path(source).is_dir()
+        and (
+            (Path(source) / "data" / "laws.parquet").is_file()
+            or (Path(source) / "laws.parquet").is_file()
+        )
+        else None
+    )
+    _log(
+        f"build start {repo} -> {out} (upload={upload} mode={mode} force={force}) local={local_dir}"
+    )
     configure_hf()
     CACHE.mkdir(parents=True, exist_ok=True)
     REPORTS.mkdir(parents=True, exist_ok=True)
-    laws, articles, source_meta = load_source(repo, CACHE)
+    laws, articles, source_meta = load_source(local_dir or repo, CACHE)
     _log(
         f"source loaded laws={source_meta['n_laws_source']} "
         f"articles={source_meta['n_articles_source']} rev={source_meta['source_revision']}"
     )
+    prior = load_prior_release(
+        _prior_dir_for(
+            country["slug"],
+            out,
+            prior_dir,
+            fetch_hub=fetch_hub_prior_ir,
+        )
+    )
+    plan = plan_rebuild(
+        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}")
+        result = {
+            "country": country["slug"],
+            "source": repo,
+            "source_revision": source_meta["source_revision"],
+            "out": str(out),
+            "target_hub_id": target_repo(country["slug"]),
+            "skipped": True,
+            "incremental": plan.to_dict(),
+            "normalization": {"n_out": plan.delta.current_count if plan.delta else 0},
+            "vector_blocker": None,
+            "neighbor_via": None,
+            "schema_version": "country-laws-ir-graphrag/v1",
+        }
+        record_progress({"event": "skipped_unchanged", **{k: v for k, v in result.items() if k != "normalization"}})
+        return result
+
     corpus, norm_report = build_corpus(laws, articles, source_meta)
     report_path = REPORTS / f"{country['slug']}_normalization.json"
     report_path.write_text(json.dumps(norm_report, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
@@ -69,47 +247,94 @@ 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
 
-    bm25 = build_index(corpus)
-    _log(f"bm25 terms={bm25['stats']['n_terms']} postings={bm25['stats']['n_postings']}")
-    _log(f"bm25 neighbors start n={len(corpus)} k={neighbor_k}")
-    neighbors = bm25_neighbors(bm25, k=neighbor_k)
-    _log("bm25 neighbors done")
-    graph = build_graph(corpus, neighbors)
-    _log(f"graph nodes={graph['stats']['n_nodes']} edges={graph['stats']['n_edges']}")
+        raise NormalizationAdmissionError(
+            f"{country['slug']} failed normalization verifiers: {verdict.get('failed_ids')}"
+        )
 
-    vector_blocker = None
-    if skip_vectors:
-        vectors = layout_stub_vectors(corpus, reason="skip_vectors flag")
-        vector_blocker = "skip_vectors"
-    elif embeddings_available():
-        try:
-            ckpt = CACHE / "embeddings" / f"{country['slug']}.npy"
-            _log(f"vectors encode start n={len(corpus)} checkpoint={ckpt}")
-            embeddings = encode_corpus(corpus, device=device, checkpoint_path=str(ckpt))
-            vectors = layout_vectors(corpus, embeddings)
-            _log(f"vectors n={vectors['stats']['n_vectors']} shards={vectors['stats']['shard_count']}")
-        except Exception as exc:
-            vector_blocker = f"embedding_failed: {exc}"
-            _log(f"vector embedding failed; writing stub ({exc})")
-            vectors = layout_stub_vectors(corpus, reason=vector_blocker)
-    else:
-        vector_blocker = "sentence-transformers/torch unavailable"
-        _log(f"vectors stub: {vector_blocker}")
-        vectors = layout_stub_vectors(corpus, reason=vector_blocker)
+    import gc
 
+    plan = plan_rebuild(
+        mode=mode,
+        source_meta=source_meta,
+        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} "
+        f"added={0 if plan.delta is None else plan.delta.n_added} "
+        f"removed={0 if plan.delta is None else plan.delta.n_removed}"
+    )
+
+    n_docs = len(corpus)
+    spill = spill_dir_for(country["slug"], CACHE)
+    spill.mkdir(parents=True, exist_ok=True)
+    corpus_ckpt = CACHE / f"{country['slug']}_corpus.parquet"
+    corpus.to_parquet(corpus_ckpt, index=False)
+    checkpoint("after_normalize", log=_log)
+
+    vectors, vector_blocker, vector_report = _encode_vectors(
+        corpus=corpus,
+        country_slug=country["slug"],
+        prior=prior,
+        plan=plan,
+        skip_vectors=skip_vectors,
+        device=device,
+    )
+    spill_pickle(spill / "vectors.pkl", vectors)
+    del vectors
+    gc.collect()
+    checkpoint("vectors_spilled", log=_log)
+    extra_manifest = {"incremental": {**plan.to_dict(), "vectors": vector_report}}
+
+    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,
-        bm25,
-        graph,
+        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"],
@@ -120,7 +345,10 @@ def build_country(
         "counts": manifest["counts"],
         "normalization": norm_report,
         "vector_blocker": vector_blocker,
+        "neighbor_via": neighbor_via,
         "schema_version": manifest["schema_version"],
+        "skipped": False,
+        "incremental": extra_manifest["incremental"],
     }
     if upload:
         from .upload import upload_release
@@ -138,25 +366,32 @@ def batch(
     slugs: list[str] | None = None,
     upload: bool = False,
     skip_done: bool = True,
+    mode: str = "auto",
+    force: bool = False,
+    skip_vectors: bool = False,
 ) -> list[dict[str, Any]]:
-    done = set()
-    if skip_done and PROGRESS.exists():
-        for line in PROGRESS.read_text(encoding="utf-8").splitlines():
-            if not line.strip():
-                continue
-            rec = json.loads(line)
-            if rec.get("event") in {"uploaded", "built_local"} and rec.get("country"):
-                done.add(rec["country"])
+    """Build every indexable country. Unchanged Hub revisions are skipped in auto mode.
+
+    ``skip_done`` is kept for compatibility: it no longer skips a country whose
+    source revision changed. Pass ``force=True`` (or ``--no-skip-done``) to
+    rebuild regardless of CID overlap.
+    """
     targets = slugs or [c["slug"] for c in indexable_countries()]
     if "malta" in targets:
         targets = ["malta"] + [s for s in targets if s != "malta"]
     results = []
+    rebuild_force = force or not skip_done
     for slug in targets:
-        if skip_done and slug in done:
-            _log(f"skip already done {slug}")
-            continue
         try:
-            results.append(build_country(slug, upload=upload))
+            results.append(
+                build_country(
+                    slug,
+                    upload=upload,
+                    mode=mode,
+                    force=rebuild_force,
+                    skip_vectors=skip_vectors,
+                )
+            )
         except Exception as exc:
             _log(f"FAILED {slug}: {exc}")
             record_progress(
@@ -169,3 +404,98 @@ def batch(
             )
             continue
     return results
+
+
+def reindex_from_gaps(
+    *,
+    upload: bool = False,
+    slugs: list[str] | None = None,
+    limit: int | None = None,
+    max_corpus_rows: int | None = 20_000,
+    skip_vectors: bool = False,
+    workers: int = 4,
+    mode: str = "auto",
+    force: bool = False,
+    all_indexable: bool = False,
+    device: str = "cuda",
+) -> list[dict[str, Any]]:
+    """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:
+        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 = [
+                r
+                for r in rows
+                if int(r.get("corpus_rows") or 0) <= int(max_corpus_rows)
+            ]
+        if limit is not None:
+            rows = rows[: int(limit)]
+        slugs = [str(r["slug"]) for r in rows]
+    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(),
+            }
+        )
+        return {"country": slug, "skipped": False, "error": str(exc)}

country_laws_ir/__init__.py

@@ -1,6 +1,6 @@
 """Country-law CID-keyed sparse GraphRAG packager (SkillCenter / publicus-ir family)."""
 
-__version__ = "0.3.0"
+__version__ = "0.5.0"
 # Layout matches SkillCenter HF release / publicus-ir family; schema string is domain-specific.
 SCHEMA_VERSION = "country-laws-ir-graphrag/v1"
 LAYOUT_FAMILY = "skillcenter-huggingface-release/v3"

country_laws_ir/__main__.py

@@ -1,4 +1,4 @@
-"""python -m country_laws_ir {build,query,batch,catalog}"""
+"""python -m country_laws_ir {build,query,batch,catalog,normalize,package-raw}"""
 
 from __future__ import annotations
 
@@ -14,17 +14,29 @@ def main(argv: list[str] | None = None) -> int:
 
     p_build = sub.add_parser("build")
     p_build.add_argument("--source-repo", "--source", dest="source", default="malta",
-                         help="Hub dataset id (endomorphosis/ipfs_<slug>_laws) or country slug")
+                         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")
+    p_build.add_argument("--upload", action="store_true",
+                         help="Publish the packaged release to justicedao/ipfs_<slug>_laws_ir (requires HF_TOKEN)")
+    p_build.add_argument("--mode", default="auto", choices=["auto", "full", "delta"],
+                         help="auto skips unchanged Hub revisions and reuses embeddings by entry_cid")
+    p_build.add_argument("--force", action="store_true", help="Ignore source fingerprint skip and reuse caches")
+    p_build.add_argument("--prior-dir", default=None, help="Prior GraphRAG release to delta against")
 
     p_batch = sub.add_parser("batch")
     p_batch.add_argument("--slugs", nargs="*", default=None)
     p_batch.add_argument("--upload", action="store_true")
-    p_batch.add_argument("--no-skip-done", action="store_true")
+    p_batch.add_argument("--no-skip-done", action="store_true",
+                         help="Force a full rebuild of every country (ignore unchanged fingerprints)")
+    p_batch.add_argument("--mode", default="auto", choices=["auto", "full", "delta"])
+    p_batch.add_argument("--skip-vectors", action="store_true")
 
     p_q = sub.add_parser("query")
     p_q.add_argument("--local-dir", required=True)
@@ -34,7 +46,52 @@ def main(argv: list[str] | None = None) -> int:
     p_norm.add_argument("--source-repo", "--source", dest="source", default="malta")
     p_norm.add_argument("--out", default=None, help="Optional JSON report path")
 
-    sub.add_parser("catalog")
+    p_cat = sub.add_parser("catalog")
+    p_cat.add_argument("--refresh", action="store_true",
+                       help="List public endomorphosis/ipfs_*_laws datasets and persist new slugs")
+
+    p_cov = sub.add_parser("coverage", help="Compare endomorphosis sources vs justicedao GraphRAG releases")
+    p_cov.add_argument("--gaps", action="store_true",
+                       help="Scan Hub for missing, stale, and incomplete IR (downloads manifests)")
+    p_cov.add_argument("--workers", type=int, default=8)
+
+    p_re = sub.add_parser(
+        "reindex",
+        help="Scan endomorphosis vs justicedao and incrementally rebuild stale/missing IR",
+    )
+    p_re.add_argument("--upload", action="store_true",
+                      help="Publish rebuilt packs to justicedao (requires HF_TOKEN)")
+    p_re.add_argument("--slugs", nargs="*", default=None)
+    p_re.add_argument("--limit", type=int, default=None)
+    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=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")
+    p_raw.add_argument("--instruments-dir", default=None,
+                       help="Collector JSON directory (default: $LEGAL_CORPORA_ROOT/<iso-or-slug>/instruments)")
+    p_raw.add_argument("--iso", default=None, help="Collector ISO directory name if different from slug")
+    p_raw.add_argument("--out", default=None, help="Local pack directory (laws.parquet + pack_meta.json)")
+    p_raw.add_argument("--source-dataset", default=None,
+                       help="Raw Hub id (default endomorphosis/ipfs_<slug>_laws)")
+    p_raw.add_argument("--prior-pack", default=None, help="Existing parquet pack to merge into")
 
     args = ap.parse_args(argv)
     if args.cmd == "build":
@@ -47,6 +104,9 @@ def main(argv: list[str] | None = None) -> int:
             device=args.device,
             neighbor_k=args.neighbor_k,
             skip_vectors=args.skip_vectors,
+            mode=args.mode,
+            force=args.force,
+            prior_dir=Path(args.prior_dir) if args.prior_dir else None,
         )
         print(json.dumps({k: result[k] for k in result if k != "normalization"}, indent=2, default=str))
         print(json.dumps({"normalization": result["normalization"]}, indent=2, default=str))
@@ -54,8 +114,17 @@ def main(argv: list[str] | None = None) -> int:
     if args.cmd == "batch":
         from .build import batch
 
-        results = batch(slugs=args.slugs, upload=args.upload, skip_done=not args.no_skip_done)
-        print(json.dumps([{"country": r["country"], "out": r["out"]} for r in results], indent=2))
+        results = batch(
+            slugs=args.slugs,
+            upload=args.upload,
+            skip_done=not args.no_skip_done,
+            mode=args.mode,
+            skip_vectors=args.skip_vectors,
+        )
+        print(json.dumps(
+            [{"country": r["country"], "out": r["out"], "skipped": r.get("skipped", False)} for r in results],
+            indent=2,
+        ))
         return 0
     if args.cmd == "query":
         from .query import main as qmain
@@ -63,12 +132,13 @@ def main(argv: list[str] | None = None) -> int:
         argv2 = ["--local-dir", args.local_dir] + [a for a in args.rest if a != "--"]
         return qmain(argv2)
     if args.cmd == "normalize":
-        from .build import CACHE, REPORTS, ROOT
+        from .build import CACHE, REPORTS
         from .catalog import get_country
         from .normalize import build_corpus, load_source
 
         country = get_country(args.source)
-        laws, articles, source_meta = load_source(country["repo"], CACHE)
+        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)
         out = Path(args.out) if args.out else REPORTS / f"{country['slug']}_normalization.json"
         out.parent.mkdir(parents=True, exist_ok=True)
@@ -76,9 +146,131 @@ def main(argv: list[str] | None = None) -> int:
         print(json.dumps({"out": str(out), "n_out": report["n_out"], "unit": report["unit"], "drops": report["drops"]}, indent=2))
         return 0
     if args.cmd == "catalog":
-        from .catalog import COUNTRIES, indexable_countries
+        from .catalog import all_countries, refresh_from_hub
+
+        countries = refresh_from_hub() if args.refresh else all_countries()
+        print(json.dumps(
+            {"n": len(countries), "indexable": len([c for c in countries if c.get("indexable")]), "countries": countries},
+            indent=2,
+        ))
+        return 0
+    if args.cmd == "coverage":
+        from .coverage import coverage_report, gap_report
+
+        report = gap_report(workers=args.workers) if args.gaps else coverage_report()
+        print(json.dumps(report, indent=2, default=str))
+        return 0
+    if args.cmd == "reindex":
+        from .build import reindex_from_gaps
 
-        print(json.dumps({"n": len(COUNTRIES), "indexable": len(indexable_countries()), "countries": COUNTRIES}, indent=2))
+        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,
+            limit=args.limit,
+            max_corpus_rows=cap,
+            skip_vectors=args.skip_vectors,
+            workers=args.workers,
+            mode=args.mode,
+            force=args.force,
+            all_indexable=args.all,
+            device=args.device,
+        )
+        print(json.dumps(
+            [
+                {
+                    "country": r.get("country"),
+                    "skipped": r.get("skipped", False),
+                    "out": r.get("out"),
+                    "hub": (r.get("hub") or {}).get("url") if isinstance(r.get("hub"), dict) else r.get("hub"),
+                    "error": r.get("error"),
+                    "kind": (r.get("incremental") or {}).get("kind"),
+                    "n_added": ((r.get("incremental") or {}).get("delta") or {}).get("n_added"),
+                    "n_unchanged": ((r.get("incremental") or {}).get("delta") or {}).get("n_unchanged"),
+                }
+                for r in results
+            ],
+            indent=2,
+            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
+
+        instruments = (
+            Path(args.instruments_dir)
+            if args.instruments_dir
+            else default_instruments_dir(args.iso or args.slug)
+        )
+        out = Path(args.out) if args.out else RELEASES / "raw-packs" / args.slug
+        meta = package_instruments(
+            instruments_dir=instruments,
+            out=out,
+            slug=args.slug,
+            source_dataset=args.source_dataset,
+            prior_pack=Path(args.prior_pack) if args.prior_pack else None,
+        )
+        print(json.dumps(meta, indent=2, default=str))
         return 0
     return 1
 

country_laws_ir/auth.py

@@ -1,16 +1,38 @@
-"""Public Hugging Face reads only. This pipeline never loads, stores, or uses a token."""
+"""Hugging Face auth helpers.
+
+Default reads stay anonymous. Gap scans and JusticeDAO uploads may use the
+operator token from the Hugging Face cache file or the environment. The token
+is never logged.
+"""
 
 from __future__ import annotations
 
 import os
+from pathlib import Path
 
 
 def configure_hf() -> None:
-    """Force anonymous public Hub access. Tokens are ignored, never printed, never stored."""
-    os.environ["HF_HUB_DISABLE_IMPLICIT_TOKEN"] = "1"
-    # Do not read HF_TOKEN / HUGGING_FACE_HUB_TOKEN. Public datasets need no auth.
+    """Do not implicitly pick up ambient tokens for anonymous public reads."""
+    os.environ.setdefault("HF_HUB_DISABLE_IMPLICIT_TOKEN", "1")
 
 
 def public_token() -> bool:
     """huggingface_hub `token=False` means anonymous (do not pick up env tokens)."""
     return False
+
+
+def operator_token() -> str | bool:
+    """Return a token for authenticated Hub reads/writes, or False if none."""
+    for key in ("HF_TOKEN", "HUGGING_FACE_HUB_TOKEN"):
+        value = (os.environ.get(key) or "").strip()
+        if value:
+            return value
+    path = Path.home() / ".cache" / "huggingface" / "token"
+    if path.is_file():
+        try:
+            value = path.read_text(encoding="utf-8").strip()
+        except OSError:
+            return False
+        if value:
+            return value
+    return False

country_laws_ir/build.py

@@ -1,7 +1,15 @@
-"""End-to-end build: normalize → BM25 → graph → vectors → package (no upload by default)."""
+"""End-to-end build: normalize → incremental vectors → BM25 → graph → package.
+
+Default mode is ``auto``: skip when the endomorphosis source revision is
+unchanged, otherwise delta-refresh embeddings by ``entry_cid`` and rebuild
+BM25/graph from the current corpus. Publication to ``justicedao/*`` is opt-in
+via ``upload=True``.
+"""
 
 from __future__ import annotations
 
+import os
+
 import json
 
 import pandas as pd
@@ -10,25 +18,34 @@ 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,
+    load_prior_release,
+    load_release_vectors_by_cid,
+    merge_embedding_maps,
+    plan_rebuild,
+    save_embedding_cache,
+)
 from .normalize import build_corpus, load_source
 from .auth import configure_hf
-from .vectors import encode_corpus, embeddings_available, layout_stub_vectors, layout_vectors
+from .vectors import (
+    DIMENSION,
+    MODEL_NAME,
+    assemble_embeddings,
+    embeddings_by_cid,
+    layout_stub_vectors,
+    layout_vectors,
+    select_device,
+)
 
-ROOT = Path("/workspace/country-laws-ir")
+ROOT = Path(os.environ.get("COUNTRY_LAWS_IR_ROOT", str(Path.home() / ".ipfs_datasets" / "country-laws-ir")))
 CACHE = ROOT / "cache"
 RELEASES = ROOT / "releases"
 REPORTS = ROOT / "reports"
@@ -43,17 +60,122 @@ 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(
+    slug: str,
+    out: Path,
+    prior_dir: Path | None,
+    *,
+    fetch_hub: bool = True,
+) -> Path | None:
+    if prior_dir is not None:
+        return Path(prior_dir)
+    if out.is_dir() and (out / "manifest.json").is_file():
+        return out
+    default = RELEASES / f"ipfs_{slug}_laws_ir"
+    if default.is_dir() and (default / "manifest.json").is_file() and default.resolve() != out.resolve():
+        return default
+    if not fetch_hub:
+        return None
+    hub = fetch_hub_prior(slug, cache_root=CACHE / "hub-ir")
+    if hub is not None:
+        _log(f"using justicedao prior {hub}")
+    return hub
+
+
+def _encode_vectors(
+    *,
+    corpus: pd.DataFrame,
+    country_slug: str,
+    prior,
+    plan,
+    skip_vectors: bool,
+    device: str,
+) -> tuple[dict[str, Any], str | None, dict[str, Any]]:
+    import gc
+
+    vector_report: dict[str, Any] = {"status": "stub"}
+    vector_blocker = None
+    if skip_vectors:
+        vectors = layout_stub_vectors(corpus, reason="skip_vectors flag")
+        return vectors, "skip_vectors", {"status": "stub", "reason": "skip_vectors"}
+
+    cid_cache_path = CACHE / "embeddings" / f"{country_slug}_by_cid.parquet"
+    prior_by_cid = {}
+    if plan.reuse_embeddings:
+        prior_by_cid = merge_embedding_maps(
+            load_embedding_cache(cid_cache_path),
+            None if prior is None else load_release_vectors_by_cid(prior.directory),
+        )
+        _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=True,
+            device=resolved,
+            checkpoint_path=str(positional),
+        )
+        if (
+            vector_report.get("status") in {"stub_missing_encoder", "incomplete"}
+            and not int(vector_report.get("n_reused") or 0)
+        ):
+            vector_blocker = vector_report.get("reason") or vector_report.get("status")
+            vectors = layout_stub_vectors(corpus, reason=str(vector_blocker))
+            return vectors, vector_blocker, vector_report
+        vectors = layout_vectors(corpus, embeddings)
+        if int(vector_report.get("n_reused") or 0) and vector_report.get("status") != "reused":
+            vectors["stats"]["status"] = "partial"
+            vectors["stats"]["n_reused"] = int(vector_report.get("n_reused") or 0)
+            vectors["stats"]["n_missing"] = int(vector_report.get("n_missing") or 0)
+            vector_blocker = vector_report.get("reason") or vector_report.get("status")
+        save_embedding_cache(
+            cid_cache_path,
+            merge_embedding_maps(prior_by_cid, embeddings_by_cid(corpus, embeddings)),
+            model_name=MODEL_NAME,
+            dimension=DIMENSION,
+        )
+        del embeddings
+        gc.collect()
+        _log(
+            f"vectors n={vectors['stats']['n_vectors']} shards={vectors['stats']['shard_count']} "
+            f"reused={vector_report.get('n_reused')} encoded={vector_report.get('n_encoded')}"
+        )
+        return vectors, None, vector_report
+    except Exception as exc:
+        vector_blocker = f"embedding_failed: {exc}"
+        _log(f"vector embedding failed; writing stub ({exc})")
+        vectors = layout_stub_vectors(corpus, reason=vector_blocker)
+        return vectors, vector_blocker, {"status": "failed", "reason": str(exc)}
 
 
 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",
+    force: bool = False,
+    prior_dir: Path | None = None,
+    fetch_hub_prior_ir: bool = True,
 ) -> dict[str, Any]:
     country = get_country(source)
     if not country.get("indexable", True):
@@ -69,7 +191,9 @@ def build_country(
         )
         else None
     )
-    _log(f"build start {repo} -> {out} (upload={upload}) local={local_dir}")
+    _log(
+        f"build start {repo} -> {out} (upload={upload} mode={mode} force={force}) local={local_dir}"
+    )
     configure_hf()
     CACHE.mkdir(parents=True, exist_ok=True)
     REPORTS.mkdir(parents=True, exist_ok=True)
@@ -78,6 +202,39 @@ def build_country(
         f"source loaded laws={source_meta['n_laws_source']} "
         f"articles={source_meta['n_articles_source']} rev={source_meta['source_revision']}"
     )
+    prior = load_prior_release(
+        _prior_dir_for(
+            country["slug"],
+            out,
+            prior_dir,
+            fetch_hub=fetch_hub_prior_ir,
+        )
+    )
+    plan = plan_rebuild(
+        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}")
+        result = {
+            "country": country["slug"],
+            "source": repo,
+            "source_revision": source_meta["source_revision"],
+            "out": str(out),
+            "target_hub_id": target_repo(country["slug"]),
+            "skipped": True,
+            "incremental": plan.to_dict(),
+            "normalization": {"n_out": plan.delta.current_count if plan.delta else 0},
+            "vector_blocker": None,
+            "neighbor_via": None,
+            "schema_version": "country-laws-ir-graphrag/v1",
+        }
+        record_progress({"event": "skipped_unchanged", **{k: v for k, v in result.items() if k != "normalization"}})
+        return result
+
     corpus, norm_report = build_corpus(laws, articles, source_meta)
     report_path = REPORTS / f"{country['slug']}_normalization.json"
     report_path.write_text(json.dumps(norm_report, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
@@ -90,9 +247,30 @@ 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
 
+    plan = plan_rebuild(
+        mode=mode,
+        source_meta=source_meta,
+        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} "
+        f"added={0 if plan.delta is None else plan.delta.n_added} "
+        f"removed={0 if plan.delta is None else plan.delta.n_removed}"
+    )
+
     n_docs = len(corpus)
     spill = spill_dir_for(country["slug"], CACHE)
     spill.mkdir(parents=True, exist_ok=True)
@@ -100,81 +278,63 @@ def build_country(
     corpus.to_parquet(corpus_ckpt, index=False)
     checkpoint("after_normalize", log=_log)
 
-    vector_blocker = None
-    if skip_vectors:
-        vectors = layout_stub_vectors(corpus, reason="skip_vectors flag")
-        vector_blocker = "skip_vectors"
-        spill_pickle(spill / "vectors.pkl", vectors)
-        del vectors
-        gc.collect()
-    elif embeddings_available():
-        try:
-            ckpt = CACHE / "embeddings" / f"{country['slug']}.npy"
-            _log(f"vectors encode start n={n_docs} checkpoint={ckpt}")
-            embeddings = encode_corpus(corpus, device=device, checkpoint_path=str(ckpt))
-            vectors = layout_vectors(corpus, embeddings)
-            _log(f"vectors n={vectors['stats']['n_vectors']} shards={vectors['stats']['shard_count']}")
-            spill_pickle(spill / "vectors.pkl", vectors)
-            del embeddings, vectors
-            gc.collect()
-            checkpoint("vectors_spilled", log=_log)
-        except Exception as exc:
-            vector_blocker = f"embedding_failed: {exc}"
-            _log(f"vector embedding failed; writing stub ({exc})")
-            vectors = layout_stub_vectors(corpus, reason=vector_blocker)
-            spill_pickle(spill / "vectors.pkl", vectors)
-            del vectors
-            gc.collect()
-    else:
-        vector_blocker = "sentence-transformers/torch unavailable"
-        _log(f"vectors stub: {vector_blocker}")
-        vectors = layout_stub_vectors(corpus, reason=vector_blocker)
-        spill_pickle(spill / "vectors.pkl", vectors)
-        del vectors
-        gc.collect()
+    vectors, vector_blocker, vector_report = _encode_vectors(
+        corpus=corpus,
+        country_slug=country["slug"],
+        prior=prior,
+        plan=plan,
+        skip_vectors=skip_vectors,
+        device=device,
+    )
+    spill_pickle(spill / "vectors.pkl", vectors)
+    del vectors
+    gc.collect()
+    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,
-        )
-        _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,
-        )
-        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"],
@@ -187,6 +347,8 @@ def build_country(
         "vector_blocker": vector_blocker,
         "neighbor_via": neighbor_via,
         "schema_version": manifest["schema_version"],
+        "skipped": False,
+        "incremental": extra_manifest["incremental"],
     }
     if upload:
         from .upload import upload_release
@@ -204,25 +366,32 @@ def batch(
     slugs: list[str] | None = None,
     upload: bool = False,
     skip_done: bool = True,
+    mode: str = "auto",
+    force: bool = False,
+    skip_vectors: bool = False,
 ) -> list[dict[str, Any]]:
-    done = set()
-    if skip_done and PROGRESS.exists():
-        for line in PROGRESS.read_text(encoding="utf-8").splitlines():
-            if not line.strip():
-                continue
-            rec = json.loads(line)
-            if rec.get("event") in {"uploaded", "built_local"} and rec.get("country"):
-                done.add(rec["country"])
+    """Build every indexable country. Unchanged Hub revisions are skipped in auto mode.
+
+    ``skip_done`` is kept for compatibility: it no longer skips a country whose
+    source revision changed. Pass ``force=True`` (or ``--no-skip-done``) to
+    rebuild regardless of CID overlap.
+    """
     targets = slugs or [c["slug"] for c in indexable_countries()]
     if "malta" in targets:
         targets = ["malta"] + [s for s in targets if s != "malta"]
     results = []
+    rebuild_force = force or not skip_done
     for slug in targets:
-        if skip_done and slug in done:
-            _log(f"skip already done {slug}")
-            continue
         try:
-            results.append(build_country(slug, upload=upload))
+            results.append(
+                build_country(
+                    slug,
+                    upload=upload,
+                    mode=mode,
+                    force=rebuild_force,
+                    skip_vectors=skip_vectors,
+                )
+            )
         except Exception as exc:
             _log(f"FAILED {slug}: {exc}")
             record_progress(
@@ -235,3 +404,98 @@ def batch(
             )
             continue
     return results
+
+
+def reindex_from_gaps(
+    *,
+    upload: bool = False,
+    slugs: list[str] | None = None,
+    limit: int | None = None,
+    max_corpus_rows: int | None = 20_000,
+    skip_vectors: bool = False,
+    workers: int = 4,
+    mode: str = "auto",
+    force: bool = False,
+    all_indexable: bool = False,
+    device: str = "cuda",
+) -> list[dict[str, Any]]:
+    """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:
+        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 = [
+                r
+                for r in rows
+                if int(r.get("corpus_rows") or 0) <= int(max_corpus_rows)
+            ]
+        if limit is not None:
+            rows = rows[: int(limit)]
+        slugs = [str(r["slug"]) for r in rows]
+    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(),
+            }
+        )
+        return {"country": slug, "skipped": False, "error": str(exc)}

country_laws_ir/catalog.py

@@ -2,15 +2,39 @@
 
 Belgium, Portugal, and Lithuania are incomplete Wayback harvests and are
 excluded from indexing. american_municipal_law is out of scope.
+
+The static ``COUNTRIES`` list is the fail-closed baseline. ``refresh_from_hub``
+persists a sidecar cache of newly listed Hub datasets so incremental scrapes
+of additional jurisdictions are indexable without a code change.
 """
 
 from __future__ import annotations
 
+import json
+import os
+from pathlib import Path
 from typing import Any
 
-EXCLUDED_SLUGS = {"belgium", "portugal", "lithuania"}
+EXCLUDED_SLUGS = {"belgium", "portugal", "lithuania", "ghana"}
 EXCLUDED_REPOS = {f"endomorphosis/ipfs_{s}_laws" for s in EXCLUDED_SLUGS}
 
+_SKIP_REASONS = {
+    "belgium": "incomplete Wayback harvest (Justel / Moniteur belge archive shard)",
+    "portugal": "incomplete Wayback harvest (Diário da República archive shard)",
+    "lithuania": "incomplete Wayback harvest (e-TAR archive shard)",
+    "ghana": "thin scrape; Act PDF path blocked by robots",
+}
+
+
+def catalog_cache_path() -> Path:
+    root = Path(
+        os.environ.get(
+            "COUNTRY_LAWS_IR_ROOT",
+            str(Path.home() / ".ipfs_datasets" / "country-laws-ir"),
+        )
+    )
+    return root / "catalog_cache.json"
+
 # Hub listing as of 2026-09-03. Refresh via `python -m country_laws_ir catalog --refresh`.
 COUNTRIES: list[dict[str, Any]] = [
     {"slug": "argentina", "repo": "endomorphosis/ipfs_argentina_laws", "name": "Argentina", "indexable": True},
@@ -88,6 +112,54 @@ COUNTRIES: list[dict[str, Any]] = [
 ]
 
 
+def load_cached_countries() -> list[dict[str, Any]]:
+    path = catalog_cache_path()
+    if not path.is_file():
+        return []
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return []
+    rows = payload.get("countries") if isinstance(payload, dict) else payload
+    if not isinstance(rows, list):
+        return []
+    out: list[dict[str, Any]] = []
+    for row in rows:
+        if isinstance(row, dict) and row.get("slug") and row.get("repo"):
+            out.append(dict(row))
+    return out
+
+
+def persist_catalog(countries: list[dict[str, Any]], path: Path | None = None) -> Path:
+    dest = path or catalog_cache_path()
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    payload = {
+        "n": len(countries),
+        "indexable": sum(1 for c in countries if c.get("indexable")),
+        "countries": countries,
+    }
+    dest.write_text(json.dumps(payload, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+    return dest
+
+
+def merge_country_rows(
+    baseline: list[dict[str, Any]],
+    extra: list[dict[str, Any]],
+) -> list[dict[str, Any]]:
+    """Static catalog wins on slug; Hub extras fill gaps."""
+    by_slug = {str(row["slug"]): dict(row) for row in baseline if row.get("slug")}
+    for row in extra:
+        slug = str(row.get("slug") or "")
+        if not slug or slug in by_slug:
+            continue
+        by_slug[slug] = dict(row)
+    return [by_slug[k] for k in sorted(by_slug)]
+
+
+def all_countries() -> list[dict[str, Any]]:
+    return merge_country_rows(COUNTRIES, load_cached_countries())
+
+
 def get_country(source: str) -> dict[str, Any]:
     source = source.strip()
     # Local filtered pack: directory with data/laws.parquet (+ optional pack_meta.json)
@@ -133,7 +205,7 @@ def get_country(source: str) -> dict[str, Any]:
     if "/" in source:
         slug = source.rsplit("/", 1)[-1]
     slug = slug.removeprefix("ipfs_").removesuffix("_laws").removesuffix("-ir")
-    for row in COUNTRIES:
+    for row in all_countries():
         if row["slug"] == slug or row["repo"] == source or row["repo"].endswith("/" + source):
             return dict(row)
     if source.startswith("endomorphosis/ipfs_") and source.endswith("_laws"):
@@ -143,20 +215,20 @@ def get_country(source: str) -> dict[str, Any]:
             "repo": source,
             "name": inferred.replace("_", " ").title(),
             "indexable": inferred not in EXCLUDED_SLUGS,
-            "skip_reason": "incomplete Wayback harvest" if inferred in EXCLUDED_SLUGS else None,
+            "skip_reason": _SKIP_REASONS.get(inferred),
         }
     raise KeyError(f"Unknown country-law source: {source}")
 
 
 def indexable_countries() -> list[dict[str, Any]]:
-    return [c for c in COUNTRIES if c.get("indexable")]
+    return [c for c in all_countries() if c.get("indexable")]
 
 
 def target_repo(slug: str) -> str:
     return f"justicedao/ipfs_{slug}_laws_ir"
 
 
-def refresh_from_hub() -> list[dict[str, Any]]:
+def refresh_from_hub(*, persist: bool = True) -> list[dict[str, Any]]:
     """Anonymous Hub listing of public endomorphosis/ipfs_*_laws datasets."""
     from huggingface_hub import HfApi
 
@@ -175,9 +247,10 @@ def refresh_from_hub() -> list[dict[str, Any]]:
             "repo": ds_id,
             "name": slug.replace("_", " ").title(),
             "indexable": slug not in EXCLUDED_SLUGS,
-            "skip_reason": (
-                "incomplete Wayback harvest" if slug in EXCLUDED_SLUGS else None
-            ),
+            "skip_reason": _SKIP_REASONS.get(slug),
         })
     found.sort(key=lambda r: r["slug"])
-    return found
+    merged = merge_country_rows(COUNTRIES, found)
+    if persist:
+        persist_catalog(merged)
+    return merged

country_laws_ir/cidutil.py

@@ -59,6 +59,27 @@ def cid_v1_raw_sha256(data: bytes) -> str:
     return "b" + _b32encode(cid_bytes)
 
 
+def sha256_key_to_cidv1(value: str) -> str:
+    """Turn a bare/prefixed SHA-256 routing key into ``bafkrei…`` CIDv1.
+
+    GraphRAG locators must not use hex digests as ``entry_cid`` / ``node_cid``.
+    """
+
+    text = str(value or "").strip()
+    if text.startswith("bafkrei"):
+        return text
+    hex_part = text[7:71] if text.lower().startswith("sha256:") else text[:64]
+    rest = text[71:] if text.lower().startswith("sha256:") else text[64:]
+    if len(hex_part) != 64:
+        return text
+    try:
+        digest = bytes.fromhex(hex_part)
+    except ValueError:
+        return text
+    cid_bytes = bytes([0x01, 0x55, 0x12, 0x20]) + digest
+    return "b" + _b32encode(cid_bytes) + rest
+
+
 def cid_of_json(obj: Any) -> str:
     return cid_v1_raw_sha256(canonical_json_bytes(obj))
 

country_laws_ir/coverage.py

@@ -0,0 +1,455 @@
+"""Compare endomorphosis raw sources against justicedao GraphRAG releases.
+
+Gap kinds
+---------
+* missing — no JusticeDAO IR (and no local pack)
+* unpublished — local IR exists, Hub IR does not
+* stale — Hub/local IR source revision does not match current endomorphosis SHA
+* incomplete — missing corpus/BM25/graph, empty corpus, or source has no laws
+* stub_vectors — IR is otherwise current but embeddings were stubbed
+"""
+
+from __future__ import annotations
+
+import json
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+from typing import Any, Mapping
+
+from .catalog import EXCLUDED_SLUGS, all_countries, target_repo
+
+ALIAS_TO_CANONICAL = {
+    "dominican_republic": "dominicanrepublic",
+    "el_salvador": "elsalvador",
+    "north_korea": "northkorea",
+    "papua_new_guinea": "papuanewguinea",
+    "san_marino": "sanmarino",
+    "trinidad_and_tobago": "trinidad",
+}
+
+
+def _slug_from_source(dataset_id: str) -> str | None:
+    if not dataset_id.startswith("endomorphosis/ipfs_") or not dataset_id.endswith("_laws"):
+        return None
+    return dataset_id.split("ipfs_", 1)[1].removesuffix("_laws")
+
+
+def _slug_from_ir(dataset_id: str) -> str | None:
+    if not dataset_id.startswith("justicedao/ipfs_") or not dataset_id.endswith("_laws_ir"):
+        return None
+    return dataset_id.split("ipfs_", 1)[1].removesuffix("_laws_ir")
+
+
+def canonical_slug(slug: str) -> str:
+    return ALIAS_TO_CANONICAL.get(slug, slug)
+
+
+def list_hub_slugs(*, author: str, kind: str) -> list[str]:
+    from huggingface_hub import HfApi
+
+    from .auth import configure_hf, operator_token, public_token
+
+    configure_hf()
+    token = operator_token() or public_token()
+    api = HfApi(token=token)
+    out: list[str] = []
+    for ds in api.list_datasets(author=author):
+        slug = _slug_from_source(ds.id) if kind == "source" else _slug_from_ir(ds.id)
+        if slug:
+            out.append(slug)
+    return sorted(set(out))
+
+
+def local_release_slugs(releases_dir: Path) -> list[str]:
+    if not releases_dir.is_dir():
+        return []
+    found: list[str] = []
+    for path in sorted(releases_dir.glob("ipfs_*_laws_ir")):
+        if (path / "manifest.json").is_file():
+            slug = path.name.removeprefix("ipfs_").removesuffix("_laws_ir")
+            found.append(slug)
+    return found
+
+
+IR_FAMILY_PREFIXES = (
+    ("data/corpus/", "ir_missing_corpus"),
+    ("data/bm25/", "ir_missing_bm25"),
+    ("data/graph/", "ir_missing_graph"),
+)
+STUB_VECTOR_STATUSES = {"stub", "stub_missing_encoder", "incomplete"}
+TINY_LAWS_BYTES = 1024
+
+
+def classify_gap(
+    *,
+    excluded: bool = False,
+    alias: bool = False,
+    source_has_laws: bool = True,
+    source_laws_bytes: int | None = None,
+    source_revision: str | None = None,
+    ir_files: list[str] | None = None,
+    ir_source_revision: str | None = None,
+    ir_corpus_rows: int | None = None,
+    vector_status: str | None = None,
+    local_only: bool = False,
+    local_source_revision: str | None = None,
+) -> dict[str, Any]:
+    """Pure classifier for missing / stale / incomplete country IR."""
+    issues: list[str] = []
+    if alias:
+        return {"status": "alias", "issues": issues, "rebuild": False, "publish": False}
+    if excluded:
+        return {"status": "excluded", "issues": issues, "rebuild": False, "publish": False}
+
+    if not source_has_laws:
+        issues.append("source_missing_laws")
+    if (
+        source_laws_bytes is not None
+        and source_laws_bytes >= 0
+        and source_laws_bytes < TINY_LAWS_BYTES
+    ):
+        issues.append("source_laws_tiny")
+
+    if ir_files is None:
+        issues.append("missing_ir")
+    else:
+        names = set(ir_files)
+        if "manifest.json" not in names:
+            issues.append("ir_missing_manifest")
+        for prefix, issue in IR_FAMILY_PREFIXES:
+            if not any(name.startswith(prefix) for name in names):
+                issues.append(issue)
+        if ir_corpus_rows is not None and int(ir_corpus_rows) <= 0:
+            issues.append("ir_empty_corpus")
+        if (
+            source_revision
+            and ir_source_revision
+            and str(source_revision) != str(ir_source_revision)
+        ):
+            issues.append("stale_source_revision")
+        if vector_status in STUB_VECTOR_STATUSES:
+            issues.append("ir_stub_vectors")
+
+    structural = {
+        "source_missing_laws",
+        "source_laws_tiny",
+        "ir_missing_manifest",
+        "ir_missing_corpus",
+        "ir_missing_bm25",
+        "ir_missing_graph",
+        "ir_empty_corpus",
+    }
+    issue_set = set(issues)
+    if "missing_ir" in issue_set:
+        status = "unpublished" if local_only else "missing"
+    elif "stale_source_revision" in issue_set:
+        status = "stale"
+    elif issue_set & structural:
+        status = "incomplete"
+    elif issue_set == {"ir_stub_vectors"}:
+        status = "stub_vectors"
+    elif not issues:
+        status = "current"
+    else:
+        status = "incomplete"
+
+    local_current = bool(
+        source_revision
+        and local_source_revision
+        and str(source_revision) == str(local_source_revision)
+    )
+    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
+    )
+    return {
+        "status": status,
+        "issues": issues,
+        "rebuild": rebuild,
+        "publish": publish,
+    }
+
+
+def _ir_source_revision(manifest: Mapping[str, Any] | None) -> str | None:
+    if not manifest:
+        return None
+    pinned = manifest.get("dataset_revision") or (manifest.get("source") or {}).get(
+        "source_revision"
+    )
+    text = str(pinned or "").strip()
+    return text or None
+
+
+def _vector_status(manifest: Mapping[str, Any] | None) -> str | None:
+    if not manifest:
+        return None
+    vector = manifest.get("vector") or {}
+    if isinstance(vector, dict) and vector.get("status"):
+        return str(vector.get("status"))
+    incremental = manifest.get("incremental") or {}
+    nested = incremental.get("vectors") if isinstance(incremental, dict) else None
+    if isinstance(nested, dict) and nested.get("status"):
+        return str(nested.get("status"))
+    if isinstance(vector, dict) and vector.get("stub"):
+        return "stub"
+    return None
+
+
+def load_local_manifest(release_dir: Path) -> dict[str, Any]:
+    path = Path(release_dir) / "manifest.json"
+    if not path.is_file():
+        return {}
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def _sibling_map(info: Any) -> dict[str, int | None]:
+    out: dict[str, int | None] = {}
+    for sib in getattr(info, "siblings", None) or []:
+        name = str(getattr(sib, "rfilename", "") or "")
+        if not name:
+            continue
+        size = getattr(sib, "size", None)
+        try:
+            out[name] = int(size) if size is not None else None  # type: ignore[assignment]
+        except (TypeError, ValueError):
+            out[name] = None  # type: ignore[assignment]
+    return out
+
+
+def _inspect_source(slug: str, cache_dir: Path | None = None) -> dict[str, Any]:
+    from huggingface_hub import dataset_info
+
+    from .auth import configure_hf, operator_token, public_token
+
+    repo = f"endomorphosis/ipfs_{slug}_laws"
+    configure_hf()
+    info = dataset_info(repo, token=operator_token() or public_token())
+    files = _sibling_map(info)
+    laws_file = next(
+        (name for name in ("data/laws.parquet", "laws.parquet") if name in files),
+        None,
+    )
+    arts_file = next(
+        (name for name in ("data/articles.parquet", "articles.parquet") if name in files),
+        None,
+    )
+    return {
+        "repo": repo,
+        "revision": getattr(info, "sha", None),
+        "files": sorted(files),
+        "has_laws": laws_file is not None,
+        "has_articles": arts_file is not None,
+        "laws_bytes": files.get(laws_file) if laws_file else None,
+        "articles_bytes": files.get(arts_file) if arts_file else None,
+    }
+
+
+def _inspect_ir(slug: str, cache_dir: Path) -> dict[str, Any] | None:
+    from huggingface_hub import HfApi, dataset_info, hf_hub_download
+    from huggingface_hub.errors import EntryNotFoundError, RepositoryNotFoundError
+
+    from .auth import configure_hf, operator_token, public_token
+
+    repo = target_repo(slug)
+    configure_hf()
+    token = operator_token() or public_token()
+    try:
+        info = dataset_info(repo, token=token)
+    except RepositoryNotFoundError:
+        return None
+    files = _sibling_map(info)
+    if len(files) < 8:
+        try:
+            listed = HfApi(token=token).list_repo_files(repo_id=repo, repo_type="dataset")
+            for name in listed:
+                files.setdefault(str(name), None)
+        except Exception:
+            pass
+    manifest: dict[str, Any] = {}
+    if "manifest.json" in files:
+        try:
+            path = hf_hub_download(
+                repo_id=repo,
+                filename="manifest.json",
+                repo_type="dataset",
+                token=token,
+                cache_dir=str(cache_dir / "hf"),
+            )
+            payload = json.loads(Path(path).read_text(encoding="utf-8"))
+            if isinstance(payload, dict):
+                manifest = payload
+        except (EntryNotFoundError, OSError, json.JSONDecodeError):
+            manifest = {}
+    counts = manifest.get("counts") if isinstance(manifest.get("counts"), dict) else {}
+    return {
+        "repo": repo,
+        "hub_revision": getattr(info, "sha", None),
+        "files": sorted(files),
+        "manifest": manifest,
+        "source_revision": _ir_source_revision(manifest),
+        "corpus_rows": counts.get("corpus_rows"),
+        "vector_status": _vector_status(manifest),
+    }
+
+
+def gap_report(
+    releases_dir: Path | None = None,
+    *,
+    slugs: list[str] | None = None,
+    workers: int = 8,
+) -> dict[str, Any]:
+    """Live Hub scan: missing, stale, incomplete, and unpublished country IR."""
+    from .build import CACHE, RELEASES
+
+    sources = slugs or [
+        s
+        for s in list_hub_slugs(author="endomorphosis", kind="source")
+        if s not in ALIAS_TO_CANONICAL
+    ]
+    hub_ir = set(list_hub_slugs(author="justicedao", kind="ir"))
+    local_dir = Path(releases_dir) if releases_dir else RELEASES
+    local_ir = set(local_release_slugs(local_dir))
+    cache_dir = CACHE
+    cache_dir.mkdir(parents=True, exist_ok=True)
+
+    rows: list[dict[str, Any]] = []
+
+    def _one(slug: str) -> dict[str, Any]:
+        last_exc: Exception | None = None
+        for attempt in range(4):
+            try:
+                source = _inspect_source(slug)
+                ir = _inspect_ir(slug, cache_dir) if slug in hub_ir else None
+                break
+            except Exception as exc:
+                last_exc = exc
+                name = type(exc).__name__
+                msg = str(exc)
+                if "429" in msg or "rate limit" in msg.lower():
+                    time.sleep(min(45, 3 ** attempt * 2))
+                    continue
+                raise
+        else:
+            raise last_exc or RuntimeError(f"scan failed for {slug}")
+        local_manifest = load_local_manifest(local_dir / f"ipfs_{slug}_laws_ir")
+        local_rev = _ir_source_revision(local_manifest) if local_manifest else None
+        classified = classify_gap(
+            excluded=slug in EXCLUDED_SLUGS,
+            alias=False,
+            source_has_laws=bool(source.get("has_laws")),
+            source_laws_bytes=source.get("laws_bytes"),
+            source_revision=source.get("revision"),
+            ir_files=None if ir is None else ir.get("files"),
+            ir_source_revision=(ir or {}).get("source_revision") or local_rev,
+            ir_corpus_rows=(ir or {}).get("corpus_rows")
+            if ir is not None
+            else (local_manifest.get("counts") or {}).get("corpus_rows")
+            if local_manifest
+            else None,
+            vector_status=(ir or {}).get("vector_status")
+            or _vector_status(local_manifest),
+            local_only=slug in local_ir and slug not in hub_ir,
+            local_source_revision=local_rev,
+        )
+        return {
+            "slug": slug,
+            "source": source.get("repo"),
+            "target": target_repo(slug),
+            "source_revision": source.get("revision"),
+            "ir_source_revision": (ir or {}).get("source_revision"),
+            "local_source_revision": local_rev,
+            "has_hub_ir": ir is not None,
+            "has_local_ir": slug in local_ir,
+            "source_has_articles": source.get("has_articles"),
+            "source_laws_bytes": source.get("laws_bytes"),
+            "corpus_rows": (ir or {}).get("corpus_rows")
+            if ir is not None
+            else (local_manifest.get("counts") or {}).get("corpus_rows")
+            if local_manifest
+            else None,
+            "vector_status": (ir or {}).get("vector_status")
+            or _vector_status(local_manifest),
+            **classified,
+        }
+
+    workers = max(1, min(int(workers), 16))
+    with ThreadPoolExecutor(max_workers=workers) as pool:
+        futs = {pool.submit(_one, slug): slug for slug in sources}
+        for fut in as_completed(futs):
+            slug = futs[fut]
+            try:
+                rows.append(fut.result())
+            except Exception as exc:
+                rows.append(
+                    {
+                        "slug": slug,
+                        "source": f"endomorphosis/ipfs_{slug}_laws",
+                        "target": target_repo(slug),
+                        "status": "incomplete",
+                        "issues": [f"scan_error:{type(exc).__name__}"],
+                        "rebuild": False,
+                        "publish": False,
+                        "error": str(exc),
+                    }
+                )
+    rows.sort(key=lambda r: str(r.get("slug")))
+    by_status: dict[str, list[str]] = {}
+    for row in rows:
+        by_status.setdefault(str(row.get("status")), []).append(str(row.get("slug")))
+    return {
+        "n": len(rows),
+        "by_status": {k: sorted(v) for k, v in sorted(by_status.items())},
+        "counts": {k: len(v) for k, v in sorted(by_status.items())},
+        "rebuild": [r["slug"] for r in rows if r.get("rebuild")],
+        "publish": [r["slug"] for r in rows if r.get("publish")],
+        "countries": rows,
+    }
+
+
+def coverage_report(releases_dir: Path | None = None) -> dict[str, Any]:
+    from .build import RELEASES
+
+    sources = list_hub_slugs(author="endomorphosis", kind="source")
+    hub_ir = list_hub_slugs(author="justicedao", kind="ir")
+    local_ir = local_release_slugs(Path(releases_dir) if releases_dir else RELEASES)
+    hub_ir_canon = {canonical_slug(s) for s in hub_ir}
+    local_ir_canon = {canonical_slug(s) for s in local_ir}
+    missing_hub: list[dict[str, Any]] = []
+    missing_local: list[dict[str, Any]] = []
+    excluded: list[str] = []
+    aliases: list[str] = []
+    for slug in sources:
+        if slug in ALIAS_TO_CANONICAL:
+            aliases.append(slug)
+            continue
+        if slug in EXCLUDED_SLUGS:
+            excluded.append(slug)
+            continue
+        row = {
+            "slug": slug,
+            "source": f"endomorphosis/ipfs_{slug}_laws",
+            "target": target_repo(slug),
+        }
+        if slug not in hub_ir_canon:
+            missing_hub.append(row)
+        if slug not in local_ir_canon and slug not in hub_ir_canon:
+            missing_local.append(row)
+    return {
+        "n_sources": len(sources),
+        "n_hub_ir": len(hub_ir),
+        "n_local_ir": len(local_ir),
+        "n_catalog": len(all_countries()),
+        "excluded": excluded,
+        "alias_sources": aliases,
+        "missing_justicedao": missing_hub,
+        "missing_local_and_hub": missing_local,
+        "local_only": sorted(local_ir_canon - hub_ir_canon),
+    }

country_laws_ir/duckdb_store.py

@@ -0,0 +1,408 @@
+"""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 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

@@ -0,0 +1,518 @@
+"""CID-keyed incremental GraphRAG rebuild for country-laws IR.
+
+Follows the US Code / patent persistent-index pattern:
+
+* ``entry_cid`` is the durable identity (not positional ``document_index``).
+* A matching source revision + parquet digest is a no-op.
+* Unchanged CIDs reuse embeddings; BM25/graph are rebuilt from the current
+  corpus because ``document_index`` is a shard pointer, not an identity.
+* Delta refresh is never labeled equivalent to a full rebuild.
+
+Public Hub reads stay anonymous. Publication to ``justicedao/*`` is a separate
+gated upload step.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+import json
+from pathlib import Path
+from typing import Any, Iterable, Mapping
+
+import pandas as pd
+
+from . import SCHEMA_VERSION
+
+class RebuildKind(str, Enum):
+    UNCHANGED = "unchanged"
+    DELTA_REFRESH = "delta_refresh"
+    FULL_REBUILD = "full_rebuild"
+
+    @classmethod
+    def coerce(cls, value: Any) -> "RebuildKind":
+        if isinstance(value, RebuildKind):
+            return value
+        text = str(value or "").strip().lower().replace("-", "_")
+        aliases = {
+            "skip": cls.UNCHANGED,
+            "noop": cls.UNCHANGED,
+            "none": cls.UNCHANGED,
+            "delta": cls.DELTA_REFRESH,
+            "incremental": cls.DELTA_REFRESH,
+            "partial": cls.DELTA_REFRESH,
+            "full": cls.FULL_REBUILD,
+            "rebuild": cls.FULL_REBUILD,
+            "force": cls.FULL_REBUILD,
+        }
+        if text in aliases:
+            return aliases[text]
+        for kind in cls:
+            if kind.value == text or kind.name.lower() == text:
+                return kind
+        raise ValueError(f"unknown rebuild kind: {value!r}")
+
+
+class BuildMode(str, Enum):
+    AUTO = "auto"
+    FULL = "full"
+    DELTA = "delta"
+
+    @classmethod
+    def coerce(cls, value: Any) -> "BuildMode":
+        if isinstance(value, BuildMode):
+            return value
+        text = str(value or "").strip().lower().replace("-", "_")
+        aliases = {
+            "incremental": cls.DELTA,
+            "diff": cls.DELTA,
+            "rebuild": cls.FULL,
+            "complete": cls.FULL,
+        }
+        if text in aliases:
+            return aliases[text]
+        for mode in cls:
+            if mode.value == text or mode.name.lower() == text:
+                return mode
+        raise ValueError(f"unknown build mode: {value!r}")
+
+
+@dataclass(frozen=True)
+class CorpusDelta:
+    added_cids: tuple[str, ...] = ()
+    removed_cids: tuple[str, ...] = ()
+    unchanged_cids: tuple[str, ...] = ()
+    prior_count: int = 0
+    current_count: int = 0
+    changed_ratio: float = 1.0
+    equivalent_to_full: bool = False
+
+    @property
+    def n_added(self) -> int:
+        return len(self.added_cids)
+
+    @property
+    def n_removed(self) -> int:
+        return len(self.removed_cids)
+
+    @property
+    def n_unchanged(self) -> int:
+        return len(self.unchanged_cids)
+
+    def to_dict(self, *, include_cids: bool = False, cid_sample: int = 8) -> dict[str, Any]:
+        payload = {
+            "n_added": self.n_added,
+            "n_removed": self.n_removed,
+            "n_unchanged": self.n_unchanged,
+            "prior_count": self.prior_count,
+            "current_count": self.current_count,
+            "changed_ratio": self.changed_ratio,
+            "equivalent_to_full": self.equivalent_to_full,
+        }
+        if include_cids:
+            payload["added_cids"] = list(self.added_cids)
+            payload["removed_cids"] = list(self.removed_cids)
+            payload["unchanged_cids"] = list(self.unchanged_cids)
+        else:
+            payload["added_cids_sample"] = list(self.added_cids[:cid_sample])
+            payload["removed_cids_sample"] = list(self.removed_cids[:cid_sample])
+        return payload
+
+
+@dataclass(frozen=True)
+class RebuildPlan:
+    kind: RebuildKind
+    mode: BuildMode
+    reason: str
+    source_revision: str
+    prior_revision: str | None = None
+    source_fingerprint: str = ""
+    prior_fingerprint: str | None = None
+    delta: CorpusDelta | None = None
+    reuse_embeddings: bool = False
+    skip_build: bool = False
+    equivalent_to_full: bool = False
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "kind": self.kind.value,
+            "mode": self.mode.value,
+            "reason": self.reason,
+            "source_revision": self.source_revision,
+            "prior_revision": self.prior_revision,
+            "source_fingerprint": self.source_fingerprint,
+            "prior_fingerprint": self.prior_fingerprint,
+            "delta": None if self.delta is None else self.delta.to_dict(include_cids=False),
+            "reuse_embeddings": self.reuse_embeddings,
+            "skip_build": self.skip_build,
+            "equivalent_to_full": self.equivalent_to_full,
+            "schema_version": SCHEMA_VERSION,
+        }
+
+
+@dataclass
+class PriorRelease:
+    directory: Path
+    manifest: dict[str, Any] = field(default_factory=dict)
+    corpus: pd.DataFrame | None = None
+    vectors_by_cid: dict[str, list[float]] | None = None
+
+    @property
+    def source_revision(self) -> str | None:
+        return (
+            self.manifest.get("dataset_revision")
+            or (self.manifest.get("source") or {}).get("source_revision")
+        )
+
+    @property
+    def fingerprint(self) -> str:
+        return source_fingerprint_from_manifest(self.manifest)
+
+
+def source_fingerprint(source_meta: Mapping[str, Any]) -> str:
+    """Stable skip key: Hub SHA plus parquet digests when present."""
+    revision = str(source_meta.get("source_revision") or "")
+    laws = str(source_meta.get("laws_sha256") or "")
+    articles = str(source_meta.get("articles_sha256") or "")
+    return f"{revision}|{laws}|{articles}"
+
+
+def source_fingerprint_from_manifest(manifest: Mapping[str, Any]) -> str:
+    revision = str(
+        manifest.get("dataset_revision")
+        or (manifest.get("source") or {}).get("source_revision")
+        or ""
+    )
+    sha = manifest.get("input_sha256") or {}
+    laws = str(sha.get("laws.parquet") or "")
+    articles = str(sha.get("articles.parquet") or "")
+    if not laws and not articles:
+        src = manifest.get("source") or {}
+        laws = str(src.get("laws_sha256") or "")
+        articles = str(src.get("articles_sha256") or "")
+    return f"{revision}|{laws}|{articles}"
+
+
+def _cid_set(frame: pd.DataFrame | None) -> set[str]:
+    if frame is None or frame.empty or "entry_cid" not in frame.columns:
+        return set()
+    return {str(x) for x in frame["entry_cid"].dropna().astype(str) if str(x).strip()}
+
+
+def diff_corpus(
+    prior: pd.DataFrame | None,
+    current: pd.DataFrame,
+) -> CorpusDelta:
+    """Diff two CID-keyed corpora. Same ``entry_cid`` implies same body."""
+    current_cids = _cid_set(current)
+    prior_cids = _cid_set(prior)
+    added = tuple(sorted(current_cids - prior_cids))
+    removed = tuple(sorted(prior_cids - current_cids))
+    unchanged = tuple(sorted(current_cids & prior_cids))
+    current_count = int(len(current_cids))
+    prior_count = int(len(prior_cids))
+    if current_count == 0:
+        ratio = 1.0 if prior_count else 0.0
+    else:
+        ratio = 1.0 - (len(unchanged) / float(current_count))
+    equivalent = prior_count == 0 or (not unchanged and current_count > 0)
+    return CorpusDelta(
+        added_cids=added,
+        removed_cids=removed,
+        unchanged_cids=unchanged,
+        prior_count=prior_count,
+        current_count=current_count,
+        changed_ratio=float(ratio),
+        equivalent_to_full=equivalent,
+    )
+
+
+def plan_rebuild(
+    *,
+    mode: BuildMode | str,
+    source_meta: Mapping[str, Any],
+    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)
+    revision = str(source_meta.get("source_revision") or "")
+    fingerprint = source_fingerprint(source_meta)
+    prior_revision = prior.source_revision if prior is not None else None
+    prior_fp = prior.fingerprint if prior is not None else None
+
+    if force or mode is BuildMode.FULL:
+        delta = None
+        if current_corpus is not None and prior is not None:
+            delta = diff_corpus(prior.corpus, current_corpus)
+        return RebuildPlan(
+            kind=RebuildKind.FULL_REBUILD,
+            mode=mode,
+            reason="operator forced full rebuild" if force else "build mode is full",
+            source_revision=revision,
+            prior_revision=prior_revision,
+            source_fingerprint=fingerprint,
+            prior_fingerprint=prior_fp,
+            delta=delta,
+            reuse_embeddings=False,
+            skip_build=False,
+            equivalent_to_full=True,
+        )
+
+    if prior is None:
+        return RebuildPlan(
+            kind=RebuildKind.FULL_REBUILD,
+            mode=mode,
+            reason="no prior release",
+            source_revision=revision,
+            prior_revision=None,
+            source_fingerprint=fingerprint,
+            prior_fingerprint=None,
+            delta=None,
+            reuse_embeddings=False,
+            skip_build=False,
+            equivalent_to_full=True,
+        )
+
+    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,
+            reason="source revision and parquet digests match prior release",
+            source_revision=revision,
+            prior_revision=prior_revision,
+            source_fingerprint=fingerprint,
+            prior_fingerprint=prior_fp,
+            delta=CorpusDelta(
+                unchanged_cids=tuple(sorted(_cid_set(prior.corpus))),
+                prior_count=int(len(_cid_set(prior.corpus))),
+                current_count=int(len(_cid_set(prior.corpus))),
+                changed_ratio=0.0,
+                equivalent_to_full=False,
+            ),
+            reuse_embeddings=True,
+            skip_build=True,
+            equivalent_to_full=False,
+        )
+
+    delta = None
+    if current_corpus is not None:
+        delta = diff_corpus(prior.corpus, current_corpus)
+        if delta.equivalent_to_full:
+            return RebuildPlan(
+                kind=RebuildKind.FULL_REBUILD,
+                mode=mode,
+                reason="CID overlap is empty; delta equals a full rebuild",
+                source_revision=revision,
+                prior_revision=prior_revision,
+                source_fingerprint=fingerprint,
+                prior_fingerprint=prior_fp,
+                delta=delta,
+                reuse_embeddings=False,
+                skip_build=False,
+                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=reason,
+        source_revision=revision,
+        prior_revision=prior_revision,
+        source_fingerprint=fingerprint,
+        prior_fingerprint=prior_fp,
+        delta=delta,
+        reuse_embeddings=True,
+        skip_build=False,
+        equivalent_to_full=False,
+    )
+
+
+def _read_sharded_parquet(directory: Path) -> pd.DataFrame | None:
+    if not directory.is_dir():
+        return None
+    parts = sorted(directory.glob("part-*.parquet"))
+    if not parts:
+        parts = sorted(p for p in directory.rglob("*.parquet") if p.is_file())
+    if not parts:
+        return None
+    frames = [pd.read_parquet(p) for p in parts]
+    return pd.concat(frames, ignore_index=True) if frames else None
+
+
+def load_release_manifest(release_dir: Path) -> dict[str, Any]:
+    path = Path(release_dir) / "manifest.json"
+    if not path.is_file():
+        return {}
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def load_release_corpus(release_dir: Path) -> pd.DataFrame | None:
+    release_dir = Path(release_dir)
+    corpus = _read_sharded_parquet(release_dir / "data" / "corpus")
+    if corpus is not None:
+        return corpus
+    checkpoint = release_dir / "corpus.parquet"
+    if checkpoint.is_file():
+        return pd.read_parquet(checkpoint)
+    return None
+
+
+def embeddings_from_vector_table(frame: pd.DataFrame) -> dict[str, list[float]]:
+    out: dict[str, list[float]] = {}
+    if frame is None or frame.empty:
+        return out
+    if "entry_cid" not in frame.columns or "embedding" not in frame.columns:
+        return out
+    for rec in frame.itertuples(index=False):
+        cid = str(getattr(rec, "entry_cid", "") or "")
+        emb = getattr(rec, "embedding", None)
+        if not cid or emb is None:
+            continue
+        if isinstance(emb, float) and pd.isna(emb):
+            continue
+        try:
+            values = [float(x) for x in list(emb)]
+        except Exception:
+            continue
+        if not values:
+            continue
+        out[cid] = values
+    return out
+
+
+def load_release_vectors_by_cid(release_dir: Path) -> dict[str, list[float]]:
+    frame = _read_sharded_parquet(Path(release_dir) / "data" / "vectors")
+    if frame is None:
+        return {}
+    return embeddings_from_vector_table(frame)
+
+
+def load_prior_release(release_dir: Path | None) -> PriorRelease | None:
+    if release_dir is None:
+        return None
+    directory = Path(release_dir)
+    if not directory.is_dir():
+        return None
+    manifest = load_release_manifest(directory)
+    if not manifest and not (directory / "data").is_dir():
+        return None
+    return PriorRelease(
+        directory=directory,
+        manifest=manifest,
+        corpus=load_release_corpus(directory),
+        vectors_by_cid=None,
+    )
+
+
+def load_embedding_cache(path: Path) -> dict[str, list[float]]:
+    if not path.is_file():
+        return {}
+    try:
+        frame = pd.read_parquet(path)
+    except Exception:
+        return {}
+    return embeddings_from_vector_table(frame)
+
+
+def save_embedding_cache(
+    path: Path,
+    by_cid: Mapping[str, Iterable[float]],
+    *,
+    model_name: str,
+    dimension: int,
+) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    rows = [
+        {
+            "entry_cid": cid,
+            "embedding": list(vec),
+            "model_name": model_name,
+            "dimension": int(dimension),
+        }
+        for cid, vec in sorted(by_cid.items())
+    ]
+    frame = pd.DataFrame(rows)
+    tmp = path.with_suffix(path.suffix + ".tmp")
+    frame.to_parquet(tmp, index=False)
+    tmp.replace(path)
+
+
+def merge_embedding_maps(
+    *maps: Mapping[str, list[float]] | None,
+) -> dict[str, list[float]]:
+    merged: dict[str, list[float]] = {}
+    for mapping in maps:
+        if not mapping:
+            continue
+        merged.update(mapping)
+    return merged
+
+
+def fetch_hub_prior(
+    slug: str,
+    dest: Path | None = None,
+    *,
+    cache_root: Path | None = None,
+) -> Path | None:
+    """Download JusticeDAO corpus+vector shards to use as an incremental parent.
+
+    Missing Hub IR is not an error: first-time countries return ``None``.
+    """
+    from huggingface_hub import snapshot_download
+    from huggingface_hub.errors import RepositoryNotFoundError
+
+    from .auth import operator_token, public_token
+    from .catalog import target_repo
+
+    root = Path(cache_root) if cache_root is not None else (
+        Path.home() / ".ipfs_datasets" / "country-laws-ir" / "cache" / "hub-ir"
+    )
+    dest = Path(dest) if dest is not None else (root / slug)
+    dest.mkdir(parents=True, exist_ok=True)
+    repo = target_repo(slug)
+    try:
+        snapshot_download(
+            repo_id=repo,
+            repo_type="dataset",
+            local_dir=str(dest),
+            allow_patterns=[
+                "manifest.json",
+                "data/vectors/**",
+                "data/corpus/**",
+                "indexes/vector_chunks.parquet",
+            ],
+            token=operator_token() or public_token(),
+        )
+    except RepositoryNotFoundError:
+        return None
+    except Exception:
+        if not (dest / "manifest.json").is_file():
+            return None
+        raise
+    if not (dest / "manifest.json").is_file():
+        return None
+    return dest

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,30 +12,42 @@ from __future__ import annotations
 
 import json
 import os
-import re
-import unicodedata
 from collections import Counter
 from pathlib import Path
 from typing import Any
 
 import pandas as pd
 from huggingface_hub import dataset_info, hf_hub_download
+from huggingface_hub.errors import EntryNotFoundError
 
 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",
+    "id",
+    "title",
+    "text",
+    "source_url",
+    "document_number",
+    "article_number",
+    "record_type",
+    "metadata_json",
+)
+
+
+def _empty_articles() -> pd.DataFrame:
+    return pd.DataFrame(columns=list(EMPTY_ARTICLE_COLUMNS))
 
 
 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:
@@ -53,21 +66,34 @@ def _download(repo_id: str, filename: str, cache_dir: Path) -> Path:
     return Path(path)
 
 
-def _resolve_local_parquet(root: Path, name: str) -> Path:
+def _repo_filenames(info: Any) -> set[str]:
+    return {str(getattr(s, "rfilename", "") or "") for s in (getattr(info, "siblings", None) or [])}
+
+
+def _pick_repo_file(filenames: set[str], name: str) -> str | None:
+    for cand in (f"data/{name}.parquet", f"{name}.parquet"):
+        if cand in filenames:
+            return cand
+    return None
+
+
+def _resolve_local_parquet(root: Path, name: str, *, required: bool = True) -> Path | None:
     """Accept either <root>/data/<name>.parquet or <root>/<name>.parquet."""
     for cand in (root / "data" / f"{name}.parquet", root / f"{name}.parquet"):
         if cand.is_file():
             return cand
-    raise FileNotFoundError(f"missing {name}.parquet under {root} (tried data/ and root)")
+    if required:
+        raise FileNotFoundError(f"missing {name}.parquet under {root} (tried data/ and root)")
+    return None
 
 
 def load_local_source(local_dir: Path) -> tuple[pd.DataFrame, pd.DataFrame, dict[str, Any]]:
     """Load a local country-laws pack (filtered preprocess layout)."""
     local_dir = Path(local_dir).resolve()
     laws_path = _resolve_local_parquet(local_dir, "laws")
-    articles_path = _resolve_local_parquet(local_dir, "articles")
+    articles_path = _resolve_local_parquet(local_dir, "articles", required=False)
     laws = pd.read_parquet(laws_path)
-    articles = pd.read_parquet(articles_path)
+    articles = pd.read_parquet(articles_path) if articles_path is not None else _empty_articles()
     validate_laws(laws)
     validate_articles(articles)
     pack_meta: dict[str, Any] = {}
@@ -91,9 +117,9 @@ def load_local_source(local_dir: Path) -> tuple[pd.DataFrame, pd.DataFrame, dict
         "source_dataset": source_dataset,
         "source_revision": source_revision,
         "laws_path": str(laws_path),
-        "articles_path": str(articles_path),
+        "articles_path": str(articles_path) if articles_path is not None else None,
         "laws_sha256": sha256_file(laws_path),
-        "articles_sha256": sha256_file(articles_path),
+        "articles_sha256": sha256_file(articles_path) if articles_path is not None else None,
         "n_laws_source": int(len(laws)),
         "n_articles_source": int(len(articles)),
         "laws_columns": list(map(str, laws.columns)),
@@ -118,19 +144,27 @@ def load_source(repo_id: str, cache_dir: Path) -> tuple[pd.DataFrame, pd.DataFra
     os.environ.setdefault("HF_HOME", str(cache_dir / "hf"))
     info = dataset_info(repo_id, token=public_token())
     revision = info.sha
-    laws_path = _download(repo_id, "data/laws.parquet", cache_dir)
-    articles_path = _download(repo_id, "data/articles.parquet", cache_dir)
+    filenames = _repo_filenames(info)
+    laws_file = _pick_repo_file(filenames, "laws") or "data/laws.parquet"
+    articles_file = _pick_repo_file(filenames, "articles")
+    laws_path = _download(repo_id, laws_file, cache_dir)
+    articles_path: Path | None = None
+    if articles_file is not None:
+        try:
+            articles_path = _download(repo_id, articles_file, cache_dir)
+        except EntryNotFoundError:
+            articles_path = None
     laws = pd.read_parquet(laws_path)
-    articles = pd.read_parquet(articles_path)
+    articles = pd.read_parquet(articles_path) if articles_path is not None else _empty_articles()
     validate_laws(laws)
     validate_articles(articles)
     meta = {
         "source_dataset": repo_id,
         "source_revision": revision,
         "laws_path": str(laws_path),
-        "articles_path": str(articles_path),
+        "articles_path": str(articles_path) if articles_path is not None else None,
         "laws_sha256": sha256_file(laws_path),
-        "articles_sha256": sha256_file(articles_path),
+        "articles_sha256": sha256_file(articles_path) if articles_path is not None else None,
         "n_laws_source": int(len(laws)),
         "n_articles_source": int(len(articles)),
         "laws_columns": list(map(str, laws.columns)),
@@ -248,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):
@@ -452,6 +515,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"]
+                        ),
                     },
                 )
             )
@@ -464,6 +530,49 @@ def build_corpus(
                     report["drop_samples"]["empty_body"].append(instrument_id)
                 continue
             meta = parent["metadata"]
+            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),
+                            },
+                        )
+                    )
+                continue
             entries.append(
                 _base_record(
                     record_type="law",
@@ -494,6 +603,9 @@ def build_corpus(
                         "law_status": parent["law_status"],
                         "parent_law_id": "",
                         "article_id": "",
+                        **_hierarchy_fields(
+                            parent["instrument_title"], body, "", language=parent["language"]
+                        ),
                     },
                 )
             )
@@ -570,5 +682,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

@@ -34,8 +34,11 @@ def package_release(
     country: dict[str, Any],
     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"
@@ -51,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.
@@ -195,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),
@@ -214,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"])
@@ -247,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,
@@ -324,12 +358,35 @@ def package_release(
         },
         "source": source_meta,
     }
+    if extra_manifest:
+        manifest.update(extra_manifest)
     (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"
@@ -546,6 +603,7 @@ def package_release_sequential(
     code_root: Path,
     normalization_report: dict[str, Any] | None = None,
     expected_rows: int | None = None,
+    extra_manifest: dict[str, Any] | None = None,
 ) -> dict[str, Any]:
     """Write release layout one section at a time (never hold corpus+bm25+graph+vectors).
 
@@ -753,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 = {
@@ -835,11 +895,14 @@ def package_release_sequential(
         },
         "source": source_meta,
     }
+    if extra_manifest:
+        manifest.update(extra_manifest)
     (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, gstats, vstats, hub_id)
     _write_gitattributes(out)
+    _write_dataset_configs(out)
     checkpoint("package_seq_done")
     return manifest
 
@@ -853,14 +916,20 @@ def package_from_spill(
     code_root: Path,
     normalization_report: dict[str, Any] | None = None,
     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),
@@ -874,4 +943,5 @@ def package_from_spill(
         code_root=Path(code_root),
         normalization_report=normalization_report,
         expected_rows=expected_rows,
+        extra_manifest=extra_manifest,
     )

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:
@@ -164,13 +176,17 @@ 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)
 
     args = ap.parse_args(argv)

country_laws_ir/raw_package.py

@@ -0,0 +1,324 @@
+"""Incrementally package raw collector instruments into laws/articles parquet.
+
+Collectors write one JSON instrument per official page under
+``$LEGAL_CORPORA_ROOT/<iso>/instruments/*.json``. Those files grow as new
+pages are scraped. This module merges them into the ``endomorphosis/ipfs_*_laws``
+parquet schema without rewriting unchanged rows, so the GraphRAG builder can
+delta-rebuild from the resulting pack.
+
+Never invents legal text or identifiers. Empty/short bodies are dropped, not
+filled.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+import pandas as pd
+
+from .cidutil import sha256_file
+from .schema import LAW_FIELD_MAP, REQUIRED_ARTICLE_COLUMNS, REQUIRED_LAW_COLUMNS
+
+LAW_COLS = [
+    "id",
+    "title",
+    "text",
+    "source_url",
+    "source_type",
+    "jurisdiction",
+    "country",
+    "language",
+    "eli",
+    "date",
+    "date_issued",
+    "retrieved_at",
+    "license",
+    "law_status",
+    "identifier",
+    "official_identifier",
+    "article_count",
+    "json_path",
+    "metadata_json",
+]
+ART_COLS = [
+    "law_id",
+    "id",
+    "title",
+    "text",
+    "source_url",
+    "document_number",
+    "article_number",
+    "record_type",
+    "metadata_json",
+]
+
+MIN_BODY_CHARS = 80
+DEFAULT_CORPORA_ROOT = Path(
+    os.environ.get(
+        "LEGAL_CORPORA_ROOT",
+        str(Path.home() / ".ipfs_datasets" / "legal-corpora"),
+    )
+)
+
+
+def _s(value: Any) -> str:
+    if value is None:
+        return ""
+    return str(value).strip()
+
+
+def _meta_json(value: Any) -> str:
+    if isinstance(value, str):
+        return value
+    try:
+        return json.dumps(value or {}, ensure_ascii=False)
+    except Exception:
+        return "{}"
+
+
+def instruments_to_frames(
+    instruments_dir: Path,
+    *,
+    min_body_chars: int = MIN_BODY_CHARS,
+) -> tuple[pd.DataFrame, pd.DataFrame, dict[str, Any]]:
+    """Read collector JSON instruments into laws/articles dataframes."""
+    laws: list[dict[str, Any]] = []
+    arts: list[dict[str, Any]] = []
+    skipped_short = 0
+    skipped_bad = 0
+    root = Path(instruments_dir)
+    files = sorted(root.glob("*.json")) if root.is_dir() else []
+    for path in files:
+        try:
+            rec = json.loads(path.read_text(encoding="utf-8"))
+        except Exception:
+            skipped_bad += 1
+            continue
+        if not isinstance(rec, dict):
+            skipped_bad += 1
+            continue
+        text = _s(rec.get("text"))
+        ident = _s(rec.get("id"))
+        title = _s(rec.get("title"))
+        if not ident or not title or len(text) < min_body_chars:
+            skipped_short += 1
+            continue
+        meta = rec.get("metadata") or {}
+        laws.append(
+            {
+                "id": ident,
+                "title": title,
+                "text": text,
+                "source_url": _s(rec.get("source_url")),
+                "source_type": _s(rec.get("source_type")),
+                "jurisdiction": _s(rec.get("jurisdiction")),
+                "country": _s(rec.get("country")),
+                "language": _s(rec.get("language")),
+                "eli": _s(rec.get("eli")) or None,
+                "date": _s(rec.get("date")) or None,
+                "date_issued": _s(rec.get("date_issued") or rec.get("date")) or None,
+                "retrieved_at": _s(rec.get("retrieved_at")) or None,
+                "license": _s(rec.get("license")),
+                "law_status": _s(rec.get("law_status")),
+                "identifier": _s(rec.get("identifier")) or ident,
+                "official_identifier": _s(rec.get("official_identifier")),
+                "article_count": rec.get("article_count") or len(rec.get("documents") or []),
+                "json_path": f"instruments/{path.name}",
+                "metadata_json": _meta_json(meta),
+            }
+        )
+        for doc in rec.get("documents") or []:
+            if not isinstance(doc, dict):
+                continue
+            art_id = _s(doc.get("id"))
+            art_title = _s(doc.get("title"))
+            art_text = _s(doc.get("text"))
+            if not art_id or not art_title or not art_text:
+                continue
+            arts.append(
+                {
+                    "law_id": ident,
+                    "id": art_id,
+                    "title": art_title,
+                    "text": art_text,
+                    "source_url": _s(doc.get("source_url")) or _s(rec.get("source_url")),
+                    "document_number": _s(doc.get("document_number")),
+                    "article_number": _s(doc.get("article_number")),
+                    "record_type": _s(doc.get("record_type")) or "article",
+                    "metadata_json": _meta_json(doc.get("metadata") or {}),
+                }
+            )
+    report = {
+        "n_instrument_files": len(files),
+        "n_laws": len(laws),
+        "n_articles": len(arts),
+        "skipped_short_or_empty": skipped_short,
+        "skipped_unreadable": skipped_bad,
+        "min_body_chars": min_body_chars,
+        "never_invented_legal_text": True,
+        "required_law_columns": list(REQUIRED_LAW_COLUMNS),
+        "required_article_columns": list(REQUIRED_ARTICLE_COLUMNS),
+        "law_field_map": dict(LAW_FIELD_MAP),
+    }
+    return (
+        pd.DataFrame(laws, columns=LAW_COLS),
+        pd.DataFrame(arts, columns=ART_COLS),
+        report,
+    )
+
+
+def _retrieved_key(value: Any) -> str:
+    return _s(value)
+
+
+def merge_laws(prior: pd.DataFrame | None, incoming: pd.DataFrame) -> pd.DataFrame:
+    """Upsert laws by ``id``. Newer ``retrieved_at`` wins; otherwise incoming wins."""
+    if prior is None or prior.empty:
+        return incoming.copy() if incoming is not None else pd.DataFrame(columns=LAW_COLS)
+    if incoming is None or incoming.empty:
+        return prior.copy()
+    by_id: dict[str, dict[str, Any]] = {}
+    for frame, incoming_flag in ((prior, False), (incoming, True)):
+        for rec in frame.to_dict(orient="records"):
+            ident = _s(rec.get("id"))
+            if not ident:
+                continue
+            existing = by_id.get(ident)
+            if existing is None:
+                by_id[ident] = rec
+                continue
+            if incoming_flag:
+                new_ts = _retrieved_key(rec.get("retrieved_at"))
+                old_ts = _retrieved_key(existing.get("retrieved_at"))
+                if not old_ts or new_ts >= old_ts:
+                    by_id[ident] = rec
+    rows = [by_id[k] for k in sorted(by_id)]
+    return pd.DataFrame(rows, columns=LAW_COLS)
+
+
+def merge_articles(prior: pd.DataFrame | None, incoming: pd.DataFrame) -> pd.DataFrame:
+    """Upsert articles by ``id``. Incoming replaces the same article id."""
+    if prior is None or prior.empty:
+        return incoming.copy() if incoming is not None else pd.DataFrame(columns=ART_COLS)
+    if incoming is None or incoming.empty:
+        return prior.copy()
+    by_id: dict[str, dict[str, Any]] = {}
+    for frame in (prior, incoming):
+        for rec in frame.to_dict(orient="records"):
+            ident = _s(rec.get("id"))
+            if not ident:
+                continue
+            by_id[ident] = rec
+    rows = [by_id[k] for k in sorted(by_id)]
+    return pd.DataFrame(rows, columns=ART_COLS)
+
+
+def load_existing_parquet(pack_dir: Path) -> tuple[pd.DataFrame | None, pd.DataFrame | None]:
+    pack_dir = Path(pack_dir)
+    laws_path = None
+    arts_path = None
+    for cand in (pack_dir / "data" / "laws.parquet", pack_dir / "laws.parquet"):
+        if cand.is_file():
+            laws_path = cand
+            break
+    for cand in (pack_dir / "data" / "articles.parquet", pack_dir / "articles.parquet"):
+        if cand.is_file():
+            arts_path = cand
+            break
+    laws = pd.read_parquet(laws_path) if laws_path else None
+    arts = pd.read_parquet(arts_path) if arts_path else None
+    return laws, arts
+
+
+def write_pack(
+    out: Path,
+    laws: pd.DataFrame,
+    articles: pd.DataFrame,
+    *,
+    slug: str,
+    source_dataset: str,
+    name: str | None = None,
+    extra_meta: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    """Write a local pack that ``load_source`` / ``get_country`` can consume."""
+    out = Path(out)
+    data_dir = out / "data"
+    data_dir.mkdir(parents=True, exist_ok=True)
+    laws_path = data_dir / "laws.parquet"
+    arts_path = data_dir / "articles.parquet"
+    laws.to_parquet(laws_path, index=False)
+    articles.to_parquet(arts_path, index=False)
+    now = datetime.now(timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z")
+    meta = {
+        "slug": slug,
+        "repo": source_dataset,
+        "source_dataset": source_dataset,
+        "name": name or slug.replace("_", " ").title(),
+        "indexable": True,
+        "source_revision": f"local:{now}",
+        "n_laws": int(len(laws)),
+        "n_articles": int(len(articles)),
+        "laws_sha256": sha256_file(laws_path),
+        "articles_sha256": sha256_file(arts_path),
+        "generated_at": now,
+        "incremental": True,
+    }
+    if extra_meta:
+        meta.update(extra_meta)
+    (out / "pack_meta.json").write_text(
+        json.dumps(meta, indent=2, ensure_ascii=False) + "\n",
+        encoding="utf-8",
+    )
+    return meta
+
+
+def package_instruments(
+    *,
+    instruments_dir: Path,
+    out: Path,
+    slug: str,
+    source_dataset: str | None = None,
+    prior_pack: Path | None = None,
+    name: str | None = None,
+    min_body_chars: int = MIN_BODY_CHARS,
+) -> dict[str, Any]:
+    """Merge collector JSON (+ optional prior parquet) into a local IR source pack."""
+    incoming_laws, incoming_arts, extract_report = instruments_to_frames(
+        instruments_dir, min_body_chars=min_body_chars
+    )
+    prior_laws = prior_arts = None
+    prior_dir = Path(prior_pack) if prior_pack else (out if out.exists() else None)
+    if prior_dir is not None:
+        prior_laws, prior_arts = load_existing_parquet(prior_dir)
+    laws = merge_laws(prior_laws, incoming_laws)
+    articles = merge_articles(prior_arts, incoming_arts)
+    if laws.empty:
+        raise RuntimeError(
+            f"no laws with text>={min_body_chars} under {instruments_dir}"
+        )
+    repo = source_dataset or f"endomorphosis/ipfs_{slug}_laws"
+    meta = write_pack(
+        out,
+        laws,
+        articles,
+        slug=slug,
+        source_dataset=repo,
+        name=name,
+        extra_meta={"extract": extract_report},
+    )
+    meta["extract"] = extract_report
+    meta["n_laws_prior"] = int(len(prior_laws)) if prior_laws is not None else 0
+    meta["n_articles_prior"] = int(len(prior_arts)) if prior_arts is not None else 0
+    meta["n_laws_incoming"] = int(len(incoming_laws))
+    meta["n_articles_incoming"] = int(len(incoming_arts))
+    meta["out"] = str(out)
+    return meta
+
+
+def default_instruments_dir(iso_or_slug: str, root: Path | None = None) -> Path:
+    base = Path(root) if root is not None else DEFAULT_CORPORA_ROOT
+    return base / iso_or_slug / "instruments"

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

@@ -1,24 +1,132 @@
-"""Hub upload is intentionally not implemented in this local pipeline.
+"""Publish a local country-laws-ir release to the JusticeDAO Hugging Face org.
 
-Later publish (operator machine, never from this run):
-
-    export HF_TOKEN=...   # never commit / never echo
-    hf upload-large-folder justicedao/ipfs_malta_laws_ir \\
-      /workspace/country-laws-ir/releases/ipfs_malta_laws_ir \\
-      --repo-type dataset --no-private --num-workers 8 \\
-      --exclude "**/__pycache__/**" --exclude "**/*.pyc"
+Reads stay anonymous (see ``auth.py``). Writes require an explicit ``--upload``
+path, a ``justicedao/`` repo id, and ``HF_TOKEN``. Protected LCR repositories
+are fail-closed via ``require_unprotected_or_runtime``.
 """
 
 from __future__ import annotations
 
+import os
 from pathlib import Path
 from typing import Any
 
+from . import TARGET_ORG
+
+_OPERATOR_HINT = (
+    "Publish later with: hf upload-large-folder "
+    "{repo} {local_dir} --repo-type dataset --no-private --num-workers 8 "
+    '--exclude "**/__pycache__/**" --exclude "**/*.pyc"'
+)
+
+
+class UploadError(RuntimeError):
+    """Raised when a JusticeDAO upload cannot proceed."""
+
+
+def _token_from_env() -> str:
+    for key in ("HF_TOKEN", "HUGGING_FACE_HUB_TOKEN"):
+        value = (os.environ.get(key) or "").strip()
+        if value:
+            return value
+    token_path = Path.home() / ".cache" / "huggingface" / "token"
+    if token_path.is_file():
+        try:
+            return token_path.read_text(encoding="utf-8").strip()
+        except OSError:
+            return ""
+    return ""
+
+
+def upload_release(
+    local_dir: Path,
+    repo_id: str,
+    *,
+    token: str | None = None,
+    commit_message: str | None = None,
+    create: bool = True,
+) -> dict[str, Any]:
+    local_dir = Path(local_dir)
+    repo_id = str(repo_id or "").strip()
+    if not local_dir.is_dir():
+        raise UploadError(f"release directory does not exist: {local_dir}")
+    if not repo_id.startswith(f"{TARGET_ORG}/"):
+        raise UploadError(
+            f"country-laws-ir publishes only to {TARGET_ORG}/*; got {repo_id!r}"
+        )
+    if not (local_dir / "manifest.json").is_file():
+        raise UploadError(f"release is missing manifest.json: {local_dir}")
+
+    # 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")
+    except UploadError:
+        raise
+    except Exception:
+        pass
+
+    resolved = (token or "").strip() or _token_from_env()
+    if not resolved:
+        raise UploadError(
+            "HF_TOKEN is required for --upload. "
+            + _OPERATOR_HINT.format(repo=repo_id, local_dir=local_dir)
+        )
+
+    from huggingface_hub import HfApi
+
+    api = HfApi(token=resolved)
+    if create:
+        api.create_repo(repo_id=repo_id, repo_type="dataset", exist_ok=True, private=False)
+    ignore = ["**/__pycache__/**", "**/*.pyc", "**/*.tmp", "**/*.tmp.npy"]
+    n_files = sum(1 for path in local_dir.rglob("*") if path.is_file())
+    nbytes = sum(path.stat().st_size for path in local_dir.rglob("*") if path.is_file())
+    use_large = n_files >= 80 or nbytes >= 80 * 1024 * 1024
+    if use_large and hasattr(api, "upload_large_folder"):
+        api.upload_large_folder(
+            folder_path=str(local_dir),
+            repo_id=repo_id,
+            repo_type="dataset",
+            ignore_patterns=ignore,
+        )
+        revision = ""
+        try:
+            from huggingface_hub import dataset_info as _dataset_info
 
-def upload_release(local_dir: Path, repo_id: str) -> dict[str, Any]:
-    raise RuntimeError(
-        "Hub upload is disabled in the local country-laws-ir pipeline. "
-        "Publish later with: hf upload-large-folder "
-        f"{repo_id} {local_dir} --repo-type dataset --no-private --num-workers 8 "
-        '--exclude "**/__pycache__/**" --exclude "**/*.pyc"'
+            pinned = _dataset_info(repo_id, token=resolved)
+            revision = str(getattr(pinned, "sha", "") or "")
+        except Exception:
+            revision = ""
+        return {
+            "url": f"https://huggingface.co/datasets/{repo_id}",
+            "repo_id": repo_id,
+            "revision": revision,
+            "local_dir": str(local_dir),
+            "method": "upload_large_folder",
+        }
+    info = api.upload_folder(
+        folder_path=str(local_dir),
+        repo_id=repo_id,
+        repo_type="dataset",
+        commit_message=commit_message
+        or f"Incremental country-laws-ir GraphRAG release for {repo_id}",
+        ignore_patterns=ignore,
     )
+    revision = getattr(info, "oid", None) or getattr(info, "commit_id", None) or ""
+    return {
+        "url": f"https://huggingface.co/datasets/{repo_id}",
+        "repo_id": repo_id,
+        "revision": revision,
+        "local_dir": str(local_dir),
+        "method": "upload_folder",
+    }

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("/workspace/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:
@@ -160,25 +261,29 @@ def _spherical_kmeans(x: np.ndarray, k: int, iters: int = 12, seed: int = 0) ->
 
 
 def _recursive_clusters(x: np.ndarray, max_size: int = MAX_ROWS_PER_FILE) -> list[np.ndarray]:
+    """Split vectors into shards of at most *max_size* without unbounded recursion.
+
+    Spherical k-means can fail to split (all points one label). In that case
+    fall back to an even index split so layout cannot recurse forever.
+    """
     n = len(x)
-    idx = np.arange(n)
-    if n <= max_size:
-        return [idx]
-    labels = _spherical_kmeans(x, k=2)
-    clusters = []
-    for lab in (0, 1):
-        members = idx[labels == lab]
-        if len(members) == 0:
+    if n == 0:
+        return []
+    pending: list[np.ndarray] = [np.arange(n)]
+    clusters: list[np.ndarray] = []
+    while pending:
+        idx = pending.pop()
+        if len(idx) <= max_size:
+            clusters.append(idx)
             continue
-        if len(members) <= max_size:
-            clusters.append(members)
-        else:
-            sub = _recursive_clusters(x[members], max_size=max_size)
-            clusters.extend([members[s] for s in sub])
-    if not clusters:
-        mid = n // 2
-        return [idx[:mid], idx[mid:]]
-    return clusters
+        labels = _spherical_kmeans(x[idx], k=2)
+        parts = [idx[labels == lab] for lab in (0, 1)]
+        parts = [p for p in parts if len(p)]
+        if len(parts) < 2 or max(len(p) for p in parts) == len(idx):
+            mid = len(idx) // 2
+            parts = [idx[:mid], idx[mid:]]
+        pending.extend(parts)
+    return clusters or [np.arange(n)]
 
 
 def layout_vectors(corpus: pd.DataFrame, embeddings: np.ndarray) -> dict[str, Any]:
@@ -333,3 +438,85 @@ def layout_stub_vectors(corpus: pd.DataFrame, reason: str) -> dict[str, Any]:
             ],
         },
     }
+
+
+def assemble_embeddings(
+    corpus: pd.DataFrame,
+    prior_by_cid: dict[str, list[float]] | None = None,
+    *,
+    encode_missing: bool = True,
+    batch_size: int = 64,
+    device: str = DEFAULT_DEVICE,
+    checkpoint_path: str | None = None,
+) -> tuple[np.ndarray, dict[str, Any]]:
+    """Align a (n, 384) matrix to *corpus* row order.
+
+    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)
+    prior = prior_by_cid or {}
+    reused_idx: list[int] = []
+    missing_idx: list[int] = []
+    cids = corpus["entry_cid"].astype(str).tolist() if n else []
+    for i, cid in enumerate(cids):
+        vec = prior.get(cid)
+        if not _is_real_vector(vec):
+            missing_idx.append(i)
+            continue
+        out[i] = np.asarray(vec, dtype=np.float32).reshape(-1)
+        reused_idx.append(i)
+
+    report: dict[str, Any] = {
+        "n_docs": n,
+        "n_reused": len(reused_idx),
+        "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 ensure_embedding_stack():
+        report["status"] = "stub_missing_encoder"
+        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=resolved,
+        checkpoint_path=checkpoint_path,
+    )
+    for local_i, corpus_i in enumerate(missing_idx):
+        out[corpus_i] = encoded[local_i]
+    report["n_encoded"] = int(len(missing_idx))
+    report["n_missing"] = 0
+    report["status"] = "merged"
+    return _l2_normalize(out), report
+
+
+def embeddings_by_cid(corpus: pd.DataFrame, matrix: np.ndarray) -> dict[str, list[float]]:
+    """Project a row-aligned embedding matrix back to a CID map."""
+    out: dict[str, list[float]] = {}
+    if corpus is None or corpus.empty:
+        return out
+    x = np.asarray(matrix, dtype=np.float32)
+    cids = corpus["entry_cid"].astype(str).tolist()
+    for i, cid in enumerate(cids):
+        if i >= len(x):
+            break
+        out[cid] = x[i].astype(np.float32).tolist()
+    return out

country_laws_ir/verify.py

@@ -0,0 +1,280 @@
+"""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_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"} 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_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:860a20675797c95295d0858ae80606b1c41f8085b5518b375e9abe0cc3c71dc1
-size 368561
+oid sha256:c5fd4064d3307d65014eda40a56474c085ee0eac48f6882aafd2eeb9596fe5df
+size 505685

data/bm25/documents/part-000001.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9aed57473c8c6a419d70f7a88e2f812d42d903624437d261637119ced083bf3c
-size 368413
+oid sha256:74795c6ccfa80c09b8bd6bc315c86eb173ec038addbaf3a286731a9836908b2d
+size 505256

data/bm25/documents/part-000002.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:2865aebd34ab1550cb1bde375e4b8746f414cdb97092ff30cf33af92dfb8ef99
-size 165483
+oid sha256:f8fcb8e856d47144a383b748ad2c1e75f27399b68f0bfbf61f2f7a82ca5236d0
+size 207945

data/bm25/postings/part-000000.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:449352808135f06bfca2bf528de4e6f8b0d6cd3a3f34984c87edfd2570c745f1
-size 793240
+oid sha256:74899c071ecc3ab75bd7fcac7ad5a6fa4f38f0b7fffbe8fd973f58f718873c22
+size 209619

data/bm25/postings/part-000001.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:033470212ddcd40e12979c4ddd2443fcf4a03786ede837ce4024837ffec7ab04
-size 783392
+oid sha256:8be646723478d95c9e03a8a4e5b12ccd93c6bd6ab645e468bb05e6515fc0c493
+size 594030

data/bm25/postings/part-000002.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:0c17ca6cb1c03079c20f9c96336842b1412e554bd555d4c5024085b863697754
-size 948081
+oid sha256:8497d4b6354f5c3b31181f041bb4e055c2e1d49fb8114803af454071d56415e3
+size 514556

data/bm25/postings/part-000003.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:61e65f19169774f27e5cd71a3e00db3dee7aa3d13c36b87042d838cd71d996ac
-size 990527
+oid sha256:35b3910b79ba80d5e12f86b657485f40c98ea7a7a26ff5814d17e6eb63595c20
+size 500924

data/bm25/postings/part-000004.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:22b90eb7821fa024d2fe0fcb23a9828b010058381b364b1eeafac5d9bbe98cd7
-size 272391
+oid sha256:f1e4707df479e2f0087ce851102cb5e8bbc4a2572cc1aa72c34dc795ca2e58c6
+size 566517

data/bm25/postings/part-000005.parquet

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

data/corpus/part-000000.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:bd47600c807926c73563bf5c40579653a2b8e937ab6e5a1634605b541ca46c9d
-size 1561917
+oid sha256:f19ce33a158a468119e6fc7f7de456d5482dbd1c0a7e20d2ecc47a72fed4d74c
+size 1570303

data/corpus/part-000001.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:db51d39448f4f36bdd0e70cb7a3413acb3e0bbd72df05f86604365d5625e5cba
-size 1453906
+oid sha256:edd08e86c071d1146b68a4662720faedeb109b3b4cd008ae44fab6594a5cfb8d
+size 1460927

data/corpus/part-000002.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:93f54c3b249d84fcc259f5022b23e99101d1ae515143995e4605414b0f8baa55
-size 596594
+oid sha256:8f48adf69ee081949795f9aa1a9de3b6ee497ce8b9035fbc5f7c816e019ce256
+size 601572

data/graph/adjacency/in/part-000000.parquet

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

data/graph/adjacency/in/part-000001.parquet

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

data/graph/adjacency/in/part-000002.parquet

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

data/graph/adjacency/in/part-000003.parquet

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

data/graph/adjacency/in/part-000004.parquet

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

data/graph/adjacency/in/part-000005.parquet

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

data/graph/adjacency/in/part-000006.parquet

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

data/graph/adjacency/in/part-000007.parquet

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

data/graph/adjacency/in/part-000008.parquet

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

data/graph/adjacency/in/part-000009.parquet

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

data/graph/adjacency/out/part-000000.parquet

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

data/graph/adjacency/out/part-000001.parquet

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

data/graph/adjacency/out/part-000002.parquet

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

data/graph/adjacency/out/part-000003.parquet

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

data/graph/adjacency/out/part-000004.parquet

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

data/graph/adjacency/out/part-000005.parquet

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