Add fan-out mode: shard one run across N Jobs

generate-embeddings.py gains an env-driven shard mode (RANK/NUM_SHARDS/RUN_ID/
OUTPUT_BUCKET): each worker embeds an exact contiguous slice, writes its parquet
+ progress heartbeats to a Bucket (object PUTs, no commit contention), and
new launch-embedding-fleet.py / consolidate-shards.py handle spawn, wait,
per-rank retry, and the single final merge commit with fleet provenance.
Unsharded behavior is unchanged.

Smoke-tested on Jobs: 20k rows x 2 t4-small workers -> exact 20,000-row output;
kill-one-worker -> --retry-rank -> --consolidate-only recovery verified.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

README.md

@@ -21,6 +21,7 @@ their dependencies (sentence-transformers vs vLLM vs Lance) are too different to
 | `generate-embeddings.py` | The default. Text or images. Simple, fast, runs anywhere. | sentence-transformers |
 | `generate-embeddings-vllm.py` | Max throughput on large *decoder* embedding models (Qwen3-Embedding). | vLLM pooling |
 | `embed-to-lance.py` | Get a **searchable vector index as a Hub dataset** (the "vector DB" path). | sentence-transformers + Lance |
+| `launch-embedding-fleet.py` | **Fan one run out across N parallel Jobs** (+ `consolidate-shards.py`). | run_uv_job + Buckets |
 
 ## Quick start
 
@@ -38,6 +39,29 @@ hf jobs uv run --flavor l4x1 -s HF_TOKEN \
 
 Always try `--max-samples 100 --private` first.
 
+## Fan-out: N Jobs in parallel
+
+One L4 does ~900 rows/s with `all-MiniLM-L6-v2`; a fleet of 8 does ~7k. `launch-embedding-fleet.py`
+splits the run into exact, non-overlapping shards (one Job each), workers stream shard parquets +
+progress heartbeats to a [Bucket](https://huggingface.co/docs/hub/storage-buckets) (object writes —
+no repo-commit contention), and a final CPU Job merges everything into the output dataset in one
+commit, with full provenance on the card.
+
+```bash
+# 8 L4s over a corpus; runs from your laptop, workers run on Jobs
+uv run https://huggingface.co/datasets/uv-scripts/embeddings/raw/main/launch-embedding-fleet.py \
+  your-name/corpus your-name/corpus-embeddings --num-shards 8 --flavor l4x1 --timeout 1h
+```
+
+Every shard is idempotent (a rank overwrites only its own files), so recovery is trivial:
+`--retry-rank 3 --run-id <id>` re-runs one failed shard with the run's original config,
+`--consolidate-only --run-id <id>` re-runs the merge. Each worker's timeout gives a **hard cost
+ceiling**: a fleet can never cost more than `N × flavor-rate × timeout`.
+
+Scale note: workers shard row-wise after loading the split, so each rank still downloads the full
+split first — fine up to a few tens of millions of rows; beyond that, shard at the file level or
+stream (planned follow-up).
+
 ## Which model?
 
 **Find the *current* best — don't trust a fixed list** (embedding quality moves fast). Check the

consolidate-shards.py

