plan: add modify reset plan

从奔曜同步本地资源树+publish到deck

.conda/base/recipe.yaml

@@ -3,7 +3,7 @@
 
 package:
   name: unilabos
-  version: 0.11.3
+  version: 0.11.1
 
 source:
   path: ../../unilabos
@@ -54,7 +54,7 @@ requirements:
   - pymodbus
   - matplotlib
   - pylibftdi
-  - uni-lab::unilabos-env ==0.11.3
+  - uni-lab::unilabos-env ==0.11.1
 
 about:
   repository: https://github.com/deepmodeling/Uni-Lab-OS

.conda/environment/recipe.yaml

@@ -2,7 +2,7 @@
 
 package:
   name: unilabos-env
-  version: 0.11.3
+  version: 0.11.1
 
 build:
   noarch: generic

.conda/full/recipe.yaml

@@ -3,7 +3,7 @@
 
 package:
   name: unilabos-full
-  version: 0.11.3
+  version: 0.11.1
 
 build:
   noarch: generic
@@ -11,7 +11,7 @@ build:
 requirements:
   run:
   # Base unilabos package (includes unilabos-env)
-  - uni-lab::unilabos ==0.11.3
+  - uni-lab::unilabos ==0.11.1
   # Documentation tools
   - sphinx
   - sphinx_rtd_theme

.cursor/skills/add-device/SKILL.md

@@ -5,98 +5,9 @@ description: Guide for adding new devices to Uni-Lab-OS (接入新设备). Uses
 
 # 添加新设备到 Uni-Lab-OS
 
-本 Skill 是自包含的设备接入指南，不依赖外部文档。迁移给别人时，只复制 `.cursor/skills/add-device/SKILL.md` 即可获得核心规则、模板、验证方式和常见错误清单。
+**第一步：** 使用 Read 工具读取 `docs/ai_guides/add_device.md`，获取完整的设备接入指南。
 
-开始实现前，仍应搜索 `unilabos/devices/` 获取同类别已有设备的接口、参数名、状态字符串和返回值风格作为参考。
-
----
-
-## 接入工作流
-
-按下面顺序推进，并在工作中维护进度：
-
-```text
-设备接入进度：
-- [ ] 1. 确定设备类别（物模型）和对外单位
-- [ ] 2. 确定通信协议
-- [ ] 3. 收集指令协议（SDK、厂商文档、寄存器表、HTTP API、用户口述）
-- [ ] 4. 对齐同类设备接口（搜索 unilabos/devices/）
-- [ ] 5. 创建驱动 unilabos/devices/<category>/<file>.py
-- [ ] 6. 验证可导入、注册表扫描、启动测试
-- [ ] 7. 如需要，配置实验图文件
-```
-
-## 设备类别（物模型）
-
-优先使用已有类别。只有确实无法归类时才使用 `custom`。
-
-| 类别 ID | 说明 | 标准属性 | 标准动作 |
-|---|---|---|---|
-| `temperature` | 加热、冷却、温控 | `temp`, `temp_target`, `status` | `set_temperature`, `stop` |
-| `pump_and_valve` | 泵、阀门、注射器 | 见子类型表 | 见子类型表 |
-| `motor` | 电机、步进马达 | `position`, `status` | `enable`, `move_position`, `move_speed`, `stop` |
-| `heaterstirrer` | 加热搅拌一体机 | `temp`, `stir_speed`, `status` | `set_temperature`, `stir`, `stop` |
-| `balance` | 天平、称重 | `weight`, `unit`, `status` | `tare`, `read_weight` |
-| `sensor` | 传感器（液位、温度等） | `value`, `level`, `status` | `read_value`, `set_threshold` |
-| `liquid_handling` | 液体处理机器人 | `status`, `deck_state` | `transfer_liquid`, `aspirate`, `dispense` |
-| `robot_arm` | 机械臂 | `arm_pose`, `arm_status` | `moveit_task`, `pick_and_place` |
-| `workstation` | 工作站、组合设备 | `workflow_sequence`, `material_info` | `create_order`, `scheduler_start`, `scheduler_stop` |
-| `virtual` | 虚拟、模拟设备 | 按模拟的真实设备定义 | 按模拟的真实设备定义 |
-| `custom` | 不属于以上类别 | 用户自定义 | 用户自定义 |
-
-`pump_and_valve` 子类型：
-
-| 子类型 | 最小通用属性 | 最小通用动作 | 单位约定 |
-|---|---|---|---|
-| 注射泵（syringe pump） | `status`, `valve_position`, `position` | `initialize`, `set_valve_position`, `set_position`, `pull_plunger`, `push_plunger`, `stop_operation` | 体积=mL, 速度=mL/s |
-| 电磁阀（solenoid valve） | `status`, `valve_position` | `open`, `close`, `set_valve_position` | 无 |
-| 蠕动泵（peristaltic pump） | `status`, `speed` | `start`, `stop`, `set_speed` | 流速=mL/min |
-
-对外暴露的属性和动作参数必须使用用户友好的物理单位（mL、ul、degC、RPM 等），硬件原始值转换放在驱动内部。
-
-## 通信协议和指令来源
-
-先确认通信方式，再确认具体指令协议。物模型只定义设备“应该做什么”，不会告诉你硬件“具体发什么字节/请求”。
-
-| 协议 | 常用 config 参数 | 常用依赖 | 现有抽象 |
-|---|---|---|---|
-| Serial (RS232/RS485) | `port`, `baudrate`, `timeout` | `pyserial` | 直接使用 `serial.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`, `timeout` | stdlib | 直接使用 `socket` |
-| HTTP API | `url`, `token`, `timeout` | `requests` | `device_comms/rpc.py` |
-| OPC UA | `url` | `opcua` | `device_comms/opcua_client/` |
-| 无通信（虚拟） | 无 | 无 | 在动作中模拟行为 |
-
-必须从以下来源之一获得指令细节：
-
-| 来源 | 处理方式 |
-|---|---|
-| 现成 SDK/驱动代码 | 读取代码，提取指令逻辑，包装进 Uni-Lab-OS 类 |
-| 协议文档/手册 | 解析命令、响应、校验、寄存器、错误码 |
-| 用户口述 | 按描述实现指令编解码，标出不确定点 |
-| 标准协议 | 使用标准实现，例如 Modbus 寄存器表、SCPI |
-| 虚拟设备 | 跳过硬件通信，在动作方法中维护模拟状态 |
-
-## 对齐已有实现（强制）
-
-实现前必须搜索 `unilabos/devices/` 中同类别设备：
-
-- 参数名必须与已有设备保持一致；动作方法参数名是接口契约，不要随意改成 `volume_ml`、`target_temp_c` 这类新名字。
-- `status` 字符串值要和同类设备一致，优先使用英文稳定值，例如 `Idle`、`Running`、`Error`。
-- 状态属性用 `@property` + `@topic_config()` 明确声明。
-- 返回值使用结构化 dict，至少包含 `success`，需要给前端展示的信息放在 `message`、`data`、`error` 等字段。
-
-## 架构选择
-
-| 场景 | 推荐方式 |
-|---|---|
-| 简单设备 | 纯 Python 类 + `@device` |
-| 工作站/组合设备 | `WorkstationBase` 或项目内已有工作站模式 |
-| 液体处理 | `LiquidHandlerAbstract` / PyLabRobot 相关模式 |
-| Modbus 设备 | 复用 `device_comms/modbus_plc/` 或项目内 Modbus 示例 |
-| OPC UA 设备 | 复用 `device_comms/opcua_client/` |
-| 外部独立包 | 使用 `create-device-package` skill |
+该指南包含设备类别（物模型）列表、通信协议模板、常见错误检查清单等。搜索 `unilabos/devices/` 获取已有设备的实现参考。
 
 ---
 
@@ -176,29 +87,6 @@ Args:
 - 如果只写 `param: 参数说明`，`title` 会兜底为字段名，`description` 使用参数说明。
 - 如果没有写参数文档，生成器也会兜底补齐 `title=<字段名>` 和 `description=""`，但新设备应优先写清楚显示名和说明。
 
-### 特殊参数类型：ResourceSlot / DeviceSlot
-
-需要前端选择资源或设备时，用特殊类型注解，registry 会自动生成 `placeholder_keys`：
-
-```python
-from typing import List
-from unilabos.registry.placeholder_type import DeviceSlot, ResourceSlot
-
-@action(description="转移液体")
-def transfer(self, source: ResourceSlot, target: ResourceSlot, volume_ul: float) -> dict:
-    """
-    Args:
-        source[源资源]: 源容器或孔位。
-        target[目标资源]: 目标容器或孔位。
-        volume_ul[体积(ul)]: 转移体积。
-    """
-    return {"success": True}
-
-@action(description="同步设备")
-def sync_devices(self, devices: List[DeviceSlot]) -> dict:
-    return {"success": True, "count": len(devices)}
-```
-
 ### @topic_config — 状态属性配置
 
 ```python
@@ -306,154 +194,3 @@ class MyDevice:
 - `post_init` 用 `@not_action` 标记，参数类型标注为 `BaseROS2DeviceNode`
 - 运行时状态存储在 `self.data` 字典中
 - 设备文件放在 `unilabos/devices/<category>/` 目录下
-
----
-
-## 通信实现片段
-
-Serial 文本指令：
-
-```python
-def _send_command(self, cmd: str) -> str:
-    self.ser.write(f"{cmd}\r\n".encode())
-    return self.ser.readline().decode().strip()
-```
-
-RS-485 响应解析要先定位帧头，不要用硬编码索引直接解析原始响应：
-
-```python
-def _normalize_response(self, raw: str, start_marker: str = "/") -> str:
-    pos = raw.find(start_marker)
-    return raw[pos:] if pos >= 0 else raw
-```
-
-自定义二进制帧：
-
-```python
-def _build_frame(self, func_code: int, data: bytes) -> bytes:
-    frame = bytearray([0xFE, func_code]) + bytearray(data)
-    checksum = sum(frame[1:]) % 256
-    frame.append(checksum)
-    return bytes(frame)
-```
-
-Modbus 寄存器映射：
-
-```python
-REGISTER_MAP = {
-    "temp_target": {"addr": 0x000B, "scale": 10},
-}
-
-def set_temperature(self, temp: float, **kwargs) -> bool:
-    reg = REGISTER_MAP["temp_target"]
-    value = int(float(temp) * reg["scale"]) & 0xFFFF
-    self.client.write_register(reg["addr"], value, slave=self.slave_id)
-    self.data["temp_target"] = temp
-    return True
-```
-
-HTTP API 映射：
-
-```python
-API_MAP = {
-    "set_temperature": {
-        "method": "POST",
-        "endpoint": "/api/temperature",
-        "body_key": "target",
-    },
-}
-```
-
-SDK 封装：
-
-```python
-from my_device_sdk import DeviceController
-
-class MyDevice:
-    def __init__(self, device_id=None, config=None, **kwargs):
-        self.config = config or {}
-        self.controller = DeviceController(port=self.config.get("port", "COM1"))
-```
-
----
-
-## 验证
-
-无需手写注册表 YAML。`@device` 装饰器 + AST 扫描会在启动或检查时生成注册表条目。
-
-```bash
-# 1. 模块可导入
-python -c "from unilabos.devices.<category>.<file> import <ClassName>"
-
-# 2. 启动测试
-unilab -g <graph>.json
-
-# 3. 仅检查注册表
-unilab --check_mode --skip_env_check
-```
-
-仅在旧代码无 `@device`、需要覆盖特殊字段、或做 `--complete_registry` 旧设备补全时，才考虑 YAML。新设备默认不要手写 YAML。
-
-## 图文件节点模板
-
-实验图 JSON 中的 `class` 对应 `@device(id=...)`，`config` 会传入 `__init__` 的 `config` 字典：
-
-```json
-{
-  "id": "my_device_1",
-  "name": "我的设备",
-  "children": [],
-  "parent": null,
-  "type": "device",
-  "class": "my_device",
-  "position": {"x": 0, "y": 0, "z": 0},
-  "config": {
-    "port": "/dev/ttyUSB0",
-    "baudrate": 9600
-  },
-  "data": {}
-}
-```
-
-工作站需要同时配置 `deck` 和 `children`：
-
-```json
-{
-  "nodes": [
-    {
-      "id": "my_station",
-      "type": "device",
-      "class": "my_workstation",
-      "children": ["my_deck"],
-      "config": {},
-      "deck": {
-        "data": {
-          "_resource_child_name": "my_deck",
-          "_resource_type": "unilabos.resources.my_module:MyDeck"
-        }
-      }
-    },
-    {
-      "id": "my_deck",
-      "type": "deck",
-      "class": "MyDeckClass",
-      "parent": "my_station",
-      "config": {"type": "MyDeckClass", "setup": true}
-    }
-  ]
-}
-```
-
----
-
-## 常见错误清单
-
-- 缺少 `@device`：设备不会被 AST 扫描发现。
-- 只有 `@property` 没有 `@topic_config()`：属性不会稳定广播到 `status_types`。
-- `post_init` 没有 `@not_action`：会被误暴露为动作。
-- `self.data = {}`：空字典会导致属性读取和 schema 初始数据不稳定，必须预填充每个状态键。
-- 动作参数重命名：不要把同类设备已有的 `volume` 改成 `volume_ml`，参数名是接口契约。
-- `status` 使用中文或临时文本：前端和工作流依赖稳定英文状态值。
-- async 方法中使用 `time.sleep()`：应使用 `await self._ros_node.sleep(seconds)`。
-- 硬编码串口响应索引：RS-485 响应前可能有噪声字节，应先定位帧头。
-- 把硬件寄存器单位暴露给用户：对外使用物理单位，驱动内部做 scale 转换。

.cursor/skills/virtual-workbench/SKILL.md

@@ -10,8 +10,7 @@ description: Operate Virtual Workbench via REST API — prepare materials, move
 - **device_id**: `virtual_workbench`
 - **Python 源码**: `unilabos/devices/virtual/workbench.py`
 - **设备类**: `VirtualWorkbench`
-- **当前纳入动作**: 5 个（`auto-prepare_materials`, `auto-move_to_heating_station`, `auto-start_heating`, `auto-move_to_output`, `transfer`）
-- **暂跳过动作**: `manual_confirm`、扣电测试 `test`（需要启用时先从最新注册表重新提取 schema）
+- **动作数**: 6（`auto-prepare_materials`, `auto-move_to_heating_station`, `auto-start_heating`, `auto-move_to_output`, `transfer`, `manual_confirm`）
 - **设备描述**: 模拟工作台，包含 1 个机械臂（每次操作 2s，独占锁）和 3 个加热台（每次加热 60s，可并行）
 
 ### 典型工作流程
@@ -152,8 +151,7 @@ curl -s -X POST "$BASE/api/v1/lab/mcp/run/action" \
 | `auto-start_heating` | `UniLabJsonCommand` |
 | `auto-move_to_output` | `UniLabJsonCommand` |
 | `transfer` | `UniLabJsonCommandAsync` |
-
-> `manual_confirm` 和扣电测试 `test` 当前不纳入本 skill 的推荐操作范围；不要基于历史 JSON 直接调用，需先重新生成并校验 schema。
+| `manual_confirm` | `UniLabJsonCommand` |
 
 ### 10. 查询任务状态
 
@@ -227,9 +225,11 @@ curl -s -X PUT "$BASE/api/v1/edge/material/node" \
 | `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 字段**，参数为纯数值/整数。
-> `manual_confirm` 先跳过，不维护其 Slot 字段表。
 
 ---
 
