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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devagent-physical-engine
-Version: 0.12.3
+Version: 0.12.4
 Summary: Verification-first agentic engineering, simulation, and evidence runtime for robotics and industrial automation.
 Author: Tom Ha
 License: All Rights Reserved
@@ -195,6 +195,8 @@ v0.12.2 additionally hardens Gazebo model-pose read-back across Harmonic CLI ren
 
 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.
 
+v0.12.4 hardens attached-tool collision read-back against equivalent MoveIt `CollisionObject` pose decompositions. DevAgent now composes the object pose with the primitive pose, canonicalizes equivalent quaternion signs before hashing, and still requires the exact attachment link, object frame, shape, dimensions, operation, and effective geometry. Exact probe evidence is preserved beside the tool payload for target diagnostics; representation-only changes no longer create false mismatches, while physical geometry drift remains 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.
@@ -422,7 +424,7 @@ Detailed engineering documentation lives in the repository:
 
 ## Project status
 
-**v0.12.3 — Beta software / evidence-gated task-specific physical simulation.**
+**v0.12.4 — 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.3 → devagent_physical_engine-0.12.4}/README.md

@@ -154,6 +154,8 @@ v0.12.2 additionally hardens Gazebo model-pose read-back across Harmonic CLI ren
 
 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.
 
+v0.12.4 hardens attached-tool collision read-back against equivalent MoveIt `CollisionObject` pose decompositions. DevAgent now composes the object pose with the primitive pose, canonicalizes equivalent quaternion signs before hashing, and still requires the exact attachment link, object frame, shape, dimensions, operation, and effective geometry. Exact probe evidence is preserved beside the tool payload for target diagnostics; representation-only changes no longer create false mismatches, while physical geometry drift remains 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.
@@ -381,7 +383,7 @@ Detailed engineering documentation lives in the repository:
 
 ## Project status
 
-**v0.12.3 — Beta software / evidence-gated task-specific physical simulation.**
+**v0.12.4 — 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.3 → devagent_physical_engine-0.12.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "devagent-physical-engine"
-version = "0.12.3"
+version = "0.12.4"
 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.3 → devagent_physical_engine-0.12.4}/src/devagent_physical_engine/__init__.py

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

{devagent_physical_engine-0.12.3 → devagent_physical_engine-0.12.4}/src/devagent_physical_engine/ros2/tool_scene.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from hashlib import sha256
 import json
+from math import isfinite, sqrt
 from pathlib import Path
 
 from ..simulation_platform import SimulationPlatformError
@@ -13,6 +14,8 @@ from .commands import RosCommandRunner
 
 def _canon_float(value: float) -> float:
     value = float(value)
+    if not isfinite(value):
+        raise SimulationPlatformError("tool_collision_geometry_non_finite")
     return 0.0 if abs(value) < 1e-12 else float(format(value, ".12g"))
 
 
@@ -21,6 +24,38 @@ def _hash(payload: object) -> str:
     return sha256(text.encode("utf-8")).hexdigest()
 
 
