@aalis/plugin-scheduler 0.15.0 → 0.17.0

package/dist/index.js

@@ -1,15 +1,27 @@
 import { cronEngine } from '@aalis/api-cron-engine';
+import { rootSessionOf, sessionManager } from '@aalis/api-session-manager';
 import { isStorageNotFound, isStorageUri, storage } from '@aalis/api-storage';
-import { tools } from '@aalis/api-tools';
+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 { configError, defineConfig, parseConfig } from '@aalis/schema-config';
-import { parseEverySeconds } from '@aalis/util-cron';
+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;
+/** 固定间隔的下限（秒）：挡住 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');
 // ──────────── 插件元数据 ────────────
@@ -17,61 +29,61 @@ 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,9 +91,9 @@ 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 页面 ────────────
@@ -89,29 +101,33 @@ export const configSchema = defineConfig({
 const JOB_FIELDS = defineConfig({
     cron: {
         type: 'string',
-        label: 'Cron 表达式',
-        description: '5 字段或别名：@hourly、@daily、@weekly、@every 30s；与固定间隔、一次性运行时间、X 秒后执行四选一',
+        label: t('cronLabel'),
+        description: t('fieldCronDescription'),
+    },
+    interval: {
+        type: 'number',
+        label: t('fieldIntervalLabel'),
+        description: t('fieldIntervalDescription', { max: MAX_INTERVAL_SECONDS }),
     },
-    interval: { type: 'number', label: '固定间隔（秒）', description: '不小于 5；与其余三种调度方式四选一' },
     runAt: {
         type: 'string',
-        label: '一次性运行时间',
-        description: 'ISO 时间，如 2026-05-19T10:00:00；执行一次后自动删除',
+        label: t('runAtLabel'),
+        description: t('fieldRunAtDescription'),
     },
     delaySeconds: {
         type: 'number',
-        label: 'X 秒后执行一次',
-        description: '换算成一次性运行时间 = 现在 + N 秒，执行一次后自动删除',
+        label: t('delaySecondsLabel'),
+        description: t('delaySecondsDescription'),
     },
-    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 },
+    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: '暂停',
+        label: t('paused'),
         default: false,
-        description: '勾选后不自动运行，要手动「恢复」；只对周期任务（cron、固定间隔）有效',
+        description: t('pausedDescription'),
     },
 });
 /** 单个会话最多几个计划任务（防资源耗尽）；编辑已有任务不计入 */
