#!/usr/bin/env bash
# H7 MEGA TRAIN · bash + pure nasm + RTX SPV (Vulkan · NOT GL)
# 7 SORT tracks · combinatorics sample · fail-only rejoin · finite forever shootable
#
#   ./Build/h7-mega-train.sh full|build|run|rtx|status|chart|clean
#   H7_JOBS=24 H7_MODE_SET=0,1,2,3,7,8,15,16,31,32,63,64,127 ./Build/h7-mega-train.sh full
#   H7_COMB=13 H7_RTX_W=512 H7_RTX_H=512 ./Build/h7-mega-train.sh full
#
# Tracks (SORT order · foundation → travel → RTX → GRIN seal):
#   0 CORE   Hostess when/how SI hand poles
#   1 MODES  every det limb × mode set
#   2 COMB2  2-arg sample (adjoin ezzie create_truth layer_stack linear_truth bgf free_eor)
#   3 COMB3  3-arg sample (si_compose spv rtx)
#   4 LINE   pure_linear · truth_layer dense · until_grin
#   5 RTX    Vulkan SPIR-V field+free (Build/h7-rtx-spv · Build/rtx.spv) · iron recheck
#   6 SEAL   GRIN · Hostess FULL · self_develop(N) · super_intel
#
set -euo pipefail
ROOT="$(cd "$(dirname "$0")/.." && pwd)"
OUT="$ROOT/out"
FAST="$OUT/h7fast"
OBJD="$FAST/obj"
BIND="$FAST/bin"
RD="$FAST/fails"                 # FAIL-only · no thrash of 50k PASS files
TSV="$FAST/mega.tsv"             # id track limb a b c want title
PROG="$OUT/hostess7_train_progress.json"
CHART="$OUT/h7_mega_chart.txt"
JOBS="${H7_JOBS:-$(nproc 2>/dev/null || echo 8)}"
MODE_SET="${H7_MODE_SET:-0,1,2,3,7,8,15,16,31,32,63,64,127}"
COMB_N="${H7_COMB:-13}"          # values in comb sample set (0..COMB_N-1 + poles)
RTX_W="${H7_RTX_W:-256}"
RTX_H="${H7_RTX_H:-256}"
RTX_SEED="${H7_RTX_SEED:-7}"
RTX_STRIDE="${H7_RTX_STRIDE:-0}" # 0=auto
SKIP_DIRS='out|Build|KateRTX|Data|json|AMOURANTHRTX|OpenPaperWork|BlueBox|RTXLayer|heuristics|multiarch'
# volatile non-det measure (live sensors / rng / clock) · real iron, not det FULL train
VOLATILE_NONDET='epoch|clock|clock64|rdrand|rdseed|rdtscp|rdrand_clock|rng|rng_clock|rng_hw|free_rng|heat|k10temp|fan|fan_pwm|fan_set'

mkdir -p "$OBJD" "$BIND" "$RD" "$OUT"
cmd="${1:-full}"
say() { echo "$*"; }

