dsh-knj-workflow 2026.9.73 → 2026.9.100

package/README.md

@@ -12,6 +12,7 @@
 - **可视化进度**：右侧栏「开发任务」tab 横向步骤条展示每个阶段状态（待执行/运行中/完成/失败），实时刷新
 - **阶段重跑 / 继续**：失败的阶段可点击「重跑」，暂停/失败的任务可点击「继续」——基于断点持久化（每阶段结果落盘）
 - **斜杠命令**：`/dev-task new <标题>`、`/dev-task list`、`/dev-task status <id>`、`/dev-task wf`
+- **AI 助手对话配置（新）**：在图编辑器里用自然语言改流程图——对话坞位于编辑器下半区（左=对话过程 / 右=指令输入），AI 返回「回复 + 编辑动作序列」，逐条校验后实时应用到画布草稿；整轮改动一次撤销，可查看推理/工具/正文流与 token 用量
 - **定时调度集成（可选）**：为 `dsh-scheduler` 提供进程内 `knjWorkflowScheduler` 服务；定时触发时按最新保存的流程定义创建并启动任务，历史可直达该任务详情
 - **UI 融入原生**：左侧栏底部「新建任务」入口 + 右侧栏两个 tab（better-sidebar 扩展点），全部使用 DSH 原生设计令牌（`--dsw-*`）
 
@@ -68,6 +69,20 @@ dsh plugin --profile web add dsh-knj-workflow
 | POST | `/devtask/tasks/:id/start` `/cancel` `/resume` | 启动 / 取消 / 继续 |
 | POST | `/devtask/tasks/:id/rerun-stage` | 重跑指定阶段 |
 | GET | `/devtask/tasks/:id/stages/:stageId` | 阶段断点产物 |
+| POST | `/devtask/assist` | AI 助手对话：`{ workflow, message, history? }` → `202 { requestId }`（异步启动） |
+| GET | `/devtask/assist/progress?id=&since=` | 对话过程：`{ events[], stream{text,reasoning,tools,usage}, done, result? }` |
+
+## AI 助手对话配置
+
+在「流程设计」打开任一工作流 → 编辑器下半区出现对话坞，用自然语言描述改动即可（如
+「在 coding 后加一个代码验证节点，输出 passed（布尔），通过走人工评审、失败回到 coding」）。
+
+- **改动可控**：AI 返回结构化编辑动作（add_node / set_node / remove_edge / add_edge / set_routes …），
+  Host 逐条做语义预检 + 全图校验，非法动作被拒并说明原因（不会写出坏图）；整轮改动 = 一次撤销步
+- **遵守流程配置规范**：内置本插件的流程配置规范（图形态、节点选型、输出字段类型、网关条件、
+  人工审批去向、并行限制、引用语法、运行语义与反模式），规范与 `validateWorkflow` 由一致性测试绑定
+- **过程可见**：对话坞实时显示助手推理、正文流、工具调用与 token 用量；可跳转查看助手完整会话
+- **独立通道**：经 workflow 引擎派专用 subagent，不占用主对话上下文；「＋ 新对话」可随时清空对话重来（画布草稿保留）
 
 ## 编排器参数
 

package/lib/assist-edits.js