@@ -0,0 +1,143 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "datasets",
+#     "huggingface-hub>=1.12",
+# ]
+# ///
+"""
+Merge the parquet shards of a fan-out embedding run (see launch-embedding-fleet.py)
+into the final Hub dataset, in one commit, with a provenance card.
+
+Reads runs/<run-id>/run.json from the run bucket, verifies all shards are present,
+downloads them, and pushes the concatenated dataset. Deliberately the ONLY step in
+the fleet that commits to a dataset repo — workers write bucket objects, so N-way
+commit contention (412s) can't happen by construction.
+
+Usually spawned as a cpu Job by the launcher; can also run locally:
+    uv run consolidate-shards.py --bucket you/embedding-runs --run-id 20260709-1200-abc123
+"""
+import argparse
+import json
+import logging
+import os
+import sys
+import tempfile
+import time
+from pathlib import Path
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+logger = logging.getLogger("consolidate-shards")
+
+
+def main():
+    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument("--bucket", required=True, help="Run bucket, e.g. you/embedding-runs")
+    p.add_argument("--run-id", required=True)
+    p.add_argument("--private", action="store_true")
+    args = p.parse_args()
+
+    from datasets import load_dataset
+    from huggingface_hub import DatasetCard, download_bucket_files, list_bucket_tree, login
+
+    token = os.environ.get("HF_TOKEN")
+    if token:
+        login(token=token)
+
+    prefix = f"runs/{args.run_id}"
+    workdir = Path(tempfile.mkdtemp(prefix=f"consolidate-{args.run_id}-"))
+
+    download_bucket_files(args.bucket, [(f"{prefix}/run.json", workdir / "run.json")],
+                          raise_on_missing_files=True)
+    run = json.loads((workdir / "run.json").read_text())
+    n = run["num_shards"]
+    out_repo = run["output_dataset"]
+
+    shard_paths = sorted(
+        f.path for f in list_bucket_tree(args.bucket, prefix=f"{prefix}/data/", recursive=True)
+        if getattr(f, "path", "").endswith(".parquet")
+    )
+    expected = [f"{prefix}/data/{i:05d}.parquet" for i in range(n)]
+    missing = sorted(set(expected) - set(shard_paths))
+    if missing:
+        logger.error(f"Missing {len(missing)}/{n} shard(s): {missing}")
+        logger.error("Re-run those ranks (launch-embedding-fleet.py --retry-rank), then consolidate again.")
+        sys.exit(1)
+
+    logger.info(f"Downloading {n} shards from {args.bucket}/{prefix}/data/")
+    local = [(path, workdir / Path(path).name) for path in expected]
+    download_bucket_files(args.bucket, local, raise_on_missing_files=True)
+
+    ds = load_dataset("parquet", data_files=[str(dst) for _, dst in local], split="train")
+    logger.info(f"Merged {n} shards → {len(ds):,} rows (manifest says {run['rows_total']:,})")
+    if run.get("rows_total") and len(ds) != run["rows_total"]:
+        logger.warning("Row count differs from manifest — check for a re-run with different --max-samples.")
+
+    # Read final worker statuses for the card's timing/throughput line (best effort).
+    stats_line = ""
+    try:
+        status_files = [(f"{prefix}/status/{i:05d}.json", workdir / f"status-{i:05d}.json") for i in range(n)]
+        download_bucket_files(args.bucket, status_files)
+        statuses = [json.loads(dst.read_text()) for _, dst in status_files if dst.exists()]
+        if statuses:
+            wall = max(s["updated_at"] for s in statuses) - min(s["started_at"] for s in statuses)
+            rps = sum(s.get("rows_per_sec") or 0 for s in statuses)
+            stats_line = f"- Fleet wall-clock: ~{wall / 60:.1f} min · aggregate ~{rps:,.0f} rows/s\n"
+    except Exception as e:
+        logger.info(f"status stats skipped: {e}")
+
+    script_url = "https://huggingface.co/datasets/uv-scripts/embeddings/raw/main/generate-embeddings.py"
+    launcher_url = "https://huggingface.co/datasets/uv-scripts/embeddings/raw/main/launch-embedding-fleet.py"
+    on_jobs = os.environ.get("JOB_ID") is not None
+    origin = ("Produced on [Hugging Face Jobs](https://huggingface.co/docs/huggingface_hub/guides/jobs)"
+              if on_jobs else "Generated")
+    jobs_tag = "\n- hf-jobs" if on_jobs else ""
+    job_list = "".join(f"  - shard {i}: `{jid}`\n" for i, jid in enumerate(run.get("job_ids", [])))
+    card = DatasetCard(
+        f"---\ntags:\n- embeddings\n- uv-script\n- generated{jobs_tag}\n---\n\n"
+        f"# {out_repo}\n\n"
+        f"Embeddings of [`{run['input_dataset']}`](https://huggingface.co/datasets/{run['input_dataset']}) "
+        f"column `{run['column']}`, computed by a fleet of {n} parallel Jobs.\n\n"
+        f"- Model: [`{run['model']}`](https://huggingface.co/{run['model']})\n"
+        f"- Fleet: {n} × `{run['flavor']}` · run `{run['run_id']}`\n"
+        f"{stats_line}"
+        f"- Worker jobs:\n{job_list}\n"
+        f"## Reproduction\n\n"
+        f"{origin} with the [`generate-embeddings.py`]({script_url}) recipe from "
+        f"[uv-scripts](https://huggingface.co/uv-scripts), fanned out with "
+        f"[`launch-embedding-fleet.py`]({launcher_url}):\n\n"
+        f"```bash\nuv run {launcher_url} \\\n"
+        f"    {run['input_dataset']} <output-dataset> --column {run['column']} "
+        f"--model {run['model']} --num-shards {n} --flavor {run['flavor']}\n```\n"
+    )
+
+    # Same retry + XET-disable fallback as generate-embeddings.py: a transient upload
+    # failure here would waste the whole fleet's (paid) work.
+    private = args.private or run.get("private", False)
+    logger.info(f"Pushing to {out_repo} (private={private})")
+    max_retries = 3
+    for attempt in range(1, max_retries + 1):
+        try:
+            if attempt > 1:
+                logger.warning("Disabling XET (fallback to HTTP upload)")
+                os.environ["HF_HUB_DISABLE_XET"] = "1"
+            ds.push_to_hub(out_repo, private=private)
+            break
+        except Exception as e:
+            logger.error(f"Upload attempt {attempt}/{max_retries} failed: {e}")
+            if attempt < max_retries:
+                delay = 30 * (2 ** (attempt - 1))
+                logger.info(f"Retrying in {delay}s...")
+                time.sleep(delay)
+            else:
+                logger.error("All upload attempts failed. Shards remain in the bucket — re-run consolidation.")
+                sys.exit(1)
+    try:
+        card.push_to_hub(out_repo, repo_type="dataset")
+    except Exception as e:
+        logger.warning(f"card push skipped: {e}")
+    logger.info(f"✅ https://huggingface.co/datasets/{out_repo}")
+
+
+if __name__ == "__main__":
+    main()

