Datasets:

justicedao
/

ipfs_pakistan_laws_ir

@@ -1,59 +1,78 @@
 {
-  "schema_version": "country-laws-ir-graphrag/v1",
-  "layout_family": "skillcenter-huggingface-release/v3",
-  "packager_version": "0.3.0",
-  "primary_key": "entry_cid",
-  "dataset_id": "endomorphosis/ipfs_pakistan_laws",
-  "dataset_repo_id": "justicedao/ipfs_pakistan_laws_ir",
-  "dataset_revision": "1455aac2978239f7047f06cf5755b217b315b158",
-  "country": {
-    "slug": "pakistan",
-    "repo": "endomorphosis/ipfs_pakistan_laws",
-    "name": "Pakistan",
-    "indexable": true
-  },
-  "disclaimer": "Research snapshot. Not legal advice. The official gazette / authentic source prevails.",
   "bm25": {
-    "k1": 1.2,
     "b": 0.75,
-    "title_weight": 5.0,
     "body_weight": 1.0,
-    "average_document_length": 1026.2346622105515,
-    "tokenizer": "fts5-unicode61-remove-diacritics-2-python/v1",
     "max_query_terms": 64,
     "posting_rows_per_record": 4096,
-    "terms_per_shard": 4096
   },
   "counts": {
     "bm25_document_chunks": 2,
     "bm25_documents": 4189,
     "bm25_keyword_shards": 7,
     "bm25_posting_rows": 28374,
     "bm25_postings": 897615,
     "bm25_terms": 28374,
     "corpus_chunks": 2,
     "corpus_rows": 4189,
     "graph_edge_chunks": 10,
     "graph_edges": 40442,
     "graph_incoming_adjacency_edges": 40442,
     "graph_incoming_adjacency_rows": 3733,
     "graph_incoming_adjacency_shards": 1,
     "graph_node_chunks": 2,
     "graph_nodes": 5171,
     "graph_outgoing_adjacency_edges": 40442,
     "graph_outgoing_adjacency_rows": 4189,
     "graph_outgoing_adjacency_shards": 2,
-    "vector_chunks": 2,
-    "vector_rows": 4189,
     "n_laws": 0,
-    "n_articles": 4189
-  },
-  "parquet": {
-    "compression": "zstd",
-    "compression_level": 6,
-    "max_rows_per_file": 4096,
-    "row_group_size": 4096
   },
   "graph": {
     "adjacency_pointers_per_row": 4096,
     "adjacency_pointers_per_shard": 8192,
@@ -61,8 +80,6 @@
       "incoming",
       "outgoing"
     ],
-    "max_remote_walk_depth": 8,
-    "ordering": "score_desc_nulls_last",
     "edge_types": [
       "ARTICLE_OF",
       "BM25_NEIGHBOR_OF",
@@ -72,94 +89,221 @@
       "HAS_SOURCE",
       "HAS_STATUS",
       "IDENTIFIED_BY"
-    ]
   },
-  "vector": {
-    "model_name": "thenlper/gte-small",
-    "dimension": 384,
-    "similarity": "cosine",
-    "assignment": "recursive_spherical_kmeans",
-    "layout": "semantic_centroid_groups",
-    "rows_sorted_by": "cosine_similarity_to_shard_centroid_desc",
-    "max_rows_per_chunk": 4096,
-    "max_rows_per_centroid": 8192,
-    "max_shards_per_centroid": 2,
-    "default_probe_centroids": 2,
-    "centroid_count": 2,
-    "shard_count": 2,
-    "n_vectors": 4189,
-    "status": "embedded"
   },
