devagent-physical-engine 0.12.1__tar.gz → 0.12.3__tar.gz

{devagent_physical_engine-0.12.1/src/devagent_physical_engine.egg-info → devagent_physical_engine-0.12.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devagent-physical-engine
-Version: 0.12.1
+Version: 0.12.3
 Summary: Verification-first agentic engineering, simulation, and evidence runtime for robotics and industrial automation.
 Author: Tom Ha
 License: All Rights Reserved
@@ -191,6 +191,10 @@ On a successful run, Gazebo / MoveIt remains open by default so the engineer can
 
 v0.12.1 hardens the initial ROS joint-state snapshot by parsing `ros2 topic echo --once` output as a YAML document stream. This accepts the normal ROS 2 trailing `---` message separator instead of incorrectly classifying an otherwise valid `/joint_states` sample as `joint_state_snapshot_invalid`.
 
+v0.12.2 additionally hardens Gazebo model-pose read-back across Harmonic CLI renderings. One shared parser now accepts both pipe-delimited and whitespace-delimited finite XYZ/RPY vectors and is used by initial world verification and dynamic workpiece pose read-back, so task simulation does not depend on a single human-readable `gz model --pose` delimiter style.
+
+v0.12.3 hardens MoveIt PlanningScene read-back when MoveIt serializes world collision objects in its own planning/root frame. A different observed frame is never trusted by label alone: DevAgent first proves the observed frame and canonical Twin frame are identity-equivalent through TF, then re-reads the scene and canonicalizes it back to the Twin planning frame before enforcing the exact geometry hash. Non-identity frames and geometry drift remain fail-closed.
+
 The packaged reference workcell is **not customer-site geometry**. Arbitrary plant layouts require an imported or user-declared physical Twin with trusted poses, collision geometry, tool/TCP information, and workpiece properties. DevAgent does not invent those site facts from a natural-language prompt.
 
 The v0.12 implementation remains evidence-gated: source/CI success does not prove the ROS target campaign has passed on a particular workstation. Use the executable qualification below before treating the task-specific path as qualified on that target.
@@ -418,7 +422,7 @@ Detailed engineering documentation lives in the repository:
 
 ## Project status
 
-**v0.12.1 — Beta software / evidence-gated task-specific physical simulation.**
+**v0.12.3 — Beta software / evidence-gated task-specific physical simulation.**
 
 The software and release pipeline are production-oriented, but physical readiness is scope-specific and evidence-driven. The UR5e task-specific reference-workcell path must pass the executable v0.12 ROS/Gazebo/MoveIt campaign on the target workstation before that scope is considered simulation-qualified there. Real robot execution remains locked. Functional-safety certification and site qualification are not claimed.
 

{devagent_physical_engine-0.12.1 → devagent_physical_engine-0.12.3}/README.md

@@ -150,6 +150,10 @@ On a successful run, Gazebo / MoveIt remains open by default so the engineer can
 
 v0.12.1 hardens the initial ROS joint-state snapshot by parsing `ros2 topic echo --once` output as a YAML document stream. This accepts the normal ROS 2 trailing `---` message separator instead of incorrectly classifying an otherwise valid `/joint_states` sample as `joint_state_snapshot_invalid`.
 
+v0.12.2 additionally hardens Gazebo model-pose read-back across Harmonic CLI renderings. One shared parser now accepts both pipe-delimited and whitespace-delimited finite XYZ/RPY vectors and is used by initial world verification and dynamic workpiece pose read-back, so task simulation does not depend on a single human-readable `gz model --pose` delimiter style.
+
+v0.12.3 hardens MoveIt PlanningScene read-back when MoveIt serializes world collision objects in its own planning/root frame. A different observed frame is never trusted by label alone: DevAgent first proves the observed frame and canonical Twin frame are identity-equivalent through TF, then re-reads the scene and canonicalizes it back to the Twin planning frame before enforcing the exact geometry hash. Non-identity frames and geometry drift remain fail-closed.
+
 The packaged reference workcell is **not customer-site geometry**. Arbitrary plant layouts require an imported or user-declared physical Twin with trusted poses, collision geometry, tool/TCP information, and workpiece properties. DevAgent does not invent those site facts from a natural-language prompt.
 
 The v0.12 implementation remains evidence-gated: source/CI success does not prove the ROS target campaign has passed on a particular workstation. Use the executable qualification below before treating the task-specific path as qualified on that target.
@@ -377,7 +381,7 @@ Detailed engineering documentation lives in the repository:
 
 ## Project status
 
-**v0.12.1 — Beta software / evidence-gated task-specific physical simulation.**
+**v0.12.3 — Beta software / evidence-gated task-specific physical simulation.**
 
 The software and release pipeline are production-oriented, but physical readiness is scope-specific and evidence-driven. The UR5e task-specific reference-workcell path must pass the executable v0.12 ROS/Gazebo/MoveIt campaign on the target workstation before that scope is considered simulation-qualified there. Real robot execution remains locked. Functional-safety certification and site qualification are not claimed.
 

{devagent_physical_engine-0.12.1 → devagent_physical_engine-0.12.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "devagent-physical-engine"
-version = "0.12.1"
+version = "0.12.3"
 description = "Verification-first agentic engineering, simulation, and evidence runtime for robotics and industrial automation."
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.11"

{devagent_physical_engine-0.12.1 → devagent_physical_engine-0.12.3}/src/devagent_physical_engine/__init__.py

@@ -41,4 +41,4 @@ __all__ = [
     "TwinValidator",
 ]
 
-__version__ = "0.12.1"
+__version__ = "0.12.3"

devagent_physical_engine-0.12.3/src/devagent_physical_engine/ros2/gazebo_cli.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from math import isfinite
+import re
+
+from ..simulation_platform import SimulationPlatformError
+
+
+_ANSI_ESCAPE = re.compile(r"\x1b\[[0-?]*[ -/]*[@-~]")
+_BRACKET = re.compile(r"\[([^\[\]\r\n]+)\]")
+_POSE_HEADER = re.compile(r"(?im)^\s*[-*]?\s*Pose\s*\[\s*XYZ(?:\s*\(m\))?\s*\].*$")
+
+
+def _vector3(payload: str) -> tuple[float, float, float] | None:
+    """Parse one Gazebo bracket vector across supported CLI renderings.
+
+    Gazebo Sim releases have rendered vectors both as ``[x | y | z]`` and
+    ``[x y z]``. Some downstream packages also emit comma-separated values.
+    Accept those presentation differences while still requiring exactly three
+    finite numeric values.
+    """
+
+    parts = payload.replace("|", " ").replace(",", " ").split()
+    if len(parts) != 3:
+        return None
+    try:
+        values = tuple(float(value) for value in parts)
+    except ValueError:
+        return None
+    if any(not isfinite(value) for value in values):
+        return None
+    return values[0], values[1], values[2]
+
+
+def parse_gz_model_pose(
+    text: str,
+) -> tuple[tuple[float, float, float], tuple[float, float, float]]:
+    """Parse ``gz model -m NAME --pose`` output deterministically.
+
+    The human-readable Gazebo CLI is not stable in its vector delimiter style.
+    Anchor on the model Pose header and parse the first two valid 3-vectors
+    beneath it as XYZ metres and RPY radians. ANSI terminal escapes are ignored.
+    A legacy plain six-number pose line is accepted as a bounded compatibility
+    fallback.
+    """
+
+    cleaned = _ANSI_ESCAPE.sub("", text)
+    header = _POSE_HEADER.search(cleaned)
+    section = cleaned[header.end() :] if header is not None else cleaned
+
+    vectors: list[tuple[float, float, float]] = []
+    for match in _BRACKET.finditer(section):
+        vector = _vector3(match.group(1))
+        if vector is None:
+            continue
+        vectors.append(vector)
+        if len(vectors) == 2:
+            return vectors[0], vectors[1]
+
+    # Compatibility with older Gazebo model tools that rendered
+    # ``x y z roll pitch yaw`` as one line instead of bracket vectors.
+    for line in section.splitlines():
+        parts = line.replace(",", " ").split()
+        if len(parts) != 6:
+            continue
+        try:
+            values = tuple(float(value) for value in parts)
+        except ValueError:
+            continue
+        if any(not isfinite(value) for value in values):
+            continue
+        return (
+            (values[0], values[1], values[2]),
+            (values[3], values[4], values[5]),
+        )
+
+    raise SimulationPlatformError("gazebo_model_pose_output_invalid")

{devagent_physical_engine-0.12.1 → devagent_physical_engine-0.12.3}/src/devagent_physical_engine/ros2/gazebo_pose.py

@@ -2,10 +2,10 @@ from __future__ import annotations
 
 from dataclasses import asdict, dataclass
 from math import isfinite
-import re
 
 from ..simulation_platform import SimulationPlatformError
 from .commands import RosCommandRunner
+from .gazebo_cli import parse_gz_model_pose
 
 
 @dataclass(frozen=True, slots=True)
@@ -21,11 +21,11 @@ class GazeboPoseUpdateReceipt:
 
 
 def _parse_position(text: str) -> tuple[float, float, float]:
-    pattern = re.compile(r"\[\s*([-+0-9.eE]+)\s*\|\s*([-+0-9.eE]+)\s*\|\s*([-+0-9.eE]+)\s*\]")
-    match = pattern.search(text)
-    if match is None:
-        raise SimulationPlatformError("gazebo_pose_readback_invalid")
-    return tuple(float(match.group(index)) for index in range(1, 4))
+    try:
+        position, _orientation = parse_gz_model_pose(text)
+    except SimulationPlatformError as exc:
+        raise SimulationPlatformError("gazebo_pose_readback_invalid") from exc
+    return position
 
 
 class GazeboPoseBridge:

{devagent_physical_engine-0.12.1 → devagent_physical_engine-0.12.3}/src/devagent_physical_engine/ros2/gazebo_world.py

@@ -8,6 +8,7 @@ from typing import Any
 from ..simulation_platform import SimulationPlatformError
 from ..twin_materialization import CanonicalTwinMaterialization
 from .commands import RosCommandRunner
+from .gazebo_cli import parse_gz_model_pose
 
 
 @dataclass(frozen=True, slots=True)
@@ -48,13 +49,7 @@ def _parse_model_names(text: str) -> set[str]:
 
 
 def _parse_pose(text: str):
-    triples: list[tuple[float, float, float]] = []
-    pattern = re.compile(r"\[\s*([-+0-9.eE]+)\s*\|\s*([-+0-9.eE]+)\s*\|\s*([-+0-9.eE]+)\s*\]")
-    for match in pattern.finditer(text):
-        triples.append(tuple(float(match.group(index)) for index in range(1, 4)))
-    if len(triples) < 2:
-        raise SimulationPlatformError("gazebo_model_pose_output_invalid")
-    return triples[0], triples[1]
+    return parse_gz_model_pose(text)
 
 
 class GazeboWorldVerifier:

{devagent_physical_engine-0.12.1 → devagent_physical_engine-0.12.3}/src/devagent_physical_engine/ros2/moveit_scene.py

@@ -2,12 +2,14 @@ from __future__ import annotations
 
 from dataclasses import asdict, dataclass
 import json
+from math import isfinite
 from pathlib import Path
 from typing import Any
 
 from ..simulation_platform import SimulationPlatformError
 from ..twin_materialization import CanonicalTwinMaterialization
 from .commands import RosCommandRunner
+from .frame_alignment import FrameAlignmentReceipt, FrameAlignmentVerifier
 
 
 @dataclass(frozen=True, slots=True)
@@ -21,6 +23,8 @@ class MoveItSceneReceipt:
     planning_frame: str
     expected_object_count: int
     observed_object_count: int | None
+    observed_planning_frames: tuple[str, ...] = ()
+    equivalent_planning_frames: tuple[str, ...] = ()
 
     def __post_init__(self) -> None:
         if not self.code.strip():
@@ -37,11 +41,44 @@ class MoveItSceneReceipt:
             raise ValueError("moveit_scene_receipt_object_count_invalid")
         if self.observed_object_count is not None and self.observed_object_count < 0:
             raise ValueError("moveit_scene_receipt_object_count_invalid")
+        if any(not value.strip() for value in self.observed_planning_frames):
+            raise ValueError("moveit_scene_receipt_observed_frame_invalid")
+        if any(not value.strip() for value in self.equivalent_planning_frames):
+            raise ValueError("moveit_scene_receipt_equivalent_frame_invalid")
 
     def to_dict(self) -> dict[str, Any]:
         return asdict(self)
 
 
+def _equivalent_frames_from_receipt(
+    planning_frame: str,
+    frame_alignment: FrameAlignmentReceipt | None,
+) -> tuple[str, ...]:
+    """Return only frames already proven identity-equivalent to the canonical frame."""
+
+    if frame_alignment is None:
+        return ()
+    if (
+        not frame_alignment.verified
+        or not isfinite(frame_alignment.translation_error_m)
+        or not isfinite(frame_alignment.rotation_error_rad)
+        or frame_alignment.translation_error_m < 0.0
+        or frame_alignment.rotation_error_rad < 0.0
+    ):
+        raise SimulationPlatformError("moveit_scene_frame_receipt_invalid")
+
+    parent = frame_alignment.parent_frame.strip()
+    child = frame_alignment.child_frame.strip()
+    expected = planning_frame.strip()
+    if not parent or not child or not expected:
+        raise SimulationPlatformError("moveit_scene_frame_receipt_invalid")
+    if child == expected:
+        return () if parent == expected else (parent,)
+    if parent == expected:
+        return () if child == expected else (child,)
+    raise SimulationPlatformError("moveit_scene_frame_receipt_unbound")
+
+
 class MoveItSceneBridge:
     """Apply canonical Twin collision geometry to MoveIt and read it back."""
 
@@ -58,15 +95,19 @@ class MoveItSceneBridge:
         self.work_dir = Path(work_dir).expanduser().resolve()
         self.timeout_s = float(timeout_s)
 
-    def apply_and_verify(
-        self, materialization: CanonicalTwinMaterialization
-    ) -> MoveItSceneReceipt:
-        self.work_dir.mkdir(parents=True, exist_ok=True)
+    def _run_probe(
+        self,
+        *,
+        materialization: CanonicalTwinMaterialization,
+        equivalent_frames: tuple[str, ...],
+    ) -> tuple[dict[str, Any], bool]:
+        payload = materialization.moveit_scene_payload()
+        payload["equivalent_planning_frames"] = list(equivalent_frames)
         payload_path = self.work_dir / f"{materialization.fingerprint}.moveit-scene.json"
         temporary = payload_path.with_suffix(payload_path.suffix + ".tmp")
         temporary.write_text(
             json.dumps(
-                materialization.moveit_scene_payload(),
+                payload,
                 sort_keys=True,
                 separators=(",", ":"),
                 allow_nan=False,
@@ -93,8 +134,73 @@ class MoveItSceneBridge:
             raise SimulationPlatformError("moveit_scene_probe_output_invalid") from exc
         if not isinstance(output, dict):
             raise SimulationPlatformError("moveit_scene_probe_output_invalid")
+        return output, result.ok
+
+    def apply_and_verify(
+        self,
+        materialization: CanonicalTwinMaterialization,
+        *,
+        frame_alignment: FrameAlignmentReceipt | None = None,
+    ) -> MoveItSceneReceipt:
+        self.work_dir.mkdir(parents=True, exist_ok=True)
+        equivalent_frames = _equivalent_frames_from_receipt(
+            materialization.planning_frame,
+            frame_alignment,
+        )
+        output, command_ok = self._run_probe(
+            materialization=materialization,
+            equivalent_frames=equivalent_frames,
+        )
         code = str(output.get("code") or "moveit_scene_probe_failed")
-        verified = bool(output.get("success")) and result.ok
+
+        # MoveIt serializes world collision objects in its own planning/root frame.
+        # If that label differs from the canonical Twin frame, do not trust it by
+        # convention.  Prove the observed frame is identity-equivalent via TF, then
+        # repeat the read-back with that exact frame admitted for canonical hashing.
+        if (
+            frame_alignment is None
+            and not equivalent_frames
+            and not bool(output.get("success"))
+            and code.startswith("scene_planning_frame_mismatch:")
+        ):
+            observed_frames = tuple(
+                sorted(
+                    {
+                        str(value).strip()
+                        for value in output.get("observed_planning_frames") or ()
+                        if str(value).strip()
+                    }
+                )
+            )
+            if len(observed_frames) != 1:
+                raise SimulationPlatformError(
+                    "moveit_scene_observed_frame_ambiguous"
+                )
+            observed_frame = observed_frames[0]
+            receipt = FrameAlignmentVerifier(self.runner).verify_identity(
+                parent_frame=observed_frame,
+                child_frame=materialization.planning_frame,
+            )
+            equivalent_frames = _equivalent_frames_from_receipt(
+                materialization.planning_frame,
+                receipt,
+            )
+            output, command_ok = self._run_probe(
+                materialization=materialization,
+                equivalent_frames=equivalent_frames,
+            )
+            code = str(output.get("code") or "moveit_scene_probe_failed")
+
+        verified = bool(output.get("success")) and command_ok
+        observed_frames = tuple(
+            sorted(
+                {
+                    str(value).strip()
+                    for value in output.get("observed_planning_frames") or ()
+                    if str(value).strip()
+                }
+            )
+        )
         receipt = MoveItSceneReceipt(
             verified=verified,
             code=code,
@@ -113,6 +219,8 @@ class MoveItSceneBridge:
                 if output.get("observed_object_count") is not None
                 else None
             ),
+            observed_planning_frames=observed_frames,
+            equivalent_planning_frames=equivalent_frames,
         )
         if not receipt.verified:
             raise SimulationPlatformError(f"moveit_scene_verification_failed:{receipt.code}")

{devagent_physical_engine-0.12.1 → devagent_physical_engine-0.12.3}/src/devagent_physical_engine/ros2/scene_probe.py

@@ -35,6 +35,71 @@ def _canonical_scene(planning_frame: str, objects: list[dict[str, Any]]) -> dict
     }
 
 
+def _verify_observed_scene(
+    *,
+    planning_frame: str,
+    expected_hash: str,
+    expected_objects: list[dict[str, Any]],
+    observed_objects: list[dict[str, Any]],
+    equivalent_planning_frames: tuple[str, ...] = (),
+) -> dict[str, Any]:
+    """Verify read-back without confusing an identity-equivalent frame label for drift.
+
+    ``equivalent_planning_frames`` is not discovered here.  It must be supplied by the
+    caller from an independently verified identity transform receipt.  Geometry is
+    always canonicalized back to ``planning_frame`` before hashing.
+    """
+
+    planning_frame = planning_frame.strip()
+    if not planning_frame:
+        raise ValueError("scene_planning_frame_required")
+    equivalent = tuple(value.strip() for value in equivalent_planning_frames)
+    if any(not value for value in equivalent):
+        raise ValueError("scene_equivalent_planning_frame_invalid")
+    accepted_frames = {planning_frame, *equivalent}
+    expected_ids = {str(item["id"]) for item in expected_objects}
+    relevant = [item for item in observed_objects if str(item["id"]) in expected_ids]
+    observed_frames = sorted({str(item.get("frame_id") or "").strip() for item in relevant})
+
+    for item in relevant:
+        frame_id = str(item.get("frame_id") or "").strip()
+        if frame_id not in accepted_frames:
+            return {
+                "success": False,
+                "code": f"scene_planning_frame_mismatch:{item['id']}:{frame_id or '<empty>'}",
+                "observed_object_count": len(relevant),
+                "observed_planning_frames": observed_frames,
+            }
+
+    canonical_objects = [
+        {
+            "id": item["id"],
+            "geometry_kind": item["geometry_kind"],
+            "dimensions_m": item["dimensions_m"],
+            "position_m": item["position_m"],
+            "quaternion_xyzw": item["quaternion_xyzw"],
+        }
+        for item in relevant
+    ]
+    observed_scene = _canonical_scene(planning_frame, canonical_objects)
+    observed_hash = _hash(observed_scene)
+    observed_ids = {str(item["id"]) for item in relevant}
+    missing = sorted(expected_ids - observed_ids)
+    success = (
+        not missing
+        and len(relevant) == len(expected_objects)
+        and observed_hash == expected_hash
+    )
+    return {
+        "success": success,
+        "code": "moveit_scene_readback_verified" if success else "moveit_scene_readback_mismatch",
+        "observed_scene_hash": observed_hash,
+        "observed_object_count": len(relevant),
+        "observed_planning_frames": observed_frames,
+        "missing_object_ids": missing,
+    }
+
+
 def _qmul(first, second):
     ax, ay, az, aw = first
     bx, by, bz, bw = second
@@ -78,6 +143,9 @@ def apply_verify(path: Path, timeout_s: float) -> dict[str, Any]:
     planning_frame = str(payload["planning_frame"])
     expected_hash = str(payload["scene_hash"])
     expected_objects = list(payload["objects"])
+    equivalent_planning_frames = tuple(
+        str(value) for value in payload.get("equivalent_planning_frames") or ()
+    )
 
     import rclpy
     from geometry_msgs.msg import Pose
@@ -155,13 +223,12 @@ def apply_verify(path: Path, timeout_s: float) -> dict[str, Any]:
         for collision in response.scene.world.collision_objects:
             if collision.id not in expected_ids:
                 continue
-            if collision.header.frame_id != planning_frame:
+            if len(collision.primitives) != 1 or len(collision.primitive_poses) != 1:
                 return {
                     "success": False,
-                    "code": f"scene_planning_frame_mismatch:{collision.id}:{collision.header.frame_id}",
+                    "code": f"scene_shape_invalid:{collision.id}",
+                    "observed_planning_frames": [collision.header.frame_id],
                 }
-            if len(collision.primitives) != 1 or len(collision.primitive_poses) != 1:
-                return {"success": False, "code": f"scene_shape_invalid:{collision.id}"}
             primitive = collision.primitives[0]
             primitive_pose = collision.primitive_poses[0]
             position, quaternion = _combine_pose(collision.pose, primitive_pose)
@@ -175,26 +242,29 @@ def apply_verify(path: Path, timeout_s: float) -> dict[str, Any]:
                     primitive.dimensions[SolidPrimitive.CYLINDER_HEIGHT],
                 ]
             else:
-                return {"success": False, "code": f"scene_shape_unsupported:{collision.id}"}
-            observed.append({
-                "id": collision.id,
-                "geometry_kind": kind,
-                "dimensions_m": dimensions,
-                "position_m": list(position),
-                "quaternion_xyzw": list(quaternion),
-            })
-
-        observed_scene = _canonical_scene(planning_frame, observed)
-        observed_hash = _hash(observed_scene)
-        missing = sorted(expected_ids - {item["id"] for item in observed})
-        success = not missing and len(observed) == len(expected_objects) and observed_hash == expected_hash
-        return {
-            "success": success,
-            "code": "moveit_scene_readback_verified" if success else "moveit_scene_readback_mismatch",
-            "observed_scene_hash": observed_hash,
-            "observed_object_count": len(observed),
-            "missing_object_ids": missing,
-        }
+                return {
+                    "success": False,
+                    "code": f"scene_shape_unsupported:{collision.id}",
+                    "observed_planning_frames": [collision.header.frame_id],
+                }
+            observed.append(
+                {
+                    "id": collision.id,
+                    "frame_id": collision.header.frame_id,
+                    "geometry_kind": kind,
+                    "dimensions_m": dimensions,
+                    "position_m": list(position),
+                    "quaternion_xyzw": list(quaternion),
+                }
+            )
+
+        return _verify_observed_scene(
+            planning_frame=planning_frame,
+            expected_hash=expected_hash,
+            expected_objects=expected_objects,
+            observed_objects=observed,
+            equivalent_planning_frames=equivalent_planning_frames,
+        )
     finally:
         node.destroy_node()
         rclpy.shutdown()

{devagent_physical_engine-0.12.1 → devagent_physical_engine-0.12.3/src/devagent_physical_engine.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devagent-physical-engine
-Version: 0.12.1
+Version: 0.12.3
 Summary: Verification-first agentic engineering, simulation, and evidence runtime for robotics and industrial automation.
 Author: Tom Ha
 License: All Rights Reserved
@@ -191,6 +191,10 @@ On a successful run, Gazebo / MoveIt remains open by default so the engineer can
 
 v0.12.1 hardens the initial ROS joint-state snapshot by parsing `ros2 topic echo --once` output as a YAML document stream. This accepts the normal ROS 2 trailing `---` message separator instead of incorrectly classifying an otherwise valid `/joint_states` sample as `joint_state_snapshot_invalid`.
 
+v0.12.2 additionally hardens Gazebo model-pose read-back across Harmonic CLI renderings. One shared parser now accepts both pipe-delimited and whitespace-delimited finite XYZ/RPY vectors and is used by initial world verification and dynamic workpiece pose read-back, so task simulation does not depend on a single human-readable `gz model --pose` delimiter style.
+
+v0.12.3 hardens MoveIt PlanningScene read-back when MoveIt serializes world collision objects in its own planning/root frame. A different observed frame is never trusted by label alone: DevAgent first proves the observed frame and canonical Twin frame are identity-equivalent through TF, then re-reads the scene and canonicalizes it back to the Twin planning frame before enforcing the exact geometry hash. Non-identity frames and geometry drift remain fail-closed.
+
 The packaged reference workcell is **not customer-site geometry**. Arbitrary plant layouts require an imported or user-declared physical Twin with trusted poses, collision geometry, tool/TCP information, and workpiece properties. DevAgent does not invent those site facts from a natural-language prompt.
 
 The v0.12 implementation remains evidence-gated: source/CI success does not prove the ROS target campaign has passed on a particular workstation. Use the executable qualification below before treating the task-specific path as qualified on that target.
@@ -418,7 +422,7 @@ Detailed engineering documentation lives in the repository:
 
 ## Project status
 
-**v0.12.1 — Beta software / evidence-gated task-specific physical simulation.**
+**v0.12.3 — Beta software / evidence-gated task-specific physical simulation.**
 
 The software and release pipeline are production-oriented, but physical readiness is scope-specific and evidence-driven. The UR5e task-specific reference-workcell path must pass the executable v0.12 ROS/Gazebo/MoveIt campaign on the target workstation before that scope is considered simulation-qualified there. Real robot execution remains locked. Functional-safety certification and site qualification are not claimed.
 

{devagent_physical_engine-0.12.1 → devagent_physical_engine-0.12.3}/src/devagent_physical_engine.egg-info/SOURCES.txt

@@ -78,6 +78,7 @@ src/devagent_physical_engine/ros2/doctor.py
 src/devagent_physical_engine/ros2/fk_pose.py
 src/devagent_physical_engine/ros2/fk_probe.py
 src/devagent_physical_engine/ros2/frame_alignment.py
+src/devagent_physical_engine/ros2/gazebo_cli.py
 src/devagent_physical_engine/ros2/gazebo_pose.py
 src/devagent_physical_engine/ros2/gazebo_world.py
 src/devagent_physical_engine/ros2/joint_state_recorder.py
@@ -112,9 +113,11 @@ tests/test_ai_cli_v07.py
 tests/test_continuous_clearance_v011.py
 tests/test_core.py
 tests/test_engineering_request_v07.py
+tests/test_gazebo_cli_v0122.py
 tests/test_interpreter_profiles_v08.py
 tests/test_live_provider_qualification.py
 tests/test_measured_motion_v10.py
+tests/test_moveit_scene_v0123.py
 tests/test_natural_language_agent_v07.py
 tests/test_openai_strict_schema_v0113.py
 tests/test_optimization_v05.py

devagent_physical_engine-0.12.3/tests/test_gazebo_cli_v0122.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+import unittest
+
+from devagent_physical_engine.ros2.gazebo_cli import parse_gz_model_pose
+from devagent_physical_engine.ros2.gazebo_pose import _parse_position
+from devagent_physical_engine.ros2.gazebo_world import _parse_pose
+from devagent_physical_engine.simulation_platform import SimulationPlatformError
+
+
+PIPE_OUTPUT = """Requesting state for world [default]...
+
+Model: [8]
+
+- Name: BOX_101
+
+- Pose [ XYZ (m) ] [ RPY (rad) ]:
+
+[0.550000 | -0.350000 | 0.820000]
+
+[0.000000 | 0.000000 | 1.570796]
+"""
+
+HARMONIC_WHITESPACE_OUTPUT = """Requesting state for world [default]...
+
+* Model [8]
+  * Name: BOX_101
+  * Pose [ XYZ (m) ] [ RPY (rad) ]:
+[0.550000 -0.350000 0.820000]
+[0.000000 -0.000000 1.570796]
+"""
+
+
+class GazeboCliPoseV0122Tests(unittest.TestCase):
+    def test_accepts_documented_pipe_delimited_pose(self):
+        position, orientation = parse_gz_model_pose(PIPE_OUTPUT)
+        self.assertEqual(position, (0.55, -0.35, 0.82))
+        self.assertEqual(orientation, (0.0, 0.0, 1.570796))
+
+    def test_accepts_harmonic_whitespace_delimited_pose(self):
+        position, orientation = parse_gz_model_pose(HARMONIC_WHITESPACE_OUTPUT)
+        self.assertEqual(position, (0.55, -0.35, 0.82))
+        self.assertEqual(orientation, (0.0, -0.0, 1.570796))
+
+    def test_world_verifier_parser_uses_harmonic_compatible_parser(self):
+        self.assertEqual(
+            _parse_pose(HARMONIC_WHITESPACE_OUTPUT),
+            ((0.55, -0.35, 0.82), (0.0, -0.0, 1.570796)),
+        )
+
+    def test_dynamic_workpiece_readback_uses_same_parser(self):
+        self.assertEqual(
+            _parse_position(HARMONIC_WHITESPACE_OUTPUT),
+            (0.55, -0.35, 0.82),
+        )
+
+    def test_ansi_terminal_escape_does_not_break_pose(self):
+        payload = "\x1b[32m" + HARMONIC_WHITESPACE_OUTPUT + "\x1b[0m"
+        self.assertEqual(parse_gz_model_pose(payload)[0], (0.55, -0.35, 0.82))
+
+    def test_legacy_plain_six_number_pose_is_supported(self):
+        self.assertEqual(
+            parse_gz_model_pose("0.55 -0.35 0.82 0.0 0.0 1.570796\n"),
+            ((0.55, -0.35, 0.82), (0.0, 0.0, 1.570796)),
+        )
+
+    def test_incomplete_pose_fails_closed(self):
+        with self.assertRaisesRegex(
+            SimulationPlatformError,
+            "gazebo_model_pose_output_invalid",
+        ):
+            parse_gz_model_pose(
+                "- Pose [ XYZ (m) ] [ RPY (rad) ]:\n[0.55 -0.35 0.82]\n"
+            )
+
+    def test_non_finite_pose_fails_closed(self):
+        with self.assertRaisesRegex(
+            SimulationPlatformError,
+            "gazebo_model_pose_output_invalid",
+        ):
+            parse_gz_model_pose(
+                "- Pose [ XYZ (m) ] [ RPY (rad) ]:\n"
+                "[0.55 -0.35 nan]\n[0.0 0.0 0.0]\n"
+            )
+
+
+if __name__ == "__main__":
+    unittest.main()