fridge_m setup: chunked_runner + run_gen_chunk + check_mismatch + push_watchdog

fridge_m/_setup/scripts/check_mismatch.py

@@ -0,0 +1,129 @@
+"""Assert per-traj T (h5 qpos length) == exo_mp4_frames == wrist_mp4_frames
+for every traj in a chunk's sim dir. Exit 0 if clean, 1 with a per-traj
+report otherwise.
+
+This is the primary lock-contention canary for the chunked pipeline. If
+this exits non-zero, treat it as a build-stopping bug (NOT a "drop these
+trajs and continue") — fix the upstream sim before launching gen on this
+chunk.
+"""
+from __future__ import annotations
+
+import argparse
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+import h5py
+
+
+_EXO_RE = re.compile(r"^episode_(\d{8})_exo_camera_1_robot_rgb(?P<suffix>_batch_(\d+)_of_(\d+)(?:_[A-Za-z0-9_]+)?)\.mp4$")
+
+
+def mp4_frame_count(path: Path) -> int:
+    out = subprocess.run(
+        [
+            "ffprobe", "-v", "error",
+            "-select_streams", "v:0",
+            "-count_frames",
+            "-show_entries", "stream=nb_read_frames",
+            "-of", "default=nokey=1:noprint_wrappers=1",
+            str(path),
+        ],
+        capture_output=True, text=True, check=False,
+    )
+    if out.returncode != 0:
+        return -1
+    s = out.stdout.strip()
+    return int(s) if s.isdigit() else -1
+
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument("--sim_dir", required=True)
+    args = p.parse_args()
+    sim_dir = Path(args.sim_dir)
+
+    if not sim_dir.exists():
+        print(f"ERROR: sim_dir does not exist: {sim_dir}", file=sys.stderr)
+        sys.exit(1)
+
+    # Enumerate trajs from the exo mp4s (lock-safe, doesn't touch h5).
+    items = []  # (shard, ep_idx, suffix, h5_path)
+    h5_cache: dict[Path, h5py.File] = {}
+    try:
+        for f in sorted(sim_dir.iterdir()):
+            if not f.is_file():
+                continue
+            m = _EXO_RE.match(f.name)
+            if not m:
+                continue
+            ep = int(m.group(1))
+            suffix = m.group("suffix")
+            shard = m.group(3)
+            total = m.group(4)
+            h5_path = sim_dir / f"trajectories_batch_{shard}_of_{total}_cam_rand.h5"
+            items.append((shard, ep, suffix, h5_path))
+
+        if not items:
+            print(f"WARN: no trajs found in {sim_dir}; treating as clean (empty chunk).")
+            sys.exit(0)
+
+        print(f"checking {len(items)} trajs in {sim_dir}")
+        mismatches = []
+        for shard, ep, suffix, h5_path in items:
+            exo_mp4 = sim_dir / f"episode_{ep:08d}_exo_camera_1_robot_rgb{suffix}.mp4"
+            wrist_mp4 = sim_dir / f"episode_{ep:08d}_wrist_camera_robot_rgb{suffix}.mp4"
+            if not exo_mp4.exists() or not wrist_mp4.exists():
+                mismatches.append((shard, ep, "missing_mp4", "-", "-", "-"))
+                continue
+            if h5_path not in h5_cache:
+                if not h5_path.exists():
+                    mismatches.append((shard, ep, "missing_h5", str(h5_path), "-", "-"))
+                    continue
+                h5_cache[h5_path] = h5py.File(h5_path, "r")
+            f = h5_cache[h5_path]
+            traj_key = None
+            # Trajs in the h5 are named traj_<idx>; idx is the per-shard local index
+            # (not the global ep id). The cleanest map is "exo mp4 list ordered by ep
+            # matches the traj_N list ordered by N". Both are produced in sync by
+            # the writer.
+            shard_eps = sorted([e for s, e, *_ in items if s == shard])
+            try:
+                local_idx = shard_eps.index(ep)
+                traj_key = f"traj_{local_idx}"
+            except ValueError:
+                mismatches.append((shard, ep, "ep_not_in_shard_list", "-", "-", "-"))
+                continue
+            if traj_key not in f:
+                mismatches.append((shard, ep, "h5_traj_missing", traj_key, "-", "-"))
+                continue
+            qpos = f[traj_key].get("obs/agent/qpos")
+            if qpos is None:
+                mismatches.append((shard, ep, "qpos_missing", traj_key, "-", "-"))
+                continue
+            T = int(qpos.shape[0])
+            ef = mp4_frame_count(exo_mp4)
+            wf = mp4_frame_count(wrist_mp4)
+            if not (T == ef == wf):
+                mismatches.append((shard, ep, "len_mismatch", T, ef, wf))
+
+        if not mismatches:
+            print(f"OK: all {len(items)} trajs in {sim_dir} have T == exo == wrist")
+            sys.exit(0)
+        print(f"\nMISMATCH ({len(mismatches)}/{len(items)}):")
+        print(f"{'shard':5s} {'ep':>10s} {'kind':<22s} {'T':>6s} {'exo':>6s} {'wrist':>6s}")
+        for shard, ep, kind, T, ef, wf in mismatches:
+            print(f"{shard:5s} {ep:>10d} {kind:<22s} {str(T):>6s} {str(ef):>6s} {str(wf):>6s}")
+        sys.exit(1)
+    finally:
+        for f in h5_cache.values():
+            try:
+                f.close()
+            except Exception:
+                pass
+
+
+if __name__ == "__main__":
+    main()

fridge_m/_setup/scripts/chunked_runner.sh

