lucen-cli 0.1.3__tar.gz → 0.1.4__tar.gz

{lucen_cli-0.1.3 → lucen_cli-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lucen-cli
-Version: 0.1.3
+Version: 0.1.4
 Summary: MouseMouse CLI (`lucen`): push robot data, train and sim-test policies, hand them to a robot through a consent gate
 License-Expression: Apache-2.0
 License-File: LICENSE

{lucen_cli-0.1.3 → lucen_cli-0.1.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lucen-cli"
-version = "0.1.3"
+version = "0.1.4"
 description = "MouseMouse CLI (`lucen`): push robot data, train and sim-test policies, hand them to a robot through a consent gate"
 # R1: `readme`, `license`, `license-files` and `[project.urls]` are what PyPI
 # renders; the LICENSE beside this file is Apache-2.0 verbatim (docs/DECISIONS.md "R1").

{lucen_cli-0.1.3 → lucen_cli-0.1.4}/src/lucen_cli/__init__.py

@@ -1,3 +1,3 @@
 """MouseMouse CLI."""
 
-__version__ = "0.1.3"
+__version__ = "0.1.4"

{lucen_cli-0.1.3 → lucen_cli-0.1.4}/src/lucen_cli/client.py

@@ -63,6 +63,7 @@ from lucen_sdk.api.files import (
 from lucen_sdk.api.files import (
     presign_upload as presign_upload_api,
 )
+from lucen_sdk.api.meta import get_capabilities as get_capabilities_api
 from lucen_sdk.api.meta import healthz as healthz_api
 from lucen_sdk.api.models import put_model_meta as put_model_meta_api
 from lucen_sdk.api.orgs import create_org as create_org_api
@@ -656,6 +657,22 @@ class HubClient:
         response = healthz_api.sync_detailed(client=self._sdk)
         return self._expect(response, HealthResponse, action="Reaching the hub")
 
+    def studio_stills(self) -> str:
+        """S2: `getCapabilities.studio_stills` — `hosted` | `local` | `none`.
+
+        `none` for a hub that predates the field, or one that cannot be asked:
+        the publisher then draws its own still, as before.
+        """
+        try:
+            response = get_capabilities_api.sync_detailed(client=self._sdk)
+        except Exception:  # a still is never worth failing a publish over
+            return "none"
+        parsed = response.parsed if int(response.status_code) == 200 else None
+        value = getattr(parsed, "studio_stills", None)
+        if value is None or isinstance(value, Unset):
+            return "none"
+        return str(getattr(value, "value", value))
+
     def overview(self) -> MyOverview:
         """`GET /v1/me/overview` (UI-API): what is yours right now, in counts (`key:read`)."""
         response = get_my_overview_api.sync_detailed(client=self._sdk)

{lucen_cli-0.1.3 → lucen_cli-0.1.4}/src/lucen_cli/cmd_model.py

@@ -165,7 +165,7 @@ def stamp(
     stdout.print(
         f"  contract                obs {contract['obs_dim']} = "
         f"{' + '.join(b['name'] for b in contract['obs_spec'])}; action "
-        f"{contract['action_dim']} ({contract['action_semantics']}); "
+        f"{contract['action_dim']} ({_semantics_line(contract)}); "
         f"{contract['control_rate_hz']:g} Hz; control_class {manifest['control_class']}"
     )
     if unchecked:
@@ -173,3 +173,14 @@ def stamp(
             f"  [yellow]not checked[/yellow]            the ONNX's {' and '.join(unchecked)} "
             "width is symbolic, so it could not be compared with the contract"
         )
+
+
+def _semantics_line(contract: dict[str, Any]) -> str:
+    """`position_offset`, or `mixed: 8 position_offset, 2 torque` (T2)."""
+    layout = contract.get("action_semantics_vec")
+    if not isinstance(layout, list):
+        return str(contract["action_semantics"])
+    counts: dict[str, int] = {}
+    for semantics in layout:
+        counts[str(semantics)] = counts.get(str(semantics), 0) + 1
+    return f"{contract['action_semantics']}: " + ", ".join(f"{n} {s}" for s, n in counts.items())

{lucen_cli-0.1.3 → lucen_cli-0.1.4}/src/lucen_cli/cmd_robot.py

@@ -795,7 +795,9 @@ def card_get(
         card = get_card(client, RepoTarget.parse(repo))
     if output is not None and not as_json:
         editable = {
-            k: v for k, v in card.items() if k not in ("interface_fingerprint", "updated_at")
+            k: v
+            for k, v in card.items()
+            if k not in ("interface_fingerprint", "updated_at", "stills")
         }
         output.write_text(
             json.dumps(editable, indent=2, ensure_ascii=False) + "\n", encoding="utf-8"
@@ -831,7 +833,7 @@ def card_set(
             f"{file} must hold a JSON object.",
             hint="`lucen robot card get OWNER/SLUG -o card.json` writes one in the right shape.",
         )
-    for key in ("needs_you", "interface_fingerprint", "updated_at"):
+    for key in ("needs_you", "interface_fingerprint", "updated_at", "stills"):
         card.pop(key, None)
     target = RepoTarget.parse(repo)
     try:

{lucen_cli-0.1.3 → lucen_cli-0.1.4}/src/lucen_cli/contract_derive.py

@@ -56,6 +56,25 @@ class DeriveError(ValueError):
     """The requested contract cannot be derived from this interface."""
 
 
+def spinning_joints(emb: Embodiment, card: dict[str, Any] | None) -> list[bool]:
+    """Per joint: is it a wheel, as far as a policy is concerned? (T2)
+
+    A joint whose action is a speed or a torque, and which the card gives no
+    `lower`/`upper` range, turns without bound. Its angle carries nothing a
+    policy can use and grows for as long as the robot drives, so the derived
+    contract observes it at scale 0 (the `joint_pos` value is dropped, the
+    `joint_vel` one kept), and the trainer leaves it out of the pose and
+    symmetry terms. Read from the interface and the card only, so the gate,
+    the browser and a deployed runtime reach the same answer from the contract.
+    """
+    limits = card_limits(card, emb.joint_order)
+    position = emb.position_driven
+    return [
+        not position[k] and limits["lower"][k] is None and limits["upper"][k] is None
+        for k in range(emb.dof)
+    ]
+
+
 def _block(name: str) -> tuple[int | None, float | tuple[float, ...], str, str | None]:
     canonical = ALIASES.get(name, name)
     if canonical not in OBS_BLOCKS:
@@ -70,13 +89,17 @@ def obs_spec_for(
     emb: Embodiment,
     blocks: list[str],
     scales: dict[str, float | list[float]] | None = None,
+    *,
+    spinning: list[bool] | None = None,
 ) -> list[dict[str, Any]]:
     """`[{name, dim, scale}]` — and the subset rule, enforced at derivation time.
 
     A `sensor` block the robot does not list under `proprioception` is refused
     here, before a policy is trained on a signal the real robot cannot supply.
     An interface that declares no proprioception at all makes no claim, so
-    there is nothing to check it against.
+    there is nothing to check it against. `spinning` (T2,
+    :func:`spinning_joints`) zeroes those joints' `joint_pos` scales after the
+    caller's scales are checked.
     """
     if not blocks:
         raise DeriveError("a contract needs at least one observation block")
@@ -100,6 +123,8 @@ def obs_spec_for(
             values = [float(raw)] * dim
         if any(v <= 0 for v in values):
             raise DeriveError(f"block `{name}`: scales must be positive")
+        if spinning and ALIASES.get(name, name) == "joint_pos":
+            values = [0.0 if spinning[k] else v for k, v in enumerate(values)]
         spec.append({"name": name, "dim": dim, "scale": values})
     if blind:
         raise DeriveError(
@@ -132,7 +157,8 @@ def derive_contract(
     n = emb.dof
     if len(default_pose) != n:
         raise DeriveError(f"default_pose has {len(default_pose)} entries for {n} joints")
-    spec = obs_spec_for(emb, blocks, scales)
+    spinning = spinning_joints(emb, card)
+    spec = obs_spec_for(emb, blocks, scales, spinning=spinning)
     if any(b["name"] == "gait_phase" for b in spec) and cycle_time_s is None:
         raise DeriveError("the `gait_phase` block needs `cycle_time_s`")
     contract: dict[str, Any] = {
@@ -151,6 +177,17 @@ def derive_contract(
         "base": emb.base,
         "command_space": emb.canonical["command_space"],
     }
+    if emb.per_group_action:
+        # T2: the layout itself, so a stamped policy carries how each output is
+        # read (the gate, the browser and a robot's runtime read these first).
+        contract["action_semantics_vec"] = list(emb.semantics)
+        contract["action_clip_vec"] = [
+            float(c) if c is not None else contract["action_clip"] for c in emb.clip
+        ]
+    if any(spinning):
+        contract["spinning_joints"] = [
+            j for j, s in zip(emb.joint_order, spinning, strict=True) if s
+        ]
     if emb.physics_dt_s is not None:
         contract["physics_dt_s"] = float(emb.physics_dt_s)
     if emb.init_base_height_m is not None:
@@ -397,11 +434,20 @@ def contract_checks(manifest: dict[str, Any], card: dict[str, Any]) -> list[dict
 
     action: list[dict[str, Any]] = []
     said: list[str] = []
-    checks = (
+    checks: tuple[tuple[str, Any, str], ...] = (
         ("action_semantics", emb.action_semantics, "{p} actions, the robot says {r}"),
         ("action_dim", emb.dof, "{p} actions, the robot drives {r}"),
         ("action_scale_vec", [float(v) for v in emb.action_scale], "scale {p}, the robot says {r}"),
     )
+    if emb.per_group_action or contract.get("action_semantics_vec") is not None:
+        checks = (
+            *checks,
+            (
+                "action_semantics_vec",
+                list(emb.semantics),
+                "per-joint actions {p}, the robot says {r}",
+            ),
+        )
     for key, robot_value, sentence in checks:
         policy_value = contract.get(key)
         if policy_value is not None and not _same(policy_value, robot_value):
@@ -487,5 +533,6 @@ __all__ = [
     "derive_plant",
     "obs_spec_for",
     "pose_without_model",
+    "spinning_joints",
     "stamp_manifest",
 ]

{lucen_cli-0.1.3 → lucen_cli-0.1.4}/src/lucen_cli/embodiment.py

@@ -17,7 +17,15 @@ Two jobs:
   A cross-package test pins the two implementations together.
 * :class:`Embodiment` flattens the declaration into what a control loop
   needs: per-joint vectors in `joint_order` (default pose, gains, limits,
-  action scale), never a dict a caller has to re-walk.
+  action semantics / scale / clip), never a dict a caller has to re-walk.
+
+T2 — mixed drive modes. An actuation group may carry its own `action`
+(`{semantics, scale, clip}`): the component of the action vector for one of
+its joints is read by the group's action, else by the top-level one. That is
+how a wheeled-legged robot declares position servos on its legs and velocity
+or torque motors on its wheels in one vector. :func:`action_layout` is the
+one place that resolves it, and the one place that refuses a joint whose
+action does not fit how its group drives it.
 """
 
 from __future__ import annotations
@@ -42,6 +50,10 @@ MODE_FOR_SEMANTICS = {
 }
 
 
+#: The semantics :attr:`Embodiment.action_semantics` reports when the joints do not share one.
+MIXED = "mixed"
+
+
 class InterfaceError(ValueError):
     """The interface is not one this code can read. The message names the field."""
 
@@ -116,8 +128,27 @@ _ACTUATION_FLOATS = (
 )
 
 
+def _semantics(value: Any, where: str) -> str:
+    semantics = _str(value, where)
+    if semantics not in ACTION_SEMANTICS:
+        raise InterfaceError(f"{where} {semantics!r} is not one of {', '.join(ACTION_SEMANTICS)}")
+    return semantics
+
+
+def _group_action(raw: Any, where: str) -> dict[str, Any]:
+    """`EmbodimentGroupAction`: semantics, scale (default 1), clip — T2."""
+    src = _object(raw, where, {"semantics", "scale", "clip"})
+    out: dict[str, Any] = {
+        "semantics": _semantics(src.get("semantics"), f"{where}.semantics"),
+        "scale": _float(src.get("scale", 1.0), f"{where}.scale"),
+    }
+    if src.get("clip") is not None:
+        out["clip"] = _float(src["clip"], f"{where}.clip")
+    return out
+
+
 def _actuation(raw: Any, where: str) -> dict[str, Any]:
-    src = _object(raw, where, {"joints", "mode", *_ACTUATION_FLOATS})
+    src = _object(raw, where, {"joints", "mode", "action", *_ACTUATION_FLOATS})
     out: dict[str, Any] = {"joints": _str_list(src.get("joints"), f"{where}.joints")}
     mode = _str(src.get("mode", "position"), f"{where}.mode")
     if mode not in ACTUATION_MODES:
@@ -126,16 +157,14 @@ def _actuation(raw: Any, where: str) -> dict[str, Any]:
     for key in _ACTUATION_FLOATS:
         if src.get(key) is not None:
             out[key] = _float(src[key], f"{where}.{key}")
+    if src.get("action") is not None:
+        out["action"] = _group_action(src["action"], f"{where}.action")
     return out
 
 
 def _action(raw: Any) -> dict[str, Any]:
     src = _object(raw, "action", {"semantics", "scale", "scale_per_joint", "clip"})
-    semantics = _str(src.get("semantics"), "action.semantics")
-    if semantics not in ACTION_SEMANTICS:
-        raise InterfaceError(
-            f"action.semantics {semantics!r} is not one of {', '.join(ACTION_SEMANTICS)}"
-        )
+    semantics = _semantics(src.get("semantics"), "action.semantics")
     out: dict[str, Any] = {
         "semantics": semantics,
         "scale": _float(src.get("scale", 1.0), "action.scale"),
@@ -328,6 +357,121 @@ def fingerprint(interface: dict[str, Any]) -> str:
     return hashlib.sha256(canonical_json(canonical_interface(interface))).hexdigest()
 
 
+# ---------------------------------------------------------------------------
+# T2: the action vector, per actuation group
+# ---------------------------------------------------------------------------
+
+
+@dataclass(frozen=True)
+class ActionLayout:
+    """How each component of the action vector is read, in `joint_order`.
+
+    `group[k]` is the index of the actuation group driving joint k (None when
+    no group drives it); `source[k]` says whose `action` the joint follows:
+    `actuation[i].action` or the top-level `action`.
+    """
+
+    semantics: tuple[str, ...]
+    scale: tuple[float, ...]
+    clip: tuple[float | None, ...]
+    mode: tuple[str, ...]
+    group: tuple[int | None, ...]
+    source: tuple[str, ...]
+    #: True when any group declares its own `action`.
+    per_group: bool
+    #: `(group index, joints, sentence)` per group whose actions do not fit its drive.
+    problems: tuple[tuple[int, tuple[str, ...], str], ...]
+
+
+def action_layout(canonical: dict[str, Any]) -> ActionLayout:
+    """Resolve every joint's action through its group, and say what does not fit.
+
+    The rule (docs/API.md, "Embodiment interface"): a joint in a group that
+    declares an `action` is read by that action; every other joint by the
+    top-level `action` (with its `scale_per_joint`). A `position` group takes
+    `position_offset` or `position_absolute`, a `velocity` group `velocity`, a
+    `torque` group `torque`. A joint no group drives is driven in the mode its
+    action needs. `scale_per_joint` may not name a joint whose group has its
+    own action: the two scales would be in different units.
+
+    The hub applies the same rule in `lucen_api.robot_validation`
+    (`interface.actuation`); a cross-package test holds the two together.
+    """
+    joints: list[str] = canonical["joint_order"]
+    n = len(joints)
+    index = {name: k for k, name in enumerate(joints)}
+    top = canonical["action"]
+    scale_map: dict[str, float] = top.get("scale_per_joint") or {}
+    group_of: list[int | None] = [None] * n
+    mode = ["position"] * n
+    for gi, group in enumerate(canonical["actuation"]):
+        for name in group["joints"]:
+            group_of[index[name]] = gi
+            mode[index[name]] = group["mode"]
+    semantics: list[str] = []
+    scale: list[float] = []
+    clip: list[float | None] = []
+    source: list[str] = []
+    for k, name in enumerate(joints):
+        driver = group_of[k]
+        own = canonical["actuation"][driver].get("action") if driver is not None else None
+        chosen = own if own is not None else top
+        semantics.append(str(chosen["semantics"]))
+        clip.append(None if chosen.get("clip") is None else float(chosen["clip"]))
+        if own is not None:
+            scale.append(float(own["scale"]))
+            source.append(f"actuation[{driver}].action")
+        else:
+            scale.append(float(scale_map.get(name, top["scale"])))
+            source.append("action")
+        if driver is None:
+            mode[k] = MODE_FOR_SEMANTICS[semantics[k]]
+    problems: list[tuple[int, tuple[str, ...], str]] = []
+    for gi, group in enumerate(canonical["actuation"]):
+        members = tuple(group["joints"])
+        found = semantics[index[members[0]]]
+        if MODE_FOR_SEMANTICS[found] != group["mode"]:
+            names = ", ".join(members)
+            if group.get("action") is not None:
+                sentence = (
+                    f"actuation[{gi}] drives {names} in `{group['mode']}` mode, but its own "
+                    f"action is `{found}`; a `{group['mode']}` group takes "
+                    f"{_takes(group['mode'])}"
+                )
+            else:
+                sentence = (
+                    f"actuation[{gi}] drives {names} in `{group['mode']}` mode, but they follow "
+                    f"the top-level action, `{found}`, which needs `{MODE_FOR_SEMANTICS[found]}` "
+                    f"mode; change the top-level action, or give actuation[{gi}] its own "
+                    f"`action` with semantics {_takes(group['mode'])}"
+                )
+            problems.append((gi, members, sentence))
+        named = sorted(set(members) & set(scale_map))
+        if group.get("action") is not None and named:
+            problems.append(
+                (
+                    gi,
+                    tuple(named),
+                    f"action.scale_per_joint names {', '.join(named)}, whose group "
+                    f"actuation[{gi}] declares its own action; set the scale there",
+                )
+            )
+    return ActionLayout(
+        semantics=tuple(semantics),
+        scale=tuple(scale),
+        clip=tuple(clip),
+        mode=tuple(mode),
+        group=tuple(group_of),
+        source=tuple(source),
+        per_group=any(g.get("action") is not None for g in canonical["actuation"]),
+        problems=tuple(problems),
+    )
+
+
+def _takes(mode: str) -> str:
+    return " or ".join(f"`{s}`" for s, m in MODE_FOR_SEMANTICS.items() if m == mode)
+
+
 # ---------------------------------------------------------------------------
 # The flattened view a control loop reads
 # ---------------------------------------------------------------------------
@@ -367,8 +511,10 @@ class Embodiment:
     armature: tuple[float | None, ...]
     friction_loss: tuple[float | None, ...]
     driven: tuple[bool, ...]
+    #: The joints' shared semantics, or :data:`MIXED` when the groups differ.
     action_semantics: str
     action_scale: tuple[float, ...]
+    #: The top-level `action.clip`.
     action_clip: float | None
     proprioception: tuple[str, ...]
     end_effectors: tuple[EndEffector, ...]
@@ -377,11 +523,21 @@ class Embodiment:
     command_ranges: dict[str, tuple[float, float]]
     soft_limit_factor: float
     max_tilt_rad: float | None
+    #: T2: each joint's own semantics and clip (its group's action, else the top-level one).
+    semantics: tuple[str, ...] = ()
+    clip: tuple[float | None, ...] = ()
+    #: T2: True when any actuation group declares its own `action`.
+    per_group_action: bool = False
 
     @property
     def fixed_base(self) -> bool:
         return self.base == "fixed"
 
+    @property
+    def position_driven(self) -> tuple[bool, ...]:
+        """Per joint: does its action name a position target (offset or absolute)?"""
+        return tuple(s.startswith("position") for s in self.semantics)
+
     @property
     def dof(self) -> int:
         return len(self.joint_order)
@@ -409,29 +565,20 @@ class Embodiment:
             key: [None] * n
             for key in ("kp", "kd", "effort_limit", "velocity_limit", "armature", "friction_loss")
         }
-        mode = ["position"] * n
         driven = [False] * n
         for group in canonical["actuation"]:
             for name in group["joints"]:
                 k = index[name]
-                mode[k] = group["mode"]
                 driven[k] = True
                 for key, values in per_joint.items():
                     if key in group:
                         values[k] = float(group[key])
         action = canonical["action"]
-        semantics = str(action["semantics"])
-        needed = MODE_FOR_SEMANTICS[semantics]
-        wrong = [joints[k] for k in range(n) if driven[k] and mode[k] != needed]
-        if wrong:
-            raise InterfaceError(
-                f"action.semantics `{semantics}` needs `{needed}`-mode actuators, but "
-                f"{', '.join(wrong)} are driven in another mode"
-            )
-        if not any(driven):
-            mode = [needed] * n
-        scale_map = action.get("scale_per_joint") or {}
-        scale = tuple(float(scale_map.get(name, action["scale"])) for name in joints)
+        layout = action_layout(canonical)
+        if layout.problems:
+            raise InterfaceError("; ".join(sentence for _, _, sentence in layout.problems))
+        shared = set(layout.semantics)
+        semantics = shared.pop() if len(shared) == 1 else MIXED
         pose_map = canonical.get("default_pose")
         pose = (
             tuple(float(pose_map.get(name, 0.0)) for name in joints)
@@ -449,7 +596,7 @@ class Embodiment:
             init_base_height_m=canonical.get("init_base_height_m"),
             control_rate_hz=float(canonical["control_rate_hz"]),
             physics_dt_s=canonical.get("physics_dt_s"),
-            mode=tuple(mode),
+            mode=layout.mode,
             kp=tuple(per_joint["kp"]),
             kd=tuple(per_joint["kd"]),
             effort_limit=tuple(per_joint["effort_limit"]),
@@ -458,7 +605,7 @@ class Embodiment:
             friction_loss=tuple(per_joint["friction_loss"]),
             driven=tuple(driven),
             action_semantics=semantics,
-            action_scale=scale,
+            action_scale=layout.scale,
             action_clip=action.get("clip"),
             proprioception=tuple(canonical["proprioception"]),
             end_effectors=tuple(
@@ -477,6 +624,9 @@ class Embodiment:
             },
             soft_limit_factor=float(canonical["safety"]["soft_limit_factor"]),
             max_tilt_rad=canonical["safety"].get("max_tilt_rad"),
+            semantics=layout.semantics,
+            clip=layout.clip,
+            per_group_action=layout.per_group,
         )
 
     @classmethod
@@ -511,10 +661,13 @@ __all__ = [
     "ACTION_SEMANTICS",
     "ACTUATION_MODES",
     "INTERFACE_VERSION",
+    "MIXED",
     "MODE_FOR_SEMANTICS",
+    "ActionLayout",
     "Embodiment",
     "EndEffector",
     "InterfaceError",
+    "action_layout",
     "canonical_interface",
     "canonical_json",
     "card_limits",

{lucen_cli-0.1.3 → lucen_cli-0.1.4}/src/lucen_cli/model_card.py

@@ -304,6 +304,14 @@ def _vla_contract_table(contract: dict[str, Any]) -> str:
     return "| | |\n|---|---|\n" + _table(rows)
 
 
+_SEMANTICS_WORDS = {
+    "position_offset": "position offsets",
+    "position_absolute": "position targets",
+    "velocity": "speeds",
+    "torque": "torques",
+}
+
+
 def _reflex_contract_table(contract: dict[str, Any]) -> str:
     """The inputs and outputs of a stamped ONNX policy, in Q4's words."""
     blocks = contract.get("obs_spec") or []
@@ -324,6 +332,20 @@ def _reflex_contract_table(contract: dict[str, Any]) -> str:
     else:
         scale_text = ", ".join(_number(v) for v in scales)
     clip = contract.get("action_clip")
+    action = f"{contract.get('action_dim')} values, one per joint" + (
+        f", clipped to ±{_number(clip)}" if clip is not None else ""
+    )
+    layout = contract.get("action_semantics_vec")
+    clips = contract.get("action_clip_vec")
+    if isinstance(layout, list) and isinstance(clips, list) and len(layout) == len(clips):
+        # T2: a robot that mixes servos and wheel motors reads each part its own way.
+        parts: dict[tuple[str, float], int] = {}
+        for semantics, bound in zip(layout, clips, strict=True):
+            parts[(str(semantics), float(bound))] = parts.get((str(semantics), float(bound)), 0) + 1
+        action = f"{contract.get('action_dim')} values, one per joint: " + ", ".join(
+            f"{count} {_SEMANTICS_WORDS.get(semantics, semantics)} clipped to ±{_number(bound)}"
+            for (semantics, bound), count in parts.items()
+        )
     rows: list[tuple[str, Any]] = [
         (
             "Observation",
@@ -331,11 +353,7 @@ def _reflex_contract_table(contract: dict[str, Any]) -> str:
             if observation
             else contract.get("obs_dim"),
         ),
-        (
-            "Action",
-            f"{contract.get('action_dim')} values, one per joint"
-            + (f", clipped to ±{_number(clip)}" if clip is not None else ""),
-        ),
+        ("Action", action),
         ("Action scale", scale_text),
         (
             "Control rate",

{lucen_cli-0.1.3 → lucen_cli-0.1.4}/src/lucen_cli/rl/mirror.py

@@ -136,6 +136,8 @@ def build_mirror(
     scale = np.asarray(emb.action_scale, dtype=np.float64)
     if np.abs(scale[perm] - scale).max() > SYMMETRY_TOL:
         return None, "the action scale differs between a joint and its mirror twin"
+    if any(emb.semantics[k] != emb.semantics[int(perm[k])] for k in range(len(joints))):
+        return None, "a joint and its mirror twin read their actions differently"
     if emb.feet and len(emb.feet) != 2 and "gait_phase" in blocks:
         return None, (
             f"the gait clock mirrors by half a cycle only on two feet; this robot declares "

{lucen_cli-0.1.3 → lucen_cli-0.1.4}/src/lucen_cli/rl/ppo.py

@@ -125,7 +125,8 @@ class PPOConfig:
     epochs: int = 5
     minibatches: int = 4
     max_grad_norm: float = 1.0
-    init_log_std: float = 0.0
+    #: One value for every output, or one per output (T2: a wheel's is not a joint offset).
+    init_log_std: float | list[float] = 0.0
     seed: int = 0