Incremental country-laws-ir GraphRAG release for justicedao/ipfs_belarus_laws_ir

.gitattributes

@@ -1,60 +1,2 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.avro filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.lz4 filter=lfs diff=lfs merge=lfs -text
-*.mds filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
 *.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
-# Audio files - uncompressed
-*.pcm filter=lfs diff=lfs merge=lfs -text
-*.sam filter=lfs diff=lfs merge=lfs -text
-*.raw filter=lfs diff=lfs merge=lfs -text
-# Audio files - compressed
-*.aac filter=lfs diff=lfs merge=lfs -text
-*.flac filter=lfs diff=lfs merge=lfs -text
-*.mp3 filter=lfs diff=lfs merge=lfs -text
-*.ogg filter=lfs diff=lfs merge=lfs -text
-*.wav filter=lfs diff=lfs merge=lfs -text
-# Image files - uncompressed
-*.bmp filter=lfs diff=lfs merge=lfs -text
-*.gif filter=lfs diff=lfs merge=lfs -text
-*.png filter=lfs diff=lfs merge=lfs -text
-*.tiff filter=lfs diff=lfs merge=lfs -text
-# Image files - compressed
-*.jpg filter=lfs diff=lfs merge=lfs -text
-*.jpeg filter=lfs diff=lfs merge=lfs -text
-*.webp filter=lfs diff=lfs merge=lfs -text
-# Video files - compressed
-*.mp4 filter=lfs diff=lfs merge=lfs -text
-*.webm filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,3 +1,132 @@
-# justicedao/ipfs_belarus_laws_ir
+---
+license: other
+task_categories:
+- text-retrieval
+tags:
+- legal
+- law
+- graphrag
+- bm25
+- research
+- not-legal-advice
+- belarus
+pretty_name: Belarus 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
+---
 
-Belarus laws IR release.
+# Belarus legislation IR (CID-keyed sparse GraphRAG)
+
+Research retrieval release of `endomorphosis/ipfs_belarus_laws` (revision `b5fe172bd073c7217d379965fb38646fc2c60bc3`) 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 Belarus 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_belarus_laws_ir`.
+
+## Counts
+
+| Field | Value |
+| --- | --- |
+| Laws (corpus units) | 0 |
+| Articles (corpus units) | 7206 |
+| Canonical docs | 7206 |
+| BM25 terms | 3186 |
+| BM25 postings | 38886 |
+| Graph nodes | 7276 |
+| Graph edges | 50442 |
+| Vectors | 7206 × 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_belarus_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_belarus_laws`. CIDs identify local content; they do not prove public IPFS pinning.

build.py

