@aalis/plugin-workflow 0.14.1 → 0.16.0

package/dist/index.js

@@ -5,286 +5,304 @@
 // 按 DAG 执行节点，结果存 data:/workflow-runs.json，
 // 定义存 workspace:/workflows/*.yaml。
 // ============================================================
+import { authority } from '@aalis/api-authority';
 import { cronEngine } from '@aalis/api-cron-engine';
+import { gateway } from '@aalis/api-gateway';
 import { hooks } from '@aalis/api-hooks';
-import { createStorageGateway, isStorageUri, storage } from '@aalis/api-storage';
-import { tools } from '@aalis/api-tools';
-import { webuiServer } from '@aalis/api-webui';
+import { isStorageUri, storage } from '@aalis/api-storage';
+import { actingIdentity, tools } from '@aalis/api-tools';
+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 { defineConfig, parseConfig } from '@aalis/schema-config';
+import { configError, defineConfig, parseConfig } from '@aalis/schema-config';
+import { TextError, textClauses, textOf, toSource } from '@aalis/schema-i18n';
+import { validateIntervalSeconds } from '@aalis/util-cron';
 import { parse, stringify } from 'yaml';
-import { runDag, validateGraph } from './engine.js';
-import { normalizeDef, WorkflowLoader } from './loader.js';
+import { errorReason, runDag, validateGraph } from './engine.js';
+import { normalizeDef, validateId, WorkflowLoader } from './loader.js';
 import { RunStore } from './persistence.js';
-import { TriggerManager } from './triggers.js';
+import { t } from './texts.js';
+import { BLOCKED_EVENT_TRIGGERS, TriggerManager } from './triggers.js';
 // ─── 配置 ───
 const configSchema = defineConfig({
     defsDir: {
         type: 'string',
-        label: '工作流定义目录',
+        label: t('defsDirLabel'),
         default: 'workspace:/workflows',
         onInvalid: 'error',
-        description: '加载存储下的 *.yaml 定义（storage URI）；AI 通过 workflow_define 创建的定义也写入此处。',
+        description: t('defsDirDescription'),
     },
     runsFile: {
         type: 'string',
-        label: '运行历史文件',
+        label: t('runsFileLabel'),
         default: 'data:/workflow-runs.json',
         onInvalid: 'error',
-        description: '保存最近 N 条运行实例（storage URI）。',
+        description: t('runsFileDescription'),
     },
     maxRuns: {
         type: 'number',
-        label: '保留最近运行条数',
+        label: t('maxRunsLabel'),
         default: 200,
-        description: '超过则按时间裁剪最旧的；最小 10。',
+        description: t('maxRunsDescription'),
     },
     enableTools: {
         type: 'boolean',
-        label: '注册 AI 工具',
+        label: t('enableToolsLabel'),
         default: true,
         onInvalid: 'error',
-        description: '开启后向 LLM 暴露 workflow_define / workflow_run 等工具。',
+        description: t('enableToolsDescription'),
     },
 });
-// ─── 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) {
+// ─── 工具函数（与工作流页共享） ───
+function triggerSummary(trigger) {
+    switch (trigger.type) {
         case 'cron':
-            return `cron ${t.expr ?? ''}`.trim();
+            return `cron ${trigger.expr ?? ''}`.trim();
         case 'interval':
-            return `每 ${t.seconds ?? '?'}s`;
+            return t('everySeconds', { seconds: trigger.seconds ?? '?' });
         case 'once':
-            return `一次性@${t.runAt ?? '?'}`;
+            return t('onceAt', { at: trigger.runAt ?? '?' });
         case 'event':
-            return `event:${t.event ?? '?'}`;
+            return `event:${trigger.event ?? '?'}`;
         case 'manual':
-            return '手动';
+            return t('manual');
         default:
-            return t.type;
+            return trigger.type;
     }
 }
