roar-cli 0.4.0__tar.gz → 0.4.2__tar.gz

{roar_cli-0.4.0 → roar_cli-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: roar-cli
-Version: 0.4.0
+Version: 0.4.2
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
@@ -34,6 +34,7 @@ Requires-Dist: ruff>=0.8.0 ; extra == 'dev'
 Requires-Dist: mypy>=1.13.0 ; extra == 'dev'
 Requires-Dist: boto3>=1.28.0 ; extra == 'dev'
 Requires-Dist: google-cloud-storage>=2.10.0 ; extra == 'dev'
+Requires-Dist: huggingface-hub>=0.20.0 ; extra == 'dev'
 Provides-Extra: dev
 License-File: LICENSE
 Summary: Reproducibility and provenance tracker for ML training pipelines

{roar_cli-0.4.0 → roar_cli-0.4.2}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "maturin"
 
 [project]
 name = "roar-cli"
-version = "0.4.0"
+version = "0.4.2"
 description = "Reproducibility and provenance tracker for ML training pipelines"
 authors = [
     { name="TReqs Team", email="info@treqs.ai" }
@@ -68,6 +68,7 @@ dev = [
     "mypy>=1.13.0",
     "boto3>=1.28.0",
     "google-cloud-storage>=2.10.0",
+    "huggingface_hub>=0.20.0",
 ]
 
 [project.scripts]
@@ -123,6 +124,7 @@ markers = [
     "diagnostic: Opt-in diagnostics or aspirational performance budgets outside the default gate",
     "large_pipeline: Stress-style pipeline coverage with larger DAG fixtures",
     "osmo_e2e: OSMO end-to-end tests requiring a Docker Compose managed KIND harness",
+    "k8s_e2e: Kubernetes end-to-end tests requiring the KIND harness (tests/backends/k8s)",
     "ray_e2e: Ray end-to-end tests requiring a running Docker cluster",
     "ray_contract: User-facing Ray contract tests using `roar run ray job submit ...`",
     "ray_diagnostic: Diagnostic Ray tests that intentionally inspect internal runtime details",

{roar_cli-0.4.0 → roar_cli-0.4.2}/roar/analyzers/experiment_trackers.py

@@ -2,6 +2,7 @@
 
 import json
 import re
+import sqlite3
 from pathlib import Path
 from typing import Any, ClassVar
 
@@ -18,6 +19,7 @@ class ExperimentTrackerAnalyzer(Analyzer):
     TRACKER_PATTERNS: ClassVar[dict[str, list[str]]] = {
         "wandb": ["wandb/", ".wandb"],
         "mlflow": ["mlruns/", "mlartifacts/"],
+        "trackio": ["huggingface/trackio", "/trackio/"],
         "neptune": [".neptune/"],
         "tensorboard": ["/runs/", "events.out.tfevents"],
     }
@@ -72,7 +74,12 @@ class ExperimentTrackerAnalyzer(Analyzer):
         for tracker in trackers_found:
             run_info = self._extract_run_info(tracker, written, env)
             if run_info:
-                results["runs"].append(run_info)
+                # trackio reports one run per project DB (a run may touch
+                # several); the other trackers return a single run dict.
+                if isinstance(run_info, list):
+                    results["runs"].extend(run_info)
+                else:
+                    results["runs"].append(run_info)
 
             # Add ignore patterns for this tracker
             for pattern in self.IGNORE_PATTERNS:
@@ -88,18 +95,26 @@ class ExperimentTrackerAnalyzer(Analyzer):
             results["ignore_patterns"].extend(["mlruns/*", "mlartifacts/*"])
         if "neptune" in trackers_found:
             results["ignore_patterns"].append(".neptune/*")
+        if "trackio" in trackers_found:
+            results["ignore_patterns"].append("*/trackio/*")
 
         # Dedupe
         results["ignore_patterns"] = sorted(set(results["ignore_patterns"]))
 
         return results if results["trackers_detected"] else None
 
-    def _extract_run_info(self, tracker: str, written_files: list, env: dict) -> dict | None:
-        """Extract run URL and metadata for a specific tracker."""
+    def _extract_run_info(self, tracker: str, written_files: list, env: dict) -> dict | list | None:
+        """Extract run URL and metadata for a specific tracker.
+
+        Most trackers return a single run dict; ``trackio`` returns a list of
+        per-project run dicts (or ``None`` when nothing usable was found).
+        """
         if tracker == "wandb":
             return self._extract_wandb_info(written_files, env)
         elif tracker == "mlflow":
             return self._extract_mlflow_info(written_files, env)
+        elif tracker == "trackio":
+            return self._extract_trackio_info(written_files, env)
         elif tracker == "neptune":
             return self._extract_neptune_info(written_files, env)
         return None
@@ -198,6 +213,91 @@ class ExperimentTrackerAnalyzer(Analyzer):
 
         return info if len(info) > 1 else None
 
+    def _extract_trackio_info(self, written_files: list, env: dict) -> list | None:
+        """Extract trackio run info + the hosted-dashboard URL — scrape only.
+
+        trackio stores one SQLite DB per project at ``.../huggingface/trackio/
+        <project>.db`` and, when a run syncs to a HF Space, records the Space in
+        ``project_metadata`` (``key='space_id'``). We read that link + the run
+        identity, exactly as the W&B extractor reads wandb's on-disk run URL — no
+        roar-side config, no env, and **never the metrics**: TReqs stores no
+        customer data, so the DAG carries a link to the externally-hosted
+        experiment, and the metrics live on the dashboard.
+
+        Returns ONE record per project DB (never splicing one project's identity
+        onto another's Space), or ``None`` if no DB yielded anything usable. Each
+        record's URL is ``https://huggingface.co/spaces/<space_id>?project=<project>``.
+        (``env`` is unused — the space comes from what trackio itself persisted.)
+        """
+        del env
+        db_paths = sorted({p for p in written_files if "trackio/" in p and p.endswith(".db")})
+
+        runs: list[dict[str, Any]] = []
+        for db_path in db_paths:
+            path = Path(db_path)
+            if not path.exists():
+                continue
+            info: dict[str, Any] = {"tracker": "trackio", "project": path.stem}
+            try:
+                con = sqlite3.connect(f"file:{db_path}?mode=ro", uri=True)
+            except sqlite3.Error:
+                continue
+            try:
+                # Two INDEPENDENT lookups: an older/imported trackio schema may
+                # lack a ``run_id`` column or the ``project_metadata`` table, so
+                # a failure of one must not discard the other.
+                run = self._trackio_run_identity(con)
+                space = self._trackio_space_id(con)
+            finally:
+                con.close()
+
+            if run:
+                info["run_id"], info["run_name"] = run
+            if space:
+                info["space_id"] = space
+                info["url"] = f"https://huggingface.co/spaces/{space}?project={info['project']}"
+
+            # Keep only DBs that yielded a run identity and/or a hosted Space
+            # (more than the always-present tracker+project keys).
+            if len(info) > 2:
+                runs.append(info)
+
+        return runs or None
+
+    @staticmethod
+    def _trackio_run_identity(con: "sqlite3.Connection") -> tuple | None:
+        """``(run_id, run_name)`` of the most recent metric row, tolerating
+        older schemas whose ``metrics`` table lacks a ``run_id`` column (trackio
+        produces these when importing TensorBoard/older runs)."""
+        try:
+            cols = {row[1] for row in con.execute("PRAGMA table_info(metrics)").fetchall()}
+        except sqlite3.Error:
+            return None
+        if not cols or not ({"run_id", "run_name"} & cols):
+            return None
+        run_id_expr = "run_id" if "run_id" in cols else "NULL"
+        run_name_expr = "run_name" if "run_name" in cols else "NULL"
+        try:
+            row = con.execute(
+                f"SELECT {run_id_expr}, {run_name_expr} FROM metrics ORDER BY rowid DESC LIMIT 1"
+            ).fetchone()
+        except sqlite3.Error:
+            return None
+        if not row or (row[0] is None and row[1] is None):
+            return None
+        return row[0], row[1]
+
+    @staticmethod
+    def _trackio_space_id(con: "sqlite3.Connection") -> str | None:
+        """The hosted HF Space id trackio persisted once a run synced, or None."""
+        try:
+            row = con.execute(
+                "SELECT value FROM project_metadata WHERE key = 'space_id' LIMIT 1"
+            ).fetchone()
+        except sqlite3.Error:
+            return None
+        return row[0] if row and row[0] else None
+
     def _extract_mlflow_info(self, written_files: list, env: dict) -> dict | None:
         """Extract MLflow run info from local files."""
         info = {"tracker": "mlflow"}

{roar_cli-0.4.0 → roar_cli-0.4.2}/roar/application/get/requests.py

@@ -23,3 +23,4 @@ class GetRequest:
     step_name: str | None = None
     limit: int | None = None  # download only the first N data files (subset get)
     full_anchor: bool = False  # re-hash non-LFS identity files past the budget
+    cache: str | None = None  # fetch bytes from this mirror; record `source` as canonical

{roar_cli-0.4.0 → roar_cli-0.4.2}/roar/application/get/service.py

@@ -12,6 +12,7 @@ from ...core.operation_metadata import build_operation_metadata_json
 from ...db.context import create_database_context
 from ...execution.recording import LocalJobRecorder, LocalRecordedArtifact
 from ...integrations.download import parse_source, resolve_download_backend
+from ...integrations.download.base import DownloadError
 from .requests import GetRequest
 from .results import GetDownloadedFile, GetResponse
 from .transfer import GetService, GetTransferResult
@@ -22,10 +23,27 @@ def get_artifacts(request: GetRequest) -> GetResponse:
     bootstrap(request.roar_dir)
     logger = get_logger()
 
-    parsed_source = parse_source(request.source)
-    backend = resolve_download_backend(request.source)
+    parsed_source = parse_source(request.source)  # canonical — always what we RECORD
+    # Fetch location: the mirror (`--cache`) when given, else the canonical source.
+    # Recording below always uses the canonical `parsed_source`, so the artifact's
+    # source_url / the AI-BOM downloadLocation stay the public URL, not the mirror.
+    fetch_url = request.cache or request.source
+    backend = resolve_download_backend(fetch_url)
+    fetch_parsed = parse_source(fetch_url)
     repo_root = request.repo_root or request.cwd
-    is_prefix = request.source.rstrip("/") != request.source or parsed_source.is_prefix
+    is_prefix = fetch_url.rstrip("/") != fetch_url or fetch_parsed.is_prefix
+
+    # A `--cache` mirror is only integrity-bound to the canonical identity when a
+    # `--hash` is given. Without it, the mirror's bytes are recorded under the
+    # canonical source_url unverified — warn so provenance isn't silently trusted.
+    if request.cache and not request.expected_hash:
+        logger.warning(
+            "--cache %s used without --hash: the mirror's bytes are not integrity-checked "
+            "against the canonical source %s, yet are recorded under it. Pass --hash "
+            "<digest> to bind the download to a known hash.",
+            request.cache,
+            request.source,
+        )
 
     git_commit = None
     git_branch = None
@@ -88,20 +106,57 @@ def get_artifacts(request: GetRequest) -> GetResponse:
             pass
 
     with create_database_context(request.roar_dir) as db_ctx:
-        service = GetService(
-            backend=backend,
-            source=parsed_source,
-            repo_root=repo_root,
-        )
         t0 = time.time()
-        transfer_result = service.get(
-            destination=request.destination,
-            expected_hash=request.expected_hash,
-            dry_run=request.dry_run,
-            force=request.force,
-            is_prefix=is_prefix,
-            limit=request.limit,
-        )
+        fetched_from_cache = False
+        try:
+            transfer_result = GetService(
+                backend=backend,
+                source=fetch_parsed,
+                repo_root=repo_root,
+            ).get(
+                destination=request.destination,
+                expected_hash=request.expected_hash,
+                dry_run=request.dry_run,
+                force=request.force,
+                is_prefix=is_prefix,
+                limit=request.limit,
+            )
+            fetched_from_cache = bool(request.cache)
+            # The transfer layer REPORTS a hash mismatch (and other soft failures)
+            # as success=False rather than raising, so trigger the same cache
+            # fallback here — otherwise a corrupt mirror hard-fails the whole get
+            # even when the canonical source would succeed (the documented behavior).
+            if request.cache and not transfer_result.dry_run and not transfer_result.success:
+                raise DownloadError(transfer_result.error or "cache fetch was unsuccessful")
+        except (DownloadError, FileNotFoundError, ValueError, OSError) as exc:
+            # A `--cache` mirror is best-effort: on miss / unreachable / hash
+            # mismatch, fall back to the canonical source (still hash-verified via
+            # --hash if given, and by content-addressing at reproduce time). A get
+            # without a cache re-raises unchanged.
+            if not request.cache:
+                raise
+            logger.warning(
+                "cache fetch from %s failed (%s); falling back to canonical source %s",
+                request.cache,
+                exc,
+                request.source,
+            )
+            fetched_from_cache = False
+            canonical_is_prefix = (
+                request.source.rstrip("/") != request.source or parsed_source.is_prefix
+            )
+            transfer_result = GetService(
+                backend=resolve_download_backend(request.source),
+                source=parsed_source,
+                repo_root=repo_root,
+            ).get(
+                destination=request.destination,
+                expected_hash=request.expected_hash,
+                dry_run=request.dry_run,
+                force=request.force,
+                is_prefix=canonical_is_prefix,
+                limit=request.limit,
+            )
         download_duration = time.time() - t0
 
         result = _materialize_get_result(
@@ -114,6 +169,8 @@ def get_artifacts(request: GetRequest) -> GetResponse:
             git_repo=git_repo_url,
             duration_seconds=download_duration,
             backend=backend,
+            fetched_from_cache=fetched_from_cache,
+            fetch_url=fetch_url,
         )
 
     git_tag_name = None
@@ -145,6 +202,26 @@ def get_artifacts(request: GetRequest) -> GetResponse:
     )
 
 
+def _canonical_source_url(file_info, request: GetRequest, fetch_url, fetched_from_cache: bool):
+    """The canonical (recorded) URL for one downloaded file.
+
+    When the bytes came from the canonical source (no ``--cache``, or a cache
+    miss/mismatch that fell back), each file's own fetch URL is already canonical.
+    When they came from a ``--cache`` mirror, remap each file's mirror URL back
+    onto the canonical prefix, so a PREFIX get records each file's own canonical
+    object (``s3://canon/data/a.pt``) rather than the bare prefix for every file.
+    """
+    remote_url = file_info.remote_url or ""
+    if not fetched_from_cache:
+        return remote_url or request.source
+    # Fetched from the mirror: swap the mirror prefix for the canonical one.
+    if fetch_url and remote_url.startswith(fetch_url) and remote_url != fetch_url:
+        suffix = remote_url[len(fetch_url) :]
+        return request.source.rstrip("/") + "/" + suffix.lstrip("/")
+    # Single-file cache (or an unmappable URL): the file itself IS the canonical source.
+    return request.source
+
+
 def _materialize_get_result(
     *,
     db_ctx,
@@ -156,6 +233,8 @@ def _materialize_get_result(
     git_repo: str | None = None,
     duration_seconds: float = 0.0,
     backend=None,
+    fetched_from_cache: bool = False,
+    fetch_url: str | None = None,
 ) -> GetResponse:
     if transfer_result.dry_run or not transfer_result.success:
         return GetResponse(
@@ -204,11 +283,18 @@ def _materialize_get_result(
         # downloaded files are the composite's components.
         output_artifacts: list[LocalRecordedArtifact] = []
     else:
+        # Record the canonical source on each downloaded artifact so it is a
+        # SOURCE node with a known origin (source_type/source_url), not a bare
+        # local file. This is what a downstream AI-BOM derives `downloadLocation`
+        # from — so it must be each file's OWN canonical URL, not a shared prefix.
+        source_type = parsed_source.scheme or None
         output_artifacts = [
             LocalRecordedArtifact(
                 path=file_info.local_path,
                 hashes={"blake3": str(file_info.hash)},
                 size=int(file_info.size or 0),
+                source_type=source_type,
+                source_url=_canonical_source_url(file_info, request, fetch_url, fetched_from_cache),
             )
             for file_info in transfer_result.downloaded_files
         ]
@@ -427,6 +513,9 @@ def _build_get_command(request: GetRequest) -> str:
     user typed.
     """
     parts = ["roar get", request.source]
+    if request.cache:
+        # Record the mirror so a reproduce replays cache-first-then-canonical.
+        parts.append(f"--cache {request.cache}")
     if request.limit is not None:
         parts.append(f"--limit {request.limit}")
     if request.step_name:

{roar_cli-0.4.0 → roar_cli-0.4.2}/roar/application/publish/put_execution.py

@@ -9,6 +9,7 @@ roar put ALWAYS registers lineage with GLaaS. This is not optional.
 
 from __future__ import annotations
 
+import shlex
 import time
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -52,6 +53,47 @@ from .put_composites import (
 from .results import PutCompositeRegistration, PutDryRunItem, PutUploadedFile
 
 
+def build_put_command(
+    sources: list[str],
+    destination: str | None,
+    *,
+    message: str,
+    public: bool = True,
+    anonymous: bool = False,
+    no_tag: bool = False,
+    as_dataset: bool = False,
+    step_name: str | None = None,
+) -> str:
+    """Reconstruct a faithful ``roar put`` command string for the job record.
+
+    The recorded command drives ``roar reproduce``, so it must include the
+    destination and every provenance-relevant flag — not just the sources and
+    message. Interaction/mode flags (``--yes``, ``--dry-run``) are intentionally
+    omitted: they control confirmation/preview, not the published result.
+    """
+    parts = ["roar", "put"]
+    if sources:
+        parts.extend(shlex.quote(s) for s in sources)
+    else:
+        parts.append("(session outputs)")
+    if destination:
+        parts.append(shlex.quote(destination))
+    if anonymous:
+        parts.append("--anonymous")
+    elif public is False:
+        parts.append("--private")
+    elif public:
+        parts.append("--public")
+    if no_tag:
+        parts.append("--no-tag")
+    if as_dataset:
+        parts.append("--as-dataset")
+    if step_name:
+        parts.extend(["--step-name", shlex.quote(step_name)])
+    parts.extend(["-m", shlex.quote(message)])
+    return " ".join(parts)
+
+
 def _upload_progress_message(done: int, total: int, uploaded_bytes: int) -> str:
     """Status line for the upload spinner, e.g. ``Uploading 12/100 files · 1.10 GB``."""
     return f"Uploading {done}/{total} files · {uploaded_bytes / 1e9:.2f} GB"
@@ -145,6 +187,7 @@ class PutService:
         git_commit: str | None = None,
         git_tag: str | None = None,
         declared: bool = False,
+        command: str | None = None,
     ) -> PutResult:
         """
         Execute a put operation.
@@ -294,6 +337,7 @@ class PutService:
                 git_context=git_context,
                 sources=sources,
                 message=message,
+                command=command,
                 uploads=uploads,
                 uploaded_files=uploaded_files,
                 artifacts_info=artifacts_info,
@@ -416,9 +460,10 @@ class PutService:
             for item in composite_registrations
         ]
 
-        # Build command string
-        source_str = " ".join(sources) if sources else "(session outputs)"
-        command = f'roar put {source_str} -m "{message}"'
+        # Build command string. Prefer the faithful command (destination + flags)
+        # supplied by the caller; fall back to a destination-aware reconstruction.
+        if command is None:
+            command = build_put_command(sources, self._destination, message=message)
 
         # Build metadata
         metadata_json = build_put_operation_metadata_json(
@@ -551,6 +596,7 @@ class PutService:
         git_context: GitContext,
         sources: list[str],
         message: str,
+        command: str | None = None,
         uploads: list[_UploadedArtifact],
         uploaded_files: list[PutUploadedFile],
         artifacts_info: list[tuple[str, str]],
@@ -571,8 +617,8 @@ class PutService:
         registration_errors: list[str] = []
         lineage_composite_registrations: list[dict[str, Any]] = []
         composite_registrations: list[dict[str, Any]] = []
-        source_str = " ".join(sources) if sources else "(session outputs)"
-        command = f'roar put {source_str} -m "{message}"'
+        if command is None:
+            command = build_put_command(sources, self._destination, message=message)
         source_type = normalize_registration_source_type(destination_type)
 
         provisional_metadata_json = build_put_operation_metadata_json(

{roar_cli-0.4.0 → roar_cli-0.4.2}/roar/application/publish/put_preparation.py

@@ -100,7 +100,9 @@ def prepare_put_execution(
     )
 
     destination_type = _destination_type(destination)
-    composite_source_type = destination_type if destination_type in {"s3", "gs", "https"} else None
+    composite_source_type = (
+        destination_type if destination_type in {"s3", "gs", "https", "hf"} else None
+    )
 
     return PreparedPutExecution(
         glaas_client=runtime.glaas_client,

{roar_cli-0.4.0 → roar_cli-0.4.2}/roar/application/publish/registration.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import json
 import time
 from dataclasses import dataclass
 from typing import Any
@@ -329,14 +330,33 @@ def prepare_batch_registration_artifacts(
         except (TypeError, ValueError):
             size = 0
 
-        prepared.append(
-            {
-                "hashes": hashes,
-                "size": size,
-                "source_type": normalize_registration_source_type(artifact.get("source_type")),
-                "session_hash": session_hash,
-            }
-        )
+        entry = {
+            "hashes": hashes,
+            "size": size,
+            "source_type": normalize_registration_source_type(artifact.get("source_type")),
+            "session_hash": session_hash,
+        }
+
+        # Carry the artifact's source URL into its registration metadata so GLaaS
+        # can emit the AI-BOM `downloadLocation` external reference. The batch
+        # payload previously dropped `source_url`, so source-tracked inputs
+        # (e.g. s3://…) reached GLaaS with a sourceType but no distribution URL.
+        source_url = artifact.get("source_url")
+        if source_url and entry["source_type"]:
+            existing = artifact.get("metadata")
+            if isinstance(existing, str):
+                try:
+                    meta = json.loads(existing)
+                except (ValueError, TypeError):
+                    meta = {}
+            elif isinstance(existing, dict):
+                meta = dict(existing)
+            else:
+                meta = {}
+            meta.setdefault("source_url", source_url)
+            entry["metadata"] = json.dumps(meta)
+
+        prepared.append(entry)
 
     return prepared
 

{roar_cli-0.4.0 → roar_cli-0.4.2}/roar/application/publish/registration_package.py

@@ -206,6 +206,8 @@ def build_registration_package(
     if composites:
         package["composites"] = composites
 
+    if labels:
+        labels = _drop_labels_for_absent_jobs(labels, job_records)
     if labels:
         filtered_labels, label_detections = _filter_label_secrets(labels, omit_filter)
         package["labels"] = filtered_labels
@@ -292,6 +294,38 @@ def _apply_redaction(
     )
 
 
+def _drop_labels_for_absent_jobs(
+    labels: list[dict[str, Any]],
+    job_records: list[dict[str, Any]],
+) -> list[dict[str, Any]]:
+    """Drop job-scoped labels whose target job is not in the package.
+
+    Labels are collected from the raw lineage, but the package's jobs are
+    noise-filtered by ``normalize_jobs_for_registration``. A job label left
+    pointing at a dropped job makes the package internally inconsistent — GLaaS
+    rejects it on publish with "Package label references a job not in the
+    package". The job label's target reaches the publish side through the job
+    record's ``job_uid`` (GLaaS's ``sourceUid``), so match on that. Non-job
+    labels (dag, artifact) are unaffected.
+    """
+    package_job_uids = {str(job.get("job_uid")) for job in job_records if job.get("job_uid")}
+    kept: list[dict[str, Any]] = []
+    dropped = 0
+    for label in labels:
+        if str(label.get("entity_type")) == "job":
+            job_uid = label.get("job_uid")
+            if not isinstance(job_uid, str) or job_uid not in package_job_uids:
+                dropped += 1
+                continue
+        kept.append(label)
+    if dropped:
+        get_logger().debug(
+            "Dropped %d job label(s) referencing jobs not in the registration package",
+            dropped,
+        )
+    return kept
+
+
 def _filter_label_secrets(
     labels: list[dict[str, Any]],
     omit_filter: OmitFilter | None,

{roar_cli-0.4.0 → roar_cli-0.4.2}/roar/application/publish/service.py

@@ -894,6 +894,8 @@ def put_artifacts(request: PutRequest) -> PutResponse:
             )
             put_commit_on_remote = is_shareable_remote(prepared.git_context.repo)
 
+            from .put_execution import build_put_command
+
             result = service.put_prepared(
                 prepared=prepared,
                 sources=request.sources,
@@ -902,6 +904,16 @@ def put_artifacts(request: PutRequest) -> PutResponse:
                 git_commit=git_commit,
                 git_tag=expected_tag,
                 declared=request.as_dataset,
+                command=build_put_command(
+                    request.sources,
+                    request.destination,
+                    message=request.message,
+                    public=request.public,
+                    anonymous=request.anonymous,
+                    no_tag=request.no_tag,
+                    as_dataset=request.as_dataset,
+                    step_name=request.step_name,
+                ),
             )
 
             # Apply step name label if provided.

{roar_cli-0.4.0 → roar_cli-0.4.2}/roar/application/reproduce/requests.py

@@ -20,3 +20,8 @@ class ReproduceRequest:
     package_sync: bool = False
     list_requirements: bool = False
     out_path: str | None = None
+    # Skip publish (`roar put`) steps — for third-party reproduction that
+    # rebuilds the artifact without re-publishing to the owner's destination.
+    no_puts: bool = False
+    # Emit an editable reproduction shell script instead of previewing/running.
+    emit_script: bool = False