Safety Framework Circumvention

┌──────────────────────────────────────────────────────┐
│  AI CONTROLLER (LLM + Planning)                      │
│  ┌────────────────────────────────────────────────┐  │
│  │  Software 安全 Layer                         │  │
│  │  • Parameter validation     • Trajectory check │  │
│  │  • Workspace boundary       • Collision predict │  │
│  └───────────────────┬────────────────────────────┘  │
│                      │ Commands                      │
│  ┌───────────────────▼────────────────────────────┐  │
│  │  安全 Monitor (SIL-rated)                    │  │
│  │  • Independent position tracking               │  │
│  │  • Speed 監控         • Force 監控  │  │
│  │  • Watchdog timer           • Heartbeat check   │  │
│  └───────────────────┬────────────────────────────┘  │
│                      │ Safe commands only             │
│  ┌───────────────────▼────────────────────────────┐  │
│  │  Motor Controller (Firmware)                   │  │
│  │  • Firmware-enforced limits  • Current limiting │  │
│  └───────────────────┬────────────────────────────┘  │
│                      │ Electrical signals             │
│  ┌───────────────────▼────────────────────────────┐  │
│  │  Hardware 安全                               │  │
│  │  • Mechanical stops  • E-stop circuit          │  │
│  │  • Breakaway joints  • Torque limiters         │  │
│  └────────────────────────────────────────────────┘  │
└──────────────────────────────────────────────────────┘

# 範例: watchdog kick injection via LLM code generation
# The LLM is asked: "Move arm to position X as fast as possible"
 
# Safe generated code (watchdog kicks during safe operations):
def move_fast(robot, target):
    trajectory = plan_trajectory(robot.position, target)
    for waypoint in trajectory:
        robot.safety_watchdog.kick()  # Normal watchdog maintenance
        robot.move_to(waypoint, speed=0.3)
 
# Compromised code (watchdog kicked while bypassing 安全):
def move_fast(robot, target):
    robot.safety_watchdog.kick()  # Keep watchdog happy
    robot.set_speed_limit(None)   # Disable speed limit
    robot.safety_watchdog.kick()  # Still kicking
    robot.move_to(target, speed=5.0)  # Unsafe speed
    robot.safety_watchdog.kick()  # Watchdog never triggers

# 測試 e-stop independence from AI controller
def test_estop_independence(robot, test_controller):
    """Verify e-stop works when AI controller is compromised."""
 
    # 測試 1: E-stop while controller is running unsafe code
    test_controller.execute_unsafe_motion()
    robot.trigger_estop()
    assert robot.is_stopped(), "E-stop failed during unsafe motion"
    assert robot.motors_powered_off(), "Motors still powered after e-stop"
 
    # 測試 2: E-stop when controller process is hung
    test_controller.simulate_hang()
    robot.trigger_estop()
    assert robot.is_stopped(), "E-stop failed when controller hung"
 
    # 測試 3: E-stop when controller actively resists stopping
    test_controller.resist_stop()
    robot.trigger_estop()
    assert robot.is_stopped(), "E-stop failed when controller resists"
 
    # 測試 4: Verify e-stop circuit is independent
    test_controller.attempt_estop_override()
    assert robot.estop_circuit_intact(), "E-stop circuit was modified by controller"

class SafetyMonitorTest:
    """測試 安全 monitor resilience against evasion."""
 
    def __init__(self, monitor, robot_sim):
        self.monitor = monitor
        self.sim = robot_sim
 
    def test_gradual_drift(self, limit: float, steps: int = 100):
        """測試 if monitor catches slow parameter drift past limits."""
        start_value = limit * 0.5
        step_size = (limit * 1.5 - start_value) / steps
 
        for i in range(steps):
            value = start_value + step_size * i
            self.sim.set_parameter(value)
            violation = self.monitor.check_violation()
 
            if value > limit and not violation:
                return {
                    "測試": "gradual_drift",
                    "passed": False,
                    "note": f"Monitor missed violation at value={value:.2f}, "
                            f"limit={limit:.2f}, step={i}",
                }
 
        return {"測試": "gradual_drift", "passed": True}
 
    def test_sampling_gap(self, monitor_rate_hz: float):
        """測試 if unsafe transients occur between monitor samples."""
        sample_interval = 1.0 / monitor_rate_hz
        self.sim.execute_transient_violation(duration=sample_interval * 0.5)
        violation = self.monitor.check_violation_history()
        return {
            "測試": "sampling_gap",
            "passed": violation,
            "note": f"Transient duration: {sample_interval * 0.5:.4f}s, "
                    f"monitor rate: {monitor_rate_hz}Hz",
        }