generate-embeddings.py

@@ -7,7 +7,7 @@
 #     "numpy",
 #     "pillow",
 #     "einops",
-#     "huggingface-hub",
+#     "huggingface-hub>=1.12",
 # ]
 # ///
 """
@@ -56,6 +56,18 @@ Examples:
     # Test on a small slice first, keep the output private
     hf jobs uv run --flavor l4x1 -s HF_TOKEN generate-embeddings.py \\
         stanfordnlp/imdb  your-name/imdb-emb --max-samples 100 --private
+
+FAN-OUT (multi-job) MODE:
+    Split one embedding run across N Jobs with --num-shards/--shard-index (or the RANK /
+    NUM_SHARDS / RUN_ID / OUTPUT_BUCKET env vars, so a launcher only varies RANK per job —
+    see launch-embedding-fleet.py). Each shard takes an exact, non-overlapping contiguous
+    slice, writes its rows to the run's bucket as runs/<run-id>/data/<rank>.parquet (object
+    PUTs — no repo-commit contention), and heartbeats progress to
+    runs/<run-id>/status/<rank>.json. consolidate-shards.py merges shards into the final
+    dataset with one commit. Re-running a failed rank overwrites only its own files (resume).
+    Note: --max-samples applies BEFORE sharding, so a capped run still partitions exactly.
+    Each rank still downloads the full split before slicing — fine at few-million-row scale;
+    for larger corpora shard at the file level or stream instead.
 """
 import argparse
 import logging
@@ -204,6 +216,61 @@ def sniff_token_lengths(model, texts, max_seq_len, sample=512):
     return median
 
 
