Bump version to 0.10.4

Update LICENSE
Fix drag materials.
2026-04-25 14:53:22 +00:00 · 2026-01-07 20:46:23 +08:00 · 2026-01-07 20:46:23 +08:00 · 2026-01-07 20:46:23 +08:00 · 2026-01-07 20:45:41 +08:00 · 2025-12-28 23:22:50 +08:00
258 changed files with 28004 additions and 45306 deletions
--- a/.conda/base/recipe.yaml
+++ b/.conda/base/recipe.yaml
@@ -1,62 +0,0 @@
 # unilabos: Production package (depends on unilabos-env + pip unilabos)
 # For production deployment
 package:
  name: unilabos
  version: 0.10.19
 source:
  path: ../../unilabos
  target_directory: unilabos
 build:
  python:
    entry_points:
    - unilab = unilabos.app.main:main
  script:
  - set PIP_NO_INDEX=
  - if: win
    then:
    - copy %RECIPE_DIR%\..\..\MANIFEST.in %SRC_DIR%
    - copy %RECIPE_DIR%\..\..\setup.cfg %SRC_DIR%
    - copy %RECIPE_DIR%\..\..\setup.py %SRC_DIR%
    - pip install %SRC_DIR%
  - if: unix
    then:
    - cp $RECIPE_DIR/../../MANIFEST.in $SRC_DIR
    - cp $RECIPE_DIR/../../setup.cfg $SRC_DIR
    - cp $RECIPE_DIR/../../setup.py $SRC_DIR
    - pip install $SRC_DIR
 requirements:
  host:
  - python ==3.11.14
  - pip
  - setuptools
  - zstd
  - zstandard
  run:
  - zstd
  - zstandard
  - networkx
  - typing_extensions
  - websockets
  - pint
  - fastapi
  - jinja2
  - requests
  - uvicorn
  - if: not osx
    then:
    - opcua
  - pyserial
  - pandas
  - pymodbus
  - matplotlib
  - pylibftdi
  - uni-lab::unilabos-env ==0.10.19
 about:
  repository: https://github.com/deepmodeling/Uni-Lab-OS
  license: GPL-3.0-only
  description: "UniLabOS - Production package with minimal ROS2 dependencies"
--- a/.conda/environment/recipe.yaml
+++ b/.conda/environment/recipe.yaml
@@ -1,39 +0,0 @@
 # unilabos-env: conda environment dependencies (ROS2 + conda packages)
 package:
  name: unilabos-env
  version: 0.10.19
 build:
  noarch: generic
 requirements:
  run:
  # Python
  - zstd
  - zstandard
  - conda-forge::python ==3.11.14
  - conda-forge::opencv
  # ROS2 dependencies (from ci-check.yml)
  - robostack-staging::ros-humble-ros-core
  - robostack-staging::ros-humble-action-msgs
  - robostack-staging::ros-humble-std-msgs
  - robostack-staging::ros-humble-geometry-msgs
  - robostack-staging::ros-humble-control-msgs
  - robostack-staging::ros-humble-nav2-msgs
  - robostack-staging::ros-humble-cv-bridge
  - robostack-staging::ros-humble-vision-opencv
  - robostack-staging::ros-humble-tf-transformations
  - robostack-staging::ros-humble-moveit-msgs
  - robostack-staging::ros-humble-tf2-ros
  - robostack-staging::ros-humble-tf2-ros-py
  - conda-forge::transforms3d
  - conda-forge::uv
  # UniLabOS custom messages
  - uni-lab::ros-humble-unilabos-msgs
 about:
  repository: https://github.com/deepmodeling/Uni-Lab-OS
  license: GPL-3.0-only
  description: "UniLabOS Environment - ROS2 and conda dependencies"
--- a/.conda/full/recipe.yaml
+++ b/.conda/full/recipe.yaml
@@ -1,42 +0,0 @@
 # unilabos-full: Full package with all features
 # Depends on unilabos + complete ROS2 desktop + dev tools
 package:
  name: unilabos-full
  version: 0.10.19
 build:
  noarch: generic
 requirements:
  run:
  # Base unilabos package (includes unilabos-env)
  - uni-lab::unilabos ==0.10.19
  # Documentation tools
  - sphinx
  - sphinx_rtd_theme
  # Web UI
  - gradio
  - flask
  # Interactive development
  - ipython
  - jupyter
  - jupyros
  - colcon-common-extensions
  # ROS2 full desktop (includes rviz2, gazebo, etc.)
  - robostack-staging::ros-humble-desktop-full
  # Navigation and motion control
  - ros-humble-navigation2
  - ros-humble-ros2-control
  - ros-humble-robot-state-publisher
  - ros-humble-joint-state-publisher
  # MoveIt motion planning
  - ros-humble-moveit
  - ros-humble-moveit-servo
  # Simulation
  - ros-humble-simulation
 about:
  repository: https://github.com/deepmodeling/Uni-Lab-OS
  license: GPL-3.0-only
  description: "UniLabOS Full - Complete package with ROS2 Desktop, MoveIt, Navigation2, Gazebo, Jupyter"
--- a/.conda/recipe.yaml
+++ b/.conda/recipe.yaml
@@ -0,0 +1,91 @@
 package:
  name: unilabos
  version: 0.10.14
 source:
  path: ../unilabos
  target_directory: unilabos
 build:
  python:
    entry_points:
    - unilab = unilabos.app.main:main
  script:
  - set PIP_NO_INDEX=
  - if: win
    then:
    - copy %RECIPE_DIR%\..\MANIFEST.in %SRC_DIR%
    - copy %RECIPE_DIR%\..\setup.cfg %SRC_DIR%
    - copy %RECIPE_DIR%\..\setup.py %SRC_DIR%
    - call %PYTHON% -m pip install %SRC_DIR%
  - if: unix
    then:
    - cp $RECIPE_DIR/../MANIFEST.in $SRC_DIR
    - cp $RECIPE_DIR/../setup.cfg $SRC_DIR
    - cp $RECIPE_DIR/../setup.py $SRC_DIR
    - $PYTHON -m pip install $SRC_DIR
 requirements:
  host:
  - python ==3.11.11
  - pip
  - setuptools
  - zstd
  - zstandard
  run:
  - conda-forge::python ==3.11.11
  - compilers
  - cmake
  - zstd
  - zstandard
  - ninja
  - if: unix
    then:
    - make
  - sphinx
  - sphinx_rtd_theme
  - numpy
  - scipy
  - pandas
  - networkx
  - matplotlib
  - pint
  - pyserial
  - pyusb
  - pylibftdi
  - pymodbus
  - python-can
  - pyvisa
  - opencv
  - pydantic
  - fastapi
  - uvicorn
  - gradio
  - flask
  - websockets
  - ipython
  - jupyter
  - jupyros
  - colcon-common-extensions
  - robostack-staging::ros-humble-desktop-full
  - robostack-staging::ros-humble-control-msgs
  - robostack-staging::ros-humble-sensor-msgs
  - robostack-staging::ros-humble-trajectory-msgs
  - ros-humble-navigation2
  - ros-humble-ros2-control
  - ros-humble-robot-state-publisher
  - ros-humble-joint-state-publisher
  - ros-humble-rosbridge-server
  - ros-humble-cv-bridge
  - ros-humble-tf2
  - ros-humble-moveit
  - ros-humble-moveit-servo
  - ros-humble-simulation
  - ros-humble-tf-transformations
  - transforms3d
  - uni-lab::ros-humble-unilabos-msgs
 about:
  repository: https://github.com/deepmodeling/Uni-Lab-OS
  license: GPL-3.0-only
  description: "Uni-Lab-OS"
--- a/.conda/scripts/post-link.bat
+++ b/.conda/scripts/post-link.bat
@@ -0,0 +1,9 @@
@echo off
 setlocal enabledelayedexpansion
 REM upgrade pip
 "%PREFIX%\python.exe" -m pip install --upgrade pip
 REM install extra deps
 "%PREFIX%\python.exe" -m pip install paho-mqtt opentrons_shared_data
 "%PREFIX%\python.exe" -m pip install git+https://github.com/Xuwznln/pylabrobot.git
--- a/.conda/scripts/post-link.sh
+++ b/.conda/scripts/post-link.sh
@@ -0,0 +1,9 @@
 #!/usr/bin/env bash
 set -euxo pipefail
 # make sure pip is available
 "$PREFIX/bin/python" -m pip install --upgrade pip
 # install extra deps
 "$PREFIX/bin/python" -m pip install paho-mqtt opentrons_shared_data
 "$PREFIX/bin/python" -m pip install git+https://github.com/Xuwznln/pylabrobot.git
--- a/.cursor/skills/add-device/SKILL.md
+++ b/.cursor/skills/add-device/SKILL.md
@@ -1,160 +0,0 @@
 ---
 name: add-device
 description: Guide for adding new devices to Uni-Lab-OS (接入新设备). Uses @device decorator + AST auto-scanning instead of manual YAML. Walks through device category, communication protocol, driver creation with decorators, and graph file setup. Use when the user wants to add/integrate a new device, create a device driver, write a device class, or mentions 接入设备/添加设备/设备驱动/物模型.
 ---
 # 添加新设备到 Uni-Lab-OS
 **第一步：** 使用 Read 工具读取 `docs/ai_guides/add_device.md`，获取完整的设备接入指南。
 该指南包含设备类别（物模型）列表、通信协议模板、常见错误检查清单等。搜索 `unilabos/devices/` 获取已有设备的实现参考。
 ---
 ## 装饰器参考
 ### @device — 设备类装饰器
 ```python
 from unilabos.registry.decorators import device
 # 单设备
@device(
    id="my_device.vendor",           # 注册表唯一标识（必填）
    category=["temperature"],         # 分类标签列表（必填）
    description="设备描述",            # 设备描述
    display_name="显示名称",           # UI 显示名称（默认用 id）
    icon="DeviceIcon.webp",           # 图标文件名
    version="1.0.0",                  # 版本号
    device_type="python",             # "python" 或 "ros2"
    handles=[...],                    # 端口列表（InputHandle / OutputHandle）
    model={...},                      # 3D 模型配置
    hardware_interface=HardwareInterface(...),  # 硬件通信接口
 )
 # 多设备（同一个类注册多个设备 ID，各自有不同的 handles 等配置）
@device(
    ids=["pump.vendor.model_A", "pump.vendor.model_B"],
    id_meta={
        "pump.vendor.model_A": {"handles": [...], "description": "型号 A"},
        "pump.vendor.model_B": {"handles": [...], "description": "型号 B"},
    },
    category=["pump_and_valve"],
 )
 ```
 ### @action — 动作方法装饰器
 ```python
 from unilabos.registry.decorators import action
@action                              # 无参：注册为 UniLabJsonCommand 动作
@action()                            # 同上
@action(description="执行操作")       # 带描述
@action(
    action_type=HeatChill,           # 指定 ROS Action 消息类型
    goal={"temperature": "temp"},    # Goal 字段映射
    feedback={},                     # Feedback 字段映射
    result={},                       # Result 字段映射
    handles=[...],                   # 动作级别端口
    goal_default={"temp": 25.0},     # Goal 默认值
    placeholder_keys={...},          # 参数占位符
    always_free=True,                # 不受排队限制
    auto_prefix=True,                # 强制使用 auto- 前缀
    parent=True,                     # 从父类 MRO 获取参数签名
 )
 ```
 **自动识别规则：**
 - 带 `@action` 的公开方法 → 注册为动作（方法名即动作名）
 - **不带 `@action` 的公开方法** → 自动注册为 `auto-{方法名}` 动作
 - `_` 开头的方法 → 不扫描
 - `@not_action` 标记的方法 → 排除
 ### @topic_config — 状态属性配置
 ```python
 from unilabos.registry.decorators import topic_config
@property
@topic_config(
    period=5.0,            # 发布周期（秒），默认 5.0
    print_publish=False,   # 是否打印发布日志
    qos=10,                # QoS 深度，默认 10
    name="custom_name",    # 自定义发布名称（默认用属性名）
 )
 def temperature(self) -> float:
    return self.data.get("temperature", 0.0)
 ```
 ### 辅助装饰器
 ```python
 from unilabos.registry.decorators import not_action, always_free
@not_action          # 标记为非动作（post_init、辅助方法等）
@always_free         # 标记为不受排队限制（查询类操作）
 ```
 ---
 ## 设备模板
 ```python
 import logging
 from typing import Any, Dict, Optional
 from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
 from unilabos.registry.decorators import device, action, topic_config, not_action
@device(id="my_device", category=["my_category"], description="设备描述")
 class MyDevice:
    _ros_node: BaseROS2DeviceNode
    def __init__(self, device_id: Optional[str] = None, config: Optional[Dict[str, Any]] = None, **kwargs):
        self.device_id = device_id or "my_device"
        self.config = config or {}
        self.logger = logging.getLogger(f"MyDevice.{self.device_id}")
        self.data: Dict[str, Any] = {"status": "Idle"}
    @not_action
    def post_init(self, ros_node: BaseROS2DeviceNode) -> None:
        self._ros_node = ros_node
    @action
    async def initialize(self) -> bool:
        self.data["status"] = "Ready"
        return True
    @action
    async def cleanup(self) -> bool:
        self.data["status"] = "Offline"
        return True
    @action(description="执行操作")
    def my_action(self, param: float = 0.0, name: str = "") -> Dict[str, Any]:
        """带 @action 装饰器 → 注册为 'my_action' 动作"""
        return {"success": True}
    def get_info(self) -> Dict[str, Any]:
        """无 @action → 自动注册为 'auto-get_info' 动作"""
        return {"device_id": self.device_id}
    @property
    @topic_config()
    def status(self) -> str:
        return self.data.get("status", "Idle")
    @property
    @topic_config(period=2.0)
    def temperature(self) -> float:
        return self.data.get("temperature", 0.0)
 ```
 ### 要点
 - `_ros_node: BaseROS2DeviceNode` 类型标注放在类体顶部
 - `__init__` 签名固定为 `(self, device_id=None, config=None, **kwargs)`
 - `post_init` 用 `@not_action` 标记，参数类型标注为 `BaseROS2DeviceNode`
 - 运行时状态存储在 `self.data` 字典中
 - 设备文件放在 `unilabos/devices/<category>/` 目录下
--- a/.cursor/skills/add-resource/SKILL.md
+++ b/.cursor/skills/add-resource/SKILL.md
@@ -1,351 +0,0 @@
 ---
 name: add-resource
 description: Guide for adding new resources (materials, bottles, carriers, decks, warehouses) to Uni-Lab-OS (添加新物料/资源). Uses @resource decorator for AST auto-scanning. Covers Bottle, Carrier, Deck, WareHouse definitions. Use when the user wants to add resources, define materials, create a deck layout, add bottles/carriers/plates, or mentions 物料/资源/resource/bottle/carrier/deck/plate/warehouse.
 ---
 # 添加新物料资源
 Uni-Lab-OS 的资源体系基于 PyLabRobot，通过扩展实现 Bottle、Carrier、WareHouse、Deck 等实验室物料管理。使用 `@resource` 装饰器注册，AST 自动扫描生成注册表条目。
 ---
 ## 资源类型
 | 类型 | 基类 | 用途 | 示例 |
 |------|------|------|------|
 | **Bottle** | `Well` (PyLabRobot) | 单个容器（瓶、小瓶、烧杯、反应器） | 试剂瓶、粉末瓶 |
 | **BottleCarrier** | `ItemizedCarrier` | 多槽位载架（放多个 Bottle） | 6 位试剂架、枪头盒 |
 | **WareHouse** | `ItemizedCarrier` | 堆栈/仓库（放多个 Carrier） | 4x4 堆栈 |
 | **Deck** | `Deck` (PyLabRobot) | 工作站台面（放多个 WareHouse） | 反应站 Deck |
 **层级关系：** `Deck` → `WareHouse` → `BottleCarrier` → `Bottle`
 WareHouse 本质上和 Site 是同一概念 — 都是定义一组固定的放置位（slot），只不过 WareHouse 多嵌套了一层 Deck。两者都需要开发者根据实际物理尺寸自行计算各 slot 的偏移坐标。
 ---
 ## @resource 装饰器
 ```python
 from unilabos.registry.decorators import resource
@resource(
    id="my_resource_id",        # 注册表唯一标识（必填）
    category=["bottles"],       # 分类标签列表（必填）
    description="资源描述",
    icon="",                    # 图标
    version="1.0.0",
    handles=[...],              # 端口列表（InputHandle / OutputHandle）
    model={...},                # 3D 模型配置
    class_type="pylabrobot",    # "python" / "pylabrobot" / "unilabos"
 )
 ```
 ---
 ## 创建规范
 ### 命名规则
 1. **`name` 参数作为前缀**：所有工厂函数必须接受 `name: str` 参数，创建子物料时以 `name` 作为前缀，确保实例名在运行时全局唯一
 2. **Bottle 命名约定**：试剂瓶-Bottle，烧杯-Beaker，烧瓶-Flask，小瓶-Vial
 3. **函数名 = `@resource(id=...)`**：工厂函数名与注册表 id 保持一致
 ### 子物料命名示例
 ```python
 # Carrier 内部的 sites 用 name 前缀
 for k, v in sites.items():
    v.name = f"{name}_{v.name}"     # "堆栈1左_A01", "堆栈1左_B02" ...
 # Carrier 中放置 Bottle 时用 name 前缀
 carrier[0] = My_Reagent_Bottle(f"{name}_flask_1")    # "堆栈1左_flask_1"
 carrier[i] = My_Solid_Vial(f"{name}_vial_{ordering[i]}")  # "堆栈1左_vial_A1"
 # create_homogeneous_resources 使用 name_prefix
 sites=create_homogeneous_resources(
    klass=ResourceHolder,
    locations=[...],
    name_prefix=name,  # 自动生成 "{name}_0", "{name}_1" ...
 )
 # Deck setup 中用仓库名称作为 name 传入
 self.warehouses = {
    "堆栈1左": my_warehouse_4x4("堆栈1左"),   # WareHouse.name = "堆栈1左"
    "试剂堆栈": my_reagent_stack("试剂堆栈"),  # WareHouse.name = "试剂堆栈"
 }
 ```
 ### 其他规范
 - **max_volume 单位为 μL**：500mL = 500000
 - **尺寸单位为 mm**：`diameter`, `height`, `size_x/y/z`, `dx/dy/dz`
 - **BottleCarrier 必须设置 `num_items_x/y/z`**：用于前端渲染布局
 - **Deck 的 `__init__` 必须接受 `setup=False`**：图文件中 `config.setup=true` 触发 `setup()`
 - **按项目分组文件**：同一工作站的资源放在 `unilabos/resources/<project>/` 下
 - **`__init__` 必须接受 `serialize()` 输出的所有字段**：`serialize()` 输出会作为 `config` 回传到 `__init__`，因此必须通过显式参数或 `**kwargs` 接受，否则反序列化会报错
 - **持久化运行时状态用 `serialize_state()`**：通过 `_unilabos_state` 字典存储可变信息（如物料内容、液体量），只存 JSON 可序列化的基本类型
 ---
 ## 资源模板
 ### Bottle
 ```python
 from unilabos.registry.decorators import resource
 from unilabos.resources.itemized_carrier import Bottle
@resource(id="My_Reagent_Bottle", category=["bottles"], description="我的试剂瓶")
 def My_Reagent_Bottle(
    name: str,
    diameter: float = 70.0,
    height: float = 120.0,
    max_volume: float = 500000.0,
    barcode: str = None,
 ) -> Bottle:
    return Bottle(
        name=name,
        diameter=diameter,
        height=height,
        max_volume=max_volume,
        barcode=barcode,
        model="My_Reagent_Bottle",
    )
 ```
 **Bottle 参数：**
 - `name`: 实例名称（运行时唯一，由上层 Carrier 以前缀方式传入）
 - `diameter`: 瓶体直径 (mm)
 - `height`: 瓶体高度 (mm)
 - `max_volume`: 最大容积（**μL**，500mL = 500000）
 - `barcode`: 条形码（可选）
 ### BottleCarrier
 ```python
 from pylabrobot.resources import ResourceHolder
 from pylabrobot.resources.carrier import create_ordered_items_2d
 from unilabos.resources.itemized_carrier import BottleCarrier
 from unilabos.registry.decorators import resource
@resource(id="My_6SlotCarrier", category=["bottle_carriers"], description="六槽位载架")
 def My_6SlotCarrier(name: str) -> BottleCarrier:
    sites = create_ordered_items_2d(
        klass=ResourceHolder,
        num_items_x=3, num_items_y=2,
        dx=10.0, dy=10.0, dz=5.0,
        item_dx=42.0, item_dy=35.0,
        size_x=20.0, size_y=20.0, size_z=50.0,
    )
    # 子 site 用 name 作为前缀
    for k, v in sites.items():
        v.name = f"{name}_{v.name}"
    carrier = BottleCarrier(
        name=name, size_x=146.0, size_y=80.0, size_z=55.0,
        sites=sites, model="My_6SlotCarrier",
    )
    carrier.num_items_x = 3
    carrier.num_items_y = 2
    carrier.num_items_z = 1
    # 放置 Bottle 时用 name 作为前缀
    ordering = ["A1", "B1", "A2", "B2", "A3", "B3"]
    for i in range(6):
        carrier[i] = My_Reagent_Bottle(f"{name}_vial_{ordering[i]}")
    return carrier
 ```
 ### WareHouse / Deck 放置位
 WareHouse 和 Site 本质上是同一概念：都是定义一组固定放置位（slot），根据物理尺寸自行批量计算偏移坐标。WareHouse 只是多嵌套了一层 Deck 而已。推荐开发者直接根据实物测量数据计算各 slot 偏移量。
 #### WareHouse（使用 warehouse_factory）
 ```python
 from unilabos.resources.warehouse import warehouse_factory
 from unilabos.registry.decorators import resource
@resource(id="my_warehouse_4x4", category=["warehouse"], description="4x4 堆栈仓库")
 def my_warehouse_4x4(name: str) -> "WareHouse":
    return warehouse_factory(
        name=name,
        num_items_x=4, num_items_y=4, num_items_z=1,
        dx=10.0, dy=10.0, dz=10.0,             # 第一个 slot 的起始偏移
        item_dx=147.0, item_dy=106.0, item_dz=130.0,  # slot 间距
        resource_size_x=127.0, resource_size_y=85.0, resource_size_z=100.0,  # slot 尺寸
        model="my_warehouse_4x4",
        col_offset=0,       # 列标签起始偏移（0 → A01, 4 → A05）
        layout="row-major",  # "row-major" 行优先 / "col-major" 列优先 / "vertical-col-major" 竖向
    )
 ```
 `warehouse_factory` 参数说明：
 - `dx/dy/dz`：第一个 slot 相对 WareHouse 原点的偏移（mm）
 - `item_dx/item_dy/item_dz`：相邻 slot 间距（mm），需根据实际物理间距测量
 - `resource_size_x/y/z`：每个 slot 的可放置区域尺寸
 - `layout`：影响 slot 标签和坐标映射
  - `"row-major"`：A01,A02,...,B01,B02,...（行优先，适合横向排列）
  - `"col-major"`：A01,B01,...,A02,B02,...（列优先）
  - `"vertical-col-major"`：竖向排列，y 坐标反向
 #### Deck 组装 WareHouse
 Deck 通过 `setup()` 将多个 WareHouse 放置到指定坐标：
 ```python
 from pylabrobot.resources import Deck, Coordinate
 from unilabos.registry.decorators import resource
@resource(id="MyStation_Deck", category=["deck"], description="我的工作站 Deck")
 class MyStation_Deck(Deck):
    def __init__(self, name="MyStation_Deck", size_x=2700.0, size_y=1080.0, size_z=1500.0,
                 category="deck", setup=False, **kwargs) -> None:
        super().__init__(name=name, size_x=size_x, size_y=size_y, size_z=size_z)
        if setup:
            self.setup()
    def setup(self) -> None:
        self.warehouses = {
            "堆栈1左": my_warehouse_4x4("堆栈1左"),
            "堆栈1右": my_warehouse_4x4("堆栈1右"),
        }
        self.warehouse_locations = {
            "堆栈1左": Coordinate(-200.0, 400.0, 0.0),  # 自行测量计算
            "堆栈1右": Coordinate(2350.0, 400.0, 0.0),
        }
        for wh_name, wh in self.warehouses.items():
            self.assign_child_resource(wh, location=self.warehouse_locations[wh_name])
 ```
 #### Site 模式（前端定向放置）
 适用于有固定孔位/槽位的设备（如移液站 PRCXI 9300），Deck 通过 `sites` 列表定义前端展示的放置位，前端据此渲染可拖拽的孔位布局：
 ```python
 import collections
 from typing import Any, Dict, List, Optional
 from pylabrobot.resources import Deck, Resource, Coordinate
 from unilabos.registry.decorators import resource
@resource(id="MyLabDeck", category=["deck"], description="带 Site 定向放置的 Deck")
 class MyLabDeck(Deck):
    # 根据设备台面实测批量计算各 slot 坐标偏移
    _DEFAULT_SITE_POSITIONS = [
        (0, 0, 0), (138, 0, 0), (276, 0, 0), (414, 0, 0),       # T1-T4
        (0, 96, 0), (138, 96, 0), (276, 96, 0), (414, 96, 0),   # T5-T8
    ]
    _DEFAULT_SITE_SIZE = {"width": 128.0, "height": 86.0, "depth": 0}
    _DEFAULT_CONTENT_TYPE = ["plate", "tip_rack", "tube_rack", "adaptor"]
    def __init__(self, name: str, size_x: float, size_y: float, size_z: float,
                 sites: Optional[List[Dict[str, Any]]] = None, **kwargs):
        super().__init__(size_x, size_y, size_z, name)
        if sites is not None:
            self.sites = [dict(s) for s in sites]
        else:
            self.sites = []
            for i, (x, y, z) in enumerate(self._DEFAULT_SITE_POSITIONS):
                self.sites.append({
                    "label": f"T{i + 1}",          # 前端显示的槽位标签
                    "visible": True,                # 是否在前端可见
                    "position": {"x": x, "y": y, "z": z},  # 槽位物理坐标
                    "size": dict(self._DEFAULT_SITE_SIZE),  # 槽位尺寸
                    "content_type": list(self._DEFAULT_CONTENT_TYPE),  # 允许放入的物料类型
                })
        self._ordering = collections.OrderedDict(
            (site["label"], None) for site in self.sites
        )
    def assign_child_resource(self, resource: Resource,
                              location: Optional[Coordinate] = None,
                              reassign: bool = True,
                              spot: Optional[int] = None):
        idx = spot
        if spot is None:
            for i, site in enumerate(self.sites):
                if site.get("label") == resource.name:
                    idx = i
                    break
        if idx is None:
            for i in range(len(self.sites)):
                if self._get_site_resource(i) is None:
                    idx = i
                    break
        if idx is None:
            raise ValueError(f"No available site for '{resource.name}'")
        loc = Coordinate(**self.sites[idx]["position"])
        super().assign_child_resource(resource, location=loc, reassign=reassign)
    def serialize(self) -> dict:
        data = super().serialize()
        sites_out = []
        for i, site in enumerate(self.sites):
            occupied = self._get_site_resource(i)
            sites_out.append({
                "label": site["label"],
                "visible": site.get("visible", True),
                "occupied_by": occupied.name if occupied else None,
                "position": site["position"],
                "size": site["size"],
                "content_type": site["content_type"],
            })
        data["sites"] = sites_out
        return data
 ```
 **Site 字段说明：**
 | 字段 | 类型 | 说明 |
 |------|------|------|
 | `label` | str | 槽位标签（如 `"T1"`），前端显示名称，也用于匹配 resource.name |
 | `visible` | bool | 是否在前端可见 |
 | `position` | dict | 物理坐标 `{x, y, z}`（mm），需自行测量计算偏移 |
 | `size` | dict | 槽位尺寸 `{width, height, depth}`（mm） |
 | `content_type` | list | 允许放入的物料类型，如 `["plate", "tip_rack", "tube_rack", "adaptor"]` |
 **参考实现：** `unilabos/devices/liquid_handling/prcxi/prcxi.py` 中的 `PRCXI9300Deck`（4x4 共 16 个 site）。
 ---
 ## 文件位置
 ```
 unilabos/resources/
 ├── <project>/              # 按项目分组
 │   ├── bottles.py          # Bottle 工厂函数
 │   ├── bottle_carriers.py  # Carrier 工厂函数
 │   ├── warehouses.py       # WareHouse 工厂函数
 │   └── decks.py            # Deck 类定义
 ```
 ---
 ## 验证
 ```bash
 # 资源可导入
 python -c "from unilabos.resources.my_project.bottles import My_Reagent_Bottle; print(My_Reagent_Bottle('test'))"
 # 启动测试（AST 自动扫描）
 unilab -g <graph>.json
 ```
 仅在以下情况仍需 YAML：第三方库资源（如 pylabrobot 内置资源，无 `@resource` 装饰器）。
 ---
 ## 关键路径
 | 内容 | 路径 |
 |------|------|
 | Bottle/Carrier 基类 | `unilabos/resources/itemized_carrier.py` |
 | WareHouse 基类 + 工厂 | `unilabos/resources/warehouse.py` |
 | PLR 注册 | `unilabos/resources/plr_additional_res_reg.py` |
 | 装饰器定义 | `unilabos/registry/decorators.py` |
--- a/.cursor/skills/add-resource/reference.md
+++ b/.cursor/skills/add-resource/reference.md
@@ -1,292 +0,0 @@
 # 资源高级参考
 本文件是 SKILL.md 的补充，包含类继承体系、序列化/反序列化、Bioyond 物料同步、非瓶类资源和仓库工厂模式。Agent 在需要实现这些功能时按需阅读。
 ---
 ## 1. 类继承体系
 ```
 PyLabRobot
 ├── Resource (PLR 基类)
 │   ├── Well
 │   │   └── Bottle (unilabos)        → 瓶/小瓶/烧杯/反应器
 │   ├── Deck
 │   │   └── 自定义 Deck 类 (unilabos) → 工作站台面
 │   ├── ResourceHolder               → 槽位占位符
 │   └── Container
 │       └── Battery (unilabos)       → 组装好的电池
 │
 ├── ItemizedCarrier (unilabos, 继承 Resource)
 │   ├── BottleCarrier (unilabos)     → 瓶载架
 │   └── WareHouse (unilabos)         → 堆栈仓库
 │
 ├── ItemizedResource (PLR)
 │   └── MagazineHolder (unilabos)    → 子弹夹载架
 │
 └── ResourceStack (PLR)
    └── Magazine (unilabos)          → 子弹夹洞位
 ```
 ### Bottle 类细节
 ```python
 class Bottle(Well):
    def __init__(self, name, diameter, height, max_volume,
                 size_x=0.0, size_y=0.0, size_z=0.0,
                 barcode=None, category="container", model=None, **kwargs):
        super().__init__(
            name=name,
            size_x=diameter,    # PLR 用 diameter 作为 size_x/size_y
            size_y=diameter,
            size_z=height,      # PLR 用 height 作为 size_z
            max_volume=max_volume,
            category=category,
            model=model,
            bottom_type="flat",
            cross_section_type="circle"
        )
 ```
 注意 `size_x = size_y = diameter`，`size_z = height`。
 ### ItemizedCarrier 核心方法
 | 方法 | 说明 |
 |------|------|
 | `__getitem__(identifier)` | 通过索引或 Excel 标识（如 `"A01"`）访问槽位 |
 | `__setitem__(identifier, resource)` | 向槽位放入资源 |
 | `get_child_identifier(child)` | 获取子资源的标识符 |
 | `capacity` | 总槽位数 |
 | `sites` | 所有槽位字典 |
 ---
 ## 2. 序列化与反序列化
 ### PLR ↔ UniLab 转换
 | 函数 | 位置 | 方向 |
 |------|------|------|
 | `ResourceTreeSet.from_plr_resources(resources)` | `resource_tracker.py` | PLR → UniLab |
 | `ResourceTreeSet.to_plr_resources()` | `resource_tracker.py` | UniLab → PLR |
 ### `from_plr_resources` 流程
 ```
 PLR Resource
    ↓ build_uuid_mapping (递归生成 UUID)
    ↓ resource.serialize() → dict
    ↓ resource.serialize_all_state() → states
    ↓ resource_plr_inner (递归构建 ResourceDictInstance)
 ResourceTreeSet
 ```
 关键：每个 PLR 资源通过 `unilabos_uuid` 属性携带 UUID，`unilabos_extra` 携带扩展数据（如 `class` 名）。
 ### `to_plr_resources` 流程
 ```
 ResourceTreeSet
    ↓ collect_node_data (收集 UUID、状态、扩展数据)
    ↓ node_to_plr_dict (转为 PLR 字典格式)
    ↓ find_subclass(type_name, PLRResource) (查找 PLR 子类)
    ↓ sub_cls.deserialize(plr_dict) (反序列化)
    ↓ loop_set_uuid, loop_set_extra (递归设置 UUID 和扩展)
 PLR Resource
 ```
 ### Bottle 序列化
 ```python
 class Bottle(Well):
    def serialize(self) -> dict:
        data = super().serialize()
        return {**data, "diameter": self.diameter, "height": self.height}
    @classmethod
    def deserialize(cls, data: dict, allow_marshal=False):
        barcode_data = data.pop("barcode", None)
        instance = super().deserialize(data, allow_marshal=allow_marshal)
        if barcode_data and isinstance(barcode_data, str):
            instance.barcode = barcode_data
        return instance
 ```
 ---
 ## 3. Bioyond 物料同步
 ### 双向转换函数
 | 函数 | 位置 | 方向 |
 |------|------|------|
 | `resource_bioyond_to_plr(materials, type_mapping, deck)` | `graphio.py` | Bioyond → PLR |
 | `resource_plr_to_bioyond(resources, type_mapping, warehouse_mapping)` | `graphio.py` | PLR → Bioyond |
 ### `resource_bioyond_to_plr` 流程
 ```
 Bioyond 物料列表
    ↓ reverse_type_mapping: {typeName → (model, UUID)}
    ↓ 对每个物料:
       typeName → 查映射 → model (如 "BIOYOND_PolymerStation_Reactor")
       initialize_resource({"name": unique_name, "class": model})
    ↓ 设置 unilabos_extra (material_bioyond_id, material_bioyond_name 等)
    ↓ 处理 detail (子物料/坐标)
    ↓ 按 locationName 放入 deck.warehouses 对应槽位
 PLR 资源列表
 ```
 ### `resource_plr_to_bioyond` 流程
 ```
 PLR 资源列表
    ↓ 遍历每个资源:
       载架(capacity > 1): 生成 details 子物料 + 坐标
       单瓶: 直接映射
    ↓ type_mapping 查找 typeId
    ↓ warehouse_mapping 查找位置 UUID
    ↓ 组装 Bioyond 格式 (name, typeName, typeId, quantity, Parameters, locations)
 Bioyond 物料列表
 ```
 ### BioyondResourceSynchronizer
 工作站通过 `ResourceSynchronizer` 自动同步物料：
 ```python
 class BioyondResourceSynchronizer(ResourceSynchronizer):
    def sync_from_external(self) -> bool:
        all_data = []
        all_data.extend(api_client.stock_material('{"typeMode": 0}'))  # 耗材
        all_data.extend(api_client.stock_material('{"typeMode": 1}'))  # 样品
        all_data.extend(api_client.stock_material('{"typeMode": 2}'))  # 试剂
        unilab_resources = resource_bioyond_to_plr(
            all_data,
            type_mapping=self.workstation.bioyond_config["material_type_mappings"],
            deck=self.workstation.deck
        )
        # 更新 deck 上的资源
 ```
 ---
 ## 4. 非瓶类资源
 ### ElectrodeSheet（极片）
 路径：`unilabos/resources/battery/electrode_sheet.py`
 ```python
 class ElectrodeSheet(ResourcePLR):
    """片状材料（极片、隔膜、弹片、垫片等）"""
    _unilabos_state = {
        "diameter": 0.0,
        "thickness": 0.0,
        "mass": 0.0,
        "material_type": "",
        "color": "",
        "info": "",
    }
 ```
 工厂函数：`PositiveCan`, `PositiveElectrode`, `NegativeCan`, `NegativeElectrode`, `SpringWasher`, `FlatWasher`, `AluminumFoil`
 ### Battery（电池）
 ```python
 class Battery(Container):
    """组装好的电池"""
    _unilabos_state = {
        "color": "",
        "electrolyte_name": "",
        "open_circuit_voltage": 0.0,
    }
 ```
 ### Magazine / MagazineHolder（子弹夹）
 ```python
 class Magazine(ResourceStack):
    """子弹夹洞位，可堆叠 ElectrodeSheet"""
    # direction, max_sheets
 class MagazineHolder(ItemizedResource):
    """多洞位子弹夹"""
    # hole_diameter, hole_depth, max_sheets_per_hole
 ```
 工厂函数 `magazine_factory()` 用 `create_homogeneous_resources` 生成洞位，可选预填 `ElectrodeSheet` 或 `Battery`。
 ---
 ## 5. 仓库工厂模式参考
 ### 实际 warehouse 工厂函数示例
 ```python
 # 行优先 4x4 仓库
 def bioyond_warehouse_1x4x4(name: str) -> WareHouse:
    return warehouse_factory(
        name=name,
        num_items_x=4, num_items_y=4, num_items_z=1,
        dx=10.0, dy=10.0, dz=10.0,
        item_dx=147.0, item_dy=106.0, item_dz=130.0,
        layout="row-major",  # A01,A02,A03,A04, B01,...
    )
 # 右侧 4x4 仓库（列名偏移）
 def bioyond_warehouse_1x4x4_right(name: str) -> WareHouse:
    return warehouse_factory(
        name=name,
        num_items_x=4, num_items_y=4, num_items_z=1,
        dx=10.0, dy=10.0, dz=10.0,
        item_dx=147.0, item_dy=106.0, item_dz=130.0,
        col_offset=4,      # A05,A06,A07,A08
        layout="row-major",
    )
 # 竖向仓库（站内试剂存放）
 def bioyond_warehouse_reagent_storage(name: str) -> WareHouse:
    return warehouse_factory(
        name=name,
        num_items_x=1, num_items_y=2, num_items_z=1,
        dx=10.0, dy=10.0, dz=10.0,
        item_dx=147.0, item_dy=106.0, item_dz=130.0,
        layout="vertical-col-major",
    )
 # 行偏移（F 行开始）
 def bioyond_warehouse_5x3x1(name: str, row_offset: int = 0) -> WareHouse:
    return warehouse_factory(
        name=name,
        num_items_x=3, num_items_y=5, num_items_z=1,
        dx=10.0, dy=10.0, dz=10.0,
        item_dx=159.0, item_dy=183.0, item_dz=130.0,
        row_offset=row_offset,  # 0→A行起，5→F行起
        layout="row-major",
    )
 ```
 ### layout 类型说明
 | layout | 命名顺序 | 适用场景 |
 |--------|---------|---------|
 | `col-major` (默认) | A01,B01,C01,D01, A02,B02,... | 列优先，标准堆栈 |
 | `row-major` | A01,A02,A03,A04, B01,B02,... | 行优先，Bioyond 前端展示 |
 | `vertical-col-major` | 竖向排列，标签从底部开始 | 竖向仓库（试剂存放、测密度） |
 ---
 ## 6. 关键路径
 | 内容 | 路径 |
 |------|------|
 | Bottle/Carrier 基类 | `unilabos/resources/itemized_carrier.py` |
 | WareHouse 类 + 工厂 | `unilabos/resources/warehouse.py` |
 | ResourceTreeSet 转换 | `unilabos/resources/resource_tracker.py` |
 | Bioyond 物料转换 | `unilabos/resources/graphio.py` |
 | Bioyond 仓库定义 | `unilabos/resources/bioyond/warehouses.py` |
 | 电池资源 | `unilabos/resources/battery/` |
 | PLR 注册 | `unilabos/resources/plr_additional_res_reg.py` |
--- a/.cursor/skills/add-workstation/SKILL.md
+++ b/.cursor/skills/add-workstation/SKILL.md
@@ -1,626 +0,0 @@
 ---
 name: add-workstation
 description: Guide for adding new workstations to Uni-Lab-OS (接入新工作站). Uses @device decorator + AST auto-scanning. Walks through workstation type, sub-device composition, driver creation, deck setup, and graph file. Use when the user wants to add a workstation, create a workstation driver, configure a station with sub-devices, or mentions 工作站/工站/station/workstation.
 ---
 # Uni-Lab-OS 工作站接入指南
 工作站（workstation）是组合多个子设备的大型设备，拥有独立的物料管理系统和工作流引擎。使用 `@device` 装饰器注册，AST 自动扫描生成注册表。
 ---
 ## 工作站类型
 | 类型                | 基类              | 适用场景                           |
 | ------------------- | ----------------- | ---------------------------------- |
 | **Protocol 工作站** | `ProtocolNode`    | 标准化学操作协议（泵转移、过滤等） |
 | **外部系统工作站**  | `WorkstationBase` | 与外部 LIMS/MES 对接               |
 | **硬件控制工作站**  | `WorkstationBase` | 直接控制 PLC/硬件                  |
 ---
 ## @device 装饰器（工作站）
 工作站也使用 `@device` 装饰器注册，参数与普通设备一致：
 ```python
@device(
    id="my_workstation",           # 注册表唯一标识（必填）
    category=["workstation"],      # 分类标签
    description="我的工作站",
 )
 ```
 如果一个工作站类支持多个具体变体，可使用 `ids` / `id_meta`，与设备的用法相同（参见 add-device SKILL）。
 ---
 ## 工作站驱动模板
 ### 模板 A：基于外部系统的工作站
 ```python
 import logging
 from typing import Dict, Any, Optional
 from pylabrobot.resources import Deck
 from unilabos.registry.decorators import device, topic_config, not_action
 from unilabos.devices.workstation.workstation_base import WorkstationBase
 try:
    from unilabos.ros.nodes.presets.workstation import ROS2WorkstationNode
 except ImportError:
    ROS2WorkstationNode = None
@device(id="my_workstation", category=["workstation"], description="我的工作站")
 class MyWorkstation(WorkstationBase):
    _ros_node: "ROS2WorkstationNode"
    def __init__(self, config=None, deck=None, protocol_type=None, **kwargs):
        super().__init__(deck=deck, **kwargs)
        self.config = config or {}
        self.logger = logging.getLogger("MyWorkstation")
        self.api_host = self.config.get("api_host", "")
        self._status = "Idle"
    @not_action
    def post_init(self, ros_node: "ROS2WorkstationNode"):
        super().post_init(ros_node)
        self._ros_node = ros_node
    async def scheduler_start(self, **kwargs) -> Dict[str, Any]:
        """注册为工作站动作"""
        return {"success": True}
    async def create_order(self, json_str: str, **kwargs) -> Dict[str, Any]:
        """注册为工作站动作"""
        return {"success": True}
    @property
    @topic_config()
    def workflow_sequence(self) -> str:
        return "[]"
    @property
    @topic_config()
    def material_info(self) -> str:
        return "{}"
 ```
 ### 模板 B：Protocol 工作站
 直接使用 `ProtocolNode`，通常不需要自定义驱动类：
 ```python
 from unilabos.devices.workstation.workstation_base import ProtocolNode
 ```
 在图文件中配置 `protocol_type` 即可。
 ---
 ## 子设备访问（sub_devices）
 工站初始化子设备后，所有子设备实例存储在 `self._ros_node.sub_devices` 字典中（key 为设备 id，value 为 `ROS2DeviceNode` 实例）。工站的驱动类可以直接获取子设备实例来调用其方法：
 ```python
 # 在工站驱动类的方法中访问子设备
 sub = self._ros_node.sub_devices["pump_1"]
 # .driver_instance — 子设备的驱动实例（即设备 Python 类的实例）
 sub.driver_instance.some_method(arg1, arg2)
 # .ros_node_instance — 子设备的 ROS2 节点实例
 sub.ros_node_instance._action_value_mappings  # 查看子设备支持的 action
 ```
 **常见用法**：
 ```python
 class MyWorkstation(WorkstationBase):
    def my_protocol(self, **kwargs):
        # 获取子设备驱动实例
        pump = self._ros_node.sub_devices["pump_1"].driver_instance
        heater = self._ros_node.sub_devices["heater_1"].driver_instance
        # 直接调用子设备方法
        pump.aspirate(volume=100)
        heater.set_temperature(80)
 ```
 > 参考实现：`unilabos/devices/workstation/bioyond_studio/reaction_station/reaction_station.py` 中通过 `self._ros_node.sub_devices.get(reactor_id)` 获取子反应器实例并更新数据。
 ---
 ## 硬件通信接口（hardware_interface）
 硬件控制型工作站通常需要通过串口（Serial）、Modbus 等通信协议控制多个子设备。Uni-Lab-OS 通过 **通信设备代理** 机制实现端口共享：一个串口只创建一个 `serial` 节点，多个子设备共享这个通信实例。
 ### 工作原理
 `ROS2WorkstationNode` 初始化时分两轮遍历子设备（`workstation.py`）：
 **第一轮 — 初始化所有子设备**：按 `children` 顺序调用 `initialize_device()`，通信设备（`serial_` / `io_` 开头的 id）优先完成初始化，创建 `serial.Serial()` 实例。其他子设备此时 `self.hardware_interface = "serial_pump"`（字符串）。
 **第二轮 — 代理替换**：遍历所有已初始化的子设备，读取子设备的 `_hardware_interface` 配置：
 ```
 hardware_interface = d.ros_node_instance._hardware_interface
 # → {"name": "hardware_interface", "read": "send_command", "write": "send_command"}
 ```
 1. 取 `name` 字段对应的属性值：`name_value = getattr(driver, hardware_interface["name"])`
   - 如果 `name_value` 是字符串且该字符串是某个子设备的 id → 触发代理替换
 2. 从通信设备获取真正的 `read`/`write` 方法
 3. 用 `setattr(driver, read_method, _read)` 将通信设备的方法绑定到子设备上
 因此：
 - **通信设备 id 必须与子设备 config 中填的字符串完全一致**（如 `"serial_pump"`）
 - **通信设备 id 必须以 `serial_` 或 `io_` 开头**（否则第一轮不会被识别为通信设备）
 - **通信设备必须在 `children` 列表中排在最前面**，确保先初始化
 ### HardwareInterface 参数说明
 ```python
 from unilabos.registry.decorators import HardwareInterface
 HardwareInterface(
    name="hardware_interface",   # __init__ 中接收通信实例的属性名
    read="send_command",         # 通信设备上暴露的读方法名
    write="send_command",        # 通信设备上暴露的写方法名
    extra_info=["list_ports"],   # 可选：额外暴露的方法
 )
 ```
 **`name` 字段的含义**：对应设备类 `__init__` 中，用于保存通信实例的**属性名**。系统据此知道要替换哪个属性。大部分设备直接用 `"hardware_interface"`，也可以自定义（如 `"io_device_port"`）。
 ### 示例 1：泵（name="hardware_interface"）
 ```python
 from unilabos.registry.decorators import device, HardwareInterface
@device(
    id="my_pump",
    category=["pump_and_valve"],
    hardware_interface=HardwareInterface(
        name="hardware_interface",
        read="send_command",
        write="send_command",
    ),
 )
 class MyPump:
    def __init__(self, port=None, address="1", **kwargs):
        # name="hardware_interface" → 系统替换 self.hardware_interface
        self.hardware_interface = port  # 初始为字符串 "serial_pump"，启动后被替换为 Serial 实例
        self.address = address
    def send_command(self, command: str):
        full_command = f"/{self.address}{command}\r\n"
        self.hardware_interface.write(bytearray(full_command, "ascii"))
        return self.hardware_interface.read_until(b"\n")
 ```
 ### 示例 2：电磁阀（name="io_device_port"，自定义属性名）
 ```python
@device(
    id="solenoid_valve",
    category=["pump_and_valve"],
    hardware_interface=HardwareInterface(
        name="io_device_port",       # 自定义属性名 → 系统替换 self.io_device_port
        read="read_io_coil",
        write="write_io_coil",
    ),
 )
 class SolenoidValve:
    def __init__(self, io_device_port: str = None, **kwargs):
        # name="io_device_port" → 图文件 config 中用 "io_device_port": "io_board_1"
        self.io_device_port = io_device_port  # 初始为字符串，系统替换为 Modbus 实例
 ```
 ### Serial 通信设备（class="serial"）
 `serial` 是 Uni-Lab-OS 内置的通信代理设备，代码位于 `unilabos/ros/nodes/presets/serial_node.py`：
 ```python
 from serial import Serial, SerialException
 from threading import Lock
 class ROS2SerialNode(BaseROS2DeviceNode):
    def __init__(self, device_id, registry_name, port: str, baudrate: int = 9600, **kwargs):
        self.port = port
        self.baudrate = baudrate
        self._hardware_interface = {
            "name": "hardware_interface",
            "write": "send_command",
            "read": "read_data",
        }
        self._query_lock = Lock()
        self.hardware_interface = Serial(baudrate=baudrate, port=port)
        BaseROS2DeviceNode.__init__(
            self, driver_instance=self, registry_name=registry_name,
            device_id=device_id, status_types={}, action_value_mappings={},
            hardware_interface=self._hardware_interface, print_publish=False,
        )
        self.create_service(SerialCommand, "serialwrite", self.handle_serial_request)
    def send_command(self, command: str):
        with self._query_lock:
            self.hardware_interface.write(bytearray(f"{command}\n", "ascii"))
            return self.hardware_interface.read_until(b"\n").decode()
    def read_data(self):
        with self._query_lock:
            return self.hardware_interface.read_until(b"\n").decode()
 ```
 在图文件中使用 `"class": "serial"` 即可创建串口代理：
 ```json
 {
  "id": "serial_pump",
  "class": "serial",
  "parent": "my_station",
  "config": { "port": "COM7", "baudrate": 9600 }
 }
 ```
 ### 图文件配置
 **通信设备必须在 `children` 列表中排在最前面**，确保先于其他子设备初始化：
 ```json
 {
  "nodes": [
    {
      "id": "my_station",
      "class": "workstation",
      "children": ["serial_pump", "pump_1", "pump_2"],
      "config": { "protocol_type": ["PumpTransferProtocol"] }
    },
    {
      "id": "serial_pump",
      "class": "serial",
      "parent": "my_station",
      "config": { "port": "COM7", "baudrate": 9600 }
    },
    {
      "id": "pump_1",
      "class": "syringe_pump_with_valve.runze.SY03B-T08",
      "parent": "my_station",
      "config": { "port": "serial_pump", "address": "1", "max_volume": 25.0 }
    },
    {
      "id": "pump_2",
      "class": "syringe_pump_with_valve.runze.SY03B-T08",
      "parent": "my_station",
      "config": { "port": "serial_pump", "address": "2", "max_volume": 25.0 }
    }
  ],
  "links": [
    {
      "source": "pump_1",
      "target": "serial_pump",
      "type": "communication",
      "port": { "pump_1": "port", "serial_pump": "port" }
    },
    {
      "source": "pump_2",
      "target": "serial_pump",
      "type": "communication",
      "port": { "pump_2": "port", "serial_pump": "port" }
    }
  ]
 }
 ```
 ### 通信协议速查
 | 协议                 | config 参数                    | 依赖包     | 通信设备 class             |
 | -------------------- | ------------------------------ | ---------- | -------------------------- |
 | Serial (RS232/RS485) | `port`, `baudrate`             | `pyserial` | `serial`                   |
 | Modbus RTU           | `port`, `baudrate`, `slave_id` | `pymodbus` | `device_comms/modbus_plc/` |
 | Modbus TCP           | `host`, `port`, `slave_id`     | `pymodbus` | `device_comms/modbus_plc/` |
 | TCP Socket           | `host`, `port`                 | stdlib     | 自定义                     |
 | HTTP API             | `url`, `token`                 | `requests` | `device_comms/rpc.py`      |
 参考实现：`unilabos/test/experiments/Grignard_flow_batchreact_single_pumpvalve.json`
 ---
 ## Deck 与物料生命周期
 ### 1. Deck 入参与两种初始化模式
 系统根据设备节点 `config.deck` 的写法，自动反序列化 Deck 实例后传入 `__init__` 的 `deck` 参数。目前 `deck` 是固定字段名，只支持一个主 Deck。建议一个设备拥有一个台面，台面上抽象二级、三级子物料。
 有两种初始化模式：
 #### init 初始化（推荐）
 `config.deck` 直接包含 `_resource_type` + `_resource_child_name`，系统先用 Deck 节点的 `config` 调用 Deck 类的 `__init__` 反序列化，再将实例传入设备的 `deck` 参数。子物料随 Deck 的 `children` 一起反序列化。
 ```json
 "config": {
    "deck": {
        "_resource_type": "unilabos.devices.liquid_handling.prcxi.prcxi:PRCXI9300Deck",
        "_resource_child_name": "PRCXI_Deck"
    }
 }
 ```
 #### deserialize 初始化
 `config.deck` 用 `data` 包裹一层，系统走 `deserialize` 路径，可传入更多参数（如 `allow_marshal` 等）：
 ```json
 "config": {
    "deck": {
        "data": {
            "_resource_child_name": "YB_Bioyond_Deck",
            "_resource_type": "unilabos.resources.bioyond.decks:BIOYOND_YB_Deck"
        }
    }
 }
 ```
 没有特殊需求时推荐 init 初始化。
 #### config.deck 字段说明
 | 字段 | 说明 |
 |------|------|
 | `_resource_type` | Deck 类的完整模块路径（`module:ClassName`） |
 | `_resource_child_name` | 对应图文件中 Deck 节点的 `id`，建立父子关联 |
 #### 设备 __init__ 接收
 ```python
 def __init__(self, config=None, deck=None, protocol_type=None, **kwargs):
    super().__init__(deck=deck, **kwargs)
    # deck 已经是反序列化后的 Deck 实例
    # → PRCXI9300Deck / BIOYOND_YB_Deck 等
 ```
 #### Deck 节点（图文件中）
 Deck 节点作为设备的 `children` 之一，`parent` 指向设备 id：
 ```json
 {
    "id": "PRCXI_Deck",
    "parent": "PRCXI",
    "type": "deck",
    "class": "",
    "children": [],
    "config": {
        "type": "PRCXI9300Deck",
        "size_x": 542, "size_y": 374, "size_z": 0,
        "category": "deck",
        "sites": [...]
    },
    "data": {}
 }
 ```
 - `config` 中的字段会传入 Deck 类的 `__init__`（因此 `__init__` 必须能接受所有 `serialize()` 输出的字段）
 - `children` 初始为空时，由同步器或手动初始化填充
 - `config.type` 填 Deck 类名
 ### 2. Deck 为空时自行初始化
 如果 Deck 节点的 `children` 为空，工作站需在 `post_init` 或首次同步时自行初始化内容：
 ```python
@not_action
 def post_init(self, ros_node):
    super().post_init(ros_node)
    if self.deck and not self.deck.children:
        self._initialize_default_deck()
 def _initialize_default_deck(self):
    from my_labware import My_TipRack, My_Plate
    self.deck.assign_child_resource(My_TipRack("T1"), spot=0)
    self.deck.assign_child_resource(My_Plate("T2"), spot=1)
 ```
 ### 3. 物料双向同步
 当工作站对接外部系统（LIMS/MES）时，需要实现 `ResourceSynchronizer` 处理双向物料同步：
 ```python
 from unilabos.devices.workstation.workstation_base import ResourceSynchronizer
 class MyResourceSynchronizer(ResourceSynchronizer):
    def sync_from_external(self) -> bool:
        """从外部系统同步到 self.workstation.deck"""
        external_data = self._query_external_materials()
        # 以外部工站为准：根据外部数据反向创建 PLR 资源实例
        for item in external_data:
            cls = self._resolve_resource_class(item["type"])
            resource = cls(name=item["name"], **item["params"])
            self.workstation.deck.assign_child_resource(resource, spot=item["slot"])
        return True
    def sync_to_external(self, resource) -> bool:
        """将 UniLab 侧物料变更同步到外部系统"""
        # 以 UniLab 为准：将 PLR 资源转为外部格式并推送
        external_format = self._convert_to_external(resource)
        return self._push_to_external(external_format)
    def handle_external_change(self, change_info) -> bool:
        """处理外部系统主动推送的变更"""
        return True
 ```
 同步策略取决于业务场景：
 - **以外部工站为准**：从外部 API 查询物料数据，反向创建对应的 PLR 资源实例放到 Deck 上
 - **以 UniLab 为准**：UniLab 侧的物料变更通过 `sync_to_external` 推送到外部系统
 在工作站 `post_init` 中初始化同步器：
 ```python
@not_action
 def post_init(self, ros_node):
    super().post_init(ros_node)
    self.resource_synchronizer = MyResourceSynchronizer(self)
    self.resource_synchronizer.sync_from_external()
 ```
 ### 4. 序列化与持久化（serialize / serialize_state）
 资源类需正确实现序列化，系统据此完成持久化和前端同步。
 **`serialize()`** — 输出资源的结构信息（`config` 层），反序列化时作为 `__init__` 的入参回传。因此 **`__init__` 必须通过 `**kwargs`接受`serialize()` 输出的所有字段\*\*，即使当前不使用：
 ```python
 class MyDeck(Deck):
    def __init__(self, name, size_x, size_y, size_z,
                 sites=None,          # serialize() 输出的字段
                 rotation=None,       # serialize() 输出的字段
                 barcode=None,        # serialize() 输出的字段
                 **kwargs):           # 兜底：接受所有未知的 serialize 字段
        super().__init__(size_x, size_y, size_z, name)
        # ...
    def serialize(self) -> dict:
        data = super().serialize()
        data["sites"] = [...]  # 自定义字段
        return data
 ```
 **`serialize_state()`** — 输出资源的运行时状态（`data` 层），用于持久化可变信息。`data` 中的内容会被正确保存和恢复：
 ```python
 class MyPlate(Plate):
    def __init__(self, name, size_x, size_y, size_z,
                 material_info=None, **kwargs):
        super().__init__(name, size_x, size_y, size_z, **kwargs)
        self._unilabos_state = {}
        if material_info:
            self._unilabos_state["Material"] = material_info
    def serialize_state(self) -> Dict[str, Any]:
        data = super().serialize_state()
        data.update(self._unilabos_state)
        return data
 ```
 关键要点：
 - `serialize()` 输出的所有字段都会作为 `config` 回传到 `__init__`，所以 `__init__` 必须能接受它们（显式声明或 `**kwargs`）
 - `serialize_state()` 输出的 `data` 用于持久化运行时状态（如物料信息、液体量等）
 - `_unilabos_state` 中只存可 JSON 序列化的基本类型（str, int, float, bool, list, dict, None）
 ### 5. 子物料自动同步
 子物料（Bottle、Plate、TipRack 等）放到 Deck 上后，系统会自动将其同步到前端的 Deck 视图。只需保证资源类正确实现了 `serialize()` / `serialize_state()` 和反序列化即可。
 ### 6. 图文件配置（参考 prcxi_9320_slim.json）
 ```json
 {
  "nodes": [
    {
      "id": "my_station",
      "type": "device",
      "class": "my_workstation",
      "config": {
        "deck": {
          "_resource_type": "unilabos.resources.my_module:MyDeck",
          "_resource_child_name": "my_deck"
        },
        "host": "10.20.30.1",
        "port": 9999
      }
    },
    {
      "id": "my_deck",
      "parent": "my_station",
      "type": "deck",
      "class": "",
      "children": [],
      "config": {
        "type": "MyLabDeck",
        "size_x": 542,
        "size_y": 374,
        "size_z": 0,
        "category": "deck",
        "sites": [
          {
            "label": "T1",
            "visible": true,
            "occupied_by": null,
            "position": { "x": 0, "y": 0, "z": 0 },
            "size": { "width": 128.0, "height": 86, "depth": 0 },
            "content_type": ["plate", "tip_rack", "tube_rack", "adaptor"]
          }
        ]
      },
      "data": {}
    }
  ],
  "edges": []
 }
 ```
 Deck 节点要点：
 - `config.type` 填 Deck 类名（如 `"PRCXI9300Deck"`）
 - `config.sites` 完整列出所有 site（从 Deck 类的 `serialize()` 输出获取）
 - `children` 初始为空（由同步器或手动初始化填充）
 - 设备节点 `config.deck._resource_type` 指向 Deck 类的完整模块路径
 ---
 ## 子设备
 子设备按标准设备接入流程创建（参见 add-device SKILL），使用 `@device` 装饰器。
 子设备约束：
 - 图文件中 `parent` 指向工作站 ID
 - 在工作站 `children` 数组中列出
 ---
 ## 关键规则
 1. **`__init__` 必须接受 `deck` 和 `**kwargs`** — `WorkstationBase.**init**`需要`deck` 参数
 2. **Deck 通过 `config.deck._resource_type` 反序列化传入** — 不要在 `__init__` 中手动创建 Deck
 3. **Deck 为空时自行初始化内容** — 在 `post_init` 中检查并填充默认物料
 4. **外部同步实现 `ResourceSynchronizer`** — `sync_from_external` / `sync_to_external`
 5. **通过 `self._children` 访问子设备** — 不要自行维护子设备引用
 6. **`post_init` 中启动后台服务** — 不要在 `__init__` 中启动网络连接
 7. **异步方法使用 `await self._ros_node.sleep()`** — 禁止 `time.sleep()` 和 `asyncio.sleep()`
 8. **使用 `@not_action` 标记非动作方法** — `post_init`, `initialize`, `cleanup`
 9. **子物料保证正确 serialize/deserialize** — 系统自动同步到前端 Deck 视图
 ---
 ## 验证
 ```bash
 # 模块可导入
 python -c "from unilabos.devices.workstation.<name>.<name> import <ClassName>"
 # 启动测试（AST 自动扫描）
 unilab -g <graph>.json
 ```
 ---
 ## 现有工作站参考
 | 工作站         | 驱动类                        | 类型     |
 | -------------- | ----------------------------- | -------- |
 | Protocol 通用  | `ProtocolNode`                | Protocol |
 | Bioyond 反应站 | `BioyondReactionStation`      | 外部系统 |
 | 纽扣电池组装   | `CoinCellAssemblyWorkstation` | 硬件控制 |
 参考路径：`unilabos/devices/workstation/` 目录下各工作站实现。
--- a/.cursor/skills/add-workstation/reference.md
+++ b/.cursor/skills/add-workstation/reference.md
@@ -1,371 +0,0 @@
 # 工作站高级模式参考
 本文件是 SKILL.md 的补充，包含外部系统集成、物料同步、配置结构等高级模式。
 Agent 在需要实现这些功能时按需阅读。
 ---
 ## 1. 外部系统集成模式
 ### 1.1 RPC 客户端
 与外部 LIMS/MES 系统通信的标准模式。继承 `BaseRequest`，所有接口统一用 POST。
 ```python
 from unilabos.device_comms.rpc import BaseRequest
 class MySystemRPC(BaseRequest):
    """外部系统 RPC 客户端"""
    def __init__(self, host: str, api_key: str):
        super().__init__(host)
        self.api_key = api_key
    def _request(self, endpoint: str, data: dict = None) -> dict:
        return self.post(
            url=f"{self.host}/api/{endpoint}",
            params={
                "apiKey": self.api_key,
                "requestTime": self.get_current_time_iso8601(),
                "data": data or {},
            },
        )
    def query_status(self) -> dict:
        return self._request("status/query")
    def create_order(self, order_data: dict) -> dict:
        return self._request("order/create", order_data)
 ```
 参考：`unilabos/devices/workstation/bioyond_studio/bioyond_rpc.py`（`BioyondV1RPC`）
 ### 1.2 HTTP 回调服务
 接收外部系统报送的标准模式。使用 `WorkstationHTTPService`，在 `post_init` 中启动。
 ```python
 from unilabos.devices.workstation.workstation_http_service import WorkstationHTTPService
 class MyWorkstation(WorkstationBase):
    def __init__(self, config=None, deck=None, **kwargs):
        super().__init__(deck=deck, **kwargs)
        self.config = config or {}
        http_cfg = self.config.get("http_service_config", {})
        self._http_service_config = {
            "host": http_cfg.get("http_service_host", "127.0.0.1"),
            "port": http_cfg.get("http_service_port", 8080),
        }
        self.http_service = None
    def post_init(self, ros_node):
        super().post_init(ros_node)
        self.http_service = WorkstationHTTPService(
            workstation_instance=self,
            host=self._http_service_config["host"],
            port=self._http_service_config["port"],
        )
        self.http_service.start()
 ```
 **HTTP 服务路由**（固定端点，由 `WorkstationHTTPHandler` 自动分发）：
 | 端点 | 调用的工作站方法 |
 |------|-----------------|
 | `/report/step_finish` | `process_step_finish_report(report_request)` |
 | `/report/sample_finish` | `process_sample_finish_report(report_request)` |
 | `/report/order_finish` | `process_order_finish_report(report_request, used_materials)` |
 | `/report/material_change` | `process_material_change_report(report_data)` |
 | `/report/error_handling` | `handle_external_error(error_data)` |
 实现对应方法即可接收回调：
 ```python
 def process_step_finish_report(self, report_request) -> Dict[str, Any]:
    """处理步骤完成报告"""
    step_name = report_request.data.get("stepName")
    return {"success": True, "message": f"步骤 {step_name} 已处理"}
 def process_order_finish_report(self, report_request, used_materials) -> Dict[str, Any]:
    """处理订单完成报告"""
    order_code = report_request.data.get("orderCode")
    return {"success": True}
 ```
 参考：`unilabos/devices/workstation/workstation_http_service.py`
 ### 1.3 连接监控
 独立线程周期性检测外部系统连接状态，状态变化时发布 ROS 事件。
 ```python
 class ConnectionMonitor:
    def __init__(self, workstation, check_interval=30):
        self.workstation = workstation
        self.check_interval = check_interval
        self._running = False
        self._thread = None
    def start(self):
        self._running = True
        self._thread = threading.Thread(target=self._monitor_loop, daemon=True)
        self._thread.start()
    def _monitor_loop(self):
        while self._running:
            try:
                # 调用外部系统接口检测连接
                self.workstation.hardware_interface.ping()
                status = "online"
            except Exception:
                status = "offline"
            time.sleep(self.check_interval)
 ```
 参考：`unilabos/devices/workstation/bioyond_studio/station.py`（`ConnectionMonitor`）
 ---
 ## 2. Config 结构模式
 工作站的 `config` 在图文件中定义，传入 `__init__`。以下是常见字段模式：
 ### 2.1 外部系统连接
 ```json
 {
    "api_host": "http://192.168.1.100:8080",
    "api_key": "YOUR_API_KEY"
 }
 ```
 ### 2.2 HTTP 回调服务
 ```json
 {
    "http_service_config": {
        "http_service_host": "127.0.0.1",
        "http_service_port": 8080
    }
 }
 ```
 ### 2.3 物料类型映射
 将 PLR 资源类名映射到外部系统的物料类型（名称 + UUID）。用于双向物料转换。
 ```json
 {
    "material_type_mappings": {
        "PLR_ResourceClassName": ["外部系统显示名", "external-type-uuid"],
        "BIOYOND_PolymerStation_Reactor": ["反应器", "3a14233b-902d-0d7b-..."]
    }
 }
 ```
 ### 2.4 仓库映射
 将仓库名映射到外部系统的仓库 UUID 和库位 UUID。用于入库/出库操作。
 ```json
 {
    "warehouse_mapping": {
        "仓库名": {
            "uuid": "warehouse-uuid",
            "site_uuids": {
                "A01": "site-uuid-A01",
                "A02": "site-uuid-A02"
            }
        }
    }
 }
 ```
 ### 2.5 工作流映射
 将内部工作流名映射到外部系统的工作流 ID。
 ```json
 {
    "workflow_mappings": {
        "internal_workflow_name": "external-workflow-uuid"
    }
 }
 ```
 ### 2.6 物料默认参数
 ```json
 {
    "material_default_parameters": {
        "NMP": {
            "unit": "毫升",
            "density": "1.03",
            "densityUnit": "g/mL",
            "description": "N-甲基吡咯烷酮"
        }
    }
 }
 ```
 ---
 ## 3. 资源同步机制
 ### 3.1 ResourceSynchronizer
 抽象基类，用于与外部物料系统双向同步。定义在 `workstation_base.py`。
 ```python
 from unilabos.devices.workstation.workstation_base import ResourceSynchronizer
 class MyResourceSynchronizer(ResourceSynchronizer):
    def __init__(self, workstation, api_client):
        super().__init__(workstation)
        self.api_client = api_client
    def sync_from_external(self) -> bool:
        """从外部系统拉取物料到 deck"""
        external_materials = self.api_client.list_materials()
        for material in external_materials:
            plr_resource = self._convert_to_plr(material)
            self.workstation.deck.assign_child_resource(plr_resource, coordinate)
        return True
    def sync_to_external(self, plr_resource) -> bool:
        """将 deck 中的物料变更推送到外部系统"""
        external_data = self._convert_from_plr(plr_resource)
        self.api_client.update_material(external_data)
        return True
    def handle_external_change(self, change_info) -> bool:
        """处理外部系统推送的物料变更"""
        return True
 ```
 ### 3.2 update_resource — 上传资源树到云端
 将 PLR Deck 序列化后通过 ROS 服务上传。典型使用场景：
 ```python
 # 在 post_init 中上传初始 deck
 from unilabos.ros.nodes.base_device_node import ROS2DeviceNode
 ROS2DeviceNode.run_async_func(
    self._ros_node.update_resource, True,
    **{"resources": [self.deck]}
 )
 # 在动作方法中更新特定资源
 ROS2DeviceNode.run_async_func(
    self._ros_node.update_resource, True,
    **{"resources": [updated_plate]}
 )
 ```
 ---
 ## 4. 工作流序列管理
 工作站通过 `workflow_sequence` 属性管理任务队列（JSON 字符串形式）。
 ```python
 class MyWorkstation(WorkstationBase):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self._workflow_sequence = []
    @property
    def workflow_sequence(self) -> str:
        """返回 JSON 字符串，ROS 自动发布"""
        import json
        return json.dumps(self._workflow_sequence)
    async def append_to_workflow_sequence(self, workflow_name: str) -> Dict[str, Any]:
        """添加工作流到队列"""
        self._workflow_sequence.append({
            "name": workflow_name,
            "status": "pending",
            "created_at": time.time(),
        })
        return {"success": True}
    async def clear_workflows(self) -> Dict[str, Any]:
        """清空工作流队列"""
        self._workflow_sequence = []
        return {"success": True}
 ```
 ---
 ## 5. 站间物料转移
 工作站之间转移物料的模式。通过 ROS ActionClient 调用目标站的动作。
 ```python
 async def transfer_materials_to_another_station(
    self,
    target_device_id: str,
    transfer_groups: list,
    **kwargs,
 ) -> Dict[str, Any]:
    """将物料转移到另一个工作站"""
    target_node = self._children.get(target_device_id)
    if not target_node:
        # 通过 ROS 节点查找非子设备的目标站
        pass
    for group in transfer_groups:
        resource = self.find_resource_by_name(group["resource_name"])
        # 从本站 deck 移除
        resource.unassign()
        # 调用目标站的接收方法
        # ...
    return {"success": True, "transferred": len(transfer_groups)}
 ```
 参考：`BioyondDispensingStation.transfer_materials_to_reaction_station`
 ---
 ## 6. post_init 完整模式
 `post_init` 是工作站初始化的关键阶段，此时 ROS 节点和子设备已就绪。
 ```python
 def post_init(self, ros_node):
    super().post_init(ros_node)
    # 1. 初始化外部系统客户端（此时 config 已可用）
    self.rpc_client = MySystemRPC(
        host=self.config.get("api_host"),
        api_key=self.config.get("api_key"),
    )
    self.hardware_interface = self.rpc_client
    # 2. 启动连接监控
    self.connection_monitor = ConnectionMonitor(self)
    self.connection_monitor.start()
    # 3. 启动 HTTP 回调服务
    if hasattr(self, '_http_service_config'):
        self.http_service = WorkstationHTTPService(
            workstation_instance=self,
            host=self._http_service_config["host"],
            port=self._http_service_config["port"],
        )
        self.http_service.start()
    # 4. 上传 deck 到云端
    ROS2DeviceNode.run_async_func(
        self._ros_node.update_resource, True,
        **{"resources": [self.deck]}
    )
    # 5. 初始化资源同步器（可选）
    self.resource_synchronizer = MyResourceSynchronizer(self, self.rpc_client)
 ```
--- a/.cursor/skills/batch-insert-reagent/SKILL.md
+++ b/.cursor/skills/batch-insert-reagent/SKILL.md
@@ -1,261 +0,0 @@
 ---
 name: batch-insert-reagent
 description: Batch insert reagents into Uni-Lab platform — add chemicals with CAS, SMILES, supplier info. Use when the user wants to add reagents, insert chemicals, batch register reagents, or mentions 录入试剂/添加试剂/试剂入库/reagent.
 ---
 # 批量录入试剂 Skill
 通过云端 API 批量录入试剂信息，支持逐条或批量操作。
 ## 前置条件（缺一不可）
 使用本 skill 前，**必须**先确认以下信息。如果缺少任何一项，**立即向用户询问并终止**，等补齐后再继续。
 ### 1. ak / sk → AUTH
 询问用户的启动参数，从 `--ak` `--sk` 或 config.py 中获取。
 生成 AUTH token（任选一种方式）：
 ```bash
 # 方式一：Python 一行生成
 python -c "import base64,sys; print('Authorization: Lab ' + base64.b64encode(f'{sys.argv[1]}:{sys.argv[2]}'.encode()).decode())" <ak> <sk>
 # 方式二：手动计算
 # base64(ak:sk) → Authorization: Lab <token>
 ```
 ### 2. --addr → BASE URL
 | `--addr` 值  | BASE                                |
 | ------------ | ----------------------------------- |
 | `test`       | `https://leap-lab.test.bohrium.com` |
 | `uat`        | `https://leap-lab.uat.bohrium.com`  |
 | `local`      | `http://127.0.0.1:48197`            |
 | 不传（默认） | `https://leap-lab.bohrium.com`      |
 确认后设置：
 ```bash
 BASE="<根据 addr 确定的 URL>"
 AUTH="Authorization: Lab <gen_auth.py 输出的 token>"
 ```
 **两项全部就绪后才可发起 API 请求。**
 ## Session State
 - `lab_uuid` — 实验室 UUID（首次通过 API #1 自动获取，**不需要问用户**）
 ## 请求约定
 所有请求使用 `curl -s`，POST 需加 `Content-Type: application/json`。
 > **Windows 平台**必须使用 `curl.exe`（而非 PowerShell 的 `curl` 别名），示例中的 `curl` 均指 `curl.exe`。
 ---
 ## API Endpoints
 ### 1. 获取实验室信息（自动获取 lab_uuid）
 ```bash
 curl -s -X GET "$BASE/api/v1/edge/lab/info" -H "$AUTH"
 ```
 返回：
 ```json
 { "code": 0, "data": { "uuid": "xxx", "name": "实验室名称" } }
 ```
 记住 `data.uuid` 为 `lab_uuid`。
 ### 2. 录入试剂
 ```bash
 curl -s -X POST "$BASE/api/v1/lab/reagent" \
  -H "$AUTH" -H "Content-Type: application/json" \
  -d '{
    "lab_uuid": "<lab_uuid>",
    "cas": "<CAS号>",
    "name": "<试剂名称>",
    "molecular_formula": "<分子式>",
    "smiles": "<SMILES>",
    "stock_in_quantity": <入库数量>,
    "unit": "<单位字符串>",
    "supplier": "<供应商>",
    "production_date": "<生产日期 ISO 8601>",
    "expiry_date": "<过期日期 ISO 8601>"
  }'
 ```
 返回成功时包含试剂 UUID：
 ```json
 {"code": 0, "data": {"uuid": "xxx", ...}}
 ```
 ---
 ## 试剂字段说明
 | 字段                | 类型   | 必填 | 说明                          | 示例                     |
 | ------------------- | ------ | ---- | ----------------------------- | ------------------------ |
 | `lab_uuid`          | string | 是   | 实验室 UUID（从 API #1 获取） | `"8511c672-..."`         |
 | `cas`               | string | 是   | CAS 注册号                    | `"7732-18-3"`            |
 | `name`              | string | 是   | 试剂中文/英文名称             | `"水"`                   |
 | `molecular_formula` | string | 是   | 分子式                        | `"H2O"`                  |
 | `smiles`            | string | 是   | SMILES 表示                   | `"O"`                    |
 | `stock_in_quantity` | number | 是   | 入库数量                      | `10`                     |
 | `unit`              | string | 是   | 单位（字符串，见下表）        | `"mL"`                   |
 | `supplier`          | string | 否   | 供应商名称                    | `"国药集团"`             |
 | `production_date`   | string | 否   | 生产日期（ISO 8601）          | `"2025-11-18T00:00:00Z"` |
 | `expiry_date`       | string | 否   | 过期日期（ISO 8601）          | `"2026-11-18T00:00:00Z"` |
 ### unit 单位值
 | 值     | 单位 |
 | ------ | ---- |
 | `"mL"` | 毫升 |
 | `"L"`  | 升   |
 | `"g"`  | 克   |
 | `"kg"` | 千克 |
 | `"瓶"` | 瓶   |
 > 根据试剂状态选择：液体用 `"mL"` / `"L"`，固体用 `"g"` / `"kg"`。
 ---
 ## 批量录入策略
 ### 方式一：用户提供 JSON 数组
 用户一次性给出多条试剂数据：
 ```json
 [
  {
    "cas": "7732-18-3",
    "name": "水",
    "molecular_formula": "H2O",
    "smiles": "O",
    "stock_in_quantity": 10,
    "unit": "mL"
  },
  {
    "cas": "64-17-5",
    "name": "乙醇",
    "molecular_formula": "C2H6O",
    "smiles": "CCO",
    "stock_in_quantity": 5,
    "unit": "L"
  }
 ]
 ```
 Agent 自动为每条补充 `lab_uuid`、`production_date`、`expiry_date` 等字段后逐条提交。
 Agent 循环调用 API #2 逐条录入，每条记录一次 API 调用。
 ### 方式二：用户逐个描述
 用户口头描述试剂（如「帮我录入 500mL 的无水乙醇，Sigma 的」），agent 自行补全字段：
 1. 根据名称查找 CAS 号、分子式、SMILES（参考下方速查表或自行推断）
 2. 构建完整的请求体
 3. 向用户确认后提交
 ### 方式三：从 CSV/表格批量导入
 用户提供 CSV 或表格文件路径，agent 读取并解析：
 ```bash
 # 期望的 CSV 格式（首行为表头）
 cas,name,molecular_formula,smiles,stock_in_quantity,unit,supplier,production_date,expiry_date
 7732-18-3,水,H2O,O,10,mL,农夫山泉,2025-11-18T00:00:00Z,2026-11-18T00:00:00Z
 ```
 ### 日期格式规则（重要）
 所有日期字段（`production_date`、`expiry_date`）**必须**使用 ISO 8601 完整格式：`YYYY-MM-DDTHH:MM:SSZ`。
 - 用户输入 `2025-03-01` → 转换为 `"2025-03-01T00:00:00Z"`
 - 用户输入 `2025/9/1` → 转换为 `"2025-09-01T00:00:00Z"`
 - 用户未提供日期 → 使用当天日期 + `T00:00:00Z`，有效期默认 +1 年
 **禁止**发送不带时间部分的日期字符串（如 `"2025-03-01"`），API 会拒绝。
 ### 执行与汇报
 每次 API 调用后：
 1. 检查返回 `code`（0 = 成功）
 2. 记录成功/失败数量
 3. 全部完成后汇总：「共录入 N 条试剂，成功 X 条，失败 Y 条」
 4. 如有失败，列出失败的试剂名称和错误信息
 ---
 ## 常见试剂速查表
 | 名称                  | CAS       | 分子式     | SMILES                               |
 | --------------------- | --------- | ---------- | ------------------------------------ |
 | 水                    | 7732-18-3 | H2O        | O                                    |
 | 乙醇                  | 64-17-5   | C2H6O      | CCO                                  |
 | 乙酸                  | 64-19-7   | C2H4O2     | CC(O)=O                              |
 | 甲醇                  | 67-56-1   | CH4O       | CO                                   |
 | 丙酮                  | 67-64-1   | C3H6O      | CC(C)=O                              |
 | 二甲基亚砜(DMSO)      | 67-68-5   | C2H6OS     | CS(C)=O                              |
 | 乙酸乙酯              | 141-78-6  | C4H8O2     | CCOC(C)=O                            |
 | 二氯甲烷              | 75-09-2   | CH2Cl2     | ClCCl                                |
 | 四氢呋喃(THF)         | 109-99-9  | C4H8O      | C1CCOC1                              |
 | N,N-二甲基甲酰胺(DMF) | 68-12-2   | C3H7NO     | CN(C)C=O                             |
 | 氯仿                  | 67-66-3   | CHCl3      | ClC(Cl)Cl                            |
 | 乙腈                  | 75-05-8   | C2H3N      | CC#N                                 |
 | 甲苯                  | 108-88-3  | C7H8       | Cc1ccccc1                            |
 | 正己烷                | 110-54-3  | C6H14      | CCCCCC                               |
 | 异丙醇                | 67-63-0   | C3H8O      | CC(C)O                               |
 | 盐酸                  | 7647-01-0 | HCl        | Cl                                   |
 | 硫酸                  | 7664-93-9 | H2SO4      | OS(O)(=O)=O                          |
 | 氢氧化钠              | 1310-73-2 | NaOH       | [Na]O                                |
 | 碳酸钠                | 497-19-8  | Na2CO3     | [Na]OC([O-])=O.[Na+]                 |
 | 氯化钠                | 7647-14-5 | NaCl       | [Na]Cl                               |
 | 乙二胺四乙酸(EDTA)    | 60-00-4   | C10H16N2O8 | OC(=O)CN(CCN(CC(O)=O)CC(O)=O)CC(O)=O |
 > 此表仅供快速参考。对于不在表中的试剂，agent 应根据化学知识推断或提示用户补充。
 ---
 ## 完整工作流 Checklist
 ```
 Task Progress:
 - [ ] Step 1: 确认 ak/sk → 生成 AUTH token
 - [ ] Step 2: 确认 --addr → 设置 BASE URL
 - [ ] Step 3: GET /edge/lab/info → 获取 lab_uuid
 - [ ] Step 4: 收集试剂信息（用户提供列表/逐个描述/CSV文件）
 - [ ] Step 5: 补全缺失字段（CAS、分子式、SMILES 等）
 - [ ] Step 6: 向用户确认待录入的试剂列表
 - [ ] Step 7: 循环调用 POST /lab/reagent 逐条录入（每条需含 lab_uuid）
 - [ ] Step 8: 汇总结果（成功/失败数量及详情）
 ```
 ---
 ## 完整示例
 用户说：「帮我录入 3 种试剂：500mL 无水乙醇、1kg 氯化钠、2L 去离子水」
 Agent 构建的请求序列：
 ```json
 // 第 1 条
 {"lab_uuid": "8511c672-...", "cas": "64-17-5", "name": "无水乙醇", "molecular_formula": "C2H6O", "smiles": "CCO", "stock_in_quantity": 500, "unit": "mL", "supplier": "国药集团", "production_date": "2025-01-01T00:00:00Z", "expiry_date": "2026-01-01T00:00:00Z"}
 // 第 2 条
 {"lab_uuid": "8511c672-...", "cas": "7647-14-5", "name": "氯化钠", "molecular_formula": "NaCl", "smiles": "[Na]Cl", "stock_in_quantity": 1, "unit": "kg", "supplier": "", "production_date": "2025-01-01T00:00:00Z", "expiry_date": "2026-01-01T00:00:00Z"}
 // 第 3 条
 {"lab_uuid": "8511c672-...", "cas": "7732-18-3", "name": "去离子水", "molecular_formula": "H2O", "smiles": "O", "stock_in_quantity": 2, "unit": "L", "supplier": "", "production_date": "2025-01-01T00:00:00Z", "expiry_date": "2026-01-01T00:00:00Z"}
 ```
--- a/.cursor/skills/batch-submit-experiment/SKILL.md
+++ b/.cursor/skills/batch-submit-experiment/SKILL.md
@@ -1,360 +0,0 @@
 ---
 name: batch-submit-experiment
 description: Batch submit experiments (notebooks) to the Uni-Lab cloud platform (leap-lab) — list workflows, generate node_params from registry schemas, submit multiple rounds, check notebook status. Use when the user wants to submit experiments, create notebooks, batch run workflows, check experiment status, or mentions 提交实验/批量实验/notebook/实验轮次/实验状态.
 ---
 # Uni-Lab 批量提交实验指南
 通过 Uni-Lab 云端 API 批量提交实验（notebook），支持多轮实验参数配置。根据 workflow 模板详情和本地设备注册表自动生成 `node_params` 模板。
 > **重要**：本指南中的 `Authorization: Lab <token>` 是 **Uni-Lab 平台专用的认证方式**，`Lab` 是 Uni-Lab 的 auth scheme 关键字，**不是** HTTP Basic 认证。请勿将其替换为 `Basic`。
 ## 前置条件（缺一不可）
 使用本指南前，**必须**先确认以下信息。如果缺少任何一项，**立即向用户询问并终止**，等补齐后再继续。
 ### 1. ak / sk → AUTH
 询问用户的启动参数，从 `--ak` `--sk` 或 config.py 中获取。
 生成 AUTH token（任选一种方式）：
 ```bash
 # 方式一：Python 一行生成（注意：scheme 是 "Lab" 不是 "Basic"）
 python -c "import base64,sys; print('Authorization: Lab ' + base64.b64encode(f'{sys.argv[1]}:{sys.argv[2]}'.encode()).decode())" <ak> <sk>
 # 方式二：手动计算
 # base64(ak:sk) → Authorization: Lab <token>
 # ⚠️ 这里的 "Lab" 是 Uni-Lab 平台的 auth scheme，绝对不能用 "Basic" 替代
 ```
 ### 2. --addr → BASE URL
 | `--addr` 值  | BASE                                |
 | ------------ | ----------------------------------- |
 | `test`       | `https://leap-lab.test.bohrium.com` |
 | `uat`        | `https://leap-lab.uat.bohrium.com`  |
 | `local`      | `http://127.0.0.1:48197`            |
 | 不传（默认） | `https://leap-lab.bohrium.com`      |
 确认后设置：
 ```bash
 BASE="<根据 addr 确定的 URL>"
 # ⚠️ Auth scheme 必须是 "Lab"（Uni-Lab 专用），不是 "Basic"
 AUTH="Authorization: Lab <上面命令输出的 token>"
 ```
 ### 3. req_device_registry_upload.json（设备注册表）
 **批量提交实验时需要本地注册表来解析 workflow 节点的参数 schema。**
 **必须先用 Glob 工具搜索文件**，不要直接猜测路径：
 ```
 Glob: **/req_device_registry_upload.json
 ```
 常见位置（仅供参考，以 Glob 实际结果为准）：
 - `<workspace>/unilabos_data/req_device_registry_upload.json`
 - `<workspace>/req_device_registry_upload.json`
 找到后**检查文件修改时间**并告知用户。超过 1 天提醒用户是否需要重新启动 `unilab`。
 **如果 Glob 搜索无结果** → 告知用户先运行 `unilab` 启动命令，等注册表生成后再执行。可跳过此步，但将无法自动生成参数模板，需要用户手动填写 `param`。
 ### 4. workflow_uuid（目标工作流）
 用户需要提供要提交的 workflow UUID。如果用户不确定，通过 API #3 列出可用 workflow 供选择。
 **四项全部就绪后才可开始。**
 ## Session State
 在整个对话过程中，agent 需要记住以下状态，避免重复询问用户：
 - `lab_uuid` — 实验室 UUID（首次通过 API #1 自动获取，**不需要问用户**）
 - `project_uuid` — 项目 UUID（通过 API #2 列出项目列表，**让用户选择**）
 - `workflow_uuid` — 工作流 UUID（用户提供或从列表选择）
 - `workflow_nodes` — workflow 中各 action 节点的 uuid、设备 ID、动作名（从 API #4 获取）
 ## 请求约定
 所有请求使用 `curl -s`，POST 需加 `Content-Type: application/json`。
 > **Windows 平台**必须使用 `curl.exe`（而非 PowerShell 的 `curl` 别名），示例中的 `curl` 均指 `curl.exe`。
 >
 > **PowerShell JSON 传参**：PowerShell 中 `-d '{"key":"value"}'` 会因引号转义失败。请将 JSON 写入临时文件，用 `-d '@tmp_body.json'`（单引号包裹 `@`，否则会被解析为 splatting 运算符）。
 ---
 ## API Endpoints
 ### 1. 获取实验室信息（自动获取 lab_uuid）
 ```bash
 curl -s -X GET "$BASE/api/v1/edge/lab/info" -H "$AUTH"
 ```
 返回：
 ```json
 { "code": 0, "data": { "uuid": "xxx", "name": "实验室名称" } }
 ```
 记住 `data.uuid` 为 `lab_uuid`。
 ### 2. 列出实验室项目（让用户选择项目）
 ```bash
 curl -s -X GET "$BASE/api/v1/lab/project/list?lab_uuid=$lab_uuid" -H "$AUTH"
 ```
 返回：
 ```json
 {
  "code": 0,
  "data": {
    "items": [
      {
        "uuid": "1b3f249a-...",
        "name": "bt",
        "description": null,
        "status": "active",
        "created_at": "2026-04-09T14:31:28+08:00"
      },
      {
        "uuid": "b6366243-...",
        "name": "default",
        "description": "默认项目",
        "status": "active",
        "created_at": "2026-03-26T11:13:36+08:00"
      }
    ]
  }
 }
 ```
 展示 `data.items[]` 中每个项目的 `name` 和 `uuid`，让用户选择。用户**必须**选择一个项目，记住 `project_uuid`（即选中项目的 `uuid`），后续创建 notebook 时需要提供。
 ### 3. 列出可用 workflow
 ```bash
 curl -s -X GET "$BASE/api/v1/lab/workflow/workflows?page=1&page_size=20&lab_uuid=$lab_uuid" -H "$AUTH"
 ```
 返回 workflow 列表，展示给用户选择。列出每个 workflow 的 `uuid` 和 `name`。
 ### 4. 获取 workflow 模板详情
 ```bash
 curl -s -X GET "$BASE/api/v1/lab/workflow/template/detail/$workflow_uuid" -H "$AUTH"
 ```
 返回 workflow 的完整结构，包含所有 action 节点信息。需要从响应中提取：
 - 每个 action 节点的 `node_uuid`
 - 每个节点对应的设备 ID（`resource_template_name`）
 - 每个节点的动作名（`node_template_name`）
 - 每个节点的现有参数（`param`）
 > **注意**：此 API 返回格式可能因版本不同而有差异。首次调用时，先打印完整响应分析结构，再提取节点信息。常见的节点字段路径为 `data.nodes[]` 或 `data.workflow_nodes[]`。
 ### 5. 提交实验（创建 notebook）
 ```bash
 curl -s -X POST "$BASE/api/v1/lab/notebook" \
  -H "$AUTH" -H "Content-Type: application/json" \
  -d '<request_body>'
 ```
 请求体结构：
 ```json
 {
  "lab_uuid": "<lab_uuid>",
  "project_uuid": "<project_uuid>",
  "workflow_uuid": "<workflow_uuid>",
  "name": "<实验名称>",
  "node_params": [
    {
      "sample_uuids": ["<样品UUID1>", "<样品UUID2>"],
      "datas": [
        {
          "node_uuid": "<workflow中的节点UUID>",
          "param": {},
          "sample_params": [
            {
              "container_uuid": "<容器UUID>",
              "sample_value": {
                "liquid_names": "<液体名称>",
                "volumes": 1000
              }
            }
          ]
        }
      ]
    }
  ]
 }
 ```
 > **注意**：`sample_uuids` 必须是 **UUID 数组**（`[]uuid.UUID`），不是字符串。无样品时传空数组 `[]`。
 ### 6. 查询 notebook 状态
 提交成功后，使用返回的 notebook UUID 查询执行状态：
 ```bash
 curl -s -X GET "$BASE/api/v1/lab/notebook/status?uuid=$notebook_uuid" -H "$AUTH"
 ```
 提交后应**立即查询一次**状态，确认 notebook 已被正确接收并开始调度。
 ---
 ## Notebook 请求体详解
 ### node_params 结构
 `node_params` 是一个数组，**每个元素代表一轮实验**：
 - 要跑 2 轮 → `node_params` 有 2 个元素
 - 要跑 N 轮 → `node_params` 有 N 个元素
 ### 每轮的字段
 | 字段           | 类型          | 说明                                      |
 | -------------- | ------------- | ----------------------------------------- |
 | `sample_uuids` | array\<uuid\> | 该轮实验的样品 UUID 数组，无样品时传 `[]` |
 | `datas`        | array         | 该轮中每个 workflow 节点的参数配置        |
 ### datas 中每个节点
 | 字段            | 类型   | 说明                                         |
 | --------------- | ------ | -------------------------------------------- |
 | `node_uuid`     | string | workflow 模板中的节点 UUID（从 API #4 获取） |
 | `param`         | object | 动作参数（根据本地注册表 schema 填写）       |
 | `sample_params` | array  | 样品相关参数（液体名、体积等）               |
 ### sample_params 中每条
 | 字段             | 类型   | 说明                                                 |
 | ---------------- | ------ | ---------------------------------------------------- |
 | `container_uuid` | string | 容器 UUID                                            |
 | `sample_value`   | object | 样品值，如 `{"liquid_names": "水", "volumes": 1000}` |
 ---
 ## 从本地注册表生成 param 模板
 ### 自动方式 — 运行脚本
 ```bash
 python scripts/gen_notebook_params.py \
  --auth <token> \
  --base <BASE_URL> \
  --workflow-uuid <workflow_uuid> \
  [--registry <path/to/req_device_registry_upload.json>] \
  [--rounds <轮次数>] \
  [--output <输出文件路径>]
 ```
 > 脚本位于本文档同级目录下的 `scripts/gen_notebook_params.py`。
 脚本会：
 1. 调用 workflow detail API 获取所有 action 节点
 2. 读取本地注册表，为每个节点查找对应的 action schema
 3. 生成 `notebook_template.json`，包含：
   - 完整 `node_params` 骨架
   - 每个节点的 param 字段及类型说明
   - `_schema_info` 辅助信息（不提交，仅供参考）
 ### 手动方式
 如果脚本不可用或注册表不存在：
 1. 调用 API #4 获取 workflow 详情
 2. 找到每个 action 节点的 `node_uuid`
 3. 在本地注册表中查找对应设备的 `action_value_mappings`：
   ```
   resources[].id == <device_id>
   → resources[].class.action_value_mappings.<action_name>.schema.properties.goal.properties
   ```
 4. 将 schema 中的 properties 作为 `param` 的字段模板
 5. 按轮次复制 `node_params` 元素，让用户填写每轮的具体值
 ### 注册表结构参考
 ```json
 {
  "resources": [
    {
      "id": "liquid_handler.prcxi",
      "class": {
        "module": "unilabos.devices.xxx:ClassName",
        "action_value_mappings": {
          "transfer_liquid": {
            "type": "LiquidHandlerTransfer",
            "schema": {
              "properties": {
                "goal": {
                  "properties": {
                    "asp_vols": {
                      "type": "array",
                      "items": { "type": "number" }
                    },
                    "sources": { "type": "array" }
                  },
                  "required": ["asp_vols", "sources"]
                }
              }
            },
            "goal_default": {}
          }
        }
      }
    }
  ]
 }
 ```
 `param` 填写时，使用 `goal.properties` 中的字段名和类型。
 ---
 ## 完整工作流 Checklist
 ```
 Task Progress:
 - [ ] Step 1: 确认 ak/sk → 生成 AUTH token
 - [ ] Step 2: 确认 --addr → 设置 BASE URL
 - [ ] Step 3: GET /edge/lab/info → 获取 lab_uuid
 - [ ] Step 4: GET /lab/project/list → 列出项目，让用户选择 → 获取 project_uuid
 - [ ] Step 5: 确认 workflow_uuid（用户提供或从 GET #3 列表选择）
 - [ ] Step 6: GET workflow detail (#4) → 提取各节点 uuid、设备ID、动作名
 - [ ] Step 7: 定位本地注册表 req_device_registry_upload.json
 - [ ] Step 8: 运行 gen_notebook_params.py 或手动匹配 → 生成 node_params 模板
 - [ ] Step 9: 引导用户填写每轮的参数（sample_uuids、param、sample_params）
 - [ ] Step 10: 构建完整请求体（含 project_uuid）→ POST /lab/notebook 提交
 - [ ] Step 11: 检查返回结果，记录 notebook UUID
 - [ ] Step 12: GET /lab/notebook/status → 查询 notebook 状态，确认已调度
 ```
 ---
 ## 常见问题
 ### Q: workflow 中有多个节点，每轮都要填所有节点的参数吗？
 是的。`datas` 数组中需要包含该轮实验涉及的每个 workflow 节点的参数。通常每个 action 节点都需要一条 `datas` 记录。
 ### Q: 多轮实验的参数完全不同吗？
 通常每轮的 `param`（设备动作参数）可能相同或相似，但 `sample_uuids` 和 `sample_params`（样品信息）每轮不同。脚本生成模板时会按轮次复制骨架，用户只需修改差异部分。
 ### Q: 如何获取 sample_uuids 和 container_uuid？
 这些 UUID 通常来自实验室的样品管理系统。向用户询问，或从资源树（API `GET /lab/material/download/$lab_uuid`）中查找。
--- a/.cursor/skills/batch-submit-experiment/scripts/gen_notebook_params.py
+++ b/.cursor/skills/batch-submit-experiment/scripts/gen_notebook_params.py
@@ -1,395 +0,0 @@
 #!/usr/bin/env python3
 """
 从 workflow 模板详情 + 本地设备注册表生成 notebook 提交用的 node_params 模板。
 用法:
  python gen_notebook_params.py --auth <token> --base <url> --workflow-uuid <uuid> [选项]
 选项:
  --auth <token>          Lab token（base64(ak:sk) 的结果，不含 "Lab " 前缀）
  --base <url>            API 基础 URL（如 https://leap-lab.test.bohrium.com）
  --workflow-uuid <uuid>  目标 workflow 的 UUID
  --registry <path>       本地注册表文件路径（默认自动搜索）
  --rounds <n>            实验轮次数（默认 1）
  --output <path>         输出模板文件路径（默认 notebook_template.json）
  --dump-response         打印 workflow detail API 的原始响应（调试用）
 示例:
  python gen_notebook_params.py \\
    --auth YTFmZDlkNGUtxxxx \\
    --base https://leap-lab.test.bohrium.com \\
    --workflow-uuid abc-123-def \\
    --rounds 2
 """
 import copy
 import json
 import os
 import sys
 from datetime import datetime
 from urllib.request import Request, urlopen
 from urllib.error import HTTPError, URLError
 REGISTRY_FILENAME = "req_device_registry_upload.json"
 def find_registry(explicit_path=None):
    """查找本地注册表文件，逻辑同 extract_device_actions.py"""
    if explicit_path:
        if os.path.isfile(explicit_path):
            return explicit_path
        if os.path.isdir(explicit_path):
            fp = os.path.join(explicit_path, REGISTRY_FILENAME)
            if os.path.isfile(fp):
                return fp
        print(f"警告: 指定的注册表路径不存在: {explicit_path}")
        return None
    candidates = [
        os.path.join("unilabos_data", REGISTRY_FILENAME),
        REGISTRY_FILENAME,
    ]
    for c in candidates:
        if os.path.isfile(c):
            return c
    script_dir = os.path.dirname(os.path.abspath(__file__))
    workspace_root = os.path.normpath(os.path.join(script_dir, "..", "..", ".."))
    for c in candidates:
        path = os.path.join(workspace_root, c)
        if os.path.isfile(path):
            return path
    cwd = os.getcwd()
    for _ in range(5):
        parent = os.path.dirname(cwd)
        if parent == cwd:
            break
        cwd = parent
        for c in candidates:
            path = os.path.join(cwd, c)
            if os.path.isfile(path):
                return path
    return None
 def load_registry(path):
    with open(path, "r", encoding="utf-8") as f:
        return json.load(f)
 def build_registry_index(registry_data):
    """构建 device_id → action_value_mappings 的索引"""
    index = {}
    for res in registry_data.get("resources", []):
        rid = res.get("id", "")
        avm = res.get("class", {}).get("action_value_mappings", {})
        if rid and avm:
            index[rid] = avm
    return index
 def flatten_goal_schema(action_data):
    """从 action_value_mappings 条目中提取 goal 层的 schema"""
    schema = action_data.get("schema", {})
    goal_schema = schema.get("properties", {}).get("goal", {})
    return goal_schema if goal_schema else schema
 def build_param_template(goal_schema):
    """根据 goal schema 生成 param 模板，含类型标注"""
    properties = goal_schema.get("properties", {})
    required = set(goal_schema.get("required", []))
    template = {}
    for field_name, field_def in properties.items():
        if field_name == "unilabos_device_id":
            continue
        ftype = field_def.get("type", "any")
        default = field_def.get("default")
        if default is not None:
            template[field_name] = default
        elif ftype == "string":
            template[field_name] = f"$TODO ({ftype}, {'required' if field_name in required else 'optional'})"
        elif ftype == "number" or ftype == "integer":
            template[field_name] = 0
        elif ftype == "boolean":
            template[field_name] = False
        elif ftype == "array":
            template[field_name] = []
        elif ftype == "object":
            template[field_name] = {}
        else:
            template[field_name] = f"$TODO ({ftype})"
    return template
 def fetch_workflow_detail(base_url, auth_token, workflow_uuid):
    """调用 workflow detail API"""
    url = f"{base_url}/api/v1/lab/workflow/template/detail/{workflow_uuid}"
    req = Request(url, method="GET")
    req.add_header("Authorization", f"Lab {auth_token}")
    try:
        with urlopen(req, timeout=30) as resp:
            return json.loads(resp.read().decode("utf-8"))
    except HTTPError as e:
        body = e.read().decode("utf-8", errors="replace")
        print(f"API 错误 {e.code}: {body}")
        return None
    except URLError as e:
        print(f"网络错误: {e.reason}")
        return None
 def extract_nodes_from_response(response):
    """
    从 workflow detail 响应中提取 action 节点列表。
    适配多种可能的响应格式。
    返回: [(node_uuid, resource_template_name, node_template_name, existing_param), ...]
    """
    data = response.get("data", response)
    search_keys = ["nodes", "workflow_nodes", "node_list", "steps"]
    nodes_raw = None
    for key in search_keys:
        if key in data and isinstance(data[key], list):
            nodes_raw = data[key]
            break
    if nodes_raw is None:
        if isinstance(data, list):
            nodes_raw = data
        else:
            for v in data.values():
                if isinstance(v, list) and len(v) > 0 and isinstance(v[0], dict):
                    nodes_raw = v
                    break
    if not nodes_raw:
        print("警告: 未能从响应中提取节点列表")
        print("响应顶层 keys:", list(data.keys()) if isinstance(data, dict) else type(data).__name__)
        return []
    result = []
    for node in nodes_raw:
        if not isinstance(node, dict):
            continue
        node_uuid = (
            node.get("uuid")
            or node.get("node_uuid")
            or node.get("id")
            or ""
        )
        resource_name = (
            node.get("resource_template_name")
            or node.get("device_id")
            or node.get("resource_name")
            or node.get("device_name")
            or ""
        )
        template_name = (
            node.get("node_template_name")
            or node.get("action_name")
            or node.get("template_name")
            or node.get("action")
            or node.get("name")
            or ""
        )
        existing_param = node.get("param", {}) or {}
        if node_uuid:
            result.append((node_uuid, resource_name, template_name, existing_param))
    return result
 def generate_template(nodes, registry_index, rounds):
    """生成 notebook 提交模板"""
    node_params = []
    schema_info = {}
    datas_template = []
    for node_uuid, resource_name, template_name, existing_param in nodes:
        param_template = {}
        matched = False
        if resource_name and template_name and resource_name in registry_index:
            avm = registry_index[resource_name]
            if template_name in avm:
                goal_schema = flatten_goal_schema(avm[template_name])
                param_template = build_param_template(goal_schema)
                goal_default = avm[template_name].get("goal_default", {})
                if goal_default:
                    for k, v in goal_default.items():
                        if k in param_template and v is not None:
                            param_template[k] = v
                matched = True
                schema_info[node_uuid] = {
                    "device_id": resource_name,
                    "action_name": template_name,
                    "action_type": avm[template_name].get("type", ""),
                    "schema_properties": list(goal_schema.get("properties", {}).keys()),
                    "required": goal_schema.get("required", []),
                }
        if not matched and existing_param:
            param_template = existing_param
        if not matched and not existing_param:
            schema_info[node_uuid] = {
                "device_id": resource_name,
                "action_name": template_name,
                "warning": "未在本地注册表中找到匹配的 action schema",
            }
        datas_template.append({
            "node_uuid": node_uuid,
            "param": param_template,
            "sample_params": [
                {
                    "container_uuid": "$TODO_CONTAINER_UUID",
                    "sample_value": {
                        "liquid_names": "$TODO_LIQUID_NAME",
                        "volumes": 0,
                    },
                }
            ],
        })
    for i in range(rounds):
        node_params.append({
            "sample_uuids": f"$TODO_SAMPLE_UUID_ROUND_{i + 1}",
            "datas": copy.deepcopy(datas_template),
        })
    return {
        "lab_uuid": "$TODO_LAB_UUID",
        "project_uuid": "$TODO_PROJECT_UUID",
        "workflow_uuid": "$TODO_WORKFLOW_UUID",
        "name": "$TODO_EXPERIMENT_NAME",
        "node_params": node_params,
        "_schema_info（仅参考，提交时删除）": schema_info,
    }
 def parse_args(argv):
    """简单的参数解析"""
    opts = {
        "auth": None,
        "base": None,
        "workflow_uuid": None,
        "registry": None,
        "rounds": 1,
        "output": "notebook_template.json",
        "dump_response": False,
    }
    i = 0
    while i < len(argv):
        arg = argv[i]
        if arg == "--auth" and i + 1 < len(argv):
            opts["auth"] = argv[i + 1]
            i += 2
        elif arg == "--base" and i + 1 < len(argv):
            opts["base"] = argv[i + 1].rstrip("/")
            i += 2
        elif arg == "--workflow-uuid" and i + 1 < len(argv):
            opts["workflow_uuid"] = argv[i + 1]
            i += 2
        elif arg == "--registry" and i + 1 < len(argv):
            opts["registry"] = argv[i + 1]
            i += 2
        elif arg == "--rounds" and i + 1 < len(argv):
            opts["rounds"] = int(argv[i + 1])
            i += 2
        elif arg == "--output" and i + 1 < len(argv):
            opts["output"] = argv[i + 1]
            i += 2
        elif arg == "--dump-response":
            opts["dump_response"] = True
            i += 1
        else:
            print(f"未知参数: {arg}")
            i += 1
    return opts
 def main():
    opts = parse_args(sys.argv[1:])
    if not opts["auth"] or not opts["base"] or not opts["workflow_uuid"]:
        print("用法:")
        print("  python gen_notebook_params.py --auth <token> --base <url> --workflow-uuid <uuid> [选项]")
        print()
        print("必需参数:")
        print("  --auth <token>          Lab token（base64(ak:sk)）")
        print("  --base <url>            API 基础 URL")
        print("  --workflow-uuid <uuid>  目标 workflow UUID")
        print()
        print("可选参数:")
        print("  --registry <path>       注册表文件路径（默认自动搜索）")
        print("  --rounds <n>            实验轮次数（默认 1）")
        print("  --output <path>         输出文件路径（默认 notebook_template.json）")
        print("  --dump-response         打印 API 原始响应")
        sys.exit(1)
    # 1. 查找并加载本地注册表
    registry_path = find_registry(opts["registry"])
    registry_index = {}
    if registry_path:
        mtime = os.path.getmtime(registry_path)
        gen_time = datetime.fromtimestamp(mtime).strftime("%Y-%m-%d %H:%M:%S")
        print(f"注册表: {registry_path}  (生成时间: {gen_time})")
        registry_data = load_registry(registry_path)
        registry_index = build_registry_index(registry_data)
        print(f"已索引 {len(registry_index)} 个设备的 action schemas")
    else:
        print("警告: 未找到本地注册表，将跳过 param 模板生成")
        print("  提交时需要手动填写各节点的 param 字段")
    # 2. 获取 workflow 详情
    print(f"\n正在获取 workflow 详情: {opts['workflow_uuid']}")
    response = fetch_workflow_detail(opts["base"], opts["auth"], opts["workflow_uuid"])
    if not response:
        print("错误: 无法获取 workflow 详情")
        sys.exit(1)
    if opts["dump_response"]:
        print("\n=== API 原始响应 ===")
        print(json.dumps(response, indent=2, ensure_ascii=False)[:5000])
        print("=== 响应结束（截断至 5000 字符） ===\n")
    # 3. 提取节点
    nodes = extract_nodes_from_response(response)
    if not nodes:
        print("错误: 未能从 workflow 中提取任何 action 节点")
        print("请使用 --dump-response 查看原始响应结构")
        sys.exit(1)
    print(f"\n找到 {len(nodes)} 个 action 节点:")
    print(f"  {'节点 UUID':<40} {'设备 ID':<30} {'动作名':<25} {'Schema'}")
    print("  " + "-" * 110)
    for node_uuid, resource_name, template_name, _ in nodes:
        matched = "✓" if (resource_name in registry_index and
                          template_name in registry_index.get(resource_name, {})) else "✗"
        print(f"  {node_uuid:<40} {resource_name:<30} {template_name:<25} {matched}")
    # 4. 生成模板
    template = generate_template(nodes, registry_index, opts["rounds"])
    template["workflow_uuid"] = opts["workflow_uuid"]
    output_path = opts["output"]
    with open(output_path, "w", encoding="utf-8") as f:
        json.dump(template, f, indent=2, ensure_ascii=False)
    print(f"\n模板已写入: {output_path}")
    print(f"  轮次数: {opts['rounds']}")
    print(f"  节点数/轮: {len(nodes)}")
    print()
    print("下一步:")
    print("  1. 打开模板文件，将 $TODO 占位符替换为实际值")
    print("  2. 删除 _schema_info 字段（仅供参考）")
    print("  3. 使用 POST /api/v1/lab/notebook 提交")
 if __name__ == "__main__":
    main()
--- a/.cursor/skills/create-device-skill/SKILL.md
+++ b/.cursor/skills/create-device-skill/SKILL.md
@@ -1,500 +0,0 @@
 ---
 name: create-device-skill
 description: Create a skill for any Uni-Lab device by extracting action schemas from the device registry. Use when the user wants to create a new device skill, add device API documentation, or set up action schemas for a device.
 ---
 # 创建设备 Skill 指南
 本 meta-skill 教你如何为任意 Uni-Lab-OS 设备创建完整的 API 操作技能（参考 `unilab-device-api` 的成功案例）。
 ## 数据源
 - **设备注册表**: `unilabos_data/req_device_registry_upload.json`
 - **结构**: `{ "resources": [{ "id": "<device_id>", "class": { "module": "<python_module:ClassName>", "action_value_mappings": { ... } } }] }`
 - **生成时机**: `unilab` 启动并完成注册表上传后自动生成
 - **module 字段**: 格式 `unilabos.devices.xxx.yyy:ClassName`，可转为源码路径 `unilabos/devices/xxx/yyy.py`，阅读源码可了解参数含义和设备行为
 ## 创建流程
 ### Step 0 — 收集必备信息（缺一不可，否则询问后终止）
 开始前**必须**确认以下 4 项信息全部就绪。如果用户未提供任何一项，**立即询问并终止当前流程**，等用户补齐后再继续。
 向用户提问：「请提供你的 unilab 启动参数，我需要以下信息：」
 #### 必备项 ①：ak / sk（认证凭据）
 来源：启动命令的 `--ak` `--sk` 参数，或 config.py 中的 `ak = "..."` `sk = "..."`。
 获取后立即生成 AUTH token：
 ```bash
 python ./scripts/gen_auth.py <ak> <sk>
 # 或从 config.py 提取
 python ./scripts/gen_auth.py --config <config.py>
 ```
 认证算法：`base64(ak:sk)` → `Authorization: Lab <token>`
 #### 必备项 ②：--addr（目标环境）
 决定 API 请求发往哪个服务器。从启动命令的 `--addr` 参数获取：
 | `--addr` 值    | BASE URL                            |
 | -------------- | ----------------------------------- |
 | `test`         | `https://leap-lab.test.bohrium.com` |
 | `uat`          | `https://leap-lab.uat.bohrium.com`  |
 | `local`        | `http://127.0.0.1:48197`            |
 | 不传（默认）   | `https://leap-lab.bohrium.com`      |
 | 其他自定义 URL | 直接使用该 URL                      |
 #### 必备项 ③：req_device_registry_upload.json（设备注册表）
 数据文件由 `unilab` 启动时自动生成，需要定位它：
 **推断 working_dir**（即 `unilabos_data` 所在目录）：
 | 条件                 | working_dir 取值                                         |
 | -------------------- | -------------------------------------------------------- |
 | 传了 `--working_dir` | `<working_dir>/unilabos_data/`（若子目录已存在则直接用） |
 | 仅传了 `--config`    | `<config 文件所在目录>/unilabos_data/`                   |
 | 都没传               | `<当前工作目录>/unilabos_data/`                          |
 **按优先级搜索文件**：
 ```
 <推断的 working_dir>/unilabos_data/req_device_registry_upload.json
 <推断的 working_dir>/req_device_registry_upload.json
 <workspace 根目录>/unilabos_data/req_device_registry_upload.json
 ```
 也可以直接 Glob 搜索：`**/req_device_registry_upload.json`
 找到后**必须检查文件修改时间**并告知用户：「找到注册表文件 `<路径>`，生成于 `<时间>`。请确认这是最近一次启动生成的。」超过 1 天提醒用户是否需要重新启动 `unilab`。
 **如果文件不存在** → 告知用户先运行 `unilab` 启动命令，等日志出现 `注册表响应数据已保存` 后再执行本流程。**终止。**
 #### 必备项 ④：目标设备
 用户需要明确要为哪个设备创建 skill。可以是设备名称（如「PRCXI 移液站」）或 device_id（如 `liquid_handler.prcxi`）。
 如果用户不确定，运行提取脚本列出所有设备供选择：
 ```bash
 python ./scripts/extract_device_actions.py --registry <找到的文件路径>
 ```
 **四项全部就绪后才进入 Step 1。**
 ### Step 1 — 列出可用设备
 运行提取脚本，列出所有设备及 action 数量和 Python 源码路径，让用户选择：
 ```bash
 # 自动搜索（默认在 unilabos_data/ 和当前目录查找）
 python ./scripts/extract_device_actions.py
 # 指定注册表文件路径
 python ./scripts/extract_device_actions.py --registry <path/to/req_device_registry_upload.json>
 ```
 脚本输出包含每个设备的 **Python 源码路径**（从 `class.module` 转换），可用于后续阅读源码理解参数含义。
 ### Step 2 — 提取 Action Schema
 用户选择设备后，运行提取脚本：
 ```bash
 python ./scripts/extract_device_actions.py [--registry <path>] <device_id> ./skills/<skill-name>/actions/
 ```
 脚本会显示设备的 Python 源码路径和类名，方便阅读源码了解参数含义。
 每个 action 生成一个 JSON 文件，包含：
 - `type` — 作为 API 调用的 `action_type`
 - `schema` — 完整 JSON Schema（含 `properties.goal.properties` 参数定义）
 - `goal` — goal 字段映射（含占位符 `$placeholder`）
 - `goal_default` — 默认值
 ### Step 3 — 写 action-index.md
 按模板为每个 action 写条目（**必须包含 `action_type`**）：
 ```markdown
 ### `<action_name>`
 <用途描述（一句话）>
 - **action_type**: `<从 actions/<name>.json 的 type 字段获取>`
 - **Schema**: [`actions/<filename>.json`](actions/<filename>.json)
 - **核心参数**: `param1`, `param2`（从 schema.required 获取）
 - **可选参数**: `param3`, `param4`
 - **占位符字段**: `field`（需填入物料信息，值以 `$` 开头）
 ```
 描述规则：
 - **每个 action 必须标注 `action_type`**（从 JSON 的 `type` 字段读取），这是 API #9 调用时的必填参数，传错会导致任务永远卡住
 - 从 `schema.properties` 读参数列表（schema 已提升为 goal 内容）
 - 从 `schema.required` 区分核心/可选参数
 - 按功能分类（移液、枪头、外设等）
 - 标注 `placeholder_keys` 中的字段类型：
  - `unilabos_resources` → **ResourceSlot**，填入 `{id, name, uuid}`（id 是路径格式，从资源树取物料节点）
  - `unilabos_devices` → **DeviceSlot**，填入路径字符串如 `"/host_node"`（从资源树筛选 type=device）
  - `unilabos_nodes` → **NodeSlot**，填入路径字符串如 `"/PRCXI/PRCXI_Deck"`（资源树中任意节点）
  - `unilabos_class` → **ClassSlot**，填入类名字符串如 `"container"`（从注册表查找）
  - `unilabos_formulation` → **FormulationSlot**，填入配方数组 `[{well_name, liquids: [{name, volume}]}]`（well_name 为目标物料的 name）
 - array 类型字段 → `[{id, name, uuid}, ...]`
 - 特殊：`create_resource` 的 `res_id`（ResourceSlot）可填不存在的路径
 ### Step 4 — 写 SKILL.md
 直接复用 `unilab-device-api` 的 API 模板，修改：
 - 设备名称
 - Action 数量
 - 目录列表
 - Session state 中的 `device_name`
 - **AUTH 头** — 使用 Step 0 中 `gen_auth.py` 生成的 `Authorization: Lab <token>`（不要硬编码 `Api` 类型的 key）
 - **Python 源码路径** — 在 SKILL.md 开头注明设备对应的源码文件，方便参考参数含义
 - **Slot 字段表** — 列出本设备哪些 action 的哪些字段需要填入 Slot（物料/设备/节点/类名）
 - **action_type 速查表** — 在 API #9 说明后面紧跟一个表格，列出每个 action 对应的 `action_type` 值（从 JSON `type` 字段提取），方便 agent 快速查找而无需打开 JSON 文件
 API 模板结构：
 ```markdown
 ## 设备信息
 - device_id, Python 源码路径, 设备类名
 ## 前置条件（缺一不可）
 - ak/sk → AUTH, --addr → BASE URL
 ## 请求约定
 - Windows 平台必须用 curl.exe（非 PowerShell 的 curl 别名）
 ## Session State
 - lab_uuid（通过 GET /edge/lab/info 直接获取，不要问用户）, device_name
 ## API Endpoints
 # - #1 GET /edge/lab/info → 直接拿到 lab_uuid
 # - #2 创建工作流 POST /lab/workflow/owner → 拼 URL 告知用户
 # - #3 创建节点 POST /edge/workflow/node
 # body: {workflow_uuid, resource_template_name: "<device_id>", node_template_name: "<action_name>"}
 # - #4 删除节点 DELETE /lab/workflow/nodes
 # - #5 更新节点参数 PATCH /lab/workflow/node
 # - #6 查询节点 handles POST /lab/workflow/node-handles
 # body: {node_uuids: ["uuid1","uuid2"]} → 返回各节点的 handle_uuid
 # - #7 批量创建边 POST /lab/workflow/edges
 # body: {edges: [{source_node_uuid, target_node_uuid, source_handle_uuid, target_handle_uuid}]}
 # - #8 启动工作流 POST /lab/workflow/{uuid}/run
 # - #9 运行设备单动作 POST /lab/mcp/run/action（⚠️ action_type 必须从 action-index.md 或 actions/<name>.json 的 type 字段获取，传错会导致任务永远卡住）
 # - #10 查询任务状态 GET /lab/mcp/task/{task_uuid}
 # - #11 运行工作流单节点 POST /lab/mcp/run/workflow/action
 # - #12 获取资源树 GET /lab/material/download/{lab_uuid}
 # - #13 获取工作流模板详情 GET /lab/workflow/template/detail/{workflow_uuid}
 # 返回 workflow 完整结构：data.nodes[] 含每个节点的 uuid、name、param、device_name、handles
 # - #14 按名称查询物料模板 GET /lab/material/template/by-name?lab_uuid=&name=
 # 返回 res_template_uuid，用于 #15 创建物料时的必填字段
 # - #15 创建物料节点 POST /edge/material/node
 # body: {res_template_uuid(从#14获取), name(自定义), display_name, parent_uuid?(从#12获取), ...}
 # - #16 更新物料节点 PUT /edge/material/node
 # body: {uuid(从#12获取), display_name?, description?, init_param_data?, data?, ...}
 ## Placeholder Slot 填写规则
 - unilabos_resources → ResourceSlot → {"id":"/path/name","name":"name","uuid":"xxx"}
 - unilabos_devices → DeviceSlot → "/parent/device" 路径字符串
 - unilabos_nodes → NodeSlot → "/parent/node" 路径字符串
 - unilabos_class → ClassSlot → "class_name" 字符串
 - unilabos_formulation → FormulationSlot → [{well_name, liquids: [{name, volume}]}] 配方数组
 - 特例：create_resource 的 res_id 允许填不存在的路径
 - 列出本设备所有 Slot 字段、类型及含义
 ## 渐进加载策略
 ## 完整工作流 Checklist
 ```
 ### Step 5 — 验证
 检查文件完整性：
 - [ ] `SKILL.md` 包含 API endpoint（#1 获取 lab_uuid、#2-#7 工作流/节点/边、#8-#11 运行/查询、#12 资源树、#13 工作流模板详情、#14-#16 物料管理）
 - [ ] `SKILL.md` 包含 Placeholder Slot 填写规则（ResourceSlot / DeviceSlot / NodeSlot / ClassSlot / FormulationSlot + create_resource 特例）和本设备的 Slot 字段表
 - [ ] `action-index.md` 列出所有 action 并有描述
 - [ ] `actions/` 目录中每个 action 有对应 JSON 文件
 - [ ] JSON 文件包含 `type`, `schema`（已提升为 goal 内容）, `goal`, `goal_default`, `placeholder_keys` 字段
 - [ ] 描述能让 agent 判断该用哪个 action
 ## Action JSON 文件结构
 ```json
 {
  "type": "LiquidHandlerTransfer",    // → API 的 action_type
  "goal": {                           // goal 字段映射
    "sources": "sources",
    "targets": "targets",
    "tip_racks": "tip_racks",
    "asp_vols": "asp_vols"
  },
  "schema": {                         // ← 直接是 goal 的 schema（已提升）
    "type": "object",
    "properties": {                   // 参数定义（即请求中 goal 的字段）
      "sources": { "type": "array", "items": { "type": "object" } },
      "targets": { "type": "array", "items": { "type": "object" } },
      "asp_vols": { "type": "array", "items": { "type": "number" } }
    },
    "required": [...],
    "_unilabos_placeholder_info": {   // ← Slot 类型标记
      "sources": "unilabos_resources",
      "targets": "unilabos_resources",
      "tip_racks": "unilabos_resources"
    }
  },
  "goal_default": { ... },            // 默认值
  "placeholder_keys": {               // ← 汇总所有 Slot 字段
    "sources": "unilabos_resources",  //    ResourceSlot
    "targets": "unilabos_resources",
    "tip_racks": "unilabos_resources",
    "target_device_id": "unilabos_devices"  // DeviceSlot
  }
 }
 ```
 > **注意**：`schema` 已由脚本从原始 `schema.properties.goal` 提升为顶层，直接包含参数定义。
 > `schema.properties` 中的字段即为 API 创建节点返回的 `data.param` 中的字段，PATCH 更新时直接修改 `param` 即可。
 ## Placeholder Slot 类型体系
 `placeholder_keys` / `_unilabos_placeholder_info` 中有 5 种值，对应不同的填写方式：
 | placeholder 值         | Slot 类型       | 填写格式                                              | 选取范围                                  |
 | ---------------------- | --------------- | ----------------------------------------------------- | ----------------------------------------- |
 | `unilabos_resources`   | ResourceSlot    | `{"id": "/path/name", "name": "name", "uuid": "xxx"}` | 仅**物料**节点（不含设备）                |
 | `unilabos_devices`     | DeviceSlot      | `"/parent/device_name"`                               | 仅**设备**节点（type=device），路径字符串 |
 | `unilabos_nodes`       | NodeSlot        | `"/parent/node_name"`                                 | **设备 + 物料**，即所有节点，路径字符串   |
 | `unilabos_class`       | ClassSlot       | `"class_name"`                                        | 注册表中已上报的资源类 name               |
 | `unilabos_formulation` | FormulationSlot | `[{well_name, liquids: [{name, volume}]}]`            | 资源树中物料节点的 **name**，配合液体配方 |
 ### ResourceSlot（`unilabos_resources`）
 最常见的类型。从资源树中选取**物料**节点（孔板、枪头盒、试剂槽等）：
 - 单个：`{"id": "/workstation/container1", "name": "container1", "uuid": "ff149a9a-..."}`
 - 数组：`[{"id": "/path/a", "name": "a", "uuid": "xxx"}, ...]`
 - `id` 从 parent 计算的路径格式，根据 action 语义选择正确的物料
 > **特例**：`create_resource` 的 `res_id`，目标物料可能尚不存在，直接填期望路径，不需要 uuid。
 ### DeviceSlot / NodeSlot / ClassSlot
 - **DeviceSlot**（`unilabos_devices`）：路径字符串如 `"/host_node"`，仅 type=device 的节点
 - **NodeSlot**（`unilabos_nodes`）：路径字符串如 `"/PRCXI/PRCXI_Deck"`，设备 + 物料均可选
 - **ClassSlot**（`unilabos_class`）：类名字符串如 `"container"`，从 `req_resource_registry_upload.json` 查找
 ### FormulationSlot（`unilabos_formulation`）
 描述**液体配方**：向哪些容器中加入哪些液体及体积。
 ```json
 [
  {
    "sample_uuid": "",
    "well_name": "bottle_A1",
    "liquids": [{ "name": "LiPF6", "volume": 0.6 }]
  }
 ]
 ```
 - `well_name` — 目标物料的 **name**（从资源树取，不是 `id` 路径）
 - `liquids[]` — 液体列表，每条含 `name`（试剂名）和 `volume`（体积，单位由上下文决定；pylabrobot 内部统一 uL）
 - `sample_uuid` — 样品 UUID，无样品传 `""`
 - 与 ResourceSlot 的区别：ResourceSlot 指向物料本身，FormulationSlot 引用物料名并附带配方信息
 ### 通过 API #12 获取资源树
 ```bash
 curl -s -X GET "$BASE/api/v1/lab/material/download/$lab_uuid" -H "$AUTH"
 ```
 注意 `lab_uuid` 在路径中（不是查询参数）。返回结构：
 ```json
 {
  "code": 0,
  "data": {
    "nodes": [
      {"name": "host_node", "uuid": "c3ec1e68-...", "type": "device", "parent": ""},
      {"name": "PRCXI", "uuid": "e249c9a6-...", "type": "device", "parent": ""},
      {"name": "PRCXI_Deck", "uuid": "fb6a8b71-...", "type": "deck", "parent": "PRCXI"}
    ],
    "edges": [...]
  }
 }
 ```
 - `data.nodes[]` — 所有节点（设备 + 物料），每个节点含 `name`、`uuid`、`type`、`parent`
 - `type` 区分设备（`device`）和物料（`deck`、`container`、`resource` 等）
 - `parent` 为父节点名称（空字符串表示顶级）
 - 填写 Slot 时根据 placeholder 类型筛选：ResourceSlot 取非 device 节点，DeviceSlot 取 device 节点
 - 创建/更新物料时：`parent_uuid` 取父节点的 `uuid`，更新目标的 `uuid` 取节点自身的 `uuid`
 ## 物料管理 API
 设备 Skill 除了设备动作外，还需支持物料节点的创建和参数设定，用于在资源树中动态管理物料。
 典型流程：先通过 **#14 按名称查询模板** 获取 `res_template_uuid` → 再通过 **#15 创建物料** → 之后可通过 **#16 更新物料** 修改属性。更新时需要的 `uuid` 和 `parent_uuid` 均从 **#12 资源树下载** 获取。
 ### API #14 — 按名称查询物料模板
 创建物料前，需要先获取物料模板的 UUID。通过模板名称查询：
 ```bash
 curl -s -X GET "$BASE/api/v1/lab/material/template/by-name?lab_uuid=$lab_uuid&name=<template_name>" -H "$AUTH"
 ```
 | 参数       | 必填   | 说明                             |
 | ---------- | ------ | -------------------------------- |
 | `lab_uuid` | **是** | 实验室 UUID（从 API #1 获取）    |
 | `name`     | **是** | 物料模板名称（如 `"container"`） |
 返回 `code: 0` 时，**`data.uuid`** 即为 `res_template_uuid`，用于 API #15 创建物料。返回还包含 `name`、`resource_type`、`handles`、`config_infos` 等模板元信息。
 模板不存在时返回 `code: 10002`，`data` 为空对象。模板名称来自资源注册表中已注册的资源类型。
 ### API #15 — 创建物料节点
 ```bash
 curl -s -X POST "$BASE/api/v1/edge/material/node" \
  -H "$AUTH" -H "Content-Type: application/json" \
  -d '<request_body>'
 ```
 请求体：
 ```json
 {
  "res_template_uuid": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
  "name": "my_custom_bottle",
  "display_name": "自定义瓶子",
  "parent_uuid": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
  "type": "",
  "init_param_data": {},
  "schema": {},
  "data": {
    "liquids": [["water", 1000, "uL"]],
    "max_volume": 50000
  },
  "plate_well_datas": {},
  "plate_reagent_datas": {},
  "pose": {},
  "model": {}
 }
 ```
 | 字段                  | 必填   | 类型          | 数据来源                            | 说明                                   |
 | --------------------- | ------ | ------------- | ----------------------------------- | -------------------------------------- |
 | `res_template_uuid`   | **是** | string (UUID) | **API #14** 按名称查询获取          | 物料模板 UUID                          |
 | `name`                | 否     | string        | **用户自定义**                      | 节点名称（标识符），可自由命名         |
 | `display_name`        | 否     | string        | 用户自定义                          | 显示名称（UI 展示用）                  |
 | `parent_uuid`         | 否     | string (UUID) | **API #12** 资源树中父节点的 `uuid` | 父节点，为空则创建顶级节点             |
 | `type`                | 否     | string        | 从模板继承                          | 节点类型                               |
 | `init_param_data`     | 否     | object        | 用户指定                            | 初始化参数，覆盖模板默认值             |
 | `data`                | 否     | object        | 用户指定                            | 节点数据，container 见下方 data 格式   |
 | `plate_well_datas`    | 否     | object        | 用户指定                            | 孔板子节点数据（创建带孔位的板时使用） |
 | `plate_reagent_datas` | 否     | object        | 用户指定                            | 试剂关联数据                           |
 | `schema`              | 否     | object        | 从模板继承                          | 自定义 schema，不传则从模板继承        |
 | `pose`                | 否     | object        | 用户指定                            | 位姿信息                               |
 | `model`               | 否     | object        | 用户指定                            | 3D 模型信息                            |
 #### container 的 `data` 格式
 > **体积单位统一为 uL（微升）**。pylabrobot 体系中所有体积值（`max_volume`、`liquids` 中的 volume）均为 uL。外部如果是 mL 需乘 1000 转换。
 ```json
 {
  "liquids": [["water", 1000, "uL"], ["ethanol", 500, "uL"]],
  "max_volume": 50000
 }
 ```
 - `liquids` — 液体列表，每条为 `[液体名称, 体积(uL), 单位字符串]`
 - `max_volume` — 容器最大容量（uL），如 50 mL = 50000 uL
 ### API #16 — 更新物料节点
 ```bash
 curl -s -X PUT "$BASE/api/v1/edge/material/node" \
  -H "$AUTH" -H "Content-Type: application/json" \
  -d '<request_body>'
 ```
 请求体：
 ```json
 {
  "uuid": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
  "parent_uuid": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
  "display_name": "新显示名称",
  "description": "新描述",
  "init_param_data": {},
  "data": {},
  "pose": {},
  "schema": {},
  "extra": {}
 }
 ```
 | 字段              | 必填   | 类型          | 数据来源                              | 说明             |
 | ----------------- | ------ | ------------- | ------------------------------------- | ---------------- |
 | `uuid`            | **是** | string (UUID) | **API #12** 资源树中目标节点的 `uuid` | 要更新的物料节点 |
 | `parent_uuid`     | 否     | string (UUID) | API #12 资源树                        | 移动到新父节点   |
 | `display_name`    | 否     | string        | 用户指定                              | 更新显示名称     |
 | `description`     | 否     | string        | 用户指定                              | 更新描述         |
 | `init_param_data` | 否     | object        | 用户指定                              | 更新初始化参数   |
 | `data`            | 否     | object        | 用户指定                              | 更新节点数据     |
 | `pose`            | 否     | object        | 用户指定                              | 更新位姿         |
 | `schema`          | 否     | object        | 用户指定                              | 更新 schema      |
 | `extra`           | 否     | object        | 用户指定                              | 更新扩展数据     |
 > 只传需要更新的字段，未传的字段保持不变。
 ## 最终目录结构
 ```
 ./<skill-name>/
 ├── SKILL.md              # API 端点 + 渐进加载指引
 ├── action-index.md       # 动作索引：描述/用途/核心参数
 └── actions/              # 每个 action 的完整 JSON Schema
    ├── action1.json
    ├── action2.json
    └── ...
 ```
--- a/.cursor/skills/create-device-skill/scripts/extract_device_actions.py
+++ b/.cursor/skills/create-device-skill/scripts/extract_device_actions.py
@@ -1,200 +0,0 @@
 #!/usr/bin/env python3
 """
 从 req_device_registry_upload.json 中提取指定设备的 action schema。
 用法:
  # 列出所有设备及 action 数量（自动搜索注册表文件）
  python extract_device_actions.py
  # 指定注册表文件路径
  python extract_device_actions.py --registry <path/to/req_device_registry_upload.json>
  # 提取指定设备的 action 到目录
  python extract_device_actions.py <device_id> <output_dir>
  python extract_device_actions.py --registry <path> <device_id> <output_dir>
 示例:
  python extract_device_actions.py --registry unilabos_data/req_device_registry_upload.json
  python extract_device_actions.py liquid_handler.prcxi .cursor/skills/unilab-device-api/actions/
 """
 import json
 import os
 import sys
 from datetime import datetime
 REGISTRY_FILENAME = "req_device_registry_upload.json"
 def find_registry(explicit_path=None):
    """
    查找 req_device_registry_upload.json 文件。
    搜索优先级：
    1. 用户通过 --registry 显式指定的路径
    2. <cwd>/unilabos_data/req_device_registry_upload.json
    3. <cwd>/req_device_registry_upload.json
    4. <script所在目录>/../../.. (workspace根) 下的 unilabos_data/
    5. 向上逐级搜索父目录（最多 5 层）
    """
    if explicit_path:
        if os.path.isfile(explicit_path):
            return explicit_path
        if os.path.isdir(explicit_path):
            fp = os.path.join(explicit_path, REGISTRY_FILENAME)
            if os.path.isfile(fp):
                return fp
        print(f"警告: 指定的路径不存在: {explicit_path}")
        return None
    candidates = [
        os.path.join("unilabos_data", REGISTRY_FILENAME),
        REGISTRY_FILENAME,
    ]
    for c in candidates:
        if os.path.isfile(c):
            return c
    script_dir = os.path.dirname(os.path.abspath(__file__))
    workspace_root = os.path.normpath(os.path.join(script_dir, "..", "..", ".."))
    for c in candidates:
        path = os.path.join(workspace_root, c)
        if os.path.isfile(path):
            return path
    cwd = os.getcwd()
    for _ in range(5):
        parent = os.path.dirname(cwd)
        if parent == cwd:
            break
        cwd = parent
        for c in candidates:
            path = os.path.join(cwd, c)
            if os.path.isfile(path):
                return path
    return None
 def load_registry(path):
    with open(path, 'r', encoding='utf-8') as f:
        return json.load(f)
 def list_devices(data):
    """列出所有包含 action_value_mappings 的设备，同时返回 module 路径"""
    resources = data.get('resources', [])
    devices = []
    for res in resources:
        rid = res.get('id', '')
        cls = res.get('class', {})
        avm = cls.get('action_value_mappings', {})
        module = cls.get('module', '')
        if avm:
            devices.append((rid, len(avm), module))
    return devices
 def flatten_schema_to_goal(action_data):
    """将 schema 中嵌套的 goal 内容提升为顶层 schema，去掉 feedback/result 包装"""
    schema = action_data.get('schema', {})
    goal_schema = schema.get('properties', {}).get('goal', {})
    if goal_schema:
        action_data = dict(action_data)
        action_data['schema'] = goal_schema
    return action_data
 def extract_actions(data, device_id, output_dir):
    """提取指定设备的 action schema 到独立 JSON 文件"""
    resources = data.get('resources', [])
    for res in resources:
        if res.get('id') == device_id:
            cls = res.get('class', {})
            module = cls.get('module', '')
            avm = cls.get('action_value_mappings', {})
            if not avm:
                print(f"设备 {device_id} 没有 action_value_mappings")
                return []
            if module:
                py_path = module.split(":")[0].replace(".", "/") + ".py"
                class_name = module.split(":")[-1] if ":" in module else ""
                print(f"Python 源码: {py_path}")
                if class_name:
                    print(f"设备类: {class_name}")
            os.makedirs(output_dir, exist_ok=True)
            written = []
            for action_name in sorted(avm.keys()):
                action_data = flatten_schema_to_goal(avm[action_name])
                filename = action_name.replace('-', '_') + '.json'
                filepath = os.path.join(output_dir, filename)
                with open(filepath, 'w', encoding='utf-8') as f:
                    json.dump(action_data, f, indent=2, ensure_ascii=False)
                written.append(filename)
                print(f"  {filepath}")
            return written
    print(f"设备 {device_id} 未找到")
    return []
 def main():
    args = sys.argv[1:]
    explicit_registry = None
    if "--registry" in args:
        idx = args.index("--registry")
        if idx + 1 < len(args):
            explicit_registry = args[idx + 1]
            args = args[:idx] + args[idx + 2:]
        else:
            print("错误: --registry 需要指定路径")
            sys.exit(1)
    registry_path = find_registry(explicit_registry)
    if not registry_path:
        print(f"错误: 找不到 {REGISTRY_FILENAME}")
        print()
        print("解决方法:")
        print("  1. 先运行 unilab 启动命令，等待注册表生成")
        print("  2. 用 --registry 指定文件路径:")
        print(f"     python {sys.argv[0]} --registry <path/to/{REGISTRY_FILENAME}>")
        print()
        print("搜索过的路径:")
        for p in [
            os.path.join("unilabos_data", REGISTRY_FILENAME),
            REGISTRY_FILENAME,
            os.path.join("<workspace_root>", "unilabos_data", REGISTRY_FILENAME),
        ]:
            print(f"  - {p}")
        sys.exit(1)
    print(f"注册表: {registry_path}")
    mtime = os.path.getmtime(registry_path)
    gen_time = datetime.fromtimestamp(mtime).strftime("%Y-%m-%d %H:%M:%S")
    size_mb = os.path.getsize(registry_path) / (1024 * 1024)
    print(f"生成时间: {gen_time}  (文件大小: {size_mb:.1f} MB)")
    data = load_registry(registry_path)
    if len(args) == 0:
        devices = list_devices(data)
        print(f"\n找到 {len(devices)} 个设备:")
        print(f"{'设备 ID':<50} {'Actions':>7}  {'Python 模块'}")
        print("-" * 120)
        for did, count, module in sorted(devices, key=lambda x: x[0]):
            py_path = module.split(":")[0].replace(".", "/") + ".py" if module else ""
            print(f"{did:<50} {count:>7}  {py_path}")
    elif len(args) == 2:
        device_id = args[0]
        output_dir = args[1]
        print(f"\n提取 {device_id} 的 actions 到 {output_dir}/")
        written = extract_actions(data, device_id, output_dir)
        if written:
            print(f"\n共写入 {len(written)} 个 action 文件")
    else:
        print("用法:")
        print("  python extract_device_actions.py [--registry <path>]                # 列出设备")
        print("  python extract_device_actions.py [--registry <path>] <device_id> <dir>  # 提取 actions")
        sys.exit(1)
 if __name__ == '__main__':
    main()
--- a/.cursor/skills/create-device-skill/scripts/gen_auth.py
+++ b/.cursor/skills/create-device-skill/scripts/gen_auth.py
@@ -1,69 +0,0 @@
 #!/usr/bin/env python3
 """
 从 ak/sk 生成 UniLab API Authorization header。
 算法: base64(ak:sk) → "Authorization: Lab <token>"
 用法:
  python gen_auth.py <ak> <sk>
  python gen_auth.py --config <config.py>
 示例:
  python gen_auth.py myak mysk
  python gen_auth.py --config experiments/config.py
 """
 import base64
 import re
 import sys
 def gen_auth(ak: str, sk: str) -> str:
    token = base64.b64encode(f"{ak}:{sk}".encode("utf-8")).decode("utf-8")
    return token
 def extract_from_config(config_path: str) -> tuple:
    """从 config.py 中提取 ak 和 sk"""
    with open(config_path, "r", encoding="utf-8") as f:
        content = f.read()
    ak_match = re.search(r'''ak\s*=\s*["']([^"']+)["']''', content)
    sk_match = re.search(r'''sk\s*=\s*["']([^"']+)["']''', content)
    if not ak_match or not sk_match:
        return None, None
    return ak_match.group(1), sk_match.group(1)
 def main():
    args = sys.argv[1:]
    if len(args) == 2 and args[0] == "--config":
        ak, sk = extract_from_config(args[1])
        if not ak or not sk:
            print(f"错误: 在 {args[1]} 中未找到 ak/sk 配置")
            print("期望格式: ak = \"xxx\"  sk = \"xxx\"")
            sys.exit(1)
        print(f"配置文件: {args[1]}")
    elif len(args) == 2:
        ak, sk = args
    else:
        print("用法:")
        print("  python gen_auth.py <ak> <sk>")
        print("  python gen_auth.py --config <config.py>")
        sys.exit(1)
    token = gen_auth(ak, sk)
    print(f"ak: {ak}")
    print(f"sk: {sk}")
    print()
    print(f"Authorization header:")
    print(f"  Authorization: Lab {token}")
    print()
    print(f"curl 用法:")
    print(f'  curl -H "Authorization: Lab {token}" ...')
    print()
    print(f"Shell 变量:")
    print(f'  AUTH="Authorization: Lab {token}"')
 if __name__ == "__main__":
    main()
--- a/.cursor/skills/host-node/SKILL.md
+++ b/.cursor/skills/host-node/SKILL.md
@@ -1,251 +0,0 @@
 ---
 name: host-node
 description: Operate Uni-Lab host node via REST API — create resources, test latency, test resource tree, manual confirm. Use when the user mentions host_node, creating resources, resource management, testing latency, or any host node operation.
 ---
 # Host Node API Skill
 ## 设备信息
 - **device_id**: `host_node`
 - **Python 源码**: `unilabos/ros/nodes/presets/host_node.py`
 - **设备类**: `HostNode`
 - **动作数**: 4（`create_resource`, `test_latency`, `auto-test_resource`, `manual_confirm`）
 ## 前置条件（缺一不可）
 使用本 skill 前，**必须**先确认以下信息。如果缺少任何一项，**立即向用户询问并终止**，等补齐后再继续。
 ### 1. ak / sk → AUTH
 从启动参数 `--ak` `--sk` 或 config.py 中获取，生成 token：`base64(ak:sk)` → `Authorization: Lab <token>`
 ### 2. --addr → BASE URL
 | `--addr` 值  | BASE                                |
 | ------------ | ----------------------------------- |
 | `test`       | `https://leap-lab.test.bohrium.com` |
 | `uat`        | `https://leap-lab.uat.bohrium.com`  |
 | `local`      | `http://127.0.0.1:48197`            |
 | 不传（默认） | `https://leap-lab.bohrium.com`      |
 确认后设置：
 ```bash
 BASE="<根据 addr 确定的 URL>"
 AUTH="Authorization: Lab <token>"
 ```
 **两项全部就绪后才可发起 API 请求。**
 ## Session State
 在整个对话过程中，agent 需要记住以下状态，避免重复询问用户：
 - `lab_uuid` — 实验室 UUID（首次通过 API #1 自动获取，**不需要问用户**）
 - `device_name` — `host_node`
 ## 请求约定
 所有请求使用 `curl -s`，POST/PATCH/DELETE 需加 `Content-Type: application/json`。
 > **Windows 平台**必须使用 `curl.exe`（而非 PowerShell 的 `curl` 别名）。
 ---
 ## API Endpoints
 ### 1. 获取实验室信息（自动获取 lab_uuid）
 ```bash
 curl -s -X GET "$BASE/api/v1/edge/lab/info" -H "$AUTH"
 ```
 返回 `data.uuid` 为 `lab_uuid`，`data.name` 为 `lab_name`。
 ### 2. 创建工作流
 ```bash
 curl -s -X POST "$BASE/api/v1/lab/workflow/owner" \
  -H "$AUTH" -H "Content-Type: application/json" \
  -d '{"name":"<名称>","lab_uuid":"<lab_uuid>","description":"<描述>"}'
 ```
 返回 `data.uuid` 为 `workflow_uuid`。创建成功后告知用户链接：`$BASE/laboratory/$lab_uuid/workflow/$workflow_uuid`
 ### 3. 创建节点
 ```bash
 curl -s -X POST "$BASE/api/v1/edge/workflow/node" \
  -H "$AUTH" -H "Content-Type: application/json" \
  -d '{"workflow_uuid":"<workflow_uuid>","resource_template_name":"host_node","node_template_name":"<action_name>"}'
 ```
 - `resource_template_name` 固定为 `host_node`
 - `node_template_name` — action 名称（如 `create_resource`, `test_latency`）
 ### 4. 删除节点
 ```bash
 curl -s -X DELETE "$BASE/api/v1/lab/workflow/nodes" \
  -H "$AUTH" -H "Content-Type: application/json" \
  -d '{"node_uuids":["<uuid1>"],"workflow_uuid":"<workflow_uuid>"}'
 ```
 ### 5. 更新节点参数
 ```bash
 curl -s -X PATCH "$BASE/api/v1/lab/workflow/node" \
  -H "$AUTH" -H "Content-Type: application/json" \
  -d '{"workflow_uuid":"<wf_uuid>","uuid":"<node_uuid>","param":{...}}'
 ```
 `param` 直接使用创建节点返回的 `data.param` 结构，修改需要填入的字段值。参考 [action-index.md](action-index.md) 确定哪些字段是 Slot。
 ### 6. 查询节点 handles
 ```bash
 curl -s -X POST "$BASE/api/v1/lab/workflow/node-handles" \
  -H "$AUTH" -H "Content-Type: application/json" \
  -d '{"node_uuids":["<node_uuid_1>","<node_uuid_2>"]}'
 ```
 ### 7. 批量创建边
 ```bash
 curl -s -X POST "$BASE/api/v1/lab/workflow/edges" \
  -H "$AUTH" -H "Content-Type: application/json" \
  -d '{"edges":[{"source_node_uuid":"<uuid>","target_node_uuid":"<uuid>","source_handle_uuid":"<uuid>","target_handle_uuid":"<uuid>"}]}'
 ```
 ### 8. 启动工作流
 ```bash
 curl -s -X POST "$BASE/api/v1/lab/workflow/<workflow_uuid>/run" -H "$AUTH"
 ```
 ### 9. 运行设备单动作
 ```bash
 curl -s -X POST "$BASE/api/v1/lab/mcp/run/action" \
  -H "$AUTH" -H "Content-Type: application/json" \
  -d '{"lab_uuid":"<lab_uuid>","device_id":"host_node","action":"<action_name>","action_type":"<type>","param":{...}}'
 ```
 `param` 直接放 goal 里的属性，**不要**再包一层 `{"goal": {...}}`。
 > **WARNING: `action_type` 必须正确，传错会导致任务永远卡住无法完成。** 从下表或 `actions/<name>.json` 的 `type` 字段获取。
 #### action_type 速查表
 | action | action_type |
 |--------|-------------|
 | `test_latency` | `UniLabJsonCommand` |
 | `create_resource` | `ResourceCreateFromOuterEasy` |
 | `auto-test_resource` | `UniLabJsonCommand` |
 | `manual_confirm` | `UniLabJsonCommand` |
 ### 10. 查询任务状态
 ```bash
 curl -s -X GET "$BASE/api/v1/lab/mcp/task/<task_uuid>" -H "$AUTH"
 ```
 ### 11. 运行工作流单节点
 ```bash
 curl -s -X POST "$BASE/api/v1/lab/mcp/run/workflow/action" \
  -H "$AUTH" -H "Content-Type: application/json" \
  -d '{"node_uuid":"<node_uuid>"}'
 ```
 ### 12. 获取资源树（物料信息）
 ```bash
 curl -s -X GET "$BASE/api/v1/lab/material/download/$lab_uuid" -H "$AUTH"
 ```
 注意 `lab_uuid` 在路径中。返回 `data.nodes[]` 含所有节点（设备 + 物料），每个节点含 `name`、`uuid`、`type`、`parent`。
 ### 13. 获取工作流模板详情
 ```bash
 curl -s -X GET "$BASE/api/v1/lab/workflow/template/detail/$workflow_uuid" -H "$AUTH"
 ```
 > 必须使用 `/lab/workflow/template/detail/{uuid}`，其他路径会返回 404。
 ### 14. 按名称查询物料模板
 ```bash
 curl -s -X GET "$BASE/api/v1/lab/material/template/by-name?lab_uuid=$lab_uuid&name=<template_name>" -H "$AUTH"
 ```
 返回 `data.uuid` 为 `res_template_uuid`，用于 API #15。
 ### 15. 创建物料节点
 ```bash
 curl -s -X POST "$BASE/api/v1/edge/material/node" \
  -H "$AUTH" -H "Content-Type: application/json" \
  -d '{"res_template_uuid":"<uuid>","name":"<名称>","display_name":"<显示名>","parent_uuid":"<父节点uuid>","data":{...}}'
 ```
 ### 16. 更新物料节点
 ```bash
 curl -s -X PUT "$BASE/api/v1/edge/material/node" \
  -H "$AUTH" -H "Content-Type: application/json" \
  -d '{"uuid":"<节点uuid>","display_name":"<新名称>","data":{...}}'
 ```
 ---
 ## Placeholder Slot 填写规则
 | `placeholder_keys` 值 | Slot 类型    | 填写格式                                              | 选取范围               |
 | --------------------- | ------------ | ----------------------------------------------------- | ---------------------- |
 | `unilabos_resources`  | ResourceSlot | `{"id": "/path/name", "name": "name", "uuid": "xxx"}` | 仅物料节点（非设备）   |
 | `unilabos_devices`    | DeviceSlot   | `"/parent/device_name"`                               | 仅设备节点（type=device） |
 | `unilabos_nodes`      | NodeSlot     | `"/parent/node_name"`                                 | 所有节点（设备 + 物料）   |
 | `unilabos_class`      | ClassSlot    | `"class_name"`                                        | 注册表中已注册的资源类    |
 ### host_node 设备的 Slot 字段表
 | Action            | 字段        | Slot 类型    | 说明                           |
 | ----------------- | ----------- | ------------ | ------------------------------ |
 | `create_resource` | `res_id`    | ResourceSlot | 新资源路径（可填不存在的路径） |
 | `create_resource` | `device_id` | DeviceSlot   | 归属设备                       |
 | `create_resource` | `parent`    | NodeSlot     | 父节点路径                     |
 | `create_resource` | `class_name`| ClassSlot    | 资源类名如 `"container"`       |
 | `auto-test_resource` | `resource`  | ResourceSlot | 单个测试物料                |
 | `auto-test_resource` | `resources` | ResourceSlot | 测试物料数组                |
 | `auto-test_resource` | `device`    | DeviceSlot   | 测试设备                    |
 | `auto-test_resource` | `devices`   | DeviceSlot   | 测试设备                    |
 ---
 ## 渐进加载策略
 1. **SKILL.md**（本文件）— API 端点 + session state 管理
 2. **[action-index.md](action-index.md)** — 按分类浏览 4 个动作的描述和核心参数
 3. **[actions/\<name\>.json](actions/)** — 仅在需要构建具体请求时，加载对应 action 的完整 JSON Schema
 ---
 ## 完整工作流 Checklist
 ```
 Task Progress:
 - [ ] Step 1: GET /edge/lab/info 获取 lab_uuid
 - [ ] Step 2: 获取资源树 (GET #12) → 记住可用物料
 - [ ] Step 3: 读 action-index.md 确定要用的 action 名
 - [ ] Step 4: 创建工作流 (POST #2) → 记住 workflow_uuid，告知用户链接
 - [ ] Step 5: 创建节点 (POST #3, resource_template_name=host_node) → 记住 node_uuid + data.param
 - [ ] Step 6: 根据 _unilabos_placeholder_info 和资源树，填写 data.param 中的 Slot 字段
 - [ ] Step 7: 更新节点参数 (PATCH #5)
 - [ ] Step 8: 查询节点 handles (POST #6) → 获取各节点的 handle_uuid
 - [ ] Step 9: 批量创建边 (POST #7) → 用 handle_uuid 连接节点
 - [ ] Step 10: 启动工作流 (POST #8) 或运行单节点 (POST #11)
 - [ ] Step 11: 查询任务状态 (GET #10) 确认完成
 ```
--- a/.cursor/skills/host-node/action-index.md
+++ b/.cursor/skills/host-node/action-index.md
@@ -1,58 +0,0 @@
 # Action Index — host_node
 4 个动作，按功能分类。每个动作的完整 JSON Schema 在 `actions/<name>.json`。
 ---
 ## 资源管理
 ### `create_resource`
 在资源树中创建新资源（容器、物料等），支持指定位置、类型和初始液体
 - **action_type**: `ResourceCreateFromOuterEasy`
 - **Schema**: [`actions/create_resource.json`](actions/create_resource.json)
 - **可选参数**: `res_id`, `device_id`, `class_name`, `parent`, `bind_locations`, `liquid_input_slot`, `liquid_type`, `liquid_volume`, `slot_on_deck`
 - **占位符字段**:
  - `res_id` — **ResourceSlot**（特例：目标物料可能尚不存在，直接填期望路径）
  - `device_id` — **DeviceSlot**，填路径字符串如 `"/host_node"`
  - `parent` — **NodeSlot**，填路径字符串如 `"/workstation/deck"`
  - `class_name` — **ClassSlot**，填类名如 `"container"`
 ### `auto-test_resource`
 测试资源系统，返回当前资源树和设备列表
 - **action_type**: `UniLabJsonCommand`
 - **Schema**: [`actions/test_resource.json`](actions/test_resource.json)
 - **可选参数**: `resource`, `resources`, `device`, `devices`
 - **占位符字段**:
  - `resource` — **ResourceSlot**，单个物料节点 `{id, name, uuid}`
  - `resources` — **ResourceSlot**，物料节点数组 `[{id, name, uuid}, ...]`
  - `device` — **DeviceSlot**，设备路径字符串
  - `devices` — **DeviceSlot**，设备路径字符串
 ---
 ## 系统工具
 ### `test_latency`
 测试设备通信延迟，返回 RTT、时间差、任务延迟等指标
 - **action_type**: `UniLabJsonCommand`
 - **Schema**: [`actions/test_latency.json`](actions/test_latency.json)
 - **参数**: 无（零参数调用）
 ---
 ## 人工确认
 ### `manual_confirm`
 创建人工确认节点，等待用户手动确认后继续
 - **action_type**: `UniLabJsonCommand`
 - **Schema**: [`actions/manual_confirm.json`](actions/manual_confirm.json)
 - **核心参数**: `timeout_seconds`（超时时间，秒）, `assignee_user_ids`（指派用户 ID 列表）
 - **占位符字段**: `assignee_user_ids` — `unilabos_manual_confirm` 类型
--- a/.cursor/skills/host-node/actions/create_resource.json
+++ b/.cursor/skills/host-node/actions/create_resource.json
@@ -1,93 +0,0 @@
 {
  "type": "ResourceCreateFromOuterEasy",
  "goal": {
    "res_id": "res_id",
    "class_name": "class_name",
    "parent": "parent",
    "device_id": "device_id",
    "bind_locations": "bind_locations",
    "liquid_input_slot": "liquid_input_slot[]",
    "liquid_type": "liquid_type[]",
    "liquid_volume": "liquid_volume[]",
    "slot_on_deck": "slot_on_deck"
  },
  "schema": {
    "type": "object",
    "properties": {
      "res_id": {
        "type": "string"
      },
      "device_id": {
        "type": "string"
      },
      "class_name": {
        "type": "string"
      },
      "parent": {
        "type": "string"
      },
      "bind_locations": {
        "type": "object",
        "properties": {
          "x": {
            "type": "number",
            "minimum": -1.7976931348623157e+308,
            "maximum": 1.7976931348623157e+308
          },
          "y": {
            "type": "number",
            "minimum": -1.7976931348623157e+308,
            "maximum": 1.7976931348623157e+308
          },
          "z": {
            "type": "number",
            "minimum": -1.7976931348623157e+308,
            "maximum": 1.7976931348623157e+308
          }
        },
        "required": [
          "x",
          "y",
          "z"
        ],
        "title": "bind_locations",
        "additionalProperties": false
      },
      "liquid_input_slot": {
        "type": "array",
        "items": {
          "type": "integer"
        }
      },
      "liquid_type": {
        "type": "array",
        "items": {
          "type": "string"
        }
      },
      "liquid_volume": {
        "type": "array",
        "items": {
          "type": "number"
        }
      },
      "slot_on_deck": {
        "type": "string"
      }
    },
    "required": [],
    "_unilabos_placeholder_info": {
      "res_id": "unilabos_resources",
      "device_id": "unilabos_devices",
      "parent": "unilabos_nodes",
      "class_name": "unilabos_class"
    }
  },
  "goal_default": {},
  "placeholder_keys": {
    "res_id": "unilabos_resources",
    "device_id": "unilabos_devices",
    "parent": "unilabos_nodes",
    "class_name": "unilabos_class"
  }
 }
--- a/.cursor/skills/host-node/actions/manual_confirm.json
+++ b/.cursor/skills/host-node/actions/manual_confirm.json
@@ -1,32 +0,0 @@
 {
  "type": "UniLabJsonCommand",
  "goal": {
    "timeout_seconds": "timeout_seconds",
    "assignee_user_ids": "assignee_user_ids"
  },
  "schema": {
    "type": "object",
    "properties": {
      "timeout_seconds": {
        "type": "integer"
      },
      "assignee_user_ids": {
        "type": "array",
        "items": {
          "type": "string"
        }
      }
    },
    "required": [
      "timeout_seconds",
      "assignee_user_ids"
    ],
    "_unilabos_placeholder_info": {
      "assignee_user_ids": "unilabos_manual_confirm"
    }
  },
  "goal_default": {},
  "placeholder_keys": {
    "assignee_user_ids": "unilabos_manual_confirm"
  }
 }
--- a/.cursor/skills/host-node/actions/test_latency.json
+++ b/.cursor/skills/host-node/actions/test_latency.json
@@ -1,11 +0,0 @@
 {
  "type": "UniLabJsonCommand",
  "goal": {},
  "schema": {
    "type": "object",
    "properties": {},
    "required": []
  },
  "goal_default": {},
  "placeholder_keys": {}
 }
--- a/.cursor/skills/host-node/actions/test_resource.json
+++ b/.cursor/skills/host-node/actions/test_resource.json
@@ -1,255 +0,0 @@
 {
  "type": "UniLabJsonCommand",
  "goal": {
    "resource": "resource",
    "resources": "resources",
    "device": "device",
    "devices": "devices"
  },
  "schema": {
    "type": "object",
    "properties": {
      "resource": {
        "type": "object",
        "additionalProperties": false,
        "properties": {
          "id": {
            "type": "string"
          },
          "name": {
            "type": "string"
          },
          "sample_id": {
            "type": "string"
          },
          "children": {
            "type": "array",
            "items": {
              "type": "string"
            }
          },
          "parent": {
            "type": "string"
          },
          "type": {
            "type": "string"
          },
          "category": {
            "type": "string"
          },
          "pose": {
            "type": "object",
            "properties": {
              "position": {
                "type": "object",
                "properties": {
                  "x": {
                    "type": "number",
                    "minimum": -1.7976931348623157e+308,
                    "maximum": 1.7976931348623157e+308
                  },
                  "y": {
                    "type": "number",
                    "minimum": -1.7976931348623157e+308,
                    "maximum": 1.7976931348623157e+308
                  },
                  "z": {
                    "type": "number",
                    "minimum": -1.7976931348623157e+308,
                    "maximum": 1.7976931348623157e+308
                  }
                },
                "required": [
                  "x",
                  "y",
                  "z"
                ],
                "title": "position",
                "additionalProperties": false
              },
              "orientation": {
                "type": "object",
                "properties": {
                  "x": {
                    "type": "number",
                    "minimum": -1.7976931348623157e+308,
                    "maximum": 1.7976931348623157e+308
                  },
                  "y": {
                    "type": "number",
                    "minimum": -1.7976931348623157e+308,
                    "maximum": 1.7976931348623157e+308
                  },
                  "z": {
                    "type": "number",
                    "minimum": -1.7976931348623157e+308,
                    "maximum": 1.7976931348623157e+308
                  },
                  "w": {
                    "type": "number",
                    "minimum": -1.7976931348623157e+308,
                    "maximum": 1.7976931348623157e+308
                  }
                },
                "required": [
                  "x",
                  "y",
                  "z",
                  "w"
                ],
                "title": "orientation",
                "additionalProperties": false
              }
            },
            "required": [
              "position",
              "orientation"
            ],
            "title": "pose",
            "additionalProperties": false
          },
          "config": {
            "type": "string"
          },
          "data": {
            "type": "string"
          }
        },
        "title": "resource"
      },
      "resources": {
        "items": {
          "type": "object",
          "additionalProperties": false,
          "properties": {
            "id": {
              "type": "string"
            },
            "name": {
              "type": "string"
            },
            "sample_id": {
              "type": "string"
            },
            "children": {
              "type": "array",
              "items": {
                "type": "string"
              }
            },
            "parent": {
              "type": "string"
            },
            "type": {
              "type": "string"
            },
            "category": {
              "type": "string"
            },
            "pose": {
              "type": "object",
              "properties": {
                "position": {
                  "type": "object",
                  "properties": {
                    "x": {
                      "type": "number",
                      "minimum": -1.7976931348623157e+308,
                      "maximum": 1.7976931348623157e+308
                    },
                    "y": {
                      "type": "number",
                      "minimum": -1.7976931348623157e+308,
                      "maximum": 1.7976931348623157e+308
                    },
                    "z": {
                      "type": "number",
                      "minimum": -1.7976931348623157e+308,
                      "maximum": 1.7976931348623157e+308
                    }
                  },
                  "required": [
                    "x",
                    "y",
                    "z"
                  ],
                  "title": "position",
                  "additionalProperties": false
                },
                "orientation": {
                  "type": "object",
                  "properties": {
                    "x": {
                      "type": "number",
                      "minimum": -1.7976931348623157e+308,
                      "maximum": 1.7976931348623157e+308
                    },
                    "y": {
                      "type": "number",
                      "minimum": -1.7976931348623157e+308,
                      "maximum": 1.7976931348623157e+308
                    },
                    "z": {
                      "type": "number",
                      "minimum": -1.7976931348623157e+308,
                      "maximum": 1.7976931348623157e+308
                    },
                    "w": {
                      "type": "number",
                      "minimum": -1.7976931348623157e+308,
                      "maximum": 1.7976931348623157e+308
                    }
                  },
                  "required": [
                    "x",
                    "y",
                    "z",
                    "w"
                  ],
                  "title": "orientation",
                  "additionalProperties": false
                }
              },
              "required": [
                "position",
                "orientation"
              ],
              "title": "pose",
              "additionalProperties": false
            },
            "config": {
              "type": "string"
            },
            "data": {
              "type": "string"
            }
          },
          "title": "resources"
        },
        "type": "array"
      },
      "device": {
        "type": "string",
        "description": "device reference"
      },
      "devices": {
        "type": "string",
        "description": "device reference"
      }
    },
    "required": [],
    "_unilabos_placeholder_info": {
      "resource": "unilabos_resources",
      "resources": "unilabos_resources",
      "device": "unilabos_devices",
      "devices": "unilabos_devices"
    }
  },
  "goal_default": {},
  "placeholder_keys": {
    "resource": "unilabos_resources",
    "resources": "unilabos_resources",
    "device": "unilabos_devices",
    "devices": "unilabos_devices"
  }
 }
--- a/.cursor/skills/submit-agent-result/SKILL.md
+++ b/.cursor/skills/submit-agent-result/SKILL.md
@@ -1,284 +0,0 @@
 ---
 name: submit-agent-result
 description: Submit historical experiment results (agent_result) to Uni-Lab cloud platform (leap-lab) notebook — read data files, assemble JSON payload, PUT to cloud API. Use when the user wants to submit experiment results, upload agent results, report experiment data, or mentions agent_result/实验结果/历史记录/notebook结果.
 ---
 # Uni-Lab 提交历史实验记录指南
 通过 Uni-Lab 云端 API 向已创建的 notebook 提交实验结果数据（agent_result）。支持从 JSON / CSV 文件读取数据，整合后提交。
 > **重要**：本指南中的 `Authorization: Lab <token>` 是 **Uni-Lab 平台专用的认证方式**，`Lab` 是 Uni-Lab 的 auth scheme 关键字，**不是** HTTP Basic 认证。请勿将其替换为 `Basic`。
 ## 前置条件（缺一不可）
 使用本指南前，**必须**先确认以下信息。如果缺少任何一项，**立即向用户询问并终止**，等补齐后再继续。
 ### 1. ak / sk → AUTH
 询问用户的启动参数，从 `--ak` `--sk` 或 config.py 中获取。
 生成 AUTH token：
 ```bash
 # ⚠️ 注意：scheme 是 "Lab"（Uni-Lab 专用），不是 "Basic"
 python -c "import base64,sys; print(base64.b64encode(f'{sys.argv[1]}:{sys.argv[2]}'.encode()).decode())" <ak> <sk>
 ```
 输出即为 token 值，拼接为 `Authorization: Lab <token>`（`Lab` 是 Uni-Lab 平台 auth scheme，不可替换为 `Basic`）。
 ### 2. --addr → BASE URL
 | `--addr` 值  | BASE                                |
 | ------------ | ----------------------------------- |
 | `test`       | `https://leap-lab.test.bohrium.com` |
 | `uat`        | `https://leap-lab.uat.bohrium.com`  |
 | `local`      | `http://127.0.0.1:48197`            |
 | 不传（默认） | `https://leap-lab.bohrium.com`      |
 确认后设置：
 ```bash
 BASE="<根据 addr 确定的 URL>"
 # ⚠️ Auth scheme 必须是 "Lab"（Uni-Lab 专用），不是 "Basic"
 AUTH="Authorization: Lab <上面命令输出的 token>"
 ```
 ### 3. notebook_uuid（**必须询问用户**）
 **必须主动询问用户**：「请提供要提交结果的 notebook UUID。」
 notebook_uuid 来自之前通过「批量提交实验」创建的实验批次，即 `POST /api/v1/lab/notebook` 返回的 `data.uuid`。
 如果用户不记得，可提示：
 - 查看之前的对话记录中创建 notebook 时返回的 UUID
 - 或通过平台页面查找对应的 notebook
 **绝不能跳过此步骤，没有 notebook_uuid 无法提交。**
 ### 4. 实验结果数据
 用户需要提供实验结果数据，支持以下方式：
 | 方式      | 说明                                            |
 | --------- | ----------------------------------------------- |
 | JSON 文件 | 直接作为 `agent_result` 的内容合并              |
 | CSV 文件  | 转为 `{"文件名": [行数据...]}` 格式             |
 | 手动指定  | 用户直接告知 key-value 数据，由 agent 构建 JSON |
 **四项全部就绪后才可开始。**
 ## Session State
 在整个对话过程中，agent 需要记住以下状态：
 - `lab_uuid` — 实验室 UUID（通过 API #1 自动获取，**不需要问用户**）
 - `notebook_uuid` — 目标 notebook UUID（**必须询问用户**）
 ## 请求约定
 所有请求使用 `curl -s`，PUT 需加 `Content-Type: application/json`。
 > **Windows 平台**必须使用 `curl.exe`（而非 PowerShell 的 `curl` 别名），示例中的 `curl` 均指 `curl.exe`。
 >
 > **PowerShell JSON 传参**：PowerShell 中 `-d '{"key":"value"}'` 会因引号转义失败。请将 JSON 写入临时文件，用 `-d '@tmp_body.json'`（单引号包裹 `@`，否则 `@` 会被 PowerShell 解析为 splatting 运算符导致报错）。
 ---
 ## API Endpoints
 ### 1. 获取实验室信息（自动获取 lab_uuid）
 ```bash
 curl -s -X GET "$BASE/api/v1/edge/lab/info" -H "$AUTH"
 ```
 返回：
 ```json
 { "code": 0, "data": { "uuid": "xxx", "name": "实验室名称" } }
 ```
 记住 `data.uuid` 为 `lab_uuid`。
 ### 2. 提交实验结果（agent_result）
 ```bash
 curl -s -X PUT "$BASE/api/v1/lab/notebook/agent-result" \
  -H "$AUTH" -H "Content-Type: application/json" \
  -d '<request_body>'
 ```
 请求体结构：
 ```json
 {
    "notebook_uuid": "<notebook_uuid>",
    "agent_result": {
        "<key1>": "<value1>",
        "<key2>": 123,
        "<nested_key>": {"a": 1, "b": 2},
        "<array_key>": [{"col1": "v1", "col2": "v2"}, ...]
    }
 }
 ```
 > **注意**：HTTP 方法是 **PUT**（不是 POST）。
 #### 必要字段
 | 字段            | 类型          | 说明                                        |
 | --------------- | ------------- | ------------------------------------------- |
 | `notebook_uuid` | string (UUID) | 目标 notebook 的 UUID，从批量提交实验时获取 |
 | `agent_result`  | object        | 实验结果数据，任意 JSON 对象                |
 #### agent_result 内容格式
 `agent_result` 接受**任意 JSON 对象**，常见格式：
 **简单键值对**：
 ```json
 {
  "avg_rtt_ms": 12.5,
  "status": "success",
  "test_count": 5
 }
 ```
 **包含嵌套结构**：
 ```json
 {
  "summary": { "total": 100, "passed": 98, "failed": 2 },
  "measurements": [
    { "sample_id": "S001", "value": 3.14, "unit": "mg/mL" },
    { "sample_id": "S002", "value": 2.71, "unit": "mg/mL" }
  ]
 }
 ```
 **从 CSV 文件导入**（脚本自动转换）：
 ```json
 {
  "experiment_data": [
    { "温度": 25, "压力": 101.3, "产率": 0.85 },
    { "温度": 30, "压力": 101.3, "产率": 0.91 }
  ]
 }
 ```
 ---
 ## 整合脚本
 本文档同级目录下的 `scripts/prepare_agent_result.py` 可自动读取文件并构建请求体。
 ### 用法
 ```bash
 python scripts/prepare_agent_result.py \
    --notebook-uuid <uuid> \
    --files data1.json data2.csv \
    [--auth <token>] \
    [--base <BASE_URL>] \
    [--submit] \
    [--output <output.json>]
 ```
 | 参数              | 必选       | 说明                                            |
 | ----------------- | ---------- | ----------------------------------------------- |
 | `--notebook-uuid` | 是         | 目标 notebook UUID                              |
 | `--files`         | 是         | 输入文件路径（支持多个，JSON / CSV）            |
 | `--auth`          | 提交时必选 | Lab token（base64(ak:sk)）                      |
 | `--base`          | 提交时必选 | API base URL                                    |
 | `--submit`        | 否         | 加上此标志则直接提交到云端                      |
 | `--output`        | 否         | 输出 JSON 路径（默认 `agent_result_body.json`） |
 ### 文件合并规则
 | 文件类型              | 合并方式                                     |
 | --------------------- | -------------------------------------------- |
 | `.json`（dict）       | 字段直接合并到 `agent_result` 顶层           |
 | `.json`（list/other） | 以文件名为 key 放入 `agent_result`           |
 | `.csv`                | 以文件名（不含扩展名）为 key，值为行对象数组 |
 多个文件的字段会合并。JSON dict 中的重复 key 后者覆盖前者。
 ### 示例
 ```bash
 # 仅生成请求体文件（不提交）
 python scripts/prepare_agent_result.py \
    --notebook-uuid 73c67dca-c8cc-4936-85a0-329106aa7cca \
    --files results.json measurements.csv
 # 生成并直接提交
 python scripts/prepare_agent_result.py \
    --notebook-uuid 73c67dca-c8cc-4936-85a0-329106aa7cca \
    --files results.json \
    --auth YTFmZDlkNGUt... \
    --base https://leap-lab.test.bohrium.com \
    --submit
 ```
 ---
 ## 手动构建方式
 如果不使用脚本，也可手动构建请求体：
 1. 将实验结果数据组装为 JSON 对象
 2. 写入临时文件：
 ```json
 {
    "notebook_uuid": "<uuid>",
    "agent_result": { ... }
 }
 ```
 3. 用 curl 提交：
 ```bash
 curl -s -X PUT "$BASE/api/v1/lab/notebook/agent-result" \
  -H "$AUTH" -H "Content-Type: application/json" \
  -d '@tmp_body.json'
 ```
 ---
 ## 完整工作流 Checklist
 ```
 Task Progress:
 - [ ] Step 1: 确认 ak/sk → 生成 AUTH token
 - [ ] Step 2: 确认 --addr → 设置 BASE URL
 - [ ] Step 3: GET /edge/lab/info → 获取 lab_uuid
 - [ ] Step 4: **询问用户** notebook_uuid（必须，不可跳过）
 - [ ] Step 5: 确认实验结果数据来源（文件路径或手动数据）
 - [ ] Step 6: 运行 prepare_agent_result.py 或手动构建请求体
 - [ ] Step 7: PUT /lab/notebook/agent-result 提交
 - [ ] Step 8: 检查返回结果，确认提交成功
 ```
 ---
 ## 常见问题
 ### Q: notebook_uuid 从哪里获取？
 从之前「批量提交实验」时 `POST /api/v1/lab/notebook` 的返回值 `data.uuid` 获取。也可以在平台 UI 中查找对应的 notebook。
 ### Q: agent_result 有固定的 schema 吗？
 没有严格 schema，接受任意 JSON 对象。但建议包含有意义的字段名和结构化数据，方便后续分析。
 ### Q: 可以多次提交同一个 notebook 的结果吗？
 可以，后续提交会覆盖之前的 agent_result。
 ### Q: 认证方式是 Lab 还是 Api？
 本指南统一使用 `Authorization: Lab <base64(ak:sk)>` 方式（`Lab` 是 Uni-Lab 平台的 auth scheme，**绝不能用 `Basic` 替代**）。如果用户有独立的 API Key，也可用 `Authorization: Api <key>` 替代。
--- a/.cursor/skills/submit-agent-result/scripts/prepare_agent_result.py
+++ b/.cursor/skills/submit-agent-result/scripts/prepare_agent_result.py
@@ -1,133 +0,0 @@
 """
 读取实验结果文件（JSON / CSV），整合为 agent_result 请求体并可选提交。
 用法:
    python prepare_agent_result.py \
        --notebook-uuid <uuid> \
        --files data1.json data2.csv \
        [--auth <Lab token>] \
        [--base <BASE_URL>] \
        [--submit] \
        [--output <output.json>]
 支持的输入文件格式:
    - .json  → 直接作为 dict 合并
    - .csv   → 转为 {"filename": [row_dict, ...]} 格式
 """
 import argparse
 import base64
 import csv
 import json
 import os
 import sys
 from pathlib import Path
 from typing import Any, Dict, List
 def read_json_file(filepath: str) -> Dict[str, Any]:
    with open(filepath, "r", encoding="utf-8") as f:
        return json.load(f)
 def read_csv_file(filepath: str) -> List[Dict[str, Any]]:
    rows = []
    with open(filepath, "r", encoding="utf-8-sig") as f:
        reader = csv.DictReader(f)
        for row in reader:
            converted = {}
            for k, v in row.items():
                try:
                    converted[k] = int(v)
                except (ValueError, TypeError):
                    try:
                        converted[k] = float(v)
                    except (ValueError, TypeError):
                        converted[k] = v
            rows.append(converted)
    return rows
 def merge_files(filepaths: List[str]) -> Dict[str, Any]:
    """将多个文件合并为一个 agent_result dict"""
    merged: Dict[str, Any] = {}
    for fp in filepaths:
        path = Path(fp)
        ext = path.suffix.lower()
        key = path.stem
        if ext == ".json":
            data = read_json_file(fp)
            if isinstance(data, dict):
                merged.update(data)
            else:
                merged[key] = data
        elif ext == ".csv":
            merged[key] = read_csv_file(fp)
        else:
            print(f"[警告] 不支持的文件格式: {fp}，跳过", file=sys.stderr)
    return merged
 def build_request_body(notebook_uuid: str, agent_result: Dict[str, Any]) -> Dict[str, Any]:
    return {
        "notebook_uuid": notebook_uuid,
        "agent_result": agent_result,
    }
 def submit(base: str, auth: str, body: Dict[str, Any]) -> Dict[str, Any]:
    try:
        import requests
    except ImportError:
        print("[错误] 提交需要 requests 库: pip install requests", file=sys.stderr)
        sys.exit(1)
    url = f"{base}/api/v1/lab/notebook/agent-result"
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Lab {auth}",
    }
    resp = requests.put(url, json=body, headers=headers, timeout=30)
    return {"status_code": resp.status_code, "body": resp.json() if resp.headers.get("content-type", "").startswith("application/json") else resp.text}
 def main():
    parser = argparse.ArgumentParser(description="整合实验结果文件并构建 agent_result 请求体")
    parser.add_argument("--notebook-uuid", required=True, help="目标 notebook UUID")
    parser.add_argument("--files", nargs="+", required=True, help="输入文件路径（JSON / CSV）")
    parser.add_argument("--auth", help="Lab token（base64(ak:sk)）")
    parser.add_argument("--base", help="API base URL")
    parser.add_argument("--submit", action="store_true", help="直接提交到云端")
    parser.add_argument("--output", default="agent_result_body.json", help="输出 JSON 文件路径")
    args = parser.parse_args()
    for fp in args.files:
        if not os.path.exists(fp):
            print(f"[错误] 文件不存在: {fp}", file=sys.stderr)
            sys.exit(1)
    agent_result = merge_files(args.files)
    body = build_request_body(args.notebook_uuid, agent_result)
    with open(args.output, "w", encoding="utf-8") as f:
        json.dump(body, f, ensure_ascii=False, indent=2)
    print(f"[完成] 请求体已保存: {args.output}")
    print(f"  notebook_uuid: {args.notebook_uuid}")
    print(f"  agent_result 字段数: {len(agent_result)}")
    print(f"  合并文件数: {len(args.files)}")
    if args.submit:
        if not args.auth or not args.base:
            print("[错误] 提交需要 --auth 和 --base 参数", file=sys.stderr)
            sys.exit(1)
        print(f"\n[提交] PUT {args.base}/api/v1/lab/notebook/agent-result ...")
        result = submit(args.base, args.auth, body)
        print(f"  HTTP {result['status_code']}")
        print(f"  响应: {json.dumps(result['body'], ensure_ascii=False)}")
 if __name__ == "__main__":
    main()
--- a/.cursor/skills/virtual-workbench/SKILL.md
+++ b/.cursor/skills/virtual-workbench/SKILL.md
@@ -1,272 +0,0 @@
 ---
 name: virtual-workbench
 description: Operate Virtual Workbench via REST API — prepare materials, move to heating stations, start heating, move to output, transfer resources. Use when the user mentions virtual workbench, virtual_workbench, 虚拟工作台, heating stations, material processing, or workbench operations.
 ---
 # Virtual Workbench API Skill
 ## 设备信息
 - **device_id**: `virtual_workbench`
 - **Python 源码**: `unilabos/devices/virtual/workbench.py`
 - **设备类**: `VirtualWorkbench`
 - **动作数**: 6（`auto-prepare_materials`, `auto-move_to_heating_station`, `auto-start_heating`, `auto-move_to_output`, `transfer`, `manual_confirm`）
 - **设备描述**: 模拟工作台，包含 1 个机械臂（每次操作 2s，独占锁）和 3 个加热台（每次加热 60s，可并行）
 ### 典型工作流程
 1. `prepare_materials` — 生成 A1-A5 物料（5 个 output handle）
 2. `move_to_heating_station` — 物料并发竞争机械臂，移动到空闲加热台
 3. `start_heating` — 启动加热（3 个加热台可并行）
 4. `move_to_output` — 加热完成后移到输出位置 Cn
 ## 前置条件（缺一不可）
 使用本 skill 前，**必须**先确认以下信息。如果缺少任何一项，**立即向用户询问并终止**，等补齐后再继续。
 ### 1. ak / sk → AUTH
 从启动参数 `--ak` `--sk` 或 config.py 中获取，生成 token：`base64(ak:sk)` → `Authorization: Lab <token>`
 ### 2. --addr → BASE URL
 | `--addr` 值  | BASE                                |
 | ------------ | ----------------------------------- |
 | `test`       | `https://leap-lab.test.bohrium.com` |
 | `uat`        | `https://leap-lab.uat.bohrium.com`  |
 | `local`      | `http://127.0.0.1:48197`            |
 | 不传（默认） | `https://leap-lab.bohrium.com`      |
 确认后设置：
 ```bash
 BASE="<根据 addr 确定的 URL>"
 AUTH="Authorization: Lab <token>"
 ```
 **两项全部就绪后才可发起 API 请求。**
 ## Session State
 - `lab_uuid` — 实验室 UUID（首次通过 API #1 自动获取，**不需要问用户**）
 - `device_name` — `virtual_workbench`
 ## 请求约定
 所有请求使用 `curl -s`，POST/PATCH/DELETE 需加 `Content-Type: application/json`。
 > **Windows 平台**必须使用 `curl.exe`（而非 PowerShell 的 `curl` 别名）。
 ---
 ## API Endpoints
 ### 1. 获取实验室信息（自动获取 lab_uuid）
 ```bash
 curl -s -X GET "$BASE/api/v1/edge/lab/info" -H "$AUTH"
 ```
 返回 `data.uuid` 为 `lab_uuid`，`data.name` 为 `lab_name`。
 ### 2. 创建工作流
 ```bash
 curl -s -X POST "$BASE/api/v1/lab/workflow/owner" \
  -H "$AUTH" -H "Content-Type: application/json" \
  -d '{"name":"<名称>","lab_uuid":"<lab_uuid>","description":"<描述>"}'
 ```
 返回 `data.uuid` 为 `workflow_uuid`。创建成功后告知用户链接：`$BASE/laboratory/$lab_uuid/workflow/$workflow_uuid`
 ### 3. 创建节点
 ```bash
 curl -s -X POST "$BASE/api/v1/edge/workflow/node" \
  -H "$AUTH" -H "Content-Type: application/json" \
  -d '{"workflow_uuid":"<workflow_uuid>","resource_template_name":"virtual_workbench","node_template_name":"<action_name>"}'
 ```
 - `resource_template_name` 固定为 `virtual_workbench`
 - `node_template_name` — action 名称（如 `auto-prepare_materials`, `auto-move_to_heating_station`）
 ### 4. 删除节点
 ```bash
 curl -s -X DELETE "$BASE/api/v1/lab/workflow/nodes" \
  -H "$AUTH" -H "Content-Type: application/json" \
  -d '{"node_uuids":["<uuid1>"],"workflow_uuid":"<workflow_uuid>"}'
 ```
 ### 5. 更新节点参数
 ```bash
 curl -s -X PATCH "$BASE/api/v1/lab/workflow/node" \
  -H "$AUTH" -H "Content-Type: application/json" \
  -d '{"workflow_uuid":"<wf_uuid>","uuid":"<node_uuid>","param":{...}}'
 ```
 参考 [action-index.md](action-index.md) 确定哪些字段是 Slot。
 ### 6. 查询节点 handles
 ```bash
 curl -s -X POST "$BASE/api/v1/lab/workflow/node-handles" \
  -H "$AUTH" -H "Content-Type: application/json" \
  -d '{"node_uuids":["<node_uuid_1>","<node_uuid_2>"]}'
 ```
 ### 7. 批量创建边
 ```bash
 curl -s -X POST "$BASE/api/v1/lab/workflow/edges" \
  -H "$AUTH" -H "Content-Type: application/json" \
  -d '{"edges":[{"source_node_uuid":"<uuid>","target_node_uuid":"<uuid>","source_handle_uuid":"<uuid>","target_handle_uuid":"<uuid>"}]}'
 ```
 ### 8. 启动工作流
 ```bash
 curl -s -X POST "$BASE/api/v1/lab/workflow/<workflow_uuid>/run" -H "$AUTH"
 ```
 ### 9. 运行设备单动作
 ```bash
 curl -s -X POST "$BASE/api/v1/lab/mcp/run/action" \
  -H "$AUTH" -H "Content-Type: application/json" \
  -d '{"lab_uuid":"<lab_uuid>","device_id":"virtual_workbench","action":"<action_name>","action_type":"<type>","param":{...}}'
 ```
 `param` 直接放 goal 里的属性，**不要**再包一层 `{"goal": {...}}`。
 > **WARNING: `action_type` 必须正确，传错会导致任务永远卡住无法完成。** 从下表或 `actions/<name>.json` 的 `type` 字段获取。
 #### action_type 速查表
 | action | action_type |
 |--------|-------------|
 | `auto-prepare_materials` | `UniLabJsonCommand` |
 | `auto-move_to_heating_station` | `UniLabJsonCommand` |
 | `auto-start_heating` | `UniLabJsonCommand` |
 | `auto-move_to_output` | `UniLabJsonCommand` |
 | `transfer` | `UniLabJsonCommandAsync` |
 | `manual_confirm` | `UniLabJsonCommand` |
 ### 10. 查询任务状态
 ```bash
 curl -s -X GET "$BASE/api/v1/lab/mcp/task/<task_uuid>" -H "$AUTH"
 ```
 ### 11. 运行工作流单节点
 ```bash
 curl -s -X POST "$BASE/api/v1/lab/mcp/run/workflow/action" \
  -H "$AUTH" -H "Content-Type: application/json" \
  -d '{"node_uuid":"<node_uuid>"}'
 ```
 ### 12. 获取资源树（物料信息）
 ```bash
 curl -s -X GET "$BASE/api/v1/lab/material/download/$lab_uuid" -H "$AUTH"
 ```
 注意 `lab_uuid` 在路径中。返回 `data.nodes[]` 含所有节点（设备 + 物料），每个节点含 `name`、`uuid`、`type`、`parent`。
 ### 13. 获取工作流模板详情
 ```bash
 curl -s -X GET "$BASE/api/v1/lab/workflow/template/detail/$workflow_uuid" -H "$AUTH"
 ```
 > 必须使用 `/lab/workflow/template/detail/{uuid}`，其他路径会返回 404。
 ### 14. 按名称查询物料模板
 ```bash
 curl -s -X GET "$BASE/api/v1/lab/material/template/by-name?lab_uuid=$lab_uuid&name=<template_name>" -H "$AUTH"
 ```
 返回 `data.uuid` 为 `res_template_uuid`，用于 API #15。
 ### 15. 创建物料节点
 ```bash
 curl -s -X POST "$BASE/api/v1/edge/material/node" \
  -H "$AUTH" -H "Content-Type: application/json" \
  -d '{"res_template_uuid":"<uuid>","name":"<名称>","display_name":"<显示名>","parent_uuid":"<父节点uuid>","data":{...}}'
 ```
 ### 16. 更新物料节点
 ```bash
 curl -s -X PUT "$BASE/api/v1/edge/material/node" \
  -H "$AUTH" -H "Content-Type: application/json" \
  -d '{"uuid":"<节点uuid>","display_name":"<新名称>","data":{...}}'
 ```
 ---
 ## Placeholder Slot 填写规则
 | `placeholder_keys` 值 | Slot 类型    | 填写格式                                              | 选取范围               |
 | --------------------- | ------------ | ----------------------------------------------------- | ---------------------- |
 | `unilabos_resources`  | ResourceSlot | `{"id": "/path/name", "name": "name", "uuid": "xxx"}` | 仅物料节点（非设备）   |
 | `unilabos_devices`    | DeviceSlot   | `"/parent/device_name"`                               | 仅设备节点（type=device） |
 | `unilabos_nodes`      | NodeSlot     | `"/parent/node_name"`                                 | 所有节点（设备 + 物料）   |
 | `unilabos_class`      | ClassSlot    | `"class_name"`                                        | 注册表中已注册的资源类    |
 ### virtual_workbench 设备的 Slot 字段表
 | Action            | 字段             | Slot 类型    | 说明                 |
 | ----------------- | ---------------- | ------------ | -------------------- |
 | `transfer`        | `resource`       | ResourceSlot | 待转移物料数组       |
 | `transfer`        | `target_device`  | DeviceSlot   | 目标设备路径         |
 | `transfer`        | `mount_resource` | ResourceSlot | 目标孔位数组         |
 | `manual_confirm`  | `resource`       | ResourceSlot | 确认用物料数组       |
 | `manual_confirm`  | `target_device`  | DeviceSlot   | 确认用目标设备       |
 | `manual_confirm`  | `mount_resource` | ResourceSlot | 确认用目标孔位数组   |
 > `prepare_materials`、`move_to_heating_station`、`start_heating`、`move_to_output` 这 4 个动作**无 Slot 字段**，参数为纯数值/整数。
 ---
 ## 渐进加载策略
 1. **SKILL.md**（本文件）— API 端点 + session state 管理 + 设备工作流概览
 2. **[action-index.md](action-index.md)** — 按分类浏览 6 个动作的描述和核心参数
 3. **[actions/\<name\>.json](actions/)** — 仅在需要构建具体请求时，加载对应 action 的完整 JSON Schema
 ---
 ## 完整工作流 Checklist
 ```
 Task Progress:
 - [ ] Step 1: GET /edge/lab/info 获取 lab_uuid
 - [ ] Step 2: 获取资源树 (GET #12) → 记住可用物料
 - [ ] Step 3: 读 action-index.md 确定要用的 action 名
 - [ ] Step 4: 创建工作流 (POST #2) → 记住 workflow_uuid，告知用户链接
 - [ ] Step 5: 创建节点 (POST #3, resource_template_name=virtual_workbench) → 记住 node_uuid + data.param
 - [ ] Step 6: 根据 _unilabos_placeholder_info 和资源树，填写 data.param 中的 Slot 字段
 - [ ] Step 7: 更新节点参数 (PATCH #5)
 - [ ] Step 8: 查询节点 handles (POST #6) → 获取各节点的 handle_uuid
 - [ ] Step 9: 批量创建边 (POST #7) → 用 handle_uuid 连接节点
 - [ ] Step 10: 启动工作流 (POST #8) 或运行单节点 (POST #11)
 - [ ] Step 11: 查询任务状态 (GET #10) 确认完成
 ```
 ### 典型 5 物料并发加热工作流示例
 ```
 prepare_materials (count=5)
  ├─ channel_1 → move_to_heating_station (material_number=1) → start_heating → move_to_output
  ├─ channel_2 → move_to_heating_station (material_number=2) → start_heating → move_to_output
  ├─ channel_3 → move_to_heating_station (material_number=3) → start_heating → move_to_output
  ├─ channel_4 → move_to_heating_station (material_number=4) → start_heating → move_to_output
  └─ channel_5 → move_to_heating_station (material_number=5) → start_heating → move_to_output
 ```
 创建节点时，`prepare_materials` 的 5 个 output handle（`channel_1` ~ `channel_5`）分别连接到 5 个 `move_to_heating_station` 节点的 `material_input` handle。每个 `move_to_heating_station` 的 `heating_station_output` 和 `material_number_output` 连接到对应 `start_heating` 的 `station_id_input` 和 `material_number_input`。
--- a/.cursor/skills/virtual-workbench/action-index.md
+++ b/.cursor/skills/virtual-workbench/action-index.md
@@ -1,76 +0,0 @@
 # Action Index — virtual_workbench
 6 个动作，按功能分类。每个动作的完整 JSON Schema 在 `actions/<name>.json`。
 ---
 ## 物料准备
 ### `auto-prepare_materials`
 批量准备物料（虚拟起始节点），生成 A1-A5 物料编号，输出 5 个 handle 供后续节点使用
 - **action_type**: `UniLabJsonCommand`
 - **Schema**: [`actions/prepare_materials.json`](actions/prepare_materials.json)
 - **可选参数**: `count`（物料数量，默认 5）
 ---
 ## 机械臂 & 加热台操作
 ### `auto-move_to_heating_station`
 将物料从 An 位置移动到空闲加热台（竞争机械臂，自动查找空闲加热台）
 - **action_type**: `UniLabJsonCommand`
 - **Schema**: [`actions/move_to_heating_station.json`](actions/move_to_heating_station.json)
 - **核心参数**: `material_number`（物料编号，integer）
 ### `auto-start_heating`
 启动指定加热台的加热程序（可并行，3 个加热台同时工作）
 - **action_type**: `UniLabJsonCommand`
 - **Schema**: [`actions/start_heating.json`](actions/start_heating.json)
 - **核心参数**: `station_id`（加热台 ID），`material_number`（物料编号）
 ### `auto-move_to_output`
 将加热完成的物料从加热台移动到输出位置 Cn
 - **action_type**: `UniLabJsonCommand`
 - **Schema**: [`actions/move_to_output.json`](actions/move_to_output.json)
 - **核心参数**: `station_id`（加热台 ID），`material_number`（物料编号）
 ---
 ## 物料转移
 ### `transfer`
 异步转移物料到目标设备（通过 ROS 资源转移）
 - **action_type**: `UniLabJsonCommandAsync`
 - **Schema**: [`actions/transfer.json`](actions/transfer.json)
 - **核心参数**: `resource`, `target_device`, `mount_resource`
 - **占位符字段**:
  - `resource` — **ResourceSlot**，待转移的物料数组 `[{id, name, uuid}, ...]`
  - `target_device` — **DeviceSlot**，目标设备路径字符串
  - `mount_resource` — **ResourceSlot**，目标孔位数组 `[{id, name, uuid}, ...]`
 ---
 ## 人工确认
 ### `manual_confirm`
 创建人工确认节点，等待用户手动确认后继续（含物料转移上下文）
 - **action_type**: `UniLabJsonCommand`
 - **Schema**: [`actions/manual_confirm.json`](actions/manual_confirm.json)
 - **核心参数**: `resource`, `target_device`, `mount_resource`, `timeout_seconds`, `assignee_user_ids`
 - **占位符字段**:
  - `resource` — **ResourceSlot**，物料数组
  - `target_device` — **DeviceSlot**，目标设备路径
  - `mount_resource` — **ResourceSlot**，目标孔位数组
  - `assignee_user_ids` — `unilabos_manual_confirm` 类型
--- a/.cursor/skills/virtual-workbench/actions/manual_confirm.json
+++ b/.cursor/skills/virtual-workbench/actions/manual_confirm.json
@@ -1,270 +0,0 @@
 {
  "type": "UniLabJsonCommand",
  "goal": {
    "resource": "resource",
    "target_device": "target_device",
    "mount_resource": "mount_resource",
    "timeout_seconds": "timeout_seconds",
    "assignee_user_ids": "assignee_user_ids"
  },
  "schema": {
    "type": "object",
    "properties": {
      "resource": {
        "items": {
          "type": "object",
          "additionalProperties": false,
          "properties": {
            "id": {
              "type": "string"
            },
            "name": {
              "type": "string"
            },
            "sample_id": {
              "type": "string"
            },
            "children": {
              "type": "array",
              "items": {
                "type": "string"
              }
            },
            "parent": {
              "type": "string"
            },
            "type": {
              "type": "string"
            },
            "category": {
              "type": "string"
            },
            "pose": {
              "type": "object",
              "properties": {
                "position": {
                  "type": "object",
                  "properties": {
                    "x": {
                      "type": "number",
                      "minimum": -1.7976931348623157e+308,
                      "maximum": 1.7976931348623157e+308
                    },
                    "y": {
                      "type": "number",
                      "minimum": -1.7976931348623157e+308,
                      "maximum": 1.7976931348623157e+308
                    },
                    "z": {
                      "type": "number",
                      "minimum": -1.7976931348623157e+308,
                      "maximum": 1.7976931348623157e+308
                    }
                  },
                  "required": [
                    "x",
                    "y",
                    "z"
                  ],
                  "title": "position",
                  "additionalProperties": false
                },
                "orientation": {
                  "type": "object",
                  "properties": {
                    "x": {
                      "type": "number",
                      "minimum": -1.7976931348623157e+308,
                      "maximum": 1.7976931348623157e+308
                    },
                    "y": {
                      "type": "number",
                      "minimum": -1.7976931348623157e+308,
                      "maximum": 1.7976931348623157e+308
                    },
                    "z": {
                      "type": "number",
                      "minimum": -1.7976931348623157e+308,
                      "maximum": 1.7976931348623157e+308
                    },
                    "w": {
                      "type": "number",
                      "minimum": -1.7976931348623157e+308,
                      "maximum": 1.7976931348623157e+308
                    }
                  },
                  "required": [
                    "x",
                    "y",
                    "z",
                    "w"
                  ],
                  "title": "orientation",
                  "additionalProperties": false
                }
              },
              "required": [
                "position",
                "orientation"
              ],
              "title": "pose",
              "additionalProperties": false
            },
            "config": {
              "type": "string"
            },
            "data": {
              "type": "string"
            }
          },
          "title": "resource"
        },
        "type": "array"
      },
      "target_device": {
        "type": "string",
        "description": "device reference"
      },
      "mount_resource": {
        "items": {
          "type": "object",
          "additionalProperties": false,
          "properties": {
            "id": {
              "type": "string"
            },
            "name": {
              "type": "string"
            },
            "sample_id": {
              "type": "string"
            },
            "children": {
              "type": "array",
              "items": {
                "type": "string"
              }
            },
            "parent": {
              "type": "string"
            },
            "type": {
              "type": "string"
            },
            "category": {
              "type": "string"
            },
            "pose": {
              "type": "object",
              "properties": {
                "position": {
                  "type": "object",
                  "properties": {
                    "x": {
                      "type": "number",
                      "minimum": -1.7976931348623157e+308,
                      "maximum": 1.7976931348623157e+308
                    },
                    "y": {
                      "type": "number",
                      "minimum": -1.7976931348623157e+308,
                      "maximum": 1.7976931348623157e+308
                    },
                    "z": {
                      "type": "number",
                      "minimum": -1.7976931348623157e+308,
                      "maximum": 1.7976931348623157e+308
                    }
                  },
                  "required": [
                    "x",
                    "y",
                    "z"
                  ],
                  "title": "position",
                  "additionalProperties": false
                },
                "orientation": {
                  "type": "object",
                  "properties": {
                    "x": {
                      "type": "number",
                      "minimum": -1.7976931348623157e+308,
                      "maximum": 1.7976931348623157e+308
                    },
                    "y": {
                      "type": "number",
                      "minimum": -1.7976931348623157e+308,
                      "maximum": 1.7976931348623157e+308
                    },
                    "z": {
                      "type": "number",
                      "minimum": -1.7976931348623157e+308,
                      "maximum": 1.7976931348623157e+308
                    },
                    "w": {
                      "type": "number",
                      "minimum": -1.7976931348623157e+308,
                      "maximum": 1.7976931348623157e+308
                    }
                  },
                  "required": [
                    "x",
                    "y",
                    "z",
                    "w"
                  ],
                  "title": "orientation",
                  "additionalProperties": false
                }
              },
              "required": [
                "position",
                "orientation"
              ],
              "title": "pose",
              "additionalProperties": false
            },
            "config": {
              "type": "string"
            },
            "data": {
              "type": "string"
            }
          },
          "title": "mount_resource"
        },
        "type": "array"
      },
      "timeout_seconds": {
        "type": "integer"
      },
      "assignee_user_ids": {
        "type": "array",
        "items": {
          "type": "string"
        }
      }
    },
    "required": [
      "resource",
      "target_device",
      "mount_resource",
      "timeout_seconds",
      "assignee_user_ids"
    ],
    "_unilabos_placeholder_info": {
      "resource": "unilabos_resources",
      "target_device": "unilabos_devices",
      "mount_resource": "unilabos_resources",
      "assignee_user_ids": "unilabos_manual_confirm"
    }
  },
  "goal_default": {},
  "placeholder_keys": {
    "resource": "unilabos_resources",
    "target_device": "unilabos_devices",
    "mount_resource": "unilabos_resources",
    "assignee_user_ids": "unilabos_manual_confirm"
  }
 }
--- a/.cursor/skills/virtual-workbench/actions/move_to_heating_station.json
+++ b/.cursor/skills/virtual-workbench/actions/move_to_heating_station.json
@@ -1,19 +0,0 @@
 {
  "type": "UniLabJsonCommand",
  "goal": {
    "material_number": "material_number"
  },
  "schema": {
    "type": "object",
    "properties": {
      "material_number": {
        "type": "integer"
      }
    },
    "required": [
      "material_number"
    ]
  },
  "goal_default": {},
  "placeholder_keys": {}
 }
--- a/.cursor/skills/virtual-workbench/actions/move_to_output.json
+++ b/.cursor/skills/virtual-workbench/actions/move_to_output.json
@@ -1,24 +0,0 @@
 {
  "type": "UniLabJsonCommand",
  "goal": {
    "station_id": "station_id",
    "material_number": "material_number"
  },
  "schema": {
    "type": "object",
    "properties": {
      "station_id": {
        "type": "integer"
      },
      "material_number": {
        "type": "integer"
      }
    },
    "required": [
      "station_id",
      "material_number"
    ]
  },
  "goal_default": {},
  "placeholder_keys": {}
 }
--- a/.cursor/skills/virtual-workbench/actions/prepare_materials.json
+++ b/.cursor/skills/virtual-workbench/actions/prepare_materials.json
@@ -1,20 +0,0 @@
 {
  "type": "UniLabJsonCommand",
  "goal": {
    "count": "count"
  },
  "schema": {
    "type": "object",
    "properties": {
      "count": {
        "type": "integer",
        "default": 5
      }
    },
    "required": []
  },
  "goal_default": {
    "count": 5
  },
  "placeholder_keys": {}
 }
--- a/.cursor/skills/virtual-workbench/actions/start_heating.json
+++ b/.cursor/skills/virtual-workbench/actions/start_heating.json
@@ -1,24 +0,0 @@
 {
  "type": "UniLabJsonCommand",
  "goal": {
    "station_id": "station_id",
    "material_number": "material_number"
  },
  "schema": {
    "type": "object",
    "properties": {
      "station_id": {
        "type": "integer"
      },
      "material_number": {
        "type": "integer"
      }
    },
    "required": [
      "station_id",
      "material_number"
    ]
  },
  "goal_default": {},
  "placeholder_keys": {}
 }
--- a/.cursor/skills/virtual-workbench/actions/transfer.json
+++ b/.cursor/skills/virtual-workbench/actions/transfer.json
@@ -1,255 +0,0 @@
 {
  "type": "UniLabJsonCommandAsync",
  "goal": {
    "resource": "resource",
    "target_device": "target_device",
    "mount_resource": "mount_resource"
  },
  "schema": {
    "type": "object",
    "properties": {
      "resource": {
        "items": {
          "type": "object",
          "additionalProperties": false,
          "properties": {
            "id": {
              "type": "string"
            },
            "name": {
              "type": "string"
            },
            "sample_id": {
              "type": "string"
            },
            "children": {
              "type": "array",
              "items": {
                "type": "string"
              }
            },
            "parent": {
              "type": "string"
            },
            "type": {
              "type": "string"
            },
            "category": {
              "type": "string"
            },
            "pose": {
              "type": "object",
              "properties": {
                "position": {
                  "type": "object",
                  "properties": {
                    "x": {
                      "type": "number",
                      "minimum": -1.7976931348623157e+308,
                      "maximum": 1.7976931348623157e+308
                    },
                    "y": {
                      "type": "number",
                      "minimum": -1.7976931348623157e+308,
                      "maximum": 1.7976931348623157e+308
                    },
                    "z": {
                      "type": "number",
                      "minimum": -1.7976931348623157e+308,
                      "maximum": 1.7976931348623157e+308
                    }
                  },
                  "required": [
                    "x",
                    "y",
                    "z"
                  ],
                  "title": "position",
                  "additionalProperties": false
                },
                "orientation": {
                  "type": "object",
                  "properties": {
                    "x": {
                      "type": "number",
                      "minimum": -1.7976931348623157e+308,
                      "maximum": 1.7976931348623157e+308
                    },
                    "y": {
                      "type": "number",
                      "minimum": -1.7976931348623157e+308,
                      "maximum": 1.7976931348623157e+308
                    },
                    "z": {
                      "type": "number",
                      "minimum": -1.7976931348623157e+308,
                      "maximum": 1.7976931348623157e+308
                    },
                    "w": {
                      "type": "number",
                      "minimum": -1.7976931348623157e+308,
                      "maximum": 1.7976931348623157e+308
                    }
                  },
                  "required": [
                    "x",
                    "y",
                    "z",
                    "w"
                  ],
                  "title": "orientation",
                  "additionalProperties": false
                }
              },
              "required": [
                "position",
                "orientation"
              ],
              "title": "pose",
              "additionalProperties": false
            },
            "config": {
              "type": "string"
            },
            "data": {
              "type": "string"
            }
          },
          "title": "resource"
        },
        "type": "array"
      },
      "target_device": {
        "type": "string",
        "description": "device reference"
      },
      "mount_resource": {
        "items": {
          "type": "object",
          "additionalProperties": false,
          "properties": {
            "id": {
              "type": "string"
            },
            "name": {
              "type": "string"
            },
            "sample_id": {
              "type": "string"
            },
            "children": {
              "type": "array",
              "items": {
                "type": "string"
              }
            },
            "parent": {
              "type": "string"
            },
            "type": {
              "type": "string"
            },
            "category": {
              "type": "string"
            },
            "pose": {
              "type": "object",
              "properties": {
                "position": {
                  "type": "object",
                  "properties": {
                    "x": {
                      "type": "number",
                      "minimum": -1.7976931348623157e+308,
                      "maximum": 1.7976931348623157e+308
                    },
                    "y": {
                      "type": "number",
                      "minimum": -1.7976931348623157e+308,
                      "maximum": 1.7976931348623157e+308
                    },
                    "z": {
                      "type": "number",
                      "minimum": -1.7976931348623157e+308,
                      "maximum": 1.7976931348623157e+308
                    }
                  },
                  "required": [
                    "x",
                    "y",
                    "z"
                  ],
                  "title": "position",
                  "additionalProperties": false
                },
                "orientation": {
                  "type": "object",
                  "properties": {
                    "x": {
                      "type": "number",
                      "minimum": -1.7976931348623157e+308,
                      "maximum": 1.7976931348623157e+308
                    },
                    "y": {
                      "type": "number",
                      "minimum": -1.7976931348623157e+308,
                      "maximum": 1.7976931348623157e+308
                    },
                    "z": {
                      "type": "number",
                      "minimum": -1.7976931348623157e+308,
                      "maximum": 1.7976931348623157e+308
                    },
                    "w": {
                      "type": "number",
                      "minimum": -1.7976931348623157e+308,
                      "maximum": 1.7976931348623157e+308
                    }
                  },
                  "required": [
                    "x",
                    "y",
                    "z",
                    "w"
                  ],
                  "title": "orientation",
                  "additionalProperties": false
                }
              },
              "required": [
                "position",
                "orientation"
              ],
              "title": "pose",
              "additionalProperties": false
            },
            "config": {
              "type": "string"
            },
            "data": {
              "type": "string"
            }
          },
          "title": "mount_resource"
        },
        "type": "array"
      }
    },
    "required": [
      "resource",
      "target_device",
      "mount_resource"
    ],
    "_unilabos_placeholder_info": {
      "resource": "unilabos_resources",
      "target_device": "unilabos_devices",
      "mount_resource": "unilabos_resources"
    }
  },
  "goal_default": {},
  "placeholder_keys": {
    "resource": "unilabos_resources",
    "target_device": "unilabos_devices",
    "mount_resource": "unilabos_resources"
  }
 }
--- a/.cursorignore
+++ b/.cursorignore
@@ -0,0 +1,26 @@
 .conda
 # .github
 .idea
 # .vscode
 output
 pylabrobot_repo
 recipes
 scripts
 service
 temp
 # unilabos/test
 # unilabos/app/web
 unilabos/device_mesh
 unilabos_data
 unilabos_msgs
 unilabos.egg-info
 CONTRIBUTORS
 # LICENSE
 MANIFEST.in
 pyrightconfig.json
 # README.md
 # README_zh.md
 setup.py
 setup.cfg
 .gitattrubutes
 **/__pycache__
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -1,19 +0,0 @@
 version: 2
 updates:
 # GitHub Actions
 - package-ecosystem: "github-actions"
  directory: "/"
  target-branch: "dev"
  schedule:
    interval: "weekly"
    day: "monday"
    time: "06:00"
  open-pull-requests-limit: 5
  reviewers:
  - "msgcenterpy-team"
  labels:
  - "dependencies"
  - "github-actions"
  commit-message:
    prefix: "ci"
    include: "scope"
--- a/.github/workflows/ci-check.yml
+++ b/.github/workflows/ci-check.yml
@@ -1,67 +0,0 @@
 name: CI Check
 on:
  push:
    branches: [main, dev]
  pull_request:
    branches: [main, dev]
 jobs:
  registry-check:
    runs-on: windows-latest
    env:
      # Fix Unicode encoding issue on Windows runner (cp1252 -> utf-8)
      PYTHONIOENCODING: utf-8
      PYTHONUTF8: 1
    defaults:
      run:
        shell: cmd
    steps:
      - uses: actions/checkout@v6
        with:
          fetch-depth: 0
      - name: Setup Miniforge
        uses: conda-incubator/setup-miniconda@v3
        with:
          miniforge-version: latest
          use-mamba: true
          channels: robostack-staging,conda-forge,uni-lab
          channel-priority: flexible
          activate-environment: check-env
          auto-update-conda: false
          show-channel-urls: true
      - name: Install ROS dependencies, uv and unilabos-msgs
        run: |
          echo Installing ROS dependencies...
          mamba install -n check-env conda-forge::uv conda-forge::opencv robostack-staging::ros-humble-ros-core robostack-staging::ros-humble-action-msgs robostack-staging::ros-humble-std-msgs robostack-staging::ros-humble-geometry-msgs robostack-staging::ros-humble-control-msgs robostack-staging::ros-humble-nav2-msgs uni-lab::ros-humble-unilabos-msgs robostack-staging::ros-humble-cv-bridge robostack-staging::ros-humble-vision-opencv robostack-staging::ros-humble-tf-transformations robostack-staging::ros-humble-moveit-msgs robostack-staging::ros-humble-tf2-ros robostack-staging::ros-humble-tf2-ros-py conda-forge::transforms3d -c robostack-staging -c conda-forge -c uni-lab -y
      - name: Install pip dependencies and unilabos
        run: |
          call conda activate check-env
          echo Installing pip dependencies...
          uv pip install -r unilabos/utils/requirements.txt
          uv pip install pywinauto git+https://github.com/Xuwznln/pylabrobot.git
          uv pip uninstall enum34 || echo enum34 not installed, skipping
          uv pip install .
      - name: Run check mode (AST registry validation)
        run: |
          call conda activate check-env
          echo Running check mode...
          python -m unilabos --check_mode --skip_env_check
      - name: Check for uncommitted changes
        shell: bash
        run: |
          if ! git diff --exit-code; then
            echo "::error::检测到文件变化！请先在本地运行 'python -m unilabos --complete_registry' 并提交变更"
            echo "变化的文件:"
            git diff --name-only
            exit 1
          fi
          echo "检查通过：无文件变化"
--- a/.github/workflows/conda-pack-build.yml
+++ b/.github/workflows/conda-pack-build.yml
@@ -13,11 +13,6 @@ on:
        required: false
        default: 'win-64'
        type: string
      build_full:
        description: '是否构建完整版 unilabos-full (默认构建轻量版 unilabos)'
        required: false
        default: false
        type: boolean
 jobs:
  build-conda-pack:
@@ -29,7 +24,7 @@ jobs:
            platform: linux-64
            env_file: unilabos-linux-64.yaml
            script_ext: sh
-          - os: macos-15 # Intel (via Rosetta)
+          - os: macos-13 # Intel
            platform: osx-64
            env_file: unilabos-osx-64.yaml
            script_ext: sh
@@ -62,7 +57,7 @@ jobs:
            echo "should_build=false" >> $GITHUB_OUTPUT
          fi
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
        if: steps.should_build.outputs.should_build == 'true'
        with:
          ref: ${{ github.event.inputs.branch }}
@@ -74,7 +69,7 @@ jobs:
        with:
          miniforge-version: latest
          use-mamba: true
-          python-version: '3.11.14'
+          python-version: '3.11.11'
          channels: conda-forge,robostack-staging,uni-lab,defaults
          channel-priority: flexible
          activate-environment: unilab
@@ -86,14 +81,7 @@ jobs:
        run: |
          echo Installing unilabos and dependencies to unilab environment...
          echo Using mamba for faster and more reliable dependency resolution...
          echo Build full: ${{ github.event.inputs.build_full }}
          if "${{ github.event.inputs.build_full }}"=="true" (
            echo Installing unilabos-full ^(complete package^)...
            mamba install -n unilab uni-lab::unilabos-full conda-pack -c uni-lab -c robostack-staging -c conda-forge -y
          ) else (
            echo Installing unilabos ^(minimal package^)...
          mamba install -n unilab uni-lab::unilabos conda-pack -c uni-lab -c robostack-staging -c conda-forge -y
          )
      - name: Install conda-pack, unilabos and dependencies (Unix)
        if: steps.should_build.outputs.should_build == 'true' && matrix.platform != 'win-64'
@@ -101,14 +89,7 @@ jobs:
        run: |
          echo "Installing unilabos and dependencies to unilab environment..."
          echo "Using mamba for faster and more reliable dependency resolution..."
          echo "Build full: ${{ github.event.inputs.build_full }}"
          if [[ "${{ github.event.inputs.build_full }}" == "true" ]]; then
            echo "Installing unilabos-full (complete package)..."
            mamba install -n unilab uni-lab::unilabos-full conda-pack -c uni-lab -c robostack-staging -c conda-forge -y
          else
            echo "Installing unilabos (minimal package)..."
          mamba install -n unilab uni-lab::unilabos conda-pack -c uni-lab -c robostack-staging -c conda-forge -y
          fi
      - name: Get latest ros-humble-unilabos-msgs version (Windows)
        if: steps.should_build.outputs.should_build == 'true' && matrix.platform == 'win-64'
@@ -312,7 +293,7 @@ jobs:
      - name: Upload distribution package
        if: steps.should_build.outputs.should_build == 'true'
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v4
        with:
          name: unilab-pack-${{ matrix.platform }}-${{ github.event.inputs.branch }}
          path: dist-package/
@@ -327,12 +308,7 @@ jobs:
          echo ==========================================
          echo Platform: ${{ matrix.platform }}
          echo Branch: ${{ github.event.inputs.branch }}
-          echo Python version: 3.11.14
+          echo Python version: 3.11.11
          if "${{ github.event.inputs.build_full }}"=="true" (
            echo Package: unilabos-full ^(complete^)
          ) else (
            echo Package: unilabos ^(minimal^)
          )
          echo.
          echo Distribution package contents:
          dir dist-package
@@ -352,12 +328,7 @@ jobs:
          echo "=========================================="
          echo "Platform: ${{ matrix.platform }}"
          echo "Branch: ${{ github.event.inputs.branch }}"
-          echo "Python version: 3.11.14"
+          echo "Python version: 3.11.11"
          if [[ "${{ github.event.inputs.build_full }}" == "true" ]]; then
            echo "Package: unilabos-full (complete)"
          else
            echo "Package: unilabos (minimal)"
          fi
          echo ""
          echo "Distribution package contents:"
          ls -lh dist-package/
--- a/.github/workflows/deploy-docs.yml
+++ b/.github/workflows/deploy-docs.yml
@@ -1,12 +1,10 @@
 name: Deploy Docs
 on:
-  # 在 CI Check 成功后自动触发（仅 main 分支）
+  push:
-  workflow_run:
+    branches: [main]
-    workflows: ["CI Check"]
+  pull_request:
    types: [completed]
    branches: [main]
  # 手动触发
  workflow_dispatch:
    inputs:
      branch:
@@ -35,19 +33,12 @@ concurrency:
 jobs:
  # Build documentation
  build:
    # 只在以下情况运行：
    # 1. workflow_run 触发且 CI Check 成功
    # 2. 手动触发
    if: |
      github.event_name == 'workflow_dispatch' ||
      (github.event_name == 'workflow_run' && github.event.workflow_run.conclusion == 'success')
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
        with:
-          # workflow_run 时使用触发工作流的分支，手动触发时使用输入的分支
+          ref: ${{ github.event.inputs.branch || github.ref }}
          ref: ${{ github.event.workflow_run.head_branch || github.event.inputs.branch || github.ref }}
          fetch-depth: 0
      - name: Setup Miniforge (with mamba)
@@ -55,7 +46,7 @@ jobs:
        with:
          miniforge-version: latest
          use-mamba: true
-          python-version: '3.11.14'
+          python-version: '3.11.11'
          channels: conda-forge,robostack-staging,uni-lab,defaults
          channel-priority: flexible
          activate-environment: unilab
@@ -84,10 +75,8 @@ jobs:
      - name: Setup Pages
        id: pages
-        uses: actions/configure-pages@v5
+        uses: actions/configure-pages@v4
-        if: |
+        if: github.ref == 'refs/heads/main' || (github.event_name == 'workflow_dispatch' && github.event.inputs.deploy_to_pages == 'true')
          github.event.workflow_run.head_branch == 'main' ||
          (github.event_name == 'workflow_dispatch' && github.event.inputs.deploy_to_pages == 'true')
      - name: Build Sphinx documentation
        run: |
@@ -105,18 +94,14 @@ jobs:
          test -f docs/_build/html/index.html && echo "✓ index.html exists" || echo "✗ index.html missing"
      - name: Upload build artifacts
-        uses: actions/upload-pages-artifact@v4
+        uses: actions/upload-pages-artifact@v3
-        if: |
+        if: github.ref == 'refs/heads/main' || (github.event_name == 'workflow_dispatch' && github.event.inputs.deploy_to_pages == 'true')
          github.event.workflow_run.head_branch == 'main' ||
          (github.event_name == 'workflow_dispatch' && github.event.inputs.deploy_to_pages == 'true')
        with:
          path: docs/_build/html
  # Deploy to GitHub Pages
  deploy:
-    if: |
+    if: github.ref == 'refs/heads/main' || (github.event_name == 'workflow_dispatch' && github.event.inputs.deploy_to_pages == 'true')
      github.event.workflow_run.head_branch == 'main' ||
      (github.event_name == 'workflow_dispatch' && github.event.inputs.deploy_to_pages == 'true')
    environment:
      name: github-pages
      url: ${{ steps.deployment.outputs.page_url }}
--- a/.github/workflows/multi-platform-build.yml
+++ b/.github/workflows/multi-platform-build.yml
@@ -1,16 +1,11 @@
 name: Multi-Platform Conda Build
 on:
  # 在 CI Check 工作流完成后触发（仅限 main/dev 分支）
  workflow_run:
    workflows: ["CI Check"]
    types:
      - completed
    branches: [main, dev]
  # 支持 tag 推送（不依赖 CI Check）
  push:
    branches: [main, dev]
    tags: ['v*']
-  # 手动触发
+  pull_request:
    branches: [main, dev]
  workflow_dispatch:
    inputs:
      platforms:
@@ -22,37 +17,9 @@ on:
        required: false
        default: false
        type: boolean
      skip_ci_check:
        description: '跳过等待 CI Check (手动触发时可选)'
        required: false
        default: false
        type: boolean
 jobs:
  # 等待 CI Check 完成的 job (仅用于 workflow_run 触发)
  wait-for-ci:
    runs-on: ubuntu-latest
    if: github.event_name == 'workflow_run'
    outputs:
      should_continue: ${{ steps.check.outputs.should_continue }}
    steps:
      - name: Check CI status
        id: check
        run: |
          if [[ "${{ github.event.workflow_run.conclusion }}" == "success" ]]; then
            echo "should_continue=true" >> $GITHUB_OUTPUT
            echo "CI Check passed, proceeding with build"
          else
            echo "should_continue=false" >> $GITHUB_OUTPUT
            echo "CI Check did not succeed (status: ${{ github.event.workflow_run.conclusion }}), skipping build"
          fi
  build:
    needs: [wait-for-ci]
    # 运行条件：workflow_run 触发且 CI 成功，或者其他触发方式
    if: |
      always() &&
      (needs.wait-for-ci.result == 'skipped' || needs.wait-for-ci.outputs.should_continue == 'true')
    strategy:
      fail-fast: false
      matrix:
@@ -60,7 +27,7 @@ jobs:
          - os: ubuntu-latest
            platform: linux-64
            env_file: unilabos-linux-64.yaml
-          - os: macos-15 # Intel (via Rosetta)
+          - os: macos-13 # Intel
            platform: osx-64
            env_file: unilabos-osx-64.yaml
          - os: macos-latest # ARM64
@@ -77,10 +44,8 @@ jobs:
        shell: bash -l {0}
    steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
        with:
          # 如果是 workflow_run 触发，使用触发 CI Check 的 commit
          ref: ${{ github.event.workflow_run.head_sha || github.ref }}
          fetch-depth: 0
      - name: Check if platform should be built
@@ -104,6 +69,7 @@ jobs:
          channels: conda-forge,robostack-staging,defaults
          channel-priority: strict
          activate-environment: build-env
          auto-activate-base: false
          auto-update-conda: false
          show-channel-urls: true
@@ -149,7 +115,7 @@ jobs:
      - name: Upload conda package artifacts
        if: steps.should_build.outputs.should_build == 'true'
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v4
        with:
          name: conda-package-${{ matrix.platform }}
          path: conda-packages-temp
--- a/.github/workflows/unilabos-conda-build.yml
+++ b/.github/workflows/unilabos-conda-build.yml
@@ -1,69 +1,32 @@
 name: UniLabOS Conda Build
 on:
  # 在 CI Check 成功后自动触发
  workflow_run:
    workflows: ["CI Check"]
    types: [completed]
    branches: [main, dev]
  # 标签推送时直接触发（发布版本）
  push:
    branches: [main, dev]
    tags: ['v*']
-  # 手动触发
+  pull_request:
    branches: [main, dev]
  workflow_dispatch:
    inputs:
      platforms:
        description: '选择构建平台 (逗号分隔): linux-64, osx-64, osx-arm64, win-64'
        required: false
        default: 'linux-64'
      build_full:
        description: '是否构建 unilabos-full 完整包 (默认只构建 unilabos 基础包)'
        required: false
        default: false
        type: boolean
      upload_to_anaconda:
        description: '是否上传到Anaconda.org'
        required: false
        default: false
        type: boolean
      skip_ci_check:
        description: '跳过等待 CI Check (手动触发时可选)'
        required: false
        default: false
        type: boolean
 jobs:
  # 等待 CI Check 完成的 job (仅用于 workflow_run 触发)
  wait-for-ci:
    runs-on: ubuntu-latest
    if: github.event_name == 'workflow_run'
    outputs:
      should_continue: ${{ steps.check.outputs.should_continue }}
    steps:
      - name: Check CI status
        id: check
        run: |
          if [[ "${{ github.event.workflow_run.conclusion }}" == "success" ]]; then
            echo "should_continue=true" >> $GITHUB_OUTPUT
            echo "CI Check passed, proceeding with build"
          else
            echo "should_continue=false" >> $GITHUB_OUTPUT
            echo "CI Check did not succeed (status: ${{ github.event.workflow_run.conclusion }}), skipping build"
          fi
  build:
    needs: [wait-for-ci]
    # 运行条件：workflow_run 触发且 CI 成功，或者其他触发方式
    if: |
      always() &&
      (needs.wait-for-ci.result == 'skipped' || needs.wait-for-ci.outputs.should_continue == 'true')
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
            platform: linux-64
-          - os: macos-15 # Intel (via Rosetta)
+          - os: macos-13 # Intel
            platform: osx-64
          - os: macos-latest # ARM64
            platform: osx-arm64
@@ -77,10 +40,8 @@ jobs:
        shell: bash -l {0}
    steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
        with:
          # 如果是 workflow_run 触发，使用触发 CI Check 的 commit
          ref: ${{ github.event.workflow_run.head_sha || github.ref }}
          fetch-depth: 0
      - name: Check if platform should be built
@@ -104,6 +65,7 @@ jobs:
          channels: conda-forge,robostack-staging,uni-lab,defaults
          channel-priority: strict
          activate-environment: build-env
          auto-activate-base: false
          auto-update-conda: false
          show-channel-urls: true
@@ -119,61 +81,12 @@ jobs:
          conda list | grep -E "(rattler-build|anaconda-client)"
          echo "Platform: ${{ matrix.platform }}"
          echo "OS: ${{ matrix.os }}"
-          echo "Build full package: ${{ github.event.inputs.build_full || 'false' }}"
+          echo "Building UniLabOS package"
          echo "Building packages:"
          echo "  - unilabos-env (environment dependencies)"
          echo "  - unilabos (with pip package)"
          if [[ "${{ github.event.inputs.build_full }}" == "true" ]]; then
            echo "  - unilabos-full (complete package)"
          fi
-      - name: Build unilabos-env (conda environment only, noarch)
+      - name: Build conda package
        if: steps.should_build.outputs.should_build == 'true'
        run: |
-          echo "Building unilabos-env (conda environment dependencies)..."
+          rattler-build build -r .conda/recipe.yaml -c uni-lab -c robostack-staging -c conda-forge
          rattler-build build -r .conda/environment/recipe.yaml -c uni-lab -c robostack-staging -c conda-forge
      - name: Upload unilabos-env to Anaconda.org (if enabled)
        if: steps.should_build.outputs.should_build == 'true' && github.event.inputs.upload_to_anaconda == 'true'
        run: |
          echo "Uploading unilabos-env to uni-lab organization..."
          for package in $(find ./output -name "unilabos-env*.conda"); do
            anaconda -t ${{ secrets.ANACONDA_API_TOKEN }} upload --user uni-lab --force "$package"
          done
      - name: Build unilabos (with pip package)
        if: steps.should_build.outputs.should_build == 'true'
        run: |
          echo "Building unilabos package..."
          # 如果已上传到 Anaconda，从 uni-lab channel 获取 unilabos-env；否则从本地 output 获取
          rattler-build build -r .conda/base/recipe.yaml -c uni-lab -c robostack-staging -c conda-forge --channel ./output
      - name: Upload unilabos to Anaconda.org (if enabled)
        if: steps.should_build.outputs.should_build == 'true' && github.event.inputs.upload_to_anaconda == 'true'
        run: |
          echo "Uploading unilabos to uni-lab organization..."
          for package in $(find ./output -name "unilabos-0*.conda" -o -name "unilabos-[0-9]*.conda"); do
            anaconda -t ${{ secrets.ANACONDA_API_TOKEN }} upload --user uni-lab --force "$package"
          done
      - name: Build unilabos-full - Only when explicitly requested
        if: |
          steps.should_build.outputs.should_build == 'true' && 
          github.event.inputs.build_full == 'true'
        run: |
          echo "Building unilabos-full package on ${{ matrix.platform }}..."
          rattler-build build -r .conda/full/recipe.yaml -c uni-lab -c robostack-staging -c conda-forge --channel ./output
      - name: Upload unilabos-full to Anaconda.org (if enabled)
        if: |
          steps.should_build.outputs.should_build == 'true' && 
          github.event.inputs.build_full == 'true' &&
          github.event.inputs.upload_to_anaconda == 'true'
        run: |
          echo "Uploading unilabos-full to uni-lab organization..."
          for package in $(find ./output -name "unilabos-full*.conda"); do
            anaconda -t ${{ secrets.ANACONDA_API_TOKEN }} upload --user uni-lab --force "$package"
          done
      - name: List built packages
        if: steps.should_build.outputs.should_build == 'true'
@@ -195,9 +108,17 @@ jobs:
      - name: Upload conda package artifacts
        if: steps.should_build.outputs.should_build == 'true'
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v4
        with:
          name: conda-package-unilabos-${{ matrix.platform }}
          path: conda-packages-temp
          if-no-files-found: warn
          retention-days: 30
      - name: Upload to Anaconda.org (uni-lab organization)
        if: github.event.inputs.upload_to_anaconda == 'true'
        run: |
          for package in $(find ./output -name "*.conda"); do
            echo "Uploading $package to uni-lab organization..."
            anaconda -t ${{ secrets.ANACONDA_API_TOKEN }} upload --user uni-lab --force "$package"
          done
--- a/.gitignore
+++ b/.gitignore
@@ -4,8 +4,6 @@ temp/
 output/
 unilabos_data/
 pyrightconfig.json
 .cursorignore
 device_package*/
 ## Python
 # Byte-compiled / optimized / DLL files
@@ -251,7 +249,4 @@ ros-humble-unilabos-msgs-0.9.13-h6403a04_5.tar.bz2
 *.bz2
 test_config.py
-# Local config files with secrets
+
 yibin_coin_cell_only_config.json
 yibin_electrolyte_config.json
 yibin_electrolyte_only_config.json
--- a/260415csv_export_walkthrough.md
+++ b/260415csv_export_walkthrough.md
@@ -1,72 +0,0 @@
 # CSV 导出功能变更概要
 ## 修改的文件
 ### 1. [bioyond_cell_workstation.py](file:///d:/UniLabdev/Uni-Lab-OS/unilabos/devices/workstation/bioyond_studio/bioyond_cell/bioyond_cell_workstation.py)
 #### 新增导入
 - `import csv` 和 `import os`（L14-15）
 #### 新增方法
 | 方法 | 功能 |
 |------|------|
 | `_extract_prep_bottle_from_report` | 从 order_finish 报文提取**配液瓶**信息（每订单最多1个） |
 | `_extract_vial_bottles_from_report` | 从 order_finish 报文提取**分液瓶**信息（每订单可多个，返回数组） |
 | `_export_order_csv` | 汇总所有信息写入 CSV 文件 |
 #### 配液瓶筛选逻辑 (`_extract_prep_bottle_from_report`)
 - `typemode="1"`, `realQuantity=1`, `usedQuantity=1`
 - `locationId` 以 `3a19deae-2c7a-` 开头（手动传递窗）
 - LIMS API 二次确认：`typeName` 含"配液瓶(小)"或"配液瓶(大)"
 #### 分液瓶筛选逻辑 (`_extract_vial_bottles_from_report`)
 - `typemode="1"`, `realQuantity=1`, `usedQuantity=1`
 - `locationId` 以 `3a19debc-84b5-` 或 `3a19debe-5200` 开头（自动堆栈-左/右）
 - LIMS API 二次确认：`typeName` 为"5ml分液瓶"或"20ml分液瓶"
 - **返回数组**，支持 1×5ml + n×20ml 的组合
 #### 修改的方法
 | 方法 | 变更 |
 |------|------|
 | `_submit_and_wait_orders` | 新增配液瓶+分液瓶提取步骤，将 `prep_bottles` 和 `vial_bottles` 存入 `final_result` |
 | `create_orders` | 添加 `csv_export_path` 参数，末尾调用 `_export_order_csv` |
 | `create_orders_formulation` | 添加 `csv_export_path` 参数，末尾调用 `_export_order_csv` |
 #### CSV 输出格式
 ```
 orderCode, orderName, 配液瓶类型, 配液瓶二维码, 分液瓶类型, 分液瓶二维码, 目标配液质量比, 真实配液质量比, 时间
 ```
 - 单个分液瓶时直接写值；多个分液瓶时类型和二维码用 JSON 数组表示
 - CSV 编码使用 `utf-8-sig`（兼容 Excel 打开）
 - `csv_export_path` 默认为空字符串，不传则不导出（向后兼容）
 ---
 ### 2. [bioyond_cell.yaml](file:///d:/UniLabdev/Uni-Lab-OS/unilabos/registry/devices/bioyond_cell.yaml)
 为两个 action 注册了 `csv_export_path` 参数：
 - `auto-create_orders`: `goal_default` + `schema.properties.goal.properties` 中添加 `csv_export_path`
 - `auto-create_orders_formulation`: 同上
 ---
 ### 3. [coin_cell_assembly.py](file:///d:/UniLabdev/Uni-Lab-OS/unilabos/devices/workstation/coin_cell_assembly/coin_cell_assembly.py) 的 CSV 改动与全流程追溯
 在 `bioyond_cell_workstation.py` 的 `_submit_and_wait_orders` 最后阶段，提取 `prep_bottles`（配液瓶）和 `vial_bottles`（分液瓶）的条码并随 `mass_ratios` 数组一起下发给各下游工站（例如扣电组装站），实现跨站的全流程配方追溯。
 并在扣电站生成的 `date_xxx.csv` 中，**替换并新增**了以下列：
 - 移除了原有的 `formulation_order_code` 与合并的 `formulation_ratio` 列。
 - 新增 `orderName` 导出
 - 新增 `prep_bottle_barcode`（奔曜传递的配液瓶二维码）
 - 新增 `vial_bottle_barcodes`（奔曜传递的分液瓶二维码，多瓶时存 JSON 数组）
 - 新增 `target_mass_ratio` 理论目标质量比
 - 新增 `real_mass_ratio` 实际称量真实质量比
 *注意：这与操作人员在手套箱内扫码传入扣电站的 `electrolyte_code` 是单独记录的，方便做数据核对。*
 ## 向后兼容性
 - `csv_export_path` 默认值为 `""`（空字符串），现有调用不受影响
 - 新增的 `prep_bottles` 和 `vial_bottles` 字段为 `final_result` 和 `mass_ratios` 内部的新增附属字段，不破坏现有数据结构。
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -1,87 +0,0 @@
 # AGENTS.md
 This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
 Also follow the monorepo-level rules in `../AGENTS.md`.
 ## Build & Development
 ```bash
 # Install in editable mode (requires mamba env with python 3.11)
 pip install -e .
 uv pip install -r unilabos/utils/requirements.txt
 # Run with a device graph
 unilab --graph <graph.json> --config <config.py> --backend ros
 unilab --graph <graph.json> --config <config.py> --backend simple  # no ROS2 needed
 # Common CLI flags
 unilab --app_bridges websocket fastapi    # communication bridges
 unilab --test_mode                        # simulate hardware, no real execution
 unilab --check_mode                       # CI validation of registry imports
 unilab --skip_env_check                   # skip auto-install of dependencies
 unilab --visual rviz|web|disable          # visualization mode
 unilab --is_slave                         # run as slave node
 # Workflow upload subcommand
 unilab workflow_upload -f <workflow.json> -n <name> --tags tag1 tag2
 # Tests
 pytest tests/                              # all tests
 pytest tests/resources/test_resourcetreeset.py  # single test file
 pytest tests/resources/test_resourcetreeset.py::TestClassName::test_method  # single test
 ```
 ## Architecture
 ### Startup Flow
 `unilab` CLI → `unilabos/app/main.py:main()` → loads config → builds registry → reads device graph (JSON/GraphML) → starts backend thread (ROS2/simple) → starts FastAPI web server + WebSocket client.
 ### Core Layers
 **Registry** (`unilabos/registry/`): Singleton `Registry` class discovers and catalogs all device types, resource types, and communication devices from YAML definitions. Device types live in `registry/devices/*.yaml`, resources in `registry/resources/`, comms in `registry/device_comms/`. The registry resolves class paths to actual Python classes via `utils/import_manager.py`.
 **Resource Tracking** (`unilabos/resources/resource_tracker.py`): Pydantic-based `ResourceDict` → `ResourceDictInstance` → `ResourceTreeSet` hierarchy. `ResourceTreeSet` is the canonical in-memory representation of all devices and resources, used throughout the system. Graph I/O is in `resources/graphio.py` (reads JSON/GraphML device topology files into `nx.Graph` + `ResourceTreeSet`).
 **Device Drivers** (`unilabos/devices/`): 30+ hardware drivers organized by device type (liquid_handling, hplc, balance, arm, etc.). Each driver is a Python class that gets wrapped by `ros/device_node_wrapper.py:ros2_device_node()` to become a ROS2 node with publishers, subscribers, and action servers.
 **ROS2 Layer** (`unilabos/ros/`): `device_node_wrapper.py` dynamically wraps any device class into `ROS2DeviceNode` (defined in `ros/nodes/base_device_node.py`). Preset node types in `ros/nodes/presets/` include `host_node`, `controller_node`, `workstation`, `serial_node`, `camera`. Messages use custom `unilabos_msgs` (pre-built, distributed via releases).
 **Protocol Compilation** (`unilabos/compile/`): 20+ protocol compilers (add, centrifuge, dissolve, filter, heatchill, stir, pump, etc.) that transform YAML protocol definitions into executable sequences.
 **Communication** (`unilabos/device_comms/`): Hardware communication adapters — OPC-UA client, Modbus PLC, RPC, and a universal driver. `app/communication.py` provides a factory pattern for WebSocket client connections to the cloud.
 **Web/API** (`unilabos/app/web/`): FastAPI server with REST API (`api.py`), Jinja2 template pages (`pages.py`), and HTTP client for cloud communication (`client.py`). Runs on port 8002 by default.
 ### Configuration System
 - **Config classes** in `unilabos/config/config.py`: `BasicConfig`, `WSConfig`, `HTTPConfig`, `ROSConfig` — all class-level attributes, loaded from Python config files
 - Config files are `.py` files with matching class names (see `config/example_config.py`)
 - Environment variables override with prefix `UNILABOS_` (e.g., `UNILABOS_BASICCONFIG_PORT=9000`)
 - Device topology defined in graph files (JSON with node-link format, or GraphML)
 ### Key Data Flow
 1. Graph file → `graphio.read_node_link_json()` → `(nx.Graph, ResourceTreeSet, resource_links)`
 2. `ResourceTreeSet` + `Registry` → `initialize_device.initialize_device_from_dict()` → `ROS2DeviceNode` instances
 3. Device nodes communicate via ROS2 topics/actions or direct Python calls (simple backend)
 4. Cloud sync via WebSocket (`app/ws_client.py`) and HTTP (`app/web/client.py`)
 ### Test Data
 Example device graphs and experiment configs are in `unilabos/test/experiments/` (not `tests/`). Registry test fixtures in `unilabos/test/registry/`.
 ## Code Conventions
 - Code comments and log messages in simplified Chinese
 - Python 3.11+, type hints expected
 - Pydantic models for data validation (`resource_tracker.py`)
 - Singleton pattern via `@singleton` decorator (`utils/decorator.py`)
 - Dynamic class loading via `utils/import_manager.py` — device classes resolved at runtime from registry YAML paths
 - CLI argument dashes auto-converted to underscores for consistency
 ## Licensing
 - Framework code: GPL-3.0
 - Device drivers (`unilabos/devices/`): DP Technology Proprietary License — do not redistribute
--- a/CHANGES_2026_03_24.md
+++ b/CHANGES_2026_03_24.md
@@ -1,168 +0,0 @@
 # 变更说明 2026-03-24
 ## 问题背景
 `BioyondElectrolyteDeck`（原 `BIOYOND_YB_Deck`）迁移后，前端物料未能正常上传/同步。
 ---
 ## 修复内容
 ### 1. `unilabos/resources/bioyond/decks.py`
 - 补回 `setup: bool = False` 参数及 `if setup: self.setup()` 逻辑，与旧版 `BIOYOND_YB_Deck` 保持一致
 - 工厂函数 `bioyond_electrolyte_deck` 保留显式调用 `deck.setup()`，避免重复初始化
 ```python
 # 修复前（缺少 setup 参数，无法通过 setup=True 触发初始化）
 def __init__(self, name, size_x, size_y, size_z, category):
    super().__init__(...)
 # 修复后
 def __init__(self, name, size_x, size_y, size_z, category, setup: bool = False):
    super().__init__(...)
    if setup:
        self.setup()
 ```
 ---
 ### 2. `unilabos/resources/graphio.py`
 - 修复 `resource_bioyond_to_plr` 中两处 `bottle.tracker.liquids` 直接赋值导致的崩溃
 - `ResourceHolder`（如枪头盒的 TipSpot 槽位）没有 `tracker` 属性，直接访问会抛出 `AttributeError`，阻断整个 Bioyond 同步流程
 ```python
 # 修复前
 bottle.tracker.liquids = [...]
 # 修复后
 if hasattr(bottle, 'tracker') and bottle.tracker is not None:
    bottle.tracker.liquids = [...]
 ```
 ---
 ### 3. `unilabos/app/main.py`
 - 保留 `file_path is not None` 条件不变（已还原），并补充注释说明原因
 - 该逻辑只在**本地文件模式**下有意义：本地 graph 文件只含设备结构，远端有已保存物料，merge 才能将两者合并
 - 远端模式（`file_path=None`）下，`resource_tree_set` 和 `request_startup_json` 来自同一份数据，merge 为空操作，条件是否加 `file_path is not None` 对结果没有影响
 ---
 ### 4. `unilabos/devices/workstation/bioyond_studio/station.py` ⭐ 核心修复
 - 当 deck 通过反序列化创建时，不会自动调用 `setup()`，导致 `deck.children` 为空，`warehouses` 始终是 `{}`
 - 增加兜底逻辑：仓库扫描后仍为空，则主动调用 `deck.setup()` 初始化仓库
 - 这是导致所有物料放置失败（`warehouse '...' 在deck中不存在。可用warehouses: []`）的根本原因
 ```python
 # 新增兜底
 if not self.deck.warehouses and hasattr(self.deck, "setup") and callable(self.deck.setup):
    logger.info("Deck 无仓库子节点，调用 setup() 初始化仓库")
    self.deck.setup()
 ```
 ---
 ---
 ## 补充修复 2026-03-25：依华扣电组装工站子物料未上传
 ### 问题
 `CoinCellAssemblyWorkstation.post_init` 直接上传空 deck，未调用 `deck.setup()`，导致：
 - 前端子物料（成品弹夹、料盘、瓶架等）不显示
 - 运行时 `self.deck.get_resource("成品弹夹")` 抛出 `ResourceNotFoundError`
 ### 修复文件
 **`unilabos/devices/workstation/coin_cell_assembly/YB_YH_materials.py`**
 - `YihuaCoinCellDeck.__init__` 补回 `setup: bool = False` 参数及 `if setup: self.setup()` 逻辑
 **`unilabos/devices/workstation/coin_cell_assembly/coin_cell_assembly.py`**
 - `post_init` 中增加与 Bioyond 工站相同的兜底逻辑：deck 无子节点时调用 `deck.setup()` 初始化
 ```python
 # post_init 中新增
 if self.deck and not self.deck.children and hasattr(self.deck, "setup") and callable(self.deck.setup):
    logger.info("YihuaCoinCellDeck 无子节点，调用 setup() 初始化")
    self.deck.setup()
 ```
 ### 联动 Bug：`MaterialPlate.create_with_holes` 构造顺序错误
 **现象**：`deck.setup()` 被调用后，启动时抛出：
 ```
 设备后初始化失败: Must specify either `ordered_items` or `ordering`.
 ```
 **根因**：`create_with_holes` 原来的逻辑是先构造空的 `MaterialPlate` 实例，再 assign 洞位：
 ```python
 # 旧（错误）：cls(...) 时 ordered_items=None → ItemizedResource.__init__ 立即报错
 plate = cls(name=name, ...)          # ← 这里就崩了
 holes = create_ordered_items_2d(...) # ← 根本没走到这里
 for hole_name, hole in holes.items():
    plate.assign_child_resource(...)
 ```
 pylabrobot 的 `ItemizedResource.__init__` 强制要求 `ordered_items` 和 `ordering` 必须有一个不为 `None`，空构造直接失败。
 **修复**：先建洞位，再作为 `ordered_items` 传给构造函数：
 ```python
 # 新（正确）：先建洞位，再一次性传入构造函数
 holes = create_ordered_items_2d(klass=MaterialHole, num_items_x=4, ...)
 return cls(name=name, ..., ordered_items=holes)
 ```
 > 此 bug 此前未被触发，是因为 `deck.setup()` 从未被调用到——正是上面 `post_init` 兜底修复引出的联动问题。
 ---
 ## 补充修复 2026-03-25：3→2→1 转运资源同步失败
 ### 问题
 配液工站（Bioyond）完成分液后，调用 `transfer_3_to_2_to_1_auto` 将分液瓶板转运到扣电工站（BatteryStation）。物理 LIMS 转运成功，但数字孪生资源树同步始终失败：
 ```
 [资源同步] ❌ 失败: 目标设备 'BatteryStation' 中未找到资源 'bottle_rack_6x2'
 ```
 ### 根因
 `_get_resource_from_device` 方法负责跨设备查找资源对象，有两个问题：
 1. **原始路径完全失效**：尝试 `from unilabos.app.ros2_app import get_device_plr_resource_by_name`，但该模块不存在，`ImportError` 被 `except Exception: pass` 静默吞掉
 2. **降级路径搜错地方**：遍历 `self._plr_resources`（Bioyond 自己的资源），不可能找到 BatteryStation 的 `bottle_rack_6x2`
 ### 修复文件
 **`unilabos/devices/workstation/bioyond_studio/bioyond_cell/bioyond_cell_workstation.py`**
 改用全局设备注册表 `registered_devices` 跨设备访问目标 deck：
 ```python
 # 修复前（失效）
 from unilabos.app.ros2_app import get_device_plr_resource_by_name  # 模块不存在
 return get_device_plr_resource_by_name(device_id, resource_name)
 # 修复后
 from unilabos.ros.nodes.base_device_node import registered_devices
 device_info = registered_devices.get(device_id)
 if device_info is not None:
    driver = device_info.get("driver_instance")  # TypedDict 是 dict，必须用 .get()
    if driver is not None:
        deck = getattr(driver, "deck", None)
        if deck is not None:
            res = deck.get_resource(resource_name)
 ```
 关键细节：`DeviceInfoType` 是 `TypedDict`（即普通 `dict`），必须用 `device_info.get("driver_instance")` 而非 `getattr(device_info, "driver_instance", None)`——后者对字典永远返回 `None`。
 ---
 ## 根本原因分析
 旧版以**本地文件模式**启动（有 `graph` 文件），deck 在启动前已通过 `merge_remote_resources` 获得仓库子节点，反序列化时能正确恢复 warehouses。
 新版以**远端模式**启动（`file_path=None`），deck 反序列化时没有仓库子节点，`station.py` 扫描为空，所有物料的 warehouse 匹配失败，Bioyond 同步的 16 个资源全部无法放置到对应仓库位，前端不显示。
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -1,4 +0,0 @@
 Please follow the rules defined in:
@AGENTS.md
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -1,5 +1,4 @@
 recursive-include unilabos/test *
 recursive-include unilabos/utils *
 recursive-include unilabos/registry *.yaml
 recursive-include unilabos/app/web/static *
 recursive-include unilabos/app/web/templates *
--- a/README.md
+++ b/README.md
@@ -31,63 +31,37 @@ Detailed documentation can be found at:
 ## Quick Start
-### 1. Setup Conda Environment
+Uni-Lab-OS recommends using `mamba` for environment management. Choose the appropriate environment file for your operating system:
 Uni-Lab-OS recommends using `mamba` for environment management. Choose the package that fits your needs:
 | Package | Use Case | Contents |
 |---------|----------|----------|
 | `unilabos` | **Recommended for most users** | Complete package, ready to use |
 | `unilabos-env` | Developers (editable install) | Environment only, install unilabos via pip |
 | `unilabos-full` | Simulation/Visualization | unilabos + ROS2 Desktop + Gazebo + MoveIt |
 ```bash
 # Create new environment
-mamba create -n unilab python=3.11.14
+mamba create -n unilab python=3.11.11
 mamba activate unilab
-
+mamba install -n unilab uni-lab::unilabos -c robostack-staging -c conda-forge
 # Option A: Standard installation (recommended for most users)
 mamba install uni-lab::unilabos -c robostack-staging -c conda-forge
 # Option B: For developers (editable mode development)
 mamba install uni-lab::unilabos-env -c robostack-staging -c conda-forge
 # Then install unilabos and dependencies:
 git clone https://github.com/deepmodeling/Uni-Lab-OS.git && cd Uni-Lab-OS
 pip install -e .
 uv pip install -r unilabos/utils/requirements.txt
 # Option C: Full installation (simulation/visualization)
 mamba install uni-lab::unilabos-full -c robostack-staging -c conda-forge
 ```
-**When to use which?**
+## Install Dev Uni-Lab-OS
 - **unilabos**: Standard installation for production deployment and general usage (recommended)
 - **unilabos-env**: For developers who need `pip install -e .` editable mode, modify source code
 - **unilabos-full**: For simulation (Gazebo), visualization (rviz2), and Jupyter notebooks
 ### 2. Clone Repository (Optional, for developers)
 ```bash
-# Clone the repository (only needed for development or examples)
+# Clone the repository
 git clone https://github.com/deepmodeling/Uni-Lab-OS.git
 cd Uni-Lab-OS
 # Install Uni-Lab-OS
 pip install .
 ```
-3. Start Uni-Lab System
+3. Start Uni-Lab System:
 Please refer to [Documentation - Boot Examples](https://deepmodeling.github.io/Uni-Lab-OS/boot_examples/index.html)
 4. Best Practice
 See [Best Practice Guide](https://deepmodeling.github.io/Uni-Lab-OS/user_guide/best_practice.html)
 ## Message Format
 Uni-Lab-OS uses pre-built `unilabos_msgs` for system communication. You can find the built versions on the [GitHub Releases](https://github.com/deepmodeling/Uni-Lab-OS/releases) page.
 ## Citation
-If you use [Uni-Lab-OS](https://arxiv.org/abs/2512.21766) in academic research, please cite:
+If you use Uni-Lab-OS in academic research, please cite:
 ```bibtex
@article{gao2025unilabos,
--- a/README_zh.md
+++ b/README_zh.md
@@ -31,63 +31,39 @@ Uni-Lab-OS 是一个用于实验室自动化的综合平台，旨在连接和控
 ## 快速开始
-### 1. 配置 Conda 环境
+1. 配置 Conda 环境
-Uni-Lab-OS 建议使用 `mamba` 管理环境。根据您的需求选择合适的安装包：
+Uni-Lab-OS 建议使用 `mamba` 管理环境。根据您的操作系统选择适当的环境文件:
 | 安装包 | 适用场景 | 包含内容 |
 |--------|----------|----------|
 | `unilabos` | **推荐大多数用户** | 完整安装包，开箱即用 |
 | `unilabos-env` | 开发者（可编辑安装） | 仅环境依赖，通过 pip 安装 unilabos |
 | `unilabos-full` | 仿真/可视化 | unilabos + ROS2 桌面版 + Gazebo + MoveIt |
 ```bash
 # 创建新环境
-mamba create -n unilab python=3.11.14
+mamba create -n unilab python=3.11.11
 mamba activate unilab
-
+mamba install -n unilab uni-lab::unilabos -c robostack-staging -c conda-forge
 # 方案 A：标准安装（推荐大多数用户）
 mamba install uni-lab::unilabos -c robostack-staging -c conda-forge
 # 方案 B：开发者环境（可编辑模式开发）
 mamba install uni-lab::unilabos-env -c robostack-staging -c conda-forge
 # 然后安装 unilabos 和依赖：
 git clone https://github.com/deepmodeling/Uni-Lab-OS.git && cd Uni-Lab-OS
 pip install -e .
 uv pip install -r unilabos/utils/requirements.txt
 # 方案 C：完整安装（仿真/可视化）
 mamba install uni-lab::unilabos-full -c robostack-staging -c conda-forge
 ```
-**如何选择？**
+2. 安装开发版 Uni-Lab-OS:
 - **unilabos**：标准安装，适用于生产部署和日常使用（推荐）
 - **unilabos-env**：开发者使用，支持 `pip install -e .` 可编辑模式，可修改源代码
 - **unilabos-full**：需要仿真（Gazebo）、可视化（rviz2）或 Jupyter Notebook
 ### 2. 克隆仓库（可选，供开发者使用）
 ```bash
-# 克隆仓库（仅开发或查看示例时需要）
+# 克隆仓库
 git clone https://github.com/deepmodeling/Uni-Lab-OS.git
 cd Uni-Lab-OS
 # 安装 Uni-Lab-OS
 pip install .
 ```
-3. 启动 Uni-Lab 系统
+3. 启动 Uni-Lab 系统:
 请见[文档-启动样例](https://deepmodeling.github.io/Uni-Lab-OS/boot_examples/index.html)
 4. 最佳实践
 请见[最佳实践指南](https://deepmodeling.github.io/Uni-Lab-OS/user_guide/best_practice.html)
 ## 消息格式
 Uni-Lab-OS 使用预构建的 `unilabos_msgs` 进行系统通信。您可以在 [GitHub Releases](https://github.com/deepmodeling/Uni-Lab-OS/releases) 页面找到已构建的版本。
 ## 引用
-如果您在学术研究中使用 [Uni-Lab-OS](https://arxiv.org/abs/2512.21766)，请引用：
+如果您在学术研究中使用 Uni-Lab-OS，请引用：
 ```bibtex
@article{gao2025unilabos,
--- a/docs/advanced_usage/configuration.md
+++ b/docs/advanced_usage/configuration.md
@@ -12,7 +12,7 @@ Uni-Lab 使用 Python 格式的配置文件（`.py`），默认为 `unilabos_dat
 **获取方式：**
-进入 [Uni-Lab 实验室](https://leap-lab.bohrium.com)，点击左下角的头像，在实验室详情中获取所在实验室的 ak 和 sk：
+进入 [Uni-Lab 实验室](https://uni-lab.bohrium.com)，点击左下角的头像，在实验室详情中获取所在实验室的 ak 和 sk：
 ![copy_aksk.gif](image/copy_aksk.gif)
@@ -69,7 +69,7 @@ class WSConfig:
 # HTTP配置
 class HTTPConfig:
-    remote_addr = "https://leap-lab.bohrium.com/api/v1"  # 远程服务器地址
+    remote_addr = "https://uni-lab.bohrium.com/api/v1"  # 远程服务器地址
 # ROS配置
 class ROSConfig:
@@ -209,8 +209,8 @@ unilab --ak "key" --sk "secret" --addr "test" --upload_registry --2d_vis -g grap
 `--addr` 参数支持以下预设值，会自动转换为对应的完整 URL：
- `test` → `https://leap-lab.test.bohrium.com/api/v1`
+- `test` → `https://uni-lab.test.bohrium.com/api/v1`
- `uat` → `https://leap-lab.uat.bohrium.com/api/v1`
+- `uat` → `https://uni-lab.uat.bohrium.com/api/v1`
 - `local` → `http://127.0.0.1:48197/api/v1`
 - 其他值 → 直接使用作为完整 URL
@@ -248,7 +248,7 @@ unilab --ak "key" --sk "secret" --addr "test" --upload_registry --2d_vis -g grap
 `ak` 和 `sk` 是必需的认证参数：
-1. **获取方式**：在 [Uni-Lab 官网](https://leap-lab.bohrium.com) 注册实验室后获得
+1. **获取方式**：在 [Uni-Lab 官网](https://uni-lab.bohrium.com) 注册实验室后获得
 2. **配置方式**：
   - **命令行参数**：`--ak "your_key" --sk "your_secret"`（最高优先级，推荐）
   - **环境变量**：`UNILABOS_BASICCONFIG_AK` 和 `UNILABOS_BASICCONFIG_SK`
@@ -276,14 +276,14 @@ WebSocket 是 Uni-Lab 的主要通信方式：
 HTTP 客户端配置用于与云端服务通信：
 | 参数          | 类型 | 默认值                                 | 说明         |
-| ------------- | ---- | --------------------------------------- | ------------ |
+| ------------- | ---- | -------------------------------------- | ------------ |
-| `remote_addr` | str  | `"https://leap-lab.bohrium.com/api/v1"` | 远程服务地址 |
+| `remote_addr` | str  | `"https://uni-lab.bohrium.com/api/v1"` | 远程服务地址 |
 **预设环境地址**：
- 生产环境：`https://leap-lab.bohrium.com/api/v1`（默认）
+- 生产环境：`https://uni-lab.bohrium.com/api/v1`（默认）
- 测试环境：`https://leap-lab.test.bohrium.com/api/v1`
+- 测试环境：`https://uni-lab.test.bohrium.com/api/v1`
- UAT 环境：`https://leap-lab.uat.bohrium.com/api/v1`
+- UAT 环境：`https://uni-lab.uat.bohrium.com/api/v1`
 - 本地环境：`http://127.0.0.1:48197/api/v1`
 ### 4. ROSConfig - ROS 配置
@@ -401,7 +401,7 @@ export UNILABOS_WSCONFIG_RECONNECT_INTERVAL="10"
 export UNILABOS_WSCONFIG_MAX_RECONNECT_ATTEMPTS="500"
 # 设置HTTP配置
-export UNILABOS_HTTPCONFIG_REMOTE_ADDR="https://leap-lab.test.bohrium.com/api/v1"
+export UNILABOS_HTTPCONFIG_REMOTE_ADDR="https://uni-lab.test.bohrium.com/api/v1"
 ```
 ## 配置文件使用方法
@@ -484,13 +484,13 @@ export UNILABOS_WSCONFIG_MAX_RECONNECT_ATTEMPTS=100
 ```python
 class HTTPConfig:
-    remote_addr = "https://leap-lab.test.bohrium.com/api/v1"
+    remote_addr = "https://uni-lab.test.bohrium.com/api/v1"
 ```
 **环境变量方式：**
 ```bash
-export UNILABOS_HTTPCONFIG_REMOTE_ADDR=https://leap-lab.test.bohrium.com/api/v1
+export UNILABOS_HTTPCONFIG_REMOTE_ADDR=https://uni-lab.test.bohrium.com/api/v1
 ```
 **命令行方式（推荐）：**
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -24,7 +24,7 @@ extensions = [
    "sphinx.ext.autodoc",
    "sphinx.ext.napoleon",  # 如果您使用 Google 或 NumPy 风格的 docstrings
    "sphinx_rtd_theme",
-    "sphinxcontrib.mermaid",
+    "sphinxcontrib.mermaid"
 ]
 source_suffix = {
@@ -58,7 +58,7 @@ html_theme = "sphinx_rtd_theme"
 # sphinx-book-theme 主题选项
 html_theme_options = {
-    "repository_url": "https://github.com/deepmodeling/Uni-Lab-OS",
+    "repository_url": "https://github.com/用户名/Uni-Lab",
    "use_repository_button": True,
    "use_issues_button": True,
    "use_edit_page_button": True,
--- a/docs/developer_guide/action_includes.md
+++ b/docs/developer_guide/action_includes.md
--- a/docs/developer_guide/add_device.md
+++ b/docs/developer_guide/add_device.md
@@ -15,9 +15,6 @@ Python 类设备驱动在完成注册表后可以直接在 Uni-Lab 中使用，
 **示例：**
 ```python
 from unilabos.registry.decorators import device, topic_config
@device(id="mock_gripper", category=["gripper"], description="Mock Gripper")
 class MockGripper:
    def __init__(self):
        self._position: float = 0.0
@@ -26,23 +23,19 @@ class MockGripper:
        self._status = "Idle"
    @property
    @topic_config()  # 添加 @topic_config 才会定时广播
    def position(self) -> float:
        return self._position
    @property
    @topic_config()
    def velocity(self) -> float:
        return self._velocity
    @property
    @topic_config()
    def torque(self) -> float:
        return self._torque
-    # 使用 @topic_config 装饰的属性，接入 Uni-Lab 时会定时对外广播
+    # 会被自动识别的设备属性，接入 Uni-Lab 时会定时对外广播
    @property
    @topic_config(period=2.0)  # 可自定义发布周期
    def status(self) -> str:
        return self._status
@@ -156,7 +149,7 @@ my_device: # 设备唯一标识符
 系统会自动分析您的 Python 驱动类并生成：
- `status_types`：从 `@topic_config` 装饰的 `@property` 或方法自动识别状态属性
+- `status_types`：从 `@property` 装饰的方法自动识别状态属性
 - `action_value_mappings`：从类方法自动生成动作映射
 - `init_param_schema`：从 `__init__` 方法分析初始化参数
 - `schema`：前端显示用的属性类型定义
@@ -186,9 +179,7 @@ Uni-Lab 设备驱动是一个 Python 类，需要遵循以下结构：
 ```python
 from typing import Dict, Any
 from unilabos.registry.decorators import device, topic_config
@device(id="my_device", category=["general"], description="My Device")
 class MyDevice:
    """设备类文档字符串
@@ -207,9 +198,8 @@ class MyDevice:
        # 初始化硬件连接
    @property
    @topic_config()  # 必须添加 @topic_config 才会广播
    def status(self) -> str:
-        """设备状态（通过 @topic_config 广播）"""
+        """设备状态（会自动广播）"""
        return self._status
    def my_action(self, param: float) -> Dict[str, Any]:
@@ -227,61 +217,34 @@ class MyDevice:
 ## 状态属性 vs 动作方法
-### 状态属性（@property + @topic_config）
+### 状态属性（@property）
-状态属性需要同时使用 `@property` 和 `@topic_config` 装饰器才会被识别并定期广播：
+状态属性会被自动识别并定期广播：
 ```python
 from unilabos.registry.decorators import topic_config
@property
@topic_config()  # 必须添加，否则不会广播
 def temperature(self) -> float:
    """当前温度"""
    return self._read_temperature()
@property
@topic_config(period=2.0)  # 可自定义发布周期（秒）
 def status(self) -> str:
    """设备状态: idle, running, error"""
    return self._status
@property
@topic_config(name="ready")  # 可自定义发布名称
 def is_ready(self) -> bool:
    """设备是否就绪"""
    return self._status == "idle"
 ```
 也可以使用普通方法（非 @property）配合 `@topic_config`：
 ```python
@topic_config(period=10.0)
 def get_sensor_data(self) -> Dict[str, float]:
    """获取传感器数据（get_ 前缀会自动去除，发布名为 sensor_data）"""
    return {"temp": self._temp, "humidity": self._humidity}
 ```
 **`@topic_config` 参数**:
 | 参数 | 类型 | 默认值 | 说明 |
 |------|------|--------|------|
 | `period` | float | 5.0 | 发布周期（秒） |
 | `print_publish` | bool | 节点默认 | 是否打印发布日志 |
 | `qos` | int | 10 | QoS 深度 |
 | `name` | str | None | 自定义发布名称 |
 **发布名称优先级**：`@topic_config(name=...)` > `get_` 前缀去除 > 方法名
 **特点**:
- 必须使用 `@topic_config` 装饰器
+- 使用`@property`装饰器
- 支持 `@property` 和普通方法
+- 只读，不能有参数
- 添加到注册表的 `status_types`
+- 自动添加到注册表的`status_types`
 - 定期发布到 ROS2 topic
 > **⚠️ 重要：** 仅有 `@property` 装饰器而没有 `@topic_config` 的属性**不会**被广播。这是一个 Breaking Change。
 ### 动作方法
 动作方法是设备可以执行的操作：
@@ -534,7 +497,6 @@ class LiquidHandler:
        self._status = "idle"
    @property
    @topic_config()
    def status(self) -> str:
        return self._status
@@ -924,52 +886,7 @@ class MyDevice:
 ## 最佳实践
-### 1. 使用 `@device` 装饰器标识设备类
+### 1. 类型注解
 ```python
 from unilabos.registry.decorators import device
@device(id="my_device", category=["heating"], description="My Heating Device", icon="heater.webp")
 class MyDevice:
    ...
 ```
 - `id`：设备唯一标识符，用于注册表匹配
 - `category`：分类列表，前端用于分组显示
 - `description`：设备描述
 - `icon`：图标文件名（可选）
 ### 2. 使用 `@topic_config` 声明需要广播的状态
 ```python
 from unilabos.registry.decorators import topic_config
 # ✓ @property + @topic_config → 会广播
@property
@topic_config(period=2.0)
 def temperature(self) -> float:
    return self._temp
 # ✓ 普通方法 + @topic_config → 会广播（get_ 前缀自动去除）
@topic_config(period=10.0)
 def get_sensor_data(self) -> Dict[str, float]:
    return {"temp": self._temp}
 # ✓ 使用 name 参数自定义发布名称
@property
@topic_config(name="ready")
 def is_ready(self) -> bool:
    return self._status == "idle"
 # ✗ 仅有 @property，没有 @topic_config → 不会广播
@property
 def internal_state(self) -> str:
    return self._state
 ```
 > **注意：** 与 `@property` 连用时，`@topic_config` 必须放在 `@property` 下面。
 ### 3. 类型注解
 ```python
 from typing import Dict, Any, Optional, List
@@ -984,7 +901,7 @@ def method(
    pass
 ```
-### 4. 文档字符串
+### 2. 文档字符串
 ```python
 def method(self, param: float) -> Dict[str, Any]:
@@ -1006,7 +923,7 @@ def method(self, param: float) -> Dict[str, Any]:
    pass
 ```
-### 5. 配置验证
+### 3. 配置验证
 ```python
 def __init__(self, config: Dict[str, Any]):
@@ -1020,7 +937,7 @@ def __init__(self, config: Dict[str, Any]):
    self.baudrate = config['baudrate']
 ```
-### 6. 资源清理
+### 4. 资源清理
 ```python
 def __del__(self):
@@ -1029,7 +946,7 @@ def __del__(self):
        self.connection.close()
 ```
-### 7. 设计前端友好的返回值
+### 5. 设计前端友好的返回值
 **记住：返回值会直接显示在 Web 界面**
--- a/docs/developer_guide/add_registry.md
+++ b/docs/developer_guide/add_registry.md
@@ -422,20 +422,18 @@ placeholder_keys:
 ### status_types
-系统会扫描你的 Python 类，从带有 `@topic_config` 装饰器的 `@property` 或方法自动生成这部分：
+系统会扫描你的 Python 类，从状态方法（property 或 get\_方法）自动生成这部分：
 ```yaml
 status_types:
-  current_temperature: float # 从 @topic_config 装饰的 @property 或方法
+  current_temperature: float # 从 get_current_temperature() 或 @property current_temperature
-  is_heating: bool
+  is_heating: bool # 从 get_is_heating() 或 @property is_heating
-  status: str
+  status: str # 从 get_status() 或 @property status
 ```
 **注意事项**：
- 仅有带 `@topic_config` 装饰器的 `@property` 或方法才会被识别为状态属性
+- 系统会查找所有 `get_` 开头的方法和 `@property` 装饰的属性
 - 没有 `@topic_config` 的 `@property` 不会生成 status_types，也不会广播
 - `get_` 前缀的方法名会自动去除前缀（如 `get_temperature` → `temperature`）
 - 类型会自动转成相应的类型（如 `str`、`float`、`bool`）
 - 如果类型是 `Any`、`None` 或未知的，默认使用 `String`
@@ -539,13 +537,11 @@ class AdvancedLiquidHandler:
        self._temperature = 25.0
    @property
    @topic_config()
    def status(self) -> str:
        """设备状态"""
        return self._status
    @property
    @topic_config()
    def temperature(self) -> float:
        """当前温度"""
        return self._temperature
@@ -813,23 +809,21 @@ my_temperature_controller:
 你的设备类需要符合以下要求：
 ```python
-from unilabos.registry.decorators import device, topic_config
+from unilabos.common.device_base import DeviceBase
-@device(id="my_device", category=["temperature"], description="My Device")
+class MyDevice(DeviceBase):
 class MyDevice:
    def __init__(self, config):
        """初始化，参数会自动分析到 init_param_schema.config"""
        super().__init__(config)
        self.port = config.get('port', '/dev/ttyUSB0')
-    # 状态方法（必须添加 @topic_config 才会生成到 status_types 并广播）
+    # 状态方法（会自动生成到 status_types）
    @property
    @topic_config()
    def status(self):
        """返回设备状态"""
        return "idle"
    @property
    @topic_config()
    def temperature(self):
        """返回当前温度"""
        return 25.0
@@ -1045,34 +1039,7 @@ resource.type      # "resource"
 ### 代码规范
-1. **使用 `@device` 装饰器标识设备类**
+1. **始终使用类型注解**
 ```python
 from unilabos.registry.decorators import device
@device(id="my_device", category=["heating"], description="My Device")
 class MyDevice:
    ...
 ```
 2. **使用 `@topic_config` 声明广播属性**
 ```python
 from unilabos.registry.decorators import topic_config
 # ✓ 需要广播的状态属性
@property
@topic_config(period=2.0)
 def temperature(self) -> float:
    return self._temp
 # ✗ 仅有 @property 不会广播
@property
 def internal_counter(self) -> int:
    return self._counter
 ```
 3. **始终使用类型注解**
 ```python
 # ✓ 好
@@ -1084,7 +1051,7 @@ def method(self, resource, device):
    pass
 ```
-4. **提供有意义的参数名**
+2. **提供有意义的参数名**
 ```python
 # ✓ 好 - 清晰的参数名
@@ -1096,7 +1063,7 @@ def transfer(self, r1: ResourceSlot, r2: ResourceSlot):
    pass
 ```
-5. **使用 Optional 表示可选参数**
+3. **使用 Optional 表示可选参数**
 ```python
 from typing import Optional
@@ -1109,7 +1076,7 @@ def method(
    pass
 ```
-6. **添加详细的文档字符串**
+4. **添加详细的文档字符串**
 ```python
 def method(
@@ -1129,13 +1096,13 @@ def method(
    pass
 ```
-7. **方法命名规范**
+5. **方法命名规范**
-   - 状态方法使用 `@property` + `@topic_config` 装饰器，或普通方法 + `@topic_config`
+   - 状态方法使用 `@property` 装饰器或 `get_` 前缀
   - 动作方法使用动词开头
   - 保持命名清晰、一致
-8. **完善的错误处理**
+6. **完善的错误处理**
   - 实现完善的错误处理
   - 添加日志记录
   - 提供有意义的错误信息
--- a/docs/developer_guide/networking_overview.md
+++ b/docs/developer_guide/networking_overview.md
@@ -23,7 +23,7 @@ Uni-Lab-OS 支持多种部署模式：
 ```
 ┌──────────────────────────────────────────────┐
 │      Cloud Platform/Self-hosted Platform     │
-│           leap-lab.bohrium.com                │
+│           uni-lab.bohrium.com                │
 │  (Resource Management, Task Scheduling,      │
 │              Monitoring)                     │
 └────────────────────┬─────────────────────────┘
@@ -221,10 +221,10 @@ Laboratory A    Laboratory B
 ```bash
 # 实验室A
-unilab --ak your_ak --sk your_sk --upload_registry
+unilab --ak your_ak --sk your_sk --upload_registry --use_remote_resource
 # 实验室B
-unilab --ak your_ak --sk your_sk --upload_registry
+unilab --ak your_ak --sk your_sk --upload_registry --use_remote_resource
 ```
 ---
@@ -444,7 +444,7 @@ ros2 daemon stop && ros2 daemon start
 ```bash
 # 测试云端连接
-curl https://leap-lab.bohrium.com/api/v1/health
+curl https://uni-lab.bohrium.com/api/v1/health
 # 测试WebSocket
 # 启动Uni-Lab后查看日志
--- a/docs/requirements.txt
+++ b/docs/requirements.txt
@@ -12,7 +12,3 @@ sphinx-copybutton>=0.5.0
 # 用于自动摘要生成
 sphinx-autobuild>=2024.2.4
 # 用于PDF导出 (rinohtype方案，纯Python无需LaTeX)
 rinohtype>=0.5.4
 sphinx-simplepdf>=1.6.0
--- a/docs/user_guide/best_practice.md
+++ b/docs/user_guide/best_practice.md
@@ -31,14 +31,6 @@
 详细的安装步骤请参考 [安装指南](installation.md)。
 **选择合适的安装包：**
 | 安装包          | 适用场景                     | 包含组件                                      |
 | --------------- | ---------------------------- | --------------------------------------------- |
 | `unilabos`      | **推荐大多数用户**，生产部署 | 完整安装包，开箱即用                          |
 | `unilabos-env`  | 开发者（可编辑安装）         | 仅环境依赖，通过 pip 安装 unilabos            |
 | `unilabos-full` | 仿真/可视化                  | unilabos + 完整 ROS2 桌面版 + Gazebo + MoveIt |
 **关键步骤：**
 ```bash
@@ -46,31 +38,15 @@
 # 下载 Miniforge: https://github.com/conda-forge/miniforge/releases
 # 2. 创建 Conda 环境
-mamba create -n unilab python=3.11.14
+mamba create -n unilab python=3.11.11
 # 3. 激活环境
 mamba activate unilab
-# 4. 安装 Uni-Lab-OS（选择其一）
+# 4. 安装 Uni-Lab-OS
 # 方案 A：标准安装（推荐大多数用户）
 mamba install uni-lab::unilabos -c robostack-staging -c conda-forge
 # 方案 B：开发者环境（可编辑模式开发）
 mamba install uni-lab::unilabos-env -c robostack-staging -c conda-forge
 pip install -e /path/to/Uni-Lab-OS  # 可编辑安装
 uv pip install -r unilabos/utils/requirements.txt  # 安装 pip 依赖
 # 方案 C：完整版（仿真/可视化）
 mamba install uni-lab::unilabos-full -c robostack-staging -c conda-forge
 ```
 **选择建议：**
 - **日常使用/生产部署**：使用 `unilabos`（推荐），完整功能，开箱即用
 - **开发者**：使用 `unilabos-env` + `pip install -e .` + `uv pip install -r unilabos/utils/requirements.txt`，代码修改立即生效
 - **仿真/可视化**：使用 `unilabos-full`，含 Gazebo、rviz2、MoveIt
 #### 1.2 验证安装
 ```bash
@@ -89,7 +65,7 @@ python -c "from unilabos_msgs.msg import Resource; print('ROS msgs OK')"
 #### 2.1 注册实验室账号
-1. 访问 [https://leap-lab.bohrium.com](https://leap-lab.bohrium.com)
+1. 访问 [https://uni-lab.bohrium.com](https://uni-lab.bohrium.com)
 2. 注册账号并登录
 3. 创建新实验室
@@ -298,7 +274,7 @@ unilab --ak your_ak --sk your_sk -g test/experiments/mock_devices/mock_all.json
 #### 5.2 访问 Web 界面
-启动系统后，访问[https://leap-lab.bohrium.com](https://leap-lab.bohrium.com)
+启动系统后，访问[https://uni-lab.bohrium.com](https://uni-lab.bohrium.com)
 #### 5.3 添加设备和物料
@@ -307,10 +283,12 @@ unilab --ak your_ak --sk your_sk -g test/experiments/mock_devices/mock_all.json
 **示例场景：** 创建一个简单的液体转移实验
 1. **添加工作站（必需）：**
   - 在"仪器设备"中找到 `work_station`
   - 添加 `workstation` x1
 2. **添加虚拟转移泵：**
   - 在"仪器设备"中找到 `virtual_device`
   - 添加 `virtual_transfer_pump` x1
@@ -438,9 +416,6 @@ unilab --ak your_ak --sk your_sk -g test/experiments/mock_devices/mock_all.json
 1. 访问 Web 界面，进入"仪器耗材"模块
 2. 在"仪器设备"区域找到并添加上述设备
 3. 在"物料耗材"区域找到并添加容器
 4. 在workstation中配置protocol_type包含PumpTransferProtocol
 ![添加Protocol类型](image/add_protocol.png)
 ![物料列表](image/material.png)
@@ -451,9 +426,8 @@ unilab --ak your_ak --sk your_sk -g test/experiments/mock_devices/mock_all.json
 **操作步骤：**
 1. 将两个 `container` 拖拽到 `workstation` 中
-2. 将 `virtual_multiway_valve` 拖拽到 `workstation` 中
+2. 将 `virtual_transfer_pump` 拖拽到 `workstation` 中
-3. 将 `virtual_transfer_pump` 拖拽到 `workstation` 中
+3. 在画布上连接它们（建立父子关系）
 4. 在画布上连接它们（建立父子关系）
 ![设备连接](image/links.png)
@@ -794,44 +768,7 @@ Waiting for host service...
 详细的设备驱动编写指南请参考 [添加设备驱动](../developer_guide/add_device.md)。
-#### 9.1 开发环境准备
+#### 9.1 为什么需要自定义设备？
 **推荐使用 `unilabos-env` + `pip install -e .` + `uv pip install`** 进行设备开发：
 ```bash
 # 1. 创建环境并安装 unilabos-env（ROS2 + conda 依赖 + uv）
 mamba create -n unilab python=3.11.14
 conda activate unilab
 mamba install uni-lab::unilabos-env -c robostack-staging -c conda-forge
 # 2. 克隆代码
 git clone https://github.com/deepmodeling/Uni-Lab-OS.git
 cd Uni-Lab-OS
 # 3. 以可编辑模式安装（推荐使用脚本，自动检测中文环境）
 python scripts/dev_install.py
 # 或手动安装：
 pip install -e .
 uv pip install -r unilabos/utils/requirements.txt
 ```
 **为什么使用这种方式？**
 - `unilabos-env` 提供 ROS2 核心组件和 uv（通过 conda 安装，避免编译）
 - `unilabos/utils/requirements.txt` 包含所有运行时需要的 pip 依赖
 - `dev_install.py` 自动检测中文环境，中文系统自动使用清华镜像
 - 使用 `uv` 替代 `pip`，安装速度更快
 - 可编辑模式：代码修改**立即生效**，无需重新安装
 **如果安装失败或速度太慢**，可以手动执行（使用清华镜像）：
 ```bash
 pip install -e . -i https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple
 uv pip install -r unilabos/utils/requirements.txt -i https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple
 ```
 #### 9.2 为什么需要自定义设备？
 Uni-Lab-OS 内置了常见设备，但您的实验室可能有特殊设备需要集成：
@@ -840,7 +777,7 @@ Uni-Lab-OS 内置了常见设备，但您的实验室可能有特殊设备需要
 - 特殊的实验流程
 - 第三方设备集成
-#### 9.3 创建 Python 包
+#### 9.2 创建 Python 包
 为了方便开发和管理，建议为您的实验室创建独立的 Python 包。
@@ -877,7 +814,7 @@ touch my_lab_devices/my_lab_devices/__init__.py
 touch my_lab_devices/my_lab_devices/devices/__init__.py
 ```
-#### 9.4 创建 setup.py
+#### 9.3 创建 setup.py
 ```python
 # my_lab_devices/setup.py
@@ -908,7 +845,7 @@ setup(
 )
 ```
-#### 9.5 开发安装
+#### 9.4 开发安装
 使用 `-e` 参数进行可编辑安装，这样代码修改后立即生效：
@@ -923,7 +860,7 @@ pip install -e . -i https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple
 - 方便调试和测试
 - 支持版本控制（git）
-#### 9.6 编写设备驱动
+#### 9.5 编写设备驱动
 创建设备驱动文件：
@@ -1064,7 +1001,7 @@ class MyPump:
 - **返回 Dict**：所有动作方法返回字典类型
 - **文档字符串**：详细说明参数和功能
-#### 9.7 测试设备驱动
+#### 9.6 测试设备驱动
 创建简单的测试脚本：
@@ -1796,27 +1733,32 @@ unilab --ak your_ak --sk your_sk -g graph.json \
 **详细步骤：**
 1. **需求分析**：
   - 明确实验流程
   - 列出所需设备和物料
   - 设计工作流程图
 2. **环境搭建**：
   - 安装 Uni-Lab-OS
   - 创建实验室账号
   - 准备开发工具（IDE、Git）
 3. **原型验证**：
   - 使用虚拟设备测试流程
   - 验证工作流逻辑
   - 调整参数
 4. **迭代开发**：
   - 实现自定义设备驱动（同时撰写单点函数测试）
   - 编写注册表
   - 单元测试
   - 集成测试
 5. **测试部署**：
   - 连接真实硬件
   - 空跑测试
   - 小规模试验
@@ -1866,7 +1808,7 @@ unilab --ak your_ak --sk your_sk -g graph.json \
 #### 14.5 社区支持
 - **GitHub Issues**：[https://github.com/deepmodeling/Uni-Lab-OS/issues](https://github.com/deepmodeling/Uni-Lab-OS/issues)
- **官方网站**：[https://leap-lab.bohrium.com](https://leap-lab.bohrium.com)
+- **官方网站**：[https://uni-lab.bohrium.com](https://uni-lab.bohrium.com)
 ---
--- a/docs/user_guide/graph_files.md
+++ b/docs/user_guide/graph_files.md
@@ -463,7 +463,7 @@ Uni-Lab 使用 `ResourceDictInstance.get_resource_instance_from_dict()` 方法
 ### 使用示例
 ```python
-from unilabos.resources.resource_tracker import ResourceDictInstance
+from unilabos.ros.nodes.resource_tracker import ResourceDictInstance
 # 旧格式节点
 old_format_node = {
@@ -626,7 +626,7 @@ unilab
 **云端图文件管理**:
-1. 登录 https://leap-lab.bohrium.com
+1. 登录 https://uni-lab.bohrium.com
 2. 进入"设备配置"
 3. 创建或编辑配置
 4. 保存到云端
--- a/docs/user_guide/image/add_protocol.png
+++ b/docs/user_guide/image/add_protocol.png
--- a/docs/user_guide/image/links.png
+++ b/docs/user_guide/image/links.png
--- a/docs/user_guide/installation.md
+++ b/docs/user_guide/installation.md
@@ -13,26 +13,15 @@
  - 开发者需要 Git 和基本的 Python 开发知识
  - 自定义 msgs 需要 GitHub 账号
 ## 安装包选择
 Uni-Lab-OS 提供三个安装包版本，根据您的需求选择：
 | 安装包 | 适用场景 | 包含组件 | 磁盘占用 |
 |--------|----------|----------|----------|
 | **unilabos** | **推荐大多数用户**，生产部署 | 完整安装包，开箱即用 | ~2-3 GB |
 | **unilabos-env** | 开发者环境（可编辑安装） | 仅环境依赖，通过 pip 安装 unilabos | ~2 GB |
 | **unilabos-full** | 仿真可视化、完整功能体验 | unilabos + 完整 ROS2 桌面版 + Gazebo + MoveIt | ~8-10 GB |
 ## 安装方式选择
 根据您的使用场景，选择合适的安装方式：
-| 安装方式               | 适用人群             | 推荐安装包        | 特点                           | 安装时间                     |
+| 安装方式               | 适用人群             | 特点                           | 安装时间                     |
-| ---------------------- | -------------------- | ----------------- | ------------------------------ | ---------------------------- |
+| ---------------------- | -------------------- | ------------------------------ | ---------------------------- |
-| **方式一：一键安装**   | 快速体验、演示       | 预打包环境        | 离线可用，无需配置             | 5-10 分钟 (网络良好的情况下) |
+| **方式一：一键安装**   | 实验室用户、快速体验 | 预打包环境，离线可用，无需配置 | 5-10 分钟 (网络良好的情况下) |
-| **方式二：手动安装**   | **大多数用户**       | `unilabos`        | 完整功能，开箱即用             | 10-20 分钟                   |
+| **方式二：手动安装**   | 标准用户、生产环境   | 灵活配置，版本可控             | 10-20 分钟                   |
-| **方式三：开发者安装** | 开发者、需要修改源码 | `unilabos-env`    | 可编辑模式，支持自定义开发     | 20-30 分钟                   |
+| **方式三：开发者安装** | 开发者、需要修改源码 | 可编辑模式，支持自定义 msgs    | 20-30 分钟                   |
 | **仿真/可视化**        | 仿真测试、可视化调试 | `unilabos-full`   | 含 Gazebo、rviz2、MoveIt       | 30-60 分钟                   |
 ---
@@ -155,38 +144,17 @@ bash Miniforge3-$(uname)-$(uname -m).sh
 使用以下命令创建 Uni-Lab 专用环境：
 ```bash
-mamba create -n unilab python=3.11.14  # 目前ros2组件依赖版本大多为3.11.14
+mamba create -n unilab python=3.11.11  # 目前ros2组件依赖版本大多为3.11.11
 mamba activate unilab
-
+mamba install -n unilab uni-lab::unilabos -c robostack-staging -c conda-forge
 # 选择安装包（三选一）：
 # 方案 A：标准安装（推荐大多数用户）
 mamba install uni-lab::unilabos -c robostack-staging -c conda-forge
 # 方案 B：开发者环境（可编辑模式开发）
 mamba install uni-lab::unilabos-env -c robostack-staging -c conda-forge
 # 然后安装 unilabos 和 pip 依赖：
 git clone https://github.com/deepmodeling/Uni-Lab-OS.git && cd Uni-Lab-OS
 pip install -e .
 uv pip install -r unilabos/utils/requirements.txt
 # 方案 C：完整版（含仿真和可视化工具）
 mamba install uni-lab::unilabos-full -c robostack-staging -c conda-forge
 ```
 **参数说明**:
 - `-n unilab`: 创建名为 "unilab" 的环境
- `uni-lab::unilabos`: 安装 unilabos 完整包，开箱即用（推荐）
+- `uni-lab::unilabos`: 从 uni-lab channel 安装 unilabos 包
 - `uni-lab::unilabos-env`: 仅安装环境依赖，适合开发者使用 `pip install -e .`
 - `uni-lab::unilabos-full`: 安装完整包（含 ROS2 Desktop、Gazebo、MoveIt 等）
 - `-c robostack-staging -c conda-forge`: 添加额外的软件源
 **包选择建议**：
 - **日常使用/生产部署**：安装 `unilabos`（推荐，完整功能，开箱即用）
 - **开发者**：安装 `unilabos-env`，然后使用 `uv pip install -r unilabos/utils/requirements.txt` 安装依赖，再 `pip install -e .` 进行可编辑安装
 - **仿真/可视化**：安装 `unilabos-full`（Gazebo、rviz2、MoveIt）
 **如果遇到网络问题**，可以使用清华镜像源加速下载：
 ```bash
@@ -195,14 +163,8 @@ mamba config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/m
 mamba config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
 mamba config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge/
-# 然后重新执行安装命令（推荐标准安装）
+# 然后重新执行安装命令
 mamba create -n unilab uni-lab::unilabos -c robostack-staging
 # 或完整版（仿真/可视化）
 mamba create -n unilab uni-lab::unilabos-full -c robostack-staging
 # pip 安装时使用清华镜像（开发者安装时使用）
 uv pip install -r unilabos/utils/requirements.txt -i https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple
 ```
 ### 第三步：激活环境
@@ -241,87 +203,58 @@ cd Uni-Lab-OS
   cd Uni-Lab-OS
   ```
-### 第二步：安装开发环境（unilabos-env）
+### 第二步：安装基础环境
-**重要**：开发者请使用 `unilabos-env` 包，它专为开发者设计：
+**推荐方式**：先通过**方式一（一键安装）**或**方式二（手动安装）**完成基础环境的安装，这将包含所有必需的依赖项（ROS2、msgs 等）。
- 包含 ROS2 核心组件和消息包（ros-humble-ros-core、std-msgs、geometry-msgs 等）
+
- 包含 transforms3d、cv-bridge、tf2 等 conda 依赖
+#### 选项 A：通过一键安装（推荐）
- 包含 `uv` 工具，用于快速安装 pip 依赖
+
- **不包含** pip 依赖和 unilabos 包（由 `pip install -e .` 和 `uv pip install` 安装）
+参考上文"方式一：一键安装"，完成基础环境的安装后，激活环境：
 ```bash
 # 创建并激活环境
 mamba create -n unilab python=3.11.14
 conda activate unilab
 # 安装开发者环境包（ROS2 + conda 依赖 + uv）
 mamba install uni-lab::unilabos-env -c robostack-staging -c conda-forge
 ```
-### 第三步：安装 pip 依赖和可编辑模式安装
+#### 选项 B：通过手动安装
-克隆代码并安装依赖：
+参考上文"方式二：手动安装"，创建并安装环境：
 ```bash
 mamba create -n unilab python=3.11.11
 conda activate unilab
 mamba install -n unilab uni-lab::unilabos -c robostack-staging -c conda-forge
 ```
 **说明**：这会安装包括 Python 3.11.11、ROS2 Humble、ros-humble-unilabos-msgs 和所有必需依赖
 ### 第三步：切换到开发版本
 现在你已经有了一个完整可用的 Uni-Lab 环境，接下来将 unilabos 包切换为开发版本：
 ```bash
 # 确保环境已激活
 conda activate unilab
-# 克隆仓库（如果还未克隆）
+# 卸载 pip 安装的 unilabos（保留所有 conda 依赖）
-git clone https://github.com/deepmodeling/Uni-Lab-OS.git
+pip uninstall unilabos -y
 cd Uni-Lab-OS
-# 切换到 dev 分支（可选）
+# 克隆 dev 分支（如果还未克隆）
 cd /path/to/your/workspace
 git clone -b dev https://github.com/deepmodeling/Uni-Lab-OS.git
 # 或者如果已经克隆，切换到 dev 分支
 cd Uni-Lab-OS
 git checkout dev
 git pull
 ```
-**推荐：使用安装脚本**（自动检测中文环境，使用 uv 加速）：
+# 以可编辑模式安装开发版 unilabos
 ```bash
 # 自动检测中文环境，如果是中文系统则使用清华镜像
 python scripts/dev_install.py
 # 或者手动指定：
 python scripts/dev_install.py --china     # 强制使用清华镜像
 python scripts/dev_install.py --no-mirror # 强制使用 PyPI
 python scripts/dev_install.py --skip-deps # 跳过 pip 依赖安装
 python scripts/dev_install.py --use-pip   # 使用 pip 而非 uv
 ```
 **手动安装**（如果脚本安装失败或速度太慢）：
 ```bash
 # 1. 安装 unilabos（可编辑模式）
 pip install -e .
 # 2. 使用 uv 安装 pip 依赖（推荐，速度更快）
 uv pip install -r unilabos/utils/requirements.txt
 # 国内用户使用清华镜像：
 pip install -e . -i https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple
 uv pip install -r unilabos/utils/requirements.txt -i https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple
 ```
-**注意**：
+**参数说明**：
 - `uv` 已包含在 `unilabos-env` 中，无需单独安装
 - `unilabos/utils/requirements.txt` 包含运行 unilabos 所需的所有 pip 依赖
 - 部分特殊包（如 pylabrobot）会在运行时由 unilabos 自动检测并安装
-**为什么使用可编辑模式？**
+- `-e`: editable mode（可编辑模式），代码修改立即生效，无需重新安装
-
+- `-i`: 使用清华镜像源加速下载
- `-e` (editable mode)：代码修改**立即生效**，无需重新安装
+- `pip uninstall unilabos`: 只卸载 pip 安装的 unilabos 包，不影响 conda 安装的其他依赖（如 ROS2、msgs 等）
 - 适合开发调试：修改代码后直接运行测试
 - 与 `unilabos-env` 配合：环境依赖由 conda 管理，unilabos 代码由 pip 管理
 **验证安装**：
 ```bash
 # 检查 unilabos 版本
 python -c "import unilabos; print(unilabos.__version__)"
 # 检查安装位置（应该指向你的代码目录）
 pip show unilabos | grep Location
 ```
 ### 第四步：安装或自定义 ros-humble-unilabos-msgs（可选）
@@ -531,45 +464,7 @@ cd $CONDA_PREFIX/envs/unilab
 ### 问题 8: 环境很大，有办法减小吗？
-**解决方案**: 
+**解决方案**: 预打包的环境包含所有依赖，通常较大（压缩后 2-5GB）。这是为了确保离线安装和完整功能。如果空间有限，考虑使用方式二手动安装，只安装需要的组件。
 1. **使用 `unilabos` 标准版**（推荐大多数用户）：
   ```bash
   mamba install uni-lab::unilabos -c robostack-staging -c conda-forge
   ```
   标准版包含完整功能，环境大小约 2-3GB（相比完整版的 8-10GB）。
 2. **使用 `unilabos-env` 开发者版**（最小化）：
   ```bash
   mamba install uni-lab::unilabos-env -c robostack-staging -c conda-forge
   # 然后手动安装依赖
   pip install -e .
   uv pip install -r unilabos/utils/requirements.txt
   ```
   开发者版只包含环境依赖，体积最小约 2GB。
 3. **按需安装额外组件**：
   如果后续需要特定功能，可以单独安装：
   ```bash
   # 需要 Jupyter
   mamba install jupyter jupyros
   # 需要可视化
   mamba install matplotlib opencv
   # 需要仿真（注意：这会安装大量依赖）
   mamba install ros-humble-gazebo-ros
   ```
 4. **预打包环境问题**：
   预打包环境（方式一）包含所有依赖，通常较大（压缩后 2-5GB）。这是为了确保离线安装和完整功能。
 **包选择建议**：
 | 需求 | 推荐包 | 预估大小 |
 |------|--------|----------|
 | 日常使用/生产部署 | `unilabos` | ~2-3 GB |
 | 开发调试（可编辑模式） | `unilabos-env` | ~2 GB |
 | 仿真/可视化 | `unilabos-full` | ~8-10 GB |
 ### 问题 9: 如何更新到最新版本？
@@ -616,7 +511,6 @@ mamba update ros-humble-unilabos-msgs -c uni-lab -c robostack-staging -c conda-f
 **提示**:
- **大多数用户**推荐使用方式二（手动安装）的 `unilabos` 标准版
+- 生产环境推荐使用方式二（手动安装）的稳定版本
- **开发者**推荐使用方式三（开发者安装），安装 `unilabos-env` 后使用 `uv pip install -r unilabos/utils/requirements.txt` 安装依赖
+- 开发和测试推荐使用方式三（开发者安装）
- **仿真/可视化**推荐安装 `unilabos-full` 完整版
+- 快速体验和演示推荐使用方式一（一键安装）
 - **快速体验和演示**推荐使用方式一（一键安装）
--- a/docs/user_guide/launch.md
+++ b/docs/user_guide/launch.md
@@ -22,6 +22,7 @@ options:
  --is_slave            Run the backend as slave node (without host privileges).
  --slave_no_host       Skip waiting for host service in slave mode
  --upload_registry     Upload registry information when starting unilab
  --use_remote_resource Use remote resources when starting unilab
  --config CONFIG       Configuration file path, supports .py format Python config files
  --port PORT           Port for web service information page
  --disable_browser     Disable opening information page on startup
@@ -54,6 +55,7 @@ Uni-Lab 的启动过程分为以下几个阶段：
 您可以直接跟随 unilabos 的提示进行，无需查阅本节
 - **工作目录设置**：
  - 如果当前目录以 `unilabos_data` 结尾，则使用当前目录
  - 否则使用 `当前目录/unilabos_data` 作为工作目录
  - 可通过 `--working_dir` 指定自定义工作目录
@@ -67,8 +69,8 @@ Uni-Lab 的启动过程分为以下几个阶段：
 支持多种后端环境：
- `--addr test`：测试环境 (`https://leap-lab.test.bohrium.com/api/v1`)
+- `--addr test`：测试环境 (`https://uni-lab.test.bohrium.com/api/v1`)
- `--addr uat`：UAT 环境 (`https://leap-lab.uat.bohrium.com/api/v1`)
+- `--addr uat`：UAT 环境 (`https://uni-lab.uat.bohrium.com/api/v1`)
 - `--addr local`：本地环境 (`http://127.0.0.1:48197/api/v1`)
 - 自定义地址：直接指定完整 URL
@@ -83,7 +85,7 @@ Uni-Lab 的启动过程分为以下几个阶段：
 支持两种方式：
 - **本地文件**：使用 `-g` 指定图谱文件（支持 JSON 和 GraphML 格式）
- **远程资源**：不指定本地文件即可
+- **远程资源**：使用 `--use_remote_resource` 从云端获取
 ### 7. 注册表构建
@@ -175,7 +177,7 @@ unilab --config path/to/your/config.py
 如果是首次使用，系统会：
-1. 提示前往 https://leap-lab.bohrium.com 注册实验室
+1. 提示前往 https://uni-lab.bohrium.com 注册实验室
 2. 引导创建配置文件
 3. 设置工作目录
@@ -194,7 +196,7 @@ unilab --config path/to/your/config.py
 unilab --ak your_ak --sk your_sk -g path/to/graph.json --upload_registry
 # 使用远程资源启动
-unilab --ak your_ak --sk your_sk
+unilab --ak your_ak --sk your_sk --use_remote_resource
 # 更新注册表
 unilab --ak your_ak --sk your_sk --complete_registry
@@ -215,7 +217,7 @@ unilab --ak your_ak --sk your_sk --port 8080 --disable_browser
 如果提示 "后续运行必须拥有一个实验室"，请确保：
- 已在 https://leap-lab.bohrium.com 注册实验室
+- 已在 https://uni-lab.bohrium.com 注册实验室
 - 正确设置了 `--ak` 和 `--sk` 参数
 - 配置文件中包含正确的认证信息
--- a/recipes/msgs/recipe.yaml
+++ b/recipes/msgs/recipe.yaml
@@ -1,6 +1,6 @@
 package:
  name: ros-humble-unilabos-msgs
-  version: 0.10.19
+  version: 0.10.14
 source:
  path: ../../unilabos_msgs
  target_directory: src
@@ -25,7 +25,7 @@ requirements:
  build:
  - ${{ compiler('cxx') }}
  - ${{ compiler('c') }}
-  - python ==3.11.14
+  - python ==3.11.11
  - numpy
  - if: build_platform != target_platform
    then:
@@ -63,14 +63,14 @@ requirements:
  - robostack-staging::ros-humble-rosidl-default-generators
  - robostack-staging::ros-humble-std-msgs
  - robostack-staging::ros-humble-geometry-msgs
-  - robostack-staging::ros2-distro-mutex=0.7
+  - robostack-staging::ros2-distro-mutex=0.6
  run:
  - robostack-staging::ros-humble-action-msgs
  - robostack-staging::ros-humble-ros-workspace
  - robostack-staging::ros-humble-rosidl-default-runtime
  - robostack-staging::ros-humble-std-msgs
  - robostack-staging::ros-humble-geometry-msgs
-  - robostack-staging::ros2-distro-mutex=0.7
+  - robostack-staging::ros2-distro-mutex=0.6
  - if: osx and x86_64
    then:
    - __osx >=${{ MACOSX_DEPLOYMENT_TARGET|default('10.14') }}
--- a/recipes/unilabos/recipe.yaml
+++ b/recipes/unilabos/recipe.yaml
@@ -1,6 +1,6 @@
 package:
  name: unilabos
-  version: "0.10.19"
+  version: "0.10.14"
 source:
  path: ../..
--- a/scripts/create_readme.py
+++ b/scripts/create_readme.py
@@ -85,7 +85,7 @@ Verification:
 -------------
 The verify_installation.py script will check:
-  - Python version (3.11.14)
+  - Python version (3.11.11)
  - ROS2 rclpy installation
  - UniLabOS installation and dependencies
@@ -104,7 +104,7 @@ Build Information:
  Branch:   {branch}
  Platform: {platform}
-  Python:   3.11.14
+  Python:   3.11.11
  Date:     {build_date}
 Troubleshooting:
--- a/scripts/dev_install.py
+++ b/scripts/dev_install.py
@@ -1,214 +0,0 @@
 #!/usr/bin/env python3
 """
 Development installation script for UniLabOS.
 Auto-detects Chinese locale and uses appropriate mirror.
 Usage:
    python scripts/dev_install.py
    python scripts/dev_install.py --no-mirror  # Force no mirror
    python scripts/dev_install.py --china      # Force China mirror
    python scripts/dev_install.py --skip-deps  # Skip pip dependencies installation
 Flow:
    1. pip install -e . (install unilabos in editable mode)
    2. Detect Chinese locale
    3. Use uv to install pip dependencies from requirements.txt
    4. Special packages (like pylabrobot) are handled by environment_check.py at runtime
 """
 import locale
 import subprocess
 import sys
 import argparse
 from pathlib import Path
 # Tsinghua mirror URL
 TSINGHUA_MIRROR = "https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple"
 def is_chinese_locale() -> bool:
    """
    Detect if system is in Chinese locale.
    Same logic as EnvironmentChecker._is_chinese_locale()
    """
    try:
        lang = locale.getdefaultlocale()[0]
        if lang and ("zh" in lang.lower() or "chinese" in lang.lower()):
            return True
    except Exception:
        pass
    return False
 def run_command(cmd: list, description: str, retry: int = 2) -> bool:
    """Run command with retry support."""
    print(f"[INFO] {description}")
    print(f"[CMD] {' '.join(cmd)}")
    for attempt in range(retry + 1):
        try:
            result = subprocess.run(cmd, check=True, timeout=600)
            print(f"[OK] {description}")
            return True
        except subprocess.CalledProcessError as e:
            if attempt < retry:
                print(f"[WARN] Attempt {attempt + 1} failed, retrying...")
            else:
                print(f"[ERROR] {description} failed: {e}")
                return False
        except subprocess.TimeoutExpired:
            print(f"[ERROR] {description} timed out")
            return False
    return False
 def install_editable(project_root: Path, use_mirror: bool) -> bool:
    """Install unilabos in editable mode using pip."""
    cmd = [sys.executable, "-m", "pip", "install", "-e", str(project_root)]
    if use_mirror:
        cmd.extend(["-i", TSINGHUA_MIRROR])
    return run_command(cmd, "Installing unilabos in editable mode")
 def install_requirements_uv(requirements_file: Path, use_mirror: bool) -> bool:
    """Install pip dependencies using uv (installed via conda-forge::uv)."""
    cmd = ["uv", "pip", "install", "-r", str(requirements_file)]
    if use_mirror:
        cmd.extend(["-i", TSINGHUA_MIRROR])
    return run_command(cmd, "Installing pip dependencies with uv", retry=2)
 def install_requirements_pip(requirements_file: Path, use_mirror: bool) -> bool:
    """Fallback: Install pip dependencies using pip."""
    cmd = [sys.executable, "-m", "pip", "install", "-r", str(requirements_file)]
    if use_mirror:
        cmd.extend(["-i", TSINGHUA_MIRROR])
    return run_command(cmd, "Installing pip dependencies with pip", retry=2)
 def check_uv_available() -> bool:
    """Check if uv is available (installed via conda-forge::uv)."""
    try:
        subprocess.run(["uv", "--version"], capture_output=True, check=True)
        return True
    except (subprocess.CalledProcessError, FileNotFoundError):
        return False
 def main():
    parser = argparse.ArgumentParser(description="Development installation script for UniLabOS")
    parser.add_argument("--china", action="store_true", help="Force use China mirror (Tsinghua)")
    parser.add_argument("--no-mirror", action="store_true", help="Force use default PyPI (no mirror)")
    parser.add_argument(
        "--skip-deps", action="store_true", help="Skip pip dependencies installation (only install unilabos)"
    )
    parser.add_argument("--use-pip", action="store_true", help="Use pip instead of uv for dependencies")
    args = parser.parse_args()
    # Determine project root
    script_dir = Path(__file__).parent
    project_root = script_dir.parent
    requirements_file = project_root / "unilabos" / "utils" / "requirements.txt"
    if not (project_root / "setup.py").exists():
        print(f"[ERROR] setup.py not found in {project_root}")
        sys.exit(1)
    print("=" * 60)
    print("UniLabOS Development Installation")
    print("=" * 60)
    print(f"Project root: {project_root}")
    print()
    # Determine mirror usage based on locale
    if args.no_mirror:
        use_mirror = False
        print("[INFO] Mirror disabled by --no-mirror flag")
    elif args.china:
        use_mirror = True
        print("[INFO] China mirror enabled by --china flag")
    else:
        use_mirror = is_chinese_locale()
        if use_mirror:
            print("[INFO] Chinese locale detected, using Tsinghua mirror")
        else:
            print("[INFO] Non-Chinese locale detected, using default PyPI")
    print()
    # Step 1: Install unilabos in editable mode
    print("[STEP 1] Installing unilabos in editable mode...")
    if not install_editable(project_root, use_mirror):
        print("[ERROR] Failed to install unilabos")
        print()
        print("Manual fallback:")
        if use_mirror:
            print(f"  pip install -e {project_root} -i {TSINGHUA_MIRROR}")
        else:
            print(f"  pip install -e {project_root}")
        sys.exit(1)
    print()
    # Step 2: Install pip dependencies
    if args.skip_deps:
        print("[INFO] Skipping pip dependencies installation (--skip-deps)")
    else:
        print("[STEP 2] Installing pip dependencies...")
        if not requirements_file.exists():
            print(f"[WARN] Requirements file not found: {requirements_file}")
            print("[INFO] Skipping dependencies installation")
        else:
            # Try uv first (faster), fallback to pip
            if args.use_pip:
                print("[INFO] Using pip (--use-pip flag)")
                success = install_requirements_pip(requirements_file, use_mirror)
            elif check_uv_available():
                print("[INFO] Using uv (installed via conda-forge::uv)")
                success = install_requirements_uv(requirements_file, use_mirror)
                if not success:
                    print("[WARN] uv failed, falling back to pip...")
                    success = install_requirements_pip(requirements_file, use_mirror)
            else:
                print("[WARN] uv not available (should be installed via: mamba install conda-forge::uv)")
                print("[INFO] Falling back to pip...")
                success = install_requirements_pip(requirements_file, use_mirror)
            if not success:
                print()
                print("[WARN] Failed to install some dependencies automatically.")
                print("You can manually install them:")
                if use_mirror:
                    print(f"  uv pip install -r {requirements_file} -i {TSINGHUA_MIRROR}")
                    print("  or:")
                    print(f"  pip install -r {requirements_file} -i {TSINGHUA_MIRROR}")
                else:
                    print(f"  uv pip install -r {requirements_file}")
                    print("  or:")
                    print(f"  pip install -r {requirements_file}")
    print()
    print("=" * 60)
    print("Installation complete!")
    print("=" * 60)
    print()
    print("Note: Some special packages (like pylabrobot) are installed")
    print("automatically at runtime by unilabos if needed.")
    print()
    print("Verify installation:")
    print('  python -c "import unilabos; print(unilabos.__version__)"')
    print()
    print("If you encounter issues, you can manually install dependencies:")
    if use_mirror:
        print(f"  uv pip install -r unilabos/utils/requirements.txt -i {TSINGHUA_MIRROR}")
    else:
        print("  uv pip install -r unilabos/utils/requirements.txt")
    print()
 if __name__ == "__main__":
    main()
--- a/scripts/workflow.py
+++ b/scripts/workflow.py
@@ -2,6 +2,7 @@ import json
 import logging
 import traceback
 import uuid
 import xml.etree.ElementTree as ET
 from typing import Any, Dict, List
 import networkx as nx
@@ -24,15 +25,7 @@ class SimpleGraph:
    def add_edge(self, source, target, **attrs):
        """添加边"""
-        # edge = {"source": source, "target": target, **attrs}
+        edge = {"source": source, "target": target, **attrs}
        edge = {
            "source": source, "target": target,
            "source_node_uuid": source,
            "target_node_uuid": target,
            "source_handle_io": "source",
            "target_handle_io": "target",
            **attrs
        }
        self.edges.append(edge)
    def to_dict(self):
@@ -49,7 +42,6 @@ class SimpleGraph:
            "multigraph": False,
            "graph": {},
            "nodes": nodes_list,
            "edges": self.edges,
            "links": self.edges,
        }
@@ -66,8 +58,495 @@ def extract_json_from_markdown(text: str) -> str:
    return text
 def convert_to_type(val: str) -> Any:
    """将字符串值转换为适当的数据类型"""
    if val == "True":
        return True
    if val == "False":
        return False
    if val == "?":
        return None
    if val.endswith(" g"):
        return float(val.split(" ")[0])
    if val.endswith("mg"):
        return float(val.split("mg")[0])
    elif val.endswith("mmol"):
        return float(val.split("mmol")[0]) / 1000
    elif val.endswith("mol"):
        return float(val.split("mol")[0])
    elif val.endswith("ml"):
        return float(val.split("ml")[0])
    elif val.endswith("RPM"):
        return float(val.split("RPM")[0])
    elif val.endswith(" °C"):
        return float(val.split(" ")[0])
    elif val.endswith(" %"):
        return float(val.split(" ")[0])
    return val
 def refactor_data(data: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
    """统一的数据重构函数，根据操作类型自动选择模板"""
    refactored_data = []
    # 定义操作映射，包含生物实验和有机化学的所有操作
    OPERATION_MAPPING = {
        # 生物实验操作
        "transfer_liquid": "SynBioFactory-liquid_handler.prcxi-transfer_liquid",
        "transfer": "SynBioFactory-liquid_handler.biomek-transfer",
        "incubation": "SynBioFactory-liquid_handler.biomek-incubation",
        "move_labware": "SynBioFactory-liquid_handler.biomek-move_labware",
        "oscillation": "SynBioFactory-liquid_handler.biomek-oscillation",
        # 有机化学操作
        "HeatChillToTemp": "SynBioFactory-workstation-HeatChillProtocol",
        "StopHeatChill": "SynBioFactory-workstation-HeatChillStopProtocol",
        "StartHeatChill": "SynBioFactory-workstation-HeatChillStartProtocol",
        "HeatChill": "SynBioFactory-workstation-HeatChillProtocol",
        "Dissolve": "SynBioFactory-workstation-DissolveProtocol",
        "Transfer": "SynBioFactory-workstation-TransferProtocol",
        "Evaporate": "SynBioFactory-workstation-EvaporateProtocol",
        "Recrystallize": "SynBioFactory-workstation-RecrystallizeProtocol",
        "Filter": "SynBioFactory-workstation-FilterProtocol",
        "Dry": "SynBioFactory-workstation-DryProtocol",
        "Add": "SynBioFactory-workstation-AddProtocol",
    }
    UNSUPPORTED_OPERATIONS = ["Purge", "Wait", "Stir", "ResetHandling"]
    for step in data:
        operation = step.get("action")
        if not operation or operation in UNSUPPORTED_OPERATIONS:
            continue
        # 处理重复操作
        if operation == "Repeat":
            times = step.get("times", step.get("parameters", {}).get("times", 1))
            sub_steps = step.get("steps", step.get("parameters", {}).get("steps", []))
            for i in range(int(times)):
                sub_data = refactor_data(sub_steps)
                refactored_data.extend(sub_data)
            continue
        # 获取模板名称
        template = OPERATION_MAPPING.get(operation)
        if not template:
            # 自动推断模板类型
            if operation.lower() in ["transfer", "incubation", "move_labware", "oscillation"]:
                template = f"SynBioFactory-liquid_handler.biomek-{operation}"
            else:
                template = f"SynBioFactory-workstation-{operation}Protocol"
        # 创建步骤数据
        step_data = {
            "template": template,
            "description": step.get("description", step.get("purpose", f"{operation} operation")),
            "lab_node_type": "Device",
            "parameters": step.get("parameters", step.get("action_args", {})),
        }
        refactored_data.append(step_data)
    return refactored_data
 def build_protocol_graph(
    labware_info: List[Dict[str, Any]], protocol_steps: List[Dict[str, Any]], workstation_name: str
 ) -> SimpleGraph:
    """统一的协议图构建函数，根据设备类型自动选择构建逻辑"""
    G = SimpleGraph()
    resource_last_writer = {}
    LAB_NAME = "SynBioFactory"
    protocol_steps = refactor_data(protocol_steps)
    # 检查协议步骤中的模板来判断协议类型
    has_biomek_template = any(
        ("biomek" in step.get("template", "")) or ("prcxi" in step.get("template", ""))
        for step in protocol_steps
    )
    if has_biomek_template:
        # 生物实验协议图构建
        for labware_id, labware in labware_info.items():
            node_id = str(uuid.uuid4())
            labware_attrs = labware.copy()
            labware_id = labware_attrs.pop("id", labware_attrs.get("name", f"labware_{uuid.uuid4()}"))
            labware_attrs["description"] = labware_id
            labware_attrs["lab_node_type"] = (
                "Reagent" if "Plate" in str(labware_id) else "Labware" if "Rack" in str(labware_id) else "Sample"
            )
            labware_attrs["device_id"] = workstation_name
            G.add_node(node_id, template=f"{LAB_NAME}-host_node-create_resource", **labware_attrs)
            resource_last_writer[labware_id] = f"{node_id}:labware"
        # 处理协议步骤
        prev_node = None
        for i, step in enumerate(protocol_steps):
            node_id = str(uuid.uuid4())
            G.add_node(node_id, **step)
            # 添加控制流边
            if prev_node is not None:
                G.add_edge(prev_node, node_id, source_port="ready", target_port="ready")
            prev_node = node_id
            # 处理物料流
            params = step.get("parameters", {})
            if "sources" in params and params["sources"] in resource_last_writer:
                source_node, source_port = resource_last_writer[params["sources"]].split(":")
                G.add_edge(source_node, node_id, source_port=source_port, target_port="labware")
            if "targets" in params:
                resource_last_writer[params["targets"]] = f"{node_id}:labware"
        # 添加协议结束节点
        end_id = str(uuid.uuid4())
        G.add_node(end_id, template=f"{LAB_NAME}-liquid_handler.biomek-run_protocol")
        if prev_node is not None:
            G.add_edge(prev_node, end_id, source_port="ready", target_port="ready")
    else:
        # 有机化学协议图构建
        WORKSTATION_ID = workstation_name
        # 为所有labware创建资源节点
        for item_id, item in labware_info.items():
            # item_id = item.get("id") or item.get("name", f"item_{uuid.uuid4()}")
            node_id = str(uuid.uuid4())
            # 判断节点类型
            if item.get("type") == "hardware" or "reactor" in str(item_id).lower():
                if "reactor" not in str(item_id).lower():
                    continue
                lab_node_type = "Sample"
                description = f"Prepare Reactor: {item_id}"
                liquid_type = []
                liquid_volume = []
            else:
                lab_node_type = "Reagent"
                description = f"Add Reagent to Flask: {item_id}"
                liquid_type = [item_id]
                liquid_volume = [1e5]
            G.add_node(
                node_id,
                template=f"{LAB_NAME}-host_node-create_resource",
                description=description,
                lab_node_type=lab_node_type,
                res_id=item_id,
                device_id=WORKSTATION_ID,
                class_name="container",
                parent=WORKSTATION_ID,
                bind_locations={"x": 0.0, "y": 0.0, "z": 0.0},
                liquid_input_slot=[-1],
                liquid_type=liquid_type,
                liquid_volume=liquid_volume,
                slot_on_deck="",
                role=item.get("role", ""),
            )
            resource_last_writer[item_id] = f"{node_id}:labware"
        last_control_node_id = None
        # 处理协议步骤
        for step in protocol_steps:
            node_id = str(uuid.uuid4())
            G.add_node(node_id, **step)
            # 控制流
            if last_control_node_id is not None:
                G.add_edge(last_control_node_id, node_id, source_port="ready", target_port="ready")
            last_control_node_id = node_id
            # 物料流
            params = step.get("parameters", {})
            input_resources = {
                "Vessel": params.get("vessel"),
                "ToVessel": params.get("to_vessel"),
                "FromVessel": params.get("from_vessel"),
                "reagent": params.get("reagent"),
                "solvent": params.get("solvent"),
                "compound": params.get("compound"),
                "sources": params.get("sources"),
                "targets": params.get("targets"),
            }
            for target_port, resource_name in input_resources.items():
                if resource_name and resource_name in resource_last_writer:
                    source_node, source_port = resource_last_writer[resource_name].split(":")
                    G.add_edge(source_node, node_id, source_port=source_port, target_port=target_port)
            output_resources = {
                "VesselOut": params.get("vessel"),
                "FromVesselOut": params.get("from_vessel"),
                "ToVesselOut": params.get("to_vessel"),
                "FiltrateOut": params.get("filtrate_vessel"),
                "reagent": params.get("reagent"),
                "solvent": params.get("solvent"),
                "compound": params.get("compound"),
                "sources_out": params.get("sources"),
                "targets_out": params.get("targets"),
            }
            for source_port, resource_name in output_resources.items():
                if resource_name:
                    resource_last_writer[resource_name] = f"{node_id}:{source_port}"
    return G
 def draw_protocol_graph(protocol_graph: SimpleGraph, output_path: str):
    """
    (辅助功能) 使用 networkx 和 matplotlib 绘制协议工作流图，用于可视化。
    """
    if not protocol_graph:
        print("Cannot draw graph: Graph object is empty.")
        return
    G = nx.DiGraph()
    for node_id, attrs in protocol_graph.nodes.items():
        label = attrs.get("description", attrs.get("template", node_id[:8]))
        G.add_node(node_id, label=label, **attrs)
    for edge in protocol_graph.edges:
        G.add_edge(edge["source"], edge["target"])
    plt.figure(figsize=(20, 15))
    try:
        pos = nx.nx_agraph.graphviz_layout(G, prog="dot")
    except Exception:
        pos = nx.shell_layout(G)  # Fallback layout
    node_labels = {node: data["label"] for node, data in G.nodes(data=True)}
    nx.draw(
        G,
        pos,
        with_labels=False,
        node_size=2500,
        node_color="skyblue",
        node_shape="o",
        edge_color="gray",
        width=1.5,
        arrowsize=15,
    )
    nx.draw_networkx_labels(G, pos, labels=node_labels, font_size=8, font_weight="bold")
    plt.title("Chemical Protocol Workflow Graph", size=15)
    plt.savefig(output_path, dpi=300, bbox_inches="tight")
    plt.close()
    print(f"  - Visualization saved to '{output_path}'")
 from networkx.drawing.nx_agraph import to_agraph
 import re
 COMPASS = {"n","e","s","w","ne","nw","se","sw","c"}
 def _is_compass(port: str) -> bool:
    return isinstance(port, str) and port.lower() in COMPASS
 def draw_protocol_graph_with_ports(protocol_graph, output_path: str, rankdir: str = "LR"):
    """
    使用 Graphviz 端口语法绘制协议工作流图。
    - 若边上的 source_port/target_port 是 compass（n/e/s/w/...），直接用 compass。
    - 否则自动为节点创建 record 形状并定义命名端口 <portname>。
    最终由 PyGraphviz 渲染并输出到 output_path（后缀决定格式，如 .png/.svg/.pdf）。
    """
    if not protocol_graph:
        print("Cannot draw graph: Graph object is empty.")
        return
    # 1) 先用 networkx 搭建有向图，保留端口属性
    G = nx.DiGraph()
    for node_id, attrs in protocol_graph.nodes.items():
        label = attrs.get("description", attrs.get("template", node_id[:8]))
        # 保留一个干净的“中心标签”，用于放在 record 的中间槽
        G.add_node(node_id, _core_label=str(label), **{k:v for k,v in attrs.items() if k not in ("label",)})
    edges_data = []
    in_ports_by_node  = {}  # 收集命名输入端口
    out_ports_by_node = {}  # 收集命名输出端口
    for edge in protocol_graph.edges:
        u = edge["source"]
        v = edge["target"]
        sp = edge.get("source_port")
        tp = edge.get("target_port")
        # 记录到图里（保留原始端口信息）
        G.add_edge(u, v, source_port=sp, target_port=tp)
        edges_data.append((u, v, sp, tp))
        # 如果不是 compass，就按“命名端口”先归类，等会儿给节点造 record
        if sp and not _is_compass(sp):
            out_ports_by_node.setdefault(u, set()).add(str(sp))
        if tp and not _is_compass(tp):
            in_ports_by_node.setdefault(v, set()).add(str(tp))
    # 2) 转为 AGraph，使用 Graphviz 渲染
    A = to_agraph(G)
    A.graph_attr.update(rankdir=rankdir, splines="true", concentrate="false", fontsize="10")
    A.node_attr.update(shape="box", style="rounded,filled", fillcolor="lightyellow", color="#999999", fontname="Helvetica")
    A.edge_attr.update(arrowsize="0.8", color="#666666")
    # 3) 为需要命名端口的节点设置 record 形状与 label
    #    左列 = 输入端口；中间 = 核心标签；右列 = 输出端口
    for n in A.nodes():
        node = A.get_node(n)
        core = G.nodes[n].get("_core_label", n)
        in_ports  = sorted(in_ports_by_node.get(n, []))
        out_ports = sorted(out_ports_by_node.get(n, []))
        # 如果该节点涉及命名端口，则用 record；否则保留原 box
        if in_ports or out_ports:
            def port_fields(ports):
                if not ports:
                    return " "  # 必须留一个空槽占位
                # 每个端口一个小格子，<p> name
                return "|".join(f"<{re.sub(r'[^A-Za-z0-9_:.|-]', '_', p)}> {p}" for p in ports)
            left  = port_fields(in_ports)
            right = port_fields(out_ports)
            # 三栏：左(入) | 中(节点名) | 右(出)
            record_label = f"{{ {left} | {core} | {right} }}"
            node.attr.update(shape="record", label=record_label)
        else:
            # 没有命名端口：普通盒子，显示核心标签
            node.attr.update(label=str(core))
    # 4) 给边设置 headport / tailport
    #    - 若端口为 compass：直接用 compass（e.g., headport="e"）
    #    - 若端口为命名端口：使用在 record 中定义的 <port> 名（同名即可）
    for (u, v, sp, tp) in edges_data:
        e = A.get_edge(u, v)
        # Graphviz 属性：tail 是源，head 是目标
        if sp:
            if _is_compass(sp):
                e.attr["tailport"] = sp.lower()
            else:
                # 与 record label 中 <port> 名一致；特殊字符已在 label 中做了清洗
                e.attr["tailport"] = re.sub(r'[^A-Za-z0-9_:.|-]', '_', str(sp))
        if tp:
            if _is_compass(tp):
                e.attr["headport"] = tp.lower()
            else:
                e.attr["headport"] = re.sub(r'[^A-Za-z0-9_:.|-]', '_', str(tp))
        # 可选：若想让边更贴边缘，可设置 constraint/spline 等
        # e.attr["arrowhead"] = "vee"
    # 5) 输出
    A.draw(output_path, prog="dot")
    print(f"  - Port-aware workflow rendered to '{output_path}'")
 def flatten_xdl_procedure(procedure_elem: ET.Element) -> List[ET.Element]:
    """展平嵌套的XDL程序结构"""
    flattened_operations = []
    TEMP_UNSUPPORTED_PROTOCOL = ["Purge", "Wait", "Stir", "ResetHandling"]
    def extract_operations(element: ET.Element):
        if element.tag not in ["Prep", "Reaction", "Workup", "Purification", "Procedure"]:
            if element.tag not in TEMP_UNSUPPORTED_PROTOCOL:
                flattened_operations.append(element)
        for child in element:
            extract_operations(child)
    for child in procedure_elem:
        extract_operations(child)
    return flattened_operations
 def parse_xdl_content(xdl_content: str) -> tuple:
    """解析XDL内容"""
    try:
        xdl_content_cleaned = "".join(c for c in xdl_content if c.isprintable())
        root = ET.fromstring(xdl_content_cleaned)
        synthesis_elem = root.find("Synthesis")
        if synthesis_elem is None:
            return None, None, None
        # 解析硬件组件
        hardware_elem = synthesis_elem.find("Hardware")
        hardware = []
        if hardware_elem is not None:
            hardware = [{"id": c.get("id"), "type": c.get("type")} for c in hardware_elem.findall("Component")]
        # 解析试剂
        reagents_elem = synthesis_elem.find("Reagents")
        reagents = []
        if reagents_elem is not None:
            reagents = [{"name": r.get("name"), "role": r.get("role", "")} for r in reagents_elem.findall("Reagent")]
        # 解析程序
        procedure_elem = synthesis_elem.find("Procedure")
        if procedure_elem is None:
            return None, None, None
        flattened_operations = flatten_xdl_procedure(procedure_elem)
        return hardware, reagents, flattened_operations
    except ET.ParseError as e:
        raise ValueError(f"Invalid XDL format: {e}")
 def convert_xdl_to_dict(xdl_content: str) -> Dict[str, Any]:
    """
    将XDL XML格式转换为标准的字典格式
    Args:
        xdl_content: XDL XML内容
    Returns:
        转换结果，包含步骤和器材信息
    """
    try:
        hardware, reagents, flattened_operations = parse_xdl_content(xdl_content)
        if hardware is None:
            return {"error": "Failed to parse XDL content", "success": False}
        # 将XDL元素转换为字典格式
        steps_data = []
        for elem in flattened_operations:
            # 转换参数类型
            parameters = {}
            for key, val in elem.attrib.items():
                converted_val = convert_to_type(val)
                if converted_val is not None:
                    parameters[key] = converted_val
            step_dict = {
                "operation": elem.tag,
                "parameters": parameters,
                "description": elem.get("purpose", f"Operation: {elem.tag}"),
            }
            steps_data.append(step_dict)
        # 合并硬件和试剂为统一的labware_info格式
        labware_data = []
        labware_data.extend({"id": hw["id"], "type": "hardware", **hw} for hw in hardware)
        labware_data.extend({"name": reagent["name"], "type": "reagent", **reagent} for reagent in reagents)
        return {
            "success": True,
            "steps": steps_data,
            "labware": labware_data,
            "message": f"Successfully converted XDL to dict format. Found {len(steps_data)} steps and {len(labware_data)} labware items.",
        }
    except Exception as e:
        error_msg = f"XDL conversion failed: {str(e)}"
        logger.error(error_msg)
        return {"error": error_msg, "success": False}
 def create_workflow(
--- a/setup.py
+++ b/setup.py
@@ -4,7 +4,7 @@ package_name = 'unilabos'
 setup(
    name=package_name,
-    version='0.10.19',
+    version='0.10.14',
    packages=find_packages(),
    include_package_data=True,
    install_requires=['setuptools'],
--- a/tests/resources/test_resourcetreeset.py
+++ b/tests/resources/test_resourcetreeset.py
@@ -2,8 +2,9 @@ import pytest
 import json
 import os
 from pylabrobot.resources import Resource as ResourcePLR
 from unilabos.resources.graphio import resource_bioyond_to_plr
-from unilabos.resources.resource_tracker import ResourceTreeSet
+from unilabos.ros.nodes.resource_tracker import ResourceTreeSet
 from unilabos.registry.registry import lab_registry
 from unilabos.resources.bioyond.decks import BIOYOND_PolymerReactionStation_Deck
--- a/tests/workflow/test.json
+++ b/tests/workflow/test.json
@@ -1,213 +0,0 @@
 {
  "workflow": [
    {
      "action": "transfer_liquid",
      "action_args": {
        "sources": "cell_lines",
        "targets": "Liquid_1",
        "asp_vol": 100.0,
        "dis_vol": 74.75,
        "asp_flow_rate": 94.0,
        "dis_flow_rate": 95.5
      }
    },
    {
      "action": "transfer_liquid",
      "action_args": {
        "sources": "cell_lines",
        "targets": "Liquid_2",
        "asp_vol": 100.0,
        "dis_vol": 74.75,
        "asp_flow_rate": 94.0,
        "dis_flow_rate": 95.5
      }
    },
    {
      "action": "transfer_liquid",
      "action_args": {
        "sources": "cell_lines",
        "targets": "Liquid_3",
        "asp_vol": 100.0,
        "dis_vol": 74.75,
        "asp_flow_rate": 94.0,
        "dis_flow_rate": 95.5
      }
    },
    {
      "action": "transfer_liquid",
      "action_args": {
        "sources": "cell_lines_2",
        "targets": "Liquid_4",
        "asp_vol": 100.0,
        "dis_vol": 74.75,
        "asp_flow_rate": 94.0,
        "dis_flow_rate": 95.5
      }
    },
    {
      "action": "transfer_liquid",
      "action_args": {
        "sources": "cell_lines_2",
        "targets": "Liquid_5",
        "asp_vol": 100.0,
        "dis_vol": 74.75,
        "asp_flow_rate": 94.0,
        "dis_flow_rate": 95.5
      }
    },
    {
      "action": "transfer_liquid",
      "action_args": {
        "sources": "cell_lines_2",
        "targets": "Liquid_6",
        "asp_vol": 100.0,
        "dis_vol": 74.75,
        "asp_flow_rate": 94.0,
        "dis_flow_rate": 95.5
      }
    },
    {
      "action": "transfer_liquid",
      "action_args": {
        "sources": "cell_lines_3",
        "targets": "dest_set",
        "asp_vol": 100.0,
        "dis_vol": 74.75,
        "asp_flow_rate": 94.0,
        "dis_flow_rate": 95.5
      }
    },
    {
      "action": "transfer_liquid",
      "action_args": {
        "sources": "cell_lines_3",
        "targets": "dest_set_2",
        "asp_vol": 100.0,
        "dis_vol": 74.75,
        "asp_flow_rate": 94.0,
        "dis_flow_rate": 95.5
      }
    },
    {
      "action": "transfer_liquid",
      "action_args": {
        "sources": "cell_lines_3",
        "targets": "dest_set_3",
        "asp_vol": 100.0,
        "dis_vol": 74.75,
        "asp_flow_rate": 94.0,
        "dis_flow_rate": 95.5
      }
    }
  ],
  "reagent": {
    "Liquid_1": {
      "slot": 1,
      "well": [
        "A4",
        "A7",
        "A10"
      ],
      "labware": "rep 1"
    },
    "Liquid_4": {
      "slot": 1,
      "well": [
        "A4",
        "A7",
        "A10"
      ],
      "labware": "rep 1"
    },
    "dest_set": {
      "slot": 1,
      "well": [
        "A4",
        "A7",
        "A10"
      ],
      "labware": "rep 1"
    },
    "Liquid_2": {
      "slot": 2,
      "well": [
        "A3",
        "A5",
        "A8"
      ],
      "labware": "rep 2"
    },
    "Liquid_5": {
      "slot": 2,
      "well": [
        "A3",
        "A5",
        "A8"
      ],
      "labware": "rep 2"
    },
    "dest_set_2": {
      "slot": 2,
      "well": [
        "A3",
        "A5",
        "A8"
      ],
      "labware": "rep 2"
    },
    "Liquid_3": {
      "slot": 3,
      "well": [
        "A4",
        "A6",
        "A10"
      ],
      "labware": "rep 3"
    },
    "Liquid_6": {
      "slot": 3,
      "well": [
        "A4",
        "A6",
        "A10"
      ],
      "labware": "rep 3"
    },
    "dest_set_3": {
      "slot": 3,
      "well": [
        "A4",
        "A6",
        "A10"
      ],
      "labware": "rep 3"
    },
    "cell_lines": {
      "slot": 4,
      "well": [
        "A1",
        "A3",
        "A5"
      ],
      "labware": "DRUG + YOYO-MEDIA"
    },
    "cell_lines_2": {
      "slot": 4,
      "well": [
        "A1",
        "A3",
        "A5"
      ],
      "labware": "DRUG + YOYO-MEDIA"
    },
    "cell_lines_3": {
      "slot": 4,
      "well": [
        "A1",
        "A3",
        "A5"
      ],
      "labware": "DRUG + YOYO-MEDIA"
    }
  }
 }
--- a/unilabos/init.py
+++ b/unilabos/init.py
@@ -1 +1 @@
-__version__ = "0.10.19"
+__version__ = "0.10.14"
--- a/unilabos/main.py
+++ b/unilabos/main.py
@@ -1,6 +0,0 @@
 """Entry point for `python -m unilabos`."""
 from unilabos.app.main import main
 if __name__ == "__main__":
    main()
--- a/unilabos/app/backend.py
+++ b/unilabos/app/backend.py
@@ -1,6 +1,6 @@
 import threading
-from unilabos.resources.resource_tracker import ResourceTreeSet
+from unilabos.ros.nodes.resource_tracker import ResourceTreeSet
 from unilabos.utils import logger
--- a/unilabos/app/main.py
+++ b/unilabos/app/main.py
@@ -1,14 +1,13 @@
 import argparse
 import asyncio
 import os
 import platform
 import shutil
 import signal
 import subprocess
 import sys
 import threading
 import time
 from typing import Dict, Any, List
 import networkx as nx
 import yaml
@@ -18,93 +17,9 @@ unilabos_dir = os.path.dirname(os.path.dirname(current_dir))
 if unilabos_dir not in sys.path:
    sys.path.append(unilabos_dir)
 from unilabos.app.utils import cleanup_for_restart
 from unilabos.utils.banner_print import print_status, print_unilab_banner
 from unilabos.config.config import load_config, BasicConfig, HTTPConfig
 # Global restart flags (used by ws_client and web/server)
 _restart_requested: bool = False
 _restart_reason: str = ""
 RESTART_EXIT_CODE = 42
 def _build_child_argv():
    """Build sys.argv for child process, stripping supervisor-only arguments."""
    result = []
    skip_next = False
    for arg in sys.argv:
        if skip_next:
            skip_next = False
            continue
        if arg in ("--restart_mode", "--restart-mode"):
            continue
        if arg in ("--auto_restart_count", "--auto-restart-count"):
            skip_next = True
            continue
        if arg.startswith("--auto_restart_count=") or arg.startswith("--auto-restart-count="):
            continue
        result.append(arg)
    return result
 def _run_as_supervisor(max_restarts: int):
    """
    Supervisor process that spawns and monitors child processes.
    Similar to Uvicorn's --reload: the supervisor itself does no heavy work,
    it only launches the real process as a child and restarts it when the child
    exits with RESTART_EXIT_CODE.
    """
    child_argv = [sys.executable] + _build_child_argv()
    restart_count = 0
    print_status(
        f"[Supervisor] Restart mode enabled (max restarts: {max_restarts}), "
        f"child command: {' '.join(child_argv)}",
        "info",
    )
    while True:
        print_status(
            f"[Supervisor] Launching process (restart {restart_count}/{max_restarts})...",
            "info",
        )
        try:
            process = subprocess.Popen(child_argv)
            exit_code = process.wait()
        except KeyboardInterrupt:
            print_status("[Supervisor] Interrupted, terminating child process...", "info")
            process.terminate()
            try:
                process.wait(timeout=10)
            except subprocess.TimeoutExpired:
                process.kill()
                process.wait()
            sys.exit(1)
        if exit_code == RESTART_EXIT_CODE:
            restart_count += 1
            if restart_count > max_restarts:
                print_status(
                    f"[Supervisor] Maximum restart count ({max_restarts}) reached, exiting",
                    "warning",
                )
                sys.exit(1)
            print_status(
                f"[Supervisor] Child requested restart ({restart_count}/{max_restarts}), restarting in 2s...",
                "info",
            )
            time.sleep(2)
        else:
            if exit_code != 0:
                print_status(f"[Supervisor] Child exited with code {exit_code}", "warning")
            else:
                print_status("[Supervisor] Child exited normally", "info")
            sys.exit(exit_code)
 def load_config_from_file(config_path):
    if config_path is None:
        config_path = os.environ.get("UNILABOS_BASICCONFIG_CONFIG_PATH", None)
@@ -134,8 +49,6 @@ def convert_argv_dashes_to_underscores(args: argparse.ArgumentParser):
 def parse_args():
    """解析命令行参数"""
    parser = argparse.ArgumentParser(description="Start Uni-Lab Edge server.")
    subparsers = parser.add_subparsers(title="Valid subcommands", dest="command")
    parser.add_argument("-g", "--graph", help="Physical setup graph file path.")
    parser.add_argument("-c", "--controllers", default=None, help="Controllers config file path.")
    parser.add_argument(
@@ -145,13 +58,6 @@ def parse_args():
        action="append",
        help="Path to the registry directory",
    )
    parser.add_argument(
        "--devices",
        type=str,
        default=None,
        action="append",
        help="Path to Python code directory for AST-based device/resource scanning",
    )
    parser.add_argument(
        "--working_dir",
        type=str,
@@ -233,7 +139,7 @@ def parse_args():
    parser.add_argument(
        "--addr",
        type=str,
-        default="https://leap-lab.bohrium.com/api/v1",
+        default="https://uni-lab.bohrium.com/api/v1",
        help="Laboratory backend address",
    )
    parser.add_argument(
@@ -241,91 +147,11 @@ def parse_args():
        action="store_true",
        help="Skip environment dependency check on startup",
    )
    parser.add_argument(
        "--check_mode",
        action="store_true",
        default=False,
        help="Run in check mode for CI: validates registry imports and ensures no file changes",
    )
    parser.add_argument(
        "--complete_registry",
        action="store_true",
        default=False,
-        help="Complete and rewrite YAML registry files using AST analysis results",
+        help="Complete registry information",
    )
    parser.add_argument(
        "--no_update_feedback",
        action="store_true",
        help="Disable sending update feedback to server",
    )
    parser.add_argument(
        "--test_mode",
        action="store_true",
        default=False,
        help="Test mode: all actions simulate execution and return mock results without running real hardware",
    )
    parser.add_argument(
        "--external_devices_only",
        action="store_true",
        default=False,
        help="Only load external device packages (--devices), skip built-in unilabos/devices/ scanning and YAML device registry",
    )
    parser.add_argument(
        "--extra_resource",
        action="store_true",
        default=False,
        help="Load extra lab_ prefixed labware resources (529 auto-generated definitions from lab_resources.py)",
    )
    parser.add_argument(
        "--restart_mode",
        action="store_true",
        default=False,
        help="Enable supervisor mode: automatically restart the process when triggered via WebSocket",
    )
    parser.add_argument(
        "--auto_restart_count",
        type=int,
        default=500,
        help="Maximum number of automatic restarts in restart mode (default: 500)",
    )
    # workflow upload subcommand
    workflow_parser = subparsers.add_parser(
        "workflow_upload",
        aliases=["wf"],
        help="Upload workflow from xdl/json/python files",
    )
    workflow_parser.add_argument(
        "-f",
        "--workflow_file",
        type=str,
        required=True,
        help="Path to the workflow file (JSON format)",
    )
    workflow_parser.add_argument(
        "-n",
        "--workflow_name",
        type=str,
        default=None,
        help="Workflow name, if not provided will use the name from file or filename",
    )
    workflow_parser.add_argument(
        "--tags",
        type=str,
        nargs="*",
        default=[],
        help="Tags for the workflow (space-separated)",
    )
    workflow_parser.add_argument(
        "--published",
        action="store_true",
        default=False,
        help="Whether to publish the workflow (default: False)",
    )
    workflow_parser.add_argument(
        "--description",
        type=str,
        default="",
        help="Workflow description, used when publishing the workflow",
    )
    return parser
@@ -338,92 +164,54 @@ def main():
    args = parser.parse_args()
    args_dict = vars(args)
    # Supervisor mode: spawn child processes and monitor for restart
    if args_dict.get("restart_mode", False):
        _run_as_supervisor(args_dict.get("auto_restart_count", 5))
        return
    # 环境检查 - 检查并自动安装必需的包 (可选)
-    skip_env_check = args_dict.get("skip_env_check", False)
+    if not args_dict.get("skip_env_check", False):
-    check_mode = args_dict.get("check_mode", False)
+        from unilabos.utils.environment_check import check_environment
    if not skip_env_check:
        from unilabos.utils.environment_check import check_environment, check_device_package_requirements
        print_status("正在进行环境依赖检查...", "info")
        if not check_environment(auto_install=True):
            print_status("环境检查失败，程序退出", "error")
            os._exit(1)
        # 第一次设备包依赖检查：build_registry 之前，确保 import map 可用
        devices_dirs_for_req = args_dict.get("devices", None)
        if devices_dirs_for_req:
            if not check_device_package_requirements(devices_dirs_for_req):
                print_status("设备包依赖检查失败，程序退出", "error")
                os._exit(1)
    else:
        print_status("跳过环境依赖检查", "warning")
    # 加载配置文件，优先加载config，然后从env读取
    config_path = args_dict.get("config")
-
+    if os.getcwd().endswith("unilabos_data"):
    # === 解析 working_dir ===
    # 规则1: working_dir 传入 → 检测 unilabos_data 子目录，已是则不修改
    # 规则2: 仅 config_path 传入 → 用其父目录作为 working_dir
    # 规则4: 两者都传入 → 各用各的，但 working_dir 仍做 unilabos_data 子目录检测
    raw_working_dir = args_dict.get("working_dir")
    if raw_working_dir:
        working_dir = os.path.abspath(raw_working_dir)
    elif config_path and os.path.exists(config_path):
        working_dir = os.path.dirname(os.path.abspath(config_path))
    else:
        working_dir = os.path.abspath(os.getcwd())
-
+    else:
    # unilabos_data 子目录自动检测
    if os.path.basename(working_dir) != "unilabos_data":
        unilabos_data_sub = os.path.join(working_dir, "unilabos_data")
        if os.path.isdir(unilabos_data_sub):
            working_dir = unilabos_data_sub
        elif not raw_working_dir and not (config_path and os.path.exists(config_path)):
            # 未显式指定路径，默认使用 cwd/unilabos_data
        working_dir = os.path.abspath(os.path.join(os.getcwd(), "unilabos_data"))
-    # === 解析 config_path ===
+    if args_dict.get("working_dir"):
        working_dir = args_dict.get("working_dir", "")
        if config_path and not os.path.exists(config_path):
-        # config_path 传入但不存在，尝试在 working_dir 中查找
+            config_path = os.path.join(working_dir, "local_config.py")
-        candidate = os.path.join(working_dir, "local_config.py")
+            if not os.path.exists(config_path):
        if os.path.exists(candidate):
            config_path = candidate
            print_status(f"在工作目录中发现配置文件: {config_path}", "info")
        else:
                print_status(
-                f"配置文件 {config_path} 不存在，工作目录 {working_dir} 中也未找到 local_config.py，"
+                    f"当前工作目录 {working_dir} 未找到local_config.py，请通过 --config 传入 local_config.py 文件路径",
                f"请通过 --config 传入 local_config.py 文件路径",
                    "error",
                )
                os._exit(1)
-    elif not config_path:
+    elif config_path and os.path.exists(config_path):
-        # 规则3: 未传入 config_path，尝试 working_dir/local_config.py
+        working_dir = os.path.dirname(config_path)
-        candidate = os.path.join(working_dir, "local_config.py")
+    elif os.path.exists(working_dir) and os.path.exists(os.path.join(working_dir, "local_config.py")):
-        if os.path.exists(candidate):
+        config_path = os.path.join(working_dir, "local_config.py")
-            config_path = candidate
+    elif not config_path and (
-            print_status(f"发现本地配置文件: {config_path}", "info")
+        not os.path.exists(working_dir) or not os.path.exists(os.path.join(working_dir, "local_config.py"))
-        else:
+    ):
        print_status(f"未指定config路径，可通过 --config 传入 local_config.py 文件路径", "info")
        print_status(f"您是否为第一次使用？并将当前路径 {working_dir} 作为工作目录？ (Y/n)", "info")
-            if check_mode or input() != "n":
+        if input() != "n":
            os.makedirs(working_dir, exist_ok=True)
            config_path = os.path.join(working_dir, "local_config.py")
            shutil.copy(
-                    os.path.join(os.path.dirname(os.path.dirname(__file__)), "config", "example_config.py"),
+                os.path.join(os.path.dirname(os.path.dirname(__file__)), "config", "example_config.py"), config_path
                    config_path,
            )
            print_status(f"已创建 local_config.py 路径： {config_path}", "info")
        else:
            os._exit(1)
-
+    # 加载配置文件
    # 加载配置文件 (check_mode 跳过)
    print_status(f"当前工作目录为 {working_dir}", "info")
    if not check_mode:
    load_config_from_file(config_path)
    # 根据配置重新设置日志级别
@@ -431,17 +219,15 @@ def main():
    if hasattr(BasicConfig, "log_level"):
        logger.info(f"Log level set to '{BasicConfig.log_level}' from config file.")
-    file_path = configure_logger(loglevel=BasicConfig.log_level, working_dir=working_dir)
+    configure_logger(loglevel=BasicConfig.log_level, working_dir=working_dir)
    if file_path is not None:
        logger.info(f"[LOG_FILE] {file_path}")
    if args.addr != parser.get_default("addr"):
        if args.addr == "test":
            print_status("使用测试环境地址", "info")
-            HTTPConfig.remote_addr = "https://leap-lab.test.bohrium.com/api/v1"
+            HTTPConfig.remote_addr = "https://uni-lab.test.bohrium.com/api/v1"
        elif args.addr == "uat":
            print_status("使用uat环境地址", "info")
-            HTTPConfig.remote_addr = "https://leap-lab.uat.bohrium.com/api/v1"
+            HTTPConfig.remote_addr = "https://uni-lab.uat.bohrium.com/api/v1"
        elif args.addr == "local":
            print_status("使用本地环境地址", "info")
            HTTPConfig.remote_addr = "http://127.0.0.1:48197/api/v1"
@@ -455,12 +241,9 @@ def main():
    if args_dict.get("sk", ""):
        BasicConfig.sk = args_dict.get("sk", "")
        print_status("传入了sk参数，优先采用传入参数！", "info")
    BasicConfig.working_dir = working_dir
    workflow_upload = args_dict.get("command") in ("workflow_upload", "wf")
    # 使用远程资源启动
-    if not workflow_upload and args_dict["use_remote_resource"]:
+    if args_dict["use_remote_resource"]:
        print_status("使用远程资源启动", "info")
        from unilabos.app.web import http_client
@@ -473,87 +256,40 @@ def main():
    BasicConfig.port = args_dict["port"] if args_dict["port"] else BasicConfig.port
    BasicConfig.disable_browser = args_dict["disable_browser"] or BasicConfig.disable_browser
    BasicConfig.working_dir = working_dir
    BasicConfig.is_host_mode = not args_dict.get("is_slave", False)
    BasicConfig.slave_no_host = args_dict.get("slave_no_host", False)
    BasicConfig.upload_registry = args_dict.get("upload_registry", False)
    BasicConfig.no_update_feedback = args_dict.get("no_update_feedback", False)
    BasicConfig.test_mode = args_dict.get("test_mode", False)
    if BasicConfig.test_mode:
        print_status("启用测试模式：所有动作将模拟执行，不调用真实硬件", "warning")
    BasicConfig.extra_resource = args_dict.get("extra_resource", False)
    if BasicConfig.extra_resource:
        print_status("启用额外资源加载：将加载lab_开头的labware资源定义", "info")
    BasicConfig.communication_protocol = "websocket"
-    machine_name = platform.node()
+    machine_name = os.popen("hostname").read().strip()
    machine_name = "".join([c if c.isalnum() or c == "_" else "_" for c in machine_name])
    BasicConfig.machine_name = machine_name
    BasicConfig.vis_2d_enable = args_dict["2d_vis"]
    BasicConfig.check_mode = check_mode
    from unilabos.registry.registry import build_registry
    # 显示启动横幅
    print_unilab_banner(args_dict)
    # Step 0: AST 分析优先 + YAML 注册表加载
    # check_mode 和 upload_registry 都会执行实际 import 验证
    devices_dirs = args_dict.get("devices", None)
    complete_registry = args_dict.get("complete_registry", False) or check_mode
    external_only = args_dict.get("external_devices_only", False)
    lab_registry = build_registry(
        registry_paths=args_dict["registry_path"],
        devices_dirs=devices_dirs,
        upload_registry=BasicConfig.upload_registry,
        check_mode=check_mode,
        complete_registry=complete_registry,
        external_only=external_only,
    )
    # Check mode: 注册表验证完成后直接退出
    if check_mode:
        device_count = len(lab_registry.device_type_registry)
        resource_count = len(lab_registry.resource_type_registry)
        print_status(f"Check mode: 注册表验证完成 ({device_count} 设备, {resource_count} 资源)，退出", "info")
        os._exit(0)
    # 以下导入依赖 ROS2 环境，check_mode 已退出不需要
    from unilabos.resources.graphio import (
        read_node_link_json,
        read_graphml,
        dict_from_graph,
        modify_to_backend_format,
    )
    from unilabos.app.communication import get_communication_client
    from unilabos.registry.registry import build_registry
    from unilabos.app.backend import start_backend
    from unilabos.app.web import http_client
    from unilabos.app.web import start_server
    from unilabos.app.register import register_devices_and_resources
-    from unilabos.resources.resource_tracker import ResourceTreeSet, ResourceDict
+    from unilabos.resources.graphio import modify_to_backend_format
    from unilabos.ros.nodes.resource_tracker import ResourceTreeSet, ResourceDict
-    # Step 1: 上传全部注册表到服务端，同步保存到 unilabos_data
+    # 显示启动横幅
-    if BasicConfig.upload_registry:
+    print_unilab_banner(args_dict)
        if BasicConfig.ak and BasicConfig.sk:
            # print_status("开始注册设备到服务端...", "info")
            try:
                register_devices_and_resources(lab_registry)
                # print_status("设备注册完成", "info")
            except Exception as e:
                print_status(f"设备注册失败: {e}", "error")
        else:
            print_status("未提供 ak 和 sk，跳过设备注册", "info")
    else:
        print_status("本次启动注册表不报送云端，如果您需要联网调试，请在启动命令增加--upload_registry", "warning")
-    # 处理 workflow_upload 子命令
+    # 注册表
-    if workflow_upload:
+    lab_registry = build_registry(
-        from unilabos.workflow.wf_utils import handle_workflow_upload_command
+        args_dict["registry_path"], args_dict.get("complete_registry", False), args_dict["upload_registry"]
-
+    )
        handle_workflow_upload_command(args_dict)
        print_status("工作流上传完成，程序退出", "info")
        os._exit(0)
    if not BasicConfig.ak or not BasicConfig.sk:
-        print_status("后续运行必须拥有一个实验室，请前往 https://leap-lab.bohrium.com 注册实验室！", "warning")
+        print_status("后续运行必须拥有一个实验室，请前往 https://uni-lab.bohrium.com 注册实验室！", "warning")
        os._exit(1)
    graph: nx.Graph
    resource_tree_set: ResourceTreeSet
@@ -621,23 +357,31 @@ def main():
            continue
    # 如果从远端获取了物料信息，则与本地物料进行同步
-    # 仅在本地文件模式下有意义：本地文件只含设备结构，远端有已保存的物料，需要 merge
+    if request_startup_json and "nodes" in request_startup_json:
    # 远端模式下 resource_tree_set 与 request_startup_json 来自同一份数据，merge 为空操作
    if file_path is not None and request_startup_json and "nodes" in request_startup_json:
        print_status("开始同步远端物料到本地...", "info")
        remote_tree_set = ResourceTreeSet.from_raw_dict_list(request_startup_json["nodes"])
        resource_tree_set.merge_remote_resources(remote_tree_set)
        print_status("远端物料同步完成", "info")
    # 第二次设备包依赖检查：云端物料同步后，community 包可能引入新的 requirements
    # TODO: 当 community device package 功能上线后，在这里调用
    #   install_requirements_txt(community_pkg_path / "requirements.txt", label="community.xxx")
    # 使用 ResourceTreeSet 代替 list
    args_dict["resources_config"] = resource_tree_set
    args_dict["devices_config"] = resource_tree_set
    args_dict["graph"] = graph_res.physical_setup_graph
    if BasicConfig.upload_registry:
        # 设备注册到服务端 - 需要 ak 和 sk
        if BasicConfig.ak and BasicConfig.sk:
            print_status("开始注册设备到服务端...", "info")
            try:
                register_devices_and_resources(lab_registry)
                print_status("设备注册完成", "info")
            except Exception as e:
                print_status(f"设备注册失败: {e}", "error")
        else:
            print_status("未提供 ak 和 sk，跳过设备注册", "info")
    else:
        print_status("本次启动注册表不报送云端，如果您需要联网调试，请在启动命令增加--upload_registry", "warning")
    if args_dict["controllers"] is not None:
        args_dict["controllers_config"] = yaml.safe_load(open(args_dict["controllers"], encoding="utf-8"))
    else:
@@ -652,7 +396,6 @@ def main():
        comm_client = get_communication_client()
        if "websocket" in args_dict["app_bridges"]:
            args_dict["bridges"].append(comm_client)
            def _exit(signum, frame):
                comm_client.stop()
                sys.exit(0)
@@ -694,13 +437,16 @@ def main():
                resource_visualization.start()
            except OSError as e:
                if "AMENT_PREFIX_PATH" in str(e):
-                    print_status(f"ROS 2环境未正确设置，跳过3D可视化启动。错误详情: {e}", "warning")
+                    print_status(
                        f"ROS 2环境未正确设置，跳过3D可视化启动。错误详情: {e}",
                        "warning"
                    )
                    print_status(
                        "建议解决方案：\n"
                        "1. 激活Conda环境: conda activate unilab\n"
                        "2. 或使用 --backend simple 参数\n"
                        "3. 或使用 --visual disable 参数禁用可视化",
-                        "info",
+                        "info"
                    )
                else:
                    raise
@@ -708,26 +454,16 @@ def main():
                time.sleep(1)
        else:
            start_backend(**args_dict)
-            restart_requested = start_server(
+            start_server(
                open_browser=not args_dict["disable_browser"],
                port=BasicConfig.port,
            )
            if restart_requested:
                print_status("[Main] Restart requested, cleaning up...", "info")
                cleanup_for_restart()
                return
    else:
        start_backend(**args_dict)
-
+        start_server(
        # 启动服务器（默认支持WebSocket触发重启）
        restart_requested = start_server(
            open_browser=not args_dict["disable_browser"],
            port=BasicConfig.port,
        )
        if restart_requested:
            print_status("[Main] Restart requested, cleaning up...", "info")
            cleanup_for_restart()
            os._exit(RESTART_EXIT_CODE)
 if __name__ == "__main__":
--- a/unilabos/app/model.py
+++ b/unilabos/app/model.py
@@ -54,7 +54,6 @@ class JobAddReq(BaseModel):
    action_type: str = Field(
        examples=["unilabos_msgs.action._str_single_input.StrSingleInput"], description="action type", default=""
    )
    sample_material: dict = Field(examples=[{"string": "string"}], description="sample uuid to material uuid")
    action_args: dict = Field(examples=[{"string": "string"}], description="action arguments", default_factory=dict)
    task_id: str = Field(examples=["task_id"], description="task uuid (auto-generated if empty)", default="")
    job_id: str = Field(examples=["job_id"], description="goal uuid (auto-generated if empty)", default="")
--- a/unilabos/app/register.py
+++ b/unilabos/app/register.py
@@ -1,8 +1,9 @@
 import json
 import time
-from typing import Any, Dict, Optional, Tuple
+from typing import Optional, Tuple, Dict, Any
 from unilabos.utils.log import logger
-from unilabos.utils.tools import normalize_json as _normalize_device
+from unilabos.utils.type_check import TypeEncoder
 def register_devices_and_resources(lab_registry, gather_only=False) -> Optional[Tuple[Dict[str, Any], Dict[str, Any]]]:
@@ -10,63 +11,50 @@ def register_devices_and_resources(lab_registry, gather_only=False) -> Optional[
    注册设备和资源到服务器（仅支持HTTP）
    """
    # 注册资源信息 - 使用HTTP方式
    from unilabos.app.web.client import http_client
    logger.info("[UniLab Register] 开始注册设备和资源...")
    # 注册设备信息
    devices_to_register = {}
    for device_info in lab_registry.obtain_registry_device_info():
-        devices_to_register[device_info["id"]] = _normalize_device(device_info)
+        devices_to_register[device_info["id"]] = json.loads(
-        logger.trace(f"[UniLab Register] 收集设备: {device_info['id']}")
+            json.dumps(device_info, ensure_ascii=False, cls=TypeEncoder)
        )
        logger.debug(f"[UniLab Register] 收集设备: {device_info['id']}")
    resources_to_register = {}
    for resource_info in lab_registry.obtain_registry_resource_info():
        resources_to_register[resource_info["id"]] = resource_info
-        logger.trace(f"[UniLab Register] 收集资源: {resource_info['id']}")
+        logger.debug(f"[UniLab Register] 收集资源: {resource_info['id']}")
    if gather_only:
        return devices_to_register, resources_to_register
-
+    # 注册设备
    if devices_to_register:
        try:
            start_time = time.time()
-            response = http_client.resource_registry(
+            response = http_client.resource_registry({"resources": list(devices_to_register.values())})
                {"resources": list(devices_to_register.values())},
                tag="device_registry",
            )
            cost_time = time.time() - start_time
-            res_data = response.json() if response.status_code == 200 else {}
+            if response.status_code in [200, 201]:
-            skipped = res_data.get("data", {}).get("skipped", False)
+                logger.info(f"[UniLab Register] 成功注册 {len(devices_to_register)} 个设备 {cost_time}ms")
            if skipped:
                logger.info(
                    f"[UniLab Register] 设备注册跳过（内容未变化）"
                    f" {len(devices_to_register)} 个 {cost_time:.3f}s"
                )
            elif response.status_code in [200, 201]:
                logger.info(f"[UniLab Register] 成功注册 {len(devices_to_register)} 个设备 {cost_time:.3f}s")
            else:
-                logger.error(f"[UniLab Register] 设备注册失败: {response.status_code}, {response.text} {cost_time:.3f}s")
+                logger.error(f"[UniLab Register] 设备注册失败: {response.status_code}, {response.text} {cost_time}ms")
        except Exception as e:
            logger.error(f"[UniLab Register] 设备注册异常: {e}")
    # 注册资源
    if resources_to_register:
        try:
            start_time = time.time()
-            response = http_client.resource_registry(
+            response = http_client.resource_registry({"resources": list(resources_to_register.values())})
                {"resources": list(resources_to_register.values())},
                tag="resource_registry",
            )
            cost_time = time.time() - start_time
-            res_data = response.json() if response.status_code == 200 else {}
+            if response.status_code in [200, 201]:
-            skipped = res_data.get("data", {}).get("skipped", False)
+                logger.info(f"[UniLab Register] 成功注册 {len(resources_to_register)} 个资源 {cost_time}ms")
            if skipped:
                logger.info(
                    f"[UniLab Register] 资源注册跳过（内容未变化）"
                    f" {len(resources_to_register)} 个 {cost_time:.3f}s"
                )
            elif response.status_code in [200, 201]:
                logger.info(f"[UniLab Register] 成功注册 {len(resources_to_register)} 个资源 {cost_time:.3f}s")
            else:
-                logger.error(f"[UniLab Register] 资源注册失败: {response.status_code}, {response.text} {cost_time:.3f}s")
+                logger.error(f"[UniLab Register] 资源注册失败: {response.status_code}, {response.text} {cost_time}ms")
        except Exception as e:
            logger.error(f"[UniLab Register] 资源注册异常: {e}")
    logger.info("[UniLab Register] 设备和资源注册完成.")
--- a/unilabos/app/utils.py
+++ b/unilabos/app/utils.py
@@ -1,176 +0,0 @@
 """
 UniLabOS 应用工具函数
 提供清理、重启等工具函数
 """
 import glob
 import os
 import shutil
 import sys
 def patch_rclpy_dll_windows():
    """在 Windows + conda 环境下为 rclpy 打 DLL 加载补丁"""
    if sys.platform != "win32" or not os.environ.get("CONDA_PREFIX"):
        return
    try:
        import rclpy
        return
    except ImportError as e:
        if not str(e).startswith("DLL load failed"):
            return
    cp = os.environ["CONDA_PREFIX"]
    impl = os.path.join(cp, "Lib", "site-packages", "rclpy", "impl", "implementation_singleton.py")
    pyd = glob.glob(os.path.join(cp, "Lib", "site-packages", "rclpy", "_rclpy_pybind11*.pyd"))
    if not os.path.exists(impl) or not pyd:
        return
    with open(impl, "r", encoding="utf-8") as f:
        content = f.read()
    lib_bin = os.path.join(cp, "Library", "bin").replace("\\", "/")
    patch = f'# UniLabOS DLL Patch\nimport os,ctypes\nos.add_dll_directory("{lib_bin}") if hasattr(os,"add_dll_directory") else None\ntry: ctypes.CDLL("{pyd[0].replace(chr(92),"/")}")\nexcept: pass\n# End Patch\n'
    shutil.copy2(impl, impl + ".bak")
    with open(impl, "w", encoding="utf-8") as f:
        f.write(patch + content)
 patch_rclpy_dll_windows()
 import gc
 import threading
 import time
 from unilabos.utils.banner_print import print_status
 def cleanup_for_restart() -> bool:
    """
    Clean up all resources for restart without exiting the process.
    This function prepares the system for re-initialization by:
    1. Stopping all communication clients
    2. Destroying ROS nodes
    3. Resetting singletons
    4. Waiting for threads to finish
    Returns:
        bool: True if cleanup was successful, False otherwise
    """
    print_status("[Restart] Starting cleanup for restart...", "info")
    # Step 1: Stop WebSocket communication client
    print_status("[Restart] Step 1: Stopping WebSocket client...", "info")
    try:
        from unilabos.app.communication import get_communication_client
        comm_client = get_communication_client()
        if comm_client is not None:
            comm_client.stop()
            print_status("[Restart] WebSocket client stopped", "info")
    except Exception as e:
        print_status(f"[Restart] Error stopping WebSocket: {e}", "warning")
    # Step 2: Get HostNode and cleanup ROS
    print_status("[Restart] Step 2: Cleaning up ROS nodes...", "info")
    try:
        from unilabos.ros.nodes.presets.host_node import HostNode
        import rclpy
        from rclpy.timer import Timer
        host_instance = HostNode.get_instance(timeout=5)
        if host_instance is not None:
            print_status(f"[Restart] Found HostNode: {host_instance.device_id}", "info")
            # Gracefully shutdown background threads
            print_status("[Restart] Shutting down background threads...", "info")
            HostNode.shutdown_background_threads(timeout=5.0)
            print_status("[Restart] Background threads shutdown complete", "info")
            # Stop discovery timer
            if hasattr(host_instance, "_discovery_timer") and isinstance(host_instance._discovery_timer, Timer):
                host_instance._discovery_timer.cancel()
                print_status("[Restart] Discovery timer cancelled", "info")
            # Destroy device nodes
            device_count = len(host_instance.devices_instances)
            print_status(f"[Restart] Destroying {device_count} device instances...", "info")
            for device_id, device_node in list(host_instance.devices_instances.items()):
                try:
                    if hasattr(device_node, "ros_node_instance") and device_node.ros_node_instance is not None:
                        device_node.ros_node_instance.destroy_node()
                        print_status(f"[Restart] Device {device_id} destroyed", "info")
                except Exception as e:
                    print_status(f"[Restart] Error destroying device {device_id}: {e}", "warning")
            # Clear devices instances
            host_instance.devices_instances.clear()
            host_instance.devices_names.clear()
            # Destroy host node
            try:
                host_instance.destroy_node()
                print_status("[Restart] HostNode destroyed", "info")
            except Exception as e:
                print_status(f"[Restart] Error destroying HostNode: {e}", "warning")
            # Reset HostNode state
            HostNode.reset_state()
            print_status("[Restart] HostNode state reset", "info")
        # Shutdown executor first (to stop executor.spin() gracefully)
        if hasattr(rclpy, "__executor") and rclpy.__executor is not None:
            try:
                rclpy.__executor.shutdown()
                rclpy.__executor = None  # Clear for restart
                print_status("[Restart] ROS executor shutdown complete", "info")
            except Exception as e:
                print_status(f"[Restart] Error shutting down executor: {e}", "warning")
        # Shutdown rclpy
        if rclpy.ok():
            rclpy.shutdown()
            print_status("[Restart] rclpy shutdown complete", "info")
    except ImportError as e:
        print_status(f"[Restart] ROS modules not available: {e}", "warning")
    except Exception as e:
        print_status(f"[Restart] Error in ROS cleanup: {e}", "warning")
        return False
    # Step 3: Reset communication client singleton
    print_status("[Restart] Step 3: Resetting singletons...", "info")
    try:
        from unilabos.app import communication
        if hasattr(communication, "_communication_client"):
            communication._communication_client = None
            print_status("[Restart] Communication client singleton reset", "info")
    except Exception as e:
        print_status(f"[Restart] Error resetting communication singleton: {e}", "warning")
    # Step 4: Wait for threads to finish
    print_status("[Restart] Step 4: Waiting for threads to finish...", "info")
    time.sleep(3)  # Give threads time to finish
    # Check remaining threads
    remaining_threads = []
    for t in threading.enumerate():
        if t.name != "MainThread" and t.is_alive():
            remaining_threads.append(t.name)
    if remaining_threads:
        print_status(
            f"[Restart] Warning: {len(remaining_threads)} threads still running: {remaining_threads}", "warning"
        )
    else:
        print_status("[Restart] All threads stopped", "info")
    # Step 5: Force garbage collection
    print_status("[Restart] Step 5: Running garbage collection...", "info")
    gc.collect()
    gc.collect()  # Run twice for weak references
    print_status("[Restart] Garbage collection complete", "info")
    print_status("[Restart] Cleanup complete. Ready for re-initialization.", "info")
    return True
--- a/unilabos/app/web/api.py
+++ b/unilabos/app/web/api.py
@@ -1052,7 +1052,7 @@ async def handle_file_import(websocket: WebSocket, request_data: dict):
                                "result": {},
                                "schema": lab_registry._generate_unilab_json_command_schema(v["args"], k),
                                "goal_default": {i["name"]: i["default"] for i in v["args"]},
-                                "handles": {},
+                                "handles": [],
                            }
                            # 不生成已配置action的动作
                            for k, v in enhanced_info["action_methods"].items()
@@ -1340,5 +1340,5 @@ def setup_api_routes(app):
    # 启动广播任务
    @app.on_event("startup")
    async def startup_event():
-        asyncio.create_task(broadcast_device_status(), name="web-api-startup-device")
+        asyncio.create_task(broadcast_device_status())
-        asyncio.create_task(broadcast_status_page_data(), name="web-api-startup-status")
+        asyncio.create_task(broadcast_status_page_data())
--- a/unilabos/app/web/client.py
+++ b/unilabos/app/web/client.py
@@ -3,15 +3,15 @@ HTTP客户端模块
 提供与远程服务器通信的客户端功能，只有host需要用
 """
-import gzip
+
 import json
 import os
 import time
 from threading import Thread
 from typing import List, Dict, Any, Optional
 from unilabos.utils.tools import fast_dumps as _fast_dumps, fast_dumps_pretty as _fast_dumps_pretty
 import requests
-from unilabos.resources.resource_tracker import ResourceTreeSet
+from unilabos.ros.nodes.resource_tracker import ResourceTreeSet
 from unilabos.utils.log import info
 from unilabos.config.config import HTTPConfig, BasicConfig
 from unilabos.utils import logger
@@ -36,9 +36,6 @@ class HTTPClient:
            auth_secret = BasicConfig.auth_secret()
            self.auth = auth_secret
            info(f"正在使用ak sk作为授权信息：[{auth_secret}]")
        # 复用 TCP/TLS 连接，避免每次请求重新握手
        self._session = requests.Session()
        self._session.headers.update({"Authorization": f"Lab {self.auth}"})
        info(f"HTTPClient 初始化完成: remote_addr={self.remote_addr}")
    def resource_edge_add(self, resources: List[Dict[str, Any]]) -> requests.Response:
@@ -51,7 +48,7 @@ class HTTPClient:
        Returns:
            Response: API响应对象
        """
-        response = self._session.post(
+        response = requests.post(
            f"{self.remote_addr}/edge/material/edge",
            json={
                "edges": resources,
@@ -78,28 +75,24 @@ class HTTPClient:
        Returns:
            Dict[str, str]: 旧UUID到新UUID的映射关系 {old_uuid: new_uuid}
        """
-        # dump() 只调用一次，复用给文件保存和 HTTP 请求
+        with open(os.path.join(BasicConfig.working_dir, "req_resource_tree_add.json"), "w", encoding="utf-8") as f:
-        nodes_info = [x for xs in resources.dump() for x in xs]
+            f.write(json.dumps({"nodes": [x for xs in resources.dump() for x in xs], "mount_uuid": mount_uuid}, indent=4))
        # 从序列化数据中提取所有节点的UUID（保存旧UUID）
        old_uuids = {n.res_content.uuid: n for n in resources.all_nodes}
        payload = {"nodes": nodes_info, "mount_uuid": mount_uuid}
        body_bytes = _fast_dumps(payload)
        with open(os.path.join(BasicConfig.working_dir, "req_resource_tree_add.json"), "wb") as f:
            f.write(_fast_dumps_pretty(payload))
        http_headers = {"Content-Type": "application/json"}
        if not self.initialized or first_add:
            self.initialized = True
            info(f"首次添加资源，当前远程地址: {self.remote_addr}")
-            response = self._session.post(
+            response = requests.post(
                f"{self.remote_addr}/edge/material",
-                data=body_bytes,
+                json={"nodes": [x for xs in resources.dump() for x in xs], "mount_uuid": mount_uuid},
-                headers=http_headers,
+                headers={"Authorization": f"Lab {self.auth}"},
                timeout=60,
            )
        else:
-            response = self._session.put(
+            response = requests.put(
                f"{self.remote_addr}/edge/material",
-                data=body_bytes,
+                json={"nodes": [x for xs in resources.dump() for x in xs], "mount_uuid": mount_uuid},
-                headers=http_headers,
+                headers={"Authorization": f"Lab {self.auth}"},
                timeout=10,
            )
@@ -117,7 +110,6 @@ class HTTPClient:
                    uuid_mapping[i["uuid"]] = i["cloud_uuid"]
        else:
            logger.error(f"添加物料失败: {response.text}")
            logger.trace(f"添加物料失败: {nodes_info}")
        for u, n in old_uuids.items():
            if u in uuid_mapping:
                n.res_content.uuid = uuid_mapping[u]
@@ -138,7 +130,7 @@ class HTTPClient:
        """
        with open(os.path.join(BasicConfig.working_dir, "req_resource_tree_get.json"), "w", encoding="utf-8") as f:
            f.write(json.dumps({"uuids": uuid_list, "with_children": with_children}, indent=4))
-        response = self._session.post(
+        response = requests.post(
            f"{self.remote_addr}/edge/material/query",
            json={"uuids": uuid_list, "with_children": with_children},
            headers={"Authorization": f"Lab {self.auth}"},
@@ -152,7 +144,6 @@ class HTTPClient:
                logger.error(f"查询物料失败: {response.text}")
            else:
                data = res["data"]["nodes"]
                logger.trace(f"resource_tree_get查询到物料: {data}")
                return data
        else:
            logger.error(f"查询物料失败: {response.text}")
@@ -170,14 +161,14 @@ class HTTPClient:
        if not self.initialized:
            self.initialized = True
            info(f"首次添加资源，当前远程地址: {self.remote_addr}")
-            response = self._session.post(
+            response = requests.post(
                f"{self.remote_addr}/lab/material",
                json={"nodes": resources},
                headers={"Authorization": f"Lab {self.auth}"},
                timeout=100,
            )
        else:
-            response = self._session.put(
+            response = requests.put(
                f"{self.remote_addr}/lab/material",
                json={"nodes": resources},
                headers={"Authorization": f"Lab {self.auth}"},
@@ -204,7 +195,7 @@ class HTTPClient:
        """
        with open(os.path.join(BasicConfig.working_dir, "req_resource_get.json"), "w", encoding="utf-8") as f:
            f.write(json.dumps({"id": id, "with_children": with_children}, indent=4))
-        response = self._session.get(
+        response = requests.get(
            f"{self.remote_addr}/lab/material",
            params={"id": id, "with_children": with_children},
            headers={"Authorization": f"Lab {self.auth}"},
@@ -245,14 +236,14 @@ class HTTPClient:
        if not self.initialized:
            self.initialized = True
            info(f"首次添加资源，当前远程地址: {self.remote_addr}")
-            response = self._session.post(
+            response = requests.post(
                f"{self.remote_addr}/lab/material",
                json={"nodes": resources},
                headers={"Authorization": f"Lab {self.auth}"},
                timeout=100,
            )
        else:
-            response = self._session.put(
+            response = requests.put(
                f"{self.remote_addr}/lab/material",
                json={"nodes": resources},
                headers={"Authorization": f"Lab {self.auth}"},
@@ -282,7 +273,7 @@ class HTTPClient:
        with open(file_path, "rb") as file:
            files = {"files": file}
            logger.info(f"上传文件: {file_path} 到 {scene}")
-            response = self._session.post(
+            response = requests.post(
                f"{self.remote_addr}/api/account/file_upload/{scene}",
                files=files,
                headers={"Authorization": f"Lab {self.auth}"},
@@ -290,54 +281,22 @@ class HTTPClient:
            )
        return response
-    def resource_registry(
+    def resource_registry(self, registry_data: Dict[str, Any] | List[Dict[str, Any]]) -> requests.Response:
        self, registry_data: Dict[str, Any] | List[Dict[str, Any]], tag: str = "registry",
    ) -> requests.Response:
        """
-        注册资源到服务器，同步保存请求/响应到 unilabos_data
+        注册资源到服务器
        Args:
            registry_data: 注册表数据，格式为 {resource_id: resource_info} / [{resource_info}]
            tag: 保存文件的标签后缀 (如 "device_registry" / "resource_registry")
        Returns:
            Response: API响应对象
        """
-        # 序列化一次，同时用于保存和发送
+        response = requests.post(
        json_bytes = _fast_dumps(registry_data)
        # 保存请求数据到 unilabos_data
        req_path = os.path.join(BasicConfig.working_dir, f"req_{tag}_upload.json")
        try:
            os.makedirs(BasicConfig.working_dir, exist_ok=True)
            with open(req_path, "wb") as f:
                f.write(_fast_dumps_pretty(registry_data))
            logger.trace(f"注册表请求数据已保存: {req_path}")
        except Exception as e:
            logger.warning(f"保存注册表请求数据失败: {e}")
        compressed_body = gzip.compress(json_bytes)
        headers = {
            "Authorization": f"Lab {self.auth}",
            "Content-Type": "application/json",
            "Content-Encoding": "gzip",
        }
        response = self._session.post(
            f"{self.remote_addr}/lab/resource",
-            data=compressed_body,
+            json=registry_data,
-            headers=headers,
+            headers={"Authorization": f"Lab {self.auth}"},
            timeout=30,
        )
        # 保存响应数据到 unilabos_data
        res_path = os.path.join(BasicConfig.working_dir, f"res_{tag}_upload.json")
        try:
            with open(res_path, "w", encoding="utf-8") as f:
                f.write(f"{response.status_code}\n{response.text}")
            logger.trace(f"注册表响应数据已保存: {res_path}")
        except Exception as e:
            logger.warning(f"保存注册表响应数据失败: {e}")
        if response.status_code not in [200, 201]:
            logger.error(f"注册资源失败: {response.status_code}, {response.text}")
        if response.status_code == 200:
@@ -356,7 +315,7 @@ class HTTPClient:
        Returns:
            Response: API响应对象
        """
-        response = self._session.get(
+        response = requests.get(
            f"{self.remote_addr}/edge/material/download",
            headers={"Authorization": f"Lab {self.auth}"},
            timeout=(3, 30),
@@ -376,106 +335,6 @@ class HTTPClient:
                logger.error(f"响应内容: {response.text}")
        return None
    def workflow_import(
        self,
        name: str,
        workflow_uuid: str,
        workflow_name: str,
        nodes: List[Dict[str, Any]],
        edges: List[Dict[str, Any]],
        tags: Optional[List[str]] = None,
        published: bool = False,
        description: str = "",
    ) -> Dict[str, Any]:
        """
        导入工作流到服务器，如果 published 为 True，则额外发起发布请求
        Args:
            name: 工作流名称（顶层）
            workflow_uuid: 工作流UUID
            workflow_name: 工作流名称（data内部）
            nodes: 工作流节点列表
            edges: 工作流边列表
            tags: 工作流标签列表，默认为空列表
            published: 是否发布工作流，默认为False
            description: 工作流描述，发布时使用
        Returns:
            Dict: API响应数据，包含 code 和 data (uuid, name)
        """
        payload = {
            "name": name,
            "data": {
                "workflow_uuid": workflow_uuid,
                "workflow_name": workflow_name,
                "nodes": nodes,
                "edges": edges,
                "tags": tags if tags is not None else [],
            },
        }
        # 保存请求到文件
        with open(os.path.join(BasicConfig.working_dir, "req_workflow_upload.json"), "w", encoding="utf-8") as f:
            f.write(json.dumps(payload, indent=4, ensure_ascii=False))
        response = self._session.post(
            f"{self.remote_addr}/lab/workflow/owner/import",
            json=payload,
            headers={"Authorization": f"Lab {self.auth}"},
            timeout=60,
        )
        # 保存响应到文件
        with open(os.path.join(BasicConfig.working_dir, "res_workflow_upload.json"), "w", encoding="utf-8") as f:
            f.write(f"{response.status_code}" + "\n" + response.text)
        if response.status_code == 200:
            res = response.json()
            if "code" in res and res["code"] != 0:
                logger.error(f"导入工作流失败: {response.text}")
                return res
            # 导入成功后，如果需要发布则额外发起发布请求
            if published:
                imported_uuid = res.get("data", {}).get("uuid", workflow_uuid)
                publish_res = self.workflow_publish(imported_uuid, description)
                res["publish_result"] = publish_res
            return res
        else:
            logger.error(f"导入工作流失败: {response.status_code}, {response.text}")
            return {"code": response.status_code, "message": response.text}
    def workflow_publish(self, workflow_uuid: str, description: str = "") -> Dict[str, Any]:
        """
        发布工作流
        Args:
            workflow_uuid: 工作流UUID
            description: 工作流描述
        Returns:
            Dict: API响应数据
        """
        payload = {
            "uuid": workflow_uuid,
            "description": description,
            "published": True,
        }
        logger.info(f"正在发布工作流: {workflow_uuid}")
        response = requests.patch(
            f"{self.remote_addr}/lab/workflow/owner",
            json=payload,
            headers={"Authorization": f"Lab {self.auth}"},
            timeout=60,
        )
        if response.status_code == 200:
            res = response.json()
            if "code" in res and res["code"] != 0:
                logger.error(f"发布工作流失败: {response.text}")
            else:
                logger.info(f"工作流发布成功: {workflow_uuid}")
            return res
        else:
            logger.error(f"发布工作流失败: {response.status_code}, {response.text}")
            return {"code": response.status_code, "message": response.text}
 # 创建默认客户端实例
 http_client = HTTPClient()
--- a/unilabos/app/web/controller.py
+++ b/unilabos/app/web/controller.py
@@ -58,14 +58,14 @@ class JobResultStore:
                feedback=feedback or {},
                timestamp=time.time(),
            )
-            logger.trace(f"[JobResultStore] Stored result for job {job_id[:8]}, status={status}")
+            logger.debug(f"[JobResultStore] Stored result for job {job_id[:8]}, status={status}")
    def get_and_remove(self, job_id: str) -> Optional[JobResult]:
        """获取并删除任务结果"""
        with self._results_lock:
            result = self._results.pop(job_id, None)
            if result:
-                logger.trace(f"[JobResultStore] Retrieved and removed result for job {job_id[:8]}")
+                logger.debug(f"[JobResultStore] Retrieved and removed result for job {job_id[:8]}")
            return result
    def get_result(self, job_id: str) -> Optional[JobResult]:
@@ -327,7 +327,6 @@ def job_add(req: JobAddReq) -> JobData:
            queue_item,
            action_type=action_type,
            action_kwargs=action_args,
            sample_material=req.sample_material,
            server_info=server_info,
        )
--- a/unilabos/app/web/server.py
+++ b/unilabos/app/web/server.py
@@ -6,6 +6,7 @@ Web服务器模块
 import webbrowser
 import uvicorn
 from fastapi import FastAPI, Request
 from fastapi.middleware.cors import CORSMiddleware
 from starlette.responses import Response
@@ -86,7 +87,7 @@ def setup_server() -> FastAPI:
    # 设置页面路由
    try:
        setup_web_pages(pages)
-        # info("[Web] 已加载Web UI模块")
+        info("[Web] 已加载Web UI模块")
    except ImportError as e:
        info(f"[Web] 未找到Web页面模块: {str(e)}")
    except Exception as e:
@@ -95,7 +96,7 @@ def setup_server() -> FastAPI:
    return app
-def start_server(host: str = "0.0.0.0", port: int = 8002, open_browser: bool = True) -> bool:
+def start_server(host: str = "0.0.0.0", port: int = 8002, open_browser: bool = True) -> None:
    """
    启动服务器
@@ -103,14 +104,7 @@ def start_server(host: str = "0.0.0.0", port: int = 8002, open_browser: bool = T
        host: 服务器主机
        port: 服务器端口
        open_browser: 是否自动打开浏览器
    Returns:
        bool: True if restart was requested, False otherwise
    """
    import threading
    import time
    from uvicorn import Config, Server
    # 设置服务器
    setup_server()
@@ -129,37 +123,7 @@ def start_server(host: str = "0.0.0.0", port: int = 8002, open_browser: bool = T
    # 启动服务器
    info(f"[Web] 启动FastAPI服务器: {host}:{port}")
-
+    uvicorn.run(app, host=host, port=port, log_config=log_config)
    # 使用支持重启的模式
    config = Config(app=app, host=host, port=port, log_config=log_config)
    server = Server(config)
    # 启动服务器线程
    server_thread = threading.Thread(target=server.run, daemon=True, name="uvicorn_server")
    server_thread.start()
    # info("[Web] Server started, monitoring for restart requests...")
    # 监控重启标志
    import unilabos.app.main as main_module
    while server_thread.is_alive():
        if hasattr(main_module, "_restart_requested") and main_module._restart_requested:
            info(
                f"[Web] Restart requested via WebSocket, reason: {getattr(main_module, '_restart_reason', 'unknown')}"
            )
            main_module._restart_requested = False
            # 停止服务器
            server.should_exit = True
            server_thread.join(timeout=5)
            info("[Web] Server stopped, ready for restart")
            return True
        time.sleep(1)
    return False
 # 当脚本直接运行时启动服务器
--- a/unilabos/app/ws_client.py
+++ b/unilabos/app/ws_client.py
@@ -23,10 +23,9 @@ from typing import Optional, Dict, Any, List
 from urllib.parse import urlparse
 from enum import Enum
-from typing_extensions import TypedDict
+from jedi.inference.gradual.typing import TypedDict
 from unilabos.app.model import JobAddReq
 from unilabos.resources.resource_tracker import ResourceDictType
 from unilabos.ros.nodes.presets.host_node import HostNode
 from unilabos.utils.type_check import serialize_result_info
 from unilabos.app.communication import BaseCommunicationClient
@@ -77,7 +76,6 @@ class JobInfo:
    start_time: float
    last_update_time: float = field(default_factory=time.time)
    ready_timeout: Optional[float] = None  # READY状态的超时时间
    always_free: bool = False  # 是否为永久闲置动作(不受排队限制)
    def update_timestamp(self):
        """更新最后更新时间"""
@@ -129,15 +127,6 @@ class DeviceActionManager:
            # 总是将job添加到all_jobs中
            self.all_jobs[job_info.job_id] = job_info
            # always_free的动作不受排队限制，直接设为READY
            if job_info.always_free:
                job_info.status = JobStatus.READY
                job_info.update_timestamp()
                job_info.set_ready_timeout(10)
                job_log = format_job_log(job_info.job_id, job_info.task_id, job_info.device_id, job_info.action_name)
                logger.trace(f"[DeviceActionManager] Job {job_log} always_free, start immediately")
                return True
            # 检查是否有正在执行或准备执行的任务
            if device_key in self.active_jobs:
                # 有正在执行或准备执行的任务，加入队列
@@ -165,7 +154,7 @@ class DeviceActionManager:
            job_info.set_ready_timeout(10)  # 设置10秒超时
            self.active_jobs[device_key] = job_info
            job_log = format_job_log(job_info.job_id, job_info.task_id, job_info.device_id, job_info.action_name)
-            logger.trace(f"[DeviceActionManager] Job {job_log} can start immediately for {device_key}")
+            logger.info(f"[DeviceActionManager] Job {job_log} can start immediately for {device_key}")
            return True
    def start_job(self, job_id: str) -> bool:
@@ -187,13 +176,9 @@ class DeviceActionManager:
                logger.error(f"[DeviceActionManager] Job {job_log} is not in READY status, current: {job_info.status}")
                return False
            # always_free的job不需要检查active_jobs
            if not job_info.always_free:
            # 检查设备上是否是这个job
            if device_key not in self.active_jobs or self.active_jobs[device_key].job_id != job_id:
-                    job_log = format_job_log(
+                job_log = format_job_log(job_info.job_id, job_info.task_id, job_info.device_id, job_info.action_name)
                        job_info.job_id, job_info.task_id, job_info.device_id, job_info.action_name
                    )
                logger.error(f"[DeviceActionManager] Job {job_log} is not the active job for {device_key}")
                return False
@@ -218,13 +203,6 @@ class DeviceActionManager:
            job_info = self.all_jobs[job_id]
            device_key = job_info.device_action_key
            # always_free的job直接清理，不影响队列
            if job_info.always_free:
                job_info.status = JobStatus.ENDED
                job_info.update_timestamp()
                del self.all_jobs[job_id]
                return None
            # 移除活跃任务
            if device_key in self.active_jobs and self.active_jobs[device_key].job_id == job_id:
                del self.active_jobs[device_key]
@@ -232,9 +210,8 @@ class DeviceActionManager:
                job_info.update_timestamp()
                # 从all_jobs中移除已结束的job
                del self.all_jobs[job_id]
-                # job_log = format_job_log(job_info.job_id, job_info.task_id, job_info.device_id, job_info.action_name)
+                job_log = format_job_log(job_info.job_id, job_info.task_id, job_info.device_id, job_info.action_name)
-                # logger.debug(f"[DeviceActionManager] Job {job_log} ended for {device_key}")
+                logger.info(f"[DeviceActionManager] Job {job_log} ended for {device_key}")
                pass
            else:
                job_log = format_job_log(job_info.job_id, job_info.task_id, job_info.device_id, job_info.action_name)
                logger.warning(f"[DeviceActionManager] Job {job_log} was not active for {device_key}")
@@ -250,20 +227,15 @@ class DeviceActionManager:
                next_job_log = format_job_log(
                    next_job.job_id, next_job.task_id, next_job.device_id, next_job.action_name
                )
-                logger.trace(f"[DeviceActionManager] Next job {next_job_log} can start for {device_key}")
+                logger.info(f"[DeviceActionManager] Next job {next_job_log} can start for {device_key}")
                return next_job
            return None
    def get_active_jobs(self) -> List[JobInfo]:
-        """获取所有正在执行的任务(含active_jobs和always_free的STARTED job)"""
+        """获取所有正在执行的任务"""
        with self.lock:
-            jobs = list(self.active_jobs.values())
+            return list(self.active_jobs.values())
            # 补充 always_free 的 STARTED job(它们不在 active_jobs 中)
            for job in self.all_jobs.values():
                if job.always_free and job.status == JobStatus.STARTED and job not in jobs:
                    jobs.append(job)
            return jobs
    def get_queued_jobs(self) -> List[JobInfo]:
        """获取所有排队中的任务"""
@@ -288,14 +260,6 @@ class DeviceActionManager:
            job_info = self.all_jobs[job_id]
            device_key = job_info.device_action_key
            # always_free的job直接清理
            if job_info.always_free:
                job_info.status = JobStatus.ENDED
                del self.all_jobs[job_id]
                job_log = format_job_log(job_info.job_id, job_info.task_id, job_info.device_id, job_info.action_name)
                logger.trace(f"[DeviceActionManager] Always-free job {job_log} cancelled")
                return True
            # 如果是正在执行的任务
            if device_key in self.active_jobs and self.active_jobs[device_key].job_id == job_id:
                # 清理active job状态
@@ -304,7 +268,7 @@ class DeviceActionManager:
                # 从all_jobs中移除
                del self.all_jobs[job_id]
                job_log = format_job_log(job_info.job_id, job_info.task_id, job_info.device_id, job_info.action_name)
-                logger.trace(f"[DeviceActionManager] Active job {job_log} cancelled for {device_key}")
+                logger.info(f"[DeviceActionManager] Active job {job_log} cancelled for {device_key}")
                # 启动下一个任务
                if device_key in self.device_queues and self.device_queues[device_key]:
@@ -317,7 +281,7 @@ class DeviceActionManager:
                    next_job_log = format_job_log(
                        next_job.job_id, next_job.task_id, next_job.device_id, next_job.action_name
                    )
-                    logger.trace(f"[DeviceActionManager] Next job {next_job_log} can start after cancel")
+                    logger.info(f"[DeviceActionManager] Next job {next_job_log} can start after cancel")
                return True
            # 如果是排队中的任务
@@ -331,7 +295,7 @@ class DeviceActionManager:
                    job_log = format_job_log(
                        job_info.job_id, job_info.task_id, job_info.device_id, job_info.action_name
                    )
-                    logger.trace(f"[DeviceActionManager] Queued job {job_log} cancelled for {device_key}")
+                    logger.info(f"[DeviceActionManager] Queued job {job_log} cancelled for {device_key}")
                    return True
            job_log = format_job_log(job_info.job_id, job_info.task_id, job_info.device_id, job_info.action_name)
@@ -369,18 +333,13 @@ class DeviceActionManager:
        timeout_jobs = []
        with self.lock:
-            # 收集所有需要检查的 READY 任务(active_jobs + always_free READY jobs)
+            # 统计READY状态的任务数量
-            ready_candidates = list(self.active_jobs.values())
+            ready_jobs_count = sum(1 for job in self.active_jobs.values() if job.status == JobStatus.READY)
            for job in self.all_jobs.values():
                if job.always_free and job.status == JobStatus.READY and job not in ready_candidates:
                    ready_candidates.append(job)
            ready_jobs_count = sum(1 for job in ready_candidates if job.status == JobStatus.READY)
            if ready_jobs_count > 0:
                logger.trace(f"[DeviceActionManager] Checking {ready_jobs_count} READY jobs for timeout")  # type: ignore  # noqa: E501
            # 找到所有超时的READY任务（只检测，不处理）
-            for job_info in ready_candidates:
+            for job_info in self.active_jobs.values():
                if job_info.is_ready_timeout():
                    timeout_jobs.append(job_info)
                    job_log = format_job_log(
@@ -400,7 +359,7 @@ class MessageProcessor:
        self.device_manager = device_manager
        self.queue_processor = None  # 延迟设置
        self.websocket_client = None  # 延迟设置
-        self.session_id = str(uuid.uuid4())[:6]  # 产生一个随机的session_id
+        self.session_id = ""
        # WebSocket连接
        self.websocket = None
@@ -409,7 +368,6 @@ class MessageProcessor:
        # 线程控制
        self.is_running = False
        self.thread = None
        self._loop = None  # asyncio event loop引用，用于外部关闭websocket
        self.reconnect_count = 0
        logger.info(f"[MessageProcessor] Initialized for URL: {websocket_url}")
@@ -436,31 +394,22 @@ class MessageProcessor:
    def stop(self) -> None:
        """停止消息处理线程"""
        self.is_running = False
        # 主动关闭websocket以快速中断消息接收循环
        ws = self.websocket
        loop = self._loop
        if ws and loop and loop.is_running():
            try:
                asyncio.run_coroutine_threadsafe(ws.close(), loop)
            except Exception:
                pass
        if self.thread and self.thread.is_alive():
            self.thread.join(timeout=2)
        logger.info("[MessageProcessor] Stopped")
    def _run(self):
        """运行消息处理主循环"""
-        self._loop = asyncio.new_event_loop()
+        loop = asyncio.new_event_loop()
        try:
-            asyncio.set_event_loop(self._loop)
+            asyncio.set_event_loop(loop)
-            self._loop.run_until_complete(self._connection_handler())
+            loop.run_until_complete(self._connection_handler())
        except Exception as e:
            logger.error(f"[MessageProcessor] Thread error: {str(e)}")
            logger.error(traceback.format_exc())
        finally:
-            if self._loop:
+            if loop:
-                self._loop.close()
+                loop.close()
            self._loop = None
    async def _connection_handler(self):
        """处理WebSocket连接和重连逻辑"""
@@ -477,10 +426,8 @@ class MessageProcessor:
                async with websockets.connect(
                    self.websocket_url,
                    ssl=ssl_context,
                    open_timeout=20,
                    ping_interval=WSConfig.ping_interval,
                    ping_timeout=10,
                    close_timeout=5,
                    additional_headers={
                        "Authorization": f"Lab {BasicConfig.auth_secret()}",
                        "EdgeSession": f"{self.session_id}",
@@ -491,98 +438,72 @@ class MessageProcessor:
                    self.connected = True
                    self.reconnect_count = 0
-                    logger.info(f"[MessageProcessor] 已连接到 {self.websocket_url}")
+                    logger.info(f"[MessageProcessor] Connected to {self.websocket_url}")
                    # 启动发送协程
-                    send_task = asyncio.create_task(self._send_handler(), name="websocket-send_task")
+                    send_task = asyncio.create_task(self._send_handler())
                    # 每次连接（含重连）后重新向服务端注册，
                    # 否则服务端不知道客户端已上线，不会推送消息。
                    if self.websocket_client:
                        self.websocket_client.publish_host_ready()
                    try:
                        # 接收消息循环
                        await self._message_handler()
                    finally:
                        # 必须在 async with __aexit__ 之前停止 send_task，
                        # 否则 send_task 会在关闭握手期间继续发送数据，
                        # 干扰 websockets 库的内部清理，导致 task 泄漏。
                        self.connected = False
                        send_task.cancel()
                        try:
                            await send_task
                        except asyncio.CancelledError:
                            pass
                        self.connected = False
            except websockets.exceptions.ConnectionClosed:
-                logger.warning("[MessageProcessor] 与服务端连接中断")
+                logger.warning("[MessageProcessor] Connection closed")
            except TimeoutError:
                logger.warning(
                    f"[MessageProcessor] 与服务端连接通信超时 (已尝试 {self.reconnect_count + 1} 次)，请检查您的网络状况"
                )
            except websockets.exceptions.InvalidStatus as e:
                logger.warning(
                    f"[MessageProcessor] 收到服务端注册码 {e.response.status_code}, 上一进程可能还未退出"
                )
            except Exception as e:
                logger.error(traceback.format_exc())
                logger.error(f"[MessageProcessor] 尝试重连时出错 {str(e)}")
            finally:
                self.connected = False
            except Exception as e:
                logger.error(f"[MessageProcessor] Connection error: {str(e)}")
                logger.error(traceback.format_exc())
                self.connected = False
            finally:
                self.websocket = None
            # 重连逻辑
-            if not self.is_running:
+            if self.is_running and self.reconnect_count < WSConfig.max_reconnect_attempts:
                break
            if self.reconnect_count < WSConfig.max_reconnect_attempts:
                self.reconnect_count += 1
                backoff = WSConfig.reconnect_interval
                logger.info(
-                    f"[MessageProcessor] 即将在 {backoff} 秒后重连 (已尝试 {self.reconnect_count}/{WSConfig.max_reconnect_attempts})"
+                    f"[MessageProcessor] Reconnecting in {WSConfig.reconnect_interval}s "
                    f"(attempt {self.reconnect_count}/{WSConfig.max_reconnect_attempts})"
                )
-                await asyncio.sleep(backoff)
+                await asyncio.sleep(WSConfig.reconnect_interval)
-            else:
+            elif self.reconnect_count >= WSConfig.max_reconnect_attempts:
                logger.error("[MessageProcessor] Max reconnection attempts reached")
                break
            else:
                self.reconnect_count -= 1
    async def _message_handler(self):
-        """处理接收到的消息。
+        """处理接收到的消息"""
        ConnectionClosed 不在此处捕获，让其向上传播到 _connection_handler，
        以便 async with websockets.connect() 的 __aexit__ 能感知连接已断，
        正确清理内部 task，避免 task 泄漏。
        """
        if not self.websocket:
            logger.error("[MessageProcessor] WebSocket connection is None")
            return
        try:
            async for message in self.websocket:
                try:
                    data = json.loads(message)
-                message_type = data.get("action", "")
+                    await self._process_message(data)
                message_data = data.get("data")
                if self.session_id and self.session_id == data.get("edge_session"):
                    await self._process_message(message_type, message_data)
                else:
                    if message_type.endswith("_material"):
                        logger.trace(
                            f"[MessageProcessor] 收到一条归属 {data.get('edge_session')} 的旧消息：{data}"
                        )
                        logger.debug(
                            f"[MessageProcessor] 跳过了一条归属 {data.get('edge_session')} 的旧消息: {data.get('action')}"
                        )
                    else:
                        await self._process_message(message_type, message_data)
                except json.JSONDecodeError:
                    logger.error(f"[MessageProcessor] Invalid JSON received: {message}")
                except Exception as e:
                    logger.error(f"[MessageProcessor] Error processing message: {str(e)}")
                    logger.error(traceback.format_exc())
        except websockets.exceptions.ConnectionClosed:
            logger.info("[MessageProcessor] Message handler stopped - connection closed")
        except Exception as e:
            logger.error(f"[MessageProcessor] Message handler error: {str(e)}")
            logger.error(traceback.format_exc())
    async def _send_handler(self):
        """处理发送队列中的消息"""
-        logger.trace("[MessageProcessor] Send handler started")
+        logger.debug("[MessageProcessor] Send handler started")
        try:
            while self.connected and self.websocket:
@@ -610,7 +531,7 @@ class MessageProcessor:
                        try:
                            message_str = json.dumps(msg, ensure_ascii=False)
                            await self.websocket.send(message_str)
-                            # logger.trace(f"[MessageProcessor] Message sent: {msg.get('action', 'unknown')}")  # type: ignore  # noqa: E501
+                            logger.trace(f"[MessageProcessor] Message sent: {msg.get('action', 'unknown')}")  # type: ignore  # noqa: E501
                        except Exception as e:
                            logger.error(f"[MessageProcessor] Failed to send message: {str(e)}")
                            logger.error(traceback.format_exc())
@@ -627,16 +548,18 @@ class MessageProcessor:
        except asyncio.CancelledError:
            logger.debug("[MessageProcessor] Send handler cancelled")
            raise
        except Exception as e:
            logger.error(f"[MessageProcessor] Fatal error in send handler: {str(e)}")
            logger.error(traceback.format_exc())
        finally:
            logger.debug("[MessageProcessor] Send handler stopped")
-    async def _process_message(self, message_type: str, message_data: Dict[str, Any]):
+    async def _process_message(self, data: Dict[str, Any]):
        """处理收到的消息"""
-        logger.trace(f"[MessageProcessor] Processing message: {message_type}")
+        message_type = data.get("action", "")
        message_data = data.get("data")
        logger.debug(f"[MessageProcessor] Processing message: {message_type}")
        try:
            if message_type == "pong":
@@ -648,23 +571,16 @@ class MessageProcessor:
            elif message_type == "cancel_action" or message_type == "cancel_task":
                await self._handle_cancel_action(message_data)
            elif message_type == "add_material":
                # noinspection PyTypeChecker
                await self._handle_resource_tree_update(message_data, "add")
            elif message_type == "update_material":
                # noinspection PyTypeChecker
                await self._handle_resource_tree_update(message_data, "update")
            elif message_type == "remove_material":
                # noinspection PyTypeChecker
                await self._handle_resource_tree_update(message_data, "remove")
-            # elif message_type == "session_id":
+            elif message_type == "session_id":
-            #     self.session_id = message_data.get("session_id")
+                self.session_id = message_data.get("session_id")
-            #     logger.info(f"[MessageProcessor] Session ID: {self.session_id}")
+                logger.info(f"[MessageProcessor] Session ID: {self.session_id}")
-            elif message_type == "add_device":
+            elif message_type == "request_reload":
-                await self._handle_device_manage(message_data, "add")
+                await self._handle_request_reload(message_data)
            elif message_type == "remove_device":
                await self._handle_device_manage(message_data, "remove")
            elif message_type == "request_restart":
                await self._handle_request_restart(message_data)
            else:
                logger.debug(f"[MessageProcessor] Unknown message type: {message_type}")
@@ -678,24 +594,6 @@ class MessageProcessor:
        if host_node:
            host_node.handle_pong_response(pong_data)
    def _check_action_always_free(self, device_id: str, action_name: str) -> bool:
        """检查该action是否标记为always_free，通过HostNode统一的_action_value_mappings查找"""
        try:
            host_node = HostNode.get_instance(0)
            if not host_node:
                return False
            # noinspection PyProtectedMember
            action_mappings = host_node._action_value_mappings.get(device_id)
            if not action_mappings:
                return False
            # 尝试直接匹配或 auto- 前缀匹配
            for key in [action_name, f"auto-{action_name}"]:
                if key in action_mappings:
                    return action_mappings[key].get("always_free", False)
            return False
        except Exception:
            return False
    async def _handle_query_action_state(self, data: Dict[str, Any]):
        """处理query_action_state消息"""
        device_id = data.get("device_id", "")
@@ -710,9 +608,6 @@ class MessageProcessor:
        device_action_key = f"/devices/{device_id}/{action_name}"
        # 检查action是否为always_free
        action_always_free = self._check_action_always_free(device_id, action_name)
        # 创建任务信息
        job_info = JobInfo(
            job_id=job_id,
@@ -722,7 +617,6 @@ class MessageProcessor:
            device_action_key=device_action_key,
            status=JobStatus.QUEUE,
            start_time=time.time(),
            always_free=action_always_free,
        )
        # 添加到设备管理器
@@ -734,13 +628,13 @@ class MessageProcessor:
            await self._send_action_state_response(
                device_id, action_name, task_id, job_id, "query_action_status", True, 0
            )
-            logger.trace(f"[MessageProcessor] Job {job_log} can start immediately")
+            logger.info(f"[MessageProcessor] Job {job_log} can start immediately")
        else:
            # 需要排队
            await self._send_action_state_response(
                device_id, action_name, task_id, job_id, "query_action_status", False, 10
            )
-            logger.trace(f"[MessageProcessor] Job {job_log} queued")
+            logger.info(f"[MessageProcessor] Job {job_log} queued")
            # 通知QueueProcessor有新的队列更新
            if self.queue_processor:
@@ -749,37 +643,9 @@ class MessageProcessor:
    async def _handle_job_start(self, data: Dict[str, Any]):
        """处理job_start消息"""
        try:
            if not data.get("sample_material"):
                data["sample_material"] = {}
            req = JobAddReq(**data)
            job_log = format_job_log(req.job_id, req.task_id, req.device_id, req.action)
            # 服务端对always_free动作可能跳过query_action_state直接发job_start，
            # 此时job尚未注册，需要自动补注册
            existing_job = self.device_manager.get_job_info(req.job_id)
            if not existing_job:
                action_name = req.action
                device_action_key = f"/devices/{req.device_id}/{action_name}"
                action_always_free = self._check_action_always_free(req.device_id, action_name)
                if action_always_free:
                    job_info = JobInfo(
                        job_id=req.job_id,
                        task_id=req.task_id,
                        device_id=req.device_id,
                        action_name=action_name,
                        device_action_key=device_action_key,
                        status=JobStatus.QUEUE,
                        start_time=time.time(),
                        always_free=True,
                    )
                    self.device_manager.add_queue_request(job_info)
                    logger.info(f"[MessageProcessor] Job {job_log} always_free, auto-registered from direct job_start")
                else:
                    logger.error(f"[MessageProcessor] Job {job_log} not registered (missing query_action_state)")
                    return
            success = self.device_manager.start_job(req.job_id)
            if not success:
                logger.error(f"[MessageProcessor] Failed to start job {job_log}")
@@ -808,7 +674,6 @@ class MessageProcessor:
                queue_item,
                action_type=req.action_type,
                action_kwargs=req.action_args,
                sample_material=req.sample_material,
                server_info=req.server_info,
            )
@@ -973,7 +838,9 @@ class MessageProcessor:
                        device_action_groups[key_add] = []
                    device_action_groups[key_add].append(item["uuid"])
-                    logger.info(f"[资源同步] 跨站Transfer: {item['uuid'][:8]} from {device_old_id} to {device_id}")
+                    logger.info(
                        f"[MessageProcessor] Resource migrated: {item['uuid'][:8]} from {device_old_id} to {device_id}"
                    )
                else:
                    # 正常update
                    key = (device_id, "update")
@@ -987,13 +854,11 @@ class MessageProcessor:
                    device_action_groups[key] = []
                device_action_groups[key].append(item["uuid"])
-        logger.trace(
+        logger.info(f"触发物料更新 {action} 分组数量: {len(device_action_groups)}, 总数量: {len(resource_uuid_list)}")
            f"[资源同步] 动作 {action} 分组数量: {len(device_action_groups)}, 总数量: {len(resource_uuid_list)}"
        )
        # 为每个(device_id, action)创建独立的更新线程
        for (device_id, actual_action), items in device_action_groups.items():
-            logger.trace(f"[资源同步] {device_id} 物料动作 {actual_action} 数量: {len(items)}")
+            logger.info(f"设备 {device_id} 物料更新 {actual_action} 数量: {len(items)}")
            def _notify_resource_tree(dev_id, act, item_list):
                try:
@@ -1025,80 +890,19 @@ class MessageProcessor:
            )
            thread.start()
-    async def _handle_device_manage(self, device_list: list[ResourceDictType], action: str):
+    async def _handle_request_reload(self, data: Dict[str, Any]):
        """Handle add_device / remove_device from LabGo server."""
        if not device_list:
            return
        for item in device_list:
            target_node_id = item.get("target_node_id", "host_node")
            def _notify(target_id: str, act: str, cfg: ResourceDictType):
                try:
                    host_node = HostNode.get_instance(timeout=5)
                    if not host_node:
                        logger.error(f"[DeviceManage] HostNode not available for {act}_device")
                        return
                    success = host_node.notify_device_manage(target_id, act, cfg)
                    if success:
                        logger.info(f"[DeviceManage] {act}_device completed on {target_id}")
                    else:
                        logger.warning(f"[DeviceManage] {act}_device failed on {target_id}")
                except Exception as e:
                    logger.error(f"[DeviceManage] Error in {act}_device: {e}")
                    logger.error(traceback.format_exc())
            thread = threading.Thread(
                target=_notify,
                args=(target_node_id, action, item),
                daemon=True,
                name=f"DeviceManage-{action}-{item.get('id', '')}",
            )
            thread.start()
    async def _handle_request_restart(self, data: Dict[str, Any]):
        """
-        处理重启请求
+        处理重载请求
-        当LabGo发送request_restart时，执行清理并触发重启
+        当LabGo发送request_reload时，重新发送设备注册信息
        """
        reason = data.get("reason", "unknown")
-        delay = data.get("delay", 2)  # 默认延迟2秒
+        logger.info(f"[MessageProcessor] Received reload request, reason: {reason}")
        logger.info(f"[MessageProcessor] Received restart request, reason: {reason}, delay: {delay}s")
-        # 发送确认消息
+        # 重新发送host_node_ready信息
-        self.send_message(
+        if self.websocket_client:
-            {"action": "restart_acknowledged", "data": {"reason": reason, "delay": delay}}
+            self.websocket_client.publish_host_ready()
-        )
+            logger.info("[MessageProcessor] Re-sent host_node_ready after reload request")
        # 设置全局重启标志
        import unilabos.app.main as main_module
        main_module._restart_requested = True
        main_module._restart_reason = reason
        # 延迟后执行清理
        await asyncio.sleep(delay)
        # 在新线程中执行清理，避免阻塞当前事件循环
        def do_cleanup():
            import time
            time.sleep(0.5)  # 给当前消息处理完成的时间
            logger.info(f"[MessageProcessor] Starting cleanup for restart, reason: {reason}")
            try:
                from unilabos.app.utils import cleanup_for_restart
                if cleanup_for_restart():
                    logger.info("[MessageProcessor] Cleanup successful, main() will restart")
                else:
                    logger.error("[MessageProcessor] Cleanup failed")
            except Exception as e:
                logger.error(f"[MessageProcessor] Error during cleanup: {e}")
        cleanup_thread = threading.Thread(target=do_cleanup, name="RestartCleanupThread", daemon=True)
        cleanup_thread.start()
        logger.info(f"[MessageProcessor] Restart cleanup scheduled")
    async def _send_action_state_response(
        self, device_id: str, action_name: str, task_id: str, job_id: str, typ: str, free: bool, need_more: int
@@ -1113,7 +917,7 @@ class MessageProcessor:
                "task_id": task_id,
                "job_id": job_id,
                "free": free,
-                "need_more": need_more + 1,
+                "need_more": need_more,
            },
        }
@@ -1171,14 +975,13 @@ class QueueProcessor:
    def stop(self) -> None:
        """停止队列处理线程"""
        self.is_running = False
        self.queue_update_event.set()  # 立即唤醒等待中的线程
        if self.thread and self.thread.is_alive():
            self.thread.join(timeout=2)
        logger.info("[QueueProcessor] Stopped")
    def _run(self):
        """运行队列处理主循环"""
-        logger.trace("[QueueProcessor] Queue processor started")
+        logger.debug("[QueueProcessor] Queue processor started")
        while self.is_running:
            try:
@@ -1253,7 +1056,7 @@ class QueueProcessor:
                    "task_id": job_info.task_id,
                    "job_id": job_info.job_id,
                    "free": False,
-                    "need_more": 10 + 1,
+                    "need_more": 10,
                },
            }
            self.message_processor.send_message(message)
@@ -1269,20 +1072,9 @@ class QueueProcessor:
        if not queued_jobs:
            return
-        queue_summary = {}
+        logger.debug(f"[QueueProcessor] Sending busy status for {len(queued_jobs)} queued jobs")
        for j in queued_jobs:
            key = f"{j.device_id}/{j.action_name}"
            queue_summary[key] = queue_summary.get(key, 0) + 1
        logger.debug(
            f"[QueueProcessor] Sending busy status for {len(queued_jobs)} queued jobs: {queue_summary}"
        )
        for job_info in queued_jobs:
            # 快照可能已过期：在遍历过程中 end_job() 可能已将此 job 移至 READY，
            # 此时不应再发送 busy/need_more，否则会覆盖已发出的 free=True 通知
            if job_info.status != JobStatus.QUEUE:
                continue
            message = {
                "action": "report_action_state",
                "data": {
@@ -1292,13 +1084,13 @@ class QueueProcessor:
                    "task_id": job_info.task_id,
                    "job_id": job_info.job_id,
                    "free": False,
-                    "need_more": 10 + 1,
+                    "need_more": 10,
                },
            }
            success = self.message_processor.send_message(message)
            job_log = format_job_log(job_info.job_id, job_info.task_id, job_info.device_id, job_info.action_name)
            if success:
-                logger.trace(f"[QueueProcessor] Sent busy/need_more for queued job {job_log}")
+                logger.debug(f"[QueueProcessor] Sent busy/need_more for queued job {job_log}")
            else:
                logger.warning(f"[QueueProcessor] Failed to send busy status for job {job_log}")
@@ -1321,7 +1113,7 @@ class QueueProcessor:
            job_info.action_name,
        )
-        logger.trace(f"[QueueProcessor] Job {job_log} completed with status: {status}")
+        logger.info(f"[QueueProcessor] Job {job_log} completed with status: {status}")
        # 结束任务，获取下一个可执行的任务
        next_job = self.device_manager.end_job(job_id)
@@ -1341,8 +1133,8 @@ class QueueProcessor:
                },
            }
            self.message_processor.send_message(message)
-            # next_job_log = format_job_log(next_job.job_id, next_job.task_id, next_job.device_id, next_job.action_name)
+            next_job_log = format_job_log(next_job.job_id, next_job.task_id, next_job.device_id, next_job.action_name)
-            # logger.debug(f"[QueueProcessor] Notified next job {next_job_log} can start")
+            logger.info(f"[QueueProcessor] Notified next job {next_job_log} can start")
            # 立即触发下一轮状态检查
            self.notify_queue_update()
@@ -1375,10 +1167,6 @@ class WebSocketClient(BaseCommunicationClient):
        self.message_processor = MessageProcessor(self.websocket_url, self.send_queue, self.device_manager)
        self.queue_processor = QueueProcessor(self.device_manager, self.message_processor)
        # running状态debounce缓存: {job_id: (last_send_timestamp, last_feedback_data)}
        self._job_running_last_sent: Dict[str, tuple] = {}
        self._job_running_debounce_interval: float = 10.0  # 秒
        # 设置相互引用
        self.message_processor.set_queue_processor(self.queue_processor)
        self.message_processor.set_websocket_client(self)
@@ -1403,6 +1191,7 @@ class WebSocketClient(BaseCommunicationClient):
        else:
            url = f"{scheme}://{parsed.netloc}/api/v1/ws/schedule"
        logger.debug(f"[WebSocketClient] URL: {url}")
        return url
    def start(self) -> None:
@@ -1415,11 +1204,13 @@ class WebSocketClient(BaseCommunicationClient):
            logger.error("[WebSocketClient] WebSocket URL not configured")
            return
        logger.info(f"[WebSocketClient] Starting connection to {self.websocket_url}")
        # 启动两个核心线程
        self.message_processor.start()
        self.queue_processor.start()
-        logger.trace("[WebSocketClient] All threads started")
+        logger.info("[WebSocketClient] All threads started")
    def stop(self) -> None:
        """停止WebSocket客户端"""
@@ -1435,8 +1226,8 @@ class WebSocketClient(BaseCommunicationClient):
                message = {"action": "normal_exit", "data": {"session_id": session_id}}
                self.message_processor.send_message(message)
                logger.info(f"[WebSocketClient] Sent normal_exit message with session_id: {session_id}")
-                # send_handler 每100ms检查一次队列，等300ms足以让消息发出
+                # 给一点时间让消息发送出去
-                time.sleep(0.3)
+                time.sleep(1)
            except Exception as e:
                logger.warning(f"[WebSocketClient] Failed to send normal_exit message: {str(e)}")
@@ -1468,7 +1259,7 @@ class WebSocketClient(BaseCommunicationClient):
            },
        }
        self.message_processor.send_message(message)
-        # logger.trace(f"[WebSocketClient] Device status published: {device_id}.{property_name}")
+        logger.trace(f"[WebSocketClient] Device status published: {device_id}.{property_name}")
    def publish_job_status(
        self, feedback_data: dict, item: QueueItem, status: str, return_info: Optional[dict] = None
@@ -1478,32 +1269,22 @@ class WebSocketClient(BaseCommunicationClient):
            logger.debug(f"[WebSocketClient] Not connected, cannot publish job status for job_id: {item.job_id}")
            return
        job_log = format_job_log(item.job_id, item.task_id, item.device_id, item.action_name)
        # 拦截最终结果状态，与原版本逻辑一致
        if status in ["success", "failed"]:
            self._job_running_last_sent.pop(item.job_id, None)
            host_node = HostNode.get_instance(0)
            if host_node:
                # 从HostNode的device_action_status中移除job_id
                try:
                    host_node._device_action_status[item.device_action_key].job_ids.pop(item.job_id, None)
                except (KeyError, AttributeError):
                    logger.warning(f"[WebSocketClient] Failed to remove job {item.job_id} from HostNode status")
            logger.info(f"[WebSocketClient] Intercepting final status for job_id: {item.job_id} - {status}")
            # 通知队列处理器job完成（包括timeout的job）
            self.queue_processor.handle_job_completed(item.job_id, status)
-        # running状态按job_id做debounce，内容变化时仍然上报
+        # 发送job状态消息
        if status == "running":
            now = time.time()
            cached = self._job_running_last_sent.get(item.job_id)
            if cached is not None:
                last_ts, last_data = cached
                if now - last_ts < self._job_running_debounce_interval and last_data == feedback_data:
                    logger.trace(f"[WebSocketClient] Job status debounced (skip): {job_log} - {status}")
                    return
            self._job_running_last_sent[item.job_id] = (now, feedback_data)
        message = {
            "action": "job_status",
            "data": {
@@ -1519,6 +1300,7 @@ class WebSocketClient(BaseCommunicationClient):
        }
        self.message_processor.send_message(message)
        job_log = format_job_log(item.job_id, item.task_id, item.device_id, item.action_name)
        logger.trace(f"[WebSocketClient] Job status published: {job_log} - {status}")
    def send_ping(self, ping_id: str, timestamp: float) -> None:
@@ -1564,9 +1346,7 @@ class WebSocketClient(BaseCommunicationClient):
            if host_node:
                # 获取设备信息
                for device_id, namespace in host_node.devices_names.items():
-                    device_key = (
+                    device_key = f"{namespace}/{device_id}" if namespace.startswith("/") else f"/{namespace}/{device_id}"
                        f"{namespace}/{device_id}" if namespace.startswith("/") else f"/{namespace}/{device_id}"
                    )
                    is_online = device_key in host_node._online_devices
                    # 获取设备的动作信息
@@ -1580,16 +1360,14 @@ class WebSocketClient(BaseCommunicationClient):
                                "action_type": str(type(client).__name__),
                            }
-                    devices.append(
+                    devices.append({
                        {
                        "device_id": device_id,
                        "namespace": namespace,
                        "device_key": device_key,
                        "is_online": is_online,
                        "machine_name": host_node.device_machine_names.get(device_id, machine_name),
                        "actions": actions,
-                        }
+                    })
                    )
                logger.info(f"[WebSocketClient] Collected {len(devices)} devices for host_ready")
        except Exception as e:
--- a/unilabos/compile/pump_protocol.py
+++ b/unilabos/compile/pump_protocol.py
@@ -95,29 +95,8 @@ def get_vessel_liquid_volume(G: nx.DiGraph, vessel: str) -> float:
    return total_volume
-def is_integrated_pump(node_class: str, node_name: str = "") -> bool:
+def is_integrated_pump(node_name):
-    """
+    return "pump" in node_name and "valve" in node_name
    判断是否为泵阀一体设备
    """
    class_lower = (node_class or "").lower()
    name_lower = (node_name or "").lower()
    if "pump" not in class_lower and "pump" not in name_lower:
        return False
    integrated_markers = [
        "valve",
        "pump_valve",
        "pumpvalve",
        "integrated",
        "transfer_pump",
    ]
    for marker in integrated_markers:
        if marker in class_lower or marker in name_lower:
            return True
    return False
 def find_connected_pump(G, valve_node):
@@ -207,9 +186,7 @@ def build_pump_valve_maps(G, pump_backbone):
    debug_print(f"🔧 过滤后的骨架: {filtered_backbone}")
    for node in filtered_backbone:
-        node_data = G.nodes.get(node, {})
+        if is_integrated_pump(G.nodes[node]["class"]):
        node_class = node_data.get("class", "") or ""
        if is_integrated_pump(node_class, node):
            pumps_from_node[node] = node
            valve_from_node[node] = node
            debug_print(f"  - 集成泵-阀: {node}")
--- a/unilabos/config/config.py
+++ b/unilabos/config/config.py
@@ -16,17 +16,12 @@ class BasicConfig:
    upload_registry = False
    machine_name = "undefined"
    vis_2d_enable = False
    no_update_feedback = False
    enable_resource_load = True
    communication_protocol = "websocket"
    startup_json_path = None  # 填写绝对路径
    disable_browser = False  # 禁止浏览器自动打开
    port = 8002  # 本地HTTP服务
-    check_mode = False  # CI 检查模式，用于验证 registry 导入和文件一致性
+    log_level: Literal['TRACE', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'] = "DEBUG"  # 'TRACE', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'
    test_mode = False  # 测试模式，所有动作不实际执行，返回模拟结果
    extra_resource = False  # 是否加载lab_开头的额外资源
    # 'TRACE', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'
    log_level: Literal["TRACE", "DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] = "DEBUG"
    @classmethod
    def auth_secret(cls):
@@ -41,12 +36,12 @@ class BasicConfig:
 class WSConfig:
    reconnect_interval = 5  # 重连间隔（秒）
    max_reconnect_attempts = 999  # 最大重连次数
-    ping_interval = 20  # ping间隔（秒）
+    ping_interval = 30  # ping间隔（秒）
 # HTTP配置
 class HTTPConfig:
-    remote_addr = "https://leap-lab.bohrium.com/api/v1"
+    remote_addr = "https://uni-lab.bohrium.com/api/v1"
 # ROS配置
@@ -70,7 +65,6 @@ def _update_config_from_module(module):
                    if not attr.startswith("_"):
                        setattr(obj, attr, getattr(getattr(module, name), attr))
 def _update_config_from_env():
    prefix = "UNILABOS_"
    for env_key, env_value in os.environ.items():
@@ -147,5 +141,5 @@ def load_config(config_path=None):
            traceback.print_exc()
            exit(1)
    else:
-        config_path = os.path.join(os.path.dirname(__file__), "example_config.py")
+        config_path = os.path.join(os.path.dirname(__file__), "local_config.py")
        load_config(config_path)
--- a/unilabos/device_comms/coin_cell_assembly_workstation.py
+++ b/unilabos/device_comms/coin_cell_assembly_workstation.py
@@ -6,7 +6,7 @@ Coin Cell Assembly Workstation
 """
 from typing import Dict, Any, List, Optional, Union
-from unilabos.resources.resource_tracker import DeviceNodeResourceTracker
+from unilabos.ros.nodes.resource_tracker import DeviceNodeResourceTracker
 from unilabos.device_comms.workstation_base import WorkstationBase, WorkflowInfo
 from unilabos.device_comms.workstation_communication import (
    WorkstationCommunicationBase, CommunicationConfig, CommunicationProtocol, CoinCellCommunication
@@ -61,7 +61,7 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
        # 创建资源跟踪器（如果没有提供）
        if resource_tracker is None:
-            from unilabos.resources.resource_tracker import DeviceNodeResourceTracker
+            from unilabos.ros.nodes.resource_tracker import DeviceNodeResourceTracker
            resource_tracker = DeviceNodeResourceTracker()
        # 初始化基类
--- a/unilabos/device_comms/opcua_client/client.py
+++ b/unilabos/device_comms/opcua_client/client.py
--- a/unilabos/device_comms/universal_driver.py
+++ b/unilabos/device_comms/universal_driver.py
@@ -1,3 +1,4 @@
 from abc import abstractmethod
 from functools import wraps
 import inspect
--- a/unilabos/devices/liquid_handling/biomek.py
+++ b/unilabos/devices/liquid_handling/biomek.py
@@ -13,7 +13,7 @@ from pylabrobot.resources import (
 import copy
 from unilabos_msgs.msg import Resource
-from unilabos.resources.resource_tracker import DeviceNodeResourceTracker  # type: ignore
+from unilabos.ros.nodes.resource_tracker import DeviceNodeResourceTracker  # type: ignore
 class LiquidHandlerBiomek:
--- a/unilabos/devices/liquid_handling/liquid_handler_abstract.py
+++ b/unilabos/devices/liquid_handling/liquid_handler_abstract.py
@@ -1,11 +1,15 @@
 from __future__ import annotations
 import asyncio
 import time
 import traceback
 from collections import Counter
 from typing import List, Sequence, Optional, Literal, Union, Iterator, Dict, Any, Callable, Set, cast
 from typing_extensions import TypedDict
 from pylabrobot.liquid_handling import LiquidHandler, LiquidHandlerBackend, LiquidHandlerChatterboxBackend, Strictness
 from unilabos.devices.liquid_handling.rviz_backend import UniLiquidHandlerRvizBackend
 from unilabos.devices.liquid_handling.laiyu.backend.laiyu_v_backend import UniLiquidHandlerLaiyuBackend
 from pylabrobot.liquid_handling.liquid_handler import TipPresenceProbingMethod
 from pylabrobot.liquid_handling.standard import GripDirection
 from pylabrobot.resources import (
@@ -21,55 +25,24 @@ from pylabrobot.resources import (
    ResourceHolder,
    Lid,
    Trash,
-    Tip, TubeRack,
+    Tip,
 )
 from typing_extensions import TypedDict
 from unilabos.devices.liquid_handling.rviz_backend import UniLiquidHandlerRvizBackend
 from unilabos.registry.placeholder_type import ResourceSlot
 from unilabos.resources.resource_tracker import (
    ResourceTreeSet,
    ResourceDict,
    EXTRA_SAMPLE_UUID,
    EXTRA_UNILABOS_SAMPLE_UUID,
 )
 from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode, ROS2DeviceNode
 from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
 class SimpleReturn(TypedDict):
-    samples: List[List[ResourceDict]]
+    samples: list
-    volumes: List[float]
+    volumes: list
 class SetLiquidReturn(TypedDict):
    wells: List[List[ResourceDict]]
    volumes: List[float]
 class SetLiquidFromPlateReturn(TypedDict):
    plate: List[List[ResourceDict]]
    wells: List[List[ResourceDict]]
    volumes: List[float]
 class TransferLiquidReturn(TypedDict):
    sources: List[List[ResourceDict]]
    targets: List[List[ResourceDict]]
 class LiquidHandlerMiddleware(LiquidHandler):
-    def __init__(
+    def __init__(self, backend: LiquidHandlerBackend, deck: Deck, simulator: bool = False, channel_num: int = 8, **kwargs):
        self, backend: LiquidHandlerBackend, deck: Deck, simulator: bool = False, channel_num: int = 8, **kwargs
    ):
        self._simulator = simulator
        self.channel_num = channel_num
        self.pending_liquids_dict = {}
        joint_config = kwargs.get("joint_config", None)
        if simulator:
            if joint_config:
-                self._simulate_backend = UniLiquidHandlerRvizBackend(
+                self._simulate_backend = UniLiquidHandlerRvizBackend(channel_num, kwargs["total_height"],
-                    channel_num, kwargs["total_height"], joint_config=joint_config, lh_device_id=deck.name
+                                                                     joint_config=joint_config, lh_device_id=deck.name)
                )
            else:
                self._simulate_backend = LiquidHandlerChatterboxBackend(channel_num)
            self._simulate_handler = LiquidHandlerAbstract(self._simulate_backend, deck, False)
@@ -186,9 +159,7 @@ class LiquidHandlerMiddleware(LiquidHandler):
        if not offsets or (isinstance(offsets, list) and len(offsets) != len(use_channels)):
            offsets = [Coordinate.zero()] * len(use_channels)
        if self._simulator:
-            return await self._simulate_handler.discard_tips(
+            return await self._simulate_handler.discard_tips(use_channels, allow_nonzero_volume, offsets, **backend_kwargs)
                use_channels, allow_nonzero_volume, offsets, **backend_kwargs
            )
        await super().discard_tips(use_channels, allow_nonzero_volume, offsets, **backend_kwargs)
        self.pending_liquids_dict = {}
        return 
@@ -209,6 +180,7 @@ class LiquidHandlerMiddleware(LiquidHandler):
        **backend_kwargs,
    ):
        if self._simulator:
            return await self._simulate_handler.aspirate(
                resources,
@@ -236,15 +208,15 @@ class LiquidHandlerMiddleware(LiquidHandler):
        res_samples = []
        res_volumes = []
        for resource, volume, channel in zip(resources, vols, use_channels):
-            sample_uuid_value = resource.unilabos_extra.get(EXTRA_SAMPLE_UUID, None)
+            res_samples.append({"name": resource.name, "sample_uuid": resource.unilabos_extra.get("sample_uuid", None)})
            res_samples.append({"name": resource.name, EXTRA_SAMPLE_UUID: sample_uuid_value})
            res_volumes.append(volume)
            self.pending_liquids_dict[channel] = {
-                EXTRA_SAMPLE_UUID: sample_uuid_value,
+                "sample_uuid": resource.unilabos_extra.get("sample_uuid", None),
-                "volume": volume,
+                "volume": volume
            }
        return SimpleReturn(samples=res_samples, volumes=res_volumes)
    async def dispense(
        self,
        resources: Sequence[Container],
@@ -282,10 +254,10 @@ class LiquidHandlerMiddleware(LiquidHandler):
        res_samples = []
        res_volumes = []
        for resource, volume, channel in zip(resources, vols, use_channels):
-            res_uuid = self.pending_liquids_dict[channel][EXTRA_SAMPLE_UUID]
+            res_uuid = self.pending_liquids_dict[channel]["sample_uuid"]
            self.pending_liquids_dict[channel]["volume"] -= volume
-            resource.unilabos_extra[EXTRA_SAMPLE_UUID] = res_uuid
+            resource.unilabos_extra["sample_uuid"] = res_uuid
-            res_samples.append({"name": resource.name, EXTRA_SAMPLE_UUID: res_uuid})
+            res_samples.append({"name": resource.name, "sample_uuid": res_uuid})
            res_volumes.append(volume)
        return SimpleReturn(samples=res_samples, volumes=res_volumes)
@@ -606,18 +578,10 @@ class LiquidHandlerMiddleware(LiquidHandler):
 class LiquidHandlerAbstract(LiquidHandlerMiddleware):
    """Extended LiquidHandler with additional operations."""
    support_touch_tip = True
    _ros_node: BaseROS2DeviceNode
-    def __init__(
+    def __init__(self, backend: LiquidHandlerBackend, deck: Deck, simulator: bool=False, channel_num:int = 8, total_height:float = 310):
        self,
        backend: LiquidHandlerBackend,
        deck: Deck,
        simulator: bool = False,
        channel_num: int = 8,
        total_height: float = 310,
    ):
        """Initialize a LiquidHandler.
        Args:
@@ -641,7 +605,6 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                        module_name = ".".join(components[:-1])
                        try:
                            import importlib
                            mod = importlib.import_module(module_name)
                        except ImportError:
                            mod = None
@@ -651,7 +614,6 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                        # Try pylabrobot style import (if available)
                        try:
                            import pylabrobot
                            backend_cls = getattr(pylabrobot, type_str, None)
                        except Exception:
                            backend_cls = None
@@ -669,68 +631,16 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
        self._ros_node = ros_node
    @classmethod
-    def set_liquid(cls, wells: list[Well], liquid_names: list[str], volumes: list[float]) -> SetLiquidReturn:
+    def set_liquid(cls, wells: list[Well], liquid_names: list[str], volumes: list[float]) -> SimpleReturn:
-        """Set the liquid in a well.
+        """Set the liquid in a well."""
-
+        res_samples = []
        如果 liquid_names 和 volumes 为空，但 wells 不为空，直接返回 wells。
        """
        res_volumes = []
        # 如果 liquid_names 和 volumes 都为空，直接返回 wells
        if not liquid_names and not volumes:
            return SetLiquidReturn(
                wells=ResourceTreeSet.from_plr_resources(wells, known_newly_created=False).dump(), volumes=res_volumes  # type: ignore
            )
        for well, liquid_name, volume in zip(wells, liquid_names, volumes):
            well.set_liquids([(liquid_name, volume)])  # type: ignore
            res_samples.append({"name": well.name, "sample_uuid": well.unilabos_extra.get("sample_uuid", None)})
            res_volumes.append(volume)
-        return SetLiquidReturn(
+        return SimpleReturn(samples=res_samples, volumes=res_volumes)
            wells=ResourceTreeSet.from_plr_resources(wells, known_newly_created=False).dump(), volumes=res_volumes  # type: ignore
        )
    def set_liquid_from_plate(
        self, plate: ResourceSlot, well_names: list[str], liquid_names: list[str], volumes: list[float]
    ) -> SetLiquidFromPlateReturn:
        """Set the liquid in wells of a plate by well names (e.g., A1, A2, B3).
        如果 liquid_names 和 volumes 为空，但 plate 和 well_names 不为空，直接返回 plate 和 wells。
        """
        assert issubclass(plate.__class__, Plate) or issubclass(plate.__class__, TubeRack) , f"plate must be a Plate, now: {type(plate)}"
        plate: Union[Plate, TubeRack]
        # 根据 well_names 获取对应的 Well 对象
        if issubclass(plate.__class__, Plate):
            wells = [plate.get_well(name) for name in well_names]
        elif issubclass(plate.__class__, TubeRack):
            wells = [plate.get_tube(name) for name in well_names]
        res_volumes = []
        # 如果 liquid_names 和 volumes 都为空，直接返回
        if not liquid_names and not volumes:
            return SetLiquidFromPlateReturn(
                plate=ResourceTreeSet.from_plr_resources([plate], known_newly_created=False).dump(),  # type: ignore
                wells=ResourceTreeSet.from_plr_resources(wells, known_newly_created=False).dump(),  # type: ignore
                volumes=res_volumes,
            )
        for well, liquid_name, volume in zip(wells, liquid_names, volumes):
            well.set_liquids([(liquid_name, volume)])  # type: ignore
            res_volumes.append(volume)
        task = ROS2DeviceNode.run_async_func(self._ros_node.update_resource, True, **{"resources": wells})
        submit_time = time.time()
        while not task.done():
            if time.time() - submit_time > 10:
                self._ros_node.lab_logger().info(f"set_liquid_from_plate {plate} 超时")
                break
            time.sleep(0.01)
        return SetLiquidFromPlateReturn(
            plate=ResourceTreeSet.from_plr_resources([plate], known_newly_created=False).dump(),  # type: ignore
            wells=ResourceTreeSet.from_plr_resources(wells, known_newly_created=False).dump(),  # type: ignore
            volumes=res_volumes,
        )
    # ---------------------------------------------------------------
    # REMOVE LIQUID --------------------------------------------------
    # ---------------------------------------------------------------
@@ -766,7 +676,7 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                target_rack = child
        target_rack = cast(TipRack, target_rack)
        available_tips = {}
-        for idx, tipSpot in enumerate(target_rack.get_all_items()):
+        for (idx, tipSpot) in enumerate(target_rack.get_all_items()):
            if tipSpot.has_tip():
                available_tips[idx] = tipSpot
                continue
@@ -774,8 +684,8 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
        print("channel_num", self.channel_num)
        if self.channel_num == 8:
-            tip_prefix = list(available_tips.values())[0].name.split("_")[0]
+            tip_prefix = list(available_tips.values())[0].name.split('_')[0]
-            colnum_list = [int(tip.name.split("_")[-1][1:]) for tip in available_tips.values()]
+            colnum_list = [int(tip.name.split('_')[-1][1:]) for tip in available_tips.values()]
            available_cols = [colnum for colnum, count in dict(Counter(colnum_list)).items() if count == 8]
            available_cols.sort() 
            available_tips_dict = {tip.name: tip for tip in available_tips.values()}
@@ -819,6 +729,7 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
        """Create a new protocol with the given metadata."""
        pass
    async def remove_liquid(
        self,
        vols: List[float],
@@ -877,11 +788,10 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                elif len(use_channels) == 8 and self.backend.num_channels == 8:
                    # 对于8个的情况，需要判断此时任务是不是能被8通道移液站来成功处理
                    if len(sources) % 8 != 0:
-                        raise ValueError(
+                        raise ValueError(f"Length of `sources` {len(sources)} must be a multiple of 8 for 8-channel mode.")
                            f"Length of `sources` {len(sources)} must be a multiple of 8 for 8-channel mode."
                        )
                    # 8个8个来取任务序列
@@ -895,23 +805,13 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                        current_asp_vols = vols[i:i + 8]
                        current_dis_vols = vols[i:i + 8]
                        current_asp_flow_rates = flow_rates[i:i + 8] if flow_rates else [None] * 8
-                        current_dis_flow_rates = (
+                        current_dis_flow_rates = flow_rates[-i*8-8:len(flow_rates)-i*8] if flow_rates else [None] * 8
                            flow_rates[-i * 8 - 8 : len(flow_rates) - i * 8] if flow_rates else [None] * 8
                        )
                        current_asp_offset = offsets[i:i + 8] if offsets else [None] * 8
                        current_dis_offset = offsets[-i*8-8:len(offsets)-i*8] if offsets else [None] * 8
                        current_asp_liquid_height = liquid_height[i:i + 8] if liquid_height else [None] * 8
-                        current_dis_liquid_height = (
+                        current_dis_liquid_height = liquid_height[-i*8-8:len(liquid_height)-i*8] if liquid_height else [None] * 8
-                            liquid_height[-i * 8 - 8 : len(liquid_height) - i * 8] if liquid_height else [None] * 8
+                        current_asp_blow_out_air_volume = blow_out_air_volume[i:i + 8] if blow_out_air_volume else [None] * 8
-                        )
+                        current_dis_blow_out_air_volume = blow_out_air_volume[-i*8-8:len(blow_out_air_volume)-i*8] if blow_out_air_volume else [None] * 8
                        current_asp_blow_out_air_volume = (
                            blow_out_air_volume[i : i + 8] if blow_out_air_volume else [None] * 8
                        )
                        current_dis_blow_out_air_volume = (
                            blow_out_air_volume[-i * 8 - 8 : len(blow_out_air_volume) - i * 8]
                            if blow_out_air_volume
                            else [None] * 8
                        )
                        await self.aspirate(
                            resources=current_reagent_sources,
@@ -1041,23 +941,13 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                        current_asp_vols = asp_vols[i:i + 8]
                        current_dis_vols = dis_vols[i:i + 8]
                        current_asp_flow_rates = flow_rates[i:i + 8] if flow_rates else [None] * 8
-                    current_dis_flow_rates = (
+                        current_dis_flow_rates = flow_rates[-i*8-8:len(flow_rates)-i*8] if flow_rates else [None] * 8
                        flow_rates[-i * 8 - 8 : len(flow_rates) - i * 8] if flow_rates else [None] * 8
                    )
                        current_asp_offset = offsets[i:i + 8] if offsets else [None] * 8
                        current_dis_offset = offsets[-i*8-8:len(offsets)-i*8] if offsets else [None] * 8
                        current_asp_liquid_height = liquid_height[i:i + 8] if liquid_height else [None] * 8
-                    current_dis_liquid_height = (
+                        current_dis_liquid_height = liquid_height[-i*8-8:len(liquid_height)-i*8] if liquid_height else [None] * 8
-                        liquid_height[-i * 8 - 8 : len(liquid_height) - i * 8] if liquid_height else [None] * 8
+                        current_asp_blow_out_air_volume = blow_out_air_volume[i:i + 8] if blow_out_air_volume else [None] * 8
-                    )
+                        current_dis_blow_out_air_volume = blow_out_air_volume[-i*8-8:len(blow_out_air_volume)-i*8] if blow_out_air_volume else [None] * 8
                    current_asp_blow_out_air_volume = (
                        blow_out_air_volume[i : i + 8] if blow_out_air_volume else [None] * 8
                    )
                    current_dis_blow_out_air_volume = (
                        blow_out_air_volume[-i * 8 - 8 : len(blow_out_air_volume) - i * 8]
                        if blow_out_air_volume
                        else [None] * 8
                    )
                        await self.aspirate(
                            resources=current_reagent_sources,
@@ -1099,6 +989,7 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                        await self.touch_tip(current_targets)
                        await self.discard_tips()
        # except Exception as e:
        #     traceback.print_exc()
        #     raise RuntimeError(f"Liquid addition failed: {e}") from e
@@ -1130,7 +1021,7 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
        mix_liquid_height: Optional[float] = None,
        delays: Optional[List[int]] = None,
        none_keys: List[str] = [],
-    ) -> TransferLiquidReturn:
+    ):
        """Transfer liquid with automatic mode detection.
        Supports three transfer modes:
@@ -1198,71 +1089,29 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
        if num_sources == 1 and num_targets > 1:
            # 模式1: 一对多 (1 source -> N targets)
            await self._transfer_one_to_many(
-                sources[0],
+                sources[0], targets, tip_racks, use_channels,
-                targets,
+                asp_vols, dis_vols, asp_flow_rates, dis_flow_rates,
-                tip_racks,
+                offsets, touch_tip, liquid_height, blow_out_air_volume,
-                use_channels,
+                spread, mix_stage, mix_times, mix_vol, mix_rate,
-                asp_vols,
+                mix_liquid_height, delays
                dis_vols,
                asp_flow_rates,
                dis_flow_rates,
                offsets,
                touch_tip,
                liquid_height,
                blow_out_air_volume,
                spread,
                mix_stage,
                mix_times,
                mix_vol,
                mix_rate,
                mix_liquid_height,
                delays,
            )
        elif num_sources > 1 and num_targets == 1:
            # 模式2: 多对一 (N sources -> 1 target)
            await self._transfer_many_to_one(
-                sources,
+                sources, targets[0], tip_racks, use_channels,
-                targets[0],
+                asp_vols, dis_vols, asp_flow_rates, dis_flow_rates,
-                tip_racks,
+                offsets, touch_tip, liquid_height, blow_out_air_volume,
-                use_channels,
+                spread, mix_stage, mix_times, mix_vol, mix_rate,
-                asp_vols,
+                mix_liquid_height, delays
                dis_vols,
                asp_flow_rates,
                dis_flow_rates,
                offsets,
                touch_tip,
                liquid_height,
                blow_out_air_volume,
                spread,
                mix_stage,
                mix_times,
                mix_vol,
                mix_rate,
                mix_liquid_height,
                delays,
            )
        elif num_sources == num_targets:
            # 模式3: 一对一 (N sources -> N targets)
            await self._transfer_one_to_one(
-                sources,
+                sources, targets, tip_racks, use_channels,
-                targets,
+                asp_vols, dis_vols, asp_flow_rates, dis_flow_rates,
-                tip_racks,
+                offsets, touch_tip, liquid_height, blow_out_air_volume,
-                use_channels,
+                spread, mix_stage, mix_times, mix_vol, mix_rate,
-                asp_vols,
+                mix_liquid_height, delays
                dis_vols,
                asp_flow_rates,
                dis_flow_rates,
                offsets,
                touch_tip,
                liquid_height,
                blow_out_air_volume,
                spread,
                mix_stage,
                mix_times,
                mix_vol,
                mix_rate,
                mix_liquid_height,
                delays,
            )
        else:
            raise ValueError(
@@ -1270,11 +1119,6 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                "Supported modes: 1->N, N->1, or N->N."
            )
        return TransferLiquidReturn(
            sources=ResourceTreeSet.from_plr_resources(list(sources), known_newly_created=False).dump(),  # type: ignore
            targets=ResourceTreeSet.from_plr_resources(list(targets), known_newly_created=False).dump(),  # type: ignore
        )
    async def _transfer_one_to_one(
        self,
        sources: Sequence[Container],
@@ -1330,9 +1174,7 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                    flow_rates=[asp_flow_rates[_]] if asp_flow_rates and len(asp_flow_rates) > _ else None,
                    offsets=[offsets[_]] if offsets and len(offsets) > _ else None,
                    liquid_height=[liquid_height[_]] if liquid_height and len(liquid_height) > _ else None,
-                    blow_out_air_volume=(
+                    blow_out_air_volume=[blow_out_air_volume[_]] if blow_out_air_volume and len(blow_out_air_volume) > _ else None,
                        [blow_out_air_volume[_]] if blow_out_air_volume and len(blow_out_air_volume) > _ else None
                    ),
                    spread=spread,
                )
                if delays is not None:
@@ -1343,9 +1185,7 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                    use_channels=use_channels,
                    flow_rates=[dis_flow_rates[_]] if dis_flow_rates and len(dis_flow_rates) > _ else None,
                    offsets=[offsets[_]] if offsets and len(offsets) > _ else None,
-                    blow_out_air_volume=(
+                    blow_out_air_volume=[blow_out_air_volume[_]] if blow_out_air_volume and len(blow_out_air_volume) > _ else None,
                        [blow_out_air_volume[_]] if blow_out_air_volume and len(blow_out_air_volume) > _ else None
                    ),
                    liquid_height=[liquid_height[_]] if liquid_height and len(liquid_height) > _ else None,
                    spread=spread,
                )
@@ -1497,9 +1337,7 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                flow_rates=[asp_flow_rates[0]] if asp_flow_rates and len(asp_flow_rates) > 0 else None,
                offsets=[offsets[0]] if offsets and len(offsets) > 0 else None,
                liquid_height=[liquid_height[0]] if liquid_height and len(liquid_height) > 0 else None,
-                blow_out_air_volume=(
+                blow_out_air_volume=[blow_out_air_volume[0]] if blow_out_air_volume and len(blow_out_air_volume) > 0 else None,
                    [blow_out_air_volume[0]] if blow_out_air_volume and len(blow_out_air_volume) > 0 else None
                ),
                spread=spread,
            )
@@ -1514,9 +1352,7 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                    use_channels=use_channels,
                    flow_rates=[dis_flow_rates[idx]] if dis_flow_rates and len(dis_flow_rates) > idx else None,
                    offsets=[offsets[idx]] if offsets and len(offsets) > idx else None,
-                    blow_out_air_volume=(
+                    blow_out_air_volume=[blow_out_air_volume[idx]] if blow_out_air_volume and len(blow_out_air_volume) > idx else None,
                        [blow_out_air_volume[idx]] if blow_out_air_volume and len(blow_out_air_volume) > idx else None
                    ),
                    liquid_height=[liquid_height[idx]] if liquid_height and len(liquid_height) > idx else None,
                    spread=spread,
                )
@@ -1552,18 +1388,10 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                current_dis_vols = dis_vols[i:i + 8]
                # 8个通道都从同一个源容器吸液，每个通道的吸液体积等于对应的分液体积
-                current_asp_flow_rates = (
+                current_asp_flow_rates = asp_flow_rates[0:1] * 8 if asp_flow_rates and len(asp_flow_rates) > 0 else None
                    asp_flow_rates[0:1] * 8 if asp_flow_rates and len(asp_flow_rates) > 0 else None
                )
                current_asp_offset = offsets[0:1] * 8 if offsets and len(offsets) > 0 else [None] * 8
-                current_asp_liquid_height = (
+                current_asp_liquid_height = liquid_height[0:1] * 8 if liquid_height and len(liquid_height) > 0 else [None] * 8
-                    liquid_height[0:1] * 8 if liquid_height and len(liquid_height) > 0 else [None] * 8
+                current_asp_blow_out_air_volume = blow_out_air_volume[0:1] * 8 if blow_out_air_volume and len(blow_out_air_volume) > 0 else [None] * 8
                )
                current_asp_blow_out_air_volume = (
                    blow_out_air_volume[0:1] * 8
                    if blow_out_air_volume and len(blow_out_air_volume) > 0
                    else [None] * 8
                )
                if mix_stage in ["before", "both"] and mix_times is not None and mix_times > 0:
                    await self.mix(
@@ -1696,9 +1524,7 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                    flow_rates=[asp_flow_rates[idx]] if asp_flow_rates and len(asp_flow_rates) > idx else None,
                    offsets=[offsets[idx]] if offsets and len(offsets) > idx else None,
                    liquid_height=[liquid_height[idx]] if liquid_height and len(liquid_height) > idx else None,
-                    blow_out_air_volume=(
+                    blow_out_air_volume=[blow_out_air_volume[idx]] if blow_out_air_volume and len(blow_out_air_volume) > idx else None,
                        [blow_out_air_volume[idx]] if blow_out_air_volume and len(blow_out_air_volume) > idx else None
                    ),
                    spread=spread,
                )
@@ -1712,18 +1538,14 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                    dis_flow_rate = dis_flow_rates[idx] if dis_flow_rates and len(dis_flow_rates) > idx else None
                    dis_offset = offsets[idx] if offsets and len(offsets) > idx else None
                    dis_liquid_height = liquid_height[idx] if liquid_height and len(liquid_height) > idx else None
-                    dis_blow_out = (
+                    dis_blow_out = blow_out_air_volume[idx] if blow_out_air_volume and len(blow_out_air_volume) > idx else None
                        blow_out_air_volume[idx] if blow_out_air_volume and len(blow_out_air_volume) > idx else None
                    )
                else:
                    # 标准模式：分液体积等于吸液体积
                    dis_vol = asp_vols[idx]
                    dis_flow_rate = dis_flow_rates[0] if dis_flow_rates and len(dis_flow_rates) > 0 else None
                    dis_offset = offsets[0] if offsets and len(offsets) > 0 else None
                    dis_liquid_height = liquid_height[0] if liquid_height and len(liquid_height) > 0 else None
-                    dis_blow_out = (
+                    dis_blow_out = blow_out_air_volume[0] if blow_out_air_volume and len(blow_out_air_volume) > 0 else None
                        blow_out_air_volume[0] if blow_out_air_volume and len(blow_out_air_volume) > 0 else None
                    )
                await self.dispense(
                    resources=[target],
@@ -1806,18 +1628,14 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                    current_dis_flow_rates = dis_flow_rates[i:i + 8] if dis_flow_rates else None
                    current_dis_offset = offsets[i:i + 8] if offsets else [None] * 8
                    current_dis_liquid_height = liquid_height[i:i + 8] if liquid_height else [None] * 8
-                    current_dis_blow_out_air_volume = (
+                    current_dis_blow_out_air_volume = blow_out_air_volume[i:i + 8] if blow_out_air_volume else [None] * 8
                        blow_out_air_volume[i : i + 8] if blow_out_air_volume else [None] * 8
                    )
                else:
                    # 标准模式：每个通道分液体积等于其吸液体积
                    current_dis_vols = current_asp_vols
                    current_dis_flow_rates = dis_flow_rates[0:1] * 8 if dis_flow_rates else None
                    current_dis_offset = offsets[0:1] * 8 if offsets else [None] * 8
                    current_dis_liquid_height = liquid_height[0:1] * 8 if liquid_height else [None] * 8
-                    current_dis_blow_out_air_volume = (
+                    current_dis_blow_out_air_volume = blow_out_air_volume[0:1] * 8 if blow_out_air_volume else [None] * 8
                        blow_out_air_volume[0:1] * 8 if blow_out_air_volume else [None] * 8
                    )
                await self.dispense(
                    resources=[target] * 8,  # 8个通道都分到同一个目标
@@ -1853,6 +1671,7 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
    #     traceback.print_exc()
    #     raise RuntimeError(f"Liquid addition failed: {e}") from e
    # ---------------------------------------------------------------
    # Helper utilities
    # ---------------------------------------------------------------
@@ -1873,6 +1692,7 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                print(f"Current time: {time.strftime('%H:%M:%S')}")
    async def touch_tip(self, targets: Sequence[Container]):
        """Touch the tip to the side of the well."""
        if not self.support_touch_tip:
--- a/unilabos/devices/liquid_handling/prcxi/prcxi.py
+++ b/unilabos/devices/liquid_handling/prcxi/prcxi.py
@@ -30,32 +30,9 @@ from pylabrobot.liquid_handling.standard import (
    ResourceMove,
    ResourceDrop,
 )
-from pylabrobot.resources import (
+from pylabrobot.resources import ResourceHolder, ResourceStack, Tip, Deck, Plate, Well, TipRack, Resource, Container, Coordinate, TipSpot, Trash, PlateAdapter, TubeRack
    ResourceHolder,
    ResourceStack,
    Tip,
    Deck,
    Plate,
    Well,
    TipRack,
    Resource,
    Container,
    Coordinate,
    TipSpot,
    Trash,
    PlateAdapter,
    TubeRack,
 )
-from unilabos.devices.liquid_handling.liquid_handler_abstract import (
+from unilabos.devices.liquid_handling.liquid_handler_abstract import LiquidHandlerAbstract, SimpleReturn
    LiquidHandlerAbstract,
    SimpleReturn,
    SetLiquidReturn,
    SetLiquidFromPlateReturn,
    TransferLiquidReturn,
 )
 from unilabos.registry.placeholder_type import ResourceSlot
 from unilabos.resources.resource_tracker import ResourceTreeSet
 from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
@@ -91,103 +68,19 @@ class PRCXI9300Deck(Deck):
    该类定义了 PRCXI 9300 的工作台布局和槽位信息。
    """
-    # T1-T16 默认位置 (4列×4行)
+    def __init__(self, name: str, size_x: float, size_y: float, size_z: float, **kwargs):
-    _DEFAULT_SITE_POSITIONS = [
+        super().__init__(name, size_x, size_y, size_z)
-        (0, 0, 0), (138, 0, 0), (276, 0, 0), (414, 0, 0),         # T1-T4
+        self.slots = [None] * 16  # PRCXI 9300/9320 最大有 16 个槽位
-        (0, 96, 0), (138, 96, 0), (276, 96, 0), (414, 96, 0),     # T5-T8
+        self.slot_locations = [Coordinate(0, 0, 0)] * 16
        (0, 192, 0), (138, 192, 0), (276, 192, 0), (414, 192, 0), # T9-T12
        (0, 288, 0), (138, 288, 0), (276, 288, 0), (414, 288, 0), # T13-T16
    ]
    _DEFAULT_SITE_SIZE = {"width": 128.0, "height": 86, "depth": 0}
    _DEFAULT_CONTENT_TYPE = ["plate", "tip_rack", "plates", "tip_racks", "tube_rack", "adaptor"]
    def __init__(self, name: str, size_x: float, size_y: float, size_z: float,
                 sites: Optional[List[Dict[str, Any]]] = None, **kwargs):
        super().__init__(size_x, size_y, size_z, name)
        if sites is not None:
            self.sites: List[Dict[str, Any]] = [dict(s) for s in sites]
        else:
            self.sites = []
            for i, (x, y, z) in enumerate(self._DEFAULT_SITE_POSITIONS):
                self.sites.append({
                    "label": f"T{i + 1}",
                    "visible": True,
                    "position": {"x": x, "y": y, "z": z},
                    "size": dict(self._DEFAULT_SITE_SIZE),
                    "content_type": list(self._DEFAULT_CONTENT_TYPE),
                })
        # _ordering: label -> None, 用于外部通过 list(keys()).index(site) 将 Tn 转换为 spot index
        self._ordering = collections.OrderedDict(
            (site["label"], None) for site in self.sites
        )
    def _get_site_location(self, idx: int) -> Coordinate:
        pos = self.sites[idx]["position"]
        return Coordinate(pos["x"], pos["y"], pos["z"])
    def _get_site_resource(self, idx: int) -> Optional[Resource]:
        site_loc = self._get_site_location(idx)
        for child in self.children:
            if child.location == site_loc:
                return child
        return None
    def assign_child_resource(
        self,
        resource: Resource,
        location: Optional[Coordinate] = None,
        reassign: bool = True,
        spot: Optional[int] = None,
    ):
        idx = spot
        if spot is not None:
            idx = spot
        else:
            for i, site in enumerate(self.sites):
                site_loc = self._get_site_location(i)
                if site.get("label") == resource.name:
                    idx = i
                    break
                if location is not None and site_loc == location:
                    idx = i
                    break
        if idx is None:
            for i in range(len(self.sites)):
                if self._get_site_resource(i) is None:
                    idx = i
                    break
        if idx is None:
            raise ValueError(f"No available site on deck '{self.name}' for resource '{resource.name}'")
        if not reassign and self._get_site_resource(idx) is not None:
            raise ValueError(f"Site {idx} ('{self.sites[idx]['label']}') is already occupied")
        loc = self._get_site_location(idx)
        super().assign_child_resource(resource, location=loc, reassign=reassign)
    def assign_child_at_slot(self, resource: Resource, slot: int, reassign: bool = False) -> None:
-        self.assign_child_resource(resource, spot=slot - 1, reassign=reassign)
+        if self.slots[slot - 1] is not None and not reassign:
            raise ValueError(f"Spot {slot} is already occupied")
-    def serialize(self) -> dict:
+        self.slots[slot - 1] = resource
-        data = super().serialize()
+        super().assign_child_resource(resource, location=self.slot_locations[slot - 1])
        sites_out = []
        for i, site in enumerate(self.sites):
            occupied = self._get_site_resource(i)
            sites_out.append({
                "label": site["label"],
                "visible": site.get("visible", True),
                "occupied_by": occupied.name if occupied is not None else None,
                "position": site["position"],
                "size": site["size"],
                "content_type": site["content_type"],
            })
        data["sites"] = sites_out
        return data
-
+class PRCXI9300Container(Plate):
 class PRCXI9300Container(Container):
    """PRCXI 9300 的专用 Container 类，继承自 Plate，用于槽位定位和未知模块。
    该类定义了 PRCXI 9300 的工作台布局和槽位信息。
@@ -200,10 +93,11 @@ class PRCXI9300Container(Container):
        size_y: float,
        size_z: float,
        category: str,
        ordering: collections.OrderedDict,
        model: Optional[str] = None,
        **kwargs,
    ):
-        super().__init__(name, size_x, size_y, size_z, category=category, model=model)
+        super().__init__(name, size_x, size_y, size_z, category=category, ordering=ordering, model=model)
        self._unilabos_state = {}
    def load_state(self, state: Dict[str, Any]) -> None:
@@ -215,80 +109,73 @@ class PRCXI9300Container(Container):
        data = super().serialize_state()
        data.update(self._unilabos_state)
        return data   
 class PRCXI9300Plate(Plate):
    """ 
    专用孔板类：
    1. 继承自 PLR 原生 Plate，保留所有物理特性。
    2. 增加 material_info 参数，用于在初始化时直接绑定 Unilab UUID。
    """
-
+    def __init__(self, name: str, size_x: float, size_y: float, size_z: float, 
    def __init__(
        self,
        name: str,
        size_x: float,
        size_y: float,
        size_z: float,
                 category: str = "plate", 
                 ordered_items: collections.OrderedDict = None, 
                 ordering: Optional[collections.OrderedDict] = None,
                 model: Optional[str] = None, 
                 material_info: Optional[Dict[str, Any]] = None, 
-        **kwargs,
+                 **kwargs):
    ):
        # 如果 ordered_items 不为 None，直接使用
        items = None
        ordering_param = None
        if ordered_items is not None:
            items = ordered_items
        elif ordering is not None:
            # 检查 ordering 中的值是否是字符串（从 JSON 反序列化时的情况）
            # 如果是字符串，说明这是位置名称，需要让 Plate 自己创建 Well 对象
            # 我们只传递位置信息（键），不传递值，使用 ordering 参数
-            if ordering:
+            if ordering and isinstance(next(iter(ordering.values()), None), str):
                values = list(ordering.values())
                value = values[0]
                if isinstance(value, str):
                # ordering 的值是字符串，只使用键（位置信息）创建新的 OrderedDict
                # 传递 ordering 参数而不是 ordered_items，让 Plate 自己创建 Well 对象
                items = None
                # 使用 ordering 参数，只包含位置信息（键）
                ordering_param = collections.OrderedDict((k, None) for k in ordering.keys())
                elif value is None:
                    ordering_param = ordering
            else:
                # ordering 的值已经是对象，可以直接使用
                items = ordering
                ordering_param = None
        else:
            items = None
            ordering_param = None
        # 根据情况传递不同的参数
        if items is not None:
-            super().__init__(
+            super().__init__(name, size_x, size_y, size_z, 
-                name, size_x, size_y, size_z, ordered_items=items, category=category, model=model, **kwargs
+                             ordered_items=items,
-            )
+                             category=category,
                             model=model, **kwargs)
        elif ordering_param is not None:
            # 传递 ordering 参数，让 Plate 自己创建 Well 对象
-            super().__init__(
+            super().__init__(name, size_x, size_y, size_z, 
-                name, size_x, size_y, size_z, ordering=ordering_param, category=category, model=model, **kwargs
+                             ordering=ordering_param,
-            )
+                             category=category,
                             model=model, **kwargs)
        else:
-            super().__init__(name, size_x, size_y, size_z, category=category, model=model, **kwargs)
+            super().__init__(name, size_x, size_y, size_z, 
                             category=category,
                             model=model, **kwargs)
        self._unilabos_state = {}
        if material_info:
            self._unilabos_state["Material"] = material_info
    def load_state(self, state: Dict[str, Any]) -> None:
        super().load_state(state)
        self._unilabos_state = state
    def serialize_state(self) -> Dict[str, Dict[str, Any]]:
        try:
            data = super().serialize_state()
        except AttributeError:
            data = {}
-        if hasattr(self, "_unilabos_state") and self._unilabos_state:
+        if hasattr(self, '_unilabos_state') and self._unilabos_state:
            safe_state = {}
            for k, v in self._unilabos_state.items():
                # 如果是 Material 字典，深入检查
@@ -309,37 +196,27 @@ class PRCXI9300Plate(Plate):
            data.update(safe_state)
        return data            # 其他顶层属性也进行类型检查
 class PRCXI9300TipRack(TipRack):
    """ 专用吸头盒类 """
-
+    def __init__(self, name: str, size_x: float, size_y: float, size_z: float, 
    def __init__(
        self,
        name: str,
        size_x: float,
        size_y: float,
        size_z: float,
                 category: str = "tip_rack", 
                 ordered_items: collections.OrderedDict = None, 
                 ordering: Optional[collections.OrderedDict] = None,
                 model: Optional[str] = None,
                 material_info: Optional[Dict[str, Any]] = None,
-        **kwargs,
+                 **kwargs):
    ):
        # 如果 ordered_items 不为 None，直接使用
        if ordered_items is not None:
            items = ordered_items
        elif ordering is not None:
-            # 检查 ordering 中的值类型来决定如何处理：
+            # 检查 ordering 中的值是否是字符串（从 JSON 反序列化时的情况）
-            # - 字符串值（从 JSON 反序列化）: 只用键创建 ordering_param
+            # 如果是字符串，说明这是位置名称，需要让 TipRack 自己创建 Tip 对象
-            # - None 值（从第二次往返序列化）: 同样只用键创建 ordering_param
+            # 我们只传递位置信息（键），不传递值，使用 ordering 参数
-            # - 对象值（已经是实际的 Resource 对象）: 直接作为 ordered_items 使用
+            if ordering and isinstance(next(iter(ordering.values()), None), str):
-            first_val = next(iter(ordering.values()), None) if ordering else None
+                # ordering 的值是字符串，只使用键（位置信息）创建新的 OrderedDict
            if not ordering or first_val is None or isinstance(first_val, str):
                # ordering 的值是字符串或 None，只使用键（位置信息）创建新的 OrderedDict
                # 传递 ordering 参数而不是 ordered_items，让 TipRack 自己创建 Tip 对象
                items = None
                # 使用 ordering 参数，只包含位置信息（键）
                ordering_param = collections.OrderedDict((k, None) for k in ordering.keys())
            else:
                # ordering 的值已经是对象，可以直接使用
@@ -351,16 +228,20 @@ class PRCXI9300TipRack(TipRack):
        # 根据情况传递不同的参数
        if items is not None:
-            super().__init__(
+            super().__init__(name, size_x, size_y, size_z, 
-                name, size_x, size_y, size_z, ordered_items=items, category=category, model=model, **kwargs
+                             ordered_items=items,
-            )
+                             category=category, 
                             model=model, **kwargs)
        elif ordering_param is not None:
            # 传递 ordering 参数，让 TipRack 自己创建 Tip 对象
-            super().__init__(
+            super().__init__(name, size_x, size_y, size_z, 
-                name, size_x, size_y, size_z, ordering=ordering_param, category=category, model=model, **kwargs
+                             ordering=ordering_param,
-            )
+                             category=category, 
                             model=model, **kwargs)
        else:
-            super().__init__(name, size_x, size_y, size_z, category=category, model=model, **kwargs)
+            super().__init__(name, size_x, size_y, size_z, 
                             category=category, 
                             model=model, **kwargs)
        self._unilabos_state = {}
        if material_info:
            self._unilabos_state["Material"] = material_info
@@ -374,7 +255,7 @@ class PRCXI9300TipRack(TipRack):
            data = super().serialize_state()
        except AttributeError:
            data = {}
-        if hasattr(self, "_unilabos_state") and self._unilabos_state:
+        if hasattr(self, '_unilabos_state') and self._unilabos_state:
            safe_state = {}
            for k, v in self._unilabos_state.items():
                # 如果是 Material 字典，深入检查
@@ -396,23 +277,16 @@ class PRCXI9300TipRack(TipRack):
            data.update(safe_state)
        return data
 class PRCXI9300Trash(Trash):
    """PRCXI 9300 的专用 Trash 类，继承自 Trash。
    该类定义了 PRCXI 9300 的工作台布局和槽位信息。
    """
-    def __init__(
+    def __init__(self, name: str, size_x: float, size_y: float, size_z: float, 
        self,
        name: str,
        size_x: float,
        size_y: float,
        size_z: float,
                 category: str = "trash", 
                 material_info: Optional[Dict[str, Any]] = None,
-        **kwargs,
+                 **kwargs):
    ):
        if name != "trash":
            print(f"Warning: PRCXI9300Trash usually expects name='trash' for backend logic, but got '{name}'.")
@@ -432,7 +306,7 @@ class PRCXI9300Trash(Trash):
            data = super().serialize_state()
        except AttributeError:
            data = {}
-        if hasattr(self, "_unilabos_state") and self._unilabos_state:
+        if hasattr(self, '_unilabos_state') and self._unilabos_state:
            safe_state = {}
            for k, v in self._unilabos_state.items():
                # 如果是 Material 字典，深入检查
@@ -454,42 +328,33 @@ class PRCXI9300Trash(Trash):
            data.update(safe_state)
        return data
 class PRCXI9300TubeRack(TubeRack):
    """
    专用管架类：用于 EP 管架、试管架等。
    继承自 PLR 的 TubeRack，并支持注入 material_info (UUID)。
    """
-
+    def __init__(self, name: str, size_x: float, size_y: float, size_z: float, 
    def __init__(
        self,
        name: str,
        size_x: float,
        size_y: float,
        size_z: float,
                 category: str = "tube_rack", 
                 items: Optional[Dict[str, Any]] = None,
                 ordered_items: Optional[OrderedDict] = None,
                 ordering: Optional[OrderedDict] = None,
                 model: Optional[str] = None,
                 material_info: Optional[Dict[str, Any]] = None, 
-        **kwargs,
+                 **kwargs):
    ):
        # 如果 ordered_items 不为 None，直接使用
        if ordered_items is not None:
            items_to_pass = ordered_items
            ordering_param = None
        elif ordering is not None:
-            # 检查 ordering 中的值类型来决定如何处理：
+            # 检查 ordering 中的值是否是字符串（从 JSON 反序列化时的情况）
-            # - 字符串值（从 JSON 反序列化）: 只用键创建 ordering_param
+            # 如果是字符串，说明这是位置名称，需要让 TubeRack 自己创建 Tube 对象
-            # - None 值（从第二次往返序列化）: 同样只用键创建 ordering_param
+            # 我们只传递位置信息（键），不传递值，使用 ordering 参数
-            # - 对象值（已经是实际的 Resource 对象）: 直接作为 ordered_items 使用
+            if ordering and isinstance(next(iter(ordering.values()), None), str):
-            first_val = next(iter(ordering.values()), None) if ordering else None
+                # ordering 的值是字符串，只使用键（位置信息）创建新的 OrderedDict
            if not ordering or first_val is None or isinstance(first_val, str):
                # ordering 的值是字符串或 None，只使用键（位置信息）创建新的 OrderedDict
                # 传递 ordering 参数而不是 ordered_items，让 TubeRack 自己创建 Tube 对象
                items_to_pass = None
                # 使用 ordering 参数，只包含位置信息（键）
                ordering_param = collections.OrderedDict((k, None) for k in ordering.keys())
            else:
                # ordering 的值已经是对象，可以直接使用
@@ -505,12 +370,20 @@ class PRCXI9300TubeRack(TubeRack):
        # 根据情况传递不同的参数
        if items_to_pass is not None:
-            super().__init__(name, size_x, size_y, size_z, ordered_items=items_to_pass, model=model, **kwargs)
+            super().__init__(name, size_x, size_y, size_z, 
                             ordered_items=items_to_pass, 
                             model=model, 
                             **kwargs)
        elif ordering_param is not None:
            # 传递 ordering 参数，让 TubeRack 自己创建 Tube 对象
-            super().__init__(name, size_x, size_y, size_z, ordering=ordering_param, model=model, **kwargs)
+            super().__init__(name, size_x, size_y, size_z, 
                             ordering=ordering_param,
                             model=model, 
                             **kwargs)
        else:
-            super().__init__(name, size_x, size_y, size_z, model=model, **kwargs)
+            super().__init__(name, size_x, size_y, size_z, 
                             model=model, 
                             **kwargs)
        self._unilabos_state = {}
        if material_info:
@@ -521,7 +394,7 @@ class PRCXI9300TubeRack(TubeRack):
            data = super().serialize_state()
        except AttributeError:
            data = {}
-        if hasattr(self, "_unilabos_state") and self._unilabos_state:
+        if hasattr(self, '_unilabos_state') and self._unilabos_state:
            safe_state = {}
            for k, v in self._unilabos_state.items():
                # 如果是 Material 字典，深入检查
@@ -543,19 +416,12 @@ class PRCXI9300TubeRack(TubeRack):
            data.update(safe_state)
        return data
 class PRCXI9300PlateAdapter(PlateAdapter):
    """
    专用板式适配器类：用于承载 Plate 的底座（如 PCR 适配器、磁吸架等）。
    支持注入 material_info (UUID)。
    """
-
+    def __init__(self, name: str, size_x: float, size_y: float, size_z: float, 
    def __init__(
        self,
        name: str,
        size_x: float,
        size_y: float,
        size_z: float,
                 category: str = "plate_adapter", 
                 model: Optional[str] = None,
                 material_info: Optional[Dict[str, Any]] = None, 
@@ -566,8 +432,7 @@ class PRCXI9300PlateAdapter(PlateAdapter):
                 dx: Optional[float] = None,
                 dy: Optional[float] = None,
                 dz: float = 0.0, # 默认Z轴偏移
-        **kwargs,
+                 **kwargs):
    ):
        # 自动居中计算：如果未指定 dx/dy，则根据适配器尺寸和孔尺寸计算居中位置
        if dx is None:
@@ -587,7 +452,7 @@ class PRCXI9300PlateAdapter(PlateAdapter):
            adapter_hole_size_y=adapter_hole_size_y,
            adapter_hole_size_z=adapter_hole_size_z,
            model=model, 
-            **kwargs,
+            **kwargs
        )
        self._unilabos_state = {}
@@ -599,7 +464,7 @@ class PRCXI9300PlateAdapter(PlateAdapter):
            data = super().serialize_state()
        except AttributeError:
            data = {}
-        if hasattr(self, "_unilabos_state") and self._unilabos_state:
+        if hasattr(self, '_unilabos_state') and self._unilabos_state:
            safe_state = {}
            for k, v in self._unilabos_state.items():
                # 如果是 Material 字典，深入检查
@@ -621,7 +486,6 @@ class PRCXI9300PlateAdapter(PlateAdapter):
            data.update(safe_state)
        return data
 class PRCXI9300Handler(LiquidHandlerAbstract):
    support_touch_tip = False
@@ -634,7 +498,7 @@ class PRCXI9300Handler(LiquidHandlerAbstract):
    def __init__(
        self,
-        deck: PRCXI9300Deck,
+        deck: Deck,
        host: str,
        port: int,
        timeout: float,
@@ -648,15 +512,13 @@ class PRCXI9300Handler(LiquidHandlerAbstract):
        is_9320=False,
    ):
        tablets_info = []
-        for site_id in range(len(deck.sites)):
+        count = 0
-            child = deck._get_site_resource(site_id)
+        for child in deck.children:
-            # 如果放其他类型的物料，是不可以的
+            if child.children:
-            if hasattr(child, "_unilabos_state") and "Material" in child._unilabos_state:
+                if "Material" in child.children[0]._unilabos_state:
-                number = site_id + 1
+                    number = int(child.name.replace("T", ""))
                    tablets_info.append(
-                    WorkTablets(
+                        WorkTablets(Number=number, Code=f"T{number}", Material=child.children[0]._unilabos_state["Material"])
                        Number=number, Code=f"T{number}", Material=child._unilabos_state["Material"]
                    )
                    )
        if is_9320:
            print("当前设备是9320")
@@ -676,14 +538,9 @@ class PRCXI9300Handler(LiquidHandlerAbstract):
        super().post_init(ros_node)
        self._unilabos_backend.post_init(ros_node)
-    def set_liquid(self, wells: list[Well], liquid_names: list[str], volumes: list[float]) -> SetLiquidReturn:
+    def set_liquid(self, wells: list[Well], liquid_names: list[str], volumes: list[float]) -> SimpleReturn:
        return super().set_liquid(wells, liquid_names, volumes)
    def set_liquid_from_plate(
        self, plate: ResourceSlot, well_names: list[str], liquid_names: list[str], volumes: list[float]
    ) -> SetLiquidFromPlateReturn:
        return super().set_liquid_from_plate(plate, well_names, liquid_names, volumes)
    def set_group(self, group_name: str, wells: List[Well], volumes: List[float]):
        return super().set_group(group_name, wells, volumes)
@@ -803,7 +660,7 @@ class PRCXI9300Handler(LiquidHandlerAbstract):
        mix_liquid_height: Optional[float] = None,
        delays: Optional[List[int]] = None,
        none_keys: List[str] = [],
-    ) -> TransferLiquidReturn:
+    ):
        return await super().transfer_liquid(
            sources,
            targets,
@@ -943,7 +800,6 @@ class PRCXI9300Handler(LiquidHandlerAbstract):
    async def heater_action(self, temperature: float, time: int):
        return await self._unilabos_backend.heater_action(temperature, time)  
    async def move_plate(
        self,
        plate: Plate,
@@ -970,7 +826,6 @@ class PRCXI9300Handler(LiquidHandlerAbstract):
            **backend_kwargs,
        )
 class PRCXI9300Backend(LiquidHandlerBackend):
    """PRCXI 9300 的后端实现，继承自 LiquidHandlerBackend。
@@ -1023,6 +878,7 @@ class PRCXI9300Backend(LiquidHandlerBackend):
        self.steps_todo_list.append(step)
        return step
    async def pick_up_resource(self, pickup: ResourcePickup, **backend_kwargs):
        resource=pickup.resource
@@ -1040,11 +896,13 @@ class PRCXI9300Backend(LiquidHandlerBackend):
    async def drop_resource(self, drop: ResourceDrop, **backend_kwargs):
        plate_number = None
        target_plate_number = backend_kwargs.get("target_plate_number", None)
        if target_plate_number is not None:
            plate_number = int(target_plate_number.name.replace("T", ""))
        is_whole_plate = True
        balance_height = 0
        if plate_number is None:
@@ -1053,6 +911,7 @@ class PRCXI9300Backend(LiquidHandlerBackend):
        self.steps_todo_list.append(step)
        return step
    async def heater_action(self, temperature: float, time: int):
        print(f"\n\nHeater action: temperature={temperature}, time={time}\n\n")
        # return await self.api_client.heater_action(temperature, time)
@@ -1121,7 +980,7 @@ class PRCXI9300Backend(LiquidHandlerBackend):
                # 检查重置状态并等待完成
                while not self.is_reset_ok:
                    print("Waiting for PRCXI9300 to reset...")
-                    if hasattr(self, "_ros_node") and self._ros_node is not None:
+                    if hasattr(self, '_ros_node') and self._ros_node is not None:
                        await self._ros_node.sleep(1)
                    else:
                        await asyncio.sleep(1)
@@ -1139,7 +998,7 @@ class PRCXI9300Backend(LiquidHandlerBackend):
        """Pick up tips from the specified resource."""
        # INSERT_YOUR_CODE
        # Ensure use_channels is converted to a list of ints if it's an array
-        if hasattr(use_channels, "tolist"):
+        if hasattr(use_channels, 'tolist'):
            _use_channels = use_channels.tolist()
        else:
            _use_channels = list(use_channels) if use_channels is not None else None
@@ -1193,7 +1052,7 @@ class PRCXI9300Backend(LiquidHandlerBackend):
    async def drop_tips(self, ops: List[Drop], use_channels: List[int] = None):
        """Pick up tips from the specified resource."""
-        if hasattr(use_channels, "tolist"):
+        if hasattr(use_channels, 'tolist'):
            _use_channels = use_channels.tolist()
        else:
            _use_channels = list(use_channels) if use_channels is not None else None
@@ -1319,7 +1178,7 @@ class PRCXI9300Backend(LiquidHandlerBackend):
    async def aspirate(self, ops: List[SingleChannelAspiration], use_channels: List[int] = None):
        """Aspirate liquid from the specified resources."""
-        if hasattr(use_channels, "tolist"):
+        if hasattr(use_channels, 'tolist'):
            _use_channels = use_channels.tolist()
        else:
            _use_channels = list(use_channels) if use_channels is not None else None
@@ -1376,7 +1235,7 @@ class PRCXI9300Backend(LiquidHandlerBackend):
    async def dispense(self, ops: List[SingleChannelDispense], use_channels: List[int] = None):
        """Dispense liquid into the specified resources."""
-        if hasattr(use_channels, "tolist"):
+        if hasattr(use_channels, 'tolist'):
            _use_channels = use_channels.tolist()
        else:
            _use_channels = list(use_channels) if use_channels is not None else None
@@ -1557,6 +1416,7 @@ class PRCXI9300Api:
                time.sleep(1)
        return success
    def call(self, service: str, method: str, params: Optional[list] = None) -> Any:
        payload = json.dumps(
            {"ServiceName": service, "MethodName": method, "Paramters": params or []}, separators=(",", ":")
@@ -1821,11 +1681,11 @@ class PRCXI9300Api:
            "LiquidDispensingMethod": liquid_method,
        }
-    def clamp_jaw_pick_up(
+    def clamp_jaw_pick_up(self,
        self,
        plate_no: int,
        is_whole_plate: bool,
        balance_height: int,
    ) -> Dict[str, Any]:
        return {
            "StepAxis": "ClampingJaw",
@@ -1835,7 +1695,7 @@ class PRCXI9300Api:
            "HoleRow": 1,
            "HoleCol": 1,
            "BalanceHeight": balance_height,
-            "PlateOrHoleNum": f"T{plate_no}",
+            "PlateOrHoleNum": f"T{plate_no}"
        }
    def clamp_jaw_drop(
@@ -1843,6 +1703,7 @@ class PRCXI9300Api:
        plate_no: int,
        is_whole_plate: bool,
        balance_height: int,
    ) -> Dict[str, Any]:
        return {
            "StepAxis": "ClampingJaw",
@@ -1852,7 +1713,7 @@ class PRCXI9300Api:
            "HoleRow": 1,
            "HoleCol": 1,
            "BalanceHeight": balance_height,
-            "PlateOrHoleNum": f"T{plate_no}",
+            "PlateOrHoleNum": f"T{plate_no}"
        }
    def shaker_action(self, time: int, module_no: int, amplitude: int, is_wait: bool):
@@ -1865,7 +1726,6 @@ class PRCXI9300Api:
            "AssistFun4": is_wait,
        }
 class DefaultLayout:
    def __init__(self, product_name: str = "PRCXI9300"):
@@ -2244,9 +2104,7 @@ if __name__ == "__main__":
            size_y=50,
            size_z=10,
            category="tip_rack",
-            ordered_items=collections.OrderedDict(
+            ordered_items=collections.OrderedDict({k: f"{child_prefix}_{k}" for k, v in tip_racks["ordering"].items()}),
                {k: f"{child_prefix}_{k}" for k, v in tip_racks["ordering"].items()}
            ),
        )
        tip_rack_serialized = tip_rack.serialize()
        tip_rack_serialized["parent_name"] = deck.name
@@ -2441,19 +2299,21 @@ if __name__ == "__main__":
    A = tree_to_list([resource_plr_to_ulab(deck)])
    with open("deck.json", "w", encoding="utf-8") as f:
-        A.insert(
+        A.insert(0, {
            0,
            {
            "id": "PRCXI",
            "name": "PRCXI",
            "parent": None,
            "type": "device",
            "class": "liquid_handler.prcxi",
-                "position": {"x": 0, "y": 0, "z": 0},
+            "position": {
                "x": 0,
                "y": 0,
                "z": 0
            },
            "config": {
                "deck": {
                    "_resource_child_name": "PRCXI_Deck",
-                        "_resource_type": "unilabos.devices.liquid_handling.prcxi.prcxi:PRCXI9300Deck",
+                    "_resource_type": "unilabos.devices.liquid_handling.prcxi.prcxi:PRCXI9300Deck"
                },
                "host": "192.168.0.121",
                "port": 9999,
@@ -2464,14 +2324,18 @@ if __name__ == "__main__":
                "debug": True,
                "simulator": True,
                "matrix_id": "5de524d0-3f95-406c-86dd-f83626ebc7cb",
-                    "is_9320": True,
+                "is_9320": True
            },
            "data": {},
-                "children": ["PRCXI_Deck"],
+            "children": [
-            },
+                "PRCXI_Deck"
-        )
+            ]
        })
        A[1]["parent"] = "PRCXI"
-        json.dump({"nodes": A, "links": []}, f, indent=4, ensure_ascii=False)
+        json.dump({
            "nodes": A,
            "links": []
        }, f, indent=4, ensure_ascii=False)
    handler = PRCXI9300Handler(
        deck=deck,
@@ -2513,6 +2377,7 @@ if __name__ == "__main__":
    time.sleep(5)
    os._exit(0)
    prcxi_api = PRCXI9300Api(host="192.168.0.121", port=9999)
    prcxi_api.list_matrices()
    prcxi_api.get_all_materials()
--- a/unilabos/devices/neware_battery_test_system/OSS_UPLOAD_README_CN.md
+++ b/unilabos/devices/neware_battery_test_system/OSS_UPLOAD_README_CN.md
@@ -219,10 +219,10 @@ device = NewareBatteryTestSystem(
 #### 步骤 2：提交测试任务
-使用 `submit_from_csv_export_ndax` 提交测试任务：
+使用 `submit_from_csv` 提交测试任务：
 ```python
-result = device.submit_from_csv_export_ndax(
+result = device.submit_from_csv(
    csv_path="test_data.csv",
    output_dir="D:/neware_output"
 )
@@ -489,7 +489,7 @@ A: 重新获取新的 Token 并更新环境变量 `UNI_LAB_AUTH_TOKEN`。
 **Q: 可以自定义上传路径吗？**  
 A: 当前版本路径由统一 API 自动分配，`oss_prefix` 参数暂不使用（保留接口兼容性）。
-**Q: 为什么不在 `submit_from_csv_export_ndax` 中自动上传？**  
+**Q: 为什么不在 `submit_from_csv` 中自动上传？**  
 A: 因为备份文件在测试进行中逐步生成，方法返回时可能文件尚未完全生成，因此提供独立的上传方法更灵活。
 **Q: 上传后如何访问文件？**  
--- a/unilabos/devices/neware_battery_test_system/OSS_UPLOAD_README_EN.md
+++ b/unilabos/devices/neware_battery_test_system/OSS_UPLOAD_README_EN.md
@@ -230,10 +230,10 @@ device = NewareBatteryTestSystem(
 #### Step 2: Submit Test Tasks
-Use `submit_from_csv_export_ndax` to submit test tasks:
+Use `submit_from_csv` to submit test tasks:
 ```python
-result = device.submit_from_csv_export_ndax(
+result = device.submit_from_csv(
    csv_path="test_data.csv",
    output_dir="D:/neware_output"
 )
@@ -500,7 +500,7 @@ A: Obtain a new API Key and update the `UNI_LAB_AUTH_TOKEN` environment variable
 **Q: Can I customize upload paths?**  
 A: Current version has paths automatically assigned by unified API. `oss_prefix` parameter is currently unused (retained for interface compatibility).
-**Q: Why not auto-upload in `submit_from_csv_export_ndax`?**  
+**Q: Why not auto-upload in `submit_from_csv`?**  
 A: Because backup files are generated progressively during testing, they may not be fully generated when the method returns. A separate upload method provides more flexibility.
 **Q: How to access files after upload?**  
--- a/unilabos/devices/neware_battery_test_system/init.py
+++ b/unilabos/devices/neware_battery_test_system/init.py
--- a/unilabos/devices/neware_battery_test_system/device.json
+++ b/unilabos/devices/neware_battery_test_system/device.json
@@ -14,7 +14,7 @@
            "config": {
                "ip": "127.0.0.1",
                "port": 502,
-                "machine_ids": [1, 2, 3, 4, 5, 6, 86],
+                "machine_id": 1,
                "devtype": "27",
                "timeout": 20,
                "size_x": 500.0,
@@ -26,7 +26,7 @@
            "data": {
                "功能说明": "新威电池测试系统，提供720通道监控和CSV批量提交功能",
                "监控功能": "支持720个通道的实时状态监控、2盘电池物料管理、状态导出等",
-                "提交功能": "通过submit_from_csv action从CSV文件批量提交测试任务（NDA备份），或通过submit_from_csv_export_excel action提交并备份为Excel格式。CSV必须包含: Battery_Code, Pole_Weight, 集流体质量, 活性物质含量, 克容量mah/g, 电池体系, 设备号, 排号, 通道号"
+                "提交功能": "通过submit_from_csv action从CSV文件批量提交测试任务。CSV必须包含: Battery_Code, Pole_Weight, 集流体质量, 活性物质含量, 克容量mah/g, 电池体系, 设备号, 排号, 通道号"
            },
            "children": []
        }
--- a/unilabos/devices/neware_battery_test_system/generate_xml_content.py
+++ b/unilabos/devices/neware_battery_test_system/generate_xml_content.py
--- a/unilabos/devices/neware_battery_test_system/neware_battery_test_system.py
+++ b/unilabos/devices/neware_battery_test_system/neware_battery_test_system.py
--- a/unilabos/devices/neware_battery_test_system/neware_driver.py
+++ b/unilabos/devices/neware_battery_test_system/neware_driver.py
@@ -1,56 +0,0 @@
 import socket
 END_MARKS = [b"\r\n#\r\n", b"</bts>"]  # 读到任一标志即可判定完整响应
 def build_start_command(devid, subdevid, chlid, CoinID,
                        ip_in_xml="127.0.0.1",
                        devtype:int=27,
                        recipe_path:str=f"D:\\HHM_test\\A001.xml",
                        backup_dir:str=f"D:\\HHM_test\\backup",
                        filetype:int=1) -> str:
    """
    filetype: 备份文件类型。0=NDA（新威原生），1=Excel。默认 1。
    """
    lines = [
        '<?xml version="1.0" encoding="UTF-8"?>',
        '<bts version="1.0">',
        '  <cmd>start</cmd>',
        '  <list count="1">',
        f'    <start ip="{ip_in_xml}" devtype="{devtype}" devid="{devid}" subdevid="{subdevid}" chlid="{chlid}" barcode="{CoinID}">{recipe_path}</start>',
        f'    <backup backupdir="{backup_dir}" remotedir="" filenametype="1" customfilename="" createdirbydate="0" filetype="{int(filetype)}" backupontime="1" backupontimeinterval="1" backupfree="0" />',
        '  </list>',
        '</bts>',
    ]
    # TCP 模式：请求必须以 #\r\n 结束（协议要求）
    return "\r\n".join(lines) + "\r\n#\r\n"
 def recv_until_marks(sock: socket.socket, timeout=60):
    sock.settimeout(timeout)  # 上限给足，协议允许到 30s:contentReference[oaicite:2]{index=2}
    buf = bytearray()
    while True:
        chunk = sock.recv(8192)
        if not chunk:
            break
        buf += chunk
        # 读到结束标志就停，避免等对端断开
        for m in END_MARKS:
            if m in buf:
                return bytes(buf)
        # 保险：读到完整 XML 结束标签也停
        if b"</bts>" in buf:
            return bytes(buf)
    return bytes(buf)
 def start_test(ip="127.0.0.1", port=502, devid=3, subdevid=2, chlid=1, CoinID="A001", recipe_path=f"D:\\HHM_test\\A001.xml", backup_dir=f"D:\\HHM_test\\backup", filetype:int=1):
    """
    filetype: 备份文件类型，0=NDA，1=Excel。默认 1。
    """
    xml_cmd = build_start_command(devid=devid, subdevid=subdevid, chlid=chlid, CoinID=CoinID, recipe_path=recipe_path, backup_dir=backup_dir, filetype=filetype)
    #print(xml_cmd)
    with socket.create_connection((ip, port), timeout=60) as s:
        s.sendall(xml_cmd.encode("utf-8"))
        data = recv_until_marks(s, timeout=60)
    return data.decode("utf-8", errors="replace")
 if __name__ == "__main__":
    resp = start_test(ip="127.0.0.1", port=502, devid=4, subdevid=10, chlid=1, CoinID="A001", recipe_path=f"D:\\HHM_test\\A001.xml", backup_dir=f"D:\\HHM_test\\backup")
    print(resp)
--- a/unilabos/devices/ros_dev/liquid_handler_joint_publisher.py
+++ b/unilabos/devices/ros_dev/liquid_handler_joint_publisher.py
@@ -19,11 +19,10 @@ from rclpy.node import Node
 import re
 class LiquidHandlerJointPublisher(BaseROS2DeviceNode):
-    def __init__(self,resources_config:list, resource_tracker, rate=50, device_id:str = "lh_joint_publisher", registry_name: str = "lh_joint_publisher", **kwargs):
+    def __init__(self,resources_config:list, resource_tracker, rate=50, device_id:str = "lh_joint_publisher", **kwargs):
        super().__init__(
            driver_instance=self,
            device_id=device_id,
            registry_name=registry_name,
            status_types={},
            action_value_mappings={},
            hardware_interface={},
--- a/unilabos/devices/virtual/virtual_sample_demo.py
+++ b/unilabos/devices/virtual/virtual_sample_demo.py
@@ -1,88 +0,0 @@
 """虚拟样品演示设备 — 用于前端 sample tracking 功能的极简 demo"""
 import asyncio
 import logging
 import random
 import time
 from typing import Any, Dict, List, Optional
 class VirtualSampleDemo:
    """虚拟样品追踪演示设备，提供两种典型返回模式：
    - measure_samples: 等长输入输出 (前端按 index 自动对齐)
    - split_and_measure: 输出比输入长，附带 samples 列标注归属
    """
    def __init__(self, device_id: Optional[str] = None, config: Optional[Dict[str, Any]] = None, **kwargs):
        if device_id is None and "id" in kwargs:
            device_id = kwargs.pop("id")
        if config is None and "config" in kwargs:
            config = kwargs.pop("config")
        self.device_id = device_id or "unknown_sample_demo"
        self.config = config or {}
        self.logger = logging.getLogger(f"VirtualSampleDemo.{self.device_id}")
        self.data: Dict[str, Any] = {"status": "Idle"}
    # ------------------------------------------------------------------
    # Action 1: 等长输入输出，无 samples 列
    # ------------------------------------------------------------------
    async def measure_samples(self, concentrations: List[float]) -> Dict[str, Any]:
        """模拟光度测量。absorbance = concentration * 0.05 + noise
        入参和出参 list 长度相等，前端按 index 自动对齐。
        """
        self.logger.info(f"measure_samples: concentrations={concentrations}")
        absorbance = [round(c * 0.05 + random.gauss(0, 0.005), 4) for c in concentrations]
        return {"concentrations": concentrations, "absorbance": absorbance}
    # ------------------------------------------------------------------
    # Action 2: 输出比输入长，带 samples 列
    # ------------------------------------------------------------------
    async def split_and_measure(self, volumes: List[float], split_count: int = 3) -> Dict[str, Any]:
        """将每个样品均分为 split_count 份后逐份测量。
        返回的 list 长度 = len(volumes) * split_count，
        附带 samples 列标注每行属于第几个输入样品 (0-based index)。
        """
        self.logger.info(f"split_and_measure: volumes={volumes}, split_count={split_count}")
        out_volumes: List[float] = []
        readings: List[float] = []
        samples: List[int] = []
        for idx, vol in enumerate(volumes):
            split_vol = round(vol / split_count, 2)
            for _ in range(split_count):
                out_volumes.append(split_vol)
                readings.append(round(random.uniform(0.1, 1.0), 4))
                samples.append(idx)
        return {"volumes": out_volumes, "readings": readings, "unilabos_samples": samples}
    # ------------------------------------------------------------------
    # Action 3: 入参和出参都带 samples 列（不等长）
    # ------------------------------------------------------------------
    async def analyze_readings(self, readings: List[float], samples: List[int]) -> Dict[str, Any]:
        """对 split_and_measure 的输出做二次分析。
        入参 readings/samples 长度相同但 > 原始样品数，
        出参同样带 samples 列，长度与入参一致。
        """
        self.logger.info(f"analyze_readings: readings={readings}, samples={samples}")
        scores: List[float] = []
        passed: List[bool] = []
        threshold = 0.4
        for r in readings:
            score = round(r * 100 + random.gauss(0, 2), 2)
            scores.append(score)
            passed.append(r >= threshold)
        return {"scores": scores, "passed": passed, "unilabos_samples": samples}
    # ------------------------------------------------------------------
    # 状态属性
    # ------------------------------------------------------------------
    @property
    def status(self) -> str:
        return self.data.get("status", "Idle")
--- a/unilabos/devices/virtual/virtual_transferpump.py
+++ b/unilabos/devices/virtual/virtual_transferpump.py
@@ -31,14 +31,14 @@ class VirtualTransferPump:
        # 从config或kwargs中获取参数，确保类型正确
        if config:
-            self.max_volume = float(config.get("max_volume", 25.0))
+            self.max_volume = float(config.get('max_volume', 25.0))
-            self.port = config.get("port", "VIRTUAL")
+            self.port = config.get('port', 'VIRTUAL')
        else:
-            self.max_volume = float(kwargs.get("max_volume", 25.0))
+            self.max_volume = float(kwargs.get('max_volume', 25.0))
-            self.port = kwargs.get("port", "VIRTUAL")
+            self.port = kwargs.get('port', 'VIRTUAL')
-        self._transfer_rate = float(kwargs.get("transfer_rate", 0))
+        self._transfer_rate = float(kwargs.get('transfer_rate', 0))
-        self.mode = kwargs.get("mode", VirtualPumpMode.Normal)
+        self.mode = kwargs.get('mode', VirtualPumpMode.Normal)
        # 状态变量 - 确保都是正确类型
        self._status = "Idle"
@@ -54,9 +54,7 @@ class VirtualTransferPump:
        self.logger = logging.getLogger(f"VirtualTransferPump.{self.device_id}")
        print(f"🚰 === 虚拟转移泵 {self.device_id} 已创建 === ✨")
-        print(
+        print(f"💨 快速模式: {'启用' if self._fast_mode else '禁用'} | 移动时间: {self._fast_move_time}s | 喷射时间: {self._fast_dispense_time}s")
            f"💨 快速模式: {'启用' if self._fast_mode else '禁用'} | 移动时间: {self._fast_move_time}s | 喷射时间: {self._fast_dispense_time}s"
        )
        print(f"📊 最大容量: {self.max_volume}mL | 端口: {self.port}")
    def post_init(self, ros_node: BaseROS2DeviceNode):
@@ -191,9 +189,7 @@ class VirtualTransferPump:
                operation_emoji = "📍"
            self.logger.info(f"🎯 SET_POSITION: {operation_type} {operation_emoji}")
-            self.logger.info(
+            self.logger.info(f"  📍 位置: {self._position:.2f}mL → {target_position:.2f}mL (移动 {volume_to_move:.2f}mL)")
                f"  📍 位置: {self._position:.2f}mL → {target_position:.2f}mL (移动 {volume_to_move:.2f}mL)"
            )
            self.logger.info(f"  🌊 速度: {velocity:.2f} mL/s")
            self.logger.info(f"  ⏰ 预计时间: {display_duration:.2f}s")
@@ -211,11 +207,7 @@ class VirtualTransferPump:
                for i in range(steps + 1):
                    # 计算当前位置和进度
                    progress = (i / steps) * 100 if steps > 0 else 100
-                    current_pos = (
+                    current_pos = start_position + (target_position - start_position) * (i / steps) if steps > 0 else target_position
                        start_position + (target_position - start_position) * (i / steps)
                        if steps > 0
                        else target_position
                    )
                    # 更新状态
                    if i < steps:
@@ -252,9 +244,7 @@ class VirtualTransferPump:
            # 📊 最终状态日志
            if volume_to_move > 0.01:
-                self.logger.info(
+                self.logger.info(f"🎉 SET_POSITION 完成! 📍 最终位置: {self._position:.2f}mL | 💧 当前体积: {self._current_volume:.2f}mL")
                    f"🎉 SET_POSITION 完成! 📍 最终位置: {self._position:.2f}mL | 💧 当前体积: {self._current_volume:.2f}mL"
                )
            # 返回符合action定义的结果
            return {
@@ -262,7 +252,7 @@ class VirtualTransferPump:
                "message": f"✅ 成功移动到位置 {self._position:.2f}mL ({operation_type})",
                "final_position": self._position,
                "final_volume": self._current_volume,
-                "operation_type": operation_type,
+                "operation_type": operation_type
            }
        except Exception as e:
@@ -272,7 +262,7 @@ class VirtualTransferPump:
                "success": False,
                "message": error_msg,
                "final_position": self._position,
-                "final_volume": self._current_volume,
+                "final_volume": self._current_volume
            }
    # 其他泵操作方法
@@ -398,9 +388,7 @@ class VirtualTransferPump:
        return self._current_volume >= (self.max_volume - 0.01)  # 允许小量误差
    def __str__(self):
-        return (
+        return f"VirtualTransferPump({self.device_id}: {self._current_volume:.2f}/{self.max_volume} ml, {self._status})"
            f"VirtualTransferPump({self.device_id}: {self._current_volume:.2f}/{self.max_volume} ml, {self._status})"
        )
    def __repr__(self):
        return self.__str__()
--- a/unilabos/devices/virtual/workbench.py
+++ b/unilabos/devices/virtual/workbench.py
@@ -1,995 +0,0 @@
 """
 Virtual Workbench Device - 模拟工作台设备
 包含:
 - 1个机械臂 (每次操作3s, 独占锁)
 - 3个加热台 (每次加热10s, 可并行)
 工作流程:
 1. A1-A5 物料同时启动, 竞争机械臂
 2. 机械臂将物料移动到空闲加热台
 3. 加热完成后, 机械臂将物料移动到C1-C5
 注意: 调用来自线程池, 使用 threading.Lock 进行同步
 """
 import logging
 import time
 from typing import Dict, Any, Optional, List
 from dataclasses import dataclass
 from enum import Enum
 from threading import Lock, RLock
 from typing_extensions import TypedDict
 from unilabos.registry.decorators import (
    device, action, ActionInputHandle, ActionOutputHandle, DataSource, topic_config, not_action, NodeType
 )
 from unilabos.registry.placeholder_type import ResourceSlot, DeviceSlot
 from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode, ROS2DeviceNode
 from unilabos.resources.resource_tracker import SampleUUIDsType, LabSample, ResourceTreeSet
 # ============ TypedDict 返回类型定义 ============
 class MoveToHeatingStationResult(TypedDict):
    """move_to_heating_station 返回类型"""
    success: bool
    station_id: int
    material_id: str
    material_number: int
    message: str
    unilabos_samples: List[LabSample]
 class StartHeatingResult(TypedDict):
    """start_heating 返回类型"""
    success: bool
    station_id: int
    material_id: str
    material_number: int
    message: str
    unilabos_samples: List[LabSample]
 class MoveToOutputResult(TypedDict):
    """move_to_output 返回类型"""
    success: bool
    station_id: int
    material_id: str
    output_position: str
    message: str
    unilabos_samples: List[LabSample]
 class PrepareMaterialsResult(TypedDict):
    """prepare_materials 返回类型 - 批量准备物料"""
    success: bool
    count: int
    material_1: int  # 物料编号1
    material_2: int  # 物料编号2
    material_3: int  # 物料编号3
    material_4: int  # 物料编号4
    material_5: int  # 物料编号5
    message: str
    unilabos_samples: List[LabSample]
 # ============ 状态枚举 ============
 class HeatingStationState(Enum):
    """加热台状态枚举"""
    IDLE = "idle"  # 空闲
    OCCUPIED = "occupied"  # 已放置物料, 等待加热
    HEATING = "heating"  # 加热中
    COMPLETED = "completed"  # 加热完成, 等待取走
 class ArmState(Enum):
    """机械臂状态枚举"""
    IDLE = "idle"  # 空闲
    BUSY = "busy"  # 工作中
@dataclass
 class HeatingStation:
    """加热台数据结构"""
    station_id: int
    state: HeatingStationState = HeatingStationState.IDLE
    current_material: Optional[str] = None  # 当前物料 (如 "A1", "A2")
    material_number: Optional[int] = None  # 物料编号 (1-5)
    heating_start_time: Optional[float] = None
    heating_progress: float = 0.0
@device(
    id="virtual_workbench",
    category=["virtual_device"],
    description="Virtual Workbench with 1 robotic arm and 3 heating stations for concurrent material processing",
 )
 class VirtualWorkbench:
    """
    Virtual Workbench Device - 虚拟工作台设备
    模拟一个包含1个机械臂和3个加热台的工作站
    - 机械臂操作耗时3秒, 同一时间只能执行一个操作
    - 加热台加热耗时10秒, 3个加热台可并行工作
    工作流:
    1. 物料A1-A5并发启动(线程池), 竞争机械臂使用权
    2. 获取机械臂后, 查找空闲加热台
    3. 机械臂将物料放入加热台, 开始加热
    4. 加热完成后, 机械臂将物料移动到目标位置Cn
    """
    _ros_node: BaseROS2DeviceNode
    # 配置常量
    ARM_OPERATION_TIME: float = 2  # 机械臂操作时间(秒)
    HEATING_TIME: float = 60.0  # 加热时间(秒)
    NUM_HEATING_STATIONS: int = 3  # 加热台数量
    def __init__(self, device_id: Optional[str] = None, config: Optional[Dict[str, Any]] = None, **kwargs):
        # 处理可能的不同调用方式
        if device_id is None and "id" in kwargs:
            device_id = kwargs.pop("id")
        if config is None and "config" in kwargs:
            config = kwargs.pop("config")
        self.device_id = device_id or "virtual_workbench"
        self.config = config or {}
        self.logger = logging.getLogger(f"VirtualWorkbench.{self.device_id}")
        self.data: Dict[str, Any] = {}
        # 从config中获取可配置参数
        self.ARM_OPERATION_TIME = float(self.config.get("arm_operation_time", self.ARM_OPERATION_TIME))
        self.HEATING_TIME = float(self.config.get("heating_time", self.HEATING_TIME))
        self.NUM_HEATING_STATIONS = int(self.config.get("num_heating_stations", self.NUM_HEATING_STATIONS))
        # 机械臂状态和锁
        self._arm_lock = Lock()
        self._arm_state = ArmState.IDLE
        self._arm_current_task: Optional[str] = None
        # 加热台状态
        self._heating_stations: Dict[int, HeatingStation] = {
            i: HeatingStation(station_id=i) for i in range(1, self.NUM_HEATING_STATIONS + 1)
        }
        self._stations_lock = RLock()
        # 任务追踪
        self._active_tasks: Dict[str, Dict[str, Any]] = {}
        self._tasks_lock = Lock()
        # 处理其他kwargs参数
        skip_keys = {"arm_operation_time", "heating_time", "num_heating_stations"}
        for key, value in kwargs.items():
            if key not in skip_keys and not hasattr(self, key):
                setattr(self, key, value)
        self.logger.info(f"=== 虚拟工作台 {self.device_id} 已创建 ===")
        self.logger.info(
            f"机械臂操作时间: {self.ARM_OPERATION_TIME}s | "
            f"加热时间: {self.HEATING_TIME}s | "
            f"加热台数量: {self.NUM_HEATING_STATIONS}"
        )
    @not_action
    def post_init(self, ros_node: BaseROS2DeviceNode):
        """ROS节点初始化后回调"""
        self._ros_node = ros_node
    @not_action
    def initialize(self) -> bool:
        """初始化虚拟工作台"""
        self.logger.info(f"初始化虚拟工作台 {self.device_id}")
        with self._stations_lock:
            for station in self._heating_stations.values():
                station.state = HeatingStationState.IDLE
                station.current_material = None
                station.material_number = None
                station.heating_progress = 0.0
        self.data.update(
            {
                "status": "Ready",
                "arm_state": ArmState.IDLE.value,
                "arm_current_task": None,
                "heating_stations": self._get_stations_status(),
                "active_tasks_count": 0,
                "message": "工作台就绪",
            }
        )
        self.logger.info(f"工作台初始化完成: {self.NUM_HEATING_STATIONS}个加热台就绪")
        return True
    @not_action
    def cleanup(self) -> bool:
        """清理虚拟工作台"""
        self.logger.info(f"清理虚拟工作台 {self.device_id}")
        self._arm_state = ArmState.IDLE
        self._arm_current_task = None
        with self._stations_lock:
            self._heating_stations.clear()
        with self._tasks_lock:
            self._active_tasks.clear()
        self.data.update(
            {
                "status": "Offline",
                "arm_state": ArmState.IDLE.value,
                "heating_stations": {},
                "message": "工作台已关闭",
            }
        )
        return True
    def _get_stations_status(self) -> Dict[int, Dict[str, Any]]:
        """获取所有加热台状态"""
        with self._stations_lock:
            return {
                station_id: {
                    "state": station.state.value,
                    "current_material": station.current_material,
                    "material_number": station.material_number,
                    "heating_progress": station.heating_progress,
                }
                for station_id, station in self._heating_stations.items()
            }
    def _update_data_status(self, message: Optional[str] = None):
        """更新状态数据"""
        self.data.update(
            {
                "arm_state": self._arm_state.value,
                "arm_current_task": self._arm_current_task,
                "heating_stations": self._get_stations_status(),
                "active_tasks_count": len(self._active_tasks),
            }
        )
        if message:
            self.data["message"] = message
    def _find_available_heating_station(self) -> Optional[int]:
        """查找空闲的加热台"""
        with self._stations_lock:
            for station_id, station in self._heating_stations.items():
                if station.state == HeatingStationState.IDLE:
                    return station_id
        return None
    def _acquire_arm(self, task_description: str) -> bool:
        """获取机械臂使用权(阻塞直到获取)"""
        self.logger.info(f"[{task_description}] 等待获取机械臂...")
        self._arm_lock.acquire()
        self._arm_state = ArmState.BUSY
        self._arm_current_task = task_description
        self._update_data_status(f"机械臂执行: {task_description}")
        self.logger.info(f"[{task_description}] 成功获取机械臂使用权")
        return True
    def _release_arm(self):
        """释放机械臂"""
        task = self._arm_current_task
        self._arm_state = ArmState.IDLE
        self._arm_current_task = None
        self._arm_lock.release()
        self._update_data_status(f"机械臂已释放 (完成: {task})")
        self.logger.info(f"机械臂已释放 (完成: {task})")
    @action(
        always_free=True, node_type=NodeType.MANUAL_CONFIRM, placeholder_keys={
            "assignee_user_ids": "unilabos_manual_confirm"
        }, goal_default={
            "timeout_seconds": 3600,
            "assignee_user_ids": []
        }, feedback_interval=300,
        handles=[
            ActionInputHandle(key="target_device", data_type="device_id",
                              label="目标设备", data_key="target_device", data_source=DataSource.HANDLE),
            ActionInputHandle(key="resource", data_type="resource",
                              label="待转移资源", data_key="resource", data_source=DataSource.HANDLE),
            ActionInputHandle(key="mount_resource", data_type="resource",
                              label="目标孔位", data_key="mount_resource", data_source=DataSource.HANDLE),
            ActionInputHandle(key="collector_mass", data_type="collector_mass",
                              label="极流体质量", data_key="collector_mass", data_source=DataSource.HANDLE),
            ActionInputHandle(key="active_material", data_type="active_material",
                              label="活性物质含量", data_key="active_material", data_source=DataSource.HANDLE),
            ActionInputHandle(key="capacity", data_type="capacity",
                              label="克容量", data_key="capacity", data_source=DataSource.HANDLE),
            ActionInputHandle(key="battery_system", data_type="battery_system",
                              label="电池体系", data_key="battery_system", data_source=DataSource.HANDLE),
            # transfer使用
            ActionOutputHandle(key="target_device", data_type="device_id",
                               label="目标设备", data_key="target_device", data_source=DataSource.EXECUTOR),
            ActionOutputHandle(key="resource", data_type="resource",
                              label="待转移资源", data_key="resource.@flatten", data_source=DataSource.EXECUTOR),
            ActionOutputHandle(key="mount_resource", data_type="resource",
                              label="目标孔位", data_key="mount_resource.@flatten", data_source=DataSource.EXECUTOR),
            # test使用
            ActionOutputHandle(key="collector_mass", data_type="collector_mass",
                              label="极流体质量", data_key="collector_mass", data_source=DataSource.EXECUTOR),
            ActionOutputHandle(key="active_material", data_type="active_material",
                              label="活性物质含量", data_key="active_material", data_source=DataSource.EXECUTOR),
            ActionOutputHandle(key="capacity", data_type="capacity",
                              label="克容量", data_key="capacity", data_source=DataSource.EXECUTOR),
            ActionOutputHandle(key="battery_system", data_type="battery_system",
                              label="电池体系", data_key="battery_system", data_source=DataSource.EXECUTOR),
        ]
    )
    def manual_confirm(
        self,
        resource: List[ResourceSlot],
        target_device: DeviceSlot,
        mount_resource: List[ResourceSlot],
        collector_mass: List[float],
        active_material: List[float],
        capacity: List[float],
        battery_system: List[str],
        timeout_seconds: int,
        assignee_user_ids: list[str],
        **kwargs
    ) -> dict:
        """
        timeout_seconds: 超时时间（秒），默认3600秒
        collector_mass: 极流体质量
        active_material: 活性物质含量
        capacity: 克容量（mAh/g）
        battery_system: 电池体系
        修改的结果无效，是只读的
        """
        resource = ResourceTreeSet.from_plr_resources(resource).dump()
        mount_resource = ResourceTreeSet.from_plr_resources(mount_resource).dump()
        kwargs.update(locals())
        kwargs.pop("kwargs")
        kwargs.pop("self")
        return kwargs
    @action(
        description="转移物料",
        handles=[
            ActionInputHandle(key="target_device", data_type="device_id",
                              label="目标设备", data_key="target_device", data_source=DataSource.HANDLE),
            ActionInputHandle(key="resource", data_type="resource",
                               label="待转移资源", data_key="resource", data_source=DataSource.HANDLE),
            ActionInputHandle(key="mount_resource", data_type="resource",
                               label="目标孔位", data_key="mount_resource", data_source=DataSource.HANDLE),
        ]
    )
    async def transfer(self, resource: List[ResourceSlot], target_device: DeviceSlot, mount_resource: List[ResourceSlot]):
        future = ROS2DeviceNode.run_async_func(self._ros_node.transfer_resource_to_another, True,
            **{
                "plr_resources": resource,
                "target_device_id": target_device,
                "target_resources": mount_resource,
                "sites": [None] * len(mount_resource),
            })
        result = await future
        return result
    @action(
        description="扣电测试启动",
        handles=[
            ActionInputHandle(key="resource", data_type="resource",
                              label="待转移资源", data_key="resource", data_source=DataSource.HANDLE),
            ActionInputHandle(key="mount_resource", data_type="resource",
                              label="目标孔位", data_key="mount_resource", data_source=DataSource.HANDLE),
            ActionInputHandle(key="collector_mass", data_type="collector_mass",
                              label="极流体质量", data_key="collector_mass", data_source=DataSource.HANDLE),
            ActionInputHandle(key="active_material", data_type="active_material",
                              label="活性物质含量", data_key="active_material", data_source=DataSource.HANDLE),
            ActionInputHandle(key="capacity", data_type="capacity",
                              label="克容量", data_key="capacity", data_source=DataSource.HANDLE),
            ActionInputHandle(key="battery_system", data_type="battery_system",
                              label="电池体系", data_key="battery_system", data_source=DataSource.HANDLE),
        ]
    )
    async def test(
        self, resource: List[ResourceSlot], mount_resource: List[ResourceSlot],  collector_mass: List[float], active_material: List[float], capacity: List[float], battery_system: list[str]
    ):
        print(resource)
        print(mount_resource)
        print(collector_mass)
        print(active_material)
        print(capacity)
        print(battery_system)
    @action(
        auto_prefix=True,
        description="批量准备物料 - 虚拟起始节点, 生成A1-A5物料, 输出5个handle供后续节点使用",
        handles=[
            ActionOutputHandle(key="channel_1", data_type="workbench_material",
                         label="实验1", data_key="material_1", data_source=DataSource.EXECUTOR),
            ActionOutputHandle(key="channel_2", data_type="workbench_material",
                         label="实验2", data_key="material_2", data_source=DataSource.EXECUTOR),
            ActionOutputHandle(key="channel_3", data_type="workbench_material",
                         label="实验3", data_key="material_3", data_source=DataSource.EXECUTOR),
            ActionOutputHandle(key="channel_4", data_type="workbench_material",
                         label="实验4", data_key="material_4", data_source=DataSource.EXECUTOR),
            ActionOutputHandle(key="channel_5", data_type="workbench_material",
                         label="实验5", data_key="material_5", data_source=DataSource.EXECUTOR),
        ],
    )
    def prepare_materials(
        self,
        sample_uuids: SampleUUIDsType,
        count: int = 5,
    ) -> PrepareMaterialsResult:
        """
        批量准备物料 - 虚拟起始节点
        作为工作流的起始节点, 生成指定数量的物料编号供后续节点使用。
        输出5个handle (material_1 ~ material_5), 分别对应实验1~5。
        """
        materials = [i for i in range(1, count + 1)]
        self.logger.info(
            f"[准备物料] 生成 {count} 个物料: A1-A{count} -> material_1~material_{count}"
        )
        return {
            "success": True,
            "count": count,
            "material_1": materials[0] if len(materials) > 0 else 0,
            "material_2": materials[1] if len(materials) > 1 else 0,
            "material_3": materials[2] if len(materials) > 2 else 0,
            "material_4": materials[3] if len(materials) > 3 else 0,
            "material_5": materials[4] if len(materials) > 4 else 0,
            "message": f"已准备 {count} 个物料: A1-A{count}",
            "unilabos_samples": [
                LabSample(
                    sample_uuid=sample_uuid,
                    oss_path="",
                    extra={"material_uuid": content} if isinstance(content, str) else (content.serialize() if content else {}),
                )
                for sample_uuid, content in sample_uuids.items()
            ],
        }
    @action(
        auto_prefix=True,
        description="将物料从An位置移动到空闲加热台, 返回分配的加热台ID",
        handles=[
            ActionInputHandle(key="material_input", data_type="workbench_material",
                        label="物料编号", data_key="material_number", data_source=DataSource.HANDLE),
            ActionOutputHandle(key="heating_station_output", data_type="workbench_station",
                         label="加热台ID", data_key="station_id", data_source=DataSource.EXECUTOR),
            ActionOutputHandle(key="material_number_output", data_type="workbench_material",
                         label="物料编号", data_key="material_number", data_source=DataSource.EXECUTOR),
        ],
    )
    def move_to_heating_station(
        self,
        sample_uuids: SampleUUIDsType,
        material_number: int,
    ) -> MoveToHeatingStationResult:
        """
        将物料从An位置移动到加热台
        多线程并发调用时, 会竞争机械臂使用权, 并自动查找空闲加热台
        """
        material_id = f"A{material_number}"
        task_desc = f"移动{material_id}到加热台"
        self.logger.info(f"[任务] {task_desc} - 开始执行")
        with self._tasks_lock:
            self._active_tasks[material_id] = {
                "status": "waiting_for_arm",
                "start_time": time.time(),
            }
        try:
            with self._tasks_lock:
                self._active_tasks[material_id]["status"] = "waiting_for_arm"
            self._acquire_arm(task_desc)
            with self._tasks_lock:
                self._active_tasks[material_id]["status"] = "finding_station"
            station_id = None
            while station_id is None:
                station_id = self._find_available_heating_station()
                if station_id is None:
                    self.logger.info(f"[{material_id}] 没有空闲加热台, 等待中...")
                    self._release_arm()
                    time.sleep(0.5)
                    self._acquire_arm(task_desc)
            with self._stations_lock:
                self._heating_stations[station_id].state = HeatingStationState.OCCUPIED
                self._heating_stations[station_id].current_material = material_id
                self._heating_stations[station_id].material_number = material_number
            with self._tasks_lock:
                self._active_tasks[material_id]["status"] = "arm_moving"
                self._active_tasks[material_id]["assigned_station"] = station_id
            self.logger.info(f"[{material_id}] 机械臂正在移动到加热台{station_id}...")
            time.sleep(self.ARM_OPERATION_TIME)
            self._update_data_status(f"{material_id}已放入加热台{station_id}")
            self.logger.info(
                f"[{material_id}] 已放入加热台{station_id} (用时{self.ARM_OPERATION_TIME}s)"
            )
            self._release_arm()
            with self._tasks_lock:
                self._active_tasks[material_id]["status"] = "placed_on_station"
            return {
                "success": True,
                "station_id": station_id,
                "material_id": material_id,
                "material_number": material_number,
                "message": f"{material_id}已成功移动到加热台{station_id}",
                "unilabos_samples": [
                    LabSample(
                        sample_uuid=sample_uuid,
                        oss_path="",
                        extra=(
                            {"material_uuid": content}
                            if isinstance(content, str) else (content.serialize() if content else {})
                        ),
                    )
                    for sample_uuid, content in sample_uuids.items()
                ],
            }
        except Exception as e:
            self.logger.error(f"[{material_id}] 移动失败: {str(e)}")
            if self._arm_lock.locked():
                self._release_arm()
            return {
                "success": False,
                "station_id": -1,
                "material_id": material_id,
                "material_number": material_number,
                "message": f"移动失败: {str(e)}",
                "unilabos_samples": [
                    LabSample(
                        sample_uuid=sample_uuid,
                        oss_path="",
                        extra=(
                            {"material_uuid": content}
                            if isinstance(content, str) else (content.serialize() if content else {})
                        ),
                    )
                    for sample_uuid, content in sample_uuids.items()
                ],
            }
    @action(
        auto_prefix=True,
        always_free=True,
        description="启动指定加热台的加热程序",
        handles=[
            ActionInputHandle(key="station_id_input", data_type="workbench_station",
                        label="加热台ID", data_key="station_id", data_source=DataSource.HANDLE),
            ActionInputHandle(key="material_number_input", data_type="workbench_material",
                        label="物料编号", data_key="material_number", data_source=DataSource.HANDLE),
            ActionOutputHandle(key="heating_done_station", data_type="workbench_station",
                         label="加热完成-加热台ID", data_key="station_id", data_source=DataSource.EXECUTOR),
            ActionOutputHandle(key="heating_done_material", data_type="workbench_material",
                         label="加热完成-物料编号", data_key="material_number", data_source=DataSource.EXECUTOR),
        ],
    )
    def start_heating(
        self,
        sample_uuids: SampleUUIDsType,
        station_id: int,
        material_number: int,
    ) -> StartHeatingResult:
        """
        启动指定加热台的加热程序
        """
        self.logger.info(f"[加热台{station_id}] 开始加热")
        if station_id not in self._heating_stations:
            return {
                "success": False,
                "station_id": station_id,
                "material_id": "",
                "material_number": material_number,
                "message": f"无效的加热台ID: {station_id}",
                "unilabos_samples": [
                    LabSample(
                        sample_uuid=sample_uuid,
                        oss_path="",
                        extra=(
                            {"material_uuid": content}
                            if isinstance(content, str) else (content.serialize() if content else {})
                        ),
                    )
                    for sample_uuid, content in sample_uuids.items()
                ],
            }
        with self._stations_lock:
            station = self._heating_stations[station_id]
            if station.current_material is None:
                return {
                    "success": False,
                    "station_id": station_id,
                    "material_id": "",
                    "material_number": material_number,
                    "message": f"加热台{station_id}上没有物料",
                    "unilabos_samples": [
                        LabSample(
                            sample_uuid=sample_uuid,
                            oss_path="",
                            extra=(
                                {"material_uuid": content}
                                if isinstance(content, str) else (content.serialize() if content else {})
                            ),
                        )
                        for sample_uuid, content in sample_uuids.items()
                    ],
                }
            if station.state == HeatingStationState.HEATING:
                return {
                    "success": False,
                    "station_id": station_id,
                    "material_id": station.current_material,
                    "material_number": material_number,
                    "message": f"加热台{station_id}已经在加热中",
                    "unilabos_samples": [
                        LabSample(
                            sample_uuid=sample_uuid,
                            oss_path="",
                            extra=(
                                {"material_uuid": content}
                                if isinstance(content, str) else (content.serialize() if content else {})
                            ),
                        )
                        for sample_uuid, content in sample_uuids.items()
                    ],
                }
            material_id = station.current_material
            station.state = HeatingStationState.HEATING
            station.heating_start_time = time.time()
            station.heating_progress = 0.0
        with self._tasks_lock:
            if material_id in self._active_tasks:
                self._active_tasks[material_id]["status"] = "heating"
        self._update_data_status(f"加热台{station_id}开始加热{material_id}")
        with self._stations_lock:
            heating_list = [
                f"加热台{sid}:{s.current_material}"
                for sid, s in self._heating_stations.items()
                if s.state == HeatingStationState.HEATING and s.current_material
            ]
        self.logger.info(f"[并行加热] 当前同时加热中: {', '.join(heating_list)}")
        start_time = time.time()
        last_countdown_log = start_time
        while True:
            elapsed = time.time() - start_time
            remaining = max(0.0, self.HEATING_TIME - elapsed)
            progress = min(100.0, (elapsed / self.HEATING_TIME) * 100)
            with self._stations_lock:
                self._heating_stations[station_id].heating_progress = progress
            self._update_data_status(f"加热台{station_id}加热中: {progress:.1f}%")
            if time.time() - last_countdown_log >= 5.0:
                self.logger.info(f"[加热台{station_id}] {material_id} 剩余 {remaining:.1f}s")
                last_countdown_log = time.time()
            if elapsed >= self.HEATING_TIME:
                break
            time.sleep(1.0)
        with self._stations_lock:
            self._heating_stations[station_id].state = HeatingStationState.COMPLETED
            self._heating_stations[station_id].heating_progress = 100.0
        with self._tasks_lock:
            if material_id in self._active_tasks:
                self._active_tasks[material_id]["status"] = "heating_completed"
        self._update_data_status(f"加热台{station_id}加热完成")
        self.logger.info(f"[加热台{station_id}] {material_id}加热完成 (用时{self.HEATING_TIME}s)")
        return {
            "success": True,
            "station_id": station_id,
            "material_id": material_id,
            "material_number": material_number,
            "message": f"加热台{station_id}加热完成",
            "unilabos_samples": [
                LabSample(
                    sample_uuid=sample_uuid,
                    oss_path="",
                    extra=(
                        {"material_uuid": content}
                        if isinstance(content, str) else (content.serialize() if content else {})
                    ),
                )
                for sample_uuid, content in sample_uuids.items()
            ],
        }
    @action(
        auto_prefix=True,
        description="将物料从加热台移动到输出位置Cn",
        handles=[
            ActionInputHandle(key="output_station_input", data_type="workbench_station",
                        label="加热台ID", data_key="station_id", data_source=DataSource.HANDLE),
            ActionInputHandle(key="output_material_input", data_type="workbench_material",
                        label="物料编号", data_key="material_number", data_source=DataSource.HANDLE),
        ],
    )
    def move_to_output(
        self,
        sample_uuids: SampleUUIDsType,
        station_id: int,
        material_number: int,
    ) -> MoveToOutputResult:
        """
        将物料从加热台移动到输出位置Cn
        """
        output_number = material_number
        if station_id not in self._heating_stations:
            return {
                "success": False,
                "station_id": station_id,
                "material_id": "",
                "output_position": f"C{output_number}",
                "message": f"无效的加热台ID: {station_id}",
                "unilabos_samples": [
                    LabSample(
                        sample_uuid=sample_uuid,
                        oss_path="",
                        extra=(
                            {"material_uuid": content}
                            if isinstance(content, str) else (content.serialize() if content else {})
                        ),
                    )
                    for sample_uuid, content in sample_uuids.items()
                ],
            }
        with self._stations_lock:
            station = self._heating_stations[station_id]
            material_id = station.current_material
            if material_id is None:
                return {
                    "success": False,
                    "station_id": station_id,
                    "material_id": "",
                    "output_position": f"C{output_number}",
                    "message": f"加热台{station_id}上没有物料",
                    "unilabos_samples": [
                        LabSample(
                            sample_uuid=sample_uuid,
                            oss_path="",
                            extra=(
                                {"material_uuid": content}
                                if isinstance(content, str) else (content.serialize() if content else {})
                            ),
                        )
                        for sample_uuid, content in sample_uuids.items()
                    ],
                }
            if station.state != HeatingStationState.COMPLETED:
                return {
                    "success": False,
                    "station_id": station_id,
                    "material_id": material_id,
                    "output_position": f"C{output_number}",
                    "message": f"加热台{station_id}尚未完成加热 (当前状态: {station.state.value})",
                    "unilabos_samples": [
                        LabSample(
                            sample_uuid=sample_uuid,
                            oss_path="",
                            extra=(
                                {"material_uuid": content}
                                if isinstance(content, str) else (content.serialize() if content else {})
                            ),
                        )
                        for sample_uuid, content in sample_uuids.items()
                    ],
                }
        output_position = f"C{output_number}"
        task_desc = f"从加热台{station_id}移动{material_id}到{output_position}"
        self.logger.info(f"[任务] {task_desc}")
        try:
            with self._tasks_lock:
                if material_id in self._active_tasks:
                    self._active_tasks[material_id]["status"] = "waiting_for_arm_output"
            self._acquire_arm(task_desc)
            with self._tasks_lock:
                if material_id in self._active_tasks:
                    self._active_tasks[material_id]["status"] = "arm_moving_to_output"
            self.logger.info(
                f"[{material_id}] 机械臂正在从加热台{station_id}取出并移动到{output_position}..."
            )
            time.sleep(self.ARM_OPERATION_TIME)
            with self._stations_lock:
                self._heating_stations[station_id].state = HeatingStationState.IDLE
                self._heating_stations[station_id].current_material = None
                self._heating_stations[station_id].material_number = None
                self._heating_stations[station_id].heating_progress = 0.0
                self._heating_stations[station_id].heating_start_time = None
            self._release_arm()
            with self._tasks_lock:
                if material_id in self._active_tasks:
                    self._active_tasks[material_id]["status"] = "completed"
                    self._active_tasks[material_id]["end_time"] = time.time()
            self._update_data_status(f"{material_id}已移动到{output_position}")
            self.logger.info(
                f"[{material_id}] 已成功移动到{output_position} (用时{self.ARM_OPERATION_TIME}s)"
            )
            return {
                "success": True,
                "station_id": station_id,
                "material_id": material_id,
                "output_position": output_position,
                "message": f"{material_id}已成功移动到{output_position}",
                "unilabos_samples": [
                    LabSample(
                        sample_uuid=sample_uuid,
                        oss_path="",
                        extra=(
                            {"material_uuid": content}
                            if isinstance(content, str)
                            else (content.serialize() if content is not None else {})
                        ),
                    )
                    for sample_uuid, content in sample_uuids.items()
                ],
            }
        except Exception as e:
            self.logger.error(f"移动到输出位置失败: {str(e)}")
            if self._arm_lock.locked():
                self._release_arm()
            return {
                "success": False,
                "station_id": station_id,
                "material_id": "",
                "output_position": output_position,
                "message": f"移动失败: {str(e)}",
                "unilabos_samples": [
                    LabSample(
                        sample_uuid=sample_uuid,
                        oss_path="",
                        extra=(
                            {"material_uuid": content}
                            if isinstance(content, str) else (content.serialize() if content else {})
                        ),
                    )
                    for sample_uuid, content in sample_uuids.items()
                ],
            }
    # ============ 状态属性 ============
    @property
    @topic_config()
    def status(self) -> str:
        return self.data.get("status", "Unknown")
    @property
    @topic_config()
    def arm_state(self) -> str:
        return self._arm_state.value
    @property
    @topic_config()
    def arm_current_task(self) -> str:
        return self._arm_current_task or ""
    @property
    @topic_config()
    def heating_station_1_state(self) -> str:
        with self._stations_lock:
            station = self._heating_stations.get(1)
            return station.state.value if station else "unknown"
    @property
    @topic_config()
    def heating_station_1_material(self) -> str:
        with self._stations_lock:
            station = self._heating_stations.get(1)
            return station.current_material or "" if station else ""
    @property
    @topic_config()
    def heating_station_1_progress(self) -> float:
        with self._stations_lock:
            station = self._heating_stations.get(1)
            return station.heating_progress if station else 0.0
    @property
    @topic_config()
    def heating_station_2_state(self) -> str:
        with self._stations_lock:
            station = self._heating_stations.get(2)
            return station.state.value if station else "unknown"
    @property
    @topic_config()
    def heating_station_2_material(self) -> str:
        with self._stations_lock:
            station = self._heating_stations.get(2)
            return station.current_material or "" if station else ""
    @property
    @topic_config()
    def heating_station_2_progress(self) -> float:
        with self._stations_lock:
            station = self._heating_stations.get(2)
            return station.heating_progress if station else 0.0
    @property
    @topic_config()
    def heating_station_3_state(self) -> str:
        with self._stations_lock:
            station = self._heating_stations.get(3)
            return station.state.value if station else "unknown"
    @property
    @topic_config()
    def heating_station_3_material(self) -> str:
        with self._stations_lock:
            station = self._heating_stations.get(3)
            return station.current_material or "" if station else ""
    @property
    @topic_config()
    def heating_station_3_progress(self) -> float:
        with self._stations_lock:
            station = self._heating_stations.get(3)
            return station.heating_progress if station else 0.0
    @property
    @topic_config()
    def active_tasks_count(self) -> int:
        with self._tasks_lock:
            return len(self._active_tasks)
    @property
    @topic_config()
    def message(self) -> str:
        return self.data.get("message", "")
--- a/Show More
+++ b/Show More
		`@@ -1,4 +0,0 @@`

			`Please follow the rules defined in:`

			`@AGENTS.md`
`@@ -1 +1 @@`
	`__version__ = "0.10.19"`	`__version__ = "0.10.14"`