@@ -270,13 +270,3 @@ prepare_materials (count=5)
 ```
 
 创建节点时，`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`。
-
-`start_heating` 完成后还需要继续连接到 `move_to_output`，否则加热完成的物料不会移出加热台：
-
-| source action | source handle | target action | target handle | 传递参数 |
-| ------------- | ------------- | ------------- | ------------- | -------- |
-| `auto-prepare_materials` | `channel_N` | `auto-move_to_heating_station` | `material_input` | `material_number` |
-| `auto-move_to_heating_station` | `heating_station_output` | `auto-start_heating` | `station_id_input` | `station_id` |
-| `auto-move_to_heating_station` | `material_number_output` | `auto-start_heating` | `material_number_input` | `material_number` |
-| `auto-start_heating` | `heating_done_station` | `auto-move_to_output` | `output_station_input` | `station_id` |
-| `auto-start_heating` | `heating_done_material` | `auto-move_to_output` | `output_material_input` | `material_number` |

.cursor/skills/virtual-workbench/action-index.md

@@ -1,8 +1,6 @@
 # Action Index — virtual_workbench
 
-当前纳入 5 个动作，按功能分类。每个动作的完整 JSON Schema 在 `actions/<name>.json`。
-
-暂跳过：`manual_confirm`、扣电测试 `test`。这两个动作需要启用时，先从最新 `req_device_registry_upload.json` 重新提取 schema 并校验参数。
+6 个动作，按功能分类。每个动作的完整 JSON Schema 在 `actions/<name>.json`。
 
 ---
 
@@ -62,18 +60,17 @@
 
 ---
 
-## 暂跳过动作
+## 人工确认
 
 ### `manual_confirm`
 
-创建人工确认节点，等待用户手动确认后继续（含物料转移上下文）。当前先不纳入推荐操作范围。
+创建人工确认节点，等待用户手动确认后继续（含物料转移上下文）
 
 - **action_type**: `UniLabJsonCommand`
 - **Schema**: [`actions/manual_confirm.json`](actions/manual_confirm.json)
-- **状态**: 暂跳过。源码参数已包含扣电测试相关字段，历史 JSON 可能过期；需要启用时重新提取 schema。
-
-### `test`
-
-启动扣电测试。当前先不纳入本 skill。
-
-- **状态**: 暂跳过。需要启用时从注册表生成 `actions/test.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` 类型

.github/workflows/ci-check.yml

@@ -25,7 +25,7 @@ jobs:
           fetch-depth: 0
 
       - name: Setup Miniforge
-        uses: conda-incubator/setup-miniconda@v4
+        uses: conda-incubator/setup-miniconda@v3
         with:
           miniforge-version: latest
           use-mamba: true

.github/workflows/conda-pack-build.yml

@@ -43,7 +43,7 @@ jobs:
             platform: linux-64
             env_file: unilabos-linux-64.yaml
             script_ext: sh
-          - os: macos-15-intel # Intel x86_64
+          - os: macos-15 # Intel (via Rosetta)
             platform: osx-64
             env_file: unilabos-osx-64.yaml
             script_ext: sh
@@ -86,7 +86,7 @@ jobs:
 
       - name: Setup Miniforge (with mamba)
         if: steps.should_build.outputs.should_build == 'true'
-        uses: conda-incubator/setup-miniconda@v4
+        uses: conda-incubator/setup-miniconda@v3
         with:
           miniforge-version: latest
           use-mamba: true

.github/workflows/deploy-docs.yml

@@ -51,7 +51,7 @@ jobs:
           fetch-depth: 0
 
       - name: Setup Miniforge (with mamba)
-        uses: conda-incubator/setup-miniconda@v4
+        uses: conda-incubator/setup-miniconda@v3
         with:
           miniforge-version: latest
           use-mamba: true
@@ -84,7 +84,7 @@ jobs:
 
       - name: Setup Pages
         id: pages
-        uses: actions/configure-pages@v6
+        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')
@@ -105,7 +105,7 @@ 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@v5
+        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')
@@ -125,4 +125,4 @@ jobs:
     steps:
       - name: Deploy to GitHub Pages
         id: deployment
-        uses: actions/deploy-pages@v5
+        uses: actions/deploy-pages@v4

.github/workflows/multi-platform-build.yml

@@ -63,7 +63,7 @@ jobs:
           - os: ubuntu-latest
             platform: linux-64
             env_file: unilabos-linux-64.yaml
-          - os: macos-15-intel # Intel x86_64
+          - os: macos-15 # Intel (via Rosetta)
             platform: osx-64
             env_file: unilabos-osx-64.yaml
           - os: macos-latest # ARM64
@@ -101,11 +101,10 @@ jobs:
 
       - name: Setup Miniforge
         if: steps.should_build.outputs.should_build == 'true'
-        uses: conda-incubator/setup-miniconda@v4
+        uses: conda-incubator/setup-miniconda@v3
         with:
           miniforge-version: latest
           use-mamba: true
-          python-version: '3.11.14'
           channels: conda-forge,robostack-staging
           channel-priority: strict
           activate-environment: build-env
@@ -115,22 +114,24 @@ jobs:
       - name: Install rattler-build and anaconda-client
         if: steps.should_build.outputs.should_build == 'true'
         run: |
-          mamba install -n build-env --override-channels -c conda-forge rattler-build anaconda-client -y
+          mamba install --override-channels -c conda-forge rattler-build anaconda-client -y
 
       - name: Show environment info
         if: steps.should_build.outputs.should_build == 'true'
         run: |
           conda info
-          conda list -n build-env | grep -E "(rattler-build|anaconda-client)"
-          conda run -n build-env rattler-build --version
-          conda run -n build-env anaconda --version
+          conda list | grep -E "(rattler-build|anaconda-client)"
           echo "Platform: ${{ matrix.platform }}"
           echo "OS: ${{ matrix.os }}"
 
       - name: Build conda package
         if: steps.should_build.outputs.should_build == 'true'
         run: |
-          conda run -n build-env rattler-build build -r ./recipes/msgs/recipe.yaml --target-platform ${{ matrix.platform }} -c robostack -c robostack-staging -c conda-forge
+          if [[ "${{ matrix.platform }}" == "osx-arm64" ]]; then
+            rattler-build build -r ./recipes/msgs/recipe.yaml -c robostack -c robostack-staging -c conda-forge
+          else
+            rattler-build build -r ./recipes/msgs/recipe.yaml -c robostack -c robostack-staging -c conda-forge
+          fi
 
       - name: List built packages
         if: steps.should_build.outputs.should_build == 'true'
@@ -170,5 +171,5 @@ jobs:
         run: |
           for package in $(find ./output -name "*.conda"); do
             echo "Uploading $package to unilab organization..."
-            conda run -n build-env anaconda -t ${{ secrets.ANACONDA_API_TOKEN }} upload --user uni-lab --force "$package"
+            anaconda -t ${{ secrets.ANACONDA_API_TOKEN }} upload --user uni-lab --force "$package"
           done

.github/workflows/unilabos-conda-build.yml

@@ -59,7 +59,7 @@ jobs:
         include:
           - os: ubuntu-latest
             platform: linux-64
-          - os: macos-15-intel # Intel x86_64
+          - os: macos-15 # Intel (via Rosetta)
             platform: osx-64
           - os: macos-latest # ARM64
             platform: osx-arm64
@@ -94,11 +94,10 @@ jobs:
 
       - name: Setup Miniforge
         if: steps.should_build.outputs.should_build == 'true'
-        uses: conda-incubator/setup-miniconda@v4
+        uses: conda-incubator/setup-miniconda@v3
         with:
           miniforge-version: latest
           use-mamba: true
-          python-version: '3.11.14'
           channels: conda-forge,robostack-staging,uni-lab
           channel-priority: strict
           activate-environment: build-env
@@ -108,15 +107,13 @@ jobs:
       - name: Install rattler-build and anaconda-client
         if: steps.should_build.outputs.should_build == 'true'
         run: |
-          mamba install -n build-env --override-channels -c conda-forge rattler-build anaconda-client -y
+          mamba install --override-channels -c conda-forge rattler-build anaconda-client -y
 
       - name: Show environment info
         if: steps.should_build.outputs.should_build == 'true'
         run: |
           conda info
-          conda list -n build-env | grep -E "(rattler-build|anaconda-client)"
-          conda run -n build-env rattler-build --version
-          conda run -n build-env anaconda --version
+          conda list | grep -E "(rattler-build|anaconda-client)"
           echo "Platform: ${{ matrix.platform }}"
           echo "OS: ${{ matrix.os }}"
           echo "Build full package: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.build_full == 'true' }}"
@@ -131,7 +128,7 @@ jobs:
         if: steps.should_build.outputs.should_build == 'true'
         run: |
           echo "Building unilabos-env (conda environment dependencies)..."
-          conda run -n build-env rattler-build build -r .conda/environment/recipe.yaml --target-platform ${{ matrix.platform }} -c uni-lab -c robostack-staging -c conda-forge
+          rattler-build build -r .conda/environment/recipe.yaml -c uni-lab -c robostack-staging -c conda-forge
 
       - name: Upload unilabos-env to Anaconda.org (if enabled)
         if: |
@@ -143,7 +140,7 @@ jobs:
         run: |
           echo "Uploading unilabos-env to uni-lab organization..."
           for package in $(find ./output -name "unilabos-env*.conda"); do
-            conda run -n build-env anaconda -t ${{ secrets.ANACONDA_API_TOKEN }} upload --user uni-lab --force "$package"
+            anaconda -t ${{ secrets.ANACONDA_API_TOKEN }} upload --user uni-lab --force "$package"
           done
 
       - name: Build unilabos (with pip package)
@@ -151,7 +148,7 @@ jobs:
         run: |
           echo "Building unilabos package..."
           # 如果已上传到 Anaconda，从 uni-lab channel 获取 unilabos-env；否则从本地 output 获取
-          conda run -n build-env rattler-build build -r .conda/base/recipe.yaml --target-platform ${{ matrix.platform }} -c uni-lab -c robostack-staging -c conda-forge --channel ./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: |
@@ -163,7 +160,7 @@ jobs:
         run: |
           echo "Uploading unilabos to uni-lab organization..."
           for package in $(find ./output -name "unilabos-0*.conda" -o -name "unilabos-[0-9]*.conda"); do
-            conda run -n build-env anaconda -t ${{ secrets.ANACONDA_API_TOKEN }} upload --user uni-lab --force "$package"
+            anaconda -t ${{ secrets.ANACONDA_API_TOKEN }} upload --user uni-lab --force "$package"
           done
 
       - name: Build unilabos-full - Only when explicitly requested
@@ -173,7 +170,7 @@ jobs:
           github.event.inputs.build_full == 'true'
         run: |
           echo "Building unilabos-full package on ${{ matrix.platform }}..."
-          conda run -n build-env rattler-build build -r .conda/full/recipe.yaml --target-platform ${{ matrix.platform }} -c uni-lab -c robostack-staging -c conda-forge --channel ./output
+          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: |
@@ -184,7 +181,7 @@ jobs:
         run: |
           echo "Uploading unilabos-full to uni-lab organization..."
           for package in $(find ./output -name "unilabos-full*.conda"); do
-            conda run -n build-env anaconda -t ${{ secrets.ANACONDA_API_TOKEN }} upload --user uni-lab --force "$package"
+            anaconda -t ${{ secrets.ANACONDA_API_TOKEN }} upload --user uni-lab --force "$package"
           done
 
       - name: List built packages

docs/developer_guide/add_PLC.md

@@ -1,611 +0,0 @@
-# PLC 通信标准与设备驱动编写指南（基于 AI4M 工站）
-
-> 本文档以 `unilabos/devices/workstation/AI4M`（水凝胶检测工站）为参考实现，
-> 介绍如何将 PLC 控制的实验设备接入 Uni-Lab-OS：包含通信协议选型、节点表标准、
-> 通信基类、设备驱动、Registry 配置以及调试方法。
->
-> 阅读对象：负责现场调试与设备接入的同学。
-
----
-
-## 0. 总览：一台 PLC 设备从硬件到云端的链路
-
-```
-       PLC（西门子 / 倍福 / 三菱 / 汇川 / 国产 PLC ...）
-                   ▲
-                   │  各家 PLC 私有协议（S7 / Modbus / EtherCAT ...）
-                   │
-        ┌──────────┴──────────┐
-        │  OPC UA Server      │  ← 统一在 PLC 侧或独立网关上配置
-        │  （内置或 KEPServer）│
-        └──────────┬──────────┘
-                   │  OPC UA over TCP（标准协议）
-                   │
-        ┌──────────┴──────────┐
-        │  Uni-Lab 设备驱动    │  ← 本教程主体
-        │  AI4MDevice         │
-        │  ├─ base_opcua_client.py  通信基类
-        │  ├─ opcua_nodes_*.csv     节点表（标准）
-        │  └─ AI4M.py               动作函数
-        └──────────┬──────────┘
-                   │  ROS2 Action / 云端 HTTP
-                   ▼
-              实验记录本 / 云端调度
-```
-
-**统一约定**：所有 PLC 设备**只暴露 OPC UA 接口**给 Uni-Lab，PC 端不直接处理 S7 / Modbus 等底层协议。
-这是 Uni-Lab 在工站类设备上的 PLC 通信标准。
-
----
-
-## 1. 为什么选 OPC UA 作为标准？
-
-| 维度 | 自研 TCP/串口协议 | Modbus | **OPC UA** |
-|---|---|---|---|
-| 厂家无关 | ✗ | 部分 | **✓** |
-| 自带类型系统 | ✗ | ✗（裸寄存器） | **✓（Boolean/Int16/Float...）** |
-| 命名空间 / 节点树 | ✗ | ✗（地址=魔数） | **✓（带名字、可分组）** |
-| 订阅推送 | ✗ | ✗ | **✓（DataChange Notification）** |
-| 鉴权 / 加密 | 自己造 | ✗ | **✓** |
-| 与 PLC 工程师沟通成本 | 高 | 中 | **低（按变量名沟通）** |
-
-实际接入时，PLC 工程师只需要在 PLC 侧把约定的"上位通讯变量"暴露到 OPC UA Server，
-我们在 PC 侧就能用 `节点名 + 数据类型` 直接读写，不用管底层是 S7 还是 Modbus。
-
----
-
-## 2. 节点表标准：`opcua_nodes_xxx.csv`
-
-PLC 侧暴露的所有变量统一**用一张 CSV 表**描述，这是 PC 端和 PLC 端**唯一的接口契约**。
-位置示例：`unilabos/devices/workstation/AI4M/opcua_nodes_AI4M.csv`。
-
-### 2.1 列定义
-
-| 列名 | 是否必填 | 说明 |
-|---|---|---|
-| `Name` | ✅ | 节点名（PLC 工程师在 PLC 项目中真实使用的变量名，通常是中文/原始名） |
-| `EnglishName` | 推荐 | 英文别名，**PC 端代码全部用这个名字**调用 |
-| `NodeType` | ✅ | `VARIABLE`（变量）或 `METHOD`（方法），AI4M 全部用变量 |
-| `DataType` | ✅ | `BOOLEAN` / `INT16` / `INT32` / `FLOAT` / `DOUBLE` / `STRING` ... |
-| `NodeLanguage` | 推荐 | `Chinese` / `English`，配合 `EnglishName` 做映射 |
-| `NodeId` | ✅ | OPC UA 标准 NodeId，格式 `ns=<namespace>;s=<string>` 或 `ns=<n>;i=<int>` |
-
-### 2.2 真实样例（节选自 `opcua_nodes_AI4M.csv`）
-
-| Name | EnglishName | NodeType | DataType | NodeLanguage | NodeId |
-|---|---|---|---|---|---|
-| 机器人空闲 | `robot_ready` | VARIABLE | BOOLEAN | Chinese | `ns=4;s=上位通讯变量\|机器人空闲` |
-| 机器人取烧杯编号 | `robot_pick_beaker_id` | VARIABLE | INT16 | Chinese | `ns=4;s=上位通讯变量\|机器人取烧杯编号` |
-| 检测1请求参数 | `station_1_request_params` | VARIABLE | BOOLEAN | Chinese | `ns=4;s=上位通讯变量\|检测1请求参数` |
-| 检测1工艺完成 | `station_1_process_complete` | VARIABLE | BOOLEAN | Chinese | `ns=4;s=上位通讯变量\|检测1工艺完成` |
-| 磁力搅拌参数设置_C[0].搅拌速度 | `mag_stirrer_c0_stir_speed` | VARIABLE | INT16 | Chinese | `ns=4;s=上位通讯变量\|磁力搅拌参数设置_C[0].搅拌速度` |
-| 报警复位 | `alarm_reset` | VARIABLE | BOOLEAN | Chinese | `ns=4;s=上位通讯变量\|报警复位` |
-
-### 2.3 设计规范（必读）
-
-1. **命名按"角色-编号-属性"分层**，便于代码批量寻址：
-   - `mag_stirrer_c{0..4}_stir_speed`（搅拌仪 0~4 的搅拌速度）
-   - `station_{1..3}_process_complete`（检测站 1~3 的完成信号）
-   - `robot_rack_pick_beaker_{1..5}_complete`（取烧杯 1~5 的完成信号）
-
-   这样在驱动里可以直接 `f"mag_stirrer_c{idx}_stir_speed"` 拼出节点名。
-
-2. **数据类型与 PLC 侧严格一致**：
-   - `BOOL` → `BOOLEAN`，`INT/WORD` → `INT16/UINT16`，`DINT` → `INT32`，`REAL` → `FLOAT`。
-   - 类型不一致会触发 `BadTypeMismatch`，写入失败。
-
-3. **NodeId 必须从 PLC 工程或 OPC UA Server 中导出**，不要自己拼。
-   常见格式：
-   - 西门子 1500：`ns=4;s=上位通讯变量|<变量名>`
-   - 倍福 TwinCAT：`ns=4;s=PLC1.MAIN.<变量名>`
-   - KEPServerEX：`ns=2;s=Channel1.Device1.<Tag>`
-
-4. **每个工站一个独立 CSV**，不要共用。
-   AI4M 中真机用 `opcua_nodes_AI4M.csv`，仿真用 `opcua_nodes_AI4M_sim.csv`。
-
----
-
-## 3. 通信基类架构
-
-文件：`unilabos/devices/workstation/AI4M/base_opcua_client.py`
-
-整个通信层分两层：
-
-```
-BaseOpcUaClient                       # 最小可用：连接 + 节点注册 + 读写 + 方法调用
-        ▲
-        │ 继承
-        │
-OpcUaClientWithSubscription           # 生产可用：+ 订阅推送 + 缓存 + 自动重连
-        ▲
-        │ 继承
-        │
-AI4MDevice                            # 业务驱动：在它之上写设备动作函数
-```
-
-### 3.1 `BaseOpcUaClient` 核心能力
-
-```python
-class BaseOpcUaClient(UniversalDriver):
-    client: Optional[Client] = None
-    _node_registry: Dict[str, OpcUaNodeBase] = {}     # name -> Variable/Method
-    _name_mapping: Dict[str, str] = {}                # 英文名 -> 中文名
-    _reverse_mapping: Dict[str, str] = {}             # 中文名 -> 英文名
-    _found_node_objects: Dict[str, Any] = {}          # 缓存 ua.Node 用于订阅
-
-    @classmethod
-    def load_csv(cls, file_path) -> Tuple[List[OpcUaNode], dict, dict]: ...
-    def register_node_list(self, node_list) -> "BaseOpcUaClient": ...
-    def use_node(self, name) -> OpcUaNodeBase: ...
-    def read_node(self, node_name: str) -> str: ...   # 返回 JSON
-    def write_node(self, json_input: str) -> str: ...
-    def call_method(self, node_name, *args) -> Tuple[Any, bool]: ...
-```
-
-它做的事情可以归纳为四步：
-
-1. **`load_csv`**：读取节点表，建立 `Name ↔ EnglishName` 双向映射。
-2. **`register_node_list`**：把节点登记进 `_variables_to_find` 待查找列表。
-3. **`_connect` → `_find_nodes`**：连上 OPC UA 后，按 `NodeId` 把每个节点解析成 `Variable` / `Method` 对象，放进 `_node_registry`。
-4. **`use_node(name)`**：业务代码取节点的唯一入口，**支持中英文混用**，找不到会自动重试一次。
-
-### 3.2 `OpcUaClientWithSubscription` 增强能力
-
-在 `BaseOpcUaClient` 基础上提供三个生产环境必备的能力：
-
-#### a) 订阅缓存（高频读零开销）
-
-```python
-def _setup_subscriptions(self):
-    self._subscription = self.client.create_subscription(
-        self._subscription_interval,    # 默认 500ms
-        SubscriptionHandler(self),
-    )
-    for node_name, node in self._node_registry.items():
-        if node.type == NodeType.VARIABLE and node.node_id:
-            handle = self._subscription.subscribe_data_change(ua_node)
-            self._subscription_handles[node_name] = handle
-```
-
-当 PLC 侧变量变化时，`datachange_notification` 回调会把新值写进 `self._node_values[name]`，
-后续 `get_node_value` 优先读缓存——**业务代码可以放心地写 `while not self.get_node_value(...): time.sleep(1)` 而不用担心 OPC UA 频繁请求**。
-
-#### b) 智能缓存的 `get_node_value`
-
-```python
-def get_node_value(self, name, use_cache=True, force_read=False):
-    # 1. 中英文名归一化
-    chinese_name = self._name_mapping.get(name, name)
-
-    # 2. force_read=True 强制透传到 OPC UA Server
-    if force_read: ...
-
-    # 3. 命中订阅推送 → 直接返回缓存
-    # 4. 命中按需读 + 未过期（cache_timeout=5s）→ 返回缓存
-    # 5. 否则发起 read 并更新缓存
-```
-
-#### c) 连接监控 + 自动重连
-
-后台线程每 30s 调一次 `client.get_namespace_array()` 探活，断线则自动 `disconnect → connect → 重新订阅`，最多重试 5 次。
-
-### 3.3 数据类型 / 节点类型
-
-`unilabos/device_comms/opcua_client/node/uniopcua.py`：
-
-```python
-class DataType(Enum):
-    BOOLEAN = VariantType.Boolean
-    INT16   = VariantType.Int16
-    INT32   = VariantType.Int32
-    FLOAT   = VariantType.Float
-    STRING  = VariantType.String
-    # ...
-
-class NodeType(Enum):
-    VARIABLE = NodeClass.Variable
-    METHOD   = NodeClass.Method
-    OBJECT   = NodeClass.Object
-```
-
-`Variable.write()` 内部会按 `DataType` 做强制类型转换，
-所以 CSV 里的 `DataType` 列就是"PC 端转换写入值的类型说明书"。
-
----
-
-## 4. 编写设备驱动：以 `AI4MDevice` 为例
-
-文件：`unilabos/devices/workstation/AI4M/AI4M.py`
-
-### 4.1 继承通信基类，最小骨架
-
-```python
-from typing import Optional
-from unilabos.devices.workstation.AI4M.base_opcua_client import OpcUaClientWithSubscription
-
-class AI4MDevice(OpcUaClientWithSubscription):
-    def __init__(
-        self,
-        url: str,                              # opc.tcp://192.168.1.10:4840
-        deck: Optional[AI4M_deck] = None,      # 物料台面（资源树）
-        csv_path: str = None,                  # 节点表 CSV
-        username: str = None,
-        password: str = None,
-        use_subscription: bool = True,
-        cache_timeout: float = 5.0,
-        subscription_interval: int = 500,
-        *args, **kwargs,
-    ):
-        super().__init__(
-            url=url, username=username, password=password,
-            use_subscription=use_subscription,
-            cache_timeout=cache_timeout,
-            subscription_interval=subscription_interval,
-            *args, **kwargs,
-        )
-
-        # 物料台面初始化（见教程 4. 物料系统）
-        self.deck = deck or AI4M_deck(setup=True)
-        self._robot_lock = threading.Lock()
-
-        # 关键：加载节点表
-        if csv_path:
-            self.load_nodes_from_csv(csv_path)
-```
-
-`load_nodes_from_csv` 会一次性完成：解析 CSV → 注册节点 → 解析 NodeId → 建立订阅，
-**之后整个驱动都通过 `self.get_node_value(name)` / `self.set_node_value(name, value)` 操作 PLC**。
-
-### 4.2 PLC 通信的核心模式：握手协议（Handshake）
-
-PLC 编程的本质是"扫描周期 + 状态机"，PC 端**绝对不能用 fire-and-forget 的方式发指令**。
-和 PLC 配合的标准模式是 **"PC 写指令 → PC 等待 PLC 回执 → PC 复位指令"**。
-
-AI4M 中所有 `trigger_*` 函数都遵循以下三种握手范式之一：
-
-#### 范式 A：脉冲触发 + 完成信号（最常用）
-
-```python
-def trigger_init(self) -> dict:
-    # ① 复位上一轮残留
-    self.set_node_value("alarm_reset", True); time.sleep(1.0)
-    self.set_node_value("alarm_reset", False)
-    self.set_node_value("manual_auto_switch", False)
-
-    # ② 等待 PLC 退出自动模式
-    while self.get_node_value("auto_mode"):
-        time.sleep(1.0)
-
-    # ③ 发起初始化脉冲（True → False）
-    self.set_node_value("initialize", True); time.sleep(1.0)
-    self.set_node_value("initialize", False)
-
-    # ④ 等待 PLC 给出完成信号
-    while not self.get_node_value("init finished"):
-        time.sleep(1.0)
-
-    return {"message": "设备初始化完成"}
-```
-
-要点：
-- **"PC 写一个 BOOL 拉高再拉低"** 模拟脉冲，PLC 用上升沿触发动作。
-- **`get_node_value` 要在 while 循环里轮询**，配合订阅缓存基本无压力。
-- **每个动作必须有"开始"和"完成"两个独立的 BOOL 节点**，不能复用。
-
-#### 范式 B：参数下发 + 请求/已执行/完成 三步握手（带数据的工艺）
-
-```python
-def trigger_station_process(self, station_id: int, mag_stir_speed: int, ...):
-    request_node        = f"station_{station_id}_request_params"
-    params_received_node = f"station_{station_id}_params_received"
-    start_node          = f"station_{station_id}_start"
-    complete_node       = f"station_{station_id}_process_complete"
-
-    # ① PC 复位三个状态位（避免上一轮影响）
-    self._reset_station_process_flags(station_id)
-
-    # ② 等 PLC 主动请求参数（PLC 准备好了才接收）
-    while not self.get_node_value(request_node):
-        time.sleep(1.0)
-
-    # ③ PC 下发参数（注意：PLC 内部数组是 0-based，PC 暴露给用户是 1-based）
-    station_idx = station_id - 1
-    self.set_node_value(f"mag_stirrer_c{station_idx}_stir_speed", mag_stir_speed)
-    self.set_node_value(f"mag_stirrer_c{station_idx}_heat_temp",  mag_stir_heat_temp)
-    self.set_node_value(f"mag_stirrer_c{station_idx}_time_set",   mag_stir_time_set)
-    self.set_node_value(f"syringe_pump_{station_idx}_abs_position_set", syringe_pump_abs_pos)
-
-    # ④ PC 通知 PLC "参数已就绪"，等 PLC 回复"已执行"
-    self.set_node_value(start_node, True)
-    while not self.get_node_value(params_received_node):
-        time.sleep(1.0)
-
-    # ⑤ 等 PLC 完成整个工艺
-    while not self.get_node_value(complete_node):
-        time.sleep(5.0)
-
-    self.set_node_value(start_node, False)   # 复位，方便下一轮
-    return {"station_id": station_id, "message": "..."}
-```
-
-四个状态位的语义：
-
-| 信号 | 方向 | 含义 |
-|---|---|---|
-| `station_X_request_params` | **PLC → PC** | "我准备好了，把参数给我" |
-| `station_X_start` | **PC → PLC** | "参数我已经写好了，开干" |
-| `station_X_params_received` | **PLC → PC** | "参数我已经吃下了" |
-| `station_X_process_complete` | **PLC → PC** | "工艺已经做完" |
-
-**这是 PLC 通信教科书级别的标准范式**，所有带数据下发的动作都建议照抄。
-
-#### 范式 C：编号下发 + 编号对应的完成信号（多目标互锁）
-
-```python
-def trigger_robot_pick_beaker(self, pick_beaker_id: int, place_station_id: int = None, ...):
-    # ① 等机器人空闲（互锁）
-    while not self.get_node_value("robot_ready"):
-        time.sleep(1.0)
-
-    # ② 阶段一：下发"取哪一杯"编号 + 等"取这一杯完成"
-    pick_complete_node  = f"robot_rack_pick_beaker_{pick_beaker_id}_complete"
-    self.set_node_value("robot_pick_beaker_id", pick_beaker_id)
-    while not self.get_node_value(pick_complete_node):
-        time.sleep(1.0)
-
-    # ③ 阶段二：下发"放到哪个工站"编号 + 等"放完成"
-    place_complete_node = f"robot_place_station_{place_station_id}_complete"
-    self._reset_station_process_flags(place_station_id)
-    self.set_node_value("robot_place_station_id", place_station_id)
-    while not self.get_node_value(place_complete_node):
-        time.sleep(1.0)
-```
-
-要点：
-- **同一个动作的多个目标用"编号变量 + 编号对应的完成信号"实现**，不要每个目标都开一个开始位。
-- **配合 Python 端 `threading.Lock()` 做软互锁**，避免多个线程争抢机器人。
-- **每个阶段有独立的完成信号**，串行等待，不能合并。
-
-### 4.3 一些容易踩坑的细节
-
-1. **节点名映射**
-   `set_node_value("alarm_reset", True)` 实际写入的是 CSV 中文名 `报警复位`，
-   `get_node_value` 同理。**业务代码全部用 EnglishName**，不要直接用中文。
-
-2. **PLC 数组索引和 PC 不一致**
-   AI4M 里 PC 暴露 `station_id ∈ {1, 2, 3}`，但 PLC 内部数组是 `C[0..2]`，
-   驱动里要做 `station_idx = station_id - 1`，**这种映射只在驱动层做一次**，
-   不要让上层（registry / 实验记录本）感知。
-
-3. **订阅模式下 BOOL 节点的边沿同步**
-   订阅有 ~500ms 延迟。如果你刚 `set_node_value(x, True)` 就立刻 `get_node_value(x)`，
-   读到的可能还是 `False`（订阅还没推回来）。
-   解决方案：**写完后用 `force_read=True` 透传一次** 或加一段 `time.sleep`。
-
-4. **永远不要忘记复位**
-   `start` 拉 True 后必须有地方拉回 False，否则下一轮 PLC 上升沿不触发。
-   AI4M 在 `_reset_station_process_flags` 中统一做：
-
-   ```python
-   def _reset_station_process_flags(self, station_id: int) -> None:
-       self.set_node_value(f"station_{station_id}_process_complete", False)
-       self.set_node_value(f"station_{station_id}_start", False)
-       self.set_node_value(f"station_{station_id}_params_received", False)
-   ```
-
-5. **耗时长的等待 sleep 加大**
-   工艺等待用 `time.sleep(5.0)`，机器人等待用 `time.sleep(1.0)`，初始化等待 `time.sleep(1.0)`，
-   不要全部用 0.1s 轮询，会把日志刷爆。
-
----
-
-## 5. 把驱动接到 Uni-Lab：Registry + Graph
-
-### 5.1 Registry YAML（动作 schema）
-
-文件：`unilabos/registry/devices/AI4M_station.yaml`
-
-```yaml
-AI4M_station:
-  category: [AI4M_station]
-  class:
-    module: unilabos.devices.workstation.AI4M.AI4M:AI4MDevice    # ← 入口类
-    type: python
-    action_value_mappings:
-      auto-trigger_init:
-        schema:
-          description: 设备初始化...
-          properties:
-            goal:    { properties: {}, required: [], type: object }
-            result:
-              properties: { message: { type: string } }
-              required: [message]
-              type: object
-          type: object
-        type: UniLabJsonCommand
-
-      auto-trigger_station_process:
-        always_free: true
-        schema:
-          description: 执行检测工艺流程
-          properties:
-            goal:
-              properties:
-                station_id:                   { type: integer, description: 检测编号 1-3 }
-                mag_stir_stir_speed:          { type: integer }
-                mag_stir_heat_temp:           { type: integer }
-                mag_stir_time_set:            { type: integer }
-                syringe_pump_abs_position_set:{ type: integer }
-              required: [station_id, mag_stir_stir_speed, mag_stir_heat_temp,
-                         mag_stir_time_set, syringe_pump_abs_position_set]
-              type: object
-            result: { ... }
-        type: UniLabJsonCommand
-
-  init_param_schema:
-    config:
-      type: object
-      required: [url]
-      properties:
-        url:                   { type: string,  description: OPC UA 服务器地址 }
-        csv_path:              { type: string,  description: 节点配置 CSV 路径 }
-        deck:                  { type: string,  description: 资源树配置 }
-        username:              { type: string }
-        password:              { type: string }
-        use_subscription:      { type: boolean, default: true }
-        cache_timeout:         { type: number,  default: 5.0 }
-        subscription_interval: { type: integer, default: 500 }
-```
-
-规则总结：
-- `class.module` 指向驱动类（`module:ClassName`）。
-- `action_value_mappings` 中的 key 形如 `auto-<方法名>`，对应驱动里的同名 Python 方法。
-- `schema.goal` 自动转成 ROS2 Action 的 goal 消息，`schema.result` 转 result。
-- `init_param_schema.config` 对应 `__init__` 的入参，**所有需要现场改的参数都要列出来**（最重要的就是 `url` 和 `csv_path`）。
-- `always_free: true` 表示该动作不占用工站独占锁（多检测站可并发执行）。
-
-### 5.2 Graph JSON（实例化）
-
-文件：`unilabos/devices/workstation/AI4M/AI4M.json`
-
-```json
-{
-  "nodes": [
-    {
-      "id": "AI4M_station",
-      "name": "AI4M_station",
-      "type": "device",
-      "class": "AI4M_station",
-      "children": ["AI4M_deck"],
-      "parent": null,
-      "config": {
-        "url": "opc.tcp://192.168.1.10:4840",
-        "csv_path": "opcua_nodes_AI4M.csv",
-        "deck": {
-          "data": {
-            "_resource_child_name": "AI4M_deck",
-            "_resource_type": "unilabos.devices.workstation.AI4M.decks:AI4M_deck"
-          }
-        }
-      }
-    },
-    {
-      "id": "AI4M_deck",
-      "type": "deck",
-      "class": "AI4M_deck",
-      "parent": "AI4M_station",
-      "config": { "type": "AI4M_deck" }
-    }
-  ]
-}
-```
-
-要点：
-- `class` 必须和 Registry YAML 的顶层 key 完全一致（`AI4M_station`）。
-- `config` 字段**逐字传给驱动 `__init__`**，所以 Graph JSON = "现场参数表"。
-- 多套相同设备时拷贝一份，把 `id` / `url` 改掉即可（参考 `AI4M002_station`）。
-
-### 5.3 启动命令（来自 `start.md`）
-
-```cmd
-# 真机
-python unilabos/app/main.py -g unilabos/devices/workstation/AI4M/AI4M.json `
-  --ak <ak> --sk <sk> --upload_registry --addr <api_url> --disable_browser
-
-# 仿真（KEPServerEX 跑在本机 49320 端口）
-python unilabos/app/main.py -g unilabos/devices/workstation/AI4M/AI4Msim.json `
-  --ak <ak> --sk <sk> --upload_registry --disable_browser
-```
-
-`--upload_registry` 会把 `AI4M_station.yaml` 的 schema 上传到云端，
-之后实验记录本就能看到所有 `auto-*` 动作。
-
----
-
-## 6. 调试方法
-
-### 6.1 用 KEPServerEX 仿真 PLC
-
-不带 PLC 的开发机上，可以用 KEPServerEX（或 `python-opcua` 自建 server）模拟。
-AI4M 提供了一份仿真节点表 `opcua_nodes_AI4M_sim.csv`，**只改 NodeId 不改语义**，
-所以驱动代码无需任何改动即可在本机调试。
-
-### 6.2 单独跑驱动（不开 ROS）
-
-在驱动文件末尾的 `if __name__ == '__main__':` 段：
-
-```python
-if __name__ == '__main__':
-    A4 = AI4MDevice(
-        url="opc.tcp://192.168.1.10:4840",
-        csv_path="opcua_nodes_AI4M.csv",
-    )
-    A4.trigger_init()
-    print("初始化完成")
-    A4.trigger_robot_pick_beaker(1, 1)
-```
-
-**新动作上线前一定要在这里裸跑一遍**，确认握手时序正确，再往上接 ROS。
-
-### 6.3 看日志判断卡在哪
-
-`base_opcua_client.py` 的日志已经覆盖了所有关键节点：
-
-```
-✓ 客户端已连接!
-✓ 找到变量节点: 'robot_ready', NodeId: ns=4;s=...
-✓ 已订阅节点: robot_ready
-✓ 节点查找完成：所有 142 个节点均已找到
-```
-
-如果看到 `⚠ 以下 N 个节点未找到`，**99% 是 CSV 里的 NodeId 写错了**，回去对一下 PLC 工程导出的 NodeId。
-
-### 6.4 检查节点是否能直接读写
-
-```python
-# 透传读，绕过订阅缓存
-A4.get_node_value("robot_ready", force_read=True)
-
-# 直接读 JSON 形式（适合从 HTTP/调试面板调）
-A4.read_node("robot_ready")
-
-# 写
-A4.set_node_value("alarm_reset", True)
-A4.write_node('{"node_name": "alarm_reset", "value": false}')
-```
-
----
-
-## 7. 接入新 PLC 设备的 Checklist
-
-接到一台新工站时，按下面顺序做就能保证不漏：
-
-- [ ] 1. 让 PLC 工程师把上位通讯变量整理到 OPC UA Server，导出 NodeId 清单。
-- [ ] 2. 在 `unilabos/devices/workstation/<设备名>/` 下新建目录，复制 `AI4M/base_opcua_client.py` 不动。
-- [ ] 3. 整理 `opcua_nodes_<设备名>.csv`，6 列填齐，并补上 `EnglishName`。
-- [ ] 4. 在该目录写设备驱动 `<设备名>.py`，继承 `OpcUaClientWithSubscription`：
-  - [ ] `__init__` 调用 `super().__init__` + `self.load_nodes_from_csv(csv_path)`。
-  - [ ] 每个动作函数用范式 A/B/C 写握手协议。
-  - [ ] 每个动作函数都返回 `dict`，至少含 `message` 字段。
-- [ ] 5. 在 `unilabos/registry/devices/` 下新建 `<设备名>_station.yaml`，配置 `init_param_schema` 和 `action_value_mappings`。
-- [ ] 6. 在该目录新建 `<设备名>.json`（Graph），填好 `url` 和 `csv_path`。
-- [ ] 7. 用 `if __name__ == '__main__':` 单独跑驱动确认握手 OK。
-- [ ] 8. 用 `python unilabos/app/main.py -g <Graph> --upload_registry ...` 上线，到实验记录本下发动作回归。
-
----
-
-## 8. 参考实现速查
-
-| 关注点 | 在 AI4M 中看哪里 |
-|---|---|
-| OPC UA 通信基类 | `base_opcua_client.py` |
-| 节点定义类型系统 | `unilabos/device_comms/opcua_client/node/uniopcua.py` |
-| 节点表 CSV 标准 | `opcua_nodes_AI4M.csv` |
-| 设备驱动入口类 | `AI4M.py: AI4MDevice` |
-| 握手范式 A（脉冲+完成） | `AI4M.py: trigger_init` |
-| 握手范式 B（请求/参数/完成） | `AI4M.py: trigger_station_process` |
-| 握手范式 C（编号+完成） | `AI4M.py: trigger_robot_pick_beaker` |
-| 自动模式批量参数下发 | `AI4M.py: download_auto_params` |
-| Registry schema | `unilabos/registry/devices/AI4M_station.yaml` |
-| Graph 实例化 | `AI4M.json` / `AI4Msim.json` |
-| 启动命令 | `start.md` |

plan/2026-05-20_add_two_node.md

@@ -0,0 +1,576 @@
+# Peptide Station 新增三个节点：等待订单完成 + 下料确认 + take-out 同步
+
+> 日期: 2026-05-20  
+> 目标文件: [peptide_station.py](../unilabos/devices/workstation/bioyond_studio/peptide_station/peptide_station.py)  
+> 参考实现:  
+> - [bioyond_cell_workstation.py](/Users/dp/python/yxz/unilabos/devices/workstation/bioyond_studio/bioyond_cell/bioyond_cell_workstation.py)（`wait_for_order_finish`、`get_material_info`）
+> - [bioyond_rpc.py L782-824](../unilabos/devices/workstation/bioyond_studio/bioyond_rpc.py)（`take_out`）
+> - [workstation_architecture.md](../docs/developer_guide/examples/workstation_architecture.md)（HTTP 报送进入 workstation，运行态记录保存在 workstation 内存）
+> 状态: 仅需求草稿，不写代码
+
+---
+
+## 一、需求背景
+
+`BioyondPeptideStation` 当前实验流程在 `start_experiment`（manual_confirm 启动调度器）之后即结束，缺少：
+
+1. **等待奔耀回报实验完成**：调度器跑完后，奔耀通过 LIMS 推送 `POST /report/order_finish` 回调；目前 peptide_station 没有把这条推送封装成 action 节点，下游无法在工作流图上等待结果，也拿不到 `usedMaterials` 等下游所需信息。
+2. **下料引导**：实验完成后操作员需要把样品/产物从仓位里取出，下料前需要看到每个物料对应的 **仓库 / 位置 / 物料名称 / 数量**；下料完成后还需要回写奔耀（调用 `take-out` 接口），让奔耀清空相应库位状态。
+
+本轮新增三个 action 节点，串在 `start_experiment` 之后：
+
+```text
+submit_experiment_dayN
+  -> start_experiment(manual_confirm 上料)
+  -> wait_for_order_finish (等回调 + 生成 unloadTable)
+  -> confirm_unload_materials (manual_confirm 下料确认)
+  -> take_out_materials (调用 take-out 同步奔耀)
+```
+
+---
+
+## 二、关键设计决策
+
+### D1. 本轮只支持单订单，`order_ids` 只做占位
+
+当前不实现多订单等待、乱序回调缓存、并发 wait 隔离。节点输入以 `order_id` 为主，`order_code` 可作为调试兜底。
+
+`order_ids` 可在 handle/返回值中保留为占位字段，但实现只处理第一笔或直接忽略多订单列表。多订单、乱序回调、跨节点重跑复用缓存放到后续迭代。
+
+### D2. `start_experiment` 需要显式透传订单字段
+
+当前 `start_experiment` 只有输入 handles，缺少输出 handles；如果下游 wait 节点要接在 `start_experiment` 之后，必须让 `start_experiment` 透传：
+
+- `order_id`
+- `order_ids`（占位）
+- `order_code`
+- `resultTable`
+
+实现时给 `start_experiment` 增加对应 `ActionOutputHandle`，并在返回值里保留这些字段。`submit_experiment_dayN` 的 `start_experiment` 嵌套字典也应包含 `order_code`，便于工作流编辑器连线。
+
+### D3. `unloadTable` 必须与 `resultTable` 字段一致
+
+`unloadTable` 不新增 `posX/posY/posZ/unit` 列，直接复用现有 `RESULT_TABLE_COLUMNS` 的四列：
+
+```python
+RESULT_TABLE_COLUMNS = [
+    {"name": "设备", "key": "whName"},
+    {"name": "位置", "key": "locationCode"},
+    {"name": "物料名称", "key": "materialName"},
+    {"name": "数量", "key": "quantity"},
+]
+```
+
+`submit_experiment_dayN` 现有上料确认表 `resultTable` 形状如下；`unloadTable` 也必须保持同一 shape，只改 `tableName` 和行数据来源：
+
+```json
+{
+  "data": [
+    {
+      "whName": "自动化堆栈",
+      "locationCode": "A1",
+      "materialName": "96孔板",
+      "quantity": "1"
+    }
+  ],
+  "columns": [
+    {"name": "设备", "key": "whName"},
+    {"name": "位置", "key": "locationCode"},
+    {"name": "物料名称", "key": "materialName"},
+    {"name": "数量", "key": "quantity"}
+  ],
+  "tableName": "resultTable"
+}
+```
+
+`material-info` 官方 schema 中位置坐标字段是 `locations[].x/y/z`，不是 `posX/posY/posZ`。本轮下料表不展示坐标。
+
+### D4. manual_confirm 只做人确认，take-out 放到普通 action
+
+`confirm_unload_materials` 只负责展示下料表、等待操作员确认并透传数据；真正的 `take-out` 调用放到后续普通 action `take_out_materials`。
+
+这样更接近 UniLab manual_confirm 的推荐模式：manual_confirm 是人机确认检查点，副作用由独立普通 action 执行。
+
+### D5. 本轮不做 unload context 缓存
+
+虽然 workstation architecture 文档支持在 workstation 内存保存 HTTP 报送记录，但本轮暂不实现 `unload_context_cache` 或 order report 缓存。
+
+因此本轮限制如下：
+
+- `wait_for_order_finish` 只等待本次进入节点之后到达的 `/report/order_finish`。
+- 如果 push 早于 wait 节点到达，本轮不自动补救。
+- 如果用户在 `confirm_unload_materials` approve 时忘记勾选，节点失败；当前架构不支持原地重新弹出同一个 manual_confirm，也不在本轮实现失败节点重跑。
+- 后续若要支持重跑复用，应在 `BioyondPeptideStation` 实例上新增 station runtime 的 `unload_context_cache`，按 `orderCode` 缓存 `unloadTable/material_ids/order_id` 等上下文。
+
+---
+
+## 三、节点 1：`wait_for_order_finish`（等推送 + 生成 unloadTable）
+
+### 行为
+
+1. 解析单订单目标：
+   - 首选 `order_id`。
+   - 如果没有 `order_code`，通过 `self.hardware_interface.order_report(order_id)` 取返回数据中的 `code` 作为 `orderCode`。
+   - `order_ids` 仅占位，本轮不实现多订单循环。
+2. 设置 `self.last_order_code = order_code`、`self.last_order_report = None`，并 `self.order_finish_event.clear()`。
+3. 阻塞在 `self.order_finish_event.wait(timeout=timeout_seconds)` 等 LIMS 推送。
+4. peptide_station override `process_order_finish_report(report_request, used_materials)`：
+   - 先调用 `super().process_order_finish_report(...)` 保留父类行为（状态发布、物料同步等）。
+   - 当 `report_request.data.orderCode == self.last_order_code` 时，把 `report_request.data` 存入 `self.last_order_report`，并 `set()` event。
+   - 非当前订单推送只记录日志，本轮不缓存。
+5. 解除阻塞后解析 `status`：
+   - `"30"` -> `success`
+   - `"-11"` -> `abnormal_stop`
+   - `"-12"` -> `manual_stop`
+   - 其它 -> `unknown_<status>`
+   - 超时 -> `timeout`
+6. 对 `report.usedMaterials[].materialId` 调用 `self.hardware_interface.material_info(material_id)`，带本地函数级 `material_info_cache` 避免重复请求。
+7. 组装 `unloadTable`、`material_ids`、`preintake_ids`、`unload_summary` 并作为输出 handles 暴露。
+
+### 入参（goal_default）
+
+| 参数 | 类型 | 说明 |
+|------|------|------|
+| `order_id` | `str` | 来自 `start_experiment` 透传输出，必填优先 |
+| `order_code` | `str` | 调试兜底；若已知 orderCode 可跳过 `order_report` 反查 |
+| `order_ids` | `List[str]` | 占位字段；本轮不实现多订单 |
+| `timeout_seconds` | `int` | 默认 `36000`（10h） |
+| `poll_mode` | `bool` | 默认 `False`；如需要可沿用 bioyond_cell 的轮询等待风格 |
+
+### 输出 handles
+
+| key | data_type | 说明 |
+|-----|-----------|------|
+| `order_finish_status` | `str` | `success` / `abnormal_stop` / `manual_stop` / `timeout` / `unknown_*` |
+| `order_finish_report` | `json` | 完整 `report_request.data` |
+| `used_materials` | `json` | JSON 化后的 `usedMaterials` 列表 |
+| `material_ids` | `json` | 从 `used_materials` 抽出的 `materialId` 列表，可为空 |
+| `preintake_ids` | `json` | 本轮默认 `[]`，保留扩展点 |
+| `unloadTable` | `table` | 下料表，字段与 `resultTable` 一致 |
+| `unload_summary` | `json` | `{ "order_code": ..., "total_items": N, "missing_material_info": [...] }` |
+| `order_id` | `str` | 透传给后续节点 |
+| `order_code` | `str` | 透传给后续节点 |
+| `order_ids` | `json` | 占位透传 |
+
+### `unloadTable` 组装规则
+
+返回结构：
+
+```json
+{
+  "data": [
+    {
+      "whName": "自动化堆栈",
+      "locationCode": "A1",
+      "materialName": "多肽产物",
+      "quantity": "10 mg"
+    }
+  ],
+  "columns": [
+    {"name": "设备", "key": "whName"},
+    {"name": "位置", "key": "locationCode"},
+    {"name": "物料名称", "key": "materialName"},
+    {"name": "数量", "key": "quantity"}
+  ],
+  "tableName": "unloadTable"
+}
+```
+
+每行字段：
+
+| key | 数据来源 |
+|-----|----------|
+| `whName` | `material_info.locations` 中匹配 `usedMaterials.locationId` 的 location 的 `whName`；匹配不到取第一条 location 的 `whName`；失败为空串 |
+| `locationCode` | 匹配 location 的 `code`；匹配不到取第一条 location 的 `code`；再兜底 `usedMaterials.locationId` |
+| `materialName` | `material_info.name`；失败为空串 |
+| `quantity` | `usedMaterials.usedQuantity`，若 `material_info.unit` 存在则拼成字符串（如 `"10 mg"`） |
+
+`material-info` 失败时不抛异常，对应行尽量保留 `locationCode` / `quantity`，`whName` 和 `materialName` 用空串，并把 `materialId` 放入 `unload_summary.missing_material_info`。
+
+### 接口依赖
+
+| 接口 | 调用方式 | 用途 |
+|------|----------|------|
+| `process_order_finish_report` 钩子 | 基类 HTTP 服务已注册 | 接 LIMS push |
+| `POST /api/lims/order/order-report` | `self.hardware_interface.order_report(order_id)` | 从 `order_id` 反查 `orderCode` |
+| `POST /api/lims/storage/material-info` | `self.hardware_interface.material_info(material_id)` | 查 `whName/locationCode/materialName/unit` |
+
+#### `order_report(order_id)` API 形式
+
+请求：
+
+```json
+{
+  "apiKey": "B10B5995",
+  "requestTime": "2026-05-20T10:50:00.123Z",
+  "data": "<orderId UUID>"
+}
+```
+
+响应中本节点只依赖 `data.code`：
+
+```json
+{
+  "code": 1,
+  "message": null,
+  "timestamp": 1779255000000,
+  "data": {
+    "id": "<orderId UUID>",
+    "name": "实验260520-103000",
+    "code": "EXP260520-103000",
+    "status": 30,
+    "statusName": "完成"
+  }
+}
+```
+
+`BioyondV1RPC.order_report(order_id)` 已经返回响应中的 `data`，所以实现中应读取 `raw.get("code")`，不是 `raw["data"]["code"]`。
+
+#### `material_info(material_id)` API 形式
+
+请求：
+
+```json
+{
+  "apiKey": "B10B5995",
+  "requestTime": "2026-05-20T10:50:00.123Z",
+  "data": "<materialId UUID>"
+}
+```
+
+响应中本节点依赖：
+
+```json
+{
+  "id": "<materialId UUID>",
+  "name": "多肽产物",
+  "unit": "mg",
+  "locations": [
+    {
+      "id": "<locationId UUID>",
+      "whid": "<warehouse UUID>",
+      "whName": "自动化堆栈",
+      "code": "A1",
+      "x": 1,
+      "y": 1,
+      "z": 1,
+      "quantity": 10
+    }
+  ]
+}
+```
+
+`BioyondV1RPC.material_info(material_id)` 已经返回响应中的 `data`。字段映射：
+
+| unloadTable key | 来源 |
+|-----------------|------|
+| `whName` | 匹配 `locationId` 的 `locations[].whName` |
+| `locationCode` | 匹配 `locationId` 的 `locations[].code` |
+| `materialName` | `name` |
+| `quantity` | `usedMaterials[].usedQuantity` + `unit` |
+
+### 实现要点
+
+- `BioyondPeptideStation.__init__` 末尾追加 `self.order_finish_event = threading.Event()`、`self.last_order_code = None`、`self.last_order_report = None`。
+- 新增 `process_order_finish_report` override，先 `super()`，再做单订单匹配。
+- `used_materials` 参数是 `MaterialUsage` dataclass 列表；输出前必须转成 JSON dict。
+- `unloadTable` 复用 `RESULT_TABLE_COLUMNS`，不新增 `UNLOAD_TABLE_COLUMNS`。
+
+---
+
+## 四、节点 2：`confirm_unload_materials`（人工下料确认）
+
+### 行为
+
+1. 接收节点 1 输出的 `order_id` / `order_code` / `material_ids` / `preintake_ids` / `unloadTable`。
+2. 进入 `NodeType.MANUAL_CONFIRM` 阻塞，操作员根据 `unloadTable` 物理下料。
+3. 操作员勾选 `materials_unloaded=True` 并 approve 后，节点函数体继续。
+4. 校验 `materials_unloaded == True`：
+   - 为 True：返回确认结果，并透传 `order_id/material_ids/preintake_ids/unloadTable` 给节点 3。
+   - 为 False：抛 `RuntimeError("下料未确认，拒绝继续 take-out")`。
+
+### 入参（goal_default）
+
+| 参数 | 类型 | 说明 |
+|------|------|------|
+| `order_id` | `str` | 来自节点 1，必填 |
+| `order_code` | `str` | 来自节点 1，日志/排错用 |
+| `material_ids` | `List[str]` | 来自节点 1，可为空 |
+| `preintake_ids` | `List[str]` | 来自节点 1，默认 `[]` |
+| `unloadTable` | `table` | 来自节点 1，供人工确认展示 |
+| `materials_unloaded` | `bool` | manual_confirm 勾选字段，默认 `False` |
+| `timeout_seconds` | `int` | 默认 `3600` |
+| `assignee_user_ids` | `List[str]` | `placeholder_keys={"assignee_user_ids": "unilabos_manual_confirm"}` |
+
+### 输出 handles
+
+| key | data_type | 说明 |
+|-----|-----------|------|
+| `unload_confirmed` | `bool` | 是否已人工确认下料 |
+| `order_id` | `str` | 透传 |
+| `order_code` | `str` | 透传 |
+| `material_ids` | `json` | 透传 |
+| `preintake_ids` | `json` | 透传 |
+| `unloadTable` | `table` | 透传 |
+
+### 实现要点
+
+- 装饰器使用 `node_type=NodeType.MANUAL_CONFIRM`。
+- `always_free=True`、`placeholder_keys`、`feedback_interval=300` 与现有 `start_experiment` 保持一致。
+- 本节点不调用 `take_out`，只做确认与透传。
+- 忘记勾选后不会自动重新显示下料指引；本轮不实现缓存或失败节点原地重跑。
+
+---
+
+## 五、节点 3：`take_out_materials`（调用 take-out 同步奔耀）
+
+### 行为
+
+1. 接收节点 2 透传的 `order_id` / `material_ids` / `preintake_ids`。
+2. 校验 `order_id` 非空。
+3. 调用 `self.hardware_interface.take_out(order_id, preintake_ids=preintake_ids, material_ids=material_ids)`。
+4. 返回 `take_out_result`、`unloaded_count`、`success`。
+
+### 入参
+
+| 参数 | 类型 | 说明 |
+|------|------|------|
+| `order_id` | `str` | 必填 |
+| `material_ids` | `List[str]` | 可为空；为空时由奔耀按 `orderId` 处理的能力以后现场确认 |
+| `preintake_ids` | `List[str]` | 可为空，默认 `[]` |
+| `order_code` | `str` | 日志/排错用 |
+
+### 输出 handles
+
+| key | data_type | 说明 |
+|-----|-----------|------|
+| `take_out_result` | `json` | `take-out` 原始响应 `{code, message, timestamp, data}` |
+| `unloaded_count` | `int` | `len(material_ids)` |
+| `success` | `bool` | `take_out_result.code == 1` 且 `data` 不为 False |
+
+### 接口依赖
+
+| 接口 | 调用方式 | 用途 |
+|------|----------|------|
+| `POST /api/lims/order/take-out` | `self.hardware_interface.take_out(order_id, preintake_ids, material_ids)` | 通知奔耀同步取出 |
+
+请求体 schema（helper script 已核对）：
+
+```json
+{
+  "apiKey": "B10B5995",
+  "requestTime": "2026-05-20T10:50:00.123Z",
+  "data": {
+    "orderId": "<UUID>",
+    "preintakeIds": [],
+    "materialIds": ["<UUID-1>", "<UUID-2>"]
+  }
+}
+```
+
+响应 schema：
+
+```json
+{
+  "code": 1,
+  "message": null,
+  "timestamp": 1779255000000,
+  "data": true
+}
+```
+
+`BioyondV1RPC.take_out(...)` 返回完整响应包，因此 `take_out_materials` 应保留原始包到 `take_out_result`。
+
+### 实现要点
+
+- 本轮不修改 `sample_waste_removal`，保持 backward compatibility。
+- 新节点只调用现有完整能力的 `take_out(...)`。
+- `preintake_ids` / `material_ids` 都按可选列表处理，默认 `[]`。
+- `take-out` 返回 `code != 1` 时返回 `success=False` 并记录 warning；是否抛异常留作开放问题。
+
+---
+
+## 六、端到端工作流连线
+
+```mermaid
+flowchart LR
+    submit["submit_experiment_dayN"] --> start["start_experiment<br/>manual_confirm: 上料"]
+    start -->|order_id, order_code| wait["wait_for_order_finish<br/>等 order_finish + 生成 unloadTable"]
+    wait -->|order_id, material_ids,<br/>preintake_ids, unloadTable| confirm["confirm_unload_materials<br/>manual_confirm: 操作员下料确认"]
+    confirm -->|order_id, material_ids,<br/>preintake_ids| takeout["take_out_materials<br/>调用 take-out 同步奔耀"]
+    bioyond["奔耀 LIMS"] -.HTTP POST /report/order_finish.-> wait
+    wait -.material-info.-> bioyond
+    takeout -.take-out.-> bioyond
+```
+
+---
+
+## 七、影响面与兼容性
+
+- **`peptide_station.py`**
+  - 修改 `start_experiment`：增加 `order_id/order_code/order_ids/resultTable` 输出 handles，并在返回值透传。
+  - 增加 `wait_for_order_finish`、`confirm_unload_materials`、`take_out_materials` 三个 action。
+  - 增加 `process_order_finish_report` override。
+  - 增加 `_build_unload_table(...)` 等私有辅助方法。
+- **`bioyond_rpc.py` 不动**
+  - `take_out` 已有完整 schema 能力。
+  - `sample_waste_removal` 本轮不改，保持兼容。
+- **基类 `station.py` 不动**
+  - override 中保留 `super().process_order_finish_report(...)` 调用。
+- **HTTP 服务不动**
+  - `WorkstationHTTPService` 已支持 `/report/order_finish`。
+- **本轮不做缓存**
+  - 不新增 `unload_context_cache`。
+  - 不支持 push 早于 wait 的自动补救。
+  - 不支持失败 manual_confirm 原地重跑。
+- **测试**：补在现有路径 `unilabos/devices/workstation/bioyond_studio/peptide_station/tests/test_peptide_station_contracts.py`
+  1. `start_experiment` 输出 handles/返回值透传 `order_id/order_code/order_ids/resultTable`。
+  2. `process_order_finish_report` orderCode 匹配 / 不匹配时 event 是否触发。
+  3. `wait_for_order_finish` 单订单成功、超时、状态映射、`used_materials` JSON 化。
+  4. `_build_unload_table` 列顺序严格等于 `RESULT_TABLE_COLUMNS`，且无 `posX/posY/posZ/unit` 列。
+  5. `material-info` 失败时不抛异常，`missing_material_info` 正确记录。
+  6. `confirm_unload_materials` 未勾选时报错，勾选后透传下游字段且不调用 `take_out`。
+  7. `take_out_materials` 调用 `hardware_interface.take_out(order_id, preintake_ids, material_ids)`，不调用 `sample_waste_removal`。
+
+---
+
+## 八、待人类确认的开放问题
+
+1. **过滤产物 vs 全量**：`usedMaterials` 同时包含试剂、耗材、样品（`typeMode` 区分），下料表是否需要默认排除试剂/耗材？当前默认全量列出。
+2. **take-out 失败是否阻塞工作流**：本计划暂定返回 `success=False` 并 warning，不抛异常；如果希望奔耀仓位状态必须一致，可改为抛 `RuntimeError`。
+3. **后续缓存/重跑能力**：如果要支持 push 早到、忘勾选后重跑复用 `unloadTable`，后续应在 `BioyondPeptideStation` station runtime 上实现 `unload_context_cache`，但本轮不做。
+4. **多订单**：本轮只保留 `order_ids` 占位，不实现多订单等待、乱序回调或并发 wait。
+
+---
+
+## 附录 A：API schema 核对摘要
+
+使用 `temp_benyao/scripts/api_helper.py --root temp_benyao/peptide` 核对：
+
+### A.1 `POST /api/lims/storage/material-info`
+
+请求：
+
+```json
+{
+  "apiKey": "B10B5995",
+  "requestTime": "2026-05-20T10:50:00.123Z",
+  "data": "<materialId UUID>"
+}
+```
+
+响应关键字段：
+
+```json
+{
+  "id": "<materialId UUID>",
+  "typeName": "样品",
+  "code": "MAT-001",
+  "barCode": "BC-001",
+  "name": "多肽产物",
+  "quantity": 10,
+  "lockQuantity": 0,
+  "unit": "mg",
+  "status": 1,
+  "isUse": true,
+  "locations": [
+    {
+      "id": "<locationId UUID>",
+      "whid": "<warehouse UUID>",
+      "whName": "自动化堆栈",
+      "code": "A1",
+      "x": 1,
+      "y": 1,
+      "z": 1,
+      "quantity": 10
+    }
+  ],
+  "detail": []
+}
+```
+
+注意：schema 没有 `posX/posY/posZ`，本轮也不展示坐标。
+
+### A.2 `POST /api/lims/order/take-out`
+
+请求：
+
+```json
+{
+  "apiKey": "B10B5995",
+  "requestTime": "2026-05-20T10:50:00.123Z",
+  "data": {
+    "orderId": "<orderId UUID>",
+    "preintakeIds": [],
+    "materialIds": ["<materialId UUID>"]
+  }
+}
+```
+
+响应：
+
+```json
+{
+  "code": 1,
+  "message": null,
+  "timestamp": 1779255000000,
+  "data": true
+}
+```
+
+源码中已有 `BioyondV1RPC.take_out(order_id, preintake_ids=None, material_ids=None)`，本轮复用它。
+
+### A.3 `/report/order_finish`
+
+`/report/order_finish` 不在 Peptide JSON OpenAPI specs 中；schema 依据：
+
+- `unilabos/devices/workstation/workstation_http_service.py`
+- `temp_benyao/peptide/docs/reference/api_manual.md`
+
+关键字段：
+
+```json
+{
+  "token": "token-from-lims",
+  "request_time": "2026-05-20 10:50:00.123",
+  "data": {
+    "orderCode": "EXP260520-103000",
+    "orderName": "实验260520-103000",
+    "startTime": "2026-05-20 09:00:00",
+    "endTime": "2026-05-20 10:50:00",
+    "status": "30",
+    "usedMaterials": [
+      {
+        "materialId": "<materialId UUID>",
+        "locationId": "<locationId UUID>",
+        "typeMode": "1",
+        "usedQuantity": 10
+      }
+    ]
+  }
+}
+```
+
+`WorkstationHTTPService` 会把 `usedMaterials[]` 转成 `MaterialUsage` dataclass 列表传给 `process_order_finish_report(report_request, used_materials)`；peptide 输出 `used_materials` handle 前需要转回 JSON dict：
+
+```json
+[
+  {
+    "materialId": "<materialId UUID>",
+    "locationId": "<locationId UUID>",
+    "typeMode": "1",
+    "usedQuantity": 10
+  }
+]
+```
+
+---
+
+## 附录 B：本轮不实现的内容
+
+- 不做 station runtime 的 `unload_context_cache`。
+- 不做多订单。
+- 不做 push 早到后的补救。
+- 不做 failed manual_confirm 原地重跑。
+- 不改前端。
+- 不改 `sample_waste_removal`。

plan/2026-05-21_01_peptide_reset_four_checkbox_plan.md

@@ -0,0 +1,461 @@
+# Peptide Four-Checkbox Reset Plan
+
+Date: 2026-05-21 16:30
+Status: Proposal only / not executed
+
+## Scope
+
+This plan replaces `2026-05-21_1556_peptide_reset_sirna_reference_plan.md` for Peptide reset work.
+
+User direction captured here:
+
+- `take_out` is unnecessary for Peptide reset.
+- Do not add a material-cache refresh checkbox.
+- Change reset to four checkbox-controlled operations:
+  - 调度器复位
+  - 订单状态复位
+  - 库位复位
+  - 仪器复位
+- The first three checkboxes default to checked.
+- The fourth checkbox, 仪器复位 / `reset_devices`, defaults to unchecked.
+- Replace the current public `reset` action with:
+  - `reset_auto`: normal ILab action node. This is the renamed/replaced version of the current reset implementation.
+  - `reset_manual`: manual-confirm action node with a physical cleanup confirmation message.
+
+## Evidence Summary
+
+Current Peptide source:
+
+- Reset action code is currently in `unilabos/devices/workstation/bioyond_studio/peptide_station/peptide_station.py`.
+- Current Peptide reset selects `scheduler_reset`, `reset_order_status`, and `reset_location`, and passes ids to order/location resets.
+- `BioyondV1RPC.reset_devices()` already calls `/api/lims/device/reset-devices` with only `apiKey` and `requestTime`.
+- `BioyondV1RPC.scheduler_reset()` already calls `/api/lims/scheduler/reset` with only `apiKey` and `requestTime`.
+- `BioyondV1RPC.reset_order_status(order_id)` and `reset_location(location_id)` currently send `data`, but live probes showed that omitted `data` succeeds.
+
+Live Peptide no-data reset probes using `temp_benyao/peptide/peptide_station_config.example.json`:
+
+- `POST /api/lims/order/reset-order-status` with request keys `["apiKey", "requestTime"]` returned HTTP 200 and `code=1`.
+- `POST /api/lims/scheduler/reset` with request keys `["apiKey", "requestTime"]` returned HTTP 200 and `code=1`.
+- `POST /api/lims/storage/reset-location` with request keys `["apiKey", "requestTime"]` returned HTTP 200 and `code=1`.
+- `reset-devices` was not live-probed in this session, but the current RPC wrapper already sends no `data`.
+
+Raw findings:
+
+- `temp_benyao/peptide/_findings/2026-05-21_1613_reset_order_status_no_data_live.md`
+- `temp_benyao/peptide/_findings/2026-05-21_1615_remaining_resets_no_data_live.md`
+
+## Proposed Public Actions
+
+### `reset_auto`
+
+Normal action node. This is the auto/no-manual-confirm path. It replaces the current public `reset` action; do not leave a second public `reset` action unless a later compatibility request explicitly asks for an alias.
+
+Checkbox schema rule:
+
+- Use plain `bool` annotations in the action signature.
+- Do not use `Annotated[bool, Field(...)]` for these checkbox params in this implementation plan.
+- The current AST registry schema path does not unwrap `Annotated[...]`; plain `bool` is required so generated JSON Schema marks the fields as boolean and the renderer can show checkboxes.
+- Put human-facing labels/descriptions in the method docstring or action description. If field-level `Field(description=...)` metadata is required later, add registry `Annotated` support and a schema test as a separate change.
+
+Decorator shape:
+
+```python
+@action(
+    always_free=True,
+    goal_default={
+        "reset_scheduler": True,
+        "reset_order_status": True,
+        "reset_location": True,
+        "reset_devices": False,
+    },
+    description="自动复位调度器/订单状态/库位，可选仪器复位",
+)
+def reset_auto(
+    self,
+    reset_scheduler: bool = True,
+    reset_order_status: bool = True,
+    reset_location: bool = True,
+    reset_devices: bool = False,
+    **kwargs: Any,
+) -> Dict[str, Any]:
+    """自动复位调度器/订单状态/库位，可选仪器复位。
+
+    Args:
+        reset_scheduler[调度器复位]: 调用 /api/lims/scheduler/reset，默认勾选。
+        reset_order_status[订单状态复位]: 调用 /api/lims/order/reset-order-status，默认勾选。
+        reset_location[库位复位]: 调用 /api/lims/storage/reset-location，默认勾选。
+        reset_devices[仪器复位]: 调用 /api/lims/device/reset-devices，默认不勾选。
+    """
+    ...
+```
+
+Implementation notes:
+
+- Use real plain-`bool` parameters, not hidden `**kwargs` and not `Annotated`, so the action renderer can expose four checkboxes.
+- Rename/replace the existing `reset` action as `reset_auto`; the implementation should not keep the old id-shaped `reset` action as another public path by default.
+- Keep the three routine reset defaults checked.
+- Keep `reset_devices` unchecked because it can be broader and more disruptive.
+- Do not require or resolve order ids or location ids.
+- Do not call `take_out`.
+- Do not call `refresh_material_cache`.
+
+### `reset_manual`
+
+Manual-confirm node. It should show the operator a physical cleanup warning, then execute the same reset helper as `reset_auto` after the operator confirms.
+
+Actual manual-confirm decorator pattern in this repo:
+
+- Use `@action(node_type=NodeType.MANUAL_CONFIRM)`.
+- Set `always_free=True`.
+- Add `placeholder_keys={"assignee_user_ids": "unilabos_manual_confirm"}`.
+- Include `timeout_seconds: int` and `assignee_user_ids: list[str]`.
+- Add `goal_default` for `timeout_seconds` and `assignee_user_ids`.
+- Manual-confirm actions are normally side-effect-light, but existing Peptide `start_experiment` is already a `MANUAL_CONFIRM` action that performs scheduler start after the operator gate, so a reset-after-confirm pattern is compatible with current Peptide style.
+
+Proposed confirmation text:
+
+```text
+请确认G3、CEM、Tecan、撕膜机、封膜机、打标机、旋转堆栈上下料位、3个转台等位置的物料已清理完毕；
+请开门检查冰箱、IDOT、酶标仪、离心机、LCMS内部没有遗留物料。
+```
+
+Decorator/function shape:
+
+```python
+RESET_MANUAL_CONFIRM_MESSAGE = (
+    "请确认G3、CEM、Tecan、撕膜机、封膜机、打标机、旋转堆栈上下料位、3个转台等位置的物料已清理完毕；\n"
+    "请开门检查冰箱、IDOT、酶标仪、离心机、LCMS内部没有遗留物料。"
+)
+
+@action(
+    always_free=True,
+    node_type=NodeType.MANUAL_CONFIRM,
+    placeholder_keys={"assignee_user_ids": "unilabos_manual_confirm"},
+    goal_default={
+        "reset_scheduler": True,
+        "reset_order_status": True,
+        "reset_location": True,
+        "reset_devices": False,
+        "physical_cleanup_confirmed": False,
+        "timeout_seconds": 3600,
+        "assignee_user_ids": [],
+    },
+    feedback_interval=300,
+    description=RESET_MANUAL_CONFIRM_MESSAGE,
+)
+def reset_manual(
+    self,
+    reset_scheduler: bool = True,
+    reset_order_status: bool = True,
+    reset_location: bool = True,
+    reset_devices: bool = False,
+    physical_cleanup_confirmed: bool = False,
+    timeout_seconds: int = 3600,
+    assignee_user_ids: Optional[List[str]] = None,
+    **kwargs: Any,
+) -> Dict[str, Any]:
+    """人工确认物理清理后执行复位。
+
+    Args:
+        reset_scheduler[调度器复位]: 调用 /api/lims/scheduler/reset，默认勾选。
+        reset_order_status[订单状态复位]: 调用 /api/lims/order/reset-order-status，默认勾选。
+        reset_location[库位复位]: 调用 /api/lims/storage/reset-location，默认勾选。
+        reset_devices[仪器复位]: 调用 /api/lims/device/reset-devices，默认不勾选。
+        physical_cleanup_confirmed[物理清理确认]: 确认清理提示中的物料检查已经完成，默认不勾选。
+    """
+    ...
+```
+
+Execution rule:
+
+- If `physical_cleanup_confirmed` is false, return a blocked result and do not call any reset API.
+- If it is true, call the same internal helper as `reset_auto`.
+- Return `confirmation_message` in the result payload so call logs preserve the exact operator instruction text.
+
+Renderer caveat:
+
+- `description` should carry the warning in generated action metadata.
+- `physical_cleanup_confirmed` must remain a plain `bool` so it renders as a checkbox.
+- The cleanup warning should be carried by the action `description` and the docstring param description. Do not rely on `Field(description=...)` unless registry `Annotated` support has been implemented and tested.
+- If the current frontend does not show action descriptions or docstring field descriptions reliably, add a read-only string parameter such as `confirmation_message: str = RESET_MANUAL_CONFIRM_MESSAGE` with `goal_default`, or use a handle-based display only after renderer behavior is verified.
+
+## Shared Internal Helper
+
+Both public actions should delegate to one helper, for example:
+
+```python
+def _execute_reset_operations(
+    self,
+    *,
+    reset_scheduler: bool,
+    reset_order_status: bool,
+    reset_location: bool,
+    reset_devices: bool,
+) -> Dict[str, Any]:
+    ...
+```
+
+Call order:
+
+1. `scheduler_reset`
+2. `reset_order_status`
+3. `reset_location`
+4. `reset_devices`
+
+Result shape:
+
+```python
+{
+    "selected_operations": [
+        {"key": "reset_scheduler", "label": "调度器复位", "selected": True},
+        {"key": "reset_order_status", "label": "订单状态复位", "selected": True},
+        {"key": "reset_location", "label": "库位复位", "selected": True},
+        {"key": "reset_devices", "label": "仪器复位", "selected": False},
+    ],
+    "executed_calls": [
+        {"operation": "scheduler_reset", "endpoint": "/api/lims/scheduler/reset", "result": {"code": 1}},
+    ],
+    "skipped_operations": [
+        {"operation": "reset_devices", "reason": "checkbox_disabled"},
+    ],
+    "warnings": [],
+}
+```
+
+Failure handling:
+
+- Execute selected operations sequentially and record each result.
+- If an operation returns non-`1` code, add a warning and continue unless the caller later requests fail-fast.
+- If an RPC method raises, catch it, record an error entry, and continue to the next selected operation unless fail-fast is introduced.
+
+## RPC Wrapper Adjustment
+
+Adjust the two id-shaped wrappers to no-data calls:
+
+- `BioyondV1RPC.reset_order_status()` should no longer require `order_id`.
+- `BioyondV1RPC.reset_location()` should no longer require `location_id`.
+
+Current no-data wrappers already exist:
+
+- `scheduler_reset()`
+- `reset_devices()`
+
+Suggested RPC signatures:
+
+```python
+def scheduler_reset(self) -> int: ...
+def reset_order_status(self) -> int: ...
+def reset_location(self) -> int: ...
+def reset_devices(self) -> int: ...
+```
+
+Compatibility option:
+
+```python
+def reset_order_status(self, order_id: Optional[str] = None) -> int:
+    del order_id
+    ...
+
+def reset_location(self, location_id: Optional[str] = None) -> int:
+    del location_id
+    ...
+```
+
+This keeps older code from crashing while making the actual wire request no-data.
+
+## Adjusted Runtime API Schemas
+
+These are the schemas Peptide reset code should target at runtime after the live no-data probes. They intentionally omit `data`, even though OpenAPI models nullable `data` for these endpoints.
+
+All four requests use:
+
+```json
+{
+  "apiKey": "string",
+  "requestTime": "date-time"
+}
+```
+
+No `data` field should be sent by default.
+
+All four responses use:
+
+```json
+{
+  "code": 1,
+  "message": "",
+  "timestamp": 0
+}
+```
+
+### 调度器复位
+
+Endpoint:
+
+```text
+POST /api/lims/scheduler/reset
+```
+
+Adjusted request:
+
+```json
+{
+  "apiKey": "B10B5995",
+  "requestTime": "2026-05-21T08:15:16.494Z"
+}
+```
+
+Live response:
+
+```json
+{
+  "code": 1,
+  "message": "",
+  "timestamp": 1779351316072
+}
+```
+
+Notes:
+
+- OpenAPI says `data` is nullable int32.
+- Live Peptide accepted omitted `data`.
+
+### 订单状态复位
+
+Endpoint:
+
+```text
+POST /api/lims/order/reset-order-status
+```
+
+Adjusted request:
+
+```json
+{
+  "apiKey": "B10B5995",
+  "requestTime": "2026-05-21T08:13:34.750Z"
+}
+```
+
+Live response:
+
+```json
+{
+  "code": 1,
+  "message": "",
+  "timestamp": 1779351214422
+}
+```
+
+Notes:
+
+- OpenAPI says `data` is nullable string.
+- Live Peptide accepted omitted `data`.
+- Do not model this as order-id scoped unless Bioyond confirms backend behavior.
+
+### 库位复位
+
+Endpoint:
+
+```text
+POST /api/lims/storage/reset-location
+```
+
+Adjusted request:
+
+```json
+{
+  "apiKey": "B10B5995",
+  "requestTime": "2026-05-21T08:15:18.924Z"
+}
+```
+
+Live response:
+
+```json
+{
+  "code": 1,
+  "message": "",
+  "timestamp": 1779351318565
+}
+```
+
+Notes:
+
+- OpenAPI says `data` is nullable string.
+- Live Peptide accepted omitted `data`.
+- Do not model this as location-id scoped unless Bioyond confirms backend behavior.
+
+### 仪器复位
+
+Endpoint:
+
+```text
+POST /api/lims/device/reset-devices
+```
+
+Adjusted request:
+
+```json
+{
+  "apiKey": "B10B5995",
+  "requestTime": "date-time"
+}
+```
+
+Expected response shape:
+
+```json
+{
+  "code": 1,
+  "message": "",
+  "timestamp": 0
+}
+```
+
+Notes:
+
+- OpenAPI says `data` is nullable string.
+- Current `BioyondV1RPC.reset_devices()` already sends no `data`.
+- This endpoint was not live-probed in the no-data reset session.
+- Keep checkbox default unchecked.
+
+## Tests To Add Before Implementation
+
+1. `reset_auto` is not `NodeType.MANUAL_CONFIRM`.
+2. `reset_manual` has `node_type=NodeType.MANUAL_CONFIRM`.
+3. `reset_manual` metadata includes:
+   - `always_free=True`
+   - `placeholder_keys={"assignee_user_ids": "unilabos_manual_confirm"}`
+   - `timeout_seconds=3600`
+   - `assignee_user_ids=[]`
+   - `physical_cleanup_confirmed=False`
+4. Both reset actions expose four real boolean params:
+   - `reset_scheduler`
+   - `reset_order_status`
+   - `reset_location`
+   - `reset_devices`
+5. The generated registry schema marks those reset params as JSON Schema `type: boolean`, not `object` or `string`, so the frontend can render checkboxes.
+6. `reset_auto` replaces the current public `reset` action. Unless a later compatibility request adds an alias, no old id-shaped public `reset` action remains.
+7. Goal defaults are:
+   - first three reset checkboxes `True`
+   - `reset_devices=False`
+8. `reset_manual(..., physical_cleanup_confirmed=False)` does not call any RPC reset method.
+9. `reset_auto()` with defaults calls:
+   - `scheduler_reset()`
+   - `reset_order_status()`
+   - `reset_location()`
+   - not `reset_devices()`
+10. `reset_auto(reset_devices=True)` also calls `reset_devices()`.
+11. `reset_order_status()` and `reset_location()` RPC wrappers send no `data` key.
+12. No reset path calls `take_out`.
+13. No reset path calls `refresh_material_cache`.
+
+## Non-Goals
+
+- Do not implement `take_out` in reset.
+- Do not refresh `material_cache` from reset.
+- Do not resolve order ids or location ids for reset.
+- Do not add Project/cache/browser cleanup routes.
+- Do not make `reset_devices` default-on.
+- Do not execute this plan during planning.

recipes/msgs/recipe.yaml

@@ -1,6 +1,6 @@
 package:
   name: ros-humble-unilabos-msgs
-  version: 0.11.3
+  version: 0.11.1
 source:
   path: ../../unilabos_msgs
   target_directory: src

recipes/unilabos/recipe.yaml

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

setup.py

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

unilabos/__init__.py

@@ -1 +1 @@
-__version__ = "0.11.3"
+__version__ = "0.11.1"

unilabos/app/model.py

@@ -59,7 +59,6 @@ class JobAddReq(BaseModel):
     task_id: str = Field(examples=["task_id"], description="task uuid (auto-generated if empty)", default="")
     job_id: str = Field(examples=["job_id"], description="goal uuid (auto-generated if empty)", default="")
     node_id: str = Field(examples=["node_id"], description="node uuid", default="")
-    notebook_id: str = Field(examples=["notebook_id"], description="notebook uuid", default="")
     server_info: dict = Field(
         examples=[{"send_timestamp": 1717000000.0}],
         description="server info (auto-generated if empty)",

unilabos/app/utils.py

@@ -10,170 +10,29 @@ import shutil
 import sys
 
 
-_PATCH_MARKER = "# UniLabOS DLL Patch"
-_PATCH_END_MARKER = "# End UniLabOS DLL Patch"
-
-# 75 = EX_TEMPFAIL: 临时失败、重试即可，避免与业务退出码冲突
-_RESTART_EXIT_CODE = 75
-
-
-def _build_dll_patch(lib_bin: str, preload_pyd: str = "") -> str:
-    """生成一段加在目标文件顶部的 DLL 加载补丁源码。
-
-    - 始终把 ``lib_bin`` 加入 DLL 搜索路径，并把 handle 挂在模块属性上，
-      防止 GC 清掉搜索路径（``os.add_dll_directory`` 的句柄被回收时
-      目录会被移除）。
-    - 可选地用 ``ctypes.CDLL`` 预加载一个 .pyd，把它的依赖 DLL 提前装入
-      进程内存，作为 ``rclpy._rclpy_pybind11`` 这类首次加载点的兜底。
-    """
-    # 用 repr() 序列化路径：Python 解析 repr 的结果会还原成原始字符串，
-    # 不需要也不能再叠加 raw-string 前缀（叠了反而会让 \\ 变成两个反斜杠）。
-    lines = [
-        _PATCH_MARKER,
-        "import os as _ulab_os",
-        f"_ulab_p = {lib_bin!r}",
-        'if hasattr(_ulab_os, "add_dll_directory") and _ulab_os.path.isdir(_ulab_p):',
-        "    try: _UNILAB_DLL_HANDLE = _ulab_os.add_dll_directory(_ulab_p)",
-        "    except Exception: _UNILAB_DLL_HANDLE = None",
-    ]
-    if preload_pyd:
-        lines.extend(
-            [
-                "import ctypes as _ulab_ctypes",
-                f"try: _ulab_ctypes.CDLL({preload_pyd!r})",
-                "except Exception: pass",
-            ]
-        )
-    lines.append(_PATCH_END_MARKER)
-    return "\n".join(lines) + "\n"
-
-
-def _apply_dll_patch(file_path: str, lib_bin: str, preload_pyd: str = "") -> bool:
-    """把 DLL 补丁前置到 ``file_path``。文件不存在或已打过补丁则返回 False。"""
-    if not os.path.isfile(file_path):
-        return False
-    with open(file_path, "r", encoding="utf-8") as f:
-        content = f.read()
-    if _PATCH_MARKER in content:
-        return False
-    shutil.copy2(file_path, file_path + ".bak")
-    with open(file_path, "w", encoding="utf-8") as f:
-        f.write(_build_dll_patch(lib_bin, preload_pyd) + content)
-    return True
-
-
-def _print_restart_banner(patched_files):
-    """打印重启提示并以 EX_TEMPFAIL 退出。
-
-    - 不使用 ANSI 颜色码：Windows 旧版 cmd / PowerShell 5 默认不开 VT 处理，
-      会把 ``\\033[1;33m`` 当做字面字符显示，反而让用户看不到正文。
-    - 同时写入 stderr 与 stdout：某些上层 launcher / supervisor 只重定向
-      其中一路，写两遍能保证用户至少看到一份。
-    - 写入前防御性把流切到 UTF-8 with replace：``main.py`` 里已经做过一次，
-      但本模块也可能被绕过 ``main.py`` 的代码路径直接 import；reconfigure
-      失败也只是退回 errors=replace，不影响整体流程。
-    """
-    if sys.platform == "win32":
-        for _stream in (sys.stdout, sys.stderr):
-            try:
-                _stream.reconfigure(encoding="utf-8", errors="replace")  # type: ignore[attr-defined]
-            except (AttributeError, OSError):
-                pass
-
-    bar = "#" * 78
-    files_lines = [f"[UniLabOS]   - {p}" for p in patched_files]
-    body = "\n".join(
-        [
-            "",
-            bar,
-            bar,
-            "##",
-            "##  [UniLabOS] Windows + conda 下检测到 DLL 加载失败，已自动打补丁。",
-            "##  [UniLabOS] DLL load failure detected on Windows + conda;",
-            "##  [UniLabOS] the following files have been auto-patched:",
-            "##",
-            *[f"##  {line}" for line in files_lines],
-            "##",
-            "##  [UniLabOS] 当前进程的 rclpy 状态已损坏，补丁需要在新进程才生效。",
-            "##  [UniLabOS] The current process is unusable; the patch only takes",
-            "##  [UniLabOS] effect on a fresh process.",
-            "##",
-            "##  >>> 请重新运行刚才的命令 / Please re-run the same command. <<<",
-            "##",
-            bar,
-            bar,
-            "",
-        ]
-    )
-
-    for stream in (sys.stderr, sys.stdout):
-        try:
-            stream.write(body)
-            stream.flush()
-        except Exception:
-            try:
-                print(body, file=stream)
-            except Exception:
-                pass
-
-    sys.exit(_RESTART_EXIT_CODE)
-
-
 def patch_rclpy_dll_windows():
-    """在 Windows + conda 环境下修复 rclpy / rosidl typesupport 的 DLL 加载。
-
-    背景：conda 安装的 ros 系列包，其原生扩展依赖 ``$CONDA_PREFIX/Library/bin``
-    下的 DLL；只有 conda 环境被正确激活、且 PATH 中含 ``Library/bin`` 时，
-    ``os.add_dll_directory`` 才能找到它们。当从快捷方式 / IDE / 子进程 /
-    没激活的 shell 启动 ``unilab`` 时，会出现 ``DLL load failed``。
-
-    本函数会:
-        1) 修补 ``rclpy/impl/implementation_singleton.py`` —— rclpy 自身的 C 扩展入口；
-        2) 修补 ``rpyutils/add_dll_directories.py`` —— 所有 ``*_s__rosidl_typesupport_c.pyd``
-           （``geometry_msgs`` / ``std_msgs`` / ``sensor_msgs`` 等）的统一加载入口。
-
-    打完补丁后**必须重启进程**才能生效（当前进程的 rclpy 已经发生过
-    ``ImportError``，子模块仍处于损坏状态）。因此函数会主动退出，并在
-    stdout/stderr 同时打印明显的重启提示，避免用户被后续报错淹没。
-    """
+    """在 Windows + conda 环境下为 rclpy 打 DLL 加载补丁"""
     if sys.platform != "win32" or not os.environ.get("CONDA_PREFIX"):
         return
-
     try:
-        import rclpy  # noqa: F401
+        import rclpy
 
         return
     except ImportError as e:
         if not str(e).startswith("DLL load failed"):
             return
-
     cp = os.environ["CONDA_PREFIX"]
-    lib_bin = os.path.join(cp, "Library", "bin")
-    site_packages = os.path.join(cp, "Lib", "site-packages")
-    if not os.path.isdir(lib_bin):
+    impl = os.path.join(cp, "Lib", "site-packages", "rclpy", "impl", "implementation_singleton.py")
+    pyd = glob.glob(os.path.join(cp, "Lib", "site-packages", "rclpy", "_rclpy_pybind11*.pyd"))
+    if not os.path.exists(impl) or not pyd:
         return
-
-    patched = []
-
-    # 1) rclpy 自身的入口
-    rclpy_impl = os.path.join(site_packages, "rclpy", "impl", "implementation_singleton.py")
-    rclpy_pyd_matches = glob.glob(os.path.join(site_packages, "rclpy", "_rclpy_pybind11*.pyd"))
-    rclpy_pyd = rclpy_pyd_matches[0] if rclpy_pyd_matches else ""
-    if rclpy_pyd and _apply_dll_patch(rclpy_impl, lib_bin, preload_pyd=rclpy_pyd):
-        patched.append(rclpy_impl)
-
-    # 2) rpyutils —— 所有 rosidl typesupport pyd 的加载点；放在 rclpy 之后
-    #    例：geometry_msgs/geometry_msgs_s__rosidl_typesupport_c.pyd
-    rpyutils_dll = os.path.join(site_packages, "rpyutils", "add_dll_directories.py")
-    if _apply_dll_patch(rpyutils_dll, lib_bin):
-        patched.append(rpyutils_dll)
-
-    if not patched:
-        # 已经打过补丁但 rclpy 仍然加载失败：原因不是缺 DLL 搜索路径，
-        # 不要再次打补丁污染文件，让上层看到真实的 ImportError。
-        return
-
-    _print_restart_banner(patched)
+    with open(impl, "r", encoding="utf-8") as f:
+        content = f.read()
+    lib_bin = os.path.join(cp, "Library", "bin").replace("\\", "/")
+    patch = f'# UniLabOS DLL Patch\nimport os,ctypes\nos.add_dll_directory("{lib_bin}") if hasattr(os,"add_dll_directory") else None\ntry: ctypes.CDLL("{pyd[0].replace(chr(92),"/")}")\nexcept: pass\n# End Patch\n'
+    shutil.copy2(impl, impl + ".bak")
+    with open(impl, "w", encoding="utf-8") as f:
+        f.write(patch + content)
 
 
 patch_rclpy_dll_windows()

unilabos/app/web/controller.py

@@ -320,7 +320,6 @@ def job_add(req: JobAddReq) -> JobData:
             action_name=action_name,
             task_id=task_id,
             job_id=job_id,
-            notebook_id=req.notebook_id,
             device_action_key=device_action_key,
         )
 

unilabos/app/ws_client.py

@@ -59,7 +59,6 @@ class QueueItem:
     action_name: str
     task_id: str
     job_id: str
-    notebook_id: str
     device_action_key: str
     next_run_time: float = 0  # 下次执行时间戳
     retry_count: int = 0  # 重试次数
@@ -72,7 +71,6 @@ class JobInfo:
     job_id: str
     task_id: str
     device_id: str
-    notebook_id: str
     action_name: str
     device_action_key: str
     status: JobStatus
@@ -541,10 +539,7 @@ class MessageProcessor:
                 self.reconnect_count += 1
                 backoff = WSConfig.reconnect_interval
                 logger.info(
-                    "[MessageProcessor] 即将在 %s 秒后重连 (已尝试 %s/%s)",
-                    backoff,
-                    self.reconnect_count,
-                    WSConfig.max_reconnect_attempts,
+                    f"[MessageProcessor] 即将在 {backoff} 秒后重连 (已尝试 {self.reconnect_count}/{WSConfig.max_reconnect_attempts})"
                 )
                 await asyncio.sleep(backoff)
             else:
@@ -708,7 +703,6 @@ class MessageProcessor:
         action_name = data.get("action_name", "")
         task_id = data.get("task_id", "")
         job_id = data.get("job_id", "")
-        notebook_id = data.get("notebook_id", "")
 
         if not all([device_id, action_name, task_id, job_id]):
             logger.error("[MessageProcessor] Missing required fields in query_action_state")
@@ -724,7 +718,6 @@ class MessageProcessor:
             job_id=job_id,
             task_id=task_id,
             device_id=device_id,
-            notebook_id=notebook_id,
             action_name=action_name,
             device_action_key=device_action_key,
             status=JobStatus.QUEUE,
@@ -739,27 +732,13 @@ class MessageProcessor:
         if can_start_immediately:
             # 可以立即开始
             await self._send_action_state_response(
-                device_id,
-                action_name,
-                task_id,
-                job_id,
-                "query_action_status",
-                True,
-                0,
-                notebook_id=notebook_id,
+                device_id, action_name, task_id, job_id, "query_action_status", True, 0
             )
             logger.trace(f"[MessageProcessor] Job {job_log} can start immediately")
         else:
             # 需要排队
             await self._send_action_state_response(
-                device_id,
-                action_name,
-                task_id,
-                job_id,
-                "query_action_status",
-                False,
-                10,
-                notebook_id=notebook_id,
+                device_id, action_name, task_id, job_id, "query_action_status", False, 10
             )
             logger.trace(f"[MessageProcessor] Job {job_log} queued")
 
@@ -789,7 +768,6 @@ class MessageProcessor:
                         job_id=req.job_id,
                         task_id=req.task_id,
                         device_id=req.device_id,
-                        notebook_id=req.notebook_id,
                         action_name=action_name,
                         device_action_key=device_action_key,
                         status=JobStatus.QUEUE,
@@ -797,16 +775,11 @@ class MessageProcessor:
                         always_free=True,
                     )
                     self.device_manager.add_queue_request(job_info)
-                    existing_job = job_info
                     logger.info(f"[MessageProcessor] Job {job_log} always_free, auto-registered from direct job_start")
                 else:
                     logger.error(f"[MessageProcessor] Job {job_log} not registered (missing query_action_state)")
                     return
 
-            if existing_job and req.notebook_id and not existing_job.notebook_id:
-                existing_job.notebook_id = req.notebook_id
-            notebook_id = req.notebook_id or (existing_job.notebook_id if existing_job else "")
-
             success = self.device_manager.start_job(req.job_id)
             if not success:
                 logger.error(f"[MessageProcessor] Failed to start job {job_log}")
@@ -822,7 +795,6 @@ class MessageProcessor:
                 action_name=req.action,
                 task_id=req.task_id,
                 job_id=req.job_id,
-                notebook_id=notebook_id,
                 device_action_key=device_action_key,
             )
 
@@ -862,7 +834,6 @@ class MessageProcessor:
                             "job_id": req.job_id,
                             "task_id": req.task_id,
                             "device_id": req.device_id,
-                            "notebook_id": queue_item.notebook_id,
                             "action_name": req.action,
                             "status": "failed",
                             "feedback_data": {},
@@ -884,7 +855,6 @@ class MessageProcessor:
                             "query_action_status",
                             True,
                             0,
-                            notebook_id=next_job.notebook_id,
                         )
                         next_job_log = format_job_log(
                             next_job.job_id, next_job.task_id, next_job.device_id, next_job.action_name
@@ -1034,16 +1004,11 @@ class MessageProcessor:
 
                     success = host_node.notify_resource_tree_update(dev_id, act, item_list)
 
-                    if success is True:
+                    if success:
                         logger.info(
                             f"[MessageProcessor] Resource tree {act} completed for device {dev_id}, "
                             f"items: {len(item_list)}"
                         )
-                    elif success is None:
-                        logger.info(
-                            f"[MessageProcessor] Resource tree {act} skipped for device {dev_id}: "
-                            "在线增加设备暂不支持"
-                        )
                     else:
                         logger.warning(f"[MessageProcessor] Resource tree {act} failed for device {dev_id}")
 
@@ -1067,11 +1032,6 @@ class MessageProcessor:
 
         for item in device_list:
             target_node_id = item.get("target_node_id", "host_node")
-            if action == "add":
-                logger.info(
-                    f"[DeviceManage] 在线增加设备暂不支持，跳过 add_device: {item.get('id', '')}"
-                )
-                continue
 
             def _notify(target_id: str, act: str, cfg: ResourceDictType):
                 try:
@@ -1141,15 +1101,7 @@ class MessageProcessor:
         logger.info(f"[MessageProcessor] Restart cleanup scheduled")
 
     async def _send_action_state_response(
-        self,
-        device_id: str,
-        action_name: str,
-        task_id: str,
-        job_id: str,
-        typ: str,
-        free: bool,
-        need_more: int,
-        notebook_id: str = "",
+        self, device_id: str, action_name: str, task_id: str, job_id: str, typ: str, free: bool, need_more: int
     ):
         """发送动作状态响应"""
         message = {
@@ -1160,7 +1112,6 @@ class MessageProcessor:
                 "action_name": action_name,
                 "task_id": task_id,
                 "job_id": job_id,
-                "notebook_id": notebook_id,
                 "free": free,
                 "need_more": need_more + 1,
             },
@@ -1243,7 +1194,6 @@ class QueueProcessor:
                             action_name=timeout_job.action_name,
                             task_id=timeout_job.task_id,
                             job_id=timeout_job.job_id,
-                            notebook_id=timeout_job.notebook_id,
                             device_action_key=timeout_job.device_action_key,
                         )
                         # 发布超时失败状态，这会触发正常的job完成流程
@@ -1302,7 +1252,6 @@ class QueueProcessor:
                     "action_name": job_info.action_name,
                     "task_id": job_info.task_id,
                     "job_id": job_info.job_id,
-                    "notebook_id": job_info.notebook_id,
                     "free": False,
                     "need_more": 10 + 1,
                 },
@@ -1342,7 +1291,6 @@ class QueueProcessor:
                     "action_name": job_info.action_name,
                     "task_id": job_info.task_id,
                     "job_id": job_info.job_id,
-                    "notebook_id": job_info.notebook_id,
                     "free": False,
                     "need_more": 10 + 1,
                 },
@@ -1388,15 +1336,12 @@ class QueueProcessor:
                     "action_name": next_job.action_name,
                     "task_id": next_job.task_id,
                     "job_id": next_job.job_id,
-                    "notebook_id": next_job.notebook_id,
                     "free": True,
                     "need_more": 0,
                 },
             }
             self.message_processor.send_message(message)
-            # next_job_log = format_job_log(
-            #     next_job.job_id, next_job.task_id, next_job.device_id, next_job.action_name
-            # )
+            # next_job_log = format_job_log(next_job.job_id, next_job.task_id, next_job.device_id, next_job.action_name)
             # logger.debug(f"[QueueProcessor] Notified next job {next_job_log} can start")
 
             # 立即触发下一轮状态检查
@@ -1565,7 +1510,6 @@ class WebSocketClient(BaseCommunicationClient):
                 "job_id": item.job_id,
                 "task_id": item.task_id,
                 "device_id": item.device_id,
-                "notebook_id": item.notebook_id,
                 "action_name": item.action_name,
                 "status": status,
                 "feedback_data": feedback_data,

unilabos/devices/workstation/bioyond_studio/bioyond_rpc.py

@@ -779,6 +779,49 @@ class BioyondV1RPC(BaseRequest):
 
         return response.get("data", {})
 
+    def take_out(
+        self,
+        order_id: str,
+        preintake_ids: list[str] | None = None,
+        material_ids: list[str] | None = None,
+    ) -> dict:
+        """取出订单关联通量/物料
+
+        参数:
+            order_id: 订单ID
+            preintake_ids: 通量ID列表，可为空
+            material_ids: 物料ID列表，可为空
+
+        返回值:
+            dict: 服务端响应包，失败返回空字典
+        """
+        if not order_id:
+            self._logger.error("取出订单关联通量/物料错误: 缺少订单ID")
+            return {}
+
+        params = {
+            "orderId": order_id,
+            "preintakeIds": list(preintake_ids or []),
+            "materialIds": list(material_ids or []),
+        }
+
+        response = self.post(
+            url=f'{self.host}/api/lims/order/take-out',
+            params={
+                "apiKey": self.api_key,
+                "requestTime": self.get_current_time_iso8601(),
+                "data": params,
+            })
+
+        if not response:
+            return {}
+
+        if response['code'] != 1:
+            self._logger.error(f"取出订单关联通量/物料错误: {response.get('message', '')}")
+            return response
+
+        return response
+
     def cancel_order(self, json_str: str) -> bool:
         """取消指定任务
 

unilabos/devices/workstation/bioyond_studio/debug_call_log.py

@@ -0,0 +1,459 @@
+"""Per-action raw call/response log for Bioyond stations.
+
+When a debug session is active, ``wrap_rpc_http`` replaces a ``BioyondV1RPC``
+instance's ``post`` / ``get`` methods with closures that perform the HTTP
+transport themselves, capture the request/response details, and append a record
+to the active session before returning exactly what ``BaseRequest`` would have
+returned. Outside of an active session the wrapped method delegates to the
+original (unwrapped) implementation, leaving non-debug behavior intact.
+
+The session writes a Markdown file under ``out_dir`` mirroring the format of
+``bioyond_debug_records/2026-04-30_160316_day3_samplefile_only_raw_calls.md``
+minus the "Raw Payload Argument" section.
+
+This module has no dependency on ``BioyondV1RPC`` itself; the only contract is
+that the wrapped instance descends from ``BaseRequest`` (i.e. has a logger
+returned by ``self.get_logger()``).
+"""
+
+from __future__ import annotations
+
+import contextvars
+import copy
+import inspect
+import json
+import re
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Iterator, List, Optional
+
+import requests
+
+__all__ = [
+    "CallRecord",
+    "CallLogContext",
+    "session",
+    "wrap_rpc_http",
+    "active_session",
+]
+
+
+_DEFAULT_TIMEOUT_GET = 30
+_DEFAULT_TIMEOUT_POST = 120
+
+
+@dataclass
+class CallRecord:
+    """One captured HTTP call inside a debug session."""
+
+    index: int
+    method: str
+    url: str
+    path: str
+    source: str
+    transport: str
+    http_status: Optional[int]
+    request_body: Any
+    response_body: Any
+    error: Optional[str] = None
+
+
+@dataclass
+class CallLogContext:
+    """State for a single ``session()`` block.
+
+    A session lazily creates its file on the first appended record. Actions
+    that abort before any RPC produce no file.
+    """
+
+    action: str
+    out_dir: Path
+    started_at: datetime
+    calls: List[CallRecord] = field(default_factory=list)
+    file_path: Optional[Path] = None
+
+    def append(self, record: CallRecord) -> None:
+        record.index = len(self.calls) + 1
+        self.calls.append(record)
+        self._write_file()
+
+    # -- file I/O -------------------------------------------------------------
+
+    def _resolve_file_path(self) -> Path:
+        if self.file_path is not None:
+            return self.file_path
+        timestamp = self.started_at.strftime("%Y-%m-%d_%H%M%S")
+        slug = _slugify_action(self.action)
+        candidate = self.out_dir / f"{timestamp}_{slug}_raw_calls.md"
+        suffix = 2
+        while candidate.exists():
+            candidate = (
+                self.out_dir
+                / f"{timestamp}_{slug}_raw_calls_{suffix:02d}.md"
+            )
+            suffix += 1
+        self.file_path = candidate
+        return self.file_path
+
+    def _write_file(self) -> None:
+        path = self._resolve_file_path()
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(_render_markdown(self), encoding="utf-8")
+
+
+_active_session: contextvars.ContextVar[Optional[CallLogContext]] = (
+    contextvars.ContextVar("_active_session", default=None)
+)
+
+
+def active_session() -> Optional[CallLogContext]:
+    """Return the currently active :class:`CallLogContext`, if any."""
+    return _active_session.get()
+
+
+@contextmanager
+def session(action: str, out_dir: Path) -> Iterator[CallLogContext]:
+    """Open a per-action debug session.
+
+    On entry, sets the module-level ``_active_session`` ContextVar so any
+    ``wrap_rpc_http``'d clients on the same thread/task record their calls.
+    On exit, the previous active session (if any) is restored.
+    """
+    ctx = CallLogContext(
+        action=str(action),
+        out_dir=Path(out_dir),
+        started_at=datetime.now(),
+    )
+    token = _active_session.set(ctx)
+    try:
+        yield ctx
+    finally:
+        _active_session.reset(token)
+
+
+def wrap_rpc_http(rpc: Any) -> None:
+    """Idempotently wrap ``rpc.post`` / ``rpc.get``.
+
+    When a session is active (``_active_session.get() is not None``), the
+    wrapped methods perform the HTTP call themselves with ``requests`` and
+    record the call before returning the same value ``BaseRequest`` would have
+    returned. When no session is active, the wrapped methods delegate to the
+    original implementation, preserving stock ``BaseRequest`` behavior.
+
+    Calling this twice on the same instance is a no-op. The wrapper does not
+    alter ``rpc.form_post`` (no Sirna action calls it as of plan 3).
+    """
+    if rpc is None:
+        return
+    if getattr(rpc, "_debug_call_log_wrapped", False):
+        return
+
+    rpc._orig_post = rpc.post
+    rpc._orig_get = rpc.get
+
+    def _wrapped_post(
+        url: str,
+        params: Any = None,
+        files: Any = None,
+        headers: Optional[dict] = None,
+    ) -> Any:
+        ctx = _active_session.get()
+        if ctx is None:
+            kwargs = {}
+            if params is not None:
+                kwargs["params"] = params
+            if files is not None:
+                kwargs["files"] = files
+            if headers is not None:
+                kwargs["headers"] = headers
+            return rpc._orig_post(url, **kwargs)
+        effective_params = params if params is not None else {}
+        effective_headers = (
+            headers
+            if headers is not None
+            else {"Content-Type": "application/json"}
+        )
+        source = _detect_source(rpc)
+        request_body = _redact(effective_params)
+        record = CallRecord(
+            index=0,
+            method="POST",
+            url=str(url),
+            path=_url_path(url),
+            source=source,
+            transport=_pick_transport(effective_params),
+            http_status=None,
+            request_body=request_body,
+            response_body=None,
+            error=None,
+        )
+        return_value: Any = None
+        try:
+            response = requests.post(
+                url,
+                data=json.dumps(effective_params) if effective_params else None,
+                headers=effective_headers,
+                timeout=_DEFAULT_TIMEOUT_POST,
+                files=files,
+            )
+        except Exception as exc:  # pragma: no cover - delegated to logger
+            record.error = f"transport error: {exc}"
+            try:
+                rpc.get_logger().error(f"Request ERROR: {exc}")
+            except Exception:
+                pass
+            ctx.append(record)
+            return None
+
+        record.http_status = response.status_code
+        record.response_body, parse_error = _decode_response_body(response)
+        try:
+            rpc.get_logger().debug(
+                f"Request >>> : {response.request.body} "
+                f"{response.status_code} {response.text}"
+            )
+        except Exception:
+            pass
+
+        if response.status_code == 200:
+            if parse_error is not None:
+                record.error = f"json parse error: {parse_error}"
+                return_value = None
+            else:
+                return_value = record.response_body
+        else:
+            record.error = f"HTTP {response.status_code}: {response.text}"
+            try:
+                rpc.get_logger().error(
+                    f"Request ERROR: ('Request ERROR:', {response.text!r})"
+                )
+            except Exception:
+                pass
+            return_value = None
+
+        ctx.append(record)
+        return return_value
+
+    def _wrapped_get(
+        url: str,
+        params: Any = None,
+        headers: Optional[dict] = None,
+    ) -> Any:
+        ctx = _active_session.get()
+        if ctx is None:
+            kwargs = {}
+            if params is not None:
+                kwargs["params"] = params
+            if headers is not None:
+                kwargs["headers"] = headers
+            return rpc._orig_get(url, **kwargs)
+        effective_params = params if params is not None else {}
+        effective_headers = (
+            headers
+            if headers is not None
+            else {"Content-Type": "application/json"}
+        )
+        source = _detect_source(rpc)
+        request_body = _redact(effective_params)
+        record = CallRecord(
+            index=0,
+            method="GET",
+            url=str(url),
+            path=_url_path(url),
+            source=source,
+            transport="params",
+            http_status=None,
+            request_body=request_body,
+            response_body=None,
+            error=None,
+        )
+        return_value: Any = None
+        try:
+            response = requests.get(
+                url,
+                params=effective_params,
+                headers=effective_headers,
+                timeout=_DEFAULT_TIMEOUT_GET,
+            )
+        except Exception as exc:  # pragma: no cover - delegated to logger
+            record.error = f"transport error: {exc}"
+            try:
+                rpc.get_logger().error(f"Request ERROR: {exc}")
+            except Exception:
+                pass
+            ctx.append(record)
+            return None
+
+        record.http_status = response.status_code
+        record.response_body, parse_error = _decode_response_body(response)
+        try:
+            rpc.get_logger().debug(
+                f"Request >>> : {effective_params} "
+                f"{response.status_code} {response.text}"
+            )
+        except Exception:
+            pass
+
+        if response.status_code == 200:
+            if parse_error is not None:
+                record.error = f"json parse error: {parse_error}"
+                return_value = None
+            else:
+                return_value = record.response_body
+
+        ctx.append(record)
+        return return_value
+
+    rpc.post = _wrapped_post
+    rpc.get = _wrapped_get
+    rpc._debug_call_log_wrapped = True
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+_URL_PATH_RE = re.compile(r"https?://[^/]+(/.*)?$")
+_SLUG_RE = re.compile(r"[^A-Za-z0-9._-]+")
+
+
+def _slugify_action(action: str) -> str:
+    slug = _SLUG_RE.sub("_", str(action)).strip("_")
+    return slug or "action"
+
+
+def _url_path(url: Any) -> str:
+    text = str(url or "")
+    match = _URL_PATH_RE.match(text)
+    if match and match.group(1):
+        return match.group(1)
+    if text.startswith("/"):
+        return text
+    return text
+
+
+def _pick_transport(params: Any) -> str:
+    if isinstance(params, dict) and "data" in params:
+        return "data"
+    return "params"
+
+
+def _detect_source(rpc: Any) -> str:
+    """Walk the call stack to find the outermost frame whose ``self`` is rpc."""
+    try:
+        stack = inspect.stack()
+    except Exception:
+        return ""
+    candidate = ""
+    try:
+        for frame_info in stack:
+            frame = frame_info.frame
+            if frame.f_locals.get("self", None) is rpc:
+                candidate = frame_info.function
+        return candidate
+    finally:
+        del stack
+
+
+def _redact(params: Any) -> Any:
+    """Return a copy of ``params`` with ``apiKey`` redacted."""
+    try:
+        cloned = copy.deepcopy(params)
+    except Exception:
+        return params
+    _redact_in_place(cloned)
+    return cloned
+
+
+def _redact_in_place(value: Any) -> None:
+    if isinstance(value, dict):
+        for key in list(value.keys()):
+            if isinstance(key, str) and key.lower() == "apikey":
+                value[key] = "<redacted>"
+            else:
+                _redact_in_place(value[key])
+    elif isinstance(value, list):
+        for item in value:
+            _redact_in_place(item)
+
+
+def _decode_response_body(response: Any) -> tuple[Any, Optional[str]]:
+    """Best-effort response decoding used for both record + return value."""
+    text = getattr(response, "text", "")
+    try:
+        return response.json(), None
+    except Exception as exc:
+        if text:
+            return {"raw_text": text}, str(exc)
+        return None, str(exc)
+
+
+# ---------------------------------------------------------------------------
+# Markdown rendering
+# ---------------------------------------------------------------------------
+
+
+def _render_markdown(ctx: CallLogContext) -> str:
+    title = f"# {ctx.action} Raw Call/Response Log"
+    parts: List[str] = [title, ""]
+    parts.append("## LIMS Calls")
+    parts.append("")
+    parts.append("| # | Method | Path | Source | HTTP |")
+    parts.append("|---|---|---|---|---|")
+    for record in ctx.calls:
+        anchor = _row_anchor(record)
+        http = (
+            f"`{record.http_status}`"
+            if record.http_status is not None
+            else "`-`"
+        )
+        parts.append(
+            f"| [{record.index}](#{anchor}) | `{record.method}` | "
+            f"`{record.path}` | `{record.source}` | {http} |"
+        )
+    parts.append("")
+
+    for record in ctx.calls:
+        parts.append(f"## {record.index} {record.method} {record.path}")
+        parts.append("")
+        parts.append(f"- Source: `{record.source}`")
+        parts.append(f"- Transport: `{record.transport}`")
+        if record.http_status is not None:
+            parts.append(f"- HTTP status: `{record.http_status}`")
+        else:
+            parts.append("- HTTP status: `-`")
+        if record.error:
+            parts.append(f"- Error: {record.error}")
+        parts.append("")
+        parts.append("### Request Body")
+        parts.append("")
+        parts.append("```json")
+        parts.append(_to_json_block(record.request_body))
+        parts.append("```")
+        parts.append("")
+        parts.append("### Response Body")
+        parts.append("")
+        parts.append("```json")
+        parts.append(_to_json_block(record.response_body))
+        parts.append("```")
+        parts.append("")
+
+    return "\n".join(parts).rstrip() + "\n"
+
+
+def _row_anchor(record: CallRecord) -> str:
+    """Build a GitHub-style anchor matching ``## N METHOD /path``."""
+    raw = f"{record.index}-{record.method}-{record.path}"
+    raw = raw.lower()
+    raw = re.sub(r"[^a-z0-9]+", "-", raw)
+    return raw.strip("-")
+
+
+def _to_json_block(value: Any) -> str:
+    try:
+        return json.dumps(value, ensure_ascii=False, indent=2, sort_keys=True)
+    except TypeError:
+        return json.dumps(str(value), ensure_ascii=False, indent=2)