+def put_bucket_files(bucket_id, add, max_retries=3):
+    """batch_bucket_files with a short retry — bucket PUTs are cheap object writes but can
+    flake transiently; shard data must not be lost to a blip."""
+    from huggingface_hub import batch_bucket_files
+    for attempt in range(1, max_retries + 1):
+        try:
+            batch_bucket_files(bucket_id, add=add)
+            return True
+        except Exception as e:
+            if attempt == max_retries:
+                raise
+            logger.warning(f"bucket PUT attempt {attempt}/{max_retries} failed: {e}; retrying in {5 * attempt}s")
+            time.sleep(5 * attempt)
+
+
+class StatusReporter:
+    """Fan-out worker heartbeat: PUTs runs/<run-id>/status/<rank>.json to the run bucket,
+    throttled to one write per ~30s (last-writer-wins per key, so N workers never contend).
+    A failed status write must never kill a paid embedding run — errors are logged, not raised."""
+
+    def __init__(self, bucket, run_id, rank, rows_total, tokens_per_row=None):
+        self.bucket, self.run_id, self.rank = bucket, run_id, rank
+        self.rows_total, self.tokens_per_row = rows_total, tokens_per_row
+        self.started_at = time.time()
+        self.rows_done = 0
+        self._last_write = 0.0
+
+    def report(self, rows_done=None, state="running", force=False):
+        import json
+        if rows_done is not None:
+            self.rows_done = rows_done
+        now = time.time()
+        if not force and now - self._last_write < 30:
+            return
+        elapsed = max(now - self.started_at, 1e-6)
+        payload = {
+            "run_id": self.run_id,
+            "rank": self.rank,
+            "state": state,
+            "rows_done": self.rows_done,
+            "rows_total": self.rows_total,
+            "tokens_done_est": int(self.rows_done * self.tokens_per_row) if self.tokens_per_row else None,
+            "rows_per_sec": round(self.rows_done / elapsed, 1),
+            "started_at": self.started_at,
+            "updated_at": now,
+            "job_id": os.environ.get("JOB_ID"),
+        }
+        dest = f"runs/{self.run_id}/status/{self.rank:05d}.json"
+        try:
+            put_bucket_files(self.bucket, [(json.dumps(payload).encode(), dest)], max_retries=2)
+            self._last_write = now
+        except Exception as e:
+            logger.warning(f"status write skipped ({e})")
+
+
 def main():
     p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
     p.add_argument("input_dataset", help="Input dataset ID on the Hugging Face Hub")
@@ -232,8 +299,42 @@ def main():
     p.add_argument("--normalize", action="store_true", default=True)
     p.add_argument("--no-normalize", dest="normalize", action="store_false")
     p.add_argument("--private", action="store_true", help="Make the output dataset private")
+    # Fan-out mode (see docstring). Env-defaulted so a launcher drives workers purely via env.
+    # Defaults stay raw strings; int conversion happens after parse so a malformed env var
+    # reaches p.error() instead of blowing up argparse construction.
+    p.add_argument("--num-shards", default=os.environ.get("NUM_SHARDS"),
+                   help="Fan-out: total number of shards (env NUM_SHARDS). Enables shard mode.")
+    p.add_argument("--shard-index", default=os.environ.get("RANK"),
+                   help="Fan-out: this worker's shard index, 0-based (env RANK).")
+    p.add_argument("--output-bucket", default=os.environ.get("OUTPUT_BUCKET"),
+                   help="Fan-out: bucket for shard parquets + status (env OUTPUT_BUCKET).")
+    p.add_argument("--run-id", default=os.environ.get("RUN_ID"),
+                   help="Fan-out: run identifier grouping shards under runs/<run-id>/ (env RUN_ID).")
     args = p.parse_args()
 
+    def int_or_error(val, name):
+        if val is None:
+            return None
+        try:
+            return int(val)
+        except (TypeError, ValueError):
+            p.error(f"{name} must be an integer (got {val!r}).")
+
+    args.num_shards = int_or_error(args.num_shards, "--num-shards / NUM_SHARDS")
+    args.shard_index = int_or_error(args.shard_index, "--shard-index / RANK")
+
+    sharded = args.num_shards is not None
+    if sharded:
+        if args.num_shards < 1:
+            p.error(f"--num-shards must be >= 1 (got {args.num_shards}).")
+        if args.shard_index is None or not 0 <= args.shard_index < args.num_shards:
+            p.error(f"--shard-index must be in [0, {args.num_shards}) when --num-shards is set "
+                    f"(got {args.shard_index}).")
+        if not (args.output_bucket and args.run_id):
+            p.error("fan-out mode needs --output-bucket and --run-id (env OUTPUT_BUCKET / RUN_ID).")
+    elif args.shard_index is not None:
+        p.error("--shard-index requires --num-shards.")
+
     import torch
     from datasets import load_dataset
     from huggingface_hub import DatasetCard, login
