@aalis/plugin-workflow 0.14.0 → 0.15.0

package/dist/index.js

@@ -7,27 +7,31 @@
 // ============================================================
 import { cronEngine } from '@aalis/api-cron-engine';
 import { hooks } from '@aalis/api-hooks';
-import { createStorageGateway, isStorageUri, storage } from '@aalis/api-storage';
+import { isStorageUri, storage } from '@aalis/api-storage';
 import { tools } from '@aalis/api-tools';
-import { webuiServer } from '@aalis/api-webui';
+import { markdownCode, webuiServer } from '@aalis/api-webui';
 import { workflow } from '@aalis/api-workflow';
 import { config, definePlugin, events, lifecycle, logger, optional, provide } from '@aalis/core';
+import { configError, defineConfig, parseConfig } from '@aalis/schema-config';
 import { parse, stringify } from 'yaml';
 import { runDag, validateGraph } from './engine.js';
 import { normalizeDef, WorkflowLoader } from './loader.js';
 import { RunStore } from './persistence.js';
 import { TriggerManager } from './triggers.js';
-const configSchema = {
+// ─── 配置 ───
+const configSchema = defineConfig({
     defsDir: {
         type: 'string',
         label: '工作流定义目录',
         default: 'workspace:/workflows',
+        onInvalid: 'error',
         description: '加载存储下的 *.yaml 定义（storage URI）；AI 通过 workflow_define 创建的定义也写入此处。',
     },
     runsFile: {
         type: 'string',
         label: '运行历史文件',
         default: 'data:/workflow-runs.json',
+        onInvalid: 'error',
         description: '保存最近 N 条运行实例（storage URI）。',
     },
     maxRuns: {
@@ -40,83 +44,11 @@ const configSchema = {
         type: 'boolean',
         label: '注册 AI 工具',
         default: true,
+        onInvalid: 'error',
         description: '开启后向 LLM 暴露 workflow_define / workflow_run 等工具。',
     },
-};
-// ─── WebUI ───
-const webuiPages = [
-    {
-        key: 'workflows',
-        label: '工作流',
-        icon: '<svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><circle cx="6" cy="6" r="3"/><circle cx="18" cy="6" r="3"/><circle cx="12" cy="18" r="3"/><path d="M9 6h6"/><path d="M7.5 8.5L11 15.5"/><path d="M16.5 8.5L13 15.5"/></svg>',
-        order: 57,
-        content: [
-            {
-                type: 'stat',
-                label: '工作流总览',
-                source: 'workflowStats',
-            },
-            {
-                type: 'table',
-                label: '工作流定义',
-                source: 'listWorkflowsTable',
-                columns: [
-                    { key: 'id', label: 'ID', nowrap: true },
-                    { key: 'name', label: '名称' },
-                    { key: 'trigger', label: '触发器', nowrap: true },
-                    { key: 'nodeCount', label: '节点' },
-                    { key: 'enabled', label: '状态', nowrap: true },
-                    { key: 'description', label: '描述', maxWidth: 360, render: 'expandable-text' },
-                ],
-                actions: [
-                    { label: '立即运行', method: 'triggerWorkflow' },
-                    { label: '禁用/启用', method: 'toggleWorkflow' },
-                    { label: '查看 YAML', method: 'getWorkflowYaml' },
-                    { label: '删除', method: 'removeWorkflow', confirm: '确定删除该工作流？(同时删除磁盘文件)', danger: true },
-                ],
-                refresh: 60,
-            },
-            {
-                type: 'table',
-                label: '最近运行历史',
-                source: 'listRunsTable',
-                columns: [
-                    { key: 'runId', label: 'Run ID', nowrap: true },
-                    { key: 'workflowId', label: '工作流', nowrap: true },
-                    { key: 'status', label: '状态', nowrap: true },
-                    { key: 'triggerSource', label: '触发源', nowrap: true },
-                    { key: 'startedAtText', label: '开始时间', nowrap: true },
-                    { key: 'durationText', label: '耗时', nowrap: true },
-                    { key: 'error', label: '错误', maxWidth: 320, render: 'expandable-text' },
-                ],
-                refresh: 30,
-            },
-            {
-                type: 'form',
-                label: '新建 / 覆盖工作流（粘贴完整 YAML）',
-                source: 'newWorkflowDraft',
-                save: 'upsertWorkflowYaml',
-                schema: {
-                    yaml: {
-                        type: 'textarea',
-                        label: 'YAML 定义',
-                        required: true,
-                        description: '完整 WorkflowDef YAML：id / name / trigger / nodes。trigger 类型支持 cron / interval / once / event / manual。' +
-                            '节点类型 tool / send-message / wait / agent（agent 节点派发指令给 agent 并等回复，配合 deps + {{outputs.X}} 做多智能体编排）。' +
-                            '保存后将立即注册触发器并持久化到 defsDir。',
-                    },
-                    persist: {
-                        type: 'boolean',
-                        label: '写入磁盘',
-                        default: true,
-                        description: '关闭后仅在内存中注册（进程重启后丢失）',
-                    },
-                },
-            },
-        ],
-    },
-];
-// ─── 工具函数（与页面动作共享） ───
+});
+// ─── 工具函数（与工作流页共享） ───
 function triggerSummary(t) {
     switch (t.type) {
         case 'cron':
@@ -133,16 +65,6 @@ function triggerSummary(t) {
             return t.type;
     }
 }
-function fmtTs(ts) {
-    if (!ts || !Number.isFinite(ts))
-        return '—';
-    try {
-        return new Date(ts).toLocaleString('zh-CN', { hour12: false });
-    }
-    catch {
-        return String(ts);
-    }
-}
 function fmtDuration(ms) {
     if (!Number.isFinite(ms) || ms < 0)
         return '—';
@@ -155,7 +77,7 @@ function fmtDuration(ms) {
     return `${m}m${s}s`;
 }
 /**
- * once 记账读不出时本次运行不安排 once：定义或启用一个 once 的回执据此如实说明（AI 工具与页面动作同一口径）。
+ * once 记账读不出时本次运行不安排 once：定义或启用一个 once 的回执据此如实说明（AI 工具与工作流页同一口径）。
  * manualRun 是各自那一面手动执行的说法；不持久化的定义重启后就没了，「重启恢复」只对写了文件的定义成立。
  */
 function onceSkippedNote(def, persist, onceLedgerReadable, manualRun) {
@@ -163,143 +85,198 @@ function onceSkippedNote(def, persist, onceLedgerReadable, manualRun) {
         return undefined;
     return `once 记账读取失败（见日志），本次运行不会触发；可用${manualRun}手动执行${persist ? '，修复运行历史文件后重启恢复' : ''}`;
 }
+const STATUS = {
+    pending: { text: '等待', state: 'inactive' },
+    running: { text: '运行中', state: 'running' },
+    success: { text: '成功' },
+    failed: { text: '失败', state: 'error' },
+    cancelled: { text: '已取消', state: 'inactive' },
+};
 /**
- * 页面动作：处理函数是闭包，直接用本次激活构造的 WorkflowService，
- * 不再按名回查容器（查到的可能是别人提供的同名服务）。
+ * 工作流页：处理函数是闭包，直接用本次激活构造的 WorkflowService，不按名回查容器（查到的可能是别人提供的同名服务）。
+ * 返回页面的句柄：定义增删与运行起止时让它重取
  */
-function registerWebuiActions(webui, service, onceLedgerReadable) {
-    webui.registerAction('workflowStats', async () => {
-        const defs = service.listWorkflows();
-        const enabled = defs.filter(d => d.enabled !== false).length;
-        const runs = service.listRuns(200);
-        const last24h = runs.filter(r => Date.now() - r.startedAt < 86_400_000);
-        const failed24h = last24h.filter(r => r.status === 'failed' || r.status === 'cancelled').length;
-        return {
-            value: defs.length,
-            hint: `启用 ${enabled} · 24h 运行 ${last24h.length} · 失败 ${failed24h}`,
-        };
-    });
-    webui.registerAction('listWorkflowsTable', async () => {
-        return service.listWorkflows().map(d => ({
-            id: d.id,
-            name: d.name ?? d.id,
-            trigger: triggerSummary(d.trigger),
-            nodeCount: d.nodes.length,
-            enabled: d.enabled === false ? '⏸ 禁用' : '✅ 启用',
-            description: d.description ?? '',
-        }));
-    });
-    webui.registerAction('listRunsTable', async () => {
-        return service.listRuns(50).map(r => {
-            const dur = (r.finishedAt ?? Date.now()) - r.startedAt;
-            const statusIcon = r.status === 'success' ? '✅' : r.status === 'failed' ? '❌' : r.status === 'cancelled' ? '⏹' : '⏳';
-            return {
-                runId: r.runId,
-                workflowId: r.workflowId,
-                status: `${statusIcon} ${r.status}`,
-                triggerSource: r.triggerSource,
-                startedAtText: fmtTs(r.startedAt),
-                durationText: fmtDuration(dur),
-                error: r.error ?? '',
-            };
-        });
-    });
-    webui.registerAction('triggerWorkflow', async (args) => {
-        try {
-            const run = await service.runWorkflow(String(args.id), {}, 'manual:webui');
-            return {
-                ok: true,
-                runId: run.runId,
-                status: run.status,
-                durationMs: (run.finishedAt ?? Date.now()) - run.startedAt,
-                error: run.error,
-            };
-        }
-        catch (err) {
-            return { ok: false, error: err instanceof Error ? err.message : String(err) };
-        }
-    });
-    webui.registerAction('toggleWorkflow', async (args) => {
-        const def = service.getWorkflow(String(args.id));
-        if (!def)
-            return { ok: false, error: '工作流不存在' };
-        const next = { ...def, enabled: def.enabled === false };
-        try {
-            await service.defineWorkflow(next, { persist: true });
-            const note = onceSkippedNote(next, true, onceLedgerReadable(), '「立即运行」');
-            return { ok: true, enabled: next.enabled, ...(note ? { message: `已启用；${note}` } : {}) };
-        }
-        catch (err) {
-            return { ok: false, error: err instanceof Error ? err.message : String(err) };
-        }
-    });
-    webui.registerAction('getWorkflowYaml', async (args) => {
-        const def = service.getWorkflow(String(args.id));
+function defineWorkflowPage(webui, service, onceLedgerReadable) {
+    const definitionOf = (id) => {
+        const def = service.getWorkflow(id);
         if (!def)
-            return { error: '工作流不存在' };
-        return { id: def.id, yaml: stringify(def) };
-    });
-    webui.registerAction('removeWorkflow', async (args) => (await service.removeWorkflow(String(args.id))) ? { ok: true } : { ok: false, error: '工作流不存在' });
-    webui.registerAction('newWorkflowDraft', async () => ({
-        yaml: `id: my-workflow
-name: 示例工作流
-description: 描述这个工作流的作用
-trigger:
-  type: manual
-vars:
-  greeting: hello
-nodes:
-  - id: say
-    type: send-message
-    sessionId: internal:demo
-    platform: internal
-    content: "{{vars.greeting}}, world!"
-`,
-        persist: true,
-    }));
-    webui.registerAction('upsertWorkflowYaml', async (args) => {
-        const yamlText = String(args.yaml ?? '').trim();
-        if (!yamlText)
-            return { ok: false, error: 'yaml 不能为空' };
-        let raw;
-        try {
-            raw = parse(yamlText);
-        }
-        catch (err) {
-            return { ok: false, error: `YAML 解析失败: ${err instanceof Error ? err.message : err}` };
-        }
-        const def = normalizeDef(raw, `wf-${Date.now()}`);
-        if (!def)
-            return { ok: false, error: '定义不合法：缺少 trigger 或 nodes' };
-        const persist = args.persist !== false;
-        try {
-            await service.defineWorkflow(def, { persist });
-            const note = onceSkippedNote(def, persist, onceLedgerReadable(), '「立即运行」');
-            return { ok: true, id: def.id, nodes: def.nodes.length, ...(note ? { message: `已保存；${note}` } : {}) };
-        }
-        catch (err) {
-            return { ok: false, error: err instanceof Error ? err.message : String(err) };
-        }
+            throw new Error(`工作流 ${id} 不存在`);
+        return def;
+    };
+    /** 启用或停用：改的是写在磁盘上的定义 */
+    const setEnabled = async (id, enabled) => {
+        const next = { ...definitionOf(id), enabled };
+        await service.defineWorkflow(next, { persist: true });
+        const note = onceSkippedNote(next, true, onceLedgerReadable(), '「立即运行」');
+        return `已${enabled ? '启用' : '停用'} ${id}${note ? `；${note}` : ''}`;
+    };
+    return webui.definePage({
+        key: 'workflows',
+        title: '工作流',
+        icon: 'workflow',
+        actions: {
+            runWorkflow: {
+                label: '立即运行',
+                effect: 'write',
+                row: true,
+                async handler({ rowKey }) {
+                    const run = await service.runWorkflow(rowKey, {}, 'manual:webui');
+                    if (run.status !== 'success') {
+                        throw new Error(`运行没有成功（${STATUS[run.status].text}）${run.error ? `：${run.error}` : ''}`);
+                    }
+                    return `已运行 ${rowKey}，用时 ${fmtDuration((run.finishedAt ?? Date.now()) - run.startedAt)}`;
+                },
+            },
+            enableWorkflow: { label: '启用', effect: 'write', row: true, handler: ({ rowKey }) => setEnabled(rowKey, true) },
+            disableWorkflow: {
+                label: '停用',
+                effect: 'write',
+                row: true,
+                handler: ({ rowKey }) => setEnabled(rowKey, false),
+            },
+            removeWorkflow: {
+                label: '删除',
+                effect: 'destructive',
+                confirm: '删除这个工作流，连同磁盘上的定义文件？',
+                row: true,
+                async handler({ rowKey }) {
+                    if (!(await service.removeWorkflow(rowKey)))
+                        throw new Error(`工作流 ${rowKey} 不存在`);
+                    return `已删除 ${rowKey}`;
+                },
+            },
+            defineWorkflow: {
+                label: '新建或覆盖',
+                effect: 'write',
+                input: {
+                    yaml: {
+                        type: 'textarea',
+                        label: 'YAML 定义',
+                        required: true,
+                        description: '完整的定义：id、name、trigger、nodes。trigger 支持 cron、interval、once、event、manual；节点支持 tool、send-message、' +
+                            'wait、agent（派发指令给 agent 并等回复，配合 deps 与 {{outputs.X}} 做多智能体编排）。同 id 的定义被覆盖，' +
+                            '保存后立即注册触发器。现有定义的 YAML 在定义表格的详情里，可以照着改。',
+                    },
+                    persist: {
+                        type: 'boolean',
+                        label: '写入磁盘',
+                        default: true,
+                        description: '关闭后只在内存里注册，重启后丢失',
+                    },
+                },
+                async handler({ input }) {
+                    let raw;
+                    try {
+                        raw = parse(input.yaml);
+                    }
+                    catch (err) {
+                        throw new Error(`YAML 解析失败：${err instanceof Error ? err.message : String(err)}`);
+                    }
+                    const def = normalizeDef(raw, `wf-${Date.now()}`);
+                    if (!def)
+                        throw new Error('定义不合法：缺少 trigger 或 nodes');
+                    await service.defineWorkflow(def, { persist: input.persist });
+                    const note = onceSkippedNote(def, input.persist, onceLedgerReadable(), '「立即运行」');
+                    return `已保存工作流 ${def.id}${note ? `；${note}` : ''}`;
+                },
+            },
+        },
+        content: [
+            {
+                type: 'info',
+                id: 'summary',
+                data() {
+                    const defs = service.listWorkflows();
+                    const recent = service.listRuns(200).filter(r => Date.now() - r.startedAt < 86_400_000);
+                    return [
+                        { label: '定义', value: defs.length },
+                        { label: '启用', value: defs.filter(d => d.enabled !== false).length },
+                        { label: '24 小时运行', value: recent.length },
+                        {
+                            label: '24 小时失败',
+                            value: recent.filter(r => r.status === 'failed' || r.status === 'cancelled').length,
+                        },
+                    ];
+                },
+            },
+            {
+                type: 'table',
+                id: 'workflows',
+                label: '定义',
+                rowKey: 'id',
+                empty: '还没有工作流',
+                columns: [
+                    { key: 'id', label: 'ID', kind: 'code' },
+                    { key: 'name', label: '名称', primary: true },
+                    { key: 'trigger', label: '触发' },
+                    { key: 'nodes', label: '节点数' },
+                    { key: 'status', label: '状态', kind: 'status', primary: true },
+                    { key: 'description', label: '描述', kind: 'long-text' },
+                ],
+                rowActions: [
+                    { action: 'runWorkflow' },
+                    { action: 'enableWorkflow', visibleWhen: 'disabled' },
+                    { action: 'disableWorkflow', visibleWhen: 'enabled' },
+                    { action: 'removeWorkflow' },
+                ],
+                data: () => service.listWorkflows().map(d => ({
+                    id: d.id,
+                    name: d.name ?? d.id,
+                    trigger: triggerSummary(d.trigger),
+                    nodes: d.nodes.length,
+                    status: d.enabled === false ? { text: '停用', state: 'inactive' } : { text: '启用' },
+                    enabled: d.enabled !== false,
+                    disabled: d.enabled === false,
+                    description: d.description ?? '',
+                })),
+                detail: [
+                    {
+                        type: 'markdown',
+                        id: 'yaml',
+                        label: 'YAML',
+                        data: ({ rowKey }) => markdownCode(stringify(definitionOf(rowKey)), 'yaml'),
+                    },
+                ],
+            },
+            {
+                type: 'table',
+                id: 'runs',
+                label: '最近运行',
+                rowKey: 'runId',
+                empty: '还没有运行过',
+                columns: [
+                    { key: 'workflowId', label: '工作流', primary: true },
+                    { key: 'status', label: '状态', kind: 'status', primary: true },
+                    { key: 'triggerSource', label: '触发来源' },
+                    { key: 'startedAt', label: '开始时间', kind: 'time' },
+                    { key: 'duration', label: '用时' },
+                    { key: 'error', label: '错误', kind: 'long-text' },
+                    { key: 'runId', label: '运行 ID', kind: 'code' },
+                ],
+                data: () => service.listRuns(50).map(r => ({
+                    runId: r.runId,
+                    workflowId: r.workflowId,
+                    status: STATUS[r.status],
+                    triggerSource: r.triggerSource,
+                    startedAt: r.startedAt,
+                    duration: fmtDuration((r.finishedAt ?? Date.now()) - r.startedAt),
+                    error: r.error ?? '',
+                })),
+            },
+            { type: 'actions', actions: ['defineWorkflow'] },
+        ],
     });
 }
-/** 路径配置只接受 storage URI；未设、留空或非字符串用默认值，其它写法（如相对路径 workspace/workflows）拒绝激活。 */
+/** 路径配置只接受 storage URI；留空用默认值，其它写法（如相对路径 workspace/workflows）拒绝激活。 */
 function resolveUri(key, input, fallback) {
-    const s = typeof input === 'string' ? input.trim() : '';
+    const s = input.trim();
     if (!s)
         return fallback;
     if (!isStorageUri(s)) {
-        throw new Error(`plugin-workflow 配置错误: ${key}="${s}" 不是 storage URI，请写成 <根名>:/<路径>（如 ${fallback}），或删掉该键使用默认值`);
+        throw configError(`${key}="${s}" 不是 storage URI，请写成 <根名>:/<路径>（如 ${fallback}），或删掉该键使用默认值`);
     }
     return s;
 }
-function resolveConfig(raw) {
-    return {
-        defsDir: resolveUri('defsDir', raw.defsDir, 'workspace:/workflows'),
-        runsFile: resolveUri('runsFile', raw.runsFile, 'data:/workflow-runs.json'),
-        maxRuns: typeof raw.maxRuns === 'number' && raw.maxRuns > 0 ? raw.maxRuns : 200,
-        enableTools: raw.enableTools !== false,
-    };
-}
 // ─── 插件入口 ───
 const uses = {
     /** cron / interval 触发器共享的整分钟 tick 与表达式解析 */
@@ -308,7 +285,7 @@ const uses = {
     storage: optional(storage),
     /** tool 节点的执行入口，兼 AI 工具面的登记口 */
     tools: optional(tools),
-    /** 工作流页与页面动作的登记口；无 WebUI 时引擎照常运行 */
+    /** 工作流页的登记口；无 WebUI 时引擎照常运行 */
     webui: optional(webuiServer),
     events,
     /** agent 节点经 'agent:turn:after' 捕获本轮回复 */
@@ -332,16 +309,24 @@ export default definePlugin({
 });
 async function run(caps) {
     const { events, hooks, lifecycle, provide, tools, webui } = caps;
-    const config = resolveConfig(caps.config);
-    const logger = caps.logger.child('workflow');
-    const storageGateway = createStorageGateway(caps.storage);
-    const loader = new WorkflowLoader(storageGateway, config.defsDir, logger);
+    const cfg = parseConfig(configSchema, caps.config.use, caps.logger.use);
+    const config = {
+        ...cfg,
+        defsDir: resolveUri('defsDir', cfg.defsDir, configSchema.defsDir.default),
+        runsFile: resolveUri('runsFile', cfg.runsFile, configSchema.runsFile.default),
+        maxRuns: cfg.maxRuns > 0 ? cfg.maxRuns : configSchema.maxRuns.default,
+    };
+    const logger = caps.logger.use.child('workflow');
+    const loader = new WorkflowLoader(caps.storage.use, config.defsDir, logger);
     const scanned = await loader.loadAll();
-    const runStore = new RunStore(storageGateway, config.runsFile, config.maxRuns, logger);
+    const runStore = new RunStore(caps.storage.use, config.runsFile, config.maxRuns, logger);
     await runStore.init();
-    const cancelTokens = new Map();
+    /** 在飞 run 的取消开关，按 runId */
+    const aborts = new Map();
+    /** 在飞的 run：拆卸先中止，再等它们收尾，被取消的 run 也要把终态写进运行历史 */
+    const running = new Set();
     // ── 触发管理器：内部 cron/interval/event 监听 ──
-    const triggers = new TriggerManager({ cronEngine: caps.cronEngine, events, logger }, (workflowId, source, payload) => {
+    const triggers = new TriggerManager({ cronEngine: caps.cronEngine, events: events.use, logger }, (workflowId, source, payload) => {
         // 异步触发，不阻塞触发源；event 触发的 payload（{args}）作为 vars 注入，{{vars.X}} 才读得到
         runById(workflowId, payload ?? {}, source).catch(err => {
             logger.error(`触发执行 workflow=${workflowId} source=${source} 失败: ${err instanceof Error ? err.message : err}`);
@@ -354,15 +339,22 @@ async function run(caps) {
     for (const def of loader.list())
         triggers.register(def);
     // ── 订阅外部 trigger:fired（来自 scheduler / 其他触发源）──
-    events.on('trigger:fired', info => {
+    events.use.on('trigger:fired', info => {
         if (!info?.workflowId)
             return;
         runById(info.workflowId, info.payload ?? {}, info.source ?? `trigger:${info.type}`).catch(err => {
             logger.error(`trigger:fired workflow=${info.workflowId} 执行失败: ${err instanceof Error ? err.message : err}`);
         });
     });
-    // ── 核心：跑一次 workflow ──
-    async function runById(workflowId, extraVars, triggerSource, caller) {
+    // ── 核心：跑一次 workflow（登记进 running，拆卸据此等它收尾）──
+    function runById(...args) {
+        const pending = execute(...args);
+        running.add(pending);
+        const settle = () => running.delete(pending);
+        pending.then(settle, settle);
+        return pending;
+    }
+    async function execute(workflowId, extraVars, triggerSource, caller) {
         const def = loader.get(workflowId);
         if (!def)
             throw new Error(`workflow "${workflowId}" 不存在`);
@@ -370,8 +362,8 @@ async function run(caps) {
             throw new Error(`workflow "${workflowId}" 已禁用`);
         const runId = `${workflowId}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
         const vars = { ...(def.vars ?? {}), ...extraVars };
-        const cancelToken = { cancelled: false };
-        cancelTokens.set(runId, cancelToken);
+        const abort = new AbortController();
+        aborts.set(runId, abort);
         const run = {
             runId,
             workflowId,
@@ -382,13 +374,14 @@ async function run(caps) {
             nodes: def.nodes.map(n => ({ id: n.id, type: n.type, status: 'pending' })),
         };
         runStore.add(run);
-        await events.emit('workflow:run:start', run);
+        page.invalidate();
+        await events.use.emit('workflow:run:start', run);
         logger.info(`run=${runId} 启动 (trigger=${triggerSource})`);
         try {
             const result = await runDag({
                 tools,
-                events,
-                hooks,
+                events: events.use,
+                hooks: hooks.use,
                 logger,
                 def,
                 runId,
@@ -396,19 +389,19 @@ async function run(caps) {
                 // 运行时身份：经 workflow_run 工具触发时以 actor 透传【调用者】授权身份，使工作流
                 // 内部工具与 agent/send_message 节点按【调用者】的权限等级过 authority 闸（而非匿名
                 // level-0）；owner 定义、谁调按谁裁决，杜绝借他人 workflow 提权。platform 保持
-                // 'workflow' 会话语义（不再借调用者平台——那会污染定时任务归属/confirm 选路等分流）。
+                // 'workflow' 会话语义（不再借调用者平台——那会污染定时任务归属/审批的发起类别等分流）。
                 // cron/event/webui 触发无调用者 → 保持匿名（仅能跑 public 工具）。
                 toolCallContext: {
                     sessionId: `workflow::${workflowId}`,
                     platform: 'workflow',
                     actor: caller?.platform && caller?.userId ? { platform: caller.platform, userId: caller.userId } : undefined,
                 },
-                cancelToken,
+                signal: abort.signal,
                 onNodeDone: (info) => {
                     const idx = run.nodes.findIndex(n => n.id === info.id);
                     if (idx >= 0)
                         run.nodes[idx] = info;
-                    events.emit('workflow:node:done', { runId, node: info }).catch(() => { });
+                    events.use.emit('workflow:node:done', { runId, node: info }).catch(() => { });
                 },
             });
             run.status = result.status;
@@ -417,11 +410,11 @@ async function run(caps) {
             run.finishedAt = Date.now();
             runStore.update(run);
             if (result.status === 'success') {
-                await events.emit('workflow:run:done', run);
+                await events.use.emit('workflow:run:done', run);
                 logger.info(`run=${runId} 完成 (${run.finishedAt - run.startedAt}ms)`);
             }
             else {
-                await events.emit('workflow:run:error', run);
+                await events.use.emit('workflow:run:error', run);
                 logger.warn(`run=${runId} ${result.status}: ${result.error ?? ''}`);
             }
         }
@@ -430,11 +423,12 @@ async function run(caps) {
             run.error = err instanceof Error ? err.message : String(err);
             run.finishedAt = Date.now();
             runStore.update(run);
-            await events.emit('workflow:run:error', run);
+            await events.use.emit('workflow:run:error', run);
             logger.error(`run=${runId} 异常: ${run.error}`);
         }
         finally {
-            cancelTokens.delete(runId);
+            aborts.delete(runId);
+            page.invalidate();
         }
         return run;
     }
@@ -458,6 +452,7 @@ async function run(caps) {
                 loader.putMemory(def);
             }
             triggers.register(def);
+            page.invalidate();
             logger.info(`workflow 已定义: ${def.id} (持久化=${opts?.persist !== false})`);
         },
         async removeWorkflow(id) {
@@ -465,16 +460,17 @@ async function run(caps) {
             const had = await loader.removeDef(id);
             triggers.unregister(id);
             runStore.clearOnceFired(id); // 定义没了，once 记账不留孤儿：同 id 重建算新工作流
+            page.invalidate();
             return had;
         },
         async runWorkflow(id, vars, source, caller) {
             return await runById(id, vars ?? {}, source ?? 'manual', caller);
         },
         cancelRun(runId) {
-            const t = cancelTokens.get(runId);
-            if (!t)
+            const abort = aborts.get(runId);
+            if (!abort)
                 return false;
-            t.cancelled = true;
+            abort.abort();
             return true;
         },
         getRun(runId) {
@@ -484,25 +480,23 @@ async function run(caps) {
             return runStore.list(limit, workflowId);
         },
     };
-    provide(workflow, service);
+    provide.use(workflow, service);
+    const page = defineWorkflowPage(webui.use, service, () => runStore.onceLedgerReadable());
     // ── AI 工具 ──
     // tools 晚上线也无妨：登记口在提供者缺席时先挂账，上线后自动补挂
     if (config.enableTools) {
-        registerTools(tools, service, () => runStore.onceLedgerReadable());
+        registerTools(tools.use, service, () => runStore.onceLedgerReadable());
     }
-    // ── WebUI ──
-    for (const page of webuiPages)
-        webui.registerPage(page);
-    registerWebuiActions(webui, service, () => runStore.onceLedgerReadable());
     // ── 清理 ──
-    lifecycle.onDispose(async () => {
+    lifecycle.use.onDispose(async () => {
         triggers.dispose();
-        // 先置 cancelled 再清表：只 clear 的话在飞 run 仍持有自己的 token 引用，会继续跑完剩余
-        // 节点、发事件，并把结果写回旧 RunStore 的历史快照
-        for (const t of cancelTokens.values())
-            t.cancelled = true;
-        cancelTokens.clear();
-        // 等排队中的运行历史 / once 记账写完再结束拆卸：否则 app.stop() 返回后仍有落盘在飞
+        // 中止全部在飞 run：不再调度新节点，阻塞中的 wait / agent 节点立即结束。再等它们收尾、排队中的运行历史 /
+        // once 记账写完才结束拆卸：否则 app.stop() 返回后仍有落盘在飞，bounce 时迟到的快照会盖掉新实例的记账。
+        // 不响应中止信号的工具节点至多让这里等到 disposeTimeoutMs；放弃等待后旧实例记为 lingering，同 id 的新实例要等那次
+        // run 真正落定、这里返回之后才起
+        for (const abort of aborts.values())
+            abort.abort();
+        await Promise.allSettled(running);
         await runStore.flushed();
     });
     logger.info(`工作流插件已启动 (${loader.list().length} 个定义已加载)`);