stateDiagram-v2
    [*] --> IDLE
    IDLE --> CHECK_READY: start
    CHECK_READY --> FEEDING: all ready
    FEEDING --> TRANSPORTING: one part confirmed
    TRANSPORTING --> INSPECTING: sensor confirmed + stop ack
    INSPECTING --> PICKING: class + route + transform valid
    INSPECTING --> REJECT: UNKNOWN / low confidence
    PICKING --> PLACING: robot + grip ack
    PLACING --> COMPLETE: placement ack
    CHECK_READY --> FAULT: subsystem unavailable
    FEEDING --> FAULT: timeout / double feed
    TRANSPORTING --> FAULT: timeout
    INSPECTING --> FAULT: camera lost
    PICKING --> FAULT: robot/gripper timeout
    FAULT --> RECOVERY_REQUIRED: safe stop
    RECOVERY_REQUIRED --> IDLE: manual reconciliation

# safe-smoke
def decision(label: str, confidence: float, routes: dict[str, str], threshold: float) -> tuple[str, str | None]:
    if label not in routes or confidence < threshold:
        return "REJECT", None
    return "ACCEPT", routes[label]

routes = {"red-cylinder": "BOX_A", "blue-cube": "BOX_B"}
assert decision("red-cylinder", 0.90, routes, 0.80) == ("ACCEPT", "BOX_A")
assert decision("red-cylinder", 0.79, routes, 0.80) == ("REJECT", None)
assert decision("UNKNOWN", 1.00, routes, 0.80) == ("REJECT", None)
print("safe-smoke: accept/reject gate PASS")

{
  "mode":"simulation-only",
  "confidence_min":0.80,
  "timeouts":{"feed":3,"transport":4,"robot":3,"gripper":2},
  "routes":{"red-cylinder":"BOX_A","blue-cube":"BOX_B"},
  "reject_zone":"MANUAL_REVIEW"
}

[
  {"id":"normal","ready":true,"feed":2,"transport":3,"camera":true,"label":"red-cylinder","confidence":0.92,"robot":2,"gripper":1,"grip_ok":true,"restart":false},
  {"id":"unknown","ready":true,"feed":1,"transport":1,"camera":true,"label":"UNKNOWN","confidence":0.35,"robot":0,"gripper":0,"grip_ok":false,"restart":false},
  {"id":"camera-lost","ready":true,"feed":1,"transport":1,"camera":false,"label":"red-cylinder","confidence":0.95,"robot":0,"gripper":0,"grip_ok":false,"restart":false},
  {"id":"robot-timeout","ready":true,"feed":1,"transport":1,"camera":true,"label":"blue-cube","confidence":0.90,"robot":4,"gripper":1,"grip_ok":true,"restart":false},
  {"id":"grip-fail","ready":true,"feed":1,"transport":1,"camera":true,"label":"blue-cube","confidence":0.90,"robot":1,"gripper":1,"grip_ok":false,"restart":false},
  {"id":"sensor-timeout","ready":true,"feed":1,"transport":5,"camera":true,"label":"red-cylinder","confidence":0.90,"robot":1,"gripper":1,"grip_ok":true,"restart":false},
  {"id":"restart-mid-cycle","ready":true,"feed":1,"transport":1,"camera":true,"label":"red-cylinder","confidence":0.90,"robot":1,"gripper":1,"grip_ok":true,"restart":true}
]

from __future__ import annotations

import argparse
import json
from dataclasses import asdict, dataclass, field
from enum import Enum
from pathlib import Path


class State(str, Enum):
    IDLE="IDLE"; CHECK_READY="CHECK_READY"; FEEDING="FEEDING"
    TRANSPORTING="TRANSPORTING"; INSPECTING="INSPECTING"
    PICKING="PICKING"; PLACING="PLACING"; COMPLETE="COMPLETE"
    REJECT="REJECT"; FAULT="FAULT"; RECOVERY_REQUIRED="RECOVERY_REQUIRED"


@dataclass
class Outcome:
    case_id: str
    state: str
    reason: str
    route: str | None
    outputs: dict[str, str]
    transitions: list[str] = field(default_factory=list)