@@ -256,6 +357,15 @@ def main():
         sys.exit(1)
     if args.max_samples:
         ds = ds.select(range(min(args.max_samples, len(ds))))
+    if sharded:
+        # Contiguous slices keep row order reconstructable at consolidation. Note the whole
+        # split was still downloaded above — acceptable at few-M rows, not at corpus scale.
+        ds = ds.shard(num_shards=args.num_shards, index=args.shard_index, contiguous=True)
+        logger.info(f"Fan-out shard {args.shard_index + 1}/{args.num_shards} of run {args.run_id}")
+        if len(ds) == 0:
+            logger.error(f"Shard {args.shard_index} is empty — num_shards exceeds the row count. "
+                         f"Lower --num-shards (or raise --max-samples).")
+            sys.exit(1)
     logger.info(f"{len(ds)} rows; modality={args.modality}")
 
     device = "cuda" if torch.cuda.is_available() else "cpu"
@@ -302,14 +412,55 @@ def main():
     else:
         encode_fn = model.encode
         encode_kwargs = {}
+    reporter = None
+    if sharded:
+        reporter = StatusReporter(args.output_bucket, args.run_id, args.shard_index,
+                                  rows_total=len(items), tokens_per_row=median_tok)
+        reporter.report(0, force=True)
+
     t0 = time.perf_counter()
-    emb = encode_fn(items, batch_size=batch_size, show_progress_bar=True,
-                    convert_to_numpy=True, normalize_embeddings=args.normalize, **encode_kwargs)
+    try:
+        if reporter is None:
+            emb = encode_fn(items, batch_size=batch_size, show_progress_bar=True,
+                            convert_to_numpy=True, normalize_embeddings=args.normalize, **encode_kwargs)
+        else:
+            # Macro-chunks so the heartbeat can report rows_done between encode calls.
+            # Chunking doesn't change results — batching happens at batch_size regardless.
+            import numpy as np
+            chunk_rows = 25_000
+            parts = []
+            for start in range(0, len(items), chunk_rows):
+                chunk = items[start:start + chunk_rows]
+                parts.append(encode_fn(chunk, batch_size=batch_size, show_progress_bar=True,
+                                       convert_to_numpy=True, normalize_embeddings=args.normalize,
+                                       **encode_kwargs))
+                reporter.report(start + len(chunk))
+            emb = np.concatenate(parts) if len(parts) > 1 else parts[0]
+    except Exception:
+        if reporter:
+            reporter.report(state="error", force=True)
+        raise
     secs = time.perf_counter() - t0
     logger.info(f"Embedded {len(items)} in {secs:.1f}s ({len(items)/secs:.0f} rows/s), dim={dim}")
 
     ds = ds.add_column(args.output_column, [e.tolist() for e in emb])
 