-function fmtTs(ts) {
-    if (!ts || !Number.isFinite(ts))
-        return '—';
-    try {
-        return new Date(ts).toLocaleString('zh-CN', { hour12: false });
-    }
-    catch {
-        return String(ts);
-    }
+/** 有平台与用户 ID 的才是一个身份，缺一个即匿名 */
+function identityOf(who) {
+    return who?.platform && who.userId ? { platform: who.platform, userId: who.userId } : undefined;
 }
+/** 定义表里的定义者：平台:用户 ID，没有的写「匿名」 */
+const identityText = (who) => (who ? `${who.platform}:${who.userId}` : t('anonymous'));
+/** 用时的写法：字典的 {ms, duration}（到秒，按读者的语言）；没有用时写「—」 */
 function fmtDuration(ms) {
-    if (!Number.isFinite(ms) || ms < 0)
-        return '—';
-    if (ms < 1000)
-        return `${ms}ms`;
-    if (ms < 60_000)
-        return `${(ms / 1000).toFixed(1)}s`;
-    const m = Math.floor(ms / 60_000);
-    const s = Math.floor((ms % 60_000) / 1000);
-    return `${m}m${s}s`;
+    return ms === undefined || !Number.isFinite(ms) || ms < 0 ? '—' : t('elapsed', { ms });
+}
+/** 运行的用时（ms）：在跑的算到现在；进程退出时中断的不知道停在何时，没有用时 */
+function elapsed(run) {
+    const end = run.status === 'running' ? Date.now() : run.finishedAt;
+    return end === undefined ? undefined : end - run.startedAt;
 }
 /**
- * once 记账读不出时本次运行不安排 once：定义或启用一个 once 的回执据此如实说明（AI 工具与页面动作同一口径）。
+ * once 记账读不出时本次运行不安排 once：定义或启用一个 once 的回执据此如实说明（AI 工具与工作流页同一口径，工具取原文）。
  * manualRun 是各自那一面手动执行的说法；不持久化的定义重启后就没了，「重启恢复」只对写了文件的定义成立。
  */
 function onceSkippedNote(def, persist, onceLedgerReadable, manualRun) {
     if (def.trigger.type !== 'once' || def.enabled === false || onceLedgerReadable)
         return undefined;
-    return `once 记账读取失败（见日志），本次运行不会触发；可用${manualRun}手动执行${persist ? '，修复运行历史文件后重启恢复' : ''}`;
+    return t(persist ? 'onceSkippedPersisted' : 'onceSkipped', { manualRun });
 }
+/** 工作流页的回执：once 记账读不出时接上附注 */
+const withNote = (receipt, note) => (note ? textClauses([receipt, note]) : receipt);
+const STATUS = {
+    pending: { text: t('statusPending'), state: 'inactive' },
+    running: { text: t('statusRunning'), state: 'running' },
+    success: { text: t('statusSuccess') },
+    failed: { text: t('statusFailed'), state: 'error' },
+    cancelled: { text: t('statusCancelled'), 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));
+function defineWorkflowPage(webui, service, definitions, onceLedgerReadable) {
+    const definitionOf = (id) => {
+        const def = service.getWorkflow(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));
-        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 TextError(t('workflowMissing', { id }));
+        return def;
+    };
+    /** 启用或停用：改的是写在磁盘上的定义，定义者沿用原来的 */
+    const setEnabled = async (id, enabled) => {
+        const next = { ...definitionOf(id), enabled };
+        await definitions.define(next, true, definitions.definedBy(id));
+        const note = onceSkippedNote(next, true, onceLedgerReadable(), t('runNow'));
+        return withNote(t(enabled ? 'enabled' : 'disabled', { id }), note);
+    };
+    return webui.definePage({
+        key: 'workflows',
+        title: t('displayName'),
+        icon: 'workflow',
+        actions: {
+            runWorkflow: {
+                label: t('runWorkflow'),
+                effect: 'write',
+                row: true,
+                async handler({ rowKey, ctx }) {
+                    // 调用者是登录的 owner：按定义者执行（见 execute 的运行身份）
+                    const run = await service.runWorkflow(rowKey, {}, 'manual:webui', ctx.caller);
+                    if (run.status !== 'success') {
+                        const status = STATUS[run.status].text;
+                        throw new TextError(run.error ? t('runNotSucceededBecause', { status, error: run.error }) : t('runNotSucceeded', { status }));
+                    }
+                    return t('ran', { id: rowKey, duration: fmtDuration(elapsed(run)) });
+                },
+            },
+            enableWorkflow: {
+                label: t('enableAction'),
+                effect: 'write',
+                row: true,
+                handler: ({ rowKey }) => setEnabled(rowKey, true),
+            },
+            disableWorkflow: {
+                label: t('disableAction'),
+                effect: 'write',
+                row: true,
+                handler: ({ rowKey }) => setEnabled(rowKey, false),
+            },
+            removeWorkflow: {
+                label: t('delete'),
+                effect: 'destructive',
+                confirm: t('deleteConfirm'),
+                row: true,
+                async handler({ rowKey }) {
+                    if (!(await service.removeWorkflow(rowKey)))
+                        throw new TextError(t('workflowMissing', { id: rowKey }));
+                    return t('deleted', { id: rowKey });
+                },
+            },
+            cancelRun: {
+                label: t('cancelRun'),
+                effect: 'destructive',
+                confirm: t('cancelRunConfirm'),
+                row: true,
+                // 只发出取消：运行照常收尾，记录留在运行历史里、状态为已取消，收尾时页面重取
+                handler({ rowKey }) {
+                    if (!service.cancelRun(rowKey))
+                        throw new TextError(t('runEnded'));
+                    return t('runCancelled', { id: rowKey });
+                },
+            },
+            defineWorkflow: {
+                label: t('defineWorkflow'),
+                effect: 'write',
+                input: {
+                    yaml: {
+                        type: 'textarea',
+                        label: t('yamlLabel'),
+                        required: true,
+                        description: t('yamlDescription'),
+                    },
+                    persist: {
+                        type: 'boolean',
+                        label: t('persistLabel'),
+                        default: true,
+                        description: t('persistDescription'),
+                    },
+                },
+                async handler({ input, ctx }) {
+                    let raw;
+                    try {
+                        raw = parse(input.yaml);
+                    }
+                    catch (err) {
+                        throw new TextError(t('yamlFailed', { error: textOf(err) }));
+                    }
+                    const def = normalizeDef(raw, `wf-${Date.now()}`);
+                    if (!def)
+                        throw new TextError(t('badDefinition'));
+                    await definitions.define(def, input.persist, ctx.caller);
+                    const note = onceSkippedNote(def, input.persist, onceLedgerReadable(), t('runNow'));
+                    return withNote(t('saved', { id: def.id }), 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: t('definitions'), value: defs.length },
+                        { label: t('stateEnabled'), value: defs.filter(d => d.enabled !== false).length },
+                        { label: t('runs24h'), value: recent.length },
+                        {
+                            label: t('failures24h'),
+                            value: recent.filter(r => r.status === 'failed').length,
+                        },
+                    ];
+                },
+            },
+            {
+                type: 'table',
+                id: 'workflows',
+                label: t('definitions'),
+                rowKey: 'id',
+                empty: t('noWorkflows'),
+                columns: [
+                    { key: 'id', label: 'ID', kind: 'code' },
+                    { key: 'name', label: t('name'), primary: true },
+                    { key: 'trigger', label: t('trigger') },
+                    { key: 'nodes', label: t('nodeCount') },
+                    { key: 'status', label: t('status'), kind: 'status', primary: true },
+                    { key: 'definedBy', label: t('definedBy') },
+                    { key: 'description', label: t('description'), 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: t('stateDisabled'), state: 'inactive' }
+                        : { text: t('stateEnabled') },
+                    enabled: d.enabled !== false,
+                    disabled: d.enabled === false,
+                    description: d.description ?? '',
+                    definedBy: identityText(definitions.definedBy(d.id)),
+                })),
+                detail: [
+                    {
+                        type: 'markdown',
+                        id: 'yaml',
+                        label: 'YAML',
+                        data: ({ rowKey }) => markdownCode(stringify(definitionOf(rowKey)), 'yaml'),
+                    },
+                ],
+            },
+            {
+                type: 'table',
+                id: 'runs',
+                label: t('recentRuns'),
+                rowKey: 'runId',
+                empty: t('noRuns'),
+                columns: [
+                    { key: 'workflowId', label: t('workflowColumn'), primary: true },
+                    { key: 'status', label: t('status'), kind: 'status', primary: true },
+                    { key: 'triggerSource', label: t('triggerSource') },
+                    { key: 'startedAt', label: t('startedAt'), kind: 'time' },
+                    { key: 'duration', label: t('duration') },
+                    { key: 'error', label: t('error'), kind: 'long-text' },
+                    { key: 'runId', label: t('runId'), kind: 'code' },
+                ],
+                rowActions: [{ action: 'cancelRun', visibleWhen: 'running' }],
+                // 最近 50 次，更早而还在跑的接在后面（按开始时间倒序，它们本就排在后面）：取消的入口不随新的运行挤掉
+                data: () => service
+                    .listRuns()
+                    .filter((r, i) => i < 50 || r.status === 'running')
+                    .map(r => ({
+                    runId: r.runId,
+                    workflowId: r.workflowId,
+                    status: STATUS[r.status],
+                    triggerSource: r.triggerSource,
+                    startedAt: r.startedAt,
+                    duration: fmtDuration(elapsed(r)),
+                    error: r.error ?? '',
+                    running: r.status === 'running',
+                })),
+            },
+            { type: 'actions', actions: ['defineWorkflow'] },
+        ],
     });
 }
 /** 路径配置只接受 storage URI；留空用默认值，其它写法（如相对路径 workspace/workflows）拒绝激活。 */