class MockCell:
    def __init__(self, cfg: dict) -> None:
        if cfg.get("mode") != "simulation-only":
            raise ValueError("only simulation-only mode")
        self.cfg = cfg
        self.state = State.IDLE
        self.outputs = {"feeder":"STOP", "conveyor":"STOP", "robot":"NO_GOAL", "gripper":"STOP"}
        self.log: list[str] = []
        self.reason = ""

    def move(self, target: State, reason: str) -> None:
        self.log.append(f"{self.state.value}->{target.value}:{reason}")
        self.state = target

    def safe_stop(self) -> None:
        self.outputs.update(feeder="STOP", conveyor="STOP", robot="NO_NEW_GOAL", gripper="HOLD_OR_STOP")

    def fail(self, reason: str) -> None:
        self.reason = reason
        self.safe_stop()
        self.move(State.FAULT, reason)
        self.move(State.RECOVERY_REQUIRED, "manual-reconciliation-required")

    def run(self, case: dict) -> Outcome:
        self.move(State.CHECK_READY, "start")
        if not bool(case["ready"]):
            self.fail("subsystem-not-ready")
        else:
            self.move(State.FEEDING, "all-ready")
            self.outputs["feeder"] = "RUN"
        if self.state is State.FEEDING:
            if int(case["feed"]) > int(self.cfg["timeouts"]["feed"]):
                self.fail("feed-timeout")
            else:
                self.outputs.update(feeder="STOP", conveyor="RUN")
                self.move(State.TRANSPORTING, "one-part-confirmed")
        if self.state is State.TRANSPORTING:
            if int(case["transport"]) > int(self.cfg["timeouts"]["transport"]):
                self.fail("sensor-timeout")
            else:
                self.outputs["conveyor"] = "STOP"
                self.move(State.INSPECTING, "part-stopped")
        if self.state is State.INSPECTING:
            if bool(case["restart"]):
                self.fail("restart-mid-cycle")
            elif not bool(case["camera"]):
                self.fail("camera-lost")
            elif str(case["label"]) not in self.cfg["routes"] or float(case["confidence"]) < float(self.cfg["confidence_min"]):
                self.reason = "classification-rejected"
                self.move(State.REJECT, self.reason)
            else:
                self.move(State.PICKING, "route-and-transform-valid")
                self.outputs["robot"] = "MOCK_GOAL"
        if self.state is State.PICKING:
            if int(case["robot"]) > int(self.cfg["timeouts"]["robot"]):
                self.fail("robot-timeout")
            elif int(case["gripper"]) > int(self.cfg["timeouts"]["gripper"]) or not bool(case["grip_ok"]):
                self.fail("grip-not-confirmed")
            else:
                self.outputs.update(robot="MOCK_GOAL_DONE", gripper="MOCK_GRIPPED")
                self.move(State.PLACING, "pick-confirmed")
        route = None
        if self.state is State.PLACING:
            route = str(self.cfg["routes"][str(case["label"])])
            self.outputs.update(robot="NO_GOAL", gripper="STOP")
            self.move(State.COMPLETE, f"placed-symbolically:{route}")
        elif self.state is State.REJECT:
            route = str(self.cfg["reject_zone"])
            self.safe_stop()
        assert self.outputs["feeder"] == self.outputs["conveyor"] == "STOP"
        return Outcome(str(case["id"]), self.state.value, self.reason or "ok", route, dict(self.outputs), list(self.log))

    def recover(self, operator_ack: bool, reconciled: bool, area_clear: bool) -> bool:
        if self.state is not State.RECOVERY_REQUIRED or not (operator_ack and reconciled and area_clear):
            return False
        self.safe_stop()
        self.move(State.IDLE, "manual-recovery")
        return True


def main() -> int:
    p = argparse.ArgumentParser()
    p.add_argument("--config", type=Path, required=True); p.add_argument("--cases", type=Path, required=True)
    p.add_argument("--out", type=Path, required=True); args = p.parse_args()
    cfg = json.loads(args.config.read_text(encoding="utf-8"))
    cases = json.loads(args.cases.read_text(encoding="utf-8"))
    results: list[Outcome] = []
    for case in cases:
        cell = MockCell(cfg); result = cell.run(case); results.append(result)
        if result.state == "RECOVERY_REQUIRED":
            assert not cell.recover(False, True, True)
            assert cell.recover(True, True, True)
    states = {r.case_id:r.state for r in results}
    assert states["normal"] == "COMPLETE" and states["unknown"] == "REJECT"
    for key in ("camera-lost","robot-timeout","grip-fail","sensor-timeout","restart-mid-cycle"):
        assert states[key] == "RECOVERY_REQUIRED"
    args.out.write_text(json.dumps([asdict(r) for r in results], ensure_ascii=False, indent=2), encoding="utf-8")
    print("PASS: COMPLETE=1 REJECT=1 RECOVERY_REQUIRED=5")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

python lab21_sorting.py --config lab21-config.json --cases lab21-cases.json --out lab21-results.json