@@ -0,0 +1,444 @@
+"""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 .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 .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 (
+    DIMENSION,
+    MODEL_NAME,
+    assemble_embeddings,
+    embeddings_available,
+    embeddings_by_cid,
+    layout_stub_vectors,
+    layout_vectors,
+)
+
+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"
+PROGRESS = ROOT / "progress.jsonl"
+
+
+def _log(msg: str) -> None:
+    ts = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+    print(f"[{ts}] {msg}", flush=True)
+
+
+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")
+
+
+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"
+        embeddings, vector_report = assemble_embeddings(
+            corpus,
+            prior_by_cid,
+            encode_missing=embeddings_available(),
+            device=device,
+            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",
+    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"
+    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(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
+    )
+    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")
+    (REPORTS / "normalization.json").write_text(
+        json.dumps(norm_report, indent=2, ensure_ascii=False) + "\n", encoding="utf-8"
+    )
+    _log(
+        f"normalized docs={len(corpus)} unit={norm_report['unit']} "
+        f"dropped={norm_report['n_dropped_total']} report={report_path}"
+    )
+    if corpus.empty:
+        raise RuntimeError("Normalized corpus is empty; refusing to package")
+
+    import gc
+
+    plan = plan_rebuild(
+        mode=mode,
+        source_meta=source_meta,
+        prior=prior,
+        current_corpus=corpus,
+        force=force,
+    )
+    _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,
+        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"],
+        "source": repo,
+        "source_revision": source_meta["source_revision"],
+        "out": str(out),
+        "target_hub_id": target_repo(country["slug"]),
+        "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
+
+        hub = upload_release(out, target_repo(country["slug"]))
+        result["hub"] = hub
+        _log(f"uploaded {hub['url']} rev={hub['revision']}")
+        record_progress({"event": "uploaded", **result})
+    else:
+        record_progress({"event": "built_local", **{k: v for k, v in result.items() if k != "normalization"}})
+    return result
+
+
+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]]:
+    """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:
+        try:
+            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(
+                {
+                    "event": "failed",
+                    "country": slug,
+                    "error": str(exc),
+                    "traceback": traceback.format_exc(),
+                }
+            )
+            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",
+) -> list[dict[str, Any]]:
+    """Scan Hub gaps and incrementally rebuild stale/missing country IR.
+
+    Default cap skips huge corpora (Finland, Dominican Republic). Pass
+    ``max_corpus_rows=None`` to include them.
+    """
+    from .coverage import gap_report
+
+    if slugs is None:
+        report = gap_report(workers=workers)
+        rows = [c for c in report["countries"] if c.get("rebuild")]
+        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]
+        _log(
+            f"reindex targets n={len(slugs)} "
+            f"(from scan rebuild={len(report.get('rebuild') or [])})"
+        )
+    results: list[dict[str, Any]] = []
+    for slug in slugs:
+        _log(f"reindex start {slug}")
+        try:
+            results.append(
+                build_country(
+                    slug,
+                    upload=upload,
+                    mode=mode,
+                    skip_vectors=skip_vectors,
+                    fetch_hub_prior_ir=True,
+                )
+            )
+        except Exception as exc:
+            _log(f"FAILED {slug}: {exc}")
+            record_progress(
+                {
+                    "event": "failed",
+                    "country": slug,
+                    "error": str(exc),
+                    "traceback": traceback.format_exc(),
+                }
+            )
+            results.append({"country": slug, "skipped": False, "error": str(exc)})
+            continue
+    return results

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,25 @@ 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("--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 +42,38 @@ 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=4)
+    p_re.add_argument("--mode", default="auto", choices=["auto", "full", "delta"])
+
+    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 +86,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 +96,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 +114,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 +128,69 @@ 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 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,
+        )
+        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 == "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_available,
+    embeddings_by_cid,
+    layout_stub_vectors,
+    layout_vectors,
+)
 
-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"
@@ -47,6 +64,95 @@ def record_progress(event: dict[str, Any]) -> None:
         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"
+        embeddings, vector_report = assemble_embeddings(
+            corpus,
+            prior_by_cid,
+            encode_missing=embeddings_available(),
+            device=device,
+            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,
@@ -54,6 +160,10 @@ def build_country(
     device: str = "cpu",
     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 +179,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 +190,35 @@ 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
+    )
+    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")
@@ -93,6 +234,19 @@ def build_country(
 
     import gc
 
+    plan = plan_rebuild(
+        mode=mode,
+        source_meta=source_meta,
+        prior=prior,
+        current_corpus=corpus,
+        force=force,
+    )
+    _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 +254,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 +323,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 +342,93 @@ 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}")
+        try:
+            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(
+                {
+                    "event": "failed",
+                    "country": slug,
+                    "error": str(exc),
+                    "traceback": traceback.format_exc(),
+                }
+            )
             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",
+) -> list[dict[str, Any]]:
+    """Scan Hub gaps and incrementally rebuild stale/missing country IR.
+
+    Default cap skips huge corpora (Finland, Dominican Republic). Pass
+    ``max_corpus_rows=None`` to include them.
+    """
+    from .coverage import gap_report
+
+    if slugs is None:
+        report = gap_report(workers=workers)
+        rows = [c for c in report["countries"] if c.get("rebuild")]
+        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]
+        _log(
+            f"reindex targets n={len(slugs)} "
+            f"(from scan rebuild={len(report.get('rebuild') or [])})"
+        )
+    results: list[dict[str, Any]] = []
+    for slug in slugs:
+        _log(f"reindex start {slug}")
         try:
-            results.append(build_country(slug, upload=upload))
+            results.append(
+                build_country(
+                    slug,
+                    upload=upload,
+                    mode=mode,
+                    skip_vectors=skip_vectors,
+                    fetch_hub_prior_ir=True,
+                )
+            )
         except Exception as exc:
             _log(f"FAILED {slug}: {exc}")
             record_progress(
@@ -233,5 +439,6 @@ def batch(
                     "traceback": traceback.format_exc(),
                 }
             )
