@aalis/plugin-commands 0.13.1 → 0.15.0

package/dist/index.js

@@ -1,86 +1,40 @@
+import { agent } from '@aalis/api-agent';
 import { authority } from '@aalis/api-authority';
 import { commands as commandsService } from '@aalis/api-commands';
+import { contributions } from '@aalis/api-contributions';
 import { gateway, INBOUND_PHASE } from '@aalis/api-gateway';
 import { hooks } from '@aalis/api-hooks';
+import { i18n } from '@aalis/api-i18n';
 import { memory } from '@aalis/api-memory';
-import { createStorageGateway, isStorageNotFound, storage } from '@aalis/api-storage';
-import { appService, config, definePlugin, events, logger, optional, provide, services, } from '@aalis/core';
+import { tools } from '@aalis/api-tools';
+import { appService, config, definePlugin, events, lifecycle, logger, optional, pluginsService, provide, } from '@aalis/core';
 import { defineConfig, parseConfig } from '@aalis/schema-config';
+import { isTextRef, TextError, textLines, textOf, toSource } from '@aalis/schema-i18n';
+import { AT_SELF_PATTERN } from '@aalis/schema-message';
 import { CommandRegistry } from './commands.js';
-import { renderDetail, renderOverview } from './help.js';
+import { t } from './texts.js';
 const configSchema = defineConfig({
     commandPrefix: {
         type: 'string',
-        label: '指令前缀',
+        label: t('prefixLabel'),
         default: '/',
         onInvalid: 'error',
-        description: '指令触发前缀，设为空字符串可使用纯关键词触发',
+        description: t('prefixDescription'),
     },
 });
