@xtalpi/agentic-lab-skills 0.0.9 → 0.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xtalpi/agentic-lab-skills",
-	"version": "0.0.9",
+	"version": "0.0.10",
 	"description": "Agentic Lab Skills",
 	"license": "MIT",
 	"author": "TheoXiong",

package/skills/lab-flow-designer/SKILL.md

@@ -4,7 +4,7 @@ description: >-
   根据流程说明 Markdown 初次生成流程注册包时，须先按 references/业务流程文档标准.md 做合规预检，不通过则不得写入产出包并须输出优化建议；对已存在的流程注册包做增量修改时跳过流程文档预检。
   也可根据用户描述生成符合规范的业务流程文档模板，供用户完善后用于流程注册包生成。
   产出与本 skill 内 embedded-template、references/skill-package-layout.md 版式同构；根 SKILL.md 须含概述、核心概念、流程图（Mermaid 池为矩形、门控为六边形）、连接关系、节点清单、门控执行规范、使用方式。
-  Use when scaffolding flow skills, valve scripts from gate YAML and compound KB rules, Processer start/complete from pipeline docs, or generating flow document templates.
+  Use when scaffolding flow skills, valve scripts from gate YAML and compound KB rules, Processer start/complete/run from pipeline docs, or generating flow document templates.
 license: Proprietary
 metadata:
   embedded-template-dir: embedded-template
@@ -38,7 +38,7 @@ metadata:
 | **极简目录范例（优先打开）** | 本 skill 内 [`embedded-template/`](embedded-template/)：2 池 + 1 门控；[`embedded-template/valves/示例数据与校验门控.md`](embedded-template/valves/示例数据与校验门控.md) 与 [`embedded-template/scripts/示例数据与校验门控.js`](embedded-template/scripts/示例数据与校验门控.js) 含「数据查询 / 映射 / 规则」与 SDK 对齐的完整参考 |
 | **版式条文** | [references/skill-package-layout.md](references/skill-package-layout.md)：目录约定、根 `SKILL.md` 各块格式、`pools`/`valves` 文字范例摘录 |
 | 门控脚本 API | [references/agentic-lab-sdk.md](references/agentic-lab-sdk.md)（生成 `scripts/*.js` 前必读） |
-| 门控脚本规范 | [references/agentic-lab-processer.md](references/agentic-lab-processer.md)：`Processer` 类的 `start`/`complete` 输入输出类型定义与代码风格参考（参数与返回值均为 **snake_case**） |
+| 门控脚本规范 | [references/agentic-lab-processer.md](references/agentic-lab-processer.md)：`Processer` 类的 `start`/`complete`（人工触发）与 `run`（自动触发）输入输出类型定义与代码风格参考（参数与返回值均为 **snake_case**） |
 | **业务流程文档模板** | [templates/业务流程文档模板.md](templates/业务流程文档模板.md)：空白模板，各章节带占位提示；用于「生成流程文档」模式 |
 | **业务流程文档示例** | [templates/业务流程文档示例.md](templates/业务流程文档示例.md)：基于 Fragment 分装流程的填写示例，供参考 |
 
@@ -121,6 +121,8 @@ metadata:
     - 规则摘要表（条件要点 + 业务动作），落入 `complete` 函数体
     - 提交参数结构（如 SDK 调用方法的参数定义与键级说明）
     - 出口池路由条件与字段映射
+- **触发方式**：每个门控的 `### 触发方式`（`自动触发` 或 `人工触发`）。自动触发门控无人工处理阶段，脚本实现 `run`（见 [references/agentic-lab-processer.md](references/agentic-lab-processer.md)）；人工触发门控保持 `start` + `complete`。
+- **模型引用**（若有）：数据池或门控的 `### 模型引用`（模型名称与版本），写入对应 `pools/*.md` 或 `valves/*.md` 的 `## 模型引用` 章节；无模型引用时省略。
 - **门控脚本配置项**：提取全局配置表中的各项，落入脚本为**模块级常量**：
   - `PageUrl`（含 `{bookid}` 占位符）→ 脚本常量 `PAGE_URL`
   - `StationBaseURL`（若有）→ 脚本常量 `STATION_BASE_URL`
@@ -160,7 +162,7 @@ metadata:
 固定两个三级标题，正文可结合本流程改写，语义须与模板一致：
 
 - **`### 数据池（Pool）`**：说明 Pool 存记录、每池有独立 Schema、随阶段变化。
-- **`### 门控（Valve）`**：说明每个 Valve 对应脚本、`Processer` 的 `start` / `complete` 职责分工。  
+- **`### 门控（Valve）`**：说明每个 Valve 对应脚本、`Processer` 的 `start` / `complete`（人工触发）或 `run`（自动触发）职责分工。  
   另起简短列表说明执行引擎通过 `this.context` 暴露的能力，**仅写** [references/agentic-lab-sdk.md](references/agentic-lab-sdk.md)「可用方法一览」中已列出的方法名（按流程实际使用选取），**不要**抄写模板里已过期的成员名。
 
 #### 3.4 `## 流程图`（本节内须含「连接关系」列表，与模板一致）
@@ -214,7 +216,7 @@ metadata:
 
 #### 3.6 `## 门控执行规范`
 
-`Processer` 代码块**原文照抄** [references/skill-package-layout.md](references/skill-package-layout.md) §2.5：`constructor`、`async start`、`async complete` 及注释；不含导出语句。不在此节展开 `context` 各方法签名（见 [references/agentic-lab-sdk.md](references/agentic-lab-sdk.md)）。
+`Processer` 代码块**原文照抄** [references/skill-package-layout.md](references/skill-package-layout.md) §2.5：人工触发门控使用 `constructor`、`async start`、`async complete`；自动触发门控使用 `constructor`、`async run`；不含导出语句。不在此节展开 `context` 各方法签名（见 [references/agentic-lab-sdk.md](references/agentic-lab-sdk.md)）。
 
 #### 3.7 `## 使用方式`
 
@@ -231,13 +233,16 @@ metadata:
   - **字段标题**：与流程说明或业务系统一致的**展示名**（可为英文短语如 `Compound ID`，或简短中文标题），供人读表与 UI 列头；**不要**把原「字段」列的英文混进「字段」列。  
   - **字段描述**、**字段类型**、**属性**、**默认值**：规则同前（属性仍仅写枚举/格式归纳，无则留空）。
 - **属性列**：仅当流程说明对该字段给出了**可选值/枚举**（含「枚举：…」「如 A、B」、用顿号/逗号分隔的取值列表等）时，将归纳后的约束写入本列，**建议**以 `枚举：` 开头（例：`枚举：固体颗粒过大，流动性差，强吸水性，易结块，易粘黏，强静电吸附，液体`）。若说明仅在「说明」列内嵌枚举长句，可将枚举部分抽到「属性」，「字段描述」保留简短业务含义。若说明中约定了**日期或时间的表达格式**（如 ISO8601、`YYYYMMDD`、批次号中的日期段），以 `格式：` 开头写入本列。无枚举、无格式约定则**属性列留空**（不写 `-` 占位语）。业务含义仍以「字段描述」为主，避免在描述与属性中完全重复粘贴同一段长文。
+- **模型引用**（若流程说明为该池指定了 3D 模型）：在 `## Schema` 之后添加 `## 模型引用`，含模型名称与版本（格式见 [references/skill-package-layout.md](references/skill-package-layout.md) §3）。无模型引用时省略。
 
 ### 5. 写入每个 `valves/<基名>.md`
 
-章节与排版对齐抽取文档 §4，**至少**包含：`## 概述`（编号步骤）、`## 关联脚本`、`## 执行流程`、`## 输入/输出`。`输入/输出` 须与门控 YAML 的 `primary`/`secondary` 与各输出池**显示名称**一致，**勿**照搬范例中的池名。
+章节与排版对齐抽取文档 §4，**至少**包含：`## 概述`（编号步骤）、`## 关联脚本`、`## 触发方式`、`## 执行流程`、`## 输入/输出`。`输入/输出` 须与门控 YAML 的 `primary`/`secondary` 与各输出池**显示名称**一致，**勿**照搬范例中的池名。
 
 若流程说明对某门控给出了下列块，须在对应 `valves/<基名>.md` 中**原样结构化呈现**（标题可用 `##` / `###`，便于脚本作者对照）：
 
