Add files using upload-large-folder tool

README.md

@@ -56,7 +56,7 @@ configs:
 
 # Saudi Arabia legislation IR (CID-keyed sparse GraphRAG)
 
-Research retrieval release of `endomorphosis/ipfs_saudiarabia_laws` (revision `47bbf142ade8`) packaged as
+Research retrieval release of `endomorphosis/ipfs_saudiarabia_laws` (revision `94bd316e19d5d391c4b9e202d199d5debf8965c3`) 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 /
@@ -73,13 +73,13 @@ Target Hub id (packaging metadata only): `justicedao/ipfs_saudiarabia_laws_ir`.
 | Field | Value |
 | --- | --- |
 | Laws (corpus units) | 0 |
-| Articles (corpus units) | 4664 |
-| Canonical docs | 4664 |
-| BM25 terms | 1498 |
-| BM25 postings | 10560 |
-| Graph nodes | 5353 |
-| Graph edges | 45185 |
-| Vectors | 4664 × 384-d `thenlper/gte-small` (embedded) |
+| Articles (corpus units) | 10466 |
+| Canonical docs | 10466 |
+| BM25 terms | 1628 |
+| BM25 postings | 16654 |
+| Graph nodes | 11743 |
+| Graph edges | 99133 |
+| Vectors | 10466 × 384-d `thenlper/gte-small` (partial) |
 
 ## Canonical fields
 

build.py

@@ -1,22 +1,59 @@
-"""End-to-end build: normalize → BM25 → graph → vectors → package (no upload by default)."""
+"""End-to-end build: normalize → incremental vectors → BM25 → graph → package.
+
+Default mode is ``auto``: skip when the endomorphosis source revision is
+unchanged, otherwise delta-refresh embeddings by ``entry_cid`` and rebuild
+BM25/graph from the current corpus. Publication to ``justicedao/*`` is opt-in
+via ``upload=True``.
+"""
 
 from __future__ import annotations
 
+import os
+
 import json
+
+import pandas as pd
 import traceback
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any
 
 from .bm25 import bm25_neighbors, build_index
+from .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 .package import package_from_spill, package_release
 from .catalog import get_country, indexable_countries, target_repo
 from .graph import build_graph
+from .incremental import (
+    fetch_hub_prior,
+    load_embedding_cache,
+    load_prior_release,
+    load_release_vectors_by_cid,
+    merge_embedding_maps,
+    plan_rebuild,
+    save_embedding_cache,
+)
 from .normalize import build_corpus, load_source
-from .package import package_release
 from .auth import configure_hf
-from .vectors import encode_corpus, embeddings_available, layout_stub_vectors, layout_vectors
+from .vectors import (
+    DIMENSION,
+    MODEL_NAME,
+    assemble_embeddings,
+    embeddings_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"
@@ -35,6 +72,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,
@@ -42,6 +168,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):
@@ -57,7 +187,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)
@@ -66,6 +198,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")
@@ -79,46 +240,86 @@ def build_country(
     if corpus.empty:
         raise RuntimeError("Normalized corpus is empty; refusing to package")
 
-    bm25 = build_index(corpus)
-    _log(f"bm25 terms={bm25['stats']['n_terms']} postings={bm25['stats']['n_postings']}")
-    _log(f"bm25 neighbors start n={len(corpus)} k={neighbor_k}")
-    neighbors = bm25_neighbors(bm25, k=neighbor_k)
-    _log("bm25 neighbors done")
-    graph = build_graph(corpus, neighbors)
-    _log(f"graph nodes={graph['stats']['n_nodes']} edges={graph['stats']['n_edges']}")
+    import gc
 
-    vector_blocker = None
-    if skip_vectors:
-        vectors = layout_stub_vectors(corpus, reason="skip_vectors flag")
-        vector_blocker = "skip_vectors"
-    elif embeddings_available():
-        try:
-            ckpt = CACHE / "embeddings" / f"{country['slug']}.npy"
-            _log(f"vectors encode start n={len(corpus)} checkpoint={ckpt}")
-            embeddings = encode_corpus(corpus, device=device, checkpoint_path=str(ckpt))
-            vectors = layout_vectors(corpus, embeddings)
-            _log(f"vectors n={vectors['stats']['n_vectors']} shards={vectors['stats']['shard_count']}")
-        except Exception as exc:
-            vector_blocker = f"embedding_failed: {exc}"
-            _log(f"vector embedding failed; writing stub ({exc})")
-            vectors = layout_stub_vectors(corpus, reason=vector_blocker)
-    else:
-        vector_blocker = "sentence-transformers/torch unavailable"
-        _log(f"vectors stub: {vector_blocker}")
-        vectors = layout_stub_vectors(corpus, reason=vector_blocker)
+    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)
 