# ── pure nasm runner · argv a b c → print limb(a,b,c) ──
emit_runner() {
  local path="$1" sym="$2"
  # a,b,c stashed in r8,r9,r10 — parse clobbers rsi; never leave args in esi across parse
  cat >"$path" <<ASM
bits 64
default rel
global _start
extern ${sym}
section .bss
align 16
buf: resb 32
section .text
; parse decimal at rsi → eax (unsigned) · clobbers eax,ecx,rsi
parse:
    xor eax, eax
.p0:
    movzx ecx, byte [rsi]
    test cl, cl
    jz .p1
    cmp cl, '0'
    jb .p1
    cmp cl, '9'
    ja .p1
    imul eax, eax, 10
    sub cl, '0'
    add eax, ecx
    inc rsi
    jmp .p0
.p1:
    ret
_start:
    mov r15, rsp
    mov r12, [r15]              ; argc
    xor r8d, r8d                ; a
    xor r9d, r9d                ; b
    xor r10d, r10d              ; c
    cmp r12, 2
    jl .go
    mov rsi, [r15+16]
    call parse
    mov r8d, eax
    cmp r12, 3
    jl .go
    mov rsi, [r15+24]
    call parse
    mov r9d, eax
    cmp r12, 4
    jl .go
    mov rsi, [r15+32]
    call parse
    mov r10d, eax
.go:
    mov edi, r8d
    mov esi, r9d
    mov edx, r10d
    xor eax, eax
    call ${sym}
    mov r11d, eax               ; result
    lea rdi, [buf+31]
    mov byte [rdi], 10
    dec rdi
    mov r9d, r11d
    mov r8d, r11d
    test r8d, r8d
    jns .aok
    neg r8d
.aok:
    mov eax, r8d
    mov ebx, 10
.it:
    xor edx, edx
    div ebx
    add dl, '0'
    mov [rdi], dl
    dec rdi
    test eax, eax
    jnz .it
    test r9d, r9d
    jns .sok
    mov byte [rdi], '-'
    dec rdi
.sok:
    inc rdi
    lea rdx, [buf+32]
    sub rdx, rdi
    mov rsi, rdi
    mov eax, 1
    mov edi, 1
    syscall
    mov eax, 60
    xor edi, edi
    syscall
ASM
}

iron_want() {
  # pure bash want for known multi-arg ops when a,b,c known · else empty
  local limb="$1" a="$2" b="$3" c="$4"
  case "$limb" in
    adjoin|layer_stack) echo $(( (a | b) | 1 )) ;;
    create_truth|ezzie|free_eor) echo $(( (a ^ b) | 1 )) ;;
    linear_truth|bgf) echo $(( (a - b) | 1 )) ;;
    si_compose) echo $(( ((a | b) ^ c) | 1 )) ;;
    spv) echo $(( (a ^ b ^ c) | 1 )) ;;
    rtx) echo $(( (a - b) | 1 )) ;;  # eax=field path · free is r8 not returned
    until_grin|discovery|truth_layer) echo $(( a | 1 )) ;;
    *) echo "" ;;
  esac
}