unilabos/devices/workstation/bioyond_studio/peptide_station/__init__.py

@@ -0,0 +1,3 @@
+from .peptide_station import BioyondPeptideStation, fetch_workflow_list, load_peptide_config
+
+__all__ = ["BioyondPeptideStation", "fetch_workflow_list", "load_peptide_config"]

unilabos/devices/workstation/bioyond_studio/peptide_station/tests/test_peptide_station_contracts.py

@@ -0,0 +1,681 @@
+"""多肽站 AST/参数/结果表 离线契约测试。"""
+
+from __future__ import annotations
+
+import importlib
+import inspect
+import json
+import sys
+from pathlib import Path
+from typing import Any, Dict, List
+from unittest.mock import MagicMock
+
+import pytest
+
+REPO_ROOT = Path(__file__).resolve().parents[6]
+if str(REPO_ROOT) not in sys.path:
+    sys.path.insert(0, str(REPO_ROOT))
+
+MODULE_PATH = "unilabos.devices.workstation.bioyond_studio.peptide_station.peptide_station"
+CLASS_NAME = "BioyondPeptideStation"
+
+ORDER_GUID = "3a20eabe-bad5-ef95-49bd-7ffbd5df189d"
+CREATE_ALLOCATION = {
+    ORDER_GUID: [
+        {
+            "materialId": "mat-tip",
+            "materialName": "200μL枪头盒",
+            "materialCode": "0008-00105",
+            "quantity": "1个",
+            "materialTypeMode": "Consumables",
+            "locationCode": "1-01",
+            "locationShowName": "1-01",
+        },
+        {
+            "materialId": "mat-plate",
+            "materialName": "96孔板",
+            "materialCode": "PLATE-96",
+            "quantity": "1",
+            "materialTypeMode": "Sample",
+            "locationCode": "A1",
+            "locationShowName": "A1-show",
+        },
+        {
+            "materialId": "mat-extra",
+            "materialName": "未知耗材",
+            "materialCode": "X-1",
+            "quantity": "2",
+            "materialTypeMode": "Future",
+            "locationCode": "Z9",
+            "locationShowName": "",
+        },
+    ]
+}
+
+FLATTENED_LIVE = [
+    {"step": "39c78d4b-b5d3-f721-2001-9d52000084c3", "step_name": "S1", "Key": "SampleFile", "m": 0, "n": 0, "Value": "", "DisplayValue": "", "TaskDisplayable": 1},
+    {"step": "39c78d4b-b5d3-f721-2001-9d52000084c3", "step_name": "S1", "Key": "Example", "m": 0, "n": 0, "Value": "x", "DisplayValue": "x", "TaskDisplayable": 1},
+    {"step": "39c78d4b-b5d3-f721-2001-9d52000084c4", "step_name": "S2", "Key": "protocol", "m": 14, "n": 28, "Value": "", "DisplayValue": "", "TaskDisplayable": 1},
+    {"step": "39c78d4b-b5d3-f721-2001-9d52000084c5", "step_name": "S3", "Key": "CEMMethodFileName", "m": 0, "n": 0, "Value": "", "DisplayValue": "", "TaskDisplayable": 1},
+]
+
+
+def _import_module() -> Any:
+    return importlib.import_module(MODULE_PATH)
+
+
+def _make_station() -> Any:
+    module = _import_module()
+    cls = getattr(module, CLASS_NAME)
+    station = object.__new__(cls)
+    station.bioyond_config = {"api_host": "http://test", "api_key": "k", "warehouse_mapping": {}}
+    rpc = MagicMock()
+    rpc.host = "http://test"
+    rpc.api_key = "k"
+    rpc.material_info.return_value = {"locations": [{"whName": "自动化堆栈", "code": "1-01"}]}
+    station.hardware_interface = rpc
+    return station
+
+
+# ---------------------------------------------------------------------------
+# 1. AST/导入面
+# ---------------------------------------------------------------------------
+
+
+def test_required_actions_exposed() -> None:
+    cls = getattr(_import_module(), CLASS_NAME)
+    required = {
+        "upload_sample_excel",
+        "list_sample_excels",
+        "get_step_parameters",
+        "submit_experiment",
+        "submit_experiment_day1",
+        "submit_experiment_day2",
+        "submit_experiment_day3",
+        "submit_experiment_day4",
+        "submit_experiment_day4_LCMS",
+        "start_experiment",
+        "reset",
+        "scheduler_start",
+        "scheduler_stop",
+        "scheduler_pause",
+        "scheduler_continue",
+        "get_order_list",
+        "get_order_report",
+        "get_aggregated_order_report",
+    }
+    have = {name for name, _ in inspect.getmembers(cls, inspect.isfunction)}
+    missing = sorted(required - have)
+    assert not missing, f"缺少动作: {missing}"
+
+
+def test_manual_confirm_node_types() -> None:
+    module = _import_module()
+    cls = getattr(module, CLASS_NAME)
+    manual = {"submit_experiment_day1", "start_experiment"}
+    normal = {
+        "submit_experiment",
+        "submit_experiment_day2",
+        "submit_experiment_day3",
+        "submit_experiment_day4",
+        "submit_experiment_day4_LCMS",
+        "reset",
+        "scheduler_start",
+        "list_sample_excels",
+        "get_step_parameters",
+        "get_order_list",
+        "get_order_report",
+    }
+    for name in manual:
+        meta = getattr(getattr(cls, name), "_action_registry_meta", {})
+        assert meta.get("node_type") == module.NodeType.MANUAL_CONFIRM, name
+    for name in normal:
+        meta = getattr(getattr(cls, name), "_action_registry_meta", {})
+        assert meta.get("node_type") != module.NodeType.MANUAL_CONFIRM, name
+
+
+def test_submit_and_reset_signatures_exclude_legacy_manual_confirm() -> None:
+    cls = getattr(_import_module(), CLASS_NAME)
+    for name in (
+        "submit_experiment",
+        "submit_experiment_day2",
+        "submit_experiment_day3",
+        "submit_experiment_day4",
+        "submit_experiment_day4_LCMS",
+        "reset",
+    ):
+        params = inspect.signature(getattr(cls, name)).parameters
+        assert "timeout_seconds" not in params, name
+        assert "assignee_user_ids" not in params, name
+
+
+def test_day1_submit_accepts_manual_confirm_kwargs() -> None:
+    """plan: Day1 是 MANUAL_CONFIRM；框架会注入 timeout_seconds/assignee_user_ids，函数必须能接收。"""
+    cls = getattr(_import_module(), CLASS_NAME)
+    sig = inspect.signature(cls.submit_experiment_day1)
+    has_kwargs = any(p.kind == inspect.Parameter.VAR_KEYWORD for p in sig.parameters.values())
+    assert has_kwargs, "submit_experiment_day1 必须有 **kwargs 以容纳人工确认框架字段"
+
+
+def test_typed_dicts_present() -> None:
+    module = _import_module()
+    for cls_name in (
+        "PeptideGenericSubmitRequiredParams",
+        "PeptideGenericSubmitOptionalParams",
+        "PeptideDay1RequiredParams",
+        "PeptideDay1OptionalParams",
+        "PeptideDay2RequiredParams",
+        "PeptideDay2OptionalParams",
+        "PeptideDay3RequiredParams",
+        "PeptideDay3OptionalParams",
+        "PeptideDay4RequiredParams",
+        "PeptideDay4OptionalParams",
+        "PeptideDay4LCMSRequiredParams",
+        "PeptideDay4LCMSOptionalParams",
+    ):
+        assert hasattr(module, cls_name), cls_name
+
+
+def test_workflow_constants_split() -> None:
+    module = _import_module()
+    assert module.DAY4_PEPTIDE_WORKFLOW_NAME == "Day4环肽酰化-酶标"
+    assert module.DAY4_LCMS_PEPTIDE_WORKFLOW_NAME == "Day4环肽酰化-酶标+LCMS"
+    assert module.DAY_WORKFLOW_BINDINGS["day4_lcms"]["sub_name"] == "Day4环肽酰化-酶标LCMS"
+    assert module.DAY1_CEM_METHOD_DEFAULT == "5microdouble-20250911.MPM"
+
+
+# ---------------------------------------------------------------------------
+# 2. Sample Excel
+# ---------------------------------------------------------------------------
+
+
+def test_list_sample_excels_modes() -> None:
+    station = _make_station()
+    records = [
+        {"fileName": "DPR019-a.xlsx", "relativePath": "upload\\sample\\DPR019-a.xlsx"},
+        {"fileName": "DPR019-b.xlsx", "relativePath": "upload\\sample\\DPR019-b.xlsx"},
+    ]
+    station._list_sample_excels = MagicMock(return_value=records)  # type: ignore[method-assign]
+
+    info = station.list_sample_excels(sample_excel_pattern="DPR019-a", deterministic_resolve=False)
+    assert "sample_excel_data" in info
+    assert "sample_excel_relative_path" not in info
+
+    resolved = station.list_sample_excels(sample_excel_pattern="DPR019-a", deterministic_resolve=True)
+    assert resolved["sample_excel_relative_path"] == "upload\\sample\\DPR019-a.xlsx"
+
+    with pytest.raises(Exception):
+        station.list_sample_excels(sample_excel_pattern="DPR019", deterministic_resolve=True)
+
+
+def test_resolve_submit_sample_file_direct_path() -> None:
+    station = _make_station()
+    relative, selected = station._resolve_submit_sample_file({}, {}, "upload/sample/x.xlsx")
+    assert relative == "upload\\sample\\x.xlsx"
+    assert selected["fileName"] == "x.xlsx"
+
+
+def test_filename_matches_pattern_substring_and_glob() -> None:
+    station = _make_station()
+    assert station._filename_matches_pattern("DPR019-20260421-thrombin-5.xlsx", "DPR019")
+    assert station._filename_matches_pattern("a.xlsx", "*.xlsx")
+    assert not station._filename_matches_pattern("a.xlsx", "*.docx")
+    assert station._filename_matches_pattern("a.xlsx", "")
+
+
+# ---------------------------------------------------------------------------
+# 3. Step parameter helper
+# ---------------------------------------------------------------------------
+
+
+def test_filter_step_parameters_preserves_zero_and_skips_unknown() -> None:
+    station = _make_station()
+    records = [
+        {"TaskDisplayable": 1, "Value": 0, "DisplayValue": ""},
+        {"TaskDisplayable": 1, "Value": "", "DisplayValue": ""},
+        {"TaskDisplayable": 0, "Value": "", "DisplayValue": ""},
+        {"TaskDisplayable": None, "Value": "", "DisplayValue": ""},
+    ]
+    filtered = station._filter_step_parameter_records(records, True, True, True)
+    assert {(r.get("Value"), r.get("TaskDisplayable")) for r in filtered} == {(0, 1), ("", 1), ("", 0)}
+
+
+def test_get_step_parameters_zero_match_returns_status() -> None:
+    station = _make_station()
+    station._query_workflow_records = MagicMock(return_value=[])  # type: ignore[method-assign]
+    out = station.get_step_parameters(workflow_name_filter="不存在")
+    status = out["step_parameters_raw_json"]
+    assert status.get("code") == -1
+    assert out["filtered_subworkflows"] == []
+
+
+def test_get_step_parameters_multi_match_returns_status() -> None:
+    station = _make_station()
+    station._query_workflow_records = MagicMock(return_value=[  # type: ignore[method-assign]
+        {"workflowId": "w1", "workflowName": "A", "subworkflowId": "s1", "subworkflowName": "A1"},
+        {"workflowId": "w1", "workflowName": "A", "subworkflowId": "s2", "subworkflowName": "A2"},
+    ])
+    out = station.get_step_parameters(workflow_name_filter="A")
+    assert out["step_parameters_raw_json"].get("code") == 0
+    assert len(out["filtered_subworkflows"]) == 2
+
+
+def test_get_step_parameters_direct_sub_workflow_id() -> None:
+    station = _make_station()
+    station._query_step_parameters = MagicMock(return_value={  # type: ignore[method-assign]
+        "39c78d4b-b5d3-f721-2001-9d52000084c3": [
+            {"name": "S1", "m": 0, "n": 0, "parameterList": [
+                {"Key": "SampleFile", "TaskDisplayable": 1, "Value": "", "DisplayValue": ""},
+            ]},
+        ]
+    })
+    out = station.get_step_parameters(sub_workflow_id="39c78d4b-b5d3-f721-2001-9d52000084c3")
+    augmented = out["step_parameters_raw_json"]
+    assert augmented["code"] == 1
+    assert any(p["Key"] == "SampleFile" for p in augmented["data"]["filteredParameters"])
+
+
+# ---------------------------------------------------------------------------
+# 4. Partial parameter entries + live resolution
+# ---------------------------------------------------------------------------
+
+
+def test_partial_entries_inject_samplefile_and_overrides() -> None:
+    station = _make_station()
+    entries, warnings = station._build_partial_parameter_entries(
+        sample_excel_relative_path="upload\\sample\\f.xlsx",
+        day_key="day2",
+        parameter_overrides=[{"Key": "Example", "Value": 0}],
+    )
+    assert entries[0] == {"Key": "SampleFile", "Value": "upload\\sample\\f.xlsx"}
+    assert any(e["Key"] == "Example" and e["Value"] == 0 for e in entries)
+    assert warnings == []
+
+
+def test_day1_partial_entries_inject_cem_default() -> None:
+    station = _make_station()
+    entries, _ = station._build_partial_parameter_entries(
+        sample_excel_relative_path="upload\\sample\\f.xlsx",
+        day_key="day1",
+        extra_autofill=[{"Key": "CEMMethodFileName", "Value": "5microdouble-20250911.MPM"}],
+    )
+    assert any(e["Key"] == "CEMMethodFileName" and e["Value"] == "5microdouble-20250911.MPM" for e in entries)
+
+
+def test_overrides_duplicate_last_write_wins_warning() -> None:
+    station = _make_station()
+    entries, warnings = station._build_partial_parameter_entries(
+        sample_excel_relative_path="x",
+        day_key="day2",
+        parameter_overrides=[
+            {"Key": "Example", "m": 0, "n": 0, "Value": "first"},
+            {"Key": "Example", "m": 0, "n": 0, "Value": "second"},
+        ],
+    )
+    example_entries = [e for e in entries if e["Key"] == "Example"]
+    assert len(example_entries) == 1
+    assert example_entries[0]["Value"] == "second"
+    assert any("重复" in w for w in warnings)
+
+
+def test_resolve_against_live_unique_match_and_failure() -> None:
+    station = _make_station()
+    resolved = station._resolve_parameter_entries_against_live_steps(
+        [{"Key": "SampleFile", "Value": "upload\\sample\\f.xlsx"}], FLATTENED_LIVE
+    )
+    assert resolved[0]["step"] == "39c78d4b-b5d3-f721-2001-9d52000084c3"
+    assert resolved[0]["m"] == 0 and resolved[0]["n"] == 0
+    # 没有 protocol 在 m/n=0/0 处 → 0 匹配
+    with pytest.raises(Exception) as exc:
+        station._resolve_parameter_entries_against_live_steps(
+            [{"Key": "protocol", "m": 0, "n": 0, "Value": "v"}], FLATTENED_LIVE
+        )
+    assert "0 条" in str(exc.value)
+
+
+def test_group_resolved_entries_uses_lowercase_keys() -> None:
+    station = _make_station()
+    grouped = station._group_resolved_entries_to_param_values([
+        {"step": "39c78d4b-b5d3-f721-2001-9d52000084c3", "Key": "SampleFile", "m": 0, "n": 0, "Value": "x"},
+    ])
+    step_entries = grouped["39c78d4b-b5d3-f721-2001-9d52000084c3"]
+    assert step_entries[0] == {"key": "SampleFile", "value": "x", "m": 0, "n": 0}
+
+
+def test_create_order_payload_shape() -> None:
+    station = _make_station()
+    payload = station._create_order_payload(
+        order_code="EXP260518-103000",
+        order_name="实验260518-103000",
+        sub_workflow_id="3a1d35f9-63ce-67d6-1784-9f6abcca4eda",
+        param_values={"39c78d4b-b5d3-f721-2001-9d52000084c3": [{"key": "SampleFile", "value": "x", "m": 0, "n": 0}]},
+        border_number=1,
+        extend_properties=None,
+    )
+    assert isinstance(payload, list) and len(payload) == 1
+    item = payload[0]
+    assert item["workFlowId"] == "3a1d35f9-63ce-67d6-1784-9f6abcca4eda"
+    assert item["paramValues"]
+    assert item["extendProperties"] == ""
+    assert item["borderNumber"] == 1
+
+
+def test_order_identity_format() -> None:
+    station = _make_station()
+    code, name = station._build_order_identity("day2")
+    assert code.startswith("EXP") and len(code) == 16  # EXP + YYMMDD-HHmmss
+    assert name.startswith("实验")
+    code2, name2 = station._build_order_identity("day2", "自定义")
+    assert name2 == "自定义"
+
+
+# ---------------------------------------------------------------------------
+# 5. Generic submit / day wrappers (含会抦住 BUG 1 的用例)
+# ---------------------------------------------------------------------------
+
+
+def _wire_submit_pipeline(station: Any) -> None:
+    station._resolve_workflow_binding_from_names = MagicMock(return_value={  # type: ignore[method-assign]
+        "workflow_name": "DAY2多肽定量",
+        "root_workflow_id": "3a1d35f0-9436-895b-2eda-039a5465275e",
+        "sub_workflow_id": "3a1d35f0-9f7e-c2c1-0bc0-8d94b81d90ca",
+        "sub_workflow_name": "DAY2多肽定量",
+        "raw": {},
+    })
+    station._resolve_workflow_binding = MagicMock(side_effect=lambda day_key: station._resolve_workflow_binding_from_names("DAY2多肽定量"))  # type: ignore[method-assign]
+    station._query_step_parameters = MagicMock(return_value={})  # type: ignore[method-assign]
+    station._flatten_step_parameters = MagicMock(return_value=FLATTENED_LIVE)  # type: ignore[method-assign]
+    station._create_order = MagicMock(return_value=json.dumps(CREATE_ALLOCATION))  # type: ignore[method-assign]
+
+
+def test_submit_experiment_generic_succeeds() -> None:
+    """plan §「Generic And Day 1 Submit」line 919-924；这条同时抦住 BUG 1（binding= 关键字）。"""
+    station = _make_station()
+    _wire_submit_pipeline(station)
+    result = station.submit_experiment(
+        {"workflow_name": "DAY2多肽定量", "sample_excel_pattern": ""},
+        {"parameter_overrides": []},
+        sample_excel_relative_path="upload/sample/f.xlsx",
+    )
+    assert result["success"] is True
+    assert result["order_id"] == ORDER_GUID
+    assert result["resultTable"]["tableName"] == "resultTable"
+
+
+def test_submit_experiment_rejects_day1_alias() -> None:
+    station = _make_station()
+    with pytest.raises(Exception):
+        station.submit_experiment(
+            {"workflow_name": "Day1线肽合成", "sample_excel_pattern": "x"},
+            {},
+            sample_excel_relative_path="upload/sample/f.xlsx",
+        )
+
+
+def test_submit_experiment_day2_calls_pipeline() -> None:
+    station = _make_station()
+    _wire_submit_pipeline(station)
+    result = station.submit_experiment_day2(
+        {"sample_excel_pattern": ""},
+        {"parameter_overrides": []},
+        sample_excel_relative_path="upload/sample/f.xlsx",
+    )
+    assert result["success"] is True
+    assert result["order_ids"] == [ORDER_GUID]
+    assert result["auto_register_materials"] is True
+    assert result["material_registration"]["status"] == "not_implemented"
+
+
+def test_day1_placeholder_does_not_call_create_order() -> None:
+    station = _make_station()
+    station._resolve_workflow_binding = MagicMock(return_value={  # type: ignore[method-assign]
+        "workflow_name": "Day1线肽合成",
+        "root_workflow_id": "rid",
+        "sub_workflow_id": "sid",
+        "sub_workflow_name": "Day1线肽合成",
+        "raw": {},
+    })
+    station._create_order = MagicMock(side_effect=AssertionError("Day1 不应触达 create_order"))  # type: ignore[method-assign]
+    out = station.submit_experiment_day1(
+        {"sample_excel_pattern": "", "cem_method_file_name": ""},
+        {},
+        sample_excel_relative_path="upload/sample/f.xlsx",
+        # 模拟人工确认框架注入的字段（这条会抦住 BUG 3）
+        timeout_seconds=3600,
+        assignee_user_ids=[],
+        materials_loaded=False,
+    )
+    assert out["status"] == "manual_confirm_placeholder"
+    assert out["cem_method_file_name"] == "5microdouble-20250911.MPM"
+    assert isinstance(out["partial_parameter_entries"], list)
+
+
+# ---------------------------------------------------------------------------
+# 6. Allocation map parsing + resultTable
+# ---------------------------------------------------------------------------
+
+
+def test_parse_allocation_map_extracts_order_id_and_groups() -> None:
+    station = _make_station()
+    parsed = station._parse_create_order_allocation_map(json.dumps(CREATE_ALLOCATION))
+    assert parsed["order_ids"] == [ORDER_GUID]
+    assert len(parsed["allocation_rows"]) == 3
+    assert set(parsed["materials_by_type"].keys()) == {"Consumables", "Sample", "Future"}
+
+
+def test_parse_allocation_map_handles_python_str_repr() -> None:
+    """RPC.create_order 返回的是 str(dict)，含单引号。"""
+    station = _make_station()
+    parsed = station._parse_create_order_allocation_map(str(CREATE_ALLOCATION))
+    assert parsed["order_ids"] == [ORDER_GUID]
+
+
+def test_parse_allocation_map_empty() -> None:
+    station = _make_station()
+    parsed = station._parse_create_order_allocation_map("{}")
+    assert parsed["allocation_rows"] == []
+    assert parsed["order_ids"] == []
+
+
+def test_build_result_table_order_and_columns() -> None:
+    station = _make_station()
+    parsed = station._parse_create_order_allocation_map(json.dumps(CREATE_ALLOCATION))
+    table = station._build_result_table(parsed["materials_by_type"])
+    assert table["tableName"] == "resultTable"
+    assert [c["key"] for c in table["columns"]] == ["whName", "locationCode", "materialName", "quantity"]
+    # 顺序：Sample → Consumables → Future（未知 mode 保留在末尾）
+    names = [row["materialName"] for row in table["data"]]
+    assert names == ["96孔板", "200μL枪头盒", "未知耗材"]
+    # locationShowName 优先 locationCode
+    assert table["data"][0]["locationCode"] == "A1-show"
+    assert table["data"][1]["locationCode"] == "1-01"
+
+
+def test_build_result_table_empty_returns_empty_data() -> None:
+    station = _make_station()
+    table = station._build_result_table({})
+    assert table["data"] == []
+    assert [c["key"] for c in table["columns"]] == ["whName", "locationCode", "materialName", "quantity"]
+
+
+def test_resolve_wh_name_handles_material_info_failure() -> None:
+    station = _make_station()
+    station.hardware_interface.material_info.side_effect = RuntimeError("HTTP 500")
+    cache: Dict[str, Dict[str, Any]] = {}
+    assert station._resolve_wh_name_by_material_id("mat-1", cache) == ""
+
+
+def test_submit_returns_warning_when_allocation_empty() -> None:
+    station = _make_station()
+    _wire_submit_pipeline(station)
+    station._create_order = MagicMock(return_value="{}")  # type: ignore[method-assign]
+    result = station.submit_experiment_day2(
+        {"sample_excel_pattern": ""},
+        {},
+        sample_excel_relative_path="upload/sample/f.xlsx",
+    )
+    assert "create_order_allocation_unavailable_for_result_table" in result["warnings"]
+
+
+# ---------------------------------------------------------------------------
+# 7. Reports + workflow records
+# ---------------------------------------------------------------------------
+
+
+def test_get_order_list_passes_json_string() -> None:
+    station = _make_station()
+    station.hardware_interface.order_query.return_value = {"items": [], "totalCount": 0}
+    station.get_order_list(filter_text="abc", page_count=10)
+    args, kwargs = station.hardware_interface.order_query.call_args
+    payload = json.loads(args[0])
+    assert payload["filter"] == "abc"
+    assert payload["pageCount"] == 10
+
+
+def test_get_order_report_calls_typed_rpc() -> None:
+    station = _make_station()
+    station.hardware_interface.order_report.return_value = {"id": ORDER_GUID, "name": "x", "preIntakes": [], "resultList": []}
+    out = station.get_order_report(ORDER_GUID)
+    station.hardware_interface.order_report.assert_called_once_with(ORDER_GUID)
+    assert out["success"] is True
+    assert out["summary"]["id"] == ORDER_GUID
+
+
+def test_get_aggregated_order_report_is_todo_placeholder() -> None:
+    station = _make_station()
+    out = station.get_aggregated_order_report(ORDER_GUID)
+    assert out["status"] == "not_implemented"
+
+
+def test_query_workflow_records_filters_unsaved_subworkflows() -> None:
+    station = _make_station()
+    station.hardware_interface.query_workflow.return_value = {
+        "items": [
+            {
+                "id": "rid",
+                "name": "Day3线肽环化",
+                "subWorkflows": [
+                    {"id": "saved-id", "name": "Day3线肽环化", "isSaved": True},
+                    {"id": "draft-id", "name": "Day3线肽环化-草稿", "isSaved": False},
+                ],
+            }
+        ]
+    }
+    records = station._query_workflow_records("Day3线肽环化")
+    assert [r["subworkflowId"] for r in records] == ["saved-id"]
+
+
+# ---------------------------------------------------------------------------
+# 8. Debug / fetch_workflow_list 守护
+# ---------------------------------------------------------------------------
+
+
+def test_module_fetch_workflow_list_is_debug_guarded() -> None:
+    module = _import_module()
+    assert module.DEBUG_CLI_ENABLED is False
+    with pytest.raises(AssertionError):
+        module.fetch_workflow_list(config={"api_host": "http://x", "api_key": "k"})
+
+
+def test_station_fetch_workflow_list_uses_rpc() -> None:
+    station = _make_station()
+    station.hardware_interface.query_workflow.return_value = {"items": [], "totalCount": 0}
+    station.fetch_workflow_list(filter_text="Day2")
+    args, _ = station.hardware_interface.query_workflow.call_args
+    payload = json.loads(args[0])
+    assert payload["filter"] == "Day2"
+    assert payload["includeDetail"] is True
+
+
+# ---------------------------------------------------------------------------
+# 9. start_experiment 装载闸门
+# ---------------------------------------------------------------------------
+
+
+def test_start_experiment_blocks_when_materials_not_loaded() -> None:
+    station = _make_station()
+    station.hardware_interface.scheduler_start.return_value = 1
+    with pytest.raises(RuntimeError):
+        station.start_experiment(
+            order_id=ORDER_GUID,
+            resultTable={"data": [{"materialName": "x"}]},
+            materials_loaded=False,
+        )
+
+
+def test_start_experiment_starts_when_table_empty() -> None:
+    station = _make_station()
+    station.hardware_interface.scheduler_start.return_value = 1
+    result = station.start_experiment(order_id=ORDER_GUID, resultTable={"data": []})
+    assert result["success"] is True
+    assert result["order_ids"] == [ORDER_GUID]
+
+
+# ---------------------------------------------------------------------------
+# 10. Reset
+# ---------------------------------------------------------------------------
+
+
+def test_reset_signature_drops_legacy_params_and_uses_literal() -> None:
+    """plan 调整：删除 dry_run/order_id/location_id；reset_operations 用 Literal 注解。"""
+    cls = getattr(_import_module(), CLASS_NAME)
+    sig = inspect.signature(cls.reset)
+    params = sig.parameters
+    for legacy in ("dry_run", "order_id", "location_id"):
+        assert legacy not in params, f"reset 不应再有 {legacy} 入参"
+    assert "reset_operations" in params
+    assert any(p.kind == inspect.Parameter.VAR_KEYWORD for p in params.values()), \
+        "reset 必须保留 **kwargs 以兜底 reset_order_id/reset_location_id"
+
+    annotation = params["reset_operations"].annotation
+    rendered = annotation if isinstance(annotation, str) else repr(annotation)
+    for op in ("scheduler_reset", "reset_order_status", "reset_location"):
+        assert op in rendered, f"reset_operations 的 Literal 必须包含 {op}"
+
+
+def test_reset_goal_default_contains_all_operations() -> None:
+    """像 sirna 一样，goal_default 默认勾选全部三个 reset 操作。"""
+    cls = getattr(_import_module(), CLASS_NAME)
+    meta = getattr(cls.reset, "_action_registry_meta", {})
+    goal_default = meta.get("goal_default") or {}
+    assert goal_default.get("reset_operations") == [
+        "scheduler_reset",
+        "reset_order_status",
+        "reset_location",
+    ]
+
+
+def test_reset_executes_typed_rpc_calls() -> None:
+    station = _make_station()
+    station.hardware_interface.scheduler_reset.return_value = 1
+    station.hardware_interface.reset_order_status.return_value = 1
+    station.hardware_interface.reset_location.return_value = 1
+    out = station.reset(
+        reset_operations=["scheduler_reset", "reset_order_status", "reset_location"],
+        reset_order_id=ORDER_GUID,
+        reset_location_id="loc-1",
+    )
+    station.hardware_interface.scheduler_reset.assert_called_once_with()
+    station.hardware_interface.reset_order_status.assert_called_once_with(ORDER_GUID)
+    station.hardware_interface.reset_location.assert_called_once_with("loc-1")
+    assert out["selected_operations"] == [
+        "scheduler_reset",
+        "reset_order_status",
+        "reset_location",
+    ]
+    assert len(out["executed_calls"]) == 3
+    assert out["skipped_operations"] == []
+
+
+def test_reset_skips_when_ids_missing() -> None:
+    """没有 order_id / location_id 时应该 skip 而不是抛错。"""
+    station = _make_station()
+    station.hardware_interface.scheduler_reset.return_value = 1
+    out = station.reset(
+        reset_operations=["scheduler_reset", "reset_order_status", "reset_location"],
+    )
+    station.hardware_interface.scheduler_reset.assert_called_once_with()
+    station.hardware_interface.reset_order_status.assert_not_called()
+    station.hardware_interface.reset_location.assert_not_called()
+    skipped_ops = {item["operation"] for item in out["skipped_operations"]}
+    assert skipped_ops == {"reset_order_status", "reset_location"}

