@aalis/plugin-scheduler 0.14.0 → 0.16.0

package/dist/index.js

@@ -1,77 +1,89 @@
 import { cronEngine } from '@aalis/api-cron-engine';
-import { createStorageGateway, isStorageNotFound, isStorageUri, storage } from '@aalis/api-storage';
-import { tools } from '@aalis/api-tools';
+import { rootSessionOf, sessionManager } from '@aalis/api-session-manager';
+import { isStorageNotFound, isStorageUri, storage } from '@aalis/api-storage';
+import { actingIdentity, tools } from '@aalis/api-tools';
 import { webuiServer } from '@aalis/api-webui';
 import { config, definePlugin, defineService, events, lifecycle, logger, optional, provide, } from '@aalis/core';
-import { defineConfig, parseConfig } from '@aalis/schema-config';
-import { parseEverySeconds } from '@aalis/util-cron';
+import { configError, defineConfig, parseConfig } from '@aalis/schema-config';
+import { TextError, textClauses, textOf, toSource } from '@aalis/schema-i18n';
+import { MAX_INTERVAL_SECONDS, parseEverySeconds, validateIntervalSeconds } from '@aalis/util-cron';
+import { t } from './texts.js';
 // ──────────── Cron 解析 ────────────
 // 解析在 @aalis/util-cron（parseEverySeconds 等）；
 // scheduler 声明 cronEngine 后调用 subscribe()/nextFireTime()。
 /** setTimeout 的 delay 上限（32 位有符号毫秒，约 24.8 天）；超过即溢出成立即触发 */
 const MAX_TIMEOUT_MS = 2 ** 31 - 1;
