Harden runtime state and exclude uploaded videos

reproduce_independently.sh

@@ -294,13 +294,17 @@ run_upload_stage() {
   local require_target="${1:-0}"
   local cmd=(python "$PIPELINE03"
     --dataset-dir "$DATASET_DIR"
+    --scratch-dataset-dir "$SCRATCH_DATASET_DIR"
     --raw-video-dir "$RAW_VIDEO_DIR"
+    --scratch-raw-video-dir "$SCRATCH_RAW_VIDEO_DIR"
     --raw-caption-dir "$RAW_CAPTION_DIR"
     --raw-metadata-dir "$RAW_METADATA_DIR"
     --archive-dir "$ARCHIVE_DIR"
     --progress-path "$PROGRESS_JSON"
     --stats-npz "$STATS_NPZ"
+    --status-journal-path "$RUNTIME_ROOT/upload_status_journal.jsonl"
     --repo-id "$REPO_ID"
+    --repo-revision "$REPO_REVISION"
     --target-bytes "$TARGET_BYTES"
     --target-folders "$TARGET_FOLDERS"
   )

reproduce_independently_slurm.sh

@@ -13,12 +13,18 @@ if [[ ! -f "$SOURCE_METADATA_CSV" && -f "$ROOT_DIR/SignVerse-2M-metadata_ori.csv
 fi
 OUTPUT_METADATA_CSV="${OUTPUT_METADATA_CSV:-$RUNTIME_ROOT/SignVerse-2M-metadata_processed.csv}"
 RAW_VIDEO_DIR="${RAW_VIDEO_DIR:-$RUNTIME_ROOT/raw_video}"
+SCRATCH_RAW_VIDEO_DIR="${SCRATCH_RAW_VIDEO_DIR:-/scratch/$USER/SignVerse-2M-runtime/raw_video}"
+SCRATCH_DATASET_DIR="${SCRATCH_DATASET_DIR:-/scratch/$USER/SignVerse-2M-runtime/dataset}"
+HOME_RAW_VIDEO_LIMIT="${HOME_RAW_VIDEO_LIMIT:-180}"
+SCRATCH_RAW_VIDEO_LIMIT="${SCRATCH_RAW_VIDEO_LIMIT:-2800}"
+DEFAULT_TOTAL_RAW_VIDEO_LIMIT="$((HOME_RAW_VIDEO_LIMIT + SCRATCH_RAW_VIDEO_LIMIT))"
 RAW_CAPTION_DIR="${RAW_CAPTION_DIR:-$RUNTIME_ROOT/raw_caption}"
 RAW_METADATA_DIR="${RAW_METADATA_DIR:-$RUNTIME_ROOT/raw_metadata}"
 DATASET_DIR="${DATASET_DIR:-$RUNTIME_ROOT/dataset}"
 ARCHIVE_DIR="${ARCHIVE_DIR:-$RUNTIME_ROOT/archives}"
 STATS_NPZ="${STATS_NPZ:-$RUNTIME_ROOT/stats.npz}"
 PROGRESS_JSON="${PROGRESS_JSON:-$RUNTIME_ROOT/archive_upload_progress.json}"
+RUNTIME_LOG_ROOT="${RUNTIME_LOG_ROOT:-/scratch/$USER/SignVerse-2M-runtime/slurm/logs}"
 
 PIPELINE01="${PIPELINE01:-$ROOT_DIR/scripts/pipeline01_download_video_fix_caption.py}"
 PIPELINE02="${PIPELINE02:-$ROOT_DIR/scripts/pipeline02_extract_dwpose_from_video.py}"
@@ -36,13 +42,15 @@ DOWNLOAD_BATCH_SIZE="${DOWNLOAD_BATCH_SIZE:-1}"
 DOWNLOAD_WORKERS="${DOWNLOAD_WORKERS:-60}"
 USE_SLURM_DOWNLOAD="${USE_SLURM_DOWNLOAD:-1}"
 PROCESS_BATCH_SIZE="${PROCESS_BATCH_SIZE:-}"
+VIDEOS_PER_JOB="${VIDEOS_PER_JOB:-5}"
 MIN_PROCESS_START_BACKLOG="${MIN_PROCESS_START_BACKLOG:-4}"
 PROCESS_PENDING_TIMEOUT_SECONDS="${PROCESS_PENDING_TIMEOUT_SECONDS:-1800}"
-RAW_BACKLOG_LIMIT="${RAW_BACKLOG_LIMIT:-180}"
+RAW_BACKLOG_LIMIT="${RAW_BACKLOG_LIMIT:-$DEFAULT_TOTAL_RAW_VIDEO_LIMIT}"
 MAX_RAW_VIDEO_BYTES="${MAX_RAW_VIDEO_BYTES:-0}"
 MAX_ITERATIONS="${MAX_ITERATIONS:-0}"
 IDLE_SLEEP_SECONDS="${IDLE_SLEEP_SECONDS:-5}"
 REPO_ID="${REPO_ID:-SignerX/SignVerse-2M}"
+REPO_REVISION="${REPO_REVISION:-dev}"
 COOKIES_FILE="${COOKIES_FILE:-$ROOT_DIR/www.youtube.com_cookies (2).txt}"
 COOKIES_FROM_BROWSER="${COOKIES_FROM_BROWSER:-}"
 EXTRACTOR_ARGS="${EXTRACTOR_ARGS:-}"
@@ -51,7 +59,7 @@ SLURM_DOWNLOAD_SUBMIT_SCRIPT="${SLURM_DOWNLOAD_SUBMIT_SCRIPT:-$ROOT_DIR/slurm/su
 GPU_PARTITIONS="gpu,gpu-redhat,cgpu"
 GPU_ACCOUNT="${GPU_ACCOUNT:-}"
 ARRAY_PARALLEL="${ARRAY_PARALLEL:-}"
-MAX_BACKLOG_VIDEOS="${MAX_BACKLOG_VIDEOS:-180}"
+MAX_BACKLOG_VIDEOS="${MAX_BACKLOG_VIDEOS:-$DEFAULT_TOTAL_RAW_VIDEO_LIMIT}"
 DOWNLOAD_CLAIM_DIR="${DOWNLOAD_CLAIM_DIR:-$STATE_ROOT/slurm/state/download_claims}"
 DOWNLOAD_CSV_LOCK_PATH="${DOWNLOAD_CSV_LOCK_PATH:-$RUNTIME_ROOT/SignVerse-2M-metadata_processed.csv.lock}"
 DOWNLOAD_PARTITIONS="${DOWNLOAD_PARTITIONS:-main}"
@@ -67,7 +75,7 @@ DOWNLOAD_CLAIM_GRACE_SECONDS="${DOWNLOAD_CLAIM_GRACE_SECONDS:-600}"
 DOWNLOAD_PARTIAL_TIMEOUT_SECONDS="${DOWNLOAD_PARTIAL_TIMEOUT_SECONDS:-1800}"
 ORCHESTRATOR_PARTITION="${ORCHESTRATOR_PARTITION:-main}"
 ORCHESTRATOR_ACCOUNT="${ORCHESTRATOR_ACCOUNT:-}"
-ORCHESTRATOR_TIME="${ORCHESTRATOR_TIME:-24:00:00}"
+ORCHESTRATOR_TIME="${ORCHESTRATOR_TIME:-12:00:00}"
 ORCHESTRATOR_CPUS_PER_TASK="${ORCHESTRATOR_CPUS_PER_TASK:-4}"
 ORCHESTRATOR_MEM="${ORCHESTRATOR_MEM:-8G}"
 RUN_LOCAL="${RUN_LOCAL:-0}"
@@ -109,6 +117,7 @@ Options:
   --target-folders N
   --download-batch-size N
   --process-batch-size N
+  --videos-per-job N
   --use-slurm-download {0,1}
   --download-partitions P1[,P2,...]
   --download-account NAME
@@ -121,6 +130,7 @@ Options:
   --max-iterations N
   --idle-sleep-seconds N
   --repo-id REPO
+  --repo-revision BRANCH
   --cookies FILE
   --cookies-from-browser BROWSER
   --extractor-args VALUE
@@ -265,6 +275,10 @@ while [[ $# -gt 0 ]]; do
       PROCESS_BATCH_SIZE="$2"
       shift 2
       ;;
+    --videos-per-job)
+      VIDEOS_PER_JOB="$2"
+      shift 2
+      ;;
     --raw-backlog-limit)
       RAW_BACKLOG_LIMIT="$2"
       shift 2
@@ -285,6 +299,10 @@ while [[ $# -gt 0 ]]; do
       REPO_ID="$2"
       shift 2
       ;;
+    --repo-revision)
+      REPO_REVISION="$2"
+      shift 2
+      ;;
     --cookies)
       COOKIES_FILE="$2"
       shift 2
@@ -353,18 +371,21 @@ if [[ -z "${SLURM_JOB_ID:-}" && "$RUN_LOCAL" != "1" ]]; then
     echo "Missing orchestration wrapper: $wrapper" >&2
     exit 1
   fi
-  export_args="ALL,ROOT_DIR=$ROOT_DIR,RUNTIME_ROOT=$RUNTIME_ROOT,STATE_ROOT=$STATE_ROOT,SOURCE_METADATA_CSV=$SOURCE_METADATA_CSV,OUTPUT_METADATA_CSV=$OUTPUT_METADATA_CSV,RAW_VIDEO_DIR=$RAW_VIDEO_DIR,RAW_CAPTION_DIR=$RAW_CAPTION_DIR,RAW_METADATA_DIR=$RAW_METADATA_DIR,DATASET_DIR=$DATASET_DIR,ARCHIVE_DIR=$ARCHIVE_DIR,STATS_NPZ=$STATS_NPZ,PROGRESS_JSON=$PROGRESS_JSON,STAGE=$STAGE,LIMIT=$LIMIT,FPS=$FPS,WORKERS=$WORKERS,TARGET_BYTES=$TARGET_BYTES,DOWNLOAD_BATCH_SIZE=$DOWNLOAD_BATCH_SIZE,DOWNLOAD_WORKERS=$DOWNLOAD_WORKERS,USE_SLURM_DOWNLOAD=$USE_SLURM_DOWNLOAD,SLURM_DOWNLOAD_SUBMIT_SCRIPT=$SLURM_DOWNLOAD_SUBMIT_SCRIPT,DOWNLOAD_PARTITIONS=$DOWNLOAD_PARTITIONS,DOWNLOAD_ACCOUNT=$DOWNLOAD_ACCOUNT,DOWNLOAD_TIME=$DOWNLOAD_TIME,DOWNLOAD_CPUS_PER_TASK=$DOWNLOAD_CPUS_PER_TASK,DOWNLOAD_MEM=$DOWNLOAD_MEM,DOWNLOAD_ARRAY_PARALLEL=$DOWNLOAD_ARRAY_PARALLEL,DOWNLOAD_MAX_ACTIVE=$DOWNLOAD_MAX_ACTIVE,DOWNLOAD_START_STAGGER_MIN=$DOWNLOAD_START_STAGGER_MIN,DOWNLOAD_START_STAGGER_MAX=$DOWNLOAD_START_STAGGER_MAX,PROCESS_BATCH_SIZE=$PROCESS_BATCH_SIZE,DOWNLOAD_CLAIM_DIR=$DOWNLOAD_CLAIM_DIR,DOWNLOAD_CSV_LOCK_PATH=$DOWNLOAD_CSV_LOCK_PATH,MIN_PROCESS_START_BACKLOG=$MIN_PROCESS_START_BACKLOG,RAW_BACKLOG_LIMIT=$RAW_BACKLOG_LIMIT,MAX_RAW_VIDEO_BYTES=$MAX_RAW_VIDEO_BYTES,MAX_ITERATIONS=$MAX_ITERATIONS,IDLE_SLEEP_SECONDS=$IDLE_SLEEP_SECONDS,REPO_ID=$REPO_ID,COOKIES_FILE=$COOKIES_FILE,COOKIES_FROM_BROWSER=$COOKIES_FROM_BROWSER,EXTRACTOR_ARGS=$EXTRACTOR_ARGS,GPU_PARTITIONS=$GPU_PARTITIONS,GPU_ACCOUNT=$GPU_ACCOUNT,ARRAY_PARALLEL=$ARRAY_PARALLEL,MAX_BACKLOG_VIDEOS=$MAX_BACKLOG_VIDEOS,FORCE_METADATA=$FORCE_METADATA,FORCE_SUBTITLES=$FORCE_SUBTITLES,FORCE_DOWNLOAD=$FORCE_DOWNLOAD,FORCE_PROCESS=$FORCE_PROCESS,SKIP_VIDEO_DOWNLOAD=$SKIP_VIDEO_DOWNLOAD,SKIP_SUBTITLES=$SKIP_SUBTITLES,DRY_RUN_UPLOAD=$DRY_RUN_UPLOAD,RUN_LOCAL=1"
+  export_args="ALL,ROOT_DIR=$ROOT_DIR,RUNTIME_ROOT=$RUNTIME_ROOT,STATE_ROOT=$STATE_ROOT,SOURCE_METADATA_CSV=$SOURCE_METADATA_CSV,OUTPUT_METADATA_CSV=$OUTPUT_METADATA_CSV,RAW_VIDEO_DIR=$RAW_VIDEO_DIR,SCRATCH_RAW_VIDEO_DIR=$SCRATCH_RAW_VIDEO_DIR,HOME_RAW_VIDEO_LIMIT=$HOME_RAW_VIDEO_LIMIT,SCRATCH_RAW_VIDEO_LIMIT=$SCRATCH_RAW_VIDEO_LIMIT,RAW_CAPTION_DIR=$RAW_CAPTION_DIR,RAW_METADATA_DIR=$RAW_METADATA_DIR,DATASET_DIR=$DATASET_DIR,SCRATCH_DATASET_DIR=$SCRATCH_DATASET_DIR,ARCHIVE_DIR=$ARCHIVE_DIR,STATS_NPZ=$STATS_NPZ,PROGRESS_JSON=$PROGRESS_JSON,STAGE=$STAGE,LIMIT=$LIMIT,FPS=$FPS,WORKERS=$WORKERS,TARGET_BYTES=$TARGET_BYTES,DOWNLOAD_BATCH_SIZE=$DOWNLOAD_BATCH_SIZE,DOWNLOAD_WORKERS=$DOWNLOAD_WORKERS,USE_SLURM_DOWNLOAD=$USE_SLURM_DOWNLOAD,SLURM_DOWNLOAD_SUBMIT_SCRIPT=$SLURM_DOWNLOAD_SUBMIT_SCRIPT,DOWNLOAD_PARTITIONS=$DOWNLOAD_PARTITIONS,DOWNLOAD_ACCOUNT=$DOWNLOAD_ACCOUNT,DOWNLOAD_TIME=$DOWNLOAD_TIME,DOWNLOAD_CPUS_PER_TASK=$DOWNLOAD_CPUS_PER_TASK,DOWNLOAD_MEM=$DOWNLOAD_MEM,DOWNLOAD_ARRAY_PARALLEL=$DOWNLOAD_ARRAY_PARALLEL,DOWNLOAD_MAX_ACTIVE=$DOWNLOAD_MAX_ACTIVE,DOWNLOAD_START_STAGGER_MIN=$DOWNLOAD_START_STAGGER_MIN,DOWNLOAD_START_STAGGER_MAX=$DOWNLOAD_START_STAGGER_MAX,PROCESS_BATCH_SIZE=$PROCESS_BATCH_SIZE,VIDEOS_PER_JOB=$VIDEOS_PER_JOB,DOWNLOAD_CLAIM_DIR=$DOWNLOAD_CLAIM_DIR,DOWNLOAD_CSV_LOCK_PATH=$DOWNLOAD_CSV_LOCK_PATH,MIN_PROCESS_START_BACKLOG=$MIN_PROCESS_START_BACKLOG,RAW_BACKLOG_LIMIT=$RAW_BACKLOG_LIMIT,MAX_RAW_VIDEO_BYTES=$MAX_RAW_VIDEO_BYTES,MAX_ITERATIONS=$MAX_ITERATIONS,IDLE_SLEEP_SECONDS=$IDLE_SLEEP_SECONDS,REPO_ID=$REPO_ID,COOKIES_FILE=$COOKIES_FILE,COOKIES_FROM_BROWSER=$COOKIES_FROM_BROWSER,EXTRACTOR_ARGS=$EXTRACTOR_ARGS,GPU_PARTITIONS=$GPU_PARTITIONS,GPU_ACCOUNT=$GPU_ACCOUNT,ARRAY_PARALLEL=$ARRAY_PARALLEL,MAX_BACKLOG_VIDEOS=$MAX_BACKLOG_VIDEOS,FORCE_METADATA=$FORCE_METADATA,FORCE_SUBTITLES=$FORCE_SUBTITLES,FORCE_DOWNLOAD=$FORCE_DOWNLOAD,FORCE_PROCESS=$FORCE_PROCESS,SKIP_VIDEO_DOWNLOAD=$SKIP_VIDEO_DOWNLOAD,SKIP_SUBTITLES=$SKIP_SUBTITLES,DRY_RUN_UPLOAD=$DRY_RUN_UPLOAD,RUN_LOCAL=1"
   if [[ ${#VIDEO_IDS[@]} -gt 0 ]]; then
     export VIDEO_IDS_JOINED
     VIDEO_IDS_JOINED="${VIDEO_IDS[*]}"
     export_args+=",VIDEO_IDS_JOINED=$VIDEO_IDS_JOINED"
   fi
+  mkdir -p "$RUNTIME_LOG_ROOT"
   cmd=(sbatch
     --partition "$ORCHESTRATOR_PARTITION"
     --time "$ORCHESTRATOR_TIME"
     --cpus-per-task "$ORCHESTRATOR_CPUS_PER_TASK"
     --mem "$ORCHESTRATOR_MEM"
-    --export "$export_args"
+    --output "$RUNTIME_LOG_ROOT/sign-dwpose-orch_%j.out"
+    --error "$RUNTIME_LOG_ROOT/sign-dwpose-orch_%j.err"
+    --export "$export_args,RUNTIME_LOG_ROOT=$RUNTIME_LOG_ROOT"
   )
   if [[ -n "$ORCHESTRATOR_ACCOUNT" ]]; then
     cmd+=(--account "$ORCHESTRATOR_ACCOUNT")
@@ -379,7 +400,7 @@ if [[ -n "${VIDEO_IDS_JOINED:-}" && ${#VIDEO_IDS[@]} -eq 0 ]]; then
   IFS=' ' read -r -a VIDEO_IDS <<< "$VIDEO_IDS_JOINED"
 fi
 
-mkdir -p "$RAW_VIDEO_DIR" "$RAW_CAPTION_DIR" "$RAW_METADATA_DIR" "$DATASET_DIR"
+mkdir -p "$RAW_VIDEO_DIR" "$SCRATCH_RAW_VIDEO_DIR" "$RAW_CAPTION_DIR" "$RAW_METADATA_DIR" "$DATASET_DIR" "$SCRATCH_DATASET_DIR"
 if [[ ! -x "$SLURM_PROCESS_SUBMIT_SCRIPT" ]]; then
   echo "Missing Slurm submit script: $SLURM_PROCESS_SUBMIT_SCRIPT" >&2
   exit 1
@@ -402,7 +423,10 @@ run_download_stage() {
       --time "$DOWNLOAD_TIME"
       --cpus-per-task "$DOWNLOAD_CPUS_PER_TASK"
       --mem "$DOWNLOAD_MEM"
-      --max-backlog-videos "$RAW_BACKLOG_LIMIT"
+      --max-backlog-videos "$RAW_BACKLOG_LIMIT" \
+      --scratch-raw-video-dir "$SCRATCH_RAW_VIDEO_DIR" \
+      --home-raw-video-limit "$HOME_RAW_VIDEO_LIMIT" \
+      --scratch-raw-video-limit "$SCRATCH_RAW_VIDEO_LIMIT"
       --workers "$DOWNLOAD_WORKERS"
       --max-active-downloads "$DOWNLOAD_MAX_ACTIVE"
       --claim-dir "$DOWNLOAD_CLAIM_DIR"
@@ -456,11 +480,14 @@ run_download_stage() {
     local cmd=(python "$PIPELINE01"
       --source-metadata-csv "$SOURCE_METADATA_CSV"
       --output-metadata-csv "$OUTPUT_METADATA_CSV"
-      --raw-video-dir "$RAW_VIDEO_DIR"
+      --raw-video-dir "$RAW_VIDEO_DIR" \
+    --scratch-raw-video-dir "$SCRATCH_RAW_VIDEO_DIR"
       --raw-caption-dir "$RAW_CAPTION_DIR"
       --raw-metadata-dir "$RAW_METADATA_DIR"
       --dataset-dir "$DATASET_DIR"
+    --scratch-dataset-dir "$SCRATCH_DATASET_DIR"
       --stats-npz "$STATS_NPZ"
+    --status-journal-path "$RUNTIME_ROOT/upload_status_journal.jsonl"
       --claim-dir "$DOWNLOAD_CLAIM_DIR"
       --csv-lock-path "$DOWNLOAD_CSV_LOCK_PATH"
     )
@@ -527,6 +554,9 @@ run_process_stage() {
   if [[ -n "$ARRAY_PARALLEL" ]]; then
     cmd+=(--array-parallel "$ARRAY_PARALLEL")
   fi
+  if [[ -n "$VIDEOS_PER_JOB" ]]; then
+    cmd+=(--videos-per-job "$VIDEOS_PER_JOB")
+  fi
   if [[ -n "$GPU_ACCOUNT" ]]; then
     cmd+=(--account "$GPU_ACCOUNT")
   fi
@@ -548,9 +578,11 @@ run_sync_csv_stage() {
     --source-metadata-csv "$SOURCE_METADATA_CSV" \
     --output-metadata-csv "$OUTPUT_METADATA_CSV" \
     --raw-video-dir "$RAW_VIDEO_DIR" \
+    --scratch-raw-video-dir "$SCRATCH_RAW_VIDEO_DIR" \
     --raw-caption-dir "$RAW_CAPTION_DIR" \
     --raw-metadata-dir "$RAW_METADATA_DIR" \
     --dataset-dir "$DATASET_DIR" \
+      --scratch-dataset-dir "$SCRATCH_DATASET_DIR" \
     --progress-path "$PROGRESS_JSON" \
     --status-journal-path "$RUNTIME_ROOT/upload_status_journal.jsonl"
 }
@@ -559,13 +591,17 @@ run_upload_stage() {
   local require_target="${1:-0}"
   local cmd=(python "$PIPELINE03"
     --dataset-dir "$DATASET_DIR"
+    --scratch-dataset-dir "$SCRATCH_DATASET_DIR"
     --raw-video-dir "$RAW_VIDEO_DIR"
+    --scratch-raw-video-dir "$SCRATCH_RAW_VIDEO_DIR"
     --raw-caption-dir "$RAW_CAPTION_DIR"
     --raw-metadata-dir "$RAW_METADATA_DIR"
     --archive-dir "$ARCHIVE_DIR"
     --progress-path "$PROGRESS_JSON"
     --stats-npz "$STATS_NPZ"
+    --status-journal-path "$RUNTIME_ROOT/upload_status_journal.jsonl"
     --repo-id "$REPO_ID"
+    --repo-revision "$REPO_REVISION"
     --target-bytes "$TARGET_BYTES"
     --target-folders "$TARGET_FOLDERS"
   )
@@ -583,18 +619,22 @@ run_upload_stage() {
 prune_processed_raw_videos() {
   python - <<PY
 from pathlib import Path
-raw_dir = Path("$RAW_VIDEO_DIR")
-dataset_dir = Path("$DATASET_DIR")
+raw_dirs = [Path("$RAW_VIDEO_DIR"), Path("$SCRATCH_RAW_VIDEO_DIR")]
+dataset_dirs = [Path("$DATASET_DIR"), Path("$SCRATCH_DATASET_DIR")]
 video_extensions = {".mp4", ".mkv", ".webm", ".mov"}
 removed = 0
-if raw_dir.exists():
-    for video_path in raw_dir.iterdir():
-        if not video_path.is_file() or video_path.suffix.lower() not in video_extensions:
-            continue
-        video_id = video_path.stem
-        if (dataset_dir / video_id / "npz" / ".complete").exists():
-            video_path.unlink(missing_ok=True)
-            removed += 1
+complete = set()
+for current_dataset_dir in dataset_dirs:
+    if current_dataset_dir.exists():
+        complete.update({p.parent.parent.name for p in current_dataset_dir.glob("*/npz/.complete")})
+for raw_dir in raw_dirs:
+    if raw_dir.exists():
+        for video_path in raw_dir.iterdir():
+            if not video_path.is_file() or video_path.suffix.lower() not in video_extensions:
+                continue
+            if video_path.stem in complete:
+                video_path.unlink(missing_ok=True)
+                removed += 1
 print(removed)
 PY
 }
@@ -619,13 +659,20 @@ PY
 count_pending_process() {
   python - <<PY
 from pathlib import Path
-raw_dir = Path("$RAW_VIDEO_DIR")
+raw_dirs = [Path("$RAW_VIDEO_DIR"), Path("$SCRATCH_RAW_VIDEO_DIR")]
 video_extensions = {".mp4", ".mkv", ".webm", ".mov"}
 pending = 0
-if raw_dir.exists():
+seen = set()
+for raw_dir in raw_dirs:
+    if not raw_dir.exists():
+        continue
     for video_path in raw_dir.iterdir():
-        if video_path.is_file() and video_path.suffix.lower() in video_extensions:
-            pending += 1
+        if not video_path.is_file() or video_path.suffix.lower() not in video_extensions:
+            continue
+        if video_path.stem in seen:
+            continue
+        seen.add(video_path.stem)
+        pending += 1
 print(pending)
 PY
 }
@@ -806,7 +853,7 @@ cleanup_stale_download_partials() {
 import time
 from pathlib import Path
 claim_dir = Path("$DOWNLOAD_CLAIM_DIR")
-raw_dir = Path("$RAW_VIDEO_DIR")
+raw_dirs = [Path("$RAW_VIDEO_DIR"), Path("$SCRATCH_RAW_VIDEO_DIR")]
 timeout = int("$DOWNLOAD_PARTIAL_TIMEOUT_SECONDS")
 now = time.time()
 active_ids = set()
@@ -817,7 +864,9 @@ try:
 except Exception:
     pass
 removed = 0
-if raw_dir.exists():
+for raw_dir in raw_dirs:
+    if not raw_dir.exists():
+        continue
     for path in raw_dir.iterdir():
         if not path.is_file():
             continue
@@ -864,26 +913,45 @@ PY
 
 count_active_process_claims() {
   python - <<PY
+import re
 import subprocess
 from datetime import datetime, timedelta
 from pathlib import Path
-from datetime import datetime, timedelta
+
 claim_dir = Path("$STATE_ROOT/slurm/state/claims")
 claim_dir.mkdir(parents=True, exist_ok=True)
 timeout_seconds = int("$PROCESS_PENDING_TIMEOUT_SECONDS")
+videos_per_job = int("${VIDEOS_PER_JOB:-1}")
 now = datetime.now()
 job_states = {}
 base_states = {}
+array_re = re.compile(r"^(?P<base>\d+)_\[(?P<start>\d+)-(?P<end>\d+)(?:%(?P<limit>\d+))?\]$")
+
+def expand_job_token(job_token: str):
+    job_token = job_token.strip()
+    match = array_re.match(job_token)
+    if not match:
+        return [job_token]
+    base = match.group("base")
+    start = int(match.group("start"))
+    end = int(match.group("end"))
+    return [f"{base}_{index}" for index in range(start, end + 1)]
+
 try:
     result = subprocess.run(["squeue", "-h", "-u", "$USER", "-o", "%i|%T"], check=True, capture_output=True, text=True)
     for line in result.stdout.splitlines():
         if not line.strip() or "|" not in line:
             continue
-        job_key, state = line.split("|", 1)
-        job_key = job_key.strip()
+        job_token, state = line.split("|", 1)
         state = state.strip().upper()
-        job_states[job_key] = state
-        base_states[job_key.split("_", 1)[0]] = state
+        if videos_per_job > 1:
+            for job_key in expand_job_token(job_token):
+                job_states[job_key] = state
+                base_states[job_key.split("_", 1)[0]] = state
+        else:
+            job_key = job_token.strip()
+            job_states[job_key] = state
+            base_states[job_key.split("_", 1)[0]] = state
 except Exception:
     job_states = {}
     base_states = {}
@@ -912,6 +980,17 @@ for claim_path in claim_dir.glob("*.claim"):
     else:
         state = base_states.get(job_id)
     if not state:
+        submitted_at = meta.get("submitted_at", "")
+        fresh_missing = False
+        if submitted_at:
+            try:
+                submitted_dt = datetime.strptime(submitted_at, "%Y-%m-%d %H:%M:%S")
+                fresh_missing = (now - submitted_dt) <= timedelta(seconds=min(timeout_seconds, 600))
+            except Exception:
+                fresh_missing = False
+        if fresh_missing:
+            count += 1
+            continue
         claim_path.unlink(missing_ok=True)
         continue
     submitted_at = meta.get("submitted_at", "")
@@ -923,7 +1002,8 @@ for claim_path in claim_dir.glob("*.claim"):
         except Exception:
             stale_pending = False
     if stale_pending:
-        subprocess.run(["scancel", job_id], check=False)
+        cancel_target = job_key or (f"{job_id}_{task_id}" if task_id else job_id)
+        subprocess.run(["scancel", cancel_target], check=False)
         claim_path.unlink(missing_ok=True)
         continue
     count += 1
@@ -933,6 +1013,7 @@ PY
 
 cleanup_stale_process_jobs() {
   python - <<PY
+import re
 import subprocess
 from datetime import datetime, timedelta
 from pathlib import Path
@@ -940,6 +1021,7 @@ from pathlib import Path
 claim_dir = Path("$STATE_ROOT/slurm/state/claims")
 claim_dir.mkdir(parents=True, exist_ok=True)
 timeout_seconds = int("$PROCESS_PENDING_TIMEOUT_SECONDS")
+videos_per_job = int("${VIDEOS_PER_JOB:-1}")
 now = datetime.now()
 
 bad_reason_tokens = (
@@ -953,6 +1035,18 @@ bad_reason_tokens = (
 timed_pending_reasons = ("Priority", "Resources", "QOS")
 
 squeue_rows = {}
+array_re = re.compile(r"^(?P<base>\d+)_\[(?P<start>\d+)-(?P<end>\d+)(?:%(?P<limit>\d+))?\]$")
+
+def expand_job_token(job_token: str):
+    job_token = job_token.strip()
+    match = array_re.match(job_token)
+    if not match:
+        return [job_token]
+    base = match.group("base")
+    start = int(match.group("start"))
+    end = int(match.group("end"))
+    return [f"{base}_{index}" for index in range(start, end + 1)]
+
 try:
     proc = subprocess.run(
         ["squeue", "-h", "-u", "$USER", "-n", "dwpose", "-o", "%i|%T|%R"],
@@ -963,8 +1057,14 @@ try:
     for line in proc.stdout.splitlines():
         if not line.strip() or "|" not in line:
             continue
-        job_key, state, reason = line.split("|", 2)
-        squeue_rows[job_key.strip()] = (state.strip().upper(), reason.strip())
+        job_token, state, reason = line.split("|", 2)
+        state = state.strip().upper()
+        reason = reason.strip()
+        if videos_per_job > 1:
+            for job_key in expand_job_token(job_token):
+                squeue_rows[job_key] = (state, reason)
+        else:
+            squeue_rows[job_token.strip()] = (state, reason)
 except Exception:
     squeue_rows = {}
 
@@ -991,6 +1091,15 @@ for claim_path in claim_dir.glob("*.claim"):
         continue
     row = squeue_rows.get(job_key)
     if not row:
+        fresh_missing = False
+        if submitted_at:
+            try:
+                submitted_dt = datetime.strptime(submitted_at, "%Y-%m-%d %H:%M:%S")
+                fresh_missing = (now - submitted_dt) <= timedelta(seconds=min(timeout_seconds, 600))
+            except Exception:
+                fresh_missing = False
+        if fresh_missing:
+            continue
         claim_path.unlink(missing_ok=True)
         removed_claims += 1
         continue
@@ -1008,8 +1117,9 @@ for claim_path in claim_dir.glob("*.claim"):
             except Exception:
                 pass
     if should_cancel:
-        subprocess.run(["scancel", job_id], check=False)
-        cancelled_jobs.add(job_id)
+        cancel_target = job_key or (f"{job_id}_{task_id}" if task_id else job_id)
+        subprocess.run(["scancel", cancel_target], check=False)
+        cancelled_jobs.add(cancel_target)
         claim_path.unlink(missing_ok=True)
         removed_claims += 1
 
@@ -1073,51 +1183,43 @@ PY
 }
 
 count_complete_pending_upload() {
-  python - <<PY
+  PYTHONPATH="$ROOT_DIR${PYTHONPATH:+:$PYTHONPATH}" python - <<PY
 import json
 from pathlib import Path
+from utils.dataset_pool import list_unuploaded_folder_paths
+
 dataset_dir = Path("$DATASET_DIR")
+scratch_dataset_dir = Path("$SCRATCH_DATASET_DIR")
 progress_path = Path("$PROGRESS_JSON")
-uploaded = set()
+uploaded = {}
 if progress_path.exists():
-    uploaded = set(json.loads(progress_path.read_text()).get("uploaded_folders", {}).keys())
-count = 0
-if dataset_dir.exists():
-    for folder_path in dataset_dir.iterdir():
-        if not folder_path.is_dir():
-            continue
-        if folder_path.name in uploaded:
-            continue
-        if (folder_path / "npz" / ".complete").exists():
-            count += 1
-print(count)
+    uploaded = json.loads(progress_path.read_text()).get("uploaded_folders", {})
+print(len(list_unuploaded_folder_paths(dataset_dir, scratch_dataset_dir, uploaded)))
 PY
 }
 
 bytes_complete_pending_upload() {
-  python - <<PY
+  PYTHONPATH="$ROOT_DIR${PYTHONPATH:+:$PYTHONPATH}" python - <<PY
 import json
 from pathlib import Path
+from utils.dataset_pool import list_unuploaded_folder_paths
+
 dataset_dir = Path("$DATASET_DIR")
+scratch_dataset_dir = Path("$SCRATCH_DATASET_DIR")
 progress_path = Path("$PROGRESS_JSON")
-uploaded = set()
+uploaded = {}
 if progress_path.exists():
-    uploaded = set(json.loads(progress_path.read_text()).get("uploaded_folders", {}).keys())
+    uploaded = json.loads(progress_path.read_text()).get("uploaded_folders", {})
 total = 0
-if dataset_dir.exists():
-    for folder_path in dataset_dir.iterdir():
-        if not folder_path.is_dir():
-            continue
-        if folder_path.name in uploaded:
-            continue
-        if not (folder_path / "npz" / ".complete").exists():
-            continue
-        for path in folder_path.rglob("*"):
-            if path.is_file():
-                try:
-                    total += path.stat().st_size
-                except OSError:
-                    pass
+for _video_id, folder_path in list_unuploaded_folder_paths(dataset_dir, scratch_dataset_dir, uploaded):
+    for path in folder_path.rglob("*"):
+        if path.is_file():
+            try:
+                stat_result = path.stat()
+            except FileNotFoundError:
+                continue
+            allocated = getattr(stat_result, "st_blocks", 0) * 512
+            total += allocated if allocated > 0 else stat_result.st_size
 print(total)
 PY
 }
@@ -1144,7 +1246,7 @@ download_loop() {
     [[ "$pending_download" =~ ^[0-9]+$ ]] || pending_download=0
     pending_process="$(count_pending_process 2>/dev/null || true)"
     [[ "$pending_process" =~ ^[0-9]+$ ]] || pending_process=0
-    raw_video_bytes="$(dir_size_bytes "$RAW_VIDEO_DIR" 2>/dev/null || true)"
+    raw_video_bytes="$(( $(dir_size_bytes "$RAW_VIDEO_DIR" 2>/dev/null || echo 0) + $(dir_size_bytes "$SCRATCH_RAW_VIDEO_DIR" 2>/dev/null || echo 0) ))"
     [[ "$raw_video_bytes" =~ ^[0-9]+$ ]] || raw_video_bytes=0
     echo "[download] iteration=$iteration pending_download=$pending_download raw_backlog=$pending_process raw_video_bytes=$raw_video_bytes pruned_raw_videos=$pruned stale_download_claims=$stale_download_claims stale_download_partials=$stale_download_partials stale_process_jobs=$stale_process_jobs stale_process_claims=$stale_process_claims stale_orphan_process_jobs=$stale_orphan_process_jobs"
 
@@ -1288,12 +1390,17 @@ upload_loop() {
   while true; do
     iteration=$((iteration + 1))
     local pruned
-    pruned="$(prune_processed_raw_videos)"
+    pruned="$(prune_processed_raw_videos 2>/dev/null || true)"
+    [[ "$pruned" =~ ^[0-9]+$ ]] || pruned=0
     local pending_download pending_process complete_pending_upload complete_pending_upload_bytes
-    pending_download="$(count_pending_downloads)"
-    pending_process="$(count_pending_process)"
-    complete_pending_upload="$(count_complete_pending_upload)"
-    complete_pending_upload_bytes="$(bytes_complete_pending_upload)"
+    pending_download="$(count_pending_downloads 2>/dev/null || true)"
+    [[ "$pending_download" =~ ^[0-9]+$ ]] || pending_download=0
+    pending_process="$(count_pending_process 2>/dev/null || true)"
+    [[ "$pending_process" =~ ^[0-9]+$ ]] || pending_process=0
+    complete_pending_upload="$(count_complete_pending_upload 2>/dev/null || true)"
+    [[ "$complete_pending_upload" =~ ^[0-9]+$ ]] || complete_pending_upload=0
+    complete_pending_upload_bytes="$(bytes_complete_pending_upload 2>/dev/null || true)"
+    [[ "$complete_pending_upload_bytes" =~ ^[0-9]+$ ]] || complete_pending_upload_bytes=0
     echo "[upload] iteration=$iteration pending_download=$pending_download raw_backlog=$pending_process complete_pending_upload=$complete_pending_upload complete_pending_upload_bytes=$complete_pending_upload_bytes pruned_raw_videos=$pruned"
 
     if [[ "$MAX_ITERATIONS" -gt 0 && "$iteration" -gt "$MAX_ITERATIONS" ]]; then

scripts/pipeline01_download_video_fix_caption.py

@@ -21,7 +21,13 @@ REPO_ROOT = Path(__file__).resolve().parents[1]
 if str(REPO_ROOT) not in sys.path:
     sys.path.insert(0, str(REPO_ROOT))
 
-from utils.stats_npz import update_video_stats
+from utils.stats_npz import update_video_stats_best_effort
+from utils.raw_video_pool import (
+    choose_download_target,
+    cleanup_partial_downloads as cleanup_partial_downloads_pool,
+    find_video_file as find_video_file_pool,
+    release_download_reservation,
+)
 
 
 DEFAULT_SOURCE_METADATA_CSV = REPO_ROOT / "SignVerse-2M-metadata_ori.csv"
@@ -31,6 +37,7 @@ DEFAULT_RAW_CAPTION_DIR = REPO_ROOT / "raw_caption"
 DEFAULT_RAW_METADATA_DIR = REPO_ROOT / "raw_metadata"
 DEFAULT_DATASET_DIR = REPO_ROOT / "dataset"
 DEFAULT_STATS_NPZ = REPO_ROOT / "stats.npz"
+DEFAULT_STATUS_JOURNAL_PATH = REPO_ROOT / "upload_status_journal.jsonl"
 DEFAULT_YT_DLP_EXTRACTOR_ARGS = "youtube:player_client=web_safari,web"
 COOKIE_DOMAINS = ("youtube.com", "google.com", "googlevideo.com", "ytimg.com")
 TIMESTAMP_LINE_RE = re.compile(
@@ -66,10 +73,14 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument("--source-metadata-csv", type=Path, default=DEFAULT_SOURCE_METADATA_CSV)
     parser.add_argument("--output-metadata-csv", type=Path, default=DEFAULT_OUTPUT_METADATA_CSV)
     parser.add_argument("--raw-video-dir", type=Path, default=DEFAULT_RAW_VIDEO_DIR)
+    parser.add_argument("--scratch-raw-video-dir", type=Path, default=None)
+    parser.add_argument("--home-raw-video-limit", type=int, default=180)
+    parser.add_argument("--scratch-raw-video-limit", type=int, default=2800)
     parser.add_argument("--raw-caption-dir", type=Path, default=DEFAULT_RAW_CAPTION_DIR)
     parser.add_argument("--raw-metadata-dir", type=Path, default=DEFAULT_RAW_METADATA_DIR)
     parser.add_argument("--dataset-dir", type=Path, default=DEFAULT_DATASET_DIR)
     parser.add_argument("--stats-npz", type=Path, default=DEFAULT_STATS_NPZ)
+    parser.add_argument("--status-journal-path", type=Path, default=DEFAULT_STATUS_JOURNAL_PATH)
     parser.add_argument("--limit", type=int, default=None)
     parser.add_argument("--video-ids", nargs="*", default=None)
     parser.add_argument("--force-metadata", action="store_true")
@@ -470,55 +481,52 @@ def subtitle_dir_for_video(dataset_dir: Path, video_id: str) -> Path:
     return dataset_dir / video_id / "captions"
 
 
-def find_video_file(raw_video_dir: Path, video_id: str) -> Path | None:
-    candidates = []
-    for path in raw_video_dir.glob(f"{video_id}.*"):
-        if path.suffix in {".mp4", ".mkv", ".webm", ".mov"}:
-            candidates.append(path)
-    return sorted(candidates)[0] if candidates else None
+def find_video_file(raw_video_dir: Path, video_id: str, scratch_raw_video_dir: Path | None = None) -> Path | None:
+    return find_video_file_pool(video_id, raw_video_dir, scratch_raw_video_dir)
 
 
-def iter_partial_download_files(raw_video_dir: Path, video_id: str) -> Iterable[Path]:
-    seen: set[Path] = set()
-    for path in raw_video_dir.glob(f"{video_id}*"):
-        if not path.is_file():
-            continue
-        suffixes = set(path.suffixes)
-        if ".part" in suffixes or ".ytdl" in suffixes or path.suffix in {".part", ".ytdl"}:
-            resolved = path.resolve()
-            if resolved not in seen:
-                seen.add(resolved)
-                yield path
+def iter_partial_download_files(raw_video_dir: Path, video_id: str, scratch_raw_video_dir: Path | None = None) -> Iterable[Path]:
+    yield from cleanup_partial_downloads_pool.__globals__['iter_partial_download_files'](video_id, raw_video_dir, scratch_raw_video_dir)
 
 
-def cleanup_partial_downloads(raw_video_dir: Path, video_id: str) -> None:
-    for partial_path in iter_partial_download_files(raw_video_dir, video_id):
-        partial_path.unlink(missing_ok=True)
+def cleanup_partial_downloads(raw_video_dir: Path, video_id: str, scratch_raw_video_dir: Path | None = None) -> None:
+    cleanup_partial_downloads_pool(video_id, raw_video_dir, scratch_raw_video_dir)
 
 
 def download_video(video_id: str, raw_video_dir: Path, args: argparse.Namespace) -> Tuple[str, str]:
-    raw_video_dir.mkdir(parents=True, exist_ok=True)
-    cleanup_partial_downloads(raw_video_dir, video_id)
-    command = build_yt_dlp_base_command(args)
-    command.extend(
-        [
-            "--output",
-            str(raw_video_dir / "%(id)s.%(ext)s"),
-            "--format",
-            "worstvideo*+worstaudio/worst",
-            "--format-sort",
-            "+res,+size,+br,+fps",
-            "--merge-output-format",
-            "mp4",
-            youtube_url(video_id),
-        ]
+    target_raw_video_dir, reservation_path = choose_download_target(
+        raw_video_dir,
+        args.scratch_raw_video_dir,
+        args.home_raw_video_limit,
+        args.scratch_raw_video_limit,
+        args.claim_dir,
+        video_id,
     )
-    result = run_command(command)
-    video_path = find_video_file(raw_video_dir, video_id)
-    cleanup_partial_downloads(raw_video_dir, video_id)
-    if result.returncode != 0 and not video_path:
-        raise RuntimeError(result.stderr.strip() or result.stdout.strip() or "video download failed")
-    return repo_relative_or_absolute(video_path) if video_path else "", ""
+    target_raw_video_dir.mkdir(parents=True, exist_ok=True)
+    try:
+        cleanup_partial_downloads(raw_video_dir, video_id, args.scratch_raw_video_dir)
+        command = build_yt_dlp_base_command(args)
+        command.extend(
+            [
+                "--output",
+                str(target_raw_video_dir / "%(id)s.%(ext)s"),
+                "--format",
+                "worstvideo*+worstaudio/worst",
+                "--format-sort",
+                "+res,+size,+br,+fps",
+                "--merge-output-format",
+                "mp4",
+                youtube_url(video_id),
+            ]
+        )
+        result = run_command(command)
+        video_path = find_video_file(raw_video_dir, video_id, args.scratch_raw_video_dir)
+        cleanup_partial_downloads(raw_video_dir, video_id, args.scratch_raw_video_dir)
+        if result.returncode != 0 and not video_path:
+            raise RuntimeError(result.stderr.strip() or result.stdout.strip() or "video download failed")
+        return repo_relative_or_absolute(video_path) if video_path else "", ""
+    finally:
+        release_download_reservation(reservation_path)
 
 
 def subtitle_file_language(path: Path, video_id: str) -> str:
@@ -853,7 +861,7 @@ def main() -> None:
                 failure_count, should_skip = record_row_failure(row, stats_record, metadata_error, args.max_failures_before_skip)
                 stats_record["last_error"] = row["error"]
                 persist_row_update(args, video_id, row, fieldnames)
-                update_video_stats(args.stats_npz, video_id, **stats_record)
+                update_video_stats_best_effort(args.stats_npz, args.status_journal_path, video_id, **stats_record)
                 print(f"  metadata failed: {metadata_error}")
                 if should_skip:
                     print(f"  skipping after {failure_count} failures")
@@ -908,7 +916,7 @@ def main() -> None:
                 row["raw_caption_dir"] = ""
 
             try:
-                existing_video = find_video_file(args.raw_video_dir, video_id)
+                existing_video = find_video_file(args.raw_video_dir, video_id, args.scratch_raw_video_dir)
                 if args.skip_video_download:
                     row["download_status"] = "skipped"
                     row["raw_video_path"] = repo_relative_or_absolute(existing_video) if existing_video else ""
@@ -947,7 +955,7 @@ def main() -> None:
             stats_record["last_error"] = row["error"]
             stats_record["updated_at"] = row["processed_at"]
             persist_row_update(args, video_id, row, fieldnames)
-            update_video_stats(args.stats_npz, video_id, **stats_record)
+            update_video_stats_best_effort(args.stats_npz, args.status_journal_path, video_id, **stats_record)
 
             if row["download_status"] == "failed":
                 print(f"  video download failed: {download_error}")

scripts/pipeline02_extract_dwpose_from_video.py

@@ -29,12 +29,15 @@ REPO_ROOT = Path(__file__).resolve().parents[1]
 if str(REPO_ROOT) not in sys.path:
     sys.path.insert(0, str(REPO_ROOT))
 
-from utils.stats_npz import load_stats, update_video_stats
+from utils.stats_npz import load_stats, update_video_stats_best_effort
+from utils.raw_video_pool import iter_raw_video_files
+from utils.dataset_pool import dataset_dir_for_video, find_dataset_video_dir
 
 
 DEFAULT_RAW_VIDEO_DIR = REPO_ROOT / "raw_video"
 DEFAULT_DATASET_DIR = REPO_ROOT / "dataset"
 DEFAULT_STATS_NPZ = REPO_ROOT / "stats.npz"
+DEFAULT_STATUS_JOURNAL_PATH = REPO_ROOT / "upload_status_journal.jsonl"
 VIDEO_EXTENSIONS = {".mp4", ".mkv", ".webm", ".mov"}
 COMPLETE_MARKER_NAME = ".complete"
 
@@ -93,7 +96,9 @@ def parse_args() -> argparse.Namespace:
         description="Extract DWpose NPZ files from raw videos."
     )
     parser.add_argument("--raw-video-dir", type=Path, default=DEFAULT_RAW_VIDEO_DIR)
+    parser.add_argument("--scratch-raw-video-dir", type=Path, default=None)
     parser.add_argument("--dataset-dir", type=Path, default=DEFAULT_DATASET_DIR)
+    parser.add_argument("--scratch-dataset-dir", type=Path, default=None)
     parser.add_argument("--fps", type=int, default=24)
     parser.add_argument("--limit", type=int, default=None)
     parser.add_argument("--workers", type=int, default=None)
@@ -102,6 +107,7 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument("--delete-source-on-success", action="store_true")
     parser.add_argument("--tmp-root", type=Path, default=Path("/tmp"))
     parser.add_argument("--stats-npz", type=Path, default=DEFAULT_STATS_NPZ)
+    parser.add_argument("--status-journal-path", type=Path, default=DEFAULT_STATUS_JOURNAL_PATH)
     parser.add_argument(
         "--single-poses-npz",
         dest="single_poses_npz",
@@ -185,18 +191,21 @@ def parse_args() -> argparse.Namespace:
 
 def select_video_paths(args: argparse.Namespace) -> List[Path]:
     args.raw_video_dir.mkdir(parents=True, exist_ok=True)
+    if args.scratch_raw_video_dir is not None:
+        args.scratch_raw_video_dir.mkdir(parents=True, exist_ok=True)
     args.dataset_dir.mkdir(parents=True, exist_ok=True)
+    if args.scratch_dataset_dir is not None:
+        args.scratch_dataset_dir.mkdir(parents=True, exist_ok=True)
     video_id_filter = set(args.video_ids or [])
     stats = load_stats(args.stats_npz)
 
     selected = []
-    for path in sorted(args.raw_video_dir.iterdir()):
-        if not path.is_file() or path.suffix.lower() not in VIDEO_EXTENSIONS:
-            continue
+    for path in sorted(iter_raw_video_files(args.raw_video_dir, args.scratch_raw_video_dir), key=lambda p: (p.stem, str(p))):
         video_id = path.stem
         if video_id_filter and video_id not in video_id_filter:
             continue
-        npz_dir = args.dataset_dir / video_id / "npz"
+        dataset_root = find_dataset_video_dir(video_id, args.dataset_dir, args.scratch_dataset_dir)
+        npz_dir = dataset_root / video_id / "npz"
         complete_marker = npz_dir / COMPLETE_MARKER_NAME
         if (
             not args.force
@@ -566,6 +575,9 @@ def optimized_process_frame_batch(
 def process_video(
     video_path: Path,
     dataset_dir: Path,
+    scratch_dataset_dir: Path | None,
+    raw_video_dir: Path,
+    scratch_raw_video_dir: Path | None,
     fps: int,
     detector: DWposeDetector,
     tmp_root: Path,
@@ -578,7 +590,8 @@ def process_video(
     optimized_frame_stride: int,
 ) -> None:
     video_id = video_path.stem
-    output_npz_dir = dataset_dir / video_id / "npz"
+    output_dataset_dir = dataset_dir_for_video(video_path, raw_video_dir, scratch_raw_video_dir, dataset_dir, scratch_dataset_dir)
+    output_npz_dir = output_dataset_dir / video_id / "npz"
     complete_marker = output_npz_dir / COMPLETE_MARKER_NAME
     poses_npz_path = output_npz_dir / "poses.npz"
     if output_npz_dir.exists() and complete_marker.exists() and not force:
@@ -732,8 +745,9 @@ def worker(rank: int, worker_count: int, video_paths: Sequence[Path], args: argp
         if index % worker_count != rank:
             continue
         try:
-            update_video_stats(
+            update_video_stats_best_effort(
                 args.stats_npz,
+                args.status_journal_path,
                 video_path.stem,
                 process_status="running",
                 last_error="",
@@ -742,6 +756,9 @@ def worker(rank: int, worker_count: int, video_paths: Sequence[Path], args: argp
             process_video(
                 video_path=video_path,
                 dataset_dir=args.dataset_dir,
+                scratch_dataset_dir=args.scratch_dataset_dir,
+                raw_video_dir=args.raw_video_dir,
+                scratch_raw_video_dir=args.scratch_raw_video_dir,
                 fps=args.fps,
                 detector=detector,
                 tmp_root=args.tmp_root,
@@ -753,8 +770,9 @@ def worker(rank: int, worker_count: int, video_paths: Sequence[Path], args: argp
                 optimized_detect_resolution=args.optimized_detect_resolution,
                 optimized_frame_stride=args.optimized_frame_stride,
             )
-            update_video_stats(
+            update_video_stats_best_effort(
                 args.stats_npz,
+                args.status_journal_path,
                 video_path.stem,
                 process_status="ok",
                 last_error="",
@@ -764,8 +782,9 @@ def worker(rank: int, worker_count: int, video_paths: Sequence[Path], args: argp
                 video_path.unlink()
                 print(f"Worker {rank}: deleted source video {video_path.name}")
         except Exception as exc:
-            update_video_stats(
+            update_video_stats_best_effort(
                 args.stats_npz,
+                args.status_journal_path,
                 video_path.stem,
                 process_status="failed",
                 last_error=str(exc),

scripts/pipeline03_upload_to_huggingface.py

@@ -1,8 +1,12 @@
 #!/usr/bin/env python3
 
 import argparse
+import contextlib
+import fcntl
+import hashlib
 import json
 import os
+import random
 import shutil
 import subprocess
 import sys
@@ -20,7 +24,8 @@ REPO_ROOT = Path(__file__).resolve().parents[1]
 if str(REPO_ROOT) not in sys.path:
     sys.path.insert(0, str(REPO_ROOT))
 
-from utils.stats_npz import update_many_video_stats_with_retry
+from utils.stats_npz import apply_status_journal_to_stats, update_many_video_stats_with_retry
+from utils.dataset_pool import find_dataset_video_dir, list_unuploaded_folder_paths as list_unuploaded_folder_paths_pool
 
 
 DEFAULT_DATASET_DIR = REPO_ROOT / "dataset"
@@ -43,17 +48,26 @@ def parse_args() -> argparse.Namespace:
         description="Archive NPZ folders into 14GB tar files and upload them to Hugging Face."
     )
     parser.add_argument("--dataset-dir", type=Path, default=DEFAULT_DATASET_DIR)
+    parser.add_argument("--scratch-dataset-dir", type=Path, default=None)
     parser.add_argument("--raw-video-dir", type=Path, default=DEFAULT_RAW_VIDEO_DIR)
+    parser.add_argument("--scratch-raw-video-dir", type=Path, default=None)
     parser.add_argument("--raw-caption-dir", type=Path, default=DEFAULT_RAW_CAPTION_DIR)
     parser.add_argument("--raw-metadata-dir", type=Path, default=DEFAULT_RAW_METADATA_DIR)
     parser.add_argument("--archive-dir", type=Path, default=DEFAULT_ARCHIVE_DIR)
     parser.add_argument("--progress-path", type=Path, default=DEFAULT_PROGRESS_PATH)
     parser.add_argument("--stats-npz", type=Path, default=DEFAULT_STATS_NPZ)
     parser.add_argument("--status-journal-path", type=Path, default=DEFAULT_STATUS_JOURNAL_PATH)
+    parser.add_argument("--processed-csv-path", type=Path, default=None)
     parser.add_argument("--repo-id", default="SignerX/SignVerse-2M")
     parser.add_argument("--repo-type", default="dataset")
+    parser.add_argument("--repo-revision", default=os.environ.get("HF_REPO_REVISION", "main"))
     parser.add_argument("--target-bytes", type=int, default=DEFAULT_TARGET_BYTES)
     parser.add_argument("--target-folders", type=int, default=DEFAULT_TARGET_FOLDERS)
+    parser.add_argument("--parallel-shards", type=int, default=1)
+    parser.add_argument("--shard-index", type=int, default=0)
+    parser.add_argument("--start-stagger-min", type=int, default=0)
+    parser.add_argument("--start-stagger-max", type=int, default=0)
+    parser.add_argument("--skip-stats-write", action="store_true")
     parser.add_argument("--require-target-bytes", action="store_true", default=True)
     parser.add_argument("--allow-small-final-batch", action="store_true")
     parser.add_argument("--dry-run", action="store_true")
@@ -78,6 +92,22 @@ def resolve_token(cli_token: str | None) -> str | None:
 
 
 
+def journal_lock_path(journal_path: Path) -> Path:
+    return journal_path.with_suffix(journal_path.suffix + '.lock')
+
+
+@contextlib.contextmanager
+def locked_journal(journal_path: Path):
+    lock_path = journal_lock_path(journal_path)
+    lock_path.parent.mkdir(parents=True, exist_ok=True)
+    with lock_path.open('a+', encoding='utf-8') as handle:
+        fcntl.flock(handle.fileno(), fcntl.LOCK_EX)
+        try:
+            yield
+        finally:
+            fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
+
+
 def append_status_journal(journal_path: Path, video_ids: Sequence[str], **updates: str) -> None:
     journal_path.parent.mkdir(parents=True, exist_ok=True)
     payload = {
@@ -85,11 +115,15 @@ def append_status_journal(journal_path: Path, video_ids: Sequence[str], **update
         "updates": {k: ("" if v is None else str(v)) for k, v in updates.items()},
         "recorded_at": time.strftime("%Y-%m-%d %H:%M:%S"),
     }
-    with journal_path.open("a", encoding="utf-8") as handle:
-        handle.write(json.dumps(payload, ensure_ascii=False) + "\n")
+    with locked_journal(journal_path):
+        with journal_path.open("a", encoding="utf-8") as handle:
+            handle.write(json.dumps(payload, ensure_ascii=False) + "\n")
 
 
-def update_many_video_stats_best_effort(stats_path: Path, journal_path: Path, video_ids: Sequence[str], **updates: str) -> None:
+def update_many_video_stats_best_effort(stats_path: Path, journal_path: Path, video_ids: Sequence[str], skip_stats_write: bool = False, **updates: str) -> None:
+    if skip_stats_write:
+        append_status_journal(journal_path, video_ids, **updates)
+        return
     try:
         update_many_video_stats_with_retry(stats_path, video_ids, **updates)
     except Exception as exc:
@@ -98,17 +132,62 @@ def update_many_video_stats_best_effort(stats_path: Path, journal_path: Path, vi
         append_status_journal(journal_path, video_ids, **payload)
         print(f"Warning: stats.npz update deferred to journal due to: {exc}")
 
-def load_progress(progress_path: Path) -> Dict[str, object]:
-    if progress_path.exists():
-        with progress_path.open("r", encoding="utf-8") as handle:
-            return json.load(handle)
+def progress_lock_path(progress_path: Path) -> Path:
+    return progress_path.with_suffix(progress_path.suffix + '.lock')
+
+
+@contextlib.contextmanager
+def locked_progress(progress_path: Path):
+    lock_path = progress_lock_path(progress_path)
+    lock_path.parent.mkdir(parents=True, exist_ok=True)
+    with lock_path.open('a+', encoding='utf-8') as handle:
+        fcntl.flock(handle.fileno(), fcntl.LOCK_EX)
+        try:
+            yield
+        finally:
+            fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
+
+
+def shard_for_video_id(video_id: str, shard_count: int) -> int:
+    if shard_count <= 1:
+        return 0
+    digest = hashlib.sha1(video_id.encode('utf-8')).hexdigest()
+    return int(digest[:8], 16) % shard_count
+
+
+def filter_folders_for_shard(folders: Sequence[Tuple[str, Path]], shard_count: int, shard_index: int) -> List[Tuple[str, Path]]:
+    if shard_count <= 1:
+        return list(folders)
+    return [(video_id, folder_path) for video_id, folder_path in folders if shard_for_video_id(video_id, shard_count) == shard_index]
+
+
+def load_progress(progress_path: Path, retries: int = 8, retry_delay: float = 0.2) -> Dict[str, object]:
+    if not progress_path.exists():
+        return {"archives": {}, "uploaded_folders": {}}
+    last_error = None
+    for _ in range(retries):
+        try:
+            with progress_path.open("r", encoding="utf-8") as handle:
+                data = handle.read()
+            if not data.strip():
+                raise json.JSONDecodeError("empty progress file", data, 0)
+            return json.loads(data)
+        except (json.JSONDecodeError, OSError) as exc:
+            last_error = exc
+            time.sleep(retry_delay)
+    if last_error is not None:
+        raise last_error
     return {"archives": {}, "uploaded_folders": {}}
 
 
 def save_progress(progress_path: Path, progress: Dict[str, object]) -> None:
     progress_path.parent.mkdir(parents=True, exist_ok=True)
-    with progress_path.open("w", encoding="utf-8") as handle:
+    tmp_path = progress_path.parent / f'.{progress_path.name}.{os.getpid()}.tmp'
+    with tmp_path.open("w", encoding="utf-8") as handle:
         json.dump(progress, handle, ensure_ascii=False, indent=2)
+        handle.flush()
+        os.fsync(handle.fileno())
+    os.replace(tmp_path, progress_path)
 
 
 def folder_size_bytes(folder_path: Path) -> int:
@@ -125,20 +204,9 @@ def folder_size_bytes(folder_path: Path) -> int:
     return total
 
 
-def list_unuploaded_folder_paths(dataset_dir: Path, progress: Dict[str, object]) -> List[Tuple[str, Path]]:
+def list_unuploaded_folder_paths(dataset_dir: Path, scratch_dataset_dir: Path | None, progress: Dict[str, object]) -> List[Tuple[str, Path]]:
     uploaded_folders = progress.get("uploaded_folders", {})
-    folders = []
-    for folder_path in sorted(dataset_dir.iterdir()):
-        if not folder_path.is_dir():
-            continue
-        folder_name = folder_path.name
-        if folder_name in uploaded_folders:
-            continue
-        npz_dir = folder_path / "npz"
-        if not (npz_dir / COMPLETE_MARKER_NAME).exists():
-            continue
-        folders.append((folder_name, folder_path))
-    return folders
+    return list_unuploaded_folder_paths_pool(dataset_dir, scratch_dataset_dir, uploaded_folders)
 
 
 def enrich_folder_sizes(folders: Sequence[Tuple[str, Path]]) -> List[Tuple[str, Path, int]]:
@@ -188,23 +256,24 @@ def preferred_temp_archive_dir() -> Path:
     path.mkdir(parents=True, exist_ok=True)
     return path
 
-def create_tar_archive(archive_path: Path, dataset_dir: Path, folder_names: Sequence[str]) -> None:
+def create_tar_archive(archive_path: Path, folder_paths: Sequence[Tuple[str, Path]]) -> None:
     archive_path.parent.mkdir(parents=True, exist_ok=True)
     with tarfile.open(archive_path, mode="w") as tar:
-        for folder_name in folder_names:
-            tar.add(dataset_dir / folder_name, arcname=folder_name, recursive=True)
+        for folder_name, folder_path in folder_paths:
+            tar.add(folder_path, arcname=folder_name, recursive=True)
 
 
-def upload_archive(api: HfApi, repo_id: str, repo_type: str, archive_path: Path) -> None:
+def upload_archive(api: HfApi, repo_id: str, repo_type: str, repo_revision: str, archive_path: Path) -> None:
     api.upload_file(
         path_or_fileobj=str(archive_path),
         path_in_repo=f"dataset/{archive_path.name}",
         repo_id=repo_id,
         repo_type=repo_type,
+        revision=repo_revision,
     )
 
 
-def upload_runtime_state_files(api: HfApi | None, repo_id: str, repo_type: str, progress_path: Path, journal_path: Path) -> None:
+def upload_runtime_state_files(api: HfApi | None, repo_id: str, repo_type: str, repo_revision: str, progress_path: Path, journal_path: Path, stats_path: Path | None = None, processed_csv_path: Path | None = None) -> None:
     if api is None:
         return
     api.upload_file(
@@ -212,6 +281,7 @@ def upload_runtime_state_files(api: HfApi | None, repo_id: str, repo_type: str,
         path_in_repo="runtime_state/archive_upload_progress.json",
         repo_id=repo_id,
         repo_type=repo_type,
+        revision=repo_revision,
     )
     if journal_path.exists():
         api.upload_file(
@@ -219,13 +289,32 @@ def upload_runtime_state_files(api: HfApi | None, repo_id: str, repo_type: str,
             path_in_repo="runtime_state/upload_status_journal.jsonl",
             repo_id=repo_id,
             repo_type=repo_type,
+            revision=repo_revision,
+        )
+    if stats_path is not None and stats_path.exists():
+        api.upload_file(
+            path_or_fileobj=str(stats_path),
+            path_in_repo="runtime_state/stats.npz",
+            repo_id=repo_id,
+            repo_type=repo_type,
+            revision=repo_revision,
+        )
+    if processed_csv_path is not None and processed_csv_path.exists():
+        api.upload_file(
+            path_or_fileobj=str(processed_csv_path),
+            path_in_repo="runtime_state/SignVerse-2M-metadata_processed.csv",
+            repo_id=repo_id,
+            repo_type=repo_type,
+            revision=repo_revision,
         )
 
 
-def upload_archive_streaming(api: HfApi, repo_id: str, repo_type: str, dataset_dir: Path, folder_names: Sequence[str], archive_name: str) -> None:
+def upload_archive_streaming(api: HfApi, repo_id: str, repo_type: str, repo_revision: str, folder_paths: Sequence[Tuple[str, Path]], archive_name: str) -> None:
     if api is None:
         raise RuntimeError('api-stream upload requires a Hugging Face token')
-    command = ['tar', '-cf', '-', '-C', str(dataset_dir), *folder_names]
+    command = ['tar', '-cf', '-']
+    for folder_name, folder_path in folder_paths:
+        command.extend(['-C', str(folder_path.parent), folder_name])
     process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
     assert process.stdout is not None
     stderr_chunks = []
@@ -244,6 +333,7 @@ def upload_archive_streaming(api: HfApi, repo_id: str, repo_type: str, dataset_d
             path_in_repo=f"dataset/{archive_name}",
             repo_id=repo_id,
             repo_type=repo_type,
+            revision=repo_revision,
         )
     finally:
         try:
@@ -273,7 +363,7 @@ def run_git(command: Sequence[str], cwd: Path) -> str:
     return (result.stdout or result.stderr or "").strip()
 
 
-def ensure_git_upload_repo(clone_dir: Path, repo_id: str, repo_type: str) -> Path:
+def ensure_git_upload_repo(clone_dir: Path, repo_id: str, repo_type: str, repo_revision: str) -> Path:
     remote_url = repo_git_url(repo_id, repo_type)
     clone_dir.parent.mkdir(parents=True, exist_ok=True)
     if not (clone_dir / '.git').exists():
@@ -283,7 +373,12 @@ def ensure_git_upload_repo(clone_dir: Path, repo_id: str, repo_type: str) -> Pat
         if configured != remote_url:
             raise RuntimeError(f"Git upload clone remote mismatch: {configured} != {remote_url}")
         run_git(["git", "fetch", "origin"], clone_dir)
-        run_git(["git", "reset", "--hard", "origin/main"], clone_dir)
+        remote_branch = f"origin/{repo_revision}"
+        existing = subprocess.run(["git", "show-ref", "--verify", f"refs/remotes/{remote_branch}"], cwd=str(clone_dir))
+        if existing.returncode == 0:
+            run_git(["git", "checkout", "-B", repo_revision, remote_branch], clone_dir)
+        else:
+            run_git(["git", "checkout", "-B", repo_revision, "origin/main"], clone_dir)
     run_git(["git", "lfs", "install", "--local"], clone_dir)
     try:
         run_git(["git", "config", "user.name"], clone_dir)
@@ -296,13 +391,13 @@ def ensure_git_upload_repo(clone_dir: Path, repo_id: str, repo_type: str) -> Pat
     return clone_dir
 
 
-def list_repo_files_via_git(clone_dir: Path, repo_id: str, repo_type: str) -> List[str]:
-    repo_dir = ensure_git_upload_repo(clone_dir, repo_id, repo_type)
+def list_repo_files_via_git(clone_dir: Path, repo_id: str, repo_type: str, repo_revision: str) -> List[str]:
+    repo_dir = ensure_git_upload_repo(clone_dir, repo_id, repo_type, repo_revision)
     return [path.name for path in repo_dir.iterdir() if path.is_file()]
 
 
-def upload_archive_via_git(clone_dir: Path, repo_id: str, repo_type: str, archive_path: Path) -> None:
-    repo_dir = ensure_git_upload_repo(clone_dir, repo_id, repo_type)
+def upload_archive_via_git(clone_dir: Path, repo_id: str, repo_type: str, repo_revision: str, archive_path: Path) -> None:
+    repo_dir = ensure_git_upload_repo(clone_dir, repo_id, repo_type, repo_revision)
     target_path = repo_dir / archive_path.name
     shutil.copy2(archive_path, target_path)
     run_git(["git", "add", archive_path.name], repo_dir)
@@ -312,50 +407,60 @@ def upload_archive_via_git(clone_dir: Path, repo_id: str, repo_type: str, archiv
     if diff_result.returncode != 1:
         raise RuntimeError(f"git diff --cached failed for {archive_path.name}")
     run_git(["git", "commit", "-m", f"Add {archive_path.name}"], repo_dir)
-    run_git(["git", "push", "origin", "main"], repo_dir)
+    run_git(["git", "push", "origin", repo_revision], repo_dir)
 
 
 def cleanup_local_assets(
     video_ids: Sequence[str],
     dataset_dir: Path,
+    scratch_dataset_dir: Path | None,
     raw_video_dir: Path,
+    scratch_raw_video_dir: Path | None,
     raw_caption_dir: Path,
     raw_metadata_dir: Path,
 ) -> None:
     for video_id in video_ids:
-        dataset_video_dir = dataset_dir / video_id
+        dataset_video_dir = find_dataset_video_dir(video_id, dataset_dir, scratch_dataset_dir)
         if dataset_video_dir.exists():
             shutil.rmtree(dataset_video_dir, ignore_errors=True)
-        for path in raw_video_dir.glob(f"{video_id}.*"):
-            if path.is_file():
-                path.unlink()
+        for raw_dir in [raw_video_dir, scratch_raw_video_dir]:
+            if raw_dir is None:
+                continue
+            for path in raw_dir.glob(f"{video_id}.*"):
+                if path.is_file():
+                    path.unlink()
         caption_dir = raw_caption_dir / video_id
         if caption_dir.exists():
             shutil.rmtree(caption_dir, ignore_errors=True)
         metadata_path = raw_metadata_dir / f"{video_id}.json"
         if metadata_path.exists():
-            metadata_path.unlink()
+            metadata_path.unlink(missing_ok=True)
 
 
 def prune_uploaded_runtime_residue(
     progress: Dict[str, object],
     dataset_dir: Path,
+    scratch_dataset_dir: Path | None,
     raw_video_dir: Path,
+    scratch_raw_video_dir: Path | None,
     raw_caption_dir: Path,
     raw_metadata_dir: Path,
 ) -> None:
     uploaded = set(progress.get("uploaded_folders", {}))
     for video_id in uploaded:
-        for path in raw_video_dir.glob(f"{video_id}.*"):
-            if path.is_file():
-                path.unlink(missing_ok=True)
+        for raw_dir in [raw_video_dir, scratch_raw_video_dir]:
+            if raw_dir is None:
+                continue
+            for path in raw_dir.glob(f"{video_id}.*"):
+                if path.is_file():
+                    path.unlink(missing_ok=True)
         caption_dir = raw_caption_dir / video_id
         if caption_dir.exists():
             shutil.rmtree(caption_dir, ignore_errors=True)
         metadata_path = raw_metadata_dir / f"{video_id}.json"
         if metadata_path.exists():
-            metadata_path.unlink()
-        dataset_video_dir = dataset_dir / video_id
+            metadata_path.unlink(missing_ok=True)
+        dataset_video_dir = find_dataset_video_dir(video_id, dataset_dir, scratch_dataset_dir)
         if dataset_video_dir.exists() and not (dataset_video_dir / "npz" / COMPLETE_MARKER_NAME).exists():
             shutil.rmtree(dataset_video_dir, ignore_errors=True)
 
@@ -371,7 +476,19 @@ def format_size(num_bytes: int) -> str:
 
 def main() -> None:
     args = parse_args()
-    print(f"[pipeline03] start upload_mode={args.upload_mode} repo_id={args.repo_id}", flush=True)
+    if args.parallel_shards < 1:
+        raise ValueError('--parallel-shards must be >= 1')
+    if not (0 <= args.shard_index < args.parallel_shards):
+        raise ValueError('--shard-index must satisfy 0 <= shard-index < parallel-shards')
+    if args.start_stagger_max < args.start_stagger_min:
+        raise ValueError('--start-stagger-max must be >= --start-stagger-min')
+    if args.start_stagger_max > 0:
+        delay = random.randint(args.start_stagger_min, args.start_stagger_max)
+        if delay > 0:
+            print(f"[pipeline03] stagger sleep {delay}s shard={args.shard_index}/{args.parallel_shards}", flush=True)
+            time.sleep(delay)
+    print(f"[pipeline03] start upload_mode={args.upload_mode} repo_id={args.repo_id} shard={args.shard_index}/{args.parallel_shards}", flush=True)
+    skip_stats_write = args.skip_stats_write or args.parallel_shards > 1
     progress = load_progress(args.progress_path)
     print(
         f"[pipeline03] loaded progress archives={len(progress.get('archives', {}))} "
@@ -382,6 +499,8 @@ def main() -> None:
     print(f"[pipeline03] token_present={bool(resolved_token)}", flush=True)
     api = HfApi(token=resolved_token) if args.upload_mode in {"api", "api-stream"} else None
     args.dataset_dir.mkdir(parents=True, exist_ok=True)
+    if args.scratch_dataset_dir is not None:
+        args.scratch_dataset_dir.mkdir(parents=True, exist_ok=True)
 
     try:
         if args.upload_mode in {"api", "api-stream"}:
@@ -389,46 +508,61 @@ def main() -> None:
             repo_files = []
         else:
             print("[pipeline03] listing repo files via git", flush=True)
-            repo_files = list_repo_files_via_git(args.git_clone_dir, args.repo_id, args.repo_type)
+            repo_files = list_repo_files_via_git(args.git_clone_dir, args.repo_id, args.repo_type, args.repo_revision)
     except Exception as exc:
         print(f"[pipeline03] repo file listing failed: {exc}", flush=True)
         traceback.print_exc()
         repo_files = []
 
     while True:
-        prune_uploaded_runtime_residue(
-            progress,
-            args.dataset_dir,
-            args.raw_video_dir,
-            args.raw_caption_dir,
-            args.raw_metadata_dir,
-        )
-        remaining_folder_paths = list_unuploaded_folder_paths(args.dataset_dir, progress)
-        if not remaining_folder_paths:
-            print("No unuploaded dataset folders remain.")
-            break
-        remaining_count = len(remaining_folder_paths)
-        print(f"[pipeline03] remaining completed folders available={remaining_count}", flush=True)
-        if remaining_count >= args.target_folders:
-            selected_folder_paths = remaining_folder_paths[: args.target_folders]
-            batch = enrich_folder_sizes(selected_folder_paths)
-            batch_names = [name for name, _, _ in batch]
-            batch_bytes = sum(folder_bytes for _, _, folder_bytes in batch)
-            print(f"[pipeline03] folder threshold reached; selecting first {len(batch_names)} folders without global size scan", flush=True)
-        else:
-            remaining_folders = enrich_folder_sizes(remaining_folder_paths)
-            remaining_bytes = total_batchable_bytes(remaining_folders)
-            require_target_bytes = args.require_target_bytes and not args.allow_small_final_batch
-            if require_target_bytes and remaining_bytes < args.target_bytes:
-                print(
-                    f"Skip upload: only {format_size(remaining_bytes)} across {remaining_count} completed NPZ folders available, below targets {format_size(args.target_bytes)} or {args.target_folders} folders."
-                )
+        with locked_progress(args.progress_path):
+            progress = load_progress(args.progress_path)
+            prune_uploaded_runtime_residue(
+                progress,
+                args.dataset_dir,
+                args.scratch_dataset_dir,
+                args.raw_video_dir,
+                args.scratch_raw_video_dir,
+                args.raw_caption_dir,
+                args.raw_metadata_dir,
+            )
+            remaining_folder_paths = list_unuploaded_folder_paths(args.dataset_dir, args.scratch_dataset_dir, progress)
+            remaining_folder_paths = filter_folders_for_shard(remaining_folder_paths, args.parallel_shards, args.shard_index)
+            if not remaining_folder_paths:
+                print(f"No unuploaded dataset folders remain for shard {args.shard_index}/{args.parallel_shards}.")
                 break
-            batch = build_batch(remaining_folders, args.target_bytes)
-            batch_names = [name for name, _, _ in batch]
-            batch_bytes = sum(folder_bytes for _, _, folder_bytes in batch)
-        archive_index = next_archive_index(progress, repo_files)
-        archive_name = f"Sign_DWPose_NPZ_{archive_index:06d}.tar"
+            remaining_count = len(remaining_folder_paths)
+            print(f"[pipeline03] remaining completed folders available={remaining_count} shard={args.shard_index}/{args.parallel_shards}", flush=True)
+            if remaining_count >= args.target_folders:
+                selected_folder_paths = remaining_folder_paths[: args.target_folders]
+                batch = enrich_folder_sizes(selected_folder_paths)
+                batch_names = [name for name, _, _ in batch]
+                batch_bytes = sum(folder_bytes for _, _, folder_bytes in batch)
+                print(f"[pipeline03] folder threshold reached; selecting first {len(batch_names)} folders without global size scan", flush=True)
+            else:
+                remaining_folders = enrich_folder_sizes(remaining_folder_paths)
+                remaining_bytes = total_batchable_bytes(remaining_folders)
+                require_target_bytes = args.require_target_bytes and not args.allow_small_final_batch
+                if require_target_bytes and remaining_bytes < args.target_bytes:
+                    print(
+                        f"Skip upload: only {format_size(remaining_bytes)} across {remaining_count} completed NPZ folders available, below targets {format_size(args.target_bytes)} or {args.target_folders} folders."
+                    )
+                    break
+                batch = build_batch(remaining_folders, args.target_bytes)
+                batch_names = [name for name, _, _ in batch]
+                batch_bytes = sum(folder_bytes for _, _, folder_bytes in batch)
+            archive_index = next_archive_index(progress, repo_files)
+            archive_name = f"Sign_DWPose_NPZ_{archive_index:06d}.tar"
+            progress["archives"][archive_name] = {
+                "folders": batch_names,
+                "size_bytes": batch_bytes,
+                "status": "uploading",
+                "reserved_at": time.strftime("%Y-%m-%d %H:%M:%S"),
+                "shard_index": args.shard_index,
+                "parallel_shards": args.parallel_shards,
+            }
+            save_progress(args.progress_path, progress)
+
         archive_root = args.archive_dir if args.upload_mode == "git-ssh" else preferred_temp_archive_dir()
         archive_path = archive_root / archive_name
 
@@ -440,6 +574,10 @@ def main() -> None:
             break
 
         args.archive_dir.mkdir(parents=True, exist_ok=True)
+        try:
+            apply_status_journal_to_stats(args.stats_npz, args.status_journal_path)
+        except Exception as exc:
+            print(f"Warning: pre-upload status compaction skipped due to: {exc}")
         append_status_journal(
             args.status_journal_path,
             batch_names,
@@ -450,14 +588,23 @@ def main() -> None:
         )
         try:
             if args.upload_mode == "api-stream":
-                upload_archive_streaming(api, args.repo_id, args.repo_type, args.dataset_dir, batch_names, archive_name)
+                upload_archive_streaming(api, args.repo_id, args.repo_type, [(name, path) for name, path, _ in batch], archive_name)
             else:
-                create_tar_archive(archive_path, args.dataset_dir, batch_names)
+                create_tar_archive(archive_path, [(name, path) for name, path, _ in batch])
                 if args.upload_mode == "api":
-                    upload_archive(api, args.repo_id, args.repo_type, archive_path)
+                    upload_archive(api, args.repo_id, args.repo_type, args.repo_revision, archive_path)
                 else:
-                    upload_archive_via_git(args.git_clone_dir, args.repo_id, args.repo_type, archive_path)
+                    upload_archive_via_git(args.git_clone_dir, args.repo_id, args.repo_type, args.repo_revision, archive_path)
         except Exception as exc:
+            with locked_progress(args.progress_path):
+                progress = load_progress(args.progress_path)
+                archive_meta = progress.get("archives", {}).get(archive_name, {})
+                if isinstance(archive_meta, dict):
+                    archive_meta["status"] = "failed"
+                    archive_meta["last_error"] = str(exc)
+                    archive_meta["failed_at"] = time.strftime("%Y-%m-%d %H:%M:%S")
+                    progress["archives"][archive_name] = archive_meta
+                    save_progress(args.progress_path, progress)
             update_many_video_stats_best_effort(
                 args.stats_npz,
                 args.status_journal_path,
@@ -465,28 +612,57 @@ def main() -> None:
                 upload_status="failed",
                 local_cleanup_status="pending",
                 archive_name=archive_name,
+                skip_stats_write=skip_stats_write,
                 last_error=str(exc),
                 updated_at=time.strftime("%Y-%m-%d %H:%M:%S"),
             )
+            try:
+                apply_status_journal_to_stats(args.stats_npz, args.status_journal_path)
+            except Exception as compact_exc:
+                print(f"Warning: failed-upload compaction skipped due to: {compact_exc}")
             if archive_path.exists():
                 archive_path.unlink(missing_ok=True)
             raise
 
-        progress["archives"][archive_name] = {
-            "folders": batch_names,
-            "size_bytes": batch_bytes,
-            "uploaded_at": time.strftime("%Y-%m-%d %H:%M:%S"),
-        }
-        for folder_name in batch_names:
-            progress["uploaded_folders"][folder_name] = archive_name
-        save_progress(args.progress_path, progress)
+        with locked_progress(args.progress_path):
+            progress = load_progress(args.progress_path)
+            progress["archives"][archive_name] = {
+                "folders": batch_names,
+                "size_bytes": batch_bytes,
+                "uploaded_at": time.strftime("%Y-%m-%d %H:%M:%S"),
+                "status": "uploaded",
+                "shard_index": args.shard_index,
+                "parallel_shards": args.parallel_shards,
+            }
+            for folder_name in batch_names:
+                progress["uploaded_folders"][folder_name] = archive_name
+            save_progress(args.progress_path, progress)
+
+        repo_files.append(f"dataset/{archive_name}")
+        update_many_video_stats_best_effort(
+            args.stats_npz,
+            args.status_journal_path,
+            batch_names,
+            upload_status="uploaded",
+            local_cleanup_status="pending",
+            archive_name=archive_name,
+            skip_stats_write=skip_stats_write,
+            last_error="",
+            updated_at=time.strftime("%Y-%m-%d %H:%M:%S"),
+        )
+        try:
+            apply_status_journal_to_stats(args.stats_npz, args.status_journal_path)
+        except Exception as exc:
+            print(f"Warning: post-upload status compaction skipped due to: {exc}")
 
         cleanup_error = ""
         try:
             cleanup_local_assets(
                 batch_names,
                 args.dataset_dir,
+                args.scratch_dataset_dir,
                 args.raw_video_dir,
+                args.scratch_raw_video_dir,
                 args.raw_caption_dir,
                 args.raw_metadata_dir,
             )
@@ -494,7 +670,6 @@ def main() -> None:
                 archive_path.unlink(missing_ok=True)
         except Exception as exc:
             cleanup_error = str(exc)
-        repo_files.append(f"dataset/{archive_name}")
         update_many_video_stats_best_effort(
             args.stats_npz,
             args.status_journal_path,
@@ -502,20 +677,29 @@ def main() -> None:
             upload_status="uploaded",
             local_cleanup_status="deleted" if not cleanup_error else "failed",
             archive_name=archive_name,
+            skip_stats_write=skip_stats_write,
             last_error=cleanup_error,
             updated_at=time.strftime("%Y-%m-%d %H:%M:%S"),
         )
-        upload_runtime_state_files(api, args.repo_id, args.repo_type, args.progress_path, args.status_journal_path)
-        prune_uploaded_runtime_residue(
-            progress,
-            args.dataset_dir,
-            args.raw_video_dir,
-            args.raw_caption_dir,
-            args.raw_metadata_dir,
-        )
+        try:
+            apply_status_journal_to_stats(args.stats_npz, args.status_journal_path)
+        except Exception as exc:
+            print(f"Warning: post-cleanup status compaction skipped due to: {exc}")
+        upload_runtime_state_files(api, args.repo_id, args.repo_type, args.repo_revision, args.progress_path, args.status_journal_path, args.stats_npz, args.processed_csv_path if hasattr(args, "processed_csv_path") else None)
+        with locked_progress(args.progress_path):
+            progress = load_progress(args.progress_path)
+            prune_uploaded_runtime_residue(
+                progress,
+                args.dataset_dir,
+                args.scratch_dataset_dir,
+                args.raw_video_dir,
+                args.scratch_raw_video_dir,
+                args.raw_caption_dir,
+                args.raw_metadata_dir,
+            )
         if cleanup_error:
             raise RuntimeError(f"Uploaded {archive_name} but local cleanup failed: {cleanup_error}")
-        print(f"Uploaded {archive_name} and cleaned raw assets for {len(batch_names)} videos.")
+        print(f"Uploaded {archive_name} and cleaned raw assets for {len(batch_names)} videos. shard={args.shard_index}/{args.parallel_shards}")
 
 
 if __name__ == "__main__":

scripts/runtime_status.py

@@ -4,13 +4,16 @@ from __future__ import annotations
 import argparse
 import csv
 import json
+import os
 import re
 import subprocess
 from collections import Counter
 from pathlib import Path
 
+from utils.dataset_pool import count_complete
+
 VIDEO_EXTS = {'.mp4', '.mkv', '.webm', '.mov'}
-ARRAY_RANGE_RE = re.compile(r'^(\d+)_(\[(.+)\])$')
+ARRAY_RANGE_RE = re.compile(r'^(\d+)_\[(.+)\]$')
 PROCESSED_REQUIRED_COLUMNS = {
     'video_id',
     'download_status',
@@ -18,6 +21,8 @@ PROCESSED_REQUIRED_COLUMNS = {
     'upload_status',
     'archive_name',
 }
+GPU_PARTITIONS = ['gpu', 'gpu-redhat', 'cgpu']
+DEFAULT_VIDEOS_PER_DWPOSE_JOB = 20
 
 
 def run_command(cmd: list[str]) -> str:
@@ -34,10 +39,38 @@ def count_claims(directory: Path) -> int:
     return sum(1 for _ in directory.glob('*.claim'))
 
 
-def count_complete(dataset_dir: Path) -> int:
-    if not dataset_dir.exists():
-        return 0
-    return sum(1 for _ in dataset_dir.glob('*/npz/.complete'))
+def aggregate_claims_by_job_key(directory: Path) -> dict[str, int]:
+    counts: Counter[str] = Counter()
+    if not directory.exists():
+        return {}
+    for path in directory.glob('*.claim'):
+        try:
+            lines = path.read_text(encoding='utf-8').splitlines()
+        except OSError:
+            continue
+        job_key = ''
+        for line in lines:
+            if line.startswith('job_key='):
+                job_key = line.split('=', 1)[1].strip()
+                break
+        if job_key:
+            counts[job_key] += 1
+    return dict(counts)
+
+
+def read_videos_per_dwpose_job(root_dir: Path) -> int:
+    worker = root_dir / 'slurm' / 'process_dwpose_array.slurm'
+    if not worker.exists():
+        return DEFAULT_VIDEOS_PER_DWPOSE_JOB
+    try:
+        for line in worker.read_text().splitlines():
+            if line.startswith('VIDEOS_PER_JOB='):
+                m = re.search(r'\$\{VIDEOS_PER_JOB:-([0-9]+)\}', line)
+                if m:
+                    return int(m.group(1))
+    except Exception:
+        pass
+    return DEFAULT_VIDEOS_PER_DWPOSE_JOB
 
 
 def sum_file_sizes(paths: list[Path]) -> int:
@@ -66,7 +99,7 @@ def expand_task_count(jobid_token: str) -> int:
     m = ARRAY_RANGE_RE.match(jobid_token)
     if not m:
         return 1
-    body = m.group(3)
+    body = m.group(2)
     if '%' in body:
         body = body.split('%', 1)[0]
     total = 0
@@ -89,9 +122,11 @@ def queue_status(username: str) -> dict[str, object]:
     output = run_command(['squeue', '-u', username, '-h', '-o', '%i|%j|%T|%P'])
     job_counts: Counter[str] = Counter()
     partition_counts: Counter[str] = Counter()
+    active_tasks_by_partition: Counter[str] = Counter()
     running_dwpose = 0
     running_download = 0
     pending_download = 0
+    pending_dwpose = 0
     if output:
         for line in output.splitlines():
             parts = line.split('|')
@@ -101,23 +136,80 @@ def queue_status(username: str) -> dict[str, object]:
             count = expand_task_count(jobid_token)
             job_counts[f'{job}|{state}'] += count
             partition_counts[f'{job}|{partition}|{state}'] += count
+            if state in {'RUNNING', 'PENDING', 'CONFIGURING'}:
+                active_tasks_by_partition[partition] += count
             if job == 'dwpose' and state == 'RUNNING':
                 running_dwpose += count
             if job == 'download' and state == 'RUNNING':
                 running_download += count
             if job == 'download' and state in {'PENDING', 'CONFIGURING'}:
                 pending_download += count
+            if job == 'dwpose' and state in {'PENDING', 'CONFIGURING'}:
+                pending_dwpose += count
     total_download = running_download + pending_download
     return {
         'running_dwpose': running_dwpose,
         'running_download': running_download,
+        'pending_dwpose_jobs': pending_dwpose,
         'pending_download_jobs': pending_download,
         'total_download_jobs': total_download,
         'job_state_counts': dict(job_counts),
         'job_partition_state_counts': dict(partition_counts),
+        'active_tasks_by_partition': dict(active_tasks_by_partition),
     }
 
 
+def gpu_partition_capacity(partitions: list[str], active_tasks_by_partition: dict[str, int]) -> list[dict[str, object]]:
+    qos_limit_by_part: dict[str, int] = {}
+    qos_output = run_command(['sacctmgr', 'show', 'qos', 'format=Name,MaxSubmitPU', '-P'])
+    if qos_output:
+        for line in qos_output.splitlines():
+            if not line.strip() or '|' not in line:
+                continue
+            name, max_submit = line.split('|', 1)
+            name = name.strip()
+            max_submit = max_submit.strip()
+            if name in partitions and max_submit:
+                try:
+                    qos_limit_by_part[name] = int(max_submit)
+                except ValueError:
+                    pass
+
+    rows: list[dict[str, object]] = []
+    for partition in partitions:
+        free_gpus = 0
+        nodes_output = run_command(['sinfo', '-h', '-N', '-p', partition, '-o', '%N'])
+        nodes = [line.strip() for line in nodes_output.splitlines() if line.strip()]
+        for node in nodes:
+            node_line = run_command(['scontrol', 'show', 'node', node, '-o'])
+            if not node_line:
+                continue
+            state_m = re.search(r'\bState=([^ ]+)', node_line)
+            state = state_m.group(1).lower() if state_m else ''
+            if any(flag in state for flag in ('drain', 'drained', 'down', 'fail', 'inval')):
+                continue
+            cfg_m = re.search(r'\bCfgTRES=.*?(?:,|^)gres/gpu=(\d+)', node_line)
+            alloc_m = re.search(r'\bAllocTRES=.*?(?:,|^)gres/gpu=(\d+)', node_line)
+            total = int(cfg_m.group(1)) if cfg_m else 0
+            used = int(alloc_m.group(1)) if alloc_m else 0
+            free = total - used
+            if free > 0:
+                free_gpus += free
+        active_tasks = int(active_tasks_by_partition.get(partition, 0))
+        qos_limit = qos_limit_by_part.get(partition)
+        submit_slots = free_gpus
+        if qos_limit is not None:
+            submit_slots = min(submit_slots, max(0, qos_limit - active_tasks))
+        rows.append({
+            'partition': partition,
+            'free_gpus': free_gpus,
+            'active_tasks': active_tasks,
+            'qos_limit': qos_limit,
+            'submit_slots': submit_slots,
+        })
+    return rows
+
+
 def filesystem_avail_bytes(path: Path) -> int:
     try:
         proc = subprocess.run(['df', '-B1', str(path)], check=False, capture_output=True, text=True)
@@ -217,9 +309,11 @@ def run_sync(runtime_root: Path) -> str:
         '--source-metadata-csv', str(runtime_root / 'SignVerse-2M-metadata_ori.csv'),
         '--output-metadata-csv', str(runtime_root / 'SignVerse-2M-metadata_processed.csv'),
         '--raw-video-dir', str(runtime_root / 'raw_video'),
+        '--scratch-raw-video-dir', str(Path(f'/scratch/{os.environ.get("USER", "sf895")}/SignVerse-2M-runtime/raw_video')),
         '--raw-caption-dir', str(runtime_root / 'raw_caption'),
         '--raw-metadata-dir', str(runtime_root / 'raw_metadata'),
         '--dataset-dir', str(runtime_root / 'dataset'),
+        '--scratch-dataset-dir', str(Path(f'/scratch/{os.environ.get("USER", "sf895")}/SignVerse-2M-runtime/dataset')),
         '--progress-path', str(runtime_root / 'archive_upload_progress.json'),
         '--status-journal-path', str(runtime_root / 'upload_status_journal.jsonl'),
     ]
@@ -234,16 +328,22 @@ def run_sync(runtime_root: Path) -> str:
 
 
 def main() -> None:
-    parser = argparse.ArgumentParser(description='Report Sign-DWPose runtime status.')
+    parser = argparse.ArgumentParser(description='Report SignVerse runtime status.')
     parser.add_argument('--runtime-root', default='/home/sf895/SignVerse-2M-runtime')
     parser.add_argument('--username', default='sf895')
     parser.add_argument('--no-sync', action='store_true')
     parser.add_argument('--json', action='store_true')
+    parser.add_argument('--include-partitions', action='store_true')
+    parser.add_argument('--scan-complete', action='store_true')
+    parser.add_argument('--scan-runtime-size', action='store_true')
     args = parser.parse_args()
 
     runtime_root = Path(args.runtime_root)
+    root_dir = Path('/cache/home/sf895/SignVerse-2M')
     raw_dir = runtime_root / 'raw_video'
+    scratch_raw_dir = Path(f'/scratch/{os.environ.get("USER", "sf895")}/SignVerse-2M-runtime/raw_video')
     dataset_dir = runtime_root / 'dataset'
+    scratch_dataset_dir = Path(f'/scratch/{os.environ.get("USER", "sf895")}/SignVerse-2M-runtime/dataset')
     claims_dir = runtime_root / 'slurm' / 'state' / 'claims'
     download_claims_dir = runtime_root / 'slurm' / 'state' / 'download_claims'
     progress_path = runtime_root / 'archive_upload_progress.json'
@@ -254,29 +354,32 @@ def main() -> None:
     if not args.no_sync:
         sync_result = run_sync(runtime_root)
 
-    raw_complete: list[Path] = []
+    raw_complete: dict[str, Path] = {}
     raw_temp: list[Path] = []
-    if raw_dir.exists():
-        for path in raw_dir.iterdir():
+    for current_raw_dir in [raw_dir, scratch_raw_dir]:
+        if not current_raw_dir.exists():
+            continue
+        for path in current_raw_dir.iterdir():
             if not path.is_file():
                 continue
             if path.suffix.lower() in VIDEO_EXTS:
-                raw_complete.append(path)
+                raw_complete.setdefault(path.stem, path)
             else:
                 raw_temp.append(path)
 
-    raw_size = sum_file_sizes(raw_complete)
+    raw_size = sum_file_sizes(list(raw_complete.values()))
     runtime_size = 0
     if runtime_root.exists():
-        for path in runtime_root.rglob('*'):
+        proc = subprocess.run(['du', '-sb', str(runtime_root)], check=False, capture_output=True, text=True)
+        if proc.returncode == 0 and proc.stdout.strip():
             try:
-                if path.is_file():
-                    runtime_size += path.stat().st_size
-            except FileNotFoundError:
-                continue
+                runtime_size = int(proc.stdout.split()[0])
+            except Exception:
+                runtime_size = 0
 
     source_rows = read_source_manifest_count(source_csv)
     progress = read_processed_progress(processed_csv)
+    videos_per_dwpose_job = read_videos_per_dwpose_job(root_dir)
 
     payload = {
         'sync_result': sync_result,
@@ -284,7 +387,7 @@ def main() -> None:
         'raw_videos': len(raw_complete),
         'raw_temp_files': len(raw_temp),
         'sent_to_gpu': count_claims(claims_dir),
-        'processed_complete': count_complete(dataset_dir),
+        'processed_complete': count_complete(dataset_dir, scratch_dataset_dir),
         'active_downloads': count_claims(download_claims_dir),
         'uploaded_archives': 0,
         'uploaded_folders': 0,
@@ -308,6 +411,22 @@ def main() -> None:
     payload['uploaded_archives'] = uploaded_archives
     payload['uploaded_folders'] = uploaded_folders
     payload.update(queue_status(args.username))
+    process_claims_by_job = aggregate_claims_by_job_key(claims_dir)
+    payload['videos_per_dwpose_job'] = videos_per_dwpose_job
+    payload['process_claim_job_keys'] = len(process_claims_by_job)
+    payload['process_claim_videos_actual'] = sum(process_claims_by_job.values())
+    payload['process_claim_videos_max_per_job'] = max(process_claims_by_job.values(), default=0)
+    payload['running_dwpose_jobs'] = payload['running_dwpose']
+    payload['running_dwpose_videos_estimated'] = payload['running_dwpose'] * videos_per_dwpose_job
+    payload['pending_dwpose_videos_estimated'] = payload['pending_dwpose_jobs'] * videos_per_dwpose_job
+    payload['total_dwpose_jobs'] = payload['running_dwpose'] + payload['pending_dwpose_jobs']
+    payload['total_dwpose_videos_estimated'] = payload['running_dwpose_videos_estimated'] + payload['pending_dwpose_videos_estimated']
+    if args.include_partitions:
+        payload['gpu_partition_capacity'] = gpu_partition_capacity(GPU_PARTITIONS, payload.get('active_tasks_by_partition', {}))
+    else:
+        payload['gpu_partition_capacity'] = []
+        payload['job_partition_state_counts'] = {}
+        payload['active_tasks_by_partition'] = {}
     payload['csv_row_match'] = (payload['processed_rows'] == payload['source_rows']) if payload['csv_ok'] else False
 
     if args.json:
@@ -320,6 +439,16 @@ def main() -> None:
     print(f"raw_temp_files={payload['raw_temp_files']}")
     print(f"sent_to_gpu={payload['sent_to_gpu']}")
     print(f"running_dwpose={payload['running_dwpose']}")
+    print(f"running_dwpose_jobs={payload['running_dwpose_jobs']}")
+    print(f"pending_dwpose_jobs={payload['pending_dwpose_jobs']}")
+    print(f"total_dwpose_jobs={payload['total_dwpose_jobs']}")
+    print(f"videos_per_dwpose_job={payload['videos_per_dwpose_job']}")
+    print(f"process_claim_job_keys={payload['process_claim_job_keys']}")
+    print(f"process_claim_videos_actual={payload['process_claim_videos_actual']}")
+    print(f"process_claim_videos_max_per_job={payload['process_claim_videos_max_per_job']}")
+    print(f"running_dwpose_videos_estimated={payload['running_dwpose_videos_estimated']}")
+    print(f"pending_dwpose_videos_estimated={payload['pending_dwpose_videos_estimated']}")
+    print(f"total_dwpose_videos_estimated={payload['total_dwpose_videos_estimated']}")
     print(f"processed_complete={payload['processed_complete']}")
     print(f"active_downloads={payload['active_downloads']}")
     print(f"running_download_jobs={payload['running_download']}")
@@ -339,6 +468,14 @@ def main() -> None:
     print(f"process_ok_rows={payload['process_ok_rows']}")
     print(f"process_running_rows={payload['process_running_rows']}")
     print(f"upload_uploaded_rows={payload['upload_uploaded_rows']}")
+    for key in sorted(payload.get('job_partition_state_counts', {})):
+        print(f"job_partition_state[{key}]={payload['job_partition_state_counts'][key]}")
+    for row in payload.get('gpu_partition_capacity', []):
+        qos_limit = row['qos_limit'] if row['qos_limit'] is not None else 'na'
+        print(
+            f"gpu_partition[{row['partition']}]=free_gpus={row['free_gpus']},"
+            f"active_tasks={row['active_tasks']},qos_limit={qos_limit},submit_slots={row['submit_slots']}"
+        )
     print(f"raw_size={human_bytes(payload['raw_size_bytes'])}")
     print(f"runtime_size={human_bytes(payload['runtime_size_bytes'])}")
     print(f"filesystem_avail={human_bytes(payload['filesystem_avail_bytes'])}")

scripts/sync_processed_csv_from_runtime.py

@@ -35,6 +35,9 @@ DEFAULT_COLUMNS = [
 VIDEO_EXTS = {'.mp4', '.mkv', '.webm', '.mov'}
 
 
+from utils.dataset_pool import complete_video_ids
+
+
 def read_csv_rows(path: Path) -> Tuple[List[Dict[str, str]], List[str]]:
     text = path.read_text(encoding='utf-8-sig')
     lines = [line for line in text.splitlines() if line.strip()]
@@ -104,9 +107,11 @@ def main():
     ap.add_argument('--source-metadata-csv', type=Path, required=True)
     ap.add_argument('--output-metadata-csv', type=Path, required=True)
     ap.add_argument('--raw-video-dir', type=Path, required=True)
+    ap.add_argument('--scratch-raw-video-dir', type=Path, default=None)
     ap.add_argument('--raw-caption-dir', type=Path, required=True)
     ap.add_argument('--raw-metadata-dir', type=Path, required=True)
     ap.add_argument('--dataset-dir', type=Path, required=True)
+    ap.add_argument('--scratch-dataset-dir', type=Path, default=None)
     ap.add_argument('--progress-path', type=Path, required=True)
     ap.add_argument('--status-journal-path', type=Path, required=True)
     args = ap.parse_args()
@@ -131,9 +136,15 @@ def main():
                     merged[k] = out_by_id[vid].get(k, '')
         rows.append(merged)
 
-    raw_videos = {p.stem: p for p in args.raw_video_dir.iterdir() if p.is_file() and p.suffix.lower() in VIDEO_EXTS} if args.raw_video_dir.exists() else {}
+    raw_videos = {}
+    if args.raw_video_dir.exists():
+        raw_videos.update({p.stem: p for p in args.raw_video_dir.iterdir() if p.is_file() and p.suffix.lower() in VIDEO_EXTS})
+    if args.scratch_raw_video_dir is not None and args.scratch_raw_video_dir.exists():
+        for p in args.scratch_raw_video_dir.iterdir():
+            if p.is_file() and p.suffix.lower() in VIDEO_EXTS and p.stem not in raw_videos:
+                raw_videos[p.stem] = p
     raw_metadata = {p.stem: p for p in args.raw_metadata_dir.glob('*.json')} if args.raw_metadata_dir.exists() else {}
-    complete = {p.parent.parent.name for p in args.dataset_dir.glob('*/npz/.complete')} if args.dataset_dir.exists() else set()
+    complete = complete_video_ids(args.dataset_dir, args.scratch_dataset_dir)
     process_claims_dir = args.dataset_dir.parent / 'slurm' / 'state' / 'claims'
     download_claims_dir = args.dataset_dir.parent / 'slurm' / 'state' / 'download_claims'
     process_claims = {p.stem for p in process_claims_dir.glob('*.claim')} if process_claims_dir.exists() else set()

slurm/orchestrator_autorestart.slurm

@@ -6,26 +6,29 @@
 #SBATCH --cpus-per-task=1
 #SBATCH --mem=512M
 #SBATCH --time=12:30:00
-#SBATCH --output=/home/sf895/SignVerse-2M-runtime/slurm/logs/orchestrator_launcher_%j.out
-#SBATCH --error=/home/sf895/SignVerse-2M-runtime/slurm/logs/orchestrator_launcher_%j.err
+#SBATCH --output=/scratch/%u/SignVerse-2M-runtime/slurm/logs/orchestrator_launcher_%j.out
+#SBATCH --error=/scratch/%u/SignVerse-2M-runtime/slurm/logs/orchestrator_launcher_%j.err
 
 set -euo pipefail
 
 ROOT_DIR="${ROOT_DIR:-/cache/home/sf895/SignVerse-2M}"
 RUNTIME_ROOT="${RUNTIME_ROOT:-/home/sf895/SignVerse-2M-runtime}"
+RUNTIME_LOG_ROOT="${RUNTIME_LOG_ROOT:-/scratch/$USER/SignVerse-2M-runtime/slurm/logs}"
 ORCH_SUBMIT_SCRIPT="${ORCH_SUBMIT_SCRIPT:-$ROOT_DIR/reproduce_independently_slurm.sh}"
 STOP_FILE="${STOP_FILE:-$RUNTIME_ROOT/STOP_AUTORESTART}"
 ROTATE_SECONDS="${ROTATE_SECONDS:-43200}"
 CHECK_INTERVAL_SECONDS="${CHECK_INTERVAL_SECONDS:-60}"
 ORCHESTRATOR_TIME="${ORCHESTRATOR_TIME:-12:00:00}"
-LAUNCHER_SCRIPT="${LAUNCHER_SCRIPT:-$(readlink -f "$0")}"
+LAUNCHER_SCRIPT="${LAUNCHER_SCRIPT:-$ROOT_DIR/slurm/orchestrator_autorestart.slurm}"
 LAUNCHER_PARTITION="${LAUNCHER_PARTITION:-main}"
 LAUNCHER_ACCOUNT="${LAUNCHER_ACCOUNT:-}"
 LAUNCHER_TIME="${LAUNCHER_TIME:-12:30:00}"
 LAUNCHER_CPUS_PER_TASK="${LAUNCHER_CPUS_PER_TASK:-1}"
 LAUNCHER_MEM="${LAUNCHER_MEM:-512M}"
+REAP_PENDING_ON_ROTATE="${REAP_PENDING_ON_ROTATE:-1}"
+REAP_JOB_NAMES="${REAP_JOB_NAMES:-dwpose download}"
 
-mkdir -p "$RUNTIME_ROOT/slurm/logs"
+mkdir -p "$RUNTIME_ROOT/slurm/logs" "$RUNTIME_LOG_ROOT"
 
 now_ts() {
   date '+%Y-%m-%d %H:%M:%S'
@@ -39,9 +42,34 @@ current_orchestrator_ids() {
   squeue -u "$USER" -h -o '%A|%j|%T' | awk -F'|' '$2=="sign-dwpose-orch" && ($3=="RUNNING" || $3=="PENDING" || $3=="CONFIGURING") {print $1}'
 }
 
+current_reapable_pending_ids() {
+  local names_regex
+  names_regex="$(printf '%s\n' $REAP_JOB_NAMES | paste -sd'|' -)"
+  squeue -u "$USER" -h -o '%A|%j|%T' | awk -F'|' -v names_re="$names_regex" '$2 ~ ("^(" names_re ")$") && $3=="PENDING" {print $1}' | sort -u
+}
+
+cancel_reapable_pending_jobs() {
+  [[ "$REAP_PENDING_ON_ROTATE" == "1" ]] || return 0
+  local ids
+  ids="$(current_reapable_pending_ids || true)"
+  if [[ -n "$ids" ]]; then
+    log "cancelling stale pending worker jobs: $(echo "$ids" | tr '\n' ' ')"
+    scancel $ids || true
+  else
+    log "no stale pending worker jobs to cancel"
+  fi
+}
+
 submit_orchestrator() {
   log "submitting orchestration with ORCHESTRATOR_TIME=$ORCHESTRATOR_TIME"
-  env     -u SLURM_JOB_ID     -u SLURM_JOB_NAME     -u SLURM_JOB_NODELIST     -u SLURM_ARRAY_JOB_ID     -u SLURM_ARRAY_TASK_ID     ORCHESTRATOR_TIME="$ORCHESTRATOR_TIME"     bash "$ORCH_SUBMIT_SCRIPT"
+  env \
+    -u SLURM_JOB_ID \
+    -u SLURM_JOB_NAME \
+    -u SLURM_JOB_NODELIST \
+    -u SLURM_ARRAY_JOB_ID \
+    -u SLURM_ARRAY_TASK_ID \
+    ORCHESTRATOR_TIME="$ORCHESTRATOR_TIME" \
+    bash "$ORCH_SUBMIT_SCRIPT"
 }
 
 cancel_orchestrators() {
@@ -62,7 +90,7 @@ submit_next_launcher() {
   if [[ -n "$LAUNCHER_ACCOUNT" ]]; then
     cmd+=("--account=$LAUNCHER_ACCOUNT")
   fi
-  cmd+=("--export=ALL,ROOT_DIR=$ROOT_DIR,RUNTIME_ROOT=$RUNTIME_ROOT,ORCH_SUBMIT_SCRIPT=$ORCH_SUBMIT_SCRIPT,STOP_FILE=$STOP_FILE,ROTATE_SECONDS=$ROTATE_SECONDS,CHECK_INTERVAL_SECONDS=$CHECK_INTERVAL_SECONDS,ORCHESTRATOR_TIME=$ORCHESTRATOR_TIME,LAUNCHER_SCRIPT=$LAUNCHER_SCRIPT,LAUNCHER_PARTITION=$LAUNCHER_PARTITION,LAUNCHER_ACCOUNT=$LAUNCHER_ACCOUNT,LAUNCHER_TIME=$LAUNCHER_TIME,LAUNCHER_CPUS_PER_TASK=$LAUNCHER_CPUS_PER_TASK,LAUNCHER_MEM=$LAUNCHER_MEM")
+  cmd+=("--export=ALL,ROOT_DIR=$ROOT_DIR,RUNTIME_ROOT=$RUNTIME_ROOT,RUNTIME_LOG_ROOT=$RUNTIME_LOG_ROOT,ORCH_SUBMIT_SCRIPT=$ORCH_SUBMIT_SCRIPT,STOP_FILE=$STOP_FILE,ROTATE_SECONDS=$ROTATE_SECONDS,CHECK_INTERVAL_SECONDS=$CHECK_INTERVAL_SECONDS,ORCHESTRATOR_TIME=$ORCHESTRATOR_TIME,LAUNCHER_SCRIPT=$LAUNCHER_SCRIPT,LAUNCHER_PARTITION=$LAUNCHER_PARTITION,LAUNCHER_ACCOUNT=$LAUNCHER_ACCOUNT,LAUNCHER_TIME=$LAUNCHER_TIME,LAUNCHER_CPUS_PER_TASK=$LAUNCHER_CPUS_PER_TASK,LAUNCHER_MEM=$LAUNCHER_MEM,REAP_PENDING_ON_ROTATE=$REAP_PENDING_ON_ROTATE,REAP_JOB_NAMES=$REAP_JOB_NAMES")
   cmd+=("$LAUNCHER_SCRIPT")
   log "submitting next launcher"
   "${cmd[@]}"
@@ -75,6 +103,7 @@ if [[ -f "$STOP_FILE" ]]; then
 fi
 
 if [[ -z "$(current_orchestrator_ids || true)" ]]; then
+  cancel_reapable_pending_jobs
   submit_orchestrator
 else
   log "existing orchestration detected; not submitting a duplicate"
@@ -86,7 +115,8 @@ while (( elapsed < ROTATE_SECONDS )); do
     exit 0
   fi
   if [[ -z "$(current_orchestrator_ids || true)" ]]; then
-    log "no live orchestration detected; submitting a replacement"
+    log "no live orchestration detected; reaping old pending workers before replacement"
+    cancel_reapable_pending_jobs
     submit_orchestrator
   fi
   sleep "$CHECK_INTERVAL_SECONDS"
@@ -98,7 +128,8 @@ if [[ -f "$STOP_FILE" ]]; then
   exit 0
 fi
 
-log "rotation boundary reached; restarting orchestration and handing off to next launcher"
+log "rotation boundary reached; reaping old pending workers and restarting orchestration"
+cancel_reapable_pending_jobs
 cancel_orchestrators
 sleep 5
 submit_orchestrator

slurm/process_download_array.slurm

@@ -18,10 +18,14 @@ CONDA_ENV="${CONDA_ENV:-signx2}"
 SOURCE_METADATA_CSV="${SOURCE_METADATA_CSV:-$RUNTIME_ROOT/SignVerse-2M-metadata_ori.csv}"
 OUTPUT_METADATA_CSV="${OUTPUT_METADATA_CSV:-$RUNTIME_ROOT/SignVerse-2M-metadata_processed.csv}"
 RAW_VIDEO_DIR="${RAW_VIDEO_DIR:-$RUNTIME_ROOT/raw_video}"
+SCRATCH_RAW_VIDEO_DIR="${SCRATCH_RAW_VIDEO_DIR:-/scratch/$USER/SignVerse-2M-runtime/raw_video}"
+HOME_RAW_VIDEO_LIMIT="${HOME_RAW_VIDEO_LIMIT:-180}"
+SCRATCH_RAW_VIDEO_LIMIT="${SCRATCH_RAW_VIDEO_LIMIT:-2800}"
 RAW_CAPTION_DIR="${RAW_CAPTION_DIR:-$RUNTIME_ROOT/raw_caption}"
 RAW_METADATA_DIR="${RAW_METADATA_DIR:-$RUNTIME_ROOT/raw_metadata}"
 DATASET_DIR="${DATASET_DIR:-$RUNTIME_ROOT/dataset}"
 STATS_NPZ="${STATS_NPZ:-$RUNTIME_ROOT/stats.npz}"
+STATUS_JOURNAL_PATH="${STATUS_JOURNAL_PATH:-$RUNTIME_ROOT/upload_status_journal.jsonl}"
 PIPELINE01="${PIPELINE01:-$ROOT_DIR/scripts/pipeline01_download_video_fix_caption.py}"
 DOWNLOAD_CLAIM_DIR="${DOWNLOAD_CLAIM_DIR:-$STATE_ROOT/slurm/state/download_claims}"
 DOWNLOAD_CSV_LOCK_PATH="${DOWNLOAD_CSV_LOCK_PATH:-$STATE_ROOT/SignVerse-2M-metadata_processed.csv.lock}"
@@ -84,10 +88,14 @@ cmd=(python "$PIPELINE01"
   --source-metadata-csv "$SOURCE_METADATA_CSV"
   --output-metadata-csv "$OUTPUT_METADATA_CSV"
   --raw-video-dir "$RAW_VIDEO_DIR"
+  --scratch-raw-video-dir "$SCRATCH_RAW_VIDEO_DIR"
+  --home-raw-video-limit "$HOME_RAW_VIDEO_LIMIT"
+  --scratch-raw-video-limit "$SCRATCH_RAW_VIDEO_LIMIT"
   --raw-caption-dir "$RAW_CAPTION_DIR"
   --raw-metadata-dir "$RAW_METADATA_DIR"
   --dataset-dir "$DATASET_DIR"
   --stats-npz "$STATS_NPZ"
+  --status-journal-path "$STATUS_JOURNAL_PATH"
   --csv-lock-path "$DOWNLOAD_CSV_LOCK_PATH"
   --limit 1
   --video-ids="$VIDEO_ID"

slurm/process_dwpose_array.slurm

@@ -15,10 +15,13 @@ ROOT_DIR="${ROOT_DIR:-/home/sf895/SignVerse-2M}"
 RUNTIME_ROOT="${RUNTIME_ROOT:-/home/sf895/SignVerse-2M-runtime}"
 STATE_ROOT="${STATE_ROOT:-/home/sf895/SignVerse-2M-runtime}"
 CONDA_SH="${CONDA_SH:-/home/sf895/miniconda3/etc/profile.d/conda.sh}"
-CONDA_ENV="${CONDA_ENV:-dwpose}"
+CONDA_ENV="${CONDA_ENV:-signx2}"
 RAW_VIDEO_DIR="${RAW_VIDEO_DIR:-$RUNTIME_ROOT/raw_video}"
+SCRATCH_RAW_VIDEO_DIR="${SCRATCH_RAW_VIDEO_DIR:-/scratch/$USER/SignVerse-2M-runtime/raw_video}"
 DATASET_DIR="${DATASET_DIR:-$RUNTIME_ROOT/dataset}"
+SCRATCH_DATASET_DIR="${SCRATCH_DATASET_DIR:-/scratch/$USER/SignVerse-2M-runtime/dataset}"
 STATS_NPZ="${STATS_NPZ:-$RUNTIME_ROOT/stats.npz}"
+STATUS_JOURNAL_PATH="${STATUS_JOURNAL_PATH:-$RUNTIME_ROOT/upload_status_journal.jsonl}"
 PIPELINE02="${PIPELINE02:-$ROOT_DIR/scripts/pipeline02_extract_dwpose_from_video.py}"
 FPS="${FPS:-24}"
 TMP_ROOT="${TMP_ROOT:-${SLURM_TMPDIR:-/tmp}}"
@@ -27,6 +30,15 @@ DELETE_SOURCE_ON_SUCCESS="${DELETE_SOURCE_ON_SUCCESS:-0}"
 CLAIM_DIR="${CLAIM_DIR:-$STATE_ROOT/slurm/state/claims}"
 RETRY_DIR="${RETRY_DIR:-$STATE_ROOT/slurm/state/gpu_init_retries}"
 MAX_GPU_INIT_RETRIES="${MAX_GPU_INIT_RETRIES:-3}"
+OPTIMIZED_MODE="${OPTIMIZED_MODE:-1}"
+OPTIMIZED_PROVIDER="${OPTIMIZED_PROVIDER:-cuda}"
+OPTIMIZED_FRAME_BATCH_SIZE="${OPTIMIZED_FRAME_BATCH_SIZE:-8}"
+OPTIMIZED_DETECT_RESOLUTION="${OPTIMIZED_DETECT_RESOLUTION:-512}"
+OPTIMIZED_FRAME_STRIDE="${OPTIMIZED_FRAME_STRIDE:-1}"
+OPTIMIZED_IO_BINDING="${OPTIMIZED_IO_BINDING:-1}"
+OPTIMIZED_GPU_DETECTOR_POSTPROCESS="${OPTIMIZED_GPU_DETECTOR_POSTPROCESS:-1}"
+OPTIMIZED_GPU_POSE_PREPROCESS="${OPTIMIZED_GPU_POSE_PREPROCESS:-0}"
+VIDEOS_PER_JOB="${VIDEOS_PER_JOB:-5}"
 
 MANIFEST="${MANIFEST:-${1:-}}"
 if [[ -z "$MANIFEST" ]]; then
@@ -46,24 +58,25 @@ if [[ ! -f "$CONDA_SH" ]]; then
   exit 1
 fi
 
-VIDEO_ID="$(sed -n "$((SLURM_ARRAY_TASK_ID + 1))p" "$MANIFEST")"
-if [[ -z "$VIDEO_ID" ]]; then
-  echo "No video id found for task index ${SLURM_ARRAY_TASK_ID} in manifest $MANIFEST" >&2
+mapfile -t ALL_VIDEO_IDS < <(sed -n "$((SLURM_ARRAY_TASK_ID * VIDEOS_PER_JOB + 1)),$(((SLURM_ARRAY_TASK_ID + 1) * VIDEOS_PER_JOB))p" "$MANIFEST")
+if [[ "${#ALL_VIDEO_IDS[@]}" -eq 0 ]]; then
+  echo "No video ids found for task index ${SLURM_ARRAY_TASK_ID} in manifest $MANIFEST" >&2
   exit 1
 fi
 
 mkdir -p "$CLAIM_DIR" "$RETRY_DIR"
-CLAIM_PATH="$CLAIM_DIR/${VIDEO_ID}.claim"
-RETRY_STATE_PATH="$RETRY_DIR/${VIDEO_ID}.state"
-cleanup_claim() {
-  rm -f "$CLAIM_PATH"
+cleanup_claims() {
+  local video_id
+  for video_id in "${ALL_VIDEO_IDS[@]}"; do
+    rm -f "$CLAIM_DIR/${video_id}.claim"
+  done
 }
-trap cleanup_claim EXIT
+trap cleanup_claims EXIT
 
 export OMP_NUM_THREADS="${SLURM_CPUS_PER_TASK:-1}"
 export MKL_NUM_THREADS="${SLURM_CPUS_PER_TASK:-1}"
 
-echo "[$(date '+%F %T')] job=${SLURM_JOB_ID:-na} task=${SLURM_ARRAY_TASK_ID} host=$(hostname) gpu=${CUDA_VISIBLE_DEVICES:-unset} video_id=$VIDEO_ID"
+echo "[$(date '+%F %T')] job=${SLURM_JOB_ID:-na} task=${SLURM_ARRAY_TASK_ID} host=$(hostname) gpu=${CUDA_VISIBLE_DEVICES:-unset} videos=${#ALL_VIDEO_IDS[@]} first_video=${ALL_VIDEO_IDS[0]}"
 
 # shellcheck disable=SC1090
 source "$CONDA_SH"
@@ -88,11 +101,13 @@ echo "Using conda env prefix=$CONDA_ENV_PREFIX"
 echo "Using LD_PRELOAD=$LD_PRELOAD"
 
 gpu_init_retry_state() {
-  local attempts="$1"
-  local host_name="$2"
-  local gpu_id="$3"
-  local reason="$4"
-  cat > "$RETRY_STATE_PATH" <<STATE
+  local video_id="$1"
+  local attempts="$2"
+  local host_name="$3"
+  local gpu_id="$4"
+  local reason="$5"
+  local retry_state_path="$RETRY_DIR/${video_id}.state"
+  cat > "$retry_state_path" <<STATE
 attempts=$attempts
 host=$host_name
 gpu=$gpu_id
@@ -102,35 +117,41 @@ STATE
 }
 
 get_retry_attempts() {
-  if [[ -f "$RETRY_STATE_PATH" ]]; then
-    awk -F'=' '/^attempts=/{print $2}' "$RETRY_STATE_PATH" | tail -n 1
+  local video_id="$1"
+  local retry_state_path="$RETRY_DIR/${video_id}.state"
+  if [[ -f "$retry_state_path" ]]; then
+    awk -F'=' '/^attempts=/{print $2}' "$retry_state_path" | tail -n 1
   else
     echo 0
   fi
 }
 
 mark_retry_exhausted() {
-  local attempts="$1"
-  local reason="$2"
+  local video_id="$1"
+  local attempts="$2"
+  local reason="$3"
   python - <<PY
 from pathlib import Path
 import sys, time
 root = Path(r"$ROOT_DIR")
 stats_path = Path(r"$STATS_NPZ")
-video_id = r"$VIDEO_ID"
+video_id = r"$video_id"
 attempts = int(r"$attempts")
 reason = r'''$reason'''
 sys.path.insert(0, str(root))
-from utils.stats_npz import update_video_stats
-update_video_stats(
+from utils.stats_npz import update_video_stats_best_effort
+journal_path = Path(r"$STATUS_JOURNAL_PATH")
+update_video_stats_best_effort(
     stats_path,
+    journal_path,
     video_id,
     process_status="skipped",
     last_error=f"gpu_init_retry_exhausted after {attempts} attempts: {reason}",
     updated_at=time.strftime("%Y-%m-%d %H:%M:%S"),
 )
 PY
-  rm -f "$RAW_VIDEO_DIR/$VIDEO_ID.mp4" "$RAW_VIDEO_DIR/$VIDEO_ID.mkv" "$RAW_VIDEO_DIR/$VIDEO_ID.webm" "$RAW_VIDEO_DIR/$VIDEO_ID.mov"
+  rm -f "$RAW_VIDEO_DIR/$video_id.mp4" "$RAW_VIDEO_DIR/$video_id.mkv" "$RAW_VIDEO_DIR/$video_id.webm" "$RAW_VIDEO_DIR/$video_id.mov"
+  rm -f "$SCRATCH_RAW_VIDEO_DIR/$video_id.mp4" "$SCRATCH_RAW_VIDEO_DIR/$video_id.mkv" "$SCRATCH_RAW_VIDEO_DIR/$video_id.webm" "$SCRATCH_RAW_VIDEO_DIR/$video_id.mov"
 }
 
 should_retry_gpu_init_failure() {
@@ -153,44 +174,81 @@ env_cmd=(env
   "CONDA_NO_PLUGINS=true"
 )
 
-cmd=(python -u "$PIPELINE02"
+cmd_base=(python -u "$PIPELINE02"
   --raw-video-dir "$RAW_VIDEO_DIR"
+  --scratch-raw-video-dir "$SCRATCH_RAW_VIDEO_DIR"
   --dataset-dir "$DATASET_DIR"
+  --scratch-dataset-dir "$SCRATCH_DATASET_DIR"
   --stats-npz "$STATS_NPZ"
+  --status-journal-path "$STATUS_JOURNAL_PATH"
   --fps "$FPS"
   --workers 1
   --tmp-root "$TMP_ROOT"
-  --video-ids="$VIDEO_ID"
 )
+if [[ "$OPTIMIZED_MODE" == "1" ]]; then
+  cmd_base+=(--optimized-mode)
+  cmd_base+=(--optimized-provider "$OPTIMIZED_PROVIDER")
+  cmd_base+=(--optimized-frame-batch-size "$OPTIMIZED_FRAME_BATCH_SIZE")
+  cmd_base+=(--optimized-detect-resolution "$OPTIMIZED_DETECT_RESOLUTION")
+  cmd_base+=(--optimized-frame-stride "$OPTIMIZED_FRAME_STRIDE")
+  if [[ "$OPTIMIZED_IO_BINDING" == "1" ]]; then
+    cmd_base+=(--optimized-io-binding)
+  fi
+  if [[ "$OPTIMIZED_GPU_DETECTOR_POSTPROCESS" == "1" ]]; then
+    cmd_base+=(--optimized-gpu-detector-postprocess)
+  fi
+  if [[ "$OPTIMIZED_GPU_POSE_PREPROCESS" == "1" ]]; then
+    cmd_base+=(--optimized-gpu-pose-preprocess)
+  fi
+else
+  cmd_base+=(--legacy-mode)
+fi
 if [[ "$FORCE_PROCESS" == "1" ]]; then
-  cmd+=(--force)
+  cmd_base+=(--force)
 fi
 if [[ "$DELETE_SOURCE_ON_SUCCESS" == "1" ]]; then
-  cmd+=(--delete-source-on-success)
+  cmd_base+=(--delete-source-on-success)
 fi
 
-TMP_LOG="$(mktemp "${TMP_ROOT%/}/dwpose_${VIDEO_ID}_XXXX.log")"
-set +e
-"${env_cmd[@]}" conda run -n "$CONDA_ENV" "${cmd[@]}" 2>&1 | tee "$TMP_LOG"
-cmd_status=${PIPESTATUS[0]}
-set -e
-
-if [[ "$cmd_status" -ne 0 ]]; then
-  npz_dir="$DATASET_DIR/$VIDEO_ID/npz"
-  if should_retry_gpu_init_failure "$TMP_LOG" "$npz_dir"; then
-    attempts="$(get_retry_attempts)"
-    attempts="$((attempts + 1))"
-    last_reason="$(tail -n 80 "$TMP_LOG" | tr '\n' ' ' | sed 's/[[:space:]]\+/ /g' | cut -c1-1200)"
-    gpu_init_retry_state "$attempts" "$(hostname)" "${CUDA_VISIBLE_DEVICES:-unset}" "$last_reason"
-    if [[ "$attempts" -ge "$MAX_GPU_INIT_RETRIES" ]]; then
-      echo "GPU init failed on multiple GPUs; marking $VIDEO_ID as skipped after $attempts attempts." >&2
-      mark_retry_exhausted "$attempts" "$last_reason"
-      exit 0
+overall_status=0
+for VIDEO_ID in "${ALL_VIDEO_IDS[@]}"; do
+  [[ -z "$VIDEO_ID" ]] && continue
+  CLAIM_PATH="$CLAIM_DIR/${VIDEO_ID}.claim"
+  RETRY_STATE_PATH="$RETRY_DIR/${VIDEO_ID}.state"
+  echo "[$(date '+%F %T')] job=${SLURM_JOB_ID:-na} task=${SLURM_ARRAY_TASK_ID} host=$(hostname) gpu=${CUDA_VISIBLE_DEVICES:-unset} video_id=$VIDEO_ID"
+
+  TMP_LOG="$(mktemp "${TMP_ROOT%/}/dwpose_${VIDEO_ID}_XXXX.log")"
+  cmd=("${cmd_base[@]}" --video-ids="$VIDEO_ID")
+  set +e
+  "${env_cmd[@]}" conda run -n "$CONDA_ENV" "${cmd[@]}" 2>&1 | tee "$TMP_LOG"
+  cmd_status=${PIPESTATUS[0]}
+  set -e
+
+  if [[ "$cmd_status" -ne 0 ]]; then
+    npz_dir="$DATASET_DIR/$VIDEO_ID/npz"
+    if [[ ! -d "$npz_dir" && -d "$SCRATCH_DATASET_DIR/$VIDEO_ID/npz" ]]; then
+      npz_dir="$SCRATCH_DATASET_DIR/$VIDEO_ID/npz"
     fi
-    echo "GPU init failure for $VIDEO_ID on host=$(hostname) gpu=${CUDA_VISIBLE_DEVICES:-unset}; retry attempt $attempts/$MAX_GPU_INIT_RETRIES will be resubmitted later." >&2
-    exit 0
+    if should_retry_gpu_init_failure "$TMP_LOG" "$npz_dir"; then
+      attempts="$(get_retry_attempts "$VIDEO_ID")"
+      attempts="$((attempts + 1))"
+      last_reason="$(tail -n 80 "$TMP_LOG" | tr '\n' ' ' | sed 's/[[:space:]]\+/ /g' | cut -c1-1200)"
+      gpu_init_retry_state "$VIDEO_ID" "$attempts" "$(hostname)" "${CUDA_VISIBLE_DEVICES:-unset}" "$last_reason"
+      if [[ "$attempts" -ge "$MAX_GPU_INIT_RETRIES" ]]; then
+        echo "GPU init failed on multiple GPUs; marking $VIDEO_ID as skipped after $attempts attempts." >&2
+        mark_retry_exhausted "$VIDEO_ID" "$attempts" "$last_reason"
+        rm -f "$CLAIM_PATH"
+        continue
+      fi
+      echo "GPU init failure for $VIDEO_ID on host=$(hostname) gpu=${CUDA_VISIBLE_DEVICES:-unset}; retry attempt $attempts/$MAX_GPU_INIT_RETRIES will be resubmitted later." >&2
+      overall_status="$cmd_status"
+      break
+    fi
+    overall_status="$cmd_status"
+    break
   fi
-  exit "$cmd_status"
-fi
 
-rm -f "$RETRY_STATE_PATH"
+  rm -f "$RETRY_STATE_PATH" "$CLAIM_PATH"
+done
+
+exit "$overall_status"

slurm/process_upload_parallel_array.slurm

@@ -0,0 +1,99 @@
+#!/usr/bin/env bash
+#SBATCH --job-name=upload
+#SBATCH --nodes=1
+#SBATCH --ntasks=1
+#SBATCH --cpus-per-task=2
+#SBATCH --mem=8G
+#SBATCH --time=24:00:00
+#SBATCH --output=%x_%A_%a.out
+#SBATCH --error=%x_%A_%a.err
+
+set -euo pipefail
+
+ROOT_DIR="${ROOT_DIR:-/home/sf895/SignVerse-2M}"
+RUNTIME_ROOT="${RUNTIME_ROOT:-/home/sf895/SignVerse-2M-runtime}"
+CONDA_SH="${CONDA_SH:-/home/sf895/miniconda3/etc/profile.d/conda.sh}"
+CONDA_ENV="${CONDA_ENV:-signx2}"
+PIPELINE03="${PIPELINE03:-$ROOT_DIR/scripts/pipeline03_upload_to_huggingface.py}"
+DATASET_DIR="${DATASET_DIR:-$RUNTIME_ROOT/dataset}"
+SCRATCH_DATASET_DIR="${SCRATCH_DATASET_DIR:-/scratch/$USER/SignVerse-2M-runtime/dataset}"
+RAW_VIDEO_DIR="${RAW_VIDEO_DIR:-$RUNTIME_ROOT/raw_video}"
+SCRATCH_RAW_VIDEO_DIR="${SCRATCH_RAW_VIDEO_DIR:-/scratch/$USER/SignVerse-2M-runtime/raw_video}"
+RAW_CAPTION_DIR="${RAW_CAPTION_DIR:-$RUNTIME_ROOT/raw_caption}"
+RAW_METADATA_DIR="${RAW_METADATA_DIR:-$RUNTIME_ROOT/raw_metadata}"
+ARCHIVE_DIR="${ARCHIVE_DIR:-$ROOT_DIR/archives}"
+PROGRESS_JSON="${PROGRESS_JSON:-$RUNTIME_ROOT/archive_upload_progress.json}"
+STATUS_JOURNAL_PATH="${STATUS_JOURNAL_PATH:-$RUNTIME_ROOT/upload_status_journal.jsonl}"
+STATS_NPZ="${STATS_NPZ:-$RUNTIME_ROOT/stats.npz}"
+REPO_ID="${REPO_ID:-SignerX/SignVerse-2M}"
+REPO_REVISION="${REPO_REVISION:-dev}"
+TARGET_BYTES="${TARGET_BYTES:-10737418240}"
+TARGET_FOLDERS="${TARGET_FOLDERS:-40}"
+PARALLEL_SHARDS="${PARALLEL_SHARDS:-1}"
+START_STAGGER_MIN="${START_STAGGER_MIN:-1}"
+START_STAGGER_MAX="${START_STAGGER_MAX:-3}"
+ALLOW_SMALL_FINAL_BATCH="${ALLOW_SMALL_FINAL_BATCH:-0}"
+REQUIRE_TARGET_BYTES="${REQUIRE_TARGET_BYTES:-1}"
+DRY_RUN_UPLOAD="${DRY_RUN_UPLOAD:-0}"
+UPLOAD_MODE="${UPLOAD_MODE:-api}"
+
+if [[ ! -f "$CONDA_SH" ]]; then
+  echo "Missing conda init script: $CONDA_SH" >&2
+  exit 1
+fi
+
+if [[ -z "${SLURM_ARRAY_TASK_ID:-}" ]]; then
+  echo "SLURM_ARRAY_TASK_ID is required." >&2
+  exit 1
+fi
+
+if (( PARALLEL_SHARDS < 1 )); then
+  echo "PARALLEL_SHARDS must be >= 1" >&2
+  exit 1
+fi
+
+if (( SLURM_ARRAY_TASK_ID < 0 || SLURM_ARRAY_TASK_ID >= PARALLEL_SHARDS )); then
+  echo "SLURM_ARRAY_TASK_ID=$SLURM_ARRAY_TASK_ID is out of range for PARALLEL_SHARDS=$PARALLEL_SHARDS" >&2
+  exit 1
+fi
+
+echo "[$(date '+%F %T')] upload shard=${SLURM_ARRAY_TASK_ID}/${PARALLEL_SHARDS} host=$(hostname)"
+
+# shellcheck disable=SC1090
+source "$CONDA_SH"
+
+cmd=(python -u "$PIPELINE03"
+  --dataset-dir "$DATASET_DIR"
+  --scratch-dataset-dir "$SCRATCH_DATASET_DIR"
+  --raw-video-dir "$RAW_VIDEO_DIR"
+  --scratch-raw-video-dir "$SCRATCH_RAW_VIDEO_DIR"
+  --raw-caption-dir "$RAW_CAPTION_DIR"
+  --raw-metadata-dir "$RAW_METADATA_DIR"
+  --archive-dir "$ARCHIVE_DIR"
+  --progress-path "$PROGRESS_JSON"
+  --stats-npz "$STATS_NPZ"
+  --status-journal-path "$STATUS_JOURNAL_PATH"
+  --repo-id "$REPO_ID"
+  --repo-revision "$REPO_REVISION"
+  --target-bytes "$TARGET_BYTES"
+  --target-folders "$TARGET_FOLDERS"
+  --parallel-shards "$PARALLEL_SHARDS"
+  --shard-index "$SLURM_ARRAY_TASK_ID"
+  --start-stagger-min "$START_STAGGER_MIN"
+  --start-stagger-max "$START_STAGGER_MAX"
+  --upload-mode "$UPLOAD_MODE"
+)
+
+if [[ "$ALLOW_SMALL_FINAL_BATCH" == "1" ]]; then
+  cmd+=(--allow-small-final-batch)
+fi
+if [[ "$REQUIRE_TARGET_BYTES" != "1" ]]; then
+  cmd+=(--allow-small-final-batch)
+fi
+if [[ "$DRY_RUN_UPLOAD" == "1" ]]; then
+  cmd+=(--dry-run)
+fi
+
+cmd+=(--skip-stats-write)
+
+CONDA_NO_PLUGINS=true conda run -n "$CONDA_ENV" "${cmd[@]}"

slurm/run_reproduce_independently_slurm.slurm

@@ -5,8 +5,8 @@
 #SBATCH --cpus-per-task=2
 #SBATCH --mem=8G
 #SBATCH --time=24:00:00
-#SBATCH --output=%x_%A.out
-#SBATCH --error=%x_%A.err
+#SBATCH --output=/scratch/%u/SignVerse-2M-runtime/slurm/logs/%x_%A.out
+#SBATCH --error=/scratch/%u/SignVerse-2M-runtime/slurm/logs/%x_%A.err
 
 set -euo pipefail
 

slurm/submit_download_slurm.sh

@@ -7,10 +7,14 @@ STATE_ROOT="${STATE_ROOT:-/home/sf895/SignVerse-2M-runtime}"
 SOURCE_METADATA_CSV="${SOURCE_METADATA_CSV:-$RUNTIME_ROOT/SignVerse-2M-metadata_ori.csv}"
 OUTPUT_METADATA_CSV="${OUTPUT_METADATA_CSV:-$RUNTIME_ROOT/SignVerse-2M-metadata_processed.csv}"
 RAW_VIDEO_DIR="${RAW_VIDEO_DIR:-$RUNTIME_ROOT/raw_video}"
+SCRATCH_RAW_VIDEO_DIR="${SCRATCH_RAW_VIDEO_DIR:-/scratch/$USER/SignVerse-2M-runtime/raw_video}"
+HOME_RAW_VIDEO_LIMIT="${HOME_RAW_VIDEO_LIMIT:-180}"
+SCRATCH_RAW_VIDEO_LIMIT="${SCRATCH_RAW_VIDEO_LIMIT:-2800}"
 RAW_CAPTION_DIR="${RAW_CAPTION_DIR:-$RUNTIME_ROOT/raw_caption}"
 RAW_METADATA_DIR="${RAW_METADATA_DIR:-$RUNTIME_ROOT/raw_metadata}"
 DATASET_DIR="${DATASET_DIR:-$RUNTIME_ROOT/dataset}"
 STATS_NPZ="${STATS_NPZ:-$RUNTIME_ROOT/stats.npz}"
+PROGRESS_JSON="${PROGRESS_JSON:-$RUNTIME_ROOT/archive_upload_progress.json}"
 SLURM_SCRIPT="$ROOT_DIR/slurm/process_download_array.slurm"
 MANIFEST_DIR="${MANIFEST_DIR:-$STATE_ROOT/slurm/manifests}"
 LOG_DIR="${LOG_DIR:-$STATE_ROOT/slurm/logs}"
@@ -25,7 +29,7 @@ CPUS_PER_TASK="1"
 MEMORY="4G"
 LIMIT=""
 ARRAY_PARALLEL=""
-MAX_BACKLOG_VIDEOS="180"
+MAX_BACKLOG_VIDEOS="2980"
 MAX_ACTIVE_DOWNLOADS="60"
 DOWNLOAD_CLAIM_GRACE_SECONDS="${DOWNLOAD_CLAIM_GRACE_SECONDS:-600}"
 WORKERS="60"
@@ -57,6 +61,9 @@ Options:
   --max-backlog-videos N     Max raw backlog + active download claims allowed. Default: 180
   --max-active-downloads N   Max active download claims allowed at once. Default: 30
   --workers N                Max download tasks to submit in one cycle. Default: 60
+  --scratch-raw-video-dir DIR  Scratch raw video pool directory
+  --home-raw-video-limit N     Home raw pool cap. Default: 180
+  --scratch-raw-video-limit N  Scratch raw pool cap. Default: 2800
   --claim-dir DIR            Download claim directory
   --csv-lock-path PATH       CSV lock path
   --video-ids ID [ID ...]    Restrict this cycle to specific videos
@@ -85,6 +92,9 @@ while [[ $# -gt 0 ]]; do
     --array-parallel) ARRAY_PARALLEL="$2"; shift 2 ;;
     --max-backlog-videos) MAX_BACKLOG_VIDEOS="$2"; shift 2 ;;
     --workers) WORKERS="$2"; shift 2 ;;
+    --scratch-raw-video-dir) SCRATCH_RAW_VIDEO_DIR="$2"; shift 2 ;;
+    --home-raw-video-limit) HOME_RAW_VIDEO_LIMIT="$2"; shift 2 ;;
+    --scratch-raw-video-limit) SCRATCH_RAW_VIDEO_LIMIT="$2"; shift 2 ;;
     --max-active-downloads) MAX_ACTIVE_DOWNLOADS="$2"; shift 2 ;;
     --claim-dir) DOWNLOAD_CLAIM_DIR="$2"; shift 2 ;;
     --csv-lock-path) DOWNLOAD_CSV_LOCK_PATH="$2"; shift 2 ;;
@@ -123,7 +133,7 @@ ACTIVE_DOWNLOAD_TASKS_FILE="$STATE_DIR/active_download_tasks_${TIMESTAMP}.txt"
 squeue -h -u "$USER" -o "%A" | sed 's/_.*//' | sort -u > "$ACTIVE_JOBS_FILE"
 squeue -h -u "$USER" -n download -t RUNNING,PENDING,CONFIGURING -o "%i" > "$ACTIVE_DOWNLOAD_TASKS_FILE"
 
-SELECTED_COUNT="$(python - "$SOURCE_METADATA_CSV" "$OUTPUT_METADATA_CSV" "$RAW_VIDEO_DIR" "$DOWNLOAD_CLAIM_DIR" "$ACTIVE_JOBS_FILE" "$ACTIVE_DOWNLOAD_TASKS_FILE" "$MAX_BACKLOG_VIDEOS" "$MAX_ACTIVE_DOWNLOADS" "$LIMIT" "$WORKERS" "$BASE_MANIFEST" "${VIDEO_IDS[*]:-}" <<'PY'
+SELECTED_COUNT="$(python - "$SOURCE_METADATA_CSV" "$OUTPUT_METADATA_CSV" "$RAW_VIDEO_DIR" "$SCRATCH_RAW_VIDEO_DIR" "$DOWNLOAD_CLAIM_DIR" "$ACTIVE_JOBS_FILE" "$ACTIVE_DOWNLOAD_TASKS_FILE" "$MAX_BACKLOG_VIDEOS" "$MAX_ACTIVE_DOWNLOADS" "$LIMIT" "$WORKERS" "$BASE_MANIFEST" "$HOME_RAW_VIDEO_LIMIT" "$SCRATCH_RAW_VIDEO_LIMIT" "$PROGRESS_JSON" "${VIDEO_IDS[*]:-}" <<'PY'
 import csv
 import sys
 from pathlib import Path
@@ -131,16 +141,29 @@ from pathlib import Path
 source_csv = Path(sys.argv[1])
 processed_csv = Path(sys.argv[2])
 raw_video_dir = Path(sys.argv[3])
-claim_dir = Path(sys.argv[4])
-active_jobs_path = Path(sys.argv[5])
-active_download_tasks_path = Path(sys.argv[6])
-max_backlog = int(sys.argv[7])
-max_active_downloads = int(sys.argv[8])
-limit_arg = sys.argv[9]
-workers = int(sys.argv[10])
-manifest_path = Path(sys.argv[11])
-video_ids_joined = sys.argv[12].strip()
+scratch_raw_video_dir = Path(sys.argv[4])
+claim_dir = Path(sys.argv[5])
+active_jobs_path = Path(sys.argv[6])
+active_download_tasks_path = Path(sys.argv[7])
+max_backlog = int(sys.argv[8])
+max_active_downloads = int(sys.argv[9])
+limit_arg = sys.argv[10]
+workers = int(sys.argv[11])
+manifest_path = Path(sys.argv[12])
+home_raw_video_limit = int(sys.argv[13])
+scratch_raw_video_limit = int(sys.argv[14])
+progress_path = Path(sys.argv[15])
+video_ids_joined = sys.argv[16].strip()
 limit = int(limit_arg) if limit_arg else None
+
+uploaded_ids = set()
+if progress_path.exists():
+    try:
+        import json
+        progress = json.loads(progress_path.read_text(encoding="utf-8"))
+        uploaded_ids = set((progress.get("uploaded_folders") or {}).keys())
+    except Exception:
+        uploaded_ids = set()
 video_filter = set(video_ids_joined.split()) if video_ids_joined else None
 
 video_extensions = {'.mp4', '.mkv', '.webm', '.mov'}
@@ -194,13 +217,24 @@ for claim_path in claim_dir.glob('*.claim'):
     else:
         claim_path.unlink(missing_ok=True)
 
-raw_backlog = 0
+home_raw_count = 0
+scratch_raw_count = 0
 existing_raw = set()
 if raw_video_dir.exists():
     for path in raw_video_dir.iterdir():
         if path.is_file() and path.suffix.lower() in video_extensions:
-            raw_backlog += 1
+            home_raw_count += 1
+            existing_raw.add(path.stem)
+if scratch_raw_video_dir.exists():
+    for path in scratch_raw_video_dir.iterdir():
+        if path.is_file() and path.suffix.lower() in video_extensions:
+            scratch_raw_count += 1
             existing_raw.add(path.stem)
+raw_backlog = home_raw_count + scratch_raw_count
+if home_raw_count >= home_raw_video_limit and scratch_raw_count >= scratch_raw_video_limit:
+    manifest_path.write_text('', encoding='utf-8')
+    print(0)
+    raise SystemExit
 
 effective_active_downloads = max(active_download_tasks, len(active_claims))
 remaining_slots = max(0, max_backlog - raw_backlog - len(active_claims))
@@ -231,6 +265,8 @@ for row in rows:
         continue
     if video_id in active_claims or video_id in existing_raw:
         continue
+    if video_id in uploaded_ids:
+        continue
     download_status = (row.get('download_status') or '').strip()
     if download_status in {'ok', 'skipped'}:
         continue
@@ -267,7 +303,7 @@ cmd=(sbatch
   --array "$ARRAY_SPEC"
   --output "$LOG_DIR/download_%A_%a.out"
   --error "$LOG_DIR/download_%A_%a.err"
-  --export "ALL,ROOT_DIR=$ROOT_DIR,RUNTIME_ROOT=$RUNTIME_ROOT,STATE_ROOT=$STATE_ROOT,CONDA_SH=/home/sf895/miniconda3/etc/profile.d/conda.sh,CONDA_ENV=signx2,SOURCE_METADATA_CSV=$SOURCE_METADATA_CSV,OUTPUT_METADATA_CSV=$OUTPUT_METADATA_CSV,RAW_VIDEO_DIR=$RAW_VIDEO_DIR,RAW_CAPTION_DIR=$RAW_CAPTION_DIR,RAW_METADATA_DIR=$RAW_METADATA_DIR,DATASET_DIR=$DATASET_DIR,STATS_NPZ=$STATS_NPZ,PIPELINE01=$ROOT_DIR/scripts/pipeline01_download_video_fix_caption.py,DOWNLOAD_CLAIM_DIR=$DOWNLOAD_CLAIM_DIR,DOWNLOAD_CSV_LOCK_PATH=$DOWNLOAD_CSV_LOCK_PATH,MANIFEST=$BASE_MANIFEST,FORCE_METADATA=$FORCE_METADATA,FORCE_SUBTITLES=$FORCE_SUBTITLES,FORCE_DOWNLOAD=$FORCE_DOWNLOAD,SKIP_VIDEO_DOWNLOAD=$SKIP_VIDEO_DOWNLOAD,SKIP_SUBTITLES=$SKIP_SUBTITLES,COOKIES_FILE=$COOKIES_FILE,COOKIES_FROM_BROWSER=$COOKIES_FROM_BROWSER,EXTRACTOR_ARGS=$EXTRACTOR_ARGS,DOWNLOAD_START_STAGGER_MIN=${DOWNLOAD_START_STAGGER_MIN:-1},DOWNLOAD_START_STAGGER_MAX=${DOWNLOAD_START_STAGGER_MAX:-3}"
+  --export "ALL,ROOT_DIR=$ROOT_DIR,RUNTIME_ROOT=$RUNTIME_ROOT,STATE_ROOT=$STATE_ROOT,CONDA_SH=/home/sf895/miniconda3/etc/profile.d/conda.sh,CONDA_ENV=signx2,SOURCE_METADATA_CSV=$SOURCE_METADATA_CSV,OUTPUT_METADATA_CSV=$OUTPUT_METADATA_CSV,RAW_VIDEO_DIR=$RAW_VIDEO_DIR,SCRATCH_RAW_VIDEO_DIR=$SCRATCH_RAW_VIDEO_DIR,HOME_RAW_VIDEO_LIMIT=$HOME_RAW_VIDEO_LIMIT,SCRATCH_RAW_VIDEO_LIMIT=$SCRATCH_RAW_VIDEO_LIMIT,RAW_CAPTION_DIR=$RAW_CAPTION_DIR,RAW_METADATA_DIR=$RAW_METADATA_DIR,DATASET_DIR=$DATASET_DIR,STATS_NPZ=$STATS_NPZ,STATUS_JOURNAL_PATH=$RUNTIME_ROOT/upload_status_journal.jsonl,PIPELINE01=$ROOT_DIR/scripts/pipeline01_download_video_fix_caption.py,DOWNLOAD_CLAIM_DIR=$DOWNLOAD_CLAIM_DIR,DOWNLOAD_CSV_LOCK_PATH=$DOWNLOAD_CSV_LOCK_PATH,MANIFEST=$BASE_MANIFEST,FORCE_METADATA=$FORCE_METADATA,FORCE_SUBTITLES=$FORCE_SUBTITLES,FORCE_DOWNLOAD=$FORCE_DOWNLOAD,SKIP_VIDEO_DOWNLOAD=$SKIP_VIDEO_DOWNLOAD,SKIP_SUBTITLES=$SKIP_SUBTITLES,COOKIES_FILE=$COOKIES_FILE,COOKIES_FROM_BROWSER=$COOKIES_FROM_BROWSER,EXTRACTOR_ARGS=$EXTRACTOR_ARGS,DOWNLOAD_START_STAGGER_MIN=${DOWNLOAD_START_STAGGER_MIN:-1},DOWNLOAD_START_STAGGER_MAX=${DOWNLOAD_START_STAGGER_MAX:-3}"
 )
 if [[ -n "$ACCOUNT" ]]; then
   cmd+=(--account "$ACCOUNT")

slurm/submit_dwpose_slurm.sh

@@ -7,8 +7,11 @@ STATE_ROOT="${STATE_ROOT:-/home/sf895/SignVerse-2M-runtime}"
 CONDA_SH="/home/sf895/miniconda3/etc/profile.d/conda.sh"
 CONDA_ENV="signx2"
 RAW_VIDEO_DIR="${RAW_VIDEO_DIR:-$RUNTIME_ROOT/raw_video}"
+SCRATCH_RAW_VIDEO_DIR="${SCRATCH_RAW_VIDEO_DIR:-/scratch/$USER/SignVerse-2M-runtime/raw_video}"
 DATASET_DIR="${DATASET_DIR:-$RUNTIME_ROOT/dataset}"
+SCRATCH_DATASET_DIR="${SCRATCH_DATASET_DIR:-/scratch/$USER/SignVerse-2M-runtime/dataset}"
 STATS_NPZ="${STATS_NPZ:-$RUNTIME_ROOT/stats.npz}"
+PROGRESS_JSON="${PROGRESS_JSON:-$RUNTIME_ROOT/archive_upload_progress.json}"
 SLURM_SCRIPT="$ROOT_DIR/slurm/process_dwpose_array.slurm"
 MANIFEST_DIR="${MANIFEST_DIR:-$STATE_ROOT/slurm/manifests}"
 LOG_DIR="${LOG_DIR:-$STATE_ROOT/slurm/logs}"
@@ -23,10 +26,17 @@ MEMORY="32G"
 FPS="24"
 LIMIT=""
 ARRAY_PARALLEL=""
-MAX_BACKLOG_VIDEOS="180"
+MAX_BACKLOG_VIDEOS="2980"
 FORCE_PROCESS=0
 DELETE_SOURCE_ON_SUCCESS=0
+VIDEOS_PER_JOB="${VIDEOS_PER_JOB:-5}"
 MAX_PER_NODE=""
+PARTITION_QOS_COOLDOWN_SECONDS="${PARTITION_QOS_COOLDOWN_SECONDS:-300}"
+PARTITION_QOS_HEADROOM="${PARTITION_QOS_HEADROOM:-2}"
+PARTITION_ACTIVE_WINDOW_DEFAULT="${PARTITION_ACTIVE_WINDOW_DEFAULT:-16}"
+PARTITION_ACTIVE_WINDOW_GPU="${PARTITION_ACTIVE_WINDOW_GPU:-16}"
+PARTITION_ACTIVE_WINDOW_GPU_REDHAT="${PARTITION_ACTIVE_WINDOW_GPU_REDHAT:-16}"
+PARTITION_ACTIVE_WINDOW_CGPU="${PARTITION_ACTIVE_WINDOW_CGPU:-8}"
 
 usage() {
   cat <<USAGE
@@ -43,9 +53,10 @@ Options:
   --mem SIZE                 Default: 32G
   --fps N                    Default: 24
   --limit N                  Only submit the first N pending, unclaimed videos this cycle
-  --max-backlog-videos N     Max claimed queued/running videos allowed at once. Default: 180
-  --array-parallel N         Add a %N cap to each node-local array
-  --max-per-node N           Cap submissions per node in a cycle
+  --max-backlog-videos N     Max claimed queued/running videos allowed at once. Default: 2980
+  --array-parallel N         Add a %N cap to each partition array
+  --max-per-node N           Cap per-node free-slot contribution before partition aggregation
+  --partition-qos-cooldown-seconds N  Skip a partition for N seconds after a submit failure. Default: 300
   --force-process            Re-run videos even if marked complete
   --delete-source-on-success Delete raw videos after successful processing
   --help
@@ -65,7 +76,9 @@ while [[ $# -gt 0 ]]; do
     --limit) LIMIT="$2"; shift 2 ;;
     --max-backlog-videos) MAX_BACKLOG_VIDEOS="$2"; shift 2 ;;
     --array-parallel) ARRAY_PARALLEL="$2"; shift 2 ;;
-    --max-per-node) MAX_PER_NODE="$2"; shift 2 ;;
+    --max-per-node) MAX_PER_NODE="$2"; shift 2 ;;&
+    --videos-per-job) VIDEOS_PER_JOB="$2"; shift 2 ;;
+    --partition-qos-cooldown-seconds) PARTITION_QOS_COOLDOWN_SECONDS="$2"; shift 2 ;;
     --force-process) FORCE_PROCESS=1; shift ;;
     --delete-source-on-success) DELETE_SOURCE_ON_SUCCESS=1; shift ;;
     -h|--help) usage; exit 0 ;;
@@ -83,24 +96,39 @@ fi
 TIMESTAMP="$(date '+%Y%m%d_%H%M%S')"
 BASE_MANIFEST="$MANIFEST_DIR/pending_videos_${TIMESTAMP}.txt"
 ACTIVE_JOBS_FILE="$STATE_DIR/active_jobs_${TIMESTAMP}.txt"
-NODE_SLOTS_FILE="$STATE_DIR/node_slots_${TIMESTAMP}.txt"
+PARTITION_SLOTS_FILE="$STATE_DIR/partition_slots_${TIMESTAMP}.txt"
+PARTITION_COOLDOWN_DIR="$STATE_DIR/partition_submit_cooldowns"
+
+mkdir -p "$PARTITION_COOLDOWN_DIR"
 
 squeue -h -u "$USER" -o "%A" | sed 's/_.*//' | sort -u > "$ACTIVE_JOBS_FILE"
 
-PENDING_COUNT="$(python - "$RAW_VIDEO_DIR" "$DATASET_DIR" "$LIMIT" "$FORCE_PROCESS" "$BASE_MANIFEST" "$CLAIM_DIR" "$ACTIVE_JOBS_FILE" "$MAX_BACKLOG_VIDEOS" <<'PY'
+PENDING_COUNT="$(python - "$RAW_VIDEO_DIR" "$SCRATCH_RAW_VIDEO_DIR" "$DATASET_DIR" "$SCRATCH_DATASET_DIR" "$LIMIT" "$FORCE_PROCESS" "$BASE_MANIFEST" "$CLAIM_DIR" "$ACTIVE_JOBS_FILE" "$MAX_BACKLOG_VIDEOS" "$PROGRESS_JSON" <<'PY'
 import sys
 from pathlib import Path
 
 raw_video_dir = Path(sys.argv[1])
-dataset_dir = Path(sys.argv[2])
-limit_arg = sys.argv[3]
-force = sys.argv[4] == '1'
-manifest_path = Path(sys.argv[5])
-claim_dir = Path(sys.argv[6])
-active_jobs_path = Path(sys.argv[7])
-max_backlog = int(sys.argv[8])
+scratch_raw_video_dir = Path(sys.argv[2])
+dataset_dir = Path(sys.argv[3])
+scratch_dataset_dir = Path(sys.argv[4])
+limit_arg = sys.argv[5]
+force = sys.argv[6] == '1'
+manifest_path = Path(sys.argv[7])
+claim_dir = Path(sys.argv[8])
+active_jobs_path = Path(sys.argv[9])
+max_backlog = int(sys.argv[10])
+progress_path = Path(sys.argv[11])
 limit = int(limit_arg) if limit_arg else None
 
+uploaded_ids = set()
+if progress_path.exists():
+    try:
+        import json
+        progress = json.loads(progress_path.read_text(encoding="utf-8"))
+        uploaded_ids = set((progress.get("uploaded_folders") or {}).keys())
+    except Exception:
+        uploaded_ids = set()
+
 video_extensions = {'.mp4', '.mkv', '.webm', '.mov'}
 claim_dir.mkdir(parents=True, exist_ok=True)
 active_jobs = set()
@@ -126,15 +154,27 @@ for claim_path in claim_dir.glob('*.claim'):
 
 remaining_slots = max(0, max_backlog - len(active_claims))
 selected = []
-if remaining_slots > 0 and raw_video_dir.exists():
-    for path in sorted(raw_video_dir.iterdir()):
+if remaining_slots > 0:
+    raw_paths = []
+    if raw_video_dir.exists():
+        raw_paths.extend(sorted(raw_video_dir.iterdir()))
+    if scratch_raw_video_dir.exists():
+        raw_paths.extend(sorted(scratch_raw_video_dir.iterdir()))
+    seen = set()
+    for path in raw_paths:
         if not path.is_file() or path.suffix.lower() not in video_extensions:
             continue
         video_id = path.stem
+        if video_id in seen:
+            continue
+        seen.add(video_id)
         if video_id in active_claims:
             continue
+        if video_id in uploaded_ids:
+            continue
         complete_marker = dataset_dir / video_id / 'npz' / '.complete'
-        if not force and complete_marker.exists():
+        scratch_complete_marker = scratch_dataset_dir / video_id / 'npz' / '.complete'
+        if not force and (complete_marker.exists() or scratch_complete_marker.exists()):
             continue
         selected.append(video_id)
         if len(selected) >= remaining_slots:
@@ -153,17 +193,86 @@ if [[ "$PENDING_COUNT" == "0" ]]; then
   exit 0
 fi
 
-AVAILABLE_SLOTS="$(python - "$PARTITIONS" "$NODE_SLOTS_FILE" "$MAX_PER_NODE" <<'PY'
+AVAILABLE_SLOTS="$(python - "$PARTITIONS" "$PARTITION_SLOTS_FILE" "$MAX_PER_NODE" "$USER" "$PARTITION_COOLDOWN_DIR" "$PARTITION_QOS_COOLDOWN_SECONDS" "$PARTITION_QOS_HEADROOM" "$PARTITION_ACTIVE_WINDOW_DEFAULT" "$PARTITION_ACTIVE_WINDOW_GPU" "$PARTITION_ACTIVE_WINDOW_GPU_REDHAT" "$PARTITION_ACTIVE_WINDOW_CGPU" <<'PY'
 import re
 import subprocess
 import sys
+from collections import defaultdict
 from pathlib import Path
 
 parts = [p for p in sys.argv[1].split(',') if p]
 out_path = Path(sys.argv[2])
 max_per_node_arg = sys.argv[3]
+user = sys.argv[4]
+cooldown_dir = Path(sys.argv[5])
+cooldown_seconds = int(sys.argv[6])
+qos_headroom = int(sys.argv[7])
+partition_active_window_default = int(sys.argv[8])
+partition_active_window_gpu = int(sys.argv[9])
+partition_active_window_gpu_redhat = int(sys.argv[10])
+partition_active_window_cgpu = int(sys.argv[11])
+partition_active_window_map = {
+    "gpu": partition_active_window_gpu,
+    "gpu-redhat": partition_active_window_gpu_redhat,
+    "cgpu": partition_active_window_cgpu,
+}
 max_per_node = int(max_per_node_arg) if max_per_node_arg else None
-slots = []
+
+qos_limit_by_part = {}
+try:
+    proc = subprocess.run(['sacctmgr', 'show', 'qos', 'format=Name,MaxSubmitPU', '-P'], capture_output=True, text=True, check=False)
+    for line in (proc.stdout or '').splitlines():
+        if not line.strip() or '|' not in line:
+            continue
+        name, max_submit = line.split('|', 1)
+        name = name.strip()
+        max_submit = max_submit.strip()
+        if name in parts and max_submit:
+            try:
+                qos_limit_by_part[name] = int(max_submit)
+            except ValueError:
+                pass
+except Exception:
+    qos_limit_by_part = {}
+
+def expand_count(jobid_token: str) -> int:
+    m = re.match(r'^(\d+)_\[(.+)\]$', jobid_token)
+    if not m:
+        return 1
+    body = m.group(2)
+    if '%' in body:
+        body = body.split('%', 1)[0]
+    total = 0
+    for part in body.split(','):
+        part = part.strip()
+        if not part:
+            continue
+        if '-' in part:
+            a, b = part.split('-', 1)
+            try:
+                total += int(b) - int(a) + 1
+            except ValueError:
+                total += 1
+        else:
+            total += 1
+    return max(total, 1)
+
+active_tasks_by_part = defaultdict(int)
+try:
+    proc = subprocess.run(['squeue', '-u', user, '-h', '-o', '%i|%P|%T'], capture_output=True, text=True, check=False)
+    for line in (proc.stdout or '').splitlines():
+        if not line.strip() or '|' not in line:
+            continue
+        jobid, partition, state = [x.strip() for x in line.split('|', 2)]
+        if partition not in parts:
+            continue
+        if state not in {'RUNNING', 'PENDING', 'CONFIGURING'}:
+            continue
+        active_tasks_by_part[partition] += expand_count(jobid)
+except Exception:
+    active_tasks_by_part = defaultdict(int)
+
+free_gpus_by_part = defaultdict(int)
 for part in parts:
     proc = subprocess.run(['sinfo', '-h', '-N', '-p', part, '-o', '%N'], capture_output=True, text=True, check=False)
     if proc.returncode != 0:
@@ -188,37 +297,76 @@ for part in parts:
         if max_per_node is not None:
             free = min(free, max_per_node)
         if free > 0:
-            slots.append((part, node, free))
-slots.sort(key=lambda item: (-item[2], item[0], item[1]))
-out_path.write_text(''.join(f'{part}\t{node}\t{free}\n' for part, node, free in slots), encoding='utf-8')
-print(sum(free for _, _, free in slots))
+            free_gpus_by_part[part] += free
+
+ordered = []
+now = __import__('time').time()
+for part in parts:
+    cooldown_path = cooldown_dir / f'{part}.until'
+    if cooldown_path.exists():
+        try:
+            until_ts = float(cooldown_path.read_text(encoding='utf-8').strip() or '0')
+        except Exception:
+            until_ts = 0.0
+        if until_ts > now:
+            continue
+        cooldown_path.unlink(missing_ok=True)
+    free_slots = free_gpus_by_part.get(part, 0)
+    if free_slots <= 0:
+        continue
+    qos_limit = qos_limit_by_part.get(part)
+    active_tasks = active_tasks_by_part.get(part, 0)
+    submit_slots = free_slots
+    if qos_limit is not None:
+        submit_slots = min(submit_slots, max(0, qos_limit - active_tasks - qos_headroom))
+    part_window = partition_active_window_map.get(part, partition_active_window_default)
+    submit_slots = min(submit_slots, max(0, part_window - active_tasks))
+    if submit_slots > 0:
+        ordered.append((part, free_slots, active_tasks, qos_limit if qos_limit is not None else 'na', submit_slots))
+
+ordered.sort(key=lambda row: (-int(row[4]), -int(row[1]), row[0]))
+
+out_path.write_text(''.join(f'{part}\t{free}\t{active}\t{qos}\t{submit}\n' for part, free, active, qos, submit in ordered), encoding='utf-8')
+print(sum(submit for _, _, _, _, submit in ordered))
 PY
 )"
 
 if [[ -z "$AVAILABLE_SLOTS" || "$AVAILABLE_SLOTS" == "0" ]]; then
-  echo "No free GPU slots detected across requested partitions."
-  rm -f "$BASE_MANIFEST" "$NODE_SLOTS_FILE"
+  echo "No free GPU/QoS submission slots detected across requested partitions."
+  rm -f "$BASE_MANIFEST" "$PARTITION_SLOTS_FILE"
   exit 0
 fi
 
-TARGET_COUNT="$PENDING_COUNT"
-if [[ "$TARGET_COUNT" -gt "$AVAILABLE_SLOTS" ]]; then
-  TARGET_COUNT="$AVAILABLE_SLOTS"
-  head -n "$TARGET_COUNT" "$BASE_MANIFEST" > "$BASE_MANIFEST.tmp"
+AVAILABLE_JOB_SLOTS="$AVAILABLE_SLOTS"
+TARGET_VIDEO_COUNT="$PENDING_COUNT"
+MAX_VIDEO_COUNT="$((AVAILABLE_JOB_SLOTS * VIDEOS_PER_JOB))"
+if [[ "$TARGET_VIDEO_COUNT" -gt "$MAX_VIDEO_COUNT" ]]; then
+  TARGET_VIDEO_COUNT="$MAX_VIDEO_COUNT"
+  head -n "$TARGET_VIDEO_COUNT" "$BASE_MANIFEST" > "$BASE_MANIFEST.tmp"
   mv "$BASE_MANIFEST.tmp" "$BASE_MANIFEST"
 fi
+TARGET_JOB_COUNT="$(((TARGET_VIDEO_COUNT + VIDEOS_PER_JOB - 1) / VIDEOS_PER_JOB))"
 
 echo "Created manifest: $BASE_MANIFEST"
 echo "Pending videos selected this cycle: $PENDING_COUNT"
-echo "Available GPU slots right now: $AVAILABLE_SLOTS"
-echo "Submitting now: $TARGET_COUNT"
+echo "Available GPU/QoS job slots right now: $AVAILABLE_JOB_SLOTS"
+echo "Submitting jobs now: $TARGET_JOB_COUNT"
+echo "Submitting videos now: $TARGET_VIDEO_COUNT"
+
+echo "Per-partition capacity snapshot:"
+while IFS=$'\t' read -r partition free_slots active_tasks qos_limit submit_slots; do
+  [[ -z "$partition" ]] && continue
+  echo "  partition=$partition free_gpus=$free_slots active_tasks=$active_tasks qos_limit=${qos_limit:-na} submit_slots=$submit_slots"
+done < "$PARTITION_SLOTS_FILE"
 
 write_claims() {
   local manifest="$1"
   local job_id="$2"
+  local index=0
   local task_id=0
   while IFS= read -r video_id; do
     [[ -z "$video_id" ]] && continue
+    task_id=$((index / VIDEOS_PER_JOB))
     cat > "$CLAIM_DIR/${video_id}.claim" <<CLAIM
 job_id=$job_id
 task_id=$task_id
@@ -226,37 +374,42 @@ job_key=${job_id}_${task_id}
 video_id=$video_id
 submitted_at=$(date '+%F %T')
 CLAIM
-    task_id=$((task_id + 1))
+    index=$((index + 1))
   done < "$manifest"
 }
 
-submit_node() {
+mark_partition_submit_cooldown() {
   local partition="$1"
-  local node="$2"
-  local manifest="$3"
-  local count="$4"
-  local array_spec="0-$((count - 1))"
+  mkdir -p "$PARTITION_COOLDOWN_DIR"
+  printf '%s\n' "$(( $(date +%s) + PARTITION_QOS_COOLDOWN_SECONDS ))" > "$PARTITION_COOLDOWN_DIR/${partition}.until"
+}
+
+submit_partition() {
+  local partition="$1"
+  local manifest="$2"
+  local count="$3"
+  local task_count="$(((count + VIDEOS_PER_JOB - 1) / VIDEOS_PER_JOB))"
+  local array_spec="0-$((task_count - 1))"
   local job_output job_id
   if [[ -n "$ARRAY_PARALLEL" ]]; then
     array_spec+="%${ARRAY_PARALLEL}"
   fi
   local -a cmd=(sbatch
     --partition "$partition"
-    --nodelist "$node"
     --array "$array_spec"
     --cpus-per-task "$CPUS_PER_TASK"
     --mem "$MEMORY"
     --time "$TIME_LIMIT"
-    --output "$LOG_DIR/dwpose_${partition}_${node}_%A_%a.out"
-    --error "$LOG_DIR/dwpose_${partition}_${node}_%A_%a.err"
-    --export "ALL,ROOT_DIR=$ROOT_DIR,RUNTIME_ROOT=$RUNTIME_ROOT,STATE_ROOT=$STATE_ROOT,CONDA_SH=$CONDA_SH,CONDA_ENV=$CONDA_ENV,RAW_VIDEO_DIR=$RAW_VIDEO_DIR,DATASET_DIR=$DATASET_DIR,STATS_NPZ=$STATS_NPZ,FPS=$FPS,FORCE_PROCESS=$FORCE_PROCESS,DELETE_SOURCE_ON_SUCCESS=$DELETE_SOURCE_ON_SUCCESS,MANIFEST=$manifest,CLAIM_DIR=$CLAIM_DIR"
+    --output "$LOG_DIR/dwpose_${partition}_%A_%a.out"
+    --error "$LOG_DIR/dwpose_${partition}_%A_%a.err"
+    --export "ALL,ROOT_DIR=$ROOT_DIR,RUNTIME_ROOT=$RUNTIME_ROOT,STATE_ROOT=$STATE_ROOT,CONDA_SH=$CONDA_SH,CONDA_ENV=$CONDA_ENV,RAW_VIDEO_DIR=$RAW_VIDEO_DIR,SCRATCH_RAW_VIDEO_DIR=$SCRATCH_RAW_VIDEO_DIR,DATASET_DIR=$DATASET_DIR,STATS_NPZ=$STATS_NPZ,FPS=$FPS,FORCE_PROCESS=$FORCE_PROCESS,DELETE_SOURCE_ON_SUCCESS=$DELETE_SOURCE_ON_SUCCESS,MANIFEST=$manifest,CLAIM_DIR=$CLAIM_DIR,VIDEOS_PER_JOB=$VIDEOS_PER_JOB"
   )
   if [[ -n "$ACCOUNT" ]]; then
     cmd+=(--account "$ACCOUNT")
   fi
   cmd+=("$SLURM_SCRIPT")
-  echo "Submitting partition=$partition node=$node array=$array_spec manifest=$manifest"
-  job_output="$("${cmd[@]}")"
+  echo "Submitting partition=$partition array=$array_spec manifest=$manifest"
+  job_output="$(${cmd[@]} 2>&1)"
   echo "$job_output"
   job_id="$(awk '/Submitted batch job/ {print $4}' <<< "$job_output" | tail -n 1)"
   if [[ -z "$job_id" ]]; then
@@ -267,36 +420,48 @@ submit_node() {
 }
 
 submitted_total=0
-failed_nodes=0
+submitted_jobs=0
+failed_partitions=0
 line_no=1
-while IFS=$'\t' read -r partition node free_slots; do
+while IFS=$'	' read -r partition free_slots active_tasks qos_limit submit_slots; do
   [[ -z "$partition" ]] && continue
-  if [[ "$submitted_total" -ge "$TARGET_COUNT" ]]; then
+  if [[ "$submitted_total" -ge "$TARGET_VIDEO_COUNT" ]]; then
     break
   fi
-  remaining=$((TARGET_COUNT - submitted_total))
-  assign_count="$free_slots"
-  if [[ "$assign_count" -gt "$remaining" ]]; then
-    assign_count="$remaining"
+  remaining_videos=$((TARGET_VIDEO_COUNT - submitted_total))
+  assign_jobs="$submit_slots"
+  if [[ "$assign_jobs" -le 0 ]]; then
+    continue
+  fi
+  max_videos_for_partition=$((assign_jobs * VIDEOS_PER_JOB))
+  assign_count="$remaining_videos"
+  if [[ "$assign_count" -gt "$max_videos_for_partition" ]]; then
+    assign_count="$max_videos_for_partition"
+  fi
+  if [[ "$assign_count" -le 0 ]]; then
+    continue
   fi
-  shard_manifest="$MANIFEST_DIR/pending_videos_${TIMESTAMP}.${partition}.${node}.txt"
+  shard_manifest="$MANIFEST_DIR/pending_videos_${TIMESTAMP}.${partition}.txt"
   sed -n "${line_no},$((line_no + assign_count - 1))p" "$BASE_MANIFEST" > "$shard_manifest"
-  shard_count="$(wc -l < "$shard_manifest" | tr -d [:space:])"
+  shard_count="$(wc -l < "$shard_manifest" | tr -d '[:space:]')"
   if [[ "$shard_count" == "0" ]]; then
     rm -f "$shard_manifest"
     continue
   fi
-  if submit_node "$partition" "$node" "$shard_manifest" "$shard_count"; then
+  if submit_partition "$partition" "$shard_manifest" "$shard_count"; then
     submitted_total=$((submitted_total + shard_count))
+    submitted_jobs=$((submitted_jobs + ((shard_count + VIDEOS_PER_JOB - 1) / VIDEOS_PER_JOB)))
     line_no=$((line_no + shard_count))
   else
-    echo "Node-local submit failed for partition=$partition node=$node; leaving those videos unclaimed for later nodes or the next cycle." >&2
+    mark_partition_submit_cooldown "$partition"
+    echo "Partition-level submit failed for partition=$partition; cooling down and leaving those videos unclaimed for the next cycle." >&2
     rm -f "$shard_manifest"
-    failed_nodes=$((failed_nodes + 1))
+    failed_partitions=$((failed_partitions + 1))
     continue
   fi
-done < "$NODE_SLOTS_FILE"
+done < "$PARTITION_SLOTS_FILE"
 
 echo "SUBMITTED_VIDEO_COUNT=$submitted_total"
-echo "FAILED_NODE_SUBMITS=$failed_nodes"
-rm -f "$NODE_SLOTS_FILE"
+echo "SUBMITTED_JOB_COUNT=$submitted_jobs"
+echo "FAILED_PARTITION_SUBMITS=$failed_partitions"
+rm -f "$PARTITION_SLOTS_FILE"

slurm/submit_upload_parallel_drain.sh

@@ -0,0 +1,87 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="${ROOT_DIR:-/home/sf895/SignVerse-2M}"
+SUBMIT_SCRIPT="${SUBMIT_SCRIPT:-$ROOT_DIR/slurm/submit_upload_parallel_slurm.sh}"
+PARALLEL_SHARDS="${PARALLEL_SHARDS:-8}"
+ARRAY_PARALLEL="${ARRAY_PARALLEL:-8}"
+PARTITION="${PARTITION:-main}"
+START_STAGGER_MIN="${START_STAGGER_MIN:-1}"
+START_STAGGER_MAX="${START_STAGGER_MAX:-3}"
+TARGET_BYTES="${TARGET_BYTES:-10737418240}"
+TARGET_FOLDERS="${TARGET_FOLDERS:-40}"
+SLEEP_BETWEEN_WAVES="${SLEEP_BETWEEN_WAVES:-15}"
+PROGRESS_JSON="${PROGRESS_JSON:-/home/sf895/SignVerse-2M-runtime/archive_upload_progress.json}"
+HOME_DATASET_DIR="${HOME_DATASET_DIR:-/home/sf895/SignVerse-2M-runtime/dataset}"
+SCRATCH_DATASET_DIR="${SCRATCH_DATASET_DIR:-/scratch/$USER/SignVerse-2M-runtime/dataset}"
+
+remaining_unuploaded() {
+  python3 - <<PY
+import json
+from pathlib import Path
+import sys
+sys.path.insert(0, '/cache/home/sf895/SignVerse-2M')
+from utils.dataset_pool import list_unuploaded_folder_paths
+progress = json.loads(Path(r"$PROGRESS_JSON").read_text())
+folders = list_unuploaded_folder_paths(Path(r"$HOME_DATASET_DIR"), Path(r"$SCRATCH_DATASET_DIR"), progress.get('uploaded_folders', {}))
+print(len(folders))
+PY
+}
+
+while true; do
+  remaining="$(remaining_unuploaded)"
+  echo "[drain] remaining_unuploaded=$remaining"
+  if [[ "$remaining" == "0" ]]; then
+    echo "[drain] backlog cleared"
+    break
+  fi
+
+  shards="$PARALLEL_SHARDS"
+  array_parallel="$ARRAY_PARALLEL"
+  extra_args=()
+  needed_shards=$(((remaining + TARGET_FOLDERS - 1) / TARGET_FOLDERS))
+  if (( needed_shards < shards )); then
+    shards="$needed_shards"
+  fi
+  if (( shards < 1 )); then
+    shards=1
+  fi
+  if (( shards == 1 )); then
+    array_parallel=""
+    extra_args+=(--allow-small-final-batch --no-require-target-bytes)
+    echo "[drain] switching to single-shard tail mode"
+  else
+    if (( array_parallel > shards )); then
+      array_parallel="$shards"
+    fi
+    echo "[drain] adaptive shard count=$shards"
+  fi
+
+  submit_cmd=(bash "$SUBMIT_SCRIPT"
+    --parallel-shards "$shards"
+    --partition "$PARTITION"
+    --start-stagger-min "$START_STAGGER_MIN"
+    --start-stagger-max "$START_STAGGER_MAX"
+    --target-bytes "$TARGET_BYTES"
+    --target-folders "$TARGET_FOLDERS"
+  )
+  if [[ -n "$array_parallel" ]]; then
+    submit_cmd+=(--array-parallel "$array_parallel")
+  fi
+  if (( ${#extra_args[@]} > 0 )); then
+    submit_cmd+=("${extra_args[@]}")
+  fi
+
+  submit_out="$("${submit_cmd[@]}")"
+  echo "$submit_out"
+  job_id="$(awk '/Submitted batch job/{print $4}' <<< "$submit_out" | tail -n1)"
+  if [[ -z "$job_id" ]]; then
+    echo "[drain] failed to parse submitted job id" >&2
+    exit 1
+  fi
+
+  while [[ -n "$(squeue -h -j "$job_id" 2>/dev/null)" ]]; do
+    sleep "$SLEEP_BETWEEN_WAVES"
+  done
+  sleep 2
+done

slurm/submit_upload_parallel_slurm.sh

@@ -0,0 +1,95 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="${ROOT_DIR:-/home/sf895/SignVerse-2M}"
+RUNTIME_ROOT="${RUNTIME_ROOT:-/home/sf895/SignVerse-2M-runtime}"
+SLURM_SCRIPT="${SLURM_SCRIPT:-$ROOT_DIR/slurm/process_upload_parallel_array.slurm}"
+PARTITION="${PARTITION:-main}"
+TIME_LIMIT="${TIME_LIMIT:-24:00:00}"
+CPUS_PER_TASK="${CPUS_PER_TASK:-2}"
+MEMORY="${MEMORY:-8G}"
+PARALLEL_SHARDS="${PARALLEL_SHARDS:-4}"
+ARRAY_PARALLEL="${ARRAY_PARALLEL:-}"
+START_STAGGER_MIN="${START_STAGGER_MIN:-1}"
+START_STAGGER_MAX="${START_STAGGER_MAX:-3}"
+TARGET_BYTES="${TARGET_BYTES:-10737418240}"
+TARGET_FOLDERS="${TARGET_FOLDERS:-40}"
+ALLOW_SMALL_FINAL_BATCH="${ALLOW_SMALL_FINAL_BATCH:-0}"
+REQUIRE_TARGET_BYTES="${REQUIRE_TARGET_BYTES:-1}"
+DRY_RUN_UPLOAD="${DRY_RUN_UPLOAD:-0}"
+UPLOAD_MODE="${UPLOAD_MODE:-api}"
+REPO_ID="${REPO_ID:-SignerX/SignVerse-2M}"
+REPO_REVISION="${REPO_REVISION:-dev}"
+
+usage() {
+  cat <<USAGE
+Usage:
+  bash slurm/submit_upload_parallel_slurm.sh [options]
+
+Options:
+  --parallel-shards N        Number of uploader shards. Default: 4
+  --array-parallel N         Optional Slurm array concurrency cap
+  --partition NAME           Slurm partition for upload jobs. Default: main
+  --time HH:MM:SS            Default: 24:00:00
+  --cpus-per-task N          Default: 2
+  --mem SIZE                 Default: 8G
+  --target-bytes N           Default: 10737418240
+  --target-folders N         Default: 40
+  --start-stagger-min N      Default: 1
+  --start-stagger-max N      Default: 3
+  --allow-small-final-batch  Permit smaller final shard upload batch
+  --no-require-target-bytes  Allow upload even below target-bytes
+  --dry-run                  Dry-run uploader
+  --upload-mode MODE         api | api-stream | git-ssh. Default: api
+  --repo-id ID               Default: SignerX/SignVerse-2M
+  --repo-revision BRANCH     Default: dev
+  --help
+USAGE
+}
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --parallel-shards) PARALLEL_SHARDS="$2"; shift 2 ;;
+    --array-parallel) ARRAY_PARALLEL="$2"; shift 2 ;;
+    --partition) PARTITION="$2"; shift 2 ;;
+    --time) TIME_LIMIT="$2"; shift 2 ;;
+    --cpus-per-task) CPUS_PER_TASK="$2"; shift 2 ;;
+    --mem) MEMORY="$2"; shift 2 ;;
+    --target-bytes) TARGET_BYTES="$2"; shift 2 ;;
+    --target-folders) TARGET_FOLDERS="$2"; shift 2 ;;
+    --start-stagger-min) START_STAGGER_MIN="$2"; shift 2 ;;
+    --start-stagger-max) START_STAGGER_MAX="$2"; shift 2 ;;
+    --allow-small-final-batch) ALLOW_SMALL_FINAL_BATCH=1; shift ;;
+    --no-require-target-bytes) REQUIRE_TARGET_BYTES=0; shift ;;
+    --dry-run) DRY_RUN_UPLOAD=1; shift ;;
+    --upload-mode) UPLOAD_MODE="$2"; shift 2 ;;
+    --repo-id) REPO_ID="$2"; shift 2 ;;
+    --repo-revision) REPO_REVISION="$2"; shift 2 ;;
+    -h|--help) usage; exit 0 ;;
+    *) echo "Unknown argument: $1" >&2; usage >&2; exit 1 ;;
+  esac
+done
+
+if (( PARALLEL_SHARDS < 1 )); then
+  echo "--parallel-shards must be >= 1" >&2
+  exit 1
+fi
+
+if (( START_STAGGER_MAX < START_STAGGER_MIN )); then
+  echo "--start-stagger-max must be >= --start-stagger-min" >&2
+  exit 1
+fi
+
+array_spec="0-$((PARALLEL_SHARDS - 1))"
+if [[ -n "$ARRAY_PARALLEL" ]]; then
+  array_spec="${array_spec}%${ARRAY_PARALLEL}"
+fi
+
+sbatch \
+  --partition="$PARTITION" \
+  --time="$TIME_LIMIT" \
+  --cpus-per-task="$CPUS_PER_TASK" \
+  --mem="$MEMORY" \
+  --array="$array_spec" \
+  --export=ALL,ROOT_DIR="$ROOT_DIR",RUNTIME_ROOT="$RUNTIME_ROOT",PARALLEL_SHARDS="$PARALLEL_SHARDS",START_STAGGER_MIN="$START_STAGGER_MIN",START_STAGGER_MAX="$START_STAGGER_MAX",TARGET_BYTES="$TARGET_BYTES",TARGET_FOLDERS="$TARGET_FOLDERS",ALLOW_SMALL_FINAL_BATCH="$ALLOW_SMALL_FINAL_BATCH",REQUIRE_TARGET_BYTES="$REQUIRE_TARGET_BYTES",DRY_RUN_UPLOAD="$DRY_RUN_UPLOAD",UPLOAD_MODE="$UPLOAD_MODE",REPO_ID="$REPO_ID",REPO_REVISION="$REPO_REVISION" \
+  "$SLURM_SCRIPT"

slurm/watch_submit_dwpose.slurm

@@ -15,9 +15,9 @@ SUBMIT_SCRIPT="${SUBMIT_SCRIPT:-$ROOT_DIR/slurm/submit_dwpose_slurm.sh}"
 GPU_PARTITIONS="${GPU_PARTITIONS:-gpu,gpu-redhat,cgpu}"
 GPU_ACCOUNT="${GPU_ACCOUNT:-}"
 SCAN_INTERVAL_SECONDS="${SCAN_INTERVAL_SECONDS:-60}"
-SUBMIT_LIMIT="${SUBMIT_LIMIT:-180}"
+SUBMIT_LIMIT="${SUBMIT_LIMIT:-2980}"
 ARRAY_PARALLEL="${ARRAY_PARALLEL:-}"
-MAX_BACKLOG_VIDEOS="${MAX_BACKLOG_VIDEOS:-180}"
+MAX_BACKLOG_VIDEOS="${MAX_BACKLOG_VIDEOS:-2980}"
 FPS="${FPS:-24}"
 MAX_ITERATIONS="${MAX_ITERATIONS:-0}"
 FORCE_PROCESS="${FORCE_PROCESS:-0}"

utils/dataset_pool.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Dict, Iterator, List, Tuple
+
+
+COMPLETE_MARKER_NAME = ".complete"
+
+
+def dataset_dir_for_video(
+    video_path: Path,
+    home_raw_dir: Path,
+    scratch_raw_dir: Path | None,
+    home_dataset_dir: Path,
+    scratch_dataset_dir: Path | None,
+) -> Path:
+    if scratch_raw_dir is not None and scratch_dataset_dir is not None:
+        try:
+            if video_path.parent.resolve() == scratch_raw_dir.resolve():
+                return scratch_dataset_dir
+        except FileNotFoundError:
+            pass
+    return home_dataset_dir
+
+
+def iter_dataset_video_dirs(home_dataset_dir: Path, scratch_dataset_dir: Path | None = None) -> Iterator[Tuple[str, Path]]:
+    seen: Dict[str, Path] = {}
+    for dataset_dir in [home_dataset_dir, scratch_dataset_dir]:
+        if dataset_dir is None or not dataset_dir.exists():
+            continue
+        for folder_path in sorted(dataset_dir.iterdir()):
+            if not folder_path.is_dir():
+                continue
+            seen.setdefault(folder_path.name, folder_path)
+    for video_id, folder_path in sorted(seen.items()):
+        yield video_id, folder_path
+
+
+def complete_video_ids(home_dataset_dir: Path, scratch_dataset_dir: Path | None = None) -> set[str]:
+    complete: set[str] = set()
+    for video_id, folder_path in iter_dataset_video_dirs(home_dataset_dir, scratch_dataset_dir):
+        if (folder_path / "npz" / COMPLETE_MARKER_NAME).exists():
+            complete.add(video_id)
+    return complete
+
+
+def count_complete(home_dataset_dir: Path, scratch_dataset_dir: Path | None = None) -> int:
+    return len(complete_video_ids(home_dataset_dir, scratch_dataset_dir))
+
+
+def find_dataset_video_dir(video_id: str, home_dataset_dir: Path, scratch_dataset_dir: Path | None = None) -> Path:
+    home_path = home_dataset_dir / video_id
+    if home_path.exists():
+        return home_path
+    if scratch_dataset_dir is not None:
+        scratch_path = scratch_dataset_dir / video_id
+        if scratch_path.exists():
+            return scratch_path
+    return home_path
+
+
+def list_unuploaded_folder_paths(
+    home_dataset_dir: Path,
+    scratch_dataset_dir: Path | None,
+    uploaded_folders: Dict[str, object],
+) -> List[Tuple[str, Path]]:
+    folders: List[Tuple[str, Path]] = []
+    for video_id, folder_path in iter_dataset_video_dirs(home_dataset_dir, scratch_dataset_dir):
+        if video_id in uploaded_folders:
+            continue
+        if not (folder_path / "npz" / COMPLETE_MARKER_NAME).exists():
+            continue
+        folders.append((video_id, folder_path))
+    return folders

utils/raw_video_pool.py

@@ -0,0 +1,164 @@
+from __future__ import annotations
+
+import contextlib
+import fcntl
+from pathlib import Path
+from typing import Iterable, Iterator, Sequence
+
+VIDEO_EXTENSIONS = {".mp4", ".mkv", ".webm", ".mov"}
+
+
+def existing_raw_dirs(*dirs: Path | None) -> list[Path]:
+    result: list[Path] = []
+    seen: set[str] = set()
+    for directory in dirs:
+        if directory is None:
+            continue
+        key = str(directory)
+        if key in seen:
+            continue
+        seen.add(key)
+        result.append(directory)
+    return result
+
+
+def collect_raw_videos(*dirs: Path | None) -> dict[str, Path]:
+    videos: dict[str, Path] = {}
+    for directory in existing_raw_dirs(*dirs):
+        if not directory.exists():
+            continue
+        for path in sorted(directory.iterdir()):
+            if not path.is_file() or path.suffix.lower() not in VIDEO_EXTENSIONS:
+                continue
+            videos.setdefault(path.stem, path)
+    return videos
+
+
+def count_raw_videos(*dirs: Path | None) -> int:
+    return len(collect_raw_videos(*dirs))
+
+
+def sum_raw_video_sizes(*dirs: Path | None) -> int:
+    return sum(path.stat().st_size for path in collect_raw_videos(*dirs).values() if path.exists())
+
+
+def iter_raw_video_files(*dirs: Path | None) -> Iterator[Path]:
+    for path in collect_raw_videos(*dirs).values():
+        yield path
+
+
+def find_video_file(video_id: str, *dirs: Path | None) -> Path | None:
+    for directory in existing_raw_dirs(*dirs):
+        if not directory.exists():
+            continue
+        candidates = []
+        for path in directory.glob(f"{video_id}.*"):
+            if path.is_file() and path.suffix.lower() in VIDEO_EXTENSIONS:
+                candidates.append(path)
+        if candidates:
+            return sorted(candidates)[0]
+    return None
+
+
+def iter_partial_download_files(video_id: str, *dirs: Path | None) -> Iterator[Path]:
+    seen: set[Path] = set()
+    for directory in existing_raw_dirs(*dirs):
+        if not directory.exists():
+            continue
+        for path in directory.glob(f"{video_id}*"):
+            if not path.is_file():
+                continue
+            suffixes = set(path.suffixes)
+            if '.part' in suffixes or '.ytdl' in suffixes or path.suffix in {'.part', '.ytdl'}:
+                resolved = path.resolve()
+                if resolved in seen:
+                    continue
+                seen.add(resolved)
+                yield path
+
+
+def cleanup_partial_downloads(video_id: str, *dirs: Path | None) -> None:
+    for partial_path in iter_partial_download_files(video_id, *dirs):
+        partial_path.unlink(missing_ok=True)
+
+
+def _count_reservations(reservation_dir: Path | None, pool_name: str) -> int:
+    if reservation_dir is None:
+        return 0
+    pool_dir = reservation_dir / pool_name
+    if not pool_dir.exists():
+        return 0
+    return sum(1 for path in pool_dir.iterdir() if path.is_file() and path.suffix == ".reserve")
+
+
+def _create_reservation(reservation_dir: Path | None, pool_name: str, reservation_key: str | None) -> Path | None:
+    if reservation_dir is None or not reservation_key:
+        return None
+    pool_dir = reservation_dir / pool_name
+    pool_dir.mkdir(parents=True, exist_ok=True)
+    reservation_path = pool_dir / f"{reservation_key}.reserve"
+    reservation_path.write_text(f"pool={pool_name}\nkey={reservation_key}\n", encoding="utf-8")
+    return reservation_path
+
+
+def release_download_reservation(reservation_path: Path | None) -> None:
+    if reservation_path is not None:
+        reservation_path.unlink(missing_ok=True)
+
+
+def choose_download_target(
+    primary_dir: Path,
+    scratch_dir: Path | None,
+    primary_limit: int,
+    scratch_limit: int,
+    reservation_dir: Path | None = None,
+    reservation_key: str | None = None,
+) -> tuple[Path, Path | None]:
+    primary_dir.mkdir(parents=True, exist_ok=True)
+    if reservation_dir is None:
+        primary_count = count_raw_videos(primary_dir)
+        if primary_count < primary_limit:
+            return primary_dir, None
+        if scratch_dir is None:
+            raise RuntimeError(
+                f"raw backlog full in primary pool ({primary_count}/{primary_limit}) and no scratch raw pool configured"
+            )
+        scratch_dir.mkdir(parents=True, exist_ok=True)
+        scratch_count = count_raw_videos(scratch_dir)
+        if scratch_count < scratch_limit:
+            return scratch_dir, None
+        raise RuntimeError(
+            f"raw backlog full in both pools: primary {primary_count}/{primary_limit}, scratch {scratch_count}/{scratch_limit}"
+        )
+
+    reservation_dir.mkdir(parents=True, exist_ok=True)
+    lock_path = reservation_dir / ".target_selection.lock"
+    with lock_path.open("a+", encoding="utf-8") as lock_handle:
+        fcntl.flock(lock_handle.fileno(), fcntl.LOCK_EX)
+        try:
+            primary_count = count_raw_videos(primary_dir) + _count_reservations(reservation_dir, "home")
+            if primary_count < primary_limit:
+                return primary_dir, _create_reservation(reservation_dir, "home", reservation_key)
+            if scratch_dir is None:
+                raise RuntimeError(
+                    f"raw backlog full in primary pool ({primary_count}/{primary_limit}) and no scratch raw pool configured"
+                )
+            scratch_dir.mkdir(parents=True, exist_ok=True)
+            scratch_count = count_raw_videos(scratch_dir) + _count_reservations(reservation_dir, "scratch")
+            if scratch_count < scratch_limit:
+                return scratch_dir, _create_reservation(reservation_dir, "scratch", reservation_key)
+            raise RuntimeError(
+                f"raw backlog full in both pools: primary {primary_count}/{primary_limit}, scratch {scratch_count}/{scratch_limit}"
+            )
+        finally:
+            with contextlib.suppress(OSError):
+                fcntl.flock(lock_handle.fileno(), fcntl.LOCK_UN)
+
+
+def remove_video_files(video_id: str, *dirs: Path | None) -> None:
+    for directory in existing_raw_dirs(*dirs):
+        if not directory.exists():
+            continue
+        for path in directory.glob(f"{video_id}.*"):
+            if path.is_file() and path.suffix.lower() in VIDEO_EXTENSIONS:
+                path.unlink(missing_ok=True)

utils/stats_npz.py

@@ -1,9 +1,10 @@
 import fcntl
+import json
 import os
 import time
 import zipfile
 from pathlib import Path
-from typing import Dict, Iterable
+from typing import Dict, Iterable, Sequence
 
 import numpy as np
 
@@ -80,8 +81,12 @@ def save_stats(stats_path: Path, stats: Dict[str, Dict[str, str]]) -> None:
     for field in STATUS_FIELDS:
         payload[field] = np.asarray([stats[video_id].get(field, "") for video_id in video_ids], dtype=object)
     tmp_path = stats_path.parent / f".{stats_path.stem}.{os.getpid()}.tmp.npz"
-    np.savez(tmp_path, **payload)
-    os.replace(tmp_path, stats_path)
+    try:
+        np.savez(tmp_path, **payload)
+        os.replace(tmp_path, stats_path)
+    finally:
+        if tmp_path.exists():
+            tmp_path.unlink(missing_ok=True)
 
 
 def ensure_record(stats: Dict[str, Dict[str, str]], video_id: str) -> Dict[str, str]:
@@ -132,3 +137,128 @@ def update_many_video_stats_with_retry(stats_path: Path, video_ids: Iterable[str
     if last_error is not None:
         raise last_error
 
+
+
+def journal_lock_path(journal_path: Path) -> Path:
+    return journal_path.with_suffix(journal_path.suffix + ".lock")
+
+
+def sidecar_status_dir(stats_path: Path) -> Path:
+    return stats_path.parent / "video_status"
+
+
+def sidecar_status_path(stats_path: Path, video_id: str) -> Path:
+    return sidecar_status_dir(stats_path) / f"{video_id}.jsonl"
+
+
+def append_status_journal(journal_path: Path, video_ids: Sequence[str], **updates: str) -> None:
+    journal_path.parent.mkdir(parents=True, exist_ok=True)
+    payload = {
+        "video_ids": list(video_ids),
+        "updates": {key: ("" if value is None else str(value)) for key, value in updates.items()},
+        "recorded_at": time.strftime("%Y-%m-%d %H:%M:%S"),
+    }
+    lock_path = journal_lock_path(journal_path)
+    with lock_path.open("a+", encoding="utf-8") as handle:
+        fcntl.flock(handle.fileno(), fcntl.LOCK_EX)
+        try:
+            with journal_path.open("a", encoding="utf-8") as journal_handle:
+                journal_handle.write(json.dumps(payload, ensure_ascii=False) + "\n")
+        finally:
+            fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
+
+
+def append_status_sidecar(stats_path: Path, video_id: str, **updates: str) -> None:
+    payload = {
+        "video_ids": [video_id],
+        "updates": {key: ("" if value is None else str(value)) for key, value in updates.items()},
+        "recorded_at": time.strftime("%Y-%m-%d %H:%M:%S"),
+    }
+    sidecar_path = sidecar_status_path(stats_path, video_id)
+    sidecar_path.parent.mkdir(parents=True, exist_ok=True)
+    lock_path = journal_lock_path(sidecar_path)
+    with lock_path.open("a+", encoding="utf-8") as handle:
+        fcntl.flock(handle.fileno(), fcntl.LOCK_EX)
+        try:
+            with sidecar_path.open("a", encoding="utf-8") as sidecar_handle:
+                sidecar_handle.write(json.dumps(payload, ensure_ascii=False) + "\n")
+        finally:
+            fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
+
+
+def update_video_stats_best_effort(stats_path: Path, journal_path: Path, video_id: str, **updates: str) -> Dict[str, str]:
+    append_status_sidecar(stats_path, video_id, **updates)
+    return {key: ("" if value is None else str(value)) for key, value in updates.items() if key in STATUS_FIELDS}
+
+
+def update_many_video_stats_best_effort(stats_path: Path, journal_path: Path, video_ids: Sequence[str], **updates: str) -> None:
+    try:
+        update_many_video_stats_with_retry(stats_path, video_ids, **updates)
+    except Exception:
+        append_status_journal(journal_path, video_ids, **updates)
+
+
+def _apply_payloads_to_stats(stats_path: Path, payloads: Sequence[dict]) -> int:
+    if not payloads:
+        return 0
+    update_count = 0
+    stats_lock_path = _lock_path(stats_path)
+    stats_lock_path.parent.mkdir(parents=True, exist_ok=True)
+    with stats_lock_path.open("a+", encoding="utf-8") as stats_handle:
+        fcntl.flock(stats_handle.fileno(), fcntl.LOCK_EX)
+        try:
+            stats = _load_stats_unlocked(stats_path)
+            for payload in payloads:
+                video_ids = [str(item) for item in payload.get("video_ids", []) if str(item)]
+                updates = payload.get("updates", {})
+                if not video_ids or not isinstance(updates, dict):
+                    continue
+                for video_id in video_ids:
+                    record = ensure_record(stats, video_id)
+                    for key, value in updates.items():
+                        if key in STATUS_FIELDS:
+                            record[key] = "" if value is None else str(value)
+                    update_count += 1
+            if update_count:
+                save_stats(stats_path, stats)
+        finally:
+            fcntl.flock(stats_handle.fileno(), fcntl.LOCK_UN)
+    return update_count
+
+
+def apply_status_journal_to_stats(stats_path: Path, journal_path: Path, remove_applied: bool = True) -> int:
+    payloads = []
+
+    if journal_path.exists() and journal_path.stat().st_size > 0:
+        lock_path = journal_lock_path(journal_path)
+        with lock_path.open("a+", encoding="utf-8") as handle:
+            fcntl.flock(handle.fileno(), fcntl.LOCK_EX)
+            try:
+                if journal_path.exists() and journal_path.stat().st_size > 0:
+                    for line in journal_path.read_text(encoding="utf-8").splitlines():
+                        if line.strip():
+                            payloads.append(json.loads(line))
+                    if remove_applied:
+                        journal_path.unlink(missing_ok=True)
+            finally:
+                fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
+
+    sidecar_dir = sidecar_status_dir(stats_path)
+    if sidecar_dir.exists():
+        for sidecar_path in sorted(sidecar_dir.glob("*.jsonl")):
+            lock_path = journal_lock_path(sidecar_path)
+            with lock_path.open("a+", encoding="utf-8") as handle:
+                fcntl.flock(handle.fileno(), fcntl.LOCK_EX)
+                try:
+                    if sidecar_path.exists() and sidecar_path.stat().st_size > 0:
+                        for line in sidecar_path.read_text(encoding="utf-8").splitlines():
+                            if line.strip():
+                                payloads.append(json.loads(line))
+                    if remove_applied:
+                        sidecar_path.unlink(missing_ok=True)
+                finally:
+                    fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
+            if remove_applied:
+                lock_path.unlink(missing_ok=True)
+
+    return _apply_payloads_to_stats(stats_path, payloads)