dsh-comfyui-canvas 0.1.10 → 0.1.12

package/CHANGELOG.md

@@ -0,0 +1,40 @@
+# Changelog
+
+本仓库变更记录（与版本号对应）。
+
+## [0.1.12] - 2026-09-28
+
+### Added
+- 工作流生命周期：`new_canvas`（调用前端"新建空白工作流"命令，无需清空/模拟点击）、`rename_workflow`（命名/重命名，无对话框）、`save_workflow`（直接持久化）
+- 布局整理：`move_node`（绝对/偏移移动）、`align_nodes`（对齐 left/right/top/bottom/hcenter/vcenter、均匀分布 horizontal/vertical、网格重排 cols+gap）
+- 通用前端命令桥接 `command`（执行任意注册命令，如 Comfy.SaveWorkflow）
+- UI 探测 `ui_probe`（诊断 Vue/pinia 链路与界面元素）
+- 组边界框顶部标题留白（50px），节点不再压盖组标题；移动/整理组内成员时组框自动重新贴合
+
+### Changed
+- host 工具新增 5 个：`comfyui_new_canvas` / `comfyui_rename_workflow` / `comfyui_save_workflow` / `comfyui_move_node` / `comfyui_align_nodes`
+- 内置技能 SOP：新建工作流优先 `comfyui_new_canvas`，复杂工作流用 `group` + `align_nodes` 整理布局
+- 版本对齐 0.1.12（插件 package.json + 桥接节点）
+
+### Security
+- `rename_workflow` 文件名安全校验（1-50 字符、拒绝路径/控制字符，防路径穿越）
+- `move_node` 数字校验（NaN 防护）、`align_nodes` 参数规整（cols≥1、gap≥0）
+- `set_param` 对前端回调容错（combo 选项异步初始化时不失败）
+
+## [0.1.11] - 2026-09-28
+
+> 覆盖 v0.1.10 发布（tag `333b009`）之后到 0.1.11 的全部更新：`0987ef5`（画布专注模式修复）+ `4a8871a`（分组功能）+ `9ca2f25`（CHANGELOG 纳入 npm files），均随 npm 0.1.11 发布。
+
+### Added
+- 工作流分组：`comfyui_group` 创建组（可传 `bounding` 显式定位）、增删成员、组边界框按节点坐标自动贴合
+- 组成员持久化：保存工作流时把成员 id（`nodes`）写入组对象 JSON，加载时自动重建成员关联（序列化补丁 + configure 钩子）——重开工作流分组原样恢复
+- 画布专注模式（会话隔离，v0.1.10 标签后补的修复）：独立画布标签写入 `activeViewBySession`，`comfyui_config` 可感知当前会话的画布专注状态
+
+### Fixed
+- 修复分组成员此前静默失效的根因：LiteGraph 缺 `addNode` 方法且 `LGraphGroup.nodes` 为只读 getter，改为桥接自管成员（`_dshNodes`）
+- 修复组边界框固定为默认值的问题：创建 / 增删成员时按节点坐标自动计算贴合
+
+### Changed
+- 版本号对齐：插件 `package.json` 与桥接节点（`version.json` / `__version__`）统一为 `0.1.11`
+- README 版本徽章更新为 0.1.11，并补充分组功能文档
+- `CHANGELOG.md` 纳入 npm 发布文件清单（`files`），随下一版本进入 npm 包

package/README.md

