Merge pull request #205 from sun7151887/push-sync-20251222

修复物料不能显示的问题

.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"

.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"

.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"

.conda/recipe.yaml

@@ -0,0 +1,92 @@
+package:
+  name: unilabos
+  version: 0.10.12
+
+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/dptech-corp/Uni-Lab-OS
+  license: GPL-3.0-only
+  description: "Uni-Lab-OS"

.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

.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

.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>/` 目录下

.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` |

.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` |

.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/` 目录下各工作站实现。

.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)
-```

.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"}
-```

.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`）中查找。

.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()

.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
-    └── ...
-```

.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()

.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()

.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) 确认完成
-```

.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` 类型

.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"
-  }
-}

.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"
-  }
-}

.cursor/skills/host-node/actions/test_latency.json

@@ -1,11 +0,0 @@
-{
-  "type": "UniLabJsonCommand",
-  "goal": {},
-  "schema": {
-    "type": "object",
-    "properties": {},
-    "required": []
-  },
-  "goal_default": {},
-  "placeholder_keys": {}
-}

.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"
-  }
-}

.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>` 替代。

.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()

.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`。

.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` 类型

.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"
-  }
-}

.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": {}
-}

.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": {}
-}

.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": {}
-}

.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": {}
-}

.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"
-  }
-}

.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"

.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 "检查通过：无文件变化"

.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
-          )
+          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
+          mamba install -n unilab uni-lab::unilabos conda-pack -c uni-lab -c robostack-staging -c conda-forge -y
 
       - 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
-          if "${{ github.event.inputs.build_full }}"=="true" (
-            echo Package: unilabos-full ^(complete^)
-          ) else (
-            echo Package: unilabos ^(minimal^)
-          )
+          echo Python version: 3.11.11
           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"
-          if [[ "${{ github.event.inputs.build_full }}" == "true" ]]; then
-            echo "Package: unilabos-full (complete)"
-          else
-            echo "Package: unilabos (minimal)"
-          fi
+          echo "Python version: 3.11.11"
           echo ""
           echo "Distribution package contents:"
           ls -lh dist-package/

.github/workflows/deploy-docs.yml

@@ -1,12 +1,10 @@
 name: Deploy Docs
 
 on:
-  # 在 CI Check 成功后自动触发（仅 main 分支）
-  workflow_run:
-    workflows: ["CI Check"]
-    types: [completed]
+  push:
+    branches: [main]
+  pull_request:
     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.workflow_run.head_branch || github.event.inputs.branch || github.ref }}
+          ref: ${{ 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
-        if: |
-          github.event.workflow_run.head_branch == 'main' ||
-          (github.event_name == 'workflow_dispatch' && github.event.inputs.deploy_to_pages == 'true')
+        uses: actions/configure-pages@v4
+        if: github.ref == 'refs/heads/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
-        if: |
-          github.event.workflow_run.head_branch == 'main' ||
-          (github.event_name == 'workflow_dispatch' && github.event.inputs.deploy_to_pages == 'true')
+        uses: actions/upload-pages-artifact@v3
+        if: github.ref == 'refs/heads/main' || (github.event_name == 'workflow_dispatch' && github.event.inputs.deploy_to_pages == 'true')
         with:
           path: docs/_build/html
 
   # Deploy to GitHub Pages
   deploy:
-    if: |
-      github.event.workflow_run.head_branch == 'main' ||
-      (github.event_name == 'workflow_dispatch' && github.event.inputs.deploy_to_pages == 'true')
+    if: github.ref == 'refs/heads/main' || (github.event_name == 'workflow_dispatch' && github.event.inputs.deploy_to_pages == 'true')
     environment:
       name: github-pages
       url: ${{ steps.deployment.outputs.page_url }}

.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

.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 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
+          echo "Building UniLabOS package"
 
-      - 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/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
+          rattler-build build -r .conda/recipe.yaml -c uni-lab -c robostack-staging -c conda-forge
 
       - 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

.gitignore

@@ -1,11 +1,8 @@
-cursor_docs/
 configs/
 temp/
 output/
 unilabos_data/
 pyrightconfig.json
-.cursorignore
-device_package*/
 ## Python
 
 # Byte-compiled / optimized / DLL files
@@ -251,7 +248,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
+

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` 内部的新增附属字段，不破坏现有数据结构。

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

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 个资源全部无法放置到对应仓库位，前端不显示。

CLAUDE.md

@@ -1,4 +0,0 @@
-
-Please follow the rules defined in:
-
-@AGENTS.md

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 *

NOTICE

@@ -1,17 +0,0 @@
-# Uni-Lab-OS Licensing Notice
-
-This project uses a dual licensing structure:
-
-## 1. Main Framework - GPL-3.0
-
-- unilabos/ (except unilabos/devices/)
-- docs/
-- tests/
-
-See [LICENSE](LICENSE) for details.
-
-## 2. Device Drivers - DP Technology Proprietary License
-
-- unilabos/devices/
-
-See [unilabos/devices/LICENSE](unilabos/devices/LICENSE) for details.

README.md

@@ -8,13 +8,17 @@
 
 **English** | [中文](README_zh.md)
 
