Reject reused update batch IDs

README.md

@@ -250,6 +250,10 @@ The latest-view rebuild is per-table and internally parallel over source
 Parquet files. Set `LATEST_REBUILD_WORKERS` to tune that fan-out for the
 machine's RAM and disk.
 
+Every ingest that can commit new archives must use a fresh `BATCH_ID`.
+Reusing a committed batch ID is rejected because all-revisions files are named
+from that ID.
+
 Use `scripts/rebuild_compact_v1.sh` only for a destructive full rebuild from a
 local complete `archives/` tree.
 

docs/PIPELINE_RUNBOOK.md

@@ -73,6 +73,11 @@ FETCHER_RPM=480        # default RPM for osu! API + every download mirror
 DISCOVER_SEARCH_RPM=480 # default RPM for mirror discovery search endpoints
 ```
 
+Use a fresh `BATCH_ID` for every ingest that may commit new archives. The
+wrapper and `ingest_osz.py` refuse to ingest with a batch ID that already has
+committed `archive_revisions`, because reusing it can overwrite existing
+`part-<batch>.parquet` files.
+
 Do not sync bucket `archives/` onto an update worker. The update worker only
 uploads its local `archives/` tree with:
 

python/ingest_osz.py

@@ -0,0 +1,1491 @@
+#!/usr/bin/env python
+"""Ingest one or more .osz archives into the compact v1 store.
+
+End-to-end pipeline (PER CHUNK):
+  1. Invoke the Rust ``osu_indexer`` binary on a chunk of archives;
+     the indexer copies the raw archive to ``archives/sha256/``, hashes each
+     member without writing extracted blob files, parses every .osu / .osb,
+     resolves references, computes rosu-pp difficulty attributes, and emits one
+     NDJSON line per row tagged with ``_table``.
+  2. Group rows by ``_table``; derive the ``set_shard`` partition column from
+     ``set_revisions``.
+  3. Atomically write compact all-revisions Parquet files with
+     ``archive_revisions`` deferred.
+  4. Atomically commit ``archive_revisions`` as the chunk commit marker.
+      Only after this row exists for an archive is the rest of its data
+      guaranteed to be on disk.
+
+Crash-safety guarantees:
+  - Archive copies are tmp+rename atomic in the indexer.
+  - Every parquet write is tmp+rename atomic via parquet_writer._atomic_write_parquet.
+  - The chunk commit marker is ``archive_revisions``: if a chunk crashes
+    before commit, ``--skip-already-ingested`` (default on) re-runs that
+    chunk on the next invocation. Re-running the same chunk_batch_id is
+    idempotent at every step.
+  - Across chunks, only the in-progress chunk's work is at risk on Ctrl+C.
+  - On startup we sweep orphan ``*.tmp.<pid>`` files older than
+    ``--gc-tmp-files-age-min`` (default 60 minutes) so leaks don't grow
+    unbounded.
+"""
+
+from __future__ import annotations
+
+import argparse
+import contextlib
+import datetime as _dt
+import hashlib
+import json
+import os
+import re
+import secrets
+import subprocess
+import sys
+import tempfile
+import time
+from pathlib import Path
+
+import pyarrow.dataset as ds
+from tqdm.auto import tqdm
+
+from parquet_writer import (
+    commit_archive_revisions,
+    group_rows_by_table,
+    load_schemas,
+    write_all_revisions_tables,
+)
+
+
+def _log(msg: str) -> None:
+    """Print to stderr with ``flush=True``.
+
+    Once stderr is not a TTY, Python switches it to block buffering, and
+    progress lines for long-running steps stop appearing in real time.
+    Forcing a flush per line keeps the log live without changing the host
+    terminal's buffering policy.
+    """
+    print(msg, file=sys.stderr, flush=True)
+
+
+def _default_batch_id() -> str:
+    stamp = _dt.datetime.now(_dt.timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+    return f"{stamp}-{secrets.token_hex(3)}"
+
+
+# Windows SetThreadExecutionState flags (winbase.h).
+# Setting ES_CONTINUOUS | ES_SYSTEM_REQUIRED tells the OS to keep
+# resetting the system idle timer until cleared — i.e. don't sleep.
+# Display sleep / screen lock are NOT inhibited; only system sleep.
+_ES_CONTINUOUS = 0x80000000
+_ES_SYSTEM_REQUIRED = 0x00000001
+
+
+def _process_alive(pid: int) -> bool:
+    """Best-effort check whether process ``pid`` is still running.
+
+    Used by :func:`repo_lock` to detect stale lock files left behind by a
+    crashed previous run. False positives (treating a dead process as alive)
+    only block the user with a clear "remove the lock" instruction; false
+    negatives (treating a live process as dead) would let two writers race,
+    which is the actual hazard — so the implementation errs on the side of
+    "alive" whenever it cannot definitively prove the process has exited.
+    """
+    if pid <= 0:
+        return False
+    if sys.platform.startswith("win"):
+        try:
+            import ctypes  # noqa: PLC0415
+
+            # use_last_error=True lets us read the Win32 error from
+            # OpenProcess so we can distinguish "no such PID" (truly dead)
+            # from "exists but unqueryable" (assume alive).
+            kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
+            # PROCESS_QUERY_LIMITED_INFORMATION (0x1000) is granted even
+            # across user / integrity-level boundaries, so we don't false-
+            # negative on processes we don't own.
+            handle = kernel32.OpenProcess(0x1000, False, pid)
+            if not handle:
+                err = ctypes.get_last_error()
+                # ERROR_INVALID_PARAMETER (87) is what the kernel returns
+                # when there is no process with the given PID — that is the
+                # only signal that lets us safely report "dead". Anything
+                # else (ACCESS_DENIED = 5, etc.) means the process probably
+                # exists but we can't query it; play it safe and assume
+                # alive, because a false negative would let two writers race.
+                return err != 87
+            exit_code = ctypes.c_ulong(0)
+            ok = kernel32.GetExitCodeProcess(handle, ctypes.byref(exit_code))
+            kernel32.CloseHandle(handle)
+            if not ok:
+                return True  # uncertain — assume alive
+            # STILL_ACTIVE = 259. Anything else = the process has exited.
+            return exit_code.value == 259
+        except (ImportError, OSError, AttributeError):
+            return True  # uncertain — assume alive
+    # POSIX: signal 0 just probes for liveness without delivering a signal.
+    try:
+        os.kill(pid, 0)
+        return True
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        # Process exists but we don't own it — alive.
+        return True
+    except OSError:
+        return True  # uncertain — assume alive
+
+
+def _try_atomic_create_lock(lock_path: Path, payload: str) -> bool:
+    """Atomically create the lock file with ``payload``.
+
+    Returns ``True`` on success, ``False`` if the file already exists.
+    ``O_CREAT | O_EXCL`` is the kernel's only race-free way to take an
+    exclusive lock against a concurrent process — a separate ``exists()``
+    check followed by ``write_text()`` has a TOCTOU window where two
+    launches both see "no lock" and both write, producing two writers
+    that each believe they hold it.
+    """
+    try:
+        fd = os.open(lock_path, os.O_CREAT | os.O_EXCL | os.O_WRONLY)
+    except FileExistsError:
+        return False
+    with os.fdopen(fd, "w", encoding="utf-8") as f:
+        f.write(payload)
+    return True
+
+
+@contextlib.contextmanager
+def repo_lock(repo_root: Path, force: bool = False):
+    """Hold an exclusive single-writer lock on ``repo_root`` for the with body.
+
+    Stores ``<pid>\\n<utc-iso-timestamp>\\n`` in ``repo_root/.ingest.lock``.
+    On entry, refuses to proceed if the lock already exists and points to a
+    PID that's still alive — two concurrent ingests against the same repo
+    would race on the orphan-parquet GC and the latest-bucket transaction
+    promotion, producing duplicate rows and lost work.
+
+    Acquisition uses ``O_CREAT | O_EXCL`` so two simultaneous launches can't
+    both pass the existence check before either writes. Stale locks (PID no
+    longer alive) are cleaned up automatically with a one-line stderr notice.
+    Pass ``force=True`` (CLI ``--force-lock``) to override even a live-PID
+    lock — only safe if the user has manually confirmed the other process
+    is gone.
+
+    Released on exit even if the body raises. The lock file lives at the
+    repo root rather than under ``data/`` so that ``rm -rf data/`` for a
+    fresh restart doesn't accidentally remove an active lock.
+
+    Yields ``had_stale_lock: bool`` so the body can decide whether paranoid
+    crash-recovery sweeps (e.g. orphan tmp file GC) need to run. Lock file
+    presence at startup means the previous run did not unwind cleanly:
+    either it was hard-killed (OS crash, SIGKILL, power loss) before its
+    ``finally`` could unlink the file, or the user is overriding a live
+    lock with ``--force-lock``. A clean exit (including caught Ctrl+C and
+    propagated exceptions) always unlinks the lock, so its absence on the
+    next startup is a positive proof of clean shutdown.
+    """
+    repo_root.mkdir(parents=True, exist_ok=True)
+    lock_path = repo_root / ".ingest.lock"
+    payload = (
+        f"{os.getpid()}\n"
+        f"{_dt.datetime.now(_dt.timezone.utc).isoformat()}\n"
+    )
+    had_stale_lock = False
+
+    if not _try_atomic_create_lock(lock_path, payload):
+        # Lock already exists. Diagnose owner before deciding whether to clean.
+        had_stale_lock = True
+        existing_pid: int | None = None
+        existing_started: str = "?"
+        try:
+            content = lock_path.read_text(encoding="utf-8").strip().splitlines()
+            existing_pid = int(content[0])
+            if len(content) > 1:
+                existing_started = content[1]
+        except (OSError, ValueError, IndexError):
+            pass
+
+        if existing_pid is not None and _process_alive(existing_pid):
+            if not force:
+                raise SystemExit(
+                    f"error: ingest lock at {lock_path} is held by PID "
+                    f"{existing_pid} (started {existing_started}). "
+                    f"Refusing to launch a second writer against {repo_root} — "
+                    f"two concurrent ingests would corrupt the dataset "
+                    f"(orphan-parquet GC and latest-bucket promotion are not "
+                    f"multi-writer safe). If you are certain that PID is gone, "
+                    f"remove the lock file or pass --force-lock."
+                )
+            print(
+                f"warning: --force-lock overriding existing lock "
+                f"(PID {existing_pid}, started {existing_started}); this is "
+                f"unsafe if the other process is still writing.",
+                file=sys.stderr,
+            )
+        elif existing_pid is not None:
+            print(
+                f"info: removing stale ingest lock at {lock_path} "
+                f"(PID {existing_pid} no longer alive; was started "
+                f"{existing_started})",
+                file=sys.stderr,
+            )
+        else:
+            print(
+                f"info: removing unparseable ingest lock at {lock_path}",
+                file=sys.stderr,
+            )
+
+        try:
+            lock_path.unlink()
+        except OSError:
+            pass
+        # Re-attempt atomically. If a third process raced in between our
+        # unlink and create, refuse rather than overwriting their lock.
+        if not _try_atomic_create_lock(lock_path, payload):
+            raise SystemExit(
+                f"error: lock at {lock_path} was re-acquired by another "
+                f"process between cleanup and retry; refusing to proceed."
+            )
+
+    try:
+        yield had_stale_lock
+    finally:
+        try:
+            lock_path.unlink()
+        except OSError:
+            pass
+
+
+@contextlib.contextmanager
+def keep_awake(enabled: bool = True):
+    """Inhibit system sleep for the duration of the ``with`` block.
+
+    On Windows: ``SetThreadExecutionState(ES_CONTINUOUS | ES_SYSTEM_REQUIRED)``
+    on entry, ``SetThreadExecutionState(ES_CONTINUOUS)`` on exit (clears the
+    flags so the system can sleep again on its normal idle policy).
+
+    On non-Windows or when ``enabled=False``: no-op.
+
+    The display is NOT kept awake — only the system. Phase 17 runs unattended,
+    so we want to let the screen turn off but keep the box awake.
+    """
+    if not enabled or not sys.platform.startswith("win"):
+        yield
+        return
+
+    try:
+        import ctypes  # noqa: PLC0415 — keep import optional for non-win platforms
+    except ImportError:
+        print(
+            "warning: ctypes unavailable; system may sleep during the run",
+            file=sys.stderr,
+        )
+        yield
+        return
+
+    try:
+        kernel32 = ctypes.windll.kernel32
+    except (AttributeError, OSError) as e:
+        print(
+            f"warning: SetThreadExecutionState unavailable ({e}); "
+            f"system may sleep during the run",
+            file=sys.stderr,
+        )
+        yield
+        return
+
+    prev = kernel32.SetThreadExecutionState(_ES_CONTINUOUS | _ES_SYSTEM_REQUIRED)
+    if prev == 0:
+        # 0 means the call failed; the doc says GetLastError gives details,
+        # but a single warning is enough — fall through and let the run
+        # proceed even without the inhibitor.
+        print(
+            "warning: SetThreadExecutionState failed; system may sleep during the run",
+            file=sys.stderr,
+        )
+        yield
+        return
+
+    print(
+        "keep-awake: system sleep inhibited (ES_SYSTEM_REQUIRED). "
+        "Display can still sleep on its normal timer.",
+        file=sys.stderr,
+    )
+    try:
+        yield
+    finally:
+        try:
+            kernel32.SetThreadExecutionState(_ES_CONTINUOUS)
+            print("keep-awake: released; normal sleep policy restored.", file=sys.stderr)
+        except Exception:
+            # We're already exiting; swallow rather than mask the real error.
+            pass
+
+
+def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
+    p = argparse.ArgumentParser(
+        prog="ingest_osz",
+        description="Ingest .osz archives into the compact v1 store.",
+    )
+    p.add_argument(
+        "archives",
+        nargs="+",
+        help=".osz files (or directories of .osz files) to ingest",
+    )
+    p.add_argument(
+        "--repo-root",
+        default=".",
+        help="root of the osu-everything repo (default: cwd)",
+    )
+    p.add_argument(
+        "--schema-version",
+        default="v1",
+        help="schema version directory under data/",
+    )
+    p.add_argument(
+        "--schemas-dir",
+        default=None,
+        help="override schema-loading directory (default: <repo>/schemas/<schema-version>)",
+    )
+    p.add_argument(
+        "--rosu-indexer",
+        default="./target/release/osu_indexer",
+        help="path to the compiled Rust indexer binary",
+    )
+
+    p.add_argument(
+        "--archives-dir",
+        default=None,
+        help="absolute directory where archive .osz CAS copies are written "
+        "(default: <repo-root>/archives)",
+    )
+
+    p.add_argument(
+        "--indexer-workers",
+        type=int,
+        default=None,
+        help="number of archives the Rust indexer processes concurrently per "
+        "chunk (forwarded as --workers). Defaults to the indexer's own "
+        "default of min(4, available_parallelism). Higher values keep both "
+        "input and CAS drives busy continuously and parallelize rosu-pp "
+        "across cores; on a single HDD spindle, going past 4 workers "
+        "thrashes seeks.",
+    )
+
+    p.add_argument(
+        "--write-all-revisions",
+        dest="write_all_revisions",
+        action="store_true",
+        default=True,
+    )
+    p.add_argument(
+        "--no-write-all-revisions",
+        dest="write_all_revisions",
+        action="store_false",
+    )
+
+    p.add_argument(
+        "--physical-partitioning",
+        choices=("schema", "none"),
+        default="none",
+        help="physical all_revisions partition layout. 'schema' preserves the "
+        "schema partition dirs; 'none' writes one parquet per table per chunk "
+        "while retaining partition columns in the file body.",
+    )
+
+    p.add_argument(
+        "--ingest-batch-id",
+        default=None,
+        help="parent batch id; chunks get '-chunk-NNNN' suffix when >1 chunk "
+        "(defaults to UTC ISO-8601 + random suffix)",
+    )
+    p.add_argument(
+        "--limit",
+        type=int,
+        default=None,
+        help="stop after N archives (useful for smoke tests)",
+    )
+    p.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="run the indexer but do not write Parquet",
+    )
+
+    p.add_argument(
+        "--skip-difficulty",
+        action="store_true",
+        help="forward to osu_indexer: skip the rosu-pp difficulty pass",
+    )
+    p.add_argument(
+        "--keep-ndjson",
+        type=Path,
+        default=None,
+        help="path to keep the indexer's NDJSON output for inspection "
+        "(default: write to a temp file and delete after; in chunked mode "
+        "the per-chunk NDJSON gets a '.<chunk_idx>' suffix)",
+    )
+
+    # Resume / crash-safety knobs.
+    p.add_argument(
+        "--skip-already-ingested",
+        dest="skip_already_ingested",
+        action="store_true",
+        default=True,
+        help="hash each input archive at startup and skip those whose "
+        "archive_sha256 is already in archive_revisions/ (default on)",
+    )
+    p.add_argument(
+        "--no-skip-already-ingested",
+        dest="skip_already_ingested",
+        action="store_false",
+    )
+    p.add_argument(
+        "--archive-sha-cache",
+        dest="archive_sha_cache",
+        action="store_true",
+        default=True,
+        help="cache (path, mtime, size, sha256) for input archives in "
+        ".scratch/input_archive_shas.json so the pre-chunk hashing pass "
+        "skips files that haven't changed since last run (default on)",
+    )
+    p.add_argument(
+        "--no-archive-sha-cache",
+        dest="archive_sha_cache",
+        action="store_false",
+        help="force-rehash every input archive at startup, ignoring the cache",
+    )
+    p.add_argument(
+        "--chunk-size",
+        type=int,
+        default=1000,
+        help="archives per indexer invocation; smaller = finer resume "
+        "granularity, larger = fewer parquet files (default 1000)",
+    )
+    p.add_argument(
+        "--gc-tmp-files",
+        dest="gc_tmp_files",
+        action="store_true",
+        default=True,
+        help="enable orphan *.tmp.<pid> file GC on startup (default on). "
+        "By default the walk only runs when a stale .ingest.lock is "
+        "detected at startup (= previous run was hard-killed); on clean "
+        "exits and Ctrl+C the walk is skipped because atomic tmp+rename + "
+        "the indexer's signal-aware drain leave no orphans. Pass "
+        "--always-gc-tmp-files to walk unconditionally.",
+    )
+    p.add_argument(
+        "--no-gc-tmp-files",
+        dest="gc_tmp_files",
+        action="store_false",
+        help="never walk for orphan tmp files. Use only when you've "
+        "manually confirmed the repo is clean — leftover tmp files will "
+        "stay on disk forever as wasted space until cleaned by hand.",
+    )
+    p.add_argument(
+        "--always-gc-tmp-files",
+        dest="always_gc_tmp_files",
+        action="store_true",
+        default=False,
+        help="walk archives/ and data/ for orphan *.tmp.<pid> files on every "
+        "startup, regardless of whether the previous run shut down cleanly.",
+    )
+    p.add_argument(
+        "--always-crash-recovery",
+        dest="always_crash_recovery",
+        action="store_true",
+        default=False,
+        help="run orphan-Parquet cleanup on every startup, regardless of "
+        "whether the previous run shut down cleanly.",
+    )
+    p.add_argument(
+        "--gc-tmp-files-age-min",
+        type=int,
+        default=60,
+        help="minimum age in minutes for tmp files to be eligible for GC "
+        "(default 60); set to 0 to delete all orphans",
+    )
+    p.add_argument(
+        "--cleanup-orphan-parquets",
+        dest="cleanup_orphan_parquets",
+        action="store_true",
+        default=True,
+        help="on startup, delete all_revisions/<table>/.../part-<batch>.parquet "
+        "files whose batch_id has no archive_revisions commit marker — "
+        "fixes duplicate rows after a crashed chunk (default on)",
+    )
+    p.add_argument(
+        "--no-cleanup-orphan-parquets",
+        dest="cleanup_orphan_parquets",
+        action="store_false",
+    )
+
+    p.add_argument(
+        "--quiet-indexer",
+        action="store_true",
+        help="forward --quiet to the Rust indexer, suppressing the per-archive "
+        "progress line. The chunk-level ETA/timing summary is still printed.",
+    )
+
+    p.add_argument(
+        "--keep-awake",
+        dest="keep_awake",
+        action="store_true",
+        default=True,
+        help="on Windows, prevent system sleep for the duration of the run "
+        "via SetThreadExecutionState (ES_SYSTEM_REQUIRED). Display sleep is "
+        "not inhibited. Default on; no-op on non-Windows.",
+    )
+    p.add_argument(
+        "--no-keep-awake",
+        dest="keep_awake",
+        action="store_false",
+    )
+
+    p.add_argument(
+        "--force-lock",
+        dest="force_lock",
+        action="store_true",
+        default=False,
+        help="override an existing repo lock even if the holding PID is still "
+        "alive. UNSAFE: two concurrent ingests against the same repo will "
+        "corrupt the dataset. Only pass this if you have manually confirmed "
+        "the previous process is gone.",
+    )
+
+    return p.parse_args(argv)
+
+
+def _resolve_indexer_path(indexer: Path, repo_root: Path) -> Path | None:
+    """Find the indexer binary by trying cwd- and repo-root-relative,
+    with and without a Windows .exe suffix."""
+    candidates: list[Path] = []
+    if indexer.is_absolute():
+        candidates.append(indexer)
+    else:
+        candidates.extend([Path.cwd() / indexer, repo_root / indexer])
+    if sys.platform.startswith("win"):
+        candidates += [c.with_suffix(c.suffix + ".exe") for c in list(candidates)]
+    for c in candidates:
+        if c.exists():
+            return c.resolve()
+    return None
+
+
+def collect_archives(inputs: list[str]) -> list[Path]:
+    out: list[Path] = []
+    for arg in inputs:
+        p = Path(arg)
+        if p.is_dir():
+            out.extend(sorted(p.rglob("*.osz")))
+        elif p.is_file() and p.suffix.lower() == ".osz":
+            out.append(p)
+        else:
+            print(f"warning: skipping non-.osz argument {arg!r}", file=sys.stderr)
+    return out
+
+
+def _format_duration(seconds: float) -> str:
+    """Compact human-readable duration ('42s', '7.3m', '4.2h')."""
+    if seconds < 60:
+        return f"{seconds:.0f}s"
+    if seconds < 3600:
+        return f"{seconds / 60:.1f}m"
+    return f"{seconds / 3600:.1f}h"
+
+
+def _format_size(num_bytes: float) -> str:
+    """Compact human-readable byte size ('312 KB', '47.2 MB', '3.1 GB')."""
+    n = float(num_bytes)
+    for unit in ("B", "KB", "MB", "GB", "TB"):
+        if n < 1024 or unit == "TB":
+            return f"{n:.1f} {unit}" if unit != "B" else f"{int(n)} B"
+        n /= 1024
+    return f"{n:.1f} TB"
+
+
+def already_ingested_shas(archive_revisions_dir: Path) -> set[str]:
+    """Read existing all_revisions/archive_revisions/ parquets and return the
+    set of archive_sha256 values currently committed.
+
+    Returns an empty set if the directory is empty or missing. Iterates
+    batches under a tqdm bar so the user sees progress while a full-corpus
+    archive_revisions/ (tens of thousands of rows across many parquets) is
+    being read.
+    """
+    if not archive_revisions_dir.exists():
+        return set()
+    parquets = list(archive_revisions_dir.rglob("*.parquet"))
+    if not parquets:
+        return set()
+    dataset = ds.dataset([str(p) for p in parquets], format="parquet")
+    scanner = dataset.scanner(columns=["archive_sha256"])
+    total = scanner.count_rows()
+    out: set[str] = set()
+    bar = tqdm(
+        total=total,
+        desc=f"reading committed archive_sha256s ({len(parquets)} parquet(s))",
+        unit="row",
+        unit_scale=True,
+        file=sys.stderr,
+        mininterval=1.0,
+        dynamic_ncols=True,
+    )
+    try:
+        for batch in scanner.to_batches():
+            out.update(batch.column("archive_sha256").to_pylist())
+            bar.update(batch.num_rows)
+    finally:
+        bar.close()
+    return out
+
+
+def sha256_of_file(path: Path) -> str:
+    h = hashlib.sha256()
+    with path.open("rb") as f:
+        for chunk in iter(lambda: f.read(1 << 20), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+# JSON sidecar mapping ``str(path.resolve()) -> {mtime_ns, size_bytes, sha256}``.
+# A re-run with unchanged inputs is dominated by the cost of statting each file
+# and reading the cache; on a 38k-archive HDD corpus this collapses ~55 minutes
+# of SHA-256 to a few seconds. A stale cache loses correctness only if the user
+# replaces a file's contents while preserving both mtime AND size — pass
+# ``--no-archive-sha-cache`` to force re-hashing if that's a real concern.
+_ARCHIVE_SHA_CACHE_BASENAME = "input_archive_shas.json"
+
+
+def _archive_sha_cache_path(repo_root: Path) -> Path:
+    return repo_root / ".scratch" / _ARCHIVE_SHA_CACHE_BASENAME
+
+
+def _load_archive_sha_cache(cache_path: Path) -> dict[str, dict]:
+    if not cache_path.exists():
+        return {}
+    try:
+        data = json.loads(cache_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as e:
+        _log(f"  warning: ignoring unreadable sha cache at {cache_path}: {e}")
+        return {}
+    if not isinstance(data, dict):
+        return {}
+    return data
+
+
+def _save_archive_sha_cache(cache_path: Path, cache: dict[str, dict]) -> None:
+    cache_path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = cache_path.with_suffix(cache_path.suffix + f".tmp.{os.getpid()}")
+    try:
+        tmp.write_text(json.dumps(cache), encoding="utf-8")
+        os.replace(tmp, cache_path)
+    except OSError as e:
+        _log(f"  warning: could not save sha cache to {cache_path}: {e}")
+        try:
+            tmp.unlink()
+        except OSError:
+            pass
+
+
+def filter_already_ingested(
+    archives: list[Path],
+    known_shas: set[str],
+    cache_path: Path | None = None,
+) -> tuple[list[Path], list[Path], list[tuple[Path, Path]]]:
+    """Hash each archive and partition into (to_ingest, already_done, duplicates).
+
+    The hashing pass also de-duplicates the *input* list by content SHA-256.
+    If ``osu_archives/`` accidentally contains two files whose bytes are
+    identical (e.g. ``1.osz`` plus ``copy_of_1.osz``), the duplicate would
+    otherwise produce two ``archive_revisions`` rows with the same primary
+    key in the same chunk. We keep the first occurrence (sorted glob order
+    is already deterministic) and report the rest as ``duplicates``.
+
+    Always hashes — including when ``known_shas`` is empty, so duplicate
+    inputs in a fresh run are still caught. To opt out of the hashing cost
+    on small/trusted inputs, pass ``--no-skip-already-ingested`` to
+    ``ingest_osz.py``; that path skips this entire function.
+
+    With ``cache_path`` set, an on-disk sidecar maps
+    ``str(path.resolve()) -> {mtime_ns, size_bytes, sha256}``. Inputs whose
+    (path, mtime_ns, size_bytes) match a cache entry skip the full hash; new
+    or modified files are hashed once and added to the cache. Saved every
+    5,000 hashes and again at function exit so a Ctrl+C mid-pass keeps the
+    work done so far. The first full-corpus pass on HDD still takes ~50 min
+    (~12 archives/sec); subsequent passes finish in seconds.
+    """
+    cache: dict[str, dict] = (
+        _load_archive_sha_cache(cache_path) if cache_path is not None else {}
+    )
+    cache_dirty = False
+    cache_hits = 0
+    save_every = 5000
+    hashes_since_save = 0
+
+    def _persist() -> None:
+        nonlocal cache_dirty, hashes_since_save
+        if cache_path is None or not cache_dirty:
+            return
+        _save_archive_sha_cache(cache_path, cache)
+        cache_dirty = False
+        hashes_since_save = 0
+
+    to_ingest: list[Path] = []
+    already_done: list[Path] = []
+    duplicates: list[tuple[Path, Path]] = []
+    seen_in_input: dict[str, Path] = {}
+    try:
+        for p in tqdm(
+            archives,
+            total=len(archives),
+            desc="hashing archives",
+            unit="archive",
+            file=sys.stderr,
+            mininterval=1.0,
+            dynamic_ncols=True,
+        ):
+            cache_key: str | None = None
+            mtime_ns: int | None = None
+            size_bytes: int | None = None
+            try:
+                stat = p.stat()
+                size_bytes = stat.st_size
+                mtime_ns = stat.st_mtime_ns
+                cache_key = str(p.resolve())
+            except OSError:
+                # If we can't stat, fall through to a fresh hash; sha256_of_file
+                # will surface the same OSError if the file is genuinely gone.
+                pass
+            entry = cache.get(cache_key) if cache_key is not None else None
+            if (
+                isinstance(entry, dict)
+                and entry.get("mtime_ns") == mtime_ns
+                and entry.get("size_bytes") == size_bytes
+                and isinstance(entry.get("sha256"), str)
+            ):
+                sha = entry["sha256"]
+                cache_hits += 1
+            else:
+                sha = sha256_of_file(p)
+                if cache_key is not None:
+                    cache[cache_key] = {
+                        "mtime_ns": mtime_ns,
+                        "size_bytes": size_bytes,
+                        "sha256": sha,
+                    }
+                    cache_dirty = True
+                    hashes_since_save += 1
+                    if hashes_since_save >= save_every:
+                        _persist()
+            if sha in seen_in_input:
+                duplicates.append((p, seen_in_input[sha]))
+            elif sha in known_shas:
+                already_done.append(p)
+                seen_in_input[sha] = p
+            else:
+                to_ingest.append(p)
+                seen_in_input[sha] = p
+    finally:
+        _persist()
+    if cache_path is not None:
+        _log(
+            f"  sha cache: {cache_hits:,}/{len(archives):,} hit(s); "
+            f"{len(archives) - cache_hits:,} fresh hash(es) "
+            f"({cache_path})"
+        )
+    return to_ingest, already_done, duplicates
+
+
+_TMP_PATTERN = re.compile(r"\.tmp\.\d+$")
+_PART_BATCH_ID_PATTERN = re.compile(r"^part-(.+)\.parquet$")
+
+
+def committed_batch_ids(archive_revisions_dir: Path) -> set[str]:
+    """Return the set of ``batch_id``s with a committed ``archive_revisions``
+    parquet file on disk.
+
+    Each AR file is named ``part-<batch_id>.parquet``; its existence is the
+    commit marker for that batch. Used by :func:`cleanup_orphan_parquets`
+    to identify all_revisions parquets from crashed chunks.
+    """
+    if not archive_revisions_dir.exists():
+        return set()
+    out: set[str] = set()
+    bar = tqdm(
+        desc="scanning archive_revisions/",
+        unit="file",
+        file=sys.stderr,
+        mininterval=1.0,
+        dynamic_ncols=True,
+    )
+    try:
+        for f in archive_revisions_dir.rglob("*.parquet"):
+            bar.update(1)
+            m = _PART_BATCH_ID_PATTERN.match(f.name)
+            if m:
+                out.add(m.group(1))
+    finally:
+        bar.close()
+    return out
+
+
+def committed_batch_ids_for_parent(
+    archive_revisions_dir: Path,
+    parent_batch_id: str,
+) -> list[str]:
+    prefix = f"{parent_batch_id}-chunk-"
+    return sorted(
+        batch_id
+        for batch_id in committed_batch_ids(archive_revisions_dir)
+        if batch_id == parent_batch_id or batch_id.startswith(prefix)
+    )
+
+
+def cleanup_orphan_parquets(
+    all_revisions_root: Path,
+    committed: set[str],
+) -> dict[str, int]:
+    """Delete ``part-<batch_id>.parquet`` files in non-archive_revisions
+    tables whose ``batch_id`` is not in ``committed``.
+
+    These are remnants of crashed chunks: their tables were written but
+    the chunk's ``archive_revisions`` row never made it to disk, so
+    skip-already-ingested will re-process the chunk and write fresh
+    parquets. Without cleanup the resume produces duplicate rows.
+
+    AR itself is never touched. Returns a per-table count of deletions.
+    """
+    out: dict[str, int] = {}
+    if not all_revisions_root.exists():
+        return out
+    table_dirs = [
+        d for d in all_revisions_root.iterdir()
+        if d.is_dir() and d.name != "archive_revisions"
+    ]
+    for table_dir in tqdm(
+        table_dirs,
+        total=len(table_dirs),
+        desc="scanning all_revisions tables",
+        unit="table",
+        file=sys.stderr,
+        mininterval=1.0,
+        dynamic_ncols=True,
+    ):
+        n = 0
+        for parquet in table_dir.rglob("*.parquet"):
+            m = _PART_BATCH_ID_PATTERN.match(parquet.name)
+            if not m:
+                continue
+            if m.group(1) not in committed:
+                try:
+                    parquet.unlink()
+                    n += 1
+                except OSError:
+                    pass
+        if n:
+            out[table_dir.name] = n
+    return out
+
+
+def cleanup_orphan_tmp_files(
+    repo_root: Path,
+    max_age_seconds: int,
+    extra_roots: list[tuple[str, Path]] | None = None,
+) -> dict[str, int]:
+    """Delete orphan ``*.tmp.<pid>`` files under archives/ and data/.
+
+    Files are eligible when their mtime is older than ``max_age_seconds``;
+    very young tmp files might belong to a concurrent run, so we skip them.
+    Returns ``{subdir: count_deleted}``.
+
+    ``extra_roots`` is an optional list of ``(label, absolute_path)`` pairs
+    to also walk, used when ``--archives-dir`` points outside ``repo_root``.
+
+    Pass ``max_age_seconds=0`` to delete unconditionally (dangerous if any
+    other process is mid-write — only safe when we're the sole writer).
+
+    Each subdir's rglob is wrapped in an indeterminate-total tqdm spinner
+    because we don't know the file count up-front and a full-corpus repo
+    can hold millions of entries — without the bar a user on HDD just sees
+    silence for 5-10 minutes.
+    """
+    standard_subs = ("archives", "data")
+    out: dict[str, int] = {s: 0 for s in standard_subs}
+    extras = list(extra_roots or [])
+    for label, _ in extras:
+        out.setdefault(label, 0)
+
+    # Build the (label, path) walk list, deduping by resolved absolute path so
+    # an extra root that aliases repo_root/archives does not get scanned twice.
+    seen: set[Path] = set()
+    targets: list[tuple[str, Path]] = []
+    for label, path in (
+        [(s, repo_root / s) for s in standard_subs] + extras
+    ):
+        try:
+            key = Path(path).resolve()
+        except OSError:
+            key = Path(path)
+        if key in seen:
+            continue
+        seen.add(key)
+        targets.append((label, path))
+
+    now = time.time()
+    for sub, root in targets:
+        if not root.exists():
+            continue
+        bar = tqdm(
+            desc=f"scanning {sub}/",
+            unit="file",
+            file=sys.stderr,
+            mininterval=1.0,
+            dynamic_ncols=True,
+        )
+        try:
+            for f in root.rglob("*"):
+                bar.update(1)
+                if not f.is_file():
+                    continue
+                if _TMP_PATTERN.search(f.name) is None:
+                    continue
+                try:
+                    age = now - f.stat().st_mtime
+                except OSError:
+                    continue
+                if age < max_age_seconds:
+                    continue
+                try:
+                    f.unlink()
+                    out[sub] += 1
+                except OSError:
+                    pass
+        finally:
+            bar.close()
+    return out
+
+
+# Per-chunk indexer wall-time bound. Phase 15 cold-cache wall is ~42 s for 100
+# archives (~0.42 s/archive); chunk_size=1000 should finish well under 10 min.
+# 1800 s is ~4× the projected typical chunk wall, leaving ample headroom for
+# I/O contention but bounded so a single deadlocked rosu-pp call (or any other
+# stuck syscall) cannot hang the orchestrator indefinitely with --keep-awake
+# active. On TimeoutExpired the chunk fails cleanly: the deferred
+# archive_revisions commit means no rows commit, and resume re-runs the chunk.
+INDEXER_TIMEOUT_SECONDS = 1800
+
+
+def run_indexer(
+    indexer: Path,
+    archives: list[Path],
+    archives_dir: Path,
+    blobs_dir: Path,
+    out_file: Path,
+    batch_id: str,
+    schema_version: str,
+    skip_difficulty: bool,
+    quiet: bool = False,
+    workers: int | None = None,
+    timeout_seconds: int | None = INDEXER_TIMEOUT_SECONDS,
+) -> None:
+    """Invoke the Rust indexer; raise CalledProcessError on non-zero exit.
+
+    The indexer streams a per-archive progress line to its own stderr, which
+    we let pass through unbuffered so the user sees real-time progress
+    during long chunks. Pass ``quiet=True`` to suppress (the indexer's
+    summary line still prints).
+
+    ``workers`` overrides the indexer's parallelism; ``None`` lets the
+    indexer pick its own default (``min(4, available_parallelism)``).
+    Larger values keep input + CAS drives busy in parallel and parallelize
+    the per-beatmap rosu-pp pass across cores.
+
+    A wall-time ``timeout_seconds`` (default ``INDEXER_TIMEOUT_SECONDS``)
+    bounds the call so a deadlocked subprocess cannot hang the orchestrator
+    forever; pass ``None`` to disable. On timeout, the call site sees
+    ``subprocess.TimeoutExpired`` propagate up; the chunk's
+    ``archive_revisions`` commit has not happened yet, so resume re-runs it.
+    """
+    cmd: list[str] = [
+        str(indexer),
+        "--archives-dir", str(archives_dir),
+        "--blobs-dir", str(blobs_dir),
+        "--out-file", str(out_file),
+        "--ingest-batch-id", batch_id,
+        "--schema-version", schema_version,
+    ]
+    if skip_difficulty:
+        cmd.append("--skip-difficulty")
+    cmd.append("--no-write-blobs")
+    if quiet:
+        cmd.append("--quiet")
+    if workers is not None:
+        cmd.extend(["--workers", str(workers)])
+    cmd.extend(str(a) for a in archives)
+    _log(
+        f"  indexer: {len(archives)} archive(s); batch_id={batch_id}"
+    )
+    try:
+        subprocess.run(cmd, check=True, timeout=timeout_seconds)
+    except subprocess.TimeoutExpired as e:
+        _log(
+            f"  indexer TIMEOUT after {e.timeout}s on batch_id={batch_id} "
+            f"({len(archives)} archive(s)); chunk will not commit, "
+            f"resume the run to retry."
+        )
+        raise
+
+
+def _process_chunk(
+    chunk: list[Path],
+    chunk_batch_id: str,
+    args: argparse.Namespace,
+    indexer_path: Path,
+    schemas: dict,
+    repo_root: Path,
+    archives_dir: Path,
+    blobs_dir: Path,
+    all_revisions_root: Path,
+    keep_ndjson: Path | None,
+) -> dict:
+    """Run the full per-chunk pipeline. Returns counts/paths/timings for reporting.
+
+    Each step is timed separately (``*_seconds`` keys in the returned dict)
+    so a long-running chunk's bottleneck is visible without re-running.
+    """
+
+    # NDJSON destination: --keep-ndjson if supplied, else a temp file.
+    # The tempfile lives under repo_root/.scratch (typically the same drive
+    # as the canonical store, e.g. E: on the dev box) rather than the OS
+    # default ($TEMP / C:\) — at chunk_size=1000 each chunk's NDJSON is
+    # 2-5 GB, and 38 chunks of create+delete on the system drive would
+    # waste ~115 GB of write churn unrelated to the dataset.
+    if keep_ndjson is not None:
+        ndjson_path = keep_ndjson
+        ndjson_path.parent.mkdir(parents=True, exist_ok=True)
+        cleanup_ndjson = False
+    else:
+        scratch_dir = repo_root / ".scratch"
+        scratch_dir.mkdir(parents=True, exist_ok=True)
+        tmp = tempfile.NamedTemporaryFile(
+            prefix=f"ingest-{chunk_batch_id}-",
+            suffix=".ndjson",
+            dir=str(scratch_dir),
+            delete=False,
+        )
+        tmp.close()
+        ndjson_path = Path(tmp.name)
+        cleanup_ndjson = True
+
+    chunk_start = time.perf_counter()
+    summary: dict = {"chunk_batch_id": chunk_batch_id, "n_archives": len(chunk)}
+
+    try:
+        t0 = time.perf_counter()
+        run_indexer(
+            indexer=indexer_path,
+            archives=chunk,
+            archives_dir=archives_dir,
+            blobs_dir=blobs_dir,
+            out_file=ndjson_path,
+            batch_id=chunk_batch_id,
+            schema_version=args.schema_version,
+            skip_difficulty=args.skip_difficulty,
+            quiet=args.quiet_indexer,
+            workers=args.indexer_workers,
+        )
+        summary["indexer_seconds"] = time.perf_counter() - t0
+
+        try:
+            summary["ndjson_bytes"] = ndjson_path.stat().st_size
+        except OSError:
+            summary["ndjson_bytes"] = 0
+
+        t0 = time.perf_counter()
+        rows_by_table = group_rows_by_table(ndjson_path)
+        summary["group_seconds"] = time.perf_counter() - t0
+        n_rows = sum(len(rs) for rs in rows_by_table.values())
+        summary["n_rows"] = n_rows
+        summary["archive_revisions_emitted"] = len(rows_by_table.get("archive_revisions", []))
+        summary["set_revisions"] = len(rows_by_table.get("set_revisions", []))
+        summary["beatmaps"] = len(rows_by_table.get("beatmaps", []))
+
+        # P0 safety: an indexer that exited 0 but produced no archive rows is
+        # never expected during a normal run. Refuse to commit an empty chunk
+        # — the resume path (skip-already-ingested) treats archive_revisions
+        # as proof the chunk is done, so a silently-empty commit would
+        # permanently mask a broken chunk.
+        if rows_by_table.get("archive_revisions") is None or not rows_by_table.get("archive_revisions"):
+            raise RuntimeError(
+                f"indexer exited 0 but produced no archive_revisions rows for "
+                f"chunk {chunk_batch_id} ({len(chunk)} input archive(s)); "
+                f"refusing to commit an empty chunk. NDJSON at {ndjson_path}"
+            )
+
+        if args.dry_run:
+            print("  dry-run: skipping Parquet writes", file=sys.stderr)
+            summary["wall_seconds"] = time.perf_counter() - chunk_start
+            return summary
+
+        # Step 3: write all_revisions tables EXCEPT archive_revisions.
+        # (archive_revisions is the chunk commit marker — written last.)
+        if args.write_all_revisions:
+            t0 = time.perf_counter()
+            written = write_all_revisions_tables(
+                rows_by_table,
+                schemas,
+                all_revisions_root,
+                chunk_batch_id,
+                defer_tables=("archive_revisions",),
+                physical_partitioning=args.physical_partitioning,
+            )
+            summary["parquet_seconds"] = time.perf_counter() - t0
+            summary["written_files"] = sum(len(ps) for ps in written.values())
+
+        # Step 4: COMMIT — atomically write archive_revisions.
+        # After this returns, --skip-already-ingested treats this chunk's
+        # archives as done.
+        if args.write_all_revisions:
+            t0 = time.perf_counter()
+            ar_paths = commit_archive_revisions(
+                rows_by_table,
+                schemas,
+                all_revisions_root,
+                chunk_batch_id,
+                physical_partitioning=args.physical_partitioning,
+            )
+            summary["ar_commit_seconds"] = time.perf_counter() - t0
+            summary["archive_revisions_committed"] = len(ar_paths)
+
+    finally:
+        if cleanup_ndjson:
+            try:
+                ndjson_path.unlink()
+            except OSError:
+                pass
+
+    summary["wall_seconds"] = time.perf_counter() - chunk_start
+    return summary
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = parse_args(argv)
+
+    repo_root = Path(args.repo_root).resolve()
+    if args.schemas_dir is not None:
+        schemas_dir = Path(args.schemas_dir).resolve()
+    else:
+        schemas_dir = repo_root / "schemas" / args.schema_version
+    if not schemas_dir.exists():
+        print(
+            f"error: {schemas_dir} not found - run from repo root or pass --repo-root",
+            file=sys.stderr,
+        )
+        return 2
+
+    indexer_path = _resolve_indexer_path(Path(args.rosu_indexer), repo_root)
+    if indexer_path is None:
+        print(
+            f"error: indexer binary not found at {args.rosu_indexer} "
+            f"(searched cwd and {repo_root}) - build it with "
+            f"`cargo build --release -p osu_indexer`",
+            file=sys.stderr,
+        )
+        return 2
+
+    archives = collect_archives(args.archives)
+    if args.limit:
+        archives = archives[: args.limit]
+    if not archives:
+        print("error: no .osz archives to ingest", file=sys.stderr)
+        return 2
+
+    parent_batch_id = args.ingest_batch_id or _default_batch_id()
+    archives_dir = (
+        Path(args.archives_dir).resolve()
+        if args.archives_dir
+        else repo_root / "archives"
+    )
+    blobs_dir = repo_root / "blobs"
+    all_revisions_root = repo_root / "data" / args.schema_version / "all_revisions"
+
+    if archives_dir != repo_root / "archives":
+        _log(f"archives dir: {archives_dir}")
+
+    # Acquire the single-writer repo lock BEFORE inhibiting sleep — if the
+    # lock fails we don't want to leave the system in a no-sleep state.
+    # The lock context yields had_stale_lock=True when a prior lock file
+    # existed at startup; that's our signal that the previous run was
+    # hard-killed (its finally never ran) and orphan tmp file GC should
+    # actually run instead of being short-circuited.
+    try:
+        with repo_lock(repo_root, force=args.force_lock) as had_stale_lock:
+            with keep_awake(enabled=args.keep_awake):
+                return _run_main(
+                    args=args,
+                    repo_root=repo_root,
+                    archives=archives,
+                    parent_batch_id=parent_batch_id,
+                    archives_dir=archives_dir,
+                    blobs_dir=blobs_dir,
+                    all_revisions_root=all_revisions_root,
+                    schemas_dir=schemas_dir,
+                    indexer_path=indexer_path,
+                    had_stale_lock=had_stale_lock,
+                )
+    except KeyboardInterrupt:
+        # Propagated up after both context managers have unwound. The chunk
+        # commit marker (archive_revisions) is the last write in a chunk's
+        # pipeline, so any uncommitted chunk simply doesn't appear on disk —
+        # rerunning with --skip-already-ingested resumes from the next chunk.
+        _log(
+            "\ningest_osz: ctrl+c received; in-flight chunk did not commit, "
+            "resume the run to retry it."
+        )
+        return 130
+
+
+def _run_main(
+    args: argparse.Namespace,
+    repo_root: Path,
+    archives: list[Path],
+    parent_batch_id: str,
+    archives_dir: Path,
+    blobs_dir: Path,
+    all_revisions_root: Path,
+    schemas_dir: Path,
+    indexer_path: Path,
+    had_stale_lock: bool,
+) -> int:
+    """Body of ``main`` extracted so the wake-lock context manager wraps every
+    long-running step (GC, hashing pass, chunked ingest) without nesting
+    half the function under an extra indent."""
+
+    schemas = load_schemas(schemas_dir)
+    _log(f"loaded {len(schemas)} table schema(s) from {schemas_dir}")
+
+    # Crash-recovery cleanup runs first; each step is a no-op when the repo is
+    # already clean.
+    # The orphan-tmp-file walk is paranoid crash recovery: it costs ~150
+    # file/s on a HDD spindle (multiple minutes for full-corpus repos).
+    # It's only useful when the previous run might have left in-flight
+    # tmp+rename writes incomplete. With:
+    #   - atomic_copy_if_absent and _atomic_write_parquet using tmp+rename
+    #   - the indexer's ctrlc::set_handler draining workers on Ctrl+C
+    #   - repo_lock's finally unlinking .ingest.lock on every soft exit
+    # a clean shutdown leaves zero orphans. So we only run the walk when
+    # the lock file *survived* the previous run (= hard-killed) or the
+    # user explicitly forces it via --always-gc-tmp-files.
+    if args.gc_tmp_files and (args.always_gc_tmp_files or had_stale_lock):
+        reason = (
+            "forced by --always-gc-tmp-files"
+            if args.always_gc_tmp_files
+            else "previous run left a stale lock"
+        )
+        _log(
+            f"scanning for orphan *.tmp.<pid> files older than "
+            f"{args.gc_tmp_files_age_min} min ({reason})"
+        )
+        # Also walk an archive CAS root that lives outside repo_root.
+        extra_roots = []
+        if archives_dir != repo_root / "archives":
+            extra_roots.append((f"archives ({archives_dir})", archives_dir))
+        gc_summary = cleanup_orphan_tmp_files(
+            repo_root,
+            max_age_seconds=args.gc_tmp_files_age_min * 60,
+            extra_roots=extra_roots,
+        )
+        gc_total = sum(gc_summary.values())
+        _log(f"  removed {gc_total} orphan tmp file(s) ({gc_summary})")
+    elif args.gc_tmp_files:
+        _log(
+            "skipping orphan tmp file scan "
+            "(previous run shut down cleanly; pass --always-gc-tmp-files "
+            "to force a paranoid walk)"
+        )
+
+    ar_dir = all_revisions_root / "archive_revisions"
+
+    # Crash-recovery suite. The compact writer only needs orphan parquet
+    # cleanup: any table parquet whose batch_id lacks an archive_revisions
+    # commit marker belongs to an interrupted chunk and must be removed before
+    # retry to avoid duplicate rows.
+    should_run_recovery = had_stale_lock or args.always_crash_recovery
+    if should_run_recovery:
+        recovery_reason = (
+            "forced by --always-crash-recovery"
+            if args.always_crash_recovery
+            else "previous run left a stale lock"
+        )
+        _log(f"running crash-recovery suite ({recovery_reason})")
+
+        if args.cleanup_orphan_parquets:
+            _log("scanning all_revisions/ for orphan parquet files")
+            committed = committed_batch_ids(ar_dir)
+            orphan_summary = cleanup_orphan_parquets(
+                all_revisions_root, committed
+            )
+            orphan_total = sum(orphan_summary.values())
+            _log(
+                f"  removed {orphan_total} orphan parquet(s) "
+                f"({len(orphan_summary)} table(s); "
+                f"{len(committed)} committed batch_id(s))"
+            )
+    else:
+        _log(
+            "skipping crash-recovery suite "
+            "(previous run shut down cleanly; pass --always-crash-recovery "
+            "to force orphan-parquet cleanup)"
+        )
+
+    # Hash each input archive and partition into (to-ingest, already-done,
+    # duplicate) so two copies of the same .osz can't produce duplicate
+    # archive_revisions rows in one chunk and a resumed run skips committed
+    # archives without re-running the indexer on them.
+    if args.skip_already_ingested:
+        known = already_ingested_shas(ar_dir)
+        if known:
+            _log(
+                f"hashing {len(archives):,} input(s) against "
+                f"{len(known):,} known archive_sha256(s)"
+            )
+        else:
+            _log(
+                f"hashing {len(archives):,} input(s) (dedup-only; "
+                f"no committed archives yet)"
+            )
+        cache_path = (
+            _archive_sha_cache_path(repo_root) if args.archive_sha_cache else None
+        )
+        archives, already_done, duplicates = filter_already_ingested(
+            archives, known, cache_path=cache_path
+        )
+        if already_done:
+            _log(f"  skipped {len(already_done):,} already-ingested archive(s)")
+        if duplicates:
+            _log(
+                f"  warning: dropped {len(duplicates):,} duplicate input archive(s) "
+                f"(same content SHA-256 as another input). First few:"
+            )
+            for dup, kept in duplicates[:5]:
+                try:
+                    dup_rel = dup.relative_to(repo_root)
+                except ValueError:
+                    dup_rel = dup
+                try:
+                    kept_rel = kept.relative_to(repo_root)
+                except ValueError:
+                    kept_rel = kept
+                _log(f"    {dup_rel}  ==  {kept_rel}")
+            if len(duplicates) > 5:
+                _log(f"    ... and {len(duplicates) - 5} more")
+        if not archives:
+            _log("all input archives are already ingested; nothing to do")
+            return 0
+
+    if not args.dry_run:
+        existing_batches = committed_batch_ids_for_parent(ar_dir, parent_batch_id)
+        if existing_batches:
+            preview = ", ".join(existing_batches[:5])
+            if len(existing_batches) > 5:
+                preview += f", ... ({len(existing_batches)} total)"
+            raise RuntimeError(
+                f"ingest_batch_id {parent_batch_id!r} already has committed "
+                f"archive_revisions parquet(s): {preview}. Refusing to ingest "
+                "new archives with a reused batch id because it would overwrite "
+                "existing part-<batch>.parquet files. Choose a fresh BATCH_ID."
+            )
+
+    chunk_size = max(1, args.chunk_size)
+    chunks = [archives[i : i + chunk_size] for i in range(0, len(archives), chunk_size)]
+    multi_chunk = len(chunks) > 1
+
+    _log(
+        f"ingest_osz: {len(archives)} archive(s); repo={repo_root}; "
+        f"parent_batch={parent_batch_id}; "
+        f"{len(chunks)} chunk(s) of up to {chunk_size}; dry_run={args.dry_run}"
+    )
+
+    overall_start = time.perf_counter()
+    cumulative_archives = 0
+    total_archives = len(archives)
+    chunk_summaries: list[dict] = []
+    for chunk_idx, chunk in enumerate(chunks):
+        if multi_chunk:
+            chunk_batch_id = f"{parent_batch_id}-chunk-{chunk_idx:04d}"
+        else:
+            chunk_batch_id = parent_batch_id
+
+        # Per-chunk NDJSON path (suffixed when multi-chunk so retained traces don't clobber).
+        if args.keep_ndjson is not None:
+            if multi_chunk:
+                keep_ndjson = args.keep_ndjson.with_suffix(
+                    f".chunk-{chunk_idx:04d}{args.keep_ndjson.suffix}"
+                )
+            else:
+                keep_ndjson = args.keep_ndjson
+        else:
+            keep_ndjson = None
+
+        _log(
+            f"\n[{chunk_idx + 1}/{len(chunks)}] chunk_batch_id={chunk_batch_id} "
+            f"({len(chunk)} archive(s))"
+        )
+
+        summary = _process_chunk(
+            chunk=chunk,
+            chunk_batch_id=chunk_batch_id,
+            args=args,
+            indexer_path=indexer_path,
+            schemas=schemas,
+            repo_root=repo_root,
+            archives_dir=archives_dir,
+            blobs_dir=blobs_dir,
+            all_revisions_root=all_revisions_root,
+            keep_ndjson=keep_ndjson,
+        )
+        chunk_summaries.append(summary)
+        cumulative_archives += len(chunk)
+
+        if not args.dry_run:
+            elapsed = time.perf_counter() - overall_start
+            rate = cumulative_archives / elapsed if elapsed > 0 else 0.0
+            remaining = max(total_archives - cumulative_archives, 0)
+            eta_seconds = remaining / rate if rate > 0 else 0.0
+            wall = summary.get("wall_seconds", 0.0)
+            ndjson_b = summary.get("ndjson_bytes", 0)
+            pct = 100.0 * cumulative_archives / total_archives if total_archives else 100.0
+            _log(
+                f"  chunk {chunk_idx + 1}/{len(chunks)} done in "
+                f"{_format_duration(wall)} | "
+                f"{cumulative_archives:,}/{total_archives:,} ({pct:.1f}%) | "
+                f"{rate:.2f} ar/s | ETA {_format_duration(eta_seconds)}"
+            )
+            _log(
+                f"    timings: indexer {summary.get('indexer_seconds', 0):.1f}s | "
+                f"group {summary.get('group_seconds', 0):.1f}s | "
+                f"parquet {summary.get('parquet_seconds', 0):.1f}s | "
+                f"ar-commit {summary.get('ar_commit_seconds', 0):.1f}s"
+            )
+            _log(
+                f"    output: {summary.get('written_files', 0)} all_rev parquet(s), "
+                f"AR={summary.get('archive_revisions_committed', 0)}, "
+                f"NDJSON={_format_size(ndjson_b)} "
+                f"({summary.get('n_rows', 0):,} rows)"
+            )
+
+    overall_elapsed = time.perf_counter() - overall_start
+    if cumulative_archives:
+        overall_rate = cumulative_archives / overall_elapsed if overall_elapsed > 0 else 0.0
+        _log(
+            f"\ningest_osz: done. {len(chunks)} chunk(s), "
+            f"{cumulative_archives:,} archive(s) in "
+            f"{_format_duration(overall_elapsed)} "
+            f"({overall_rate:.2f} ar/s)."
+        )
+    else:
+        _log(f"\ningest_osz: done. {len(chunks)} chunk(s) processed.")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/update_maps_v1.sh

@@ -54,6 +54,21 @@ cleanup_stale_lock_file() {
   fi
 }
 
+batch_archive_path_count() {
+  "$PYTHON" python/list_batch_archives.py --repo-root . --batch-id "$BATCH_ID" | wc -l | tr -d ' '
+}
+
+refuse_reused_batch_id_for_ingest() {
+  local count
+  count="$(batch_archive_path_count)"
+  if [ "$count" -gt 0 ]; then
+    echo "BATCH_ID=${BATCH_ID} already has ${count} committed archive path(s)." >&2
+    echo "Refusing to fetch or ingest with a reused batch id because it can overwrite existing part-${BATCH_ID}.parquet files." >&2
+    echo "Choose a fresh BATCH_ID, for example: BATCH_ID=update-v1-\$(date -u +%Y%m%dT%H%M%SZ)" >&2
+    exit 64
+  fi
+}
+
 cleanup_stale_lock_file "${STATE_DB}.run.lock" "fetcher"
 cleanup_stale_lock_file ".ingest.lock" "ingest"
 
@@ -142,6 +157,8 @@ fi
 mkdir -p "$INPUT_DIR"
 
 if [ "$FETCH" = "1" ]; then
+  refuse_reused_batch_id_for_ingest
+
   enumerate_args=(--statuses "$STATUSES" --mode "$MODE")
   if [ "${ENUMERATE_FULL_RESCAN:-0}" = "1" ]; then
     enumerate_args+=(--full-rescan)
@@ -196,6 +213,8 @@ input_count="$(find "$INPUT_DIR" -type f -name '*.osz' | wc -l)"
 echo "input_archive_count=${input_count}"
 
 if [ "$input_count" -gt 0 ]; then
+  refuse_reused_batch_id_for_ingest
+
   "$PYTHON" python/ingest_osz.py "$INPUT_DIR" \
     --repo-root . \
     --rosu-indexer "$INDEXER" \
@@ -209,7 +228,7 @@ if [ "$input_count" -gt 0 ]; then
   "$PYTHON" python/rebuild_latest_snapshot.py --repo-root . --workers "$LATEST_REBUILD_WORKERS"
   "$PYTHON" python/validate_compact_v1.py --repo-root . --max-data-files 10000
 
-  batch_archive_paths="$("$PYTHON" python/list_batch_archives.py --repo-root . --batch-id "$BATCH_ID" | wc -l | tr -d ' ')"
+  batch_archive_paths="$(batch_archive_path_count)"
   echo "batch_archive_paths=${batch_archive_paths}"
 else
   batch_archive_paths=0