@@ -0,0 +1,132 @@
+#!/bin/bash
+# Sequential-per-chunk fridge_m pipeline orchestrator for viscam3 (4x RTX 3090).
+#
+# Per chunk:
+#   1. Launch 4 sim shards on GPUs 0-3, writing to sim_chunks/chunk_NNN/.
+#   2. Wait for all 4 sim shards to exit (releases h5 locks).
+#   3. Run check_mismatch.py on the chunk; abort on mismatch.
+#   4. Run run_gen_chunk.py on the chunk using ALL 4 GPUs (since on viscam3 we
+#      can't afford to dedicate any GPU to a concurrent next-chunk sim).
+#   5. Move on to next chunk.
+#
+# Env vars (with defaults):
+#   ROOT             -> /scr/ravenh/fridge_m
+#   NUM_CHUNKS       -> 12  (chunk yields ~45 trajs each so 12 * 45 ~= 540 trajs)
+#   SAMPLES_PER_HOUSE-> 3
+#   SEED_BASE        -> 30000  (sim seed = SEED_BASE + chunk_idx*100 + shard)
+#   GPUS             -> "0,1,2,3"
+#   START_CHUNK      -> 1  (set higher to resume; existing dirs are skipped)
+#   STOP_AT_TRAJS    -> 500  (orchestrator exits once #trajs in sim_chunks >= this)
+#
+set -uo pipefail
+
+ROOT="${ROOT:-/scr/ravenh/fridge_m}"
+NUM_CHUNKS="${NUM_CHUNKS:-12}"
+SAMPLES_PER_HOUSE="${SAMPLES_PER_HOUSE:-3}"
+SEED_BASE="${SEED_BASE:-30000}"
+GPUS="${GPUS:-0,1,2,3}"
+START_CHUNK="${START_CHUNK:-1}"
+STOP_AT_TRAJS="${STOP_AT_TRAJS:-500}"
+
+REPO_MOLMO=/svl/u/ravenh/renderscale/molmospaces
+SIM_CHUNKS="$ROOT/sim_chunks"
+GEN_CHUNKS="$ROOT/gen_chunks"
+SCRATCH_GEN="$ROOT/_workdir_gen"
+LOGS="$ROOT/logs"
+SCRIPTS="$ROOT/scripts"
+mkdir -p "$SIM_CHUNKS" "$GEN_CHUNKS" "$SCRATCH_GEN" "$LOGS"
+
+CONDA_SH=/svl/u/ravenh/miniconda3/etc/profile.d/conda.sh
+# Inherit the conda env from the parent shell (mlspaces).
+source "$CONDA_SH"
+conda activate mlspaces
+
+# data_gen_fridge_m.sh passes `--camera_extrinsics scripts/datagen/picked_camera_extrinsics.json`
+# (a relative path that run_pipeline.py opens directly), so all sim shards must
+# run with cwd=$REPO_MOLMO. Without this, every shard dies with FileNotFoundError
+# and the orchestrator burns through chunks at ~30s/chunk doing nothing.
+cd "$REPO_MOLMO"
+
+# Tee everything to the runner log.
+exec > >(stdbuf -oL tee -a "$LOGS/chunked_runner.log") 2>&1
+
+echo "=========================================="
+echo "[chunked_runner] start $(date -Iseconds)"
+echo "  ROOT=$ROOT NUM_CHUNKS=$NUM_CHUNKS SPH=$SAMPLES_PER_HOUSE SEED_BASE=$SEED_BASE"
+echo "  GPUS=$GPUS START_CHUNK=$START_CHUNK STOP_AT_TRAJS=$STOP_AT_TRAJS"
+echo "=========================================="
+
+count_sim_trajs() {
+  # globs across all chunks
+  find "$SIM_CHUNKS" -maxdepth 2 -name 'episode_*_exo_camera_1_robot_rgb*.mp4' 2>/dev/null | wc -l
+}
+
+for ((n=START_CHUNK; n<=NUM_CHUNKS; n++)); do
+  CHUNK_DIR="$SIM_CHUNKS/chunk_$(printf '%03d' $n)"
+  GEN_DIR="$GEN_CHUNKS/chunk_$(printf '%03d' $n)"
+  CHUNK_SCRATCH="$SCRATCH_GEN/chunk_$(printf '%03d' $n)"
+  mkdir -p "$CHUNK_DIR" "$GEN_DIR" "$CHUNK_SCRATCH"
+
+  current=$(count_sim_trajs)
+  echo ""
+  echo "=== chunk $n / $NUM_CHUNKS   (current_sim_trajs=$current target=$STOP_AT_TRAJS) ==="
+  if [ "$current" -ge "$STOP_AT_TRAJS" ]; then
+    echo "[chunked_runner] target reached; exiting outer loop."
+    break
+  fi
+
+  # --- Step 1: launch 4 sim shards on GPUs 0-3, write to chunk dir ---
+  echo "[chunked_runner] step1: launching 4 sim shards -> $CHUNK_DIR"
+  declare -a SIM_PIDS=()
+  for s in 1 2 3 4; do
+    GPU=$((s - 1))
+    SEED=$((SEED_BASE + n*100 + s))
+    LOG="$LOGS/sim_chunk_$(printf '%03d' $n)_shard_${s}.log"
+    CUDA_VISIBLE_DEVICES=$GPU OUTPUT_DIR="$CHUNK_DIR" SAMPLES_PER_HOUSE="$SAMPLES_PER_HOUSE" \
+      nohup bash "$REPO_MOLMO/scripts/datagen/data_gen_fridge_m.sh" "$s" 4 "$SEED" \
+      > "$LOG" 2>&1 &
+    SIM_PIDS+=($!)
+    echo "  shard $s/4 GPU=$GPU SEED=$SEED PID=$! log=$LOG"
+  done
+
+  # --- Step 2: wait for all 4 sim shards to exit ---
+  echo "[chunked_runner] step2: waiting for sim shards to exit..."
+  for pid in "${SIM_PIDS[@]}"; do
+    if ! wait "$pid"; then
+      echo "[chunked_runner] WARN: sim shard PID $pid exited non-zero"
+    fi
+  done
+  echo "[chunked_runner] all sim shards for chunk $n exited"
+
+  # --- Step 3: check mismatch ---
+  echo "[chunked_runner] step3: check_mismatch.py on chunk $n"
+  if ! python "$SCRIPTS/check_mismatch.py" --sim_dir "$CHUNK_DIR"; then
+    echo "[chunked_runner] FATAL: mismatch in chunk $n -> aborting orchestrator. Inspect $CHUNK_DIR before continuing."
+    exit 2
+  fi
+
+  # --- Step 4: gen on all 4 GPUs (sequential per chunk) ---
+  CHUNK_TRAJ_COUNT=$(find "$CHUNK_DIR" -maxdepth 1 -name 'episode_*_exo_camera_1_robot_rgb*.mp4' 2>/dev/null | wc -l)
+  echo "[chunked_runner] step4: gen on chunk $n ($CHUNK_TRAJ_COUNT trajs) using GPUs=$GPUS"
+  SEQ_OFFSET=$((n*100))
+  if ! python "$SCRIPTS/run_gen_chunk.py" \
+      --sim_src "$CHUNK_DIR" \
+      --out_dir "$GEN_DIR" \
+      --scratch "$CHUNK_SCRATCH" \
+      --gpus "$GPUS" \
+      --seq_offset "$SEQ_OFFSET" 2>&1 | stdbuf -oL tee "$LOGS/gen_chunk_$(printf '%03d' $n).log"; then
+    echo "[chunked_runner] WARN: gen chunk $n exited non-zero (some trajs may have failed; continuing)"
+  fi
+  echo "[chunked_runner] step4: gen chunk $n done"
+
+  # Free per-chunk scratch tmps to save disk (depth + inf_tmp are reproducible).
+  rm -rf "$CHUNK_SCRATCH/_inf_tmp" 2>/dev/null || true
+done
+
+final_sim=$(count_sim_trajs)
+final_gen=$(find "$GEN_CHUNKS" -maxdepth 2 -name 'generated_episode_*_exo_camera_1*.mp4' 2>/dev/null | wc -l)
+echo ""
+echo "=========================================="
+echo "[chunked_runner] DONE $(date -Iseconds)"
+echo "  final_sim_trajs=$final_sim final_gen_trajs=$final_gen"
+echo "=========================================="

