@aalis/plugin-user-profile 0.14.0 → 0.15.1

package/dist/index.js

@@ -1,15 +1,19 @@
 import { commands } from '@aalis/api-commands';
 import { contributions } from '@aalis/api-contributions';
 import { hooks } from '@aalis/api-hooks';
-import { lightestThinking, llm, resolveLLMModel } from '@aalis/api-llm';
+import { i18n, outputLanguageFor } from '@aalis/api-i18n';
+import { chatModelPicker, lightestThinking, llm } from '@aalis/api-llm';
 import { clearMetadataNamespaces, memory } from '@aalis/api-memory';
+import { persona } from '@aalis/api-persona';
 import { tools } from '@aalis/api-tools';
 import { userRelation } from '@aalis/api-user-relation';
 import { webuiServer } from '@aalis/api-webui';
-import { config, definePlugin, events, logger, optional } from '@aalis/core';
+import { config, definePlugin, events, lifecycle, logger, optional } from '@aalis/core';
 import { defineConfig, parseConfig } from '@aalis/schema-config';
-import { DIRECTIVE_KINDS, WellKnownMetadataKeys } from '@aalis/schema-message';
+import { TextError, textClauses, textLines, textOf } from '@aalis/schema-i18n';
+import { DIRECTIVE_KINDS, WellKnownMetadataKeys, wasAddressed } from '@aalis/schema-message';
 import { parseLLMJsonObject } from '@aalis/util-json-repair';
+import { t } from './texts.js';
 // ════════════════════════════════════════════════════════════
 // plugin-user-profile — 用户事实档案
 //
@@ -23,7 +27,7 @@ import { parseLLMJsonObject } from '@aalis/util-json-repair';
 // - 渐进合并：每次提取由 LLM 输出 add/remove 两个数组，自然演化
 // - 零侵入：通过 events + middleware 接入，不修改 agent / persona / memory
 //
-// 关系强度（relationScore, 0~100）计算规则：
+// 关系强度（relationScore, 0~100）计算规则（只算真人的话，带来源的注入不加）：
 // - 每条入站消息（无论 agent 是否回复）：+ relationIncrementWitness（默认 0.1，旁观档）
 // - 若 agent 触发回复，额外叠加：
 //     direct（私聊）        + relationIncrementDirect    默认 1.0
@@ -34,103 +38,105 @@ import { parseLLMJsonObject } from '@aalis/util-json-repair';
 // 例：群聊纯旁观一条 = +0.1；群聊被 @ 并回复 = +0.1 + 1.5 = +1.6；私聊一条 = +0.1 + 1.0 = +1.1
 // ════════════════════════════════════════════════════════════
 const PROFILE_NS = 'user:profile';
+/** 人设服务不在、或卡没取名时，提取提示里对机器人的称呼 */
+const BOT_FALLBACK_NAME = '机器人';
 const configSchema = defineConfig({
     extractEveryNMessages: {
         type: 'number',
-        label: '每 N 条消息提取一次',
-        description: '同一用户每发 N 条消息触发一次事实提取。无论 Aalis 是否回复都会计数，群聊中每人独立计数。设为 1 表示每条消息都尝试提取（不推荐）；设为 0 或负数则禁用提取（仍会注入已有档案）',
+        label: t('extractEveryLabel'),
+        description: t('extractEveryDescription'),
         default: 5,
     },
     historyForExtraction: {
         type: 'number',
-        label: '提取参考历史条数',
-        description: '触发提取时，喂给 LLM 的最近消息条数',
+        label: t('historyLabel'),
+        description: t('historyDescription'),
         default: 8,
     },
     maxFactsPerUser: {
         type: 'number',
-        label: '单用户事实上限',
-        description: '超出后按 updatedAt 升序淘汰最久未更新的，旧事实自动淘汰。最小有效值为 5（写入时自动下限），不支持设为 0 来禁用提取；若要禁用提取请将 extractEveryNMessages 设为 0',
+        label: t('maxFactsLabel'),
+        description: t('maxFactsDescription'),
         default: 30,
     },
     maxFactCharsPerItem: {
         type: 'number',
-        label: '单条事实字数上限',
-        description: '超出会被裁断，避免 LLM 输出长段落代替事实',
+        label: t('maxFactCharsLabel'),
+        description: t('maxFactCharsDescription'),
         default: 80,
     },
     maxOtherParticipants: {
         type: 'number',
-        label: '群聊其他参与者档案上限',
-        description: '群聊中除当前发言者外，最多加载多少人的档案摘要注入 LLM。0 表示禁用群聊多用户注入',
+        label: t('maxOthersLabel'),
+        description: t('maxOthersDescription'),
         default: 3,
     },
     maxFactsForOthers: {
         type: 'number',
-        label: '其他参与者摘要条数上限',
-        description: '群聊背景参与者每人只显示最近更新的 N 条事实，避免 prompt 过长',
+        label: t('maxFactsForOthersLabel'),
+        description: t('maxFactsForOthersDescription'),
         default: 5,
     },
     temporaryFactMaxAgeDays: {
         type: 'number',
-        label: '临时事实保留天数',
-        description: 'temporality=temporary 的事实超过该天数未更新后不再主动注入 prompt（仍保留在档案中，等待后续 update/remove）。0 表示不淡出',
+        label: t('temporaryMaxAgeLabel'),
+        description: t('temporaryMaxAgeDescription'),
         default: 90,
     },
     relationScoreDecayPerDay: {
         type: 'number',
-        label: '关系强度每日衰减',
-        description: '用户长期未互动时，relationScore 每天衰减的分数。0 表示不衰减',
+        label: t('decayLabel'),
+        description: t('decayDescription'),
         default: 0.5,
     },
     relationIncrementDirect: {
         type: 'number',
-        label: '私聊关系增量',
-        description: 'direct 触发时每条消息增加的关系强度',
+        label: t('directLabel'),
+        description: t('directDescription'),
         default: 1,
     },
     relationIncrementImmediate: {
         type: 'number',
-        label: '主动呼叫关系增量',
-        description: '群聊 @/名字主动触发时每条消息增加的关系强度',
+        label: t('immediateLabel'),
+        description: t('immediateDescription'),
         default: 1.5,
     },
     relationIncrementInterval: {
         type: 'number',
-        label: '群聊被动参与关系增量',
-        description: '群聊频率/活跃度被动触发或普通入站消息增加的关系强度',
+        label: t('intervalLabel'),
+        description: t('intervalDescription'),
         default: 0.5,
     },
     relationIncrementWitness: {
         type: 'number',
-        label: '旁观（不回复）关系增量',
-        description: '每条入站消息无论 agent 是否回复都加上的最低档增量。若 agent 触发回复，会再叠加 direct/immediate/interval 之一。0 表示旁观不加分；互动次数与最近互动时戳仍照记（衰减基准与最近互动排序的唯一来源）',
+        label: t('witnessLabel'),
+        description: t('witnessDescription'),
         default: 0.1,
     },
-    extractLLM: {
-        type: 'llm-ref',
-        label: '提取用模型',
-        description: '留空则使用当前 LLM 服务的默认模型。事实提取是简单结构化任务，推荐选择廉价/快速模型（如 deepseek-chat）以降低成本',
-    },
     allowGlobalBackfill: {
         type: 'boolean',
         onInvalid: 'error',
-        label: '允许跨会话补齐副档案',
-        description: '当前群/会话中的候选不足时，是否允许从其他群、私聊等跨会话中选取最近互动过的用户来补全「其他参与者背景摘要」。关闭后仅限当前上下文内出现过的用户',
+        label: t('backfillLabel'),
+        description: t('backfillDescription'),
         default: false,
     },
 });