-  "canonical_fields": [
-    "entry_cid",
-    "law_cid",
-    "record_type",
-    "jurisdiction",
-    "language",
-    "instrument_id",
-    "instrument_title",
-    "article_number",
-    "article_title",
-    "title",
-    "body",
-    "source_url",
-    "snapshot_date",
-    "coverage",
-    "license",
-    "collector",
-    "source_dataset",
-    "source_revision"
-  ],
   "input_sha256": {
-    "laws.parquet": "3e78a111290f997799a167ea90495ba28ea8a429eb4fdf8d46a30066f017c8d0",
-    "articles.parquet": "c64c476a788b97fe949e5cb0a583753c9cb12e45b68bbf553a86ab5a4086113f"
   },
   "model_id": "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": {
-    "source_dataset": "endomorphosis/ipfs_pakistan_laws",
-    "source_revision": "1455aac2978239f7047f06cf5755b217b315b158",
-    "laws_sha256": "3e78a111290f997799a167ea90495ba28ea8a429eb4fdf8d46a30066f017c8d0",
-    "articles_sha256": "c64c476a788b97fe949e5cb0a583753c9cb12e45b68bbf553a86ab5a4086113f",
-    "n_laws_in": 958,
-    "n_articles_in": 4189,
-    "unit": "article",
     "article_law_coverage": 4.372651356993737,
-    "sparse_article_fallback": false,
     "drops": {
-      "empty_body": 0,
-      "missing_instrument": 0,
       "duplicate_cid": 0,
-      "duplicate_source_kept_first": 0
     },
-    "drop_samples": {
-      "empty_body": [],
-      "missing_instrument": [],
-      "duplicate_cid": []
     },
     "language_breakdown": {
       "en": 4189
     },
     "quality_flags": {
-      "articles_table_empty": false,
-      "sparse_article_fallback": false,
-      "article_law_coverage": 4.372651356993737,
       "all_source_article_counts_zero": false,
       "article_extraction_status_counts": {
-        "ok": 326,
-        "missing": 632
       },
       "missing_date": false,
       "missing_date_issued": true,
-      "eli_present": false,
       "never_invented_legal_text": true,
-      "empty_bodies_dropped": 0,
-      "duplicate_cids_dropped": 0
     },
     "schema_surprises": [
       "laws.article_count dtype=int32",
@@ -167,107 +311,66 @@
       "laws.eli non-null=0/958",
       "laws.language values=['en']"
     ],
-    "n_out": 4189,
-    "never_invented_legal_text": true,
-    "n_before_dedupe": 4189,
-    "n_dropped_total": 0,
-    "record_type_breakdown": {
-      "article": 4189
-    },
-    "jurisdiction_breakdown": {
-      "PK": 4189
-    },
     "snapshot_dates": [
       "2026-09-03"
-    ]
   },
   "schema_mapping": {
-    "laws": {
-      "id": "instrument_id",
-      "title": "instrument_title",
-      "text": "body",
-      "article_count_dtype_source": "int32"
-    },
     "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": {
-      "cid": "bafkreibweooqqhvormikdxj5sobo5rsm7xpr44npkd44updtcqign25nka",
-      "sha256": "36239d081eae8b10a1dd3d9382eec64cfddf1e71af50f9ca3c73141066ebad50",
-      "size_bytes": 9041,
-      "relative_path": "indexes/bm25_document_chunks.parquet"
-    },
-    "bm25_keyword_shards": {
-      "cid": "bafkreifdycukwlbfr5qguzvydycne5lsdel65pzk6nnxakb4xev4odte6i",
-      "sha256": "a3c0a8ab2c258f606a66b81e04d275721917eebf2af35b70283cb92bc70e64f2",
-      "size_bytes": 10862,
-      "relative_path": "indexes/bm25_keyword_shards.parquet"
-    },
-    "corpus_chunks": {
-      "cid": "bafkreif5e77tq4ssvc37s3obghhyx5hanjfl7ckn4yn7hplmx3rzhukcyu",
-      "sha256": "bd27ff387252a8b7f96dc131cf8bf4e06a4abf894de61bf3bd6cbee393d142c5",
-      "size_bytes": 8959,
-      "relative_path": "indexes/corpus_chunks.parquet"
-    },
-    "graph_edge_chunks": {
-      "cid": "bafkreialkroh3qbkmczcmffhxf6s5n7rmbpcc7w4ojy26wnejtet6hudmi",
-      "sha256": "0b545c7dc02a60b22614a7b97d2eb7f1605e217edc7271af59a44cc93f1e8362",
-      "size_bytes": 10236,
-      "relative_path": "indexes/graph_edge_chunks.parquet"
-    },
-    "graph_incoming_adjacency": {
-      "cid": "bafkreig4sordi3o2wm5x33j4oasim6mqbeyomsd5snusqffdiqjurk3jzu",
-      "sha256": "dc93a2346ddab33b7ded3c70248679900930e6487d93692814a3441348ab69cd",
-      "size_bytes": 11958,
-      "relative_path": "indexes/graph_incoming_adjacency.parquet"
-    },
-    "graph_node_chunks": {
-      "cid": "bafkreiebzxmpmol3wdpn5pnfxpn4p24nohbgznzxqhagkpkzt4g3w2mncu",
-      "sha256": "81cdd8f6397bb0dedebda5bbdbc7eb8d71c26cb73781c0653d599f0dbb698d15",
-      "size_bytes": 8991,
-      "relative_path": "indexes/graph_node_chunks.parquet"
-    },
-    "graph_outgoing_adjacency": {
-      "cid": "bafkreihldpn2sp4z7wmlbvnskq3miocwaagq5xpfevz5dkdvileeiq22rq",
-      "sha256": "eb1bdba93f99fd98b0d5b25436c43856000d0edde52573d1a87542c844435a8c",
-      "size_bytes": 12182,
-      "relative_path": "indexes/graph_outgoing_adjacency.parquet"
-    },
-    "vector_chunks": {
-      "cid": "bafkreihuoy7brzfhcbunx47dtnl3oy442lknpjyqixg45krjrrnt6gi6u4",
-      "sha256": "f4763e18e4a71068dbf3e39b57b7639cd2d4d7a71045cdceaa298c5b3f191ea7",
-      "size_bytes": 22883,
-      "relative_path": "indexes/vector_chunks.parquet"
-    }
   },
   "source": {
-    "source_dataset": "endomorphosis/ipfs_pakistan_laws",
-    "source_revision": "1455aac2978239f7047f06cf5755b217b315b158",
-    "laws_path": "/workspace/country-laws-ir/cache/hf/datasets--endomorphosis--ipfs_pakistan_laws/snapshots/1455aac2978239f7047f06cf5755b217b315b158/data/laws.parquet",
     "articles_path": "/workspace/country-laws-ir/cache/hf/datasets--endomorphosis--ipfs_pakistan_laws/snapshots/1455aac2978239f7047f06cf5755b217b315b158/data/articles.parquet",
-    "laws_sha256": "3e78a111290f997799a167ea90495ba28ea8a429eb4fdf8d46a30066f017c8d0",
     "articles_sha256": "c64c476a788b97fe949e5cb0a583753c9cb12e45b68bbf553a86ab5a4086113f",
-    "n_laws_source": 958,
-    "n_articles_source": 4189,
     "laws_columns": [
       "id",
       "title",
@@ -289,23 +392,33 @@
       "json_path",
       "metadata_json"
     ],
-    "articles_columns": [
-      "law_id",
-      "id",
-      "title",
-      "text",
-      "source_url",
-      "document_number",
-      "article_number",
-      "record_type",
-      "metadata_json"
-    ],
-    "article_count_dtype": "int32",
     "schema_surprises": [
       "laws.article_count dtype=int32",
       "laws.date_issued is entirely null",
       "laws.eli non-null=0/958",
       "laws.language values=['en']"
-    ]
   }
 }

 {
   "bm25": {
+    "average_document_length": 1026.2346622105515,
     "b": 0.75,
     "body_weight": 1.0,
+    "k1": 1.2,
     "max_query_terms": 64,
     "posting_rows_per_record": 4096,
+    "terms_per_shard": 4096,
+    "title_weight": 5.0,
+    "tokenizer": "fts5-unicode61-remove-diacritics-2-python/v1"
+  },
+  "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"
+  ],
+  "cid": {
+    "codec": "raw",
+    "hash": "sha2-256",
+    "multibase": "base32",
+    "payload": "json.dumps(obj, sort_keys=True, ensure_ascii=False, separators=(',', ':')).encode('utf-8')"
+  },
+  "country": {
+    "indexable": true,
+    "name": "Pakistan",
+    "repo": "endomorphosis/ipfs_pakistan_laws",
+    "slug": "pakistan"
   },
   "counts": {
     "bm25_document_chunks": 2,
     "bm25_documents": 4189,
     "bm25_keyword_shards": 7,
     "bm25_posting_rows": 28374,
+    "bm25_posting_shards": 7,
     "bm25_postings": 897615,
     "bm25_terms": 28374,
     "corpus_chunks": 2,
     "corpus_rows": 4189,
+    "corpus_shards": 2,
     "graph_edge_chunks": 10,
     "graph_edges": 40442,
     "graph_incoming_adjacency_edges": 40442,
     "graph_incoming_adjacency_rows": 3733,
     "graph_incoming_adjacency_shards": 1,
     "graph_node_chunks": 2,
+    "graph_node_shards": 2,
     "graph_nodes": 5171,
     "graph_outgoing_adjacency_edges": 40442,
     "graph_outgoing_adjacency_rows": 4189,
     "graph_outgoing_adjacency_shards": 2,
+    "n_articles": 4189,
     "n_laws": 0,
+    "vector_chunks": 2,
+    "vector_rows": 4189
   },
