devagent-physical-engine 1.8.6__tar.gz → 1.8.8__tar.gz

{devagent_physical_engine-1.8.6/src/devagent_physical_engine.egg-info → devagent_physical_engine-1.8.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devagent-physical-engine
-Version: 1.8.6
+Version: 1.8.8
 Summary: Verification-first robotics commissioning runtime with exact-Twin evidence, qualified UR5e Gazebo/MoveIt report execution, truthful robot support tiers, selective verification, replay, regression, and FAT reporting.
 Author: Tom Ha
 License: All Rights Reserved
@@ -76,7 +76,7 @@ regression + FAT report + Evidence Viewer
 Python 3.11+ is required.
 
 ```bash
-python -m pip install --upgrade devagent-physical-engine==1.8.6
+python -m pip install --upgrade devagent-physical-engine==1.8.8
 ```
 
 Verify the installed package:
@@ -88,7 +88,7 @@ python -c "import devagent_physical_engine as d; print(d.__version__)"
 Expected:
 
 ```text
-1.8.6
+1.8.8
 ```
 
 Run the normal customer workflow:
@@ -438,6 +438,16 @@ Every lifecycle transition persists a deterministic receipt containing probe std
 
 This release does not disable collision checking, change the verified tool/workpiece geometry, modify motion targets, planner types or speeds, detach early, grant site qualification, or expand real-execution authority.
 
+## v1.8.8 canonical world integrity gate before GRASP
+
+v1.8.8 packages the latest workpiece-lifecycle diagnostics as an unambiguous release version so target acceptance no longer runs newer code while reporting `1.8.6`.
+
+Before ATTACH, DevAgent now reasserts the exact canonical Twin workpiece into the live MoveIt world, synchronously reads the object back, normalizes ROS `uint8/octet` primitive representations safely, and requires exact identity/frame/geometry plus bounded pose agreement before attachment is attempted. Primitive type `0` remains invalid; DevAgent does not infer BOX/CYLINDER from dimensions or weaken collision checking.
+
+The lifecycle receipt records the pre/post primitive type representation, canonical-world reassert result, semantic verification, and the exact inner failure code. Existing target poses, conservative Pilz motion limits, tool/workpiece geometry, site-qualification boundaries, and `real_execution_allowed = false` remain unchanged.
+
+Hosted CI qualifies the software/build/install contract. The ROS/Gazebo/MoveIt workstation still requires a fresh target acceptance run of the released 1.8.8 artifact before this specific workpiece path can be called physically qualified.
+
 ## Qualified visual-execution scope
 
 Measured report-test execution remains intentionally narrow:
@@ -638,9 +648,9 @@ devagent-physical-ai optional provider-backed engineering front end
 
 # Project status
 
-**v1.8.6 — Production/Stable software workflow**
+**v1.8.8 — Production/Stable software workflow**
 
-v1.8.6 retains v1.8.5 quaternion canonicalization, v1.8.4 PyPI metadata compliance, v1.8.3 synchronous service-safe attachment, v1.8.2 scoped destination-support place contact, and v1.8.1 direct UR5e controller/action binding. It upgrades the workpiece lifecycle to canonical MoveIt existing-object world↔attached transitions, strict physical-semantic pose/geometry verification, and persistent expected/observed lifecycle diagnostics instead of using floating representation SHA equality as PASS authority.
+v1.8.8 retains the v1.8.6 semantic lifecycle and the target-candidate improvements layered after it, while making the package/version identity explicit. The current GRASP path adds ROS-octet-safe diagnostics and a synchronous canonical-world reassert/readback gate before attachment. This release is intended to make the next workstation qualification run reproducible and attributable to one exact installable artifact.
 
 Production-oriented software capabilities include:
 
@@ -655,7 +665,7 @@ exact Requirement → Mapping → Verification Plan → Case provenance
 truthful robot support tiers
 qualified UR5e report-test visual execution contract
 direct UR5e controller-manager/action readiness binding
-canonical MoveIt existing-object workpiece attach/detach
+canonical MoveIt workpiece lifecycle with world-integrity gate
 semantic workpiece pose/geometry verification with persistent diagnostics
 scoped destination-support place contact
 experimental exact ABB IRB1200 Gazebo/MoveIt/RViz preview

{devagent_physical_engine-1.8.6 → devagent_physical_engine-1.8.8}/README.md

@@ -35,7 +35,7 @@ regression + FAT report + Evidence Viewer
 Python 3.11+ is required.
 
 ```bash
-python -m pip install --upgrade devagent-physical-engine==1.8.6
+python -m pip install --upgrade devagent-physical-engine==1.8.8
 ```
 
 Verify the installed package:
@@ -47,7 +47,7 @@ python -c "import devagent_physical_engine as d; print(d.__version__)"
 Expected:
 
 ```text
-1.8.6
+1.8.8
 ```
 
 Run the normal customer workflow:
@@ -397,6 +397,16 @@ Every lifecycle transition persists a deterministic receipt containing probe std
 
 This release does not disable collision checking, change the verified tool/workpiece geometry, modify motion targets, planner types or speeds, detach early, grant site qualification, or expand real-execution authority.
 
+## v1.8.8 canonical world integrity gate before GRASP
+
+v1.8.8 packages the latest workpiece-lifecycle diagnostics as an unambiguous release version so target acceptance no longer runs newer code while reporting `1.8.6`.
+
+Before ATTACH, DevAgent now reasserts the exact canonical Twin workpiece into the live MoveIt world, synchronously reads the object back, normalizes ROS `uint8/octet` primitive representations safely, and requires exact identity/frame/geometry plus bounded pose agreement before attachment is attempted. Primitive type `0` remains invalid; DevAgent does not infer BOX/CYLINDER from dimensions or weaken collision checking.
+
+The lifecycle receipt records the pre/post primitive type representation, canonical-world reassert result, semantic verification, and the exact inner failure code. Existing target poses, conservative Pilz motion limits, tool/workpiece geometry, site-qualification boundaries, and `real_execution_allowed = false` remain unchanged.
+
+Hosted CI qualifies the software/build/install contract. The ROS/Gazebo/MoveIt workstation still requires a fresh target acceptance run of the released 1.8.8 artifact before this specific workpiece path can be called physically qualified.
+
 ## Qualified visual-execution scope
 
 Measured report-test execution remains intentionally narrow:
@@ -597,9 +607,9 @@ devagent-physical-ai optional provider-backed engineering front end
 
 # Project status
 
-**v1.8.6 — Production/Stable software workflow**
+**v1.8.8 — Production/Stable software workflow**
 
-v1.8.6 retains v1.8.5 quaternion canonicalization, v1.8.4 PyPI metadata compliance, v1.8.3 synchronous service-safe attachment, v1.8.2 scoped destination-support place contact, and v1.8.1 direct UR5e controller/action binding. It upgrades the workpiece lifecycle to canonical MoveIt existing-object world↔attached transitions, strict physical-semantic pose/geometry verification, and persistent expected/observed lifecycle diagnostics instead of using floating representation SHA equality as PASS authority.
+v1.8.8 retains the v1.8.6 semantic lifecycle and the target-candidate improvements layered after it, while making the package/version identity explicit. The current GRASP path adds ROS-octet-safe diagnostics and a synchronous canonical-world reassert/readback gate before attachment. This release is intended to make the next workstation qualification run reproducible and attributable to one exact installable artifact.
 
 Production-oriented software capabilities include:
 
@@ -614,7 +624,7 @@ exact Requirement → Mapping → Verification Plan → Case provenance
 truthful robot support tiers
 qualified UR5e report-test visual execution contract
 direct UR5e controller-manager/action readiness binding
-canonical MoveIt existing-object workpiece attach/detach
+canonical MoveIt workpiece lifecycle with world-integrity gate
 semantic workpiece pose/geometry verification with persistent diagnostics
 scoped destination-support place contact
 experimental exact ABB IRB1200 Gazebo/MoveIt/RViz preview

{devagent_physical_engine-1.8.6 → devagent_physical_engine-1.8.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "devagent-physical-engine"
-version = "1.8.6"
+version = "1.8.8"
 description = "Verification-first robotics commissioning runtime with exact-Twin evidence, qualified UR5e Gazebo/MoveIt report execution, truthful robot support tiers, selective verification, replay, regression, and FAT reporting."
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.11"
@@ -66,6 +66,8 @@ omit = [
   # Pure contracts/reference-workcell logic remains inside the hosted coverage gate.
   "src/devagent_physical_engine/ros2/*_probe.py",
   "src/devagent_physical_engine/ros2/workpiece_scene_probe_v186.py",
+  "src/devagent_physical_engine/ros2/workpiece_scene_probe_v187.py",
+  "src/devagent_physical_engine/ros2/workpiece_scene_probe_v188.py",
   "src/devagent_physical_engine/ros2/qualification*.py",
   "src/devagent_physical_engine/ros2/joint_state_recorder.py",
   "src/devagent_physical_engine/ros2/ur5e_adapter.py",

{devagent_physical_engine-1.8.6 → devagent_physical_engine-1.8.8}/src/devagent_physical_engine/__init__.py

@@ -219,4 +219,4 @@ install_industrial_motion_v170()
 install_controller_runtime_hotfix_v181()
 install_one_command_runtime()
 
-__version__ = "1.8.6"
+__version__ = "1.8.8"

{devagent_physical_engine-1.8.6 → devagent_physical_engine-1.8.8}/src/devagent_physical_engine/ros2/workpiece_scene.py

@@ -124,7 +124,7 @@ class MoveItWorkpieceLifecycleBridge:
         )
         temporary.replace(payload_path)
 
-        helper = Path(__file__).with_name("workpiece_scene_probe_v186.py").resolve()
+        helper = Path(__file__).with_name("workpiece_scene_probe_v188.py").resolve()
         result = self.runner.run(
             (
                 "python3",

devagent_physical_engine-1.8.8/src/devagent_physical_engine/ros2/workpiece_scene_probe_v187.py

@@ -0,0 +1,408 @@
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import Any
+
+try:
+    from .workpiece_scene_probe import (
+        _canonical_attachment,
+        _collision_object,
+        _compose,
+        _hash,
+        _lookup_transform,
+        _pose_payload,
+    )
+    from .workpiece_scene_probe_v186 import (
+        GEOMETRY_DIMENSION_TOLERANCE_M,
+        _apply_scene,
+        _dimensions_match,
+        _inspect_collision,
+        _read_scene_state,
+        _verify_semantics,
+    )
+except ImportError:  # Direct helper execution under distro Python.
+    from workpiece_scene_probe import (  # type: ignore[no-redef]
+        _canonical_attachment,
+        _collision_object,
+        _compose,
+        _hash,
+        _lookup_transform,
+        _pose_payload,
+    )
+    from workpiece_scene_probe_v186 import (  # type: ignore[no-redef]
+        GEOMETRY_DIMENSION_TOLERANCE_M,
+        _apply_scene,
+        _dimensions_match,
+        _inspect_collision,
+        _read_scene_state,
+        _verify_semantics,
+    )
+
+
+def _diagnostic_hash(
+    *,
+    tool_link: str,
+    item: dict[str, Any],
+    position,
+    quaternion,
+) -> str:
+    return _hash(_canonical_attachment(tool_link, item, position, quaternion))
+
+
+def transition(path: Path, *, operation: str, timeout_s: float) -> dict[str, Any]:
+    payload = json.loads(path.read_text(encoding="utf-8"))
+    item = dict(payload["workpiece"])
+    planning_frame = str(payload["planning_frame"])
+    tool_link = str(payload["tool_link"])
+    touch_links = tuple(str(value) for value in payload.get("touch_links", [tool_link]))
+    materialization_hash = str(payload["materialization_hash"])
+    twin_hash = str(payload["twin_hash"])
+    workpiece_id = str(item["id"])
+
+    pose_data = item["pose"]
+    expected_world_position = tuple(float(value) for value in pose_data["position_m"])
+    expected_world_q = tuple(float(value) for value in pose_data["quaternion_xyzw"])
+    expected_item = {
+        "id": workpiece_id,
+        "geometry_kind": str(item["geometry_kind"]),
+        "dimensions_m": [float(value) for value in item["dimensions_m"]],
+    }
+
+    import rclpy
+    from geometry_msgs.msg import Pose
+    from moveit_msgs.msg import AttachedCollisionObject, CollisionObject, PlanningScene
+    from moveit_msgs.srv import ApplyPlanningScene, GetPlanningScene
+    from shape_msgs.msg import SolidPrimitive
+    from tf2_ros import Buffer, TransformListener
+
+    rclpy.init()
+    node = rclpy.create_node("devagent_workpiece_scene_probe_v187")
+    apply_client = node.create_client(ApplyPlanningScene, "/apply_planning_scene")
+    get_client = node.create_client(GetPlanningScene, "/get_planning_scene")
+    buffer = Buffer()
+    listener = TransformListener(buffer, node, spin_thread=False)
+    try:
+        if not apply_client.wait_for_service(timeout_sec=timeout_s):
+            return {"success": False, "code": "apply_planning_scene_unavailable"}
+        if not get_client.wait_for_service(timeout_sec=timeout_s):
+            return {"success": False, "code": "get_planning_scene_unavailable"}
+
+        pre_world, pre_attached = _read_scene_state(
+            get_client, node, timeout_s, workpiece_id
+        )
+
+        if operation == "attach":
+            if len(pre_world) != 1 or pre_attached:
+                return {
+                    "success": False,
+                    "code": "workpiece_attach_precondition_mismatch",
+                    "observed_world_count": len(pre_world),
+                    "observed_attached_count": len(pre_attached),
+                }
+
+            try:
+                observed_world = _inspect_collision(pre_world[0], SolidPrimitive)
+            except ValueError as exc:
+                return {
+                    "success": False,
+                    "code": "workpiece_world_shape_invalid",
+                    "detail": str(exc),
+                }
+
+            world_semantics = _verify_semantics(
+                expected_item=expected_item,
+                expected_frame=planning_frame,
+                expected_position=expected_world_position,
+                expected_quaternion=expected_world_q,
+                observed=observed_world,
+            )
+            if not world_semantics["success"]:
+                return {
+                    "success": False,
+                    "code": "workpiece_world_semantic_mismatch",
+                    "observed_world": observed_world,
+                    "world_semantics": world_semantics,
+                }
+
+            transform = _lookup_transform(
+                node,
+                buffer,
+                target_frame=tool_link,
+                source_frame=planning_frame,
+                timeout_s=timeout_s,
+            )
+            transform_position = (
+                float(transform.transform.translation.x),
+                float(transform.transform.translation.y),
+                float(transform.transform.translation.z),
+            )
+            transform_q = (
+                float(transform.transform.rotation.x),
+                float(transform.transform.rotation.y),
+                float(transform.transform.rotation.z),
+                float(transform.transform.rotation.w),
+            )
+            expected_relative_position, expected_relative_q = _compose(
+                transform_position,
+                transform_q,
+                observed_world["position_m"],
+                observed_world["quaternion_xyzw"],
+            )
+
+            # v1.8.5 target evidence proved this explicit AttachedCollisionObject
+            # representation is accepted by the real Jazzy MoveIt stack. v1.8.6
+            # changed both the verifier and the attach mechanism to an ID-only transfer,
+            # making the resulting relative pose depend on MoveIt's asynchronously
+            # sampled internal RobotState while the verifier used live TF. Keep semantic
+            # verification, but make the command and verifier share this exact TF-derived
+            # tool-relative pose and the already-verified geometry. MoveIt removes the
+            # same-ID world object as part of the attach; no redundant world REMOVE is sent.
+            attached = AttachedCollisionObject()
+            attached.link_name = tool_link
+            attached.touch_links = list(touch_links)
+            attached.object = _collision_object(
+                expected_item,
+                tool_link,
+                expected_relative_position,
+                expected_relative_q,
+                operation=CollisionObject.ADD,
+                CollisionObject=CollisionObject,
+                Pose=Pose,
+                SolidPrimitive=SolidPrimitive,
+            )
+            scene = PlanningScene()
+            scene.is_diff = True
+            scene.robot_state.is_diff = True
+            scene.robot_state.attached_collision_objects.append(attached)
+            failure = _apply_scene(apply_client, node, scene, timeout_s)
+            if failure is not None:
+                return {
+                    **failure,
+                    "attach_mode": "explicit_verified_geometry",
+                    "expected_attachment_pose": _pose_payload(
+                        expected_relative_position, expected_relative_q
+                    ),
+                }
+
+            post_world, post_attached = _read_scene_state(
+                get_client, node, timeout_s, workpiece_id
+            )
+            observed_link = (
+                post_attached[0].link_name if len(post_attached) == 1 else None
+            )
+            if post_world or len(post_attached) != 1 or observed_link != tool_link:
+                return {
+                    "success": False,
+                    "code": "workpiece_attach_readback_mismatch",
+                    "attach_mode": "explicit_verified_geometry",
+                    "observed_world_count": len(post_world),
+                    "observed_attached_count": len(post_attached),
+                    "observed_attached_link": observed_link,
+                }
+
+            observed_touch_links = tuple(sorted(set(post_attached[0].touch_links)))
+            expected_touch_links = tuple(sorted(set(touch_links)))
+            if observed_touch_links != expected_touch_links:
+                return {
+                    "success": False,
+                    "code": "workpiece_attachment_touch_links_mismatch",
+                    "attach_mode": "explicit_verified_geometry",
+                    "expected_touch_links": list(expected_touch_links),
+                    "observed_touch_links": list(observed_touch_links),
+                }
+
+            try:
+                observed_attached = _inspect_collision(
+                    post_attached[0].object, SolidPrimitive
+                )
+            except ValueError as exc:
+                return {
+                    "success": False,
+                    "code": "workpiece_attached_shape_invalid",
+                    "attach_mode": "explicit_verified_geometry",
+                    "detail": str(exc),
+                }
+
+            attached_semantics = _verify_semantics(
+                expected_item=expected_item,
+                expected_frame=tool_link,
+                expected_position=expected_relative_position,
+                expected_quaternion=expected_relative_q,
+                observed=observed_attached,
+            )
+            expected_hash = _diagnostic_hash(
+                tool_link=tool_link,
+                item=expected_item,
+                position=expected_relative_position,
+                quaternion=expected_relative_q,
+            )
+            observed_item = {
+                "id": observed_attached["id"],
+                "geometry_kind": observed_attached["geometry_kind"],
+                "dimensions_m": observed_attached["dimensions_m"],
+            }
+            observed_hash = _diagnostic_hash(
+                tool_link=tool_link,
+                item=observed_item,
+                position=observed_attached["position_m"],
+                quaternion=observed_attached["quaternion_xyzw"],
+            )
+            diagnostic = {
+                "materialization_hash": materialization_hash,
+                "twin_hash": twin_hash,
+                "attach_mode": "explicit_verified_geometry",
+                "observed_world_present": False,
+                "observed_attached_link": tool_link,
+                "expected_attachment_hash": expected_hash,
+                "observed_attachment_hash": observed_hash,
+                "representation_hash_match": observed_hash == expected_hash,
+                "expected_attachment_pose": _pose_payload(
+                    expected_relative_position, expected_relative_q
+                ),
+                "observed_attachment": observed_attached,
+                "attachment_semantics": attached_semantics,
+                "expected_touch_links": list(expected_touch_links),
+                "observed_touch_links": list(observed_touch_links),
+            }
+            if not attached_semantics["success"]:
+                return {
+                    "success": False,
+                    "code": "workpiece_attachment_semantic_mismatch",
+                    **diagnostic,
+                }
+            return {
+                "success": True,
+                "code": "workpiece_attach_verified",
+                "attachment_hash": expected_hash,
+                **diagnostic,
+            }
+
+        if operation == "detach":
+            if pre_world or len(pre_attached) != 1:
+                return {
+                    "success": False,
+                    "code": "workpiece_detach_precondition_mismatch",
+                    "observed_world_count": len(pre_world),
+                    "observed_attached_count": len(pre_attached),
+                }
+            if pre_attached[0].link_name != tool_link:
+                return {
+                    "success": False,
+                    "code": "workpiece_detach_link_mismatch",
+                    "observed_attached_link": pre_attached[0].link_name,
+                    "expected_attached_link": tool_link,
+                }
+            try:
+                before_detach = _inspect_collision(
+                    pre_attached[0].object, SolidPrimitive
+                )
+            except ValueError as exc:
+                return {
+                    "success": False,
+                    "code": "workpiece_attached_shape_invalid",
+                    "detail": str(exc),
+                }
+            if (
+                before_detach["geometry_kind"] != expected_item["geometry_kind"]
+                or not _dimensions_match(
+                    expected_item["dimensions_m"],
+                    before_detach["dimensions_m"],
+                    GEOMETRY_DIMENSION_TOLERANCE_M,
+                )
+            ):
+                return {
+                    "success": False,
+                    "code": "workpiece_detach_geometry_mismatch",
+                    "observed_attachment": before_detach,
+                }
+
+            attached = AttachedCollisionObject()
+            attached.link_name = tool_link
+            attached.object.id = workpiece_id
+            attached.object.operation = CollisionObject.REMOVE
+            scene = PlanningScene()
+            scene.is_diff = True
+            scene.robot_state.is_diff = True
+            scene.robot_state.attached_collision_objects.append(attached)
+            failure = _apply_scene(apply_client, node, scene, timeout_s)
+            if failure is not None:
+                return failure
+
+            post_world, post_attached = _read_scene_state(
+                get_client, node, timeout_s, workpiece_id
+            )
+            if len(post_world) != 1 or post_attached:
+                return {
+                    "success": False,
+                    "code": "workpiece_detach_readback_mismatch",
+                    "observed_world_count": len(post_world),
+                    "observed_attached_count": len(post_attached),
+                }
+            try:
+                observed_world = _inspect_collision(post_world[0], SolidPrimitive)
+            except ValueError as exc:
+                return {
+                    "success": False,
+                    "code": "workpiece_world_shape_invalid",
+                    "detail": str(exc),
+                }
+            world_semantics = _verify_semantics(
+                expected_item=expected_item,
+                expected_frame=planning_frame,
+                expected_position=expected_world_position,
+                expected_quaternion=expected_world_q,
+                observed=observed_world,
+            )
+            diagnostic = {
+                "materialization_hash": materialization_hash,
+                "twin_hash": twin_hash,
+                "observed_world_present": True,
+                "observed_attached_link": None,
+                "observed_world": observed_world,
+                "world_semantics": world_semantics,
+            }
+            if not world_semantics["success"]:
+                return {
+                    "success": False,
+                    "code": "workpiece_detach_semantic_mismatch",
+                    **diagnostic,
+                }
+            return {
+                "success": True,
+                "code": "workpiece_detach_verified",
+                **diagnostic,
+            }
+
+        return {"success": False, "code": "workpiece_operation_invalid"}
+    finally:
+        del listener
+        node.destroy_node()
+        rclpy.shutdown()
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("operation", choices=("attach", "detach"))
+    parser.add_argument("--input", required=True)
+    parser.add_argument("--timeout", type=float, default=20.0)
+    args = parser.parse_args()
+    try:
+        result = transition(
+            Path(args.input).expanduser().resolve(),
+            operation=str(args.operation),
+            timeout_s=float(args.timeout),
+        )
+    except Exception as exc:
+        result = {
+            "success": False,
+            "code": f"workpiece_scene_probe_error:{type(exc).__name__}",
+            "detail": str(exc),
+        }
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result.get("success") else 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())