fridge_m/_setup/scripts/final_flush.py

@@ -0,0 +1,85 @@
+"""Final HF flush for the fridge_m chunked run on viscam3.
+
+Uploads:
+  - /scr/ravenh/fridge_m/sim_chunks   -> Ravenh97/sim_data:fridge_m (INCL. h5)
+  - /scr/ravenh/fridge_m/gen_chunks   -> Ravenh97/generated_video:fridge_m
+  - /scr/ravenh/fridge_m/prompts      -> Ravenh97/generated_video:fridge_m/prompts (setup record)
+  - /scr/ravenh/fridge_m/scripts      -> Ravenh97/sim_data:fridge_m/scripts (setup record)
+
+Patches DEFAULT_REQUEST_TIMEOUT=300 because commits with hundreds of files (esp.
+the h5 batch) hit the default 10s ReadTimeout otherwise.
+"""
+from __future__ import annotations
+
+import time
+import huggingface_hub.constants as _hf_constants
+_hf_constants.DEFAULT_REQUEST_TIMEOUT = 600  # extra-generous for the h5-heavy push
+
+from huggingface_hub import HfApi  # noqa: E402
+
+
+SCRATCH_PATTERNS = [
+    "_workdir/**", "_workdir_gen/**", "_shard/**", "_inf_tmp/**",
+    "_depth_logs/**", "_depth/**",
+]
+
+
+def push(folder, repo_id, path_in_repo, msg, ignore_patterns):
+    api = HfApi()
+    api.create_repo(repo_id, repo_type="dataset", exist_ok=True)
+    t0 = time.time()
+    print(f"[final_flush] -> {repo_id}:{path_in_repo} (folder={folder})", flush=True)
+    print(f"[final_flush]   ignore_patterns={ignore_patterns}", flush=True)
+    api.upload_folder(
+        folder_path=str(folder),
+        repo_id=repo_id,
+        repo_type="dataset",
+        path_in_repo=path_in_repo,
+        ignore_patterns=ignore_patterns,
+        commit_message=msg,
+    )
+    print(f"[final_flush]   OK in {time.time()-t0:.1f}s", flush=True)
+
+
+def main():
+    # 1. sim_chunks (INCL. h5 files this time — durable backup)
+    push(
+        folder="/scr/ravenh/fridge_m/sim_chunks",
+        repo_id="Ravenh97/sim_data",
+        path_in_repo="fridge_m",
+        msg="fridge_m viscam3 FINAL flush at 300 trajs (incl. h5)",
+        ignore_patterns=SCRATCH_PATTERNS,
+    )
+
+    # 2. gen_chunks (mp4s + prompts + _logs; no h5 to worry about here)
+    push(
+        folder="/scr/ravenh/fridge_m/gen_chunks",
+        repo_id="Ravenh97/generated_video",
+        path_in_repo="fridge_m",
+        msg="fridge_m viscam3 FINAL flush at 300 trajs",
+        ignore_patterns=SCRATCH_PATTERNS,
+    )
+
+    # 3. prompts setup record (small; tells future readers what scene prompts were used)
+    push(
+        folder="/scr/ravenh/fridge_m/prompts",
+        repo_id="Ravenh97/generated_video",
+        path_in_repo="fridge_m/_setup/prompts",
+        msg="fridge_m setup: prompts.json",
+        ignore_patterns=[],
+    )
+
+    # 4. scripts setup record (so anyone can reproduce the chunked pipeline)
+    push(
+        folder="/scr/ravenh/fridge_m/scripts",
+        repo_id="Ravenh97/sim_data",
+        path_in_repo="fridge_m/_setup/scripts",
+        msg="fridge_m setup: chunked_runner + run_gen_chunk + check_mismatch + push_watchdog",
+        ignore_patterns=[],
+    )
+
+    print("[final_flush] DONE", flush=True)
+
+
+if __name__ == "__main__":
+    main()

fridge_m/_setup/scripts/push_watchdog.py