+  "dataset_id": "endomorphosis/ipfs_pakistan_laws",
+  "dataset_repo_id": "justicedao/ipfs_pakistan_laws_ir",
+  "dataset_revision": "1455aac2978239f7047f06cf5755b217b315b158",
+  "disclaimer": "Research snapshot. Not legal advice. The official gazette / authentic source prevails.",
   "graph": {
     "adjacency_pointers_per_row": 4096,
     "adjacency_pointers_per_shard": 8192,
       "incoming",
       "outgoing"
     ],
     "edge_types": [
       "ARTICLE_OF",
       "BM25_NEIGHBOR_OF",
       "HAS_SOURCE",
       "HAS_STATUS",
       "IDENTIFIED_BY"
+    ],
+    "max_remote_walk_depth": 8,
+    "ordering": "score_desc_nulls_last"
   },
+  "indexes": {
+    "bm25_document_chunks": {
+      "cid": "bafkreibweooqqhvormikdxj5sobo5rsm7xpr44npkd44updtcqign25nka",
+      "content_cid": "bafkreiaqk3yr7ogvphbkh64thhmkspvuoxqqgqikgr2sbgw44tqyfnnxx4",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/bm25_document_chunks.parquet",
+      "row_count": 2,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "1056f11fb8d579c2a3fb9339d8a93eb475e103410a3475209adce4e182b5b7bf",
+      "size_bytes": 5194
+    },
+    "bm25_documents": {
+      "content_cid": "bafkreiaqk3yr7ogvphbkh64thhmkspvuoxqqgqikgr2sbgw44tqyfnnxx4",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/bm25_document_chunks.parquet",
+      "row_count": 2,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "1056f11fb8d579c2a3fb9339d8a93eb475e103410a3475209adce4e182b5b7bf",
+      "size_bytes": 5194
+    },
+    "bm25_keyword_index": {
+      "content_cid": "bafkreic7liukomgtqc3nafmleq43jrnb4wmunqkxqej25vjkb4fi33ldom",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/bm25_keyword_shards.parquet",
+      "row_count": 7,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "5f5a28a730d380b6d0158b2439b4c5a1e59946c1578113aed52a0f0a8ded6373",
+      "size_bytes": 5255
+    },
+    "bm25_keyword_shards": {
+      "cid": "bafkreifdycukwlbfr5qguzvydycne5lsdel65pzk6nnxakb4xev4odte6i",
+      "content_cid": "bafkreic7liukomgtqc3nafmleq43jrnb4wmunqkxqej25vjkb4fi33ldom",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/bm25_keyword_shards.parquet",
+      "row_count": 7,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "5f5a28a730d380b6d0158b2439b4c5a1e59946c1578113aed52a0f0a8ded6373",
+      "size_bytes": 5255
+    },
+    "bm25_postings": {
+      "content_cid": "bafkreic7liukomgtqc3nafmleq43jrnb4wmunqkxqej25vjkb4fi33ldom",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/bm25_keyword_shards.parquet",
+      "row_count": 7,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "5f5a28a730d380b6d0158b2439b4c5a1e59946c1578113aed52a0f0a8ded6373",
+      "size_bytes": 5255
+    },
+    "corpus": {
+      "content_cid": "bafkreigkcgc447veovvtufspz3gpjcawm7ss32iu4j2nw7fla2d3nkjzti",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/corpus_chunks.parquet",
+      "row_count": 2,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "ca1185ce7ea4756b3a164fceccf4881667e52de914e274db7cab0687b6a9399a",
+      "size_bytes": 5108
+    },
+    "corpus_chunks": {
+      "cid": "bafkreif5e77tq4ssvc37s3obghhyx5hanjfl7ckn4yn7hplmx3rzhukcyu",
+      "content_cid": "bafkreigkcgc447veovvtufspz3gpjcawm7ss32iu4j2nw7fla2d3nkjzti",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/corpus_chunks.parquet",
+      "row_count": 2,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "ca1185ce7ea4756b3a164fceccf4881667e52de914e274db7cab0687b6a9399a",
+      "size_bytes": 5108
+    },
+    "graph_edge_chunks": {
+      "cid": "bafkreialkroh3qbkmczcmffhxf6s5n7rmbpcc7w4ojy26wnejtet6hudmi",
+      "content_cid": "bafkreietrw5b6x2hdexa46hqbtapko2m2oogbqxii3lg5w3tbycx26z3yi",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/graph_edge_chunks.parquet",
+      "row_count": 10,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "938dba1f5f47192e0e78f00cc0f53b4cd39c60c2e846d66edb730e057d7b3bc2",
+      "size_bytes": 6669
+    },
+    "graph_edges": {
+      "content_cid": "bafkreietrw5b6x2hdexa46hqbtapko2m2oogbqxii3lg5w3tbycx26z3yi",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/graph_edge_chunks.parquet",
+      "row_count": 10,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "938dba1f5f47192e0e78f00cc0f53b4cd39c60c2e846d66edb730e057d7b3bc2",
+      "size_bytes": 6669
+    },
+    "graph_incoming_adjacency": {
+      "cid": "bafkreig4sordi3o2wm5x33j4oasim6mqbeyomsd5snusqffdiqjurk3jzu",
+      "content_cid": "bafkreifcjopqb2xeflscvswixgiaihjtl4kyrqkc2h5avxqpdly2ry465a",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/graph_incoming_adjacency.parquet",
+      "row_count": 1,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "a24b9f00eae42ae42acac8b990041d335f1588c142d1fa0ade0f1af1a8e39ee8",
+      "size_bytes": 5042
+    },
+    "graph_node_chunks": {
+      "cid": "bafkreiebzxmpmol3wdpn5pnfxpn4p24nohbgznzxqhagkpkzt4g3w2mncu",
+      "content_cid": "bafkreihsym7fh6tg5q5j3tcg73hffgj37kvlhapglgclnwqmqlxc7v3kwi",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/graph_node_chunks.parquet",
+      "row_count": 2,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "f2c33e53fa66ec3a9dcc46fece52993bfaaab381e65984b6da0c82ee2fd76ab2",
+      "size_bytes": 5156
+    },
+    "graph_nodes": {
+      "content_cid": "bafkreihsym7fh6tg5q5j3tcg73hffgj37kvlhapglgclnwqmqlxc7v3kwi",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/graph_node_chunks.parquet",
+      "row_count": 2,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "f2c33e53fa66ec3a9dcc46fece52993bfaaab381e65984b6da0c82ee2fd76ab2",
+      "size_bytes": 5156
+    },
+    "graph_outgoing_adjacency": {
+      "cid": "bafkreihldpn2sp4z7wmlbvnskq3miocwaagq5xpfevz5dkdvileeiq22rq",
+      "content_cid": "bafkreidb26nfmo2f6vy2bllxb4tbtgj3hg56t7gvp3ksz3dhnauxlc3erm",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/graph_outgoing_adjacency.parquet",
+      "row_count": 2,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "61d79a563b45f571a0ad770f2619993b39bbe9fcd57ed52cec676829758b648b",
+      "size_bytes": 5295
+    },
+    "vector_chunks": {
+      "cid": "bafkreihuoy7brzfhcbunx47dtnl3oy442lknpjyqixg45krjrrnt6gi6u4",
+      "content_cid": "bafkreie7waagffbuxmzeb2oi43ggmr3k63nsz5gz4kxqet5vgpuah2ydfq",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/vector_chunks.parquet",
+      "row_count": 2,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "9fb000629434bb3240e9c8e6cc66476af6db2cf4d9e2af024fb533e803eb032c",
+      "size_bytes": 5116
+    },
+    "vectors": {
+      "content_cid": "bafkreie7waagffbuxmzeb2oi43ggmr3k63nsz5gz4kxqet5vgpuah2ydfq",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/vector_chunks.parquet",
+      "row_count": 2,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "9fb000629434bb3240e9c8e6cc66476af6db2cf4d9e2af024fb533e803eb032c",
+      "size_bytes": 5116
+    }
   },
   "input_sha256": {
+    "articles.parquet": "c64c476a788b97fe949e5cb0a583753c9cb12e45b68bbf553a86ab5a4086113f",
+    "laws.parquet": "3e78a111290f997799a167ea90495ba28ea8a429eb4fdf8d46a30066f017c8d0"
   },