+def _canonical_quaternion(values) -> tuple[float, float, float, float]:
+    quaternion = tuple(float(value) for value in values)
+    if len(quaternion) != 4 or any(not isfinite(value) for value in quaternion):
+        raise SimulationPlatformError("tool_collision_quaternion_invalid")
+    norm = sqrt(sum(value * value for value in quaternion))
+    if norm <= 0.0:
+        raise SimulationPlatformError("tool_collision_quaternion_invalid")
+    quaternion = tuple(value / norm for value in quaternion)
+    for component in (quaternion[3], quaternion[0], quaternion[1], quaternion[2]):
+        if abs(component) <= 1e-15:
+            continue
+        if component < 0.0:
+            quaternion = tuple(-value for value in quaternion)
+        break
+    return tuple(_canon_float(value) for value in quaternion)
+
+
+def _canonical_tool_payload(
+    item: dict[str, object], binding: ToolCollisionBinding
+) -> dict[str, object]:
+    return {
+        "id": item["id"],
+        "link_name": binding.mount_link,
+        "geometry_kind": item["geometry_kind"],
+        "dimensions_m": [
+            _canon_float(value) for value in item["dimensions_m"]  # type: ignore[index]
+        ],
+        "position_m": [_canon_float(value) for value in binding.position_m],
+        "quaternion_xyzw": list(_canonical_quaternion(binding.quaternion_xyzw)),
+    }
+
+
 class MoveItToolCollisionBridge:
     def __init__(
         self,
@@ -36,25 +71,19 @@ class MoveItToolCollisionBridge:
         self.timeout_s = float(timeout_s)
 
     @staticmethod
-    def _geometry_payload(tool: ToolSpec, binding: ToolCollisionBinding) -> tuple[dict[str, object], str]:
+    def _geometry_payload(
+        tool: ToolSpec, binding: ToolCollisionBinding
+    ) -> tuple[dict[str, object], str]:
         if tool.geometry.kind not in {GeometryKind.BOX, GeometryKind.CYLINDER}:
             raise SimulationPlatformError("tool_collision_geometry_not_materializable")
         if not tool.geometry.collision_geometry:
             raise SimulationPlatformError("tool_collision_geometry_disabled")
-        item = {
+        item: dict[str, object] = {
             "id": f"devagent_tool_{sha256(tool.tool_id.encode('utf-8')).hexdigest()[:12]}",
             "geometry_kind": tool.geometry.kind.value,
             "dimensions_m": [float(value) for value in tool.geometry.dimensions_m],
         }
-        canonical = {
-            "id": item["id"],
-            "link_name": binding.mount_link,
-            "geometry_kind": item["geometry_kind"],
-            "dimensions_m": [_canon_float(value) for value in item["dimensions_m"]],
-            "position_m": [_canon_float(value) for value in binding.position_m],
-            "quaternion_xyzw": [_canon_float(value) for value in binding.quaternion_xyzw],
-        }
-        return item, _hash(canonical)
+        return item, _hash(_canonical_tool_payload(item, binding))
 
     def apply_and_verify(
         self,
@@ -76,10 +105,17 @@ class MoveItToolCollisionBridge:
             "tool_geometry_hash": geometry_hash,
             "binding_hash": binding.fingerprint,
         }
-        payload_path = self.work_dir / f"{materialization.fingerprint}.{binding.fingerprint}.tool.json"
+        payload_path = self.work_dir / (
+            f"{materialization.fingerprint}.{binding.fingerprint}.tool.json"
+        )
         temporary = payload_path.with_suffix(payload_path.suffix + ".tmp")
         temporary.write_text(
-            json.dumps(payload, sort_keys=True, separators=(",", ":"), allow_nan=False),
+            json.dumps(
+                payload,
+                sort_keys=True,
+                separators=(",", ":"),
+                allow_nan=False,
+            ),
             encoding="utf-8",
         )
         temporary.replace(payload_path)
@@ -101,6 +137,16 @@ class MoveItToolCollisionBridge:
             raise SimulationPlatformError("tool_scene_probe_output_invalid") from exc
         if not isinstance(output, dict):
             raise SimulationPlatformError("tool_scene_probe_output_invalid")
+
+        # Preserve the exact target read-back evidence even on failure. This keeps
+        # target-specific MoveIt serialization visible instead of collapsing it into
+        # a generic top-level qualification code.
+        output_path = payload_path.with_suffix(".probe.json")
+        output_path.write_text(
+            json.dumps(output, sort_keys=True, indent=2, allow_nan=False) + "\n",
+            encoding="utf-8",
+        )
+
         receipt = ToolCollisionReceipt(
             verified=bool(output.get("success")) and result.ok,
             code=str(output.get("code") or "tool_scene_probe_failed"),
@@ -121,7 +167,9 @@ class MoveItToolCollisionBridge:
             ),
         )
         if not receipt.verified:
-            raise SimulationPlatformError(f"tool_collision_verification_failed:{receipt.code}")
+            raise SimulationPlatformError(
+                f"tool_collision_verification_failed:{receipt.code}"
+            )
         if receipt.observed_link != binding.mount_link:
             raise SimulationPlatformError("tool_collision_mount_link_mismatch")
         return receipt

devagent_physical_engine-0.12.4/src/devagent_physical_engine/ros2/tool_scene_probe.py

@@ -0,0 +1,365 @@
+from __future__ import annotations
+
+import argparse
+from hashlib import sha256
+import json
+from math import isfinite, sqrt
+from pathlib import Path
+from typing import Any
+
+
+def _canon_float(value: float) -> float:
+    value = float(value)
+    if not isfinite(value):
+        raise ValueError("tool_pose_non_finite")
+    return 0.0 if abs(value) < 1e-12 else float(format(value, ".12g"))
+
+
+def _hash(payload: object) -> str:
+    text = json.dumps(payload, sort_keys=True, separators=(",", ":"), allow_nan=False)
+    return sha256(text.encode("utf-8")).hexdigest()
+
+
+def _qnorm(values):
+    values = tuple(float(value) for value in values)
+    if len(values) != 4 or any(not isfinite(value) for value in values):
+        raise ValueError("tool_quaternion_invalid")
+    norm = sqrt(sum(value * value for value in values))
+    if norm <= 0:
+        raise ValueError("tool_quaternion_zero")
+    return tuple(value / norm for value in values)
+
+
+def _qcanonical(values):
+    """Canonicalize equivalent q/-q rotations to one deterministic representation."""
+
+    quaternion = _qnorm(values)
+    # Prefer positive w. For exact 180-degree rotations where w == 0, use the first
+    # non-zero xyz component as the deterministic sign discriminator.
+    for component in (quaternion[3], quaternion[0], quaternion[1], quaternion[2]):
+        if abs(component) <= 1e-15:
+            continue
+        if component < 0.0:
+            quaternion = tuple(-value for value in quaternion)
+        break
+    return tuple(_canon_float(value) for value in quaternion)
+
+
+def _qmul(first, second):
+    ax, ay, az, aw = first
+    bx, by, bz, bw = second
+    return (
+        aw * bx + ax * bw + ay * bz - az * by,
+        aw * by - ax * bz + ay * bw + az * bx,
+        aw * bz + ax * by - ay * bx + az * bw,
+        aw * bw - ax * bx - ay * by - az * bz,
+    )
+
+
+def _qconj(quaternion):
+    return (-quaternion[0], -quaternion[1], -quaternion[2], quaternion[3])
+
+
+def _qrot(quaternion, vector):
+    quaternion = _qnorm(quaternion)
+    output = _qmul(
+        _qmul(quaternion, (vector[0], vector[1], vector[2], 0.0)),
+        _qconj(quaternion),
+    )
+    return output[:3]
+
+
+def _compose(first_position, first_q, second_position, second_q):
+    """Compose object pose with a shape pose as defined by CollisionObject.msg."""
+
+    first_q = _qnorm(first_q)
+    second_q = _qnorm(second_q)
+    rotated = _qrot(first_q, second_position)
+    position = tuple(
+        float(first_position[index]) + rotated[index] for index in range(3)
+    )
+    return position, _qcanonical(_qmul(first_q, second_q))
+
+
+def _pose_from_msg(pose):
+    return (
+        (
+            float(pose.position.x),
+            float(pose.position.y),
+            float(pose.position.z),
+        ),
+        (
+            float(pose.orientation.x),
+            float(pose.orientation.y),
+            float(pose.orientation.z),
+            float(pose.orientation.w),
+        ),
+    )
+
+
+def _pose_payload(position, quaternion) -> dict[str, list[float]]:
+    return {
+        "position_m": [_canon_float(value) for value in position],
+        "quaternion_xyzw": list(_qcanonical(quaternion)),
+    }
+
+
+def _canonical_tool(
+    item: dict[str, Any], *, link_name: str, position, quaternion
+) -> dict[str, Any]:
+    return {
+        "id": str(item["id"]),
+        "link_name": link_name,
+        "geometry_kind": str(item["geometry_kind"]),
+        "dimensions_m": [_canon_float(value) for value in item["dimensions_m"]],
+        "position_m": [_canon_float(value) for value in position],
+        "quaternion_xyzw": list(_qcanonical(quaternion)),
+    }
+
+
+def _primitive(item, SolidPrimitive):
+    primitive = SolidPrimitive()
+    dimensions = [float(value) for value in item["dimensions_m"]]
+    kind = str(item["geometry_kind"])
+    if kind == "box":
+        primitive.type = SolidPrimitive.BOX
+        primitive.dimensions = dimensions
+    elif kind == "cylinder":
+        primitive.type = SolidPrimitive.CYLINDER
+        primitive.dimensions = [dimensions[1], dimensions[0]]
+    else:
+        raise ValueError(f"unsupported_tool_geometry:{kind}")
+    return primitive
+
+
+def _wait_future(node, future, timeout_s: float) -> bool:
+    import rclpy
+
+    rclpy.spin_until_future_complete(node, future, timeout_sec=timeout_s)
+    return future.done()
+
+
+def apply_verify(path: Path, timeout_s: float) -> dict[str, Any]:
+    payload = json.loads(path.read_text(encoding="utf-8"))
+    item = dict(payload["tool"])
+    link_name = str(payload["mount_link"])
+    touch_links = [str(value) for value in payload.get("touch_links", [link_name])]
+    position = tuple(float(value) for value in payload["position_m"])
+    quaternion = _qcanonical(payload["quaternion_xyzw"])
+    expected_hash = str(payload["tool_geometry_hash"])
+
+    computed_expected_hash = _hash(
+        _canonical_tool(
+            item,
+            link_name=link_name,
+            position=position,
+            quaternion=quaternion,
+        )
+    )
+    if computed_expected_hash != expected_hash:
+        return {
+            "success": False,
+            "code": "tool_payload_hash_mismatch",
+            "expected_attachment_hash": expected_hash,
+            "computed_expected_attachment_hash": computed_expected_hash,
+        }
+
+    import rclpy
+    from geometry_msgs.msg import Pose
+    from moveit_msgs.msg import (
+        AttachedCollisionObject,
+        CollisionObject,
+        PlanningScene,
+        PlanningSceneComponents,
+    )
+    from moveit_msgs.srv import ApplyPlanningScene, GetPlanningScene
+    from shape_msgs.msg import SolidPrimitive
+
+    rclpy.init()
+    node = rclpy.create_node("devagent_tool_scene_probe")
+    apply_client = node.create_client(ApplyPlanningScene, "/apply_planning_scene")
+    get_client = node.create_client(GetPlanningScene, "/get_planning_scene")
+    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"}
+
+        collision = CollisionObject()
+        collision.header.frame_id = link_name
+        collision.id = str(item["id"])
+        collision.operation = CollisionObject.ADD
+        collision.pose = Pose()
+        collision.pose.position.x = position[0]
+        collision.pose.position.y = position[1]
+        collision.pose.position.z = position[2]
+        collision.pose.orientation.x = quaternion[0]
+        collision.pose.orientation.y = quaternion[1]
+        collision.pose.orientation.z = quaternion[2]
+        collision.pose.orientation.w = quaternion[3]
+        identity = Pose()
+        identity.orientation.w = 1.0
+        collision.primitives = [_primitive(item, SolidPrimitive)]
+        collision.primitive_poses = [identity]
+
+        attached = AttachedCollisionObject()
+        attached.link_name = link_name
+        attached.touch_links = touch_links
+        attached.object = collision
+
+        scene = PlanningScene()
+        scene.is_diff = True
+        scene.robot_state.is_diff = True
+        scene.robot_state.attached_collision_objects.append(attached)
+        request = ApplyPlanningScene.Request()
+        request.scene = scene
+        future = apply_client.call_async(request)
+        if not _wait_future(node, future, timeout_s):
+            return {"success": False, "code": "tool_apply_timeout"}
+        response = future.result()
+        if response is None or not response.success:
+            return {"success": False, "code": "tool_apply_rejected"}
+
+        get_request = GetPlanningScene.Request()
+        get_request.components.components = (
+            PlanningSceneComponents.ROBOT_STATE_ATTACHED_OBJECTS
+        )
+        future = get_client.call_async(get_request)
+        if not _wait_future(node, future, timeout_s):
+            return {"success": False, "code": "tool_readback_timeout"}
+        response = future.result()
+        if response is None:
+            return {"success": False, "code": "tool_readback_empty"}
+
+        matches = [
+            value
+            for value in response.scene.robot_state.attached_collision_objects
+            if value.object.id == str(item["id"])
+        ]
+        if len(matches) != 1:
+            return {
+                "success": False,
+                "code": "tool_attachment_readback_count_mismatch",
+                "observed_attachment_count": len(matches),
+            }
+        observed_attachment = matches[0]
+        if observed_attachment.link_name != link_name:
+            return {
+                "success": False,
+                "code": "tool_attachment_link_mismatch",
+                "observed_link": observed_attachment.link_name,
+                "expected_link": link_name,
+            }
+
+        observed = observed_attachment.object
+        observed_header_frame = str(observed.header.frame_id)
+        if observed_header_frame != link_name:
+            return {
+                "success": False,
+                "code": "tool_attachment_frame_mismatch",
+                "observed_link": observed_attachment.link_name,
+                "observed_header_frame": observed_header_frame,
+                "expected_header_frame": link_name,
+            }
+        if observed.operation != CollisionObject.ADD:
+            return {
+                "success": False,
+                "code": "tool_attachment_operation_mismatch",
+                "observed_operation": int(observed.operation),
+            }
+        if len(observed.primitives) != 1 or len(observed.primitive_poses) != 1:
+            return {
+                "success": False,
+                "code": "tool_attachment_shape_invalid",
+                "observed_primitive_count": len(observed.primitives),
+                "observed_primitive_pose_count": len(observed.primitive_poses),
+            }
+
+        primitive = observed.primitives[0]
+        if primitive.type == SolidPrimitive.BOX:
+            kind = "box"
+            dimensions = list(primitive.dimensions)
+        elif primitive.type == SolidPrimitive.CYLINDER:
+            kind = "cylinder"
+            dimensions = [
+                primitive.dimensions[SolidPrimitive.CYLINDER_RADIUS],
+                primitive.dimensions[SolidPrimitive.CYLINDER_HEIGHT],
+            ]
+        else:
+            return {
+                "success": False,
+                "code": "tool_attachment_shape_unsupported",
+                "observed_shape_type": int(primitive.type),
+            }
+
+        observed_item = {
+            "id": observed.id,
+            "geometry_kind": kind,
+            "dimensions_m": dimensions,
+        }
+        object_position, object_quaternion = _pose_from_msg(observed.pose)
+        primitive_position, primitive_quaternion = _pose_from_msg(
+            observed.primitive_poses[0]
+        )
+        effective_position, effective_quaternion = _compose(
+            object_position,
+            object_quaternion,
+            primitive_position,
+            primitive_quaternion,
+        )
+        observed_hash = _hash(
+            _canonical_tool(
+                observed_item,
+                link_name=link_name,
+                position=effective_position,
+                quaternion=effective_quaternion,
+            )
+        )
+        success = observed_hash == expected_hash
+        return {
+            "success": success,
+            "code": (
+                "tool_collision_verified"
+                if success
+                else "tool_collision_hash_mismatch"
+            ),
+            "expected_attachment_hash": expected_hash,
+            "observed_attachment_hash": observed_hash,
+            "observed_link": observed_attachment.link_name,
+            "observed_header_frame": observed_header_frame,
+            "observed_object_pose": _pose_payload(
+                object_position, object_quaternion
+            ),
+            "observed_primitive_pose": _pose_payload(
+                primitive_position, primitive_quaternion
+            ),
+            "observed_effective_pose": _pose_payload(
+                effective_position, effective_quaternion
+            ),
+        }
+    finally:
+        node.destroy_node()
+        rclpy.shutdown()
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--input", required=True)
+    parser.add_argument("--timeout", type=float, default=20.0)
+    args = parser.parse_args()
+    try:
+        result = apply_verify(
+            Path(args.input).expanduser().resolve(), float(args.timeout)
+        )
+    except Exception as exc:
+        result = {
+            "success": False,
+            "code": f"tool_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())

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devagent-physical-engine
-Version: 0.12.3
+Version: 0.12.4
 Summary: Verification-first agentic engineering, simulation, and evidence runtime for robotics and industrial automation.
 Author: Tom Ha
 License: All Rights Reserved
@@ -195,6 +195,8 @@ v0.12.2 additionally hardens Gazebo model-pose read-back across Harmonic CLI ren
 
 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.
 
+v0.12.4 hardens attached-tool collision read-back against equivalent MoveIt `CollisionObject` pose decompositions. DevAgent now composes the object pose with the primitive pose, canonicalizes equivalent quaternion signs before hashing, and still requires the exact attachment link, object frame, shape, dimensions, operation, and effective geometry. Exact probe evidence is preserved beside the tool payload for target diagnostics; representation-only changes no longer create false mismatches, while physical geometry drift remains 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.
@@ -422,7 +424,7 @@ Detailed engineering documentation lives in the repository:
 
 ## Project status
 
-**v0.12.3 — Beta software / evidence-gated task-specific physical simulation.**
+**v0.12.4 — 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.3 → devagent_physical_engine-0.12.4}/src/devagent_physical_engine.egg-info/SOURCES.txt

@@ -140,6 +140,7 @@ tests/test_setup_profile.py
 tests/test_sim_real_qualification_v011.py
 tests/test_simulation_platform_v08.py
 tests/test_tool_collision_v011.py
+tests/test_tool_scene_v0124.py
 tests/test_trajectory_qualification_v09.py
 tests/test_twin_materialization_v10.py
 tests/test_twin_v08.py