simulo-interfaces 0.23.0__tar.gz → 0.24.0__tar.gz

{simulo_interfaces-0.23.0/src/simulo_interfaces.egg-info → simulo_interfaces-0.24.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simulo-interfaces
-Version: 0.23.0
+Version: 0.24.0
 Summary: Typed Python contracts for the Simulo cloud robotics SDK and managed simulation runtime.
 Author-email: Simulo Team <team@simulo.ai>
 License: BSD-3-Clause

{simulo_interfaces-0.23.0 → simulo_interfaces-0.24.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "simulo-interfaces"
-version = "0.23.0"
+version = "0.24.0"
 description = "Typed Python contracts for the Simulo cloud robotics SDK and managed simulation runtime."
 readme = "PYPI.md"
 requires-python = ">=3.11"

{simulo_interfaces-0.23.0 → simulo_interfaces-0.24.0}/src/simulo/interfaces/authoring/__init__.py

@@ -1,13 +1,10 @@
 """Part C — the typed authoring surface.
 
-The **relocation and mirror destination** for the Simulo authoring value types.
-Each type here has exactly ONE definition — this one — shared by both
-distributions: the thin client authors these values at submit (torch-free,
-e.g. ``simulo.Pose(xyz=(1, 2, 3))``) and the backend executes them on the
-worker. There is no other copy and no re-export shim anywhere ("nuke as you
-go", per the owner's 2026-07-26 directive recorded in the plan): the former
-backend ``core`` modules for these types are deleted, so ``isinstance`` keeps
-working because only this definition exists.
+The relocation and mirror destination for shared authoring value types.
+Each value type has one definition here, used by the torch-free client when
+submitting a job and by the backend when executing it. Robot configuration
+records retain their existing backend import paths as re-exports of these
+same objects.
 
 Relocated so far — Wave C1: ``pose`` (``Pose``), ``materials`` (``Material``,
 ``SurfaceMaterial``), ``physics`` (``Physics``, ``Collision``, ``RigidPhysics``,
@@ -53,8 +50,9 @@ clearly in a submit-only installation.
 Two relocation mechanisms select which types land here and how (see the derived
 plan for the full worked example and rejected alternatives):
 
-* **RELOCATE** — the class definition MOVES here; the old ``core/<module>.py``
-  is deleted and every call site rewritten in the same PR (no re-export shims).
+* **RELOCATE** — the class definition MOVES here. Dependency-bearing modules
+  that also exposed a shared value type can re-export its one definition for
+  existing callers; dependency-free modules move with their call sites.
   Reserved for types with zero import-time *or* call-time dependency on
   anything that cannot live in a zero-dependency package.
 * **MIRROR** — a ``typing.Protocol`` (named ``*Protocol``, matching the
@@ -99,6 +97,7 @@ from simulo.interfaces.authoring.physics import (
     Physics,
     RigidPhysics,
 )
+from simulo.interfaces.authoring.policy_inputs import PolicyInput, PolicyInputSchema
 from simulo.interfaces.authoring.pose import Pose
 from simulo.interfaces.authoring.primitives import (
     Cone,
@@ -111,6 +110,7 @@ from simulo.interfaces.authoring.primitives import (
 from simulo.interfaces.authoring.prop import PropProtocol, PropStateProtocol
 from simulo.interfaces.authoring.record import RecordConfig
 from simulo.interfaces.authoring.robot import RobotProtocol, RobotStateProtocol
+from simulo.interfaces.authoring.robot_config import ActuatorGainsConfig, ArticulationConfig, JointConfig
 from simulo.interfaces.authoring.scene import SceneGroupProtocol, SceneProtocol
 from simulo.interfaces.authoring.sensor import CameraProtocol
 from simulo.interfaces.authoring.terrain import (
@@ -175,6 +175,8 @@ __all__ = [
     "RecordConfig",
     # injected policy input (dependency-free; loading is deferred to execution)
     "PolicyCheckpoint",
+    "PolicyInput",
+    "PolicyInputSchema",
     # visual
     "VisualMarkerBase",
     "AxesMarker",
@@ -185,6 +187,10 @@ __all__ = [
     # scene (MIRROR — the concrete classes live in the backend package)
     "SceneProtocol",
     "SceneGroupProtocol",
+    # robot configuration (dependency-free owning definitions)
+    "ActuatorGainsConfig",
+    "ArticulationConfig",
+    "JointConfig",
     # robot / prop / sensor / actuator (MIRROR — the concrete classes live in
     # the backend package and explicitly inherit these Protocols)
     "RobotProtocol",

simulo_interfaces-0.24.0/src/simulo/interfaces/authoring/policy_inputs.py

@@ -0,0 +1,207 @@
+"""Dependency-free declarations for raw actor and critic inputs.
+
+Images must be batched RGB uint8 NHWC. The contract requires future trainer
+and export consumers to convert the current minibatch to NCHW float and divide
+by 255; ``center`` also subtracts 0.5. These transforms belong in the actor's
+graph. This module checks declarations and raw values, not graph behavior.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+from collections.abc import Mapping
+from dataclasses import asdict, dataclass
+from typing import Any, Literal
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class PolicyInput:
+    """One named input, with ``shape`` excluding the environment batch.
+
+    Names match ``[A-Za-z][A-Za-z0-9_]*``; shape dimensions are positive.
+    Tuple and list shapes are accepted and stored as tuples. Defaults are
+    ``dtype="float32"``, ``kind="numeric"`` and ``preprocessing="none"``.
+    Numeric inputs require float32, no camera and no preprocessing. Image
+    inputs require uint8, shape ``(H, W, 3)`` and a nonblank camera scene name:
+    the last segment of ``scene.add(camera, at="/World/<name>")``. Full paths
+    are rejected. LearningEnv setup requires that camera's purpose to be
+    ``"policy"``. Two policy cameras cannot share a scene name.
+    """
+
+    name: str
+    shape: tuple[int, ...]
+    dtype: str = "float32"
+    kind: Literal["numeric", "image"] = "numeric"
+    camera: str | None = None
+    preprocessing: Literal["none", "center"] = "none"
+
+    def __post_init__(self) -> None:
+        label = f"Input {self.name!r}"
+        if isinstance(self.shape, list):
+            object.__setattr__(self, "shape", tuple(self.shape))
+        if not isinstance(self.name, str) or not re.fullmatch(r"[A-Za-z][A-Za-z0-9_]*", self.name):
+            raise ValueError(f"{label}: name must start with a letter and contain only letters, digits or underscores.")
+        if (
+            not isinstance(self.shape, tuple)
+            or not self.shape
+            or any(type(dim) is not int or dim <= 0 for dim in self.shape)
+        ):
+            raise ValueError(f"{label}: shape must be a nonempty tuple of positive dimensions, excluding batch.")
+        if self.kind not in ("numeric", "image"):
+            raise ValueError(f"{label}: kind must be 'numeric' or 'image'.")
+        if self.preprocessing not in ("none", "center"):
+            raise ValueError(f"{label}: preprocessing must be 'none' or 'center'.")
+        if self.kind == "image":
+            if self.dtype != "uint8":
+                raise ValueError(f"{label}: image dtype must be uint8 RGB NHWC, got {self.dtype!r}.")
+            if len(self.shape) != 3 or self.shape[-1] != 3:
+                raise ValueError(f"{label}: image shape must be (H, W, 3) RGB NHWC, excluding batch, got {self.shape}.")
+            if not isinstance(self.camera, str) or not self.camera.strip():
+                raise ValueError(f"{label}: image inputs require a camera identity.")
+            if "/" in self.camera or self.camera != self.camera.strip():
+                raise ValueError(f"{label}: camera must be a scene name, the last segment of scene.add(..., at=...).")
+        elif self.dtype != "float32" or self.camera is not None or self.preprocessing != "none":
+            raise ValueError(f"{label}: numeric inputs require float32, no camera, and preprocessing='none'.")
+
+    def to_dict(self) -> dict[str, Any]:
+        """Return JSON metadata, converting the stored tuple shape to a list."""
+        return {**asdict(self), "shape": list(self.shape)}
+
+    @classmethod
+    def from_dict(cls, value: Mapping[str, Any]) -> PolicyInput:
+        """Parse JSON, converting list shapes to tuples; reject unknown fields."""
+        if not isinstance(value, Mapping):
+            raise ValueError("Input declaration must be an object.")
+        allowed = {"name", "shape", "dtype", "kind", "camera", "preprocessing"}
+        if set(value) - allowed or not {"name", "shape"} <= set(value):
+            raise ValueError(f"Input {value.get('name')!r}: declaration has missing or unknown fields.")
+        shape = value["shape"]
+        if not isinstance(shape, (list, tuple)):
+            raise ValueError(f"Input {value['name']!r}: shape must be an array of positive dimensions.")
+        return cls(**{**value, "shape": tuple(shape)})
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class PolicyInputSchema:
+    """Ordered actor inputs and optional separate training-only critic inputs.
+
+    ``critic=None`` means the critic uses exactly the actor declarations.
+    Future export and playback consumers must use only ``actor``. A critic
+    declaration sharing an actor name must be identical. Actor inputs omitted
+    from an explicit critic are not supplied to that critic. Order is part of
+    checkpoint compatibility, including numeric concatenation order.
+    """
+
+    actor: tuple[PolicyInput, ...]
+    critic: tuple[PolicyInput, ...] | None = None
+
+    def __post_init__(self) -> None:
+        for role, inputs in (("actor", self.actor), ("critic", self.critic_inputs)):
+            if not isinstance(inputs, tuple) or not inputs:
+                raise ValueError(f"{role} inputs must be a nonempty tuple of PolicyInput declarations.")
+            seen: set[str] = set()
+            for spec in inputs:
+                if not isinstance(spec, PolicyInput):
+                    raise ValueError(f"{role} inputs must contain PolicyInput declarations.")
+                if spec.name in seen:
+                    raise ValueError(f"{role} input {spec.name!r}: duplicate input name.")
+                seen.add(spec.name)
+        actor = {spec.name: spec for spec in self.actor}
+        for spec in self.critic_inputs:
+            if spec.name in actor and spec != actor[spec.name]:
+                raise ValueError(
+                    f"critic input {spec.name!r}: declaration contradicts the actor input of the same name."
+                )
+
+    @property
+    def critic_inputs(self) -> tuple[PolicyInput, ...]:
+        """Effective critic declarations, defaulting to actor inputs."""
+        return self.actor if self.critic is None else self.critic
+
+    def to_dict(self) -> dict[str, Any]:
+        """Return the actor/critic schema for a checkpoint sidecar."""
+        return {
+            "actor": [spec.to_dict() for spec in self.actor],
+            "critic": None if self.critic is None else [spec.to_dict() for spec in self.critic],
+        }
+
+    @classmethod
+    def from_dict(cls, value: Mapping[str, Any]) -> PolicyInputSchema:
+        """Parse a schema without permitting undeclared metadata."""
+        if not isinstance(value, Mapping) or set(value) != {"actor", "critic"}:
+            raise ValueError("Policy input schema requires exactly actor and critic fields.")
+        actor, critic = value["actor"], value["critic"]
+        if not isinstance(actor, (list, tuple)) or (critic is not None and not isinstance(critic, (list, tuple))):
+            raise ValueError("Policy input schema actor and critic must be arrays (critic may be null).")
+        return cls(
+            actor=tuple(PolicyInput.from_dict(spec) for spec in actor),
+            critic=None if critic is None else tuple(PolicyInput.from_dict(spec) for spec in critic),
+        )
+
+    @property
+    def fingerprint(self) -> str:
+        """SHA-256 of ordered inputs, including camera and preprocessing.
+
+        An omitted critic and an explicitly identical critic are equivalent.
+        Batch size is absent, so a checkpoint can change parallelism.
+        """
+
+        def canonical(spec: PolicyInput) -> dict[str, Any]:
+            # Pin v1's subset: future defaulted fields do not invalidate hashes.
+            return {name: getattr(spec, name) for name in ("name", "shape", "dtype", "kind", "camera", "preprocessing")}
+
+        metadata = {
+            "version": "simulo.policy-input-fingerprint.v1",
+            "actor": [canonical(spec) for spec in self.actor],
+            "critic": [canonical(spec) for spec in self.critic_inputs],
+        }
+        return hashlib.sha256(json.dumps(metadata, sort_keys=True, separators=(",", ":")).encode()).hexdigest()
+
+    def validate_values(
+        self,
+        actor: Any,
+        critic: Any,
+        *,
+        batch_size: int | None = None,
+    ) -> None:
+        """Check raw names, shapes, dtypes and batch size at LearningEnv._init_spaces.
+
+        Values need only ``shape`` and ``dtype`` attributes. No engine or tensor
+        package is imported. One declared numeric input may use the legacy
+        tensor return; multiple or image inputs require a named mapping. Values
+        must have a leading num_envs batch. Failures raise ValueError naming the
+        role and input. Legacy tasks with no schema are not checked by setup.
+        """
+        expected_batch = batch_size
+        for role, specs, values in (("actor", self.actor, actor), ("critic", self.critic_inputs, critic)):
+            if not isinstance(values, Mapping):
+                if len(specs) != 1 or specs[0].kind != "numeric":
+                    raise ValueError(f"{role} input {specs[0].name!r}: named inputs require a mapping.")
+                values = {specs[0].name: values}
+            declared = {spec.name for spec in specs}
+            for name in values:
+                if name not in declared:
+                    raise ValueError(f"{role} input {name!r}: unknown input name.")
+            for spec in specs:
+                if spec.name not in values:
+                    raise ValueError(f"{role} input {spec.name!r}: missing input.")
+                value = values[spec.name]
+                shape = tuple(getattr(value, "shape", ()))
+                if (
+                    len(shape) != len(spec.shape) + 1
+                    or shape[1:] != spec.shape
+                    or type(shape[0]) is not int
+                    or shape[0] <= 0
+                ):
+                    raise ValueError(
+                        f"{role} input {spec.name!r}: expected batched shape (N, {spec.shape}), got {shape}."
+                    )
+                if expected_batch is None:
+                    expected_batch = shape[0]
+                if shape[0] != expected_batch:
+                    raise ValueError(f"{role} input {spec.name!r}: expected batch {expected_batch}, got {shape[0]}.")
+                dtype = str(getattr(value, "dtype", "")).removeprefix("torch.")
+                if dtype != spec.dtype:
+                    raise ValueError(f"{role} input {spec.name!r}: expected dtype {spec.dtype}, got {dtype!r}.")

{simulo_interfaces-0.23.0 → simulo_interfaces-0.24.0}/src/simulo/interfaces/authoring/prop.py

@@ -154,15 +154,21 @@ class PropProtocol(Protocol):
 
     @property
     def default_pose(self) -> TensorLike:
-        """The prop's spawn pose in the **world** frame, ``(num_envs, 7)``.
+        """The prop's spawn pose in the **world** frame.
 
-        The pose the prop was authored at, already offset by each
-        environment's own origin — so it is directly comparable with
-        ``state.pose`` and directly usable as the base for a randomised
-        reset. Index it with the environments being reset
-        (``prop.default_pose[env_ids]``), perturb, and write it back with
+        For a prop added with ``per_environment=True`` (the default), the pose
+        has shape ``(num_envs, 7)`` and includes each environment's origin, so
+        it is directly comparable with ``state.pose`` and directly usable as
+        the base for a randomised reset. Index it with the environments being
+        reset (``prop.default_pose[env_ids]``), perturb, and write it back with
         :meth:`set_pose`.
 
+        For a prop added with ``per_environment=False``, this is one row
+        containing its authored world pose with no environment origin. A
+        shared prop is supported only when the scene has one environment;
+        scene building refuses ``per_environment=False`` for a prop when
+        ``num_envs > 1``.
+
         Raises ``RuntimeError`` until the simulation runtime has attached the
         prop.
         """

{simulo_interfaces-0.23.0 → simulo_interfaces-0.24.0}/src/simulo/interfaces/authoring/record.py

@@ -195,6 +195,11 @@ class RecordConfig:
     profile precedence can distinguish "user passed False" from "default
     None". Do not edit defaults to plain ``bool`` — the silent-default
     mitigation depends on the tri-state.
+
+    ``record_all_envs`` expands numeric recording data only. Policy camera
+    video always uses ``env_indices`` (default: environment 0), so host frame
+    buffers and encoder count are bounded by the selected environments and
+    declared cameras, independently of the total environment count.
     """
 
     output_path: Optional[Union[str, "os.PathLike[str]", Path]] = None

{simulo_interfaces-0.23.0 → simulo_interfaces-0.24.0}/src/simulo/interfaces/authoring/robot.py

@@ -64,6 +64,7 @@ from typing import Any, Dict, List, Optional, Protocol, Tuple, runtime_checkable
 
 from simulo.interfaces.authoring.asset import AssetSource
 from simulo.interfaces.authoring.pose import Pose
+from simulo.interfaces.authoring.robot_config import ArticulationConfig, JointConfig
 from simulo.interfaces.runtime.tensors import TensorLike
 
 
@@ -183,17 +184,21 @@ class RobotProtocol(Protocol):
     scale: Tuple[float, float, float]
     """Per-axis spawn scale factor."""
 
-    articulation: Any
+    articulation: ArticulationConfig
     """Articulation physics and control configuration."""
 
-    joint_config: Optional[List[Any]]
+    joint_config: Optional[List[JointConfig]]
     """Optional per-joint configurations."""
 
     disable_gravity: bool
     """If ``True``, gravity is disabled for this robot."""
 
     actuator_gains: Optional[Dict[str, Any]]
-    """Optional mapping of actuator-group names to gain configurations."""
+    """Optional mapping of actuator-group names to gain configurations.
+
+    Catalog robots support only the ``"all_joints"`` key; other keys are ignored
+    with a warning.
+    """
 
     # -- Identity and attachment ------------------------------------------
 
@@ -257,12 +262,19 @@ class RobotProtocol(Protocol):
 
     @property
     def default_pose(self) -> TensorLike:
-        """Base pose that :meth:`reset` writes in the world frame, shape
-        ``(num_envs, 7)`` with columns ``[x, y, z, qw, qx, qy, qz]``:
-        position in m followed by a w-first unit quaternion. Each
-        environment's origin is included. Available from ``on_start``
-        onward. Each read returns a new tensor, so writing into it cannot
-        change a later reset."""
+        """Base pose that :meth:`reset` writes in the world frame.
+
+        Columns are ``[x, y, z, qw, qx, qy, qz]``: position in m followed by a
+        w-first unit quaternion. For a robot added with
+        ``per_environment=True`` (the default), the shape is ``(num_envs, 7)``
+        and each environment's origin is included. For a robot added with
+        ``per_environment=False``, this is one row containing its authored
+        world pose with no environment origin. A shared robot is supported
+        only when the scene has one environment; scene building refuses
+        ``per_environment=False`` for a robot when ``num_envs > 1``. Available
+        from ``on_start`` onward. Each read returns a new tensor, so writing
+        into it cannot change a later reset.
+        """
         ...
 
     @property

simulo_interfaces-0.24.0/src/simulo/interfaces/authoring/robot_config.py

@@ -0,0 +1,82 @@
+"""Dependency-free robot physics and joint-control configuration."""
+
+from dataclasses import dataclass
+from typing import List, Optional, Tuple
+
+
+@dataclass
+class ActuatorGainsConfig:
+    """Configuration for an actuator group.
+
+    Actuators control named groups of joints.
+    Use this to configure control properties per actuator group.
+
+    Attributes:
+        stiffness: Position gain (P in PD control). Set to 0 for effort control.
+        damping: Velocity gain (D in PD control). Set to 0 for effort control.
+    """
+
+    stiffness: float = 0.0
+    damping: float = 0.0
+
+
+@dataclass
+class JointConfig:
+    """Configuration for a single joint.
+
+    Stored-USD robots receive force drives on drive-less joints. Only non-None
+    gains and limits override existing values; zero is an explicit override.
+
+    Attributes:
+        name: Joint name
+        type: Joint type (revolute, prismatic, fixed, etc.)
+        limits: (lower, upper) position limits in radians or meters
+        effort_limit: Maximum torque/force in N·m or N. Stored USD joints use
+            this value when non-None; otherwise they keep the USD/PhysX limit.
+            Only newly created drives get a finite fallback of 1000.
+        velocity_limit: Maximum velocity in rad/s or m/s. Stored USD joints use
+            this value when non-None; otherwise they keep the USD/PhysX limit.
+            Only newly created drives get a finite fallback of 100.
+        damping: Velocity gain; None keeps task actuator_gains or USD gains.
+        stiffness: Position gain; None keeps task actuator_gains or USD gains.
+        armature: Armature inertia; not applied by the stored-USD builder.
+    """
+
+    name: str = ""
+    type: str = "revolute"
+    limits: Optional[Tuple[float, float]] = None
+    effort_limit: Optional[float] = None
+    velocity_limit: Optional[float] = None
+    damping: Optional[float] = None
+    stiffness: Optional[float] = None
+    armature: float = 0.0
+
+
+@dataclass
+class ArticulationConfig:
+    """Configuration for robot articulation physics and control.
+
+    For stored USDs, only non-None solver, self-collision and root-fixing
+    settings override USD-authored values or PhysX defaults. Declaring joint
+    defaults alone leaves those physics settings intact. Sleep and stabilization
+    thresholds are not applied by the stored-USD builder.
+
+    Attributes:
+        solver_position_iterations: Position solver iteration count
+        solver_velocity_iterations: Velocity solver iteration count
+        sleep_threshold: Velocity threshold for sleep
+        stabilization_threshold: Stabilization threshold
+        enable_self_collision: Whether to enable self-collision
+        default_joint_positions: Default joint positions (rad or m)
+        default_joint_velocities: Default joint velocities (rad/s or m/s)
+        fix_root_link: Whether to create a fixed joint from the root link to the world
+    """
+
+    solver_position_iterations: Optional[int] = None
+    solver_velocity_iterations: Optional[int] = None
+    sleep_threshold: float = 0.005
+    stabilization_threshold: float = 0.001
+    enable_self_collision: Optional[bool] = None
+    default_joint_positions: Optional[List[float]] = None
+    default_joint_velocities: Optional[List[float]] = None
+    fix_root_link: Optional[bool] = None

{simulo_interfaces-0.23.0 → simulo_interfaces-0.24.0}/src/simulo/interfaces/authoring/scene.py

@@ -77,6 +77,9 @@ class SceneGroupProtocol(Protocol):
 
         ``per_environment=True`` (the default) clones the item per environment
         when the scene has more than one environment.
+        Shared robots and props are supported only when the scene has one
+        environment. Transform children are not replicated; add robots and
+        props directly to a multi-environment scene.
         """
         ...
 
@@ -116,7 +119,9 @@ class SceneProtocol(Protocol):
 
         ``per_environment=True`` (the default) clones the item per environment
         when ``num_envs > 1``; pass ``per_environment=False`` for shared items
-        like ground planes and global lights.
+        like ground planes and global lights. Shared robots and props are
+        supported only when ``num_envs == 1``. Transform children are not
+        replicated; add robots and props directly to a multi-environment scene.
         """
         ...
 

{simulo_interfaces-0.23.0 → simulo_interfaces-0.24.0}/src/simulo/interfaces/authoring/sensor.py

@@ -32,7 +32,7 @@ documented-omissions allowlist):
   implementation; giving them contract homes is a later, separate decision.
 """
 
-from typing import Any, List, Optional, Protocol, runtime_checkable
+from typing import Any, List, Literal, Optional, Protocol, runtime_checkable
 
 from simulo.interfaces.runtime.tensors import TensorLike
 
@@ -88,6 +88,14 @@ class CameraProtocol(SensorProtocol, Protocol):
     height: int
     """Image height in pixels."""
 
+    purpose: Literal["observer", "policy"]
+    """Camera label, default "observer"; only "observer" and "policy" are valid.
+
+    Construction rejects other values with ValueError. LearningEnv setup
+    requires "policy" for declared image cameras. Rendering and recording
+    consumers are implemented in later milestones.
+    """
+
     data_types: List[str]
     """Data types to capture (e.g. ``"rgb"``, ``"depth"``, ``"normals"``,
     ``"semantic"``)."""

{simulo_interfaces-0.23.0 → simulo_interfaces-0.24.0}/src/simulo/interfaces/platform/asset_catalog.py

@@ -695,7 +695,7 @@ ASSET_NOT_FOUND_CODE = "asset_not_found"
 # plane); this docstring is the drift anchor for a future reconciliation
 # where the control plane imports these directly instead of re-declaring
 # them. The thin client's `simulo asset publish`/`validate` error
-# rendering (`_client/cli.py::_friendly_asset_error`) matches these exact
+# rendering (`_client/commands/assets.py::_friendly_asset_error`) matches these exact
 # strings, never a hand-typed literal.
 # --------------------------------------------------------------------------
 
@@ -727,7 +727,7 @@ ASSET_UPLOAD_INCOMPLETE_CODE = "asset_upload_incomplete"
 # "mirrored, not imported" precedent above), so this is a value-only
 # duplication, drift-anchored by this docstring. The thin client's
 # `simulo asset get`/`deprecate`/`delete` error rendering
-# (`_client/cli.py::_friendly_asset_error`) matches these exact strings so
+# (`_client/commands/assets.py::_friendly_asset_error`) matches these exact strings so
 # the server's already user-language message renders verbatim, never a
 # code-prefixed wire dump.
 # --------------------------------------------------------------------------

{simulo_interfaces-0.23.0 → simulo_interfaces-0.24.0}/src/simulo/interfaces/platform/evaluation.py

@@ -4,9 +4,10 @@ An eval job runs a trained checkpoint on numbered episodes and judges each
 one with the eval file's ``@app.success`` function. The runtime returns the
 report as a plain ``dict`` of :class:`EvaluationReport` shape and registers it
 as a ``report`` output; the client renders it, the Console reads it from the
-job result, and the control plane checks its schema version. Every episode's
-detail goes in ``episodes.csv`` (:func:`episodes_csv_columns`), so the report
-stays small whatever the episode count.
+job result, and the control plane validates it before accepting completion.
+Every episode's detail goes in ``episodes.csv``
+(:func:`episodes_csv_columns`), so the report stays small whatever the episode
+count.
 
 The comparison block (``--compare``) is part of v1 from the start, so comparing
 two checkpoints never needs a new schema version. Additive-only: a breaking
@@ -300,6 +301,11 @@ class EvaluationComparison(TypedDict):
     """The ``--compare`` checkpoint."""
     compared_result: EvaluationResult
     """The ``--compare`` checkpoint's own RESULT."""
+    task_changed: NotRequired[bool]
+    """Whether the evaluation task differs from the ``--compare`` checkpoint's training task.
+
+    Omitted by reports written before this additive v1 field existed.
+    """
     improved: int
     """Episodes that failed with ``compared_with`` and succeeded with the ``--policy`` checkpoint."""
     regressed: int