@@ -0,0 +1,133 @@
+"""HF push watchdog for fridge_m sim and gen chunked layouts.
+
+Polls a root dir, counts finalized trajs by globbing the exo-camera mp4
+pattern (lock-safe — never opens h5), and pushes to a HF subfolder every
+`--push_every` new trajs, up to `--max_target`. Skips *.h5 files during
+incremental pushes (too large to re-upload often); h5s get pushed once at
+the final flush.
+
+Patches `huggingface_hub.constants.DEFAULT_REQUEST_TIMEOUT=300` before
+importing HfApi so that commits with hundreds of files don't hit the
+default 10s ReadTimeout.
+"""
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+import time
+from pathlib import Path
+
+import huggingface_hub.constants as _hf_constants
+_hf_constants.DEFAULT_REQUEST_TIMEOUT = 300
+
+from huggingface_hub import HfApi  # noqa: E402
+
+
+def count_finalized(root: Path, kind: str) -> int:
+    """Count finalized trajs across chunked subdirs by globbing the exo-camera mp4.
+
+    kind = 'sim' counts `episode_*_exo_camera_1_robot_rgb*.mp4`.
+    kind = 'gen' counts `generated_episode_*_exo_camera_1*.mp4`.
+    """
+    if not root.exists():
+        return 0
+    if kind == "sim":
+        pat = "**/episode_*_exo_camera_1_robot_rgb*.mp4"
+    elif kind == "gen":
+        pat = "**/generated_episode_*_exo_camera_1*.mp4"
+    else:
+        raise ValueError(kind)
+    return sum(1 for _ in root.rglob(pat.replace("**/", "")) if True) + 0  # placeholder
+    # NB: replaced with proper rglob below
+
+
+def count_finalized_v2(root: Path, kind: str) -> int:
+    if not root.exists():
+        return 0
+    if kind == "sim":
+        return len(list(root.rglob("episode_*_exo_camera_1_robot_rgb*.mp4")))
+    elif kind == "gen":
+        return len(list(root.rglob("generated_episode_*_exo_camera_1*.mp4")))
+    else:
+        raise ValueError(kind)
+
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument("--root", required=True, help="local dir to push (rglob'd)")
+    p.add_argument("--repo_id", required=True, help="HF dataset repo, e.g. Ravenh97/sim_data")
+    p.add_argument("--path_in_repo", required=True, help="subfolder in repo to push under, e.g. fridge_m/sim")
+    p.add_argument("--kind", choices=["sim", "gen"], required=True)
+    p.add_argument("--push_every", type=int, default=50)
+    p.add_argument("--max_target", type=int, default=1000)
+    p.add_argument("--idle_exit_seconds", type=int, default=7200,
+                   help="exit cleanly if traj count has not increased for this long AND >= max_target")
+    p.add_argument("--poll_seconds", type=int, default=60)
+    args = p.parse_args()
+
+    root = Path(args.root)
+    api = HfApi()
+    try:
+        api.create_repo(args.repo_id, repo_type="dataset", exist_ok=True)
+    except Exception as exc:
+        print(f"[push_watchdog] create_repo warning: {exc}", flush=True)
+
+    last_pushed = 0
+    last_count = -1
+    last_change_t = time.time()
+    print(
+        f"[push_watchdog] root={root} repo={args.repo_id}:{args.path_in_repo} kind={args.kind} "
+        f"push_every={args.push_every} max_target={args.max_target}",
+        flush=True,
+    )
+    while True:
+        n = count_finalized_v2(root, args.kind)
+        if n != last_count:
+            print(f"[push_watchdog] count={n} last_pushed={last_pushed} target={args.max_target}", flush=True)
+            last_count = n
+            last_change_t = time.time()
+        # Threshold: push at multiples of push_every once we've passed that threshold.
+        threshold = ((n // args.push_every) * args.push_every)
+        if threshold > last_pushed and threshold > 0:
+            try:
+                t0 = time.time()
+                print(f"[push_watchdog] pushing at threshold {threshold} (count={n})...", flush=True)
+                api.upload_folder(
+                    folder_path=str(root),
+                    repo_id=args.repo_id,
+                    repo_type="dataset",
+                    path_in_repo=args.path_in_repo,
+                    ignore_patterns=["*.h5", "_workdir/**", "_workdir_gen/**", "_shard/**", "_inf_tmp/**", "_depth_logs/**", "_depth/**"],
+                    commit_message=f"fridge_m {args.kind} push at {threshold} trajs",
+                )
+                last_pushed = threshold
+                print(f"[push_watchdog] push at {threshold} OK in {time.time()-t0:.1f}s", flush=True)
+            except Exception as exc:
+                print(f"[push_watchdog] push at {threshold} FAILED: {exc}", flush=True)
+        # Final flush: when count >= max_target, do one more push that INCLUDES h5 files.
+        if n >= args.max_target and last_pushed >= ((args.max_target // args.push_every) * args.push_every):
+            print(f"[push_watchdog] doing FINAL flush (incl. h5) at count={n}...", flush=True)
+            try:
+                t0 = time.time()
+                api.upload_folder(
+                    folder_path=str(root),
+                    repo_id=args.repo_id,
+                    repo_type="dataset",
+                    path_in_repo=args.path_in_repo,
+                    ignore_patterns=["_workdir/**", "_workdir_gen/**", "_shard/**", "_inf_tmp/**", "_depth_logs/**", "_depth/**"],
+                    commit_message=f"fridge_m {args.kind} FINAL flush at {n} trajs (incl. h5)",
+                )
+                print(f"[push_watchdog] FINAL flush OK in {time.time()-t0:.1f}s; exiting.", flush=True)
+            except Exception as exc:
+                print(f"[push_watchdog] FINAL flush FAILED: {exc}", flush=True)
+            sys.exit(0)
+        # Idle exit (only after target reached so we don't kill the watchdog prematurely).
+        if n >= args.max_target and (time.time() - last_change_t) > args.idle_exit_seconds:
+            print(f"[push_watchdog] idle {args.idle_exit_seconds}s past target; exiting.", flush=True)
+            sys.exit(0)
+        time.sleep(args.poll_seconds)
+
+
+if __name__ == "__main__":
+    main()

fridge_m/_setup/scripts/run_gen_chunk.py

@@ -0,0 +1,378 @@
+"""Single-pass gen orchestrator for one fridge_m chunk.
+
+Adapted from Sim2RealGen_Video_Model/run_fridge_7.py for chunked layout:
+  - SIM_SRC, OUT_DIR, SCRATCH are CLI args (per-chunk).
+  - PROMPTS_JSON points at the local fridge_m prompts (kitchen, white/gray
+    wall, light yellow/white/gray floor, single stainless steel fridge).
+  - Single pass (no watch loop). Returns 0 only if all queued items produced
+    both ext1 and wrist generated mp4s; non-zero if any fail.
+  - Caller (chunked_runner.sh) is responsible for ensuring sim shards have
+    exited before invoking this — otherwise depth_methods.py acquires h5
+    shared locks while sim writers hold exclusive locks (the silent-data-loss
+    bug documented in datagen_pipeline_fridge_m.md gotcha #6).
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+
+REPO = Path("/svl/u/ravenh/renderscale/Sim2RealGen_Video_Model")
+LORA = REPO / "lora_ckpts/Wan2.1-Fun-V1.1-1.3B-DualControl-3View-PrevFrame_minimal_lora/step-4740.safetensors"
+PROMPTS_JSON = Path("/scr/ravenh/fridge_m/prompts/prompts.json")
+
+# Layout: 4 shards per chunk, shared output dir, suffix `_cam_rand`.
+# data_gen_fridge_m.sh defaults TOTAL_SHARDS=4 and SHARDS 1..4.
+SHARDS = [
+    (f"b{i}", "", f"trajectories_batch_{i}_of_4_cam_rand.h5", f"_batch_{i}_of_4_cam_rand")
+    for i in (1, 2, 3, 4)
+]
+
+_EXO_RGB_RE = re.compile(
+    r"^episode_(\d{8})_exo_camera_1_robot_rgb(?P<suffix>_batch_\d+_of_\d+(?:_[A-Za-z0-9_]+)?)\.mp4$"
+)
+
+
+def _load_prompts() -> tuple[list[str], str]:
+    d = json.loads(PROMPTS_JSON.read_text())
+    return d["scenes"], d["fixed_prefix"]
+
+
+def make_prompt(seq_idx: int, scenes: list[str], fixed_prefix: str) -> str:
+    s = scenes[seq_idx % len(scenes)]
+    return f"Video of a real {s}. {fixed_prefix}"
+
+
+def make_seed(seq_idx: int) -> int:
+    return 1000 + seq_idx * 13
+
+
+def list_trajs_from_disk(src_dir: Path, mp4_suffix: str) -> list[int]:
+    if not src_dir.exists():
+        return []
+    ids: list[int] = []
+    for f in src_dir.iterdir():
+        if not f.is_file():
+            continue
+        m = _EXO_RGB_RE.match(f.name)
+        if m and m.group("suffix") == mp4_suffix:
+            ids.append(int(m.group(1)))
+    return sorted(ids)
+
+
+def build_queue(sim_src: Path, target: int) -> list[tuple]:
+    queue: list[tuple] = []
+    for shard_id, _shard_rel_dir, h5_name, mp4_suffix in SHARDS:
+        idxs = list_trajs_from_disk(sim_src, mp4_suffix)
+        for idx in idxs:
+            ext_rgb = sim_src / f"episode_{idx:08d}_exo_camera_1_robot_rgb{mp4_suffix}.mp4"
+            wrist_rgb = sim_src / f"episode_{idx:08d}_wrist_camera_robot_rgb{mp4_suffix}.mp4"
+            if not (ext_rgb.exists() and wrist_rgb.exists()):
+                continue
+            queue.append((shard_id, h5_name, mp4_suffix, idx))
+            if target > 0 and len(queue) >= target:
+                return queue
+    return queue
+
+
+def shard_scratch_dir(scratch: Path, shard_id: str) -> Path:
+    return scratch / "_shard" / shard_id
+
+
+def shard_depth_root(scratch: Path, shard_id: str) -> Path:
+    return scratch / "_depth" / shard_id
+
+
+def _prepare_shard_workdir(
+    scratch: Path, sim_src: Path, shard_id: str, h5_name: str, mp4_suffix: str, episodes: list[int]
+) -> Path:
+    work = shard_scratch_dir(scratch, shard_id)
+    work.mkdir(parents=True, exist_ok=True)
+    src_h5 = sim_src / h5_name
+    link_h5 = work / h5_name
+    if not link_h5.exists() and src_h5.exists():
+        link_h5.symlink_to(src_h5)
+    for idx in episodes:
+        for cam in ("exo_camera_1", "wrist_camera"):
+            fn = f"episode_{idx:08d}_{cam}_robot_rgb{mp4_suffix}.mp4"
+            src_mp4 = sim_src / fn
+            if not src_mp4.exists():
+                continue
+            dst = work / fn
+            if not dst.exists():
+                dst.symlink_to(src_mp4)
+    return work
+
+
+def launch_depth_for_shard_async(
+    scratch: Path,
+    sim_src: Path,
+    shard_id: str,
+    h5_name: str,
+    mp4_suffix: str,
+    episodes: list[int],
+) -> subprocess.Popen | None:
+    work = shard_scratch_dir(scratch, shard_id)
+    if (work / "_depth_done").exists():
+        return None
+    _prepare_shard_workdir(scratch, sim_src, shard_id, h5_name, mp4_suffix, episodes)
+    out_root = shard_depth_root(scratch, shard_id)
+    out_root.mkdir(parents=True, exist_ok=True)
+    log = scratch / "_depth_logs" / f"{shard_id}.log"
+    log.parent.mkdir(parents=True, exist_ok=True)
+    cmd = [
+        sys.executable, str(REPO / "scripts/depth_methods.py"),
+        "--sim_dir", str(work),
+        "--out_root", str(out_root),
+        "--methods", "h5_v4",
+        "--method_label", "h5_v4",
+        "--use_raw_pct",
+        "--raw_pct", "1,99",
+        "--inv_clip", "1,20",
+        "--inv_map", "log",
+        "--depth_size", "416,240",
+        "--episodes", ",".join(str(i) for i in episodes),
+    ]
+    print(f"[depth-bg] {shard_id}: launching depth_methods.py for {len(episodes)} episodes (log {log})",
+          flush=True)
+    lf = open(log, "w")
+    popen = subprocess.Popen(cmd, stdout=lf, stderr=subprocess.STDOUT)
+    popen._log_handle = lf
+    popen._shard_id = shard_id
+    return popen
+
+
+def is_shard_depth_done(scratch: Path, shard_id: str) -> bool:
+    return (shard_scratch_dir(scratch, shard_id) / "_depth_done").exists()
+
+
+def output_paths(out_dir: Path, traj_idx: int, mp4_suffix: str) -> tuple[Path, Path]:
+    out_ext = out_dir / f"generated_episode_{traj_idx:08d}_exo_camera_1{mp4_suffix}.mp4"
+    out_wrist = out_dir / f"generated_episode_{traj_idx:08d}_wrist_camera{mp4_suffix}.mp4"
+    return out_ext, out_wrist
+
+
+def already_done(out_dir: Path, item) -> bool:
+    _shard_id, _h5_name, mp4_suffix, idx = item
+    out_ext, out_wrist = output_paths(out_dir, idx, mp4_suffix)
+    return out_ext.exists() and out_wrist.exists()
+
+
+def launch_inference(
+    scratch: Path,
+    out_dir: Path,
+    scenes: list[str],
+    fixed_prefix: str,
+    gpu: int,
+    seq_idx: int,
+    item,
+) -> subprocess.Popen:
+    shard_id, _h5_name, mp4_suffix, idx = item
+    depth_root = shard_depth_root(scratch, shard_id) / "h5_v4" / f"episode_{idx:08d}"
+    ext_depth = depth_root / "ext1" / "depth" / "original_depth.mp4"
+    ext_mask = depth_root / "ext1" / "mask" / "rgb_robot.mp4"
+    wrist_depth = depth_root / "wrist" / "depth" / "original_depth.mp4"
+    wrist_mask = depth_root / "wrist" / "mask" / "rgb_robot.mp4"
+    for p in (ext_depth, ext_mask, wrist_depth, wrist_mask):
+        if not p.exists():
+            raise RuntimeError(f"missing depth/mask file: {p}")
+
+    work = scratch / "_inf_tmp" / f"{shard_id}_ep{idx:08d}"
+    if work.exists():
+        shutil.rmtree(work)
+    work.mkdir(parents=True, exist_ok=True)
+
+    prompt = make_prompt(seq_idx, scenes, fixed_prefix)
+    seed = make_seed(seq_idx)
+
+    prompts_dir = out_dir / "prompts"
+    prompts_dir.mkdir(parents=True, exist_ok=True)
+    (prompts_dir / f"episode_{idx:08d}{mp4_suffix}.txt").write_text(
+        f"prompt: {prompt}\nseed: {seed}\nshard: {shard_id}\nseq_idx: {seq_idx}\n"
+    )
+
+    log_dir = out_dir / "_logs"
+    log_dir.mkdir(parents=True, exist_ok=True)
+    log = log_dir / f"{shard_id}_ep{idx:08d}.log"
+
+    env = {**os.environ, "CUDA_VISIBLE_DEVICES": str(gpu), "DIFFSYNTH_SKIP_DOWNLOAD": "true"}
+    cmd = [
+        sys.executable, str(REPO / "sim2realgen/inference_long_video.py"),
+        "--views",
+        f"ext1:{ext_depth}:{ext_mask}",
+        f"wrist:{wrist_depth}:{wrist_mask}",
+        "--prompt", prompt,
+        "--lora_path", str(LORA),
+        "--height", "240", "--width", "416",
+        "--clip_length", "81",
+        "--num_inference_steps", "30",
+        "--cfg_scale", "5.0",
+        "--seed", str(seed),
+        "--output_dir", str(work),
+    ]
+    lf = open(log, "w")
+    popen = subprocess.Popen(cmd, cwd=str(REPO), env=env, stdout=lf, stderr=subprocess.STDOUT)
+    popen._log_handle = lf
+    popen._work_dir = work
+    popen._gpu = gpu
+    popen._item = item
+    popen._seq_idx = seq_idx
+    return popen
+
+
+def finalize(popen, out_dir: Path) -> str:
+    rc = popen.poll()
+    popen._log_handle.close()
+    shard_id, _h5_name, mp4_suffix, idx = popen._item
+    work = popen._work_dir
+    if rc != 0:
+        return f"FAIL rc={rc} {shard_id} ep{idx:08d}"
+    out_ext, out_wrist = output_paths(out_dir, idx, mp4_suffix)
+    src_ext = work / "generated_ext1.mp4"
+    src_wrist = work / "generated_wrist.mp4"
+    if not (src_ext.exists() and src_wrist.exists()):
+        return f"FAIL no_outputs {shard_id} ep{idx:08d}"
+    out_dir.mkdir(parents=True, exist_ok=True)
+    shutil.move(str(src_ext), str(out_ext))
+    shutil.move(str(src_wrist), str(out_wrist))
+    shutil.rmtree(work, ignore_errors=True)
+    return f"OK {shard_id} ep{idx:08d} (gpu={popen._gpu} seq={popen._seq_idx})"
+
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument("--sim_src", required=True)
+    p.add_argument("--out_dir", required=True)
+    p.add_argument("--scratch", required=True)
+    p.add_argument("--gpus", default="0,1,2,3")
+    p.add_argument("--target", type=int, default=0,
+                   help="Max queue length (0 = all available). Useful for early-exit smoke runs.")
+    p.add_argument("--seq_offset", type=int, default=0,
+                   help="Add this to every seq_idx so prompts/seeds vary across chunks.")
+    args = p.parse_args()
+
+    sim_src = Path(args.sim_src)
+    out_dir = Path(args.out_dir)
+    scratch = Path(args.scratch)
+    out_dir.mkdir(parents=True, exist_ok=True)
+    scratch.mkdir(parents=True, exist_ok=True)
+    gpus = [int(x) for x in args.gpus.split(",") if x.strip()]
+
+    scenes, fixed_prefix = _load_prompts()
+    t0 = time.time()
+
+    queue = build_queue(sim_src, args.target)
+    print(f"queue length: {len(queue)} (sim_src={sim_src})", flush=True)
+    if not queue:
+        print("empty queue; nothing to do.", flush=True)
+        return 0
+
+    eps_per_shard: dict[str, tuple[str, str, list[int]]] = {}
+    for shard_id, h5_name, mp4_suffix, idx in queue:
+        if shard_id not in eps_per_shard:
+            eps_per_shard[shard_id] = (h5_name, mp4_suffix, [])
+        eps_per_shard[shard_id][2].append(idx)
+    print(f"shards: {[(s, len(v[2])) for s, v in eps_per_shard.items()]}", flush=True)
+
+    depth_procs: dict[str, subprocess.Popen] = {}
+    failed_depth_shards: set[str] = set()
+    depth_attempts: dict[str, int] = {}
+    MAX_DEPTH_ATTEMPTS = 3
+
+    def spawn_depth(shard_id: str):
+        h5_name, mp4_suffix, eps = eps_per_shard[shard_id]
+        eps_sorted = sorted(set(eps))
+        p = launch_depth_for_shard_async(scratch, sim_src, shard_id, h5_name, mp4_suffix, eps_sorted)
+        if p is not None:
+            depth_procs[shard_id] = p
+            depth_attempts[shard_id] = depth_attempts.get(shard_id, 0) + 1
+        else:
+            print(f"[depth-bg done] {shard_id} (already had _depth_done marker)", flush=True)
+
+    for shard_id in eps_per_shard:
+        spawn_depth(shard_id)
+
+    def reap_depth():
+        for shard_id, p in list(depth_procs.items()):
+            rc = p.poll()
+            if rc is None:
+                continue
+            p._log_handle.close()
+            del depth_procs[shard_id]
+            if rc == 0:
+                (shard_scratch_dir(scratch, shard_id) / "_depth_done").touch()
+                print(f"[depth-bg done] {shard_id} rc=0", flush=True)
+                continue
+            attempts = depth_attempts.get(shard_id, 1)
+            if attempts < MAX_DEPTH_ATTEMPTS:
+                print(f"[depth-bg retry {attempts}/{MAX_DEPTH_ATTEMPTS}] {shard_id} rc={rc}", flush=True)
+                spawn_depth(shard_id)
+            else:
+                failed_depth_shards.add(shard_id)
+                print(f"[depth-bg FAIL] {shard_id} rc={rc} after {attempts} attempts", flush=True)
+
+    in_flight: dict[int, subprocess.Popen] = {}
+    cursor = 0
+    n_ok = n_skip = n_fail = 0
+    while cursor < len(queue) or in_flight or depth_procs:
+        reap_depth()
+        # Skip already-done items.
+        while cursor < len(queue) and already_done(out_dir, queue[cursor]):
+            n_skip += 1
+            cursor += 1
+        # Skip items whose shard failed depth.
+        while cursor < len(queue) and queue[cursor][0] in failed_depth_shards:
+            print(f"[skip-depth-fail] cursor={cursor} {queue[cursor][0]} ep{queue[cursor][3]:08d}",
+                  flush=True)
+            n_fail += 1
+            cursor += 1
+        # Dispatch onto free GPUs.
+        for gpu in gpus:
+            if gpu in in_flight or cursor >= len(queue):
+                continue
+            item = queue[cursor]
+            if not is_shard_depth_done(scratch, item[0]):
+                break
+            try:
+                popen = launch_inference(
+                    scratch, out_dir, scenes, fixed_prefix, gpu, cursor + args.seq_offset, item,
+                )
+                in_flight[gpu] = popen
+                print(f"[launch gpu={gpu}] cursor={cursor} {item[0]} ep{item[3]:08d}", flush=True)
+            except Exception as exc:
+                print(f"[launch FAIL] {item}: {exc}", flush=True)
+                n_fail += 1
+            cursor += 1
+        progressed = False
+        for gpu, popen in list(in_flight.items()):
+            if popen.poll() is None:
+                continue
+            msg = finalize(popen, out_dir)
+            print(f"[done gpu={gpu}] {msg}", flush=True)
+            if msg.startswith("OK"):
+                n_ok += 1
+            else:
+                n_fail += 1
+            del in_flight[gpu]
+            progressed = True
+        if not progressed and (in_flight or depth_procs):
+            time.sleep(5)
+
+    dt = time.time() - t0
+    print(
+        f"\n== gen_chunk done sim_src={sim_src.name} out={out_dir.name} "
+        f"ok={n_ok} skip={n_skip} fail={n_fail} queue={len(queue)} elapsed={dt/60:.1f}min ==",
+        flush=True,
+    )
+    return 1 if n_fail else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

fridge_m/_setup/scripts/smoke_gen.sh

@@ -0,0 +1,111 @@
+#!/bin/bash
+# Smoke-test the gen pipeline for fridge_m on a single trajectory.
+#
+# Usage: bash smoke_gen.sh <GPU_ID>
+#   GPU_ID:   CUDA device for the inference (depth runs on the same GPU).
+#
+# Assumes:
+#   - sim output is in /scr/ravenh/fridge_m/smoke_sim/
+#   - prompts.json is at /scr/ravenh/fridge_m/prompts/prompts.json
+#
+# Outputs:
+#   - depth/mask mp4s under /scr/ravenh/fridge_m/smoke_gen/_depth/
+#   - generated_ext1.mp4, generated_wrist.mp4 under /scr/ravenh/fridge_m/smoke_gen/inf/
+#   - VRAM snapshots in /scr/ravenh/fridge_m/logs/smoke_gen_vram.csv
+#
+set -e
+GPU="${1:-1}"
+REPO=/svl/u/ravenh/renderscale/Sim2RealGen_Video_Model
+SIM_DIR=/scr/ravenh/fridge_m/smoke_sim
+GEN_BASE=/scr/ravenh/fridge_m/smoke_gen
+DEPTH_OUT="$GEN_BASE/_depth"
+INF_OUT="$GEN_BASE/inf"
+LOG_DIR=/scr/ravenh/fridge_m/logs
+LORA="$REPO/lora_ckpts/Wan2.1-Fun-V1.1-1.3B-DualControl-3View-PrevFrame_minimal_lora/step-4740.safetensors"
+
+mkdir -p "$DEPTH_OUT" "$INF_OUT" "$LOG_DIR"
+
+# Pick the first available exo-camera RGB mp4 (this is the unambiguous "traj finalized" signal).
+EXO_MP4=$(ls "$SIM_DIR"/episode_*_exo_camera_1_robot_rgb*.mp4 2>/dev/null | head -1)
+if [ -z "$EXO_MP4" ]; then
+  echo "ERROR: no exo-camera mp4 found in $SIM_DIR" >&2
+  exit 1
+fi
+EP=$(basename "$EXO_MP4" | sed -E 's/^episode_([0-9]{8})_.*/\1/')
+echo "[smoke_gen] using episode $EP from $SIM_DIR (GPU=$GPU)"
+
+source /svl/u/ravenh/miniconda3/etc/profile.d/conda.sh
+conda activate mlspaces
+
+# Background nvidia-smi VRAM polling (1s) until inference exits.
+VRAM_CSV="$LOG_DIR/smoke_gen_vram.csv"
+: > "$VRAM_CSV"
+(
+  while :; do
+    ts=$(date +%s)
+    nvidia-smi --query-gpu=index,memory.used --format=csv,noheader,nounits \
+      | awk -v ts=$ts '{print ts","$0}' >> "$VRAM_CSV"
+    sleep 1
+  done
+) &
+VRAM_PID=$!
+trap "kill $VRAM_PID 2>/dev/null || true" EXIT
+
+# --- Step 1: depth_methods.py ---
+echo "[smoke_gen] step 1/2 depth_methods.py"
+t0=$(date +%s)
+CUDA_VISIBLE_DEVICES="$GPU" python "$REPO/scripts/depth_methods.py" \
+  --sim_dir "$SIM_DIR" \
+  --out_root "$DEPTH_OUT" \
+  --methods h5_v4 \
+  --method_label h5_v4 \
+  --use_raw_pct \
+  --raw_pct 1,99 \
+  --inv_clip 1,20 \
+  --inv_map log \
+  --depth_size 416,240 \
+  --episodes "$EP" \
+  2>&1 | tee "$LOG_DIR/smoke_gen_depth.log"
+t1=$(date +%s)
+echo "[smoke_gen] depth_methods.py done in $((t1-t0))s"
+
+DEPTH_ROOT="$DEPTH_OUT/h5_v4/episode_$EP"
+EXT_DEPTH="$DEPTH_ROOT/ext1/depth/original_depth.mp4"
+EXT_MASK="$DEPTH_ROOT/ext1/mask/rgb_robot.mp4"
+WRIST_DEPTH="$DEPTH_ROOT/wrist/depth/original_depth.mp4"
+WRIST_MASK="$DEPTH_ROOT/wrist/mask/rgb_robot.mp4"
+for p in "$EXT_DEPTH" "$EXT_MASK" "$WRIST_DEPTH" "$WRIST_MASK"; do
+  [ -f "$p" ] || { echo "ERROR: missing $p" >&2; exit 1; }
+done
+
+# --- Step 2: inference_long_video.py ---
+# Pick the first prompt from prompts.json + fixed prefix.
+PROMPT=$(python -c "import json,sys; d=json.load(open('/scr/ravenh/fridge_m/prompts/prompts.json')); print(f'Video of a real {d[\"scenes\"][0]}. ' + d['fixed_prefix'])")
+echo "[smoke_gen] prompt: $PROMPT" | head -c 400
+echo ""
+echo "$PROMPT" > "$INF_OUT/prompt.txt"
+
+echo "[smoke_gen] step 2/2 inference_long_video.py"
+t2=$(date +%s)
+cd "$REPO"
+DIFFSYNTH_SKIP_DOWNLOAD=true CUDA_VISIBLE_DEVICES="$GPU" python "$REPO/sim2realgen/inference_long_video.py" \
+  --views \
+    "ext1:$EXT_DEPTH:$EXT_MASK" \
+    "wrist:$WRIST_DEPTH:$WRIST_MASK" \
+  --prompt "$PROMPT" \
+  --lora_path "$LORA" \
+  --height 240 --width 416 \
+  --clip_length 81 \
+  --num_inference_steps 30 \
+  --cfg_scale 5.0 \
+  --seed 1000 \
+  --output_dir "$INF_OUT" \
+  2>&1 | tee "$LOG_DIR/smoke_gen_inf.log"
+t3=$(date +%s)
+echo "[smoke_gen] inference done in $((t3-t2))s; total step2 wall=$((t3-t2))s"
+echo "[smoke_gen] outputs: $(ls -la $INF_OUT/*.mp4 2>/dev/null)"
+
+# Peak VRAM
+echo "[smoke_gen] peak VRAM (MiB) per GPU during run:"
+awk -F, '{vram[$2]=($3>vram[$2]?$3:vram[$2])} END{for (g in vram) printf "  GPU%s peak=%dMiB\n", g, vram[g]}' "$VRAM_CSV"
+echo "[smoke_gen] DONE depth=$((t1-t0))s inf=$((t3-t2))s total=$((t3-t0))s"

fridge_m/_setup/scripts/stop_after_chunk_6.sh

@@ -0,0 +1,44 @@
+#!/bin/bash
+# Watches chunked_runner.log for the chunk-7 launch line and stops the runner
+# before chunk 7 sim shards do any real work. Chunks 1..6 will be fully sim+gen
+# complete (the runner is sequential per chunk, so by the time the chunk-7 start
+# line appears, chunk 6's gen has fully finished).
+
+set -uo pipefail
+
+RUNNER_PID=${RUNNER_PID:-542661}
+LOG=/scr/ravenh/fridge_m/logs/chunked_runner.log
+STOP_AFTER_CHUNK=${STOP_AFTER_CHUNK:-6}
+
+NEXT=$((STOP_AFTER_CHUNK + 1))
+echo "[stop_watcher] watching $LOG for chunk-$NEXT launch (= chunks 1..$STOP_AFTER_CHUNK fully done); runner_pid=$RUNNER_PID"
+
+stdbuf -oL tail -n 1000 -F "$LOG" 2>/dev/null \
+  | stdbuf -oL grep -E --line-buffered "^=== chunk $NEXT / " \
+  | while IFS= read -r line; do
+    ts=$(date -Iseconds)
+    echo "[stop_watcher] TRIGGER at $ts: $line"
+    echo "[stop_watcher] SIGTERMing runner_pid=$RUNNER_PID"
+    kill -TERM "$RUNNER_PID" 2>/dev/null || true
+    sleep 1
+    echo "[stop_watcher] killing any newly-launched chunk-$NEXT sim shards (still in startup)"
+    pkill -TERM -f 'data_gen_fridge_m\.sh' 2>/dev/null || true
+    pkill -TERM -f 'run_pipeline_no_clip\.py' 2>/dev/null || true
+    sleep 5
+    pkill -KILL -f 'data_gen_fridge_m\.sh' 2>/dev/null || true
+    pkill -KILL -f 'run_pipeline_no_clip\.py' 2>/dev/null || true
+    # Remove the aborted chunk-N dir if it has 0 finalized trajs.
+    aborted="/scr/ravenh/fridge_m/sim_chunks/chunk_$(printf '%03d' $NEXT)"
+    if [ -d "$aborted" ]; then
+      n=$(ls "$aborted"/episode_*_exo_camera_1_robot_rgb*.mp4 2>/dev/null | wc -l)
+      echo "[stop_watcher] aborted chunk dir $aborted finalized=$n"
+      if [ "$n" = "0" ]; then
+        rm -rf "$aborted"
+        rm -rf "/scr/ravenh/fridge_m/gen_chunks/chunk_$(printf '%03d' $NEXT)"
+        rm -rf "/scr/ravenh/fridge_m/_workdir_gen/chunk_$(printf '%03d' $NEXT)"
+        echo "[stop_watcher] removed empty $aborted and matching gen/scratch dirs"
+      fi
+    fi
+    echo "[stop_watcher] DONE at $(date -Iseconds); parent should run final HF flush next"
+    exit 0
+  done

fridge_m/_setup/scripts/stop_at_300.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+# Watches chunked_runner.log for a chunk-start line where current_sim_trajs >= 300.
+# When it fires, SIGTERMs the chunked_runner and any newly-launched sim shards
+# (which are still in startup at this point per the chunked_runner's step1 -> step2
+# transition window — no rollouts in flight yet). Prior chunks (1..N-1) are fully
+# sim+gen complete because the runner is sequential per chunk.
+#
+# After the kill, removes the aborted chunk's sim dir (empty/partial; safer than
+# pushing partial mp4s to HF) and signals the parent script to handle final HF flush.
+
+set -uo pipefail
+
+RUNNER_PID=${RUNNER_PID:-542661}
+LOG=/scr/ravenh/fridge_m/logs/chunked_runner.log
+THRESHOLD=${THRESHOLD:-300}
+
+echo "[stop_watcher] watching $LOG for current_sim_trajs >= $THRESHOLD; runner_pid=$RUNNER_PID"
+
+stdbuf -oL tail -n 1000 -F "$LOG" 2>/dev/null \
+  | stdbuf -oL grep -E -o 'current_sim_trajs=[0-9]+' \
+  | while IFS= read -r line; do
+    n=$(echo "$line" | cut -d= -f2)
+    if [ "$n" -ge "$THRESHOLD" ]; then
+      ts=$(date -Iseconds)
+      echo "[stop_watcher] TRIGGER at $ts: current_sim_trajs=$n >= $THRESHOLD"
+      echo "[stop_watcher] SIGTERMing runner_pid=$RUNNER_PID"
+      kill -TERM "$RUNNER_PID" 2>/dev/null || true
+      sleep 1
+      echo "[stop_watcher] killing any newly-launched sim shards (still in startup)"
+      pkill -TERM -f 'data_gen_fridge_m\.sh' 2>/dev/null || true
+      pkill -TERM -f 'run_pipeline_no_clip\.py' 2>/dev/null || true
+      sleep 5
+      pkill -KILL -f 'data_gen_fridge_m\.sh' 2>/dev/null || true
+      pkill -KILL -f 'run_pipeline_no_clip\.py' 2>/dev/null || true
+      # Identify the aborted chunk and clean it up if it has no finalized trajs.
+      latest_dir=$(ls -d /scr/ravenh/fridge_m/sim_chunks/chunk_*/ 2>/dev/null | tail -1)
+      if [ -n "$latest_dir" ]; then
+        latest_count=$(ls "$latest_dir"episode_*_exo_camera_1_robot_rgb*.mp4 2>/dev/null | wc -l)
+        echo "[stop_watcher] latest sim chunk: $latest_dir (finalized=$latest_count)"
+        if [ "$latest_count" = "0" ]; then
+          echo "[stop_watcher] removing empty aborted chunk $latest_dir"
+          rm -rf "$latest_dir"
+          # also drop the matching gen_chunks empty dir
+          base=$(basename "$latest_dir")
+          rm -rf "/scr/ravenh/fridge_m/gen_chunks/$base"
+          rm -rf "/scr/ravenh/fridge_m/_workdir_gen/$base"
+        fi
+      fi
+      echo "[stop_watcher] DONE at $(date -Iseconds); parent should run final HF flush next"
+      exit 0
+    fi
+  done