Wave3A OH/state admin+EO additive +851 rows

data/ARE-US-COUNTY-MUNICIPAL.parquet

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

data/oh_ARE-US-OH_resume_20261106T055344Z.parquet

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

data/oh_OH_official_normalized_existing.parquet

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

data/oh_OH_official_resume_20261106T054123Z.parquet

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

scrapers_and_normalizers/README.md

@@ -0,0 +1,6 @@
+# US Admin Rules & EO (seed-driven, pause-capable)
+
+- Seeds: `/workspace/coverage/world_admin_eo_seeds_20261105.jsonl`
+- Live official URLs primary for IN/NH/TN/WY; Wayback only on failure (`archive_source`)
+- Deep frontier crawl per state (multi-record), Governor EOs → `us_executive_orders_20261105`
+- Memguard: pause/hibernate below 4.2 GiB, resume at 4.35 GiB; disk exit; RSS re-exec at 500 MiB

scrapers_and_normalizers/federal_collector.py

@@ -0,0 +1,290 @@
+"""Stream B targets: ARE-US-ECFR, ARE-US-FR, ARE-US-EO — keyless official APIs."""
+from __future__ import annotations
+
+import io
+import time
+import xml.etree.ElementTree as ET
+from typing import Any, Callable, Dict, Iterable, List, Optional, Set, Tuple
+
+import requests
+
+from normalizer import from_ecfr_section, from_federal_register_doc, xml_to_text, strip_html
+
+UA = "AdminRulesEOScraper/1.0 (+research; keyless; contact via justicedao HF)"
+FR_API = "https://www.federalregister.gov/api/v1/documents.json"
+ECFR_TITLES = "https://www.ecfr.gov/api/versioner/v1/titles.json"
+FR_FIELDS = [
+    "document_number", "title", "type", "subtype", "presidential_document_number",
+    "executive_order_number", "publication_date", "html_url", "abstract",
+    "body_html_url", "full_text_xml_url", "raw_text_url", "agencies", "citation",
+]
+
+
+class PoliteSession:
+    def __init__(self, delay: float = 0.75):
+        self.s = requests.Session()
+        self.s.headers["User-Agent"] = UA
+        self.s.verify = True
+        self.delay = delay
+        self._last = 0.0
+        self.n = 0
+
+    def get(self, url: str, **kwargs) -> Optional[requests.Response]:
+        wait = self.delay - (time.time() - self._last)
+        if wait > 0:
+            time.sleep(wait)
+        for attempt in range(3):
+            try:
+                r = self.s.get(url, timeout=90, verify=True, **kwargs)
+                self._last = time.time()
+                self.n += 1
+                if r.status_code == 429:
+                    ra = float(r.headers.get("Retry-After") or (5 * (attempt + 1)))
+                    time.sleep(min(ra, 90))
+                    continue
+                return r
+            except requests.RequestException:
+                time.sleep(5 * (attempt + 1))
+        return None
+
+
+def ecfr_as_of(sess: PoliteSession) -> Tuple[str, List[Dict[str, Any]]]:
+    r = sess.get(ECFR_TITLES)
+    if not r or r.status_code != 200:
+        return "2026-11-04", []
+    titles = list((r.json() or {}).get("titles") or [])
+    date = titles[0].get("up_to_date_as_of") if titles else "2026-11-04"
+    return date, titles
+
+
+def iter_structure_parts(node: Dict[str, Any]) -> Iterable[str]:
+    if not isinstance(node, dict):
+        return
+    if (node.get("type") or "").lower() == "part":
+        ident = str(node.get("identifier") or "")
+        if ident:
+            yield ident
+    for c in node.get("children") or []:
+        yield from iter_structure_parts(c)
+
+
+def list_parts_for_title(sess: PoliteSession, date: str, title_num: int) -> List[str]:
+    r = sess.get(f"https://www.ecfr.gov/api/versioner/v1/structure/{date}/title-{title_num}.json")
+    if not r or r.status_code != 200:
+        return []
+    return list(dict.fromkeys(iter_structure_parts(r.json())))
+
+
+def _section_text_from_elem(elem: ET.Element) -> Tuple[str, str]:
+    head = ""
+    chunks: List[str] = []
+    for el in elem.iter():
+        tag = (el.tag or "").split("}")[-1].upper()
+        if tag == "HEAD" and el.text and not head:
+            head = (el.text or "").strip()
+        if el.text and el.text.strip():
+            chunks.append(el.text.strip())
+        if el.tail and el.tail.strip():
+            chunks.append(el.tail.strip())
+    text = " ".join(chunks)
+    text = " ".join(text.split())
+    return head, text
+
+
+def parse_part_xml_sections(xml_bytes: bytes, title_num: int, part: str, date: str) -> List[Dict[str, Any]]:
+    """Parse a single-part eCFR XML payload (small) into section records via iterparse."""
+    out: List[Dict[str, Any]] = []
+    source_url = f"https://www.ecfr.gov/current/title-{title_num}/part-{part}"
+    try:
+        # wrap if needed
+        raw = xml_bytes
+        if b"<ECFR" not in raw[:200] and b"<DIV" in raw[:200]:
+            raw = b"<WRAP>" + raw + b"</WRAP>"
+        context = ET.iterparse(io.BytesIO(raw), events=("end",))
+        for event, elem in context:
+            tag = (elem.tag or "").split("}")[-1].upper()
+            typ = (elem.attrib.get("TYPE") or "").upper()
+            if tag.startswith("DIV") and typ == "SECTION":
+                sec = elem.attrib.get("N") or ""
+                head, text = _section_text_from_elem(elem)
+                if text and len(text) > 20:
+                    out.append(
+                        from_ecfr_section(
+                            title_num=title_num, part=part, section=sec,
+                            head=head, text=text, source_url=f"{source_url}/section-{sec}", date=date,
+                        )
+                    )
+                elem.clear()
+            elif tag.startswith("DIV") and typ == "PART":
+                # if no sections emitted, keep part-level text
+                pass
+    except ET.ParseError:
+        text = xml_to_text(xml_bytes)
+        if text:
+            out.append(
+                from_ecfr_section(
+                    title_num=title_num, part=part, section="",
+                    head=f"Part {part}", text=text[:50000], source_url=source_url, date=date,
+                )
+            )
+    if not out:
+        text = xml_to_text(xml_bytes)
+        if text:
+            out.append(
+                from_ecfr_section(
+                    title_num=title_num, part=part, section="",
+                    head=f"Part {part}", text=text[:50000], source_url=source_url, date=date,
+                )
+            )
+    return out
+
+
+def collect_ecfr_title_parts(
+    sess: PoliteSession,
+    title_num: int,
+    date: str,
+    *,
+    seen_add: Callable[[str], bool],
+    max_parts: Optional[int] = None,
+    max_records: int = 200,
+    should_continue: Optional[Callable[[], bool]] = None,
+) -> List[Dict[str, Any]]:
+    parts = list_parts_for_title(sess, date, title_num)
+    out: List[Dict[str, Any]] = []
+    for i, part in enumerate(parts):
+        if max_parts is not None and i >= max_parts:
+            break
+        if should_continue and not should_continue():
+            break
+        if len(out) >= max_records:
+            break
+        r = sess.get(
+            f"https://www.ecfr.gov/api/versioner/v1/full/{date}/title-{title_num}.xml",
+            params={"part": part},
+        )
+        if not r or r.status_code != 200 or not r.content:
+            # fallback HTML/xml current
+            r2 = sess.get(f"https://www.ecfr.gov/current/title-{title_num}/part-{part}.xml")
+            if not r2 or r2.status_code != 200:
+                continue
+            payload = r2.content
+        else:
+            payload = r.content
+        # refuse huge single payloads
+        if len(payload) > 8_000_000:
+            continue
+        for rec in parse_part_xml_sections(payload, title_num, part, date):
+            if seen_add(rec["id"]):
+                out.append(rec)
+            if len(out) >= max_records:
+                break
+        if should_continue and not should_continue():
+            break
+    return out
+
+
+def iter_fr_documents(
+    sess: PoliteSession,
+    conditions: List[Tuple[str, str]],
+    *,
+    per_page: int = 100,
+    max_pages: int = 10,
+    publication_date_gte: Optional[str] = None,
+) -> Iterable[Dict[str, Any]]:
+    for page in range(1, max_pages + 1):
+        params: List[Tuple[str, Any]] = [
+            ("per_page", per_page), ("page", page), ("order", "newest"),
+        ]
+        params.extend(conditions)
+        if publication_date_gte:
+            params.append(("conditions[publication_date][gte]", publication_date_gte))
+        for f in FR_FIELDS:
+            params.append(("fields[]", f))
+        r = sess.get(FR_API, params=params)
+        if not r or r.status_code != 200:
+            break
+        data = r.json() or {}
+        results = data.get("results") or []
+        if not results:
+            break
+        for doc in results:
+            yield doc
+        if page >= int(data.get("total_pages") or page):
+            break
+
+
+def fetch_doc_text(sess: PoliteSession, doc: Dict[str, Any]) -> str:
+    xml_url = doc.get("full_text_xml_url")
+    if xml_url:
+        r = sess.get(xml_url)
+        if r and r.status_code == 200 and r.content and len(r.content) < 5_000_000:
+            return xml_to_text(r.content)
+    raw = doc.get("raw_text_url")
+    if raw:
+        r = sess.get(raw)
+        if r and r.status_code == 200 and r.text and len(r.content) < 5_000_000:
+            return r.text.strip()
+    body = doc.get("body_html_url")
+    if body:
+        r = sess.get(body)
+        if r and r.status_code == 200 and r.text and len(r.content) < 5_000_000:
+            return strip_html(r.text)
+    return doc.get("abstract") or ""
+
+
+def collect_eo(
+    sess: PoliteSession,
+    seen_add: Callable[[str], bool],
+    *,
+    max_docs: int = 40,
+    kinds: Optional[List[str]] = None,
+) -> List[Dict[str, Any]]:
+    kinds = kinds or ["executive_order", "proclamation", "determination", "memorandum", "notice"]
+    out: List[Dict[str, Any]] = []
+    for kind in kinds:
+        if len(out) >= max_docs:
+            break
+        for doc in iter_fr_documents(
+            sess,
+            [("conditions[type][]", "PRESDOCU"), ("conditions[presidential_document_type][]", kind)],
+            per_page=min(100, max_docs - len(out)),
+            max_pages=3,
+        ):
+            text = fetch_doc_text(sess, doc)
+            rec = from_federal_register_doc(doc, text, gap_target_id="ARE-US-EO",
+                                            target_hf_repo="justicedao/ipfs_us_executive_orders")
+            if seen_add(rec["id"]):
+                out.append(rec)
+            if len(out) >= max_docs:
+                break
+    return out
+
+
+def collect_fr_after(
+    sess: PoliteSession,
+    seen_add: Callable[[str], bool],
+    *,
+    gte: str = "2026-07-01",
+    max_docs: int = 40,
+    types: Optional[List[str]] = None,
+) -> List[Dict[str, Any]]:
+    types = types or ["RULE", "PRORULE", "NOTICE"]
+    out: List[Dict[str, Any]] = []
+    for t in types:
+        if len(out) >= max_docs:
+            break
+        for doc in iter_fr_documents(
+            sess,
+            [("conditions[type][]", t)],
+            per_page=min(100, max_docs - len(out)),
+            max_pages=2,
+            publication_date_gte=gte,
+        ):
+            text = fetch_doc_text(sess, doc)
+            rec = from_federal_register_doc(doc, text, gap_target_id="ARE-US-FR",
+                                            target_hf_repo="justicedao/ipfs_federal_register")
+            if seen_add(rec["id"]):
+                out.append(rec)
+            if len(out) >= max_docs:
+                break
+    return out

