@aalis/plugin-workflow 0.15.0 → 0.17.0

package/dist/index.js

@@ -5,179 +5,207 @@
 // 按 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 { isStorageUri, storage } from '@aalis/api-storage';
-import { tools } from '@aalis/api-tools';
+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 { 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'),
     },
 });
 // ─── 工具函数（与工作流页共享） ───
-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;
     }
 }
+/** 有平台与用户 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: '等待', state: 'inactive' },
-    running: { text: '运行中', state: 'running' },
-    success: { text: '成功' },
-    failed: { text: '失败', state: 'error' },
-    cancelled: { text: '已取消', state: 'inactive' },
+    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，不按名回查容器（查到的可能是别人提供的同名服务）。
  * 返回页面的句柄：定义增删与运行起止时让它重取
  */
-function defineWorkflowPage(webui, service, onceLedgerReadable) {
+function defineWorkflowPage(webui, service, definitions, onceLedgerReadable) {
     const definitionOf = (id) => {
         const def = service.getWorkflow(id);
         if (!def)
-            throw new Error(`工作流 ${id} 不存在`);
+            throw new TextError(t('workflowMissing', { 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}` : ''}`;
+        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: '工作流',
+        title: t('displayName'),
         icon: 'workflow',
         actions: {
             runWorkflow: {
-                label: '立即运行',
+                label: t('runWorkflow'),
                 effect: 'write',
                 row: true,
-                async handler({ rowKey }) {
-                    const run = await service.runWorkflow(rowKey, {}, 'manual:webui');
+                async handler({ rowKey, ctx }) {
+                    // 调用者是登录的 owner：按定义者执行（见 execute 的运行身份）
+                    const run = await service.runWorkflow(rowKey, {}, 'manual:webui', ctx.caller);
                     if (run.status !== 'success') {
-                        throw new Error(`运行没有成功（${STATUS[run.status].text}）${run.error ? `：${run.error}` : ''}`);
+                        const status = STATUS[run.status].text;
+                        throw new TextError(run.error ? t('runNotSucceededBecause', { status, error: run.error }) : t('runNotSucceeded', { status }));
                     }
-                    return `已运行 ${rowKey}，用时 ${fmtDuration((run.finishedAt ?? Date.now()) - run.startedAt)}`;
+                    return t('ran', { id: rowKey, duration: fmtDuration(elapsed(run)) });
                 },
             },
-            enableWorkflow: { label: '启用', effect: 'write', row: true, handler: ({ rowKey }) => setEnabled(rowKey, true) },
+            enableWorkflow: {
+                label: t('enableAction'),
+                effect: 'write',
+                row: true,
+                handler: ({ rowKey }) => setEnabled(rowKey, true),
+            },
             disableWorkflow: {
-                label: '停用',
+                label: t('disableAction'),
                 effect: 'write',
                 row: true,
                 handler: ({ rowKey }) => setEnabled(rowKey, false),
             },
             removeWorkflow: {
-                label: '删除',
+                label: t('delete'),
                 effect: 'destructive',
-                confirm: '删除这个工作流，连同磁盘上的定义文件？',
+                confirm: t('deleteConfirm'),
                 row: true,
                 async handler({ rowKey }) {
                     if (!(await service.removeWorkflow(rowKey)))
-                        throw new Error(`工作流 ${rowKey} 不存在`);
-                    return `已删除 ${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: '新建或覆盖',
+                label: t('defineWorkflow'),
                 effect: 'write',
                 input: {
                     yaml: {
                         type: 'textarea',
-                        label: 'YAML 定义',
+                        label: t('yamlLabel'),
                         required: true,
-                        description: '完整的定义：id、name、trigger、nodes。trigger 支持 cron、interval、once、event、manual；节点支持 tool、send-message、' +
-                            'wait、agent（派发指令给 agent 并等回复，配合 deps 与 {{outputs.X}} 做多智能体编排）。同 id 的定义被覆盖，' +
-                            '保存后立即注册触发器。现有定义的 YAML 在定义表格的详情里，可以照着改。',
+                        description: t('yamlDescription'),
                     },
                     persist: {
                         type: 'boolean',
-                        label: '写入磁盘',
+                        label: t('persistLabel'),
                         default: true,
-                        description: '关闭后只在内存里注册，重启后丢失',
+                        description: t('persistDescription'),
                     },
                 },
-                async handler({ input }) {
+                async handler({ input, ctx }) {
                     let raw;
                     try {
                         raw = parse(input.yaml);
                     }
                     catch (err) {
-                        throw new Error(`YAML 解析失败：${err instanceof Error ? err.message : String(err)}`);
+                        throw new TextError(t('yamlFailed', { error: textOf(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}` : ''}`;
+                        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);
                 },
             },
         },
@@ -189,12 +217,12 @@ function defineWorkflowPage(webui, service, onceLedgerReadable) {
                     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: t('definitions'), value: defs.length },
+                        { label: t('stateEnabled'), value: defs.filter(d => d.enabled !== false).length },
+                        { label: t('runs24h'), value: recent.length },
                         {
-                            label: '24 小时失败',
-                            value: recent.filter(r => r.status === 'failed' || r.status === 'cancelled').length,
+                            label: t('failures24h'),
+                            value: recent.filter(r => r.status === 'failed').length,
                         },
                     ];
                 },
@@ -202,16 +230,17 @@ function defineWorkflowPage(webui, service, onceLedgerReadable) {
             {
                 type: 'table',
                 id: 'workflows',
-                label: '定义',
+                label: t('definitions'),
                 rowKey: 'id',
-                empty: '还没有工作流',
+                empty: t('noWorkflows'),
                 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' },
+                    { 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' },
@@ -224,10 +253,13 @@ function defineWorkflowPage(webui, service, onceLedgerReadable) {
                     name: d.name ?? d.id,
                     trigger: triggerSummary(d.trigger),
                     nodes: d.nodes.length,
-                    status: d.enabled === false ? { text: '停用', state: 'inactive' } : { text: '启用' },
+                    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: [
                     {
@@ -241,26 +273,32 @@ function defineWorkflowPage(webui, service, onceLedgerReadable) {
             {
                 type: 'table',
                 id: 'runs',
-                label: '最近运行',
+                label: t('recentRuns'),
                 rowKey: 'runId',
-                empty: '还没有运行过',
+                empty: t('noRuns'),
                 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' },
+                    { 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' },
                 ],
-                data: () => service.listRuns(50).map(r => ({
+                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((r.finishedAt ?? Date.now()) - r.startedAt),
+                    duration: fmtDuration(elapsed(r)),
                     error: r.error ?? '',
+                    running: r.status === 'running',
                 })),
             },
             { type: 'actions', actions: ['defineWorkflow'] },
@@ -273,7 +311,7 @@ function resolveUri(key, input, fallback) {
     if (!s)
         return fallback;
     if (!isStorageUri(s)) {
-        throw configError(`${key}="${s}" 不是 storage URI，请写成 <根名>:/<路径>（如 ${fallback}），或删掉该键使用默认值`);
+        throw configError(t('badUri', { key, value: s, fallback }));
     }
     return s;
 }
@@ -281,15 +319,22 @@ function resolveUri(key, input, fallback) {
 const uses = {
     /** cron / interval 触发器共享的整分钟 tick 与表达式解析 */
     cronEngine,
-    /** 定义（*.yaml）与运行历史的持久化出口 */
-    storage: optional(storage),
+    /**
+     * 定义（*.yaml）与运行历史的持久化出口：激活时读回。required：读回要在它上线之后（optional 不参与激活先后），
+     * 它下线时随之停下、重新上线后重新读回
+     */
+    storage,
     /** tool 节点的执行入口，兼 AI 工具面的登记口 */
     tools: optional(tools),
     /** 工作流页的登记口；无 WebUI 时引擎照常运行 */
     webui: optional(webuiServer),
+    /** 判调用者是不是 owner，定运行身份；缺席时判不出谁是 owner，调用者与定义者不是同一身份的按匿名 */
+    authority: optional(authority),
     events,
     /** agent 节点经 'agent:turn:after' 捕获本轮回复 */
     hooks,
+    /** agent 节点经它送达指令；缺席时 agent 节点失败 */
+    gateway: optional(gateway),
     lifecycle,
     logger,
     config,
@@ -297,7 +342,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'],
@@ -317,36 +362,39 @@ async function run(caps) {
         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(caps.storage.use, config.runsFile, config.maxRuns, logger);
     await runStore.init();
+    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: events.use, logger }, (workflowId, source, payload) => {
+    const triggers = new TriggerManager({ cronEngine: caps.cronEngine, events: events.use, logger, signal: lifecycle.use.signal }, (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 全部重放
+    // 定义已从磁盘删除的，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.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（登记进 running，拆卸据此等它收尾）──
+    // ── 核心：执行一次 workflow（登记进 running，拆卸据此等它收尾）──
     function runById(...args) {
         const pending = execute(...args);
         running.add(pending);
@@ -354,12 +402,24 @@ async function run(caps) {
         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 abort = new AbortController();
@@ -378,24 +438,25 @@ async function run(caps) {
         await events.use.emit('workflow:run:start', run);
         logger.info(`run=${runId} 启动 (trigger=${triggerSource})`);
         try {
+            // 执行完毕就摘掉中止句柄，再记终态、发收尾事件：之后的 cancelRun 回 false，不对已经落定的运行回「已取消」
             const result = await runDag({
                 tools,
                 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' 会话语义（不再借调用者平台——那会污染定时任务归属/审批的发起类别等分流）。
-                // 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: '' }],
                 },
+                callerSessionId: caller?.sessionId,
                 signal: abort.signal,
                 onNodeDone: (info) => {
                     const idx = run.nodes.findIndex(n => n.id === info.id);
@@ -403,7 +464,7 @@ async function run(caps) {
                         run.nodes[idx] = info;
                     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;
@@ -415,23 +476,64 @@ async function run(caps) {
             }
             else {
                 await events.use.emit('workflow:run:error', run);
-                logger.warn(`run=${runId} ${result.status}: ${result.error ?? ''}`);
+                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.use.emit('workflow:run:error', run);
-            logger.error(`run=${runId} 异常: ${run.error}`);
+            logger.error(`run=${runId} 异常: ${toSource(run.error)}`);
         }
         finally {
-            aborts.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() {
@@ -440,28 +542,20 @@ 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);
-            page.invalidate();
-            logger.info(`workflow 已定义: ${def.id} (持久化=${opts?.persist !== false})`);
+        defineWorkflow(def, opts) {
+            // 认不出调用方是谁：没有定义者
+            return define(def, opts?.persist !== false, undefined);
         },
         async removeWorkflow(id) {
-            // 先删文件，删不掉就抛错、触发器与 once 记账原样保留：先清账的话，重启后定义被重新载入，过期 once 会重放
-            const had = await loader.removeDef(id);
+            // 只动已载入的定义，删的是它载入时的文件：别的 id（借 ../ 指到定义目录之外的、载入失败的）不碰存储
+            if (!loader.get(id))
+                return false;
+            // 先删文件，删不掉就抛错、触发器与 once 记录原样保留：先清掉记录的话，重启后定义被重新载入，过期 once 会重放
+            await loader.removeDef(id);
             triggers.unregister(id);
-            runStore.clearOnceFired(id); // 定义没了，once 记账不留孤儿：同 id 重建算新工作流
+            runStore.forget(id); // 定义没了，once 记录与定义者不留孤儿：同 id 重建算新工作流
             page.invalidate();
-            return had;
+            return true;
         },
         async runWorkflow(id, vars, source, caller) {
             return await runById(id, vars ?? {}, source ?? 'manual', caller);
@@ -481,19 +575,19 @@ async function run(caps) {
         },
     };
     provide.use(workflow, service);
-    const page = defineWorkflowPage(webui.use, service, () => runStore.onceLedgerReadable());
+    const page = defineWorkflowPage(webui.use, service, definitions, () => runStore.onceLedgerReadable());
     // ── AI 工具 ──
-    // tools 晚上线也无妨：登记口在提供者缺席时先挂账，上线后自动补挂
+    // tools 晚上线也无妨：登记口在提供者缺席时先记下，上线后自动补挂
     if (config.enableTools) {
-        registerTools(tools.use, service, () => runStore.onceLedgerReadable());
+        registerTools(tools.use, service, definitions, () => runStore.onceLedgerReadable());
     }
     // ── 清理 ──
     lifecycle.use.onDispose(async () => {
         triggers.dispose();
         // 中止全部在飞 run：不再调度新节点，阻塞中的 wait / agent 节点立即结束。再等它们收尾、排队中的运行历史 /
-        // once 记账写完才结束拆卸：否则 app.stop() 返回后仍有落盘在飞，bounce 时迟到的快照会盖掉新实例的记账。
+        // once 记录写完才结束拆卸：否则 app.stop() 返回后仍有落盘在飞，bounce 时迟到的快照会盖掉新实例的记录。
         // 不响应中止信号的工具节点至多让这里等到 disposeTimeoutMs；放弃等待后旧实例记为 lingering，同 id 的新实例要等那次
-        // run 真正落定、这里返回之后才起
+        // run 真正落定、这里返回之后才启动
         for (const abort of aborts.values())
             abort.abort();
         await Promise.allSettled(running);
@@ -502,13 +596,19 @@ async function run(caps) {
     logger.info(`工作流插件已启动 (${loader.list().length} 个定义已加载)`);
 }
 // ─── AI 工具注册 ───
-/** onceLedgerReadable：once 记账读不出时本次运行不安排 once，workflow_define 的回执据此如实说明 */
-function registerTools(tools, service, onceLedgerReadable) {
-    tools.registerGroup({ name: 'workflow', label: '工作流', description: '定义、运行、查询自主工作流（DAG）' });
+/** onceLedgerReadable：once 记录读不出时本次运行不安排 once，workflow_define 的回执据此如实说明 */
+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',
@@ -518,7 +618,7 @@ function registerTools(tools, service, onceLedgerReadable) {
                     ' 节点支持类型 tool / send-message / wait / agent；deps 形成 DAG；字符串值支持 {{vars.X}} 与 {{outputs.Y}} 插值。' +
                     ' agent 节点（instruction 必填，可选 sessionId/platform/timeoutSeconds）会把指令派发给 agent 并等待其回复，' +
                     '回复经 out 存入 outputs 供下游插值——用 deps + agent 节点即可表达"分解→依赖→串/并行→管道→聚合"的确定性多智能体编排。' +
-                    ' once 触发器一生只触发一次：同 id 覆盖不会重新触发，要再跑一次请先 workflow_remove 再定义，或直接 workflow_run。',
+                    ' once 触发器一生只触发一次：同 id 覆盖不会重新触发，要再执行一次请先 workflow_remove 再定义，或直接 workflow_run。',
                 parameters: {
                     type: 'object',
                     properties: {
@@ -529,7 +629,7 @@ function registerTools(tools, service, onceLedgerReadable) {
                 },
             },
         },
-        handler: async (args) => {
+        handler: async (args, callCtx) => {
             const yamlText = String(args.yaml ?? '');
             let raw;
             try {
@@ -543,7 +643,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) });
@@ -554,11 +656,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',
@@ -581,7 +684,7 @@ function registerTools(tools, service, onceLedgerReadable) {
         },
     });
     tools.register({
-        risk: 'sensitive',
+        risk: 'dangerous',
         groups: ['workflow'],
         definition: {
             type: 'function',
@@ -599,17 +702,35 @@ 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) {
@@ -618,6 +739,8 @@ function registerTools(tools, service, onceLedgerReadable) {
         },
     });
     tools.register({
+        // 只看不改：运行的出错原因带会话 id（agent 节点的几句都写目标会话，私聊会话的 id 带对方账号），与 scheduler_list_jobs 同档
+        visibility: 'restricted',
         groups: ['workflow'],
         definition: {
             type: 'function',
@@ -643,14 +766,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',