@@ -3,7 +3,7 @@
 > [中文](README.zh.md) · English
 
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
-[![Version](https://img.shields.io/badge/version-0.1.7-brightgreen.svg)](https://github.com/wbin0001/dsh-comfyui-canvas/releases)
+[![Version](https://img.shields.io/badge/version-0.1.12-brightgreen.svg)](https://github.com/wbin0001/dsh-comfyui-canvas/releases)
 [![GitHub Stars](https://img.shields.io/github/stars/wbin0001/dsh-comfyui-canvas.svg?style=social)](https://github.com/wbin0001/dsh-comfyui-canvas)
 [![DSH](https://img.shields.io/badge/DSH-v0.1.x-blueviolet.svg)](https://github.com/DeepSeek-Harness/DSH)
 [![ComfyUI](https://img.shields.io/badge/ComfyUI-0.34+-orange.svg)](https://github.com/comfyanonymous/ComfyUI)
@@ -12,7 +12,6 @@
 **Keywords**: ComfyUI · Stable Diffusion · 文生图 text-to-image · 图生图 img2img · AI 绘画 AI art · workflow 工作流 · music 音乐 · video 视频 · 3D · DeepSeek Harness · DSH
 
 > **✅ DSH version compatibility (since v0.1.4)**: the split-screen layout is **fully self-contained** in the plugin — it uses only official DSH slots (`conversation.session.header.utilities`) and DOM `data-*` anchors, with **zero core modifications**. Works on any official DSH **v0.1.x** (including v0.1.2+ with the breaking client refresh) without patches. The earlier split-rail implementation depended on private core patches; v0.1.4 removes that dependency entirely.
-> - ❌ **Non-official desktop wrappers** (e.g. the community `dsh-desktop`) are not guaranteed compatible — they bundle an upstream version that may be ahead of or behind this plugin's baseline; rely on official DSH.
 
 ![dsh-comfyui-canvas demo — agent drives a live ComfyUI workflow and fetches the output grid back into the chat](docs/screenshots/03-output-grid.png)
 
@@ -32,7 +31,7 @@ This package is the DSH-side plugin, and it ships the ComfyUI-side bridge node t
 |---|---|
 | **ComfyUI canvas split** | Clicking the **ComfyUI** button in the session header drops you straight into **canvas-on-the-left + chat-rail-on-the-right** split mode — the canvas embeds the ComfyUI frontend (local or cloud) alongside the official conversation rail, so you can chat with the agent while watching it drive the canvas. The iframe stays alive (no reload); click the button again to exit split. |
 | **Visual canvas copilot** | The agent operates **the canvas you are looking at** — nodes appear, links wire, widgets change and runs trigger live on screen, so you watch every step instead of trusting an opaque JSON edit. Output images come back into the chat via `comfyui_get_outputs`. |
-| **Canvas ops tools** | `comfyui_read_workflow`, `add_node`, `connect`, `set_param`, `remove_node`, `inject_text`, `load_workflow`, `run`, `debug`, `clear`, `group` — build and fix workflows on the live canvas; `clear` starts a blank canvas for a new workflow, `group` organizes complex workflows into named groups (prompt / sampler / output areas), and `inject_text` writes conversation text straight into a node or a new wirable source. |
+| **Canvas ops tools** | `comfyui_read_workflow`, `add_node`, `connect`, `set_param`, `remove_node`, `inject_text`, `load_workflow`, `run`, `debug`, `clear`, `group` — build and fix workflows on the live canvas; `group` organizes complex workflows into named groups (prompt / sampler / output areas) with auto-fitted boxes, title headroom and membership persistence. **Workflow lifecycle** (v0.1.12): `comfyui_new_canvas` starts a brand-new blank workflow through the frontend's own "New Blank Workflow" action (no clearing, no click), `comfyui_rename_workflow` names/renames it, `comfyui_save_workflow` persists it — all via the frontend stores, no dialogs. **Layout** (v0.1.12): `comfyui_move_node` (absolute/offset) and `comfyui_align_nodes` (align / distribute / grid) tidy the canvas, and group boxes re-fit automatically when a member moves. |
 | **Production tools** | `comfyui_batch_run` sweeps a parameter matrix (seeds/prompts/strengths) in one go — either explicit `runs` or a declarative `matrix` (`zip` parallel slots / `product` cartesian expansion); `comfyui_get_outputs` pulls the resulting files back into the chat — images, videos, gifs, and audio — with optional `outputStem` auto-incrementing names (`stem.01.png`, never overwrites); `comfyui_attach_file` uploads any local file (image/audio/video/3D/text) into ComfyUI's input/ for the matching Load node; `comfyui_export_api` exports the live canvas as API-format workflow JSON for comfy-cli headless batch runs. |
 | **One-click bridge install** | `comfyui_setup_bridge` detects / installs / updates the ComfyUI-side bridge node into `custom_nodes/` (idempotent, verifies the files, tells you when to restart) — no more manual copy step; `comfyui_config` reports `bridgeInstalled` / `bridgeVersion` / `bridgeUpToDate` at a glance. |
 | **Projects & traceability** | Downloads default to the project directory (Settings → Project directory, default `<workspace>/projects`); every downloaded run appends `runs.json` (promptId / overrides / timestamp / files) so any output can be traced back to its parameters. Failed runs return a structured `executionError` (node id / node type / exception / message) instead of a raw JSON wall. |
@@ -137,7 +136,7 @@ Works on **Windows**, **macOS** and **Linux**. The agent tools talk to ComfyUI o
 ## Usage
 
 1. Open a conversation and click the **ComfyUI** button in the session header — the canvas appears on the left with the Chat rail (messages + input) on the right, so you can instruct the agent while watching it work the canvas. Click the button again to exit split mode.
-2. Ask the agent to do canvas work: *"read the current workflow"*, *"set KSampler seed to 42"*, *"check the canvas for errors"*, *"run it"*.
+2. Ask the agent to do canvas work: "read the current workflow", "set KSampler seed to 42", "check the canvas for errors", "run it".
 3. The agent reads `comfyui_config` first, so it knows it's on the canvas and stays focused on canvas operations.
 
 ### Conversation → canvas
@@ -152,7 +151,7 @@ Content the agent generates in the chat — images and text — can become Comfy
 
 ### Canvas + MCP — two driving modes of the same ComfyUI
 
-The plugin is the **canvas driver**: it sees and edits the *live canvas* the user is looking at (add nodes, wire links, tweak widgets, run, fetch the run's output images via `comfyui_get_outputs`, sweep parameters via `comfyui_batch_run`). It never needs a saved workflow file.
+The plugin is the **canvas driver**: it sees and edits the live canvas the user is looking at (add nodes, wire links, tweak widgets, run, fetch the run's output images via `comfyui_get_outputs`, sweep parameters via `comfyui_batch_run`). It never needs a saved workflow file.
 
 For **pipeline-style / headless workloads**, ComfyUI's official **Comfy CLI** (`comfy-cli`, a standalone Python CLI that can also expose an **MCP server**) is the complementary executor. The two are not alternatives — they are two driving modes of the **same** ComfyUI instance, covering the full workflow lifecycle:
 
@@ -177,12 +176,24 @@ The built-in `comfyui-canvas-ops` skill instructs the agent to pick the right op
 | Scenario | Mode |
 |---|---|
 | **Edit an existing workflow** | Incremental edits on the current canvas (`set_param` / `connect` / `add_node` / `remove_node` / `inject_text`) — never a whole-graph `load_workflow` that would wipe the unsaved state |
-| **Start a new workflow** | `comfyui_clear` (blank canvas, guarded by a `confirm` flag) then build up |
-| **Build a complex workflow** | `comfyui_group` — organize into named groups (prompt / sampler / output areas) |
+| **Start a new workflow** | `comfyui_new_canvas` (a brand-new blank canvas via the frontend's own New action) or `comfyui_clear` (blank the current canvas, `confirm`-guarded), then build up |
+| **Build a complex workflow** | `comfyui_group` named groups (prompt / sampler / output areas) + `comfyui_align_nodes` / `comfyui_move_node` tidy layout |
 | **Quick validation / batch / unattended** | **API/MCP path** — submit an API-format workflow directly (or via an MCP server), no need to visualize on the canvas |
 
 The agent decides the path up front: visual canvas mode when the user is watching / tuning, API/MCP mode for fast validation, batch sweeps and unattended runs.
 
+### Workflow groups (organize complex pipelines)
+
+`comfyui_group` organizes a complex canvas into **named groups** that survive save/load:
+
+| Action | Behavior |
+|---|---|
+| `add` | Create a named group around the given nodes; the box auto-fits the nodes (an explicit `bounding` is honored when given) |
+| `add_nodes` / `remove_nodes` | Add / remove member nodes; the box re-fits automatically |
+| `rename` / `list` | Rename a group / list groups with their members |
+
+**Membership persistence**: saving the workflow serializes each group's member ids (`nodes`) next to `title` / `bounding` / `color`, and loading re-attaches them — a saved workflow reopens with the same boxes and their memberships intact.
+
 ## Requirements
 
 - DeepSeek Harness Web (DSH), Node `^22.19.0 || >=24`
@@ -207,7 +218,7 @@ dsh-comfyui-canvas/
 │       ├── __init__.py       # /dsh-bridge/* HTTP routes on the ComfyUI server
 │       └── entry/bridge.js   # injected frontend: reports graph + runs commands
 ├── lib/
-│   ├── index.js              # DSH host: 21 canvas tools + 4 built-in skills
+│   ├── index.js              # DSH host: 26 canvas tools + 4 built-in skills
 │   └── client.js             # DSH web: split canvas (left) + chat rail (right) / settings
 ├── LICENSE
 ├── README.md
@@ -218,6 +229,7 @@ The **bridge** is the only ComfyUI-side dependency. It exposes `/dsh-bridge/work
 
 ## Known issues
 
+- **Non-official desktop wrappers** are not guaranteed compatible — they bundle an upstream version that may be ahead of or behind this plugin's baseline; rely on official DSH.
 - `comfyui_reload` currently supports **Windows only** (uses `netstat`/`taskkill`); on macOS/Linux it fails loud instead of pretending, restart ComfyUI manually there.
 - The former "node previews missing after a run" is fixed in v0.1.1: removed the iframe's `referrerpolicy="no-referrer"` to match the native tab environment, and `bridge.js` now listens to ComfyUI's `executed` event to force a canvas redraw.
 

package/README.zh.md

@@ -3,7 +3,7 @@
 > 中文 · [English](README.md)
 
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
-[![Version](https://img.shields.io/badge/version-0.1.7-brightgreen.svg)](https://github.com/wbin0001/dsh-comfyui-canvas/releases)
+[![Version](https://img.shields.io/badge/version-0.1.12-brightgreen.svg)](https://github.com/wbin0001/dsh-comfyui-canvas/releases)
 [![GitHub Stars](https://img.shields.io/github/stars/wbin0001/dsh-comfyui-canvas.svg?style=social)](https://github.com/wbin0001/dsh-comfyui-canvas)
 [![DSH](https://img.shields.io/badge/DSH-v0.1.x-blueviolet.svg)](https://github.com/DeepSeek-Harness/DSH)
 [![ComfyUI](https://img.shields.io/badge/ComfyUI-0.34+-orange.svg)](https://github.com/comfyanonymous/ComfyUI)
@@ -12,7 +12,6 @@
 **关键词**：ComfyUI · Stable Diffusion · 文生图 · 图生图 · AI 绘画 · 工作流 workflow · 音乐 music · 视频 video · 3D · DeepSeek Harness · DSH
 
 > **✅ DSH 版本兼容（v0.1.4 起）**：分屏布局已完全**自包含**在插件内——只用官方 DSH 插槽（`conversation.session.header.utilities`）与 DOM `data-*` 锚点，**零核心改动**。任何官方 DSH **v0.1.x**（含带破坏性 client 更新的 v0.1.2+）都开箱即用、无需补丁。此前分屏 rail 依赖 DSH 私有核心补丁，v0.1.4 已彻底移除该依赖。
-> - ❌ **非官方桌面封装**（如 `dsh-desktop` 社区版）不保证兼容——它内部跑的上游版本可能超前/滞后于本插件基线，请以官方 DSH 为准。
 
 ![dsh-comfyui-canvas 演示 —— agent 驱动实时 ComfyUI 工作流，把出图网格直接带回对话](docs/screenshots/03-output-grid.png)
 
@@ -33,7 +32,7 @@
 | **画布分屏入口** | 点会话标头右侧的 **ComfyUI** 按钮进入**画布左 + 对话 rail 右**的分屏形态——画布内嵌 ComfyUI 前端（本地/云端），右侧是官方对话 rail，边看画布边发消息让 agent 操控。iframe 常驻不重载，再点按钮即关闭分屏。 |
 | **分屏布局（自包含）** | ComfyUI 按钮 = 画布左 + 对话右，状态按会话隔离。只用官方插槽（`conversation.session.header.utilities`）+ DOM `data-*` 锚点与 CSS 变量，**零核心改动**，上游样式变化也不受影响。 |
 | **可视化画布副驾** | agent 操作**你正在看的画布**——节点出现、连线接上、参数变化、运行触发，全部实时显示在屏幕上，每一步都看得见，而不是黑盒改 JSON。出图经 `comfyui_get_outputs` 直接带回对话。 |
-| **画布操作工具** | `comfyui_read_workflow` / `add_node` / `connect` / `set_param` / `remove_node` / `inject_text` / `load_workflow` / `run` / `debug` / `clear` / `group`——在活画布上搭建与修复工作流；`clear` 清出空白画布新建工作流，`group` 把复杂工作流分成具名组（提示词区 / 采样区 / 输出区），`inject_text` 把对话文本一步注入为可连线节点。 |
+| **画布操作工具** | `comfyui_read_workflow` / `add_node` / `connect` / `set_param` / `remove_node` / `inject_text` / `load_workflow` / `run` / `debug` / `clear` / `group`——在活画布上搭建与修复工作流；`group` 把复杂工作流分成具名组（提示词区 / 采样区 / 输出区），组框自动贴合、预留标题行、成员随保存持久化。**工作流生命周期**（v0.1.12）：`comfyui_new_canvas` 直接调用前端"新建空白工作流"命令开新画布（不用清空、不模拟点击）、`comfyui_rename_workflow` 命名/重命名、`comfyui_save_workflow` 保存——全部走前端 store、无对话框。**布局整理**（v0.1.12）：`comfyui_move_node`（绝对/偏移移动）、`comfyui_align_nodes`（对齐 / 均匀分布 / 网格重排）整理画布，组内成员移动时组框自动重新贴合。 |
 | **生产工具** | `comfyui_batch_run` 一次扫参数矩阵（seed / prompt / 强度）——支持显式 `runs` 或声明式 `matrix`（`zip` 并行槽位 / `product` 笛卡尔展开）；`comfyui_get_outputs` 把产物直接带回对话——图像、视频、GIF、音频都支持，可传 `outputStem` 自动编号（`stem.01.png`，永不覆盖）；`comfyui_attach_file` 把本机任意文件（图片/音频/视频/3D/**文本**）上传进 ComfyUI `input/` 供对应 Load 节点使用；`comfyui_export_api` 把当前画布导出为 API 格式工作流，供 comfy-cli 无人值守批量。 |
 | **桥接节点一键安装** | `comfyui_setup_bridge` 检测 / 安装 / 更新 ComfyUI 侧桥接节点到 `custom_nodes/`（幂等、校验文件、提示何时重启）——不再需要手动复制；`comfyui_config` 一眼报告 `bridgeInstalled` / `bridgeVersion` / `bridgeUpToDate`。 |
 | **项目目录与溯源** | 下载默认落「项目目录」（设置页可改，默认 `<工作区>/projects`）；每次下载把 `runs.json`（promptId / overrides / 时间戳 / 文件）追加进项目目录，任意一张图都能追溯回它的生成参数。运行失败返回结构化 `executionError`（节点 id / 节点类型 / 异常类型 / 信息），不再是一堵 JSON 墙。 |
@@ -148,10 +147,10 @@ mv comfyui-bridge/ComfyUI-DSH-Canvas ../ComfyUI-DSH-Canvas && cd .. && rm -rf ds
 
 1. 打开一个会话，点会话标头右侧的 **ComfyUI** 按钮——进入**画布左 + 对话 rail 右**的分屏形态（再点一次即关闭分屏，回到纯对话）。
 2. 直接让 agent 干画布活：
-   - *“读取当前工作流”*
-   - *“给 KSampler 设 seed 为 42”*
-   - *“检查画布有没有报错”*
-   - *“运行一次”*
+   - 「读取当前工作流」
+   - 「给 KSampler 设 seed 为 42」
+   - 「检查画布有没有报错」
+   - 「运行一次」
 3. agent 会先读 `comfyui_config` 确认当前在画布模式，然后专注画布操作。
 
 ### 对话产物 → 画布
@@ -190,12 +189,24 @@ pip install comfy-cli   # 独立 CLI，非 DSH 插件 —— 见 https://github.
 | 场景 | 模式 |
 |---|---|
 | **修改现有工作流** | 在当前画布上**增量编辑**（`set_param` / `connect` / `add_node` / `remove_node` / `inject_text`）——绝不用整图 `load_workflow` 冲掉未保存现场 |
-| **新建工作流** | `comfyui_clear`（清出空白画布，带 `confirm` 防误清）再逐步搭 |
-| **搭建复杂工作流** | `comfyui_group`——分成具名组（提示词区 / 采样区 / 输出区） |
+| **新建工作流** | `comfyui_new_canvas`（新建空白画布）或 `comfyui_clear`（清空当前画布，带 `confirm` 防误清）再逐步搭 |
+| **搭建复杂工作流** | `comfyui_group` 分具名组（提示词区 / 采样区 / 输出区）+ `comfyui_align_nodes` / `comfyui_move_node` 整理布局 |
 | **快速验证 / 批量 / 无人值守** | **API/MCP 路径**——直接提交 API 格式工作流（或经 MCP server），不必可视化画布 |
 
 agent 动手前先判断场景：用户在实时看画布 / 需要调优 → 画布路径；快速验证、批量扫参、无人值守 → API/MCP 路径。
 
+### 工作流分组（组织复杂流水线）
+
+`comfyui_group` 把复杂画布分成**具名组**，且分组随工作流保存/重载完整恢复：
+
+| 命令 | 行为 |
+|---|---|
+| `add` | 围绕指定节点创建具名组，组框**自动贴合**节点（也可传 `bounding` 精确定位） |
+| `add_nodes` / `remove_nodes` | 增删组成员，组框自动重新贴合 |
+| `rename` / `list` | 重命名 / 列出组及成员 |
+
+**成员持久化**：保存工作流时把每个组的成员 id（`nodes`）与 `title` / `bounding` / `color` 一并写入 JSON，加载时自动重建成员关联——重开工作流后，组框和成员关系都原样保留。
+
 ---
 
 ## 环境要求
@@ -226,7 +237,7 @@ dsh-comfyui-canvas/
 │       ├── __init__.py       # ComfyUI 服务端 /dsh-bridge/* 路由
 │       └── entry/bridge.js   # 注入画布前端：上报画布 + 执行命令
 ├── lib/
-│   ├── index.js              # DSH host：15 个画布工具 + 会话隔离模式
+│   ├── index.js              # DSH host：26 个画布工具 + 会话隔离模式
 │   └── client.js             # DSH web：分屏画布（画布左+对话右）/ 设置页
 ├── LICENSE
 ├── README.md
@@ -240,6 +251,7 @@ dsh-comfyui-canvas/
 
 ## 已知问题
 
+- **非官方桌面封装**不保证兼容——它内部跑的上游版本可能超前/滞后于本插件基线，请以官方 DSH 为准。
 - `comfyui_reload` 目前**仅支持 Windows**（依赖 `netstat`/`taskkill`）；macOS/Linux 上会明确报错而非假装成功，需手动重启 ComfyUI。
 - 此前"画布运行后节点预览不显示"已在 v0.1.1 修复：移除 iframe 的 `referrerpolicy="no-referrer"` 消除环境差异，并在 `bridge.js` 监听 ComfyUI `executed` 事件强制重绘画布。
 

package/comfyui-bridge/ComfyUI-DSH-Canvas/__init__.py

@@ -9,7 +9,7 @@
 
 # Bridge release version. The DSH plugin compares this against its embedded
 # copy (see version.json) to decide whether an update is needed.
-__version__ = "0.1.7"
+__version__ = "0.1.12"
 
 import os
 import time

package/comfyui-bridge/ComfyUI-DSH-Canvas/entry/bridge.js

@@ -94,11 +94,61 @@ function applyWidgetValue(node, widget, value) {
       throw new Error(`value ${JSON.stringify(value)} is not a valid option for ${widget.name} (${labels.join(", ")})`);
     }
   }
-  widget.callback?.(widget.value, widget);
-  node.onWidgetChanged?.(widget, widget.value, null, null);
+  try {
+    widget.callback?.(widget.value, widget);
+    node.onWidgetChanged?.(widget, widget.value, null, null);
+  } catch {
+    // The widget value is still applied; the frontend callback may not be
+    // ready (e.g. a combo's options initialize asynchronously right after the
+    // node is created), so a callback hiccup must not fail the set_param.
+  }
   node.setDirtyCanvas?.(true, true);
 }
 
+// v0.1.12: some LiteGraph builds ship LGraphGroup without addNode /
+// computeBounding, so the bridge owns group membership and the bounding box
+// instead of relying on those methods. `bounding` stays pos.concat(size), so
+// saved workflows render the same box on load. The top edge keeps extra room
+// (`titlePad`) so the group's title row never sits under a node.
+function groupBounds(nodeObjs, pad = 20, titlePad = 50) {
+  if (!nodeObjs.length) return null;
+  let x1 = Infinity, y1 = Infinity, x2 = -Infinity, y2 = -Infinity;
+  for (const n of nodeObjs) {
+    const [x, y] = n.pos;
+    const [w, h] = n.size;
+    x1 = Math.min(x1, x);
+    y1 = Math.min(y1, y);
+    x2 = Math.max(x2, x + w);
+    y2 = Math.max(y2, y + h);
+  }
+  return [x1 - pad, y1 - pad - titlePad, x2 - x1 + 2 * pad, y2 - y1 + 2 * pad + titlePad];
+}
+
+function groupSetNodes(group, nodeObjs, keepBounds = false) {
+  // LGraphGroup.nodes is a read-only getter in some frontends, so membership
+  // lives on a bridge-owned property instead of the group's own array.
+  group._dshNodes = Array.isArray(nodeObjs) ? nodeObjs.slice() : [];
+  if (keepBounds) return;
+  const bb = groupBounds(group._dshNodes);
+  if (bb) {
+    group.pos = [bb[0], bb[1]];
+    group.size = [bb[2], bb[3]];
+  }
+}
+
+// v0.1.12: re-fit the bounding box of every group a moved node belongs to.
+function refitNodeGroups(graph, node) {
+  for (const g of graph?._groups ?? []) {
+    if (Array.isArray(g._dshNodes) && g._dshNodes.includes(node)) {
+      const bb = groupBounds(g._dshNodes);
+      if (bb) {
+        g.pos = [bb[0], bb[1]];
+        g.size = [bb[2], bb[3]];
+      }
+    }
+  }
+}
+
 async function executeCommand(cmd, payload) {
   const graph = app.graph;
   const LiteGraph = await resolveLiteGraph();
@@ -147,6 +197,88 @@ async function executeCommand(cmd, payload) {
       return { removed: String(nodeId) };
     }
 
+    // v0.1.12: move a node (absolute `pos` or relative `offset`) and re-fit
+    // the bounding boxes of any groups the node belongs to.
+    case "move_node": {
+      const { nodeId, pos, offset } = payload;
+      const node = graph.getNodeById(+nodeId);
+      if (!node) throw new Error(`node not found: ${nodeId}`);
+      if (Array.isArray(pos) && pos.length >= 2 && isFinite(+pos[0]) && isFinite(+pos[1])) {
+        node.pos = [+pos[0], +pos[1]];
+      } else if (Array.isArray(offset) && offset.length >= 2 && isFinite(+offset[0]) && isFinite(+offset[1])) {
+        node.pos = [node.pos[0] + +offset[0], node.pos[1] + +offset[1]];
+      } else {
+        throw new Error("move_node requires payload.pos [x,y] or payload.offset [dx,dy] as numbers");
+      }
+      refitNodeGroups(graph, node);
+      scheduleReport();
+      return { nodeId: String(node.id), pos: node.pos.slice() };
+    }
+
+    // v0.1.12: tidy a set of nodes — align edges/centers, distribute evenly
+    // along an axis, or reflow into a grid. Re-fits the groups the nodes
+    // belong to, so aligned group members stay wrapped by their group box.
+    case "align_nodes": {
+      const { nodeIds, mode = "align", edge = "left", axis = "horizontal" } = payload ?? {};
+      const cols = Math.max(1, Math.floor(+payload?.cols || 2));
+      const gap = Math.max(0, +payload?.gap || 40);
+      const nodes = (Array.isArray(nodeIds) ? nodeIds : []).map((id) => graph.getNodeById(+id)).filter(Boolean);
+      if (!nodes.length) throw new Error("align_nodes requires payload.nodeIds");
+      const x1 = Math.min(...nodes.map((n) => n.pos[0]));
+      const x2 = Math.max(...nodes.map((n) => n.pos[0] + n.size[0]));
+      const y1 = Math.min(...nodes.map((n) => n.pos[1]));
+      const y2 = Math.max(...nodes.map((n) => n.pos[1] + n.size[1]));
+      const cx = (x1 + x2) / 2;
+      const cy = (y1 + y2) / 2;
+      if (mode === "grid") {
+        const colW = Math.max(...nodes.map((n) => n.size[0])) + gap;
+        const rowH = Math.max(...nodes.map((n) => n.size[1])) + gap;
+        nodes.forEach((n, i) => {
+          n.pos = [x1 + (i % cols) * colW, y1 + Math.floor(i / cols) * rowH];
+        });
+      } else if (mode === "distribute") {
+        const sorted = [...nodes].sort((a, b) => axis === "vertical"
+          ? (a.pos[1] + a.size[1] / 2) - (b.pos[1] + b.size[1] / 2)
+          : (a.pos[0] + a.size[0] / 2) - (b.pos[0] + b.size[0] / 2));
+        if (sorted.length < 3) {
+          const mid = axis === "vertical" ? cy : cx;
+          sorted.forEach((n) => {
+            if (axis === "vertical") n.pos[1] = mid - n.size[1] / 2;
+            else n.pos[0] = mid - n.size[0] / 2;
+          });
+        } else {
+          const first = sorted[0];
+          const last = sorted[sorted.length - 1];
+          const from = axis === "vertical" ? first.pos[1] + first.size[1] / 2 : first.pos[0] + first.size[0] / 2;
+          const to = axis === "vertical" ? last.pos[1] + last.size[1] / 2 : last.pos[0] + last.size[0] / 2;
+          const step = (to - from) / (sorted.length - 1);
+          sorted.forEach((n, i) => {
+            const c = from + i * step;
+            if (axis === "vertical") n.pos[1] = c - n.size[1] / 2;
+            else n.pos[0] = c - n.size[0] / 2;
+          });
+        }
+      } else {
+        nodes.forEach((n) => {
+          if (edge === "left") n.pos[0] = x1;
+          else if (edge === "right") n.pos[0] = x2 - n.size[0];
+          else if (edge === "top") n.pos[1] = y1;
+          else if (edge === "bottom") n.pos[1] = y2 - n.size[1];
+          else if (edge === "hcenter") n.pos[0] = cx - n.size[0] / 2;
+          else if (edge === "vcenter") n.pos[1] = cy - n.size[1] / 2;
+        });
+      }
+      for (const n of nodes) refitNodeGroups(graph, n);
+      scheduleReport();
+      return {
+        moved: nodes.map((n) => String(n.id)),
+        mode,
+        edge: mode === "align" ? edge : null,
+        axis: mode === "distribute" ? axis : null,
+        cols: mode === "grid" ? cols : null,
+      };
+    }
+
     // M2: load a whole workflow back onto the canvas (rewrite loop).
     case "load_workflow": {
       const data = payload.workflow;
@@ -331,10 +463,146 @@ async function executeCommand(cmd, payload) {
       return { cleared: true, nodes: 0 };
     }
 
-    // v0.1.6: group nodes into named groups (complex-workflow organization).
-    // Uses LiteGraph's native group API (graph._groups). Availability varies
-    // across custom frontends, so `list` reports groupingAvailable so the
-    // agent can degrade gracefully instead of hard-failing.
+    // v0.1.12: probe which UI affordances exist so the agent can pick the
+    // right element to drive (e.g. the New-workflow button may live in the
+    // topbar, sidebar or menu depending on the frontend's current view).
+    case "ui_probe": {
+      const selectors = Array.isArray(payload.selectors) ? payload.selectors : [
+        ".new-blank-workflow-button",
+        "[aria-label*='new']",
+        "[aria-label*='New']",
+        "[data-testid*='workflow']",
+        "[data-testid*='Workflow']",
+        "button:has(> i.pi-plus)",
+      ];
+      const found = [];
+      for (const sel of selectors) {
+        try {
+          const els = document.querySelectorAll(sel);
+          if (els.length) {
+            const first = els[0];
+            found.push({
+              selector: sel,
+              count: els.length,
+              tag: first.tagName,
+              cls: String(first.className || "").slice(0, 80),
+              aria: first.getAttribute("aria-label") || "",
+              text: (first.textContent || "").trim().slice(0, 30),
+            });
+          }
+        } catch {
+          /* invalid selector */
+        }
+      }
+      // Vue app chain diagnostic (which hop breaks the pinia command store).
+      const rootEl = document.querySelector("#vue-app") ?? document.querySelector("#app") ?? document.body;
+      const vueApp = rootEl?.__vue_app__ ?? null;
+      const pinia = vueApp?.config?.globalProperties?.$pinia ?? null;
+      const vue = {
+        appElId: rootEl.id || rootEl.tagName,
+        hasVueApp: Boolean(vueApp),
+        hasPinia: Boolean(pinia),
+        storeIds: pinia?._s ? Array.from(pinia._s.keys()).slice(0, 50) : null,
+      };
+      return { probed: selectors, found, vue };
+    }
+
+    // v0.1.12: start a brand-new workflow through the frontend's own command
+    // (Comfy.NewBlankWorkflow — the sidebar/topbar "新建" action), invoked via
+    // the pinia command store instead of a DOM click. Falls back to clicking
+    // the topbar button when the store is unreachable.
+    case "new_canvas": {
+      const rootEl = document.querySelector("#vue-app") ?? document.querySelector("#app") ?? document.body;
+      const pinia = rootEl.__vue_app__?.config?.globalProperties?.$pinia;
+      const store = pinia?._s?.get("command");
+      if (store && typeof store.execute === "function") {
+        await store.execute("Comfy.NewBlankWorkflow");
+        scheduleReport();
+        return { triggered: true, via: "command-store" };
+      }
+      const btn = document.querySelector(".new-blank-workflow-button");
+      if (btn && typeof btn.click === "function") {
+        btn.click();
+        scheduleReport();
+        return { triggered: true, via: "topbar-new-button" };
+      }
+      throw new Error("new-blank-workflow not reachable (no command store, no button)");
+    }
+
+    // v0.1.12: name / rename the active workflow directly through the
+    // workflow store (no dialog). Without payload.name it reports the current
+    // workflow name, path and persistence state.
+    case "rename_workflow": {
+      const rootEl = document.querySelector("#vue-app") ?? document.querySelector("#app") ?? document.body;
+      const pinia = rootEl?.__vue_app__?.config?.globalProperties?.$pinia;
+      const workflowStore = pinia?._s?.get("workflow");
+      const workflow = workflowStore?.activeWorkflow ?? null;
+      if (!workflow) throw new Error("no active workflow");
+      const name = typeof payload.name === "string" ? payload.name.trim() : "";
+      if (!name) {
+        return {
+          filename: workflow.filename ?? "",
+          path: workflow.path ?? "",
+          isPersisted: Boolean(workflow.isPersisted),
+          isTemporary: Boolean(workflow.isTemporary),
+        };
+      }
+      // Filename safety: cap length and reject path/control characters so a
+      // crafted name cannot escape the workflow directory (mirrors the
+      // frontend's own 1-50 char filename rule).
+      if (name.length > 50 || /[\\/:*?"<>|\u0000-\u001f]/.test(name)) {
+        throw new Error(`invalid workflow name: 1-50 chars, no path or control characters (${JSON.stringify(name)})`);
+      }
+      if (typeof workflowStore.renameWorkflow !== "function") {
+        throw new Error("workflow store lacks renameWorkflow");
+      }
+      const suffix = workflow.suffix || "json";
+      const finalName = /\.\w+$/.test(name) ? name : `${name}.${suffix}`;
+      const newPath = workflow.directory
+        ? `${workflow.directory}/${finalName}`
+        : finalName;
+      await workflowStore.renameWorkflow(workflow, newPath);
+      scheduleReport();
+      return { renamed: true, filename: finalName, path: newPath };
+    }
+
+    // v0.1.12: execute any frontend command by id through the command store
+    // (e.g. Comfy.SaveWorkflow / Comfy.SaveWorkflowAs), no dialog, no click.
+    case "command": {
+      const rootEl = document.querySelector("#vue-app") ?? document.querySelector("#app") ?? document.body;
+      const pinia = rootEl?.__vue_app__?.config?.globalProperties?.$pinia;
+      const store = pinia?._s?.get("command");
+      const id = typeof payload.id === "string" ? payload.id : "";
+      if (!id) throw new Error("command requires payload.id");
+      if (!store || typeof store.execute !== "function") {
+        throw new Error("command store not reachable");
+      }
+      await store.execute(id, payload.options);
+      scheduleReport();
+      return { executed: id };
+    }
+
+    // v0.1.12: persist the active workflow directly through the workflow
+    // store (no dialog) — the reliable no-UI equivalent of Comfy.SaveWorkflow.
+    case "save_workflow": {
+      const rootEl = document.querySelector("#vue-app") ?? document.querySelector("#app") ?? document.body;
+      const pinia = rootEl?.__vue_app__?.config?.globalProperties?.$pinia;
+      const workflowStore = pinia?._s?.get("workflow");
+      const workflow = workflowStore?.activeWorkflow ?? null;
+      if (!workflow) throw new Error("no active workflow");
+      if (typeof workflowStore.saveWorkflow !== "function") {
+        throw new Error("workflow store lacks saveWorkflow");
+      }
+      await workflowStore.saveWorkflow(workflow);
+      scheduleReport();
+      return { saved: true, filename: workflow.filename ?? "", path: workflow.path ?? "" };
+    }
+
+    // v0.1.8: group nodes into named groups (complex-workflow organization).
+    // The bridge manages membership and the bounding box itself (groupSetNodes)
+    // because not every LiteGraph build ships LGraphGroup.addNode. Availability
+    // varies across custom frontends, so `list` reports groupingAvailable so
+    // the agent can degrade gracefully instead of hard-failing.
     case "group": {
       const { action, title, id, nodeIds } = payload ?? {};
       const groups = graph?._groups ?? null;
@@ -349,10 +617,14 @@ async function executeCommand(cmd, payload) {
           if (!title || typeof title !== "string") throw new Error("group add requires payload.title");
           const nodeObjs = (Array.isArray(nodeIds) ? nodeIds : []).map((n) => graph.getNodeById(+n)).filter(Boolean);
           const group = new LiteGraph.LGraphGroup(title);
-          for (const n of nodeObjs) group.addNode?.(n);
+          if (Array.isArray(payload.bounding)) {
+            group.pos = [payload.bounding[0], payload.bounding[1]];
+            group.size = [payload.bounding[2], payload.bounding[3]];
+          }
+          groupSetNodes(group, nodeObjs, Array.isArray(payload.bounding));
           groups.push(group);
           scheduleReport();
-          return { groupingAvailable: true, id: groups.indexOf(group), title: group.title, nodes: nodeObjs.map((n) => String(n.id)) };
+          return { groupingAvailable: true, id: groups.indexOf(group), title: group.title, nodes: group._dshNodes.map((n) => String(n.id)) };
         }
         case "rename": {
           const g = groups[+id];
@@ -364,22 +636,32 @@ async function executeCommand(cmd, payload) {
         case "add_nodes": {
           const g = groups[+id];
           if (!g) throw new Error(`group not found: ${id}`);
+          const seen = new Set((g._dshNodes ?? []).map((n) => n.id));
+          const merged = (g._dshNodes ?? []).slice();
           const added = [];
           for (const n of Array.isArray(nodeIds) ? nodeIds : []) {
             const node = graph.getNodeById(+n);
-            if (node && !(g.nodes ?? []).includes(node)) { g.addNode?.(node); added.push(String(n)); }
+            if (!node || seen.has(node.id)) continue;
+            seen.add(node.id);
+            merged.push(node);
+            added.push(String(n));
           }
+          groupSetNodes(g, merged);
           scheduleReport();
           return { groupingAvailable: true, id: +id, added };
         }
         case "remove_nodes": {
           const g = groups[+id];
           if (!g) throw new Error(`group not found: ${id}`);
+          const ids = new Set((Array.isArray(nodeIds) ? nodeIds : []).map((n) => String(n)));
           const removed = [];
-          for (const n of Array.isArray(nodeIds) ? nodeIds : []) {
-            const node = graph.getNodeById(+n);
-            if (node && (g.nodes ?? []).includes(node)) { g.removeNode?.(node); removed.push(String(n)); }
-          }
+          groupSetNodes(g, (g._dshNodes ?? []).filter((n) => {
+            if (ids.has(String(n.id))) {
+              removed.push(String(n.id));
+              return false;
+            }
+            return true;
+          }));
           scheduleReport();
           return { groupingAvailable: true, id: +id, removed };
         }
@@ -389,7 +671,7 @@ async function executeCommand(cmd, payload) {
             groups: groups.map((g, i) => ({
               id: i,
               title: g.title ?? "",
-              nodes: (g.nodes ?? []).map((n) => String(n.id)),
+              nodes: (g._dshNodes ?? []).map((n) => String(n.id)),
             })),
           };
         }
@@ -449,10 +731,40 @@ app.registerExtension({
       graph.configure = function (...args) {
         const out = prevGraphConfigure.apply(this, args);
         scheduleReport();
+        // v0.1.11: re-attach persisted group membership after a graph load so
+        // saved workflows restore which nodes belong to each group.
+        const data = args[0];
+        const groupsData = Array.isArray(data?.groups) ? data.groups : null;
+        const groups = this?._groups ?? null;
+        if (groupsData && Array.isArray(groups)) {
+          for (let i = 0; i < groups.length && i < groupsData.length; i++) {
+            const ids = groupsData[i]?.nodes;
+            if (!Array.isArray(ids)) continue;
+            const nodeObjs = ids.map((id) => this.getNodeById(+id)).filter(Boolean);
+            groupSetNodes(groups[i], nodeObjs, true);
+          }
+        }
         return out;
       };
     }
 
+    // v0.1.11: persist group membership in saved workflows — patch the group
+    // serializer so member ids land in the workflow JSON next to
+    // title/bounding/color, and the configure hook above restores them on load.
+    resolveLiteGraph().then((LG) => {
+      const proto = LG?.LGraphGroup?.prototype;
+      const orig = proto?.serialize;
+      if (!proto || typeof orig !== "function" || proto._dshSerializePatched) return;
+      proto._dshSerializePatched = true;
+      proto.serialize = function () {
+        const data = orig.call(this) ?? {};
+        if (Array.isArray(this._dshNodes) && this._dshNodes.length) {
+          data.nodes = this._dshNodes.map((n) => n.id);
+        }
+        return data;
+      };
+    });
+
     // M1: listen for write commands pushed over the WebSocket.
     // Per-tab targeting (M3): when the backend names a target clientId (the
     // last one that reported), only that tab executes — several open ComfyUI

package/comfyui-bridge/ComfyUI-DSH-Canvas/version.json

@@ -1,4 +1,4 @@
 {
   "name": "ComfyUI-DSH-Canvas",
-  "version": "0.1.7"
+  "version": "0.1.12"
 }

package/lib/client.js

@@ -1086,6 +1086,11 @@ function CanvasTab(props) {
     };
     fit();
     outer.style.display = "flex";
+    // 画布专注模式：告知 host 本会话正在画布标签（comfyui_config 按会话读取，
+    // agent 据此知道你在画布开工；按会话隔离，卸载时写回 chat）。
+    if (scope && typeof scope.set === "function" && props.sessionId) {
+      setSessionView(scope, String(props.sessionId), "canvas");
+    }
     var sync = function () {
       // frame.src 常带尾斜杠而 activeBase 不带——裸 !== 会让每次挂载都重置 src
       // 导致 ComfyUI 重载。归一化后仅当地址真正变化才更新。
@@ -1104,6 +1109,9 @@ function CanvasTab(props) {
       if (ro) ro.disconnect();
       window.removeEventListener("resize", fit);
       document.documentElement.removeAttribute("data-dsh-comfyui-fullscreen");
+      if (scope && typeof scope.set === "function" && props.sessionId) {
+        setSessionView(scope, String(props.sessionId), "chat");
+      }
       // 仅隐藏，不摘除：iframe 浏览上下文保活，切回秒开。
       outer.style.display = "none";
     };

package/lib/index.js

@@ -1582,6 +1582,92 @@ export function apply(ctx) {
     },
   }))
 
+  // v0.1.12: workflow lifecycle + node layout tools — new canvas, name/rename,
+  // save, move, align — driven through the frontend's own stores (no dialog,
+  // no DOM click), so they work in any view of the ComfyUI page.
+  ctx.tools.register(defineTool({
+    name: 'comfyui_new_canvas',
+    description: 'Start a brand-new blank workflow on the live ComfyUI canvas through the frontend\'s own ' +
+      '"New Blank Workflow" action (Comfy.NewBlankWorkflow) instead of clearing the current graph. ' +
+      'Matches the sidebar 新建画布. The previous workflow view is replaced — read/export it first if needed.',
+    parameters: {},
+    output: { schema: { type: 'object', additionalProperties: true }, render: renderJSON },
+    async execute(_args, exec) {
+      return sendCommand(baseUrl(), bridgeToken(), 'new_canvas', {}, exec.signal, { timeoutMs: 10000 })
+    },
+  }))
+
+  ctx.tools.register(defineTool({
+    name: 'comfyui_rename_workflow',
+    description: 'Name or rename the active ComfyUI workflow directly (no dialog). Without `name` it reports the ' +
+      'current workflow filename / path / persistence state. Names are capped at 50 chars and reject path and ' +
+      'control characters.',
+    parameters: {
+      name: { type: 'string', description: 'New workflow name (omit to only query the current name/state).' },
+    },
+    output: { schema: { type: 'object', additionalProperties: true }, render: renderJSON },
+    async execute(args, exec) {
+      return sendCommand(baseUrl(), bridgeToken(), 'rename_workflow', { name: args?.name }, exec.signal, { timeoutMs: 10000 })
+    },
+  }))
+
+  ctx.tools.register(defineTool({
+    name: 'comfyui_save_workflow',
+    description: 'Persist the active ComfyUI workflow through the frontend workflow store (no dialog) — the ' +
+      'reliable no-UI equivalent of Comfy.SaveWorkflow. Use after building/editing so the workflow survives reload.',
+    parameters: {},
+    output: { schema: { type: 'object', additionalProperties: true }, render: renderJSON },
+    async execute(_args, exec) {
+      return sendCommand(baseUrl(), bridgeToken(), 'save_workflow', {}, exec.signal, { timeoutMs: 10000 })
+    },
+  }))
+
+  ctx.tools.register(defineTool({
+    name: 'comfyui_move_node',
+    description: 'Move a node on the live ComfyUI canvas by absolute `pos` [x,y] or relative `offset` [dx,dy]. ' +
+      'Group boxes containing the node are re-fitted automatically, so moving a group member keeps its box hugging it.',
+    parameters: {
+      nodeId: { type: 'number', required: true, description: 'Node id to move.' },
+      pos: { type: 'array', description: 'Absolute canvas position [x, y].' },
+      offset: { type: 'array', description: 'Relative offset [dx, dy] added to the current position.' },
+    },
+    output: { schema: { type: 'object', additionalProperties: true }, render: renderJSON },
+    async execute(args, exec) {
+      return sendCommand(baseUrl(), bridgeToken(), 'move_node', {
+        nodeId: args?.nodeId,
+        pos: args?.pos,
+        offset: args?.offset,
+      }, exec.signal, { timeoutMs: 8000 })
+    },
+  }))
+
+  ctx.tools.register(defineTool({
+    name: 'comfyui_align_nodes',
+    description: 'Tidy a set of nodes on the live ComfyUI canvas: align edges/centers (`mode=align`, ' +
+      '`edge=left|right|top|bottom|hcenter|vcenter`), distribute evenly (`mode=distribute`, ' +
+      '`axis=horizontal|vertical`), or reflow into a grid (`mode=grid`, `cols`, `gap`). Group boxes of the ' +
+      'moved nodes are re-fitted automatically.',
+    parameters: {
+      nodeIds: { type: 'array', required: true, description: 'Node ids to arrange.' },
+      mode: { type: 'string', enum: ['align', 'distribute', 'grid'], description: 'Arrangement mode (default align).' },
+      edge: { type: 'string', enum: ['left', 'right', 'top', 'bottom', 'hcenter', 'vcenter'], description: 'Alignment edge for mode=align.' },
+      axis: { type: 'string', enum: ['horizontal', 'vertical'], description: 'Distribution axis for mode=distribute.' },
+      cols: { type: 'number', description: 'Column count for mode=grid (default 2).' },
+      gap: { type: 'number', description: 'Gap between cells for mode=grid (default 40).' },
+    },
+    output: { schema: { type: 'object', additionalProperties: true }, render: renderJSON },
+    async execute(args, exec) {
+      return sendCommand(baseUrl(), bridgeToken(), 'align_nodes', {
+        nodeIds: args?.nodeIds,
+        mode: args?.mode,
+        edge: args?.edge,
+        axis: args?.axis,
+        cols: args?.cols,
+        gap: args?.gap,
+      }, exec.signal, { timeoutMs: 8000 })
+    },
+  }))
+
   // v0.1.2 C: node development/debug tools — read / edit custom-node source and
   // reload ComfyUI so the change takes effect, all from the conversation. The
   // canvas doubles as the observation window: edit → reload → run a minimal
@@ -1753,8 +1839,8 @@ export function apply(ctx) {
         '| 场景 | 做法 | 禁止 |',
         '|---|---|---|',
         '| 修改现有工作流 | 当前画布直接增量编辑（set_param/connect/add_node/remove_node/inject_text） | 不要 load_workflow 整图替换（冲掉未保存现场） |',
-        '| 新建工作流 | 先 comfyui_clear 开空白画布再搭 | 不要在有内容/运行记录的画布上直接覆盖 |',
-        '| 搭建复杂工作流 | 用 comfyui_group 组节点分组（提示词区/采样区/输出区…） | 不要所有节点平铺一团 |',
+        '| 新建工作流 | 先 comfyui_new_canvas 新建空白画布（或 comfyui_clear 清空当前画布）再搭 | 不要在有内容/运行记录的画布上直接覆盖 |',
+        '| 搭建复杂工作流 | comfyui_group 分组 + comfyui_align_nodes / comfyui_move_node 整理布局（提示词区/采样区/输出区…） | 不要所有节点平铺一团 |',
         '| 快速验证/批量/无人值守 | 走 API/MCP 路径（mcp-comfyui 或原生 /prompt 直接提交），不必可视化 | 不要为展示而无谓地在画布上一步步搭 |',
         '',
         '双路径选择：可视调优/用户在看画布 → 画布路径（bridge 命令）；快速验证/批量/用户未开画布 → API/MCP 路径（导出 workflow 直交，或 mcp-comfyui 工具）。',
@@ -1769,7 +1855,7 @@ export function apply(ctx) {
         '6. comfyui_get_outputs 取回出图（支持 images/videos/gifs/audio）',
         '7. 用 vision 工具自检出图质量 → 不达标回 step 3 迭代；达标再交付',
         '',
-        '安全约定：读取永远只读；写操作（改节点/运行/替换图/清空画布）先向用户确认；批量用 comfyui_batch_run；清空画布（comfyui_clear）前先 comfyui_read_workflow 留存现场。',
+        '安全约定：读取永远只读；写操作（改节点/运行/替换图/清空画布/新建/重命名/保存）先向用户确认；批量用 comfyui_batch_run；清空画布（comfyui_clear）或新建画布（comfyui_new_canvas）前先 comfyui_read_workflow 留存现场，搭建完成后用 comfyui_save_workflow 保存。',
       ].join('\n'),
     })
     skills.register({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-comfyui-canvas",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "Give DeepSeek Harness agents live control of your ComfyUI canvas (local or cloud): embed it as a split-screen tab, then read/edit/run workflows, debug errors, fetch output images, and batch-sweep parameters straight from the chat. Ships the ComfyUI-side bridge node.",
   "type": "module",
   "main": "lib/index.js",
@@ -14,6 +14,7 @@
     "LICENSE",
     "README.md",
     "README.zh.md",
+    "CHANGELOG.md",
     "cordis.patch.yml",
     "lib",
     "comfyui-bridge",