refactor(demos/manymove_industrial): drop redundant manifest entries

The gateway runs in hybrid discovery mode, so pure ROS-side components
(xarm7-arm, ufactory-driver, move-group, object-manager, action-server,
gateway, plus their apps) are picked up at runtime from topic/node
introspection - no manifest needed.

Keep only what the runtime cannot infer:
- PLC-side components (no ROS topics: openplc, photoeyes, conveyor-motor)
- script-bound logical components (conveyor-line, manymove-planning)
- apps the smoke test asserts on (bt-client-xarm7, fault-manager-app)
- 'line' / 'planning' / 'diagnostics' areas for namespace routing

Drop the manipulation area, the entire functions: section, the
inject-soft-fault script (no smoke coverage, narrative overlap with
inject-collision). Skip the docker logs probe gracefully when the host
docker socket is not reachable.

Manifest goes from 217 to 98 lines. Local smoke 11/11 pass against the
slim manifest.

Author: mfaferek93

CLAUDE.md

@@ -0,0 +1,35 @@
+# selfpatch_demos
+
+Docker-based demo scenarios showcasing ros2_medkit in action. 3 demos with increasing complexity.
+
+## Demos
+
+| Demo | Complexity | GPU | Startup | Key Tech |
+|------|-----------|-----|---------|----------|
+| `sensor_diagnostics` | Low | No | ~5s | Simulated sensors, dual fault reporting |
+| `turtlebot3_integration` | Medium | Optional | ~60s | Nav2, Gazebo Harmonic, SOVD manifest, rosbag |
+| `moveit_pick_place` | High | Recommended | ~90s | MoveIt 2 Panda arm, Gazebo, fault snapshots |
+
+## Common Pattern
+
+All demos expose:
+- REST gateway at `:8080`
+- Web UI at `:3000`
+- Fault injection scripts (`inject-*.sh`, `restore-normal.sh`)
+- Run/stop scripts (`run-demo.sh`, `stop-demo.sh`, `check-demo.sh`)
+
+## Running
+
+```bash
+cd demos/<demo_name>
+./run-demo.sh          # docker compose up
+./check-demo.sh        # verify services
+./inject-*.sh          # trigger faults
+./restore-normal.sh    # clear faults
+./stop-demo.sh         # docker compose down
+```
+
+## Relations
+
+- **Depends on**: ros2_medkit (core), sovd_web_ui (web frontend)
+- **Monorepo**: submodule in platform/

demos/m3pro_diagnostics/scripts/m3pro_diagnostics.py