+- **触发方式**：`## 触发方式`，取值 `自动触发` 或 `人工触发`，置于 `## 关联脚本` 之后。
+- **模型引用**（若流程说明指定了模型）：`## 模型引用`，含模型名称与版本。无模型引用时省略。
 - **门控 YAML**（`valve_id`、`name`、`order`、`input`、`output`）；若文档使用 `Stash:` 等非标准键表示目标池，**保留原文**，并在 valve 文内加一句说明：实现时按 [agentic-lab-sdk.md](references/agentic-lab-sdk.md) 获取出口池，以返回的 `pool.name` 与**池显示名称**匹配。
 - **前置处理**（对应 `start`）：提取配置项（如 `bookid`）、规则摘要表，说明 `start` 函数需执行的逻辑。
 - **人工处理**：界面形态与数据绑定描述（仅供参考，不由门控脚本实现）。
@@ -250,8 +255,9 @@ metadata:
 
 ### 6. 写入每个 `scripts/<基名>.js`
 
-1. **先读** [references/agentic-lab-sdk.md](references/agentic-lab-sdk.md) 与 [references/agentic-lab-processer.md](references/agentic-lab-processer.md)；`this.context` **仅**使用 sdk 文件已列出的成员；`start`/`complete` 的输入输出类型须对齐 processer 规范。
-2. **结构**对齐 [embedded-template/scripts/示例数据与校验门控.js](embedded-template/scripts/示例数据与校验门控.js)：`Processer` 类、`constructor(context)`、`async start` / `async complete`；脚本以类定义结束，禁止添加任何导出语句。示例中与本门控文档无关的业务分支**省略**。
+1. **先读** [references/agentic-lab-sdk.md](references/agentic-lab-sdk.md) 与 [references/agentic-lab-processer.md](references/agentic-lab-processer.md)；`this.context` **仅**使用 sdk 文件已列出的成员；`start`/`complete`（或 `run`）的输入输出类型须对齐 processer 规范。
+2. **结构**对齐 [embedded-template/scripts/示例数据与校验门控.js](embedded-template/scripts/示例数据与校验门控.js)：`Processer` 类、`constructor(context)`、`async start` / `async complete`（人工触发）或 `async run`（自动触发）；脚本以类定义结束，禁止添加任何导出语句。示例中与本门控文档无关的业务分支**省略**。
+2.5. **触发方式分支**：读取对应 `valves/<基名>.md` 中的 `## 触发方式`。若为 **人工触发** → 脚本结构同现有（`constructor` + `start` + `complete`）；若为 **自动触发** → 脚本使用 `constructor` + `run`（类型定义见 [references/agentic-lab-processer.md](references/agentic-lab-processer.md)），不含 `start` 或 `complete`。
 3. **注释**与流程说明规则编号对应；业务分支处可用 `TODO`，**不得**编造文档未定义的池名或 API。
 4. **实现逻辑**须遵循下文「门控脚本编写指引」（含 **`limit`/`offset` 默认全量** 约定）。
 5. **按需生成**：详见下文「编写指引 §0」。
@@ -307,6 +313,14 @@ metadata:
 
 - **`complete(params)`**（对应**后置处理**）：解构 **`valve_id`** 与 **`tickets`**（snake_case 入参）→ **优先使用 `params.tickets` 作为业务数据源**（引擎已传入完整 ticket 数据，无需重新查询；仅当流程说明后置处理中**明确要求**获取额外数据或最新状态时才按需查询）→ 按流程说明后置处理中的规则执行业务逻辑（准备提交参数、按需调用 SDK 方法、判定成败等）→ 按 [agentic-lab-sdk.md](references/agentic-lab-sdk.md) 获取出口池 → 将入口池 tickets 更新为 `finished` → 按出口池条件映射 `new_tickets`（含 `flow_id`、`pool_id`、`order_id`、`detail`、`status: 'created'`、`parent_ticket_id`）→ 返回 `{ new_tickets }`（由引擎自动创建，**不**在脚本内直接追加 tickets）。
 
+### 3.1 `run` 分工（自动触发门控专用）
+
+自动触发门控无人工处理阶段，`run` 合并了 `start` 与 `complete` 的职责。
+
+- **`run(params)`**：解构 **`valve_id`、`pool_ids`**（snake_case）→ 按 [agentic-lab-sdk.md](references/agentic-lab-sdk.md) 查询入口池数据 → 按需调用 SDK 方法 → 按数据处理规则更新 `ticket.detail` → 按 SDK 更新 tickets → 按 [agentic-lab-sdk.md](references/agentic-lab-sdk.md) 获取出口池 → 将入口池 tickets 更新为 `finished` → 按出口池条件映射 `new_tickets` → 返回 `{ new_tickets }`。
+
+  **与 `start` + `complete` 的区别**：`run` **不返回** `orbit_link` 或 `ticket_ids`（无人工阶段无需页面链接或 ticket 列表交互）。类型定义见 [references/agentic-lab-processer.md](references/agentic-lab-processer.md)。
+
 ### 4. 运行环境约束（沙箱可用全局对象）
 
 门控脚本在**沙箱**中执行，**仅**以下全局对象/函数可用：