+  "layout_family": "skillcenter-huggingface-release/v3",
   "model_id": "thenlper/gte-small",
   "normalization": {
     "article_law_coverage": 4.372651356993737,
+    "articles_sha256": "c64c476a788b97fe949e5cb0a583753c9cb12e45b68bbf553a86ab5a4086113f",
+    "drop_samples": {
+      "duplicate_cid": [],
+      "empty_body": [],
+      "missing_instrument": []
+    },
     "drops": {
       "duplicate_cid": 0,
+      "duplicate_source_kept_first": 0,
+      "empty_body": 0,
+      "missing_instrument": 0
     },
+    "jurisdiction_breakdown": {
+      "PK": 4189
     },
     "language_breakdown": {
       "en": 4189
     },
+    "laws_sha256": "3e78a111290f997799a167ea90495ba28ea8a429eb4fdf8d46a30066f017c8d0",
+    "n_articles_in": 4189,
+    "n_before_dedupe": 4189,
+    "n_dropped_total": 0,
+    "n_laws_in": 958,
+    "n_out": 4189,
+    "never_invented_legal_text": true,
     "quality_flags": {
       "all_source_article_counts_zero": false,
       "article_extraction_status_counts": {
+        "missing": 632,
+        "ok": 326
       },
+      "article_law_coverage": 4.372651356993737,
+      "articles_table_empty": false,
+      "duplicate_cids_dropped": 0,
+      "eli_present": false,
+      "empty_bodies_dropped": 0,
       "missing_date": false,
       "missing_date_issued": true,
       "never_invented_legal_text": true,
+      "sparse_article_fallback": false
+    },
+    "record_type_breakdown": {
+      "article": 4189
     },
     "schema_surprises": [
       "laws.article_count dtype=int32",
       "laws.eli non-null=0/958",
       "laws.language values=['en']"
     ],
     "snapshot_dates": [
       "2026-09-03"
+    ],
+    "source_dataset": "endomorphosis/ipfs_pakistan_laws",
+    "source_revision": "1455aac2978239f7047f06cf5755b217b315b158",
+    "sparse_article_fallback": false,
+    "unit": "article"
+  },
+  "packager_version": "0.3.0",
+  "parquet": {
+    "compression": "zstd",
+    "compression_level": 6,
+    "max_rows_per_file": 4096,
+    "row_group_size": 4096
   },