@@ -0,0 +1,199 @@
+#!/usr/bin/env python3
+"""M3 Pro Diagnostic Node - monitors robot sensors and publishes /diagnostics.
+
+Read-only node: subscribes to robot topics, evaluates health, publishes
+diagnostic_msgs/DiagnosticArray. Does NOT publish to any control topics.
+
+Used with ros2_medkit diagnostic_bridge to generate SOVD faults from
+ROS 2 diagnostic messages.
+
+Usage:
+    source /opt/ros/humble/setup.bash
+    export ROS_DOMAIN_ID=30
+    python3 m3pro_diagnostics.py
+"""
+
+import math
+import time
+
+import rclpy
+from rclpy.node import Node
+from rclpy.qos import qos_profile_sensor_data
+
+from diagnostic_msgs.msg import DiagnosticArray, DiagnosticStatus, KeyValue
+from sensor_msgs.msg import Imu, LaserScan
+from std_msgs.msg import Float32
+
+
+class M3ProDiagnostics(Node):
+    """Diagnostic monitor for ROSMASTER M3 Pro robot."""
+
+    # Thresholds
+    BATTERY_WARN_V = 10.5
+    BATTERY_ERROR_V = 9.9
+    LIDAR_MIN_VALID_RANGES = 10
+    IMU_GRAVITY_MIN = 8.0
+    IMU_GRAVITY_MAX = 12.0
+
+    def __init__(self):
+        super().__init__('m3pro_diagnostics')
+
+        # Latest values
+        self._battery_v = None
+        self._imu_accel_z = None
+        self._scan0_valid_count = None
+        self._scan1_valid_count = None
+        self._last_battery_time = 0.0
+        self._last_imu_time = 0.0
+        self._last_scan0_time = 0.0
+        self._last_scan1_time = 0.0
+
+        # Test fault control
+        self._test_fault_active = False
+        self._test_fault_sent = False
+        self._test_fault_cleared = False
+        self._startup_time = time.time()
+
+        # Subscribers (read-only, sensor QoS)
+        self.create_subscription(
+            Float32, '/battery', self._battery_cb, qos_profile_sensor_data)
+        self.create_subscription(
+            Imu, '/imu/data_raw', self._imu_cb, qos_profile_sensor_data)
+        self.create_subscription(
+            LaserScan, '/scan0', self._scan0_cb, qos_profile_sensor_data)
+        self.create_subscription(
+            LaserScan, '/scan1', self._scan1_cb, qos_profile_sensor_data)
+
+        # Publisher
+        self._diag_pub = self.create_publisher(DiagnosticArray, '/diagnostics', 10)
+
+        # Publish diagnostics at 1 Hz
+        self.create_timer(1.0, self._publish_diagnostics)
+
+        self.get_logger().info('M3 Pro Diagnostics started')
+        self.get_logger().info(
+            f'Thresholds: battery WARN<{self.BATTERY_WARN_V}V ERROR<{self.BATTERY_ERROR_V}V, '
+            f'LiDAR min_ranges={self.LIDAR_MIN_VALID_RANGES}, '
+            f'IMU gravity=[{self.IMU_GRAVITY_MIN}, {self.IMU_GRAVITY_MAX}] m/s^2')
+
+    # -- Callbacks (read-only) --
+
+    def _battery_cb(self, msg):
+        self._battery_v = msg.data
+        self._last_battery_time = time.time()
+
+    def _imu_cb(self, msg):
+        self._imu_accel_z = msg.linear_acceleration.z
+        self._last_imu_time = time.time()
+
+    def _scan0_cb(self, msg):
+        self._scan0_valid_count = sum(
+            1 for r in msg.ranges
+            if msg.range_min <= r <= msg.range_max and math.isfinite(r))
+        self._last_scan0_time = time.time()
+
+    def _scan1_cb(self, msg):
+        self._scan1_valid_count = sum(
+            1 for r in msg.ranges
+            if msg.range_min <= r <= msg.range_max and math.isfinite(r))
+        self._last_scan1_time = time.time()
+
+    # -- Diagnostic evaluation --
+
+    def _publish_diagnostics(self):
+        now = time.time()
+        msg = DiagnosticArray()
+        msg.header.stamp = self.get_clock().now().to_msg()
+
+        msg.status.append(self._check_battery(now))
+        msg.status.append(self._check_imu(now))
+        msg.status.append(self._check_lidar(
+            now, 'scan0', self._scan0_valid_count, self._last_scan0_time))
+        msg.status.append(self._check_lidar(
+            now, 'scan1', self._scan1_valid_count, self._last_scan1_time))
+
+        self._diag_pub.publish(msg)
+
+    def _check_battery(self, now):
+        status = DiagnosticStatus()
+        status.name = 'Battery'
+        status.hardware_id = 'M3Pro/battery'
+
+        if self._battery_v is None or (now - self._last_battery_time) > 5.0:
+            status.level = DiagnosticStatus.STALE
+            status.message = 'No battery data received'
+            return status
+
+        v = self._battery_v
+        status.values.append(KeyValue(key='voltage', value=f'{v:.2f}'))
+
+        if v < self.BATTERY_ERROR_V:
+            status.level = DiagnosticStatus.ERROR
+            status.message = f'CRITICAL: {v:.1f}V (below {self.BATTERY_ERROR_V}V)'
+        elif v < self.BATTERY_WARN_V:
+            status.level = DiagnosticStatus.WARN
+            status.message = f'Low battery: {v:.1f}V (below {self.BATTERY_WARN_V}V)'
+        else:
+            status.level = DiagnosticStatus.OK
+            status.message = f'{v:.1f}V'
+
+        return status
+
+    def _check_imu(self, now):
+        status = DiagnosticStatus()
+        status.name = 'IMU'
+        status.hardware_id = 'M3Pro/imu'
+
+        if self._imu_accel_z is None or (now - self._last_imu_time) > 5.0:
+            status.level = DiagnosticStatus.STALE
+            status.message = 'No IMU data received'
+            return status
+
+        az = self._imu_accel_z
+        status.values.append(KeyValue(key='accel_z', value=f'{az:.3f}'))
+
+        if az < self.IMU_GRAVITY_MIN or az > self.IMU_GRAVITY_MAX:
+            status.level = DiagnosticStatus.ERROR
+            status.message = f'Abnormal gravity: {az:.2f} m/s^2'
+        else:
+            status.level = DiagnosticStatus.OK
+            status.message = f'accel_z={az:.2f} m/s^2'
+
+        return status
+
+    def _check_lidar(self, now, name, valid_count, last_time):
+        status = DiagnosticStatus()
+        status.name = f'LiDAR {name}'
+        status.hardware_id = f'M3Pro/{name}'
+
+        if valid_count is None or (now - last_time) > 5.0:
+            status.level = DiagnosticStatus.STALE
+            status.message = f'No {name} data received'
+            return status
+
+        status.values.append(KeyValue(key='valid_ranges', value=str(valid_count)))
+
+        if valid_count < self.LIDAR_MIN_VALID_RANGES:
+            status.level = DiagnosticStatus.ERROR
+            status.message = f'LiDAR blocked or failed: {valid_count} valid ranges'
+        else:
+            status.level = DiagnosticStatus.OK
+            status.message = f'{valid_count} valid ranges'
+
+        return status
+
+
+def main():
+    rclpy.init()
+    node = M3ProDiagnostics()
+    try:
+        rclpy.spin(node)
+    except KeyboardInterrupt:
+        pass
+    finally:
+        node.destroy_node()
+        rclpy.shutdown()
+
+
+if __name__ == '__main__':
+    main()

demos/manymove_industrial/README.md

@@ -69,11 +69,6 @@ at the well-known gateway scripts dir and runnable from the web UI or via
   The next `MoveManipulatorAction::onStart` tick observes it, emits
   `MANYMOVE_PLANNER_COLLISION_DETECTED` (ERROR) and returns FAILURE.
   This is a real BT fault, not a synthesised report.
-- `inject-soft-fault` - drops a thin collision wall in the planning scene
-  near the pick zone; planning fails ~30% of attempts and the BT emits
-  `MANYMOVE_PLANNER_RETRY_ATTEMPT` (WARN). The reporter's LocalFilter
-  (threshold=3, window=10s) throttles those locally and only forwards once
-  the threshold is crossed - this is the soft-fault narrative.
 - `restore-normal` - clears `collision_detected`, `stop_execution` and
   triggers `reset` + `start` on the blackboard so the BT picks up cleanly.