scrapers_and_normalizers/gap_queue.py

@@ -0,0 +1,25 @@
+"""Load US items from world_complete_gap_matrix bot_work_queues.admin_rules_eo_scraper."""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Dict, List
+
+MATRIX = Path("/workspace/world_complete_gap_matrix_20261105.json")
+US_LANES = {"us_federal_admin_eo", "us_state_admin_and_eo", "us_local_admin_and_eo"}
+
+
+def load_us_queue() -> List[Dict[str, Any]]:
+    data = json.loads(MATRIX.read_text(encoding="utf-8"))
+    q = data["bot_work_queues"]["admin_rules_eo_scraper"]
+    us = [it for it in q if it.get("lane") in US_LANES or str(it.get("target_id", "")).startswith("ARE-US-")]
+    us.sort(key=lambda x: int(x.get("priority_rank") or 9999))
+    return us
+
+
+def state_code_from_target(target_id: str) -> str | None:
+    # ARE-US-OH-ADMIN-EO -> OH
+    parts = target_id.split("-")
+    if len(parts) >= 4 and parts[0] == "ARE" and parts[1] == "US" and parts[-2] == "ADMIN":
+        return parts[2]
+    return None

scrapers_and_normalizers/io_zst.py

@@ -0,0 +1,211 @@
+"""Append-only .jsonl.zst writer + SeenIds + pause-capable memguard."""
+from __future__ import annotations
+
+import gc
+import json
+import os
+import time
+from pathlib import Path
+from typing import Any, Optional, Set
+
+import zstandard as zstd
+
+from normalizer import dumps_line
+
+
+class JsonlZstWriter:
+    def __init__(self, path: str | Path, level: int = 3):
+        self.path = Path(path)
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        self._fh = open(self.path, "ab")
+        self._cctx = zstd.ZstdCompressor(level=level)
+        self.count = 0
+
+    def write(self, rec: dict) -> None:
+        line = (dumps_line(rec) + "\n").encode("utf-8")
+        self._fh.write(self._cctx.compress(line))
+        self.count += 1
+        if self.count % 20 == 0:
+            self._fh.flush()
+
+    def flush(self) -> None:
+        self._fh.flush()
+
+    def close(self) -> None:
+        try:
+            self._fh.flush()
+        finally:
+            self._fh.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc):
+        self.close()
+
+
+def write_json(path: str | Path, obj: Any) -> None:
+    p = Path(path)
+    p.parent.mkdir(parents=True, exist_ok=True)
+    tmp = p.with_suffix(p.suffix + ".tmp")
+    tmp.write_text(json.dumps(obj, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+    os.replace(tmp, p)
+
+
+def load_json(path: str | Path, default: Any = None) -> Any:
+    p = Path(path)
+    if not p.exists():
+        return default
+    return json.loads(p.read_text(encoding="utf-8"))
+
+
+def mem_available_bytes() -> int:
+    with open("/proc/meminfo") as f:
+        for line in f:
+            if line.startswith("MemAvailable:"):
+                return int(line.split()[1]) * 1024
+    return 0
+
+
+def process_rss_bytes() -> int:
+    with open("/proc/self/status") as f:
+        for line in f:
+            if line.startswith("VmRSS:"):
+                return int(line.split()[1]) * 1024
+    return 0
+
+
+def disk_free_bytes(path: str = "/workspace") -> int:
+    st = os.statvfs(path)
+    return st.f_bavail * st.f_frsize
+
+
+class MemGuard:
+    MEM_FLOOR = 4_509_715_660       # 4.2 GiB — pause below
+    MEM_RESUME = 4_670_881_382      # 4.35 GiB — resume at/above
+    DISK_FLOOR = 10 * 1024 ** 3
+    RSS_REEXEC = 500 * 1024 ** 2    # re-exec above 500 MiB
+    RSS_CEILING = 550 * 1024 ** 2
+
+    def __init__(self, check_every_items: int = 5, check_every_seconds: float = 10.0):
+        self.check_every_items = check_every_items
+        self.check_every_seconds = check_every_seconds
+        self._n = 0
+        self._last = 0.0
+        self.stop_reason: Optional[str] = None
+        self.need_pause = False
+        self.need_reexec = False
+        self.need_exit = False
+
+    def evaluate(self) -> str:
+        """Return 'ok' | 'pause' | 'reexec' | 'exit_disk'."""
+        mem = mem_available_bytes()
+        disk = disk_free_bytes()
+        rss = process_rss_bytes()
+        if disk < self.DISK_FLOOR:
+            self.need_exit = True
+            self.stop_reason = f"disk_stop free={disk} < {self.DISK_FLOOR}"
+            return "exit_disk"
+        if rss > self.RSS_REEXEC:
+            self.need_reexec = True
+            self.stop_reason = f"rss_reexec rss={rss} > {self.RSS_REEXEC}"
+            return "reexec"
+        if mem < self.MEM_FLOOR:
+            self.need_pause = True
+            self.stop_reason = f"paused_low_mem MemAvailable={mem} < {self.MEM_FLOOR}"
+            return "pause"
+        self.need_pause = False
+        return "ok"
+
+    def tick(self, items: int = 1) -> str:
+        self._n += items
+        now = time.time()
+        if self._n < self.check_every_items and (now - self._last) < self.check_every_seconds:
+            return "ok"
+        self._n = 0
+        self._last = now
+        return self.evaluate()
+
+    @classmethod
+    def wait_until_resume(cls, log_fn=None, status_fn=None, stop_flag=None) -> bool:
+        """Sleep in low-RSS loop until MemAvailable >= MEM_RESUME or stop. Return True if resumed."""
+        while True:
+            if stop_flag and stop_flag():
+                return False
+            mem = mem_available_bytes()
+            disk = disk_free_bytes()
+            if disk < cls.DISK_FLOOR:
+                if log_fn:
+                    log_fn(f"DISK_EXIT during pause free={disk}")
+                return False
+            if mem >= cls.MEM_RESUME:
+                gc.collect()
+                if log_fn:
+                    log_fn(f"RESUME MemAvailable={mem} >= {cls.MEM_RESUME}")
+                return True
+            if status_fn:
+                status_fn(state="paused_low_mem", mem_available_bytes=mem)
+            if log_fn:
+                log_fn(f"HIBERNATE MemAvailable={mem} < {cls.MEM_RESUME}; sleep 30s")
+            gc.collect()
+            time.sleep(30)
+
+
+class SeenIds:
+    def __init__(self, path: str | Path, max_keep: int = 500_000):
+        self.path = Path(path)
+        self.max_keep = max_keep
+        self.ids: Set[str] = set()
+        self._dirty = 0
+        if self.path.exists():
+            try:
+                data = json.loads(self.path.read_text(encoding="utf-8"))
+                self.ids = set(data.get("ids") or [])
+            except Exception:
+                for line in self.path.read_text(encoding="utf-8", errors="replace").splitlines():
+                    line = line.strip()
+                    if line and not line.startswith("{"):
+                        self.ids.add(line)
+
+    def __contains__(self, rid: str) -> bool:
+        return rid in self.ids
+
+    def add(self, rid: str) -> bool:
+        if rid in self.ids:
+            return False
+        self.ids.add(rid)
+        self._dirty += 1
+        if self._dirty >= 40:
+            self.flush()
+        return True
+
+    def flush(self) -> None:
+        ids = sorted(self.ids)
+        if len(ids) > self.max_keep:
+            ids = ids[-self.max_keep :]
+            self.ids = set(ids)
+        write_json(self.path, {"ids": ids, "count": len(ids), "updated_at": time.time()})
+        self._dirty = 0
+
+
+def load_ids_from_zst(path: Path, seen: SeenIds) -> int:
+    if not path.exists():
+        return 0
+    n = 0
+    try:
+        with zstd.ZstdDecompressor().stream_reader(open(path, "rb")) as r:
+            text = r.read().decode("utf-8", errors="replace")
+        for line in text.splitlines():
+            if not line.strip():
+                continue
+            try:
+                o = json.loads(line)
+            except Exception:
+                continue
+            rid = o.get("id")
+            if rid and rid not in seen.ids:
+                seen.ids.add(rid)
+                n += 1
+    except Exception:
+        return n
+    return n

scrapers_and_normalizers/municipal_collector.py

@@ -0,0 +1,136 @@
+"""ARE-US-COUNTY-MUNICIPAL-ADMIN-EO — keyless municipal/county admin rules & mayoral EOs."""
+from __future__ import annotations
+
+import time
+from typing import Any, Callable, Dict, List, Optional, Tuple
+
+import requests
+from bs4 import BeautifulSoup
+
+from normalizer import base_record, strip_html
+
+UA = "AdminRulesEOScraper/1.0 (+research; keyless; contact via justicedao HF)"
+TARGET = "ARE-US-COUNTY-MUNICIPAL-ADMIN-EO"
+HF = "justicedao/ipfs_us_executive_orders"
+
+PORTALS = [
+    {"locality": "New York City", "state": "NY", "url": "https://rules.cityofnewyork.us/", "kind": "admin_rules"},
+    {"locality": "New York City", "state": "NY",
+     "url": "https://www.nyc.gov/office-of-the-mayor/news/executive-orders.page", "kind": "mayoral_eo"},
+    {"locality": "San Francisco", "state": "CA",
+     "url": "https://sf.gov/resource/2022/mayoral-executive-directives", "kind": "mayoral_eo"},
+    {"locality": "Chicago", "state": "IL",
+     "url": "https://www.chicago.gov/city/en/depts/mayor/press_room/executive-orders.html", "kind": "mayoral_eo"},
+    {"locality": "Los Angeles", "state": "CA",
+     "url": "https://mayor.lacity.gov/executive-directives", "kind": "mayoral_eo"},
+    {"locality": "Philadelphia", "state": "PA",
+     "url": "https://www.phila.gov/departments/mayor/executive-orders/", "kind": "mayoral_eo"},
+    {"locality": "Washington", "state": "DC",
+     "url": "https://mayor.dc.gov/mayor-orders", "kind": "mayoral_eo"},
+    {"locality": "King County", "state": "WA",
+     "url": "https://kingcounty.gov/en/legacy/council/legislation/kc_code.aspx", "kind": "county_code"},
+    {"locality": "Cook County", "state": "IL",
+     "url": "https://www.cookcountyil.gov/agency/board-commissioners", "kind": "county"},
+]
+
+
+class PoliteSession:
+    def __init__(self, delay: float = 1.0):
+        self.s = requests.Session()
+        self.s.headers["User-Agent"] = UA
+        self.s.verify = True
+        self.delay = delay
+        self._last = 0.0
+
+    def get(self, url: str) -> Tuple[Optional[requests.Response], Optional[str]]:
+        wait = self.delay - (time.time() - self._last)
+        if wait > 0:
+            time.sleep(wait)
+        try:
+            r = self.s.get(url, timeout=45, verify=True)
+        except requests.RequestException as e:
+            self._last = time.time()
+            return None, f"net_error:{e.__class__.__name__}"
+        self._last = time.time()
+        low = (r.text or "")[:4000].lower()
+        if r.status_code in (403, 429, 503) or "just a moment" in low or "captcha" in low:
+            return r, "blocked_waf"
+        if r.status_code != 200:
+            return r, f"http_{r.status_code}"
+        return r, None
+
+
+def collect_municipal(
+    sess: PoliteSession,
+    seen_add: Callable[[str], bool],
+    *,
+    max_records: int = 30,
+) -> Tuple[List[Dict[str, Any]], List[Dict[str, Any]]]:
+    out: List[Dict[str, Any]] = []
+    manifest: List[Dict[str, Any]] = []
+    for p in PORTALS:
+        if len(out) >= max_records:
+            break
+        r, flag = sess.get(p["url"])
+        entry = {**p, "status": flag or ("ok" if r else "fetch_failed"),
+                 "http_status": getattr(r, "status_code", None)}
+        manifest.append(entry)
+        if not r or flag:
+            # status stub
+            rec = base_record(
+                gap_target_id=TARGET, jurisdiction=f"US-{p['state']}-{p['locality'][:12]}",
+                subdivision_level="municipal" if "County" not in p["locality"] else "county",
+                document_type="portal_status", title=f"{p['locality']} portal {entry['status']}",
+                text=f"status={entry['status']} url={p['url']}", source_url=p["url"],
+                state_or_province=p["state"], locality=p["locality"],
+                target_hf_repo=HF, extra={"portal_kind": p["kind"], "portal_status": entry["status"]},
+            )
+            if seen_add(rec["id"]):
+                out.append(rec)
+            continue
+        soup = BeautifulSoup(r.text, "html.parser")
+        title = soup.title.get_text(" ", strip=True) if soup.title else p["locality"]
+        text = soup.get_text("\n", strip=True)[:10000]
+        dtype = "mayoral_eo" if p["kind"] == "mayoral_eo" else "municipal_admin_rules"
+        rec = base_record(
+            gap_target_id=TARGET, jurisdiction=f"US-{p['state']}",
+            subdivision_level="municipal" if "County" not in p["locality"] else "county",
+            document_type=dtype, title=title, text=text, source_url=p["url"],
+            state_or_province=p["state"], locality=p["locality"],
+            target_hf_repo=HF, extra={"portal_kind": p["kind"]},
+        )
+        if seen_add(rec["id"]):
+            out.append(rec)
+        # follow a few same-host links that look like EO/order docs
+        host = p["url"].split("/")[2]
+        followed = 0
+        for a in soup.select("a[href]"):
+            if followed >= 3 or len(out) >= max_records:
+                break
+            href = a.get("href") or ""
+            if href.startswith("/"):
+                href = p["url"].rstrip("/") + "/" + href.lstrip("/") if "://" not in href else href
+                # fix double
+                if href.startswith("/"):
+                    href = "https://" + host + href
+            if host not in href:
+                continue
+            low = href.lower()
+            if not any(k in low for k in ("executive", "order", "eo-", "directive", "rule")):
+                continue
+            r2, f2 = sess.get(href)
+            if not r2 or f2:
+                continue
+            t2 = strip_html(r2.text)[:12000]
+            if len(t2) < 80:
+                continue
+            rec2 = base_record(
+                gap_target_id=TARGET, jurisdiction=f"US-{p['state']}",
+                subdivision_level="municipal", document_type=dtype,
+                title=(a.get_text(" ", strip=True) or href)[:200], text=t2, source_url=href,
+                state_or_province=p["state"], locality=p["locality"], target_hf_repo=HF,
+            )
+            if seen_add(rec2["id"]):
+                out.append(rec2)
+                followed += 1
+    return out, manifest

scrapers_and_normalizers/normalizer.py

@@ -0,0 +1,214 @@
+"""Normalize US admin-rule / EO / FR / eCFR rows into a shared schema with gap_target_id."""
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+from datetime import datetime, timezone
+from typing import Any, Dict, Optional
+from xml.etree import ElementTree as ET
+
+SCHEMA_VERSION = "us_admin_rules_eo_normalized_v2"
+
+
+def utc_now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def sha256_text(text: str) -> str:
+    return hashlib.sha256((text or "").encode("utf-8", errors="replace")).hexdigest()
+
+
+def make_id(*parts: str) -> str:
+    return sha256_text("|".join(p or "" for p in parts))
+
+
+def strip_html(html: str) -> str:
+    if not html:
+        return ""
+    text = re.sub(r"(?is)<script[^>]*>.*?</script>", " ", html)
+    text = re.sub(r"(?is)<style[^>]*>.*?</style>", " ", text)
+    text = re.sub(r"(?s)<[^>]+>", " ", text)
+    text = re.sub(r"&nbsp;", " ", text)
+    text = re.sub(r"&amp;", "&", text)
+    text = re.sub(r"&lt;", "<", text)
+    text = re.sub(r"&gt;", ">", text)
+    return re.sub(r"\s+", " ", text).strip()
+
+
+def xml_to_text(xml_bytes: bytes | str) -> str:
+    if isinstance(xml_bytes, bytes):
+        raw = xml_bytes.decode("utf-8", errors="replace")
+    else:
+        raw = xml_bytes
+    try:
+        root = ET.fromstring(raw)
+    except ET.ParseError:
+        return strip_html(raw)
+    chunks: list[str] = []
+    for el in root.iter():
+        if el.text and el.text.strip():
+            chunks.append(el.text.strip())
+        if el.tail and el.tail.strip():
+            chunks.append(el.tail.strip())
+    return re.sub(r"\s+", " ", " ".join(chunks)).strip()
+
+
+def base_record(
+    *,
+    gap_target_id: str,
+    jurisdiction: str,
+    subdivision_level: str,
+    document_type: str,
+    title: str,
+    text: str,
+    source_url: str,
+    citation: Optional[str] = None,
+    agency: Optional[str] = None,
+    state_or_province: Optional[str] = None,
+    locality: Optional[str] = None,
+    effective_date: Optional[str] = None,
+    published_date: Optional[str] = None,
+    transport: str = "https",
+    archive_source: Optional[str] = None,
+    scraped_at: Optional[str] = None,
+    extra: Optional[Dict[str, Any]] = None,
+    target_hf_repo: Optional[str] = None,
+) -> Dict[str, Any]:
+    text = (text or "").strip()
+    content_hash = sha256_text(text)
+    rid = make_id(gap_target_id, jurisdiction, document_type, citation or "", source_url, content_hash[:16])
+    return {
+        "id": rid,
+        "gap_target_id": gap_target_id,
+        "schema_version": SCHEMA_VERSION,
+        "jurisdiction": jurisdiction,
+        "subdivision_level": subdivision_level,
+        "country": "US",
+        "state_or_province": state_or_province,
+        "locality": locality,
+        "document_type": document_type,
+        "agency": agency,
+        "citation": citation,
+        "title": title,
+        "text": text,
+        "effective_date": effective_date,
+        "published_date": published_date,
+        "source_url": source_url,
+        "transport": transport,
+        "archive_source": archive_source,
+        "scraped_at": scraped_at or utc_now(),
+        "content_hash": content_hash,
+        "target_hf_repo": target_hf_repo,
+        "extra": extra or {},
+    }
+
+
+def from_oh_official_row(row: Dict[str, Any], gap_target_id: str = "ARE-US-OH-ADMIN-EO",
+                         target_hf_repo: str = "justicedao/ipfs_state_admin_rules") -> Dict[str, Any]:
+    return base_record(
+        gap_target_id=gap_target_id,
+        jurisdiction=f"US-{row.get('state') or 'OH'}",
+        subdivision_level="state",
+        document_type="admin_rule",
+        title=row.get("title") or "",
+        text=row.get("text") or "",
+        source_url=row.get("source_url") or "",
+        citation=row.get("citation"),
+        state_or_province=row.get("state") or "OH",
+        transport=row.get("transport") or "https",
+        scraped_at=row.get("fetched_at"),
+        target_hf_repo=target_hf_repo,
+        extra={"legacy_sha256": row.get("sha256")},
+    )
+
+
+def from_federal_register_doc(doc: Dict[str, Any], text: str, gap_target_id: str,
+                              target_hf_repo: Optional[str] = None) -> Dict[str, Any]:
+    subtype = (doc.get("subtype") or "").strip()
+    ptype = (doc.get("type") or "").strip()
+    if gap_target_id == "ARE-US-EO" or subtype.lower() == "executive order" or doc.get("executive_order_number"):
+        if "proclamation" in subtype.lower():
+            document_type = "proclamation"
+        elif "determination" in subtype.lower():
+            document_type = "determination"
+        elif "memorandum" in subtype.lower():
+            document_type = "memorandum"
+        elif "administrative" in subtype.lower():
+            document_type = "administrative_order"
+        elif gap_target_id == "ARE-US-EO" and subtype:
+            document_type = subtype.lower().replace(" ", "_")
+        else:
+            document_type = "executive_order"
+    elif ptype == "Rule":
+        document_type = "rule"
+    elif ptype == "Proposed Rule":
+        document_type = "proposed_rule"
+    elif ptype == "Notice":
+        document_type = "register_notice"
+    else:
+        document_type = (ptype or "register_document").lower().replace(" ", "_")
+
+    agencies = doc.get("agencies") or []
+    agency = None
+    if agencies and isinstance(agencies[0], dict):
+        agency = agencies[0].get("name") or agencies[0].get("raw_name")
+    elif agencies and isinstance(agencies[0], str):
+        agency = agencies[0]
+
+    citation = doc.get("citation")
+    if document_type == "executive_order" and doc.get("executive_order_number"):
+        citation = citation or f"E.O. {doc['executive_order_number']}"
+
+    if not target_hf_repo:
+        target_hf_repo = (
+            "justicedao/ipfs_us_executive_orders" if gap_target_id == "ARE-US-EO"
+            else "justicedao/ipfs_federal_register"
+        )
+
+    return base_record(
+        gap_target_id=gap_target_id,
+        jurisdiction="US-FEDERAL",
+        subdivision_level="federal",
+        document_type=document_type,
+        title=doc.get("title") or "",
+        text=text or (doc.get("abstract") or ""),
+        source_url=doc.get("html_url") or doc.get("body_html_url") or "",
+        citation=citation,
+        agency=agency,
+        published_date=doc.get("publication_date"),
+        transport="https",
+        target_hf_repo=target_hf_repo,
+        extra={
+            "document_number": doc.get("document_number"),
+            "presidential_document_number": doc.get("presidential_document_number"),
+            "executive_order_number": doc.get("executive_order_number"),
+            "subtype": subtype,
+            "full_text_xml_url": doc.get("full_text_xml_url"),
+            "body_html_url": doc.get("body_html_url"),
+            "raw_text_url": doc.get("raw_text_url"),
+        },
+    )
+
+
+def from_ecfr_section(*, title_num: int, part: str, section: str, head: str, text: str,
+                      source_url: str, date: str) -> Dict[str, Any]:
+    citation = f"{title_num} CFR § {section}" if section else f"{title_num} CFR Part {part}"
+    return base_record(
+        gap_target_id="ARE-US-ECFR",
+        jurisdiction="US-FEDERAL",
+        subdivision_level="federal",
+        document_type="ecfr_section" if section else "ecfr_part",
+        title=head or citation,
+        text=text,
+        source_url=source_url,
+        citation=citation,
+        published_date=date,
+        transport="https",
+        target_hf_repo="justicedao/ipfs_us_cfr",
+        extra={"ecfr_title": title_num, "ecfr_part": part, "ecfr_section": section, "as_of": date},
+    )
+
+
+def dumps_line(rec: Dict[str, Any]) -> str:
+    return json.dumps(rec, ensure_ascii=False, separators=(",", ":"))

scrapers_and_normalizers/schema.json

@@ -0,0 +1,7 @@
+{
+  "name": "us_admin_rules_eo_normalized_v2",
+  "required_fields": ["id", "gap_target_id", "jurisdiction", "subdivision_level", "country", "document_type", "title", "text", "source_url", "transport", "scraped_at", "content_hash"],
+  "gap_target_ids": ["ARE-US-ECFR", "ARE-US-FR", "ARE-US-EO", "ARE-US-*-ADMIN-EO", "ARE-US-COUNTY-MUNICIPAL-ADMIN-EO"],
+  "dedupe": "persistent SeenIds checkpoint; skip emitted id on restart",
+  "memguard": {"MemAvailable_floor_bytes": 4509715660, "disk_floor_bytes": 10737418240, "rss_ceiling_bytes": 576716800}
+}

scrapers_and_normalizers/seeds.py

@@ -0,0 +1,101 @@
+"""Load verified US seeds from world_admin_eo_seeds_20261105.jsonl."""
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+from urllib.parse import urlparse
+
+SEEDS_PATH = Path("/workspace/coverage/world_admin_eo_seeds_20261105.jsonl")
+WAYBACK_RE = re.compile(r"^https?://web\.archive\.org/web/\d+(?:id_)?/(https?://.*)$", re.I)
+
+
+def unwrap_wayback(url: str) -> Tuple[str, bool]:
+    """Return (live_or_original_url, was_wayback)."""
+    m = WAYBACK_RE.match(url or "")
+    if m:
+        return m.group(1), True
+    return url, False
+
+
+def load_us_seeds() -> List[Dict[str, Any]]:
+    rows = []
+    for line in SEEDS_PATH.read_text(encoding="utf-8").splitlines():
+        if not line.strip():
+            continue
+        o = json.loads(line)
+        if str(o.get("target_id", "")).startswith("ARE-US-"):
+            rows.append(o)
+    # preserve file order (matches gap matrix priority)
+    return rows
+
+
+def seed_urls_by_role(seed: Dict[str, Any]) -> Dict[str, List[Dict[str, Any]]]:
+    out: Dict[str, List[Dict[str, Any]]] = {}
+    for u in seed.get("urls") or []:
+        role = u.get("role") or "unknown"
+        out.setdefault(role, []).append(u)
+    return out
+
+
+def preferred_fetch_urls(seed: Dict[str, Any], role: str) -> List[Tuple[str, Optional[str]]]:
+    """Return ordered (url, archive_source) pairs: live first, then wayback fallbacks.
+
+    archive_source is None for live official; 'wayback' for archive.org URLs.
+    """
+    roles = seed_urls_by_role(seed)
+    entries = roles.get(role) or []
+    live: List[Tuple[str, Optional[str]]] = []
+    wb: List[Tuple[str, Optional[str]]] = []
+    seen = set()
+    for e in entries:
+        raw = e.get("url") or ""
+        orig, was_wb = unwrap_wayback(raw)
+        if orig not in seen:
+            live.append((orig, None))
+            seen.add(orig)
+        if was_wb and raw not in seen:
+            wb.append((raw, "wayback"))
+            seen.add(raw)
+        elif not was_wb:
+            # also keep raw if somehow different
+            pass
+    # Extra live candidates for hard states
+    tid = seed.get("target_id") or ""
+    extras = {
+        "ARE-US-IN-ADMIN-EO": [
+            "https://iga.in.gov/laws/iac",
+            "https://iar.iga.in.gov/iac/irtoc.htm",
+            "https://iar.iga.in.gov/code/current",
+        ],
+        "ARE-US-NH-ADMIN-EO": [
+            "https://gc.nh.gov/rules/",
+            "https://gc.nh.gov/rules/about_rules/listagencies.aspx",
+            "https://www.gencourt.state.nh.us/rules/",
+        ],
+        "ARE-US-TN-ADMIN-EO": [
+            "https://publications.tnsosfiles.com/rules/",
+            "https://sos.tn.gov/publications/services/effective-rules-and-regulations-of-the-state-of-tennessee",
+        ],
+        "ARE-US-WY-ADMIN-EO": [
+            "https://rules.wyo.gov/",
+            "https://rules.wyo.gov/Search.aspx",
+            "https://rules.wyo.gov/Search.aspx?mode=7",
+        ],
+    }
+    if role == "admin_code":
+        pref=[]
+        for u in extras.get(tid, []):
+            if u not in seen:
+                pref.append((u, None))
+                seen.add(u)
+        live = pref + live
+    return live + wb
+
+
+def state_code_from_target(target_id: str) -> Optional[str]:
+    parts = target_id.split("-")
+    if len(parts) >= 4 and parts[0] == "ARE" and parts[1] == "US" and parts[-2] == "ADMIN":
+        return parts[2]
+    return None

scrapers_and_normalizers/state_admin_collector.py

@@ -0,0 +1,504 @@
+"""Deep US state/territory admin-code + governor EO crawler (seed-driven).
+
+Uses /workspace/coverage/world_admin_eo_seeds_20261105.jsonl verified portals.
+Live official URLs first; Wayback only if live fails (archive_source=wayback).
+Extracts multiple substantive rule/EO pages per cycle via URL frontier checkpoints.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional, Set, Tuple
+from urllib.parse import urljoin, urlparse
+
+import requests
+from bs4 import BeautifulSoup
+
+from normalizer import base_record, from_oh_official_row, strip_html
+from seeds import preferred_fetch_urls, state_code_from_target, unwrap_wayback
+
+UA = "AdminRulesEOScraper/1.0 (+research; keyless; contact via justicedao HF)"
+OH_BASE = "https://codes.ohio.gov"
+OH_ROWS = Path("/workspace/legal-corpora/us_state_admin_rules_20261104/OH.official/rows.jsonl")
+OH_CURSOR = Path("/workspace/legal-corpora/us_state_admin_rules_20261104/_collector/oh_agency_cursor.json")
+FRONTIER_DIR = Path("/workspace/legal-corpora/us_state_admin_rules_20261104/_collector/frontiers")
+STATE_ROOT = Path("/workspace/legal-corpora/us_state_admin_rules_20261104")
+EO_ROOT = Path("/workspace/legal-corpora/us_executive_orders_20261105")
+
+RULE_HINTS = re.compile(
+    r"(rule|rules|regulation|admin.?code|chapter|title|section|csr|nac|wac|oac|iac|kar|njac|comar|tar)",
+    re.I,
+)
+EO_HINTS = re.compile(r"(executive.?order|exec.?order|\beo\b|proclamation|directive|governor)", re.I)
+NAV_NOISE = re.compile(r"(login|signin|cart|facebook|twitter|linkedin|instagram|javascript:|#)$", re.I)
+
+
+class PoliteSession:
+    def __init__(self, delay: float = 0.9):
+        self.s = requests.Session()
+        self.s.headers["User-Agent"] = UA
+        self.s.verify = True
+        self.delay = delay
+        self._last = 0.0
+        self.n = 0
+
+    def get(self, url: str) -> Tuple[Optional[requests.Response], Optional[str]]:
+        wait = self.delay - (time.time() - self._last)
+        if wait > 0:
+            time.sleep(wait)
+        try:
+            r = self.s.get(url, timeout=45, verify=True, allow_redirects=True)
+        except requests.RequestException as e:
+            self._last = time.time()
+            return None, f"net_error:{e.__class__.__name__}"
+        self._last = time.time()
+        self.n += 1
+        low = (r.text or "")[:5000].lower()
+        if r.status_code in (403, 429, 503) or "cf-challenge" in low or "just a moment" in low or "captcha" in low:
+            return r, "blocked_waf"
+        if r.status_code != 200:
+            return r, f"http_{r.status_code}"
+        return r, None
+
+
+def wayback_closest(sess: PoliteSession, url: str) -> Tuple[Optional[str], Optional[requests.Response]]:
+    api = f"https://archive.org/wayback/available?url={url}"
+    r, flag = sess.get(api)
+    if not r or flag:
+        return None, None
+    try:
+        snap = (((r.json() or {}).get("archived_snapshots") or {}).get("closest") or {})
+        wu = snap.get("url")
+    except Exception:
+        return None, None
+    if not wu:
+        return None, None
+    r2, flag2 = sess.get(wu)
+    if not r2 or flag2:
+        return wu, None
+    return wu, r2
+
+
+def fetch_with_fallback(
+    sess: PoliteSession, candidates: List[Tuple[str, Optional[str]]]
+) -> Tuple[Optional[requests.Response], str, Optional[str], Optional[str]]:
+    """Try live URLs then wayback. Returns (resp, final_url, archive_source, status)."""
+    last_status = "no_candidates"
+    for url, arch in candidates:
+        r, flag = sess.get(url)
+        if r and not flag:
+            return r, url, arch, "ok"
+        last_status = flag or "fetch_failed"
+        if flag == "blocked_waf" or (r and r.status_code in (403, 401, 404, 500)):
+            # try wayback of the live URL
+            live, _ = unwrap_wayback(url)
+            wu, wr = wayback_closest(sess, live)
+            if wr:
+                return wr, wu or url, "wayback", "ok_wayback"
+    return None, "", None, last_status
+
+
+def _same_site(base: str, href: str) -> bool:
+    try:
+        b = urlparse(base).netloc.lower().lstrip("www.")
+        h = urlparse(href).netloc.lower().lstrip("www.")
+        return bool(h) and (h == b or h.endswith("." + b) or b.endswith("." + h))
+    except Exception:
+        return False
+
+
+def extract_links(base_url: str, html: str, kind: str) -> List[str]:
+    soup = BeautifulSoup(html, "html.parser")
+    out: List[str] = []
+    for a in soup.select("a[href]"):
+        href = (a.get("href") or "").strip()
+        if not href or href.startswith("mailto:") or NAV_NOISE.search(href):
+            continue
+        full = urljoin(base_url, href)
+        if full.startswith("//"):
+            full = "https:" + full
+        if not full.startswith("http"):
+            continue
+        if not _same_site(base_url, full):
+            continue
+        text = (a.get_text(" ", strip=True) or "") + " " + full
+        if kind == "admin" and not RULE_HINTS.search(text) and not RULE_HINTS.search(full):
+            # still allow .pdf/.htm rule-ish paths
+            if not re.search(r"\.(pdf|html?|aspx?)$", full, re.I):
+                continue
+        if kind == "eo" and not EO_HINTS.search(text) and not EO_HINTS.search(full):
+            if not re.search(r"\.(pdf|html?|aspx?)$", full, re.I):
+                continue
+        out.append(full.split("#")[0])
+    # dedupe preserve order
+    return list(dict.fromkeys(out))
+
+
+def is_substantive(text: str, title: str = "") -> bool:
+    t = (text or "").strip()
+    if len(t) < 400:
+        return False
+    # reject thin nav shells
+    low = t.lower()
+    nav_marks = sum(1 for k in ("home", "contact us", "privacy", "accessibility", "skip to") if k in low[:800])
+    if nav_marks >= 3 and len(t) < 1200:
+        return False
+    return True
+
+
+def frontier_path(target_id: str) -> Path:
+    FRONTIER_DIR.mkdir(parents=True, exist_ok=True)
+    safe = re.sub(r"[^A-Za-z0-9_\-]", "_", target_id)
+    return FRONTIER_DIR / f"{safe}.json"
+
+
+def load_frontier(target_id: str) -> Dict[str, Any]:
+    p = frontier_path(target_id)
+    if p.exists():
+        try:
+            return json.loads(p.read_text(encoding="utf-8"))
+        except Exception:
+            pass
+    return {"queue": [], "visited": [], "cursor": 0}
+
+
+def save_frontier(target_id: str, fr: Dict[str, Any]) -> None:
+    # cap visited
+    visited = list(dict.fromkeys(fr.get("visited") or []))[-4000:]
+    queue = list(dict.fromkeys(fr.get("queue") or []))[:2000]
+    fr = {"queue": queue, "visited": visited, "cursor": int(fr.get("cursor") or 0),
+          "updated_at": datetime.now(timezone.utc).isoformat()}
+    p = frontier_path(target_id)
+    tmp = p.with_suffix(".tmp")
+    tmp.write_text(json.dumps(fr), encoding="utf-8")
+    tmp.replace(p)
+
+
+def make_doc_record(
+    *,
+    gap_target_id: str,
+    state: str,
+    title: str,
+    text: str,
+    source_url: str,
+    document_type: str,
+    archive_source: Optional[str],
+    target_hf_repo: str,
+    locality: Optional[str] = None,
+) -> Dict[str, Any]:
+    level = "territorial" if state in ("PR", "GU", "VI", "AS", "MP", "DC") and locality is None else "state"
+    if state == "DC":
+        level = "state"
+    if locality:
+        level = "municipal"
+    return base_record(
+        gap_target_id=gap_target_id,
+        jurisdiction=f"US-{state}",
+        subdivision_level=level,
+        document_type=document_type,
+        title=title[:300],
+        text=text[:60000],
+        source_url=source_url,
+        citation=title[:200] if title else None,
+        state_or_province=state,
+        locality=locality,
+        transport="https" if source_url.startswith("https") else "http",
+        archive_source=archive_source,
+        target_hf_repo=target_hf_repo,
+    )
+
+
+# ---- OH deep resume (unchanged approach) ----
+def load_oh_done_urls() -> Set[str]:
+    done: Set[str] = set()
+    if OH_ROWS.exists():
+        with open(OH_ROWS, encoding="utf-8") as f:
+            for line in f:
+                try:
+                    done.add(json.loads(line)["source_url"])
+                except Exception:
+                    continue
+    return done
+
+
+def load_oh_cursor() -> Dict[str, Any]:
+    if OH_CURSOR.exists():
+        try:
+            return json.loads(OH_CURSOR.read_text(encoding="utf-8"))
+        except Exception:
+            pass
+    return {"completed_agencies": [], "skip_until_agency": "/ohio-administrative-code/122"}
+
+
+def save_oh_cursor(cur: Dict[str, Any]) -> None:
+    OH_CURSOR.parent.mkdir(parents=True, exist_ok=True)
+    tmp = OH_CURSOR.with_suffix(".tmp")
+    tmp.write_text(json.dumps(cur, indent=2) + "\n", encoding="utf-8")
+    tmp.replace(OH_CURSOR)
+
+
+def append_oh_legacy_row(cit: str, title: str, text: str, url: str) -> Dict[str, Any]:
+    OH_ROWS.parent.mkdir(parents=True, exist_ok=True)
+    row = {
+        "state": "OH", "citation": cit, "title": title, "text": text, "source_url": url,
+        "fetched_at": datetime.now(timezone.utc).isoformat(),
+        "sha256": hashlib.sha256(text.encode()).hexdigest(), "transport": "https",
+    }
+    with open(OH_ROWS, "a", encoding="utf-8") as f:
+        f.write(json.dumps(row, ensure_ascii=False) + "\n")
+    return row
+
+
+def resume_ohio(sess: PoliteSession, done: Set[str], seen_add: Callable[[str], bool], *, max_new: int = 25):
+    manifest: Dict[str, Any] = {"portal": OH_BASE + "/ohio-administrative-code", "status": "ok"}
+    out: List[Dict[str, Any]] = []
+    cur = load_oh_cursor()
+    completed: Set[str] = set(cur.get("completed_agencies") or [])
+    skip_until = cur.get("skip_until_agency")
+    r, flag = sess.get(OH_BASE + "/ohio-administrative-code")
+    if flag or not r:
+        manifest["status"] = flag or "fetch_failed"
+        return out, manifest
+    top = BeautifulSoup(r.text, "html.parser")
+    ags = sorted({
+        a["href"] for a in top.select("a[href]")
+        if re.fullmatch(r"/ohio-administrative-code/[0-9a-z:\-]+", a.get("href") or "")
+        and "chapter" not in a["href"] and "rule" not in a["href"]
+    })
+    started = not skip_until
+    for ag in ags:
+        if len(out) >= max_new:
+            break
+        if not started:
+            if ag < skip_until:
+                continue
+            started = True
+            cur["skip_until_agency"] = None
+            save_oh_cursor({**cur, "completed_agencies": sorted(completed)})
+        if ag in completed:
+            continue
+        r, flag = sess.get(OH_BASE + ag)
+        if flag == "blocked_waf" or not r:
+            if flag == "blocked_waf":
+                manifest["status"] = "blocked_waf"
+                break
+            continue
+        chs = list(dict.fromkeys(
+            a["href"] for a in BeautifulSoup(r.text, "html.parser").select(
+                'a[href^="/ohio-administrative-code/chapter-"]'
+            )
+        ))
+        agency_new = 0
+        agency_seen = 0
+        all_done = True
+        for ch in chs:
+            if len(out) >= max_new:
+                break
+            r, flag = sess.get(OH_BASE + ch)
+            if flag == "blocked_waf" or not r:
+                if flag == "blocked_waf":
+                    manifest["status"] = "blocked_waf"
+                    return out, manifest
+                continue
+            rules = list(dict.fromkeys(
+                a["href"] for a in BeautifulSoup(r.text, "html.parser").select(
+                    'a[href^="/ohio-administrative-code/rule-"]'
+                )
+            ))
+            for ru in rules:
+                agency_seen += 1
+                u = OH_BASE + ru
+                if u in done:
+                    continue
+                all_done = False
+                if len(out) >= max_new:
+                    break
+                r, flag = sess.get(u)
+                if flag or not r:
+                    if flag == "blocked_waf":
+                        manifest["status"] = "blocked_waf"
+                        return out, manifest
+                    continue
+                b = BeautifulSoup(r.text, "html.parser")
+                h = b.select_one("section.laws-header h1")
+                body = b.select_one("section.laws-body")
+                if not h or not body:
+                    continue
+                ht = h.get_text(" ", strip=True)
+                cit, _, title = ht.partition("|")
+                text = body.get_text("\n", strip=True)
+                legacy = append_oh_legacy_row(cit.strip(), title.strip(), text, u)
+                rec = from_oh_official_row(legacy)
+                if seen_add(rec["id"]):
+                    out.append(rec)
+                done.add(u)
+                agency_new += 1
+        if agency_seen > 0 and all_done and agency_new == 0 and len(out) < max_new:
+            completed.add(ag)
+            save_oh_cursor({"completed_agencies": sorted(completed), "last_agency": ag})
+        elif agency_new > 0:
+            save_oh_cursor({"completed_agencies": sorted(completed), "last_agency": ag})
+    manifest["new"] = len(out)
+    return out, manifest
+
+
+def deep_collect_state(
+    sess: PoliteSession,
+    seed: Dict[str, Any],
+    seen_add: Callable[[str], bool],
+    *,
+    max_admin: int = 12,
+    max_eo: int = 8,
+) -> Tuple[List[Dict[str, Any]], List[Dict[str, Any]], Dict[str, Any]]:
+    """Return (admin_records, eo_records, manifest)."""
+    tid = seed["target_id"]
+    st = state_code_from_target(tid) or "XX"
+    hf_admin = seed.get("target_hf_repo") or "justicedao/ipfs_state_admin_rules"
+    hf_eo = "justicedao/ipfs_us_executive_orders"
+    admin_out: List[Dict[str, Any]] = []
+    eo_out: List[Dict[str, Any]] = []
+    man: Dict[str, Any] = {"target_id": tid, "state": st, "admin_status": None, "eo_status": None}
+
+    if st == "OH":
+        done = load_oh_done_urls()
+        recs, m = resume_ohio(sess, done, seen_add, max_new=max_admin)
+        admin_out.extend(recs)
+        man["admin_status"] = m
+        # also governor EO if present in seeds
+    else:
+        fr = load_frontier(tid)
+        visited = set(fr.get("visited") or [])
+        queue = list(fr.get("queue") or [])
+
+        # seed admin_code
+        admin_cands = preferred_fetch_urls(seed, "admin_code")
+        if admin_cands and not queue:
+            queue.extend([u for u, _ in admin_cands[:5]])
+
+        # ensure we fetch at least one admin seed page to expand frontier
+        if admin_cands:
+            r, final_url, arch, status = fetch_with_fallback(sess, admin_cands)
+            man["admin_status"] = status
+            man["admin_url"] = final_url
+            if r:
+                visited.add(final_url)
+                links = extract_links(final_url, r.text, "admin")
+                for L in links[:80]:
+                    if L not in visited and L not in queue:
+                        queue.append(L)
+                # if seed page itself is substantive, keep it
+                title = BeautifulSoup(r.text, "html.parser").title
+                title_s = title.get_text(" ", strip=True) if title else f"{st} admin"
+                text = BeautifulSoup(r.text, "html.parser").get_text("\n", strip=True)
+                if is_substantive(text, title_s):
+                    rec = make_doc_record(
+                        gap_target_id=tid, state=st, title=title_s, text=text,
+                        source_url=final_url, document_type="admin_rule",
+                        archive_source=arch, target_hf_repo=hf_admin,
+                    )
+                    if seen_add(rec["id"]):
+                        admin_out.append(rec)
+
+        # crawl frontier for admin docs
+        while queue and len(admin_out) < max_admin:
+            url = queue.pop(0)
+            if url in visited:
+                continue
+            visited.add(url)
+            r, flag = sess.get(url)
+            arch = "wayback" if "web.archive.org" in url else None
+            if flag or not r:
+                if flag == "blocked_waf":
+                    live, _ = unwrap_wayback(url)
+                    wu, wr = wayback_closest(sess, live)
+                    if wr:
+                        r, url, arch, flag = wr, wu or url, "wayback", None
+                    else:
+                        continue
+                else:
+                    continue
+            soup = BeautifulSoup(r.text, "html.parser")
+            title = soup.title.get_text(" ", strip=True) if soup.title else url
+            # prefer PDF binary skip — only text/html
+            ctype = (r.headers.get("content-type") or "").lower()
+            if "pdf" in ctype:
+                # store short PDF meta stub only if substantive headers
+                text = f"[PDF content-type] bytes={len(r.content)} url={url}"
+                if len(r.content) > 5000:
+                    rec = make_doc_record(
+                        gap_target_id=tid, state=st, title=title or Path(urlparse(url).path).name,
+                        text=text, source_url=url, document_type="admin_rule_pdf_meta",
+                        archive_source=arch, target_hf_repo=hf_admin,
+                    )
+                    if seen_add(rec["id"]):
+                        admin_out.append(rec)
+                continue
+            text = soup.get_text("\n", strip=True)
+            if is_substantive(text, title):
+                rec = make_doc_record(
+                    gap_target_id=tid, state=st, title=title, text=text,
+                    source_url=url, document_type="admin_rule",
+                    archive_source=arch, target_hf_repo=hf_admin,
+                )
+                if seen_add(rec["id"]):
+                    admin_out.append(rec)
+            # expand a bit
+            if len(visited) < 120:
+                for L in extract_links(url, r.text, "admin")[:20]:
+                    if L not in visited and L not in queue:
+                        queue.append(L)
+
+        fr["queue"] = queue
+        fr["visited"] = list(visited)
+        save_frontier(tid, fr)
+
+    # Governor EO role
+    eo_cands = preferred_fetch_urls(seed, "governor_eo")
+    if eo_cands:
+        r, final_url, arch, status = fetch_with_fallback(sess, eo_cands)
+        man["eo_status"] = status
+        man["eo_url"] = final_url
+        if r:
+            links = extract_links(final_url, r.text, "eo")
+            # include landing if substantive
+            soup = BeautifulSoup(r.text, "html.parser")
+            title = soup.title.get_text(" ", strip=True) if soup.title else f"{st} Governor EOs"
+            text = soup.get_text("\n", strip=True)
+            candidates = [(final_url, r, arch, title)]
+            for L in links[: max_eo * 3]:
+                if len(candidates) >= max_eo + 1:
+                    break
+                r2, f2 = sess.get(L)
+                a2 = "wayback" if "web.archive.org" in L else None
+                if f2 or not r2:
+                    continue
+                s2 = BeautifulSoup(r2.text, "html.parser")
+                t2 = s2.title.get_text(" ", strip=True) if s2.title else L
+                candidates.append((L, r2, a2, t2))
+            for url, resp, a, title in candidates:
+                if len(eo_out) >= max_eo:
+                    break
+                ctype = (resp.headers.get("content-type") or "").lower()
+                if "pdf" in ctype:
+                    text = f"[PDF] bytes={len(resp.content)} url={url}"
+                    if len(resp.content) < 3000:
+                        continue
+                else:
+                    text = BeautifulSoup(resp.text, "html.parser").get_text("\n", strip=True)
+                if not is_substantive(text, title) and "pdf" not in ctype:
+                    continue
+                rec = make_doc_record(
+                    gap_target_id=tid, state=st, title=title, text=text,
+                    source_url=url, document_type="governor_eo",
+                    archive_source=a, target_hf_repo=hf_eo,
+                )
+                if seen_add(rec["id"]):
+                    eo_out.append(rec)
+
+    man["admin_written"] = len(admin_out)
+    man["eo_written"] = len(eo_out)
+    return admin_out, eo_out, man

scrapers_and_normalizers/unified_daemon.py

@@ -0,0 +1,347 @@
+#!/usr/bin/env python3
+"""Seed-driven US Admin Rules & EO daemon with pause/hibernate memguard.
+
+Queue: /workspace/coverage/world_admin_eo_seeds_20261105.jsonl (US ARE-US-* rows).
+MemAvailable < 4.2 GiB -> flush, gc, status=paused_low_mem, sleep until >= 4.35 GiB.
+Disk < 10 GiB -> exit. RSS > 500 MiB -> flush + os.execv self.
+"""
+from __future__ import annotations
+
+import gc
+import json
+import os
+import signal
+import sys
+import time
+import traceback
+from datetime import datetime, timezone
+from pathlib import Path
+
+BUNDLE = Path(__file__).resolve().parent
+sys.path.insert(0, str(BUNDLE))
+IPFS = Path("/workspace/ipfs_datasets_py_latest")
+if IPFS.exists():
+    sys.path.insert(0, str(IPFS))
+
+from io_zst import (
+    JsonlZstWriter, MemGuard, SeenIds, load_ids_from_zst, load_json, write_json,
+    mem_available_bytes, disk_free_bytes, process_rss_bytes,
+)
+from seeds import load_us_seeds, state_code_from_target
+from federal_collector import (
+    PoliteSession as FedSession, ecfr_as_of, collect_ecfr_title_parts, collect_eo, collect_fr_after,
+)
+from state_admin_collector import PoliteSession as StateSession, deep_collect_state
+from municipal_collector import PoliteSession as MuniSession, collect_municipal
+
+FED_ROOT = Path("/workspace/legal-corpora/us_federal_admin_eo_20261105")
+STATE_ROOT = Path("/workspace/legal-corpora/us_state_admin_rules_20261104")
+EO_ROOT = Path("/workspace/legal-corpora/us_executive_orders_20261105")
+STATE_SHARDS = STATE_ROOT / "shards"
+COLLECTOR = STATE_ROOT / "_collector"
+STATUS_STATE = COLLECTOR / "status.json"
+STATUS_FED = FED_ROOT / "status.json"
+STATUS_EO = EO_ROOT / "status.json"
+CKPT = COLLECTOR / "checkpoint_gap.json"
+SEEN_PATH = COLLECTOR / "seen_ids.json"
+LOG = Path("/workspace/logs/us_admin_eo_gap_daemon_20261105.log")
+SEEDS_PATH = "/workspace/coverage/world_admin_eo_seeds_20261105.jsonl"
+
+STOP = False
+
+
+def log(msg: str) -> None:
+    LOG.parent.mkdir(parents=True, exist_ok=True)
+    line = f"{datetime.now().isoformat(timespec='seconds')} {msg}"
+    with open(LOG, "a", encoding="utf-8") as f:
+        f.write(line + "\n")
+    print(line, flush=True)
+
+
+def _sig(signum, frame):
+    global STOP
+    STOP = True
+    log(f"SIGNAL {signum} -> graceful stop")
+
+
+signal.signal(signal.SIGTERM, _sig)
+signal.signal(signal.SIGINT, _sig)
+
+
+def dual_status(**kwargs):
+    payload = dict(kwargs)
+    payload.update({
+        "updated_at": datetime.now(timezone.utc).isoformat(),
+        "pid": os.getpid(),
+        "mem_available_bytes": mem_available_bytes(),
+        "disk_free_bytes": disk_free_bytes(),
+        "rss_bytes": process_rss_bytes(),
+        "mem_floor_bytes": MemGuard.MEM_FLOOR,
+        "mem_resume_bytes": MemGuard.MEM_RESUME,
+        "disk_floor_bytes": MemGuard.DISK_FLOOR,
+        "rss_reexec_bytes": MemGuard.RSS_REEXEC,
+        "seeds": SEEDS_PATH,
+        "log": str(LOG),
+        "seen_ids_path": str(SEEN_PATH),
+    })
+    for path in (STATUS_STATE, STATUS_FED, STATUS_EO):
+        prev = load_json(path, default={}) or {}
+        prev.update(payload)
+        write_json(path, prev)
+
+
+def shard_path(root: Path, prefix: str) -> Path:
+    (root / "shards").mkdir(parents=True, exist_ok=True)
+    ts = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+    return root / "shards" / f"{prefix}_{ts}.jsonl.zst"
+
+
+def write_batch(path: Path, records: list, seen: SeenIds) -> int:
+    if not records:
+        return 0
+    with JsonlZstWriter(path) as w:
+        for rec in records:
+            w.write(rec)
+        w.flush()
+    seen.flush()
+    return len(records)
+
+
+def seed_seen(seen: SeenIds) -> int:
+    n = 0
+    for root in [FED_ROOT / "shards", STATE_SHARDS, STATE_ROOT / "OH.official" / "shards", EO_ROOT / "shards"]:
+        if not root.exists():
+            continue
+        for p in root.glob("*.jsonl.zst"):
+            n += load_ids_from_zst(p, seen)
+        for p in root.glob("**/*.jsonl.zst"):
+            n += load_ids_from_zst(p, seen)
+    # also per-state .gap
+    for p in STATE_ROOT.glob("*.gap/shards/*.jsonl.zst"):
+        n += load_ids_from_zst(p, seen)
+    seen.flush()
+    return n
+
+
+def handle_guard(action: str, guard: MemGuard, seen: SeenIds, ckpt: dict) -> bool:
+    """Return False if caller should exit; True to continue (possibly after pause/reexec)."""
+    if action == "ok":
+        return True
+    seen.flush()
+    write_json(CKPT, ckpt)
+    gc.collect()
+    if action == "exit_disk":
+        dual_status(state="exited", stop_reason=guard.stop_reason, totals=ckpt.get("totals"))
+        log(f"EXIT_DISK {guard.stop_reason}")
+        return False
+    if action == "reexec":
+        dual_status(state="reexec_rss", stop_reason=guard.stop_reason, totals=ckpt.get("totals"))
+        log(f"REEXEC {guard.stop_reason}")
+        os.execv(sys.executable, [sys.executable, "-u", str(Path(__file__).resolve())] + sys.argv[1:])
+        return False  # unreachable
+    if action == "pause":
+        dual_status(state="paused_low_mem", stop_reason=guard.stop_reason, totals=ckpt.get("totals"),
+                    queue_index=ckpt.get("queue_index"), ecfr_title_index=ckpt.get("ecfr_title_index"),
+                    current_target="(paused)")
+        log(f"PAUSE {guard.stop_reason}")
+        ok = MemGuard.wait_until_resume(
+            log_fn=log,
+            status_fn=lambda **kw: dual_status(totals=ckpt.get("totals"),
+                                              queue_index=ckpt.get("queue_index"),
+                                              ecfr_title_index=ckpt.get("ecfr_title_index"),
+                                              current_target="(paused)", **kw),
+            stop_flag=lambda: STOP,
+        )
+        if not ok:
+            dual_status(state="exited", stop_reason="stop_during_pause_or_disk", totals=ckpt.get("totals"))
+            return False
+        dual_status(state="running", stop_reason=None, totals=ckpt.get("totals"))
+        return True
+    return True
+
+
+def main() -> int:
+    for d in [FED_ROOT / "shards", STATE_SHARDS, EO_ROOT / "shards", COLLECTOR,
+              STATE_ROOT / "OH.official" / "shards"]:
+        d.mkdir(parents=True, exist_ok=True)
+
+    guard = MemGuard()
+    seen = SeenIds(SEEN_PATH)
+    seeded = seed_seen(seen)
+    log(f"START pid={os.getpid()} seeded_seen={seeded} total_seen={len(seen.ids)} mem={mem_available_bytes()}")
+
+    # Immediate pause if already below floor
+    action = guard.evaluate()
+    ckpt = load_json(CKPT, default={}) or {}
+    if action != "ok":
+        if not handle_guard(action, guard, seen, ckpt):
+            return 0
+
+    queue = load_us_seeds()
+    queue_index = int(ckpt.get("queue_index") or 0)
+    ecfr_title_index = int(ckpt.get("ecfr_title_index") or 0)
+    totals = ckpt.get("totals") or {"written": 0, "skipped_dup": 0, "by_target": {}}
+
+    def seen_add(rid: str) -> bool:
+        ok = seen.add(rid)
+        if not ok:
+            totals["skipped_dup"] = totals.get("skipped_dup", 0) + 1
+        return ok
+
+    fed = FedSession(delay=0.7)
+    state = StateSession(delay=0.9)
+    muni = MuniSession(delay=1.0)
+
+    dual_status(state="starting", stream="seeds_us", queue_len=len(queue), queue_index=queue_index, totals=totals)
+    date, titles = ecfr_as_of(fed)
+    title_nums = [int(t["number"]) for t in titles if not t.get("reserved")] or list(range(1, 51))
+    log(f"seeds={len(queue)} eCFR as_of={date} titles={len(title_nums)}")
+
+    while not STOP:
+        action = guard.tick()
+        ckpt = {
+            "queue_index": queue_index, "ecfr_title_index": ecfr_title_index,
+            "totals": totals, "saved_at": datetime.now(timezone.utc).isoformat(),
+        }
+        if not handle_guard(action, guard, seen, ckpt):
+            return 0
+
+        if queue_index >= len(queue):
+            # wrap: continue ECFR titles if needed else restart from FR/EO/state deepen
+            if ecfr_title_index < len(title_nums):
+                queue_index = 0
+                log(f"WRAP to ECFR title_index={ecfr_title_index}")
+            else:
+                queue_index = 0
+                log("FULL WRAP deepen cycle")
+
+        seed = queue[queue_index]
+        tid = seed["target_id"]
+        lane = seed.get("lane")
+        hf = seed.get("target_hf_repo")
+        dual_status(state="running", current_target=tid, queue_index=queue_index, lane=lane,
+                    target_hf_repo=hf, totals=totals, ecfr_title_index=ecfr_title_index)
+        log(f"TARGET {queue_index+1}/{len(queue)} {tid} lane={lane} hf={hf}")
+
+        try:
+            if tid == "ARE-US-ECFR":
+                wrote_any = 0
+                for _ in range(2):
+                    if ecfr_title_index >= len(title_nums) or STOP:
+                        break
+                    action = guard.tick()
+                    if action != "ok":
+                        ckpt = {"queue_index": queue_index, "ecfr_title_index": ecfr_title_index,
+                                "totals": totals, "saved_at": datetime.now(timezone.utc).isoformat()}
+                        if not handle_guard(action, guard, seen, ckpt):
+                            return 0
+                        break
+                    tnum = title_nums[ecfr_title_index]
+                    recs = collect_ecfr_title_parts(
+                        fed, tnum, date, seen_add=seen_add, max_parts=10, max_records=60,
+                        should_continue=lambda: (not STOP) and guard.evaluate() == "ok",
+                    )
+                    if recs:
+                        path = shard_path(FED_ROOT, f"ARE-US-ECFR_title{tnum}")
+                        n = write_batch(path, recs, seen)
+                        wrote_any += n
+                        totals["written"] = totals.get("written", 0) + n
+                        totals.setdefault("by_target", {})
+                        totals["by_target"][tid] = totals["by_target"].get(tid, 0) + n
+                        log(f"ECFR title {tnum} wrote {n}")
+                    ecfr_title_index += 1
+                queue_index += 1
+
+            elif tid == "ARE-US-EO":
+                recs = collect_eo(fed, seen_add, max_docs=25)
+                path = shard_path(EO_ROOT, "ARE-US-EO")
+                # also keep federal staging copy for continuity
+                n = write_batch(path, recs, seen)
+                if recs:
+                    write_batch(shard_path(FED_ROOT, "ARE-US-EO"), recs, seen)
+                totals["written"] = totals.get("written", 0) + n
+                totals.setdefault("by_target", {})
+                totals["by_target"][tid] = totals["by_target"].get(tid, 0) + n
+                log(f"EO wrote {n}")
+                queue_index += 1
+
+            elif tid == "ARE-US-FR":
+                recs = collect_fr_after(fed, seen_add, gte="2026-07-01", max_docs=30)
+                path = shard_path(FED_ROOT, "ARE-US-FR")
+                n = write_batch(path, recs, seen)
+                totals["written"] = totals.get("written", 0) + n
+                totals.setdefault("by_target", {})
+                totals["by_target"][tid] = totals["by_target"].get(tid, 0) + n
+                log(f"FR wrote {n}")
+                queue_index += 1
+
+            elif tid == "ARE-US-COUNTY-MUNICIPAL-ADMIN-EO":
+                recs, man = collect_municipal(muni, seen_add, max_records=20)
+                path = shard_path(EO_ROOT, "ARE-US-COUNTY-MUNICIPAL")
+                n = write_batch(path, recs, seen)
+                write_json(COLLECTOR / "municipal_manifest.json", man)
+                totals["written"] = totals.get("written", 0) + n
+                totals.setdefault("by_target", {})
+                totals["by_target"][tid] = totals["by_target"].get(tid, 0) + n
+                log(f"MUNICIPAL wrote {n}")
+                queue_index += 1
+
+            elif tid.endswith("-ADMIN-EO"):
+                admin_recs, eo_recs, man = deep_collect_state(
+                    state, seed, seen_add, max_admin=12, max_eo=8,
+                )
+                st = state_code_from_target(tid) or "XX"
+                n_admin = n_eo = 0
+                if admin_recs:
+                    # per-state + aggregate state shards
+                    out_dir = STATE_ROOT / f"{st}.gap" / "shards"
+                    out_dir.mkdir(parents=True, exist_ok=True)
+                    ts = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+                    p1 = out_dir / f"{tid}_{ts}.jsonl.zst"
+                    n_admin = write_batch(p1, admin_recs, seen)
+                    write_batch(STATE_SHARDS / f"{tid}_{ts}.jsonl.zst", admin_recs, seen)
+                if eo_recs:
+                    ts = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+                    n_eo = write_batch(shard_path(EO_ROOT, f"{tid}_gov_eo"), eo_recs, seen)
+                with open(COLLECTOR / "portal_manifest.jsonl", "a", encoding="utf-8") as mf:
+                    mf.write(json.dumps(man) + "\n")
+                n = n_admin + n_eo
+                totals["written"] = totals.get("written", 0) + n
+                totals.setdefault("by_target", {})
+                totals["by_target"][tid] = totals["by_target"].get(tid, 0) + n
+                log(f"{tid} wrote admin={n_admin} eo={n_eo} status={man.get('admin_status')}/{man.get('eo_status')}")
+                queue_index += 1
+            else:
+                log(f"SKIP {tid}")
+                queue_index += 1
+
+        except Exception as e:
+            log(f"ERR {tid} {e!r}\n{traceback.format_exc()}")
+            queue_index += 1
+
+        ckpt = {
+            "queue_index": queue_index, "ecfr_title_index": ecfr_title_index,
+            "totals": totals, "saved_at": datetime.now(timezone.utc).isoformat(),
+        }
+        write_json(CKPT, ckpt)
+        seen.flush()
+        dual_status(state="running", queue_index=queue_index, ecfr_title_index=ecfr_title_index,
+                    totals=totals, current_target=tid)
+        gc.collect()
+
+    seen.flush()
+    dual_status(state="exited", totals=totals, queue_index=queue_index, stop_reason="signal")
+    log(f"EXIT signal totals={totals}")
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main() or 0)
+    except Exception as e:
+        log(f"FATAL {e!r}\n{traceback.format_exc()}")
+        try:
+            dual_status(state="fatal", error=repr(e))
+        except Exception:
+            pass
+        sys.exit(1)