+  "primary_key": "entry_cid",
   "schema_mapping": {
     "articles": {
       "id": "source_id / article identity",
       "law_id": "instrument_id",
+      "text": "body",
+      "title": "article_title"
     },
+    "fail_closed": true,
+    "laws": {
+      "article_count_dtype_source": "int32",
+      "id": "instrument_id",
+      "text": "body",
+      "title": "instrument_title"
+    },
+    "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.",
+    "required_article_columns": [
       "id",
+      "law_id",
       "title",
       "text"
     ],
+    "required_law_columns": [
       "id",
       "title",
       "text"
     ],
+    "unit_policy": "prefer articles; fall back to law-level when articles empty"
   },
+  "schema_version": "country-laws-ir-graphrag/v1",
   "source": {
+    "article_count_dtype": "int32",
+    "articles_columns": [
+      "law_id",
+      "id",
+      "title",
+      "text",
+      "source_url",
+      "document_number",
+      "article_number",
+      "record_type",
+      "metadata_json"
+    ],
     "articles_path": "/workspace/country-laws-ir/cache/hf/datasets--endomorphosis--ipfs_pakistan_laws/snapshots/1455aac2978239f7047f06cf5755b217b315b158/data/articles.parquet",
     "articles_sha256": "c64c476a788b97fe949e5cb0a583753c9cb12e45b68bbf553a86ab5a4086113f",
     "laws_columns": [
       "id",
       "title",
       "json_path",
       "metadata_json"
     ],
+    "laws_path": "/workspace/country-laws-ir/cache/hf/datasets--endomorphosis--ipfs_pakistan_laws/snapshots/1455aac2978239f7047f06cf5755b217b315b158/data/laws.parquet",
+    "laws_sha256": "3e78a111290f997799a167ea90495ba28ea8a429eb4fdf8d46a30066f017c8d0",
+    "n_articles_source": 4189,
+    "n_laws_source": 958,
     "schema_surprises": [
       "laws.article_count dtype=int32",
       "laws.date_issued is entirely null",
       "laws.eli non-null=0/958",
       "laws.language values=['en']"
+    ],
+    "source_dataset": "endomorphosis/ipfs_pakistan_laws",
+    "source_revision": "1455aac2978239f7047f06cf5755b217b315b158"
+  },
+  "vector": {
+    "assignment": "recursive_spherical_kmeans",
+    "centroid_count": 2,
+    "default_probe_centroids": 2,
+    "dimension": 384,
+    "layout": "semantic_centroid_groups",
+    "max_rows_per_centroid": 8192,
+    "max_rows_per_chunk": 4096,
+    "max_shards_per_centroid": 2,
+    "model_name": "thenlper/gte-small",
+    "n_vectors": 4189,
+    "rows_sorted_by": "cosine_similarity_to_shard_centroid_desc",
+    "shard_count": 2,
+    "similarity": "cosine",
+    "status": "embedded"
   }
 }

scripts/query_hf_graphrag.py ADDED Viewed

	@@ -0,0 +1,406 @@