@@ -122,10 +138,15 @@ const uses = {
     tools,
     // 共享 cron tick 与表达式校验
     cronEngine,
-    /** 动态任务的持久化出口；没有 storage 时任务只活在本次激活里（读写各自降级） */
-    storage: optional(storage),
+    /**
+     * 动态任务的持久化出口：激活时读回整表、增删改整表写回。required：读回要在它上线之后（optional 不参与激活先后），
+     * 它下线时随之停下、重新上线后重新读回
+     */
+    storage,
     /** 计划任务页的登记口；无 WebUI 时调度照常运行 */
     webui: optional(webuiServer),
+    /** 认调用所在的会话是不是子会话（在子会话里建任务要写明目标）；没有会话管理就没有子会话 */
+    sessionManager: optional(sessionManager),
     events,
     lifecycle,
     logger,
@@ -134,7 +155,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'],
@@ -146,7 +167,7 @@ export default definePlugin({
 });
 async function run(caps) {
     const cfg = parseConfig(configSchema, caps.config.use, caps.logger.use);
-    const { cronEngine, storage, webui, events, lifecycle, logger, provide, tools } = caps;
+    const { cronEngine, storage, webui, sessionManager, events, lifecycle, logger, provide, tools } = caps;
     const config = resolveConfig(cfg);
     const runtimes = new Map();
     // 配置中定义的任务名称集合（不需要持久化）
@@ -154,16 +175,26 @@ async function run(caps) {
     // 动态任务集合（需要持久化）
     const dynamicJobs = new Map();
     // ── 持久化读写 （经 storage 抽象，默认 data:/scheduler-jobs.json） ──
+    // 文件形状：{ jobs: [动态任务], onceFired: { <配置里一次性任务的名字>: <执行过的那次 runAt 原文> } }
     const persistUri = config.persistPath;
     /**
-     * 激活时那次读失败了、又不是「文件不存在」（storage 不在场、读错误、解析失败、结构不对）：写的是整表，
-     * 此后一律拒写，否则下一次增删改就把原有动态任务冲掉。只在激活时读一次，storage 迟到也不重读。
+     * 激活时那次读失败了、又不是「文件不存在」（读错误、解析失败、结构不对）：写的是整份，
+     * 此后一律拒写，否则下一次增删改就把原有动态任务与执行记录冲掉；配置里的一次性任务执行过没有也无从判断，
+     * 本次运行不安排。只在激活时读一次。
      */
     let loadFailed = false;
-    /** 拒写期间新建或改动的任务只在内存、重启即失：回执末尾如实注明（AI 工具与计划任务页同一附注），文件正常时为空串 */
-    const persistNote = () => loadFailed ? `；仅本次运行生效，未写入 ${persistUri}：它读不出来，处理办法见「需要处理」里的提示` : '';
+    /**
+     * 拒写期间新建或改动的任务只在内存、重启即失：回执末尾如实注明（AI 工具与计划任务页同一附注，工具取原文），
+     * 文件正常时没有
+     */
+    const persistNote = () => (loadFailed ? t('notPersisted', { uri: persistUri }) : undefined);
     // 先读完持久化任务再登记页面：登记之后到服务就绪之间不再有等待，页面一出现取数与动作就可用
     const persisted = await loadDynamicJobs();
+    /**
+     * 配置里一次性任务的执行记录：任务名 → 执行过的那次 runAt 原文。到点先记下再执行，记过的之后激活不再执行；
+     * 配置里改了 runAt 与记录对不上，算新的一次
+     */
+    const onceFired = persisted.onceFired;
     // ── 计划任务页：动作是本次激活的闭包，直接操作本插件自己的调度表；登记随激活撤回 ──
     /**
      * 新建与编辑共用：调度方式恰好一个（四者是互不相容的定时语义，多填时取哪个都是猜），与 scheduler_create_job
@@ -176,28 +207,25 @@ async function run(caps) {
         const rawRunAt = input.runAt?.trim() || undefined;
         const provided = [cron, interval, delaySeconds, rawRunAt].filter(v => v !== undefined).length;
         if (provided === 0)
-            throw new Error('cron、固定间隔、一次性运行时间、X 秒后执行必须填写其中之一');
+            throw new TextError(t('scheduleMissing'));
         if (provided > 1)
-            throw new Error('cron、固定间隔、一次性运行时间、X 秒后执行互斥，只能填一个');
+            throw new TextError(t('scheduleConflict'));
         const runAt = delaySeconds !== undefined ? new Date(Date.now() + delaySeconds * 1000).toISOString() : rawRunAt;
         // 一次性任务被暂停时到点的定时器直接跳过，之后既不重排也不自删，任务就永久卡死在那里
         if (input.paused && runAt)
-            throw new Error('暂停对一次性任务（一次性运行时间、X 秒后执行）没有可用语义');
-        // 防误填高频任务：挡住 interval:0.5 这类会占满调度的间隔
-        if (interval !== undefined && interval < 5)
-            throw new Error('固定间隔不能小于 5 秒（防高频任务耗尽资源）');
+            throw new TextError(t('pauseOneShot'));
         const sessionId = input.sessionId.trim();
         if (!sessionId)
-            throw new Error('目标会话 ID 不能为空');
+            throw new TextError(t('sessionIdEmpty'));
         const content = input.content.trim();
         if (!content)
-            throw new Error('消息内容不能为空');
+            throw new TextError(t('contentEmpty'));
         if (creating) {
             const all = service.getJobs();
             if (all.some(j => j.name === name))
-                throw new Error(`已有同名任务 ${name}，改它用「编辑」`);
+                throw new TextError(t('duplicateName', { name }));
             if (all.filter(j => j.sessionId === sessionId).length >= MAX_JOBS_PER_SESSION) {
-                throw new Error(`本会话定时任务数已达上限 ${MAX_JOBS_PER_SESSION}，请先删除部分任务再新建`);
+                throw new TextError(t('tooManyJobs', { max: MAX_JOBS_PER_SESSION }));
             }
         }
         service.setJob({
@@ -213,81 +241,82 @@ async function run(caps) {
             enabled: input.enabled,
             paused: input.paused,
         });
-        return `已保存任务 ${name}${persistNote()}`;
+        const note = persistNote();
+        return note ? textClauses([t('jobSaved', { name }), note]) : t('jobSaved', { name });
     }
     const jobsPage = webui.use.definePage({
         key: 'scheduler',
-        title: '计划任务',
+        title: t('pageTitle'),
         icon: 'clock',
         actions: {
             createJob: {
-                label: '新建',
+                label: t('create'),
                 effect: 'write',
                 input: {
-                    name: { type: 'string', label: '名称', required: true, description: '任务的唯一标识' },
+                    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 Error('名称不能为空');
+                        throw new TextError(t('nameEmpty'));
                     return saveJob(name, input, ctx.caller, true);
                 },
             },
             editJob: {
-                label: '编辑',
+                label: t('edit'),
                 effect: 'write',
                 row: true,
                 input: JOB_FIELDS,
                 handler({ rowKey, input, ctx }) {
                     if (!service.getJobs().some(j => j.name === rowKey))
-                        throw new Error(`任务 ${rowKey} 不存在`);
+                        throw new TextError(t('jobMissing', { name: rowKey }));
                     return saveJob(rowKey, input, ctx.caller, false);
                 },
             },
             triggerJob: {
-                label: '立即执行',
+                label: t('triggerNow'),
                 effect: 'write',
                 row: true,
                 async handler({ rowKey }) {
                     // 这一轮还没执行完时 triggerJob 直接跳过；与它置 running 在同一个同步段里判，没有竞态
                     if (service.getJobs().find(j => j.name === rowKey)?.running) {
-                        throw new Error(`任务 ${rowKey} 正在执行，这次没有再触发`);
+                        throw new TextError(t('jobRunning', { name: rowKey }));
                     }
                     if (!(await service.triggerJob(rowKey)))
-                        throw new Error(`任务 ${rowKey} 不存在`);
-                    return `已执行 ${rowKey}`;
+                        throw new TextError(t('jobMissing', { name: rowKey }));
+                    return t('triggered', { name: rowKey });
                 },
             },
             pauseJob: {
-                label: '暂停',
+                label: t('pause'),
                 effect: 'write',
                 row: true,
                 handler({ rowKey }) {
                     if (!service.pauseJob(rowKey))
-                        throw new Error('任务不存在，或是一次性任务（不能暂停，只能删除重建）');
-                    return `已暂停 ${rowKey}`;
+                        throw new TextError(t('cannotPause'));
+                    return t('pausedReceipt', { name: rowKey });
                 },
             },
             resumeJob: {
-                label: '恢复',
+                label: t('resume'),
                 effect: 'write',
                 row: true,
                 handler({ rowKey }) {
                     if (!service.resumeJob(rowKey))
-                        throw new Error(`任务 ${rowKey} 不存在`);
-                    return `已恢复 ${rowKey}`;
+                        throw new TextError(t('jobMissing', { name: rowKey }));
+                    return t('resumed', { name: rowKey });
                 },
             },
             removeJob: {
-                label: '删除',
+                label: t('delete'),
                 effect: 'destructive',
-                confirm: '删除这个计划任务？',
+                confirm: t('deleteConfirm'),
                 row: true,
                 handler({ rowKey }) {
                     if (!service.removeJob(rowKey))
-                        throw new Error(`任务 ${rowKey} 不存在`);
-                    return `已删除 ${rowKey}`;
+                        throw new TextError(t('jobMissing', { name: rowKey }));
+                    return t('deleted', { name: rowKey });
                 },
             },
         },
@@ -296,16 +325,16 @@ async function run(caps) {
                 type: 'table',
                 id: 'jobs',
                 rowKey: 'name',
-                empty: '还没有计划任务',
+                empty: t('noJobs'),
                 columns: [
-                    { key: 'name', label: '名称', primary: true },
-                    { key: 'schedule', label: '调度' },
-                    { key: 'sessionId', label: '目标会话' },
-                    { key: 'status', label: '状态', kind: 'status', primary: true },
-                    { key: 'nextRun', label: '下次执行', kind: 'countdown' },
-                    { key: 'lastRun', label: '上次执行', kind: 'time' },
-                    { key: 'runCount', label: '执行次数' },
-                    { key: 'lastResult', label: '最近结果', kind: 'long-text' },
+                    { 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' },
@@ -326,14 +355,19 @@ async function run(caps) {
                         content: j.content,
                         enabled: j.enabled,
                         paused: j.paused,
-                        schedule: j.cron ?? (j.interval ? `每 ${j.interval} 秒` : j.runAt ? `一次性 ${j.runAt}` : '未设置'),
+                        schedule: j.cron ??
+                            (j.interval
+                                ? t('everySeconds', { seconds: j.interval })
+                                : j.runAt
+                                    ? t('oneShot', { at: j.runAt })
+                                    : t('unset')),
                         status: !j.enabled
-                            ? { text: '禁用', state: 'inactive' }
+                            ? { text: t('statusDisabled'), state: 'inactive' }
                             : j.paused
-                                ? { text: '暂停', state: 'inactive' }
+                                ? { text: t('paused'), state: 'inactive' }
                                 : j.running
-                                    ? { text: '执行中', state: 'running' }
-                                    : { text: '就绪' },
+                                    ? { text: t('statusRunning'), state: 'running' }
+                                    : { text: t('statusReady') },
                         nextRun: ready && j.nextRun > 0 ? j.nextRun : undefined,
                         lastRun: j.lastRun || undefined,
                         runCount: j.runCount,
@@ -347,7 +381,7 @@ async function run(caps) {
         ],
     });
     async function loadDynamicJobs() {
-        /** 失败出在读文件这一步（存储插件不在、persistPath 的根名写错、文件读不了），文件内容未必有错 */
+        /** 失败出在读文件这一步（persistPath 的根名写错、文件读不了），文件内容未必有错 */
         let reading = true;
         try {
             let raw;
@@ -357,16 +391,21 @@ async function run(caps) {
             catch (err) {
                 // 只有「文件不存在」算全新；「未知存储根」等其它失败不能当成空表
                 if (isStorageNotFound(err))
-                    return [];
+                    return { jobs: [], onceFired: new Map() };
                 throw err;
             }
             reading = false;
             const data = JSON.parse(raw);
-            if (!Array.isArray(data)) {
-                throw new Error(`持久化任务文件不是数组（得到 ${data === null ? 'null' : typeof data}）`);
+            // 执行记录有一条不是运行时间也算读不懂：当成没有记录就会把执行过的一次性任务再执行一次
+            if (!isRecord(data) ||
+                !Array.isArray(data.jobs) ||
+                !isRecord(data.onceFired) ||
+                !Object.values(data.onceFired).every(at => typeof at === 'string')) {
+                throw new TextError(t('badShape'));
             }
+            const onceFired = new Map(Object.entries(data.onceFired));
             // biome-ignore lint/suspicious/noExplicitAny: 从 JSON 文件反序列化的原始字段，手动校验转型
-            return data.map((j) => {
+            const jobs = data.jobs.map((j) => {
                 const hasActor = typeof j.actorPlatform === 'string' &&
                     j.actorPlatform.trim().length > 0 &&
                     typeof j.actorUserId === 'string' &&
@@ -392,6 +431,7 @@ async function run(caps) {
                     paused: j.paused === true,
                 };
             });
+            return { jobs, onceFired };
         }
         catch (err) {
             loadFailed = true;
@@ -400,13 +440,10 @@ async function run(caps) {
             webui.use.notify({
                 id: 'jobs-load',
                 level: 'error',
-                title: `计划任务文件 ${persistUri} 读不出来，里面的任务没有加载`,
-                detail: (reading
-                    ? '确认本地存储插件在运行、配置项 persistPath 的根名写对、这个文件能读取，然后重载本插件。'
-                    : '修好这个文件后重载本插件：内容要是任务数组；不要里面的任务就把它移走再重载。') +
-                    `修好之前新建与改动的任务只在本次运行生效。原因：${err instanceof Error ? err.message : String(err)}`,
+                title: t('loadFailedTitle', { uri: persistUri }),
+                detail: t(reading ? 'loadFailedReading' : 'loadFailedContent', { error: textOf(err) }),
             });
-            return [];
+            return { jobs: [], onceFired: new Map() };
         }
     }
     /**
@@ -422,7 +459,7 @@ async function run(caps) {
             return;
         }
         const jobs = [...dynamicJobs.values()];
-        const payload = JSON.stringify(jobs, null, 2);
+        const payload = JSON.stringify({ jobs, onceFired: Object.fromEntries(onceFired) }, null, 2);
         saveChain = saveChain
             .then(() => storage.use.writeFile(persistUri, payload))
             .then(() => {
@@ -455,11 +492,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 走**创建者**的权限等级。
@@ -475,12 +514,12 @@ async function run(caps) {
             await events.use.emit('inbound:message', message);
             rt.lastRun = Date.now();
             rt.runCount++;
-            rt.lastResult = '成功';
+            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}`;
+            rt.lastResult = t('jobFailed', { error: textOf(err) });
             logger.use.error(`任务 "${jobName}" 执行失败: ${msg}`);
             await events.use.emit('scheduler:job:error', jobName, msg);
         }
@@ -496,7 +535,8 @@ 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;
@@ -512,12 +552,23 @@ async function run(caps) {
         return 0;
     }
     // ── 初始化所有任务 ──
-    /** cron 订阅不上、永远不会运行的任务各一条提示：任务重排或删掉时撤回 */
+    /** 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;
@@ -550,14 +601,21 @@ 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) {
@@ -573,48 +631,27 @@ async function run(caps) {
             catch (err) {
                 const reason = err instanceof Error ? err.message : String(err);
                 logger.use.warn(`任务 ${jobCfg.name} cron 订阅失败: ${reason}`);
-                const fromConfig = configJobNames.has(jobCfg.name);
-                unscheduled.set(jobCfg.name, webui.use.notify({
-                    id: `unscheduled:${jobCfg.name}`,
-                    level: 'error',
-                    title: `计划任务「${jobCfg.name}」没有排上，不会运行`,
-                    detail: fromConfig
-                        ? `在配置文件里改正这个任务的 cron 或 timeZone，保存后生效。原因：${reason}`
-                        : `在计划任务页编辑这个任务，改正它的 cron 后保存。原因：${reason}`,
-                    open: fromConfig ? 'config' : { page: 'scheduler' },
-                }));
+                markUnscheduled(jobCfg.name, textOf(err));
             }
         }
-        // 一次性任务：到点用 setTimeout 触发一次，执行完 disable 并持久化
+        // 一次性任务：到点用 setTimeout 执行一次（见 fireOneShot）；配置里执行过的停用后载入，不到这里
         if (jobCfg.runAt && jobCfg.enabled) {
             const targetMs = Date.parse(jobCfg.runAt);
             if (Number.isFinite(targetMs)) {
-                const delay = targetMs - Date.now();
-                if (delay <= 0) {
-                    // 已过期：立即执行一次，然后 disable（与下面未到点分支同一判据，暂停态不执行）
-                    setImmediate(() => {
-                        if (!rt.paused) {
-                            executeJob(rt).finally(() => disableOneShot(rt));
+                // 远期 runAt 分段重排：delay 超过 2^31-1ms 会溢出成立即触发。每段最多排到上限，段末未到点就续排下一段，到点才执行。
+                // 已过期的（含停机时错过的）排 0ms，下一轮定时器就执行：与未到点的同记在 rt.timer，清理段一并撤掉，激活后紧接着
+                // 重载时不会在拆卸之后的旧实例上再执行一次
+                const arm = (wait) => {
+                    rt.timer = setTimeout(() => {
+                        const remain = targetMs - Date.now();
+                        if (remain > 0) {
+                            arm(Math.min(remain, MAX_TIMEOUT_MS));
+                            return;
                         }
-                    });
-                }
-                else {
-                    // 远期 runAt 分段重排：delay 超过 2^31-1ms 会溢出成立即触发。每段最多排到上限，
-                    // 段末未到点就续排下一段，到点才执行
-                    const arm = (wait) => {
-                        rt.timer = setTimeout(() => {
-                            const remain = targetMs - Date.now();
-                            if (remain > 0) {
-                                arm(Math.min(remain, MAX_TIMEOUT_MS));
-                                return;
-                            }
-                            if (!rt.paused) {
-                                executeJob(rt).finally(() => disableOneShot(rt));
-                            }
-                        }, wait);
-                    };
-                    arm(Math.min(delay, MAX_TIMEOUT_MS));
-                }
+                        fireOneShot(rt);
+                    }, wait);
+                };
+                arm(Math.max(0, Math.min(targetMs - Date.now(), MAX_TIMEOUT_MS)));
             }
             else {
                 logger.use.warn(`任务 ${jobCfg.name} 的 runAt 无法解析: ${jobCfg.runAt}`);
@@ -631,17 +668,34 @@ async function run(caps) {
                     : '(no schedule)';
         logger.use.info(`任务已注册: ${jobCfg.name} ${scheduleHint}`);
     }
-    /** 一次性任务执行完后的清理：动态任务直接删除；静态 yaml 任务仅标记 enabled=false */
+    /**
+     * 一次性任务到点（过期分支与未到点分支同一判据，暂停态不执行）：先记下、排进写盘，再执行——配置里的记下「任务名 + runAt」，
+     * 动态的从持久化任务里删掉。执行要等投递、可能很久，途中重载本插件或停机，拆卸等这次写盘落定，之后激活不再执行
+     */
+    function fireOneShot(rt) {
+        if (rt.paused)
+            return;
+        const { name, runAt } = rt.config;
+        if (!configJobNames.has(name))
+            dynamicJobs.delete(name);
+        else if (runAt)
+            onceFired.set(name, runAt);
+        saveDynamicJobs();
+        executeJob(rt).finally(() => disableOneShot(rt));
+    }
+    /**
+     * 一次性任务执行完：动态任务执行前已删掉并落盘，这里只撤调度表里的这一条（执行途中同名重建的那条不动），不再写盘；
+     * 静态 yaml 任务仅标记 enabled=false
+     */
     function disableOneShot(rt) {
         const jobName = rt.config.name;
-        if (dynamicJobs.has(jobName)) {
+        if (!configJobNames.has(jobName)) {
             if (rt.timer)
                 clearTimeout(rt.timer);
             if (rt.cronDispose)
                 rt.cronDispose();
-            runtimes.delete(jobName);
-            dynamicJobs.delete(jobName);
-            saveDynamicJobs();
+            if (runtimes.get(jobName) === rt)
+                runtimes.delete(jobName);
             jobsPage.invalidate();
             logger.use.info(`一次性任务已执行完毕并删除: ${jobName}`);
             return;
@@ -652,39 +706,81 @@ async function run(caps) {
         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.use.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 resolved = p && u ? job : { ...job, actorPlatform: 'webui', actorUserId: 'console' };
+        // 一次性任务按「任务名 + runAt」认：记录对得上的执行过了，与本次运行里执行完的一样停用；记录读不出时无从判断执行过没有，
+        // 本次运行不安排。改了 runAt 的对不上记录，算新的一次
+        const settled = !!job.runAt && job.enabled && (loadFailed || onceFired.get(job.name) === job.runAt);
+        if (settled && loadFailed) {
+            logger.use.warn(`一次性任务 "${job.name}" 执行过没有无从判断（持久化文件读不出），本次运行不安排`);
+        }
+        else if (settled) {
+            logger.use.info(`一次性任务 "${job.name}"（runAt: ${job.runAt}）已执行过，不再执行`);
+        }
+        initJob(settled ? { ...resolved, enabled: false } : resolved);
     }
-    // 持久化的动态任务（同名的配置文件任务优先）
-    for (const job of persisted) {
-        if (!runtimes.has(job.name)) {
+    // 持久化的动态任务：配置文件里写了的名字归配置文件，那一条没载入也不让同名的动态任务顶上来；
+    // 文件里重名的只认第一条
+    for (const job of persisted.jobs) {
+        if (!configJobNames.has(job.name) && !runtimes.has(job.name)) {
             dynamicJobs.set(job.name, job);
             initJob(job);
         }
     }
-    if (persisted.length > 0) {
-        logger.use.info(`已加载 ${persisted.length} 个持久化任务`);
+    if (persisted.jobs.length > 0) {
+        logger.use.info(`已加载 ${persisted.jobs.length} 个持久化任务`);
     }
     // ── 注册 scheduler 服务 ──
-    /** 无效的 cron 当场拒收：收下了也订阅不上、永远不会运行，还会落进持久化文件。页面、工具与别的插件都经服务新建与修改 */
-    function rejectInvalidCron(job) {
-        if (!job.cron)
-            return;
-        const checked = cronEngine.use.validate(job.cron);
-        if (!checked.ok)
-            throw new Error(checked.reason);
+    /**
+     * 配置文件里写了的名字归配置文件（那一条没载入也一样）：页面、工具与别的插件经服务新建与修改时都不能用它，免得顶替它、
+     * 撤掉它的错误提示，又因名字在配置里不落盘、重启就没了
+     */
+    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);
+        }
+    }
+    /**
+     * 清理段开始之后置位，新建与修改一律拒收：拿着旧服务对象的调用方此时再交来任务，会在本实例上挂清理不再撤的定时器与
+     * cron 订阅、照常触发，还按本实例的内存整表写盘，盖掉新实例的文件。删除、暂停与恢复不用拦：清理段清空了调度表，
+     * 它们找不到任务，不写盘
+     */
+    let disposed = false;
     const service = {
         getJobs() {
             return [...runtimes.values()].map(rt => ({
@@ -746,20 +842,20 @@ async function run(caps) {
             return true;
         },
         addJob(job) {
-            rejectInvalidCron(job);
+            if (disposed)
+                throw new TextError(t('disposed', { name: job.name }));
+            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 覆盖`);
-            }
-            rejectInvalidCron(job);
+            // upsert：先 remove 再 add
+            if (disposed)
+                throw new TextError(t('disposed', { name: job.name }));
+            rejectConfigName(job.name);
+            rejectInvalidSchedule(job);
             const existed = runtimes.get(job.name);
             if (existed) {
                 if (existed.timer)
@@ -795,7 +891,8 @@ async function run(caps) {
     // ── 注册 AI 工具：让 Agent 可以自主创建/管理任务 ──
     tools.use.registerGroup({
         name: 'scheduler',
-        label: '定时任务',
+        label: t('displayName'),
+        summary: t('groupSummary'),
         description: '创建、查看和取消定时/周期性自主行动计划',
     });
     tools.use.register({
@@ -830,7 +927,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: '届时发送给自己的指令/提示内容' },
                     },
@@ -839,9 +939,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;
@@ -860,19 +960,30 @@ 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（本回合本就在代人执行，如子任务链、workflow 或定时任务驱动的回合），否则用物理身份；
-                // 两者皆空则子任务匿名（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,
             };
@@ -891,9 +1002,10 @@ 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)}` : ''}`,
             });
         },
     });
@@ -919,8 +1031,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,
@@ -982,7 +1094,7 @@ 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 ? '已删除' : '任务不存在' });
@@ -1006,7 +1118,7 @@ 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 ? '已暂停' : '任务不存在，或是一次性任务（不能暂停，只能删除重建）' });
@@ -1030,14 +1142,15 @@ 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.use.onDispose(() => {
+    lifecycle.use.onDispose(async () => {
+        disposed = true;
         for (const rt of runtimes.values()) {
             if (rt.timer)
                 clearInterval(rt.timer);
@@ -1045,10 +1158,13 @@ async function run(caps) {
                 rt.cronDispose();
         }
         runtimes.clear();
+        // 等排队中的写盘落定再结束拆卸：否则重启时新实例读到的文件还没有这次改动，app.stop() 返回后也仍有写在飞
+        await saveChain;
     });
     logger.use.info(`计划任务调度器已启动 (${config.jobs.length} 个任务)`);
 }
 // ──────────── 辅助函数 ────────────
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
 export function resolveConfig(cfg) {
     return {
         jobs: cfg.jobs.map(j => ({
@@ -1065,7 +1181,7 @@ function resolvePersistPath(input) {
     if (!s)
         return configSchema.persistPath.default;
     if (!isStorageUri(s)) {
-        throw configError(`persistPath="${s}" 不是 storage URI，请写成 <根名>:/<路径>（如 data:/scheduler-jobs.json），或删掉该键使用默认值`);
+        throw configError(t('badPersistPath', { value: s }));
     }
     return s;
 }