roar-cli 0.2.8__tar.gz → 0.2.9__tar.gz

{roar_cli-0.2.8 → roar_cli-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: roar-cli
-Version: 0.2.8
+Version: 0.2.9
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research

{roar_cli-0.2.8 → roar_cli-0.2.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "roar-cli"
-version = "0.2.8"
+version = "0.2.9"
 description = "Reproducibility and provenance tracker for ML training pipelines"
 authors = [
     { name="TReqs Team", email="info@treqs.ai" }
@@ -81,6 +81,7 @@ include = [
     { path = "LICENSE", format = "wheel" },
     { path = "roar/bin/*", format = "sdist" },
     { path = "roar/bin/*", format = "wheel" },
+    { path = "roar_inject.pth", format = "wheel" },
 ]
 
 [tool.pytest.ini_options]
@@ -97,6 +98,8 @@ markers = [
     "cloud: Tests for cloud storage operations",
     "happy_path: Happy path tests for core functionality",
     "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",
 ]
 addopts = "-v --strict-markers -n auto --dist loadfile --ignore=tests/ebpf --ignore=tests/live_glaas --ignore=tests/benchmarks --ignore=tests/integration --ignore=tests/e2e"
 timeout = 60

{roar_cli-0.2.8 → roar_cli-0.2.9}/roar/cli/commands/_execution.py

@@ -48,7 +48,7 @@ def validate_git_clean() -> str:
     except (subprocess.CalledProcessError, FileNotFoundError):
         # Ray jobs run from extracted working dirs that are not git repos.
         # Allow execution there while preserving git checks everywhere else.
-        if "RAY_JOB_CONFIG_JSON_ENV_VAR" in os.environ:
+        if "RAY_JOB_ID" in os.environ:
             return cwd
         raise click.ClickException(
             "roar requires the working directory to be inside a git repository."

{roar_cli-0.2.8 → roar_cli-0.2.9}/roar/cli/commands/_ray_job_submit.py

@@ -10,6 +10,13 @@ from pathlib import Path
 from ...glaas_client import GlaasClient
 from ...ray.fragment_key import generate_fragment_key, save_key
 
+_ROAR_WORKER_PY_EXECUTABLE = "roar-worker"
+_ROAR_WORKER_SETUP_HOOK = "roar.ray.roar_worker._startup"
+_ROAR_DRIVER_ENTRYPOINT_MODULE = "roar.ray.driver_entrypoint"
+_ROAR_JOB_INSTRUMENTED_ENV_VAR = "ROAR_JOB_INSTRUMENTED"
+_ROAR_CLUSTER_GLAAS_URL_ENV = "ROAR_CLUSTER_GLAAS_URL"
+_ROAR_CLUSTER_AWS_ENDPOINT_URL_ENV = "ROAR_CLUSTER_AWS_ENDPOINT_URL"
+
 
 @dataclass(frozen=True)
 class RayJobSubmitRewrite:
@@ -30,6 +37,7 @@ def maybe_rewrite_ray_job_submit(command: list[str]) -> RayJobSubmitRewrite:
     entrypoint = list(command[separator_index + 1 :])
     if not entrypoint:
         return RayJobSubmitRewrite(command=command)
+    entrypoint = _wrap_entrypoint_for_driver_proxy(entrypoint)
 
     runtime_env_json_arg = _find_runtime_env_json(before_separator)
     runtime_env = _load_runtime_env(before_separator, runtime_env_json_arg)
@@ -38,16 +46,54 @@ def maybe_rewrite_ray_job_submit(command: list[str]) -> RayJobSubmitRewrite:
         return RayJobSubmitRewrite(command=command)
 
     merged_pip = _merge_roar_runtime_env_pip(runtime_env.get("pip"))
-    if merged_pip or ("pip" in runtime_env and merged_pip is not None):
+    if merged_pip:
         runtime_env["pip"] = merged_pip
+    else:
+        runtime_env.pop("pip", None)
+
+    # py_executable is intentionally NOT set at job level — it would apply to the
+    # JobSupervisor/driver process which doesn't have roar installed yet (pip runs after
+    # the supervisor starts). worker_process_setup_hook is sufficient: it runs inside
+    # each worker process after the runtime env (and pip) is ready.
+    runtime_env["worker_process_setup_hook"] = _ROAR_WORKER_SETUP_HOOK
 
     env_vars = dict(runtime_env.get("env_vars", {}) or {})
+    env_vars[_ROAR_JOB_INSTRUMENTED_ENV_VAR] = "1"
+    env_vars["ROAR_WRAP"] = "1"
+    env_vars["ROAR_RAY_NODE_AGENTS"] = "1"
+    # Stable job_id shared by driver + workers for node agent name resolution.
+    import uuid as _uuid
+
+    env_vars["ROAR_JOB_ID"] = _uuid.uuid4().hex[:8]
+
+    # Tell the job driver where roar.db lives (CWD inside the Ray job is the
+    # extracted working_dir, not the original project directory).
+    roar_dir = os.environ.get("ROAR_PROJECT_DIR", "")
+    if not roar_dir:
+        # Use CWD — `roar run` is invoked from the project root.
+        roar_dir = os.getcwd()
+    if roar_dir and os.path.isfile(os.path.join(roar_dir, ".roar", "roar.db")):
+        env_vars["ROAR_PROJECT_DIR"] = roar_dir
+
+    # Route S3 traffic through the per-node proxy (port 19191) for I/O capture.
+    # Save the REAL upstream endpoint (not the roar-run local proxy) so the
+    # cluster-side proxy can forward to the actual S3 service.
+    original_endpoint = (
+        os.environ.get("ROAR_UPSTREAM_S3_ENDPOINT") or os.environ.get("AWS_ENDPOINT_URL") or ""
+    )
+    cluster_upstream_endpoint = _resolve_cluster_upstream_s3_endpoint(original_endpoint)
+    if cluster_upstream_endpoint:
+        env_vars["ROAR_UPSTREAM_S3_ENDPOINT"] = cluster_upstream_endpoint
+    env_vars["ROAR_PROXY_PORT"] = "19191"
+    env_vars["AWS_ENDPOINT_URL"] = "http://127.0.0.1:19191"
+
     fragment_session_id: str | None = None
 
     glaas_url = _resolve_glaas_url()
     if glaas_url:
-        env_vars["GLAAS_URL"] = glaas_url
-        env_vars["GLAAS_API_URL"] = glaas_url
+        cluster_glaas_url = _resolve_cluster_glaas_url(glaas_url)
+        if cluster_glaas_url:
+            env_vars["GLAAS_URL"] = cluster_glaas_url
 
         key = generate_fragment_key()
         try:
@@ -67,7 +113,6 @@ def maybe_rewrite_ray_job_submit(command: list[str]) -> RayJobSubmitRewrite:
         runtime_env.pop("env_vars", None)
 
     before_separator = _store_runtime_env(before_separator, runtime_env, runtime_env_json_arg)
-    entrypoint = _wrap_entrypoint(entrypoint)
     return RayJobSubmitRewrite(
         command=[*before_separator, "--", *entrypoint],
         session_id=fragment_session_id,
@@ -84,6 +129,17 @@ def _is_ray_job_submit(command: list[str]) -> bool:
     return binary == "ray" and noun in {"job", "jobs"} and verb == "submit"
 
 
+def _wrap_entrypoint_for_driver_proxy(entrypoint: list[str]) -> list[str]:
+    if (
+        len(entrypoint) >= 3
+        and entrypoint[1] == "-m"
+        and entrypoint[2] == _ROAR_DRIVER_ENTRYPOINT_MODULE
+    ):
+        return entrypoint
+
+    return ["python", "-m", _ROAR_DRIVER_ENTRYPOINT_MODULE, "--", *entrypoint]
+
+
 def _find_runtime_env_json(command: list[str]) -> tuple[int, int | None] | None:
     for index, arg in enumerate(command):
         if arg == "--runtime-env-json":
@@ -137,27 +193,23 @@ def _store_runtime_env(
     return command_out
 
 
-def _wrap_entrypoint(entrypoint: list[str]) -> list[str]:
-    if len(entrypoint) >= 2 and Path(entrypoint[0]).name == "roar" and entrypoint[1] == "run":
-        return entrypoint
-    return ["roar", "run", *entrypoint]
-
-
 def _merge_roar_runtime_env_pip(existing_pip: object) -> list[str] | None:
     roar_req = _resolve_roar_requirement()
-    if roar_req is None:
-        # Local dev mode: vendor wheel present means cluster has roar pre-installed.
-        # Skip pip injection — preserve existing pip list unchanged.
-        existing = _coerce_runtime_env_pip(existing_pip)
-        return existing if existing else None
     dependencies = _coerce_runtime_env_pip(existing_pip)
     dependencies = [
         dependency
         for dependency in dependencies
         if _requirement_name(dependency) not in {"roar-cli", "roar"}
+        # Also deduplicate URL-based requirements (e.g. presigned S3 URLs).
+        # _requirement_name() returns the full URL for these, so the name-based
+        # filter above never matches them — without this check the URL would
+        # survive the filter and get appended again, producing duplicates.
+        and dependency.strip() != roar_req.strip()
     ]
-    dependencies.append(roar_req)
-    return dependencies
+    # "skip" means roar is already installed on workers (e.g. Docker image with editable install).
+    if roar_req != "skip":
+        dependencies.append(roar_req)
+    return dependencies if dependencies else None
 
 
 def _coerce_runtime_env_pip(value: object) -> list[str]:
@@ -183,24 +235,23 @@ def _requirement_name(requirement: str) -> str:
     return text.strip().lower()
 
 
-def _resolve_roar_requirement() -> str | None:
-    import os
+def _resolve_roar_requirement() -> str:
+    import importlib.metadata as importlib_metadata
 
-    wheel_path = Path(os.getcwd()) / "vendor" / "roar-cli.whl"
-    if wheel_path.exists():
-        # Local dev mode: vendor wheel exists, cluster has roar pre-installed.
-        # Signal to skip pip injection entirely.
-        return None
+    # Allow overriding the pip requirement — useful for testing unreleased wheels via S3 URL
+    # without a PyPI publish. Set ROAR_CLUSTER_PIP_REQ=https://... in the environment.
+    override = os.environ.get("ROAR_CLUSTER_PIP_REQ", "").strip()
+    if override:
+        return override
 
-    import importlib.metadata as importlib_metadata
+    try:
+        version = importlib_metadata.version("roar-cli")
+        return f"roar-cli=={version}"
+    except importlib_metadata.PackageNotFoundError:
+        pass
+    except Exception:
+        pass
 
-    for package_name in ("roar-cli", "roar"):
-        try:
-            return f"{package_name}=={importlib_metadata.version(package_name)}"
-        except importlib_metadata.PackageNotFoundError:
-            continue
-        except Exception:
-            break
     return "roar-cli"
 
 
@@ -209,10 +260,28 @@ def _resolve_glaas_url() -> str | None:
 
     url = get_glaas_url()
     if not url:
-        return None
+        return "https://api.glaas.ai"
     return str(url)
 
 
+def _resolve_cluster_glaas_url(host_glaas_url: str | None) -> str | None:
+    override = os.environ.get(_ROAR_CLUSTER_GLAAS_URL_ENV, "").strip()
+    if override:
+        return override
+    if not host_glaas_url:
+        return None
+    return str(host_glaas_url)
+
+
+def _resolve_cluster_upstream_s3_endpoint(host_endpoint: str | None) -> str | None:
+    override = os.environ.get(_ROAR_CLUSTER_AWS_ENDPOINT_URL_ENV, "").strip()
+    if override:
+        return override
+    if not host_endpoint:
+        return None
+    return str(host_endpoint)
+
+
 def _register_fragment_session(
     glaas_url: str,
     session_id: str,

{roar_cli-0.2.8 → roar_cli-0.2.9}/roar/cli/commands/init.py

@@ -119,8 +119,6 @@ fallback_enabled = true
 enabled = true
 # Inject roar-cli into runtime_env.pip for remote workers
 pip_install = true
-# Shared log directory for Ray worker I/O capture
-log_dir = "/shared/.roar-logs"
 # Actor attribution mode for Ray actor methods (per_call | per_actor)
 actor_attribution = "per_call"
 

{roar_cli-0.2.8 → roar_cli-0.2.9}/roar/cli/commands/register.py

@@ -1,9 +1,9 @@
 """
 Native Click implementation of the register command.
 
-Usage: roar register [options] <artifact_path>
+Usage: roar register [options] <target>
 
-Registers an artifact and its complete lineage with GLaaS.
+Registers artifact, step, or session lineage with GLaaS.
 """
 
 import click
@@ -25,7 +25,7 @@ def _confirm_secrets(detected_secrets: list[str]) -> bool:
 
 
 @click.command("register")
-@click.argument("artifact_path", type=click.STRING)
+@click.argument("target", type=click.STRING)
 @click.option(
     "--dry-run",
     is_flag=True,
@@ -44,15 +44,15 @@ def _confirm_secrets(detected_secrets: list[str]) -> bool:
 )
 @click.pass_obj
 @require_init
-def register(
-    ctx: RoarContext, artifact_path: str, dry_run: bool, yes: bool, as_blake3: bool
-) -> None:
-    """Register artifact lineage with GLaaS.
+def register(ctx: RoarContext, target: str, dry_run: bool, yes: bool, as_blake3: bool) -> None:
+    """Register lineage with GLaaS.
 
-    Submits the complete lineage of an artifact to the GLaaS server,
-    including all jobs and artifacts in the dependency chain.
+    Submits lineage to the GLaaS server, starting from one of:
+    - an artifact path
+    - a DAG step reference like ``@4``
+    - a local session hash/prefix previously shown by roar
 
-    The ARTIFACT_PATH must be a file that has been tracked by roar run.
+    Artifact paths must refer to files tracked by roar.
 
     If secrets are detected in the data (API keys, tokens, passwords, etc.),
     you will be prompted to confirm. Use --yes to skip the prompt and
@@ -67,6 +67,10 @@ def register(
 
         roar register -y model.pt           # Skip confirmation prompt
 
+        roar register @4                    # Register the lineage for DAG step 4
+
+        roar register 8d7a1f2c...           # Register a whole local session
+
         roar register --as-blake3 model.pt  # Upgrade S3 etag hashes
 
         roar register outputs/metrics.json  # Register from subdirectory
@@ -74,9 +78,9 @@ def register(
     # Create service
     service = RegisterService()
 
-    # Register the artifact lineage
-    result = service.register_artifact_lineage(
-        artifact_path=artifact_path,
+    # Register the requested lineage target
+    result = service.register_lineage_target(
+        target=target,
         roar_dir=ctx.roar_dir,
         cwd=ctx.cwd,
         dry_run=dry_run,
@@ -105,9 +109,10 @@ def register(
         click.echo("")
         click.echo("View on GLaaS:")
         click.echo(f"  Session:  {web_url}/dag/{result.session_hash}")
-        click.echo(f"  Artifact: {web_url}/artifact/{result.artifact_hash}")
+        if result.artifact_hash:
+            click.echo(f"  Artifact: {web_url}/artifact/{result.artifact_hash}")
     else:
-        click.echo(f"Registered lineage for: {artifact_path}")
+        click.echo(f"Registered lineage for: {target}")
         click.echo(f"  Session: {result.session_hash[:12]}...")
         click.echo(f"  Jobs: {result.jobs_registered}")
         click.echo(f"  Artifacts: {result.artifacts_registered}")
@@ -122,12 +127,13 @@ def register(
             for error in result.error.split("; "):
                 click.echo(f"  - {error}", err=True)
 
-        # Print reproduce command
-        click.echo("")
-        click.echo("To reproduce this artifact:")
-        click.echo(f"  roar reproduce {result.artifact_hash}")
+        if result.artifact_hash:
+            click.echo("")
+            click.echo("To reproduce this artifact:")
+            click.echo(f"  roar reproduce {result.artifact_hash}")
 
         click.echo("")
         click.echo("View on GLaaS:")
         click.echo(f"  Session:  {web_url}/dag/{result.session_hash}")
-        click.echo(f"  Artifact: {web_url}/artifact/{result.artifact_hash}")
+        if result.artifact_hash:
+            click.echo(f"  Artifact: {web_url}/artifact/{result.artifact_hash}")

{roar_cli-0.2.8 → roar_cli-0.2.9}/roar/cli/context.py

@@ -7,6 +7,7 @@ passed through the Click command chain via ctx.obj.
 
 from __future__ import annotations
 
+import os
 import sys
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -137,5 +138,12 @@ class RoarContext:
 
     @property
     def has_repo(self) -> bool:
-        """Check if we're in a git repository."""
-        return self.repo_root is not None
+        """Check if we're in a git repository.
+
+        Returns True when ROAR_JOB_INSTRUMENTED=1 (Ray job driver running
+        from an extracted working_dir that is not a git repo).
+        """
+        if self.repo_root is not None:
+            return True
+        # Ray job drivers run from extracted working dirs without .git
+        return os.environ.get("ROAR_JOB_INSTRUMENTED") == "1"

{roar_cli-0.2.8 → roar_cli-0.2.9}/roar/cli/decorators.py

@@ -79,7 +79,9 @@ def require_init(f: F) -> F:
 
         initialized = bool(ctx.is_initialized) or _has_roar_dir(ctx)
 
-        if not initialized and "RAY_JOB_CONFIG_JSON_ENV_VAR" in os.environ:
+        if not initialized and (
+            "RAY_JOB_ID" in os.environ or os.environ.get("ROAR_JOB_INSTRUMENTED") == "1"
+        ):
             try:
                 _auto_init_for_ray_job(ctx)
             except Exception as e:

{roar_cli-0.2.8 → roar_cli-0.2.9}/roar/config.py

@@ -138,11 +138,6 @@ CONFIGURABLE_KEYS = {
         "default": True,
         "description": "Inject roar-cli into Ray runtime_env.pip for remote workers",
     },
-    "ray.log_dir": {
-        "type": str,
-        "default": "/shared/.roar-logs",
-        "description": "Shared Ray worker log directory for roar collection",
-    },
     "ray.actor_attribution": {
         "type": str,
         "default": "per_call",

{roar_cli-0.2.8 → roar_cli-0.2.9}/roar/core/interfaces/repositories.py

@@ -149,6 +149,10 @@ class SessionRepository(Protocol):
         """Get session by ID."""
         ...
 
+    def get_all(self) -> list[dict[str, Any]]:
+        """Get all sessions."""
+        ...
+
     def get_by_hash_prefix(self, hash_prefix: str) -> dict[str, Any] | None:
         """Get first session matching a hash prefix."""
         ...

{roar_cli-0.2.8 → roar_cli-0.2.9}/roar/core/models/config.py

@@ -184,7 +184,6 @@ class RayConfig(ConfigBaseModel):
 
     enabled: bool = True
     pip_install: bool = True
-    log_dir: str = "/shared/.roar-logs"
     actor_attribution: Literal["per_call", "per_actor"] = "per_call"
 
 

{roar_cli-0.2.8 → roar_cli-0.2.9}/roar/db/repositories/session.py

@@ -11,12 +11,20 @@ from pathlib import Path
 from typing import Any
 
 import blake3
-from sqlalchemy import delete, func, select, update
+from sqlalchemy import case, delete, func, select, update
 from sqlalchemy.orm import Session as SASession
 
 from ...core.interfaces.repositories import SessionRepository
 from ..models import Job, Session
 
+_STEP_NOISE_COMMANDS = (
+    "ray_task:unknown",
+    "ray_task:__init__",
+    "ray_task:s3_proxy",
+    "ray_task:s3_driver_proxy",
+    "ray_task:RoarNodeAgent.__init__",
+)
+
 
 class SQLAlchemySessionRepository(SessionRepository):
     """
@@ -212,6 +220,17 @@ class SQLAlchemySessionRepository(SessionRepository):
         session = self._session.get(Session, session_id)
         return self._session_to_dict(session) if session else None
 
+    def get_all(self) -> list[dict[str, Any]]:
+        """Get all sessions ordered by most recent first."""
+        sessions = (
+            self._session.execute(
+                select(Session).order_by(Session.created_at.desc(), Session.id.desc())
+            )
+            .scalars()
+            .all()
+        )
+        return [self._session_to_dict(session) for session in sessions]
+
     def get_by_hash(self, session_hash: str) -> dict[str, Any] | None:
         """
         Get a session by its content hash.
@@ -313,9 +332,30 @@ class SQLAlchemySessionRepository(SessionRepository):
                 .where(
                     Job.session_id == session_id,
                     Job.step_number == step_number,
-                    Job.job_type.is_(None) | (Job.job_type == "run"),
+                    Job.job_type.is_(None) | (Job.job_type != "build"),
+                )
+                .order_by(
+                    case(
+                        (Job.job_type.is_(None), 6),
+                        (Job.job_type == "run", 6),
+                        (
+                            Job.command.is_not(None)
+                            & (~Job.command.in_(_STEP_NOISE_COMMANDS))
+                            & Job.parent_job_uid.is_not(None)
+                            & Job.script.is_not(None)
+                            & (~Job.script.like("%.%")),
+                            5,
+                        ),
+                        (
+                            Job.command.is_not(None) & (~Job.command.in_(_STEP_NOISE_COMMANDS)),
+                            4,
+                        ),
+                        (Job.command.in_(_STEP_NOISE_COMMANDS), 1),
+                        else_=2,
+                    ).desc()
                 )
                 .order_by(Job.timestamp.desc())
+                .order_by(Job.id.desc())
                 .limit(1)
             )
         job = self._session.execute(query).scalar_one_or_none()
@@ -605,6 +645,7 @@ class SQLAlchemySessionRepository(SessionRepository):
         return {
             "id": job.id,
             "job_uid": job.job_uid,
+            "parent_job_uid": job.parent_job_uid,
             "timestamp": job.timestamp,
             "command": job.command,
             "script": job.script,

{roar_cli-0.2.8 → roar_cli-0.2.9}/roar/glaas/auth.py

@@ -20,9 +20,9 @@ def get_glaas_url() -> str | None:
     """Get GLaaS server URL from config or environment."""
     from ..config import config_get
 
-    url = config_get("glaas.url")
+    url = os.environ.get("GLAAS_URL")
     if not url:
-        url = os.environ.get("GLAAS_URL")
+        url = config_get("glaas.url")
     return url
 
 

{roar_cli-0.2.8 → roar_cli-0.2.9}/roar/presenters/dag_data_builder.py

@@ -4,6 +4,14 @@ from __future__ import annotations
 
 from typing import Any
 
+_STEP_NOISE_COMMANDS = {
+    "ray_task:unknown",
+    "ray_task:__init__",
+    "ray_task:s3_proxy",
+    "ray_task:s3_driver_proxy",
+    "ray_task:RoarNodeAgent.__init__",
+}
+
 
 class DagDataBuilder:
     """Build DAG visualization data from session."""
@@ -115,6 +123,41 @@ class DagDataBuilder:
 
         return steps_by_number
 
+    def _step_sort_key(self, step: dict) -> tuple[int, float, int]:
+        job_type = step.get("job_type")
+        command = str(step.get("command") or "")
+        script = str(step.get("script") or "")
+        parent_job_uid = str(step.get("parent_job_uid") or "")
+        is_phase_wrapper = (
+            command.startswith("ray_task:")
+            and command not in _STEP_NOISE_COMMANDS
+            and bool(parent_job_uid)
+            and bool(script)
+            and "." not in script
+        )
+        if job_type in (None, "run"):
+            priority = 6
+        elif is_phase_wrapper:
+            priority = 5
+        elif command and command not in _STEP_NOISE_COMMANDS:
+            priority = 4
+        elif command in _STEP_NOISE_COMMANDS:
+            priority = 1
+        else:
+            priority = 2
+        return (
+            priority,
+            float(step.get("timestamp") or 0.0),
+            int(step.get("id") or 0),
+        )
+
+    def _representative_steps(self, steps_by_number: dict[int, list[dict]]) -> dict[int, dict]:
+        return {
+            num: max(group, key=self._step_sort_key)
+            for num, group in steps_by_number.items()
+            if group
+        }
+
     def _select_steps(
         self,
         steps_by_number: dict[int, list[dict]],
@@ -124,13 +167,14 @@ class DagDataBuilder:
         """Pick which steps to show based on expanded mode."""
         if expanded:
             return steps
-        return [steps_by_number[num][-1] for num in sorted(steps_by_number.keys())]
+        representative_by_step = self._representative_steps(steps_by_number)
+        return [representative_by_step[num] for num in sorted(representative_by_step.keys())]
 
     def _collect_artifacts(
         self, steps_by_number: dict[int, list[dict]]
     ) -> tuple[dict[str, dict], dict[str, list[str]]]:
         """Build all_artifacts and artifacts_by_path from latest step outputs."""
-        latest_by_step: dict[int, dict] = {num: group[-1] for num, group in steps_by_number.items()}
+        latest_by_step = self._representative_steps(steps_by_number)
 
         all_artifacts: dict[str, dict] = {}
         artifacts_by_path: dict[str, list[str]] = {}
@@ -179,7 +223,7 @@ class DagDataBuilder:
         all_artifacts: dict[str, dict],
     ) -> dict[str, list[int]]:
         """Build consumer relationships from step inputs."""
-        latest_by_step: dict[int, dict] = {num: group[-1] for num, group in steps_by_number.items()}
+        latest_by_step = self._representative_steps(steps_by_number)
 
         artifact_consumers: dict[str, list[int]] = {}
 
@@ -206,7 +250,7 @@ class DagDataBuilder:
         expanded: bool,
     ) -> list[dict]:
         """Build node data for each step to show."""
-        latest_by_step: dict[int, dict] = {num: group[-1] for num, group in steps_by_number.items()}
+        latest_by_step = self._representative_steps(steps_by_number)
         nodes = []
 
         for step in steps_to_show:

{roar_cli-0.2.8 → roar_cli-0.2.9}/roar/ray/actor.py

@@ -13,10 +13,7 @@ class RoarLogCollectorActor:
         token: str | None = None,
         glaas_url: str | None = None,
     ) -> None:
-        self._events: list[dict] = []
-        self._fragments: list[dict] = []
         self._streamer: GlaasFragmentStreamer | None = None
-
         if session_id and token and glaas_url:
             self._streamer = GlaasFragmentStreamer(
                 session_id=session_id,
@@ -24,20 +21,17 @@ class RoarLogCollectorActor:
                 glaas_url=glaas_url,
             )
 
-    def append_batch(self, events: list[dict]) -> None:
-        self._events.extend(events)
+    def ping(self) -> bool:
+        return True
 
-    def get_all(self) -> list[dict]:
-        return list(self._events)
+    def append_batch(self, _events: list[dict]) -> None:
+        # Deprecated compatibility shim for legacy worker hooks.
+        return None
 
     def append_fragment(self, fragment: dict) -> None:
-        self._fragments.append(fragment)
         if self._streamer is not None:
             self._streamer.append_fragment(fragment)
 
-    def get_all_fragments(self) -> list[dict]:
-        return list(self._fragments)
-
     def flush_to_glaas(self) -> bool:
         if self._streamer is None:
             return True