fix: OOM 16Gi — mirror row-group stream + watchdog tier-2/3 kills

Space hit 'Memory limit exceeded (16Gi)' twice this morning. Two causes
addressed:

1. dataset-mirror was loading entire parquet shards into memory via
pq.read_table().to_pylist() — for big sources like OpenHermes-2.5
(~5 GB shards) that ate all 16 GB by itself. Switched to ParquetFile
.read_row_group() iterator which keeps peak memory bounded to
~1 row-group worth (typically <500 MB).

2. Self-heal-watchdog only killed dataset-enrich shards. New tiers:
- Tier-1 (>=85%): kill 1-3 youngest dataset-enrich shards (existing)
- Tier-2 (>=90%): also SIGTERM dataset-mirror + parquet-direct + llm-burst
- Tier-3 (>=95%): also SIGTERM agentic-crawler + scrape-continuous
Restart loops in each daemon will respawn after Space recovers.

bin/dataset-mirror.sh

@@ -194,11 +194,15 @@ for src_id, slug in SOURCES:
         out_rows = []
         for shard in sorted(local_path.rglob("*.parquet")):
             try:
-                table = pq.read_table(shard)
-                df = table.to_pylist()
+                # Stream by row group to keep memory bounded — reading 5GB
+                # parquet as one table easily blows 16GB Space cap.
+                pf = pq.ParquetFile(shard)
             except Exception as e:
                 print(f"  skip shard {shard.name}: {type(e).__name__}: {str(e)[:80]}", flush=True)
                 continue
+            row_groups_iter = (pf.read_row_group(i).to_pylist()
+                               for i in range(pf.num_row_groups))
+            df = (row for rg in row_groups_iter for row in rg)
             for row in df:
                 scanned += 1
                 # ── Robust prompt/response extraction across many schemas ──

bin/self-heal-watchdog.sh

@@ -57,8 +57,9 @@ heal_memory() {
     # Adaptive aggressiveness — kill more shards as pct gets dangerously close.
     local kill_count=1
     [[ "$pct" -ge 90 ]] && kill_count=2     # 90%+: kill 2 youngest
-    [[ "$pct" -ge 95 ]] && kill_count=3     # 95%+: kill 3 youngest, plus parquet-direct if running
+    [[ "$pct" -ge 95 ]] && kill_count=3     # 95%+: kill 3 youngest + supporting hogs
 
+    # Tier-1 victims — dataset-enrich shards
     local victims
     victims=$(pgrep -f "dataset-enrich.sh" | sort -nr | head -"$kill_count")
     if [[ -n "$victims" ]]; then
@@ -67,10 +68,21 @@ heal_memory() {
             kill -TERM "$pid" 2>/dev/null || true
         done
     fi
-    # Also nuke parquet-direct if mem is critical — it's the second-biggest hog
+
+    # Tier-2 victims (when pct critical) — large parquet/dataset-mirror loaders
+    if [[ "$pct" -ge 90 ]]; then
+        for pat in "dataset-mirror.sh" "parquet-direct-ingest.sh" "llm-burst-generator.py"; do
+            local pid=$(pgrep -f "$pat" | head -1)
+            [[ -n "$pid" ]] && { log "  -> CRITICAL: SIGTERM $pat pid=$pid"; kill -TERM "$pid" 2>/dev/null || true; }
+        done
+    fi
+
+    # Tier-3 nuclear (95%+) — kill agentic-crawler + research-loop too
     if [[ "$pct" -ge 95 ]]; then
-        local pq=$(pgrep -f "parquet-direct-ingest.sh" | head -1)
-        [[ -n "$pq" ]] && { log "  -> CRITICAL: SIGTERM parquet-direct pid=$pq"; kill -TERM "$pq" 2>/dev/null || true; }
+        for pat in "agentic-crawler.sh" "github-agentic-crawler" "scrape-continuous"; do
+            local pid=$(pgrep -f "$pat" | head -1)
+            [[ -n "$pid" ]] && { log "  -> NUCLEAR: SIGTERM $pat pid=$pid"; kill -TERM "$pid" 2>/dev/null || true; }
+        done
     fi
 }