-[![GitHub Stars](https://img.shields.io/github/stars/dptech-corp/Uni-Lab-OS.svg)](https://github.com/deepmodeling/Uni-Lab-OS/stargazers)
-[![GitHub Forks](https://img.shields.io/github/forks/dptech-corp/Uni-Lab-OS.svg)](https://github.com/deepmodeling/Uni-Lab-OS/network/members)
-[![GitHub Issues](https://img.shields.io/github/issues/dptech-corp/Uni-Lab-OS.svg)](https://github.com/deepmodeling/Uni-Lab-OS/issues)
-[![GitHub License](https://img.shields.io/github/license/dptech-corp/Uni-Lab-OS.svg)](https://github.com/deepmodeling/Uni-Lab-OS/blob/main/LICENSE)
+[![GitHub Stars](https://img.shields.io/github/stars/dptech-corp/Uni-Lab-OS.svg)](https://github.com/dptech-corp/Uni-Lab-OS/stargazers)
+[![GitHub Forks](https://img.shields.io/github/forks/dptech-corp/Uni-Lab-OS.svg)](https://github.com/dptech-corp/Uni-Lab-OS/network/members)
+[![GitHub Issues](https://img.shields.io/github/issues/dptech-corp/Uni-Lab-OS.svg)](https://github.com/dptech-corp/Uni-Lab-OS/issues)
+[![GitHub License](https://img.shields.io/github/license/dptech-corp/Uni-Lab-OS.svg)](https://github.com/dptech-corp/Uni-Lab-OS/blob/main/LICENSE)
 
 Uni-Lab-OS is a platform for laboratory automation, designed to connect and control various experimental equipment, enabling automation and standardization of experimental workflows.
 
+## 🏆 Competition
+
+Join the [Intelligent Organic Chemistry Synthesis Competition](https://bohrium.dp.tech/competitions/1451645258) to explore automated synthesis with Uni-Lab-OS!
+
 ## Key Features
 
 - Multi-device integration management
@@ -27,89 +31,41 @@ Uni-Lab-OS is a platform for laboratory automation, designed to connect and cont
 
 Detailed documentation can be found at:
 
-- [Online Documentation](https://deepmodeling.github.io/Uni-Lab-OS/)
+- [Online Documentation](https://xuwznln.github.io/Uni-Lab-OS-Doc/)
 
 ## Quick Start
 
-### 1. Setup Conda Environment
-
-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 |
+Uni-Lab-OS recommends using `mamba` for environment management. Choose the appropriate environment file for your operating system:
 
 ```bash
 # Create new environment
-mamba create -n unilab python=3.11.14
+mamba create -n unilab python=3.11.11
 mamba activate unilab
-
-# 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
+mamba install -n unilab uni-lab::unilabos -c robostack-staging -c conda-forge
 ```
 
-**When to use which?**
-- **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)
+## Install Dev Uni-Lab-OS
 
 ```bash
-# Clone the repository (only needed for development or examples)
-git clone https://github.com/deepmodeling/Uni-Lab-OS.git
+# Clone the repository
+git clone https://github.com/dptech-corp/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)
+Please refer to [Documentation - Boot Examples](https://xuwznln.github.io/Uni-Lab-OS-Doc/boot_examples/index.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:
-
-```bibtex
-@article{gao2025unilabos,
-    title = {UniLabOS: An AI-Native Operating System for Autonomous Laboratories},
-    doi = {10.48550/arXiv.2512.21766},
-    publisher = {arXiv},
-    author = {Gao, Jing and Chang, Junhan and Que, Haohui and Xiong, Yanfei and
-              Zhang, Shixiang and Qi, Xianwei and Liu, Zhen and Wang, Jun-Jie and
-              Ding, Qianjun and Li, Xinyu and Pan, Ziwei and Xie, Qiming and
-              Yan, Zhuang and Yan, Junchi and Zhang, Linfeng},
-    year = {2025}
-}
-```
+Uni-Lab-OS uses pre-built `unilabos_msgs` for system communication. You can find the built versions on the [GitHub Releases](https://github.com/dptech-corp/Uni-Lab-OS/releases) page.
 
 ## License
 
-This project uses a dual licensing structure:
-
-- **Main Framework**: GPL-3.0 - see [LICENSE](LICENSE)
-- **Device Drivers** (`unilabos/devices/`): DP Technology Proprietary License
-
-See [NOTICE](NOTICE) for complete licensing details.
+This project is licensed under GPL-3.0 - see the [LICENSE](LICENSE) file for details.
 
 ## Project Statistics
 
@@ -121,4 +77,4 @@ See [NOTICE](NOTICE) for complete licensing details.
 
 ## Contact Us
 
-- GitHub Issues: [https://github.com/deepmodeling/Uni-Lab-OS/issues](https://github.com/deepmodeling/Uni-Lab-OS/issues)
+- GitHub Issues: [https://github.com/dptech-corp/Uni-Lab-OS/issues](https://github.com/dptech-corp/Uni-Lab-OS/issues)

README_zh.md

@@ -8,13 +8,17 @@
 
 [English](README.md) | **中文**
 
-[![GitHub Stars](https://img.shields.io/github/stars/dptech-corp/Uni-Lab-OS.svg)](https://github.com/deepmodeling/Uni-Lab-OS/stargazers)
-[![GitHub Forks](https://img.shields.io/github/forks/dptech-corp/Uni-Lab-OS.svg)](https://github.com/deepmodeling/Uni-Lab-OS/network/members)
-[![GitHub Issues](https://img.shields.io/github/issues/dptech-corp/Uni-Lab-OS.svg)](https://github.com/deepmodeling/Uni-Lab-OS/issues)
-[![GitHub License](https://img.shields.io/github/license/dptech-corp/Uni-Lab-OS.svg)](https://github.com/deepmodeling/Uni-Lab-OS/blob/main/LICENSE)
+[![GitHub Stars](https://img.shields.io/github/stars/dptech-corp/Uni-Lab-OS.svg)](https://github.com/dptech-corp/Uni-Lab-OS/stargazers)
+[![GitHub Forks](https://img.shields.io/github/forks/dptech-corp/Uni-Lab-OS.svg)](https://github.com/dptech-corp/Uni-Lab-OS/network/members)
+[![GitHub Issues](https://img.shields.io/github/issues/dptech-corp/Uni-Lab-OS.svg)](https://github.com/dptech-corp/Uni-Lab-OS/issues)
+[![GitHub License](https://img.shields.io/github/license/dptech-corp/Uni-Lab-OS.svg)](https://github.com/dptech-corp/Uni-Lab-OS/blob/main/LICENSE)
 
 Uni-Lab-OS 是一个用于实验室自动化的综合平台，旨在连接和控制各种实验设备，实现实验流程的自动化和标准化。
 
+## 🏆 比赛
+
+欢迎参加[有机化学合成智能实验大赛](https://bohrium.dp.tech/competitions/1451645258)，使用 Uni-Lab-OS 探索自动化合成！
+
 ## 核心特点
 
 - 多设备集成管理
@@ -27,89 +31,43 @@ Uni-Lab-OS 是一个用于实验室自动化的综合平台，旨在连接和控
 
 详细文档可在以下位置找到:
 
-- [在线文档](https://deepmodeling.github.io/Uni-Lab-OS/)
+- [在线文档](https://xuwznln.github.io/Uni-Lab-OS-Doc/)
 
 ## 快速开始
 
-### 1. 配置 Conda 环境
+1. 配置 Conda 环境
 
-Uni-Lab-OS 建议使用 `mamba` 管理环境。根据您的需求选择合适的安装包：
-
-| 安装包 | 适用场景 | 包含内容 |
-|--------|----------|----------|
-| `unilabos` | **推荐大多数用户** | 完整安装包，开箱即用 |
-| `unilabos-env` | 开发者（可编辑安装） | 仅环境依赖，通过 pip 安装 unilabos |
-| `unilabos-full` | 仿真/可视化 | unilabos + ROS2 桌面版 + Gazebo + MoveIt |
+Uni-Lab-OS 建议使用 `mamba` 管理环境。根据您的操作系统选择适当的环境文件:
 
 ```bash
 # 创建新环境
-mamba create -n unilab python=3.11.14
+mamba create -n unilab python=3.11.11
 mamba activate unilab
-
-# 方案 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
+mamba install -n unilab uni-lab::unilabos -c robostack-staging -c conda-forge
 ```
 
-**如何选择？**
-- **unilabos**：标准安装，适用于生产部署和日常使用（推荐）
-- **unilabos-env**：开发者使用，支持 `pip install -e .` 可编辑模式，可修改源代码
-- **unilabos-full**：需要仿真（Gazebo）、可视化（rviz2）或 Jupyter Notebook
-
-### 2. 克隆仓库（可选，供开发者使用）
+2. 安装开发版 Uni-Lab-OS:
 
 ```bash
-# 克隆仓库（仅开发或查看示例时需要）
-git clone https://github.com/deepmodeling/Uni-Lab-OS.git
+# 克隆仓库
+git clone https://github.com/dptech-corp/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)
+请见[文档-启动样例](https://xuwznln.github.io/Uni-Lab-OS-Doc/boot_examples/index.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)，请引用：
-
-```bibtex
-@article{gao2025unilabos,
-    title = {UniLabOS: An AI-Native Operating System for Autonomous Laboratories},
-    doi = {10.48550/arXiv.2512.21766},
-    publisher = {arXiv},
-    author = {Gao, Jing and Chang, Junhan and Que, Haohui and Xiong, Yanfei and
-              Zhang, Shixiang and Qi, Xianwei and Liu, Zhen and Wang, Jun-Jie and
-              Ding, Qianjun and Li, Xinyu and Pan, Ziwei and Xie, Qiming and
-              Yan, Zhuang and Yan, Junchi and Zhang, Linfeng},
-    year = {2025}
-}
-```
+Uni-Lab-OS 使用预构建的 `unilabos_msgs` 进行系统通信。您可以在 [GitHub Releases](https://github.com/dptech-corp/Uni-Lab-OS/releases) 页面找到已构建的版本。
 
 ## 许可证
 
-本项目采用双许可证结构：
-
-- **主框架**：GPL-3.0 - 详见 [LICENSE](LICENSE)
-- **设备驱动** (`unilabos/devices/`)：深势科技专有许可证
-
-完整许可证说明请参阅 [NOTICE](NOTICE)。
+此项目采用 GPL-3.0 许可 - 详情请参阅 [LICENSE](LICENSE) 文件。
 
 ## 项目统计
 
@@ -121,4 +79,4 @@ Uni-Lab-OS 使用预构建的 `unilabos_msgs` 进行系统通信。您可以在
 
 ## 联系我们
 
-- GitHub Issues: [https://github.com/deepmodeling/Uni-Lab-OS/issues](https://github.com/deepmodeling/Uni-Lab-OS/issues)
+- GitHub Issues: [https://github.com/dptech-corp/Uni-Lab-OS/issues](https://github.com/dptech-corp/Uni-Lab-OS/issues)

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`
-- `uat` → `https://leap-lab.uat.bohrium.com/api/v1`
+- `test` → `https://uni-lab.test.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`
@@ -275,15 +275,15 @@ 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://leap-lab.test.bohrium.com/api/v1`
-- UAT 环境：`https://leap-lab.uat.bohrium.com/api/v1`
+- 生产环境：`https://uni-lab.bohrium.com/api/v1`（默认）
+- 测试环境：`https://uni-lab.test.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
 ```
 
 **命令行方式（推荐）：**

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,

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` 和普通方法
-- 添加到注册表的 `status_types`
+- 使用`@property`装饰器
+- 只读，不能有参数
+- 自动添加到注册表的`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` 装饰器标识设备类
-
-```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. 类型注解
+### 1. 类型注解
 
 ```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 界面**
 

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 或方法
-  is_heating: bool
-  status: str
+  current_temperature: float # 从 get_current_temperature() 或 @property current_temperature
+  is_heating: bool # 从 get_is_heating() 或 @property is_heating
+  status: str # 从 get_status() 或 @property status
 ```
 
 **注意事项**：
 
-- 仅有带 `@topic_config` 装饰器的 `@property` 或方法才会被识别为状态属性
-- 没有 `@topic_config` 的 `@property` 不会生成 status_types，也不会广播
-- `get_` 前缀的方法名会自动去除前缀（如 `get_temperature` → `temperature`）
+- 系统会查找所有 `get_` 开头的方法和 `@property` 装饰的属性
 - 类型会自动转成相应的类型（如 `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:
+class MyDevice(DeviceBase):
     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` 装饰器标识设备类**
-
-```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. **始终使用类型注解**
+1. **始终使用类型注解**
 
 ```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. **完善的错误处理**
    - 实现完善的错误处理
    - 添加日志记录
    - 提供有意义的错误信息

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后查看日志

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

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（选择其一）
-
-# 方案 A：标准安装（推荐大多数用户）
+# 4. 安装 Uni-Lab-OS
 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` 中
-3. 将 `virtual_transfer_pump` 拖拽到 `workstation` 中
-4. 在画布上连接它们（建立父子关系）
+2. 将 `virtual_transfer_pump` 拖拽到 `workstation` 中
+3. 在画布上连接它们（建立父子关系）
 
 ![设备连接](image/links.png)
 
@@ -794,44 +768,7 @@ Waiting for host service...
 
 详细的设备驱动编写指南请参考 [添加设备驱动](../developer_guide/add_device.md)。
 
-#### 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 为什么需要自定义设备？
+#### 9.1 为什么需要自定义设备？
 
 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. **测试部署**：
+
    - 连接真实硬件
    - 空跑测试
    - 小规模试验
@@ -1865,8 +1807,8 @@ 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)
+- **GitHub Issues**：[https://github.com/dptech-corp/Uni-Lab-OS/issues](https://github.com/dptech-corp/Uni-Lab-OS/issues)
+- **官方网站**：[https://uni-lab.bohrium.com](https://uni-lab.bohrium.com)
 
 ---
 

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 = {
@@ -477,10 +477,10 @@ old_format_node = {
 instance = ResourceDictInstance.get_resource_instance_from_dict(old_format_node)
 
 # 访问标准化后的数据
-print(instance.res_content.id)  # "pump_1"
-print(instance.res_content.uuid)  # 自动生成的 UUID
+print(instance.res_content.id)      # "pump_1"
+print(instance.res_content.uuid)    # 自动生成的 UUID
 print(instance.res_content.config)  # {}
-print(instance.res_content.data)  # {}
+print(instance.res_content.data)    # {}
 ```
 
 ### 格式迁移建议
@@ -626,7 +626,7 @@ unilab
 
 **云端图文件管理**:
 
-1. 登录 https://leap-lab.bohrium.com
+1. 登录 https://uni-lab.bohrium.com
 2. 进入"设备配置"
 3. 创建或编辑配置
 4. 保存到云端
@@ -857,4 +857,4 @@ class ResourceDictPosition(BaseModel):
 - 在 Web 界面中使用模板创建
 - 参考示例文件：`test/experiments/` 目录
 - 查看 ResourceDict 源码了解完整定义
-- [GitHub 讨论区](https://github.com/deepmodeling/Uni-Lab-OS/discussions)
+- [GitHub 讨论区](https://github.com/dptech-corp/Uni-Lab-OS/discussions)

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 分钟 (网络良好的情况下) |
-| **方式二：手动安装**   | **大多数用户**       | `unilabos`        | 完整功能，开箱即用             | 10-20 分钟                   |
-| **方式三：开发者安装** | 开发者、需要修改源码 | `unilabos-env`    | 可编辑模式，支持自定义开发     | 20-30 分钟                   |
-| **仿真/可视化**        | 仿真测试、可视化调试 | `unilabos-full`   | 含 Gazebo、rviz2、MoveIt       | 30-60 分钟                   |
+| 安装方式               | 适用人群             | 特点                           | 安装时间                     |
+| ---------------------- | -------------------- | ------------------------------ | ---------------------------- |
+| **方式一：一键安装**   | 实验室用户、快速体验 | 预打包环境，离线可用，无需配置 | 5-10 分钟 (网络良好的情况下) |
+| **方式二：手动安装**   | 标准用户、生产环境   | 灵活配置，版本可控             | 10-20 分钟                   |
+| **方式三：开发者安装** | 开发者、需要修改源码 | 可编辑模式，支持自定义 msgs    | 20-30 分钟                   |
 
 ---
 
@@ -48,7 +37,7 @@ Uni-Lab-OS 提供三个安装包版本，根据您的需求选择：
 
 #### 第一步：下载预打包环境
 
-1. 访问 [GitHub Actions - Conda Pack Build](https://github.com/deepmodeling/Uni-Lab-OS/actions/workflows/conda-pack-build.yml)
+1. 访问 [GitHub Actions - Conda Pack Build](https://github.com/dptech-corp/Uni-Lab-OS/actions/workflows/conda-pack-build.yml)
 
 2. 选择最新的成功构建记录（绿色勾号 ✓）
 
@@ -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
-
-# 选择安装包（三选一）：
-
-# 方案 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
+mamba install -n unilab uni-lab::unilabos -c robostack-staging -c conda-forge
 ```
 
 **参数说明**:
 
 - `-n unilab`: 创建名为 "unilab" 的环境
-- `uni-lab::unilabos`: 安装 unilabos 完整包，开箱即用（推荐）
-- `uni-lab::unilabos-env`: 仅安装环境依赖，适合开发者使用 `pip install -e .`
-- `uni-lab::unilabos-full`: 安装完整包（含 ROS2 Desktop、Gazebo、MoveIt 等）
+- `uni-lab::unilabos`: 从 uni-lab channel 安装 unilabos 包
 - `-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
 ```
 
 ### 第三步：激活环境
@@ -227,13 +189,13 @@ conda activate unilab
 ### 第一步：克隆仓库
 
 ```bash
-git clone https://github.com/deepmodeling/Uni-Lab-OS.git
+git clone https://github.com/dptech-corp/Uni-Lab-OS.git
 cd Uni-Lab-OS
 ```
 
 如果您需要贡献代码，建议先 Fork 仓库：
 
-1. 访问 https://github.com/deepmodeling/Uni-Lab-OS
+1. 访问 https://github.com/dptech-corp/Uni-Lab-OS
 2. 点击右上角的 "Fork" 按钮
 3. Clone 您的 Fork 版本：
    ```bash
@@ -241,87 +203,58 @@ cd Uni-Lab-OS
    cd Uni-Lab-OS
    ```
 
-### 第二步：安装开发环境（unilabos-env）
+### 第二步：安装基础环境
 
-**重要**：开发者请使用 `unilabos-env` 包，它专为开发者设计：
-- 包含 ROS2 核心组件和消息包（ros-humble-ros-core、std-msgs、geometry-msgs 等）
-- 包含 transforms3d、cv-bridge、tf2 等 conda 依赖
-- 包含 `uv` 工具，用于快速安装 pip 依赖
-- **不包含** pip 依赖和 unilabos 包（由 `pip install -e .` 和 `uv pip install` 安装）
+**推荐方式**：先通过**方式一（一键安装）**或**方式二（手动安装）**完成基础环境的安装，这将包含所有必需的依赖项（ROS2、msgs 等）。
+
+#### 选项 A：通过一键安装（推荐）
+
+参考上文"方式一：一键安装"，完成基础环境的安装后，激活环境：
 
 ```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
 
-# 克隆仓库（如果还未克隆）
-git clone https://github.com/deepmodeling/Uni-Lab-OS.git
-cd Uni-Lab-OS
+# 卸载 pip 安装的 unilabos（保留所有 conda 依赖）
+pip uninstall unilabos -y
 
-# 切换到 dev 分支（可选）
+# 克隆 dev 分支（如果还未克隆）
+cd /path/to/your/workspace
+git clone -b dev https://github.com/dptech-corp/Uni-Lab-OS.git
+# 或者如果已经克隆，切换到 dev 分支
+cd Uni-Lab-OS
 git checkout dev
 git pull
-```
 
-**推荐：使用安装脚本**（自动检测中文环境，使用 uv 加速）：
-
-```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
-
-# 国内用户使用清华镜像：
+# 以可编辑模式安装开发版 unilabos
 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)：代码修改**立即生效**，无需重新安装
-- 适合开发调试：修改代码后直接运行测试
-- 与 `unilabos-env` 配合：环境依赖由 conda 管理，unilabos 代码由 pip 管理
-
-**验证安装**：
-
-```bash
-# 检查 unilabos 版本
-python -c "import unilabos; print(unilabos.__version__)"
-
-# 检查安装位置（应该指向你的代码目录）
-pip show unilabos | grep Location
-```
+- `-e`: editable mode（可编辑模式），代码修改立即生效，无需重新安装
+- `-i`: 使用清华镜像源加速下载
+- `pip uninstall unilabos`: 只卸载 pip 安装的 unilabos 包，不影响 conda 安装的其他依赖（如 ROS2、msgs 等）
 
 ### 第四步：安装或自定义 ros-humble-unilabos-msgs（可选）
 
@@ -531,45 +464,7 @@ cd $CONDA_PREFIX/envs/unilab
 
 ### 问题 8: 环境很大，有办法减小吗？
 
-**解决方案**: 
-
-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 |
+**解决方案**: 预打包的环境包含所有依赖，通常较大（压缩后 2-5GB）。这是为了确保离线安装和完整功能。如果空间有限，考虑使用方式二手动安装，只安装需要的组件。
 
 ### 问题 9: 如何更新到最新版本？
 
@@ -608,15 +503,14 @@ mamba update ros-humble-unilabos-msgs -c uni-lab -c robostack-staging -c conda-f
 ## 需要帮助？
 
 - **故障排查**: 查看更详细的故障排查信息
-- **GitHub Issues**: [报告问题](https://github.com/deepmodeling/Uni-Lab-OS/issues)
+- **GitHub Issues**: [报告问题](https://github.com/dptech-corp/Uni-Lab-OS/issues)
 - **开发者文档**: 查看开发者指南获取更多技术细节
-- **社区讨论**: [GitHub Discussions](https://github.com/deepmodeling/Uni-Lab-OS/discussions)
+- **社区讨论**: [GitHub Discussions](https://github.com/dptech-corp/Uni-Lab-OS/discussions)
 
 ---
 
 **提示**:
 
-- **大多数用户**推荐使用方式二（手动安装）的 `unilabos` 标准版
-- **开发者**推荐使用方式三（开发者安装），安装 `unilabos-env` 后使用 `uv pip install -r unilabos/utils/requirements.txt` 安装依赖
-- **仿真/可视化**推荐安装 `unilabos-full` 完整版
-- **快速体验和演示**推荐使用方式一（一键安装）
+- 生产环境推荐使用方式二（手动安装）的稳定版本
+- 开发和测试推荐使用方式三（开发者安装）
+- 快速体验和演示推荐使用方式一（一键安装）

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 uat`：UAT 环境 (`https://leap-lab.uat.bohrium.com/api/v1`)
+- `--addr test`：测试环境 (`https://uni-lab.test.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` 参数
 - 配置文件中包含正确的认证信息
 

new_cellconfig.json

@@ -0,0 +1,54 @@
+{
+  "nodes": [
+    {
+      "id": "BatteryStation",
+      "name": "扣电工作站",
+      "parent": null,
+      "children": [
+        "coin_cell_deck"
+      ],
+      "type": "device",
+      "class":"coincellassemblyworkstation_device",
+      "position": {
+        "x": 0,
+        "y": 0,
+        "z": 0
+      },
+      "config": {
+        "deck": {
+          "data": {
+            "_resource_child_name": "YB_YH_Deck",
+            "_resource_type": "unilabos.devices.workstation.coin_cell_assembly.YB_YH_materials:CoincellDeck"
+          }
+        },
+        "debug_mode": true,
+        "protocol_type": []
+      }
+    },
+    {
+      "id": "YB_YH_Deck",
+      "name": "YB_YH_Deck",
+      "children": [],
+      "parent": "BatteryStation",
+      "type": "deck",
+      "class": "CoincellDeck",
+      "position": {
+        "x": 0,
+        "y": 0,
+        "z": 0
+      },
+      "config": {
+        "type": "CoincellDeck",
+        "setup": true,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        }
+      },
+      "data": {}
+    }
+  ],
+  "links": []
+}

new_cellconfig3c.json

@@ -0,0 +1,95 @@
+{
+  "nodes": [
+    {
+      "id": "bioyond_cell_workstation",
+      "name": "配液分液工站",
+      "parent": null,
+      "children": [
+        "YB_Bioyond_Deck"
+      ],
+      "type": "device",
+      "class": "bioyond_cell",
+      "config": {
+        "deck": {
+          "data": {
+            "_resource_child_name": "YB_Bioyond_Deck",
+            "_resource_type": "unilabos.resources.bioyond.decks:BIOYOND_YB_Deck"
+          }
+        },
+        "protocol_type": []
+      },
+      "data": {}
+    },
+    {
+      "id": "YB_Bioyond_Deck",
+      "name": "YB_Bioyond_Deck",
+      "children": [],
+      "parent": "bioyond_cell_workstation",
+      "type": "deck",
+      "class": "BIOYOND_YB_Deck",
+      "position": {
+        "x": 0,
+        "y": 0,
+        "z": 0
+      },
+      "config": {
+        "type": "BIOYOND_YB_Deck",
+        "setup": true,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        }
+      },
+      "data": {}
+    },
+    {
+      "id": "BatteryStation",
+      "name": "扣电工作站",
+      "parent": null,
+      "children": [
+        "coin_cell_deck"
+      ],
+      "type": "device",
+      "class":"coincellassemblyworkstation_device",
+      "config": {
+        "deck": {
+          "data": {
+            "_resource_child_name": "YB_YH_Deck",
+            "_resource_type": "unilabos.devices.workstation.coin_cell_assembly.YB_YH_materials:CoincellDeck"
+          }
+        },
+        "protocol_type": []
+      },
+      "position": {
+        "size": {"height": 1450, "width": 1450, "depth": 2100},
+        "position": {
+          "x": -1500,
+          "y": 0,
+          "z": 0
+        }
+      }
+    },
+    {
+      "id": "YB_YH_Deck",
+      "name": "YB_YH_Deck",
+      "children": [],
+      "parent": "BatteryStation",
+      "type": "deck",
+      "class": "CoincellDeck",
+      "config": {
+        "type": "CoincellDeck",
+        "setup": true,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        }
+      },
+      "data": {}
+    }
+  ],
+  "links": []
+}

recipes/msgs/recipe.yaml

@@ -1,6 +1,6 @@
 package:
   name: ros-humble-unilabos-msgs
-  version: 0.10.19
+  version: 0.10.12
 source:
   path: ../../unilabos_msgs
   target_directory: src
@@ -17,7 +17,7 @@ build:
     - bash $SRC_DIR/build_ament_cmake.sh
 
 about:
-  repository: https://github.com/deepmodeling/Uni-Lab-OS
+  repository: https://github.com/dptech-corp/Uni-Lab-OS
   license: BSD-3-Clause
   description: "ros-humble-unilabos-msgs is a package that provides message definitions for Uni-Lab-OS."
 
@@ -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') }}

recipes/unilabos/recipe.yaml

@@ -1,6 +1,6 @@
 package:
   name: unilabos
-  version: "0.10.19"
+  version: "0.10.12"
 
 source:
   path: ../..

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:
@@ -126,7 +126,7 @@ If installation fails:
 For more help:
   - Documentation: docs/user_guide/installation.md
   - Quick Start: QUICK_START_CONDA_PACK.md
-  - Issues: https://github.com/deepmodeling/Uni-Lab-OS/issues
+  - Issues: https://github.com/dptech-corp/Uni-Lab-OS/issues
 
 License:
 --------
@@ -134,7 +134,7 @@ License:
 UniLabOS is licensed under GPL-3.0-only.
 See LICENSE file for details.
 
-Repository: https://github.com/deepmodeling/Uni-Lab-OS
+Repository: https://github.com/dptech-corp/Uni-Lab-OS
 """
 
     return readme

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()

setup.py

@@ -4,7 +4,7 @@ package_name = 'unilabos'
 
 setup(
     name=package_name,
-    version='0.10.19',
+    version='0.10.12',
     packages=find_packages(),
     include_package_data=True,
     install_requires=['setuptools'],

test/experiments/reaction_station_bioyond.json

@@ -0,0 +1,72 @@
+{
+    "nodes": [
+        {
+            "id": "reaction_station_bioyond",
+            "name": "reaction_station_bioyond",
+            "parent": null,
+            "children": [
+                "Bioyond_Deck"
+            ],
+            "type": "device",
+            "class": "reaction_station.bioyond",
+            "config": {
+                "config": {
+                    "api_key": "DE9BDDA0",
+                    "api_host": "http://192.168.1.200:44402",
+                    "workflow_mappings": {
+                        "reactor_taken_out": "3a16081e-4788-ca37-eff4-ceed8d7019d1",
+                        "reactor_taken_in": "3a160df6-76b3-0957-9eb0-cb496d5721c6",
+                        "Solid_feeding_vials": "3a160877-87e7-7699-7bc6-ec72b05eb5e6",
+                        "Liquid_feeding_vials(non-titration)": "3a167d99-6158-c6f0-15b5-eb030f7d8e47",
+                        "Liquid_feeding_solvents": "3a160824-0665-01ed-285a-51ef817a9046",
+                        "Liquid_feeding(titration)": "3a16082a-96ac-0449-446a-4ed39f3365b6",
+                        "liquid_feeding_beaker": "3a16087e-124f-8ddb-8ec1-c2dff09ca784",
+                        "Drip_back": "3a162cf9-6aac-565a-ddd7-682ba1796a4a"
+                    },
+                    "material_type_mappings": {
+                        "烧杯": ["YB_1FlaskCarrier", "3a14196b-24f2-ca49-9081-0cab8021bf1a"],
+                        "试剂瓶": ["YB_1BottleCarrier", ""],
+                        "样品板": ["YB_6StockCarrier", "3a14196e-b7a0-a5da-1931-35f3000281e9"],
+                        "分装板": ["YB_6VialCarrier", "3a14196e-5dfe-6e21-0c79-fe2036d052c4"],
+                        "样品瓶": ["YB_Solid_Stock", "3a14196a-cf7d-8aea-48d8-b9662c7dba94"],
+                        "90%分装小瓶": ["YB_Solid_Vial", "3a14196c-cdcf-088d-dc7d-5cf38f0ad9ea"],
+                        "10%分装小瓶": ["YB_Liquid_Vial", "3a14196c-76be-2279-4e22-7310d69aed68"]
+                    }
+                },
+                "deck": {
+                    "data": {
+                        "_resource_child_name": "Bioyond_Deck",
+                        "_resource_type": "unilabos.resources.bioyond.decks:BIOYOND_PolymerReactionStation_Deck"
+                    }
+                },
+                "protocol_type": []
+            },
+            "data": {}
+        },
+        {
+            "id": "Bioyond_Deck",
+            "name": "Bioyond_Deck",
+            "children": [
+            ],
+            "parent": "reaction_station_bioyond",
+            "type": "deck",
+            "class": "BIOYOND_PolymerReactionStation_Deck",
+            "position": {
+                "x": 0,
+                "y": 0,
+                "z": 0
+            },
+            "config": {
+                "type": "BIOYOND_PolymerReactionStation_Deck",
+                "setup": true,
+                "rotation": {
+                    "x": 0,
+                    "y": 0,
+                    "z": 0,
+                    "type": "Rotation"
+                }
+            },
+            "data": {}
+        }
+    ]
+}

test/resources/YB_materials_info.json

@@ -0,0 +1,52 @@
+[
+    {
+        "id": "3a1d377b-299d-d0f2-ced9-48257f60dfad",
+        "typeName": "加样头(大)",
+        "code": "0005-00145",
+        "barCode": "",
+        "name": "LiDFOB",
+        "quantity": 9999.0,
+        "lockQuantity": 0.0,
+        "unit": "个",
+        "status": 1,
+        "isUse": false,
+        "locations": [
+            {
+                "id": "3a19da56-1379-ff7c-1745-07e200b44ce2",
+                "whid": "3a19da56-1378-613b-29f2-871e1a287aa5",
+                "whName": "粉末加样头堆栈",
+                "code": "0005-0001",
+                "x": 1,
+                "y": 1,
+                "z": 1,
+                "quantity": 0
+            }
+        ],
+        "detail": []
+    },
+    {
+        "id": "3a1d377b-6a81-6a7e-147c-f89f6463656d",
+        "typeName": "液",
+        "code": "0006-00141",
+        "barCode": "",
+        "name": "EMC",
+        "quantity": 99999.0,
+        "lockQuantity": 0.0,
+        "unit": "g",
+        "status": 1,
+        "isUse": false,
+        "locations": [
+            {
+                "id": "3a1baa20-a7b1-c665-8b9c-d8099d07d2f6",
+                "whid": "3a1baa20-a7b0-5c19-8844-5de8924d4e78",
+                "whName": "4号手套箱内部堆栈",
+                "code": "0015-0001",
+                "x": 1,
+                "y": 1,
+                "z": 1,
+                "quantity": 0
+            }
+        ],
+        "detail": []
+    }
+]

test/resources/test copy.json

@@ -0,0 +1,99 @@
+ {
+        "typeId": "3a190c8b-3284-af78-d29f-9a69463ad047",
+        "code": "",
+        "barCode": "",
+        "name": "test",
+        "unit": "",
+        "parameters": "{}",
+        "quantity": "",
+        "details": [
+            {
+                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb",
+                "code": "",
+                "name": "配液瓶(小)11",
+                "quantity": "1",
+                "x": 1,
+                "y": 1,
+                "z": 1,
+                "unit": "",
+                "parameters": "{}"
+            },
+            {
+                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb",
+                "code": "",
+                "name": "配液瓶(小)21",
+                "quantity": "1",
+                "x": 2,
+                "y": 1,
+                "z": 1,
+                "unit": "",
+                "parameters": "{}"
+            },
+            {
+                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb",
+                "code": "",
+                "name": "配液瓶(小)12",
+                "quantity": "1",
+                "x": 1,
+                "y": 2,
+                "z": 1,
+                "unit": "",
+                "parameters": "{}"
+            },
+            {
+                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb",
+                "code": "",
+                "name": "配液瓶(小)22",
+                "quantity": "1",
+                "x": 2,
+                "y": 2,
+                "z": 1,
+                "unit": "",
+                "parameters": "{}"
+            },
+            {
+                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb",
+                "code": "",
+                "name": "配液瓶(小)13",
+                "quantity": "1",
+                "x": 1,
+                "y": 3,
+                "z": 1,
+                "unit": "",
+                "parameters": "{}"
+            },
+            {
+                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb",
+                "code": "",
+                "name": "配液瓶(小)23",
+                "quantity": "1",
+                "x": 2,
+                "y": 3,
+                "z": 1,
+                "unit": "",
+                "parameters": "{}"
+            },
+            {
+                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb",
+                "code": "",
+                "name": "配液瓶(小)14",
+                "quantity": "1",
+                "x": 1,
+                "y": 4,
+                "z": 1,
+                "unit": "",
+                "parameters": "{}"
+            },
+            {
+                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb",
+                "code": "",
+                "name": "配液瓶(小)24",
+                "quantity": "1",
+                "x": 2,
+                "y": 4,
+                "z": 1,
+                "unit": "",
+                "parameters": "{}"
+            }
+        ]
+    }

test/resources/test.json

@@ -0,0 +1,148 @@
+[
+    {
+        "id": "3a1d4c14-a9fb-d7dc-9e96-7a3ad6e50219",
+        "typeName": "配液瓶(小)板",
+        "code": "0001-00093",
+        "barCode": "",
+        "name": "test",
+        "quantity": 2.0,
+        "lockQuantity": 0.0,
+        "unit": "块",
+        "status": 1,
+        "isUse": false,
+        "locations": [
+            {
+                "id": "3a19deae-2c7a-36f5-5e41-02c5b66feaea",
+                "whid": "3a19deae-2c79-05a3-9c76-8e6760424841",
+                "whName": "手动堆栈",
+                "code": "1",
+                "x": 1,
+                "y": 1,
+                "z": 1,
+                "quantity": 0
+            }
+        ],
+        "detail": [
+            {
+                "id": "3a1d4c14-a9fc-1daa-71fa-146cb1ccb930",
+                "detailMaterialId": "3a1d4c14-a9fc-4f38-4c48-68486c391c42",
+                "code": "0001-00093 - 05",
+                "name": "配液瓶(小)",
+                "quantity": "1",
+                "lockQuantity": "0",
+                "unit": "个",
+                "x": 1,
+                "y": 3,
+                "z": 1,
+                "associateId": null,
+                "typeName": "配液瓶(小)",
+                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb"
+            },
+            {
+                "id": "3a1d4c14-a9fc-3659-ea61-cd587da9e131",
+                "detailMaterialId": "3a1d4c14-a9fc-018f-93e5-c49343d37758",
+                "code": "0001-00093 - 08",
+                "name": "配液瓶(小)",
+                "quantity": "1",
+                "lockQuantity": "0",
+                "unit": "个",
+                "x": 2,
+                "y": 4,
+                "z": 1,
+                "associateId": null,
+                "typeName": "配液瓶(小)",
+                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb"
+            },
+            {
+                "id": "3a1d4c14-a9fc-3f94-de83-979d2646e313",
+                "detailMaterialId": "3a1d4c14-a9fc-9987-c0ef-4b7cbad49e6b",
+                "code": "0001-00093 - 01",
+                "name": "配液瓶(小)",
+                "quantity": "1",
+                "lockQuantity": "0",
+                "unit": "个",
+                "x": 1,
+                "y": 1,
+                "z": 1,
+                "associateId": null,
+                "typeName": "配液瓶(小)",
+                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb"
+            },
+            {
+                "id": "3a1d4c14-a9fc-8c35-6b25-913b11dbaf4e",
+                "detailMaterialId": "3a1d4c14-a9fc-9a83-865b-0c26ea5e8cc4",
+                "code": "0001-00093 - 03",
+                "name": "配液瓶(小)",
+                "quantity": "1",
+                "lockQuantity": "0",
+                "unit": "个",
+                "x": 1,
+                "y": 2,
+                "z": 1,
+                "associateId": null,
+                "typeName": "配液瓶(小)",
+                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb"
+            },
+            {
+                "id": "3a1d4c14-a9fc-b41f-e968-64953bfddccd",
+                "detailMaterialId": "3a1d4c14-a9fc-daf7-9d64-e5ec8d3ae0e2",
+                "code": "0001-00093 - 07",
+                "name": "配液瓶(小)",
+                "quantity": "1",
+                "lockQuantity": "0",
+                "unit": "个",
+                "x": 1,
+                "y": 4,
+                "z": 1,
+                "associateId": null,
+                "typeName": "配液瓶(小)",
+                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb"
+            },
+            {
+                "id": "3a1d4c14-a9fc-c20f-c26e-b1bb2cdc3bca",
+                "detailMaterialId": "3a1d4c14-a9fc-673b-ac83-aaaf71287f1f",
+                "code": "0001-00093 - 06",
+                "name": "配液瓶(小)",
+                "quantity": "1",
+                "lockQuantity": "0",
+                "unit": "个",
+                "x": 2,
+                "y": 3,
+                "z": 1,
+                "associateId": null,
+                "typeName": "配液瓶(小)",
+                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb"
+            },
+            {
+                "id": "3a1d4c14-a9fc-cf21-059c-fde361d82b6f",
+                "detailMaterialId": "3a1d4c14-a9fc-25b1-e736-6b0d8dac0fae",
+                "code": "0001-00093 - 02",
+                "name": "配液瓶(小)",
+                "quantity": "1",
+                "lockQuantity": "0",
+                "unit": "个",
+                "x": 2,
+                "y": 1,
+                "z": 1,
+                "associateId": null,
+                "typeName": "配液瓶(小)",
+                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb"
+            },
+            {
+                "id": "3a1d4c14-a9fc-d732-2b93-9b2bd2bf581b",
+                "detailMaterialId": "3a1d4c14-a9fc-7f5d-b6b6-8bcb2e15f320",
+                "code": "0001-00093 - 04",
+                "name": "配液瓶(小)",
+                "quantity": "1",
+                "lockQuantity": "0",
+                "unit": "个",
+                "x": 2,
+                "y": 2,
+                "z": 1,
+                "associateId": null,
+                "typeName": "配液瓶(小)",
+                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb"
+            }
+        ]
+    }
+]

test/resources/test_bottle_carrier.py

@@ -1,7 +1,7 @@
 import pytest
 
 from unilabos.resources.bioyond.bottle_carriers import BIOYOND_Electrolyte_6VialCarrier, BIOYOND_Electrolyte_1BottleCarrier
-from unilabos.resources.bioyond.bottles import BIOYOND_PolymerStation_Solid_Vial, BIOYOND_PolymerStation_Solution_Beaker, BIOYOND_PolymerStation_Reagent_Bottle
+from unilabos.resources.bioyond.bottles import YB_Solid_Vial, YB_Solution_Beaker, YB_Reagent_Bottle
 
 
 def test_bottle_carrier() -> "BottleCarrier":
@@ -16,9 +16,9 @@ def test_bottle_carrier() -> "BottleCarrier":
     print(f"1烧杯载架: {beaker_carrier.name}, 位置数: {len(beaker_carrier.sites)}")
 
     # 创建瓶子和烧杯
-    powder_bottle = BIOYOND_PolymerStation_Solid_Vial("powder_bottle_01")
-    solution_beaker = BIOYOND_PolymerStation_Solution_Beaker("solution_beaker_01")
-    reagent_bottle = BIOYOND_PolymerStation_Reagent_Bottle("reagent_bottle_01")
+    powder_bottle = YB_Solid_Vial("powder_bottle_01")
+    solution_beaker = YB_Solution_Beaker("solution_beaker_01")
+    reagent_bottle = YB_Reagent_Bottle("reagent_bottle_01")
 
     print(f"\n创建的物料:")
     print(f"粉末瓶: {powder_bottle.name} - {powder_bottle.diameter}mm x {powder_bottle.height}mm, {powder_bottle.max_volume}μL")

test/resources/test_converter_bioyond.py

@@ -12,13 +12,13 @@ lab_registry.setup()
 
 
 type_mapping = {
-    "烧杯": ("BIOYOND_PolymerStation_1FlaskCarrier", "3a14196b-24f2-ca49-9081-0cab8021bf1a"),
-    "试剂瓶": ("BIOYOND_PolymerStation_1BottleCarrier", ""),
-    "样品板": ("BIOYOND_PolymerStation_6StockCarrier", "3a14196e-b7a0-a5da-1931-35f3000281e9"),
-    "分装板": ("BIOYOND_PolymerStation_6VialCarrier", "3a14196e-5dfe-6e21-0c79-fe2036d052c4"),
-    "样品瓶": ("BIOYOND_PolymerStation_Solid_Stock", "3a14196a-cf7d-8aea-48d8-b9662c7dba94"),
-    "90%分装小瓶": ("BIOYOND_PolymerStation_Solid_Vial", "3a14196c-cdcf-088d-dc7d-5cf38f0ad9ea"),
-    "10%分装小瓶": ("BIOYOND_PolymerStation_Liquid_Vial", "3a14196c-76be-2279-4e22-7310d69aed68"),
+    "烧杯": ("YB_1FlaskCarrier", "3a14196b-24f2-ca49-9081-0cab8021bf1a"),
+    "试剂瓶": ("YB_1BottleCarrier", ""),
+    "样品板": ("YB_6StockCarrier", "3a14196e-b7a0-a5da-1931-35f3000281e9"),
+    "分装板": ("YB_6VialCarrier", "3a14196e-5dfe-6e21-0c79-fe2036d052c4"),
+    "样品瓶": ("YB_Solid_Stock", "3a14196a-cf7d-8aea-48d8-b9662c7dba94"),
+    "90%分装小瓶": ("YB_Solid_Vial", "3a14196c-cdcf-088d-dc7d-5cf38f0ad9ea"),
+    "10%分装小瓶": ("YB_Liquid_Vial", "3a14196c-76be-2279-4e22-7310d69aed68"),
 }
 
 

test/resources/test_resourcetreeset.py

@@ -1,24 +1,24 @@
+from ast import If
 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
+from unilabos.resources.bioyond.decks import YB_Deck
 
 lab_registry.setup()
 
 
 type_mapping = {
-    "烧杯": ("BIOYOND_PolymerStation_1FlaskCarrier", "3a14196b-24f2-ca49-9081-0cab8021bf1a"),
-    "试剂瓶": ("BIOYOND_PolymerStation_1BottleCarrier", ""),
-    "样品板": ("BIOYOND_PolymerStation_6StockCarrier", "3a14196e-b7a0-a5da-1931-35f3000281e9"),
-    "分装板": ("BIOYOND_PolymerStation_6VialCarrier", "3a14196e-5dfe-6e21-0c79-fe2036d052c4"),
-    "样品瓶": ("BIOYOND_PolymerStation_Solid_Stock", "3a14196a-cf7d-8aea-48d8-b9662c7dba94"),
-    "90%分装小瓶": ("BIOYOND_PolymerStation_Solid_Vial", "3a14196c-cdcf-088d-dc7d-5cf38f0ad9ea"),
-    "10%分装小瓶": ("BIOYOND_PolymerStation_Liquid_Vial", "3a14196c-76be-2279-4e22-7310d69aed68"),
+    "加样头(大)": ("YB_jia_yang_tou_da", "3a190ca0-b2f6-9aeb-8067-547e72c11469"),
+    "液": ("YB_1BottleCarrier", "3a190ca1-2add-2b23-f8e1-bbd348b7f790"),
+    "配液瓶(小)板": ("YB_peiyepingxiaoban", "3a190c8b-3284-af78-d29f-9a69463ad047"),
+    "配液瓶(小)": ("YB_pei_ye_xiao_Bottler", "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb"),
 }
 
 
@@ -56,12 +56,20 @@ def bioyond_materials_liquidhandling_2() -> list[dict]:
     "bioyond_materials_reaction",
     "bioyond_materials_liquidhandling_1",
 ])
-def test_resourcetreeset_from_plr(materials_fixture, request) -> list[dict]:
-    materials = request.getfixturevalue(materials_fixture)
-    deck = BIOYOND_PolymerReactionStation_Deck("test_deck")
+def test_resourcetreeset_from_plr() -> list[dict]:
+    # 直接加载 bioyond_materials_reaction.json 文件
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    json_path = os.path.join(current_dir, "test.json")
+    with open(json_path, "r", encoding="utf-8") as f:
+        materials = json.load(f)
+    deck = YB_Deck("test_deck")
     output = resource_bioyond_to_plr(materials, type_mapping=type_mapping, deck=deck)
-    print(deck.summary())
+    print(output)
+    # print(deck.summary())
 
     r = ResourceTreeSet.from_plr_resources([deck])
     print(r.dump())
     # json.dump(deck.serialize(), open("test.json", "w", encoding="utf-8"), indent=4)
+
+if __name__ == "__main__":
+    test_resourcetreeset_from_plr()

test/ros/msgs/test_runner.py

@@ -11,10 +11,10 @@ import os
 # 添加项目根目录到路径
 sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))))
 
-# 导入测试模块（统一从 tests 包获取）
-from tests.ros.msgs.test_basic import TestBasicFunctionality
-from tests.ros.msgs.test_conversion import TestBasicConversion, TestMappingConversion
-from tests.ros.msgs.test_mapping import TestTypeMapping, TestFieldMapping
+# 导入测试模块
+from test.ros.msgs.test_basic import TestBasicFunctionality
+from test.ros.msgs.test_conversion import TestBasicConversion, TestMappingConversion
+from test.ros.msgs.test_mapping import TestTypeMapping, TestFieldMapping
 
 
 def run_tests():

tests/__init__.py

@@ -1,7 +0,0 @@
-"""
-测试包根目录。
-
-让 `tests.*` 模块可以被正常 import（例如给 `unilabos` 下的测试入口使用）。
-"""
-
-

tests/devices/__init__.py

@@ -1 +0,0 @@
-

tests/devices/liquid_handling/__init__.py

@@ -1,5 +0,0 @@
-"""
-液体处理设备相关测试。
-"""
-
-

tests/devices/liquid_handling/test_transfer_liquid.py

@@ -1,505 +0,0 @@
-import asyncio
-from dataclasses import dataclass
-from typing import Any, Iterable, List, Optional, Sequence, Tuple
-
-import pytest
-
-from unilabos.devices.liquid_handling.liquid_handler_abstract import LiquidHandlerAbstract
-
-
-@dataclass(frozen=True)
-class DummyContainer:
-    name: str
-
-    def __repr__(self) -> str:  # pragma: no cover
-        return f"DummyContainer({self.name})"
-
-
-@dataclass(frozen=True)
-class DummyTipSpot:
-    name: str
-
-    def __repr__(self) -> str:  # pragma: no cover
-        return f"DummyTipSpot({self.name})"
-
-
-def make_tip_iter(n: int = 256) -> Iterable[List[DummyTipSpot]]:
-    """Yield lists so code can safely call `tip.extend(next(self.current_tip))`."""
-    for i in range(n):
-        yield [DummyTipSpot(f"tip_{i}")]
-
-
-class FakeLiquidHandler(LiquidHandlerAbstract):
-    """不初始化真实 backend/deck；仅用来记录 transfer_liquid 内部调用序列。"""
-
-    def __init__(self, channel_num: int = 8):
-        # 不调用 super().__init__，避免真实硬件/后端依赖
-        self.channel_num = channel_num
-        self.support_touch_tip = True
-        self.current_tip = iter(make_tip_iter())
-        self.calls: List[Tuple[str, Any]] = []
-
-    async def pick_up_tips(self, tip_spots, use_channels=None, offsets=None, **backend_kwargs):
-        self.calls.append(("pick_up_tips", {"tips": list(tip_spots), "use_channels": use_channels}))
-
-    async def aspirate(
-        self,
-        resources: Sequence[Any],
-        vols: List[float],
-        use_channels: Optional[List[int]] = None,
-        flow_rates: Optional[List[Optional[float]]] = None,
-        offsets: Any = None,
-        liquid_height: Any = None,
-        blow_out_air_volume: Any = None,
-        spread: str = "wide",
-        **backend_kwargs,
-    ):
-        self.calls.append(
-            (
-                "aspirate",
-                {
-                    "resources": list(resources),
-                    "vols": list(vols),
-                    "use_channels": list(use_channels) if use_channels is not None else None,
-                    "flow_rates": list(flow_rates) if flow_rates is not None else None,
-                    "offsets": list(offsets) if offsets is not None else None,
-                    "liquid_height": list(liquid_height) if liquid_height is not None else None,
-                    "blow_out_air_volume": list(blow_out_air_volume) if blow_out_air_volume is not None else None,
-                },
-            )
-        )
-
-    async def dispense(
-        self,
-        resources: Sequence[Any],
-        vols: List[float],
-        use_channels: Optional[List[int]] = None,
-        flow_rates: Optional[List[Optional[float]]] = None,
-        offsets: Any = None,
-        liquid_height: Any = None,
-        blow_out_air_volume: Any = None,
-        spread: str = "wide",
-        **backend_kwargs,
-    ):
-        self.calls.append(
-            (
-                "dispense",
-                {
-                    "resources": list(resources),
-                    "vols": list(vols),
-                    "use_channels": list(use_channels) if use_channels is not None else None,
-                    "flow_rates": list(flow_rates) if flow_rates is not None else None,
-                    "offsets": list(offsets) if offsets is not None else None,
-                    "liquid_height": list(liquid_height) if liquid_height is not None else None,
-                    "blow_out_air_volume": list(blow_out_air_volume) if blow_out_air_volume is not None else None,
-                },
-            )
-        )
-
-    async def discard_tips(self, use_channels=None, *args, **kwargs):
-        # 有的分支是 discard_tips(use_channels=[0])，有的分支是 discard_tips([0..7])（位置参数）
-        self.calls.append(("discard_tips", {"use_channels": list(use_channels) if use_channels is not None else None}))
-
-    async def custom_delay(self, seconds=0, msg=None):
-        self.calls.append(("custom_delay", {"seconds": seconds, "msg": msg}))
-
-    async def touch_tip(self, targets):
-        # 原实现会访问 targets.get_size_x() 等；测试里只记录调用
-        self.calls.append(("touch_tip", {"targets": targets}))
-
-    async def mix(self, targets, mix_time=None, mix_vol=None, height_to_bottom=None, offsets=None, mix_rate=None, none_keys=None):
-        self.calls.append(
-            (
-                "mix",
-                {
-                    "targets": targets,
-                    "mix_time": mix_time,
-                    "mix_vol": mix_vol,
-                },
-            )
-        )
-
-
-def run(coro):
-    return asyncio.run(coro)
-
-
-def test_one_to_one_single_channel_basic_calls():
-    lh = FakeLiquidHandler(channel_num=1)
-    lh.current_tip = iter(make_tip_iter(64))
-
-    sources = [DummyContainer(f"S{i}") for i in range(3)]
-    targets = [DummyContainer(f"T{i}") for i in range(3)]
-
-    run(
-        lh.transfer_liquid(
-            sources=sources,
-            targets=targets,
-            tip_racks=[],
-            use_channels=[0],
-            asp_vols=[1, 2, 3],
-            dis_vols=[4, 5, 6],
-            mix_times=None,  # 应该仍能执行（不 mix）
-        )
-    )
-
-    assert [c[0] for c in lh.calls].count("pick_up_tips") == 3
-    assert [c[0] for c in lh.calls].count("aspirate") == 3
-    assert [c[0] for c in lh.calls].count("dispense") == 3
-    assert [c[0] for c in lh.calls].count("discard_tips") == 3
-
-    # 每次 aspirate/dispense 都是单孔列表
-    aspirates = [payload for name, payload in lh.calls if name == "aspirate"]
-    assert aspirates[0]["resources"] == [sources[0]]
-    assert aspirates[0]["vols"] == [1.0]
-
-    dispenses = [payload for name, payload in lh.calls if name == "dispense"]
-    assert dispenses[2]["resources"] == [targets[2]]
-    assert dispenses[2]["vols"] == [6.0]
-
-
-def test_one_to_one_single_channel_before_stage_mixes_prior_to_aspirate():
-    lh = FakeLiquidHandler(channel_num=1)
-    lh.current_tip = iter(make_tip_iter(16))
-
-    source = DummyContainer("S0")
-    target = DummyContainer("T0")
-
-    run(
-        lh.transfer_liquid(
-            sources=[source],
-            targets=[target],
-            tip_racks=[],
-            use_channels=[0],
-            asp_vols=[5],
-            dis_vols=[5],
-            mix_stage="before",
-            mix_times=1,
-            mix_vol=3,
-        )
-    )
-
-    names = [name for name, _ in lh.calls]
-    assert names.count("mix") == 1
-    assert names.index("mix") < names.index("aspirate")
-
-
-def test_one_to_one_eight_channel_groups_by_8():
-    lh = FakeLiquidHandler(channel_num=8)
-    lh.current_tip = iter(make_tip_iter(256))
-
-    sources = [DummyContainer(f"S{i}") for i in range(16)]
-    targets = [DummyContainer(f"T{i}") for i in range(16)]
-    asp_vols = list(range(1, 17))
-    dis_vols = list(range(101, 117))
-
-    run(
-        lh.transfer_liquid(
-            sources=sources,
-            targets=targets,
-            tip_racks=[],
-            use_channels=list(range(8)),
-            asp_vols=asp_vols,
-            dis_vols=dis_vols,
-            mix_times=0,  # 触发逻辑但不 mix
-        )
-    )
-
-    # 16 个任务 -> 2 组，每组 8 通道一起做
-    assert [c[0] for c in lh.calls].count("pick_up_tips") == 2
-    aspirates = [payload for name, payload in lh.calls if name == "aspirate"]
-    dispenses = [payload for name, payload in lh.calls if name == "dispense"]
-    assert len(aspirates) == 2
-    assert len(dispenses) == 2
-
-    assert aspirates[0]["resources"] == sources[0:8]
-    assert aspirates[0]["vols"] == [float(v) for v in asp_vols[0:8]]
-    assert dispenses[1]["resources"] == targets[8:16]
-    assert dispenses[1]["vols"] == [float(v) for v in dis_vols[8:16]]
-
-
-def test_one_to_one_eight_channel_requires_multiple_of_8_targets():
-    lh = FakeLiquidHandler(channel_num=8)
-    lh.current_tip = iter(make_tip_iter(64))
-
-    sources = [DummyContainer(f"S{i}") for i in range(9)]
-    targets = [DummyContainer(f"T{i}") for i in range(9)]
-
-    with pytest.raises(ValueError, match="multiple of 8"):
-        run(
-            lh.transfer_liquid(
-                sources=sources,
-                targets=targets,
-                tip_racks=[],
-                use_channels=list(range(8)),
-                asp_vols=[1] * 9,
-                dis_vols=[1] * 9,
-                mix_times=0,
-            )
-        )
-
-
-def test_one_to_one_eight_channel_parameter_lists_are_chunked_per_8():
-    lh = FakeLiquidHandler(channel_num=8)
-    lh.current_tip = iter(make_tip_iter(512))
-
-    sources = [DummyContainer(f"S{i}") for i in range(16)]
-    targets = [DummyContainer(f"T{i}") for i in range(16)]
-    asp_vols = [i + 1 for i in range(16)]
-    dis_vols = [200 + i for i in range(16)]
-    asp_flow_rates = [0.1 * (i + 1) for i in range(16)]
-    dis_flow_rates = [0.2 * (i + 1) for i in range(16)]
-    offsets = [f"offset_{i}" for i in range(16)]
-    liquid_heights = [i * 0.5 for i in range(16)]
-    blow_out_air_volume = [i + 0.05 for i in range(16)]
-
-    run(
-        lh.transfer_liquid(
-            sources=sources,
-            targets=targets,
-            tip_racks=[],
-            use_channels=list(range(8)),
-            asp_vols=asp_vols,
-            dis_vols=dis_vols,
-            asp_flow_rates=asp_flow_rates,
-            dis_flow_rates=dis_flow_rates,
-            offsets=offsets,
-            liquid_height=liquid_heights,
-            blow_out_air_volume=blow_out_air_volume,
-            mix_times=0,
-        )
-    )
-
-    aspirates = [payload for name, payload in lh.calls if name == "aspirate"]
-    dispenses = [payload for name, payload in lh.calls if name == "dispense"]
-    assert len(aspirates) == len(dispenses) == 2
-
-    for batch_idx in range(2):
-        start = batch_idx * 8
-        end = start + 8
-        asp_call = aspirates[batch_idx]
-        dis_call = dispenses[batch_idx]
-        assert asp_call["resources"] == sources[start:end]
-        assert asp_call["flow_rates"] == asp_flow_rates[start:end]
-        assert asp_call["offsets"] == offsets[start:end]
-        assert asp_call["liquid_height"] == liquid_heights[start:end]
-        assert asp_call["blow_out_air_volume"] == blow_out_air_volume[start:end]
-        assert dis_call["flow_rates"] == dis_flow_rates[start:end]
-        assert dis_call["offsets"] == offsets[start:end]
-        assert dis_call["liquid_height"] == liquid_heights[start:end]
-        assert dis_call["blow_out_air_volume"] == blow_out_air_volume[start:end]
-
-
-def test_one_to_one_eight_channel_handles_32_tasks_four_batches():
-    lh = FakeLiquidHandler(channel_num=8)
-    lh.current_tip = iter(make_tip_iter(1024))
-
-    sources = [DummyContainer(f"S{i}") for i in range(32)]
-    targets = [DummyContainer(f"T{i}") for i in range(32)]
-    asp_vols = [i + 1 for i in range(32)]
-    dis_vols = [300 + i for i in range(32)]
-
-    run(
-        lh.transfer_liquid(
-            sources=sources,
-            targets=targets,
-            tip_racks=[],
-            use_channels=list(range(8)),
-            asp_vols=asp_vols,
-            dis_vols=dis_vols,
-            mix_times=0,
-        )
-    )
-
-    pick_calls = [name for name, _ in lh.calls if name == "pick_up_tips"]
-    aspirates = [payload for name, payload in lh.calls if name == "aspirate"]
-    dispenses = [payload for name, payload in lh.calls if name == "dispense"]
-    assert len(pick_calls) == 4
-    assert len(aspirates) == len(dispenses) == 4
-    assert aspirates[0]["resources"] == sources[0:8]
-    assert aspirates[-1]["resources"] == sources[24:32]
-    assert dispenses[0]["resources"] == targets[0:8]
-    assert dispenses[-1]["resources"] == targets[24:32]
-
-
-def test_one_to_many_single_channel_aspirates_total_when_asp_vol_too_small():
-    lh = FakeLiquidHandler(channel_num=1)
-    lh.current_tip = iter(make_tip_iter(64))
-
-    source = DummyContainer("SRC")
-    targets = [DummyContainer(f"T{i}") for i in range(3)]
-    dis_vols = [10, 20, 30]  # sum=60
-
-    run(
-        lh.transfer_liquid(
-            sources=[source],
-            targets=targets,
-            tip_racks=[],
-            use_channels=[0],
-            asp_vols=10,  # 小于 sum(dis_vols) -> 应吸 60
-            dis_vols=dis_vols,
-            mix_times=0,
-        )
-    )
-
-    aspirates = [payload for name, payload in lh.calls if name == "aspirate"]
-    assert len(aspirates) == 1
-    assert aspirates[0]["resources"] == [source]
-    assert aspirates[0]["vols"] == [60.0]
-    assert aspirates[0]["use_channels"] == [0]
-    dispenses = [payload for name, payload in lh.calls if name == "dispense"]
-    assert [d["vols"][0] for d in dispenses] == [10.0, 20.0, 30.0]
-
-
-def test_one_to_many_eight_channel_basic():
-    lh = FakeLiquidHandler(channel_num=8)
-    lh.current_tip = iter(make_tip_iter(128))
-
-    source = DummyContainer("SRC")
-    targets = [DummyContainer(f"T{i}") for i in range(8)]
-    dis_vols = [i + 1 for i in range(8)]
-
-    run(
-        lh.transfer_liquid(
-            sources=[source],
-            targets=targets,
-            tip_racks=[],
-            use_channels=list(range(8)),
-            asp_vols=999,  # one-to-many 8ch 会按 dis_vols 吸（每通道各自）
-            dis_vols=dis_vols,
-            mix_times=0,
-        )
-    )
-
-    aspirates = [payload for name, payload in lh.calls if name == "aspirate"]
-    assert aspirates[0]["resources"] == [source] * 8
-    assert aspirates[0]["vols"] == [float(v) for v in dis_vols]
-    dispenses = [payload for name, payload in lh.calls if name == "dispense"]
-    assert dispenses[0]["resources"] == targets
-    assert dispenses[0]["vols"] == [float(v) for v in dis_vols]
-
-
-def test_many_to_one_single_channel_standard_dispense_equals_asp_by_default():
-    lh = FakeLiquidHandler(channel_num=1)
-    lh.current_tip = iter(make_tip_iter(128))
-
-    sources = [DummyContainer(f"S{i}") for i in range(3)]
-    target = DummyContainer("T")
-    asp_vols = [5, 6, 7]
-
-    run(
-        lh.transfer_liquid(
-            sources=sources,
-            targets=[target],
-            tip_racks=[],
-            use_channels=[0],
-            asp_vols=asp_vols,
-            dis_vols=1,  # many-to-one 允许标量；非比例模式下实际每次分液=对应 asp_vol
-            mix_times=0,
-        )
-    )
-
-    dispenses = [payload for name, payload in lh.calls if name == "dispense"]
-    assert [d["vols"][0] for d in dispenses] == [float(v) for v in asp_vols]
-    assert all(d["resources"] == [target] for d in dispenses)
-
-
-def test_many_to_one_single_channel_before_stage_mixes_target_once():
-    lh = FakeLiquidHandler(channel_num=1)
-    lh.current_tip = iter(make_tip_iter(128))
-
-    sources = [DummyContainer("S0"), DummyContainer("S1")]
-    target = DummyContainer("T")
-
-    run(
-        lh.transfer_liquid(
-            sources=sources,
-            targets=[target],
-            tip_racks=[],
-            use_channels=[0],
-            asp_vols=[5, 6],
-            dis_vols=1,
-            mix_stage="before",
-            mix_times=2,
-            mix_vol=4,
-        )
-    )
-
-    names = [name for name, _ in lh.calls]
-    assert names[0] == "mix"
-    assert names.count("mix") == 1
-
-
-def test_many_to_one_single_channel_proportional_mixing_uses_dis_vols_per_source():
-    lh = FakeLiquidHandler(channel_num=1)
-    lh.current_tip = iter(make_tip_iter(128))
-
-    sources = [DummyContainer(f"S{i}") for i in range(3)]
-    target = DummyContainer("T")
-    asp_vols = [5, 6, 7]
-    dis_vols = [1, 2, 3]
-
-    run(
-        lh.transfer_liquid(
-            sources=sources,
-            targets=[target],
-            tip_racks=[],
-            use_channels=[0],
-            asp_vols=asp_vols,
-            dis_vols=dis_vols,  # 比例模式
-            mix_times=0,
-        )
-    )
-
-    dispenses = [payload for name, payload in lh.calls if name == "dispense"]
-    assert [d["vols"][0] for d in dispenses] == [float(v) for v in dis_vols]
-
-
-def test_many_to_one_eight_channel_basic():
-    lh = FakeLiquidHandler(channel_num=8)
-    lh.current_tip = iter(make_tip_iter(256))
-
-    sources = [DummyContainer(f"S{i}") for i in range(8)]
-    target = DummyContainer("T")
-    asp_vols = [10 + i for i in range(8)]
-
-    run(
-        lh.transfer_liquid(
-            sources=sources,
-            targets=[target],
-            tip_racks=[],
-            use_channels=list(range(8)),
-            asp_vols=asp_vols,
-            dis_vols=999,  # 非比例模式下每通道分液=对应 asp_vol
-            mix_times=0,
-        )
-    )
-
-    aspirates = [payload for name, payload in lh.calls if name == "aspirate"]
-    dispenses = [payload for name, payload in lh.calls if name == "dispense"]
-    assert aspirates[0]["resources"] == sources
-    assert aspirates[0]["vols"] == [float(v) for v in asp_vols]
-    assert dispenses[0]["resources"] == [target] * 8
-    assert dispenses[0]["vols"] == [float(v) for v in asp_vols]
-
-
-def test_transfer_liquid_mode_detection_unsupported_shape_raises():
-    lh = FakeLiquidHandler(channel_num=8)
-    lh.current_tip = iter(make_tip_iter(64))
-
-    sources = [DummyContainer("S0"), DummyContainer("S1")]
-    targets = [DummyContainer("T0"), DummyContainer("T1"), DummyContainer("T2")]
-
-    with pytest.raises(ValueError, match="Unsupported transfer mode"):
-        run(
-            lh.transfer_liquid(
-                sources=sources,
-                targets=targets,
-                tip_racks=[],
-                use_channels=[0],
-                asp_vols=[1, 1],
-                dis_vols=[1, 1, 1],
-                mix_times=0,
-            )
-        )
-

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"
-    }
-  }
-}