simulo 0.28.2__tar.gz → 0.29.0__tar.gz

{simulo-0.28.2/src/simulo.egg-info → simulo-0.29.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simulo
-Version: 0.28.2
+Version: 0.29.0
 Summary: Python SDK and CLI for cloud-native robotics simulation, reinforcement learning, and robot policy training on managed GPUs.
 Author-email: Simulo Team <team@simulo.ai>
 License: BSD-3-Clause
@@ -31,7 +31,7 @@ Classifier: Topic :: System :: Distributed Computing
 Classifier: Typing :: Typed
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: simulo-interfaces<0.21,>=0.20.2
+Requires-Dist: simulo-interfaces<0.22,>=0.21.0
 Requires-Dist: mcap<2,>=1.3
 Requires-Dist: defusedxml>=0.7.1
 Requires-Dist: usd-core<27,>=26.5
@@ -62,12 +62,11 @@ Simulo is a cloud-native AI platform for robotics simulation and training. Its
 lightweight `simulo` Python SDK and CLI let you define robot-learning applications
 locally, submit them to the Simulo cloud, and inspect the results. The platform
 handles managed GPU execution, reproducible packaging, versioned assets,
-checkpoints, trained models, recordings, and live 3D viewing.
+policies, checkpoints, recordings, ONNX bundles, and live 3D viewing.
 
 The package installed on your computer is torch-free and requires no local GPU or
-simulator. The managed runtime executes reinforcement-learning training, policy
-evaluation and inference, and scripted robotics simulations on managed GPUs in
-the cloud.
+simulator. The managed runtime executes reinforcement-learning training on
+managed GPUs in the cloud.
 
 ## What you can do
 
@@ -75,7 +74,7 @@ the cloud.
 - Build vectorized reinforcement-learning environments and train robot policies with PPO.
 - Start with validated catalog robots or publish your own OpenUSD (USD) and URDF assets.
 - Continue training from the best or latest checkpoint produced by an earlier job.
-- Evaluate policies, run inference, and export trained policies as verified ONNX bundles.
+- Export an explicit policy checkpoint as a verified ONNX bundle.
 - Stream logs, retrieve results and outputs, capture MCAP rollout recordings, and watch a live 3D view.
 
 ## Install
@@ -93,12 +92,13 @@ Simulo requires Python 3.11 or newer. One installation provides both the
 simulo create mybot
 simulo login
 cd mybot
-simulo run app.py --frozen --strict-assets
+simulo run train.py --frozen --strict-assets
 ```
 
 `simulo create` writes a complete starter application to your machine without
-requiring a login or network connection. The default application trains a PPO
-policy on a validated cartpole asset. `simulo run` packages the source, resolves
+requiring a login or network connection. It creates `task.py`, `train.py`, and
+`.simuloignore`; the default application trains a PPO policy on a validated cartpole
+asset. `simulo run` packages the source, resolves
 and pins its assets, submits the job, and follows its cloud logs.
 
 ## Explore robotics samples
@@ -114,8 +114,9 @@ See the repository README for setup and usage.
 simulo jobs                       # list submitted jobs and status
 simulo logs --follow              # stream the latest job's logs
 simulo result                     # read the job's result
-simulo models                     # list or download trained models
-simulo export                     # export the best policy as verified ONNX
+simulo policy list                # list training policies and checkpoints
+simulo policy get policy_x:best   # download a verified checkpoint
+simulo export policy_x:best       # export a verified ONNX bundle
 simulo recordings                 # download MCAP rollout recordings
 simulo outputs                    # retrieve other saved outputs
 simulo view                       # view a running --viewstream job in 3D
@@ -135,7 +136,7 @@ simulo asset publish ./my-robot --kind robot
 
 Simulo catalogs keep robot, world, and prop assets versioned and traceable. You
 can use validated global assets immediately or publish your own USD or URDF
-package for reuse across training, evaluation, and inference jobs.
+package for reuse across training jobs.
 
 ## Learn more
 

{simulo-0.28.2 → simulo-0.29.0}/PYPI.md

@@ -6,12 +6,11 @@ Simulo is a cloud-native AI platform for robotics simulation and training. Its
 lightweight `simulo` Python SDK and CLI let you define robot-learning applications
 locally, submit them to the Simulo cloud, and inspect the results. The platform
 handles managed GPU execution, reproducible packaging, versioned assets,
-checkpoints, trained models, recordings, and live 3D viewing.
+policies, checkpoints, recordings, ONNX bundles, and live 3D viewing.
 
 The package installed on your computer is torch-free and requires no local GPU or
-simulator. The managed runtime executes reinforcement-learning training, policy
-evaluation and inference, and scripted robotics simulations on managed GPUs in
-the cloud.
+simulator. The managed runtime executes reinforcement-learning training on
+managed GPUs in the cloud.
 
 ## What you can do
 
@@ -19,7 +18,7 @@ the cloud.
 - Build vectorized reinforcement-learning environments and train robot policies with PPO.
 - Start with validated catalog robots or publish your own OpenUSD (USD) and URDF assets.
 - Continue training from the best or latest checkpoint produced by an earlier job.
-- Evaluate policies, run inference, and export trained policies as verified ONNX bundles.
+- Export an explicit policy checkpoint as a verified ONNX bundle.
 - Stream logs, retrieve results and outputs, capture MCAP rollout recordings, and watch a live 3D view.
 
 ## Install
@@ -37,12 +36,13 @@ Simulo requires Python 3.11 or newer. One installation provides both the
 simulo create mybot
 simulo login
 cd mybot
-simulo run app.py --frozen --strict-assets
+simulo run train.py --frozen --strict-assets
 ```
 
 `simulo create` writes a complete starter application to your machine without
-requiring a login or network connection. The default application trains a PPO
-policy on a validated cartpole asset. `simulo run` packages the source, resolves
+requiring a login or network connection. It creates `task.py`, `train.py`, and
+`.simuloignore`; the default application trains a PPO policy on a validated cartpole
+asset. `simulo run` packages the source, resolves
 and pins its assets, submits the job, and follows its cloud logs.
 
 ## Explore robotics samples
@@ -58,8 +58,9 @@ See the repository README for setup and usage.
 simulo jobs                       # list submitted jobs and status
 simulo logs --follow              # stream the latest job's logs
 simulo result                     # read the job's result
-simulo models                     # list or download trained models
-simulo export                     # export the best policy as verified ONNX
+simulo policy list                # list training policies and checkpoints
+simulo policy get policy_x:best   # download a verified checkpoint
+simulo export policy_x:best       # export a verified ONNX bundle
 simulo recordings                 # download MCAP rollout recordings
 simulo outputs                    # retrieve other saved outputs
 simulo view                       # view a running --viewstream job in 3D
@@ -79,7 +80,7 @@ simulo asset publish ./my-robot --kind robot
 
 Simulo catalogs keep robot, world, and prop assets versioned and traceable. You
 can use validated global assets immediately or publish your own USD or URDF
-package for reuse across training, evaluation, and inference jobs.
+package for reuse across training jobs.
 
 ## Learn more
 

{simulo-0.28.2 → simulo-0.29.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "simulo"
-version = "0.28.2"
+version = "0.29.0"
 description = "Python SDK and CLI for cloud-native robotics simulation, reinforcement learning, and robot policy training on managed GPUs."
 readme = "PYPI.md"
 requires-python = ">=3.11"
@@ -59,7 +59,7 @@ classifiers = [
 # mcap: used by `simulo recordings` to read back a downloaded recording and
 # verify it (message count) — MIT-licensed, deps only lz4+zstandard.
 dependencies = [
-    "simulo-interfaces>=0.20.2,<0.21",
+    "simulo-interfaces>=0.21.0,<0.22",
     "mcap>=1.3,<2",
     # Hardened XML parsing for URDF ingestion (USD Asset Catalogs, PR-12 fix
     # loop 2, security NIT): stdlib xml.etree.ElementTree relies on
@@ -157,7 +157,7 @@ namespaces = true
 # each is read at runtime via `importlib.resources.files(...)`, never `__file__`
 # path math, so this glob actually landing in the built wheel is load-bearing —
 # see tests/test_create_wheel_packaging.py.
-"simulo._client.templates" = ["training/*.tmpl", "inference/*.tmpl", "scenario/*.tmpl"]
+"simulo._client.templates" = ["training/*.tmpl"]
 
 [tool.mypy]
 python_version = "3.11"

{simulo-0.28.2 → simulo-0.29.0}/src/simulo/__init__.py

@@ -44,8 +44,8 @@ Three kinds of name live on ``simulo``:
   stdlib-only (``NewType`` is the underlying ``str`` at runtime).
 * **Lazy, mode-aware** names — the learning names ``Task / Scene / Robot /
   LearningEnv / RLTrainer / …`` plus the execution-time ``save_output`` and
-  ``run`` (the scenario execution loop) — are
-  resolved through the PEP 562 ``__getattr__`` below, which delegates to the
+  authoring value types described below — are resolved through the PEP 562
+  ``__getattr__`` below, which delegates to the
   thin client's internal learning-name resolver. At submit (discovery mode) they resolve to
   lean stand-ins so the user app imports without the heavy runtime; only the
   backend runner (execution mode) resolves them to the real implementations.
@@ -81,16 +81,18 @@ from simulo._client.volume import Volume
 # never a second import.
 from simulo.interfaces import (
     CheckpointId,
+    CheckpointRefIsJobError,
     ContractViolationError,
     Digest,
     ImportResolutionError,
     JobFailedError,
     JobId,
     JobPublicId,
-    ModelPublicId,
+    JobType,
     OrganizationId,
     OutputPublicId,
     PackageId,
+    PolicyPublicId,
     ProjectId,
     RecordingPublicId,
     ResourceId,
@@ -99,11 +101,12 @@ from simulo.interfaces import (
     ResumeIncompatibleError,
     SimuloError,
     TagId,
-    TrainedModelId,
+    checkpoint_ref_is_job_hint,
+    parse_checkpoint_ref,
     parse_job_public_id,
-    parse_model_public_id,
     parse_output_public_id,
     parse_recording_public_id,
+    policy_id_for_job,
 )
 
 # The authoring value types that the lazy resolver does NOT already carry.
@@ -179,17 +182,20 @@ __all__ = [
     "ProjectId",
     "PackageId",
     "JobId",
+    "JobType",
     "JobPublicId",
-    "ModelPublicId",
+    "PolicyPublicId",
     "RecordingPublicId",
     "OutputPublicId",
     "parse_job_public_id",
-    "parse_model_public_id",
+    "parse_checkpoint_ref",
+    "policy_id_for_job",
+    "checkpoint_ref_is_job_hint",
+    "CheckpointRefIsJobError",
     "parse_recording_public_id",
     "parse_output_public_id",
     "ResourceId",
     "CheckpointId",
-    "TrainedModelId",
     "TagId",
     "ResourceUri",
     "Digest",
@@ -256,7 +262,6 @@ __all__ = [
     "RewardComponent",
     "RewardSet",
     "Robot",
-    "Scenario",
     "Scene",
     "SensorOffset",
     "Simulation",
@@ -268,7 +273,6 @@ __all__ = [
     "Trainer",
     "Visual",
     "World",
-    "run",
     "save_output",
 ]
 
@@ -283,6 +287,12 @@ def __getattr__(name: str) -> object:
     """
     if name in _LEARNING_NAMES:
         return _resolve_learning(name)
+    removed_hints = {
+        "Scenario": "simulo.Scenario was removed. Use a typed @app.job instead.",
+        "run": "simulo.run was removed. Use `simulo run train.py` instead.",
+    }
+    if name in removed_hints:
+        raise AttributeError(removed_hints[name])
     raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
 
 
@@ -318,15 +328,6 @@ if TYPE_CHECKING:
     #   NOT the declared type; see the facades module docstring for the
     #   known gap); facade fidelity to the contract AND to the concrete
     #   worker class is pinned by the backend suite's conformance engine.
-    # * **Called mirror** name (``simulo.run(scenario_class, ...)`` — the one
-    #   non-learning, non-instantiated member of this kind): same problem as
-    #   an instantiated mirror one level down — with no override, ``run``
-    #   types as ``object`` (``__getattr__``'s declared return), and
-    #   ``object`` is not *callable* at all. It aliases a plain FUNCTION
-    #   facade (there is no Protocol for a bare function to alias against),
-    #   never registered in the backend's class-shaped conformance engine —
-    #   see the facades module docstring for where its drift guard lives
-    #   instead.
     # * **Annotation-position mirror** names alias their contract Protocol:
     #   ``Scene`` is ``SceneProtocol`` — measured across every shipped user
     #   surface it appears only as ``def build(self, scene: simulo.Scene)``,
@@ -380,7 +381,6 @@ if TYPE_CHECKING:
         PlayerProtocol,
         PolicyProtocol,
         RewardComponentProtocol,
-        ScenarioProtocol,
         TaskProtocol,
         TerminationConditionProtocol,
         TrainerProtocol,
@@ -389,7 +389,6 @@ if TYPE_CHECKING:
     # Subclassable names alias their Protocol so ``class X(simulo.Task)`` is checked
     # against ``TaskProtocol``.
     Task = TaskProtocol
-    Scenario = ScenarioProtocol
     Policy = PolicyProtocol
     Player = PlayerProtocol
     Trainer = TrainerProtocol
@@ -401,20 +400,6 @@ if TYPE_CHECKING:
     # ``save_output`` aliases its real execution-mode implementation (a
     # torch-free thin-client function), so ``simulo.save_output("summary",
     # path)`` type-checks with the precise signature instead of ``Any``.
-    # ``run`` (the scenario execution loop) aliases its typing FACADE — a
-    # plain FUNCTION facade, not a class one (there is no ``RunProtocol`` to
-    # alias against; ``run`` is not a contract method). Without this, ``run``
-    # falls back to ``__getattr__``'s ``-> object`` return type, and
-    # ``object`` is not callable: ``simulo.run(MyScenario, ...)`` in a freshly
-    # scaffolded app is a hard mypy error no ``--ignore-missing-imports`` can
-    # suppress. The facade's real target (``simulo.scenario.run``) lives in
-    # the ``simulo-backend`` distribution — outside this package's own
-    # ``MYPYPATH`` — but the facade itself is thin-client-resident code
-    # (``simulo/_client/facades.py``), exactly like ``Camera``'s facade for
-    # the same reason; see that module's docstring for the full rationale and
-    # where drift against the real function is caught (a live, unmocked
-    # signature comparison in ``simulo-backend``'s test suite, not mypy).
-    from simulo._client.facades import run as run
     from simulo._client.outputs import save_output as save_output
 
     # RELOCATED authoring value types (Plan C — Waves C1, C2, then C4's

simulo-0.28.2/src/simulo/_client/_entrypoint.py → simulo-0.29.0/src/simulo/_client/_arguments.py

@@ -1,21 +1,8 @@
-"""Map ``simulo run`` command-line arguments onto a function's signature.
-
-Two submit paths share this module's introspection, pointed at different
-targets:
-
-* **The entrypoint path** — ``simulo run app.py`` maps ``--flag value``
-  arguments onto the registered ``@app.entrypoint``'s parameters and
-  invokes it; the entrypoint's own ``spawn()`` calls end at exactly one
-  submit (:func:`run_entrypoint` / :func:`parse_args`). (A direct ``python
-  app.py`` never reaches this module: :meth:`App.entrypoint` prints the
-  exact equivalent ``simulo run`` command to stderr and exits 2.)
-* **The no-entrypoint path** — with no ``@app.entrypoint`` declared, the
-  CLI maps the same ``--flag value`` arguments directly onto the chosen
-  ``@app.job``'s own signature (:func:`parse_explicit_args`) and spawns it.
-  Only EXPLICITLY-passed flags are returned there: a defaulted-but-unpassed
-  parameter must stay out of the submitted ``args`` so an upgraded client
-  submits the byte-identical package (same ``canonical_args`` → same
-  ``package_id``) for the no-flags case it always produced ``args={}`` for.
+"""Map ``simulo run`` arguments onto a sole job's signature.
+
+Only explicitly passed flags are returned: a defaulted-but-unpassed parameter
+must stay out of submitted ``args`` so the no-flags package identity remains
+stable.
 
 An argument parser is built from the target's signature: each parameter
 ``foo_bar`` becomes ``--foo-bar`` (dash for underscore), coerced from the
@@ -135,10 +122,8 @@ def _strip_optional_annotation(ann: Any) -> Any:
 def conclusive_param_type(param: inspect.Parameter) -> Optional[type]:
     """The scalar type a ``--flag`` value is conclusively coerced to, or ``None``.
 
-    Unlike :func:`_param_type` — whose ``str`` FALLBACK is fine for an
-    entrypoint (the entrypoint body runs client-side and can fix things up) —
-    the no-entrypoint job path submits the coerced value straight into the
-    job's ``args``, so a guess is a silent wrong submission: ``tags: list = []``
+    The sole-job path submits the coerced value straight into the job's
+    ``args``, so a guess is a silent wrong submission: ``tags: list = []``
     would coerce ``--tags release`` through ``list("release")`` into
     ``["r", "e", "l", ...]``, and a ``Path``/``set``/enum value would crash
     ``json.dumps`` at manifest time. ``None`` here means "reject at submit".
@@ -146,8 +131,7 @@ def conclusive_param_type(param: inspect.Parameter) -> Optional[type]:
     Conclusive: a non-``None`` scalar default (its type), or an ``int`` /
     ``float`` / ``bool`` / ``str`` annotation — real type, PEP 563 string, or
     either wrapped in ``Optional[...]`` / ``| None``. An unannotated parameter
-    stays ``str`` (the documented text fallback, unchanged from the entrypoint
-    convention).
+    stays ``str`` (the documented text fallback).
     """
     default = param.default
     if default is not inspect.Parameter.empty and default is not None:
@@ -204,11 +188,11 @@ def build_parser(
 ) -> argparse.ArgumentParser:
     """Build an ``argparse`` parser from a function's signature.
 
-    With ``sentinel_defaults=False`` (the entrypoint path — behavior unchanged),
-    a defaulted parameter's parser default is the signature's own default, so
+    With ``sentinel_defaults=False``, a defaulted parameter's parser default is
+    the signature's own default, so
     ``parse_args`` yields EVERY parameter, and values coerce via
     :func:`_param_type` (``str`` fallback included). With
-    ``sentinel_defaults=True`` (the no-entrypoint job path), defaulted
+    ``sentinel_defaults=True`` (the sole-job path), defaulted
     parameters default to the private ``_UNSET`` sentinel instead — so
     :func:`parse_explicit_args` can tell an explicitly-passed flag from an
     untouched default — and values coerce via :func:`conclusive_param_type`
@@ -217,7 +201,7 @@ def build_parser(
     function's own name, as before.
 
     ``exclude`` drops the named parameters from the parser entirely — the
-    no-entrypoint path passes its DEFERRED unmappable-but-defaulted parameters
+    sole-job path passes its DEFERRED unmappable-but-defaulted parameters
     here (see :func:`unmappable_params`), so a flag targeting one — even via
     an argparse abbreviation the caller's exact-token scan cannot see — fails
     at submit as an unrecognized argument rather than being mis-parsed.
@@ -225,7 +209,7 @@ def build_parser(
     sig = inspect.signature(fn)
     doc = (inspect.getdoc(fn) or "").strip().splitlines()
     parser = argparse.ArgumentParser(
-        prog=prog if prog is not None else getattr(fn, "__name__", "entrypoint"),
+        prog=prog if prog is not None else getattr(fn, "__name__", "job"),
         description=doc[0] if doc else None,
     )
     for name, param in sig.parameters.items():
@@ -264,19 +248,6 @@ def build_parser(
     return parser
 
 
-def parse_args(fn: Callable[..., object], argv: Sequence[str]) -> dict[str, Any]:
-    """Parse ``argv`` against ``fn``'s signature into a keyword-argument dict."""
-    parser = build_parser(fn)
-    namespace = parser.parse_args(list(argv))
-    sig = inspect.signature(fn)
-    kwargs: dict[str, Any] = {}
-    for name, param in sig.parameters.items():
-        if param.kind in _SKIP_KINDS:
-            continue
-        kwargs[name] = getattr(namespace, name)
-    return kwargs
-
-
 def parse_explicit_args(
     fn: Callable[..., object],
     argv: Sequence[str],
@@ -286,13 +257,13 @@ def parse_explicit_args(
 ) -> dict[str, Any]:
     """Parse ``argv`` against ``fn``'s signature; return ONLY explicitly-passed kwargs.
 
-    The no-entrypoint submit path maps CLI flags onto a ``@app.job``'s own
-    signature with this: a parameter the user did not pass stays OUT of the
+    The sole-job submit path maps CLI flags onto a ``@app.job`` signature: a
+    parameter the user did not pass stays OUT of the
     returned dict (the job body applies its own default on the worker), so the
     no-flags case still submits ``args={}`` — exactly what pre-mapping clients
     always submitted — and ``package_id`` is unchanged across the upgrade.
-    A parameter without a default is required, exactly as on the entrypoint
-    path. ``exclude`` names parameters left out of the parser and the result
+    A parameter without a default is required. ``exclude`` names parameters
+    left out of the parser and the result
     (the deferred unmappable-but-defaulted ones — see :func:`build_parser`).
     """
     parser = build_parser(fn, sentinel_defaults=True, prog=prog, exclude=exclude)
@@ -306,8 +277,3 @@ def parse_explicit_args(
         if value is not _UNSET:
             kwargs[name] = value
     return kwargs
-
-
-def run_entrypoint(fn: Callable[..., object], argv: Sequence[str]) -> object:
-    """Parse ``argv`` for ``fn`` and invoke it (the single submit happens inside)."""
-    return fn(**parse_args(fn, argv))

{simulo-0.28.2 → simulo-0.29.0}/src/simulo/_client/_runner.py

@@ -26,7 +26,7 @@ from pathlib import Path
 from typing import Any, NoReturn, Optional
 
 from simulo.interfaces.ids import JobId, JobPublicId
-from simulo.interfaces.platform.enums import JobStatus
+from simulo.interfaces.platform.enums import JobStatus, JobType
 from simulo.interfaces.platform.runs import JOB_SCOPE_MINE
 
 #: Poll cadence for cloud ``.get()``. Module-level so tests can shrink it.
@@ -90,6 +90,10 @@ class JobHandle:
         cloud: bool = False,
         base_url: Optional[str] = None,
         token: Optional[str] = None,
+        job_type: Optional[JobType] = None,
+        input_checkpoint: Optional[str] = None,
+        deferred_stdout: str = "",
+        deferred_stderr: str = "",
     ) -> None:
         self._job_id = job_id
         self._public_id = public_id
@@ -98,6 +102,10 @@ class JobHandle:
         self._cloud = cloud
         self._base_url = base_url
         self._token = token
+        self._job_type = job_type
+        self._input_checkpoint = input_checkpoint
+        self._deferred_stdout = deferred_stdout
+        self._deferred_stderr = deferred_stderr
 
     @property
     def job_id(self) -> JobId:
@@ -134,6 +142,31 @@ class JobHandle:
         """The bearer token to observe this job with (cloud mode only)."""
         return self._token
 
+    @property
+    def job_type(self) -> Optional[JobType]:
+        """Declared type for a cloud submission; absent on legacy local handles."""
+        return self._job_type
+
+    @property
+    def input_checkpoint(self) -> Optional[str]:
+        """Policy checkpoint requested with ``simulo run --from``."""
+        return self._input_checkpoint
+
+    @property
+    def deferred_stdout(self) -> str:
+        """Submit-time output held until the cloud job header is printed."""
+        return self._deferred_stdout
+
+    @property
+    def deferred_stderr(self) -> str:
+        """Submit-time stderr held until the cloud job header is printed."""
+        return self._deferred_stderr
+
+    def _defer_submit_output(self, *, stdout: str = "", stderr: str = "") -> None:
+        """Append client-owned submit output for rendering after the job header."""
+        self._deferred_stdout += stdout
+        self._deferred_stderr += stderr
+
     def execute_hint(self) -> str:
         """The command that executes this submitted package locally (local-disk mode)."""
         return f"simulo-backend run-package {self._package_path} --job {self._job_name}"

{simulo-0.28.2 → simulo-0.29.0}/src/simulo/_client/_secure_downloads.py

@@ -4,7 +4,7 @@ THE RACE THIS CLOSES. The bulk download path validates its assembled
 filename and the selected destination directory as PATH STRINGS
 (``_contained_bulk_download_destination`` in ``cli.py``: resolve, then
 ``relative_to``) before any bytes are fetched. The actual write — inside
-this client's ``download_model``/``download_output``/``download_recording``
+this client's checkpoint/output/recording download paths
 — re-derives the SAME destination from its path string again, after a
 network fetch: an ``exist_ok=True`` ``mkdir`` (which silently ACCEPTS a
 symlink planted at a previously-missing path, so long as it resolves to a