unilabos/devices/workstation/bioyond_studio/station.py

@@ -7,6 +7,7 @@ Bioyond Workstation Implementation
 import time
 import traceback
 import threading
+from contextlib import contextmanager
 from datetime import datetime
 from typing import Dict, Any, List, Optional, Union
 import json
@@ -14,6 +15,7 @@ from pathlib import Path
 
 from unilabos.devices.workstation.workstation_base import WorkstationBase, ResourceSynchronizer
 from unilabos.devices.workstation.bioyond_studio.bioyond_rpc import BioyondV1RPC
+from unilabos.devices.workstation.bioyond_studio import debug_call_log
 from unilabos.registry.placeholder_type import ResourceSlot, DeviceSlot
 from unilabos.resources.warehouse import WareHouse
 from unilabos.utils.log import logger
@@ -54,13 +56,17 @@ class ConnectionMonitor:
     def _monitor_loop(self):
         while self._running:
             try:
-                # 使用 lightweight API 检查连接
-                # query_matial_type_list 是比较快的查询
-                start_time = time.time()
-                result = self.workstation.hardware_interface.material_type_list()
+                # 使用轻量级调度状态接口检查连接，避免启动时打印完整物料类型列表。
+                result = self.workstation.hardware_interface.scheduler_status()
 
                 status = "online" if result else "offline"