-const KNOWN_CATEGORIES = [
-    '兴趣爱好',
-    '职业身份',
-    '人际关系',
-    '近期处境',
-    '价值观',
-    '性格特征',
-    '偏好',
-    '忌讳',
-    '其他',
-];
+/**
+ * 事实分类，用于 LLM 在同类下做覆写决策。分类值是给模型的、落盘的标识，界面显示这里的名字；
+ * 次序即提示词里列出与档案分组的次序
+ */
+const CATEGORY_NAMES = {
+    兴趣爱好: t('categoryInterests'),
+    职业身份: t('categoryOccupation'),
+    人际关系: t('categoryRelationships'),
+    近期处境: t('categorySituation'),
+    价值观: t('categoryValues'),
+    性格特征: t('categoryPersonality'),
+    偏好: t('categoryPreferences'),
+    忌讳: t('categoryTaboos'),
+    其他: t('categoryOther'),
+};
+const KNOWN_CATEGORIES = Object.keys(CATEGORY_NAMES);
 /** 生成事实的稳定短 ID（前缀 f 加 5 位 base36，对 30 条以内规模碰撞概率极低） */
 function genShortId(existing) {
     for (let i = 0; i < 8; i++) {
@@ -171,31 +177,34 @@ function isTargetUserMessage(message, userId, platform) {
     return !msgPlatform || !platform || msgPlatform === platform;
 }
 /**
- * 将文本标准化为可子串匹配的形式：去空白、去常见标点、toLowerCase。
- * 用于 sourceQuote 校验，容忍 LLM 轻微原词改写。
+ * 核对原话的规整，原话与语料用同一份：NFKC（全角与半角、兼容写法归成同一个字）、小写，去掉 Unicode 标点、空白与不显示的字符
+ * （表情里的变体选择符与连接符）；符号照留，「C++」不会只剩一个字母
  */
 function normalizeForQuoteMatch(s) {
     return s
+        .normalize('NFKC')
         .toLowerCase()
-        .replace(/[\s\u3000]+/g, '')
-        .replace(/[。，、；：？！“”‘’（）《》【】.,;:?!"'()[\]<>\-_~`*]/g, '');
+        .replace(/[\p{P}\s\p{Default_Ignorable_Code_Point}]+/gu, '');
 }
 /**
- * 拼接目标用户自己发言作为 sourceQuote 校验语料。
- * 只包含目标用户 role==='user' 且 metadata.userId 匹配的消息。
+ * 目标用户各条发言规整后的语料，原话的片段要落在其中某一条里。只收发言人自己写的字（存档另记的 SpokenContent，没记就是归档
+ * 正文本身）：被引用的原文、识图、语音转写、视频描述、文件正文与合并转发都不在发言人的话里
  */
 function buildTargetUserCorpus(history, userId, platform) {
     return history
         .filter(m => isTargetUserMessage(m, userId, platform))
-        .map(m => m.content ?? '')
-        .join('\n');
+        .map(m => {
+        const spoken = m.metadata?.[WellKnownMetadataKeys.SpokenContent];
+        return normalizeForQuoteMatch(typeof spoken === 'string' ? spoken : (m.content ?? ''));
+    });
 }
 /**
  * 渲染完整会话历史供提取 LLM 作为消歧上下文：
- * 每行带身份标签区分「目标用户」与「其他用户」，
- * 不做 strip（引用原话不会在目标用户语料中出现，sourceQuote 校验能拦住）。
+ * 每行带身份标签区分「目标用户」「其他用户」与她自己（botName），
+ * 不做 strip：给模型看的是归档正文（引用、附件描述与转发都在，消歧要用）；
+ * 核对原话另取发言人自己写的话（buildTargetUserCorpus）。
  */
-function renderHistoryForExtract(history, userId, platform) {
+function renderHistoryForExtract(history, userId, platform, botName) {
     return history
         .filter(m => (m.role === 'user' || m.role === 'assistant' || m.role === 'notice') && m.content)
         .map(m => {
@@ -204,8 +213,8 @@ function renderHistoryForExtract(history, userId, platform) {
         if (!content)
             return '';
         if (m.role === 'assistant') {
-            // Aalis 的回复：加标签让 LLM 知道用户是在跟谁互动，用于判断「对 Aalis 的行为」
-            return `[${time}] [Aalis]: ${content}`;
+            // 她的回复：加标签让 LLM 知道用户是在跟谁互动，用于判断用户对她的行为
+            return `[${time}] [${botName}]: ${content}`;
         }
         if (m.role === 'notice') {
             // 平台事件（群禁言 / 撤回 / 成员进出 / poke 等），供提取判断「用户被谁怎么了」之类上下文
@@ -222,6 +231,13 @@ function renderHistoryForExtract(history, userId, platform) {
         .filter(Boolean)
         .join('\n');
 }
+/** 解析一次提取的回复：在输出上限处停下的不完整，看着是合法 JSON 也不收。不能用时交回原因，写进日志与重试提示 */
+function readExtractReply(resp) {
+    if (resp.finishReason === 'length')
+        return { why: '在长度上限处被截断，不完整' };
+    const { parsed } = parseLLMJsonObject((resp.content ?? '').trim());
+    return parsed ? { parsed } : { why: '不是合法的 JSON 对象' };
+}
 const uses = {
     memory,
     llm,
@@ -230,21 +246,26 @@ const uses = {
     contributions,
     config,
     logger,
+    lifecycle,
     tools: optional(tools),
     commands: optional(commands),
     userRelation: optional(userRelation),
+    /** 提取提示里机器人的称呼取人设名；缺席时用中性称呼 */
+    persona: optional(persona),
+    /** 事实的语言：取全局层的语言列表（读者是 owner），缺席时按中文 */
+    i18n: optional(i18n),
     /** 档案页；不在时照常记档案 */
     webui: optional(webuiServer),
 };
 export default definePlugin({
     name: '@aalis/plugin-user-profile',
-    displayName: '用户事实档案',
+    displayName: t('displayName'),
     subsystem: 'memory',
     configSchema,
     uses,
     apply: registerUserProfile,
 });
-function registerUserProfile({ memory, llm, events, hooks, contributions, config, logger, tools, commands, userRelation, webui, }) {
+function registerUserProfile({ memory, llm, events, hooks, contributions, config, logger, lifecycle, tools, commands, userRelation, persona, i18n, webui, }) {
     const parsed = parseConfig(configSchema, config.use, logger.use);
     const cfg = {
         ...parsed,
@@ -259,17 +280,13 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
         relationIncrementImmediate: Math.max(0, parsed.relationIncrementImmediate),
         relationIncrementInterval: Math.max(0, parsed.relationIncrementInterval),
         relationIncrementWitness: Math.max(0, parsed.relationIncrementWitness),
-        extractLLM: parsed.extractLLM &&
-            typeof parsed.extractLLM === 'object' &&
-            parsed.extractLLM.provider &&
-            parsed.extractLLM.model
-            ? parsed.extractLLM
-            : undefined,
     };
     /** 每会话每用户累计入站消息数（用于 extractEveryNMessages 计数），不随提取重置 */
     const userMessageCount = new Map();
     /** 防止同一用户的提取并发触发 */
     const inflightExtractions = new Set();
+    /** 提取模型：llm 服务给本插件挑的能对话的那一个（见 chatModelPicker） */
+    const pickChatModel = chatModelPicker(llm, () => logger.use.warn('没有可用的对话模型，事实提取跳过'));
     const relationScorePrecision = Math.min(6, Math.max(decimalPlaces(cfg.relationScoreDecayPerDay), decimalPlaces(cfg.relationIncrementDirect), decimalPlaces(cfg.relationIncrementImmediate), decimalPlaces(cfg.relationIncrementInterval)));
     function userKeyOf(platform, userId) {
         return `${platform ?? ''}:${userId}`;
@@ -387,19 +404,19 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
             ref = undefined;
         }
         if (!Array.isArray(ref) || ref.length !== 2 || !ref.every(part => typeof part === 'string')) {
-            throw new Error(`不认识的事实：${rowKey}`);
+            throw new TextError(t('unknownFact', { rowKey }));
         }
         return ref;
     }
     const page = webui.use.definePage({
         key: 'profiles',
-        title: '用户档案',
+        title: t('profiles'),
         icon: 'contact',
         actions: {
             forgetFact: {
-                label: '删除',
+                label: t('forgetLabel'),
                 effect: 'destructive',
-                confirm: '删掉后，以后的对话里不再带上这条事实。',
+                confirm: t('forgetConfirm'),
                 row: true,
                 async handler({ rowKey }) {
                     const [userKey, factId] = parseFactRef(rowKey);
@@ -407,28 +424,28 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
                     const profile = await loadProfile(mem, userKey);
                     const hit = profile?.facts.find(f => f.id === factId);
                     if (!profile || !hit)
-                        throw new Error('这条事实已经不在档案里了');
+                        throw new TextError(t('factGone'));
                     await saveProfile(mem, userKey, {
                         ...profile,
                         facts: profile.facts.filter(f => f !== hit),
                         updatedAt: Date.now(),
                     });
                     page.invalidate();
-                    return `已删除：${hit.text}`;
+                    return t('forgotten', { text: hit.text });
                 },
             },
             clearProfile: {
-                label: '清空档案',
+                label: t('clearProfileLabel'),
                 effect: 'destructive',
-                confirm: '这个人的全部事实连同关系强度、互动次数一起清空。',
+                confirm: t('clearProfileConfirm'),
                 row: true,
                 async handler({ rowKey }) {
                     const mem = pinnedMemory();
                     if (!(await mem.getMetadata(PROFILE_NS, rowKey)))
-                        throw new Error(`${rowKey} 已经没有档案了`);
+                        throw new TextError(t('profileGone', { key: rowKey }));
                     await mem.deleteMetadata(PROFILE_NS, rowKey);
                     page.invalidate();
-                    return `已清空 ${rowKey} 的档案`;
+                    return t('profileCleared', { key: rowKey });
                 },
             },
         },
@@ -437,12 +454,12 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
                 type: 'table',
                 id: 'profiles',
                 rowKey: 'key',
-                description: '她从对话里记下的关于各人的事实，会带进以后的对话。这里只能删除，不能改写。',
-                empty: '还没有人的档案',
+                description: t('pageDescription'),
+                empty: t('pageEmpty'),
                 columns: [
-                    { key: 'key', label: '用户', primary: true },
-                    { key: 'facts', label: '事实', primary: true },
-                    { key: 'updatedAt', label: '最近记下', kind: 'time' },
+                    { key: 'key', label: t('columnUser'), primary: true },
+                    { key: 'facts', label: t('columnFacts'), primary: true },
+                    { key: 'updatedAt', label: t('columnLastNoted'), kind: 'time' },
                 ],
                 async data() {
                     const entries = await memory.use.listMetadata(PROFILE_NS);
@@ -460,12 +477,12 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
                         type: 'table',
                         id: 'facts',
                         rowKey: 'ref',
-                        empty: '这个人的档案里没有事实了',
+                        empty: t('factsEmpty'),
                         columns: [
-                            { key: 'text', label: '事实', primary: true },
-                            { key: 'category', label: '分类' },
-                            { key: 'temporality', label: '时效' },
-                            { key: 'updatedAt', label: '记下', kind: 'time' },
+                            { key: 'text', label: t('columnFact'), primary: true },
+                            { key: 'category', label: t('columnCategory') },
+                            { key: 'temporality', label: t('columnTerm') },
+                            { key: 'updatedAt', label: t('columnNoted'), kind: 'time' },
                         ],
                         rowActions: [{ action: 'forgetFact' }],
                         async data({ rowKey }) {
@@ -475,8 +492,8 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
                                 .map(f => ({
                                 ref: JSON.stringify([rowKey, f.id]),
                                 text: f.text,
-                                category: f.category ?? '',
-                                temporality: f.temporality === 'temporary' ? '近期' : '长期',
+                                category: f.category ? CATEGORY_NAMES[f.category] : '',
+                                temporality: f.temporality === 'temporary' ? t('termShort') : t('termLong'),
                                 updatedAt: f.updatedAt,
                             }));
                         },
@@ -499,14 +516,14 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
                 if (!x || typeof x !== 'object')
                     return [];
                 const o = x;
-                const t = typeof o.text === 'string' ? o.text.trim() : '';
-                if (!t)
+                const text = typeof o.text === 'string' ? o.text.trim() : '';
+                if (!text)
                     return [];
                 const category = normalizeCategory(o.category);
                 const sourceQuote = typeof o.sourceQuote === 'string' ? o.sourceQuote.trim() : '';
                 return [
                     {
-                        text: t,
+                        text,
                         category,
                         temporality: normalizeTemporality(o.temporality, category),
                         timeHint: normalizeTextField(o.timeHint),
@@ -521,15 +538,15 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
                     return [];
                 const o = x;
                 const id = typeof o.id === 'string' ? o.id.trim() : '';
-                const t = typeof o.text === 'string' ? o.text.trim() : '';
-                if (!id || !t)
+                const text = typeof o.text === 'string' ? o.text.trim() : '';
+                if (!id || !text)
                     return [];
                 const category = normalizeCategory(o.category);
                 const sourceQuote = typeof o.sourceQuote === 'string' ? o.sourceQuote.trim() : '';
                 return [
                     {
                         id,
-                        text: t,
+                        text,
                         category,
                         temporality: normalizeTemporality(o.temporality, category),
                         timeHint: normalizeTextField(o.timeHint),
@@ -538,27 +555,38 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
                 ];
             })
             : [];
+        // 只给 id 的字符串没有原话：当成只有 id 的一项，校验时按没给原话丢弃并 warn，不静默放过
         const remove = Array.isArray(obj.remove)
-            ? obj.remove
-                .filter((x) => typeof x === 'string' && x.trim().length > 0)
-                .map(s => s.trim())
+            ? obj.remove.flatMap(x => {
+                const item = typeof x === 'string' ? { id: x } : x;
+                if (!item || typeof item !== 'object')
+                    return [];
+                const o = item;
+                const id = typeof o.id === 'string' ? o.id.trim() : '';
+                if (!id)
+                    return [];
+                const sourceQuote = typeof o.sourceQuote === 'string' ? o.sourceQuote.trim() : '';
+                return [{ id, sourceQuote }];
+            })
             : [];
         return { add, update, remove };
     }
     /** 调用 LLM 从历史中提取/修订事实，返回 add / update / remove 三类操作。 */
-    async function llmExtractFacts(history, existingFacts, nickname, userId, platform) {
+    async function llmExtractFacts(history, existingFacts, nickname, userId, platform, sessionId) {
         const empty = {
             add: [],
             update: [],
             remove: [],
         };
+        // 她在提示里的称呼取这个会话的人设名，标签、规则与例句同一个名字
+        const botName = (persona.present ? persona.use.getPersonaName({ sessionId, platform }) : '') || BOT_FALLBACK_NAME;
         const sys = '你是用户档案管理员。输入是一段多用户会话历史，每行开头有身份标签：' +
-            '`[目标用户 X(uid)]`、`[其他用户 Y(uid)]` 或 `[Aalis]`。上下文仅供消歧，' +
-            '**只允许根据「目标用户」自己的发言写入事实**，不能根据其他用户、Aalis 的猜测或提问写入事实。' +
+            `\`[目标用户 X(uid)]\`、\`[其他用户 Y(uid)]\` 或 \`[${botName}]\`。上下文仅供消歧，` +
+            `**只允许根据「目标用户」自己的发言写入事实**，不能根据其他用户、${botName} 的猜测或提问写入事实。` +
             '\n\n你可以执行三种操作（在一次输出里组合）：' +
             '\n- add: 添加新事实，需指定 text、category、sourceQuote' +
             '\n- update: 用 id 精确替换某条已知事实，同样需 sourceQuote（优先使用 update 而非 add 来避免重复）' +
-            '\n- remove: 用 id 删除已被推翻、过时的事实（不需 sourceQuote）' +
+            '\n- remove: 用 id 删除已被目标用户推翻的事实，同样需 sourceQuote（目标用户推翻它的那句原话）' +
             '\n\n规则：' +
             '\n1. 事实的**主语必须是「目标用户」本人**，不能是 ta 转述、讨论、评价的第三方。' +
             '即使 sourceQuote 出自目标用户原话，也要先在脑中追问：' +
@@ -566,34 +594,34 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
             '\n   - 是认真陈述，还是反讽/否定/假设/角色扮演？（"我可不喜欢爵士" → 否定，不写；跑团扮演 NPC 的台词 → 不写）' +
             '\n   - 如果原始依据来自「其他用户」的发言，即使在说目标用户，也不允许写入（他人可能记错、说反话）' +
             '\n   **拿不准就不写。profile 漏几条没关系，写错才麻烦。**' +
-            '\n   ⚠️ 例外——`人际关系` 类：除上述通用规则外，该类还允许记录目标用户**与 Aalis 之间长期可观察的关系模式**，' +
+            `\n   ⚠️ 例外——\`人际关系\` 类：除上述通用规则外，该类还允许记录目标用户**与 ${botName} 之间长期可观察的关系模式**，` +
             '包含两种情况：' +
-            '\n   (a) 行为身份类：用户在 Aalis 项目中扮演的角色或长期重复的行为' +
-            '（示例 text：「是 Aalis 的开发维护者」「经常向 Aalis 提交功能建议」「常帮助测试和排查 Aalis 的故障」）' +
-            '\n   (b) 长期情感模式类：用户对 Aalis 表现出的**反复出现的态度倾向**（不是单次情绪）' +
-            '（示例 text：「常对 Aalis 表达依赖与喜爱」「习惯把日常烦恼向 Aalis 倾诉」「喜欢调侃 Aalis」）' +
+            `\n   (a) 行为身份类：用户围绕 ${botName} 扮演的角色或长期重复的行为` +
+            `（示例 text：「是 ${botName} 的开发维护者」「经常向 ${botName} 提交功能建议」「常帮助测试和排查 ${botName} 的故障」）` +
+            `\n   (b) 长期情感模式类：用户对 ${botName} 表现出的**反复出现的态度倾向**（不是单次情绪）` +
+            `（示例 text：「常对 ${botName} 表达依赖与喜爱」「习惯把日常烦恼向 ${botName} 倾诉」「喜欢调侃 ${botName}」）` +
             '\n   ❌ 严禁仅凭单次发言推断情感事实：一次抱怨/一次感谢/一次撒娇都不算"模式"，不写。' +
             '必须是已有事实佐证 + 本轮再次出现的同类行为才允许 update 强化，或会话历史多处反复出现才允许 add。' +
             '依据必须是「目标用户」发言中可直接推断的内容，sourceQuote 取目标用户发言原话。' +
-            '\n2. **sourceQuote 必须是「目标用户」自己发言中的原话片段**，可以是某一句话的一部分，必须能一字不改在「目标用户」某行的原文中找到；不要采用「其他用户」的原话，不要自己总结改写' +
+            '\n2. **sourceQuote 必须是「目标用户」自己发言中的原话片段**，可以是某一句话的一部分，必须能一字不改在「目标用户」某行的原文中找到；不要采用「其他用户」的原话，不要自己总结改写；' +
+            '只算 ta 自己写的字：行首的发送者前缀、行里附带的「[引用 … 的消息: …]」、图片与语音视频的描述、文件内容、合并转发都不算' +
             '\n3. 在同一 category 下，如果新信息与已有事实在含义上重叠（例如已知"喜欢猫"，新信息"还喜欢狗"），应以 update 改写原 id 为更全面的版本，而不是 add 再加一条' +
             '\n4. 如果新对话明确推翻或修正了某条已知事实（如已知"在北京工作"，但用户说"我刚搬到上海"），用 update 替换或 remove 删除' +
-            `\n5. 每条 text 用一句简洁中文，不超过 ${cfg.maxFactCharsPerItem} 字，不带「用户」「他」等代词，直接陈述事实` +
+            `\n5. 每条 text 用一句简洁的 ${outputLanguageFor(i18n, { host: true }, 'zh-CN')}，不超过 ${cfg.maxFactCharsPerItem} 个字符，不带「用户」「他」等代词，直接陈述事实` +
             '\n6. 如果没有任何更新，或所有候选都拿不准，三个数组都返回空——**保守优先**' +
             `\n7. category 必须是以下之一：${KNOWN_CATEGORIES.join('、')}` +
             '\n8. 每条 add/update 都必须给出 temporality：长期稳定偏好、性格、身份、人际关系用 permanent；近期状态、正在进行的事、短期计划用 temporary' +
             '\n9. 如果对话中出现明确或隐含时间（如“最近”“上周”“今年4月”“昨天”），用 timeHint 记录简短时间线索；没有就省略或用空字符串' +
             '\n\n输出严格的 JSON（不要其他文本）：' +
-            '\n{"add": [{"text": "...", "category": "...", "temporality": "permanent|temporary", "timeHint": "...", "sourceQuote": "目标用户发言中的原话片段"}], "update": [{"id": "已知事实的id", "text": "新表述", "category": "...", "temporality": "permanent|temporary", "timeHint": "...", "sourceQuote": "目标用户发言中的原话片段"}], "remove": ["已知事实的id"]}';
+            '\n{"add": [{"text": "...", "category": "...", "temporality": "permanent|temporary", "timeHint": "...", "sourceQuote": "目标用户发言中的原话片段"}], "update": [{"id": "已知事实的id", "text": "新表述", "category": "...", "temporality": "permanent|temporary", "timeHint": "...", "sourceQuote": "目标用户发言中的原话片段"}], "remove": [{"id": "已知事实的id", "sourceQuote": "目标用户发言中的原话片段"}]}';
         const factListText = existingFacts.length > 0
             ? existingFacts.map(f => `[${f.id}] (${f.category ?? '未分类'}) ${f.text}`).join('\n')
             : '（暂无）';
         const who = nickname ? `${nickname}（${userId}）` : userId;
-        const renderedHistory = renderHistoryForExtract(history, userId, platform);
+        const renderedHistory = renderHistoryForExtract(history, userId, platform, botName);
         const user = `# 提取目标\n${who}\n\n# 已知事实（带 id，请在 update/remove 中精确引用 id）\n${factListText}` +
             `\n\n# 会话历史（含多用户，仅供消歧；只能从「目标用户」发言中提取事实）\n${renderedHistory || '（暂无会话历史）'}`;
-        // 优先用 cfg.extractLLM 指定的模型；否则取默认 chat-capable LLM。
-        const entry = resolveLLMModel(llm, cfg.extractLLM, ['chat']);
+        const entry = pickChatModel();
         if (!entry)
             return empty;
         const extractLlm = entry.use;
@@ -602,27 +630,27 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
                 { role: 'system', content: sys },
                 { role: 'user', content: user },
             ];
+            // 提取是本插件自己发起的：停用、停机时随之停下（出错照旧只记 debug、这一批不写）
             const resp = await extractLlm.chat({
                 messages: baseMessages,
                 temperature: 0.2,
                 maxTokens: 800,
                 think: lightestThinking(extractLlm),
+                signal: lifecycle.use.signal,
             });
-            let text = (resp.content ?? '').trim();
-            if (!text)
-                return empty;
-            let { parsed } = parseLLMJsonObject(text);
-            if (!parsed) {
-                // util-json-repair 已尝试剥 fence + 修裸引号 + 补括号；仍失败 → 模型多半
-                // 写成了纯文本/markdown。给一次显式反馈再来一次，避免一次失败丢失整批事实。
-                logger.use.warn(`[user-profile] LLM 输出无法解析为 JSON，尝试重试一次。原文前 200 字：${text.slice(0, 200)}`);
+            const text = (resp.content ?? '').trim();
+            let reply = readExtractReply(resp);
+            if ('why' in reply) {
+                // 截断，或 util-json-repair 剥过围栏、修过裸引号仍不是合法 JSON（空回复也算：提示词要求没有事实也回三个空数组）：给一次
+                // 显式反馈再来一次，避免一次失败丢失整批事实
+                logger.use.warn(`[user-profile] LLM 输出${reply.why}，尝试重试一次。原文前 200 字：${text.slice(0, 200)}`);
                 const retryResp = await extractLlm.chat({
                     messages: [
                         ...baseMessages,
                         { role: 'assistant', content: text },
                         {
                             role: 'user',
-                            content: '你上一条输出无法被 JSON.parse（很可能是包了 markdown 代码块、夹杂解释文字、或被截断）。' +
+                            content: `你上一条输出${reply.why}。` +
                                 '请只输出**一个**合法的 JSON 对象，第一个字符必须是 `{`、最后一个字符必须是 `}`，' +
                                 '禁止 ```json 围栏、禁止任何解释、禁止 markdown。如果实在没有可写入的事实，' +
                                 '就输出 `{"add":[],"update":[],"remove":[]}`。',
@@ -631,45 +659,42 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
                     temperature: 0.2,
                     maxTokens: 800,
                     think: lightestThinking(extractLlm),
+                    signal: lifecycle.use.signal,
                 });
-                text = (retryResp.content ?? '').trim();
-                ({ parsed } = parseLLMJsonObject(text));
-                if (!parsed) {
-                    logger.use.warn(`[user-profile] LLM 重试后仍无法解析 JSON，放弃本批次。重试原文前 200 字：${text.slice(0, 200)}`);
+                reply = readExtractReply(retryResp);
+                if ('why' in reply) {
+                    logger.use.warn(`[user-profile] LLM 重试后输出仍${reply.why}，放弃本批次。重试原文前 200 字：${(retryResp.content ?? '').trim().slice(0, 200)}`);
                     return empty;
                 }
                 logger.use.debug('[user-profile] LLM 重试后解析成功');
             }
-            const { add, update, remove } = parseFactOps(parsed);
-            // sourceQuote 校验：quote 可能跨多条消息（LLM 用 \n 拼接），
-            // 因此按行拆分，每行（非空）都必须能在「目标用户」语料中找到 normalize 后的子串。
-            // 这样即使行与行之间夹着其他用户的消息也不会被错误拒收。
-            const targetCorpus = normalizeForQuoteMatch(buildTargetUserCorpus(history, userId, platform));
-            const validateSourceQuote = (item, kind) => {
-                const q = item.sourceQuote?.trim() ?? '';
-                if (!q) {
-                    logger.use.warn(`[user-profile] 丢弃 ${kind} fact（未提供 sourceQuote）: ${item.text}`);
+            const { add, update, remove } = parseFactOps(reply.parsed);
+            // 增改删都要附原话：按行拆开（quote 可能跨多条消息，LLM 用 \n 拼接），每行规整后（normalizeForQuoteMatch）要落在目标用户
+            // 自己写的某一条话里（见 buildTargetUserCorpus），任一片段找不到整条丢弃并 warn；规整后不含字母或数字的行不算片段，一个
+            // 片段都没有的按没给原话。模型会凭空编事实，也会把别人的话、图上的字记到他头上，核对原话挡的是这两种。不设字数下限：接在
+            // 问句后面的「是的」是合法的原话；也不核对事实能不能从原话推出来：每次提取要多一次调用
+            const targetCorpus = buildTargetUserCorpus(history, userId, platform);
+            const validateSourceQuote = (quote, kind, what) => {
+                const fragments = quote
+                    .split(/\r?\n/)
+                    .map(line => ({ line, normalized: normalizeForQuoteMatch(line) }))
+                    .filter(({ normalized }) => /[\p{L}\p{N}]/u.test(normalized));
+                if (fragments.length === 0) {
+                    logger.use.warn(`[user-profile] 丢弃 ${kind} fact（未提供 sourceQuote）: ${what}`);
                     return false;
                 }
-                const lines = q
-                    .split(/\r?\n/)
-                    .map(l => l.trim())
-                    .filter(l => l.length > 0);
-                const fragments = lines.length > 0 ? lines : [q];
-                for (const frag of fragments) {
-                    const normalized = normalizeForQuoteMatch(frag);
-                    if (!normalized)
-                        continue;
-                    if (!targetCorpus.includes(normalized)) {
-                        logger.use.warn(`[user-profile] 丢弃 ${kind} fact（sourceQuote 片段不在目标用户 ${userId} 发言中）: text="${item.text}" fragment="${frag}"`);
+                for (const { line, normalized } of fragments) {
+                    if (!targetCorpus.some(spoken => spoken.includes(normalized))) {
+                        logger.use.warn(`[user-profile] 丢弃 ${kind} fact（sourceQuote 片段不在目标用户 ${userId} 发言中）: ${what} fragment="${line.trim()}"`);
                         return false;
                     }
                 }
                 return true;
             };
-            const validatedAdd = add.filter(item => validateSourceQuote(item, 'add'));
-            const validatedUpdate = update.filter(item => validateSourceQuote(item, 'update'));
-            return { add: validatedAdd, update: validatedUpdate, remove };
+            const validatedAdd = add.filter(item => validateSourceQuote(item.sourceQuote, 'add', item.text));
+            const validatedUpdate = update.filter(item => validateSourceQuote(item.sourceQuote, 'update', item.text));
+            const validatedRemove = remove.filter(item => validateSourceQuote(item.sourceQuote, 'remove', `id=${item.id}`));
+            return { add: validatedAdd, update: validatedUpdate, remove: validatedRemove };
         }
         catch (err) {
             logger.use.debug(`事实提取 LLM 调用失败：${err instanceof Error ? err.message : String(err)}`);
@@ -688,8 +713,6 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
             return cfg.relationIncrementImmediate;
         if (triggerType === 'interval')
             return cfg.relationIncrementInterval;
-        if (triggerType === 'idle')
-            return 0;
         if (triggerType === 'witness')
             return cfg.relationIncrementWitness;
         return cfg.relationIncrementDirect;
@@ -705,12 +728,11 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
         const daysSinceLast = last ? Math.max(0, (now - last) / 86_400_000) : 0;
         const decayed = clampRelationScore((profile.relationScore ?? 0) - daysSinceLast * cfg.relationScoreDecayPerDay);
         const nextScore = clampRelationScore(decayed + relationIncrementFor(triggerType));
-        const shouldCount = countInteraction && triggerType !== 'idle';
         return {
             ...profile,
             relationScore: nextScore,
-            interactionCount: (profile.interactionCount ?? 0) + (shouldCount ? 1 : 0),
-            lastInteractionAt: shouldCount ? now : profile.lastInteractionAt,
+            interactionCount: (profile.interactionCount ?? 0) + (countInteraction ? 1 : 0),
+            lastInteractionAt: countInteraction ? now : profile.lastInteractionAt,
             updatedAt: now,
         };
     }
@@ -813,14 +835,14 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
             if (!history.some(m => isTargetUserMessage(m, userId, platform)))
                 return;
             const snapshotFacts = (await loadProfile(mem, userKey))?.facts ?? [];
-            const ops = await llmExtractFacts(history, snapshotFacts, nickname, userId, platform);
+            const ops = await llmExtractFacts(history, snapshotFacts, nickname, userId, platform, sessionId);
             const hasFactOps = ops.add.length > 0 || ops.update.length > 0 || ops.remove.length > 0;
             if (!hasFactOps)
                 return;
             // 以 LLM 返回后重读的档案为合并基底：调用期间档案可能被清空或删了事实，以调用前的快照
             // 为基底会把删掉的内容整份写回；重读也保住期间写入的 relationScore 等字段
             const fresh = (await loadProfile(mem, userKey)) ?? { facts: [], updatedAt: 0 };
-            const newFacts = mergeFactList(fresh.facts, ops.add, dropUpdatesOfDeletedFacts(ops.update, snapshotFacts, fresh.facts), ops.remove);
+            const newFacts = mergeFactList(fresh.facts, ops.add, dropUpdatesOfDeletedFacts(ops.update, snapshotFacts, fresh.facts), ops.remove.map(r => r.id));
             await saveProfile(mem, userKey, {
                 ...fresh,
                 facts: newFacts,
@@ -850,9 +872,10 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
     // 注:钩子无优先级机制,同相位 handler 按插件激活序执行;本 handler 只做副作用
     // (更新关系分数)不改消息,与其它 handler 顺序无关。
     // 关系强度与"是否触发回复"绑定，因此仍走 agent:input:before 中间件。
+    // 只算真人的话，与旁观那一路同一个判据：带来源的注入（子任务的任务消息、好友申请通知等）不是谁在跟她说话，不加
     hooks.use.middleware('agent:input:before', async (data, next) => {
-        const { userId, platform, triggerType } = data.message;
-        if (userId) {
+        const { userId, platform, triggerType, source } = data.message;
+        if (userId && !source) {
             const userKey = userKeyOf(platform, userId);
             try {
                 // 仅叠加 score，互动计数与时戳由 witness 路径统一负责，
@@ -865,13 +888,25 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
         }
         await next();
     });
+    // 本插件自己发起的后台写（旁观关系更新、事实提取）记在这里：收尾时等它们落定再撤回。信号在收尾开始时已断，提取停在当前
+    // 这一步，已经开始的写入写完
+    const running = new Set();
+    const track = (work) => {
+        running.add(work);
+        void work.then(() => running.delete(work));
+    };
+    lifecycle.use.onDrain(async () => {
+        while (running.size > 0)
+            await Promise.all(running);
+    }, '等在途的档案写入');
     // ─── 事实提取触发：每条入站消息落库后立即计数，与 agent 是否回复无关 ───
     // 监听 message-archive 在 archiveIncoming 落库成功后发出的 inbound:message:archived 事件，
     // 确保缓冲消息（onebot saveBufferedMessage 等不触发 agent 回复的路径）也能纳入计数。
     events.use.on('inbound:message:archived', data => {
         const { sessionId, incoming } = data;
         const { userId, platform, nickname } = incoming;
-        if (!userId)
+        // 带来源的注入不是这个账号说的话：不计旁观、不计提取，也就不为它带的账号（如子任务的 parent:<父会话>）建档
+        if (!userId || incoming.source)
             return;
         // 旁观档位：每条入站消息都加 witness 增量（默认 0.1），与 agent 是否回复无关。
         // agent:input:before 中间件在触发回复时会再叠加 direct/immediate/interval 增量。
@@ -879,12 +914,12 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
         // lastInteractionAt 的唯一写点，设门会连带关掉计数与时戳（衰减基准、最近互动
         // 排序全失效）。增量为 0 时 relationIncrementFor 自然返回 0，不加分即可。
         const userKey = userKeyOf(platform, userId);
-        void updateRelationForUser(userKey, 'witness').catch((err) => logger.use.debug(`witness 关系更新异常 (${userKey}): ${err instanceof Error ? err.message : String(err)}`));
+        track(updateRelationForUser(userKey, 'witness').catch((err) => logger.use.debug(`witness 关系更新异常 (${userKey}): ${err instanceof Error ? err.message : String(err)}`)));
         const countKey = extractionCountKeyOf(sessionId, platform, userId);
         const count = (userMessageCount.get(countKey) ?? 0) + 1;
         userMessageCount.set(countKey, count);
         if (cfg.extractEveryNMessages > 0 && count % cfg.extractEveryNMessages === 0) {
-            void triggerExtractionForUser(sessionId, userId, platform ?? '', nickname).catch((err) => logger.use.debug(`事实提取异常 (${countKey}): ${err instanceof Error ? err.message : String(err)}`));
+            track(triggerExtractionForUser(sessionId, userId, platform ?? '', nickname).catch((err) => logger.use.debug(`事实提取异常 (${countKey}): ${err instanceof Error ? err.message : String(err)}`)));
         }
     });
     function isFactActive(fact) {
@@ -905,36 +940,50 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
             meta.push('临时状态');
         return `- ${fact.text}（${meta.join('；')}）`;
     }
-    /** 将一个用户的 Fact[] 渲染为分组文本块 */
+    /** 生效的事实按分类分组，次序同 KNOWN_CATEGORIES；没有分类的归「其他」。给模型的档案块与 /profile 共用 */
+    function groupFacts(facts) {
+        const active = facts.filter(isFactActive);
+        return KNOWN_CATEGORIES.flatMap(cat => {
+            const items = active.filter(f => (f.category ?? '其他') === cat);
+            return items.length > 0 ? [[cat, items]] : [];
+        });
+    }
+    /** 将一个用户的 Fact[] 渲染为分组文本块（给模型的） */
     function renderProfileBlock(facts, label, compact) {
-        const groups = new Map();
-        const activeFacts = facts.filter(isFactActive);
-        // compact 模式（群聊背景参与者）：只取最近更新的 N 条，不分组
-        const subset = compact
-            ? [...activeFacts].sort((a, b) => b.updatedAt - a.updatedAt).slice(0, cfg.maxFactsForOthers)
-            : activeFacts;
-        for (const f of subset) {
-            const key = f.category ?? '其他';
-            if (!groups.has(key))
-                groups.set(key, []);
-            groups.get(key).push(renderFactLine(f, !compact));
-        }
         if (compact) {
-            // compact 模式：平铺，不加分组标题
+            // compact 模式（群聊背景参与者）：只取最近更新的 N 条，平铺，不加分组标题
+            const subset = facts
+                .filter(isFactActive)
+                .sort((a, b) => b.updatedAt - a.updatedAt)
+                .slice(0, cfg.maxFactsForOthers);
             return `### ${label}\n${subset.map(f => renderFactLine(f, false)).join('\n')}`;
         }
-        const sections = [];
-        for (const cat of KNOWN_CATEGORIES) {
-            const items = groups.get(cat);
-            if (items && items.length > 0)
-                sections.push(`## ${cat}\n${items.join('\n')}`);
-        }
-        for (const [cat, items] of groups) {
-            if (!KNOWN_CATEGORIES.includes(cat) && items.length > 0) {
-                sections.push(`## ${cat}\n${items.join('\n')}`);
-            }
-        }
-        return sections.join('\n\n');
+        return groupFacts(facts)
+            .map(([cat, items]) => `## ${cat}\n${items.map(f => renderFactLine(f, true)).join('\n')}`)
+            .join('\n\n');
+    }
+    /** /profile 的回复：与给模型的档案块同一分组与版式，分类名与说明按读者语言 */
+    function profileText(profile, userKey) {
+        const factText = (fact) => t('factLine', {
+            text: fact.text,
+            meta: textClauses([
+                ...(fact.timeHint ? [t('factTimeHint', { hint: fact.timeHint })] : []),
+                t('factObserved', { at: fact.observedAt }),
+                ...(fact.temporality === 'temporary' ? [t('factTemporary')] : []),
+            ]),
+        });
+        return textLines([
+            t('profileHead', { key: userKey }),
+            t('profileMeta', {
+                score: (profile.relationScore ?? 0).toFixed(relationScorePrecision),
+                count: profile.interactionCount ?? 0,
+            }),
+            ...groupFacts(profile.facts).flatMap(([cat, items]) => [
+                '',
+                t('section', { name: CATEGORY_NAMES[cat] }),
+                ...items.map(factText),
+            ]),
+        ]);
     }
     function renderRelationLine(profile) {
         const score = profile.relationScore ?? 0;
@@ -943,28 +992,33 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
             return '';
         return `关系强度：${score.toFixed(relationScorePrecision)}/100；累计互动：${count} 次。`;
     }
-    // ─── LLM 调用前注入（agent:prompt 贡献 / turn-context 槽——档案按当前发言者取材、换人即变，落历史后护前缀缓存）：根据 triggerType 区分主发言者语义 ───
-    //   direct/immediate/undefined → view.userId 是主发言者，注入完整档案 + 其他参与者摘要
+    // ─── LLM 调用前注入（agent:prompt 贡献 / turn-context 槽——档案按当前发言者取材、换人即变，落历史后护前缀缓存）：按这一轮各条输入的 triggerType 区分主发言者语义 ───
+    //   direct/immediate/undefined → 点名的输入（带来源的注入不算，见 wasAddressed），它的发言者是主发言者：各注入完整档案，其余参与者给摘要
     //   interval                   → 无主发言者（只是恰好撞上频率），所有参与者一律 compact 摘要
     //   idle                       → 无 userId，只注入历史 messages 中出现的参与者 compact 摘要
-    // 多块返回保序共键：主发言者档案 → 其他参与者。
+    // 没有一条点名的输入时没有主发言者。多块返回保序共键：各主发言者档案（按输入先后）→ 其他参与者。
     contributions.use.contribute('agent:prompt', {
         id: 'user-profile',
         anchor: 'turn-context',
         async build(data) {
-            // 干跑(token 快照)跳过档案加载——该路径 userId 为空串,加载既昂贵又无意义
+            // 干跑(token 快照)跳过档案加载——该路径没有输入,加载既昂贵又无意义
             if (data.dryRun)
                 return null;
             const mem = memory.present ? memory.use : undefined;
             const blocksToInsert = [];
-            const trigger = data.triggerType ?? 'direct';
-            const hasPrimarySpeaker = trigger === 'direct' || trigger === 'immediate';
+            const addressed = data.inputs.map(({ message }) => message).filter(wasAddressed);
+            const hasPrimarySpeaker = addressed.length > 0;
+            /** 主发言者：点名的输入里有账号的发言者，按 userKey 去重、按输入先后 */
+            const primaries = new Map();
+            for (const { platform, userId } of addressed) {
+                if (userId)
+                    primaries.set(userKeyOf(platform, userId), userId);
+            }
             // 1. 主发言者完整档案：仅在确实有人在「和 Aalis 对话」时注入
-            if (hasPrimarySpeaker && data.userId) {
-                const userKey = userKeyOf(data.platform, data.userId);
+            for (const [userKey, userId] of primaries) {
                 const profile = await loadProfileLenient(mem, userKey);
                 if (profile?.facts.some(isFactActive)) {
-                    const body = renderProfileBlock(profile.facts, data.userId, false);
+                    const body = renderProfileBlock(profile.facts, userId, false);
                     const relationLine = renderRelationLine(profile);
                     // 可选：从 user-relation 服务取「同社群活跃成员」（按配置的社群发现算法所得标签 + PageRank 排序）。
                     // 服务不存在 / 节点没社群标签 / 报错都静默跳过；该字段是锦上添花，不破坏档案主体。
@@ -982,7 +1036,7 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
                     catch (err) {
                         logger.use.debug(`读取 community peers 失败: ${err instanceof Error ? err.message : String(err)}`);
                     }
-                    const block = `# 关于当前对话者（${data.userId}）的已知事实\n` +
+                    const block = `# 关于当前对话者（${userId}）的已知事实\n` +
                         '以下是你跨会话长期积累的关于该用户的事实，用于让回应更自然贴合其个性。' +
                         '不要主动罗列这些事实，也不要让用户觉得你在「读档案」，而是让它自然影响你的语气和话题选择。' +
                         '这些事实来自零散对话的推断，未必完全准确；也不要把它们与对话历史片段拼接成新的强陈述，' +
@@ -997,10 +1051,8 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
             // 2. 群聊其他参与者：按最近互动优先加载档案
             //    - 先从当前 LLM 上下文的 messages 中倒序收集最近发言者
             //    - 再从跨会话 user:profile metadata 中按 lastInteractionAt 倒序补齐
-            //    - hasPrimarySpeaker 为 true 时排除主发言者
-            //    - hasPrimarySpeaker 为 false 时（interval/idle）所有人平等显示
+            //    - 排除主发言者；没有主发言者时（interval/idle）所有人平等显示
             if (cfg.maxOtherParticipants > 0) {
-                const primaryKey = hasPrimarySpeaker && data.userId ? userKeyOf(data.platform, data.userId) : undefined;
                 const others = new Map();
                 const candidateLimit = Math.max(cfg.maxOtherParticipants * 5, cfg.maxOtherParticipants + 10);
                 function addOther(userId, platform, nickname) {
@@ -1008,7 +1060,7 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
                     if (!uid)
                         return false;
                     const userKey = userKeyOf(platform, uid);
-                    if (primaryKey && userKey === primaryKey)
+                    if (primaries.has(userKey))
                         return false;
                     if (others.has(userKey))
                         return false;
@@ -1082,13 +1134,17 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
         },
     });
     // ─── 参与统一的 memory:clear ───
+    // 用户档案是跨会话的，只在清理全部会话时清：会话级清理不动它，显式选了 user-profile 时回一行未清理（不带类型的会话级清理，
+    // 含删除会话，不出这一行）
+    contributions.use.contribute('memory:clear-type', { id: 'user-profile', label: t('clearType') });
     hooks.use.middleware('memory:clear', async (data, next) => {
         if (data.types && !data.types.includes('user-profile')) {
             await next();
             return;
         }
         if (data.scope !== 'all') {
-            // 用户档案是跨会话的，会话级清除不动它
+            if (data.types)
+                data.results.push({ source: 'user-profile', type: 'user-profile', success: false, message: t('clearSkipped') });
             await next();
             return;
         }
@@ -1107,16 +1163,15 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
                 source: 'user-profile',
                 type: 'user-profile',
                 success: true,
-                message: `用户档案已清空 (${keys.length} 条)`,
+                message: t('clearDone', { count: keys.length }),
             });
         }
         catch (err) {
-            const m = err instanceof Error ? err.message : String(err);
             data.results.push({
                 source: 'user-profile',
                 type: 'user-profile',
                 success: false,
-                message: `用户档案清空失败: ${m}`,
+                message: t('clearFailed', { error: textOf(err) }),
             });
         }
         page.invalidate();
@@ -1125,19 +1180,20 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
     // ─── 工具：user_profile_lookup ───
     // 让 Agent 在对话中主动查询任意用户的事实档案。
     // 设计要点：
-    // - 全局可查（用户决定 C）：跨平台/跨群均可
+    // - 全局可查：跨平台/跨群均可
     // - 两种调用方式：① user_key 直传；② platform+user_id 组合
     tools.use.registerGroup({
         name: 'user-profile',
-        label: '用户档案',
-        description: '查询 Aalis 已经积累的某人事实档案。',
+        label: t('profiles'),
+        summary: t('groupSummary'),
+        description: '查询已经积累的某人事实档案。',
     });
     tools.use.register({
         definition: {
             type: 'function',
             function: {
                 name: 'user_profile_lookup',
-                description: '查询 Aalis 已积累的某个用户的事实档案。当对话中提到某人、或你想回忆已知信息时使用。' +
+                description: '查询你已积累的某个用户的事实档案。当对话中提到某人、或你想回忆已知信息时使用。' +
                     '可通过 user_key（"<platform>:<userId>"）直查，或用 platform + user_id 组合。',
                 parameters: {
                     type: 'object',
@@ -1199,36 +1255,33 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
     // /profile              查看自己的档案
     // /profile clear        清除自己的档案（authority=2，自己删自己的）
     // /profile clear nuke   清空所有用户档案（authority=3，dangerous）
-    commands.use.command('profile', '查看你在 Aalis 中的事实档案').action(async (argv) => {
+    commands.use.command('profile', t('profileDescription')).action(async (argv) => {
         const userId = argv.session.userId;
         if (!userId)
-            return '当前会话未识别用户身份，无法查看档案。';
+            return t('noIdentityView');
         const userKey = userKeyOf(argv.session.platform, userId);
         const profile = await loadProfileLenient(memory.present ? memory.use : undefined, userKey);
         if (!profile || profile.facts.length === 0) {
-            return `📭 暂无档案数据 (${userKey})`;
+            return t('noProfileYet', { key: userKey });
         }
-        const block = renderProfileBlock(profile.facts, userKey, false);
-        const meta = `关系强度：${(profile.relationScore ?? 0).toFixed(relationScorePrecision)}/100，互动次数：${profile.interactionCount ?? 0}`;
-        return `📇 你的档案 (${userKey})\n${meta}\n\n${block}`;
+        return profileText(profile, userKey);
     });
-    commands.use.command('profile.clear', '清除你自己的事实档案', { visibility: 'restricted' }).action(async (argv) => {
+    commands.use.command('profile.clear', t('clearDescription'), { visibility: 'restricted' }).action(async (argv) => {
         const userId = argv.session.userId;
         if (!userId)
-            return '当前会话未识别用户身份，无法清除档案。';
+            return t('noIdentityClear');
         const userKey = userKeyOf(argv.session.platform, userId);
         const mem = pinnedMemory();
         try {
             const existed = await mem.getMetadata(PROFILE_NS, userKey);
             if (!existed)
-                return `📭 你当前没有档案数据 (${userKey})`;
+                return t('noOwnProfile', { key: userKey });
             await mem.deleteMetadata(PROFILE_NS, userKey);
             page.invalidate();
-            return `✅ 已清除你的档案 (${userKey})`;
+            return t('ownCleared', { key: userKey });
         }
         catch (err) {
-            const m = err instanceof Error ? err.message : String(err);
-            return `❌ 清除失败：${m}`;
+            return t('ownClearFailed', { error: textOf(err) });
         }
     });
     // 定点除毒入口（2026-08 群主档案投毒事件的运维刚需）：此前删单条事实只能
@@ -1236,7 +1289,7 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
     //（它改的是**他人**档案，且 target 含冒号时直传 key、可触及任意一份档案）。
     // id 未命中时列出前若干条供定位。
     commands.use
-        .command('profile.forget <target:string> <factId:string>', '定点删除某用户档案中的一条事实（运维除毒）', {
+        .command('profile.forget <target:string> <factId:string>', t('forgetDescription'), {
         risk: 'dangerous',
     })
         .action(async (argv, targetArg, factIdArg) => {
@@ -1247,14 +1300,14 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
         try {
             const profile = await loadProfile(mem, userKey);
             if (!profile || profile.facts.length === 0)
-                return `📭 无档案数据 (${userKey})`;
+                return t('noProfile', { key: userKey });
             const hit = profile.facts.find(f => f.id === factId);
             if (!hit) {
                 const listing = profile.facts
                     .slice(0, 20)
                     .map(f => `  [${f.id}] ${f.text.slice(0, 50)}`)
                     .join('\n');
-                return `未找到事实 [${factId}]。${userKey} 现有 ${profile.facts.length} 条：\n${listing}`;
+                return t('factNotFound', { factId, key: userKey, count: profile.facts.length, listing });
             }
             await saveProfile(mem, userKey, {
                 ...profile,
@@ -1262,22 +1315,21 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
                 updatedAt: Date.now(),
             });
             page.invalidate();
-            return `✅ 已删除 ${userKey} 的事实 [${factId}]：${hit.text.slice(0, 60)}`;
+            return t('factForgotten', { key: userKey, factId, text: hit.text.slice(0, 60) });
         }
         catch (err) {
-            return `❌ 删除失败：${err instanceof Error ? err.message : String(err)}`;
+            return t('forgetFailed', { error: textOf(err) });
         }
     });
-    commands.use.command('profile.clear.nuke', '【危险】清空所有用户档案', { risk: 'dangerous' }).action(async () => {
+    commands.use.command('profile.clear.nuke', t('nukeDescription'), { risk: 'dangerous' }).action(async () => {
         const mem = pinnedMemory();
         try {
             const [keys] = await clearMetadataNamespaces(mem, [PROFILE_NS], logger.use);
             page.invalidate();
-            return `✅ 已清空全部用户档案（${keys.length} 条）`;
+            return t('nukeDone', { count: keys.length });
         }
         catch (err) {
-            const m = err instanceof Error ? err.message : String(err);
-            return `❌ 清空失败：${m}`;
+            return t('nukeFailed', { error: textOf(err) });
         }
     });
     logger.use.info(`用户事实档案已启用 (every=${cfg.extractEveryNMessages <= 0 ? '禁用提取' : `${cfg.extractEveryNMessages}msgs`}, history=${cfg.historyForExtraction}, ` +