-/**
- * 删除目录及内部所有内容，返回顶层子项数（用于"清了 N 张/N 个会话"提示）。
- * 目录不存在返回 -1。
- */
-async function removeDirCounted(storage, dirUri) {
-    try {
-        const st = await storage.stat(dirUri);
-        if (!st.isDirectory)
-            return -1;
-        const list = await storage.list(dirUri);
-        await storage.delete(dirUri);
-        return list.entries.length;
-    }
-    catch (err) {
-        if (isStorageNotFound(err))
-            return -1;
-        throw err;
-    }
-}
-/** 可清理类型。globalOnly：跨会话数据，只在 /clear all 时清理 */
-export const CLEAR_TYPES = [
-    { id: 'context', label: '消息历史与会话上下文（含摘要与待办）' },
-    { id: 'summary', label: '会话摘要' },
-    { id: 'vector', label: '向量记忆' },
-    { id: 'image', label: '图片缓存' },
-    { id: 'video', label: '视频缓存' },
-    { id: 'audio', label: '语音缓存' },
-    { id: 'file', label: '文件缓存' },
-    { id: 'persona', label: '会话角色状态' },
-    { id: 'checkpoint', label: '检查点（对话回滚存档）' },
-    { id: 'user-profile', label: '用户档案与第三方行为指令', globalOnly: true },
-    { id: 'user-relation', label: '用户关系图谱', globalOnly: true },
-];
-/**
- * 附件缓存种类 → `data:/` 目录 + 中文标签。
- * 目录名与 @aalis/plugin-adapter-onebot 的 attachment-cache `KIND_DIR` 对齐
- * （image→images / video→videos / audio→audios / file→files），落盘路径为
- * `data:/{dir}/{safeSessionId}/{hash}.{ext}`。改这里即同步 /clear 覆盖面。
- */
-export const ATTACHMENT_KINDS = [
-    { type: 'image', dir: 'images', label: '图片' },
-    { type: 'video', dir: 'videos', label: '视频' },
-    { type: 'audio', dir: 'audios', label: '语音' },
-    { type: 'file', dir: 'files', label: '文件' },
-];
-const CLEAR_TYPE_ALIASES = {
-    history: 'context',
-    messages: 'context',
-    profile: 'user-profile',
-    profiles: 'user-profile',
-};
-function normalizeClearTypes(raw, prefix) {
+/** 按登记表核对 -t 的取值：不给或含 all 时清全部类型（undefined），有不认识的抛给人看的错 */
+function normalizeClearTypes(raw, known, prefix) {
     const values = Array.isArray(raw) ? raw : typeof raw === 'string' ? [raw] : [];
     const types = values
         .flatMap(v => String(v).split(','))
         .map(v => v.trim())
-        .filter(Boolean)
-        .map(v => CLEAR_TYPE_ALIASES[v] ?? v);
+        .filter(Boolean);
     if (types.length === 0 || types.includes('all'))
         return undefined;
-    const known = new Set(CLEAR_TYPES.map(t => t.id));
-    const unknown = types.find(t => !known.has(t));
+    const unknown = types.find(type => !known.some(k => k.id === type));
     if (unknown) {
-        throw new Error(`未知清理类型: ${unknown}。可用类型: all, ${CLEAR_TYPES.map(t => t.id).join(', ')}。说明见 ${prefix}help clear`);
+        const ids = ['all', ...known.map(k => k.id)].join(', ');
+        throw new TextError(t('unknownClearType', { type: unknown, types: ids, prefix }));
     }
     return [...new Set(types)];
 }
@@ -93,258 +47,245 @@ const uses = {
      */
     commands: optional(commandsService),
     gateway,
-    storage: optional(storage),
     memory: optional(memory),
+    /** /clear 清消息历史时经它先停下并按住这些会话；缺席时没有在跑的回合要停 */
+    agent: optional(agent),
     authority: optional(authority),
-    app: optional(appService),
+    /** /status 写已登记的工具数 */
+    tools: optional(tools),
+    /** /status 写插件在跑与出错的个数；缺席时不写这一行 */
+    plugins: optional(pluginsService),
+    /** /clear 的类型按 memory:clear-type 的登记表取；缺席时只认 all */
+    contributions: optional(contributions),
+    /** 回复与帮助按这条指令所在会话的语言渲染；缺席时按原文 */
+    i18n: optional(i18n),
+    app: appService,
     events,
     hooks,
+    /** 停用时结算等待中的意图确认 */
+    lifecycle,
     logger,
     config,
     provide,
-    services,
 };
 export default definePlugin({
     name: '@aalis/plugin-commands',
-    displayName: '内置指令',
+    displayName: t('displayName'),
     subsystem: 'core',
     configSchema,
     provides: [commandsService],
     uses,
     apply: registerCommands,
 });
-function registerCommands({ commands, gateway, storage, memory, authority, app, events, hooks, logger, config, provide, services, }) {
-    const cfg = parseConfig(configSchema, config, logger);
+function registerCommands({ commands, gateway, memory, agent, authority, tools, plugins, contributions, i18n, app, events, hooks, lifecycle, logger, config, provide, }) {
+    const cfg = parseConfig(configSchema, config.use, logger.use);
     // 创建指令注册表并注册为服务
-    const registry = new CommandRegistry(logger);
-    const storageGateway = createStorageGateway(storage);
+    const registry = new CommandRegistry(logger.use, authority, i18n);
     // 可见性的运行时覆盖（authorityOverrides）现归 authority 配置，不在指令注册表加载。
     // 配置指令系统
     registry.prefix = cfg.commandPrefix;
     // 注册服务
-    provide(commandsService, registry);
-    // ===== 统一 memory:clear 中间件：附件缓存清理（图片/视频/语音/文件）=====
-    //
-    // 附件按 data:/{images|videos|audios|files}/{safeSessionId} 落盘（与 onebot
-    // attachment-cache 的 KIND_DIR 对齐）。独立 middleware 使 /clear 与 deleteSession
-    // 走同一清理路径——deleteSession 触发的 memory:clear 也清附件，杜绝文件泄漏
-    // （四类必须齐清，漏掉任一类即留下残留文件）。
-    //
-    // types 语义：未指定=清全部附件；指定则只清命中的种类（如 /clear -t video）。
-    hooks.middleware('memory:clear', async (data, next) => {
-        const safeSessionId = data.sessionId?.replace(/[:/\\]/g, '_');
-        for (const k of ATTACHMENT_KINDS) {
-            if (data.types && !data.types.includes(k.type))
-                continue;
-            try {
-                if (data.scope === 'all') {
-                    const removed = await removeDirCounted(storageGateway, `data:/${k.dir}`);
-                    data.results.push({
-                        source: `${k.type}-cache`,
-                        type: k.type,
-                        success: true,
-                        message: removed >= 0 ? `所有${k.label}缓存已清空（${removed} 个会话目录）` : `${k.label}缓存目录不存在，无需清空`,
-                    });
-                }
-                else if (safeSessionId) {
-                    const removed = await removeDirCounted(storageGateway, `data:/${k.dir}/${safeSessionId}`);
-                    data.results.push({
-                        source: `${k.type}-cache`,
-                        type: k.type,
-                        success: true,
-                        message: removed >= 0 ? `当前会话${k.label}缓存已清空（${removed} 个）` : `当前会话无${k.label}缓存`,
-                    });
-                }
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                data.results.push({
-                    source: `${k.type}-cache`,
-                    type: k.type,
-                    success: false,
-                    message: `${k.label}缓存清空失败: ${msg}`,
-                });
-            }
-        }
-        await next();
-    });
+    provide.use(commandsService, registry);
     // ===== inbound:command 相位：命令命中则执行并中断后续相位 =====
     //
     // 命令拦截只在 inbound:command 命名相位做，适配器不内联拦截，
     // 所有平台共享同一套命令解析路径。
     // plugin-gateway 的 INBOUND_PHASE_ORDER 把本相位放在 trigger / flow 之前。
     //
-    // 受信任系统源：scheduler 等内部触发器写入 message.source。
-    // 这些来源的权限身份来自创建时固化的 message.actor（scheduler 在 setJob / addJob /
-    // 静态配置载入这三条建任务路径上各自 snapshot 创建者身份），守卫按 actor 的真实等级
-    // 评估——与普通用户走同一闸门，不存在 bypassGuard 式的全绕过。
-    // **actor 缺省即匿名**：创建者匿名时不得回填 owner，否则受信来源就成了提权通道
-    // （在触发路径把空 actor 补成 `webui:console` 之类，等于开了一条 owner 快速通道）。
-    // skipConfirm 仍然需要：cron 上下文无人可点受限二次确认弹窗（authorize 仍生效）。
-    // 同时这些 source 通常指向 internal 虚拟 session（无适配器接收），
-    // 因此结果不走 outbound 而是写日志，避免发到虚空。
-    // 受信系统源 = 免交互确认（skipConfirm）+ 结果写日志而非回发。仅 scheduler：
-    // 它建任务的入口是 dangerous + confirm:'always'（L2 且每次真人确认），拿到受信特权
-    // 的成本与特权本身相称。
-    // 刻意排除的两项（2026-08-28 对抗审计定，勿再"修死项"重开）：
-    //   'system' —— 只出现在出站消息，无入站生产者，纯死值，删。
-    //   'workflow:*' —— 曾想按前缀纳入，但 workflow_define/workflow_run 只是 sensitive(L1)、
-    //     零确认，一旦受信，L1 就能定义 send-message 节点向任意会话静默投递 /clear 这类
-    //     0 级 + confirm:'session' 命令、且无回显——confirm 闸（防注入误清）被绕过。
-    //     故 workflow 派发**不受信**：它经 COMMAND 相位的命令照常走 confirm，虚拟会话无人
-    //     应答即超时拒（fail-closed）。要让 workflow 自动化免确认，须先把 define/run 抬到
-    //     与 scheduler 相称的档位，那是单独的决定。
-    const TRUSTED_SOURCE_EXACT = new Set(['scheduler']);
-    const isTrustedSystemSource = (source) => !!source && TRUSTED_SOURCE_EXACT.has(source);
-    hooks.middleware(INBOUND_PHASE.COMMAND, async (data, next) => {
+    // 只有人亲手写的文字才执行指令。真人入站（平台适配器、WebUI、终端）不带 source，照常解析；带 source 的注入不论
+    // source 叫什么，都不过指令解析、当普通消息往下走，只有声明了 ownerApproved 的照常解析：文字在建立时经 owner 过目过原文。
+    // 带声明的注入：
+    // - 权限身份取创建时固化的 message.actor，守卫按它的真实等级评估，与普通用户走同一闸门。**actor 缺省即匿名**：
+    //   创建者匿名时不得回填 owner（在触发路径把空 actor 补成 `webui:console` 之类，等于开了一条 owner 快速通道）；
+    // - 没人可问，免 session 档的确认（skipConfirm；authorize 仍生效，always 档照常要确认、无从确认即拒）；
+    //   免确认只对创建者是 owner 的注入生效（执行守卫按授权身份判），别人建的任务里需要确认的指令照旧直接拒；
+    // - 通常指向没有适配器接收的 internal 虚拟会话，结果写日志而不回发，避免发到虚空。
+    /**
+     * 回到消息所在的会话。文字对象交给网关按这个会话的语言渲染，content 写原文。required 依赖在调度收敛前可能短暂缺席，
+     * 故保留事件兜底（发出原文）
+     */
+    async function reply(message, result) {
+        const out = {
+            ...(isTextRef(result) ? { content: toSource(result), text: result } : { content: result }),
+            sessionId: message.sessionId,
+            platform: message.platform,
+            source: 'command',
+        };
+        const gatewayService = gateway.present ? gateway.use : undefined;
+        if (gatewayService)
+            await gatewayService.dispatchOutbound(out);
+        else
+            await events.use.emit('outbound:message', out);
+    }
+    // ===== 意图确认：人亲手输入、声明了 confirm 的指令，在同一会话里问发出者本人 =====
+    //
+    // 只认这个人在这个会话里的下一条消息（带 source 的注入不认）：y 为确认，其余取消，这条回复吞掉、不往下走；
+    // 时限内不回也取消。问的是「确定要这么做吗」，不是 owner 审批：非 owner 的发出者本人确认即可。
+    const INTENT_TIMEOUT_MS = 60_000;
+    const YES = /^\s*(?:y|yes)\s*$/i;
+    /** 等回复的意图确认：键是会话与发出者，值是结算函数 */
+    const intents = new Map();
+    const intentKey = (m) => `${m.sessionId}\n${m.platform}\n${m.userId}`;
+    function askIntent(message, raw) {
+        return () => new Promise(resolve => {
+            const key = intentKey(message);
+            const settle = (confirmed) => {
+                clearTimeout(timer);
+                if (intents.get(key) === settle)
+                    intents.delete(key);
+                resolve(confirmed);
+            };
+            const timer = setTimeout(() => settle(false), INTENT_TIMEOUT_MS);
+            timer.unref?.();
+            intents.set(key, settle);
+            void reply(message, t('confirmIntent', { command: raw, seconds: INTENT_TIMEOUT_MS / 1000 }));
+        });
+    }
+    // 停用（含重载）时等待中的确认按取消结算：新实例不认得它们，留到时限只会在拆卸之后才回「已取消」。
+    // 在撤回登记之前结算，网关还在，取消的回复发得出去
+    lifecycle.use.onDrain(() => {
+        for (const settle of [...intents.values()])
+            settle(false);
+    }, '取消等待中的意图确认');
+    hooks.use.middleware(INBOUND_PHASE.COMMAND, async (data, next) => {
         const { message } = data;
-        // 内部触发（idle-trigger 等无 userId）不参与命令解析
-        if (!message.content)
+        const injected = message.source !== undefined;
+        // 开头对她的 @（AT_SELF_PATTERN，只认开头）不算正文，意图确认的回复与指令同用这一份：在群里 @ 她或引用她的消息发指令、
+        // 回 y 时，QQ 客户端会在开头插一个。开头 @ 的是别人时照旧不算
+        const content = message.content ?? '';
+        const at = AT_SELF_PATTERN.exec(content);
+        const text = at?.index === 0 ? content.slice(at[0].length) : content;
+        const settle = injected ? undefined : intents.get(intentKey(message));
+        if (settle) {
+            settle(YES.test(text));
+            return;
+        }
+        // 带 source 又没声明 ownerApproved 的注入不是人亲手写的，与没有文字的消息一样不参与命令解析
+        if (!content || (injected && !message.ownerApproved))
             return next();
-        const parsed = registry.parseCommand(message.content);
+        const parsed = registry.parseCommand(text);
         if (!parsed)
             return next();
         // 解析到 "<prefix>foo" 但没有任何插件注册过该指令 → 当作普通消息处理
         // （归档、trigger、agent 等下游相位继续工作），避免对错字/打字噪音回显"未知指令"。
         if (!registry.hasMatch(parsed.name, parsed.args))
             return next();
-        const isSystemTrigger = isTrustedSystemSource(message.source);
         try {
             // 优先用 actor（系统触发器注入的代理身份），fallback 到消息原始身份。
             // 与 agent 工具调用路径解析调用者身份同语义。
-            const result = await registry.execute(parsed.name, {
+            const result = await registry.run(parsed.name, {
                 sessionId: message.sessionId,
                 platform: message.actor?.platform ?? message.platform,
                 userId: message.actor?.userId ?? message.userId,
                 sessionType: message.sessionType,
                 args: parsed.args,
                 raw: parsed.raw,
-                skipConfirm: isSystemTrigger,
+                // 走到这里的注入都声明了 ownerApproved
+                skipConfirm: injected,
+                // 人亲手输入的消息才问得到发出者
+                confirmIntent: !injected && message.userId !== undefined ? askIntent(message, parsed.raw) : undefined,
             });
             if (result) {
-                if (isSystemTrigger) {
-                    // 系统触发器（scheduler）的 sessionId 通常是 internal 虚拟 session，
-                    // 走 outbound 也无人接收；直接写日志便于排查。
-                    const preview = result.length > 500 ? `${result.slice(0, 500)}…` : result;
-                    logger.info(`[${message.source}] ${parsed.raw} → session=${message.sessionId} 结果:\n${preview}`);
+                if (injected) {
+                    const output = toSource(result);
+                    const preview = output.length > 500 ? `${output.slice(0, 500)}…` : output;
+                    logger.use.info(`[${message.source}] ${parsed.raw} → session=${message.sessionId} 结果:\n${preview}`);
                 }
                 else {
-                    // required 依赖在调度收敛前可能短暂缺席，故保留事件兜底
-                    const gatewayService = gateway.current;
-                    const reply = {
-                        content: result,
-                        sessionId: message.sessionId,
-                        platform: message.platform,
-                        source: 'command',
-                    };
-                    if (gatewayService) {
-                        await gatewayService.dispatchOutbound(reply);
-                    }
-                    else {
-                        await events.emit('outbound:message', reply);
-                    }
+                    await reply(message, result);
                 }
             }
         }
         catch (err) {
-            logger.warn(`指令执行失败: ${err}`);
+            logger.use.warn(`指令执行失败: ${err}`);
         }
         // 命令命中：不调用 next() —— 整个入站管道立即停止（不再进入 trigger/flow/dispatch）
     });
     // ===== 内置指令 =====
-    commands.command('help [name:text]', '显示指令列表；带指令名看用法详情').action(async (_argv, name) => {
-        const all = registry.getAll();
-        // 无参 → 概览（只列顶层，子指令折成计数）
-        if (!name) {
-            const childCount = (top) => all.filter(c => c.name.startsWith(`${top}.`) && !c.name.slice(top.length + 1).includes('.')).length;
-            return renderOverview(all, registry.prefix, childCount);
-        }
-        // 有参 → 详情。接受空格与点两种写法：`help session set` ≡ `help session.set`
-        const path = String(name)
-            .trim()
+    // 只列调用者能用的指令：用不了的在帮助里当作不存在
+    commands.use
+        .command('help [name:text]', t('helpDescription'))
+        .argument('name', t('helpName'))
+        .action(async (argv, name) => {
+        const path = String(name ?? '')
             .split(/[\s.]+/)
             .filter(Boolean);
-        const cmd = registry.getNode(path);
-        if (!cmd)
-            return `没有指令 ${path.join(' ')}。敲 ${registry.prefix}help 看可用指令。`;
-        const prefixDot = `${cmd.name}.`;
-        const children = all.filter(c => c.name.startsWith(prefixDot) && !c.name.slice(prefixDot.length).includes('.'));
-        return renderDetail(cmd, children, registry.prefix);
+        return path.length > 0 ? registry.detail(path, argv.session) : registry.overview(argv.session);
     });
-    commands.command('status', '显示系统状态').action(async () => {
-        const lines = ['**系统状态：**', ''];
-        // 按名枚举：这张表回答的只是"在不在"，其中大半个子系统本插件并不依赖，
-        // 按名动态查不产生依赖边，也就不会把它们拖进本插件的激活闸与关停顺序。
-        const checks = [
-            ['WebUI Server', services.get('webui-server') !== undefined],
-            ['CLI', services.get('cli') !== undefined],
-            ['LLM 服务', services.get('llm') !== undefined],
-            ['Agent', services.get('agent') !== undefined],
-            ['记忆服务', services.get('memory') !== undefined],
-            ['人格服务', services.get('persona') !== undefined],
-            ['Embedding', services.get('embedding') !== undefined],
-            ['向量库', services.get('vectorstore') !== undefined],
-        ];
-        for (const [label, ok] of checks) {
-            lines.push(`- ${label}: ${ok ? '✅ 可用' : '❌ 不可用'}`);
-        }
-        const toolService = services.get('tools');
-        lines.push(`- 已注册工具: ${toolService ? toolService.getAll().length : 0} 个`);
-        lines.push(`- 已注册指令: ${registry.getAll().length} 个`);
-        return lines.join('\n');
+    // 只给计数：逐项的检查（哪个插件为什么没起来、缺什么服务）交给 /doctor，末尾指过去
+    commands.use.command('status', t('statusDescription')).action(async () => {
+        const status = plugins.present ? plugins.use.getStatus() : undefined;
+        const count = (state) => status?.filter(p => p.state === state).length ?? 0;
+        return textLines([
+            t('statusTitle'),
+            '',
+            ...(status ? [t('statusPlugins', { active: count('active'), error: count('error') })] : []),
+            t('statusTools', { count: tools.present ? tools.use.getAll().length : 0 }),
+            t('statusCommands', { count: registry.getAll().length }),
+            '',
+            t('statusDoctor', { prefix: registry.prefix }),
+        ]);
     });
-    commands.command('shutdown', '关闭应用', { visibility: 'restricted' }).action(async () => {
-        const host = app.current;
-        if (!host)
-            return '无法访问应用服务';
+    commands.use.command('shutdown', t('shutdownDescription'), { visibility: 'restricted' }).action(async () => {
+        const host = app.use;
         setTimeout(async () => {
             await host.stop();
             process.exit(0);
         }, 500);
-        return '正在关闭应用…';
+        return t('shuttingDown');
     });
-    commands.command('restart', '重启应用', { visibility: 'restricted' }).action(async () => {
-        const host = app.current;
-        if (!host)
-            return '无法访问应用服务';
-        host.restart();
-        return '正在重启应用…';
+    commands.use.command('restart', t('restartDescription'), { visibility: 'restricted' }).action(async () => {
+        app.use.restart();
+        return t('restarting');
     });
-    async function runClear(cmdCtx, scope, types) {
+    // ===== /clear —— 清空记忆 =====
+    // 默认清当前会话；全局清理通过显式危险子指令 /clear all 进入，避免把高危语义藏在普通选项里。
+    // 类型由处理它的插件登记（本插件登记它清的消息历史 context），-t 的可选项按登记表现取，同一类型只列一次。
+    contributions.use.contribute('memory:clear-type', { id: 'context', label: t('typeContext') });
+    /** 登记的清理类型，按收集次序去重：同一类型几家登记时取第一家的显示名 */
+    function clearTypes() {
+        if (!contributions.present)
+            return [];
+        const byId = new Map();
+        for (const { spec } of contributions.use.collect('memory:clear-type'))
+            if (!byId.has(spec.id))
+                byId.set(spec.id, spec);
+        return [...byId.values()];
+    }
+    async function runClear(cmdCtx, scope, types, known) {
         const isGlobal = scope === 'all';
         // 预检：消息历史清不了就整条不执行。各插件的 memory:clear 中间件先于消息清理运行，放行就会清掉摘要、待办、
         // 附件等，留下「消息还在、其余已清」的半截状态。预检只决定执行与否，清理时另取当时的记忆后端
         const clearsMessages = !types || types.includes('context');
-        const memoryAtStart = memory.current;
+        const memoryAtStart = memory.present ? memory.use : undefined;
         if (clearsMessages && !memoryAtStart)
-            return '⚠ 记忆服务不可用，本次未清理任何内容。';
-        if (clearsMessages && isGlobal && !memoryAtStart?.clearAll) {
-            return '⚠ 记忆后端不支持全局清空消息历史，本次未清理任何内容。可用 -t 指定 context 以外的类型单独清理。';
-        }
+            return t('noMemoryBackend');
+        if (clearsMessages && isGlobal && !memoryAtStart?.clearAll)
+            return t('noGlobalClear');
         const clearData = {
             scope,
             types,
             sessionId: cmdCtx.sessionId,
             results: [],
         };
-        await hooks.run('memory:clear', clearData, async () => {
+        const run = () => hooks.use.run('memory:clear', clearData, async () => {
             if (!clearsMessages)
                 return;
             try {
                 // 中间件链可能要等一阵（在途落库、向量清空与保存），期间 memory 胜者可能已更换：按此刻的胜者清理，
                 // 不复用预检取到的实例，免得清到已下线的旧后端
-                const memoryService = memory.current;
-                if (!memoryService)
-                    throw new Error('记忆服务在清理期间下线');
+                if (!memory.present)
+                    throw new TextError(t('memoryGone'));
+                const memoryService = memory.use;
                 if (isGlobal) {
                     if (!memoryService.clearAll)
-                        throw new Error('清理期间换上的记忆后端不支持全局清空');
+                        throw new TextError(t('noGlobalClearMidway'));
                     await memoryService.clearAll();
                     clearData.results.push({
                         source: 'memory',
                         type: 'context',
                         success: true,
-                        message: '所有消息历史和归档已清空',
+                        message: t('historyClearedAll'),
                     });
                 }
                 else {
@@ -353,80 +294,72 @@ function registerCommands({ commands, gateway, storage, memory, authority, app,
                         source: 'memory',
                         type: 'context',
                         success: true,
-                        message: '当前会话消息历史已清空',
+                        message: t('historyClearedSession'),
                     });
                 }
             }
             catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                clearData.results.push({ source: 'memory', type: 'context', success: false, message: `清空失败: ${msg}` });
+                clearData.results.push({
+                    source: 'memory',
+                    type: 'context',
+                    success: false,
+                    message: t('clearFailed', { error: textOf(err) }),
+                });
             }
-            // 图片缓存与 vectorstore/persona/user-profile 等子系统的清理
-            // 统一由各自的 memory:clear middleware 处理（见上面的附件缓存 middleware）。
+            // 附件、向量、人设、用户档案等子系统的清理由各自的 memory:clear 中间件处理（附件归写入它的插件）。
             // runClear 仅负责调度 hook 与处理 memory 主体。
         });
-        const lines = clearData.results.map(r => `${r.success ? '✅' : '⚠'} ${r.message}`);
+        // 清消息历史时经 agent 先停下这些会话在跑的一轮、按住它们，再跑整条清理链：停下与按住在各家清理之外，不看它们的登记先后
+        await (clearsMessages && agent.present
+            ? agent.use.clearing(isGlobal ? undefined : [cmdCtx.sessionId], run)
+            : run());
+        // 每行就是各家的说明，成败已写在说明里
+        const lines = clearData.results.map(r => r.message);
         // 显式要求的类型逐个核对：没有任何一行标注该类型，就是没有已启用的插件处理它，照实说明
-        for (const t of CLEAR_TYPES) {
-            if (!types?.includes(t.id) || clearData.results.some(r => r.type === t.id))
+        for (const { id, label } of known) {
+            if (!types?.includes(id) || clearData.results.some(r => r.type === id))
                 continue;
-            lines.push(!isGlobal && t.globalOnly
-                ? `⚠ ${t.label}只在 ${registry.prefix}clear all 时清理，本次未清理`
-                : `⚠ ${t.label}：没有已启用的插件处理这一类型，未清理`);
+            lines.push(t('unhandledType', { type: label }));
         }
-        if (lines.length === 0)
-            return '无可清除的记忆模块。';
-        return lines.join('\n');
+        return lines.length === 0 ? t('nothingCleared') : textLines(lines);
     }
-    /**
-     * 清空共享会话（群/频道）所需的最低等级。私聊会话归用户本人，不受此限——
-     * 清自己的记忆是自助行为；群会话一人清掉会毁掉所有人的上下文，故要求同
-     * `visibility:'restricted'` 的等级 2。
-     */
-    const CLEAR_SHARED_MIN_LEVEL = 2;
     async function runClearFromOptions(argv, scope) {
+        const known = clearTypes();
         let types;
         try {
-            types = normalizeClearTypes(argv.options.type, registry.prefix);
+            types = normalizeClearTypes(argv.options.type, known, registry.prefix);
         }
         catch (err) {
-            return err instanceof Error ? err.message : String(err);
-        }
-        // 共享会话设防：静态声明只能给出与会话归属无关的策略，这一档必须在运行期判。
-        if (argv.session.sessionType && argv.session.sessionType !== 'private') {
-            const auth = authority.current;
-            const isOwner = auth?.isOwner(argv.session.platform, argv.session.userId) ?? false;
-            const level = auth?.listUsers().find(u => u.platform === argv.session.platform && u.userId === argv.session.userId)?.level ??
-                0;
-            if (!isOwner && level < CLEAR_SHARED_MIN_LEVEL) {
-                return `清空共享会话需要等级 ${CLEAR_SHARED_MIN_LEVEL}（当前 ${level}）。私聊里可以随时清理自己的会话。`;
-            }
+            return textOf(err);
         }
-        return runClear({ sessionId: argv.session.sessionId }, scope, types);
+        return runClear({ sessionId: argv.session.sessionId }, scope, types, known);
     }
-    const clearTypeOptDesc = `清理类型，可重复或用逗号分隔；all 为全部类型。${CLEAR_TYPES.map(t => `${t.id}：${t.label}${t.globalOnly ? '（仅全局清理）' : ''}`).join('；')}`;
-    commands
-        // 清空**当前会话**的记忆。风险随会话归属而变，静态声明取「最松的安全默认」：
-        // confirm:'session' 但不抬等级——私聊里会话是用户自己的，清自己的记忆属自助行为，
-        // 要 2 级等于剥夺；确认则挡住提示词注入触发的误清（需真人点一下）。
-        // 群聊会话是共享的，一人清掉毁掉所有人的上下文——那一档在 action 里按
-        // sessionType 另行设防（与 /bind 等私聊敏感指令同一模式）。
-        .command('clear', '清空当前会话记忆；用 --type 选择消息、摘要、向量、图片等清理类型', {
+    const clearTypeOption = {
+        description: t('clearTypeDescription'),
+        choices: () => [
+            { value: 'all', description: t('clearTypeAll') },
+            ...clearTypes().map(({ id, label }) => ({ value: id, description: label })),
+        ],
+    };
+    commands.use
+        // 清空**当前会话**的记忆；确认挡住提示词注入触发的误清（需真人回一句）。
+        .command('clear', t('clearDescription'), {
+        risk: 'sensitive',
         confirm: 'session',
     })
-        .option('type', '-t <type:string[]>', { description: clearTypeOptDesc })
+        .option('type', '-t <type:string[]>', clearTypeOption)
         .example('/clear')
         .example('/clear --type context,vector')
         .example('/clear -t vector -t image')
         .example('/clear all --type all')
         .action(async (argv) => runClearFromOptions(argv, 'session'));
-    commands
+    commands.use
         // 全局清空，比 /clear 更重：同样 dangerous（等级 2 + 二次确认）。
         // 原先只写 visibility:'restricted' 拿到了等级 2 但漏了 confirm。
-        .command('clear.all', '【危险】按 --type 清空全部会话；未指定类型时清空全部类型', {
+        .command('clear.all', t('clearAllDescription'), {
         risk: 'dangerous',
     })
-        .option('type', '-t <type:string[]>', { description: clearTypeOptDesc })
+        .option('type', '-t <type:string[]>', clearTypeOption)
         .action(async (argv) => runClearFromOptions(argv, 'all'));
 }
 //# sourceMappingURL=index.js.map