list_det_limbs() {
  local d limb
  for d in "$ROOT"/*/; do
    limb=$(basename "$d")
    [[ "$limb" =~ ^\. ]] && continue
    [[ "$limb" =~ ^($SKIP_DIRS)$ ]] && continue
    [[ "$limb" =~ ^($VOLATILE_NONDET)$ ]] && continue
    [[ -f "$d/x86_64.asm" ]] || continue
    # only real opcodes · not comments mentioning "rdrand family"
    grep -qiE '^\s*(syscall|rdrand|rdtsc|rdseed)\b' "$d/x86_64.asm" 2>/dev/null && continue
    printf '%s\n' "$limb"
  done | LC_ALL=C sort -u
}

build_bins() {
  say "BUILD · jobs=$JOBS · nasm limbs + pure-asm 3-arg runners"
  local list="$FAST/limbs.txt"
  list_det_limbs >"$list"
  local nlimbs
  nlimbs=$(wc -l <"$list" | tr -d ' ')
  say "BUILD · det_limbs=$nlimbs"

  xargs -a "$list" -P "$JOBS" -I{} bash -c '
    ROOT="'"$ROOT"'"; OBJD="'"$OBJD"'"
    limb="$1"
    src="$ROOT/$limb/x86_64.asm"
    obj="$OBJD/$limb.o"
    [[ -f "$src" ]] || exit 0
    if [[ -f "$obj" && "$obj" -nt "$src" ]]; then exit 0; fi
    nasm -f elf64 -o "$obj" "$src" 2>/dev/null || exit 0
  ' _ {}

  local limb sym rasm
  while IFS= read -r limb; do
    [[ -f "$OBJD/$limb.o" ]] || continue
    sym=$(grep -m1 -E '^\s*global\s+\w+' "$ROOT/$limb/x86_64.asm" 2>/dev/null | awk '{print $2}' || true)
    [[ -n "$sym" && "$sym" =~ ^[A-Za-z_][A-Za-z0-9_]*$ ]] || continue
    rasm="$BIND/${limb}_runner.asm"
    if [[ ! -f "$rasm" ]] || [[ "$ROOT/$limb/x86_64.asm" -nt "$rasm" ]]; then
      emit_runner "$rasm" "$sym" || true
    fi
  done <"$list"

  xargs -a "$list" -P "$JOBS" -I{} bash -c '
    OBJD="'"$OBJD"'"; BIND="'"$BIND"'"
    limb="$1"
    obj="$OBJD/$limb.o"
    robj="$OBJD/${limb}_runner.o"
    rasm="$BIND/${limb}_runner.asm"
    bin="$BIND/$limb"
    [[ -f "$obj" && -f "$rasm" ]] || exit 0
    if [[ -f "$bin" && "$bin" -nt "$obj" && "$bin" -nt "$rasm" ]]; then exit 0; fi
    nasm -f elf64 -o "$robj" "$rasm" 2>/dev/null || exit 0
    ld -o "$bin" -e _start "$robj" "$obj" 2>/dev/null || exit 0
    chmod +x "$bin" 2>/dev/null || true
  ' _ {}

  local bins
  bins=$(find "$BIND" -maxdepth 1 -type f -executable ! -name '*.asm' 2>/dev/null | wc -l | tr -d ' ')
  say "BUILD done · bins=$bins"
}

# ── RTX SPV (Vulkan) · never GL ──
run_rtx_spv() {
  local bin="$ROOT/Build/h7-rtx-spv"
  if [[ ! -x "$bin" ]]; then
    say "RTX SPV · compile h7-rtx-spv (vulkan · not gl)"
    gcc -O2 -o "$bin" "$ROOT/Build/h7-rtx-spv.c" -ldl -lvulkan 2>/dev/null \
      || { say "RTX SPV · compile failed · skip track 5"; return 1; }
  fi
  if [[ ! -f "$ROOT/Build/rtx.spv" ]]; then
    glslangValidator -V -S comp -o "$ROOT/Build/rtx.spv" "$ROOT/Build/rtx.comp" 2>/dev/null \
      || { say "RTX SPV · no rtx.spv"; return 1; }
  fi
  say "RTX SPV · Vulkan dispatch ${RTX_W}x${RTX_H} seed=$RTX_SEED · not GL"
  "$bin" "$RTX_W" "$RTX_H" "$RTX_SEED" "$FAST" 2>&1 | tee "$FAST/rtx_spv_run.log"
  # nvidia stamp
  nvidia-smi --query-gpu=name,pstate,utilization.gpu,memory.used,temperature.gpu --format=csv,noheader \
    2>/dev/null | tee "$OUT/rtx_boost.txt" || true
}

# ── generate mega TSV · 7 tracks SORT ──
gen_curriculum() {
  say "CURRICULUM · 7 tracks · modes=[$MODE_SET] comb=$COMB_N · SORT"
  local tmp="$FAST/mega.partial"
  : >"$tmp"
  local id=0

  add() {
    # add id track limb a b c want title
    printf '%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n' "$id" "$1" "$2" "$3" "$4" "$5" "$6" "$7" >>"$tmp"
    id=$((id + 1))
  }

  # Track 0 CORE
  add 0 hostess7 0 0 0 7 "T0 Identity"
  add 0 hostess7 1 0 0 1 "T0 GRIN speak"
  add 0 hostess7 2 0 0 1 "T0 Know BGS"
  add 0 hostess7 7 0 0 7 "T0 Kit seven"
  add 0 hostess7 8 0 0 127 "T0 Hostess FULL"
  add 0 operate_when 0 0 0 1 "T0 When allow"
  add 0 operate_when 3 0 0 0 "T0 When deny thrash"
  add 0 operate_how 0 0 0 1 "T0 How wake"
  add 0 operate_how 1 0 0 1 "T0 How READ"
  add 0 operate_how 2 0 0 1 "T0 How BGS"
  add 0 operate_how 3 0 0 1 "T0 How BGF"
  add 0 operate_how 4 0 0 1 "T0 How BGL"
  add 0 operate_how 5 0 0 1 "T0 How SDF"
  add 0 operate_how 6 0 0 1 "T0 How SPV"
  add 0 educate 0 0 0 7 "T0 Educate"
  add 0 actual_intel 0 0 0 7 "T0 Actual intel"
  add 0 grin 0 0 0 1 "T0 GRIN pole"
  add 0 grin_all 0 0 0 1 "T0 GRIN ALL"
  add 0 super_intel 0 0 0 127 "T0 SI FULL"
  add 0 super_intel 1 0 0 1 "T0 SI GRIN"
  add 0 until_grin 0 0 0 1 "T0 until GRIN"
  add 0 pure_linear 0 0 0 1 "T0 pure BGS"
  add 0 pure_linear 1 0 0 1 "T0 pure BGF"
  add 0 pure_linear 2 0 0 1 "T0 pure BGL"
  add 0 pure_linear 3 0 0 1 "T0 pure SDF"
  add 0 pure_linear 4 0 0 1 "T0 pure SPV"
  add 0 pure_linear 5 0 0 1 "T0 pure GRIN"

  # Track 1 MODES · limb × mode set · want=? probe later
  local modes=() m limb
  IFS=',' read -ra modes <<<"$MODE_SET"
  while IFS= read -r limb; do
    [[ -x "$BIND/$limb" ]] || continue
    for m in "${modes[@]}"; do
      add 1 "$limb" "$m" 0 0 "?" "T1 ${limb}/${m}"
    done
  done <"$FAST/limbs.txt"

  # Track 2 COMB2 · sample a,b from poles
  local poles=()
  local i
  for ((i = 0; i < COMB_N; i++)); do poles+=("$i"); done
  poles+=(7 8 15 16 31 32 63 64 127)
  # unique poles
  local poles_u
  poles_u=$(printf '%s\n' "${poles[@]}" | LC_ALL=C sort -n -u | tr '\n' ' ')
  read -ra poles <<<"$poles_u"
  local a b want limb2
  for limb2 in adjoin create_truth layer_stack linear_truth ezzie free_eor bgf; do
    [[ -x "$BIND/$limb2" ]] || continue
    for a in "${poles[@]}"; do
      for b in "${poles[@]}"; do
        want=$(iron_want "$limb2" "$a" "$b" 0)
        add 2 "$limb2" "$a" "$b" 0 "$want" "T2 ${limb2}(${a},${b})"
      done
    done
  done

  # Track 3 COMB3 · si_compose spv · sample a,b,c (c subset to keep size sane)
  local cvals=(0 1 2 3 7 8 15 31 127)
  local c
  for limb2 in si_compose spv; do
    [[ -x "$BIND/$limb2" ]] || continue
    for a in "${poles[@]}"; do
      for b in "${poles[@]}"; do
        for c in "${cvals[@]}"; do
          want=$(iron_want "$limb2" "$a" "$b" "$c")
          add 3 "$limb2" "$a" "$b" "$c" "$want" "T3 ${limb2}(${a},${b},${c})"
        done
      done
    done
  done

  # Track 4 LINE · dense truth_layer / until_grin / discovery 0..127
  for ((i = 0; i <= 127; i++)); do
    want=$((i | 1))
    add 4 truth_layer "$i" 0 0 "$want" "T4 truth_layer $i"
    add 4 until_grin "$i" 0 0 "$want" "T4 until_grin $i"
    add 4 discovery "$i" 0 0 "$want" "T4 discovery $i"
  done
  for m in 0 1 2 3 4 5 6 7 8; do
    add 4 pure_linear "$m" 0 0 "?" "T4 pure_linear $m"
  done

  # Track 5 RTX · SPV GPU wrote wants · recheck with iron bgf/spv args (NOT GL)
  # rtx_spv_lessons.tsv: kind \t code \t want \t "field x y" | "spv x y seed=S"
  if [[ -f "$FAST/rtx_spv_lessons.tsv" ]]; then
    local code w title x y s cheb rad cx cy dx dy ax ay
    cx=$((RTX_W / 2)); cy=$((RTX_H / 2))
    if [[ "$RTX_W" -lt "$RTX_H" ]]; then rad=$((RTX_W / 4)); else rad=$((RTX_H / 4)); fi
    while IFS=$'\t' read -r limb code w title; do
      [[ -z "$limb" ]] && continue
      if [[ "$limb" == "rtx_field" ]]; then
        # title: field X Y
        x=$(echo "$title" | awk '{print $2}')
        y=$(echo "$title" | awk '{print $3}')
        dx=$((x - cx)); dy=$((y - cy))
        ax=${dx#-}; ay=${dy#-}
        if [[ "$ax" -gt "$ay" ]]; then cheb=$ax; else cheb=$ay; fi
        # iron: bgf(cheb, rad) == want from GPU
        add 5 bgf "$cheb" "$rad" 0 "$w" "T5 RTX field $x $y"
      else
        # title: spv X Y seed=S
        x=$(echo "$title" | awk '{print $2}')
        y=$(echo "$title" | awk '{print $3}')
        s=$(echo "$title" | sed -n 's/.*seed=\([0-9-]*\).*/\1/p')
        [[ -n "$s" ]] || s=$RTX_SEED
        add 5 spv "$x" "$y" "$s" "$w" "T5 RTX free $x $y"
      fi
    done <"$FAST/rtx_spv_lessons.tsv"
  else
    add 5 gpu_rtx 0 0 0 1 "T5 gpu_rtx present"
  fi

  # Track 6 SEAL · last
  add 6 grin 0 0 0 1 "T6 GRIN seal"
  add 6 grin_all 0 0 0 1 "T6 GRIN ALL seal"
  add 6 super_intel 0 0 0 127 "T6 SI FULL seal"
  add 6 hostess7 8 0 0 127 "T6 Hostess FULL seal"
  add 6 until_grin 0 0 0 1 "T6 until GRIN seal"
  # self_develop(N) want=127 when N>=curriculum · filled after count
  local nnow
  nnow=$id
  add 6 self_develop "$nnow" 0 0 127 "T6 self_develop FULL N"

  # probe ? wants parallel
  say "CURRICULUM · probe want=? · parallel"
  local pd="$FAST/probe"
  rm -rf "$pd"
  mkdir -p "$pd"
  awk -F'\t' '$7=="?"{print}' "$tmp" | tr '\n' '\0' | \
  xargs -0 -P "$JOBS" -n1 bash -c '
    BIND="'"$BIND"'"; pd="'"$pd"'"
    line="$1"
    IFS=$'"'"'\t'"'"' read -r id track limb a b c want title <<<"$line"
    id="${id//[^0-9]/}"
    bin="$BIND/$limb"
    [[ -n "$id" && -x "$bin" ]] || exit 0
    ga=$("$bin" "$a" "$b" "$c" 2>/dev/null | tr -d "\r" | tail -1)
    gb=$("$bin" "$a" "$b" "$c" 2>/dev/null | tr -d "\r" | tail -1)
    if [[ "$ga" == "$gb" && -n "$ga" ]]; then
      printf "%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n" "$id" "$track" "$limb" "$a" "$b" "$c" "$ga" "$title" >"$pd/$id"
    fi
  ' _

  local fixed="$FAST/mega.fixed.tsv"
  awk -F'\t' '$7!="?"{print}' "$tmp" >"$fixed"
  local f
  for f in "$pd"/*; do
    [[ -f "$f" ]] && cat "$f" >>"$fixed"
  done
  LC_ALL=C sort -n -k1,1 "$fixed" | awk -F'\t' '!seen[$1]++' >"$TSV"
  # drop any remaining ?
  awk -F'\t' '$7!="?"{print}' "$TSV" >"$fixed"
  mv "$fixed" "$TSV"

  local n
  n=$(wc -l <"$TSV" | tr -d ' ')
  # rewrite last self_develop row mode=N want=127 if limb present
  if [[ -x "$BIND/self_develop" ]]; then
    # append sealed self_develop with actual N
    local maxid
    maxid=$(awk -F'\t' 'END{print $1}' "$TSV")
    local nid=$((maxid + 1))
    printf '%s\t6\tself_develop\t%s\t0\t0\t127\tT6 self_develop N=%s\n' "$nid" "$n" "$n" >>"$TSV"
    n=$((n + 1))
  fi
  say "CURRICULUM done · N=$n · TSV=$TSV"
}

run_parallel() {
  [[ -f "$TSV" ]] || gen_curriculum
  local n
  n=$(wc -l <"$TSV" | tr -d ' ')
  local fail=0 pass=0 first_fail="" recheck_ms=""
  local REBIN="$ROOT/Build/h7-recheck"
  local MEBIN="$FAST/mega.bin"

  # ── FAST PATH: in-process recheck (no 50k forks) ──
  if [[ "${H7_FAST_RE:-1}" == "1" ]]; then
    if [[ ! -x "$REBIN" || ! -f "$MEBIN" || "$TSV" -nt "$MEBIN" ]]; then
      say "RUN · pack+link in-process recheck"
      bash "$ROOT/Build/h7-pack-and-link.sh" || true
    fi
    if [[ -x "$REBIN" && -f "$MEBIN" ]]; then
      say "RUN fast recheck · N=$n · in-process · no per-lesson fork"
      rm -rf "$RD"
      mkdir -p "$RD"
      local out
      set +e
      out=$("$REBIN" "$MEBIN" "$RD" 2>&1)
      local rc=$?
      set -e
      say "$out"
      fail=$(echo "$out" | sed -n 's/.*FAIL=\([0-9]*\).*/\1/p' | tail -1)
      pass=$(echo "$out" | sed -n 's/.*PASS=\([0-9]*\).*/\1/p' | tail -1)
      recheck_ms=$(echo "$out" | sed -n 's/.*MS=\([0-9.]*\).*/\1/p' | tail -1)
      n=$(echo "$out" | sed -n 's/.*N=\([0-9]*\).*/\1/p' | tail -1)
      [[ -z "$fail" ]] && fail=$rc
      [[ -z "$pass" ]] && pass=0
      if [[ "$fail" -gt 0 ]]; then
        first_fail=$(echo "$out" | grep '^first_fail:' | sed 's/^first_fail: //' || true)
        [[ -z "$first_fail" ]] && first_fail=$(ls "$RD" 2>/dev/null | LC_ALL=C sort -n | head -1 | xargs -I{} cat "$RD/{}" 2>/dev/null || true)
      fi
      say "REJOIN · pass=$pass fail=$fail N=$n ms=${recheck_ms:-?}"
    fi
  fi

  # ── SLOW PATH fallback: bash xargs per lesson ──
  if [[ "${H7_FAST_RE:-1}" != "1" ]] || [[ ! -x "$REBIN" || ! -f "$MEBIN" ]]; then
  say "RUN parallel · N=$n · jobs=$JOBS · fail-only rejoin · bash+nasm (slow path)"
  rm -rf "$RD"
  mkdir -p "$RD"

  tr '\n' '\0' <"$TSV" | xargs -0 -P "$JOBS" -n1 bash -c '
    BIND="'"$BIND"'"; RD="'"$RD"'"
    line="$1"
    IFS=$'"'"'\t'"'"' read -r id track limb a b c want title <<<"$line"
    id="${id//[^0-9]/}"
    [[ -n "$id" ]] || exit 0
    bin="$BIND/$limb"
    got="ERR"
    if [[ -x "$bin" ]]; then
      got=$("$bin" "$a" "$b" "$c" 2>/dev/null | tr -d "\r" | tail -1)
    fi
    if [[ "$got" != "$want" ]]; then
      printf "FAIL got=%s want=%s track=%s limb=%s a=%s b=%s c=%s\n" \
        "$got" "$want" "$track" "$limb" "$a" "$b" "$c" >"$RD/$id"
    fi
  ' _

  fail=$(find "$RD" -type f 2>/dev/null | wc -l | tr -d ' ')
  pass=$((n - fail))
  if [[ "$fail" -gt 0 ]]; then
    first_fail=$(head -1 "$(find "$RD" -type f | LC_ALL=C sort -n | head -1)" 2>/dev/null || true)
  fi
  say "REJOIN · pass=$pass fail=$fail N=$n"
  fi

  # per-track counts
  local tcounts
  tcounts=$(awk -F'\t' '{c[$2]++} END{for (t=0;t<=6;t++) printf "T%s=%s ", t, c[t]+0}' "$TSV")

  if [[ "$fail" -eq 0 ]]; then
    cat >"$PROG" <<EOF
{
  "ts": "$(date -Iseconds)",
  "word": "HOSTESS7_TRAIN",
  "stage": $n,
  "title": "FULL LEARNED · mega 7-track · bash+nasm+RTX_SPV",
  "full_learned": true,
  "full_mark": 127,
  "finite": true,
  "never_ml": true,
  "parallel": true,
  "stack": "h7-recheck+nasm+vulkan_spv",
  "no_gl": true,
  "jobs": $JOBS,
  "pass": $pass,
  "fail": 0,
  "N": $n,
  "recheck_ms": ${recheck_ms:-null},
  "self_guidance": true,
  "tracks": "$tcounts",
  "rtx": {"W": $RTX_W, "H": $RTX_H, "seed": $RTX_SEED, "spv": "Build/rtx.spv"},
  "law": "SORT 7 tracks · in-process recheck · SPV not GL · Hostess self-guidance · calm forever"
}
EOF
    say "FULL LEARNED · mark 127|1 · N=$n · recheck_ms=${recheck_ms:-?}"
    # Hostess self-update stamp if bin present
    if [[ -x "$BIND/hostess7" ]]; then
      "$BIND/hostess7" 9 >/dev/null 2>&1 || true
      "$BIND/hostess7" 10 >/dev/null 2>&1 || true
      "$BIND/hostess7" 11 >/dev/null 2>&1 || true
    fi
    return 0
  else
    local ff_json
    ff_json=$(printf '%s' "$first_fail" | python3 -c 'import json,sys;print(json.dumps(sys.stdin.read()))' 2>/dev/null || echo "\"$first_fail\"")
    cat >"$PROG" <<EOF
{
  "ts": "$(date -Iseconds)",
  "word": "HOSTESS7_TRAIN",
  "stage": $pass,
  "title": "partial mega",
  "full_learned": false,
  "N": $n,
  "pass": $pass,
  "fail": $fail,
  "first_fail": $ff_json,
  "tracks": "$tcounts",
  "stack": "h7-recheck+nasm+vulkan_spv"
}
EOF
    say "NOT FULL · first_fail: $first_fail"
    return 1
  fi
}