-    code_root = Path(__file__).resolve().parent.parent
-    manifest = package_release(
-        out,
-        corpus,
-        bm25,
-        graph,
-        vectors,
-        source_meta,
-        country,
-        code_root,
-        normalization_report=norm_report,
+    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,
+            extra_manifest=extra_manifest,
+        )
+        _log(f"packaged sequential via={neighbor_via} {out}")
+    else:
+        bm25 = build_index(corpus)
+        _log(f"bm25 terms={bm25['stats']['n_terms']} postings={bm25['stats']['n_postings']}")
+        _log(f"bm25 neighbors start n={n_docs} k={neighbor_k}")
+        neighbors = bm25_neighbors(bm25, k=neighbor_k)
+        _log("bm25 neighbors done")
+        graph = build_graph(corpus, neighbors)
+        del neighbors
+        gc.collect()
+        _log(f"graph nodes={graph['stats']['n_nodes']} edges={graph['stats']['n_edges']}")
+        with open(spill / "vectors.pkl", "rb") as _vf:
+            import pickle as _pickle
+            vectors = _pickle.load(_vf)
+        code_root = Path(__file__).resolve().parent.parent
+        manifest = package_release(
+            out, corpus, bm25, graph, vectors, source_meta, country, code_root,
+            normalization_report=norm_report,
+            extra_manifest=extra_manifest,
+        )
+        del corpus, bm25, graph, vectors
+        gc.collect()
     _log(f"packaged {out}")
     result = {
         "country": country["slug"],
@@ -129,7 +330,10 @@ def build_country(
         "counts": manifest["counts"],
         "normalization": norm_report,
         "vector_blocker": vector_blocker,
+        "neighbor_via": neighbor_via,
         "schema_version": manifest["schema_version"],
+        "skipped": False,
+        "incremental": extra_manifest["incremental"],
     }
     if upload:
         from .upload import upload_release
@@ -147,25 +351,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(
@@ -176,5 +448,6 @@ def batch(
                     "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,22 +1,59 @@
-"""End-to-end build: normalize → BM25 → graph → vectors → package (no upload by default)."""
+"""End-to-end build: normalize → incremental vectors → BM25 → graph → package.
+
+Default mode is ``auto``: skip when the endomorphosis source revision is
+unchanged, otherwise delta-refresh embeddings by ``entry_cid`` and rebuild
+BM25/graph from the current corpus. Publication to ``justicedao/*`` is opt-in
+via ``upload=True``.
+"""
 
 from __future__ import annotations
 
+import os
+
 import json
+
+import pandas as pd
 import traceback
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any
 
 from .bm25 import bm25_neighbors, build_index
+from .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 .package import package_from_spill, package_release
 from .catalog import get_country, indexable_countries, target_repo
 from .graph import build_graph
+from .incremental import (
+    fetch_hub_prior,
+    load_embedding_cache,
+    load_prior_release,
+    load_release_vectors_by_cid,
+    merge_embedding_maps,
+    plan_rebuild,
+    save_embedding_cache,
+)
 from .normalize import build_corpus, load_source
-from .package import package_release
 from .auth import configure_hf
-from .vectors import encode_corpus, embeddings_available, layout_stub_vectors, layout_vectors
+from .vectors import (
+    DIMENSION,
+    MODEL_NAME,
+    assemble_embeddings,
+    embeddings_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"
@@ -35,6 +72,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,
@@ -42,6 +168,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):
@@ -57,7 +187,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)
@@ -66,6 +198,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")
@@ -79,46 +240,86 @@ def build_country(
     if corpus.empty:
         raise RuntimeError("Normalized corpus is empty; refusing to package")
 
-    bm25 = build_index(corpus)
-    _log(f"bm25 terms={bm25['stats']['n_terms']} postings={bm25['stats']['n_postings']}")
-    _log(f"bm25 neighbors start n={len(corpus)} k={neighbor_k}")
-    neighbors = bm25_neighbors(bm25, k=neighbor_k)
-    _log("bm25 neighbors done")
-    graph = build_graph(corpus, neighbors)
-    _log(f"graph nodes={graph['stats']['n_nodes']} edges={graph['stats']['n_edges']}")
+    import gc
 
-    vector_blocker = None
-    if skip_vectors:
-        vectors = layout_stub_vectors(corpus, reason="skip_vectors flag")
-        vector_blocker = "skip_vectors"
-    elif embeddings_available():
-        try:
-            ckpt = CACHE / "embeddings" / f"{country['slug']}.npy"
-            _log(f"vectors encode start n={len(corpus)} checkpoint={ckpt}")
-            embeddings = encode_corpus(corpus, device=device, checkpoint_path=str(ckpt))
-            vectors = layout_vectors(corpus, embeddings)
-            _log(f"vectors n={vectors['stats']['n_vectors']} shards={vectors['stats']['shard_count']}")
-        except Exception as exc:
-            vector_blocker = f"embedding_failed: {exc}"
-            _log(f"vector embedding failed; writing stub ({exc})")
-            vectors = layout_stub_vectors(corpus, reason=vector_blocker)
-    else:
-        vector_blocker = "sentence-transformers/torch unavailable"
-        _log(f"vectors stub: {vector_blocker}")
-        vectors = layout_stub_vectors(corpus, reason=vector_blocker)
+    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)
 
-    code_root = Path(__file__).resolve().parent.parent
-    manifest = package_release(
-        out,
-        corpus,
-        bm25,
-        graph,
-        vectors,
-        source_meta,
-        country,
-        code_root,
-        normalization_report=norm_report,
+    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,
+            extra_manifest=extra_manifest,
+        )
+        _log(f"packaged sequential via={neighbor_via} {out}")
+    else:
+        bm25 = build_index(corpus)
+        _log(f"bm25 terms={bm25['stats']['n_terms']} postings={bm25['stats']['n_postings']}")
+        _log(f"bm25 neighbors start n={n_docs} k={neighbor_k}")
+        neighbors = bm25_neighbors(bm25, k=neighbor_k)
+        _log("bm25 neighbors done")
+        graph = build_graph(corpus, neighbors)
+        del neighbors
+        gc.collect()
+        _log(f"graph nodes={graph['stats']['n_nodes']} edges={graph['stats']['n_edges']}")
+        with open(spill / "vectors.pkl", "rb") as _vf:
+            import pickle as _pickle
+            vectors = _pickle.load(_vf)
+        code_root = Path(__file__).resolve().parent.parent
+        manifest = package_release(
+            out, corpus, bm25, graph, vectors, source_meta, country, code_root,
+            normalization_report=norm_report,
+            extra_manifest=extra_manifest,
+        )
+        del corpus, bm25, graph, vectors
+        gc.collect()
     _log(f"packaged {out}")
     result = {
         "country": country["slug"],
@@ -129,7 +330,10 @@ def build_country(
         "counts": manifest["counts"],
         "normalization": norm_report,
         "vector_blocker": vector_blocker,
+        "neighbor_via": neighbor_via,
         "schema_version": manifest["schema_version"],
+        "skipped": False,
+        "incremental": extra_manifest["incremental"],
     }
     if upload:
         from .upload import upload_release
@@ -147,25 +351,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(
@@ -176,5 +448,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/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/mem.py

@@ -0,0 +1,236 @@
+"""Process / host memory watchdog for large IR builds (DO OOM lesson).
+
+Env overrides:
+  IR_MEM_WARN_GIB   MemAvailable threshold to shed collectors (default 3.5)
+  IR_MEM_ABORT_GIB  MemAvailable abort floor (default 2.5)
+  IR_RSS_ABORT_GIB  process RSS hard abort (default 12.0)
+  IR_MEM_LOG_EVERY  rows between mem logs when callers pass every_n (default 5000)
+"""
+from __future__ import annotations
+
+import gc
+import os
+import signal
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Callable
+
+DEFAULT_WARN_GIB = 3.5
+DEFAULT_ABORT_AVAIL_GIB = 2.5
+DEFAULT_ABORT_RSS_GIB = 12.0
+DEFAULT_LOG_EVERY = 5000
+
+# Prefer shedding zero-article / lean collectors first; protect AT+DK until last.
+DEFAULT_SHED_ORDER: list[tuple[str, tuple[str, ...]]] = [
+    ("mm", ("collect_mm", "run_collector_cc.sh collect_mm")),
+    ("th", ("collect_th", "run_collector_cc.sh collect_th")),
+    ("is-reg", ("collect_is", "is-reg", "run_collector_cc.sh collect_is")),
+    ("lt", ("collect_lt", "run_collector_cc.sh collect_lt")),
+    ("kw", ("collect_kw", "run_collector_cc.sh collect_kw")),
+    ("mt", ("collect_mt", "run_collector_cc.sh collect_mt")),
+    ("dk", ("collect_dk", "run_collector_cc.sh collect_dk")),
+    ("at", ("collect_at", "run_collector_cc.sh collect_at", "at_deepen")),
+]
+
+
+class MemAbort(RuntimeError):
+    """Raised when MemAvailable or RSS crosses hard abort thresholds."""
+
+
+def _env_float(name: str, default: float) -> float:
+    raw = os.environ.get(name)
+    if raw is None or raw == "":
+        return default
+    try:
+        return float(raw)
+    except ValueError:
+        return default
+
+
+def warn_gib() -> float:
+    return _env_float("IR_MEM_WARN_GIB", DEFAULT_WARN_GIB)
+
+
+def abort_avail_gib() -> float:
+    return _env_float("IR_MEM_ABORT_GIB", DEFAULT_ABORT_AVAIL_GIB)
+
+
+def abort_rss_gib() -> float:
+    return _env_float("IR_RSS_ABORT_GIB", DEFAULT_ABORT_RSS_GIB)
+
+
+def log_every() -> int:
+    try:
+        return max(1, int(os.environ.get("IR_MEM_LOG_EVERY", DEFAULT_LOG_EVERY)))
+    except ValueError:
+        return DEFAULT_LOG_EVERY
+
+
+def mem_available_gib() -> float:
+    try:
+        for line in Path("/proc/meminfo").read_text().splitlines():
+            if line.startswith("MemAvailable:"):
+                return int(line.split()[1]) / 1024 / 1024
+    except Exception:
+        pass
+    return -1.0
+
+
+def rss_gib(pid: int | None = None) -> float:
+    path = Path(f"/proc/{pid or 'self'}/status")
+    try:
+        for line in path.read_text().splitlines():
+            if line.startswith("VmRSS:"):
+                return int(line.split()[1]) / 1024 / 1024
+    except Exception:
+        pass
+    return -1.0
+
+
+def snapshot(stage: str = "") -> dict[str, Any]:
+    return {
+        "stage": stage,
+        "mem_avail_gib": round(mem_available_gib(), 3),
+        "rss_gib": round(rss_gib(), 3),
+        "ts": datetime.now(timezone.utc).isoformat(),
+    }
+
+
+def log_mem(stage: str, log: Callable[[str], None] | None = None) -> dict[str, Any]:
+    snap = snapshot(stage)
+    msg = (
+        f"mem stage={stage} MemAvailable={snap['mem_avail_gib']:.2f}G "
+        f"RSS={snap['rss_gib']:.2f}G"
+    )
+    if log is not None:
+        log(msg)
+    else:
+        print(f"[{snap['ts']}] {msg}", flush=True)
+    return snap
+
+
+def discover_pids(*patterns: str) -> list[int]:
+    found: list[int] = []
+    try:
+        for proc in Path("/proc").iterdir():
+            if not proc.name.isdigit():
+                continue
+            try:
+                cmd = (proc / "cmdline").read_bytes().replace(b"\x00", b" ").decode(
+                    "utf-8", "ignore"
+                )
+            except Exception:
+                continue
+            if any(p in cmd for p in patterns):
+                found.append(int(proc.name))
+    except Exception:
+        pass
+    return found
+
+
+def shed_collectors(
+    stage: str,
+    *,
+    warn: float | None = None,
+    protect: frozenset[str] | None = None,
+    log: Callable[[str], None] | None = None,
+    notes: list[dict[str, Any]] | None = None,
+) -> list[dict[str, Any]]:
+    """SIGTERM lean collectors when MemAvailable < warn. Protect AT/DK by default until last."""
+    warn = warn_gib() if warn is None else warn
+    protect = protect if protect is not None else frozenset({"at", "dk"})
+    g = mem_available_gib()
+    out: list[dict[str, Any]] = []
+    if g < 0 or g >= warn:
+        return out
+    # First pass: non-protected; second pass: protected if still under warn.
+    for pass_protected in (False, True):
+        for name, pats in DEFAULT_SHED_ORDER:
+            if (name in protect) != pass_protected:
+                continue
+            pids = discover_pids(*pats)
+            for pid in pids:
+                try:
+                    os.kill(pid, 0)
+                except ProcessLookupError:
+                    continue
+                except PermissionError:
+                    continue
+                try:
+                    os.kill(pid, signal.SIGTERM)
+                    note = {
+                        "stage": stage,
+                        "name": name,
+                        "pid": pid,
+                        "mem_before": round(g, 2),
+                        "protected_pass": pass_protected,
+                    }
+                    out.append(note)
+                    if notes is not None:
+                        notes.append(note)
+                    msg = f"SIGTERM collector {name} pid={pid} mem={g:.2f}G stage={stage}"
+                    if log:
+                        log(msg)
+                    else:
+                        print(msg, flush=True)
+                except ProcessLookupError:
+                    pass
+                except Exception as exc:
+                    msg = f"SIGTERM failed {name} pid={pid}: {exc}"
+                    if log:
+                        log(msg)
+                    else:
+                        print(msg, flush=True)
+            g = mem_available_gib()
+            if g >= warn:
+                return out
+    return out
+
+
+def checkpoint(
+    stage: str,
+    *,
+    row: int | None = None,
+    every_n: int | None = None,
+    shed: bool = True,
+    abort: bool = True,
+    log: Callable[[str], None] | None = None,
+    notes: list[dict[str, Any]] | None = None,
+) -> dict[str, Any]:
+    """Periodic mem log + optional shed + hard abort.
+
+    Call every N rows with ``row`` set; always logs when row is None.
+    """
+    every = every_n if every_n is not None else log_every()
+    if row is not None and row != 0 and row % every != 0:
+        # Still enforce hard abort cheaply on every call.
+        rss = rss_gib()
+        avail = mem_available_gib()
+        if abort and rss >= abort_rss_gib():
+            raise MemAbort(f"RSS_ABORT stage={stage} rss={rss:.2f}G > {abort_rss_gib()}G")
+        if abort and 0 <= avail < abort_avail_gib():
+            if shed:
+                shed_collectors(stage, log=log, notes=notes)
+                avail = mem_available_gib()
+            if 0 <= avail < abort_avail_gib():
+                raise MemAbort(
+                    f"MEM_ABORT stage={stage} MemAvailable={avail:.2f}G < {abort_avail_gib()}G"
+                )
+        return snapshot(stage)
+
+    snap = log_mem(stage if row is None else f"{stage}@{row}", log=log)
+    if shed and 0 <= snap["mem_avail_gib"] < warn_gib():
+        shed_collectors(stage, log=log, notes=notes)
+        snap = log_mem(f"{stage}_after_shed", log=log)
+        gc.collect()
+    if abort:
+        if snap["rss_gib"] >= abort_rss_gib():
+            raise MemAbort(
+                f"RSS_ABORT stage={stage} rss={snap['rss_gib']:.2f}G > {abort_rss_gib()}G"
+            )
+        if 0 <= snap["mem_avail_gib"] < abort_avail_gib():
+            raise MemAbort(
+                f"MEM_ABORT stage={stage} MemAvailable={snap['mem_avail_gib']:.2f}G "
+                f"< {abort_avail_gib()}G"
+            )
+    return snap

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

@@ -2,7 +2,9 @@
 
 from __future__ import annotations
 
+import gc
 import json
+import pickle
 import shutil
 from pathlib import Path
 from typing import Any
@@ -32,6 +34,7 @@ def package_release(
     country: dict[str, Any],
     code_root: Path,
     normalization_report: dict[str, Any] | None = None,
+    extra_manifest: dict[str, Any] | None = None,
 ) -> dict[str, Any]:
     if out.exists():
         shutil.rmtree(out)
@@ -322,6 +325,8 @@ 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)
@@ -528,3 +533,353 @@ python -m country_laws_ir query --local-dir /workspace/country-laws-ir/releases/
 Do not treat retrieval as proof. Do not invent citations.
 """
     (skill_dir / "SKILL.md").write_text(text, encoding="utf-8")
+
+
+def package_release_sequential(
+    out: Path,
+    *,
+    corpus_path: Path,
+    bm25_documents_path: Path,
+    bm25_postings_path: Path,
+    bm25_stats: dict[str, Any],
+    graph: dict[str, Any] | Path,
+    vectors: dict[str, Any] | Path,
+    source_meta: dict[str, Any],
+    country: dict[str, Any],
+    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).
+
+    ``graph`` / ``vectors`` may be in-memory dicts or pickle Paths.
+    Loads and frees each artifact before the next. Prefer this for n>=40k.
+    """
+    from .mem import checkpoint, log_mem
+
+    def _load_obj(obj_or_path):
+        if isinstance(obj_or_path, (str, Path)):
+            p = Path(obj_or_path)
+            with p.open("rb") as f:
+                return pickle.load(f)
+        return obj_or_path
+
+    if out.exists():
+        shutil.rmtree(out)
+    out.mkdir(parents=True, exist_ok=True)
+    indexes_dir = out / "indexes"
+    indexes_dir.mkdir(parents=True, exist_ok=True)
+    log_mem("package_seq_start")
+
+    # --- corpus ---
+    corpus = pd.read_parquet(corpus_path)
+    if expected_rows is not None and len(corpus) != expected_rows:
+        raise ValueError(f"corpus rows {len(corpus)} != expected {expected_rows}")
+    n_laws = int((corpus["record_type"] == "law").sum()) if "record_type" in corpus else 0
+    n_articles = int((corpus["record_type"] == "article").sum()) if "record_type" in corpus else 0
+    corpus_rows = int(len(corpus))
+    corpus_idx = write_sharded(
+        corpus, out / "data" / "corpus", "data/corpus",
+        kind="corpus", key_col="entry_cid", index_col="document_index",
+    )
+    write_parquet(indexes_dir / "corpus_chunks.parquet", _index_df(corpus_idx))
+    del corpus
+    gc.collect()
+    checkpoint("package_corpus_done")
+
+    # --- bm25 documents ---
+    documents = pd.read_parquet(bm25_documents_path)
+    bm25_doc_idx = write_sharded(
+        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))
+    n_bm25_docs = int(len(documents))
+    del documents
+    gc.collect()
+
+    postings = pd.read_parquet(bm25_postings_path)
+    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))
+    n_posting_rows = int(len(postings))
+    del postings
+    gc.collect()
+    checkpoint("package_bm25_done")
+
+    # --- graph ---
+    graph = _load_obj(graph)
+    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))
+    gstats = graph["stats"]
+    n_graph_nodes = int(len(graph["nodes"]))
+    n_graph_edges = int(len(graph["edges"]))
+    n_in = int(len(incoming)) if incoming is not None else 0
+    n_out = int(len(outgoing)) if outgoing is not None else 0
+    edge_types = gstats.get("edge_types") or [
+        "HAS_JURISDICTION", "HAS_LANGUAGE", "BELONGS_TO_LAW", "HAS_ARTICLE", "BM25_NEIGHBOR_OF",
+    ]
+    del graph, incoming, outgoing
+    gc.collect()
+    checkpoint("package_graph_done")
+
+    # --- vectors ---
+    vectors = _load_obj(vectors)
+    vectors_df = vectors["vectors"]
+    if "embedding" in vectors_df.columns and vectors_df["embedding"].isna().all():
+        vectors_write = vectors_df.drop(columns=["embedding"])
+        vectors_write["embedding_status"] = "stub_missing"
+    else:
+        vectors_write = vectors_df
+    vec_idx = write_sharded(
+        vectors_write, out / "data" / "vectors", "data/vectors",
+        kind="vectors", key_col="entry_cid", index_col="document_index",
+    )
+    meta_by_cluster = {m["cluster_id"]: m for m in vectors["chunk_meta"]}
+    for r in vec_idx:
+        m = meta_by_cluster.get(r["shard_id"], {})
+        r["centroid"] = m.get("centroid", [])
+        r["shard_centroid"] = m.get("shard_centroid", [])
+        r["centroid_min_score"] = m.get("centroid_min_score", 0.0)
+        r["centroid_shard_count"] = m.get("centroid_shard_count", 1)
+        r["chunk_in_cluster"] = m.get("chunk_in_cluster", 0)
+        r["cluster_id"] = m.get("cluster_id", r["shard_id"])
+        r["dimension"] = 384
+        r["model_name"] = "thenlper/gte-small"
+        if m.get("stub"):
+            r["stub"] = True
+            r["stub_reason"] = m.get("stub_reason", "")
+    write_parquet(indexes_dir / "vector_chunks.parquet", _index_df(vec_idx))
+    vstats = vectors["stats"]
+    n_vectors = int(len(vectors_df))
+    del vectors, vectors_df, vectors_write
+    gc.collect()
+    checkpoint("package_vectors_done")
+
+    # --- bundle code ---
+    pkg_src = Path(__file__).resolve().parent
+    dest_pkg = out / "country_laws_ir"
+    shutil.copytree(
+        pkg_src, dest_pkg, dirs_exist_ok=True,
+        ignore=shutil.ignore_patterns("__pycache__", "*.pyc", ".venv"),
+    )
+    scripts_dir = out / "scripts"
+    scripts_dir.mkdir(exist_ok=True)
+    for name in (
+        "build_country_laws_ir.py", "normalize_country_laws.py",
+        "query_country_laws_hf.py", "query_country_laws_ir.py", "generate_country_laws_ir.py",
+    ):
+        src = code_root / "scripts" / name
+        if src.exists():
+            shutil.copy2(src, scripts_dir / name)
+    shutil.copy2(pkg_src / "normalize.py", out / "normalize.py")
+    shutil.copy2(pkg_src / "query.py", out / "query.py")
+    shutil.copy2(pkg_src / "build.py", out / "build.py")
+    hub_id = target_repo(country["slug"])
+    _write_skill(out, country, hub_id=hub_id)
+
+    reports_dir = out / "reports"
+    reports_dir.mkdir(exist_ok=True)
+    if normalization_report is not None:
+        payload = json.dumps(normalization_report, indent=2, ensure_ascii=False) + "\n"
+        (out / "normalization_report.json").write_text(payload, encoding="utf-8")
+        (reports_dir / "normalization.json").write_text(payload, encoding="utf-8")
+
+    counts = {
+        "bm25_document_chunks": len(bm25_doc_idx),
+        "bm25_documents": n_bm25_docs,
+        "bm25_keyword_shards": len(posting_idx),
+        "bm25_posting_rows": n_posting_rows,
+        "bm25_postings": int(bm25_stats["n_postings"]),
+        "bm25_terms": int(bm25_stats["n_terms"]),
+        "corpus_chunks": len(corpus_idx),
+        "corpus_rows": corpus_rows,
+        "graph_edge_chunks": len(edge_idx),
+        "graph_edges": n_graph_edges,
+        "graph_incoming_adjacency_edges": n_graph_edges,
+        "graph_incoming_adjacency_rows": n_in,
+        "graph_incoming_adjacency_shards": len(in_idx),
+        "graph_node_chunks": len(node_idx),
+        "graph_nodes": n_graph_nodes,
+        "graph_outgoing_adjacency_edges": n_graph_edges,
+        "graph_outgoing_adjacency_rows": n_out,
+        "graph_outgoing_adjacency_shards": len(out_idx),
+        "vector_chunks": len(vec_idx),
+        "vector_rows": n_vectors,
+        "n_laws": n_laws,
+        "n_articles": n_articles,
+    }
+
+    def idx_desc(name: str) -> dict[str, Any]:
+        path = indexes_dir / name
+        return file_descriptor(path, f"indexes/{name}")
+
+    manifest = {
+        "schema_version": SCHEMA_VERSION,
+        "layout_family": LAYOUT_FAMILY,
+        "packager_version": __version__,
+        "primary_key": "entry_cid",
+        "dataset_id": source_meta["source_dataset"],
+        "dataset_repo_id": hub_id,
+        "dataset_revision": source_meta["source_revision"],
+        "country": country,
+        "disclaimer": "Research snapshot. Not legal advice. The official gazette / authentic source prevails.",
+        "bm25": {k: bm25_stats[k] for k in (
+            "k1", "b", "title_weight", "body_weight", "average_document_length",
+            "tokenizer", "max_query_terms", "posting_rows_per_record", "terms_per_shard",
+        ) if k in bm25_stats},
+        "counts": counts,
+        "parquet": {
+            "compression": "zstd",
+            "compression_level": 6,
+            "max_rows_per_file": MAX_ROWS_PER_FILE,
+            "row_group_size": MAX_ROWS_PER_FILE,
+        },
+        "graph": {
+            "adjacency_pointers_per_row": ADJ_POINTERS_PER_ROW,
+            "adjacency_pointers_per_shard": ADJ_POINTERS_PER_SHARD,
+            "directions": ["incoming", "outgoing"],
+            "max_remote_walk_depth": 8,
+            "ordering": "score_desc_nulls_last",
+            "edge_types": edge_types,
+        },
+        "vector": vstats,
+        "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",
+        ],
+        "input_sha256": {
+            "laws.parquet": source_meta.get("laws_sha256"),
+            "articles.parquet": source_meta.get("articles_sha256"),
+        },
+        "model_id": (vstats or {}).get("model_name", "thenlper/gte-small"),
+        "cid": {
+            "codec": "raw",
+            "hash": "sha2-256",
+            "multibase": "base32",
+            "payload": "json.dumps(obj, sort_keys=True, ensure_ascii=False, separators=(',', ':')).encode('utf-8')",
+        },
+        "normalization": normalization_report or {},
+        "packaging_mode": "sequential_spill",
+        "schema_mapping": {
+            "laws": {
+                "id": "instrument_id", "title": "instrument_title", "text": "body",
+                "article_count_dtype_source": source_meta.get("article_count_dtype"),
+            },
+            "articles": {
+                "id": "source_id / article identity", "law_id": "instrument_id",
+                "title": "article_title", "text": "body",
+            },
+            "unit_policy": "prefer articles; fall back to law-level when articles empty",
+            "required_law_columns": ["id", "title", "text"],
+            "required_article_columns": ["id", "law_id", "title", "text"],
+            "fail_closed": True,
+            "notes": (
+                "Malta and Germany share the same column names. Drift: Malta article_count "
+                "is int64, Germany article_count is int32; Germany eli is often null. "
+                "Identifiers are never invented. Layout matches SkillCenter HF release / publicus-ir family."
+            ),
+        },
+        "indexes": {
+            "bm25_document_chunks": idx_desc("bm25_document_chunks.parquet"),
+            "bm25_keyword_shards": idx_desc("bm25_keyword_shards.parquet"),
+            "corpus_chunks": idx_desc("corpus_chunks.parquet"),
+            "graph_edge_chunks": idx_desc("graph_edge_chunks.parquet"),
+            "graph_incoming_adjacency": idx_desc("graph_incoming_adjacency.parquet"),
+            "graph_node_chunks": idx_desc("graph_node_chunks.parquet"),
+            "graph_outgoing_adjacency": idx_desc("graph_outgoing_adjacency.parquet"),
+            "vector_chunks": idx_desc("vector_chunks.parquet"),
+        },
+        "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)
+    checkpoint("package_seq_done")
+    return manifest
+
+
+def package_from_spill(
+    out: Path,
+    spill: Path,
+    corpus_path: Path,
+    source_meta: dict[str, Any],
+    country: dict[str, Any],
+    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."""
+    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)
+    return package_release_sequential(
+        out,
+        corpus_path=Path(corpus_path),
+        bm25_documents_path=spill / "bm25_documents.parquet",
+        bm25_postings_path=spill / "bm25_postings.parquet",
+        bm25_stats=bm25_stats,
+        graph=spill / "graph.pkl",
+        vectors=spill / "vectors.pkl",
+        source_meta=source_meta,
+        country=country,
+        code_root=Path(code_root),
+        normalization_report=normalization_report,
+        expected_rows=expected_rows,
+        extra_manifest=extra_manifest,
+    )

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/spill.py

@@ -0,0 +1,763 @@
+"""Disk-spill helpers for large country IR builds (SQLite FTS neighbors + BM25 TF).
+
+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.
+"""
+from __future__ import annotations
+
+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
+
+import numpy as np
+import pandas as pd
+import pyarrow.parquet as pq
+
+from . import SCHEMA_VERSION
+from .bm25 import (
+    B,
+    BODY_WEIGHT,
+    K1,
+    POSTING_ROWS_PER_RECORD,
+    TERMS_PER_SHARD,
+    TITLE_WEIGHT,
+)
+from .graph import _adjacency, _edge, build_graph
+from .mem import MemAbort, checkpoint, log_mem
+from .tokenize import tokenize
+
+SQLITE_THRESHOLD = 40_000
+BATCH = 256
+NEIGHBOR_SHARD = 5_000
+NEIGHBOR_K = 8
+DF_CAP = 1500
+MAX_QTERMS = 8
+TITLE_W = TITLE_WEIGHT
+BODY_W = BODY_WEIGHT
+
+
+def spill_dir_for(slug: str, cache: Path) -> Path:
+    return Path(cache) / f"{slug}_bm25_spill"
+
+
+def spill_pickle(path: Path, obj: Any) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_suffix(path.suffix + ".tmp")
+    with tmp.open("wb") as f:
+        pickle.dump(obj, f, protocol=pickle.HIGHEST_PROTOCOL)
+    tmp.replace(path)
+
+
+def load_pickle(path: Path) -> Any:
+    with path.open("rb") as f:
+        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:
+    if not db_path.is_file():
+        return False
+    try:
+        conn = sqlite3.connect(f"file:{db_path}?mode=ro", uri=True)
+        n = int(conn.execute("SELECT COUNT(*) FROM documents").fetchone()[0])
+        conn.close()
+        return n == expected
+    except Exception:
+        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 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,
+    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.
+
+    Does not assemble the full neighbor list. Resume skips shards already on disk
+    whose end index is covered (contiguous from 0).
+    """
+    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
+        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)
+    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()
+
+
+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"))
+    for sp in paths:
+        parts = sp.stem.split("_")
+        start_i = int(parts[1])
+        yield start_i, load_pickle(sp)
+
+
+def assemble_neighbors_streaming(spill: Path, n_docs: int) -> list:
+    """Assemble only when unavoidable; prefer build_graph_from_neighbor_shards."""
+    neighbors: list = []
+    for start_i, part in iter_neighbor_shards(spill):
+        while len(neighbors) < start_i:
+            neighbors.append([])
+        neighbors.extend(part)
+        del part
+        gc.collect()
+    while len(neighbors) < n_docs:
+        neighbors.append([])
+    if len(neighbors) > n_docs:
+        neighbors = neighbors[:n_docs]
+    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 build_graph_from_neighbor_shards(
+    corpus: pd.DataFrame,
+    spill: Path,
+    *,
+    log: Callable[[str], None] | None = None,
+) -> dict[str, Any]:
+    """Build graph without holding the full neighbor list.
+
+    Structural edges first (neighbors=[]), then stream BM25_NEIGHBOR_OF from shards
+    and recompute adjacency once.
+    """
+    n = len(corpus)
+    # Structural + facets only
+    graph = build_graph(corpus, [[] for _ in range(n)])
+    cid_by_idx = corpus["entry_cid"].tolist()
+    extra_edges: list[dict[str, Any]] = []
+    seen = 0
+    for start_i, part in iter_neighbor_shards(spill):
+        for offset, neigh in enumerate(part):
+            i = start_i + offset
+            if i >= n:
+                break
+            src = cid_by_idx[i]
+            for item in neigh:
+                if len(item) == 3:
+                    j, score, terms = item
+                else:
+                    j, score = item[0], item[1]
+                    terms = []
+                tgt = cid_by_idx[int(j)]
+                extra_edges.append(
+                    _edge(
+                        src,
+                        "BM25_NEIGHBOR_OF",
+                        tgt,
+                        "bm25-okapi",
+                        float(score),
+                        {"k": 8, "neighbor_index": int(j)},
+                        matched_terms=list(terms),
+                    )
+                )
+        seen += len(part)
+        del part
+        if len(extra_edges) >= 50_000:
+            # Flush into edges df incrementally
+            add = pd.DataFrame(extra_edges)
+            graph["edges"] = pd.concat([graph["edges"], add], ignore_index=True)
+            extra_edges.clear()
+            del add
+            gc.collect()
+            checkpoint(f"graph_neighbor_edges@{seen}", row=seen, every_n=50_000, log=log)
+    if extra_edges:
+        add = pd.DataFrame(extra_edges)
+        graph["edges"] = pd.concat([graph["edges"], add], ignore_index=True)
+        del add, extra_edges
+        gc.collect()
+
+    edges_df = graph["edges"]
+    if not edges_df.empty:
+        edges_df = edges_df.drop_duplicates("edge_cid").reset_index(drop=True)
+        edges_df = edges_df.sort_values(
+            ["edge_type", "source_cid", "target_cid"]
+        ).reset_index(drop=True)
+    graph["edges"] = edges_df
+    node_type = {r["node_cid"]: r["node_type"] for r in graph["nodes"].to_dict("records")}
+    incoming, outgoing = _adjacency(edges_df, node_type)
+    graph["incoming"] = incoming
+    graph["outgoing"] = outgoing
+    graph["stats"] = {
+        "n_nodes": int(len(graph["nodes"])),
+        "n_edges": int(len(edges_df)),
+        "n_doc_nodes": int(
+            graph["nodes"]["node_type"].isin(["law_entry", "article", "law"]).sum()
+        ),
+        "n_facet_nodes": int(
+            graph["nodes"]["node_type"].astype(str).str.startswith("facet_").sum()
+        ),
+        "edge_types": sorted(edges_df["edge_type"].unique().tolist())
+        if not edges_df.empty
+        else [],
+    }
+    if log:
+        log(
+            f"graph from shards nodes={graph['stats']['n_nodes']} "
+            f"edges={graph['stats']['n_edges']}"
+        )
+    return graph
+
+
+def build_bm25_tf_spill(
+    corpus_path: Path,
+    spill: Path,
+    n_docs: int,
+    *,
+    batch: int = 512,
+    log: Callable[[str], None] | None = None,
+) -> dict[str, Any]:
+    """Stream tokenize corpus → SQLite TF → bm25_documents/postings parquet + stats.
+
+    Resume: if bm25_documents.parquet + bm25_postings.parquet + bm25_stats.pkl 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_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 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")
+    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"
+    )
+    title_len = np.zeros(n_docs, dtype=np.int32)
+    body_len = np.zeros(n_docs, dtype=np.int32)
+    meta_path = spill / "doc_meta_rows.parquet"
+    meta_path.unlink(missing_ok=True)
+    meta_buf: list[dict] = []
+    pf = pq.ParquetFile(corpus_path)
+    schema_names = set(pf.schema_arrow.names)
+    cols = [
+        c
+        for c in [
+            "document_index",
+            "entry_cid",
+            "law_cid",
+            "instrument_id",
+            "law_id",
+            "source_id",
+            "title",
+            "instrument_title",
+            "article_number",
+            "article_title",
+            "record_type",
+            "language",
+            "jurisdiction",
+            "body",
+        ]
+        if c in schema_names
+    ]
+    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"])
+        for i in range(m):
+            di = int(d["document_index"][i])
+            title = str((d.get("title") or [""])[i] or "")
+            body = str((d.get("body") or [""])[i] or "")
+            tt = tokenize(title)
+            bt = tokenize(body)
+            title_len[di] = len(tt)
+            body_len[di] = len(bt)
+            tf_t: dict[str, int] = defaultdict(int)
+            tf_b: dict[str, int] = defaultdict(int)
+            for tok in tt:
+                tf_t[tok] += 1
+            for tok in bt:
+                tf_b[tok] += 1
+            for tok in set(tf_t) | set(tf_b):
+                batch_rows.append((tok, di, int(tf_t.get(tok, 0)), int(tf_b.get(tok, 0))))
+            law_id = str((d.get("law_id") or d.get("instrument_id") or [""])[i] or "")
+            instrument_id = str(
+                (d.get("instrument_id") or d.get("law_id") or [""])[i] or ""
+            )
+            meta_buf.append(
+                {
+                    "entry_cid": str(d["entry_cid"][i]),
+                    "document_index": di,
+                    "law_cid": str((d.get("law_cid") or [""])[i] or ""),
+                    "instrument_id": instrument_id,
+                    "law_id": law_id,
+                    "source_id": str(d["source_id"][i]),
+                    "title": title,
+                    "instrument_title": str(
+                        (d.get("instrument_title") or [""])[i] or ""
+                    ),
+                    "article_number": str((d.get("article_number") or [""])[i] or ""),
+                    "article_title": str((d.get("article_title") or [""])[i] or ""),
+                    "record_type": str(d["record_type"][i]),
+                    "language": str((d.get("language") or [""])[i] or ""),
+                    "jurisdiction": str((d.get("jurisdiction") or [""])[i] or ""),
+                }
+            )
+            if len(batch_rows) >= 20_000:
+                conn.executemany(
+                    "INSERT OR REPLACE INTO tf VALUES (?,?,?,?)", batch_rows
+                )
+                batch_rows.clear()
+        processed += m
+        if len(meta_buf) >= 20_000:
+            dfm = pd.DataFrame(meta_buf)
+            if meta_path.exists():
+                old = pd.read_parquet(meta_path)
+                dfm = pd.concat([old, dfm], ignore_index=True)
+                del old
+            dfm.to_parquet(meta_path, index=False)
+            del dfm
+            meta_buf.clear()
+            gc.collect()
+        if processed % 20_000 == 0:
+            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)
+        batch_rows.clear()
+    if meta_buf:
+        dfm = pd.DataFrame(meta_buf)
+        if meta_path.exists():
+            old = pd.read_parquet(meta_path)
+            dfm = pd.concat([old, dfm], ignore_index=True)
+            del old
+        dfm.to_parquet(meta_path, index=False)
+        del dfm
+        meta_buf.clear()
+    conn.commit()
+    if log:
+        log("bm25 tf spilled; 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
+    meta_df = pd.read_parquet(meta_path).sort_values("document_index").reset_index(drop=True)
+    assert len(meta_df) == n_docs
+    meta_df["title_length"] = title_len[meta_df["document_index"].to_numpy()]
+    meta_df["body_length"] = body_len[meta_df["document_index"].to_numpy()]
+    meta_df["document_length"] = np.round(
+        doc_len[meta_df["document_index"].to_numpy()]
+    ).astype(int)
+    meta_df["schema_version"] = SCHEMA_VERSION
+    meta_df.to_parquet(docs_path, index=False)
+    del meta_df
+    gc.collect()
+    meta_path.unlink(missing_ok=True)
+
+    posting_rows: list[dict] = []
+    n_postings = 0
+    n_terms = 0
+    part_i = 0
+    cur_term = None
+    cur_items: list = []
+
+    def flush_term(term: str, items: list) -> None:
+        nonlocal n_postings, n_terms, part_i, posting_rows
+        if not items:
+            return
+        n_terms += 1
+        dfreq = len(items)
+        cfreq = sum(int(ttf) + int(btf) for _, ttf, btf in items)
+        idf = _idf(n_docs, dfreq)
+        chunks = [
+            items[i : i + POSTING_ROWS_PER_RECORD]
+            for i in range(0, max(len(items), 1), POSTING_ROWS_PER_RECORD)
+        ]
+        n_chunks = len(chunks)
+        for cidx, chunk in enumerate(chunks):
+            posting_rows.append(
+                {
+                    "term": term,
+                    "document_indices": [int(d) for d, _, _ in chunk],
+                    "title_frequencies": [int(ttf) for _, ttf, _ in chunk],
+                    "body_frequencies": [int(btf) for _, _, btf in chunk],
+                    "tfs": [
+                        TITLE_WEIGHT * int(ttf) + BODY_WEIGHT * int(btf)
+                        for _, ttf, btf in chunk
+                    ],
+                    "lengths": [int(round(doc_len[int(d)])) for d, _, _ in chunk],
+                    "document_lengths": [
+                        int(round(doc_len[int(d)])) for d, _, _ in chunk
+                    ],
+                    "document_frequency": int(dfreq),
+                    "corpus_frequency": int(cfreq),
+                    "idf": float(idf),
+                    "posting_chunk_index": int(cidx),
+                    "posting_chunk_count": int(n_chunks),
+                    "schema_version": SCHEMA_VERSION,
+                }
+            )
+        n_postings += dfreq
+        if len(posting_rows) >= 8_000:
+            pd.DataFrame(posting_rows).to_parquet(
+                spill / f"postings_part_{part_i:08d}.parquet", index=False
+            )
+            posting_rows.clear()
+            part_i += 1
+            gc.collect()
+
+    for term, doc, ttf, btf in conn.execute(
+        "SELECT term, doc, ttf, btf FROM tf ORDER BY term, doc"
+    ):
+        term = str(term)
+        if cur_term is None:
+            cur_term = term
+        if term != cur_term:
+            flush_term(cur_term, cur_items)
+            cur_items = []
+            cur_term = term
+            if n_terms and n_terms % 50_000 == 0:
+                checkpoint(f"bm25_postings_terms", row=n_terms, every_n=50_000, log=log)
+        cur_items.append((int(doc), int(ttf), int(btf)))
+    if cur_term is not None:
+        flush_term(cur_term, cur_items)
+    if posting_rows:
+        pd.DataFrame(posting_rows).to_parquet(
+            spill / f"postings_part_{part_i:08d}.parquet", index=False
+        )
+        posting_rows.clear()
+    conn.close()
+    gc.collect()
+
+    parts = sorted(spill.glob("postings_part_*.parquet"))
+    frames: list[pd.DataFrame] = []
+    for i, part in enumerate(parts):
+        frames.append(pd.read_parquet(part))
+        if len(frames) >= 8:
+            frames = [pd.concat(frames, ignore_index=True)]
+            gc.collect()
+        if i and i % 20 == 0:
+            checkpoint(f"concat_postings", row=i, every_n=20, log=log)
+    postings = pd.concat(frames, ignore_index=True) if frames else pd.DataFrame()
+    del frames
+    for part in parts:
+        part.unlink()
+    postings.to_parquet(post_path, index=False)
+    out_rows = len(postings)
+    del postings
+    gc.collect()
+    stats = {
+        "k1": K1,
+        "b": B,
+        "title_weight": TITLE_WEIGHT,
+        "body_weight": BODY_WEIGHT,
+        "average_document_length": avgdl,
+        "tokenizer": "fts5-unicode61-remove-diacritics-2-python/v1",
+        "max_query_terms": 64,
+        "posting_rows_per_record": POSTING_ROWS_PER_RECORD,
+        "terms_per_shard": TERMS_PER_SHARD,
+        "n_docs": n_docs,
+        "n_terms": int(n_terms),
+        "n_posting_rows": int(out_rows),
+        "n_postings": int(n_postings),
+    }
+    spill_pickle(stats_path, stats)
+    try:
+        bm25_sql.unlink()
+    except Exception:
+        pass
+    if log:
+        log(f"bm25 spill done terms={n_terms} posting_rows={out_rows}")
+    return {"stats": stats, "documents": docs_path, "postings": post_path}
+
+
+def should_use_sqlite(n_docs: int, threshold: int = SQLITE_THRESHOLD) -> bool:
+    return n_docs >= threshold

country_laws_ir/upload.py

@@ -1,24 +1,119 @@
-"""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}")
+
+    from ipfs_datasets_py.huggingface.protected_repo_guard import (
+        require_unprotected_or_runtime,
+    )
+
+    require_unprotected_or_runtime(repo_id, method="upload_folder")
+
+    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(
@@ -109,6 +109,14 @@ def encode_corpus(
         out[done:j] = np.asarray(chunk, dtype=np.float32)
         done = j
         print(f"embeddings checkpoint {done}/{n}", flush=True)
+        try:
+            from .mem import checkpoint as _mem_checkpoint
+            _mem_checkpoint(f"embeddings@{done}", row=done, every_n=max(chunk_size, 4096))
+        except Exception as _mem_exc:
+            # MemAbort should propagate; other import issues are non-fatal
+            from .mem import MemAbort
+            if isinstance(_mem_exc, MemAbort):
+                raise
         if ckpt is not None:
             ckpt.parent.mkdir(parents=True, exist_ok=True)
             tmp = ckpt.with_name(ckpt.name + ".tmp.npy")
@@ -152,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]:
@@ -325,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:d345ec5581397c74a89b1ed1048f474287f1b5129367c9b638003a9c3484d603
-size 264694
+oid sha256:9715076442ca16843e1d3b668c2dd4f72da6fe73ca866a619410f0e7e05bef22
+size 225443

data/bm25/documents/part-000001.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:1c34ab9ba4967e07d922a3e1dc40d2ea8ccbc6c63f0ca933ed6c55ad823f40fe
-size 60550
+oid sha256:d79f787718607e3065b05ac9158ba4cf04849eb19487abc3dd0a9cac1d84d336
+size 228691

data/bm25/documents/part-000002.parquet

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

data/bm25/postings/part-000000.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9e4eee65e33f3248b0a26291e28eedb3aaf5ed23aa5c9598ec9d0578f3576b5b
-size 61192
+oid sha256:266797c124919a5850f86412ec1d6048e89eafd7256167b93aab43adbfcdf8af
+size 91212

data/corpus/part-000000.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:de235829a76e4a7cce70a64b8012a2429df5dd491900693d1539f330d5b3011a
-size 1169368
+oid sha256:46102abb0a7568dbe47d0a5499394ed6cbc49e2bf3d4299f52240d0ea8b1b182
+size 825350

data/corpus/part-000001.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:71264c61710b4ba78aa5d43d811413fced90735af5d5ea2adea21c8370067706
-size 217659
+oid sha256:e3dcf57cf368128c832290a45e1a8b3b2bb955dcea47e4b7d1ba7ee7cefd8141
+size 889092

data/corpus/part-000002.parquet

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

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

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:1470056f8510670ca0d7415acd2036f06b4822198bfb595226fda3899aa07028
-size 1919573
+oid sha256:b5ae8159e9610e8273b6f0ae6808135665013f4e2a2328dc58b807e553d60c39
+size 4043739

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

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

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

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:170fd7e68c564206b2787385b5f04e19a0196b7095a5a675c748b7739513a346
-size 1690859
+oid sha256:a25617b35049c699a029cbe0bd2f8c66bdabca99de45f26cde1a7c067552400c
+size 1697225

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

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:318f674adc836c6f059986fd1c606a3c14789508f5d0b0d3a5faa7262088fb55
-size 284009
+oid sha256:307f38ab0a43180a9633bc71c28f7e9f6ba8a394f30419917db2d9dc51f97ae8
+size 1706486

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

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

data/graph/edges/part-000000.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:4e1e7ae18f7f655a1284c8a08971b3821975e34dfd5f3f73a5e8334c04a7a3a3
-size 336796
+oid sha256:3e51821bcf8f013af89fc53a9924d5b2b6deb04470e10618e6654de10981f3e5
+size 348216

data/graph/edges/part-000001.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:4cd2b8af88680ad1a586445e7b2885a28c8be29dfec2c0ec0ff329b6b8f41744
-size 271946
+oid sha256:2a541f531b76a820aa78026ce21f31a22777dd3438375550930f8ee39bcd4185
+size 348363

data/graph/edges/part-000002.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:669a1f7747159d8049ec6f0621767868e622cbcd11c88abbc5e259c62819c6ca
-size 244967
+oid sha256:fbbd636f8d7b99cb7003542cf13d8f278c98c0fedff4004be73374a6147ac5c6
+size 330693

data/graph/edges/part-000003.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6c420523f984d8681a7f9076bfeb4f964dee054d2612f5192592f37fbbee08bc
-size 250330
+oid sha256:9d53666031670a391288610840421c434fd843c70aae3aaf35fc6f487c4f63fe
+size 260252

data/graph/edges/part-000004.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:698cae834637ba330cac9f38b2592eae9c46220b1bc734bce877a8f62188d4f6
-size 318588
+oid sha256:feb8c16c3cdedc1c18f494a1dc278c150f621bd0a95644edce79624287cdbfc9
+size 262502

data/graph/edges/part-000005.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:d034aefbb5e1133fed88c915b0c60644bfd9e6be1628058fec015caefe02822e
-size 309322
+oid sha256:22c81d796baa1c7e1ae327932db90377301f6962c002388f0c8238b792c087be
+size 255648

data/graph/edges/part-000006.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:2df223ad01074d03c32638631a1f27c9f8818d6d665272fb815b5dc1cf61c47f
-size 295287
+oid sha256:08de6ce68626afd1133d61fbac3e80d5352eabd5490a33c6a54c97fe4e814e3f
+size 259115

data/graph/edges/part-000007.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f042a4f3ed3a1899c392363f6aac204a514da5fb614fbe75b3a08da69ecbd168
-size 295317
+oid sha256:32f91d29ec12a64f68c17039f75714915f3edd93bba0deba18c92bfd7a02b98e
+size 261895

data/graph/edges/part-000008.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:01046772948634bcec10e065befdeedf19720bd9d3bdbdef79a6b8b5a0d98ccf
-size 295177
+oid sha256:4fee4ab4126d602f365eb58ac6ba71fed18669174ee1f25d00aea324be297d88
+size 287748

data/graph/edges/part-000009.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f71d7008f704d2ac3940cb652e9f9095a524a20c1103702b337934feae5fe5a9
-size 304736
+oid sha256:667069c928f98dba9d646e16edd75d353023c4f1215f3b366f5b519513117d72
+size 325546

data/graph/edges/part-000010.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:3b2b1616145a5a52e8d7831dfb7d46d71a6ec295eac1c09698c610e8b2323964
-size 313212
+oid sha256:b5095fe5abfa27d30d8b59957761caecbb1bae240b4f0eb7746dc5926ab72776
+size 325416

data/graph/edges/part-000011.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:3a6eeabea29335583af5848c6d69769c91881da832c1fc131b83f92b84e3ac64
-size 20795
+oid sha256:4b782af9977168879129a14bfe0965fba9da3b0bd2d69cc3b284224048b5eddc
+size 318293

data/graph/edges/part-000012.parquet

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

data/graph/edges/part-000013.parquet

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

data/graph/edges/part-000014.parquet

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

data/graph/edges/part-000015.parquet

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

data/graph/edges/part-000016.parquet

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

data/graph/edges/part-000017.parquet

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

data/graph/edges/part-000018.parquet

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

data/graph/edges/part-000019.parquet

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

data/graph/edges/part-000020.parquet

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