@zhin.js/plugin-reminder 1.0.4 → 1.0.6

package/src/admin-i18n.ts

@@ -0,0 +1,154 @@
+import { createMessages, type Locale } from 'zhin.js/i18n';
+import { PluginTaskError } from 'zhin.js/plugin-runtime';
+
+const catalog = {
+  "invalidTarget": {
+    "zh-CN": "请提供完整有效的目标账号、会话、父容器和线程",
+    "en": "Provide a complete valid account, conversation, parent container and thread."
+  },
+  "requestReused": {
+    "zh-CN": "同一请求 ID 已用于其他内容",
+    "en": "This request ID was already used for different content."
+  },
+  "invalidAction": {
+    "zh-CN": "任务 ID 或操作无效",
+    "en": "Invalid task ID or action."
+  },
+  "updateParameters": {
+    "zh-CN": "仅编辑操作接受参数",
+    "en": "Only the update action accepts parameters."
+  },
+  "finished": {
+    "zh-CN": "任务已结束，不能再次取消",
+    "en": "This task has ended and cannot be cancelled again."
+  },
+  "invalidMutation": {
+    "zh-CN": "操作须包含 UUID requestId 和读取到的 expectedRevision",
+    "en": "The operation requires a UUID requestId and the expectedRevision read from the task list."
+  },
+  "replayConflict": {
+    "zh-CN": "同一操作请求 ID 已用于其他内容，禁止重放",
+    "en": "This operation request ID was used for different content and cannot be replayed."
+  },
+  "delivering": {
+    "zh-CN": "投递中或未确认；不会自动重试",
+    "en": "Delivery is in progress or unconfirmed; no automatic retry."
+  },
+  "quota": {
+    "zh-CN": "管理员提醒池已达上限，请先取消任务；聊天个人提醒使用独立配额",
+    "en": "The administrator reminder quota is full. Cancel a task first; chat reminders have a separate quota."
+  },
+  "notFound": {
+    "zh-CN": "未找到当前实例的管理员任务；聊天任务不在此入口管理",
+    "en": "No administrator task was found in this instance. Chat tasks are managed separately."
+  },
+  "pauseState": {
+    "zh-CN": "仅待执行任务可以暂停；未确认投递不能暂停或恢复",
+    "en": "Only scheduled tasks can be paused. Unconfirmed deliveries cannot be paused or resumed."
+  },
+  "resumeState": {
+    "zh-CN": "仅已暂停任务可以恢复；未确认投递不能恢复或重试",
+    "en": "Only paused tasks can be resumed. Unconfirmed deliveries cannot be resumed or retried."
+  },
+  "expired": {
+    "zh-CN": "一次性任务时间已过，请先编辑为未来时间再恢复",
+    "en": "This one-time reminder is past due. Set a future time before resuming."
+  },
+  "updateState": {
+    "zh-CN": "编辑前请先暂停任务；未确认投递不能编辑",
+    "en": "Pause the task before editing. Unconfirmed deliveries cannot be edited."
+  },
+  "stopped": {
+    "zh-CN": "管理员提醒服务属于已停止的插件实例",
+    "en": "This administrator reminder service belongs to a stopped plugin instance."
+  },
+  "retired": {
+    "zh-CN": "管理员提醒服务属于未发布或已退役的 generation",
+    "en": "This administrator reminder service belongs to an unpublished or retired generation."
+  },
+  "invalidParameters": {
+    "zh-CN": "参数须包含 1–500 字提醒内容、带 offset 的 ISO 时间及可选的 60 秒至一年整数周期",
+    "en": "Provide 1–500 characters of reminder text, an ISO time with an explicit offset, and optionally an integer interval from 60 seconds to one year."
+  },
+  "invalidInstant": {
+    "zh-CN": "提醒时间须为有效且带 Z 或 ±hh:mm 的 ISO 时间",
+    "en": "Use a valid ISO reminder time with Z or an explicit ±hh:mm offset."
+  },
+  "future": {
+    "zh-CN": "提醒时间须在未来一年内",
+    "en": "The reminder must be scheduled within the next year."
+  },
+  "revision": {
+    "zh-CN": "任务列表已变化，请刷新后重新确认操作",
+    "en": "The task list changed. Refresh it and confirm the operation again."
+  },
+  "capacity": {
+    "zh-CN": "管理员提醒池状态达到 32 条或 60 KiB 上限，请先取消并整理任务",
+    "en": "Administrator reminders reached the 32-task or 60 KiB limit. Cancel and clean up tasks first."
+  },
+  "corrupt": {
+    "zh-CN": "管理员提醒持久状态格式无效，已停止投递",
+    "en": "Administrator reminder storage is invalid. Delivery has stopped."
+  },
+  "waiting": {
+    "zh-CN": "等待执行",
+    "en": "Waiting to run"
+  },
+  "paused": {
+    "zh-CN": "管理员暂停",
+    "en": "Paused by an administrator"
+  },
+  "resumedSkipping": {
+    "zh-CN": "已恢复，并跳过错过的周期轮次",
+    "en": "Resumed; missed intervals were skipped"
+  },
+  "resumed": {
+    "zh-CN": "管理员恢复",
+    "en": "Resumed by an administrator"
+  },
+  "edited": {
+    "zh-CN": "已编辑，保持暂停；请确认后恢复",
+    "en": "Updated and still paused. Confirm before resuming."
+  },
+  "cancelled": {
+    "zh-CN": "管理员取消；已经开始的投递无法撤回",
+    "en": "Cancelled by an administrator. A delivery already in progress cannot be recalled."
+  },
+  "skipped": {
+    "zh-CN": "已跳过错过的周期轮次",
+    "en": "Missed intervals were skipped"
+  },
+  "unknown": {
+    "zh-CN": "平台未确认投递，请核实目标会话后取消并另建任务；不会自动重试",
+    "en": "The platform did not confirm delivery. Check the target conversation, then cancel and create another task; no automatic retry."
+  },
+  "delivered": {
+    "zh-CN": "已确认投递",
+    "en": "Delivery confirmed"
+  },
+  "rejected": {
+    "zh-CN": "平台明确未投递或拒绝；任务已停止",
+    "en": "The platform confirmed no delivery or rejected it. The task has stopped."
+  },
+  "stateNote": {
+    "zh-CN": "{detail}；状态仅表示调度事实，不代表平台连接或投递健康",
+    "en": "{detail}; state records scheduling facts, not platform connection or delivery health."
+  }
+} as const;
+export const adminText = createMessages(catalog);
+export type AdminTextKey = keyof typeof catalog;
+export function isAdminTextKey(value: unknown): value is AdminTextKey { return typeof value === 'string' && Object.hasOwn(catalog, value); }
+
+/** Persist a stable presentation key; preserve legacy text for older readers. */
+export function taskDetail(detailKey: AdminTextKey) { return { detailKey, detail: adminText('zh-CN', detailKey) }; }
+export function formatTaskDetail(task: { detail: string; detailKey?: AdminTextKey }, locale?: Locale): string {
+  return task.detailKey ? adminText(locale, task.detailKey) : task.detail;
+}
+
+export class LocalizedTaskError extends PluginTaskError {
+  readonly messageKey: AdminTextKey;
+  constructor(code: ConstructorParameters<typeof PluginTaskError>[0], messageKey: AdminTextKey) {
+    super(code, adminText('zh-CN', messageKey)); this.messageKey = messageKey;
+  }
+  localize(locale?: Locale): PluginTaskError { return new PluginTaskError(this.code, adminText(locale, this.messageKey)); }
+}