@@ -430,6 +444,8 @@ console.info(`[Processer] v${__ARTIFACT_VERSION__} (skill: ${__ARTIFACT_SKILL__}
 - 一级参数/返回值 snake_case；嵌套 JSON 保持原格式（见「编写指引 §3」）
 - `orbit_link` = `PageUrl` + `bookid`（见「编写指引 §3 orbit_link 生成步骤」）
 - 门控三阶段：前置处理 → `start`、后置处理 → `complete`、人工处理 → UI 技能（见「解析流程说明 §1」）
+- **触发方式**：自动触发门控脚本须实现 `run`（非 `start` + `complete`）；人工触发保持 `start` + `complete`（见「编写指引 §3.1」与 [agentic-lab-processer.md](references/agentic-lab-processer.md)）
+- **模型引用**：流程说明中关联 3D 模型的池和门控，须在对应 `pools/*.md` 或 `valves/*.md` 写入 `## 模型引用`（模型名称 + 版本）；无模型引用时省略
 - `complete` 优先使用 `params.tickets`，非必要不重查（见「编写指引 §3」）
 - 脚本以 `Processer` 类结束，禁止 `return`/`module.exports`/`export`（见「生成流程 §6」）
 - 按需生成，禁止冗余：代码和 Schema 仅覆盖流程文档明确写出的内容（见「编写指引 §0」）
@@ -483,10 +499,11 @@ node <本skill目录>/testing/test-processer.mjs \
 | 轮次 | 检查内容 | 失败级别 |
 |------|---------|---------|
 | **语法检查** | JavaScript 语法正确性 | 阻断 |
-| **结构检查** | `Processer` 类存在，含 `constructor`、`start`、`complete` | 阻断 |
-| **正常轮 `start`** | 正常类型 mock 数据运行，检查返回 `{ orbit_link: string, ticket_ids: number[] }` | 阻断 |
-| **正常轮 `complete`** | 正常类型 mock 数据运行，检查返回 `{ new_tickets: [...] }` 结构正确 | 阻断 |
-| **对抗轮 `start` + `complete`** | 第 3 条 ticket 的 text 字段填为 number/null，验证类型安全编码 | 警告（不阻断） |
+| **结构检查** | `Processer` 类存在，含 `constructor` + (`start`、`complete`)（人工触发）或 `run`（自动触发） | 阻断 |
+| **正常轮 `start`** | 人工触发：正常类型 mock 数据运行，检查返回 `{ orbit_link: string, ticket_ids: number[] }` | 阻断 |
+| **正常轮 `complete`** | 人工触发：正常类型 mock 数据运行，检查返回 `{ new_tickets: [...] }` 结构正确 | 阻断 |
+| **正常轮 `run`** | 自动触发：正常类型 mock 数据运行，检查返回 `{ new_tickets: [...] }` 结构正确 | 阻断 |
+| **对抗轮 `start` + `complete` / `run`** | 第 3 条 ticket 的 text 字段填为 number/null，验证类型安全编码 | 警告（不阻断） |
 | **合规审计** | SDK 方法白名单、列表查询 `limit`/`offset`、返回值 snake_case | 未知 SDK 方法→阻断；其余→警告 |
 
 ### 结果判定与自动修复
@@ -522,6 +539,8 @@ node <本skill目录>/testing/test-processer.mjs \
 | `ticket.list called without limit` | `ticket.list called without explicit limit` | 添加 `limit: DEFAULT_QUERY_LIMIT, offset: 0` |
 | `camelCase key in return value` | `"ticketIds" is camelCase — must be snake_case` | 改为 `ticket_ids` 等 snake_case 键名 |
 | `Processer missing start() method` | 结构检查未通过 | 确保 `Processer` 类包含 `async start(params)` 方法 |
+| `Processer missing run() method` | 自动触发门控结构检查未通过 | 确保 `Processer` 类包含 `async run(params)` 方法，移除 `start`/`complete` |
+| `run() new_tickets 缺必填字段` | `new_tickets[0].pool_id must be number` | 检查 run 中 new_tickets 映射逻辑，补全 `flow_id`/`pool_id`/`order_id`/`detail`/`status` |
 
 ## 脚本预览（试运行）
 

package/skills/lab-flow-designer/embedded-template/SKILL.md

@@ -59,7 +59,7 @@ flowchart LR
 
 ## 门控执行规范
 
-每个 Valve 的 JavaScript 脚本导出 `Processer` 类，必须实现 `start` / `complete`。由流程说明生成真实流程注册包时，脚本**仅实现文档明确要求**的逻辑与字段处理，须遵循主 `SKILL.md`「门控脚本编写指引」；下方代码块仅示意类骨架。
+每个 Valve 的 JavaScript 脚本导出 `Processer` 类，必须实现 `start` / `complete`（人工触发）或 `run`（自动触发）。由流程说明生成真实流程注册包时，脚本**仅实现文档明确要求**的逻辑与字段处理，须遵循主 `SKILL.md`「门控脚本编写指引」；下方代码块仅示意类骨架。
 
 ```javascript
 class Processer {
@@ -81,6 +81,21 @@ class Processer {
 }
 ```
 
+**自动触发门控**使用 `run` 替代 `start` + `complete`（详见 [references/agentic-lab-processer.md](../references/agentic-lab-processer.md)）：
+
+```javascript
+class Processer {
+  constructor(context) {
+    this.context = context;
+  }
+
+  async run(params) {
+    // params: { valve_id, pool_ids }
+    // 查询入口池 → 执行业务逻辑 → 获取出口池 → 映射 new_tickets
+  }
+}
+```
+
 ## 使用方式
 
 1. 查看各 Pool 的 [pools/](pools/) 目录了解数据表结构

package/skills/lab-flow-designer/embedded-template/pools//345/205/245/345/217/243/346/261/240.md

@@ -10,3 +10,12 @@
 |------|----------|----------|----------|------|--------|
 | id | ID | 业务主键 | string |  | - |
 | detail | Detail | 业务明细 JSON | json |  | - |
+
+## 模型引用
+
+> 本池无关联 3D 模型，本节仅作版式示意。实际生成时，无模型引用的池省略本节。
+
+| 属性 | 值 |
+|------|-----|
+| 名称 | example-pool-model |
+| 版本 | 1.0.0 |

package/skills/lab-flow-designer/embedded-template/pools//345/207/272/345/217/243/346/261/240.md

@@ -10,3 +10,12 @@
 |------|----------|----------|----------|------|--------|
 | id | ID | 业务主键 | string |  | - |
 | detail | Detail | 业务明细 JSON | json |  | - |
+
+## 模型引用
+
+> 本池无关联 3D 模型，本节仅作版式示意。实际生成时，无模型引用的池省略本节。
+
+| 属性 | 值 |
+|------|-----|
+| 名称 | example-pool-model |
+| 版本 | 1.0.0 |

package/skills/lab-flow-designer/embedded-template/valves//347/244/272/344/276/213/346/225/260/346/215/256/344/270/216/346/240/241/351/252/214/351/227/250/346/216/247.md

@@ -10,6 +10,21 @@
 
 该脚本导出 `Processer` 类，实现 `start` 和 `complete` 方法。
 
+## 触发方式
+
+人工触发
+
+> 人工触发门控执行顺序：前置处理（脚本 `start`）→ 人工处理（页面）→ 后置处理（脚本 `complete`）。自动触发门控使用 `run` 方法替代 `start` + `complete`，详见 [references/agentic-lab-processer.md](../../references/agentic-lab-processer.md)。
+
+## 模型引用
+
+> 本门控无关联 3D 模型，本节仅作版式示意。实际生成时，无模型引用的门控省略本节。
+
+| 属性 | 值 |
+|------|-----|
+| 名称 | example-valve-model |
+| 版本 | 1.0.0 |
+
 ## 门控 YAML（与流程说明对齐）
 
 流程说明中可能使用 `Stash:` 等键表示目标池；生成脚本时按 [agentic-lab-sdk.md](../../references/agentic-lab-sdk.md) 获取出口池，以返回的 **`pool.name`**（或文档中的池显示名称）匹配目标池（`valve_id` 来自 `Processer` 入参）。

package/skills/lab-flow-designer/references/agentic-lab-processer.md

@@ -1,6 +1,6 @@
 > Agentic Lab 门控脚本
 >
-> `this.context` 上可用的 SDK 方法详见 [agentic-lab-sdk.md](agentic-lab-sdk.md)。本文件仅定义 `Processer` 类的 `start`/`complete` 输入输出类型与代码风格。
+> `this.context` 上可用的 SDK 方法详见 [agentic-lab-sdk.md](agentic-lab-sdk.md)。本文件定义 `Processer` 类的 `start`/`complete`（人工触发门控）与 `run`（自动触发门控）输入输出类型与代码风格。
 
 ### 类型定义
 
@@ -39,8 +39,27 @@ interface CompleteExecutionResult {
 async complete(params: CompleteExecutionParams): Promise<CompleteExecutionResult>
 ```
 
+#### run（自动触发门控专用）
 
-### 示例
+自动触发门控不经过人工处理阶段，使用 `run` 替代 `start` + `complete`。`run` 合并了前置与后置处理：接收 `valve_id` 与 `pool_ids`（同 `start`），直接返回 `new_tickets`（同 `complete`），无需 `orbit_link` 或 `ticket_ids`。
+
+```typescript
+interface RunExecutionParams {
+  valve_id: number;
+  pool_ids: number[];
+  [propName: string]: any;
+}
+
+interface RunExecutionResult {
+  new_tickets?: Record<string, any>[]; // 待新增的tickets，由引擎创建到数据表
+  [propName: string]: any;
+}
+
+async run(params: RunExecutionParams): Promise<RunExecutionResult>
+```
+
+
+### 示例（人工触发门控）
 
 ```javascript
 class Processer {
@@ -76,3 +95,28 @@ class Processer {
 ```
 
 完整可运行代码参考见 [`embedded-template/scripts/示例数据与校验门控.js`](../embedded-template/scripts/示例数据与校验门控.js)。
+
+### 示例（自动触发门控）
+
+```javascript
+class Processer {
+  // context: 执行引擎提供的SDK
+  constructor(context) {
+    this.context = context;
+    console.info(`[Processer] v${__ARTIFACT_VERSION__} (skill: ${__ARTIFACT_SKILL__})`);
+  }
+
+  // params: { valve_id, pool_ids }
+  async run(params) {
+    // 按 agentic-lab-sdk.md 查询入口池数据
+    // 按需调用 SDK 方法查询化合物/工站/流程等外部数据
+    // 执行业务逻辑（无人工处理阶段）
+    // 按 agentic-lab-sdk.md 获取出口池
+    // 将入口池 tickets 更新为 finished 状态
+    // 按出口池 Schema 映射 new_tickets
+    return {
+      new_tickets: [/* 按出口池映射的新 tickets */]
+    }
+  }
+}
+```

package/skills/lab-flow-designer/references/skill-package-layout.md

@@ -86,7 +86,7 @@ metadata:
 
 ### 2.5 `## 门控执行规范` 代码块（`Processer` 类骨架，须保留；不含脚本尾部导出）
 