-                msg = "Connection established" if status == "online" else "Failed to get material type list"
+                if status == "online":
+                    msg = (
+                        f"Scheduler status={result.get('status')}, "
+                        f"hasTask={result.get('hasTask')}"
+                    )
+                else:
+                    msg = "Failed to get scheduler status"
 
                 if status != self._last_status:
                     logger.info(f"Bioyond连接状态变更: {self._last_status} -> {status}")
@@ -174,6 +180,8 @@ class BioyondResourceSynchronizer(ResourceSynchronizer):
                 logger.warning("从Bioyond获取的物料数据为空")
                 return False
 
+            self._update_material_cache_from_stock(all_bioyond_data)
+
             # 转换为UniLab格式
             unilab_resources = resource_bioyond_to_plr(
                 all_bioyond_data,
@@ -187,6 +195,29 @@ class BioyondResourceSynchronizer(ResourceSynchronizer):
             logger.error(f"从Bioyond同步物料数据失败: {e}")
             return False
 
+    def _update_material_cache_from_stock(self, materials: List[Dict[str, Any]]) -> None:
+        """用本次库存查询结果同步 RPC 的 name -> material id 缓存。"""
+        material_cache = getattr(self.bioyond_api_client, "material_cache", None)
+        if not isinstance(material_cache, dict):
+            return
+
+        before_count = len(material_cache)
+        for material in materials:
+            material_name = material.get("name")
+            material_id = material.get("id")
+            if material_name and material_id:
+                material_cache[material_name] = material_id
+
+            for detail_material in material.get("detail", []) or []:
+                detail_name = detail_material.get("name")
+                detail_id = detail_material.get("detailMaterialId") or detail_material.get("id")
+                if detail_name and detail_id:
+                    material_cache[detail_name] = detail_id
+
+        logger.debug(
+            f"已用Bioyond库存同步物料缓存: {before_count} -> {len(material_cache)}"
+        )
+
     def sync_to_external(self, resource: Any) -> bool:
         """将本地物料数据变更同步到Bioyond系统"""
         try:
@@ -678,6 +709,70 @@ class BioyondWorkstation(WorkstationBase):
     集成Bioyond物料管理的工作站实现
     """
 
+    # 子类（如 sirna / peptide）覆写以指定默认 raw-call 日志目录。
+    # 路径相对仓库根；为 None 时若 debug_log=True 仍会写入临时位置。
+    _DEBUG_LOG_DEFAULT_DIR: Optional[str] = None
+
+    def _create_bioyond_rpc(self, config: Dict[str, Any]) -> BioyondV1RPC:
+        """创建 Bioyond RPC 客户端并应用调试包装。
+
+        所有创建 ``BioyondV1RPC`` 的路径（饿汉初始化、Sirna 延迟初始化、
+        以及未来的前端重新配置路径）都应通过该 helper，
+        以确保 debug_log 包装与命名/日志策略保持一致。
+        """
+        rpc = BioyondV1RPC(config)
+        debug_call_log.wrap_rpc_http(rpc)
+        return rpc
+
+    def _set_hardware_interface(self, rpc: BioyondV1RPC) -> BioyondV1RPC:
+        """将已构造的 RPC 客户端设置到 ``self.hardware_interface``，并应用调试包装。"""
+        debug_call_log.wrap_rpc_http(rpc)
+        self.hardware_interface = rpc
+        return rpc
+
+    def _debug_log_resolved_dir(self) -> Path:
+        """解析 ``debug_log_dir`` 为绝对路径。"""
+        configured = (getattr(self, "bioyond_config", {}) or {}).get("debug_log_dir")
+        default_dir = getattr(self, "_DEBUG_LOG_DEFAULT_DIR", None)
+        candidate = configured or default_dir or "bioyond_debug_records"
+        path = Path(candidate)
+        if not path.is_absolute():
+            repo_root = Path(__file__).resolve().parents[4]
+            path = repo_root / path
+        return path
+
+    def _ensure_debug_log_state(self) -> None:
+        """从 ``self.bioyond_config`` 派生 ``_debug_log_enabled`` / ``_debug_log_dir``。
+
+        每次进入 ``_debug_call_session`` 时都重新解析，以兼容前端在运行时
+        修改 ``bioyond_config['debug_log']`` 或目录的场景；同时也容忍
+        子类（如 Sirna 延迟初始化）在 ``__init__`` 早期未触发本方法。
+        """
+        cfg = getattr(self, "bioyond_config", {}) or {}
+        self._debug_log_enabled = bool(cfg.get("debug_log"))
+        self._debug_log_dir = self._debug_log_resolved_dir()
+
+    @contextmanager
+    def _debug_call_session(self, action_name: str):
+        """在 action 体外加一层 debug 会话上下文。
+
+        - ``debug_log`` 关闭时是空上下文，开销为 0。
+        - ``debug_log`` 开启时进入 :func:`debug_call_log.session`，所有
+          已被 ``wrap_rpc_http`` 包装过的 RPC 客户端都会捕获本次 action
+          产生的 HTTP 调用并写入 Markdown 文件。
+
+        子类（如 ``end_experiment``、``manual_unload`` 等）可以直接在
+        action 体里以 ``with self._debug_call_session("action_name"):`` 包裹。
+        """
+        cfg = getattr(self, "bioyond_config", {}) or {}
+        enabled = bool(cfg.get("debug_log"))
+        if not enabled:
+            yield None
+            return
+        out_dir = BioyondWorkstation._debug_log_resolved_dir(self)
+        with debug_call_log.session(action_name, out_dir) as ctx:
+            yield ctx
+
     def _publish_task_status(
         self,
         task_id: str,
@@ -862,7 +957,7 @@ class BioyondWorkstation(WorkstationBase):
             self.bioyond_config = {}
             print("警告: 未提供 bioyond_config，请确保在 JSON 配置文件中提供完整配置")
 
-        self.hardware_interface = BioyondV1RPC(self.bioyond_config)
+        self.hardware_interface = self._create_bioyond_rpc(self.bioyond_config)
 
     def resource_tree_add(self, resources: List[ResourcePLR]) -> None:
         """添加资源到资源树并更新ROS节点
@@ -1338,11 +1433,7 @@ class BioyondWorkstation(WorkstationBase):
             if self.hardware_interface:
                 self.hardware_interface.scheduler_reset()
 
-            # 刷新物料缓存
-            if self.hardware_interface:
-                self.hardware_interface.refresh_material_cache()
-
-            # 重新同步资源
+            # 重新同步资源，并用同一次库存查询结果更新物料缓存
             if self.resource_synchronizer:
                 self.resource_synchronizer.sync_from_external()
 

unilabos/resources/bioyond/__init__.py

@@ -0,0 +1,9 @@
+try:
+    from . import peptide_materials  # noqa: F401  ensure @resource classes are importable for PLR deserialize
+except Exception:  # pragma: no cover - 允许轻量环境导入非资源辅助函数
+    peptide_materials = None  # type: ignore[assignment]
+
+try:
+    from . import sirna_materials  # noqa: F401  ensure @resource classes are importable for PLR deserialize
+except Exception:  # pragma: no cover - 允许轻量环境导入非资源辅助函数
+    sirna_materials = None  # type: ignore[assignment]

unilabos/resources/bioyond/decks.py

@@ -1,6 +1,8 @@
 from os import name
+
 from pylabrobot.resources import Deck, Coordinate, Rotation
 
+from unilabos.registry.decorators import resource
 from unilabos.resources.bioyond.YB_warehouses import (
     bioyond_warehouse_1x4x4,
     bioyond_warehouse_1x4x4_right,  # 新增：右侧仓库 (A05～D08)
@@ -23,6 +25,11 @@ from unilabos.resources.bioyond.YB_warehouses import (
 from unilabos.resources.bioyond.warehouses import (
     bioyond_warehouse_tipbox_storage_left,   # 新增：Tip盒堆栈(左)
     bioyond_warehouse_tipbox_storage_right,  # 新增：Tip盒堆栈(右)
+    bioyond_warehouse_sirna_automation_stack,
+    bioyond_warehouse_sirna_centrifuge_balance_plate_stack,
+    bioyond_warehouse_sirna_g3_liquid_handler,
+    bioyond_warehouse_numeric_stack,  # 新增：数字编码堆栈 (用于多肽站)
+    bioyond_warehouse_live_grid,
 )
 
 
@@ -101,6 +108,83 @@ class BIOYOND_PolymerPreparationStation_Deck(Deck):
         for warehouse_name, warehouse in self.warehouses.items():
             self.assign_child_resource(warehouse, location=self.warehouse_locations[warehouse_name])
 
+@resource(
+    id="BIOYOND_SirnaStation_Deck",
+    category=["deck"],
+    description="BIOYOND 小核酸工作站 Deck",
+    icon="配液站.webp",
+)
+class BIOYOND_SirnaStation_Deck(Deck):
+    WAREHOUSE_BIOYOND_AXIS = {
+        "G3移液站": "xy_col_row",
+        "自动化堆栈": "xy_col_row",
+        "离心机配平板堆栈": "xy_col_row",
+    }
+    WAREHOUSE_BIOYOND_KEY_AXIS = {
+        "G3移液站": "col_row",
+        "自动化堆栈": "col_row",
+        "离心机配平板堆栈": "col_row",
+    }
+    # Bioyond warehouse UUID -> 本地仓库名称 映射。
+    # 留空时由配置（station config 的 ``warehouse_bioyond_ids``）注入。
+    # graph 节点也可在 deck.config.warehouse_bioyond_ids 覆盖。
+    WAREHOUSE_BIOYOND_IDS: dict = {}
+
+    def __init__(
+        self,
+        name: str = "SirnaStation_Deck",
+        size_x: float = 2700.0,
+        size_y: float = 1080.0,
+        size_z: float = 1500.0,
+        category: str = "deck",
+        setup: bool = False,
+        warehouse_bioyond_ids: dict | None = None,
+        **kwargs,
+    ) -> None:
+        super().__init__(name=name, size_x=size_x, size_y=size_y, size_z=size_z)
+        # 按需写入实例级覆盖；保留默认空 mapping，避免改动模型常量。
+        self.warehouse_bioyond_ids: dict = dict(self.WAREHOUSE_BIOYOND_IDS)
+        if warehouse_bioyond_ids:
+            self.warehouse_bioyond_ids.update(warehouse_bioyond_ids)
+        if setup:
+            self.setup()
+
+    @classmethod
+    def deserialize(cls, data: dict, allow_marshal: bool = False):
+        if data.get("children") and data.get("setup") is True:
+            data = data.copy()
+            data["setup"] = False
+        result = super().deserialize(data, allow_marshal=allow_marshal)
+        result._ensure_sirna_warehouse_metadata()
+        return result
+
+    def _ensure_sirna_warehouse_metadata(self) -> None:
+        for child in getattr(self, "children", []):
+            name = getattr(child, "name", "")
+            axis = self.WAREHOUSE_BIOYOND_AXIS.get(name)
+            if axis and not hasattr(child, "bioyond_axis"):
+                child.bioyond_axis = axis
+            key_axis = self.WAREHOUSE_BIOYOND_KEY_AXIS.get(name)
+            if key_axis and not hasattr(child, "bioyond_key_axis"):
+                child.bioyond_key_axis = key_axis
+
+    def setup(self) -> None:
+        # Sirna 读接口 /api/storage/location/locations-by-type 返回完整固定堆栈清单。
+        # LIMS 在库物料接口仍使用相同的 自动化堆栈 名称和数字库位编码。
+        self.warehouses = {
+            "G3移液站": bioyond_warehouse_sirna_g3_liquid_handler(),
+            "自动化堆栈": bioyond_warehouse_sirna_automation_stack(),
+            "离心机配平板堆栈": bioyond_warehouse_sirna_centrifuge_balance_plate_stack(),
+        }
+        self.warehouse_locations = {
+            "G3移液站": Coordinate(0.0, 0.0, 0.0),
+            "自动化堆栈": Coordinate(220.0, 0.0, 0.0),
+            "离心机配平板堆栈": Coordinate(1740.0, 0.0, 0.0),
+        }
+
+        for warehouse_name, warehouse in self.warehouses.items():
+            self.assign_child_resource(warehouse, location=self.warehouse_locations[warehouse_name])
+
 class BIOYOND_YB_Deck(Deck):
     def __init__(
         self,
@@ -150,12 +234,207 @@ class BIOYOND_YB_Deck(Deck):
         for warehouse_name, warehouse in self.warehouses.items():
             self.assign_child_resource(warehouse, location=self.warehouse_locations[warehouse_name])
 
+@resource(
+    id="BIOYOND_PeptideStation_Deck",
+    category=["deck"],
+    description="BIOYOND 多肽工作站 Deck",
+    icon="preparation_station.webp",
+)
+class BIOYOND_PeptideStation_Deck(Deck):
+    WAREHOUSE_BIOYOND_AXIS = dict.fromkeys(
+        [
+            "自动化堆栈",
+            "低温冰箱仓库",
+            "Tecan移液站库",
+            "G3移液站库",
+            "IDOT移液站库",
+            "G3缓冲库",
+            "盖板缓冲库",
+            "配平板缓冲库",
+            "IDOT缓冲库",
+            "固相合成板底座缓冲位",
+            "离心机库位",
+            "热封膜机位",
+        ],
+        "xy_col_row",
+    )
+    WAREHOUSE_BIOYOND_KEY_AXIS = dict.fromkeys(WAREHOUSE_BIOYOND_AXIS, "col_row")
+
+    def __init__(
+        self,
+        name: str = "PeptideStation_Deck",
+        size_x: float = 2700.0,
+        size_y: float = 2000.0,
+        size_z: float = 1500.0,
+        category: str = "deck",
+        setup: bool = False
+    ) -> None:
+        super().__init__(name=name, size_x=size_x, size_y=size_y, size_z=size_z)
+        if setup:
+            self.setup()
+
+    @classmethod
+    def deserialize(cls, data: dict, allow_marshal: bool = False):
+        if data.get("children") and data.get("setup") is True:
+            data = data.copy()
+            data["setup"] = False
+            # 已有序列化子资源，跳过 setup 避免重复创建
+            result = super(BIOYOND_PeptideStation_Deck, cls).deserialize(data, allow_marshal=allow_marshal)
+        else:
+            result = super(BIOYOND_PeptideStation_Deck, cls).deserialize(data, allow_marshal=allow_marshal)
+        result._ensure_peptide_warehouse_metadata()
+        return result
+
+    def _ensure_peptide_warehouse_metadata(self) -> None:
+        for child in getattr(self, "children", []):
+            name = getattr(child, "name", "")
+            axis = self.WAREHOUSE_BIOYOND_AXIS.get(name)
+            if axis and not hasattr(child, "bioyond_axis"):
+                child.bioyond_axis = axis
+            key_axis = self.WAREHOUSE_BIOYOND_KEY_AXIS.get(name)
+            if key_axis and not hasattr(child, "bioyond_key_axis"):
+                child.bioyond_key_axis = key_axis
+
+    def _frontend_y_flipped_coordinate(self, display_x: float, display_y: float, child) -> Coordinate:
+        """把期望显示坐标转换为兼容前端 y 轴翻转的存储坐标。"""
+        return Coordinate(display_x, self.get_size_y() - display_y - child.get_size_y(), 0.0)
+
+    def setup(self) -> None:
+        # 多肽工作站仓库配置
+        # 基于 2026-05-09 live API probe 发现的实际仓库拓扑 (12个仓库)
+        # 数据来源: Bioyond 现场仓库发现结果。
+        self.warehouses = {
+            # 主自动化堆栈 - live API: code 10-17 -> x=17, y=10，显示为 17 行×10 列
+            "自动化堆栈": bioyond_warehouse_numeric_stack(
+                "自动化堆栈",
+                rows=17,
+                columns=10,
+                bioyond_axis="xy_col_row",
+                bioyond_key_axis="col_row",
+                frontend_y_flip=True,
+            ),
+
+            # 低温存储
+            "低温冰箱仓库": bioyond_warehouse_live_grid(
+                "低温冰箱仓库",
+                rows=3,
+                columns=2,
+                slot_keys=["1", "2", "3", "4", "5", "6"],
+                bioyond_key_axis="col_row",
+                frontend_y_flip=True,
+            ),
+
+            # 移液站库位
+            "Tecan移液站库": bioyond_warehouse_live_grid(
+                "Tecan移液站库",
+                rows=18,
+                columns=1,
+                slot_keys=[str(index) for index in range(1, 19)],
+                bioyond_key_axis="col_row",
+                frontend_y_flip=True,
+            ),
+            "G3移液站库": bioyond_warehouse_live_grid(
+                "G3移液站库",
+                rows=18,
+                columns=1,
+                slot_keys=["1", "2", "3", "4", "垃圾桶", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18"],
+                bioyond_key_axis="col_row",
+                frontend_y_flip=True,
+            ),
+            "IDOT移液站库": bioyond_warehouse_live_grid(
+                "IDOT移液站库",
+                rows=12,
+                columns=1,
+                slot_keys=[f"0009-{index:04d}" for index in range(1, 13)],
+                bioyond_key_axis="col_row",
+                frontend_y_flip=True,
+            ),
+
+            # 缓冲库位
+            "G3缓冲库": bioyond_warehouse_live_grid(
+                "G3缓冲库",
+                rows=5,
+                columns=1,
+                slot_keys=[str(index) for index in range(1, 6)],
+                bioyond_key_axis="col_row",
+                frontend_y_flip=True,
+            ),
+            "盖板缓冲库": bioyond_warehouse_live_grid(
+                "盖板缓冲库",
+                rows=7,
+                columns=1,
+                slot_keys=[str(index) for index in range(1, 8)],
+                bioyond_key_axis="col_row",
+                frontend_y_flip=True,
+            ),
+            "配平板缓冲库": bioyond_warehouse_live_grid(
+                "配平板缓冲库",
+                rows=3,
+                columns=1,
+                slot_keys=[str(index) for index in range(1, 4)],
+                bioyond_key_axis="col_row",
+                frontend_y_flip=True,
+            ),
+            "IDOT缓冲库": bioyond_warehouse_live_grid(
+                "IDOT缓冲库",
+                rows=2,
+                columns=1,
+                slot_keys=["1", "1"],
+                bioyond_key_axis="col_row",
+                frontend_y_flip=True,
+            ),
+            "固相合成板底座缓冲位": bioyond_warehouse_live_grid(
+                "固相合成板底座缓冲位",
+                rows=4,
+                columns=1,
+                slot_keys=[f"0015-{index:04d}" for index in range(1, 5)],
+                bioyond_key_axis="col_row",
+                frontend_y_flip=True,
+            ),
+
+            # 设备库位
+            "离心机库位": bioyond_warehouse_live_grid(
+                "离心机库位",
+                rows=4,
+                columns=1,
+                slot_keys=[f"0017-{index:04d}" for index in range(1, 5)],
+                bioyond_key_axis="col_row",
+                frontend_y_flip=True,
+            ),
+            "热封膜机位": bioyond_warehouse_live_grid(
+                "热封膜机位",
+                rows=2,
+                columns=1,
+                slot_keys=[f"0016-{index:04d}" for index in range(1, 3)],
+                bioyond_key_axis="col_row",
+                frontend_y_flip=True,
+            ),
+        }
+
+        # 仓库显示布局：紧凑排列；存储 y 坐标按前端兼容翻转预先反向。
+        display_layout = {
+            "自动化堆栈": (0.0, 0.0),
+            "Tecan移液站库": (1520.0, 0.0),
+            "G3移液站库": (1710.0, 0.0),
+            "IDOT移液站库": (1900.0, 0.0),
+            "G3缓冲库": (2090.0, 0.0),
+            "盖板缓冲库": (2090.0, 580.0),
+            "低温冰箱仓库": (2280.0, 0.0),
+            "配平板缓冲库": (2280.0, 370.0),
+            "IDOT缓冲库": (2470.0, 370.0),
+            "固相合成板底座缓冲位": (2280.0, 740.0),
+            "离心机库位": (2470.0, 740.0),
+            "热封膜机位": (2280.0, 1210.0),
+        }
+        self.warehouse_locations = {
+            name: self._frontend_y_flipped_coordinate(x, y, self.warehouses[name])
+            for name, (x, y) in display_layout.items()
+        }
+
+        for warehouse_name, warehouse in self.warehouses.items():
+            self.assign_child_resource(warehouse, location=self.warehouse_locations[warehouse_name])
+
 def YB_Deck(name: str) -> Deck:
     by=BIOYOND_YB_Deck(name=name)
     by.setup()
     return by
-
-
-
-
-

unilabos/resources/bioyond/peptide_materials.py

@@ -0,0 +1,247 @@
+"""Peptide Station Material Resource Definitions."""
+
+from __future__ import annotations
+
+from collections import OrderedDict
+
+try:
+    from pylabrobot.resources import Container, Plate, TipRack
+except Exception:  # pragma: no cover - 允许无 pylabrobot 的轻量动作测试导入
+    class _FallbackResource:
+        def __init__(self, *args, **kwargs):
+            self.args = args
+            self.kwargs = kwargs
+
+    class Container(_FallbackResource):  # type: ignore[no-redef]
+        pass
+
+    class Plate(_FallbackResource):  # type: ignore[no-redef]
+        pass
+
+    class TipRack(_FallbackResource):  # type: ignore[no-redef]
+        pass
+
+try:
+    from unilabos.registry.decorators import resource
+except Exception:  # pragma: no cover - 允许无完整 registry 依赖时导入常量
+    def resource(*args, **kwargs):
+        def decorator(cls):
+            return cls
+
+        return decorator
+
+
+def _ensure_itemized_ordering(kwargs: dict) -> None:
+    if kwargs.get("ordering") is None and kwargs.get("ordered_items") is None:
+        kwargs["ordering"] = OrderedDict()
+
+
+class _PeptideTipRack(TipRack):
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault("size_x", 127.76)
+        kwargs.setdefault("size_y", 85.48)
+        kwargs.setdefault("size_z", 64.0)
+        kwargs.setdefault("with_tips", True)
+        _ensure_itemized_ordering(kwargs)
+        super().__init__(*args, **kwargs)
+
+
+class _PeptidePlate(Plate):
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault("size_x", 127.76)
+        kwargs.setdefault("size_y", 85.48)
+        kwargs.setdefault("size_z", 14.35)
+        kwargs.setdefault("plate_type", "skirted")
+        _ensure_itemized_ordering(kwargs)
+        super().__init__(*args, **kwargs)
+
+
+@resource(
+    id="bioyond_peptide_1000ul_tip_rack",
+    category=["labware", "tip_rack"],
+    description="1000uL tip rack for Bioyond peptide station",
+)
+class BioyondPeptide_1000ul_TipRack(_PeptideTipRack):
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault("model", "bioyond_peptide_1000ul_tip_rack")
+        super().__init__(*args, **kwargs)
+
+
+@resource(
+    id="bioyond_peptide_200ul_tip_rack",
+    category=["labware", "tip_rack"],
+    description="200uL tip rack for Bioyond peptide station",
+)
+class BioyondPeptide_200ul_TipRack(_PeptideTipRack):
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault("model", "bioyond_peptide_200ul_tip_rack")
+        super().__init__(*args, **kwargs)
+
+
+@resource(
+    id="bioyond_peptide_50ul_tip_rack",
+    category=["labware", "tip_rack"],
+    description="50uL tip rack for Bioyond peptide station",
+)
+class BioyondPeptide_50ul_TipRack(_PeptideTipRack):
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault("model", "bioyond_peptide_50ul_tip_rack")
+        super().__init__(*args, **kwargs)
+
+
+@resource(
+    id="bioyond_peptide_96_well_deep_well_plate",
+    category=["labware", "plate"],
+    description="96 well deep well plate for Bioyond peptide station",
+)
+class BioyondPeptide_96WellDeepWellPlate(_PeptidePlate):
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault("model", "bioyond_peptide_96_well_deep_well_plate")
+        kwargs.setdefault("size_z", 44.0)
+        super().__init__(*args, **kwargs)
+
+
+@resource(
+    id="bioyond_peptide_96_well_synthesis_plate",
+    category=["labware", "plate"],
+    description="96 well solid-phase synthesis plate for Bioyond peptide station",
+)
+class BioyondPeptide_96WellSynthesisPlate(_PeptidePlate):
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault("model", "bioyond_peptide_96_well_synthesis_plate")
+        super().__init__(*args, **kwargs)
+
+
+@resource(
+    id="bioyond_peptide_96_well_synthesis_plate_base",
+    category=["labware", "adapter"],
+    description="96 well solid-phase synthesis plate base for Bioyond peptide station",
+)
+class BioyondPeptide_96WellSynthesisPlateBase(_PeptidePlate):
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault("model", "bioyond_peptide_96_well_synthesis_plate_base")
+        kwargs.setdefault("size_z", 20.0)
+        super().__init__(*args, **kwargs)
+
+
+@resource(
+    id="bioyond_peptide_96_well_balance_plate",
+    category=["labware", "plate"],
+    description="96 well balance plate for Bioyond peptide station",
+)
+class BioyondPeptide_96WellBalancePlate(_PeptidePlate):
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault("model", "bioyond_peptide_96_well_balance_plate")
+        super().__init__(*args, **kwargs)
+
+
+@resource(
+    id="bioyond_peptide_384_well_plate",
+    category=["labware", "plate"],
+    description="384 well plate for Bioyond peptide station",
+)
+class BioyondPeptide_384WellPlate(_PeptidePlate):
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault("model", "bioyond_peptide_384_well_plate")
+        super().__init__(*args, **kwargs)
+
+
+@resource(
+    id="bioyond_peptide_384_lcms_plate",
+    category=["labware", "plate"],
+    description="384 well LCMS plate for Bioyond peptide station",
+)
+class BioyondPeptide_384LCMSPlate(_PeptidePlate):
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault("model", "bioyond_peptide_384_lcms_plate")
+        super().__init__(*args, **kwargs)
+
+
+@resource(
+    id="bioyond_peptide_384_balance_plate",
+    category=["labware", "plate"],
+    description="384 well balance plate for Bioyond peptide station",
+)
+class BioyondPeptide_384BalancePlate(_PeptidePlate):
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault("model", "bioyond_peptide_384_balance_plate")
+        super().__init__(*args, **kwargs)
+
+
+@resource(
+    id="bioyond_peptide_cover_plate",
+    category=["labware", "cover"],
+    description="Cover plate for Bioyond peptide station",
+)
+class BioyondPeptide_CoverPlate(_PeptidePlate):
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault("model", "bioyond_peptide_cover_plate")
+        kwargs.setdefault("size_z", 8.0)
+        super().__init__(*args, **kwargs)
+
+
+@resource(
+    id="bioyond_peptide_sealing_base",
+    category=["labware", "adapter"],
+    description="Sealing base for Bioyond peptide station",
+)
+class BioyondPeptide_SealingBase(_PeptidePlate):
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault("model", "bioyond_peptide_sealing_base")
+        kwargs.setdefault("size_z", 20.0)
+        super().__init__(*args, **kwargs)
+
+
+@resource(
+    id="bioyond_peptide_reagent_trough",
+    category=["labware", "trough"],
+    description="Reagent trough for Bioyond peptide station",
+)
+class BioyondPeptide_ReagentTrough(Container):
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault("size_x", 127.76)
+        kwargs.setdefault("size_y", 85.48)
+        kwargs.setdefault("size_z", 44.0)
+        kwargs.setdefault("max_volume", 300000.0)
+        kwargs.setdefault("model", "bioyond_peptide_reagent_trough")
+        super().__init__(*args, **kwargs)
+
+
+DEFAULT_PEPTIDE_MATERIAL_TYPE_MAPPINGS = {
+    "bioyond_peptide_1000ul_tip_rack": ["1000μL枪头盒", "3a1890bb-736e-cfdd-3213-eb314e8a60f9"],
+    "bioyond_peptide_200ul_tip_rack": ["200μL枪头盒", "3a1890bb-36d1-964a-18bd-0bf0f2877a7b"],
+    "bioyond_peptide_50ul_tip_rack": ["50μL枪头盒", "3a1890bc-5fae-361c-cc09-e6f2f6dcd71d"],
+    "bioyond_peptide_96_well_deep_well_plate": ["96孔深孔板", "3a1890bc-1fa8-fe39-9faa-12279ed4569b"],
+    "bioyond_peptide_96_well_synthesis_plate": ["96孔固相合成板", "3a1871cb-99f3-f01d-23e2-08dbbd0045b5"],
+    "bioyond_peptide_96_well_synthesis_plate_base": ["96孔固相合成板底座", "3a1b997e-241b-64f0-80d1-47bca08799d1"],
+    "bioyond_peptide_96_well_balance_plate": ["96孔配平板", "3a187661-2378-1e20-fa5c-a27d49fdc15d"],
+    "bioyond_peptide_384_well_plate": ["384孔酶标板", "3a1890bf-2148-ed20-92bd-d85869947d9a"],
+    "bioyond_peptide_384_lcms_plate": ["384孔LCMS板", "3a1e6a8b-cb61-74da-a089-8e6f197f80f0"],
+    "bioyond_peptide_384_balance_plate": ["384孔配平板", "3a18be7e-47cc-888c-fc68-055753286826"],
+    "bioyond_peptide_cover_plate": ["防挥发盖板", "3a19d5a6-b0e2-b486-e5eb-bcabc632f4de"],
+    "bioyond_peptide_sealing_base": ["封膜底座", "3a1d1d7b-e33b-6975-165d-c56cba5ed345"],
+    "bioyond_peptide_reagent_trough": ["12道试剂槽", "3a18b431-ac58-ca2e-9680-2a4f5880ea45"],
+}
+
+
+MATERIAL_TYPE_CODE_TO_CLASS = {
+    "0001": BioyondPeptide_96WellSynthesisPlate,
+    "0002": BioyondPeptide_96WellBalancePlate,
+    "0008": BioyondPeptide_200ul_TipRack,
+    "0009": BioyondPeptide_1000ul_TipRack,
+    "0011": BioyondPeptide_96WellDeepWellPlate,
+    "0012": BioyondPeptide_50ul_TipRack,
+    "0016": BioyondPeptide_384WellPlate,
+    "0018": BioyondPeptide_384WellPlate,
+    "0024": BioyondPeptide_ReagentTrough,
+    "0026": BioyondPeptide_384BalancePlate,
+    "0035": BioyondPeptide_CoverPlate,
+    "0039": BioyondPeptide_96WellSynthesisPlateBase,
+    "0041": BioyondPeptide_SealingBase,
+    "0049": BioyondPeptide_384LCMSPlate,
+}
+
+
+def get_material_class_by_type_code(type_code: str):
+    """Return a peptide material class by Bioyond material type code."""
+    return MATERIAL_TYPE_CODE_TO_CLASS.get(type_code)

unilabos/resources/bioyond/warehouses.py

@@ -1,5 +1,192 @@
+from pylabrobot.resources import Coordinate
+from pylabrobot.resources.carrier import ResourceHolder, create_homogeneous_resources
+
 from unilabos.resources.warehouse import WareHouse, warehouse_factory
 
+
+class BioyondWareHouse(WareHouse):
+    """Bioyond 仓库，额外保存服务端 x/y 坐标和库位标签语义。"""
+
+    def __init__(self, *args, bioyond_axis: str = "xy_row_col", bioyond_key_axis: str = "row_col", **kwargs):
+        super().__init__(*args, **kwargs)
+        self.bioyond_axis = bioyond_axis
+        self.bioyond_key_axis = bioyond_key_axis
+
+    def serialize(self) -> dict:
+        data = super().serialize()
+        data["bioyond_axis"] = self.bioyond_axis
+        data["bioyond_key_axis"] = self.bioyond_key_axis
+        return data
+
+
+def bioyond_warehouse_numeric_stack(
+    name: str,
+    rows: int = 10,
+    columns: int = 17,
+    bioyond_axis: str = "xy_row_col",
+    bioyond_key_axis: str = "row_col",
+    frontend_y_flip: bool = False,
+) -> WareHouse:
+    """创建 Bioyond 数字库位堆栈，库位名使用服务端返回的 行-列 格式。
+
+    bioyond_axis: 仓库级别的 Bioyond 坐标轴约定，供 graphio 的坐标映射使用。
+        - "xy_row_col" (default): Bioyond x→row, y→col (reaction/peptide 历史约定).
+        - "xy_col_row": Bioyond x→col, y→row (Sirna live API 实测约定).
+    bioyond_key_axis: 库位标签生成约定。
+        - "row_col" (default): 视觉行列和标签行列一致，例如 10 行 x 17 列 → 1-1..10-17。
+        - "col_row": 视觉行列转置，但标签仍保持 Bioyond row-col，例如
+          17 行 x 10 列 → 1-1..10-17。
+    未设置时 graphio 回退到默认 "xy_row_col"，其他调用方保持原行为。
+    """
+    num_items_x = columns
+    num_items_y = rows
+    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
+    resource_size_x = 127.0
+    resource_size_y = 86.0
+    resource_size_z = 25.0
+    size_y = dy + item_dy * num_items_y
+    locations = []
+    for row in range(num_items_y):
+        display_y = dy + row * item_dy
+        y = size_y - display_y - resource_size_y if frontend_y_flip else display_y
+        for col in range(num_items_x):
+            locations.append(Coordinate(dx + col * item_dx, y, dz))
+    holders = create_homogeneous_resources(
+        klass=ResourceHolder,
+        locations=locations,
+        resource_size_x=resource_size_x,
+        resource_size_y=resource_size_y,
+        resource_size_z=resource_size_z,
+        name_prefix=name,
+    )
+    if bioyond_key_axis == "row_col":
+        keys = [
+            f"{row + 1}-{col + 1}"
+            for row in range(num_items_y)
+            for col in range(num_items_x)
+        ]
+    elif bioyond_key_axis == "col_row":
+        keys = [
+            f"{col + 1}-{row + 1}"
+            for row in range(num_items_y)
+            for col in range(num_items_x)
+        ]
+    else:
+        raise ValueError(f"未知 Bioyond 库位标签约定: {bioyond_key_axis!r}")
+    warehouse = BioyondWareHouse(
+        name=name,
+        size_x=dx + item_dx * num_items_x,
+        size_y=size_y,
+        size_z=dz + item_dz * num_items_z,
+        num_items_x=num_items_x,
+        num_items_y=num_items_y,
+        num_items_z=num_items_z,
+        ordering_layout="row-major",
+        sites={key: holder for key, holder in zip(keys, holders.values())},
+        category="warehouse",
+        bioyond_axis=bioyond_axis,
+        bioyond_key_axis=bioyond_key_axis,
+    )
+    return warehouse
+
+
+def bioyond_warehouse_live_grid(
+    name: str,
+    rows: int,
+    columns: int,
+    slot_keys: list[str] | None = None,
+    bioyond_axis: str = "xy_col_row",
+    bioyond_key_axis: str = "row_col",
+    frontend_y_flip: bool = False,
+) -> WareHouse:
+    """创建 Bioyond 实测库位网格，按服务端 code 保存位点标签。
+
+    默认用于 Peptide live API 返回的坐标：x 是视觉列，y 是视觉行。
+    当服务端 code 重复时，为保持 PLR ordering 唯一性，会给后续重复项追加 ``#N``。
+    """
+    num_items_x = columns
+    num_items_y = rows
+    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
+    resource_size_x = 127.0
+    resource_size_y = 86.0
+    resource_size_z = 25.0
+    size_y = dy + item_dy * num_items_y
+    locations = []
+    for row in range(num_items_y):
+        display_y = dy + row * item_dy
+        y = size_y - display_y - resource_size_y if frontend_y_flip else display_y
+        for col in range(num_items_x):
+            locations.append(Coordinate(dx + col * item_dx, y, dz))
+    holders = create_homogeneous_resources(
+        klass=ResourceHolder,
+        locations=locations,
+        resource_size_x=resource_size_x,
+        resource_size_y=resource_size_y,
+        resource_size_z=resource_size_z,
+        name_prefix=name,
+    )
+    keys = slot_keys or [str(index + 1) for index in range(num_items_x * num_items_y)]
+    if len(keys) != len(holders):
+        raise ValueError(f"{name} 库位数量不匹配: keys={len(keys)}, holders={len(holders)}")
+
+    seen: dict[str, int] = {}
+    unique_keys: list[str] = []
+    for key in keys:
+        count = seen.get(key, 0) + 1
+        seen[key] = count
+        unique_keys.append(key if count == 1 else f"{key}#{count}")
+
+    return BioyondWareHouse(
+        name=name,
+        size_x=dx + item_dx * num_items_x,
+        size_y=size_y,
+        size_z=dz + item_dz * num_items_z,
+        num_items_x=num_items_x,
+        num_items_y=num_items_y,
+        num_items_z=num_items_z,
+        ordering_layout="row-major",
+        sites={key: holder for key, holder in zip(unique_keys, holders.values())},
+        category="warehouse",
+        bioyond_axis=bioyond_axis,
+        bioyond_key_axis=bioyond_key_axis,
+    )
+
+
+# ================ 小核酸工作站相关堆栈 ================
+
+def bioyond_warehouse_sirna_g3_liquid_handler(name: str = "G3移液站") -> WareHouse:
+    """创建小核酸 G3 移液站库位堆栈：显示为 14 行 x 1 列，标签保持 1-1..1-14。"""
+    return bioyond_warehouse_numeric_stack(
+        name, rows=14, columns=1, bioyond_axis="xy_col_row", bioyond_key_axis="col_row"
+    )
+
+
+def bioyond_warehouse_sirna_automation_stack(name: str = "自动化堆栈") -> WareHouse:
+    """创建小核酸自动化堆栈：显示为 17 行 x 10 列，标签保持 1-1..10-17。"""
+    return bioyond_warehouse_numeric_stack(
+        name, rows=17, columns=10, bioyond_axis="xy_col_row", bioyond_key_axis="col_row"
+    )
+
+
+def bioyond_warehouse_sirna_centrifuge_balance_plate_stack(name: str = "离心机配平板堆栈") -> WareHouse:
+    """创建小核酸离心机配平板堆栈：显示为 1 行 x 2 列，标签保持 1-1、2-1。"""
+    return bioyond_warehouse_numeric_stack(
+        name, rows=1, columns=2, bioyond_axis="xy_col_row", bioyond_key_axis="col_row"
+    )
+
+
 # ================ 反应站相关堆栈 ================
 
 def bioyond_warehouse_1x4x4(name: str) -> WareHouse:

unilabos/resources/graphio.py

@@ -736,7 +736,7 @@ def resource_bioyond_to_plr(bioyond_materials: list[dict], type_mapping: Dict[st
             logger.warning(f"物料 {unique_name} 不是有效的 ResourcePLR 实例，类型: {type(plr_material)}")
             continue
 
-        plr_material.code = material.get("code", "") and material.get("barCode", "") or ""
+        plr_material.code = material.get("barCode") or material.get("code") or ""
         plr_material.unilabos_uuid = str(uuid.uuid4())
 
         # ⭐ 保存 Bioyond 原始信息到 unilabos_extra（用于出库时查询）
@@ -864,11 +864,22 @@ def resource_bioyond_to_plr(bioyond_materials: list[dict], type_mapping: Dict[st
                     warehouse = deck.warehouses[wh_name]
                     logger.debug(f"[Warehouse匹配] 找到warehouse: {wh_name} (容量: {warehouse.capacity}, 行×列: {warehouse.num_items_x}×{warehouse.num_items_y})")
 
-                    # Bioyond坐标映射 (重要！): x→行(1=A,2=B...), y→列(1=01,2=02...), z→层(通常=1)
-                    x = loc.get("x", 1)  # 行号 (1-based: 1=A, 2=B, 3=C, 4=D)
-                    y = loc.get("y", 1)  # 列号 (1-based: 1=01, 2=02, 3=03...)
+                    # Bioyond坐标映射:
+                    # - 历史 row_col 仓库中 x/y 直接按行/列参与索引。
+                    # - Sirna 的库位标签为 col-row，stock-material 返回 x=标签第二段、y=标签第一段。
+                    #   因此 x=13,y=4 应落到 key=4-13，而不是交换后落到 3-5。
+                    x = loc.get("x", 1)
+                    y = loc.get("y", 1)
                     z = loc.get("z", 1)  # 层号 (1-based, 通常为1)
 
+                    # 仓库级别的轴约定覆盖。
+                    # 对旧的 row-col 视觉标签，bioyond_axis="xy_col_row" 需要交换 x/y。
+                    # 对 Sirna 的 col-row 库位标签，原始 x/y 已能直接索引到 code 对应位置，不再交换。
+                    bioyond_axis = getattr(warehouse, "bioyond_axis", "xy_row_col")
+                    bioyond_key_axis = getattr(warehouse, "bioyond_key_axis", "row_col")
+                    if bioyond_axis == "xy_col_row" and bioyond_key_axis != "col_row":
+                        x, y = y, x
+
                     # 如果是右侧堆栈，需要调整列号 (5→1, 6→2, 7→3, 8→4)
                     if wh_name == "堆栈1右":
                         y = y - 4  # 将5-8映射到1-4
@@ -912,10 +923,43 @@ def resource_bioyond_to_plr(bioyond_materials: list[dict], type_mapping: Dict[st
                             logger.debug(f"列优先warehouse {wh_name}: x={x}(行),y={y}(列) → row={row_idx},col={col_idx} → idx={idx}")
 
                     if 0 <= idx < warehouse.capacity:
-                        if warehouse[idx] is None or isinstance(warehouse[idx], ResourceHolder):
+                        slot_key = None
+                        ordering = getattr(warehouse, "_ordering", {})
+                        sites = getattr(warehouse, "sites", [])
+                        if isinstance(ordering, dict) and idx < len(sites):
+                            site_at_idx = sites[idx]
+                            slot_key = next(
+                                (key for key, site in ordering.items() if site is site_at_idx),
+                                None,
+                            )
+
+                        current_resource = warehouse[idx]
+                        if current_resource is None or isinstance(current_resource, (ResourceHolder, str)):
+                            if isinstance(current_resource, str):
+                                logger.warning(
+                                    f"⚠️ 物料 {unique_name} 覆盖 {wh_name}[{idx}]"
+                                    f"{f'({slot_key})' if slot_key else ''} 的旧占位 occupied_by={current_resource!r}"
+                                )
                             # 物料尺寸已在放入warehouse前根据需要进行了交换
                             warehouse[idx] = plr_material
-                            logger.debug(f"✅ 物料 {unique_name} 放置到 {wh_name}[{idx}] (Bioyond坐标: x={loc.get('x')}, y={loc.get('y')})")
+                            logger.debug(
+                                f"✅ 物料 {unique_name} 放置到 {wh_name}[{idx}]"
+                                f"{f'({slot_key})' if slot_key else ''} "
+                                f"(Bioyond坐标: x={loc.get('x')}, y={loc.get('y')})"
+                            )
+                        else:
+                            parent = getattr(current_resource, "parent", None)
+                            current_repr = repr(current_resource)
+                            current_len = len(current_resource) if isinstance(current_resource, str) else None
+                            logger.warning(
+                                f"⚠️ 物料 {unique_name} 跳过放置到 {wh_name}[{idx}]"
+                                f"{f'({slot_key})' if slot_key else ''}：目标库位已有 "
+                                f"{type(current_resource).__name__}"
+                                f"(value={current_repr}, len={current_len})"
+                                f"(name={getattr(current_resource, 'name', None)}, "
+                                f"parent={getattr(parent, 'name', None)}, "
+                                f"uuid={getattr(current_resource, 'unilabos_uuid', None)})"
+                            )
                     else:
                         logger.warning(f"❌ 物料 {unique_name} 的索引 {idx} 超出仓库 {wh_name} 容量 {warehouse.capacity}")
                 else:

unilabos/resources/plr_additional_res_reg.py

@@ -18,3 +18,7 @@ def register():
     from unilabos.devices.liquid_handling.rviz_backend import UniLiquidHandlerRvizBackend
     from unilabos.devices.liquid_handling.laiyu.backend.laiyu_v_backend import UniLiquidHandlerLaiyuBackend
 
+    # noinspection PyUnresolvedReferences
+    from unilabos.resources.bioyond.decks import BIOYOND_SirnaStation_Deck
+    # noinspection PyUnresolvedReferences
+    from unilabos.resources.bioyond.decks import BIOYOND_PeptideStation_Deck

unilabos/ros/nodes/base_device_node.py

@@ -45,7 +45,6 @@ from unilabos.resources.graphio import (
 )
 from unilabos.resources.plr_additional_res_reg import register
 from unilabos.ros.msgs.message_converter import (
-    String,
     convert_to_ros_msg,
     convert_from_ros_msg_with_mapping,
     convert_to_ros_msg_with_mapping,
@@ -251,8 +250,7 @@ class PropertyPublisher:
     ):
         self.node = node
         self.name = name
-        self.msg_type = self._normalize_msg_type(msg_type)
-        self.original_msg_type = msg_type
+        self.msg_type = msg_type
         self.get_method = get_method
         self.timer_period = initial_period
         self.print_publish = print_publish
@@ -260,36 +258,16 @@ class PropertyPublisher:
 
         self._value = None
         try:
-            self.publisher_ = node.create_publisher(self.msg_type, f"{name}", qos)
+            self.publisher_ = node.create_publisher(msg_type, f"{name}", qos)
         except Exception as e:
             self.node.lab_logger().error(
-                f"StatusError, DeviceId: {self.node.device_id} 创建发布者 {name} 失败，"
-                f"可能由于注册表有误，类型: {msg_type}，错误: {e}"
+                f"StatusError, DeviceId: {self.node.device_id} 创建发布者 {name} 失败，可能由于注册表有误，类型: {msg_type}，错误: {e}"
             )
-            self.msg_type = String
-            try:
-                self.publisher_ = node.create_publisher(self.msg_type, f"{name}", qos)
-                self.node.lab_logger().warning(
-                    f"属性 {name} 的发布类型已降级为 String，原始类型: {msg_type}"
-                )
-            except Exception:
-                self.publisher_ = None
         self.timer = node.create_timer(self.timer_period, self.publish_property)
         self.__loop = ROS2DeviceNode.get_asyncio_loop()
-        str_msg_type = str(self.msg_type)[8:-2]
+        str_msg_type = str(msg_type)[8:-2]
         self.node.lab_logger().trace(f"发布属性: {name}, 类型: {str_msg_type}, 周期: {initial_period}秒, QoS: {qos}")
 
-    @staticmethod
-    def _normalize_msg_type(msg_type):
-        if msg_type in (dict, list, tuple, set) or msg_type in ("dict", "list", "tuple", "set"):
-            return String
-        return msg_type
-
-    def _normalize_value(self, value):
-        if self.msg_type is String and isinstance(value, (dict, list, tuple, set)):
-            return json.dumps(value, ensure_ascii=False, cls=TypeEncoder)
-        return value
-
     def get_property(self):
         if asyncio.iscoroutinefunction(self.get_method):
             # 如果是异步函数，运行事件循环并等待结果
@@ -324,16 +302,12 @@ class PropertyPublisher:
                 pass
                 # self.node.lab_logger().trace(f"【.publish_property】发布 {self.msg_type}: {value}")
             if value is not None:
-                if self.publisher_ is None:
-                    return
-                value = self._normalize_value(value)
                 msg = convert_to_ros_msg(self.msg_type, value)
                 self.publisher_.publish(msg)
                 # self.node.lab_logger().trace(f"【.publish_property】属性 {self.name} 发布成功")
         except Exception as e:
-            topic = getattr(self.publisher_, "topic", self.name)
             self.node.lab_logger().error(
-                f"【.publish_property】发布属性 {topic} 出错: {str(e)}\n{traceback.format_exc()}"
+                f"【.publish_property】发布属性 {self.publisher_.topic} 出错: {str(e)}\n{traceback.format_exc()}"
             )
 
     def change_frequency(self, period):

unilabos/ros/nodes/presets/host_node.py

@@ -1691,9 +1691,7 @@ class HostNode(BaseROS2DeviceNode):
         else:
             self.lab_logger().warning("⚠️ 收到无效的Pong响应（缺少ping_id）")
 
-    def notify_resource_tree_update(
-        self, device_id: str, action: str, resource_uuid_list: List[str]
-    ) -> Optional[bool]:
+    def notify_resource_tree_update(self, device_id: str, action: str, resource_uuid_list: List[str]) -> bool:
         """
         通知设备节点更新资源树
 
@@ -1703,14 +1701,13 @@ class HostNode(BaseROS2DeviceNode):
             resource_uuid_list: 资源UUIDs
 
         Returns:
-            True if the update completed, False if it failed, None if it was intentionally skipped.
+            bool: 操作是否成功
         """
         try:
+            # 检查设备是否存在
             if device_id not in self.devices_names:
-                self.lab_logger().info(
-                    f"[Host Node-Resource] 在线增加设备暂不支持，跳过设备 {device_id} 的资源树 {action} 更新"
-                )
-                return None
+                self.lab_logger().error(f"[Host Node-Resource] Device {device_id} not found in devices_names")
+                return False
 
             namespace = self.devices_names[device_id]
             device_key = f"{namespace}/{device_id}"

unilabos/utils/environment_check.py

@@ -47,10 +47,7 @@ def _has_uv() -> bool:
 
 def _install_command(installer: str, package: str, upgrade: bool, is_chinese: bool) -> List[str]:
     if installer == "uv":
-        # uv >= 0.5 默认要求虚拟环境，对 conda env 会报 "No virtual environment found"。
-        # 显式 --python sys.executable 让 uv 把当前解释器（conda/venv/system 都行）
-        # 视为目标环境，绕开 venv 检测。
-        cmd = ["uv", "pip", "install", "--python", sys.executable]
+        cmd = ["uv", "pip", "install"]
         if upgrade:
             cmd.append("--upgrade")
         cmd.append(package)
@@ -92,11 +89,7 @@ def _print_manual_git_install_hint(requirement: str) -> None:
         return
 
     repo_dir = _repo_dir_name(git_url)
-    install_cmd = (
-        f'uv pip install --python "{sys.executable}" -e .'
-        if _has_uv()
-        else f"{sys.executable} -m pip install -e ."
-    )
+    install_cmd = "uv pip install -e ." if _has_uv() else f"{sys.executable} -m pip install -e ."
     if _is_chinese_locale() and not _has_uv():
         install_cmd += " -i https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple"
 

unilabos_msgs/package.xml

@@ -2,7 +2,7 @@
 <?xml-model href="http://download.ros.org/schema/package_format3.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
 <package format="3">
   <name>unilabos_msgs</name>
-  <version>0.11.3</version>
+  <version>0.11.1</version>
   <description>ROS2 Messages package for unilabos devices</description>
   <maintainer email="changjh@pku.edu.cn">Junhan Chang</maintainer>
   <maintainer email="18435084+Xuwznln@users.noreply.github.com">Xuwznln</maintainer>