+#!/usr/bin/env python3
+"""Standalone thin-client search for a Hugging Face GraphRAG release.
+Hub consumers can copy ``scripts/query_hf_graphrag.py`` (and
+``semantic_traversal.py`` when present) out of the dataset and search without
+downloading the full corpus:
+  python scripts/query_hf_graphrag.py --local-root . bm25 "foia agency"
+  python scripts/query_hf_graphrag.py --repo-id ORG/NAME --revision PIN \\
+      neighbors bafkrei... --direction both --limit 25
+Requires pyarrow. Remote queries also need huggingface_hub. Vector search
+needs numpy; local embedding needs sentence-transformers.
+"""
+from __future__ import annotations
+import argparse
+import hashlib
+import heapq
+import json
+import math
+import os
+import re
+import sys
+from collections import defaultdict
+from pathlib import Path, PurePosixPath
+from typing import Any, Mapping, Sequence
+TOKEN_RE = re.compile(r"[a-z0-9]+(?:[-_./:][a-z0-9]+)*", re.I)
+DEFAULT_MANIFEST = "manifest.json"
+DEFAULT_CACHE = Path("~/.cache/ipfs_datasets_py/hf-graphrag-query").expanduser()
+class RemoteQueryError(RuntimeError):
+    """Malformed release or missing dependency."""
+def _safe_relative(path: str) -> PurePosixPath:
+    rel = PurePosixPath(str(path or "").replace("\\", "/"))
+    if rel.is_absolute() or ".." in rel.parts or not rel.parts:
+        raise RemoteQueryError(f"unsafe release path: {path!r}")
+    return rel
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+class ArtifactResolver:
+    """Fetch only requested files from a local root or the Hub."""
+    def __init__(
+        self,
+        *,
+        repo_id: str,
+        revision: str,
+        token: str | None,
+        cache_dir: Path,
+        local_root: Path | None,
+    ) -> None:
+        self.repo_id = repo_id
+        self.revision = revision
+        self.token = token
+        self.cache_dir = cache_dir
+        self.local_root = local_root.expanduser().resolve() if local_root else None
+        self.fetched: dict[str, int] = {}
+    def path(self, relative: str, descriptor: Mapping[str, Any] | None = None) -> Path:
+        safe = _safe_relative(relative)
+        if self.local_root is not None:
+            path = (self.local_root.joinpath(*safe.parts)).resolve()
+            try:
+                path.relative_to(self.local_root)
+            except ValueError as exc:
+                raise RemoteQueryError("path escapes release root") from exc
+            if not path.is_file():
+                raise RemoteQueryError(f"missing {relative}")
+        else:
+            try:
+                from huggingface_hub import hf_hub_download
+            except ImportError as exc:
+                raise RemoteQueryError("huggingface_hub is required for --repo-id") from exc
+            path = Path(
+                hf_hub_download(
+                    repo_id=self.repo_id,
+                    filename=safe.as_posix(),
+                    repo_type="dataset",
+                    revision=self.revision,
+                    token=self.token,
+                    cache_dir=str(self.cache_dir),
+                )
+            )
+        if descriptor and descriptor.get("sha256"):
+            got = _sha256(path)
+            expected = str(descriptor["sha256"]).removeprefix("sha256:")
+            if got != expected:
+                raise RemoteQueryError(f"sha256 mismatch for {relative}")
+        self.fetched[safe.as_posix()] = path.stat().st_size
+        return path
+    def json(self, relative: str) -> Any:
+        return json.loads(self.path(relative).read_text(encoding="utf-8"))
+    def parquet(self, relative: str, columns: Sequence[str] | None = None, descriptor=None):
+        import pyarrow.parquet as pq
+        return pq.read_table(
+            self.path(relative, descriptor),
+            columns=list(columns) if columns else None,
+        )
+    def trace(self) -> dict[str, Any]:
+        files = [
+            {"relative_path": path, "size_bytes": size}
+            for path, size in sorted(self.fetched.items())
+        ]
+        return {
+            "file_count": len(files),
+            "files": files,
+            "total_file_bytes": sum(item["size_bytes"] for item in files),
+        }
+def _tokenize(query: str) -> list[str]:
+    return [token.lower() for token in TOKEN_RE.findall(query or "")]
+def _bm25_score(tf: float, idf: float, doc_len: float, avgdl: float, k1: float, b: float) -> float:
+    if tf <= 0 or idf <= 0 or avgdl <= 0:
+        return 0.0
+    denom = tf + k1 * (1.0 - b + b * (doc_len / avgdl))
+    if denom <= 0:
+        return 0.0
+    return idf * (tf * (k1 + 1.0) / denom)
+def _index_rows(manifest: Mapping[str, Any], key: str) -> list[dict[str, Any]]:
+    indexes = manifest.get("indexes") or {}
+    row = indexes.get(key) or indexes.get(key.replace("_", "-"))
+    return [row] if isinstance(row, dict) and row.get("relative_path") else []
+class ThinClient:
+    def __init__(self, resolver: ArtifactResolver, manifest: Mapping[str, Any]) -> None:
+        self.resolver = resolver
+        self.manifest = dict(manifest)
+    def _locator(self, name: str) -> list[dict[str, Any]]:
+        indexes = self.manifest.get("indexes") or {}
+        aliases = {
+            "bm25_keyword_shards": (
+                "bm25_keyword_shards",
+                "bm25_postings",
+                "bm25_keyword_index",
+            ),
+            "bm25_postings": (
+                "bm25_postings",
+                "bm25_keyword_shards",
+                "bm25_keyword_index",
+            ),
+        }.get(name, (name,))
+        candidates: list[tuple[str, Mapping[str, Any] | None]] = []
+        seen: set[str] = set()
+        for key in aliases:
+            desc = indexes.get(key)
+            if isinstance(desc, dict) and desc.get("relative_path"):
+                relative = str(desc["relative_path"])
+                if relative not in seen:
+                    candidates.append((relative, desc))
+                    seen.add(relative)
+            for fallback in (f"indexes/{key}.parquet", f"indexes/{key}.json"):
+                if fallback not in seen:
+                    candidates.append((fallback, None))
+                    seen.add(fallback)
+        for relative, desc in candidates:
+            try:
+                if relative.endswith(".json"):
+                    payload = self.resolver.json(relative)
+                    rows = payload.get("routing") or payload.get("shards") or payload
+                    if isinstance(rows, list):
+                        return [dict(row) for row in rows]
+                    continue
+                try:
+                    table = self.resolver.parquet(relative, descriptor=desc)
+                except RemoteQueryError as exc:
+                    # Rewritten locators often keep the country-pack name
+                    # with a stale sha256. Retry the same path unchecked.
+                    if "sha256 mismatch" not in str(exc) or desc is None:
+                        raise
+                    table = self.resolver.parquet(relative, descriptor=None)
+                return table.to_pylist()
+            except (RemoteQueryError, OSError, FileNotFoundError):
+                continue
+        raise RemoteQueryError(f"locator missing: {name}")
+    def _covering(self, rows: Sequence[Mapping[str, Any]], key: str) -> list[dict[str, Any]]:
+        hits = []
+        for row in rows:
+            first = str(row.get("first_key") or "")
+            last = str(row.get("last_key") or "")
+            if first <= key <= last:
+                hits.append(dict(row))
+        return hits or [dict(row) for row in rows if str(row.get("first_key") or "") == key]
+    def bm25(self, query: str, *, top_k: int) -> dict[str, Any]:
+        terms = _tokenize(query)[:64]
+        config = dict(self.manifest.get("bm25") or {})
+        k1 = float(config.get("k1") or 1.2)
+        b = float(config.get("b") or 0.75)
+        avgdl = float(config.get("average_document_length") or config.get("avg_doc_tokens") or 1.0)
+        title_w = float(config.get("title_weight") or 1.0)
+        body_w = float(config.get("body_weight") or 1.0)
+        loc = self._locator("bm25_keyword_shards") or self._locator("bm25_postings")
+        scores: dict[str, float] = defaultdict(float)
+        matched: dict[str, set[str]] = defaultdict(set)
+        shards = 0
+        for term in terms:
+            for row in self._covering(loc, term):
+                relative = str(row.get("relative_path") or "")
+                table = self.resolver.parquet(relative, descriptor=row)
+                names = set(table.schema.names)
+                shards += 1
+                if "document_indices" in names:
+                    for rec in table.to_pylist():
+                        if str(rec.get("term")) != term:
+                            continue
+                        idf = float(rec.get("idf") or 0.0)
+                        for doc, title_tf, body_tf, length in zip(
+                            rec.get("document_indices") or (),
+                            rec.get("title_frequencies") or (),
+                            rec.get("body_frequencies") or (),
+                            rec.get("document_lengths") or (),
+                        ):
+                            tf = title_w * float(title_tf or 0) + body_w * float(body_tf or 0)
+                            key = str(int(doc))
+                            scores[key] += _bm25_score(tf, idf, float(length or 0), avgdl, k1, b)
+                            matched[key].add(term)
+                elif "legal_id" in names:
+                    for rec in table.to_pylist():
+                        if str(rec.get("term")) != term:
+                            continue
+                        key = str(rec.get("legal_id") or rec.get("entry_cid"))
+                        scores[key] += float(rec.get("tf") or 0)
+                        matched[key].add(term)
+        ranked = heapq.nlargest(top_k, scores.items(), key=lambda item: item[1])
+        hits = [
+            {
+                "id": doc,
+                "score": score,
+                "matched_terms": sorted(matched[doc]),
+                "authority": "context_only",
+            }
+            for doc, score in ranked
+        ]
+        return {"mode": "bm25", "query": query, "hits": hits, "fetch_trace": self.resolver.trace(), "shards": shards}
+    def neighbors(self, node_cid: str, *, direction: str, limit: int) -> dict[str, Any]:
+        name = (
+            "graph_outgoing_adjacency"
+            if direction in {"out", "outgoing"}
+            else "graph_incoming_adjacency"
+        )
+        if direction in {"both"}:
+            left = self.neighbors(node_cid, direction="outgoing", limit=limit)
+            right = self.neighbors(node_cid, direction="incoming", limit=limit)
+            return {
+                "mode": "neighbors",
+                "node_cid": node_cid,
+                "outgoing": left.get("hits"),
+                "incoming": right.get("hits"),
+                "fetch_trace": self.resolver.trace(),
+            }
+        loc = self._locator(name)
+        pages = []
+        for row in self._covering(loc, node_cid):
+            table = self.resolver.parquet(str(row["relative_path"]), descriptor=row)
+            for rec in table.to_pylist():
+                if str(rec.get("node_cid")) != node_cid:
+                    continue
+                pages.append(rec)
+        hits = []
+        for rec in pages:
+            neighbors = rec.get("neighbor_cids") or []
+            types = rec.get("edge_types") or []
+            methods = rec.get("retrieval_methods") or []
+            scores = rec.get("scores") or []
+            for i, neighbor in enumerate(neighbors[:limit]):
+                hits.append(
+                    {
+                        "neighbor_cid": neighbor,
+                        "edge_type": types[i] if i < len(types) else "",
+                        "retrieval_method": methods[i] if i < len(methods) else "",
+                        "score": scores[i] if i < len(scores) else None,
+                    }
+                )
+            if len(hits) >= limit:
+                break
+        return {
+            "mode": "neighbors",
+            "node_cid": node_cid,
+            "direction": direction,
+            "hits": hits[:limit],
+            "fetch_trace": self.resolver.trace(),
+        }
+    def walk(self, node_cid: str, *, max_depth: int, max_nodes: int, direction: str) -> dict[str, Any]:
+        seen = {node_cid}
+        frontier = [node_cid]
+        edges = []
+        depth = 0
+        while frontier and depth < max_depth and len(seen) < max_nodes:
+            nxt = []
+            for node in frontier:
+                page = self.neighbors(node, direction=direction if direction != "both" else "outgoing", limit=32)
+                for hit in page.get("hits") or []:
+                    dst = str(hit.get("neighbor_cid") or "")
+                    if not dst or dst in seen:
+                        continue
+                    seen.add(dst)
+                    edges.append({"src": node, **hit})
+                    nxt.append(dst)
+                    if len(seen) >= max_nodes:
+                        break
+            frontier = nxt
+            depth += 1
+        return {
+            "mode": "walk",
+            "seed": node_cid,
+            "nodes": sorted(seen),
+            "edges": edges,
+            "depth": depth,
+            "fetch_trace": self.resolver.trace(),
+        }
+def _load_query_vector(text: str, model_name: str) -> list[float]:
+    from sentence_transformers import SentenceTransformer
+    model = SentenceTransformer(model_name)
+    vector = model.encode([text], normalize_embeddings=True)[0]
+    return [float(value) for value in vector]
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--repo-id", default="")
+    parser.add_argument("--revision", default="")
+    parser.add_argument("--local-root", default="")
+    parser.add_argument("--manifest", default=DEFAULT_MANIFEST)
+    parser.add_argument("--cache-dir", default=str(DEFAULT_CACHE))
+    parser.add_argument("--json", action="store_true")
+    sub = parser.add_subparsers(dest="mode", required=True)
+    bm25 = sub.add_parser("bm25")
+    bm25.add_argument("query")
+    bm25.add_argument("--top-k", type=int, default=10)
+    vec = sub.add_parser("vector")
+    vec.add_argument("query")
+    vec.add_argument("--top-k", type=int, default=10)
+    vec.add_argument("--model", default="")
+    neigh = sub.add_parser("neighbors")
+    neigh.add_argument("node_cid")
+    neigh.add_argument("--direction", default="both")
+    neigh.add_argument("--limit", type=int, default=25)
+    walk = sub.add_parser("walk")
+    walk.add_argument("node_cid")
+    walk.add_argument("--direction", default="outgoing")
+    walk.add_argument("--max-depth", type=int, default=2)
+    walk.add_argument("--max-nodes", type=int, default=100)
+    args = parser.parse_args(argv)
+    local = Path(args.local_root).expanduser() if args.local_root else None
+    if local is None and not args.repo_id:
+        raise SystemExit("pass --local-root or --repo-id")
+    if args.repo_id and not args.revision:
+        raise SystemExit("remote queries require an immutable --revision pin")
+    resolver = ArtifactResolver(
+        repo_id=args.repo_id,
+        revision=args.revision,
+        token=os.environ.get("HF_TOKEN") or os.environ.get("HUGGING_FACE_HUB_TOKEN"),
+        cache_dir=Path(args.cache_dir),
+        local_root=local,
+    )
+    manifest = resolver.json(args.manifest)
+    client = ThinClient(resolver, manifest)
+    if args.mode == "bm25":
+        result = client.bm25(args.query, top_k=max(1, args.top_k))
+    elif args.mode == "neighbors":
+        result = client.neighbors(args.node_cid, direction=args.direction, limit=max(1, args.limit))
+    elif args.mode == "walk":
+        result = client.walk(
+            args.node_cid,
+            max_depth=max(1, args.max_depth),
+            max_nodes=max(1, args.max_nodes),
+            direction=args.direction,
+        )
+    else:
+        raise SystemExit("vector search in the standalone client needs --model; use neighbors/bm25 here")
+    print(json.dumps(result, indent=2, sort_keys=True))
+    return 0
+if __name__ == "__main__":
+    raise SystemExit(main())