+    if sharded:
+        # Shard mode: no repo commit here (N workers committing → 412 contention). Write this
+        # rank's parquet to the run bucket; consolidate-shards.py makes the single final commit.
+        out_path = f"/tmp/shard-{args.shard_index:05d}.parquet"
+        dest = f"runs/{args.run_id}/data/{args.shard_index:05d}.parquet"
+        try:
+            ds.to_parquet(out_path)
+            logger.info(f"Uploading shard parquet → {args.output_bucket}/{dest}")
+            put_bucket_files(args.output_bucket, [(out_path, dest)])
+        except Exception:
+            reporter.report(state="error", force=True)
+            raise
+        reporter.report(len(items), state="done", force=True)
+        logger.info(f"✅ shard {args.shard_index + 1}/{args.num_shards} of run {args.run_id} uploaded")
+        return
+
     # For the card: record the effective prefix (explicit, else the model's registered one).
     side_keys = ("query",) if args.query_mode else ("document", "passage", "corpus")
     effective = prompt_str if prompt_str is not None else next(

launch-embedding-fleet.py

@@ -0,0 +1,261 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "datasets",
+#     "huggingface-hub>=1.12",
+# ]
+# ///
+"""
+Fan one embedding run out across N Hugging Face Jobs, then consolidate.
+
+Runs generate-embeddings.py once per shard (each worker gets RANK / NUM_SHARDS /
+RUN_ID / OUTPUT_BUCKET via env), workers write parquet shards + progress heartbeats
+to the run bucket (object PUTs — no repo-commit contention), and when all workers
+finish a consolidation Job merges the shards into the final Hub dataset with one
+commit. Runs locally on your laptop; only the workers/consolidator run on Jobs.
+
+Examples:
+    # Smoke: 2 small-GPU jobs over a 20k-row slice
+    uv run launch-embedding-fleet.py stanfordnlp/imdb your-name/imdb-emb \\
+        --max-samples 20000 --num-shards 2 --flavor t4-small --timeout 20m
+
+    # Mid-size: 8 L4s over a few million rows
+    uv run launch-embedding-fleet.py your-name/corpus your-name/corpus-emb \\
+        --num-shards 8 --flavor l4x1 --timeout 1h
+
+    # Re-run one failed shard, then consolidate an existing run
+    uv run launch-embedding-fleet.py ... --run-id 20260709-1200-abc123 --retry-rank 3
+    uv run launch-embedding-fleet.py ... --run-id 20260709-1200-abc123 --consolidate-only
+
+Resume model: every worker writes only runs/<run-id>/data/<rank>.parquet and its own
+status file, so re-running a rank is idempotent. The launcher exiting early never
+orphans a run — --retry-rank / --consolidate-only pick it back up.
+"""
+import argparse
+import json
+import logging
+import os
+import secrets as pysecrets
+import sys
+import time
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+logger = logging.getLogger("launch-embedding-fleet")
+
+SCRIPT_BASE = "https://huggingface.co/datasets/uv-scripts/embeddings/raw/main"
+
+
+def put_json(bucket, path, obj, token=None):
+    from huggingface_hub import batch_bucket_files
+    batch_bucket_files(bucket, add=[(json.dumps(obj, indent=2).encode(), path)], token=token)
+
+
+def rows_in_split(input_dataset, config, split):
+    """Row count WITHOUT downloading: builder metadata, else the dataset-viewer size API."""
+    try:
+        from datasets import load_dataset_builder
+        b = load_dataset_builder(input_dataset, config) if config else load_dataset_builder(input_dataset)
+        n = b.info.splits[split].num_examples
+        if n:
+            return n
+    except Exception as e:
+        logger.info(f"builder metadata unavailable ({e}); trying dataset-viewer size API")
+    try:
+        import huggingface_hub
+        r = huggingface_hub.get_session().get(
+            "https://datasets-server.huggingface.co/size", params={"dataset": input_dataset}
+        )
+        r.raise_for_status()
+        for s in r.json()["size"]["splits"]:
+            if s["split"] == split and (config is None or s["config"] == config):
+                return s["num_rows"]
+    except Exception as e:
+        logger.info(f"size API unavailable ({e})")
+    return None
+
+
+def main():
+    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument("input_dataset")
+    p.add_argument("output_dataset")
+    p.add_argument("--model", default="sentence-transformers/all-MiniLM-L6-v2")
+    p.add_argument("--column", default="text")
+    p.add_argument("--split", default="train")
+    p.add_argument("--config", default=None)
+    p.add_argument("--max-samples", type=int, default=None)
+    p.add_argument("--num-shards", type=int, default=8)
+    p.add_argument("--flavor", default="l4x1")
+    p.add_argument("--timeout", default="1h", help="Per-worker timeout — also the hard cost ceiling")
+    p.add_argument("--bucket", default=None,
+                   help="Run bucket (default: <namespace>/embedding-runs)")
+    p.add_argument("--script", default=f"{SCRIPT_BASE}/generate-embeddings.py",
+                   help="Worker script: raw URL (default) or a local .py path for dev")
+    p.add_argument("--consolidate-script", default=f"{SCRIPT_BASE}/consolidate-shards.py",
+                   help="Consolidator script: raw URL (default) or local path for dev")
+    p.add_argument("--rows-total", type=int, default=None,
+                   help="Override when the dataset has no split metadata")
+    p.add_argument("--private", action="store_true", help="Final output dataset is private")
+    p.add_argument("--embed-args", nargs=argparse.REMAINDER, default=[],
+                   help="Everything after --embed-args is passed through to generate-embeddings.py "
+                        "verbatim — put it LAST (any launcher flags after it are swallowed too).")
+    p.add_argument("--run-id", default=None, help="Attach to an existing run (with --retry-rank/--consolidate-only)")
+    p.add_argument("--retry-rank", type=int, default=None, help="Re-spawn a single failed shard of --run-id")
+    p.add_argument("--consolidate-only", action="store_true", help="Just run consolidation for --run-id")
+    p.add_argument("--no-wait", action="store_true",
+                   help="Spawn workers and exit (run --consolidate-only later)")
+    args = p.parse_args()
+
+    from huggingface_hub import (JobStage, create_bucket, download_bucket_files, get_token,
+                                 run_uv_job, wait_for_job, whoami)
+
+    # Workers need a real token as a secret (bucket writes + output push); env may be empty
+    # when the user authenticated via `hf auth login` (keyring/hub cache).
+    token = os.environ.get("HF_TOKEN") or get_token()
+    if not token:
+        p.error("No HF token found — set HF_TOKEN or run `hf auth login`.")
+    namespace = whoami(token=token)["name"]
+    bucket = args.bucket or f"{namespace}/embedding-runs"
+
+    if (args.retry_rank is not None or args.consolidate_only) and not args.run_id:
+        p.error("--retry-rank / --consolidate-only need --run-id")
+    if args.num_shards < 1:
+        p.error(f"--num-shards must be >= 1 (got {args.num_shards})")
+
+    def read_manifest(run_id):
+        import tempfile
+        from pathlib import Path
+        with tempfile.TemporaryDirectory() as td:
+            dst = Path(td) / "run.json"
+            download_bucket_files(bucket, [(f"runs/{run_id}/run.json", dst)],
+                                  raise_on_missing_files=True, token=token)
+            return json.loads(dst.read_text())
+
+    # Workers are always spawned from the run manifest, never from current CLI flags —
+    # a --retry-rank months later must reproduce the original slice/model/args exactly.
+    def spawn_worker(rank, manifest):
+        script_args = [manifest["input_dataset"], manifest["output_dataset"],
+                       "--model", manifest["model"], "--column", manifest["column"],
+                       "--split", manifest["split"]]
+        if manifest.get("config"):
+            script_args += ["--config", manifest["config"]]
+        if manifest.get("max_samples"):
+            script_args += ["--max-samples", str(manifest["max_samples"])]
+        script_args += list(manifest.get("embed_args") or [])
+        job = run_uv_job(
+            args.script,
+            script_args=script_args,
+            flavor=manifest["flavor"],
+            timeout=manifest["timeout"],
+            env={
+                "RANK": str(rank),
+                "NUM_SHARDS": str(manifest["num_shards"]),
+                "RUN_ID": manifest["run_id"],
+                "OUTPUT_BUCKET": bucket,
+            },
+            secrets={"HF_TOKEN": token},
+            labels={"embedding-fleet-run": manifest["run_id"], "rank": str(rank)},
+            token=token,
+        )
+        logger.info(f"  rank {rank} → job {job.id} ({manifest['flavor']})")
+        return job
+
+    def spawn_consolidator(run_id):
+        job = run_uv_job(
+            args.consolidate_script,
+            script_args=[
+                "--bucket", bucket, "--run-id", run_id,
+            ] + (["--private"] if args.private else []),
+            flavor="cpu-upgrade",
+            timeout="30m",
+            secrets={"HF_TOKEN": token},
+            labels={"embedding-fleet-run": run_id, "role": "consolidate"},
+            token=token,
+        )
+        logger.info(f"Consolidation job {job.id} (cpu-upgrade) — merges shards → {args.output_dataset}")
+        return job
+
+    # --- attach-to-existing-run paths ---
+    if args.retry_rank is not None:
+        manifest = read_manifest(args.run_id)
+        if not 0 <= args.retry_rank < manifest["num_shards"]:
+            p.error(f"--retry-rank must be in [0, {manifest['num_shards']}) for run {args.run_id}")
+        logger.info(f"Re-spawning rank {args.retry_rank} of run {args.run_id} (config from manifest)")
+        job = spawn_worker(args.retry_rank, manifest)
+        info = wait_for_job(job.id, token=token)
+        if info.status.stage != JobStage.COMPLETED:
+            logger.error(f"Retry of rank {args.retry_rank} did not complete "
+                         f"(stage={info.status.stage}, job {job.id}).")
+            sys.exit(1)
+        logger.info("Retry completed; run --consolidate-only when all shards are done.")
+        return
+
+    if args.consolidate_only:
+        job = spawn_consolidator(args.run_id)
+        info = wait_for_job(job.id, token=token)
+        sys.exit(0 if info.status.stage == JobStage.COMPLETED else 1)
+
+    # --- fresh run ---
+    rows_total = args.rows_total or rows_in_split(args.input_dataset, args.config, args.split)
+    if rows_total is None:
+        p.error("Couldn't determine the split's row count — pass --rows-total.")
+    if args.max_samples:
+        rows_total = min(rows_total, args.max_samples)
+    if args.num_shards > rows_total:
+        p.error(f"--num-shards {args.num_shards} exceeds the row count ({rows_total}) — "
+                f"some shards would be empty.")
+
+    run_id = time.strftime("%Y%m%d-%H%M%S") + "-" + pysecrets.token_hex(3)
+    create_bucket(bucket, private=True, exist_ok=True, token=token)
+
+    manifest = {
+        "run_id": run_id,
+        "input_dataset": args.input_dataset,
+        "output_dataset": args.output_dataset,
+        "model": args.model,
+        "column": args.column,
+        "split": args.split,
+        "config": args.config,
+        "max_samples": args.max_samples,
+        "num_shards": args.num_shards,
+        "rows_total": rows_total,
+        "flavor": args.flavor,
+        "timeout": args.timeout,
+        "private": args.private,
+        "embed_args": list(args.embed_args),
+        "started_at": time.time(),
+        "job_ids": [],
+    }
+    put_json(bucket, f"runs/{run_id}/run.json", manifest, token=token)
+    logger.info(f"Run {run_id}: {rows_total:,} rows → {args.num_shards} shards "
+                f"(~{rows_total // args.num_shards:,} rows each) on {args.flavor}")
+
+    jobs = [spawn_worker(rank, manifest) for rank in range(args.num_shards)]
+    manifest["job_ids"] = [j.id for j in jobs]
+    put_json(bucket, f"runs/{run_id}/run.json", manifest, token=token)
+
+    logger.info(f"Manifest: hf://buckets/{bucket}/runs/{run_id}/run.json")
+    logger.info(f"Dashboard: https://huggingface.co/spaces/davanstrien/embedding-fleet-dashboard?run={run_id}")
+
+    if args.no_wait:
+        logger.info(f"--no-wait: consolidate later with --run-id {run_id} --consolidate-only")
+        return
+
+    logger.info("Waiting for workers…")
+    infos = wait_for_job([j.id for j in jobs], token=token)
+    failed = [(rank, j.id) for rank, (j, i) in enumerate(zip(jobs, infos))
+              if i.status.stage != JobStage.COMPLETED]
+    if failed:
+        logger.error(f"{len(failed)} worker(s) did not complete: {failed}")
+        logger.error(f"Re-run each with --run-id {run_id} --retry-rank <rank>, then --consolidate-only.")
+        sys.exit(1)
+
+    job = spawn_consolidator(run_id)
+    info = wait_for_job(job.id, token=token)
+    if info.status.stage != JobStage.COMPLETED:
+        logger.error(f"Consolidation failed (job {job.id}); retry with --consolidate-only --run-id {run_id}")
+        sys.exit(1)
+    logger.info(f"✅ https://huggingface.co/datasets/{args.output_dataset}")
+
+
+if __name__ == "__main__":
+    main()