feat(burst-but-dont-die): adaptive auto-scaler + tighter discoverer cycle

User: 'burst เลย แต่ห้ามตาย'

bin/v2/auto-scaler.sh — adaptive worker scaling by memory tier:
≥10GB free → BURST: 4 streaming + 1 bulk (max throughput)
≥6GB free → MID: 3 streaming
≥4GB free → SAFE: 2 streaming
≥3GB free → MIN: 1 streaming
<3GB free → CRISIS: kill all workers (let cron finish)

Cron M%5==4 every 5 min: read /proc/meminfo MemAvailable, count active
workers via pgrep, compute target, spawn or kill the diff.

Discord notify on tier transition (BURST/MID/SAFE/MIN/CRISIS).

continuous-discoverer:
per-step sleep: 8s → 4s
cycle gap: 30s → 10s
→ ~2x faster discovery cadence (was ~5min cycle, now ~2.5min)

Net effect on cpu-basic 16GB:
• Memory guard (d8d7a71) prevents heavy cron tasks from OOM
• Auto-scaler (this commit) maxes worker throughput when safe
• Stagger fix (3234167) prevents minute=0 collision
• 3 layers of protection + adaptive scaling = burst-but-dont-die

Expected: in BURST tier (10GB free, no cron tasks running) we run
4 streamers + 1 bulk = ~5x current 1-streamer baseline. When cron
tasks fire and consume memory, scaler drops to MIN/CRISIS and pauses
workers; tasks complete; scaler ramps back up. No more OOM crashes.

bin/v2/auto-scaler.sh

@@ -0,0 +1,107 @@
+#!/usr/bin/env bash
+# Surrogate-1 v2 — adaptive worker auto-scaler.
+#
+# User: 'burst เลย แต่ห้ามตาย'
+#
+# Strategy: monitor MemAvailable every minute. Spawn streaming workers UP
+# when memory is plentiful (burst mode); kill workers when memory tight.
+# No fixed BULK/STREAM_WORKERS — fully dynamic.
+#
+# Memory tiers (cpu-basic 16 GB Space):
+#   ≥10 GB free → BURST: target 4 streaming + 1 bulk worker (max)
+#   ≥6 GB free  → MID:   target 3 streaming
+#   ≥4 GB free  → SAFE:  target 2 streaming
+#   ≥3 GB free  → MIN:   target 1 streaming (current default)
+#   <3 GB free  → CRISIS: kill all workers, let cron tasks finish
+#
+# Each tick: read avail mem, count current workers, spawn/kill the diff.
+# Kill order: bulk first (heaviest), then youngest streaming.
+# Spawn always streaming first (lightest).
+#
+# Cron: M%5 (every 5 min, no minute=0 collide).
+set -uo pipefail
+[[ -f "$HOME/.hermes/.env" ]] && { set -a; source "$HOME/.hermes/.env" 2>/dev/null; set +a; }
+
+LOG="$HOME/.surrogate/logs/auto-scaler.log"
+mkdir -p "$(dirname "$LOG")"
+
+# Read MemAvailable
+if [[ -r /proc/meminfo ]]; then
+    AVAIL_MB=$(awk '/^MemAvailable:/{print int($2/1024)}' /proc/meminfo)
+else
+    AVAIL_MB=99999
+fi
+
+# Count current workers
+N_BULK=$(pgrep -cf "bulk-mirror-worker.sh" 2>/dev/null || echo 0)
+N_STREAM=$(pgrep -cf "streaming-mirror-worker.sh" 2>/dev/null || echo 0)
+
+# Determine target by memory tier
+if   (( AVAIL_MB >= 10000 )); then T_STREAM=4; T_BULK=1; TIER="BURST"
+elif (( AVAIL_MB >= 6000  )); then T_STREAM=3; T_BULK=0; TIER="MID"
+elif (( AVAIL_MB >= 4000  )); then T_STREAM=2; T_BULK=0; TIER="SAFE"
+elif (( AVAIL_MB >= 3000  )); then T_STREAM=1; T_BULK=0; TIER="MIN"
+else                                T_STREAM=0; T_BULK=0; TIER="CRISIS"
+fi
+
+ACTION=""
+
+# CRISIS: kill everything
+if [[ "$TIER" == "CRISIS" ]]; then
+    pkill -f "bulk-mirror-worker.sh" 2>/dev/null && ACTION="${ACTION}killed-bulk "
+    pkill -f "streaming-mirror-worker.sh" 2>/dev/null && ACTION="${ACTION}killed-stream "
+fi
+
+# Spawn streaming up to target
+DIFF=$((T_STREAM - N_STREAM))
+if (( DIFF > 0 )); then
+    for _ in $(seq 1 "$DIFF"); do
+        wid="autoscale-stream-$(date +%s)-$$-${RANDOM}"
+        nohup bash "$HOME/.surrogate/bin/v2/streaming-mirror-worker.sh" "$wid" \
+            > "$HOME/.surrogate/logs/stream-$wid.log" 2>&1 &
+        ACTION="${ACTION}+stream "
+    done
+elif (( DIFF < 0 )); then
+    # Kill youngest streaming first
+    KILLN=$(( -DIFF ))
+    pgrep -f "streaming-mirror-worker.sh" | tail -"$KILLN" | xargs -r kill 2>/dev/null
+    ACTION="${ACTION}-${KILLN}stream "
+fi
+
+# Spawn bulk up to target
+DIFF_B=$((T_BULK - N_BULK))
+if (( DIFF_B > 0 )); then
+    for _ in $(seq 1 "$DIFF_B"); do
+        wid="autoscale-bulk-$(date +%s)-$$-${RANDOM}"
+        nohup bash "$HOME/.surrogate/bin/v2/bulk-mirror-worker.sh" "$wid" \
+            > "$HOME/.surrogate/logs/bulk-$wid.log" 2>&1 &
+        ACTION="${ACTION}+bulk "
+    done
+elif (( DIFF_B < 0 )); then
+    KILLN=$(( -DIFF_B ))
+    pgrep -f "bulk-mirror-worker.sh" | tail -"$KILLN" | xargs -r kill 2>/dev/null
+    ACTION="${ACTION}-${KILLN}bulk "
+fi
+
+[[ -z "$ACTION" ]] && ACTION="steady"
+
+echo "[$(date '+%H:%M:%S')] tier=$TIER avail=${AVAIL_MB}MB stream=$N_STREAM/$T_STREAM bulk=$N_BULK/$T_BULK action=$ACTION" >> "$LOG"
+
+# Discord notify on tier change (compare to last)
+LAST_TIER_FILE="$HOME/.surrogate/logs/.auto-scaler-last-tier"
+LAST_TIER=$(cat "$LAST_TIER_FILE" 2>/dev/null || echo "")
+if [[ "$TIER" != "$LAST_TIER" ]]; then
+    echo "$TIER" > "$LAST_TIER_FILE"
+    if [[ -n "${DISCORD_WEBHOOK:-}" ]]; then
+        case "$TIER" in
+            BURST)  emoji="🚀" ;;
+            MID)    emoji="⚡" ;;
+            SAFE)   emoji="✅" ;;
+            MIN)    emoji="⚠️" ;;
+            CRISIS) emoji="🔴" ;;
+        esac
+        curl -s -X POST -H "Content-Type: application/json" \
+            -d "{\"content\":\"$emoji auto-scaler: tier $LAST_TIER → **$TIER** (avail ${AVAIL_MB}MB) → stream=$T_STREAM bulk=$T_BULK\"}" \
+            "$DISCORD_WEBHOOK" >/dev/null 2>&1 || true
+    fi
+fi