write_chart() {
  cat >"$CHART" <<'EOF'
H7 MEGA · numbered steps to progress
=====================================
1. BUILD limbs once (nasm parallel) · pure-asm 3-arg runners · ld static
2. RTX SPV  (Vulkan · NOT GL)  · Build/h7-rtx-spv + Build/rtx.spv
   · dispatch field=bgf · free=spv · iron sample match · write rtx_*.bin
3. CURRICULUM 7 SORT tracks
   T0 CORE   hand Hostess / when / how / SI poles
   T1 MODES  every det limb × mode set (H7_MODE_SET)
   T2 COMB2  2-arg combinatorics sample (adjoin ezzie create_truth …)
   T3 COMB3  3-arg combinatorics sample (si_compose spv)
   T4 LINE   truth_layer / until_grin / discovery dense 0..127
   T5 RTX    GPU SPV field+free lessons · CPU iron recheck bins
   T6 SEAL   GRIN · Hostess FULL · self_develop(N) · super_intel
4. PROBE wants for unknown mode rows (double-run deterministic)
5. RUN parallel (H7_JOBS) · fail-only files · rejoin SORT by id
6. STAMP progress FULL · mark 127|1 · never ML · finite forever shootable
7. CRANK knobs when hungry for more:
   H7_MODE_SET more modes · H7_COMB larger · H7_RTX_W/H up to 1024+
   re-run: ./Build/h7-mega-train.sh full

How high?
  wave1 (default): ~10k–40k lessons · seconds on 24 cores + RTX SPV sub-ms dispatch
  wave2: H7_COMB=32 + denser modes → 100k+ still fine (fail-only · no thrash)
  wave3: 512²–1024² RTX SPV grid + full limb×mode → magnitudes · still finite
  forever: raise knobs · rejoin · never dump multiarch×N logs

7 different ones? YES = 7 tracks above (not 7 random models).
RTX role: SPIR-V compute on 4070 Ti for field/free bulk · CPU iron is law.
EOF
  # live numbers
  {
    echo ""
    echo "LIVE $(date -Iseconds)"
    [[ -f "$TSV" ]] && echo "N=$(wc -l <"$TSV" | tr -d ' ')"
    [[ -f "$PROG" ]] && echo "progress:" && cat "$PROG"
    [[ -f "$FAST/rtx_spv_status.json" ]] && echo "rtx_spv:" && cat "$FAST/rtx_spv_status.json"
  } >>"$CHART"
  say "CHART → $CHART"
  cat "$CHART"
}