-// ----- 服务描述符（按激活绑定；调用型：绑定接口是 ServiceRef）-----
+/** 固定间隔的下限（秒）：挡住 interval:0.5 这类会占满调度、耗尽资源的高频任务 */
+const MIN_INTERVAL_SECONDS = 5;
+/**
+ * 固定间隔（含 cron 的 `@every`）无效的原因，所有入口与配置、存量文件同一条：要是大于 0、不超过定时器能排的上限（超过的溢出成
+ * 每毫秒触发）的数，且不小于 MIN_INTERVAL_SECONDS
+ */
+function intervalProblem(seconds) {
+    return validateIntervalSeconds(seconds) ?? (seconds < MIN_INTERVAL_SECONDS ? t('intervalTooShort') : null);
+}
+// ----- 服务描述符（调用型：业务层就是提供者的形状）-----
 export const scheduler = defineService('scheduler');
 // ──────────── 插件元数据 ────────────
 export const configSchema = defineConfig({
     jobs: {
         type: 'array',
         onInvalid: 'error',
-        label: '计划任务列表',
-        description: '配置定时/周期性任务，让 AI 主动执行计划。',
+        label: t('jobsLabel'),
+        description: t('jobsDescription'),
         items: {
-            name: { type: 'string', label: '任务名称' },
+            name: { type: 'string', label: t('jobNameLabel') },
             cron: {
                 type: 'string',
-                label: 'Cron 表达式',
-                description: '5 段格式: 分 时 日 月 周 (如 "0 9 * * *" = 每天 9:00)。与"固定间隔"二选一。',
+                label: t('cronLabel'),
+                description: t('cronDescription'),
             },
             interval: {
                 type: 'number',
-                label: '固定间隔(秒)',
-                description: '每隔 N 秒执行一次。与"Cron 表达式"二选一。',
+                label: t('intervalLabel'),
+                description: t('intervalDescription'),
             },
             runAt: {
                 type: 'string',
-                label: '一次性运行时间',
-                description: 'ISO 字符串；执行一次后自动禁用。',
+                label: t('runAtLabel'),
+                description: t('runAtDescription'),
             },
             sessionId: {
                 type: 'string',
-                label: '目标会话 ID',
-                description: '任务消息发往的会话 ID。可以是真实群/用户会话，也可以自定义（如 scheduler::daily）。',
+                label: t('sessionIdLabel'),
+                description: t('sessionIdDescription'),
             },
             platform: {
                 type: 'string',
                 onInvalid: 'error',
-                label: '目标平台',
+                label: t('platformLabel'),
                 required: true,
-                description: '任务消息的平台标识（如 internal、webui、onebot）。仅用于消息路由。',
+                description: t('platformDescription'),
                 default: 'internal',
             },
             actorPlatform: {
                 type: 'string',
                 onInvalid: 'error',
-                label: '执行身份-平台',
-                description: '代理身份的 platform（与目标平台解耦）。authority 按 (actorPlatform, actorUserId) 联合裁决能力。留空 = webui。',
+                label: t('actorPlatformLabel'),
+                description: t('actorPlatformDescription'),
             },
             actorUserId: {
                 type: 'string',
                 onInvalid: 'error',
-                label: '执行身份-用户 ID',
-                description: '代理身份的 userId。留空 = console（与 actorPlatform=webui 组合即 owner，拥有一切能力）。',
+                label: t('actorUserIdLabel'),
+                description: t('actorUserIdDescription'),
             },
             content: {
                 type: 'string',
-                label: '消息内容',
+                label: t('contentLabel'),
                 default: '',
-                description: '发送给 Agent 的指令/提示内容。',
+                description: t('contentDescription'),
             },
-            enabled: { type: 'boolean', label: '启用', default: true, onInvalid: 'error' },
+            enabled: { type: 'boolean', label: t('enabledLabel'), default: true, onInvalid: 'error' },
             timeZone: {
                 type: 'string',
-                label: '时区 (IANA)',
-                description: 'cron 求值所用时区，如 Asia/Shanghai、Europe/London。留空 = 进程本地时区。仅对 cron 类任务生效。',
+                label: t('timeZoneLabel'),
+                description: t('timeZoneDescription'),
             },
         },
         default: [],
@@ -79,84 +91,47 @@ export const configSchema = defineConfig({
     persistPath: {
         type: 'string',
         onInvalid: 'error',
-        label: '动态任务存储路径',
+        label: t('persistPathLabel'),
         default: 'data:/scheduler-jobs.json',
-        description: '通过 AI 或 WebUI 创建的任务会持久化到此 storage URI，重启后自动加载。',
+        description: t('persistPathDescription'),
     },
 });
 // ──────────── WebUI 页面 ────────────
-const webuiPages = [
-    {
-        key: 'scheduler',
-        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="12" cy="12" r="10"/><polyline points="12,6 12,12 16,14"/></svg>',
-        order: 55,
-        content: [
-            {
-                type: 'table',
-                label: '任务列表',
-                source: 'listJobs',
-                columns: [
-                    { key: 'name', label: '名称' },
-                    { key: 'schedule', label: '调度规则' },
-                    { key: 'sessionId', label: '目标会话' },
-                    { key: 'status', label: '状态' },
-                    { key: 'nextRun', label: '下次执行', render: 'countdown' },
-                    { key: 'lastRunText', label: '上次执行' },
-                    { key: 'runCount', label: '执行次数' },
-                    { key: 'lastResult', label: '最近结果' },
-                ],
-                actions: [
-                    { label: '立即执行', method: 'triggerJob' },
-                    { label: '暂停', method: 'pauseJob' },
-                    { label: '恢复', method: 'resumeJob' },
-                    { label: '删除', method: 'removeJob', confirm: '确定删除该任务？', danger: true },
-                ],
-                refresh: 30,
-            },
-            {
-                type: 'form',
-                label: '新建 / 编辑任务',
-                source: 'newJobDraft',
-                save: 'upsertJob',
-                schema: {
-                    name: {
-                        type: 'string',
-                        label: '名称',
-                        required: true,
-                        description: '任务唯一标识；填已有动态任务名会覆盖（配置文件中的静态任务无法覆盖）',
-                    },
-                    cron: {
-                        type: 'string',
-                        label: 'Cron 表达式',
-                        description: '5 字段或别名：@hourly / @daily / @weekly / @every 30s；与 interval / runAt / delaySeconds 四选一',
-                    },
-                    interval: { type: 'number', label: '固定间隔（秒）', description: '与 cron / runAt / delaySeconds 四选一' },
-                    runAt: {
-                        type: 'string',
-                        label: '一次性运行时间',
-                        description: 'ISO 字符串，如 2026-05-19T10:00:00；执行一次后自动删除',
-                    },
-                    delaySeconds: {
-                        type: 'number',
-                        label: 'X 秒后执行一次',
-                        description: '与 cron / interval / runAt 四选一；填写后会转换为 runAt = now + N 秒，执行一次后自动删除',
-                    },
-                    sessionId: { type: 'string', label: '目标会话 ID', required: true },
-                    platform: { type: 'string', label: '目标平台', default: 'internal' },
-                    content: { type: 'textarea', label: '消息内容', required: true, description: '届时发送给自己的指令/提示' },
-                    enabled: { type: 'boolean', label: '启用', default: true },
-                    paused: {
-                        type: 'boolean',
-                        label: '创建后立即暂停',
-                        default: false,
-                        description: '勾选后任务创建但不会自动运行，需手动「恢复」；仅周期任务（cron / interval）可用',
-                    },
-                },
-            },
-        ],
+/** 新建与编辑共用的输入：调度方式（四选一）、目标会话与内容。新建另收任务名，编辑的任务名取这一行 */
+const JOB_FIELDS = defineConfig({
+    cron: {
+        type: 'string',
+        label: t('cronLabel'),
+        description: t('fieldCronDescription'),
+    },
+    interval: {
+        type: 'number',
+        label: t('fieldIntervalLabel'),
+        description: t('fieldIntervalDescription', { max: MAX_INTERVAL_SECONDS }),
+    },
+    runAt: {
+        type: 'string',
+        label: t('runAtLabel'),
+        description: t('fieldRunAtDescription'),
+    },
+    delaySeconds: {
+        type: 'number',
+        label: t('delaySecondsLabel'),
+        description: t('delaySecondsDescription'),
     },
-];
+    sessionId: { type: 'string', label: t('sessionIdLabel'), required: true },
+    platform: { type: 'string', label: t('platformLabel'), default: 'internal' },
+    content: { type: 'textarea', label: t('contentLabel'), required: true, description: t('fieldContentDescription') },
+    enabled: { type: 'boolean', label: t('enabledLabel'), default: true },
+    paused: {
+        type: 'boolean',
+        label: t('paused'),
+        default: false,
+        description: t('pausedDescription'),
+    },
+});
+/** 单个会话最多几个计划任务（防资源耗尽）；编辑已有任务不计入 */
+const MAX_JOBS_PER_SESSION = 20;
 // ──────────── 插件入口 ────────────
 const uses = {
     // tools 必须先就绪，否则下方 register tool 全部静默丢失（optional 不参与激活闸）
@@ -165,8 +140,10 @@ const uses = {
     cronEngine,
     /** 动态任务的持久化出口；没有 storage 时任务只活在本次激活里（读写各自降级） */
     storage: optional(storage),
-    /** 页面与页面动作的登记口；无 WebUI 时调度照常运行 */
+    /** 计划任务页的登记口；无 WebUI 时调度照常运行 */
     webui: optional(webuiServer),
+    /** 认调用所在的会话是不是子会话（在子会话里建任务要写明目标）；没有会话管理就没有子会话 */
+    sessionManager: optional(sessionManager),
     events,
     lifecycle,
     logger,
@@ -175,7 +152,7 @@ const uses = {
 };
 export default definePlugin({
     name: '@aalis/plugin-scheduler',
-    displayName: '定时任务',
+    displayName: t('displayName'),
     subsystem: 'scheduler',
     extends: {
         events: ['scheduler:job:start', 'scheduler:job:done', 'scheduler:job:error'],
@@ -186,41 +163,231 @@ export default definePlugin({
     apply: run,
 });
 async function run(caps) {
-    const cfg = parseConfig(configSchema, caps.config, caps.logger);
-    const { cronEngine, storage, webui, events, lifecycle, logger, provide, tools } = caps;
+    const cfg = parseConfig(configSchema, caps.config.use, caps.logger.use);
+    const { cronEngine, storage, webui, sessionManager, events, lifecycle, logger, provide, tools } = caps;
     const config = resolveConfig(cfg);
-    for (const page of webuiPages)
-        webui.registerPage(page);
     const runtimes = new Map();
     // 配置中定义的任务名称集合（不需要持久化）
     const configJobNames = new Set(config.jobs.map(j => j.name));
     // 动态任务集合（需要持久化）
     const dynamicJobs = new Map();
     // ── 持久化读写 （经 storage 抽象，默认 data:/scheduler-jobs.json） ──
-    const storageGateway = createStorageGateway(storage);
     const persistUri = config.persistPath;
     /**
      * 激活时那次读失败了、又不是「文件不存在」（storage 不在场、读错误、解析失败、结构不对）：写的是整表，
      * 此后一律拒写，否则下一次增删改就把原有动态任务冲掉。只在激活时读一次，storage 迟到也不重读。
      */
     let loadFailed = false;
-    /** 拒写期间新建或改动的任务只在内存、重启即失：回执末尾如实注明（AI 工具与 WebUI 表单同一附注），文件正常时为空串 */
-    const persistNote = () => (loadFailed ? `；仅本次运行生效，未写入 ${persistUri}（加载失败，见日志）` : '');
+    /**
+     * 拒写期间新建或改动的任务只在内存、重启即失：回执末尾如实注明（AI 工具与计划任务页同一附注，工具取原文），
+     * 文件正常时没有
+     */
+    const persistNote = () => (loadFailed ? t('notPersisted', { uri: persistUri }) : undefined);
+    // 先读完持久化任务再登记页面：登记之后到服务就绪之间不再有等待，页面一出现取数与动作就可用
+    const persisted = await loadDynamicJobs();
+    // ── 计划任务页：动作是本次激活的闭包，直接操作本插件自己的调度表；登记随激活撤回 ──
+    /**
+     * 新建与编辑共用：调度方式恰好一个（四者是互不相容的定时语义，多填时取哪个都是猜），与 scheduler_create_job
+     * 工具路径同一条判据与同一份 delaySeconds 换算。actor 取闸门放行后的调用者，不从输入读，免得伪造他人身份
+     */
+    function saveJob(name, input, caller, creating) {
+        const cron = input.cron?.trim() || undefined;
+        const interval = input.interval !== undefined && input.interval > 0 ? input.interval : undefined;
+        const delaySeconds = input.delaySeconds !== undefined && input.delaySeconds > 0 ? Math.floor(input.delaySeconds) : undefined;
+        const rawRunAt = input.runAt?.trim() || undefined;
+        const provided = [cron, interval, delaySeconds, rawRunAt].filter(v => v !== undefined).length;
+        if (provided === 0)
+            throw new TextError(t('scheduleMissing'));
+        if (provided > 1)
+            throw new TextError(t('scheduleConflict'));
+        const runAt = delaySeconds !== undefined ? new Date(Date.now() + delaySeconds * 1000).toISOString() : rawRunAt;
+        // 一次性任务被暂停时到点的定时器直接跳过，之后既不重排也不自删，任务就永久卡死在那里
+        if (input.paused && runAt)
+            throw new TextError(t('pauseOneShot'));
+        const sessionId = input.sessionId.trim();
+        if (!sessionId)
+            throw new TextError(t('sessionIdEmpty'));
+        const content = input.content.trim();
+        if (!content)
+            throw new TextError(t('contentEmpty'));
+        if (creating) {
+            const all = service.getJobs();
+            if (all.some(j => j.name === name))
+                throw new TextError(t('duplicateName', { name }));
+            if (all.filter(j => j.sessionId === sessionId).length >= MAX_JOBS_PER_SESSION) {
+                throw new TextError(t('tooManyJobs', { max: MAX_JOBS_PER_SESSION }));
+            }
+        }
+        service.setJob({
+            name,
+            cron,
+            interval,
+            runAt,
+            sessionId,
+            platform: input.platform,
+            actorPlatform: caller.platform,
+            actorUserId: caller.userId,
+            content,
+            enabled: input.enabled,
+            paused: input.paused,
+        });
+        const note = persistNote();
+        return note ? textClauses([t('jobSaved', { name }), note]) : t('jobSaved', { name });
+    }
+    const jobsPage = webui.use.definePage({
+        key: 'scheduler',
+        title: t('pageTitle'),
+        icon: 'clock',
+        actions: {
+            createJob: {
+                label: t('create'),
+                effect: 'write',
+                input: {
+                    name: { type: 'string', label: t('name'), required: true, description: t('nameDescription') },
+                    ...JOB_FIELDS,
+                },
+                handler({ input, ctx }) {
+                    const name = input.name.trim();
+                    if (!name)
+                        throw new TextError(t('nameEmpty'));
+                    return saveJob(name, input, ctx.caller, true);
+                },
+            },
+            editJob: {
+                label: t('edit'),
+                effect: 'write',
+                row: true,
+                input: JOB_FIELDS,
+                handler({ rowKey, input, ctx }) {
+                    if (!service.getJobs().some(j => j.name === rowKey))
+                        throw new TextError(t('jobMissing', { name: rowKey }));
+                    return saveJob(rowKey, input, ctx.caller, false);
+                },
+            },
+            triggerJob: {
+                label: t('triggerNow'),
+                effect: 'write',
+                row: true,
+                async handler({ rowKey }) {
+                    // 这一轮还没执行完时 triggerJob 直接跳过；与它置 running 在同一个同步段里判，没有竞态
+                    if (service.getJobs().find(j => j.name === rowKey)?.running) {
+                        throw new TextError(t('jobRunning', { name: rowKey }));
+                    }
+                    if (!(await service.triggerJob(rowKey)))
+                        throw new TextError(t('jobMissing', { name: rowKey }));
+                    return t('triggered', { name: rowKey });
+                },
+            },
+            pauseJob: {
+                label: t('pause'),
+                effect: 'write',
+                row: true,
+                handler({ rowKey }) {
+                    if (!service.pauseJob(rowKey))
+                        throw new TextError(t('cannotPause'));
+                    return t('pausedReceipt', { name: rowKey });
+                },
+            },
+            resumeJob: {
+                label: t('resume'),
+                effect: 'write',
+                row: true,
+                handler({ rowKey }) {
+                    if (!service.resumeJob(rowKey))
+                        throw new TextError(t('jobMissing', { name: rowKey }));
+                    return t('resumed', { name: rowKey });
+                },
+            },
+            removeJob: {
+                label: t('delete'),
+                effect: 'destructive',
+                confirm: t('deleteConfirm'),
+                row: true,
+                handler({ rowKey }) {
+                    if (!service.removeJob(rowKey))
+                        throw new TextError(t('jobMissing', { name: rowKey }));
+                    return t('deleted', { name: rowKey });
+                },
+            },
+        },
+        content: [
+            {
+                type: 'table',
+                id: 'jobs',
+                rowKey: 'name',
+                empty: t('noJobs'),
+                columns: [
+                    { key: 'name', label: t('name'), primary: true },
+                    { key: 'schedule', label: t('schedule') },
+                    { key: 'sessionId', label: t('target') },
+                    { key: 'status', label: t('status'), kind: 'status', primary: true },
+                    { key: 'nextRun', label: t('nextRun'), kind: 'countdown' },
+                    { key: 'lastRun', label: t('lastRun'), kind: 'time' },
+                    { key: 'runCount', label: t('runCount') },
+                    { key: 'lastResult', label: t('lastResult'), kind: 'long-text' },
+                ],
+                rowActions: [
+                    { action: 'triggerJob' },
+                    { action: 'pauseJob', visibleWhen: 'pausable' },
+                    { action: 'resumeJob', visibleWhen: 'paused' },
+                    { action: 'editJob', visibleWhen: 'editable' },
+                    { action: 'removeJob' },
+                ],
+                data: () => service.getJobs().map(j => {
+                    const ready = j.enabled && !j.paused && !j.running;
+                    return {
+                        name: j.name,
+                        cron: j.cron,
+                        interval: j.interval,
+                        runAt: j.runAt,
+                        sessionId: j.sessionId,
+                        platform: j.platform,
+                        content: j.content,
+                        enabled: j.enabled,
+                        paused: j.paused,
+                        schedule: j.cron ??
+                            (j.interval
+                                ? t('everySeconds', { seconds: j.interval })
+                                : j.runAt
+                                    ? t('oneShot', { at: j.runAt })
+                                    : t('unset')),
+                        status: !j.enabled
+                            ? { text: t('statusDisabled'), state: 'inactive' }
+                            : j.paused
+                                ? { text: t('paused'), state: 'inactive' }
+                                : j.running
+                                    ? { text: t('statusRunning'), state: 'running' }
+                                    : { text: t('statusReady') },
+                        nextRun: ready && j.nextRun > 0 ? j.nextRun : undefined,
+                        lastRun: j.lastRun || undefined,
+                        runCount: j.runCount,
+                        lastResult: j.lastResult,
+                        pausable: ready && !!(j.cron || j.interval),
+                        editable: !configJobNames.has(j.name),
+                    };
+                }),
+            },
+            { type: 'actions', actions: ['createJob'] },
+        ],
+    });
     async function loadDynamicJobs() {
+        /** 失败出在读文件这一步（存储插件不在、persistPath 的根名写错、文件读不了），文件内容未必有错 */
+        let reading = true;
         try {
             let raw;
             try {
-                raw = (await storageGateway.readFile(persistUri, 'utf-8'));
+                raw = (await storage.use.readFile(persistUri, 'utf-8'));
             }
             catch (err) {
-                // 只有「文件不存在」算全新；网关的「未知存储根」等其它失败不能当成空表
+                // 只有「文件不存在」算全新；「未知存储根」等其它失败不能当成空表
                 if (isStorageNotFound(err))
                     return [];
                 throw err;
             }
+            reading = false;
             const data = JSON.parse(raw);
             if (!Array.isArray(data)) {
-                throw new Error(`持久化任务文件不是数组（得到 ${data === null ? 'null' : typeof data}）`);
+                throw new TextError(t('notArray', { got: data === null ? 'null' : typeof data }));
             }
             // biome-ignore lint/suspicious/noExplicitAny: 从 JSON 文件反序列化的原始字段，手动校验转型
             return data.map((j) => {
@@ -233,7 +400,7 @@ async function run(caps) {
                     // `saveDynamicJobs` 的 JSON.stringify 会丢掉 undefined 键，匿名创建的任务落盘后
                     // 与无 actor 字段的老任务同形；此处补 owner 即等于给它开一条提权通道。
                     // 「创建者未知」不等于「创建者是 owner」。
-                    logger.warn(`持久化任务 "${j.name}" 缺少 actor 身份，已按匿名（最低权限）运行；如需更高权限请在 WebUI 中显式设置创建者身份`);
+                    logger.use.warn(`持久化任务 "${j.name}" 缺少 actor 身份，已按匿名（最低权限）运行；如需更高权限请在 WebUI 中显式设置创建者身份`);
                 }
                 return {
                     name: String(j.name ?? 'unnamed'),
@@ -252,7 +419,14 @@ async function run(caps) {
         }
         catch (err) {
             loadFailed = true;
-            logger.warn(`加载持久化任务失败，本次运行不再写入该文件: ${err}`);
+            logger.use.warn(`加载持久化任务失败，本次运行不再写入该文件: ${err}`);
+            // 里面的任务全没加载、新改动也不落盘：只记日志用户看不到
+            webui.use.notify({
+                id: 'jobs-load',
+                level: 'error',
+                title: t('loadFailedTitle', { uri: persistUri }),
+                detail: t(reading ? 'loadFailedReading' : 'loadFailedContent', { error: textOf(err) }),
+            });
             return [];
         }
     }
@@ -265,17 +439,17 @@ async function run(caps) {
     let saveChain = Promise.resolve();
     function saveDynamicJobs() {
         if (loadFailed) {
-            logger.warn(`持久化任务上次加载失败，跳过写入以免覆盖原有任务（本次改动仅在内存生效）: ${persistUri}`);
+            logger.use.warn(`持久化任务上次加载失败，跳过写入以免覆盖原有任务（本次改动仅在内存生效）: ${persistUri}`);
             return;
         }
         const jobs = [...dynamicJobs.values()];
         const payload = JSON.stringify(jobs, null, 2);
         saveChain = saveChain
-            .then(() => storageGateway.writeFile(persistUri, payload))
+            .then(() => storage.use.writeFile(persistUri, payload))
             .then(() => {
-            logger.debug(`已持久化 ${jobs.length} 个动态任务`);
+            logger.use.debug(`已持久化 ${jobs.length} 个动态任务`);
         }, err => {
-            logger.warn(`持久化任务失败: ${err}`);
+            logger.use.warn(`持久化任务失败: ${err}`);
         });
     }
     // ── 发送调度消息 ──
@@ -283,15 +457,16 @@ async function run(caps) {
         if (rt.running)
             return;
         rt.running = true;
+        jobsPage.invalidate();
         const jobName = rt.config.name;
         try {
-            logger.info(`执行任务: ${jobName}`);
-            await events.emit('scheduler:job:start', jobName);
+            logger.use.info(`执行任务: ${jobName}`);
+            await events.use.emit('scheduler:job:start', jobName);
             // 通用触发事件：供 workflow 等订阅者使用
             // （任务本身仍走 inbound:message 投递，这里同时广播 trigger:fired，
             //  便于平滑迁移到 plugin-workflow）
             // biome-ignore lint/suspicious/noExplicitAny: 事件类型由 api-workflow 增广，scheduler 不直接依赖
-            await events.emit('trigger:fired', {
+            await events.use.emit('trigger:fired', {
                 source: `scheduler:${jobName}`,
                 type: rt.config.cron ? 'cron' : 'interval',
                 payload: {
@@ -301,11 +476,13 @@ async function run(caps) {
                     content: rt.config.content,
                 },
             });
+            // 内容由 owner 写下或审批（见 SchedulerService；owner 免了 scheduler_create_job 的确认时例外，见 security-model），声明 ownerApproved
             const message = {
                 content: rt.config.content,
                 sessionId: rt.config.sessionId,
                 platform: rt.config.platform,
                 source: 'scheduler',
+                ownerApproved: true,
             };
             // 注入代理身份：authority 守卫优先读 actor 而非 platform/userId，
             // 从而让 scheduler 触发的 AI 走**创建者**的权限等级。
@@ -318,20 +495,21 @@ async function run(caps) {
             if (actorPlatform && actorUserId) {
                 message.actor = { platform: actorPlatform, userId: actorUserId };
             }
-            await events.emit('inbound:message', message);
+            await events.use.emit('inbound:message', message);
             rt.lastRun = Date.now();
             rt.runCount++;
-            rt.lastResult = '成功';
-            await events.emit('scheduler:job:done', jobName);
+            rt.lastResult = t('jobSucceeded');
+            await events.use.emit('scheduler:job:done', jobName);
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            rt.lastResult = `失败: ${msg}`;
-            logger.error(`任务 "${jobName}" 执行失败: ${msg}`);
-            await events.emit('scheduler:job:error', jobName, msg);
+            rt.lastResult = t('jobFailed', { error: textOf(err) });
+            logger.use.error(`任务 "${jobName}" 执行失败: ${msg}`);
+            await events.use.emit('scheduler:job:error', jobName, msg);
         }
         finally {
             rt.running = false;
+            jobsPage.invalidate();
         }
     }
     // ── 估算下次执行时间 ──
@@ -341,19 +519,44 @@ async function run(caps) {
             return Number.isFinite(ms) ? ms : 0;
         }
         if (job.interval) {
-            return (lastRun || Date.now()) + job.interval * 1000;
+            // 间隔无效的任务没有排上（见 initJob），不知道下次
+            return intervalProblem(job.interval) ? 0 : (lastRun || Date.now()) + job.interval * 1000;
         }
         if (job.cron) {
             const tz = job.timeZone?.trim() || undefined;
-            // 每次求值取当前提供者：cron-engine 换人后不会算在旧实例上
-            return cronEngine.require().nextFireTime(job.cron, new Date(), undefined, tz ? { timeZone: tz } : undefined) ?? 0;
+            // 每次求值取当前提供者：cron-engine 换人后不会算在旧实例上。时区无效时它同步抛错：这只是展示用的估计，
+            // 按「不知道」处理，任务排不上的原因由订阅失败的提示报出
+            try {
+                return cronEngine.use.nextFireTime(job.cron, new Date(), undefined, tz ? { timeZone: tz } : undefined) ?? 0;
+            }
+            catch {
+                return 0;
+            }
         }
         return 0;
     }
     // ── 初始化所有任务 ──
+    /** cron 订阅不上、固定间隔无效，永远不会运行的任务各一条提示：任务重排或删掉时撤回 */
+    const unscheduled = new Map();
+    function clearUnscheduled(name) {
+        unscheduled.get(name)?.clear();
+        unscheduled.delete(name);
+    }
+    /** 发「没有排上」的提示：配置文件里的任务写去配置里改，别的写去计划任务页编辑，带出原因 */
+    function markUnscheduled(name, reason) {
+        const fromConfig = configJobNames.has(name);
+        unscheduled.set(name, webui.use.notify({
+            id: `unscheduled:${name}`,
+            level: 'error',
+            title: t('unscheduledTitle', { name }),
+            detail: t(fromConfig ? 'unscheduledInConfig' : 'unscheduledOnPage', { error: reason }),
+            open: fromConfig ? 'config' : { page: 'scheduler' },
+        }));
+    }
     function initJob(jobCfg) {
         if (runtimes.has(jobCfg.name))
             return;
+        clearUnscheduled(jobCfg.name);
         // 归一化 cron 快捷符；"@every Ns" 转成 interval 通道
         if (jobCfg.cron) {
             const everySec = parseEverySeconds(jobCfg.cron);
@@ -367,7 +570,7 @@ async function run(caps) {
         // 创建口与 pauseJob 都已拒绝这种组合，但存量持久化文件里可能还留着；启动时告警并按未暂停处理
         // （要停掉它请改 enabled 或直接删除）。
         if (jobCfg.runAt && !jobCfg.cron && !jobCfg.interval && jobCfg.paused) {
-            logger.warn(`任务 "${jobCfg.name}" 是一次性任务却带 paused，暂停对其无可用语义；已按未暂停处理`);
+            logger.use.warn(`任务 "${jobCfg.name}" 是一次性任务却带 paused，暂停对其无可用语义；已按未暂停处理`);
             jobCfg.paused = false;
         }
         const rt = {
@@ -382,20 +585,27 @@ async function run(caps) {
             // 优先采用持久化的 paused 字段；若未设置则回落到 enabled 状态（禁用即视作暂停）
             paused: jobCfg.paused === true || !jobCfg.enabled,
         };
-        // 固定间隔调度
-        if (jobCfg.interval && jobCfg.interval > 0 && jobCfg.enabled) {
-            rt.timer = setInterval(() => {
-                if (!rt.paused) {
-                    executeJob(rt);
-                    rt.nextRun = estimateNextRun(rt.config, Date.now());
-                }
-            }, jobCfg.interval * 1000);
+        // 固定间隔调度。间隔无效（见 intervalProblem）的不排、发提示：服务入口已当场拒收，这里只剩配置文件与存量文件里的任务
+        if (jobCfg.interval !== undefined && jobCfg.enabled) {
+            const problem = intervalProblem(jobCfg.interval);
+            if (problem) {
+                logger.use.warn(`任务 ${jobCfg.name} 的固定间隔无效: ${toSource(problem)}`);
+                markUnscheduled(jobCfg.name, problem);
+            }
+            else {
+                rt.timer = setInterval(() => {
+                    if (!rt.paused) {
+                        executeJob(rt);
+                        rt.nextRun = estimateNextRun(rt.config, Date.now());
+                    }
+                }, jobCfg.interval * 1000);
+            }
         }
         // cron 任务：订阅到共享 cron-engine
         if (jobCfg.cron && jobCfg.enabled) {
             try {
                 const tz = jobCfg.timeZone?.trim() || undefined;
-                rt.cronDispose = cronEngine.require().subscribe(jobCfg.cron, () => {
+                rt.cronDispose = cronEngine.use.subscribe(jobCfg.cron, () => {
                     if (rt.paused || !rt.config.enabled)
                         return;
                     executeJob(rt);
@@ -403,7 +613,9 @@ async function run(caps) {
                 }, tz ? { timeZone: tz } : undefined);
             }
             catch (err) {
-                logger.warn(`任务 ${jobCfg.name} cron 订阅失败: ${err instanceof Error ? err.message : err}`);
+                const reason = err instanceof Error ? err.message : String(err);
+                logger.use.warn(`任务 ${jobCfg.name} cron 订阅失败: ${reason}`);
+                markUnscheduled(jobCfg.name, textOf(err));
             }
         }
         // 一次性任务：到点用 setTimeout 触发一次，执行完 disable 并持久化
@@ -438,10 +650,11 @@ async function run(caps) {
                 }
             }
             else {
-                logger.warn(`任务 ${jobCfg.name} 的 runAt 无法解析: ${jobCfg.runAt}`);
+                logger.use.warn(`任务 ${jobCfg.name} 的 runAt 无法解析: ${jobCfg.runAt}`);
             }
         }
         runtimes.set(jobCfg.name, rt);
+        jobsPage.invalidate();
         const scheduleHint = jobCfg.cron
             ? `(cron: ${jobCfg.cron})`
             : jobCfg.interval
@@ -449,7 +662,7 @@ async function run(caps) {
                 : jobCfg.runAt
                     ? `(runAt: ${jobCfg.runAt})`
                     : '(no schedule)';
-        logger.info(`任务已注册: ${jobCfg.name} ${scheduleHint}`);
+        logger.use.info(`任务已注册: ${jobCfg.name} ${scheduleHint}`);
     }
     /** 一次性任务执行完后的清理：动态任务直接删除；静态 yaml 任务仅标记 enabled=false */
     function disableOneShot(rt) {
@@ -462,40 +675,75 @@ async function run(caps) {
             runtimes.delete(jobName);
             dynamicJobs.delete(jobName);
             saveDynamicJobs();
-            logger.info(`一次性任务已执行完毕并删除: ${jobName}`);
+            jobsPage.invalidate();
+            logger.use.info(`一次性任务已执行完毕并删除: ${jobName}`);
             return;
         }
         // 静态配置任务：不删，仅标记 enabled=false（yaml 才是权威源）
         rt.config.enabled = false;
         rt.paused = true;
-        logger.info(`一次性任务已执行完毕并停用（静态）: ${jobName}`);
+        jobsPage.invalidate();
+        logger.use.info(`一次性任务已执行完毕并停用（静态）: ${jobName}`);
     }
-    // 静态 YAML 任务的「创建者」是编辑配置文件的人——那本身就是 owner 行为，故缺省补 owner。
+    // 静态 YAML 任务的「创建者」是编辑配置文件的人——那本身就是 owner 行为，故两项都不写时补 owner。
     // **这是全插件唯一允许推断 owner 的地方**：来源是配置文件（只有能写盘的人才改得动），
     // 不是运行时输入。补在此处而非触发时，是为了让「谁是 actor」在任务入表那一刻就定死，
     // 触发路径只透传、不再有第二次机会发明身份。YAML 显式写 actor 则用其值（可降权）。
     for (const job of config.jobs) {
         const p = job.actorPlatform?.trim();
         const u = job.actorUserId?.trim();
-        if ((p && !u) || (!p && u)) {
-            // 半指定：只写了一半就当没写，会被整体替换成 owner —— 那与作者意图相反
-            // （写 actor 通常是为了**降权**）。不静默升权，也不因此拒绝启动。
-            logger.warn(`任务 "${job.name}" 只写了 actorPlatform/actorUserId 其中一个，两者必须成对；已按未指定处理（owner）`);
+        if (!p !== !u) {
+            // 只写了一半：写执行身份通常是为了降权，补成 owner 与作者意图相反，另一半也无从知道，所以这条不载入
+            logger.use.error(`任务 "${job.name}" 只写了 actorPlatform、actorUserId 其中一个，两者须成对填写；这条任务没有载入`);
+            unscheduled.set(job.name, webui.use.notify({
+                id: `unscheduled:${job.name}`,
+                level: 'error',
+                title: t('halfActorTitle', { name: job.name }),
+                detail: t('halfActorDetail'),
+                open: 'config',
+            }));
+            continue;
         }
         initJob(p && u ? job : { ...job, actorPlatform: 'webui', actorUserId: 'console' });
     }
-    // 加载持久化的动态任务
-    const persisted = await loadDynamicJobs();
+    // 持久化的动态任务：配置文件里写了的名字归配置文件，那一条没载入也不让同名的动态任务顶上来；
+    // 文件里重名的只认第一条
     for (const job of persisted) {
-        if (!runtimes.has(job.name)) {
+        if (!configJobNames.has(job.name) && !runtimes.has(job.name)) {
             dynamicJobs.set(job.name, job);
             initJob(job);
         }
     }
     if (persisted.length > 0) {
-        logger.info(`已加载 ${persisted.length} 个持久化任务`);
+        logger.use.info(`已加载 ${persisted.length} 个持久化任务`);
     }
     // ── 注册 scheduler 服务 ──
+    /**
+     * 配置文件里写了的名字归配置文件（那一条没载入也一样）：页面、工具与别的插件经服务新建与修改时都不能用它，免得顶替它、
+     * 撤掉它的错误提示，又因名字在配置里不落盘、重启就没了
+     */
+    function rejectConfigName(name) {
+        if (configJobNames.has(name))
+            throw new TextError(t('fromConfig', { name }));
+    }
+    /**
+     * 无效的 cron 与固定间隔（含 cron 的 `@every`，见 intervalProblem）当场拒收：收下了也订阅不上、永远不会运行，或者间隔太短、
+     * 超过定时器能排的上限溢出成每毫秒触发，还会落进持久化文件。页面、工具与别的插件都经服务新建与修改
+     */
+    function rejectInvalidSchedule(job) {
+        if (job.cron) {
+            const checked = cronEngine.use.validate(job.cron);
+            if (!checked.ok)
+                throw typeof checked.text === 'string' ? new Error(checked.text) : new TextError(checked.text);
+        }
+        const every = job.cron ? parseEverySeconds(job.cron) : 0;
+        const interval = every > 0 ? every : job.interval;
+        if (interval !== undefined) {
+            const problem = intervalProblem(interval);
+            if (problem)
+                throw new TextError(problem);
+        }
+    }
     const service = {
         getJobs() {
             return [...runtimes.values()].map(rt => ({
@@ -521,7 +769,7 @@ async function run(caps) {
                 return false;
             // 一次性任务被暂停会永久卡住（到点的定时器直接跳过且不重排），与创建口同一判据：直接拒绝
             if (rt.config.runAt && !rt.config.cron && !rt.config.interval) {
-                logger.warn(`一次性任务不能暂停: ${jobName}（只能删除重建）`);
+                logger.use.warn(`一次性任务不能暂停: ${jobName}（只能删除重建）`);
                 return false;
             }
             rt.paused = true;
@@ -530,7 +778,8 @@ async function run(caps) {
                 dynamicJobs.set(jobName, { ...rt.config });
                 saveDynamicJobs();
             }
-            logger.info(`任务已暂停: ${jobName}`);
+            jobsPage.invalidate();
+            logger.use.info(`任务已暂停: ${jobName}`);
             return true;
         },
         resumeJob(jobName) {
@@ -544,7 +793,8 @@ async function run(caps) {
                 dynamicJobs.set(jobName, { ...rt.config });
                 saveDynamicJobs();
             }
-            logger.info(`任务已恢复: ${jobName}`);
+            jobsPage.invalidate();
+            logger.use.info(`任务已恢复: ${jobName}`);
             return true;
         },
         async triggerJob(jobName) {
@@ -555,18 +805,16 @@ async function run(caps) {
             return true;
         },
         addJob(job) {
+            rejectConfigName(job.name);
+            rejectInvalidSchedule(job);
             initJob(job);
-            // 非配置中定义的任务需要持久化
-            if (!configJobNames.has(job.name)) {
-                dynamicJobs.set(job.name, job);
-                saveDynamicJobs();
-            }
+            dynamicJobs.set(job.name, job);
+            saveDynamicJobs();
         },
         setJob(job) {
-            // upsert：先 remove 再 add；命中 config 静态任务时不允许覆盖
-            if (configJobNames.has(job.name)) {
-                throw new Error(`任务 "${job.name}" 来自配置文件，无法通过 setJob 覆盖`);
-            }
+            // upsert：先 remove 再 add
+            rejectConfigName(job.name);
+            rejectInvalidSchedule(job);
             const existed = runtimes.get(job.name);
             if (existed) {
                 if (existed.timer)
@@ -592,116 +840,21 @@ async function run(caps) {
                 dynamicJobs.delete(jobName);
                 saveDynamicJobs();
             }
-            logger.info(`任务已删除: ${jobName}`);
+            clearUnscheduled(jobName);
+            jobsPage.invalidate();
+            logger.use.info(`任务已删除: ${jobName}`);
             return true;
         },
     };
-    provide(scheduler, service);
-    // ── WebUI 页面动作 ──
-    // 动作是本次激活的闭包，直接操作本插件自己的调度表；登记随激活撤回。
-    webui.registerAction('listJobs', async () => {
-        return service.getJobs().map(j => {
-            const ready = j.enabled && !j.paused && !j.running;
-            return {
-                ...j,
-                nextRun: ready ? j.nextRun : 0,
-                schedule: j.cron ?? (j.interval ? `每 ${j.interval}s` : j.runAt ? `一次性@${j.runAt}` : '未设置'),
-                status: !j.enabled ? '❌ 禁用' : j.paused ? '⏸ 暂停' : j.running ? '⏳ 执行中' : '✅ 就绪',
-                lastRunText: j.lastRun ? new Date(j.lastRun).toLocaleString('zh-CN') : '从未',
-            };
-        });
-    });
-    webui.registerAction('triggerJob', async (args) => service.triggerJob(args.name));
-    // 三个开关类 action 返回 { ok, error }：裸 boolean 会被前端按成功处理（一次性任务不能暂停就是这样被静默掉的）
-    webui.registerAction('pauseJob', async (args) => service.pauseJob(args.name)
-        ? { ok: true }
-        : { ok: false, error: '任务不存在，或是一次性任务（不能暂停，只能删除重建）' });
-    webui.registerAction('resumeJob', async (args) => service.resumeJob(args.name) ? { ok: true } : { ok: false, error: '任务不存在' });
-    webui.registerAction('removeJob', async (args) => service.removeJob(args.name) ? { ok: true } : { ok: false, error: '任务不存在' });
-    webui.registerAction('newJobDraft', async () => ({
-        name: '',
-        cron: '',
-        interval: 0,
-        runAt: '',
-        delaySeconds: 0,
-        sessionId: '',
-        platform: 'internal',
-        content: '',
-        enabled: true,
-        paused: false,
-    }));
-    webui.registerAction('upsertJob', async (args, caller) => {
-        const jobName = String(args.name ?? '').trim();
-        if (!jobName)
-            return { ok: false, error: '任务名称不能为空' };
-        const cron = String(args.cron ?? '').trim() || undefined;
-        const interval = Number(args.interval) > 0 ? Number(args.interval) : undefined;
-        const delaySeconds = Number(args.delaySeconds) > 0 ? Math.floor(Number(args.delaySeconds)) : undefined;
-        const rawRunAt = String(args.runAt ?? '').trim() || undefined;
-        // 调度方式恰好一个：四者同时也是四种互不相容的定时语义（周期 cron / 周期间隔 / 一次性），
-        // 多填时取哪个都是猜，一律报错要求填一个——与 scheduler_create_job 工具路径同一条判据。
-        const provided = [cron, interval, delaySeconds, rawRunAt].filter(v => v !== undefined).length;
-        if (provided === 0) {
-            return { ok: false, error: 'cron / interval / runAt / delaySeconds 必须填写其中之一' };
-        }
-        if (provided > 1) {
-            return { ok: false, error: 'cron / interval / runAt / delaySeconds 互斥，只能填一个' };
-        }
-        // delaySeconds → runAt：与 scheduler_create_job 工具路径同一份转换（到点执行一次后自动停止）
-        const runAt = delaySeconds !== undefined ? new Date(Date.now() + delaySeconds * 1000).toISOString() : rawRunAt;
-        // 「创建后立即暂停」只对周期任务有意义：一次性任务被暂停时到点的 setTimeout 直接跳过，
-        // 之后既不会重排也不会自删（disableOneShot 只在真执行后走），任务就永久卡死在那里。
-        if (args.paused === true && runAt) {
-            return { ok: false, error: '创建后立即暂停对一次性任务（runAt / delaySeconds）没有可用语义' };
-        }
-        // 防资源耗尽（scheduler 工具对聊天访客公开）：interval 下限，挡住 interval:0.5 这类高频任务。
-        if (interval !== undefined && interval < 5) {
-            return { ok: false, error: 'interval 不能小于 5 秒（防高频任务耗尽资源）' };
-        }
-        const sessionId = String(args.sessionId ?? '').trim();
-        if (!sessionId)
-            return { ok: false, error: 'sessionId 不能为空' };
-        const content = String(args.content ?? '').trim();
-        if (!content)
-            return { ok: false, error: 'content 不能为空' };
-        // 防资源耗尽：单会话任务数上限；更新已有任务（同名）不计入，仅拦新建。
-        const MAX_JOBS_PER_SESSION = 20;
-        const allJobs = service.getJobs();
-        if (!allJobs.some(j => j.name === jobName) &&
-            allJobs.filter(j => j.sessionId === sessionId).length >= MAX_JOBS_PER_SESSION) {
-            return { ok: false, error: `本会话定时任务数已达上限 ${MAX_JOBS_PER_SESSION}，请先删除部分任务再新建` };
-        }
-        try {
-            // actor 从权限闸放行后的 caller 快照（登录账户或单 token 模式的 webui:console），
-            // 不从 args 读取，避免 WebUI 调用方伪造他人身份。
-            const actor = caller ?? { platform: 'webui', userId: 'console' };
-            service.setJob({
-                name: jobName,
-                cron,
-                interval,
-                runAt,
-                sessionId,
-                platform: String(args.platform ?? 'internal'),
-                actorPlatform: actor.platform,
-                actorUserId: actor.userId,
-                content,
-                enabled: args.enabled !== false,
-                paused: args.paused === true,
-            });
-            const note = persistNote();
-            return note ? { ok: true, message: `已保存${note}` } : { ok: true };
-        }
-        catch (err) {
-            return { ok: false, error: err instanceof Error ? err.message : String(err) };
-        }
-    });
+    provide.use(scheduler, service);
     // ── 注册 AI 工具：让 Agent 可以自主创建/管理任务 ──
-    tools.registerGroup({
+    tools.use.registerGroup({
         name: 'scheduler',
-        label: '定时任务',
+        label: t('displayName'),
+        summary: t('groupSummary'),
         description: '创建、查看和取消定时/周期性自主行动计划',
     });
-    tools.register({
+    tools.use.register({
         groups: ['scheduler'],
         definition: {
             type: 'function',
@@ -733,7 +886,10 @@ async function run(caps) {
                             type: 'string',
                             description: 'ISO 8601 绝对时间，到点执行一次后自动停止。例："2026-05-19T15:46:44+08:00"。',
                         },
-                        sessionId: { type: 'string', description: '任务消息发往的会话 ID。不传则默认使用当前会话。' },
+                        sessionId: {
+                            type: 'string',
+                            description: '任务消息发往的会话 ID。不传则默认使用当前会话（子任务里必须传）。',
+                        },
                         platform: { type: 'string', description: '目标平台标识。不传则默认使用当前平台。' },
                         content: { type: 'string', description: '届时发送给自己的指令/提示内容' },
                     },
@@ -742,9 +898,9 @@ async function run(caps) {
             },
         },
         // 建任务 = 让 AI 在未来自主行动，且 actor 身份在此固化（见 resolveActor）。
-        // 写类：restricted + 每次确认——被注入的 LLM 建一条 cron 就等于拿到持久执行面。
+        // 写类：restricted + 确认，与别的要确认的操作同一规则（参与者都是 owner 且在免确认白名单里的回合免）。
         risk: 'dangerous',
-        confirm: 'always',
+        confirm: 'session',
         handler: async (args, callCtx) => {
             // 互斥校验：cron / interval / delaySeconds / runAt 必须恰好提供一个
             const hasCron = typeof args.cron === 'string' && args.cron.trim().length > 0;
@@ -763,25 +919,41 @@ async function run(caps) {
             if (hasDelay) {
                 runAt = new Date(Date.now() + Math.floor(args.delaySeconds) * 1000).toISOString();
             }
+            const target = typeof args.sessionId === 'string' ? args.sessionId.trim() : '';
+            const here = sessionManager.present ? sessionManager.use.getSession(callCtx.sessionId) : undefined;
+            // 子会话没有窗口，删掉后发往它的任务就静默丢了：在子会话里不按默认发回当前会话，要写明目标；根会话的 id 作候选
+            if (!target && here?.parentId) {
+                const root = rootSessionOf(here, id => sessionManager.use.getSession(id));
+                const candidate = root ? `；要发回根会话，sessionId 写 "${root.id}"` : '';
+                return JSON.stringify({
+                    error: `在子任务里建定时任务必须写明目标会话 sessionId：子任务的会话删掉后，发往它的任务会静默丢失${candidate}`,
+                });
+            }
+            // 安全关键：创建者强制取这次调用的授权身份（api-tools 的 actingIdentity），不从 args 读取：即使 LLM 在 prompt 中尝试
+            // 伪造身份也会被忽略。只有一位参与者时是他（代人执行的回合，如子任务链、workflow 或定时任务驱动的，就是被代的人）；
+            // 这一项声明了确认，多人的一轮里经 owner 批过，参与者已换成她；没有单一身份的是无主体，任务按匿名（defaultAuthority）
+            // 运行，实现权限的自然传递与不可提升
+            const creator = actingIdentity(callCtx);
             const job = {
                 name: args.name,
                 cron: hasCron ? args.cron.trim() : undefined,
                 interval: hasInterval ? args.interval : undefined,
                 runAt,
-                sessionId: args.sessionId || callCtx.sessionId,
+                sessionId: target || callCtx.sessionId,
                 platform: args.platform || callCtx.platform || 'internal',
-                // 安全关键：actor 强制从 callCtx snapshot，不从 args 读取。
-                // 这样即使 LLM 在 prompt 中尝试伪造身份，也会被忽略——它只能以当前调用者的身份创建任务。
-                // 优先 callCtx.actor（本回合本就在代人执行，如委派/子任务链），否则用物理身份；
-                // 两者皆空则子任务匿名（defaultAuthority），实现权限的自然传递与不可提升。
-                actorPlatform: callCtx.actor?.platform ?? callCtx.platform,
-                actorUserId: callCtx.actor?.userId ?? callCtx.userId,
+                actorPlatform: creator.platform,
+                actorUserId: creator.userId || undefined,
                 content: args.content,
                 enabled: true,
             };
             if (runtimes.has(job.name))
                 return JSON.stringify({ error: `任务 "${job.name}" 已存在` });
-            service.addJob(job);
+            try {
+                service.addJob(job);
+            }
+            catch (err) {
+                return JSON.stringify({ error: err instanceof Error ? err.message : String(err) });
+            }
             const scheduleDesc = job.cron
                 ? `cron="${job.cron}"`
                 : job.interval
@@ -789,13 +961,14 @@ async function run(caps) {
                     : job.runAt
                         ? `一次性 @ ${job.runAt}`
                         : '?';
+            const note = persistNote();
             return JSON.stringify({
                 ok: true,
-                message: `任务 "${job.name}" 已创建 (${scheduleDesc})，目标会话: ${job.sessionId} (${job.platform})${persistNote()}`,
+                message: `任务 "${job.name}" 已创建 (${scheduleDesc})，目标会话: ${job.sessionId} (${job.platform})${note ? `；${toSource(note)}` : ''}`,
             });
         },
     });
-    tools.register({
+    tools.use.register({
         groups: ['scheduler'],
         definition: {
             type: 'function',
@@ -817,8 +990,8 @@ async function run(caps) {
                 },
             },
         },
-        // 读类：任务清单含 sessionId / prompt，属信息暴露向量；不弹确认。
-        risk: 'sensitive',
+        // 只看不改：任务清单含 sessionId / prompt，2 级、不确认，低于 2 级的看不到
+        visibility: 'restricted',
         handler: async (args) => {
             const all = service.getJobs().map(j => ({
                 name: j.name,
@@ -862,7 +1035,7 @@ async function run(caps) {
             });
         },
     });
-    tools.register({
+    tools.use.register({
         groups: ['scheduler'],
         definition: {
             type: 'function',
@@ -880,13 +1053,13 @@ async function run(caps) {
         },
         // 删类：删掉定时任务不可逆（无回收站）。
         risk: 'dangerous',
-        confirm: 'always',
+        confirm: 'session',
         handler: async (args) => {
             const ok = service.removeJob(args.name);
             return JSON.stringify({ ok, message: ok ? '已删除' : '任务不存在' });
         },
     });
-    tools.register({
+    tools.use.register({
         groups: ['scheduler'],
         definition: {
             type: 'function',
@@ -904,13 +1077,13 @@ async function run(caps) {
         },
         // 改状态类：暂停等于静默停掉一条自主行动，用户不会收到任何提示。
         risk: 'dangerous',
-        confirm: 'always',
+        confirm: 'session',
         handler: async (args) => {
             const ok = service.pauseJob(args.name);
             return JSON.stringify({ ok, message: ok ? '已暂停' : '任务不存在，或是一次性任务（不能暂停，只能删除重建）' });
         },
     });
-    tools.register({
+    tools.use.register({
         groups: ['scheduler'],
         definition: {
             type: 'function',
@@ -928,14 +1101,14 @@ async function run(caps) {
         },
         // 改状态类：恢复会让一条被停掉的自主行动重新开始跑。
         risk: 'dangerous',
-        confirm: 'always',
+        confirm: 'session',
         handler: async (args) => {
             const ok = service.resumeJob(args.name);
             return JSON.stringify({ ok, message: ok ? '已恢复' : '任务不存在' });
         },
     });
     // ── 清理 ──
-    lifecycle.onDispose(() => {
+    lifecycle.use.onDispose(() => {
         for (const rt of runtimes.values()) {
             if (rt.timer)
                 clearInterval(rt.timer);
@@ -944,7 +1117,7 @@ async function run(caps) {
         }
         runtimes.clear();
     });
-    logger.info(`计划任务调度器已启动 (${config.jobs.length} 个任务)`);
+    logger.use.info(`计划任务调度器已启动 (${config.jobs.length} 个任务)`);
 }
 // ──────────── 辅助函数 ────────────
 export function resolveConfig(cfg) {
@@ -963,7 +1136,7 @@ function resolvePersistPath(input) {
     if (!s)
         return configSchema.persistPath.default;
     if (!isStorageUri(s)) {
-        throw new Error(`plugin-scheduler 配置错误: persistPath="${s}" 不是 storage URI，请写成 <根名>:/<路径>（如 data:/scheduler-jobs.json），或删掉该键使用默认值`);
+        throw configError(t('badPersistPath', { value: s }));
     }
     return s;
 }