@@ -293,7 +311,7 @@ function resolveUri(key, input, fallback) {
     if (!s)
         return fallback;
     if (!isStorageUri(s)) {
-        throw new Error(`plugin-workflow 配置错误: ${key}="${s}" 不是 storage URI，请写成 <根名>:/<路径>（如 ${fallback}），或删掉该键使用默认值`);
+        throw configError(t('badUri', { key, value: s, fallback }));
     }
     return s;
 }
@@ -305,11 +323,15 @@ const uses = {
     storage: optional(storage),
     /** tool 节点的执行入口，兼 AI 工具面的登记口 */
     tools: optional(tools),
-    /** 工作流页与页面动作的登记口；无 WebUI 时引擎照常运行 */
+    /** 工作流页的登记口；无 WebUI 时引擎照常运行 */
     webui: optional(webuiServer),
+    /** 判调用者是不是 owner，定运行身份；缺席时判不出谁是 owner，调用者与定义者不是同一身份的按匿名 */
+    authority: optional(authority),
     events,
     /** agent 节点经 'agent:turn:after' 捕获本轮回复 */
     hooks,
+    /** agent 节点经它送达指令；缺席时 agent 节点失败 */
+    gateway: optional(gateway),
     lifecycle,
     logger,
     config,
@@ -317,7 +339,7 @@ const uses = {
 };
 export default definePlugin({
     name: '@aalis/plugin-workflow',
-    displayName: '工作流',
+    displayName: t('displayName'),
     subsystem: 'workflow',
     extends: {
         events: ['workflow:run:start', 'workflow:run:done', 'workflow:run:error', 'workflow:node:done', 'trigger:fired'],
@@ -329,52 +351,76 @@ export default definePlugin({
 });
 async function run(caps) {
     const { events, hooks, lifecycle, provide, tools, webui } = caps;
-    const cfg = parseConfig(configSchema, caps.config, caps.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.child('workflow');
-    const storageGateway = createStorageGateway(caps.storage);
-    const loader = new WorkflowLoader(storageGateway, config.defsDir, logger);
-    const scanned = await loader.loadAll();
-    const runStore = new RunStore(storageGateway, config.runsFile, config.maxRuns, logger);
+    const logger = caps.logger.use.child('workflow');
+    // 先读运行历史：载入定义时按里面的定义者账本认定义者
+    const runStore = new RunStore(caps.storage.use, config.runsFile, config.maxRuns, logger);
     await runStore.init();
-    const cancelTokens = new Map();
+    const loader = new WorkflowLoader(caps.storage.use, config.defsDir, logger);
+    const scanned = await loader.loadAll((id, sha256) => runStore.definerOf(id, sha256));
+    /** 在飞 run 的取消开关，按 runId */
+    const aborts = new Map();
+    /** 在飞的 run：拆卸先中止，再等它们收尾，被取消的 run 也要把终态写进运行历史 */
+    const running = new Set();
+    /** 定时与事件触发：以定义者作调用者 */
+    const runAsDefiner = (workflowId, vars, source) => runById(workflowId, vars, source, loader.definedBy(workflowId));
     // ── 触发管理器：内部 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 => {
+        runAsDefiner(workflowId, payload ?? {}, source).catch(err => {
             logger.error(`触发执行 workflow=${workflowId} source=${source} 失败: ${err instanceof Error ? err.message : err}`);
         });
     }, runStore);
-    // 定义已从磁盘删除的，once 记账不留孤儿（手删 yaml 不经 removeWorkflow）；注册前清。
+    // 定义已从磁盘删除的，once 记账与定义者不留孤儿（手删 yaml 不经 removeWorkflow）；注册前清。
     // 列目录失败那次启动看到的是空集，不能据此清账——否则下次启动所有过期 once 全部重放
     if (scanned)
-        runStore.pruneOnceFired(new Set(loader.list().map(d => d.id)));
+        runStore.prune(new Set(loader.list().map(d => d.id)));
     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 => {
+        runAsDefiner(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;
+    }
+    /**
+     * 运行身份：调用者是 owner 时取定义者（没有即匿名），否则取调用者。两者都是 owner 才按 owner 跑，有一方不是 owner 就由
+     * 那一方定：owner 调起别人定义或覆盖过的编排按那个人的等级执行，免确认也只对 owner 生效，借别人的编排提不了权
+     */
+    function runIdentity(invoker, definer) {
+        if (caps.authority.present) {
+            return invoker && caps.authority.use.isOwner(invoker.platform, invoker.userId) ? definer : invoker;
+        }
+        // 权限服务不在（停用或重载的窗口）时判不出谁是 owner：两者是同一身份才按它，否则匿名
+        return invoker?.platform === definer?.platform && invoker?.userId === definer?.userId ? invoker : undefined;
+    }
+    async function execute(workflowId, extraVars, triggerSource, caller) {
         const def = loader.get(workflowId);
         if (!def)
-            throw new Error(`workflow "${workflowId}" 不存在`);
+            throw new TextError(t('runMissing', { id: workflowId }));
         if (def.enabled === false)
-            throw new Error(`workflow "${workflowId}" 已禁用`);
+            throw new TextError(t('runDisabled', { id: workflowId }));
+        const actor = runIdentity(identityOf(caller), loader.definedBy(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,
@@ -385,62 +431,106 @@ 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 {
+            // 跑完就摘掉中止句柄，再记终态、发收尾事件：之后的 cancelRun 回 false，不对已经落定的运行回「已取消」
             const result = await runDag({
                 tools,
-                events,
-                hooks,
+                events: events.use,
+                hooks: hooks.use,
+                gateway: caps.gateway,
                 logger,
                 def,
                 runId,
                 vars,
-                // 运行时身份：经 workflow_run 工具触发时以 actor 透传【调用者】授权身份，使工作流
-                // 内部工具与 agent/send_message 节点按【调用者】的权限等级过 authority 闸（而非匿名
-                // level-0）；owner 定义、谁调按谁裁决，杜绝借他人 workflow 提权。platform 保持
-                // 'workflow' 会话语义（不再借调用者平台——那会污染定时任务归属/confirm 选路等分流）。
-                // cron/event/webui 触发无调用者 → 保持匿名（仅能跑 public 工具）。
+                // 运行身份是工具调用上下文的唯一参与者，交给工作流内部工具与 agent/send_message 节点，按它的等级过 authority 闸；
+                // 匿名的是无主体，只能跑 public 工具。platform 保持 'workflow' 会话语义（不借调用者平台——那会污染定时任务归属/审批的
+                // 发起类别等分流）。
                 toolCallContext: {
                     sessionId: `workflow::${workflowId}`,
                     platform: 'workflow',
-                    actor: caller?.platform && caller?.userId ? { platform: caller.platform, userId: caller.userId } : undefined,
+                    participants: [actor ?? { platform: 'workflow', userId: '' }],
                 },
-                cancelToken,
+                callerSessionId: caller?.sessionId,
+                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(() => { });
                 },
-            });
+            }).finally(() => aborts.delete(runId));
             run.status = result.status;
             run.nodes = result.nodes;
             run.error = result.error;
             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);
-                logger.warn(`run=${runId} ${result.status}: ${result.error ?? ''}`);
+                await events.use.emit('workflow:run:error', run);
+                logger.warn(`run=${runId} ${result.status}: ${toSource(result.error) ?? ''}`);
             }
         }
         catch (err) {
             run.status = 'failed';
-            run.error = err instanceof Error ? err.message : String(err);
+            run.error = errorReason(err);
             run.finishedAt = Date.now();
             runStore.update(run);
-            await events.emit('workflow:run:error', run);
-            logger.error(`run=${runId} 异常: ${run.error}`);
+            await events.use.emit('workflow:run:error', run);
+            logger.error(`run=${runId} 异常: ${toSource(run.error)}`);
         }
         finally {
-            cancelTokens.delete(runId);
+            page.invalidate();
         }
         return run;
     }
+    /**
+     * 触发器写错的原因：收下了也订阅不上、永远不会触发。cron 交 cron-engine 校验；interval 与定时任务的固定间隔同一条（大于 0、
+     * 不超过定时器能排的上限，超过的溢出成每毫秒触发）；once 的 runAt 要能解析；event 不能订阅不可作触发源的事件
+     */
+    function triggerError(trigger) {
+        switch (trigger.type) {
+            case 'cron': {
+                const checked = caps.cronEngine.use.validate(String(trigger.expr ?? ''));
+                return checked.ok ? null : checked.text;
+            }
+            case 'interval':
+                return validateIntervalSeconds(trigger.seconds);
+            case 'once':
+                return Number.isFinite(Date.parse(String(trigger.runAt)))
+                    ? null
+                    : t('badRunAt', { runAt: String(trigger.runAt) });
+            case 'event':
+                return BLOCKED_EVENT_TRIGGERS.has(trigger.event) ? t('blockedEventTrigger', { event: trigger.event }) : null;
+            default:
+                return null;
+        }
+    }
+    /**
+     * 定义或覆盖：定义者记进账本，连同写进文件的文本的哈希；只在内存里的定义，定义者也只在内存。新定义的 id 不合规（它是新定义
+     * 文件的文件名；已载入的照原 id 改写它自己的文件）、图不合法、启用的定义触发器写错的，报错、不保存。停用的定义不注册触发器，
+     * 不校验它（定义目录里载入的、触发器写错的要能停用），启用时再校验
+     */
+    async function define(def, persist, definer) {
+        const err = (loader.get(def.id) ? null : validateId(def.id)) ??
+            validateGraph(def) ??
+            (def.enabled === false ? null : triggerError(def.trigger));
+        if (err)
+            throw typeof err === 'string' ? new Error(err) : new TextError(err);
+        if (persist)
+            runStore.recordDefiner(def.id, definer, await loader.saveDef(def));
+        loader.putMemory(def, definer);
+        // 重新触发器
+        triggers.register(def);
+        page.invalidate();
+        logger.info(`workflow 已定义: ${def.id} (持久化=${persist})`);
+    }
+    const definitions = { define, definedBy: id => loader.definedBy(id) };
     // ── WorkflowService ──
     const service = {
         listWorkflows() {
@@ -449,35 +539,29 @@ async function run(caps) {
         getWorkflow(id) {
             return loader.get(id);
         },
-        async defineWorkflow(def, opts) {
-            const err = validateGraph(def);
-            if (err)
-                throw new Error(err);
-            // 重新触发器
-            if (opts?.persist !== false) {
-                await loader.saveDef(def);
-            }
-            else {
-                loader.putMemory(def);
-            }
-            triggers.register(def);
-            logger.info(`workflow 已定义: ${def.id} (持久化=${opts?.persist !== false})`);
+        defineWorkflow(def, opts) {
+            // 认不出调用方是谁：没有定义者
+            return define(def, opts?.persist !== false, undefined);
         },
         async removeWorkflow(id) {
+            // 只动已载入的定义，删的是它载入时的文件：别的 id（借 ../ 指到定义目录之外的、载入失败的）不碰存储
+            if (!loader.get(id))
+                return false;
             // 先删文件，删不掉就抛错、触发器与 once 记账原样保留：先清账的话，重启后定义被重新载入，过期 once 会重放
-            const had = await loader.removeDef(id);
+            await loader.removeDef(id);
             triggers.unregister(id);
-            runStore.clearOnceFired(id); // 定义没了，once 记账不留孤儿：同 id 重建算新工作流
-            return had;
+            runStore.forget(id); // 定义没了，once 记账与定义者不留孤儿：同 id 重建算新工作流
+            page.invalidate();
+            return true;
         },
         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) {
@@ -487,37 +571,41 @@ async function run(caps) {
             return runStore.list(limit, workflowId);
         },
     };
-    provide(workflow, service);
+    provide.use(workflow, service);
+    const page = defineWorkflowPage(webui.use, service, definitions, () => runStore.onceLedgerReadable());
     // ── AI 工具 ──
     // tools 晚上线也无妨：登记口在提供者缺席时先挂账，上线后自动补挂
     if (config.enableTools) {
-        registerTools(tools, service, () => runStore.onceLedgerReadable());
+        registerTools(tools.use, service, definitions, () => 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} 个定义已加载)`);
 }
 // ─── AI 工具注册 ───
 /** onceLedgerReadable：once 记账读不出时本次运行不安排 once，workflow_define 的回执据此如实说明 */
-function registerTools(tools, service, onceLedgerReadable) {
-    tools.registerGroup({ name: 'workflow', label: '工作流', description: '定义、运行、查询自主工作流（DAG）' });
+function registerTools(tools, service, definitions, onceLedgerReadable) {
+    tools.registerGroup({
+        name: 'workflow',
+        label: t('displayName'),
+        summary: t('groupSummary'),
+        description: '定义、运行、查询自主工作流（DAG）',
+    });
     tools.register({
-        // 编排定义/触发/删除：可定义向任意 sessionId 发消息/跑 agent 的工作流，挡住不受信任访客经
-        // LLM 驱动。sensitive(L1)，不加逐次 confirm。只读 list/get_runs 保持 public。
-        risk: 'sensitive',
+        // 定义、跑、删编排：编排存下来以后按定义者的身份自己运行，节点能往任意会话发消息、开一轮。与子任务、定时任务、停后台任务
+        // 同一规则，2 级加确认，审批卡上是原文；别人单独发起的没人能批即拒，参与者都是 owner 且在免确认白名单里（或确认覆盖设为
+        // off）时免，批过的调用按批的人执行、定义者随之是他。列与看运行记录只看不改：2 级、不确认
+        risk: 'dangerous',
         groups: ['workflow'],
         definition: {
             type: 'function',
@@ -538,7 +626,7 @@ function registerTools(tools, service, onceLedgerReadable) {
                 },
             },
         },
-        handler: async (args) => {
+        handler: async (args, callCtx) => {
             const yamlText = String(args.yaml ?? '');
             let raw;
             try {
@@ -552,7 +640,9 @@ function registerTools(tools, service, onceLedgerReadable) {
                 return JSON.stringify({ error: '定义不合法：缺少 trigger 或 nodes' });
             const persist = args.persist !== false;
             try {
-                await service.defineWorkflow(def, { persist });
+                // 定义者取调用者的授权身份：经审批的是批的人，匿名的不记
+                const definedBy = identityOf(actingIdentity(callCtx));
+                await definitions.define(def, persist, definedBy);
             }
             catch (e) {
                 return JSON.stringify({ error: e instanceof Error ? e.message : String(e) });
@@ -563,11 +653,12 @@ function registerTools(tools, service, onceLedgerReadable) {
                 id: def.id,
                 nodes: def.nodes.length,
                 trigger: def.trigger.type,
-                ...(note ? { note } : {}),
+                ...(note ? { note: toSource(note) } : {}),
             });
         },
     });
     tools.register({
+        visibility: 'restricted',
         groups: ['workflow'],
         definition: {
             type: 'function',
@@ -590,7 +681,7 @@ function registerTools(tools, service, onceLedgerReadable) {
         },
     });
     tools.register({
-        risk: 'sensitive',
+        risk: 'dangerous',
         groups: ['workflow'],
         definition: {
             type: 'function',
@@ -608,17 +699,34 @@ function registerTools(tools, service, onceLedgerReadable) {
             },
         },
         handler: async (args, callCtx) => {
+            const { signal } = callCtx;
+            const aborted = JSON.stringify({ error: '回合已中止，不再等' });
+            if (signal?.aborted)
+                return aborted;
             try {
-                // 透传调用者身份：工作流内部工具按调用者权限跑（owner 定义、谁调用按谁的档位裁决）。
-                // 优先 callCtx.actor（本回合已在代人执行时链式传递），否则物理身份。
-                const run = await service.runWorkflow(String(args.id), args.vars ?? {}, 'manual:tool', callCtx.actor ?? { platform: callCtx.platform, userId: callCtx.userId });
+                // 透传调用者的授权身份（这一项要 owner 确认：批过的是批的人，免了的是那位 owner）；运行身份按它与定义者定（见 execute）。
+                // 调起这次运行的会话也带上：这一轮在等这次运行，指向它的 agent 节点立即失败。调用被中止（这一轮被停止键、禁言、/clear
+                // 等停下）时不再等这次运行，这一轮才落定得了；运行不取消
+                const run = await new Promise((resolve, reject) => {
+                    const stop = () => resolve(undefined);
+                    signal?.addEventListener('abort', stop, { once: true });
+                    service
+                        .runWorkflow(String(args.id), args.vars ?? {}, 'manual:tool', {
+                        ...actingIdentity(callCtx),
+                        sessionId: callCtx.sessionId,
+                    })
+                        .then(resolve, reject)
+                        .finally(() => signal?.removeEventListener('abort', stop));
+                });
+                if (!run)
+                    return aborted;
                 return JSON.stringify({
                     ok: true,
                     runId: run.runId,
                     status: run.status,
-                    durationMs: (run.finishedAt ?? Date.now()) - run.startedAt,
-                    nodes: run.nodes.map(n => ({ id: n.id, status: n.status, error: n.error })),
-                    error: run.error,
+                    durationMs: elapsed(run),
+                    nodes: run.nodes.map(n => ({ id: n.id, status: n.status, error: toSource(n.error) })),
+                    error: toSource(run.error),
                 });
             }
             catch (e) {
@@ -627,6 +735,8 @@ function registerTools(tools, service, onceLedgerReadable) {
         },
     });
     tools.register({
+        // 只看不改：运行的出错原因带会话 id（agent 节点的几句都写目标会话，私聊会话的 id 带对方账号），与 scheduler_list_jobs 同档
+        visibility: 'restricted',
         groups: ['workflow'],
         definition: {
             type: 'function',
@@ -652,14 +762,14 @@ function registerTools(tools, service, onceLedgerReadable) {
                     status: r.status,
                     triggerSource: r.triggerSource,
                     startedAt: new Date(r.startedAt).toISOString(),
-                    durationMs: (r.finishedAt ?? Date.now()) - r.startedAt,
-                    error: r.error,
+                    durationMs: elapsed(r),
+                    error: toSource(r.error),
                 })),
             });
         },
     });
     tools.register({
-        risk: 'sensitive',
+        risk: 'dangerous',
         groups: ['workflow'],
         definition: {
             type: 'function',