-门控执行顺序：**前置处理（脚本 `start`）→ 人工处理（页面）→ 后置处理（脚本 `complete`）**。参数与返回值**一律 snake_case**（对齐 [agentic-lab-processer.md](agentic-lab-processer.md)）。
+门控执行顺序：**前置处理（脚本 `start`）→ 人工处理（页面）→ 后置处理（脚本 `complete`）**（人工触发门控）或 **`run`**（自动触发门控）。参数与返回值**一律 snake_case**（对齐 [agentic-lab-processer.md](agentic-lab-processer.md)）。
 
 ```javascript
 class Processer {
@@ -117,6 +117,26 @@ class Processer {
 }
 ```
 
+**自动触发门控**的 `Processer` 骨架使用 `run` 替代 `start` + `complete`（详见 [agentic-lab-processer.md](agentic-lab-processer.md)）：
+
+```javascript
+class Processer {
+  constructor(context) {
+    this.context = context;
+    console.info(`[Processer] v${__ARTIFACT_VERSION__} (skill: ${__ARTIFACT_SKILL__})`);
+  }
+
+  // --- 自动触发 → run ---
+  // params: { valve_id, pool_ids }
+  // returns: { new_tickets }
+  async run(params) {
+    const { valve_id, pool_ids } = params;
+    // 查询入口池数据 → 执行业务逻辑 → 获取出口池 → 入口池 tickets 更新为 finished → 映射 new_tickets
+    return { new_tickets };
+  }
+}
+```
+
 ### 2.6 `## 使用方式`（三条，语义对齐）
 
 ```markdown
@@ -152,6 +172,21 @@ class Processer {
 
 **属性列规则**：流程说明里若写清枚举/可选值，写入 `枚举：…`；若写清日期或时间串格式，写入 `格式：…`；否则该格留空。
 
+### 模型引用（可选）
+
+若流程说明为该数据池指定了 3D 模型文件，在 `## Schema` 之后添加：
+
+```markdown
+## 模型引用
+
+| 属性 | 值 |
+|------|-----|
+| 名称 | （模型文件名称） |
+| 版本 | （模型版本） |
+```
+
+无模型引用时**省略本节**（不写空占位）。
+
 ---
 
 ## 4. `valves/<基名>.md` 格式（节选范例）
