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

{devagent_physical_engine-0.12.2/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.2
+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
@@ -193,6 +193,10 @@ v0.12.1 hardens the initial ROS joint-state snapshot by parsing `ros2 topic echo
 
 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.
+
+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.
@@ -420,7 +424,7 @@ Detailed engineering documentation lives in the repository:
 
 ## Project status
 
-**v0.12.2 — 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.2 → devagent_physical_engine-0.12.4}/README.md

@@ -152,6 +152,10 @@ v0.12.1 hardens the initial ROS joint-state snapshot by parsing `ros2 topic echo
 
 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.
+
+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.
@@ -379,7 +383,7 @@ Detailed engineering documentation lives in the repository:
 
 ## Project status
 
-**v0.12.2 — 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.2 → 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.2"
+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.2 → devagent_physical_engine-0.12.4}/src/devagent_physical_engine/__init__.py

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

{devagent_physical_engine-0.12.2 → devagent_physical_engine-0.12.4}/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.2 → devagent_physical_engine-0.12.4}/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.2 → 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