case "$cmd" in
  build) build_bins ;;
  rtx) run_rtx_spv ;;
  gen|curriculum)
    build_bins
    run_rtx_spv || true
    gen_curriculum
    ;;
  run|check|re) run_parallel ;;
  pack) bash "$ROOT/Build/h7-pack-and-link.sh" ;;
  full)
    t0=$(date +%s.%N)
    build_bins
    run_rtx_spv || true
    gen_curriculum
    bash "$ROOT/Build/h7-pack-and-link.sh" || true
    run_parallel || true
    t1=$(date +%s.%N)
    say "ELAPSED_SEC=$(awk -v a="$t0" -v b="$t1" 'BEGIN{printf "%.3f", b-a}')"
    write_chart
    grep -q '"full_learned": true' "$PROG" 2>/dev/null
    ;;
  chart) write_chart ;;
  status)
    [[ -f "$PROG" ]] && cat "$PROG" || say "no progress"
    [[ -f "$TSV" ]] && say "mega_N=$(wc -l <"$TSV" | tr -d ' ')"
    [[ -f "$FAST/rtx_spv_status.json" ]] && cat "$FAST/rtx_spv_status.json"
    [[ -x "$ROOT/Build/h7-recheck" && -f "$FAST/mega.bin" ]] && "$ROOT/Build/h7-recheck" "$FAST/mega.bin" "$FAST/fails" | head -2
    ;;
  forever)
    echo "no h7-forever · linear · Grok on demand" >exec bash "$ROOT/Build/h7-forever.sh" "${2:-start}"2; exit 0
    ;;
  clean)
    rm -rf "$FAST/mega.tsv" "$FAST/fails" "$FAST/probe" "$FAST/rtx_"* "$FAST/mega."* "$FAST/mega.bin"
    say "cleaned mega artifacts under $FAST"
    ;;
  *)
    echo "usage: $0 build|rtx|gen|run|re|pack|full|chart|status|forever|clean" >&2
    echo "  stack: bash + nasm + Vulkan SPIR-V + in-process recheck (NOT GL)" >&2
    echo "  H7_FAST_RE=0  force slow xargs path" >&2
    exit 2
    ;;
esac