skill/query-hf-graphrag/SKILL.md ADDED Viewed

	@@ -0,0 +1,52 @@

+---
+name: query-hf-graphrag
+description: Query the CID-keyed ipfs_pakistan_laws_ir GraphRAG release on Hugging Face with bounded BM25, centroid-routed vectors, adjacency neighbors, and graph walks. Use when an agent must retrieve lexical, semantic, or graph context without downloading the full corpus.
+---
+# Query ipfs_pakistan_laws_ir on Hugging Face
+Use the bundled search script. It fetches only the manifest, compact locators,
+matching posting/vector/adjacency shards, and corpus rows for final hits.
+Repository: `justicedao/ipfs_pakistan_laws_ir`. Primary key is `entry_cid`. Integer `document_index`
+is a compact pointer, not an identity.
+Research snapshot. Similarity edges cannot establish legal authority.
+## Choose retrieval
+- `bm25` for citations, docket numbers, quoted terms, and exact names.
+- `vector` for paraphrases and topical similarity.
+- `neighbors` / `walk` after you have a `node_cid`.
+- Merge BM25 and vector hits on `entry_cid`. Similarity edges (`BM25_NEIGHBOR_OF`, `EMBEDDING_NEIGHBOR_OF`, `contains_term`) are retrieval proposals only.
+## BM25
+```bash
+python scripts/query_hf_graphrag.py \
+  --repo-id justicedao/ipfs_pakistan_laws_ir \
+  --revision <pinned-commit> \
+  bm25 "clean air act section 111" --top-k 10
+```
+Local checkout:
+```bash
+python scripts/query_hf_graphrag.py --local-root . bm25 "clean air act section 111"
+```
+Install `pyarrow` and `huggingface_hub`. Set `HF_TOKEN` for private datasets.
+Always pin `--revision` for remote queries; never use `main`.
+## Neighbors and walks
+```bash
+python scripts/query_hf_graphrag.py --local-root . neighbors <node-cid> --direction both --limit 25
+python scripts/query_hf_graphrag.py --local-root . walk <node-cid> --max-depth 2 --max-nodes 100
+```
+Inspect `fetch_trace`. A budget stop is a partial walk, not proof that no
+further path exists. Treat hits as `context_only`.
+Read [references/schema.md](references/schema.md) for locator and posting
+contracts.