@@ -0,0 +1,284 @@
+/**
+ * dsh-knj-workflow AI 助手编辑动作引擎（纯函数，零依赖）
+ * ---------------------------------------------------------------
+ * applyEdits(workflow, edits) —— 把 AI 助手返回的编辑动作序列可靠地应用
+ * 到工作流草稿上，作为「对话配置工作流」的安全地基：
+ *
+ *   - 语义预检（动作级）：删 start/end、引用不存在的节点/边、重复边、
+ *     set_node 写 x/y/id、set_meta 改 workflow.id、human routes 目标无效、
+ *     未知动作类型 —— 单条 rejected（含原因），跳过该动作，其余合法动作继续；
+ *   - 图结构终检（批级）：全部动作应用后跑一次 validateWorkflow。
+ *       ok  → 返回 { workflow: 应用后, applied, rejected }
+ *       !ok → 整批回滚：workflow = 原始（深拷贝）, applied = [], rejected 追记图错误
+ *
+ * 数据模型约定（与 lib/graph.js / orchestrator.js 一致，勿偏离）：
+ *   workflow = { id, name, schemaVersion:2, inputs, nodes:[{id,type,title,...}], edges:[{from,to,when?,default?}] }
+ *   节点 type：start | end | task | gateway-xor | gateway-and | human
+ *   human 节点去向：routes（label + to）优先，兼容 approveTo/rejectTo
+ *
+ * AI 不允许：写 x/y 坐标（布局归 Client）、整体替换 workflow、修改 workflow.id。
+ */
+
+import { validateWorkflow } from './graph.js';
+
+const NODE_TYPES = new Set(['start', 'end', 'task', 'gateway-xor', 'gateway-and', 'human']);
+const KNOWN_ACTIONS = new Set([
+  'add_node', 'set_node', 'remove_node',
+  'add_edge', 'set_edge', 'remove_edge',
+  'set_routes', 'set_meta',
+]);
+// set_node 允许写的节点字段白名单（AI 不可写布局坐标/内部类型/输入映射）
+const NODE_PATCH_KEYS = new Set(['title', 'body', 'routes', 'approveTo', 'rejectTo', 'maxRuns', 'skill', 'description', 'displayFrom']);
+// set_meta 允许写的顶层字段（id 是身份，绝不允许 AI 改）
+const META_PATCH_KEYS = new Set(['name', 'description', 'inputs']);
+
+/** 深拷贝辅助（JSON 往返即可，数据均为可序列化结构）。 */
+function clone(x) { return JSON.parse(JSON.stringify(x)); }
+
+/** 无 id 的 add_node：英文标题 → task-<slug>；否则 task-<随机 6 位>。 */
+function autoNodeId(nodes, title, type) {
+  const slug = String(title || '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+  if (slug) {
+    const base = `task-${slug}`;
+    if (!nodes.some((n) => n.id === base)) return base;
+    return `${base}-${Math.random().toString(36).slice(2, 8)}`;
+  }
+  const t = type === 'task' ? 'task' : type;
+  for (let i = 0; i < 20; i++) {
+    const id = `${t}-${Math.random().toString(36).slice(2, 8)}`;
+    if (!nodes.some((n) => n.id === id)) return id;
+  }
+  return `${t}-${Date.now().toString(36)}`;
+}
+
+/** 默认 task 节点形状：与 orchestrator/graph 约定对齐（inputs 依赖显式声明）。 */
+function blankNode(id, type, title, extra) {
+  const node = { id, type, title: title || '' };
+  if (type === 'task') {
+    node.inputs = [];
+    node.body = { prompt: '', mode: 'single', output: {} };
+  }
+  if (extra && typeof extra === 'object') {
+    for (const k of Object.keys(extra)) {
+      if (k === 'id' || k === 'type' || k === 'x' || k === 'y') continue; // AI 不许直接写
+      node[k] = clone(extra[k]);
+    }
+  }
+  return node;
+}
+
+/** 动作语义预检（不含整图拓扑）。返回错误字符串；null 表示通过。 */
+function precheck(workflow, action) {
+  if (!action || typeof action !== 'object') return '动作必须是对象';
+  const a = action.action;
+  if (!KNOWN_ACTIONS.has(a)) return `未知动作类型: ${a}`;
+
+  const { nodes, edges } = workflow;
+  const hasNode = (id) => nodes.some((n) => n.id === id);
+  const nodeType = (id) => (nodes.find((n) => n.id === id) || {}).type;
+  const edgeKey = (from, to) => `${from}\u0000${to}`;
+  const edgeSet = new Set(edges.map((e) => edgeKey(e.from, e.to)));
+
+  switch (a) {
+    case 'add_node': {
+      const type = action.type;
+      if (!NODE_TYPES.has(type)) return `add_node type 非法: ${type}`;
+      if (action.id !== undefined && action.id !== null && action.id !== '') {
+        if (typeof action.id !== 'string') return 'add_node id 必须是字符串';
+        if (hasNode(action.id)) return `节点 id 已存在: ${action.id}`;
+      }
+      // routes 目标有效性（human）
+      const routes = Array.isArray(action.routes) ? action.routes : [];
+      for (const r of routes) {
+        if (!r || !r.label) return `human 去向缺少标签`;
+        if (r.to && !hasNode(r.to) && r.to !== action.id) return `human 去向「${r.label}」目标不存在: ${r.to}`;
+      }
+      return null;
+    }
+    case 'remove_node': {
+      const id = action.id;
+      if (!hasNode(id)) return `节点不存在: ${id}`;
+      const t = nodeType(id);
+      if (t === 'start' || t === 'end') return `节点 ${id} 是流程必需起止点（${t}），不能删除`;
+      return null;
+    }
+    case 'set_node': {
+      const id = action.id;
+      if (!hasNode(id)) return `节点不存在: ${id}`;
+      const t = nodeType(id);
+      const bad = Object.keys(action.patch || {}).filter((k) => !NODE_PATCH_KEYS.has(k));
+      if (bad.length) return `set_node 不允许写字段: ${bad.join(', ')}（坐标/类型/id 由系统管理）`;
+      if (t !== 'human' && (action.patch?.routes || action.patch?.approveTo || action.patch?.rejectTo)) {
+        return `仅 human 节点可配置去向（routes/approveTo/rejectTo）`;
+      }
+      return null;
+    }
+    case 'add_edge': {
+      const from = action.from, to = action.to;
+      if (!hasNode(from)) return `add_edge from 节点不存在: ${from}`;
+      if (!hasNode(to)) return `add_edge to 节点不存在: ${to}`;
+      if (edgeSet.has(edgeKey(from, to))) return `重复边（已存在连线）: ${from} → ${to}`;
+      if (from === to) return `不允许自环边: ${from} → ${from}`;
+      return null;
+    }
+    case 'remove_edge': {
+      const from = action.from, to = action.to;
+      if (!edgeSet.has(edgeKey(from, to))) return `边不存在: ${from} → ${to}`;
+      return null;
+    }
+    case 'set_edge': {
+      const from = action.from, to = action.to;
+      if (!edgeSet.has(edgeKey(from, to))) return `边不存在: ${from} → ${to}`;
+      const bad = Object.keys(action.patch || {}).filter((k) => !['when', 'default'].includes(k));
+      if (bad.length) return `set_edge 不允许写字段: ${bad.join(', ')}（仅 when/default）`;
+      return null;
+    }
+    case 'set_routes': {
+      const id = action.id;
+      if (!hasNode(id)) return `节点不存在: ${id}`;
+      if (nodeType(id) !== 'human') return `仅 human 节点可配置去向（当前 ${nodeType(id)}）`;
+      const routes = Array.isArray(action.routes) ? action.routes : [];
+      if (routes.length === 0) return `human 节点 ${id} 至少需要一个去向`;
+      const labels = new Set();
+      for (const r of routes) {
+        if (!r || !r.label) return `human 去向缺少标签`;
+        if (labels.has(r.label)) return `human 去向标签重复: ${r.label}`;
+        labels.add(r.label);
+        if (!r.to || !hasNode(r.to)) return `human 去向「${r.label}」目标无效: ${r.to}`;
+      }
+      return null;
+    }
+    case 'set_meta': {
+      const bad = Object.keys(action).filter((k) => k !== 'action' && !META_PATCH_KEYS.has(k));
+      if (bad.length) return `set_meta 不允许写字段: ${bad.join(', ')}（id 不可改）`;
+      return null;
+    }
+    default:
+      return null;
+  }
+}
+
+/** 应用单个动作到 wf（在 precheck 通过后调用；返回新 wf，不就地修改）。 */
+function applyOne(wf, action) {
+  const out = clone(wf);
+  switch (action.action) {
+    case 'add_node': {
+      const id = action.id || autoNodeId(out.nodes, action.title, action.type);
+      const node = blankNode(id, action.type, action.title, action);
+      out.nodes.push(node);
+      return { wf: out, nodeId: id };
+    }
+    case 'remove_node': {
+      const id = action.id;
+      out.nodes = out.nodes.filter((n) => n.id !== id);
+      out.edges = out.edges.filter((e) => e.from !== id && e.to !== id);
+      return { wf: out };
+    }
+    case 'set_node': {
+      out.nodes = out.nodes.map((n) => {
+        if (n.id !== action.id) return n;
+        const patch = action.patch || {};
+        const next = { ...n };
+        for (const k of Object.keys(patch)) {
+          if (k === 'body' && n.body) next.body = { ...n.body, ...clone(patch.body) };
+          else next[k] = clone(patch[k]);
+        }
+        return next;
+      });
+      return { wf: out };
+    }
+    case 'add_edge': {
+      const e = { from: action.from, to: action.to };
+      if (action.when !== undefined) e.when = clone(action.when);
+      if (action.default !== undefined) e.default = !!action.default;
+      out.edges.push(e);
+      return { wf: out };
+    }
+    case 'remove_edge': {
+      out.edges = out.edges.filter((e) => !(e.from === action.from && e.to === action.to));
+      return { wf: out };
+    }
+    case 'set_edge': {
+      out.edges = out.edges.map((e) => {
+        if (!(e.from === action.from && e.to === action.to)) return e;
+        const patch = action.patch || {};
+        const next = { ...e };
+        for (const k of ['when', 'default']) {
+          if (k in patch) next[k] = k === 'default' ? !!patch[k] : clone(patch[k]);
+        }
+        return next;
+      });
+      return { wf: out };
+    }
+    case 'set_routes': {
+      out.nodes = out.nodes.map((n) => {
+        if (n.id !== action.id) return n;
+        const next = { ...n };
+        next.routes = clone(action.routes);
+        delete next.approveTo;
+        delete next.rejectTo;
+        return next;
+      });
+      return { wf: out };
+    }
+    case 'set_meta': {
+      for (const k of Object.keys(action)) {
+        if (k === 'action') continue;
+        out[k] = clone(action[k]);
+      }
+      return { wf: out };
+    }
+    default:
+      return { wf: out };
+  }
+}
+
+/**
+ * 把编辑动作序列应用到工作流草稿。
+ * @param {object} workflow 现有工作流（不可变：无论成败都不修改入参）
+ * @param {Array}  edits    编辑动作数组 [{ action, ... }]
+ * @returns {{ workflow, applied: Array, rejected: Array }}
+ */
+export function applyEdits(workflow, edits) {
+  if (!workflow || typeof workflow !== 'object') {
+    return { workflow, applied: [], rejected: [{ action: null, reason: 'workflow 必须是对象' }] };
+  }
+  if (!Array.isArray(edits)) {
+    return { workflow: clone(workflow), applied: [], rejected: [{ action: null, reason: 'edits 必须是数组' }] };
+  }
+  if (!Array.isArray(workflow.nodes) || !Array.isArray(workflow.edges)) {
+    return { workflow: clone(workflow), applied: [], rejected: [{ action: null, reason: 'workflow 必须是 { nodes, edges } 结构' }] };
+  }
+
+  let current = clone(workflow);
+  const applied = [];
+  const rejected = [];
+
+  for (const action of edits) {
+    const err = precheck(current, action);
+    if (err) {
+      rejected.push({ action: clone(action || null), reason: err });
+      continue;
+    }
+    try {
+      const { wf, nodeId } = applyOne(current, action);
+      current = wf;
+      applied.push({ action: action.action, nodeId, from: action.from, to: action.to, id: action.id });
+    } catch (error) {
+      // 单动作意外错误：按 rejected 处理，不污染图
+      rejected.push({ action: clone(action), reason: `应用动作失败: ${error instanceof Error ? error.message : String(error)}` });
+    }
+  }
+
+  // 图结构终检：整批合法性。不通过 → 整批回滚，绝不放行坏图。
+  const v = validateWorkflow(current);
+  if (!v.ok) {
+    const reason = `图校验未通过: ${(v.errors || []).join('；')}`;
+    return { workflow: clone(workflow), applied: [], rejected: [...rejected, { action: null, reason }] };
+  }
+
+  return { workflow: current, applied, rejected };
+}