bin/v2/continuous-discoverer.sh

@@ -198,7 +198,7 @@ while true; do
     CYCLE=$((CYCLE+1))
     for fn in "${SOURCE_FNS[@]}"; do
         $fn 2>>"$LOG" || true
-        sleep 8   # polite per-step throttle
+        sleep 4   # tighter — burst mode (was 8s)
     done
 
     # Re-seed coordinator every 10 cycles (~50 min) so newly-added rows enter queue
@@ -209,5 +209,5 @@ while true; do
         notify "cycle $CYCLE done — queue total $TOTAL sources"
     fi
 
-    sleep 30   # cycle gap (each full cycle ~5 min counting per-step sleeps)
+    sleep 10   # tighter cycle gap — burst mode (was 30s)
 done

start.sh

@@ -397,6 +397,8 @@ while true; do
     # Each major task picks a unique M%X==N offset so no two fire together.
     [[ $((M % 2)) -eq 1 ]] && bash ~/.surrogate/bin/surrogate-dev-loop.sh 1 >> "$LOG" 2>&1 &
     [[ $((M % 5)) -eq 2 ]] && bash ~/.surrogate/bin/work-queue-producer.sh >> "$LOG" 2>&1 &
+    # Auto-scaler — spawn/kill workers based on free memory tier (burst-but-don't-die)
+    [[ $((M % 5)) -eq 4 ]] && bash ~/.surrogate/bin/v2/auto-scaler.sh >> "$LOG" 2>&1 &
     # push-training-to-hf gated by memory (loads big shard into RAM).
     # Anchor (24GB) takes over when capacity arrives — see anchor cron-loop.
     [[ $((M % 3)) -eq 1 ]] && bash ~/.surrogate/bin/v2/memory-guard.sh \