package/src/admin-tasks.ts

@@ -1,3 +1,6 @@
+import { adminText, taskDetail, formatTaskDetail, isAdminTextKey, LocalizedTaskError, type AdminTextKey } from './admin-i18n.js';
+import { resolveLocale, type Locale } from 'zhin.js/i18n';
+import { reminderMessages as t } from './i18n.js';
 import { createHash, randomUUID } from 'node:crypto';
 import { createDeliveryTarget, type DeliveryTarget, type OutboundHost, type PluginStateStore } from 'zhin.js';
 import { PluginTaskError, createGenerationAdmissionGate, generationAdmissionSource, type JsonValue, type PluginTask, type PluginTaskAction, type PluginTaskMutation,
@@ -9,9 +12,9 @@ import { MAX_DELAY_SECONDS, nextPeriodicTime, parseReminderInstant } from './tim
 export const ADMIN_REMINDER_STATE_KEY = 'admin-reminders/v1';
 type AdminTask = {
   readonly id: string; readonly creation: string; readonly target: DeliveryTarget; readonly text: string;
-  readonly createdAt: number; readonly nextRunAt: number; readonly intervalMs: number | null;
+  readonly locale?: Locale; readonly createdAt: number; readonly nextRunAt: number; readonly intervalMs: number | null;
   readonly state: Exclude<PluginTask['state'], 'running'>; readonly claimId: string | null;
-  readonly lastRunAt: number | null; readonly detail: string;
+  readonly lastRunAt: number | null; readonly detail: string; readonly detailKey?: AdminTextKey;
 };
 type MutationReceipt = { readonly id: string; readonly fingerprint: string; readonly taskId: string; readonly operation: 'create' | PluginTaskAction };
 export type AdminReminderBook = { readonly version: 1; readonly revision: string;
@@ -22,60 +25,79 @@ const uuidPattern = /^[\da-f]{8}-(?:[\da-f]{4}-){3}[\da-f]{12}$/iu;
 
 /** A separate administrator state pool; no sender identity and no access to chat reminders. */
 export class AdministratorReminderTasks implements PluginTaskProvider {
+  readonly i18n = {
+  "en": {
+    "title": "Administrator reminders",
+    "description": "Send one-time or recurring reminders to an exact account, conversation and thread, independently of personal chat reminders.",
+    "effects": [
+      "Creating a task schedules delivery through this plugin instance. Pausing or cancelling cannot recall a delivery already in progress.",
+      "Unconfirmed delivery is never retried or resumed automatically. Check the target conversation before cancelling and creating another task."
+    ]
+  }
+} as const;
   readonly title = '管理员提醒';
   readonly description = '独立于聊天个人提醒，向指定账号、会话及线程发送一次性或固定周期提醒';
   readonly effects = ['创建后将在指定时间通过当前插件实例向目标会话发送提醒；暂停或取消不能撤回已开始的投递', '未确认的投递不会自动重试或恢复，需核实目标会话后取消并另建任务'];
   readonly schema = { type: 'object', additionalProperties: false, required: ['text', 'at'], properties: {
-    text: { type: 'string', minLength: 1, maxLength: 500, title: '提醒内容' },
-    at: { type: 'string', format: 'date-time', title: '首次执行时间', description: '未来一年内、显式包含 Z 或 ±hh:mm 的 ISO 时间' },
-    intervalSeconds: { type: 'integer', minimum: 60, maximum: MAX_DELAY_SECONDS, title: '周期秒数（可选）' },
+    text: { type: 'string', minLength: 1, maxLength: 500, 'x-i18n': {"en": {"title": "Reminder text"}}, title: '提醒内容' },
+    at: { type: 'string', format: 'date-time', 'x-i18n': {"en": {"title": "First run time", "description": "ISO time within the next year, with Z or an explicit ±hh:mm offset"}}, title: '首次执行时间', description: '未来一年内、显式包含 Z 或 ±hh:mm 的 ISO 时间' },
+    intervalSeconds: { type: 'integer', minimum: 60, maximum: MAX_DELAY_SECONDS, 'x-i18n': {"en": {"title": "Interval in seconds (optional)"}}, title: '周期秒数（可选）' },
   } } as const;
   #stopped = false;
   readonly #admission = createGenerationAdmissionGate();
   get [generationAdmissionSource]() { return [this.#admission]; }
-  constructor(private readonly state: PluginStateStore, private readonly outbound: OutboundHost, private readonly config: ReminderConfig) {}
+  private readonly state: PluginStateStore;
+  private readonly outbound: OutboundHost;
+  private readonly config: ReminderConfig;
+  private readonly projectLocale: Locale;
+  constructor(state: PluginStateStore, outbound: OutboundHost, config: ReminderConfig, projectLocale: Locale = 'zh-CN') {
+    this.state = state;
+    this.outbound = outbound;
+    this.config = config;
+    this.projectLocale = projectLocale;
+  }
   stop(): void { this.#stopped = true; }
 
-  async read(): Promise<PluginTaskSnapshot> {
-    return this.#admit(async () => this.#snapshot(readBook(await this.state.get<AdminReminderBook>(ADMIN_REMINDER_STATE_KEY))));
+  async read(options?: { readonly locale?: Locale }): Promise<PluginTaskSnapshot> {
+    return this.#admit(async () => this.#snapshot(readBook(await this.state.get<AdminReminderBook>(ADMIN_REMINDER_STATE_KEY)), options?.locale), options?.locale);
   }
 
   async create(input: PluginTaskMutation & Readonly<{ target: DeliveryTarget; parameters: Readonly<Record<string, JsonValue>> }>): Promise<PluginTaskSnapshot> {
-    return this.#admit(() => this.#create(input));
+    return this.#admit(() => this.#create(input), input.locale);
   }
   async #create(input: PluginTaskMutation & Readonly<{ target: DeliveryTarget; parameters: Readonly<Record<string, JsonValue>> }>): Promise<PluginTaskSnapshot> {
     this.#assertLive(); assertMutation(input);
     let target: DeliveryTarget;
-    try { target = createDeliveryTarget({ conversation: input.target }); } catch { throw invalid('请提供完整有效的目标账号、会话、父容器和线程'); }
+    try { target = createDeliveryTarget({ conversation: input.target }); } catch { throw invalid('invalidTarget'); }
     const parameters = parseParameters(input.parameters);
     const fingerprint = digest({ operation: 'create', target, parameters });
     const revision = randomUUID(); const now = Date.now();
-    const task: AdminTask = { id: input.requestId, creation: fingerprint, target, text: parameters.text, createdAt: now,
+    const task: AdminTask = { id: input.requestId, creation: fingerprint, target, locale: this.projectLocale, text: parameters.text, createdAt: now,
       nextRunAt: Date.parse(parameters.at), intervalMs: parameters.intervalSeconds === undefined ? null : parameters.intervalSeconds * 1000,
-      state: 'scheduled', claimId: null, lastRunAt: null, detail: '等待执行' };
+      state: 'scheduled', claimId: null, lastRunAt: null, ...taskDetail('waiting') };
     const result = await this.state.update<AdminReminderBook>(ADMIN_REMINDER_STATE_KEY, current => {
       this.#assertLive(); const book = readBook(current);
       if (reconcile(book, input.requestId, fingerprint)) return book;
       assertRevision(book, input.expectedRevision);
       const existing = book.tasks.find(item => item.id === input.requestId);
-      if (existing) { if (existing.creation !== fingerprint) throw conflict('同一请求 ID 已用于其他内容'); return book; }
+      if (existing) { if (existing.creation !== fingerprint) throw conflict('requestReused'); return book; }
       assertFuture(task.nextRunAt, now);
       const active = book.tasks.filter(item => activeStates.has(item.state));
-      if (active.length >= this.config.adminMaxTasks) throw invalid('管理员提醒池已达上限，请先取消任务；聊天个人提醒使用独立配额');
+      if (active.length >= this.config.adminMaxTasks) throw invalid('quota');
       const historyLimit = Math.max(0, this.config.adminMaxTasks - active.length - 1);
       const history = historyLimit ? book.tasks.filter(item => !activeStates.has(item.state)).slice(-historyLimit) : [];
       return bounded({ ...book, revision, tasks: [...active, ...history, task], receipts: receipt(book, input.requestId, fingerprint, task.id, 'create') });
     });
-    return this.#snapshot(readBook(result));
+    return this.#snapshot(readBook(result), input.locale);
   }
 
   async change(input: PluginTaskMutation & Readonly<{ id: string; action: PluginTaskAction; parameters?: Readonly<Record<string, JsonValue>> }>): Promise<PluginTaskSnapshot> {
-    return this.#admit(() => this.#change(input));
+    return this.#admit(() => this.#change(input), input.locale);
   }
   async #change(input: PluginTaskMutation & Readonly<{ id: string; action: PluginTaskAction; parameters?: Readonly<Record<string, JsonValue>> }>): Promise<PluginTaskSnapshot> {
     this.#assertLive(); assertMutation(input);
-    if (typeof input.id !== 'string' || !uuidPattern.test(input.id) || !['pause', 'resume', 'cancel', 'update'].includes(input.action)) throw invalid('任务 ID 或操作无效');
-    if (input.action !== 'update' && input.parameters !== undefined) throw invalid('仅编辑操作接受参数');
+    if (typeof input.id !== 'string' || !uuidPattern.test(input.id) || !['pause', 'resume', 'cancel', 'update'].includes(input.action)) throw invalid('invalidAction');
+    if (input.action !== 'update' && input.parameters !== undefined) throw invalid('updateParameters');
     const parameters = input.action === 'update' ? parseParameters(input.parameters) : undefined;
     const fingerprint = digest({ operation: 'change', id: input.id, action: input.action, parameters: parameters ?? null });
     const revision = randomUUID(); const now = Date.now();
@@ -84,30 +106,30 @@ export class AdministratorReminderTasks implements PluginTaskProvider {
       if (reconcile(book, input.requestId, fingerprint)) return book;
       assertRevision(book, input.expectedRevision);
       const task = book.tasks.find(item => item.id === input.id);
-      if (!task) throw new PluginTaskError('not_found', '未找到当前实例的管理员任务；聊天任务不在此入口管理');
+      if (!task) throw new LocalizedTaskError('not_found', 'notFound');
       let changed: AdminTask;
       switch (input.action) {
         case 'pause':
-          if (task.state !== 'scheduled') throw invalid('仅待执行任务可以暂停；未确认投递不能暂停或恢复');
-          changed = { ...task, state: 'paused', detail: '管理员暂停' }; break;
+          if (task.state !== 'scheduled') throw invalid('pauseState');
+          changed = { ...task, state: 'paused', ...taskDetail('paused') }; break;
         case 'resume': {
-          if (task.state !== 'paused') throw invalid('仅已暂停任务可以恢复；未确认投递不能恢复或重试');
-          if (task.intervalMs === null && task.nextRunAt <= now) throw invalid('一次性任务时间已过，请先编辑为未来时间再恢复');
+          if (task.state !== 'paused') throw invalid('resumeState');
+          if (task.intervalMs === null && task.nextRunAt <= now) throw invalid('expired');
           const nextRunAt = task.nextRunAt <= now && task.intervalMs !== null ? nextPeriodicTime(task.nextRunAt, task.intervalMs, now) : task.nextRunAt;
-          changed = { ...task, state: 'scheduled', nextRunAt, detail: nextRunAt !== task.nextRunAt ? '已恢复，并跳过错过的周期轮次' : '管理员恢复' }; break;
+          changed = { ...task, state: 'scheduled', nextRunAt, ...taskDetail(nextRunAt !== task.nextRunAt ? 'resumedSkipping' : 'resumed') }; break;
         }
         case 'update':
-          if (task.state !== 'paused') throw invalid('编辑前请先暂停任务；未确认投递不能编辑');
+          if (task.state !== 'paused') throw invalid('updateState');
           assertFuture(Date.parse(parameters!.at), now);
           changed = { ...task, text: parameters!.text, nextRunAt: Date.parse(parameters!.at),
-            intervalMs: parameters!.intervalSeconds === undefined ? null : parameters!.intervalSeconds * 1000, detail: '已编辑，保持暂停；请确认后恢复' }; break;
+            intervalMs: parameters!.intervalSeconds === undefined ? null : parameters!.intervalSeconds * 1000, ...taskDetail('edited') }; break;
         case 'cancel':
-          if (!activeStates.has(task.state)) throw invalid('任务已结束，不能再次取消');
-          changed = { ...task, state: 'cancelled', detail: '管理员取消；已经开始的投递无法撤回' }; break;
+          if (!activeStates.has(task.state)) throw invalid('finished');
+          changed = { ...task, state: 'cancelled', ...taskDetail('cancelled') }; break;
       }
       return bounded({ ...book, revision, tasks: book.tasks.map(item => item.id === task.id ? changed : item), receipts: receipt(book, input.requestId, fingerprint, task.id, input.action) });
     });
-    return this.#snapshot(readBook(result));
+    return this.#snapshot(readBook(result), input.locale);
   }
 
   /** Called only by the existing ReminderService worker, within its shared batch limit. */
@@ -118,11 +140,11 @@ export class AdministratorReminderTasks implements PluginTaskProvider {
       const tasks = book.tasks.map(task => {
         if (task.state !== 'scheduled' || task.nextRunAt > now) return task;
         if (task.intervalMs !== null && now - task.nextRunAt > this.config.missedGraceSeconds * 1000) {
-          changed = true; return { ...task, nextRunAt: nextPeriodicTime(task.nextRunAt, task.intervalMs, now), detail: '已跳过错过的周期轮次' };
+          changed = true; return { ...task, nextRunAt: nextPeriodicTime(task.nextRunAt, task.intervalMs, now), ...taskDetail('skipped') };
         }
         if (claimed) return task;
         changed = claimed = true;
-        return { ...task, state: 'unknown' as const, claimId, lastRunAt: now, detail: '投递中或未确认；不会自动重试' };
+        return { ...task, state: 'unknown' as const, claimId, lastRunAt: now, ...taskDetail('delivering') };
       });
       return changed ? bounded({ ...book, revision, tasks }) : current;
     });
@@ -131,12 +153,12 @@ export class AdministratorReminderTasks implements PluginTaskProvider {
 
   async deliver(task: AdminTask): Promise<void> {
     if (this.#stopped) return;
-    let state: AdminTask['state'] = 'unknown'; let detail = '平台未确认投递，请核实目标会话后取消并另建任务；不会自动重试';
+    let state: AdminTask['state'] = 'unknown'; let detail = taskDetail('unknown');
     try {
-      const id = await this.outbound.sendTarget!(task.target, `⏰ 提醒：${task.text}`);
-      if (id) { state = task.intervalMs === null ? 'succeeded' : 'scheduled'; detail = '已确认投递'; }
+      const id = await this.outbound.sendTarget!(task.target, t(resolveLocale(task.locale), 'notification', { text: task.text }), { locale: resolveLocale(task.locale) });
+      if (id) { state = task.intervalMs === null ? 'succeeded' : 'scheduled'; detail = taskDetail('delivered'); }
     } catch (error) {
-      if (error instanceof EndpointDeliveryError && error.disposition !== 'unknown') { state = 'failed'; detail = '平台明确未投递或拒绝；任务已停止'; }
+      if (error instanceof EndpointDeliveryError && error.disposition !== 'unknown') { state = 'failed'; detail = taskDetail('rejected'); }
     }
     const revision = randomUUID();
     await this.state.update<AdminReminderBook>(ADMIN_REMINDER_STATE_KEY, current => {
@@ -144,24 +166,27 @@ export class AdministratorReminderTasks implements PluginTaskProvider {
       const tasks = book.tasks.map(item => {
         if (item.id !== task.id || item.claimId !== task.claimId || item.state !== 'unknown') return item;
         changed = true;
-        return { ...item, state, detail, ...(state === 'scheduled' && task.intervalMs !== null
+        return { ...item, state, ...detail, ...(state === 'scheduled' && task.intervalMs !== null
           ? { nextRunAt: nextPeriodicTime(task.nextRunAt, task.intervalMs, Date.now()) } : {}) };
       });
       return changed ? bounded({ ...book, revision, tasks }) : current;
     });
   }
 
-  #assertLive(): void { if (this.#stopped) throw new PluginTaskError('unavailable', '管理员提醒服务属于已停止的插件实例'); }
-  async #admit<T>(operation: () => Promise<T>): Promise<T> {
-    this.#assertLive(); const release = this.#admission.acquire();
-    if (!release) throw new PluginTaskError('unavailable', '管理员提醒服务属于未发布或已退役的 generation');
-    try { return await operation(); } finally { release(); }
+  #assertLive(): void { if (this.#stopped) throw new LocalizedTaskError('unavailable', 'stopped'); }
+  async #admit<T>(operation: () => Promise<T>, locale?: Locale): Promise<T> {
+    let release: (() => void) | undefined;
+    try {
+    this.#assertLive(); release = this.#admission.acquire();
+    if (!release) throw new LocalizedTaskError('unavailable', 'retired');
+    return await operation();
+    } catch (error) { throw error instanceof LocalizedTaskError ? error.localize(locale) : error; } finally { release?.(); }
   }
-  #snapshot(book: AdminReminderBook): PluginTaskSnapshot {
+  #snapshot(book: AdminReminderBook, locale?: Locale): PluginTaskSnapshot {
     return { revision: book.revision, receipts: book.receipts.map(item => ({ requestId: item.id, taskId: item.taskId, operation: item.operation })), tasks: book.tasks.map(task => ({
       id: task.id, ownership: 'administrator', title: taskTitle(task.text), target: task.target, state: task.state, createdAt: task.createdAt,
       ...(task.state === 'scheduled' || task.state === 'paused' ? { nextRunAt: task.nextRunAt } : {}), ...(task.lastRunAt === null ? {} : { lastRunAt: task.lastRunAt }),
-      timezone: this.config.timezone, detail: `${task.detail}；状态仅表示调度事实，不代表平台连接或投递健康`,
+      timezone: this.config.timezone, detail: adminText(locale, 'stateNote', { detail: formatTaskDetail(task, locale) }),
       parameters: { text: task.text, at: new Date(task.nextRunAt).toISOString(), ...(task.intervalMs === null ? {} : { intervalSeconds: task.intervalMs / 1000 }) },
       actions: task.state === 'scheduled' ? ['pause', 'cancel'] : task.state === 'paused' ? ['update', 'resume', 'cancel'] : task.state === 'unknown' ? ['cancel'] : [],
     })) };
@@ -169,18 +194,18 @@ export class AdministratorReminderTasks implements PluginTaskProvider {
 }
 
 function assertMutation(input: PluginTaskMutation): void {
-  if (typeof input.requestId !== 'string' || !uuidPattern.test(input.requestId) || typeof input.expectedRevision !== 'string' || !input.expectedRevision || input.expectedRevision.length > 128) throw invalid('操作须包含 UUID requestId 和读取到的 expectedRevision');
+  if (typeof input.requestId !== 'string' || !uuidPattern.test(input.requestId) || typeof input.expectedRevision !== 'string' || !input.expectedRevision || input.expectedRevision.length > 128) throw invalid('invalidMutation');
 }
 function parseParameters(value: Readonly<Record<string, JsonValue>> | undefined): Parameters {
   if (!value || Array.isArray(value) || Object.keys(value).some(key => !['text', 'at', 'intervalSeconds'].includes(key))
     || typeof value.text !== 'string' || !value.text.trim() || value.text.length > 500 || typeof value.at !== 'string'
-    || (value.intervalSeconds !== undefined && (typeof value.intervalSeconds !== 'number' || !Number.isSafeInteger(value.intervalSeconds) || value.intervalSeconds < 60 || value.intervalSeconds > MAX_DELAY_SECONDS))) throw invalid('参数须包含 1–500 字提醒内容、带 offset 的 ISO 时间及可选的 60 秒至一年整数周期');
+    || (value.intervalSeconds !== undefined && (typeof value.intervalSeconds !== 'number' || !Number.isSafeInteger(value.intervalSeconds) || value.intervalSeconds < 60 || value.intervalSeconds > MAX_DELAY_SECONDS))) throw invalid('invalidParameters');
   let at: number;
-  try { at = parseReminderInstant(value.at); } catch { throw invalid('提醒时间须为有效且带 Z 或 ±hh:mm 的 ISO 时间'); }
+  try { at = parseReminderInstant(value.at); } catch { throw invalid('invalidInstant'); }
   return { text: value.text, at: new Date(at).toISOString(), ...(value.intervalSeconds === undefined ? {} : { intervalSeconds: value.intervalSeconds as number }) };
 }
 function assertFuture(at: number, now: number): void {
-  if (!Number.isSafeInteger(at) || at <= now || at - now > MAX_DELAY_SECONDS * 1000) throw invalid('提醒时间须在未来一年内');
+  if (!Number.isSafeInteger(at) || at <= now || at - now > MAX_DELAY_SECONDS * 1000) throw invalid('future');
 }
 function digest(value: unknown): string { return createHash('sha256').update(JSON.stringify(value)).digest('hex'); }
 function taskTitle(text: string): string {
@@ -195,17 +220,17 @@ function taskTitle(text: string): string {
 function reconcile(book: AdminReminderBook, id: string, fingerprint: string): boolean {
   const previous = book.receipts.find(item => item.id === id);
   if (!previous) return false;
-  if (previous.fingerprint !== fingerprint) throw conflict('同一操作请求 ID 已用于其他内容，禁止重放');
+  if (previous.fingerprint !== fingerprint) throw conflict('replayConflict');
   return true;
 }
-function assertRevision(book: AdminReminderBook, revision: string): void { if (book.revision !== revision) throw conflict('任务列表已变化，请刷新后重新确认操作'); }
+function assertRevision(book: AdminReminderBook, revision: string): void { if (book.revision !== revision) throw conflict('revision'); }
 function receipt(book: AdminReminderBook, id: string, fingerprint: string, taskId: string, operation: MutationReceipt['operation']): readonly MutationReceipt[] {
   return [...book.receipts, { id, fingerprint, taskId, operation }].slice(-128);
 }
-function invalid(message: string): PluginTaskError { return new PluginTaskError('invalid_input', message); }
-function conflict(message: string): PluginTaskError { return new PluginTaskError('conflict', message); }
+function invalid(message: AdminTextKey): PluginTaskError { return new LocalizedTaskError('invalid_input', message); }
+function conflict(message: AdminTextKey): PluginTaskError { return new LocalizedTaskError('conflict', message); }
 function bounded(book: AdminReminderBook): AdminReminderBook {
-  if (book.tasks.length > 32 || new TextEncoder().encode(JSON.stringify(book)).byteLength > 60 * 1024) throw invalid('管理员提醒池状态达到 32 条或 60 KiB 上限，请先取消并整理任务');
+  if (book.tasks.length > 32 || new TextEncoder().encode(JSON.stringify(book)).byteLength > 60 * 1024) throw invalid('capacity');
   return book;
 }
 function readBook(value: AdminReminderBook | undefined): AdminReminderBook {
@@ -221,9 +246,10 @@ function readBook(value: AdminReminderBook | undefined): AdminReminderBook {
         || (task.intervalMs !== null && (!Number.isSafeInteger(task.intervalMs) || task.intervalMs < 60_000 || task.intervalMs > MAX_DELAY_SECONDS * 1000))
         || !['scheduled', 'paused', 'unknown', 'succeeded', 'failed', 'cancelled'].includes(task.state)
         || (task.claimId !== null && (typeof task.claimId !== 'string' || !task.claimId)) || (task.lastRunAt !== null && !Number.isSafeInteger(task.lastRunAt))
+        || (task.locale !== undefined && task.locale !== 'zh-CN' && task.locale !== 'en') || (task.detailKey !== undefined && !isAdminTextKey(task.detailKey))
         || typeof task.detail !== 'string' || !Number.isFinite(new Date(task.nextRunAt).getTime())) throw new Error('invalid task');
       createDeliveryTarget({ conversation: task.target }); ids.add(task.id);
     }
     return bounded(value);
-  } catch { throw new PluginTaskError('unavailable', '管理员提醒持久状态格式无效，已停止投递'); }
+  } catch { throw new LocalizedTaskError('unavailable', 'corrupt'); }
 }

package/src/caller.ts

@@ -1,10 +1,12 @@
+import { resolveLocale, type Locale } from 'zhin.js/i18n';
+import { reminderMessages as t } from './i18n.js';
 import { createDeliveryTarget } from 'zhin.js';
 import type { CommandMessage } from '@zhin.js/command';
 import { ReminderInputError, type ReminderActor } from './service.js';
 
-export function reminderActor(input: CommandMessage | undefined): ReminderActor {
-  if (!input?.sender?.id) throw new ReminderInputError('提醒指令需要真实会话和发送者');
-  return { senderId: input.sender.id, target: createDeliveryTarget(input) };
+export function reminderActor(input: CommandMessage | undefined, locale: Locale = resolveLocale(input?.locale)): ReminderActor {
+  if (!input?.sender?.id) throw new ReminderInputError(t(locale, 'actorRequired'));
+  return { senderId: input.sender.id, target: createDeliveryTarget(input), locale };
 }
 
 export async function replyReminder(operation: () => Promise<string>): Promise<string> {

package/src/config.ts

@@ -1,12 +1,12 @@
 import { Schema } from 'zhin.js';
 
 export const reminderConfig = Schema.object({
-  timezone: Schema.string().default('UTC').description('解释 create 自然时间并显示提醒的 IANA 时区；ISO 绝对时间仍须显式 offset').effect('reload'),
-  maxTasks: Schema.number().min(1).max(32).step(1).default(20).description('每实例聊天个人提醒池的活跃任务上限；与管理员池独立，降低上限不删除既有任务').effect('reload'),
-  adminMaxTasks: Schema.number().min(1).max(32).step(1).default(20).description('每实例管理员提醒池的活跃任务上限（待执行、暂停或未确认）；与聊天池独立，两池总量可达上限之和').effect('reload'),
-  maxTasksPerSender: Schema.number().min(1).max(10).step(1).default(10).description('同一发送者在同一会话的任务上限').effect('reload'),
-  batchSize: Schema.number().min(1).max(5).step(1).default(5).description('每次扫描最多投递的任务数').effect('reload'),
-  missedGraceSeconds: Schema.number().min(5).max(60).step(1).default(15).description('周期轮次超过此延迟后跳过；停机期间不补历史轮次').effect('reload'),
+  timezone: Schema.string().default('UTC').description('解释 create 自然时间并显示提醒的 IANA 时区；ISO 绝对时间仍须显式 offset').i18n({"en": {"description": "IANA timezone for natural reminder times and display. Absolute ISO times still require an explicit offset."}}).effect('reload'),
+  maxTasks: Schema.number().min(1).max(32).step(1).default(20).description('每实例聊天个人提醒池的活跃任务上限；与管理员池独立，降低上限不删除既有任务').i18n({"en": {"description": "Maximum active personal chat reminders per instance, separate from administrator tasks. Lowering the limit does not delete existing tasks."}}).effect('reload'),
+  adminMaxTasks: Schema.number().min(1).max(32).step(1).default(20).description('每实例管理员提醒池的活跃任务上限（待执行、暂停或未确认）；与聊天池独立，两池总量可达上限之和').i18n({"en": {"description": "Maximum active administrator reminders (scheduled, paused or unconfirmed) per instance. Separate from chat tasks; the two quotas are additive."}}).effect('reload'),
+  maxTasksPerSender: Schema.number().min(1).max(10).step(1).default(10).description('同一发送者在同一会话的任务上限').i18n({"en": {"description": "Maximum tasks per sender in the same conversation."}}).effect('reload'),
+  batchSize: Schema.number().min(1).max(5).step(1).default(5).description('每次扫描最多投递的任务数').i18n({"en": {"description": "Maximum tasks delivered in each scan."}}).effect('reload'),
+  missedGraceSeconds: Schema.number().min(5).max(60).step(1).default(15).description('周期轮次超过此延迟后跳过；停机期间不补历史轮次').i18n({"en": {"description": "Skip recurring runs delayed beyond this many seconds. Missed runs during downtime are not backfilled."}}).effect('reload'),
 });
 
 export type ReminderConfig = Schema.Output<typeof reminderConfig>;

package/src/create-reminder.ts

@@ -1,3 +1,5 @@
+import { resolveLocale } from 'zhin.js/i18n';
+import { reminderMessages as t } from './i18n.js';
 import type { CommandContext } from 'zhin.js/command';
 import type { ReminderConfig } from './config.js';
 import { reminderActor } from './caller.js';
@@ -7,7 +9,6 @@ import { ReminderTimeInputError, parseNaturalReminderTime, formatReminderTime }
 
 const STEP_TIMEOUT = 60_000;
 const FLOW_TIMEOUT = 3 * STEP_TIMEOUT;
-const TIMEOUT_TEXT = '提醒输入超时，未创建提醒；请重新执行 remind create。';
 class ReminderCreationCancelled extends Error {}
 class ReminderCreationDeadline extends Error {}
 class ReminderPreviewDeliveryError extends Error {}
@@ -17,23 +18,28 @@ export async function createPersonalReminder(
   context: CommandContext<ReminderConfig>,
   parameters: Readonly<{ when?: string; text?: string }>,
 ): Promise<string | undefined> {
-  if (!context.input?.sender?.id || !context.interaction || !context.input.$replyFrom && !context.input.$reply) return '请在真实聊天会话中使用此指令；需要发送者身份和交互能力，未创建提醒。';
+  const locale = resolveLocale(context.locale);
+  const createCommand = context.formatCommand('remind create');
+  const listCommand = context.formatCommand('remind list');
+  const restart = createCommand ? t(locale, 'restartCommand', { command: createCommand }) : t(locale, 'restart');
+  const timeoutText = `${t(locale, 'flowTimeout')} ${restart}`;
+  const checkExisting = listCommand ? t(locale, 'checkCommand', { command: listCommand }) : t(locale, 'checkNoCommand');
+  if (!context.input?.sender?.id || !context.interaction || !context.input.$replyFrom && !context.input.$reply) return t(locale, 'needsChat');
   const deadline = Date.now() + FLOW_TIMEOUT;
   let creating = false;
   try {
-    const actor = reminderActor(context.input);
+    const actor = reminderActor(context.input, locale);
     const interaction = context.interaction;
     const timezone = context.config.timezone;
     const steps = new Map<string, number>();
-    const invocationHead = /^(.*?remind)\s+create(?:\s|$)/iu.exec(context.input.content.trim())?.[1];
-    const isCommand = (value: string) => /^[!/#.]?remind\s+(?:create|after|at|every|list|cancel)(?:\s|$)/iu.test(value)
-      || !!invocationHead && value.startsWith(`${invocationHead} `);
+    const commandHeads = ['create', 'after', 'at', 'every', 'list', 'cancel'].map(name => context.formatCommand(`remind ${name}`)).filter((value): value is string => !!value);
+    const isCommand = (value: string) => commandHeads.some(head => value === head || value.startsWith(`${head} `));
     const checkDeadline = () => {
       context.signal.throwIfAborted();
       if (Date.now() >= deadline) throw new ReminderCreationDeadline();
     };
     const checkCancel = (value: string) => {
-      if (/^(?:取消|cancel)$/iu.test(value.trim())) throw new ReminderCreationCancelled();
+      if (value.trim().toLowerCase() === (locale === 'en' ? 'cancel' : '取消')) throw new ReminderCreationCancelled();
     };
     const ask = async (stage: 'time' | 'body' | 'confirmation', title: string, description: string, maxLength: number): Promise<string> => {
       checkDeadline();
@@ -42,8 +48,8 @@ export async function createPersonalReminder(
       const remaining = Math.min(deadline, stepDeadline) - Date.now();
       if (remaining <= 0) throw new ReminderCreationDeadline();
       const answer = (await interaction.ask({ type: 'text', title, description,
-        tip: '直接回复内容，不加命令前缀；输入“取消”或 cancel 可退出。', maxLength,
-        timeout: remaining, timeoutText: TIMEOUT_TEXT, signal: context.signal,
+        tip: t(locale, 'answerTip'), maxLength,
+        timeout: remaining, timeoutText, signal: context.signal,
       })).trim();
       checkDeadline(); checkCancel(answer); return answer;
     };
@@ -53,8 +59,10 @@ export async function createPersonalReminder(
     let timeError = '';
     while (!parsed) {
       checkDeadline();
-      if (!expression) expression = await ask('time', '什么时候提醒你？', [timeError, `按 ${timezone} 解析，例如“10分钟后”或“明天上午九点”；也可使用带 offset 的 ISO 时间。`].filter(Boolean).join('\n'), 200);
-      try { parsed = parseNaturalReminderTime(expression, { now: Date.now(), timezone }); }
+      if (!expression) expression = await ask('time', t(locale, 'askWhen'), [timeError, t(locale, 'whenHelp', { timezone })].filter(Boolean).join('\n'), 200);
+      try {
+        parsed = parseNaturalReminderTime(expression, { now: Date.now(), timezone, locale });
+      }
       catch (error) {
         if (!(error instanceof ReminderTimeInputError)) throw error;
         timeError = error.message; expression = undefined;
@@ -64,13 +72,13 @@ export async function createPersonalReminder(
     if (text) checkCancel(text);
     let textError = '';
     while (!text || text.length > 500 || isCommand(text)) {
-      if (text) textError = isCommand(text) ? '当前正在补全提醒；请直接回复正文，或先取消后重新发指令。' : '提醒正文须为 1–500 个字符。';
-      text = await ask('body', '提醒你做什么？', [textError, '请输入纯文字提醒正文（1–500 字）。'].filter(Boolean).join('\n'), 500);
+      if (text) textError = isCommand(text) ? t(locale, 'bodyCommand') : t(locale, 'bodyLimit');
+      text = await ask('body', t(locale, 'askBody'), [textError, t(locale, 'bodyHelp')].filter(Boolean).join('\n'), 500);
     }
     const target = actor.target;
-    const scene = `${target.kind} ${target.id}${target.parent ? `；父容器 ${target.parent.kind} ${target.parent.id}` : ''}${target.threadId ? `；话题 ${target.threadId}` : ''}`;
+    const scene = `${target.kind} ${target.id}${target.parent ? `; ${t(locale, 'parent')} ${target.parent.kind} ${target.parent.id}` : ''}${target.threadId ? `; ${t(locale, 'thread')} ${target.threadId}` : ''}`;
     const account = `${target.endpoint.adapter} / ${target.endpoint.id.replaceAll('\0', ' / ')}`;
-    const preview = `时间：${formatReminderTime(parsed.at, parsed.timezone)}\n原会话：${scene}\n账号：${account}\n正文（原样显示）：\n${text}\n\n请等待下一条确认提示，再输入“确认”创建；不会更换目标会话。\n若确认后未收到创建结果，请先在原会话用 remind list 核对，不要直接重复创建。`;
+    const preview = `${t(locale, 'preview', { time: formatReminderTime(parsed.at, parsed.timezone), scene, account, text })}\n${checkExisting}`;
     checkDeadline();
     // Canonical text avoids interpreting reminder content as Markdown/HTML in the prompt renderer.
     const previewContent = { type: 'text', data: { text: preview } };
@@ -81,26 +89,26 @@ export async function createPersonalReminder(
     if (!receipt || typeof receipt !== 'object' || !('status' in receipt) || receipt.status !== 'sent') throw new ReminderPreviewDeliveryError();
     let confirmError = '';
     while (true) {
-      const answer = await ask('confirmation', '确认创建这条提醒？', [confirmError, '请核对上一条预览的时间、时区、正文和原会话；仅输入“确认”才创建。'].filter(Boolean).join('\n'), 500);
-      if (answer === '确认') break;
-      confirmError = '未创建提醒。请明确输入“确认”，或输入“取消”退出。';
+      const answer = await ask('confirmation', t(locale, 'askConfirm'), [confirmError, t(locale, 'confirmHelp')].filter(Boolean).join('\n'), 500);
+      if (answer.toLowerCase() === (locale === 'en' ? 'confirm' : '确认')) break;
+      confirmError = t(locale, 'confirmInvalid');
     }
     checkDeadline();
-    if (parsed.at <= Date.now()) return '提醒时间已过，未创建提醒。请重新执行 remind create 并选择未来时间；不会自动顺延。';
+    if (parsed.at <= Date.now()) return `${t(locale, 'expired')} ${restart}`;
     const service = context.use(reminderServiceToken);
     creating = true;
     const task = await service.add(actor, text, parsed.at, null);
-    return `已创建个人提醒\n${service.describe(task)}`;
+    return `${t(locale, 'personalCreated')}\n${service.describe(task, locale)}`;
   } catch (error) {
-    if (error instanceof ReminderCreationCancelled) return '已取消，未创建提醒。';
-    if (error instanceof ReminderInputError) return `未创建提醒：${error.message}`;
-    if (creating) return '提醒创建结果未能确认，请先使用 remind list 核对；不要直接重复创建。';
+    if (error instanceof ReminderCreationCancelled) return t(locale, 'flowCancelled');
+    if (error instanceof ReminderInputError) return t(locale, 'notCreated', { error: error.message });
+    if (creating) return checkExisting;
     if (context.signal.aborted
       || error instanceof Error && ['UserInteractionTimeoutError', 'UserInteractionSupersededError', 'AbortError'].includes(error.name)) return undefined;
     if (error instanceof Error && /(?:retired|inactive generation|scope has ended)/iu.test(error.message)) return undefined;
     // Core reports ask timeouts itself; this deadline can instead expire during preview delivery.
-    if (error instanceof ReminderCreationDeadline) return TIMEOUT_TEXT;
-    if (error instanceof ReminderPreviewDeliveryError || error instanceof Error && error.name === 'UserInteractionDeliveryError') return '提示消息未能确认送达，未创建提醒；请核对会话后重新执行，不会自动重发。';
+    if (error instanceof ReminderCreationDeadline) return timeoutText;
+    if (error instanceof ReminderPreviewDeliveryError || error instanceof Error && error.name === 'UserInteractionDeliveryError') return t(locale, 'previewFailed');
     throw error;
   }
 }