package/lib/assist-edits.test.js

@@ -0,0 +1,283 @@
+/**
+ * dsh-knj-workflow AI 助手编辑动作引擎单元测试（node:test，零依赖）
+ * ---------------------------------------------------------------
+ * 运行：node --test lib/assist-edits.test.js
+ * 覆盖：applyEdits 逐条应用/语义预检/图校验回滚、动作集白名单、非法场景、
+ *       原 workflow 深度不可变。
+ *
+ * 引擎语义（与 design/assist-impl-phase1.spec.md 一致）：
+ *   - 动作级语义预检失败 → rejected（含原因），跳过该动作，其余合法动作继续；
+ *   - 全部动作应用后跑一次 validateWorkflow：
+ *       ok  → 返回 { workflow: 应用后, applied, rejected }
+ *       !ok → 整批回滚：workflow = 原始深拷贝, applied = [], rejected 追加图校验错误
+ */
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { applyEdits } from './assist-edits.js';
+
+/** 串行基座：start → a(task) → end（合法图） */
+function baseWorkflow(over = {}) {
+  return {
+    id: 'wf-base', name: '基座', schemaVersion: 2, revision: 1,
+    inputs: [],
+    nodes: [
+      { id: 'start', type: 'start' },
+      { id: 'a', type: 'task', title: 'A', inputs: [], body: { prompt: '做 A', mode: 'single', output: {} } },
+      { id: 'end', type: 'end' },
+    ],
+    edges: [
+      { from: 'start', to: 'a' },
+      { from: 'a', to: 'end' },
+    ],
+    ...over,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// 动作集白名单与基本语义
+// ---------------------------------------------------------------------------
+test('applyEdits: add_node 合法（无 id 时按标题生成 task-<slug>，可被同批引用）', () => {
+  const wf = baseWorkflow();
+  const r = applyEdits(wf, [
+    { action: 'remove_edge', from: 'a', to: 'end' }, // 先拆原边，a 才有空间接新分支
+    { action: 'add_node', type: 'task', title: 'Verify', body: { prompt: '校验', mode: 'single', output: { passed: { type: 'boolean' } } } },
+    { action: 'add_edge', from: 'a', to: 'task-verify' },
+    { action: 'add_edge', from: 'task-verify', to: 'end' },
+  ]);
+  assert.equal(r.rejected.length, 0, JSON.stringify(r.rejected));
+  assert.equal(r.applied.length, 4);
+  const node = r.workflow.nodes.find((n) => n.id === 'task-verify');
+  assert.ok(node && node.title === 'Verify' && node.type === 'task');
+});
+
+test('applyEdits: add_node 中文标题 → 兜底随机 task-xxxx 前缀', () => {
+  const wf = baseWorkflow();
+  const r = applyEdits(wf, [
+    { action: 'add_node', type: 'task', id: 'task-zh', title: '验证' },
+    { action: 'remove_edge', from: 'a', to: 'end' },
+    { action: 'add_edge', from: 'a', to: 'task-zh' },
+    { action: 'add_edge', from: 'task-zh', to: 'end' },
+  ]);
+  assert.equal(r.rejected.length, 0, JSON.stringify(r.rejected));
+  // 兜底生成逻辑单独存在即可，这里验证显式 id 仍可用
+  const node = r.workflow.nodes.find((n) => n.id === 'task-zh');
+  assert.ok(node && node.title === '验证');
+});
+
+test('applyEdits: 显式 id 生效且不重复生成', () => {
+  const wf = baseWorkflow();
+  const r = applyEdits(wf, [
+    { action: 'remove_edge', from: 'a', to: 'end' },
+    { action: 'add_node', type: 'task', id: 'verify', title: '验证' },
+    { action: 'add_edge', from: 'a', to: 'verify' },
+    { action: 'add_edge', from: 'verify', to: 'end' },
+  ]);
+  assert.equal(r.rejected.length, 0);
+  assert.ok(r.workflow.nodes.some((n) => n.id === 'verify'));
+});
+
+test('applyEdits: 未知动作类型被拒且不影响其它合法动作', () => {
+  const wf = baseWorkflow();
+  const r = applyEdits(wf, [
+    { action: 'explode_everything' },
+    { action: 'set_meta', name: '改名' },
+  ]);
+  assert.equal(r.rejected.length, 1);
+  assert.match(r.rejected[0].reason, /未知动作|explode_everything/);
+  assert.ok(r.applied.some((x) => x.action === 'set_meta'));
+  assert.equal(r.workflow.name, '改名');
+});
+
+test('applyEdits: 空 edits / 非数组 edits 不崩溃', () => {
+  assert.equal(applyEdits(baseWorkflow(), []).applied.length, 0);
+  const r = applyEdits(baseWorkflow(), null);
+  assert.ok(Array.isArray(r.rejected) && r.rejected.length >= 1);
+});
+
+// ---------------------------------------------------------------------------
+// 动作级非法场景（逐条拒绝，不污染，不影响后续）
+// ---------------------------------------------------------------------------
+test('applyEdits: 删除 start / end 被拒', () => {
+  const wf = baseWorkflow();
+  const r = applyEdits(wf, [
+    { action: 'remove_node', id: 'start' },
+    { action: 'remove_node', id: 'end' },
+  ]);
+  assert.equal(r.rejected.length, 2);
+  assert.ok(r.workflow.nodes.some((n) => n.id === 'start'));
+  assert.ok(r.workflow.nodes.some((n) => n.id === 'end'));
+});
+
+test('applyEdits: remove_node / remove_edge 引用不存在的节点/边被拒', () => {
+  const wf = baseWorkflow();
+  const r = applyEdits(wf, [
+    { action: 'remove_node', id: 'ghost' },
+    { action: 'remove_edge', from: 'a', to: 'ghost' },
+  ]);
+  assert.equal(r.rejected.length, 2);
+});
+
+test('applyEdits: 重复边被拒（同一 from→to 已有）', () => {
+  const wf = baseWorkflow();
+  const r = applyEdits(wf, [
+    { action: 'add_edge', from: 'start', to: 'a' },
+  ]);
+  assert.equal(r.rejected.length, 1);
+  assert.match(r.rejected[0].reason, /重复|已存在/);
+});
+
+test('applyEdits: add_edge 指向不存在的节点被拒', () => {
+  const wf = baseWorkflow();
+  const r = applyEdits(wf, [{ action: 'add_edge', from: 'a', to: 'nope' }]);
+  assert.equal(r.rejected.length, 1);
+  assert.match(r.rejected[0].reason, /不存在/);
+});
+
+test('applyEdits: set_node 不允许写 x/y 坐标与 id', () => {
+  const wf = baseWorkflow();
+  const r = applyEdits(wf, [
+    { action: 'set_node', id: 'a', patch: { x: 999, y: 999, title: '改标题' } },
+  ]);
+  assert.equal(r.rejected.length, 1);
+  assert.match(r.rejected[0].reason, /x|y|id/);
+  const a = r.workflow.nodes.find((n) => n.id === 'a');
+  assert.equal(a.x, undefined);
+  assert.equal(a.title, 'A');
+});
+
+test('applyEdits: set_meta 不允许改 workflow id', () => {
+  const wf = baseWorkflow();
+  const r = applyEdits(wf, [{ action: 'set_meta', id: 'evil-id', name: 'x' }]);
+  assert.equal(r.rejected.length, 1);
+  assert.equal(r.workflow.id, 'wf-base');
+});
+
+test('applyEdits: human 节点 routes 指向不存在节点被拒', () => {
+  const wf = baseWorkflow();
+  const r = applyEdits(wf, [
+    { action: 'add_node', type: 'human', id: 'h1', title: '审批', routes: [{ label: '通过', to: 'nope' }] },
+  ]);
+  assert.equal(r.rejected.length, 1);
+});
+
+test('applyEdits: set_node 引用不存在节点被拒', () => {
+  const wf = baseWorkflow();
+  const r = applyEdits(wf, [{ action: 'set_node', id: 'ghost', patch: { title: 'x' } }]);
+  assert.equal(r.rejected.length, 1);
+});
+
+// ---------------------------------------------------------------------------
+// 终检回滚场景（图校验失败 → 整批回滚，原图不被污染）
+// ---------------------------------------------------------------------------
+test('applyEdits: 孤立节点导致终检失败 → 整批回滚', () => {
+  const wf = baseWorkflow();
+  const r = applyEdits(wf, [{ action: 'add_node', type: 'task', id: 'orphan', title: '孤儿' }]);
+  assert.equal(r.applied.length, 0);
+  assert.ok(r.rejected.length >= 1);
+  assert.match(r.rejected.map((x) => x.reason).join(' '), /孤立|入边|校验/);
+  assert.deepEqual(r.workflow, wf, '整批回滚后原 workflow 不被污染');
+});
+
+test('applyEdits: XOR 出边不足/缺 default 导致终检失败 → 回滚', () => {
+  const wf = baseWorkflow();
+  // 把 a 后改接 XOR，但 XOR 只给 1 条出边 → 非法
+  const r = applyEdits(wf, [
+    { action: 'add_node', type: 'gateway-xor', id: 'gw', title: '分支' },
+    { action: 'add_node', type: 'task', id: 'd1', title: 'D1' },
+    { action: 'remove_edge', from: 'a', to: 'end' },
+    { action: 'add_edge', from: 'a', to: 'gw' },
+    { action: 'add_edge', from: 'gw', to: 'd1' }, // 仅 1 条出边且非 default → XOR 出边<2
+    { action: 'add_edge', from: 'd1', to: 'end' },
+  ]);
+  assert.equal(r.applied.length, 0, JSON.stringify(r.rejected));
+  assert.deepEqual(r.workflow, wf);
+});
+
+test('applyEdits: 完整 XOR 分流合法批量 → 全部 applied 无 rejected', () => {
+  const wf = baseWorkflow();
+  const r = applyEdits(wf, [
+    { action: 'add_node', type: 'gateway-xor', id: 'gw', title: '复杂度' },
+    { action: 'add_node', type: 'task', id: 'd1', title: '设计', body: { prompt: '设计', mode: 'single', output: {} } },
+    { action: 'add_node', type: 'task', id: 'd2', title: '直接编码', body: { prompt: '编码', mode: 'single', output: {} } },
+    { action: 'remove_edge', from: 'a', to: 'end' },
+    { action: 'add_edge', from: 'a', to: 'gw' },
+    { action: 'add_edge', from: 'gw', to: 'd1', when: { field: 'level', op: 'eq', value: 'high' } },
+    { action: 'add_edge', from: 'gw', to: 'd2', default: true },
+    { action: 'add_edge', from: 'd1', to: 'end' },
+    { action: 'add_edge', from: 'd2', to: 'end' },
+  ]);
+  assert.equal(r.rejected.length, 0, JSON.stringify(r.rejected));
+  assert.equal(r.applied.length, 9);
+  assert.ok(r.workflow.nodes.some((n) => n.id === 'gw'));
+  // 终检通过 → workflow 是应用后的（非回滚）
+  assert.notDeepEqual(r.workflow, wf);
+});
+
+test('applyEdits: AND 并行 split+join 合法（gateway-and 双向）', () => {
+  const wf = baseWorkflow();
+  const r = applyEdits(wf, [
+    { action: 'add_node', type: 'gateway-and', id: 'split', title: '并行' },
+    { action: 'add_node', type: 'gateway-and', id: 'join', title: '汇合' },
+    { action: 'add_node', type: 'task', id: 'b1', title: 'B1', body: { prompt: '', mode: 'single', output: {} } },
+    { action: 'add_node', type: 'task', id: 'b2', title: 'B2', body: { prompt: '', mode: 'single', output: {} } },
+    { action: 'remove_edge', from: 'a', to: 'end' },
+    { action: 'add_edge', from: 'a', to: 'split' },
+    { action: 'add_edge', from: 'split', to: 'b1' },
+    { action: 'add_edge', from: 'split', to: 'b2' },
+    { action: 'add_edge', from: 'b1', to: 'join' },
+    { action: 'add_edge', from: 'b2', to: 'join' },
+    { action: 'add_edge', from: 'join', to: 'end' },
+  ]);
+  assert.equal(r.rejected.length, 0, JSON.stringify(r.rejected));
+});
+
+test('applyEdits: human 节点 + routes 通过/驳回 合法', () => {
+  const wf = baseWorkflow();
+  const r = applyEdits(wf, [
+    { action: 'add_node', type: 'human', id: 'h1', title: '评审', routes: [{ label: '通过', to: 'end' }] },
+    { action: 'remove_edge', from: 'a', to: 'end' },
+    { action: 'add_edge', from: 'a', to: 'h1' },
+  ]);
+  assert.equal(r.rejected.length, 0, JSON.stringify(r.rejected));
+});
+
+test('applyEdits: 环线（驳回重做）合法：a → h1 → a', () => {
+  const wf = baseWorkflow();
+  const r = applyEdits(wf, [
+    { action: 'add_node', type: 'human', id: 'h1', title: '审批', routes: [{ label: '通过', to: 'end' }, { label: '驳回', to: 'a' }] },
+    { action: 'remove_edge', from: 'a', to: 'end' },
+    { action: 'add_edge', from: 'a', to: 'h1' },
+  ]);
+  assert.equal(r.rejected.length, 0, JSON.stringify(r.rejected));
+  // human 去向经 routes 表达：通过 → end（虚拟边）
+});
+
+test('applyEdits: set_node 修改 prompt/输出字段合法且保留其余字段', () => {
+  const wf = baseWorkflow();
+  const r = applyEdits(wf, [
+    { action: 'set_node', id: 'a', patch: { title: 'A 加强', body: { prompt: '更严格地做 A', mode: 'single', output: { passed: { type: 'boolean' } } } } },
+  ]);
+  assert.equal(r.rejected.length, 0);
+  const a = r.workflow.nodes.find((n) => n.id === 'a');
+  assert.equal(a.title, 'A 加强');
+  assert.equal(a.body.prompt, '更严格地做 A');
+  assert.deepEqual(a.body.output, { passed: { type: 'boolean' } });
+});
+
+// ---------------------------------------------------------------------------
+// 深度不可变：任何路径都不修改传入对象
+// ---------------------------------------------------------------------------
+test('applyEdits: 失败与成功路径均不改传入 workflow（深度不可变）', () => {
+  const wf = baseWorkflow();
+  const before = JSON.stringify(wf);
+  // 失败路径（终检回滚）
+  applyEdits(wf, [{ action: 'add_node', type: 'task', id: 'orphan2', title: '孤' }]);
+  // 成功路径
+  applyEdits(wf, [
+    { action: 'remove_edge', from: 'a', to: 'end' },
+    { action: 'add_node', type: 'task', id: 'v2', title: '验' },
+    { action: 'add_edge', from: 'a', to: 'v2' },
+    { action: 'add_edge', from: 'v2', to: 'end' },
+  ]);
+  assert.equal(JSON.stringify(wf), before);
+});