@@ -182,6 +217,35 @@ class Processer {
 - **输出池**: 出口池
 ```
 
+### 触发方式（推荐，缺省为人工触发）
+
+每个门控文档建议在 `## 关联脚本` 之后包含 `## 触发方式`：
+
+```markdown
+## 触发方式
+
+人工触发
+```
+
+取值为 `自动触发` 或 `人工触发`。未指定时默认按**人工触发**处理：
+- **人工触发**（默认）：门控执行顺序为 前置处理（脚本 `start`）→ 人工处理（页面）→ 后置处理（脚本 `complete`），脚本实现 `start` + `complete`。
+- **自动触发**：门控无人工处理阶段，脚本实现 `run` 方法（见 [agentic-lab-processer.md](agentic-lab-processer.md)）。
+
+### 模型引用（可选）
+
+若流程说明为该门控指定了 3D 模型文件，添加：
+
+```markdown
+## 模型引用
+
+| 属性 | 值 |
+|------|-----|
+| 名称 | （模型文件名称） |
+| 版本 | （模型版本） |
+```
+
+无模型引用时**省略本节**（不写空占位）。
+
 ---
 
 ## 5. `scripts/<基名>.js` 格式

package/skills/lab-flow-designer/references//344/270/232/345/212/241/346/265/201/347/250/213/346/226/207/346/241/243/346/240/207/345/207/206.md

@@ -64,6 +64,8 @@
 **检查点**：每个在拓扑与门控 YAML 中出现的池，表中有一行；**显示名称**与 YAML `input`/`output` 中的池名一致。  
 **检查点**：**逻辑 ID** 在同一文档内唯一（如 `stash_input`），且仅使用字母、数字、下划线（便于下游映射）。
 
+**模型引用（可选）**：若数据池关联 3D 模型，须在该池的描述中包含 `模型引用` 标题子节，写明模型名称与版本。无关联模型时省略。
+
 ---
 
 ### 2.4 `## 4. 池间流转（拓扑）`（必备）
@@ -97,13 +99,17 @@
 
 对每个门控，建议按下列顺序组织（可合并标题，但**信息不得缺**）：
 
+> **标题层级**：下列各项标题文字（如「触发方式」「模型引用」等）的 Markdown 层级（`##` / `###` / `####`）取决于门控在文档中的嵌套深度，以标题文字匹配为准，不要求固定 `#` 数量。
+
 1. **门控标题**：`### 5.x <门控显示名称>`（编号与 `order` 建议一致或递增）。  
 2. **YAML 代码块**：`yaml`，须含 `name`、`order`、`input`、`output`；**`valve_id` 可选**（若写则全文档唯一）。  
    - 目标池键名可使用 `Stash:` 等非标准键，但须在总述或脚注说明与实现侧 **pool 显示名称** 的对应关系。  
-3. **化合物 / 外部数据查询方式**（若本门控需要）：说明查哪类库、用哪些入口字段作键、汇总规则等。  
-4. **字段映射表**（若存在库表/API 列与门控加工字段对应）：两列表头清晰（如「门控加工数据 | 库字段」）。  
-5. **数据处理规则表**（强烈推荐）：列至少包含 **`序号` | `规则摘要` | `条件要点` | `业务动作或结果`**；序号建议 **章内连续小数编号**（如 `1.1`、`1.2`，与门控章节号前缀一致），便于脚本注释逐条对应。  
-6. **操作员步骤**（若为人工门控）：编号列表，步骤可执行、可验收。
+3. **触发方式**（推荐，缺省为人工触发）：`触发方式` 标题，取值 `自动触发` 或 `人工触发`。未指定时默认按**人工触发**处理。自动触发门控无人工处理阶段，脚本实现 `run`；人工触发门控脚本实现 `start` + `complete`。
+4. **化合物 / 外部数据查询方式**（若本门控需要）：说明查哪类库、用哪些入口字段作键、汇总规则等。  
+5. **字段映射表**（若存在库表/API 列与门控加工字段对应）：两列表头清晰（如「门控加工数据 | 库字段」）。  
+6. **数据处理规则表**（强烈推荐）：列至少包含 **`序号` | `规则摘要` | `条件要点` | `业务动作或结果`**；序号建议 **章内连续小数编号**（如 `1.1`、`1.2`，与门控章节号前缀一致），便于脚本注释逐条对应。  
+7. **操作员步骤**（若为人工门控）：编号列表，步骤可执行、可验收。
+8. **模型引用**（若本门控关联 3D 模型）：`模型引用` 标题，写明模型名称与版本。无关联模型时省略。
 
 **Process 批量提交（可选）**：若门控需触发 **Rhea / 设备侧批量提交任务**，须在流程文档中写明调用时机、**`items` 每条**中的 **`process`（流程模板名，即 process_name 语义）**、**`params` / `table_objects` 等如何从业务数据拼装**，以及 **`baseURL`（服务根地址）的语义来源**（配置、环境变量、订单字段等，由集成解析为字符串 URL）。**path、HTTP 方法** 由 SDK 固定，流程文档**不要求**写 path / method；生成脚本时映射为 SDK 中对应方法（见 [`references/agentic-lab-sdk.md`](agentic-lab-sdk.md)；Wire 细节见 [`references/rhea-api/execute_process_batch.md`](rhea-api/execute_process_batch.md) 供预检对照 `items[]` 形状）。
 
@@ -182,6 +188,8 @@
 - [ ] **§3.1**：门控规则与 `output` 条件可判定，无未定义模糊用语；分支互斥或优先级已说明。  
 - [ ] **§3.2**：所提依赖、**SDK/API**、字段均在 **agentic-lab-sdk**（及已列 rhea-api）与 §2 中有依据；**无不支持或未文档化的 API**。  
 - [ ] **§3.3**：凡 **Process / 任务提交 / SDK 调用**，**`items`** 与 **`baseURL` 语义**可对照 **agentic-lab-sdk + rhea-api** 校验；其它查询的分页与 **filter** 意图可落地；**不**要求流程写 path/HTTP 方法。
+- [ ] **触发方式**（推荐）：建议每个门控含 `触发方式` 标题（`自动触发` 或 `人工触发`）；未指定时默认为人工触发。自动触发门控无操作员步骤与人工处理章节。
+- [ ] **模型引用**：关联 3D 模型的数据池或门控含 `模型引用` 标题（模型名称、模型版本）；无关联模型时可省略。
 
 ---
 

package/skills/lab-flow-designer/templates//344/270/232/345/212/241/346/265/201/347/250/213/346/226/207/346/241/243/346/250/241/346/235/277.md

@@ -60,6 +60,14 @@
 
 > **提示**：显示名称须与门控 YAML 中的 `input`/`output` 池名逐字一致（含标点、中间点「·」等）。逻辑 ID 仅使用小写字母、数字、下划线。
 
+### 3.1 数据池模型引用（按需）
+
+> 若数据池关联 3D 模型，在此列出模型信息。无关联模型时省略本节。
+
+| 池显示名称 | 模型名称 | 模型版本 |
+| --------- | ------- | ------- |
+| （例：待处理池） | （例：reactor_v2） | （例：1.0.0） |
+
 ***
 
 ## 4. 池间流转（拓扑）
@@ -111,6 +119,10 @@ output:
     condition: （路由条件）
 ```
 
+#### 触发方式
+
+（自动触发 / 人工触发）
+
 **化合物数据查询方式**（若本门控需要查询外部数据）
 
 （说明查哪类库、用哪些入口字段作键、返回什么、汇总规则等）
@@ -133,6 +145,13 @@ output:
 1. （步骤描述，可执行、可验收）
 2. （...）
 
+**模型引用**（若本门控关联 3D 模型，无则省略）
+
+| 属性 | 值 |
+|------|-----|
+| 名称 | （模型名称） |
+| 版本 | （模型版本） |
+
 ***
 
 ### 5.2 （门控 2 显示名称）
@@ -149,13 +168,17 @@ output:
     condition: （路由条件）
 ```
 
+#### 触发方式
+
+（自动触发 / 人工触发）
+
 **数据处理规则**
 
 | 序号 | 规则摘要 | 条件要点 | 业务动作或结果 |
 | --- | ------- | ------- | ----------- |
 | 2.1 | （简述） | （条件） | （动作或路由结果） |
 
-> **提示**：按需复制门控子节，每个门控至少包含 YAML 代码块和数据处理规则表。需查询外部数据的加「查询方式」和「字段映射表」，人工门控加「操作员步骤」。
+> **提示**：按需复制门控子节，每个门控至少包含 YAML 代码块和触发方式。需查询外部数据的加「查询方式」和「字段映射表」，含计算/判定的加「数据处理规则」，人工触发门控加「操作员步骤」，关联 3D 模型的加「模型引用」。
 
 ***
 

package/skills/lab-flow-designer/templates//344/270/232/345/212/241/346/265/201/347/250/213/346/226/207/346/241/243/347/244/272/344/276/213.md

@@ -76,6 +76,8 @@
 | 缺料化合物池 | `stash_missing` | 异常池 | 无可用源瓶或库存不足 |
 | 已分装化合物池 | `stash_done` | 终点池 | 交货确认完成，流程结束 |
 
+> **提示**：本流程数据池未关联 3D 模型，故省略模型引用。
+
 ***
 
 ## 4. 池间流转（拓扑）
@@ -133,6 +135,10 @@ output:
     condition: 是否缺料 = 缺料
 ```
 
+#### 触发方式
+
+人工触发
+
 **化合物数据查询方式**
 
 查询化合物库存的可用量：使用输入池 Compound ID 作为索引，通过 XFC 上海系统接口查询化合物库存（`compound.getStockFromXfcSh`），查找 status = 可用的记录，返回可用量字段的值并汇总加和。
@@ -174,6 +180,10 @@ output:
     condition: 任一档位偏差超出容差或其它执行失败情形
 ```
 
+#### 触发方式
+
+人工触发
+
 **数据处理规则**
 
 | 序号 | 规则摘要 | 条件要点 | 业务动作或结果 |

package/skills/lab-flow-designer/testing/test-processer.mjs

@@ -356,6 +356,34 @@ function validateCompleteResult(result) {
   return errors;
 }
 
+function validateRunResult(result) {
+  const errors = [];
+  if (typeof result !== 'object' || result === null) {
+    errors.push('run() must return an object, got ' + (result === null ? 'null' : typeof result));
+    return errors;
+  }
+  if (result.new_tickets !== undefined) {
+    if (!Array.isArray(result.new_tickets)) {
+      errors.push(`run().new_tickets must be array, got ${typeof result.new_tickets}`);
+    } else {
+      for (let i = 0; i < Math.min(result.new_tickets.length, 3); i++) {
+        const t = result.new_tickets[i];
+        if (typeof t.flow_id !== 'number') errors.push(`new_tickets[${i}].flow_id must be number, got ${typeof t.flow_id}`);
+        if (typeof t.pool_id !== 'number') errors.push(`new_tickets[${i}].pool_id must be number, got ${typeof t.pool_id}`);
+        if (typeof t.order_id !== 'number') errors.push(`new_tickets[${i}].order_id must be number, got ${typeof t.order_id}`);
+        if (typeof t.detail !== 'object' || t.detail === null) errors.push(`new_tickets[${i}].detail must be object`);
+        if (typeof t.status !== 'string') errors.push(`new_tickets[${i}].status must be string, got ${typeof t.status}`);
+      }
+    }
+  }
+  for (const key of Object.keys(result)) {
+    if (CAMEL_CASE_PATTERN.test(key)) {
+      errors.push(`run() return key "${key}" is camelCase — must be snake_case`);
+    }
+  }
+  return errors;
+}
+
 // ─── Script loader via vm ──────────────────────────────────────────
 
 function loadProcesserClass(scriptContent, filename) {
@@ -621,8 +649,10 @@ function formatTicketsTable(tickets, maxDetailKeys) {
 
 function formatPreviewReport(trace) {
   const { scriptPath, valveName, valveConfig, pools, dataSource,
-          inputTickets, startResult, startError, startTraceLog, startDetailDiffs,
-          completeTickets, completeResult, completeError, completeTraceLog, completeDetailDiffs } = trace;
+          inputTickets, isAutoTrigger,
+          startResult, startError, startTraceLog, startDetailDiffs,
+          completeTickets, completeResult, completeError, completeTraceLog, completeDetailDiffs,
+          runResult, runError, runTraceLog, runDetailDiffs } = trace;
 
   const lines = [];
   const push = (...args) => lines.push(...args);
@@ -638,108 +668,176 @@ function formatPreviewReport(trace) {
   push(`- 入口池: ${inputPoolNames}`);
   push(`- 出口池: ${outputPoolNames}`);
   push(`- 数据来源: ${dataSource}`);
-  push(`- tickets 数: ${inputTickets.length}`, '');
+  push(`- tickets 数: ${inputTickets.length}`);
+  push(`- 触发方式: ${isAutoTrigger ? '自动触发 (run)' : '人工触发 (start/complete)'}`, '');
+
+  if (isAutoTrigger) {
+    // run() trace
+    push('## run() 执行追踪', '');
+    push(`### 输入数据 (${inputTickets.length} 条 tickets)`, '');
+    push(formatTicketsTable(inputTickets));
+
+    push('### SDK 调用链', '');
+    for (const entry of (runTraceLog || [])) {
+      const paramStr = JSON.stringify(entry.params);
+      push(`${entry.seq + 1}. \`${entry.method}(${paramStr === '{}' ? '' : paramStr})\` → ${entry.returnSummary}`);
+    }
+    push('');
 
-  // start() trace
-  push('## start() 执行追踪', '');
-  push(`### 输入数据 (${inputTickets.length} 条 tickets)`, '');
-  push(formatTicketsTable(inputTickets));
+    if (runDetailDiffs && runDetailDiffs.length > 0) {
+      push('### ticket.detail 变更 (run 阶段)', '');
+      push('| ticket | 字段 | 变更前 | 变更后 |');
+      push('|--------|------|--------|--------|');
+      for (const d of runDetailDiffs) {
+        for (const c of d.changes) {
+          push(`| #${d.ticketId} | ${c.key} | ${c.before} | ${c.after} |`);
+        }
+      }
+      push('');
+    }
 
-  push('### SDK 调用链', '');
-  for (const entry of startTraceLog) {
-    const paramStr = JSON.stringify(entry.params);
-    push(`${entry.seq + 1}. \`${entry.method}(${paramStr === '{}' ? '' : paramStr})\` → ${entry.returnSummary}`);
-  }
-  push('');
-
-  if (startDetailDiffs.length > 0) {
-    push('### ticket.detail 变更 (start 阶段)', '');
-    push('| ticket | 字段 | 变更前 | 变更后 |');
-    push('|--------|------|--------|--------|');
-    for (const d of startDetailDiffs) {
-      for (const c of d.changes) {
-        push(`| #${d.ticketId} | ${c.key} | ${c.before} | ${c.after} |`);
+    if (runError) {
+      push(`### run() 错误`, '');
+      push(`\`\`\`\n${runError}\n\`\`\``, '');
+    } else if (runResult) {
+      push('### 数据路由', '');
+      if (runResult.new_tickets && runResult.new_tickets.length > 0) {
+        const routeMap = new Map();
+        for (const nt of runResult.new_tickets) {
+          const poolId = nt.pool_id;
+          if (!routeMap.has(poolId)) routeMap.set(poolId, []);
+          routeMap.get(poolId).push(nt);
+        }
+        push('| 目标池 | pool_id | 数量 | status |');
+        push('|--------|---------|------|--------|');
+        for (const [poolId, nts] of routeMap) {
+          const poolName = valveConfig.output_pools.find((_, i) => 100 + i === poolId)?.name || `pool_${poolId}`;
+          push(`| ${poolName} | ${poolId} | ${nts.length} | ${nts[0]?.status || '-'} |`);
+        }
+        push('');
+      } else {
+        push('(无 new_tickets 返回)', '');
       }
     }
-    push('');
-  }
 
-  if (startError) {
-    push(`### start() 错误`, '');
-    push(`\`\`\`\n${startError}\n\`\`\``, '');
-  } else if (startResult) {
-    push('### 返回值', '');
-    push(`- orbit_link: \`${startResult.orbit_link}\``);
-    push(`- ticket_ids: [${(startResult.ticket_ids || []).join(', ')}]`);
-    push('');
-  }
+    // Summary
+    push('## 执行摘要', '');
+    const usedMethods = new Set((runTraceLog || []).map(c => c.method));
+    const allMethods = ['ticket.list', 'ticket.update', 'ticket.append', 'pool.getNext',
+      'compound.getStockFromXfcSh', 'process.list', 'process.execute', 'station.list'];
+    const unused = allMethods.filter(m => !usedMethods.has(m));
 
-  // complete() trace
-  push('## complete() 执行追踪', '');
-  push(`### 输入 tickets (${(completeTickets || []).length} 条)`, '');
+    const runStatus = runError
+      ? `✗ 失败: ${runError.split('\n')[0]}`
+      : `✓ 成功 (${(runTraceLog || []).length} SDK 调用, ${(runResult?.new_tickets || []).length} new_tickets)`;
 
-  push('### SDK 调用链', '');
-  for (const entry of completeTraceLog) {
-    const paramStr = JSON.stringify(entry.params);
-    push(`${entry.seq + 1}. \`${entry.method}(${paramStr === '{}' ? '' : paramStr})\` → ${entry.returnSummary}`);
-  }
-  push('');
-
-  if (completeDetailDiffs.length > 0) {
-    push('### ticket.detail 变更 (complete 阶段)', '');
-    push('| ticket | 字段 | 变更前 | 变更后 |');
-    push('|--------|------|--------|--------|');
-    for (const d of completeDetailDiffs) {
-      for (const c of d.changes) {
-        push(`| #${d.ticketId} | ${c.key} | ${c.before} | ${c.after} |`);
-      }
+    push(`- run: ${runStatus}`);
+    if (unused.length > 0) {
+      push(`- 未调用的 SDK 方法: ${unused.join(', ')}`);
+    }
+    push('');
+  } else {
+    // start() trace
+    push('## start() 执行追踪', '');
+    push(`### 输入数据 (${inputTickets.length} 条 tickets)`, '');
+    push(formatTicketsTable(inputTickets));
+
+    push('### SDK 调用链', '');
+    for (const entry of startTraceLog) {
+      const paramStr = JSON.stringify(entry.params);
+      push(`${entry.seq + 1}. \`${entry.method}(${paramStr === '{}' ? '' : paramStr})\` → ${entry.returnSummary}`);
     }
     push('');
-  }
 
-  if (completeError) {
-    push(`### complete() 错误`, '');
-    push(`\`\`\`\n${completeError}\n\`\`\``, '');
-  } else if (completeResult) {
-    push('### 数据路由', '');
-    if (completeResult.new_tickets && completeResult.new_tickets.length > 0) {
-      const routeMap = new Map();
-      for (const nt of completeResult.new_tickets) {
-        const poolId = nt.pool_id;
-        if (!routeMap.has(poolId)) routeMap.set(poolId, []);
-        routeMap.get(poolId).push(nt);
+    if (startDetailDiffs.length > 0) {
+      push('### ticket.detail 变更 (start 阶段)', '');
+      push('| ticket | 字段 | 变更前 | 变更后 |');
+      push('|--------|------|--------|--------|');
+      for (const d of startDetailDiffs) {
+        for (const c of d.changes) {
+          push(`| #${d.ticketId} | ${c.key} | ${c.before} | ${c.after} |`);
+        }
       }
-      push('| 目标池 | pool_id | 数量 | status |');
-      push('|--------|---------|------|--------|');
-      for (const [poolId, nts] of routeMap) {
-        const poolName = valveConfig.output_pools.find((_, i) => 100 + i === poolId)?.name || `pool_${poolId}`;
-        push(`| ${poolName} | ${poolId} | ${nts.length} | ${nts[0]?.status || '-'} |`);
+      push('');
+    }
+
+    if (startError) {
+      push(`### start() 错误`, '');
+      push(`\`\`\`\n${startError}\n\`\`\``, '');
+    } else if (startResult) {
+      push('### 返回值', '');
+      push(`- orbit_link: \`${startResult.orbit_link}\``);
+      push(`- ticket_ids: [${(startResult.ticket_ids || []).join(', ')}]`);
+      push('');
+    }
+
+    // complete() trace
+    push('## complete() 执行追踪', '');
+    push(`### 输入 tickets (${(completeTickets || []).length} 条)`, '');
+
+    push('### SDK 调用链', '');
+    for (const entry of completeTraceLog) {
+      const paramStr = JSON.stringify(entry.params);
+      push(`${entry.seq + 1}. \`${entry.method}(${paramStr === '{}' ? '' : paramStr})\` → ${entry.returnSummary}`);
+    }
+    push('');
+
+    if (completeDetailDiffs.length > 0) {
+      push('### ticket.detail 变更 (complete 阶段)', '');
+      push('| ticket | 字段 | 变更前 | 变更后 |');
+      push('|--------|------|--------|--------|');
+      for (const d of completeDetailDiffs) {
+        for (const c of d.changes) {
+          push(`| #${d.ticketId} | ${c.key} | ${c.before} | ${c.after} |`);
+        }
       }
       push('');
-    } else {
-      push('(无 new_tickets 返回)', '');
     }
-  }
 
-  // Summary
-  push('## 执行摘要', '');
-  const allCalls = [...startTraceLog, ...completeTraceLog];
-  const usedMethods = new Set(allCalls.map(c => c.method));
-  const allMethods = ['ticket.list', 'ticket.update', 'ticket.append', 'pool.getNext',
-    'compound.getStockFromXfcSh', 'process.list', 'process.execute', 'station.list'];
-  const unused = allMethods.filter(m => !usedMethods.has(m));
-
-  const startStatus = startError ? `✗ 失败: ${startError.split('\n')[0]}` : `✓ 成功 (${startTraceLog.length} SDK 调用, ${inputTickets.length} tickets)`;
-  const completeStatus = completeError
-    ? `✗ 失败: ${completeError.split('\n')[0]}`
-    : `✓ 成功 (${completeTraceLog.length} SDK 调用, ${(completeResult?.new_tickets || []).length} new_tickets)`;
-
-  push(`- start: ${startStatus}`);
-  push(`- complete: ${completeStatus}`);
-  if (unused.length > 0) {
-    push(`- 未调用的 SDK 方法: ${unused.join(', ')}`);
+    if (completeError) {
+      push(`### complete() 错误`, '');
+      push(`\`\`\`\n${completeError}\n\`\`\``, '');
+    } else if (completeResult) {
+      push('### 数据路由', '');
+      if (completeResult.new_tickets && completeResult.new_tickets.length > 0) {
+        const routeMap = new Map();
+        for (const nt of completeResult.new_tickets) {
+          const poolId = nt.pool_id;
+          if (!routeMap.has(poolId)) routeMap.set(poolId, []);
+          routeMap.get(poolId).push(nt);
+        }
+        push('| 目标池 | pool_id | 数量 | status |');
+        push('|--------|---------|------|--------|');
+        for (const [poolId, nts] of routeMap) {
+          const poolName = valveConfig.output_pools.find((_, i) => 100 + i === poolId)?.name || `pool_${poolId}`;
+          push(`| ${poolName} | ${poolId} | ${nts.length} | ${nts[0]?.status || '-'} |`);
+        }
+        push('');
+      } else {
+        push('(无 new_tickets 返回)', '');
+      }
+    }
+
+    // Summary
+    push('## 执行摘要', '');
+    const allCalls = [...startTraceLog, ...completeTraceLog];
+    const usedMethods = new Set(allCalls.map(c => c.method));
+    const allMethods = ['ticket.list', 'ticket.update', 'ticket.append', 'pool.getNext',
+      'compound.getStockFromXfcSh', 'process.list', 'process.execute', 'station.list'];
+    const unused = allMethods.filter(m => !usedMethods.has(m));
+
+    const startStatus = startError ? `✗ 失败: ${startError.split('\n')[0]}` : `✓ 成功 (${startTraceLog.length} SDK 调用, ${inputTickets.length} tickets)`;
+    const completeStatus = completeError
+      ? `✗ 失败: ${completeError.split('\n')[0]}`
+      : `✓ 成功 (${completeTraceLog.length} SDK 调用, ${(completeResult?.new_tickets || []).length} new_tickets)`;
+
+    push(`- start: ${startStatus}`);
+    push(`- complete: ${completeStatus}`);
+    if (unused.length > 0) {
+      push(`- 未调用的 SDK 方法: ${unused.join(', ')}`);
+    }
+    push('');
   }
-  push('');
 
   return lines.join('\n');
 }
@@ -787,59 +885,85 @@ async function runPreview(args) {
   }
 
   const inputPoolIds = valveConfig.input_pools.map((_, i) => i + 1);
+  const proto = ProcesserClass.prototype;
+  const isAutoTrigger = typeof proto.run === 'function' && typeof proto.start !== 'function';
+
   const trace = {
-    scriptPath, valveName, valveConfig, pools, dataSource, inputTickets,
+    scriptPath, valveName, valveConfig, pools, dataSource, inputTickets, isAutoTrigger,
     startResult: null, startError: null, startTraceLog: [], startDetailDiffs: [],
     completeTickets: null, completeResult: null, completeError: null, completeTraceLog: [], completeDetailDiffs: [],
+    runResult: null, runError: null, runTraceLog: [], runDetailDiffs: [],
   };
 
-  // Run start()
-  {
+  if (isAutoTrigger) {
+    // Auto-trigger: run()
     const tc = createTracingContext(pools, valveConfig, inputTickets);
     let processer;
     try {
       processer = new ProcesserClass(tc.context);
     } catch (e) {
-      trace.startError = `constructor threw: ${e.message}\n${e.stack}`;
+      trace.runError = `constructor threw: ${e.message}\n${e.stack}`;
       console.log(formatPreviewReport(trace));
       process.exit(1);
     }
 
     try {
-      trace.startResult = await processer.start({ valve_id: 1, pool_ids: inputPoolIds });
+      trace.runResult = await processer.run({ valve_id: 1, pool_ids: inputPoolIds });
     } catch (e) {
-      trace.startError = `${e.constructor.name}: ${e.message}\n${e.stack}`;
+      trace.runError = `${e.constructor.name}: ${e.message}\n${e.stack}`;
     }
-    trace.startTraceLog = tc.traceLog;
-    trace.startDetailDiffs = tc.detailDiffs;
-  }
-
-  // Run complete()
-  {
-    const completeTickets = inputTickets.map(t => ({ ...t, status: 'created' }));
-    trace.completeTickets = completeTickets;
+    trace.runTraceLog = tc.traceLog;
+    trace.runDetailDiffs = tc.detailDiffs;
+  } else {
+    // Manual-trigger: start() + complete()
+    // Run start()
+    {
+      const tc = createTracingContext(pools, valveConfig, inputTickets);
+      let processer;
+      try {
+        processer = new ProcesserClass(tc.context);
+      } catch (e) {
+        trace.startError = `constructor threw: ${e.message}\n${e.stack}`;
+        console.log(formatPreviewReport(trace));
+        process.exit(1);
+      }
 
-    const tc = createTracingContext(pools, valveConfig, completeTickets);
-    let processer;
-    try {
-      processer = new ProcesserClass(tc.context);
-    } catch (e) {
-      trace.completeError = `constructor threw: ${e.message}\n${e.stack}`;
-      console.log(formatPreviewReport(trace));
-      process.exit(1);
+      try {
+        trace.startResult = await processer.start({ valve_id: 1, pool_ids: inputPoolIds });
+      } catch (e) {
+        trace.startError = `${e.constructor.name}: ${e.message}\n${e.stack}`;
+      }
+      trace.startTraceLog = tc.traceLog;
+      trace.startDetailDiffs = tc.detailDiffs;
     }
 
-    try {
-      trace.completeResult = await processer.complete({ valve_id: 1, tickets: completeTickets });
-    } catch (e) {
-      trace.completeError = `${e.constructor.name}: ${e.message}\n${e.stack}`;
+    // Run complete()
+    {
+      const completeTickets = inputTickets.map(t => ({ ...t, status: 'created' }));
+      trace.completeTickets = completeTickets;
+
+      const tc = createTracingContext(pools, valveConfig, completeTickets);
+      let processer;
+      try {
+        processer = new ProcesserClass(tc.context);
+      } catch (e) {
+        trace.completeError = `constructor threw: ${e.message}\n${e.stack}`;
+        console.log(formatPreviewReport(trace));
+        process.exit(1);
+      }
+
+      try {
+        trace.completeResult = await processer.complete({ valve_id: 1, tickets: completeTickets });
+      } catch (e) {
+        trace.completeError = `${e.constructor.name}: ${e.message}\n${e.stack}`;
+      }
+      trace.completeTraceLog = tc.traceLog;
+      trace.completeDetailDiffs = tc.detailDiffs;
     }
-    trace.completeTraceLog = tc.traceLog;
-    trace.completeDetailDiffs = tc.detailDiffs;
   }
 
   console.log(formatPreviewReport(trace));
-  const hasError = trace.startError || trace.completeError;
+  const hasError = isAutoTrigger ? trace.runError : (trace.startError || trace.completeError);
   process.exit(hasError ? 1 : 0);
 }
 
@@ -856,7 +980,7 @@ async function runTests(args) {
     script: scriptPath,
     phases: {
       syntax: { pass: false },
-      structure: { pass: false, hasConstructor: false, hasStart: false, hasComplete: false },
+      structure: { pass: false, hasConstructor: false, hasStart: false, hasComplete: false, hasRun: false },
       normalRun: {
         start: { pass: false, returnValid: false, errors: [] },
         complete: { pass: false, returnValid: false, errors: [] },
@@ -914,18 +1038,23 @@ async function runTests(args) {
   result.phases.structure.hasConstructor = typeof ProcesserClass === 'function';
   result.phases.structure.hasStart = typeof proto.start === 'function';
   result.phases.structure.hasComplete = typeof proto.complete === 'function';
+  result.phases.structure.hasRun = typeof proto.run === 'function';
   result.phases.structure.pass =
     result.phases.structure.hasConstructor &&
-    result.phases.structure.hasStart &&
-    result.phases.structure.hasComplete;
+    (
+      (result.phases.structure.hasStart && result.phases.structure.hasComplete) ||
+      result.phases.structure.hasRun
+    );
 
   if (!result.phases.structure.pass) {
-    if (!result.phases.structure.hasStart) result.errors.push('Processer missing start() method');
-    if (!result.phases.structure.hasComplete) result.errors.push('Processer missing complete() method');
+    if (!result.phases.structure.hasRun && !result.phases.structure.hasStart) result.errors.push('Processer missing start() method (manual-trigger) or run() method (auto-trigger)');
+    if (!result.phases.structure.hasRun && !result.phases.structure.hasComplete) result.errors.push('Processer missing complete() method (manual-trigger) or run() method (auto-trigger)');
     result.status = 'fail';
     return result;
   }
 
+  const isAutoTrigger = result.phases.structure.hasRun && !result.phases.structure.hasStart;
+
   // Load pool schemas and valve config
   const pools = loadAllPools(poolsDir);
   const valveConfig = loadValveConfig(valvesDir, valveName);
@@ -938,41 +1067,62 @@ async function runTests(args) {
     try {
       processer = new ProcesserClass(mock.context);
     } catch (e) {
-      result.phases.normalRun.start.errors.push(`constructor threw: ${e.message}`);
+      const phaseKey = isAutoTrigger ? 'run' : 'start';
+      if (!result.phases.normalRun[phaseKey]) result.phases.normalRun[phaseKey] = { pass: false, returnValid: false, errors: [] };
+      result.phases.normalRun[phaseKey].errors.push(`constructor threw: ${e.message}`);
       result.errors.push(`Normal run constructor error: ${e.message}`);
       result.status = 'fail';
       return result;
     }
 
-    // start
-    try {
-      const startResult = await processer.start({ valve_id: 1, pool_ids: inputPoolIds });
-      const startErrors = validateStartResult(startResult);
-      result.phases.normalRun.start.returnValid = startErrors.length === 0;
-      result.phases.normalRun.start.errors = startErrors;
-      result.phases.normalRun.start.pass = startErrors.length === 0;
-      if (startErrors.length > 0) {
-        result.errors.push(...startErrors.map(e => `[normal start] ${e}`));
+    if (isAutoTrigger) {
+      // Auto-trigger: test run()
+      if (!result.phases.normalRun.run) result.phases.normalRun.run = { pass: false, returnValid: false, errors: [] };
+      try {
+        const runResult = await processer.run({ valve_id: 1, pool_ids: inputPoolIds });
+        const runErrors = validateRunResult(runResult);
+        result.phases.normalRun.run.returnValid = runErrors.length === 0;
+        result.phases.normalRun.run.errors = runErrors;
+        result.phases.normalRun.run.pass = runErrors.length === 0;
+        if (runErrors.length > 0) {
+          result.errors.push(...runErrors.map(e => `[normal run] ${e}`));
+        }
+      } catch (e) {
+        result.phases.normalRun.run.errors.push(e.message);
+        result.errors.push(`[normal run] Runtime error: ${e.message}`);
+      }
+    } else {
+      // Manual-trigger: test start() + complete()
+      // start
+      try {
+        const startResult = await processer.start({ valve_id: 1, pool_ids: inputPoolIds });
+        const startErrors = validateStartResult(startResult);
+        result.phases.normalRun.start.returnValid = startErrors.length === 0;
+        result.phases.normalRun.start.errors = startErrors;
+        result.phases.normalRun.start.pass = startErrors.length === 0;
+        if (startErrors.length > 0) {
+          result.errors.push(...startErrors.map(e => `[normal start] ${e}`));
+        }
+      } catch (e) {
+        result.phases.normalRun.start.errors.push(e.message);
+        result.errors.push(`[normal start] Runtime error: ${e.message}`);
       }
-    } catch (e) {
-      result.phases.normalRun.start.errors.push(e.message);
-      result.errors.push(`[normal start] Runtime error: ${e.message}`);
-    }
 
-    // complete — use mock tickets from the start phase (with updated details if any)
-    try {
-      const completeTickets = mock.mockTickets.map(t => ({ ...t, status: 'created' }));
-      const completeResult = await processer.complete({ valve_id: 1, tickets: completeTickets });
-      const completeErrors = validateCompleteResult(completeResult);
-      result.phases.normalRun.complete.returnValid = completeErrors.length === 0;
-      result.phases.normalRun.complete.errors = completeErrors;
-      result.phases.normalRun.complete.pass = completeErrors.length === 0;
-      if (completeErrors.length > 0) {
-        result.errors.push(...completeErrors.map(e => `[normal complete] ${e}`));
+      // complete — use mock tickets from the start phase (with updated details if any)
+      try {
+        const completeTickets = mock.mockTickets.map(t => ({ ...t, status: 'created' }));
+        const completeResult = await processer.complete({ valve_id: 1, tickets: completeTickets });
+        const completeErrors = validateCompleteResult(completeResult);
+        result.phases.normalRun.complete.returnValid = completeErrors.length === 0;
+        result.phases.normalRun.complete.errors = completeErrors;
+        result.phases.normalRun.complete.pass = completeErrors.length === 0;
+        if (completeErrors.length > 0) {
+          result.errors.push(...completeErrors.map(e => `[normal complete] ${e}`));
+        }
+      } catch (e) {
+        result.phases.normalRun.complete.errors.push(e.message);
+        result.errors.push(`[normal complete] Runtime error: ${e.message}`);
       }
-    } catch (e) {
-      result.phases.normalRun.complete.errors.push(e.message);
-      result.errors.push(`[normal complete] Runtime error: ${e.message}`);
     }
 
     result.sdkCalls = [...new Set(mock.callLog.map(c => c.method))];
@@ -998,7 +1148,9 @@ async function runTests(args) {
     }
   }
 
-  const normalPass = result.phases.normalRun.start.pass && result.phases.normalRun.complete.pass;
+  const normalPass = isAutoTrigger
+    ? result.phases.normalRun.run?.pass
+    : result.phases.normalRun.start.pass && result.phases.normalRun.complete.pass;
   if (!normalPass) {
     result.status = 'fail';
   }
@@ -1010,26 +1162,39 @@ async function runTests(args) {
     try {
       processer = new ProcesserClass(mock.context);
     } catch (e) {
-      result.phases.adversarialRun.start.errors.push(`constructor threw: ${e.message}`);
+      const phaseKey = isAutoTrigger ? 'run' : 'start';
+      if (!result.phases.adversarialRun[phaseKey]) result.phases.adversarialRun[phaseKey] = { pass: false, errors: [] };
+      result.phases.adversarialRun[phaseKey].errors.push(`constructor threw: ${e.message}`);
       result.warnings.push(`[adversarial] constructor error: ${e.message}`);
     }
 
     if (processer) {
-      try {
-        await processer.start({ valve_id: 1, pool_ids: inputPoolIds });
-        result.phases.adversarialRun.start.pass = true;
-      } catch (e) {
-        result.phases.adversarialRun.start.errors.push(e.message);
-        result.warnings.push(`[adversarial start] ${e.constructor.name}: ${e.message}`);
-      }
+      if (isAutoTrigger) {
+        if (!result.phases.adversarialRun.run) result.phases.adversarialRun.run = { pass: false, errors: [] };
+        try {
+          await processer.run({ valve_id: 1, pool_ids: inputPoolIds });
+          result.phases.adversarialRun.run.pass = true;
+        } catch (e) {
+          result.phases.adversarialRun.run.errors.push(e.message);
+          result.warnings.push(`[adversarial run] ${e.constructor.name}: ${e.message}`);
+        }
+      } else {
+        try {
+          await processer.start({ valve_id: 1, pool_ids: inputPoolIds });
+          result.phases.adversarialRun.start.pass = true;
+        } catch (e) {
+          result.phases.adversarialRun.start.errors.push(e.message);
+          result.warnings.push(`[adversarial start] ${e.constructor.name}: ${e.message}`);
+        }
 
-      try {
-        const completeTickets = mock.mockTickets.map(t => ({ ...t, status: 'created' }));
-        await processer.complete({ valve_id: 1, tickets: completeTickets });
-        result.phases.adversarialRun.complete.pass = true;
-      } catch (e) {
-        result.phases.adversarialRun.complete.errors.push(e.message);
-        result.warnings.push(`[adversarial complete] ${e.constructor.name}: ${e.message}`);
+        try {
+          const completeTickets = mock.mockTickets.map(t => ({ ...t, status: 'created' }));
+          await processer.complete({ valve_id: 1, tickets: completeTickets });
+          result.phases.adversarialRun.complete.pass = true;
+        } catch (e) {
+          result.phases.adversarialRun.complete.errors.push(e.message);
+          result.warnings.push(`[adversarial complete] ${e.constructor.name}: ${e.message}`);
+        }
       }
 
       result.phases.compliance.warnings.push(