skill/query-hf-graphrag/agents/openai.yaml ADDED Viewed

	@@ -0,0 +1,4 @@

+interface:
+  display_name: "Query ipfs_pakistan_laws_ir"
+  short_description: "Search the remote GraphRAG release"
+  default_prompt: "Use $query-hf-graphrag to search this Hugging Face GraphRAG release with BM25, vectors, or a bounded graph walk."

skill/query-hf-graphrag/references/schema.md ADDED Viewed

	@@ -0,0 +1,35 @@

+# GraphRAG remote release schema
+`manifest.json` declares `primary_key` (`entry_cid`), BM25 constants, vector
+layout, and compact index descriptors. Verify `sha256` / `cid` before parsing
+a shard.
+## Identity
+- `entry_cid`: CIDv1 primary identity.
+- `document_index`: dense `0..N-1` pointer used only inside postings.
+- Data shards are Zstandard Parquet with at most 4,096 rows.
+## BM25
+`indexes/bm25_keyword_shards.parquet` maps inclusive `first_key`/`last_key`
+term ranges to posting shards. Nested posting rows contain `term` plus aligned
+`document_indices`, `document_lengths`, `title_frequencies`, `body_frequencies`,
+and `idf`. Posting shards must be globally sorted by term with disjoint
+ranges; a term never spans two shards. In-memory cells: `write_term_sorted_posting_shards`.
+Already-dumped shards (any consumer): `pack_range_routed_family` at build time
+or `repair_graphrag_range_routing` on a release root. Both use the same
+resource-aware process pool. Exploded `(term, legal_id, tf)` shards remain readable.
+## Vectors
+`indexes/vector_chunks.parquet` maps centroid groups to at most two physical
+shards of 4,096 rows. Probe a few centroids, then exact-score inside those
+shards.
+## Graph
+`indexes/graph_outgoing_adjacency.parquet` and
+`indexes/graph_incoming_adjacency.parquet` map `node_cid` ranges to paged
+adjacency. Each page holds at most 4,096 pointers. Similarity neighbors cannot
+establish legal authority.

skill/query-hf-graphrag/scripts/query_hf_graphrag.py ADDED Viewed

	@@ -0,0 +1,13 @@

+#!/usr/bin/env python3
+from pathlib import Path
+import runpy
+ROOT = Path(__file__).resolve().parents[3]
+for candidate in (
+    ROOT / "scripts" / "query_hf_graphrag.py",
+    ROOT / "scripts" / "query_hf_graphrag.py",
+):
+    if candidate.is_file():
+        runpy.run_path(str(candidate), run_name="__main__")
+        break
+else:
+    raise SystemExit("GraphRAG query client is missing from this release")