+            results.append({"country": slug, "skipped": False, "error": str(exc)})
             continue
     return results

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,452 @@
+"""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"} and not local_current
+    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,500 @@
+"""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,
+) -> 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,
+        )
+
+    if prior_fp == fingerprint and fingerprint.strip("|"):
+        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,
+            )
+
+    return RebuildPlan(
+        kind=RebuildKind.DELTA_REFRESH,
+        mode=mode,
+        reason="source changed; reuse embeddings for unchanged entry_cids",
+        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

@@ -19,6 +19,7 @@ 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
@@ -27,6 +28,21 @@ from .schema import SchemaError, validate_articles, validate_laws
 
 _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:
@@ -53,21 +69,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 +120,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 +147,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)),

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/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:
@@ -170,7 +182,11 @@ def main(argv: list[str] | None = None) -> int:
     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,114 @@
+"""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: list[dict[str, Any]] = []
+    for rec in corpus.itertuples(index=False):
+        rows.append(
+            {
+                "entry_cid": str(rec.entry_cid),
+                "title": str(getattr(rec, "title", "") or ""),
+                "body": str(getattr(rec, "body", "") or ""),
+                "record_type": str(getattr(rec, "record_type", "") or "law"),
+                "document_index": int(rec.document_index),
+            }
+        )
+    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/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

@@ -52,7 +52,7 @@ def encode_corpus(
     from .auth import configure_hf
 
     configure_hf()
-    cache_root = _Path("/workspace/country-laws-ir/cache/hf")
+    cache_root = _Path(os.environ.get("COUNTRY_LAWS_IR_ROOT", str(_Path.home() / ".ipfs_datasets" / "country-laws-ir"))) / "cache" / "hf"
     os.environ.setdefault("HF_HOME", str(cache_root))
     os.environ.setdefault("HF_HUB_DISABLE_IMPLICIT_TOKEN", "1")
     os.environ.setdefault(
@@ -160,25 +160,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 +337,89 @@ 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 = "cpu",
+    checkpoint_path: str | None = None,
+) -> tuple[np.ndarray, dict[str, Any]]:
+    """Align a (n, 384) matrix to *corpus* row order, reusing unchanged CIDs.
+
+    Positional checkpoints are unsafe when scrapes append pages. Identity is
+    ``entry_cid``. Missing CIDs are encoded only when ``encode_missing`` is true
+    and sentence-transformers is available.
+    """
+    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 vec is None:
+            missing_idx.append(i)
+            continue
+        try:
+            arr = np.asarray(vec, dtype=np.float32).reshape(-1)
+        except Exception:
+            missing_idx.append(i)
+            continue
+        if arr.shape[0] != DIMENSION:
+            missing_idx.append(i)
+            continue
+        out[i] = arr
+        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,
+        "dimension": DIMENSION,
+        "status": "reused" if not missing_idx else "partial",
+    }
+    if not missing_idx:
+        report["status"] = "reused"
+        return _l2_normalize(out) if n else out, report
+    if not encode_missing:
+        report["status"] = "incomplete"
+        return out, report
+    if not embeddings_available():
+        report["status"] = "stub_missing_encoder"
+        report["reason"] = "sentence-transformers/torch unavailable"
+        return out, report
+
+    missing = corpus.iloc[missing_idx].reset_index(drop=True)
+    encoded = encode_corpus(
+        missing,
+        batch_size=batch_size,
+        device=device,
+        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

data/bm25/documents/part-000000.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:0126ab21ab8e2d4c0f0450e086c5ceb2ce34c6a609c7b4d373c9da1b4b1ff712
-size 388156
+oid sha256:294554df475057dfed6b86149ea892b17fb1c22699a94f3a51708f4f38cae438
+size 515338

data/bm25/documents/part-000001.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:39a94321a6f865d3abfca9ea230aa919cfd196ae49eec566d5e8f6d8501ede84
-size 262027
+oid sha256:514461cb0e3acfbe7979265fd70be56d74dd4002e29f3e598a270b21a48a6b85
+size 376787

data/bm25/postings/part-000000.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:d3299d0aef565430905f27ff52dec9517b970907a8de563e95b0f6fd2013a470
-size 145522
+oid sha256:c45a5e312424a98df8a7c540900be908d170cd3a639f4182899b71265d20eecb
+size 121424

data/corpus/part-000000.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:e3936d5fd6af0248f39c2b6bc065c40792dd01f48ef4e693850c20873cdc7427
-size 2177785
+oid sha256:a468393fe819e3eb672936989c670fdf53d7cc95ea2813c13e54a3d55539f87b
+size 2182154

data/corpus/part-000001.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:65b68715ff1263800580dc2ac372f6428720f3cdb860e285b92ff005be0b3676
-size 896606
+oid sha256:cf7eb157f3e815bca421ee5977ed814c305ec5eab641cff93037a0eccd5be4be
+size 883744

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

data/graph/edges/part-000000.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:4fc70580ef7005724ba03f84ef87c5c82a1d36bcc97be37994023ca0c1c7ebe4
-size 185160
+oid sha256:32ab186365708b90ff61ffa173aaaac85184d42f8514f48ebcf6c0e0be7c3b30
+size 264562

data/graph/edges/part-000001.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:92887a48016e3f6f5b3e33a45c3a138dfa90044eb6cc2b626e8879219d96254b
-size 180603
+oid sha256:bf316b04b8b922ee9f143cc766f66e6076fb495f60a400e0e847285614d28816
+size 265032

data/graph/edges/part-000002.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:7ffa7ba09740584d432d0b3c430683cede0f9d7dce7ed76bcd5d33521fee1e36
-size 180510
+oid sha256:aef0aac061a4d85f7ed4ed99b1c695d76a3ac76d2a648b9a20cb60daba936b2f
+size 265803

data/graph/edges/part-000003.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:be46ce498d14c32e5eb3232b600cdfc22e0a9d4a881a1e45a516a736350e9ccf
-size 181435
+oid sha256:94b042536fef2e395a7b43d492ee85041079a98b84116b9b90d04cecd50b8a5d
+size 264851

data/graph/edges/part-000004.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:c47ce911f925f50923f68e5463dd5c07faeddcc200499944900f7ebcce96a766
-size 185012
+oid sha256:464f03c76ecb06b050e827421db8bf5c1936bcacb6a51bd798510c22da43cb11
+size 264985

data/graph/edges/part-000005.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:15118034cdb586a05a70f86cff34f0b9ad2a563a41429ed153ba73d49950d3c4
-size 184524
+oid sha256:7643d06945a00aff2f7193deb398d67dd4c7a89d2112c8cd11642d7109bc08d3
+size 266393

data/graph/edges/part-000006.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f424c5e9fbf3e55d2f2a2d5ea9edeed81a7d58cd141ca335c3e34c156e064230
-size 180857
+oid sha256:a4d0ea82d592d97f8668d4013bf8fe63472ad736cb8c77c1e70ccabc62830026
+size 265910

data/graph/edges/part-000007.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:63dca3b715b05890aaff0e370b100f1415d76fc1c67f1e90746642d76e06b715
-size 180750
+oid sha256:d7850fd4aaf23d9f1d18a2cced497d1181c51b82aae326abd3266bd12e59d45d
+size 264530

data/graph/edges/part-000008.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:08d3e6874bde422e059cf14f0371ec903a773581b4378dd2abe3b20f8925e390
-size 180211
+oid sha256:070ae9d0cc103e57f64887863a806182ff495eaba236451361bd01cf41400f80
+size 266023

data/graph/edges/part-000009.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:ddd65e0332170dbf1c3ad2c7cced900848e3fb9a2f2a3e7ffe7a7194d79f7967
-size 179413
+oid sha256:29360cc08242bdc38828f2454c9644197a43da7bad5c8c49eaaefc5b443c59b1
+size 266323

data/graph/edges/part-000010.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:445f1dd137675a51e5d1c25212c19f50cfe6039129b0209ae183497f89ecd3b3
-size 181862
+oid sha256:5b061ef0caa60f59725d9bdacfc176b19923621c1562be74cbfd794d290f70e0
+size 265788