@aalis/plugin-user-profile 0.1.0

package/dist/index.js

@@ -0,0 +1,2158 @@
+import { useCommandService } from '@aalis/plugin-commands-api';
+import { resolveLLMModel } from '@aalis/plugin-llm-api';
+import { WellKnownKinds } from '@aalis/plugin-message-api';
+import { useToolService } from '@aalis/plugin-tools-api';
+import { parseLLMJsonObject } from '@aalis/util-json-repair';
+import '@aalis/plugin-agent-api';
+import '@aalis/plugin-commands-api';
+// ════════════════════════════════════════════════════════════
+// plugin-user-profile — 用户事实档案
+//
+// 通过 LLM 从对话中提取「关于用户的长期事实」（喜好、经历、关系、近况），
+// 按 platform:userId 维度落库到 memory metadata 的 user:profile namespace。
+// 在 LLM 调用前注入到系统提示，让 Aalis 真正「记得这个人」。
+//
+// 设计原则：
+// - 单点落库：所有事实存在一个 metadata 文档，避免散落多处
+// - 冷却节流：同一用户在 N 秒内不重复提取，避免 LLM 调用风暴
+// - 渐进合并：每次提取由 LLM 输出 add/remove 两个数组，自然演化
+// - 零侵入：通过 events + middleware 接入，不修改 agent / persona / memory
+//
+// 关系强度（relationScore, 0~100）计算规则：
+// - 每条入站消息（无论 agent 是否回复）：+ relationIncrementWitness（默认 0.1，旁观档）
+// - 若 agent 触发回复，额外叠加：
+//     direct（私聊）        + relationIncrementDirect    默认 1.0
+//     immediate（@/呼名）   + relationIncrementImmediate 默认 1.5
+//     interval（被动触发）  + relationIncrementInterval  默认 0.5
+// - 每日衰减：(now - lastInteractionAt) 天数 × relationScoreDecayPerDay（默认 0.5/天）
+// - 上限 100，下限 0
+// 例：群聊纯旁观一条 = +0.1；群聊被 @ 并回复 = +0.1 + 1.5 = +1.6；私聊一条 = +0.1 + 1.0 = +1.1
+// ════════════════════════════════════════════════════════════
+export const name = '@aalis/plugin-user-profile';
+export const displayName = '用户事实档案';
+export const subsystem = 'memory';
+export const inject = {
+    required: ['memory', 'llm'],
+    optional: ['user-relation', 'tools'],
+};
+const PROFILE_NS = 'user:profile';
+/** Aalis 自档案的 userKey 前缀。userKeyOf 形如 `platform:userId`，
+ *  这里用 `__self__:<personaName>` 这种不可能在真实平台出现的形式做隔离。
+ *  按 persona name 分堆：同名 persona（如 onebot 上的 aalis 与 webui 上的 aalis-webui两张卡都叫 Aalis）共享内心；
+ *  不同 persona（如 Babel）各自独立。 */
+const SELF_KEY_PREFIX = '__self__:';
+const DEFAULT_PERSONA_NAME = 'Aalis';
+/** 第三方行为指令的独立 namespace（与 user:profile 解耦，独立生命周期）。
+ *  指令是「第三方对 Aalis 的客观行为约束」（如：不要长时间封禁；按严重程度分层禁言），
+ *  按 persona 名分堆（key = persona 名），与 selfFacts 的归属方式保持一致：
+ *  同名 persona（如 onebot 与 webui 两张都叫 Aalis）共享准则；不同 persona（如 Babel）各自独立。 */
+const INSTRUCTIONS_NS = 'aalis:instructions';
+export const configSchema = {
+    extractEveryNMessages: {
+        type: 'number',
+        label: '每 N 条消息提取一次',
+        description: '同一用户每发 N 条消息触发一次事实提取。无论 Aalis 是否回复都会计数，群聊中每人独立计数。设为 1 表示每条消息都尝试提取（不推荐）；设为 0 或负数则禁用提取（仍会注入已有档案）',
+        default: 5,
+    },
+    historyForExtraction: {
+        type: 'number',
+        label: '提取参考历史条数',
+        description: '触发提取时，喂给 LLM 的最近消息条数',
+        default: 8,
+    },
+    maxFactsPerUser: {
+        type: 'number',
+        label: '单用户事实上限',
+        description: '超出后按 updatedAt 升序淘汰最久未更新的，旧事实自动淘汰。最小有效值为 5（写入时自动下限），不支持设为 0 来禁用提取；若要禁用提取请将 extractEveryNMessages 设为 0',
+        default: 30,
+    },
+    maxFactCharsPerItem: {
+        type: 'number',
+        label: '单条事实字数上限',
+        description: '超出会被裁断，避免 LLM 输出长段落代替事实',
+        default: 80,
+    },
+    maxOtherParticipants: {
+        type: 'number',
+        label: '群聊其他参与者档案上限',
+        description: '群聊中除当前发言者外，最多加载多少人的档案摘要注入 LLM。0 表示禁用群聊多用户注入',
+        default: 3,
+    },
+    maxFactsForOthers: {
+        type: 'number',
+        label: '其他参与者摘要条数上限',
+        description: '群聊背景参与者每人只显示最近更新的 N 条事实，避免 prompt 过长',
+        default: 5,
+    },
+    injectFeelingsForOthers: {
+        type: 'boolean',
+        label: '群聊副档案注入 Aalis 感受',
+        description: '在群聊其他参与者的 compact 档案后，附带 Aalis 对该用户的主观感受（与主发言者档案逻辑相同，但条数受 maxFeelingsForOthers 限制）。默认关闭以保持原有 prompt 体积',
+        default: false,
+    },
+    maxFeelingsForOthers: {
+        type: 'number',
+        label: '其他参与者感受条数上限',
+        description: '当 injectFeelingsForOthers 开启时，每位群聊背景参与者最多注入多少条 Aalis 感受',
+        default: 3,
+    },
+    temporaryFactMaxAgeDays: {
+        type: 'number',
+        label: '临时事实保留天数',
+        description: 'temporality=temporary 的事实超过该天数未更新后不再主动注入 prompt（仍保留在档案中，等待后续 update/remove）。0 表示不淡出',
+        default: 90,
+    },
+    relationScoreDecayPerDay: {
+        type: 'number',
+        label: '关系强度每日衰减',
+        description: '用户长期未互动时，relationScore 每天衰减的分数。0 表示不衰减',
+        default: 0.5,
+    },
+    relationIncrementDirect: {
+        type: 'number',
+        label: '私聊关系增量',
+        description: 'direct 触发时每条消息增加的关系强度',
+        default: 1,
+    },
+    relationIncrementImmediate: {
+        type: 'number',
+        label: '主动呼叫关系增量',
+        description: '群聊 @/名字主动触发时每条消息增加的关系强度',
+        default: 1.5,
+    },
+    relationIncrementInterval: {
+        type: 'number',
+        label: '群聊被动参与关系增量',
+        description: '群聊频率/活跃度被动触发或普通入站消息增加的关系强度',
+        default: 0.5,
+    },
+    relationIncrementWitness: {
+        type: 'number',
+        label: '旁观（不回复）关系增量',
+        description: '每条入站消息无论 agent 是否回复都加上的最低档增量。若 agent 触发回复，会再叠加 direct/immediate/interval 之一。0 表示禁用旁观计分',
+        default: 0.1,
+    },
+    extractLLM: {
+        type: 'llm-ref',
+        label: '提取用模型',
+        description: '留空则使用当前 LLM 服务的默认模型。事实提取是简单结构化任务，推荐选择廉价/快速模型（如 deepseek-chat）以降低成本',
+    },
+    allowGlobalBackfill: {
+        type: 'boolean',
+        label: '允许跨会话补齐副档案',
+        description: '当前群/会话中的候选不足时，是否允许从其他群、私聊等跨会话中选取最近互动过的用户来补全「其他参与者背景摘要」。关闭后仅限当前上下文内出现过的用户',
+        default: false,
+    },
+    enableAalisFeelings: {
+        type: 'boolean',
+        label: '启用 Aalis 对用户的主观感受',
+        description: '在每位用户的客观事实档案之外，额外让 Aalis 以「主观视角」记录对该用户的态度/情感/边缘观察（独立 schema，注入 prompt 时单独成段）。复用同一次 LLM 提取调用，不增加额外成本',
+        default: true,
+    },
+    maxFeelingsPerUser: {
+        type: 'number',
+        label: 'Aalis 对单个用户的感受条数上限',
+        description: '超出后按 updatedAt 升序淘汰最久未更新的，旧感受自动淘汰。建议比客观事实少。' +
+            '特殊值：设为 0 等于「只看不写」——不再让 LLM 提取新感受，但已存在的旧感受仍保留在档案中、仍会被注入 prompt（持久冻结）。' +
+            '若要彻底关闭注入，请关闭上方的「启用 Aalis 对用户的主观感受」总开关',
+        default: 15,
+    },
+    enableSelfProfile: {
+        type: 'boolean',
+        label: '启用 Aalis 自档案',
+        description: '让 Aalis 周期性地反思自身，提炼「关于自己的事实」（近期心情走向、在意的事、自我观察）。注入到所有 LLM 调用的 system prompt 早段，提供跨会话的人格延续性',
+        default: true,
+    },
+    selfReflectEveryNMessages: {
+        type: 'number',
+        label: 'Aalis 自反思触发频次',
+        description: '全局累计入站消息每 N 条触发一次自反思。建议比单用户提取慢（默认 25），避免抖动',
+        default: 25,
+    },
+    selfReflectHistory: {
+        type: 'number',
+        label: '自反思参考历史条数',
+        description: '触发自反思时，从触发会话取最近多少条消息作为反思材料',
+        default: 16,
+    },
+    maxSelfFacts: {
+        type: 'number',
+        label: 'Aalis 自档案事实上限',
+        description: '超出后按 updatedAt 升序淘汰最久未更新的。最小有效值为 5（写入时自动下限），不支持设为 0 来禁用；若要禁用自反思请关闭 enableSelfProfile',
+        default: 20,
+    },
+    enableInstructions: {
+        type: 'boolean',
+        label: '启用第三方行为指令',
+        description: '让 Aalis 记录第三方（管理员/操作者）对其行为的客观指令（如「不要长时间封禁」「按严重程度分层禁言」），作为跨会话的行为约束。' +
+            '注入到 system prompt 最前段，优先级高于自反思 selfFacts。按当前 persona 名分堆。',
+        default: true,
+    },
+    instructionMinAuthority: {
+        type: 'number',
+        label: '指令最小权限门槛',
+        description: '只有 authority ≥ 该值的用户的发言才会被采纳为指令来源（防陌生人塞规则）。默认 2（一般管理员），设为 5 表示仅 owner。' +
+            '通过 /instruct 命令手动添加的指令不走该门槛（命令本身已是 authority 2 守卫）',
+        default: 2,
+    },
+    instructionExtractEveryNMessages: {
+        type: 'number',
+        label: '指令自动提取触发频次',
+        description: '全局累计入站消息每 N 条触发一次指令提取。建议比自反思更慢（默认 40），降低成本；设为 0 禁用 LLM 自动提取，只保留 /instruct 命令通道',
+        default: 40,
+    },
+    instructionHistoryForExtraction: {
+        type: 'number',
+        label: '指令提取参考历史条数',
+        description: '触发指令提取时从触发会话取最近多少条消息作为提取材料',
+        default: 20,
+    },
+    maxInstructions: {
+        type: 'number',
+        label: '指令条数上限',
+        description: '超出后按 updatedAt 升序淘汰最久未更新的。最小有效值为 3。指令上限建议比 selfFacts 紧，准则少而准比多而散更好',
+        default: 12,
+    },
+    maxInstructionCharsPerItem: {
+        type: 'number',
+        label: '单条指令字数上限',
+        description: '超出会被裁断',
+        default: 120,
+    },
+};
+export const defaultConfig = {
+    extractEveryNMessages: 5,
+    historyForExtraction: 8,
+    maxFactsPerUser: 30,
+    maxFactCharsPerItem: 80,
+    maxOtherParticipants: 3,
+    maxFactsForOthers: 5,
+    injectFeelingsForOthers: false,
+    maxFeelingsForOthers: 3,
+    temporaryFactMaxAgeDays: 90,
+    relationScoreDecayPerDay: 0.5,
+    relationIncrementDirect: 1,
+    relationIncrementImmediate: 1.5,
+    relationIncrementInterval: 0.5,
+    relationIncrementWitness: 0.1,
+    allowGlobalBackfill: false,
+    enableAalisFeelings: true,
+    maxFeelingsPerUser: 15,
+    enableSelfProfile: true,
+    selfReflectEveryNMessages: 25,
+    selfReflectHistory: 16,
+    maxSelfFacts: 20,
+    enableInstructions: true,
+    instructionMinAuthority: 2,
+    instructionExtractEveryNMessages: 40,
+    instructionHistoryForExtraction: 20,
+    maxInstructions: 12,
+    maxInstructionCharsPerItem: 120,
+};
+const KNOWN_CATEGORIES = [
+    '兴趣爱好',
+    '职业身份',
+    '人际关系',
+    '近期处境',
+    '价值观',
+    '性格特征',
+    '偏好',
+    '忌讳',
+    '其他',
+];
+const KNOWN_INSTRUCTION_CATEGORIES = [
+    '审核与处罚',
+    '隐私与边界',
+    '语气与表达',
+    '响应策略',
+    '安全',
+    '其他',
+];
+/** 生成稳定短 ID（6 字符 base36，对 30 条以内规模碰撞概率极低） */
+function genFactId(existing) {
+    for (let i = 0; i < 8; i++) {
+        const id = `f${Math.random().toString(36).slice(2, 7)}`;
+        if (!existing.has(id))
+            return id;
+    }
+    // 极端兜底：加时间戳后缀
+    return `f${Date.now().toString(36).slice(-5)}`;
+}
+function decimalPlaces(value) {
+    if (!Number.isFinite(value))
+        return 0;
+    const text = String(value).toLowerCase();
+    const exponentIndex = text.indexOf('e');
+    if (exponentIndex >= 0) {
+        const mantissa = text.slice(0, exponentIndex);
+        const exponent = Number(text.slice(exponentIndex + 1));
+        const mantissaDecimals = mantissa.split('.')[1]?.replace(/0+$/, '').length ?? 0;
+        return Math.max(0, mantissaDecimals - exponent);
+    }
+    return text.split('.')[1]?.replace(/0+$/, '').length ?? 0;
+}
+function metadataString(message, key) {
+    const value = message.metadata?.[key];
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function getMessageUserId(message) {
+    return metadataString(message, 'userId') ?? message.name;
+}
+function isTargetUserMessage(message, userId, platform) {
+    if (message.role !== 'user' || !message.content)
+        return false;
+    const msgUserId = getMessageUserId(message);
+    if (msgUserId !== userId)
+        return false;
+    const msgPlatform = metadataString(message, 'platform');
+    return !msgPlatform || !platform || msgPlatform === platform;
+}
+/**
+ * 将文本标准化为可子串匹配的形式：去空白、去常见标点、toLowerCase。
+ * 用于 sourceQuote 校验，容忍 LLM 轻微原词改写。
+ */
+function normalizeForQuoteMatch(s) {
+    return s
+        .toLowerCase()
+        .replace(/[\s\u3000]+/g, '')
+        .replace(/[。，、；：？！“”‘’（）《》【】.,;:?!"'()[\]<>\-_~`*]/g, '');
+}
+/**
+ * 拼接目标用户自己发言作为 sourceQuote 校验语料。
+ * 只包含目标用户 role==='user' 且 metadata.userId 匹配的消息。
+ */
+function buildTargetUserCorpus(history, userId, platform) {
+    return history
+        .filter(m => isTargetUserMessage(m, userId, platform))
+        .map(m => m.content ?? '')
+        .join('\n');
+}
+/**
+ * 渲染完整会话历史供提取 LLM 作为消歧上下文：
+ * 每行带身份标签区分「目标用户」与「其他用户」，
+ * 不做 strip（引用原话不会在目标用户语料中出现，sourceQuote 校验能拦住）。
+ */
+function renderHistoryForExtract(history, userId, platform) {
+    return history
+        .filter(m => (m.role === 'user' || m.role === 'assistant' || m.role === 'notice') && m.content)
+        .map(m => {
+        const time = m.timestamp ? new Date(m.timestamp).toLocaleString('zh-CN', { hour12: false }) : '';
+        const content = (m.content ?? '').trim();
+        if (!content)
+            return '';
+        if (m.role === 'assistant') {
+            // Aalis 的回复：加标签让 LLM 知道用户是在跟谁互动，用于判断「对 Aalis 的行为」
+            return `[${time}] [Aalis]: ${content}`;
+        }
+        if (m.role === 'notice') {
+            // 平台事件（群禁言 / 撤回 / 成员进出 / poke 等），供提取判断「用户被谁怎么了」之类上下文
+            return `[${time}] [系统通知]: ${content}`;
+        }
+        const nickname = metadataString(m, 'nickname');
+        const msgUserId = getMessageUserId(m) ?? '';
+        const msgPlatform = metadataString(m, 'platform');
+        const isTarget = msgUserId === userId && (!msgPlatform || !platform || msgPlatform === platform);
+        const label = nickname ? `${nickname}(${msgUserId || '?'})` : msgUserId || '?';
+        const tag = isTarget ? '目标用户' : '其他用户';
+        return `[${time}] [${tag} ${label}]: ${content}`;
+    })
+        .filter(Boolean)
+        .join('\n');
+}
+export function apply(ctx, config) {
+    const cfg = {
+        extractEveryNMessages: config.extractEveryNMessages ?? 5,
+        historyForExtraction: Math.max(2, config.historyForExtraction ?? 8),
+        maxFactsPerUser: Math.max(5, config.maxFactsPerUser ?? 30),
+        maxFactCharsPerItem: Math.max(20, config.maxFactCharsPerItem ?? 80),
+        maxOtherParticipants: Math.max(0, config.maxOtherParticipants ?? 3),
+        maxFactsForOthers: Math.max(1, config.maxFactsForOthers ?? 5),
+        injectFeelingsForOthers: config.injectFeelingsForOthers ?? false,
+        maxFeelingsForOthers: Math.max(1, config.maxFeelingsForOthers ?? 3),
+        temporaryFactMaxAgeDays: Math.max(0, config.temporaryFactMaxAgeDays ?? 90),
+        relationScoreDecayPerDay: Math.max(0, config.relationScoreDecayPerDay ?? 0.5),
+        relationIncrementDirect: Math.max(0, config.relationIncrementDirect ?? 1),
+        relationIncrementImmediate: Math.max(0, config.relationIncrementImmediate ?? 1.5),
+        relationIncrementInterval: Math.max(0, config.relationIncrementInterval ?? 0.5),
+        relationIncrementWitness: Math.max(0, config.relationIncrementWitness ?? 0.1),
+        extractLLM: config.extractLLM &&
+            typeof config.extractLLM === 'object' &&
+            config.extractLLM.provider &&
+            config.extractLLM.model
+            ? config.extractLLM
+            : undefined,
+        allowGlobalBackfill: config.allowGlobalBackfill ?? false,
+        enableAalisFeelings: config.enableAalisFeelings ?? true,
+        maxFeelingsPerUser: Math.max(0, config.maxFeelingsPerUser ?? 15),
+        enableSelfProfile: config.enableSelfProfile ?? true,
+        selfReflectEveryNMessages: Math.max(0, config.selfReflectEveryNMessages ?? 25),
+        selfReflectHistory: Math.max(4, config.selfReflectHistory ?? 16),
+        maxSelfFacts: Math.max(5, config.maxSelfFacts ?? 20),
+        enableInstructions: config.enableInstructions ?? true,
+        instructionMinAuthority: Math.max(0, config.instructionMinAuthority ?? 2),
+        instructionExtractEveryNMessages: Math.max(0, config.instructionExtractEveryNMessages ?? 40),
+        instructionHistoryForExtraction: Math.max(4, config.instructionHistoryForExtraction ?? 20),
+        maxInstructions: Math.max(3, config.maxInstructions ?? 12),
+        maxInstructionCharsPerItem: Math.max(20, config.maxInstructionCharsPerItem ?? 120),
+    };
+    /** 每会话每用户累计入站消息数（用于 extractEveryNMessages 计数），不随提取重置 */
+    const userMessageCount = new Map();
+    /** 防止同一用户的提取并发触发 */
+    const inflightExtractions = new Set();
+    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}`;
+    }
+    function extractionCountKeyOf(sessionId, platform, userId) {
+        return `${sessionId}:${userKeyOf(platform, userId)}`;
+    }
+    /** 返回当前活跃 persona 的 self key（运行时解析，跟随 persona 切换）。
+     *  若 persona 服务不可用或未配 name，回退到默认 `aalis`。 */
+    function getCurrentPersonaName() {
+        try {
+            const persona = ctx.getService('persona');
+            const name = persona?.getPersonaName?.()?.trim();
+            return name && name.length > 0 ? name : DEFAULT_PERSONA_NAME;
+        }
+        catch {
+            return DEFAULT_PERSONA_NAME;
+        }
+    }
+    function getSelfKey() {
+        return `${SELF_KEY_PREFIX}${getCurrentPersonaName()}`;
+    }
+    /** instructions 按 persona 名分堆：直接以 persona 名作为 metadata key */
+    function getInstructionsKey() {
+        return getCurrentPersonaName();
+    }
+    function normalizeInstructionCategory(v) {
+        if (typeof v !== 'string')
+            return undefined;
+        return KNOWN_INSTRUCTION_CATEGORIES.includes(v) ? v : undefined;
+    }
+    function normalizeInstructionSeverity(v) {
+        return v === 'must' || v === 'should' || v === 'avoid' ? v : undefined;
+    }
+    function clipInstructionText(s) {
+        return s.length > cfg.maxInstructionCharsPerItem ? `${s.slice(0, cfg.maxInstructionCharsPerItem)}…` : s;
+    }
+    /** 生成 Instruction 短 ID（与 Fact 同前缀但带 'i' 区分，便于日志中识别） */
+    function genInstructionId(existing) {
+        for (let i = 0; i < 8; i++) {
+            const id = `i${Math.random().toString(36).slice(2, 7)}`;
+            if (!existing.has(id))
+                return id;
+        }
+        return `i${Date.now().toString(36).slice(-5)}`;
+    }
+    function parseInstructionArray(raw) {
+        const usedIds = new Set();
+        const list = [];
+        for (const item of raw) {
+            if (!item || typeof item !== 'object')
+                continue;
+            const obj = item;
+            const text = typeof obj.text === 'string' ? obj.text.trim() : '';
+            if (!text)
+                continue;
+            let id = typeof obj.id === 'string' && obj.id.trim() ? obj.id.trim() : genInstructionId(usedIds);
+            while (usedIds.has(id))
+                id = genInstructionId(usedIds);
+            usedIds.add(id);
+            const updatedAt = typeof obj.updatedAt === 'number' ? obj.updatedAt : 0;
+            const observedAt = typeof obj.observedAt === 'number' ? obj.observedAt : updatedAt || undefined;
+            list.push({
+                id,
+                text,
+                category: normalizeInstructionCategory(obj.category),
+                severity: normalizeInstructionSeverity(obj.severity),
+                sourceUserKey: typeof obj.sourceUserKey === 'string' && obj.sourceUserKey.trim() ? obj.sourceUserKey : undefined,
+                sourceUserName: typeof obj.sourceUserName === 'string' && obj.sourceUserName.trim() ? obj.sourceUserName : undefined,
+                sourceChannel: obj.sourceChannel === 'llm' || obj.sourceChannel === 'command' ? obj.sourceChannel : undefined,
+                observedAt,
+                updatedAt,
+            });
+        }
+        return list;
+    }
+    async function loadInstructions() {
+        const memory = ctx.getService('memory');
+        const empty = { instructions: [], updatedAt: 0 };
+        if (!memory?.getMetadata)
+            return empty;
+        try {
+            const doc = await memory.getMetadata(INSTRUCTIONS_NS, getInstructionsKey());
+            if (!doc)
+                return empty;
+            const instructions = Array.isArray(doc.instructions) ? parseInstructionArray(doc.instructions) : [];
+            return { instructions, updatedAt: typeof doc.updatedAt === 'number' ? doc.updatedAt : 0 };
+        }
+        catch (err) {
+            ctx.logger.debug(`加载指令档案失败: ${err instanceof Error ? err.message : String(err)}`);
+            return empty;
+        }
+    }
+    async function saveInstructions(doc) {
+        const memory = ctx.getService('memory');
+        if (!memory?.saveMetadata)
+            return;
+        await memory.saveMetadata(INSTRUCTIONS_NS, getInstructionsKey(), {
+            instructions: doc.instructions,
+            updatedAt: doc.updatedAt,
+        });
+    }
+    /** 把 add/update/remove 应用到现有 instructions，应用上限与单条裁剪 */
+    function mergeInstructions(existing, add, update, remove) {
+        const now = Date.now();
+        const byId = new Map();
+        for (const ins of existing)
+            byId.set(ins.id, ins);
+        for (const id of remove)
+            byId.delete(id);
+        const usedIds = new Set(byId.keys());
+        for (const { id, patch } of update) {
+            const old = byId.get(id);
+            if (!old)
+                continue;
+            byId.set(id, {
+                ...old,
+                ...patch,
+                id,
+                text: patch.text ? clipInstructionText(patch.text) : old.text,
+                observedAt: old.observedAt ?? now,
+                updatedAt: now,
+            });
+        }
+        const textSet = new Set(Array.from(byId.values()).map(f => f.text));
+        for (const a of add) {
+            const text = clipInstructionText(a.text);
+            if (textSet.has(text))
+                continue;
+            const id = genInstructionId(usedIds);
+            usedIds.add(id);
+            byId.set(id, {
+                id,
+                text,
+                category: a.category,
+                severity: a.severity,
+                sourceUserKey: a.sourceUserKey,
+                sourceUserName: a.sourceUserName,
+                sourceChannel: a.sourceChannel,
+                observedAt: now,
+                updatedAt: now,
+            });
+            textSet.add(text);
+        }
+        let merged = Array.from(byId.values());
+        if (cfg.maxInstructions > 0 && merged.length > cfg.maxInstructions) {
+            merged.sort((a, b) => a.updatedAt - b.updatedAt);
+            merged = merged.slice(merged.length - cfg.maxInstructions);
+        }
+        merged.sort((a, b) => a.updatedAt - b.updatedAt);
+        return merged;
+    }
+    function renderInstructionLine(ins) {
+        const tag = ins.severity === 'must' ? '【必须】' : ins.severity === 'avoid' ? '【避免】' : '【应当】';
+        const source = ins.sourceUserName ? `（来自 ${ins.sourceUserName}）` : '';
+        return `- ${tag} ${ins.text}${source}`;
+    }
+    function renderInstructionsBlock(instructions) {
+        if (instructions.length === 0)
+            return '';
+        const groups = new Map();
+        for (const ins of instructions) {
+            const key = ins.category ?? '其他';
+            if (!groups.has(key))
+                groups.set(key, []);
+            groups.get(key).push(ins);
+        }
+        const sections = [];
+        for (const cat of KNOWN_INSTRUCTION_CATEGORIES) {
+            const items = groups.get(cat);
+            if (items && items.length > 0) {
+                sections.push(`## ${cat}\n${items.map(renderInstructionLine).join('\n')}`);
+            }
+        }
+        for (const [cat, items] of groups) {
+            if (!KNOWN_INSTRUCTION_CATEGORIES.includes(cat) && items.length > 0) {
+                sections.push(`## ${cat}\n${items.map(renderInstructionLine).join('\n')}`);
+            }
+        }
+        return sections.join('\n\n');
+    }
+    function normalizeTemporality(v, category) {
+        if (v === 'permanent' || v === 'temporary')
+            return v;
+        return category === '近期处境' ? 'temporary' : 'permanent';
+    }
+    function normalizeTextField(v) {
+        if (typeof v !== 'string')
+            return undefined;
+        const s = v.trim();
+        return s.length > 0 ? s.slice(0, 40) : undefined;
+    }
+    /** 解析 metadata 中的事实数组（兼容旧格式 string[]，自动迁移） */
+    function parseFactArray(raw) {
+        const usedIds = new Set();
+        const facts = [];
+        for (const item of raw) {
+            if (typeof item === 'string' && item.trim()) {
+                const id = genFactId(usedIds);
+                usedIds.add(id);
+                facts.push({ id, text: item.trim(), temporality: 'permanent', updatedAt: 0 });
+            }
+            else if (item && typeof item === 'object') {
+                const obj = item;
+                const text = typeof obj.text === 'string' ? obj.text.trim() : '';
+                if (!text)
+                    continue;
+                let id = typeof obj.id === 'string' && obj.id.trim() ? obj.id.trim() : genFactId(usedIds);
+                while (usedIds.has(id))
+                    id = genFactId(usedIds);
+                usedIds.add(id);
+                const cat = typeof obj.category === 'string' && KNOWN_CATEGORIES.includes(obj.category)
+                    ? obj.category
+                    : undefined;
+                const updatedAt = typeof obj.updatedAt === 'number' ? obj.updatedAt : 0;
+                const observedAt = typeof obj.observedAt === 'number' ? obj.observedAt : updatedAt || undefined;
+                facts.push({
+                    id,
+                    text,
+                    category: cat,
+                    temporality: normalizeTemporality(obj.temporality, cat),
+                    observedAt,
+                    timeHint: normalizeTextField(obj.timeHint),
+                    updatedAt,
+                });
+            }
+        }
+        return facts;
+    }
+    /** 读取一个用户的现有档案（不存在返回 undefined）。兼容旧格式 string[]，自动迁移 */
+    async function loadProfile(userKey) {
+        const memory = ctx.getService('memory');
+        if (!memory?.getMetadata)
+            return undefined;
+        try {
+            const doc = await memory.getMetadata(PROFILE_NS, userKey);
+            if (!doc)
+                return undefined;
+            const facts = Array.isArray(doc.facts) ? parseFactArray(doc.facts) : [];
+            return {
+                facts,
+                aalisFeelings: Array.isArray(doc.aalisFeelings) ? parseFactArray(doc.aalisFeelings) : undefined,
+                relationScore: typeof doc.relationScore === 'number' ? Math.min(100, Math.max(0, doc.relationScore)) : 0,
+                interactionCount: typeof doc.interactionCount === 'number' ? Math.max(0, Math.floor(doc.interactionCount)) : 0,
+                lastInteractionAt: typeof doc.lastInteractionAt === 'number' ? doc.lastInteractionAt : undefined,
+                updatedAt: typeof doc.updatedAt === 'number' ? doc.updatedAt : 0,
+            };
+        }
+        catch (err) {
+            ctx.logger.debug(`加载用户档案失败 (${userKey}): ${err instanceof Error ? err.message : String(err)}`);
+            return undefined;
+        }
+    }
+    /** 保存档案（覆盖式） */
+    async function saveProfile(userKey, profile) {
+        const memory = ctx.getService('memory');
+        if (!memory?.saveMetadata)
+            return;
+        const payload = {
+            facts: profile.facts,
+            relationScore: profile.relationScore ?? 0,
+            interactionCount: profile.interactionCount ?? 0,
+            lastInteractionAt: profile.lastInteractionAt,
+            updatedAt: profile.updatedAt,
+        };
+        if (profile.aalisFeelings && profile.aalisFeelings.length > 0) {
+            payload.aalisFeelings = profile.aalisFeelings;
+        }
+        await memory.saveMetadata(PROFILE_NS, userKey, payload);
+    }
+    function normalizeCategory(v) {
+        if (typeof v !== 'string')
+            return undefined;
+        return KNOWN_CATEGORIES.includes(v) ? v : undefined;
+    }
+    /** 调用 LLM 从历史中提取/修订事实，返回 add / update / remove 三类操作，
+     *  以及（可选）Aalis 对该用户的主观感受 feelings* 三类操作。 */
+    async function llmExtractFacts(history, existingFacts, existingFeelings, nickname, userId, platform) {
+        const empty = {
+            add: [],
+            update: [],
+            remove: [],
+            feelingsAdd: [],
+            feelingsUpdate: [],
+            feelingsRemove: [],
+        };
+        const includeFeelings = cfg.enableAalisFeelings && cfg.maxFeelingsPerUser > 0;
+        const feelingsPrompt = includeFeelings
+            ? '\n\n## 额外任务：Aalis 对该用户的主观感受（aalisFeelings）\n' +
+                '除了上面的客观事实，你还要以「Aalis（你）」的第一人称视角，记录对该用户的**主观态度/情感/边缘观察**。' +
+                '这些是 Aalis 自己的内心感受、对这个人的印象、相处中形成的偏好，不是客观事实。' +
+                '\n\n### ⚠️ 反自我强化（最重要）\n' +
+                '下面会给你看「已知 Aalis 对该用户的感受」——这就是上一轮你自己写下的、下一轮会注入回 system prompt 影响 Aalis 语气的内容，' +
+                '然后又被你读到并再次确认。这是会自我放大的闭环，必须主动反向校正：' +
+                '\n  (a) **不要因为档案里已经有某条感受就强化它**：「已有"觉得他依赖我"」+ 本批又出现一次撒娇 ≠ 自动 update 成"非常依赖我"，' +
+                '这只是同方向的重复采样，不构成新依据' +
+                '\n  (b) 真正值得 update 的，是出现**新的、与既有感受相反或正交的依据**：' +
+                '若历史中出现明显反例（如已有"觉得他冷淡" 但本批多处主动关心你），优先 update / remove 让感受更接近真实' +
+                '\n  (c) add 一条全新感受需要**整段历史多处反复出现**，单次互动一律不写' +
+                '\n  (d) 如果只是同方向重复，宁可什么都不动让档案保持稳定，也不要让 updatedAt 假装"还在更新"' +
+                '\n\n常规规则：' +
+                '\n- 允许包含「关于自己的反思」（如「我注意到自己跟 ta 聊技术时容易激动」）让感受更立体' +
+                '\n- text 以 Aalis 的口吻写：「觉得他可靠」「和他聊天总是轻松」「对她的依赖让我有点不知所措」「他偶尔的冒犯让我警觉」等' +
+                '\n- 同样支持 add / update / remove；id 空间与 facts 独立' +
+                `\n- 单条不超过 ${cfg.maxFactCharsPerItem} 字；保守优先，没有就空数组` +
+                '\n- 不需要 sourceQuote（这是主观感受，不需要原话依据）' +
+                '\n- temporality：长期形成的印象用 permanent；近期情绪/状态用 temporary' +
+                '\n- 输出字段名：feelingsAdd / feelingsUpdate / feelingsRemove（与 add/update/remove 并列）'
+            : '';
+        const sys = '你是用户档案管理员。输入是一段多用户会话历史，每行开头有身份标签：' +
+            '`[目标用户 X(uid)]`、`[其他用户 Y(uid)]` 或 `[Aalis]`。上下文仅供消歧，' +
+            '**只允许根据「目标用户」自己的发言写入事实**，不能根据其他用户、Aalis 的猜测或提问写入事实。' +
+            '\n\n你可以执行三种操作（在一次输出里组合）：' +
+            '\n- add: 添加新事实，需指定 text、category、sourceQuote' +
+            '\n- update: 用 id 精确替换某条已知事实，同样需 sourceQuote（优先使用 update 而非 add 来避免重复）' +
+            '\n- remove: 用 id 删除已被推翻、过时的事实（不需 sourceQuote）' +
+            '\n\n规则：' +
+            '\n1. 事实的**主语必须是「目标用户」本人**，不能是 ta 转述、讨论、评价的第三方。' +
+            '即使 sourceQuote 出自目标用户原话，也要先在脑中追问：' +
+            '\n   - 这是 ta 在说自己，还是在评价/复述别人？（比如目标用户说"小明会写檄文" → 这是关于小明的，不写）' +
+            '\n   - 是认真陈述，还是反讽/否定/假设/角色扮演？（"我可不喜欢爵士" → 否定，不写；跑团扮演 NPC 的台词 → 不写）' +
+            '\n   - 如果原始依据来自「其他用户」的发言，即使在说目标用户，也不允许写入（他人可能记错、说反话）' +
+            '\n   **拿不准就不写。profile 漏几条没关系，写错才麻烦。**' +
+            '\n   ⚠️ 例外——`人际关系` 类：除上述通用规则外，该类还允许记录目标用户**与 Aalis 之间长期可观察的关系模式**，' +
+            '包含两种情况：' +
+            '\n   (a) 行为身份类：用户在 Aalis 项目中扮演的角色或长期重复的行为' +
+            '（示例 text：「是 Aalis 的开发维护者」「经常向 Aalis 提交功能建议」「常帮助测试和排查 Aalis 的故障」）' +
+            '\n   (b) 长期情感模式类：用户对 Aalis 表现出的**反复出现的态度倾向**（不是单次情绪）' +
+            '（示例 text：「常对 Aalis 表达依赖与喜爱」「习惯把日常烦恼向 Aalis 倾诉」「喜欢调侃 Aalis」）' +
+            '\n   ❌ 严禁仅凭单次发言推断情感事实：一次抱怨/一次感谢/一次撒娇都不算"模式"，不写。' +
+            '必须是已有事实佐证 + 本轮再次出现的同类行为才允许 update 强化，或会话历史多处反复出现才允许 add。' +
+            '依据必须是「目标用户」发言中可直接推断的内容，sourceQuote 取目标用户发言原话。' +
+            '\n2. **sourceQuote 必须是「目标用户」自己发言中的原话片段**，可以是某一句话的一部分，必须能一字不改在「目标用户」某行的原文中找到；不要采用「其他用户」的原话，不要自己总结改写' +
+            '\n3. 在同一 category 下，如果新信息与已有事实在含义上重叠（例如已知"喜欢猫"，新信息"还喜欢狗"），应以 update 改写原 id 为更全面的版本，而不是 add 再加一条' +
+            '\n4. 如果新对话明确推翻或修正了某条已知事实（如已知"在北京工作"，但用户说"我刚搬到上海"），用 update 替换或 remove 删除' +
+            `\n5. 每条 text 用一句简洁中文，不超过 ${cfg.maxFactCharsPerItem} 字，不带「用户」「他」等代词，直接陈述事实` +
+            '\n6. 如果没有任何更新，或所有候选都拿不准，三个数组都返回空——**保守优先**' +
+            `\n7. category 必须是以下之一：${KNOWN_CATEGORIES.join('、')}` +
+            '\n8. 每条 add/update 都必须给出 temporality：长期稳定偏好、性格、身份、人际关系用 permanent；近期状态、正在进行的事、短期计划用 temporary' +
+            '\n9. 如果对话中出现明确或隐含时间（如“最近”“上周”“今年4月”“昨天”），用 timeHint 记录简短时间线索；没有就省略或用空字符串' +
+            feelingsPrompt +
+            '\n\n输出严格的 JSON（不要其他文本）：' +
+            '\n{"add": [{"text": "...", "category": "...", "temporality": "permanent|temporary", "timeHint": "...", "sourceQuote": "目标用户发言中的原话片段"}], "update": [{"id": "已知事实的id", "text": "新表述", "category": "...", "temporality": "permanent|temporary", "timeHint": "...", "sourceQuote": "目标用户发言中的原话片段"}], "remove": ["已知事实的id"]' +
+            (includeFeelings
+                ? ', "feelingsAdd": [{"text": "Aalis 视角的感受", "temporality": "permanent|temporary"}], "feelingsUpdate": [{"id": "已知感受的id", "text": "...", "temporality": "permanent|temporary"}], "feelingsRemove": ["已知感受的id"]'
+                : '') +
+            '}';
+        const factListText = existingFacts.length > 0
+            ? existingFacts.map(f => `[${f.id}] (${f.category ?? '未分类'}) ${f.text}`).join('\n')
+            : '（暂无）';
+        const feelingsListText = includeFeelings
+            ? existingFeelings.length > 0
+                ? existingFeelings.map(f => `[${f.id}] ${f.text}`).join('\n')
+                : '（暂无）'
+            : '';
+        const who = nickname ? `${nickname}（${userId}）` : userId;
+        const renderedHistory = renderHistoryForExtract(history, userId, platform);
+        const user = `# 提取目标\n${who}\n\n# 已知事实（带 id，请在 update/remove 中精确引用 id）\n${factListText}` +
+            (includeFeelings
+                ? `\n\n# 已知 Aalis 对该用户的感受（带 id，请在 feelingsUpdate/feelingsRemove 中精确引用 id）\n${feelingsListText}`
+                : '') +
+            `\n\n# 会话历史（含多用户，仅供消歧；只能从「目标用户」发言中提取事实，feelings 可基于整段历史）\n${renderedHistory || '（暂无会话历史）'}`;
+        // 优先用 cfg.extractLLM 指定的模型；否则取默认 chat-capable LLM。
+        const entry = resolveLLMModel(ctx, cfg.extractLLM, ['chat']);
+        if (!entry)
+            return empty;
+        const extractLlm = entry.instance;
+        try {
+            const baseMessages = [
+                { role: 'system', content: sys },
+                { role: 'user', content: user },
+            ];
+            const resp = await extractLlm.chat({
+                messages: baseMessages,
+                temperature: 0.2,
+                maxTokens: 800,
+                think: false,
+            });
+            let text = (resp.content ?? '').trim();
+            if (!text)
+                return empty;
+            let { parsed } = parseLLMJsonObject(text);
+            if (!parsed) {
+                // util-json-repair 已尝试剥 fence + 修裸引号 + 补括号；仍失败 → 模型多半
+                // 写成了纯文本/markdown。给一次显式反馈再来一次，避免一次失败丢失整批事实。
+                ctx.logger.warn(`[user-profile] LLM 输出无法解析为 JSON，尝试重试一次。原文前 200 字：${text.slice(0, 200)}`);
+                const retryResp = await extractLlm.chat({
+                    messages: [
+                        ...baseMessages,
+                        { role: 'assistant', content: text },
+                        {
+                            role: 'user',
+                            content: '你上一条输出无法被 JSON.parse（很可能是包了 markdown 代码块、夹杂解释文字、或被截断）。' +
+                                '请只输出**一个**合法的 JSON 对象，第一个字符必须是 `{`、最后一个字符必须是 `}`，' +
+                                '禁止 ```json 围栏、禁止任何解释、禁止 markdown。如果实在没有可写入的事实，' +
+                                '就输出 `{"add":[],"update":[],"remove":[]}`。',
+                        },
+                    ],
+                    temperature: 0.2,
+                    maxTokens: 800,
+                    think: false,
+                });
+                text = (retryResp.content ?? '').trim();
+                ({ parsed } = parseLLMJsonObject(text));
+                if (!parsed) {
+                    ctx.logger.warn(`[user-profile] LLM 重试后仍无法解析 JSON，放弃本批次。重试原文前 200 字：${text.slice(0, 200)}`);
+                    return empty;
+                }
+                ctx.logger.debug('[user-profile] LLM 重试后解析成功');
+            }
+            const parsedObj = parsed;
+            const add = Array.isArray(parsedObj.add)
+                ? parsedObj.add.flatMap(x => {
+                    if (!x || typeof x !== 'object')
+                        return [];
+                    const o = x;
+                    const t = typeof o.text === 'string' ? o.text.trim() : '';
+                    if (!t)
+                        return [];
+                    const category = normalizeCategory(o.category);
+                    const sourceQuote = typeof o.sourceQuote === 'string' ? o.sourceQuote.trim() : '';
+                    return [
+                        {
+                            text: t,
+                            category,
+                            temporality: normalizeTemporality(o.temporality, category),
+                            timeHint: normalizeTextField(o.timeHint),
+                            sourceQuote,
+                        },
+                    ];
+                })
+                : [];
+            const update = Array.isArray(parsedObj.update)
+                ? parsedObj.update.flatMap(x => {
+                    if (!x || typeof x !== 'object')
+                        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)
+                        return [];
+                    const category = normalizeCategory(o.category);
+                    const sourceQuote = typeof o.sourceQuote === 'string' ? o.sourceQuote.trim() : '';
+                    return [
+                        {
+                            id,
+                            text: t,
+                            category,
+                            temporality: normalizeTemporality(o.temporality, category),
+                            timeHint: normalizeTextField(o.timeHint),
+                            sourceQuote,
+                        },
+                    ];
+                })
+                : [];
+            const remove = Array.isArray(parsedObj.remove)
+                ? parsedObj.remove
+                    .filter((x) => typeof x === 'string' && x.trim().length > 0)
+                    .map(s => s.trim())
+                : [];
+            // sourceQuote 校验：quote 可能跨多条消息（LLM 用 \n 拼接），
+            // 因此按行拆分，每行（非空）都必须能在「目标用户」语料中找到 normalize 后的子串。
+            // 这样即使行与行之间夹着其他用户的消息也不会被错误拒收。
+            const targetCorpus = normalizeForQuoteMatch(buildTargetUserCorpus(history, userId, platform));
+            const validateSourceQuote = (item, kind) => {
+                const q = item.sourceQuote?.trim() ?? '';
+                if (!q) {
+                    ctx.logger.warn(`[user-profile] 丢弃 ${kind} fact（未提供 sourceQuote）: ${item.text}`);
+                    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)) {
+                        ctx.logger.warn(`[user-profile] 丢弃 ${kind} fact（sourceQuote 片段不在目标用户 ${userId} 发言中）: text="${item.text}" fragment="${frag}"`);
+                        return false;
+                    }
+                }
+                return true;
+            };
+            const validatedAdd = add.filter(item => validateSourceQuote(item, 'add'));
+            const validatedUpdate = update.filter(item => validateSourceQuote(item, 'update'));
+            // 剥除 sourceQuote，不入库
+            const stripQuote = (item) => {
+                const { sourceQuote: _omit, ...rest } = item;
+                void _omit;
+                return rest;
+            };
+            // feelings：与 facts 同 schema，但不要求 category/sourceQuote
+            const parseFeelingItem = (x, withId) => {
+                if (!x || typeof x !== 'object')
+                    return null;
+                const o = x;
+                const t = typeof o.text === 'string' ? o.text.trim() : '';
+                if (!t)
+                    return null;
+                const item = {
+                    text: t,
+                    temporality: normalizeTemporality(o.temporality),
+                    timeHint: normalizeTextField(o.timeHint),
+                };
+                if (withId) {
+                    const id = typeof o.id === 'string' ? o.id.trim() : '';
+                    if (!id)
+                        return null;
+                    item.id = id;
+                }
+                return item;
+            };
+            const feelingsAdd = includeFeelings && Array.isArray(parsedObj.feelingsAdd)
+                ? parsedObj.feelingsAdd.flatMap(x => {
+                    const it = parseFeelingItem(x, false);
+                    return it ? [it] : [];
+                })
+                : [];
+            const feelingsUpdate = includeFeelings && Array.isArray(parsedObj.feelingsUpdate)
+                ? parsedObj.feelingsUpdate.flatMap(x => {
+                    const it = parseFeelingItem(x, true);
+                    return it?.id
+                        ? [
+                            {
+                                id: it.id,
+                                text: it.text,
+                                temporality: it.temporality,
+                                timeHint: it.timeHint,
+                            },
+                        ]
+                        : [];
+                })
+                : [];
+            const feelingsRemove = includeFeelings && Array.isArray(parsedObj.feelingsRemove)
+                ? parsedObj.feelingsRemove
+                    .filter((x) => typeof x === 'string' && x.trim().length > 0)
+                    .map(s => s.trim())
+                : [];
+            return {
+                add: validatedAdd.map(stripQuote),
+                update: validatedUpdate.map(stripQuote),
+                remove,
+                feelingsAdd,
+                feelingsUpdate,
+                feelingsRemove,
+            };
+        }
+        catch (err) {
+            ctx.logger.debug(`事实提取 LLM 调用失败：${err instanceof Error ? err.message : String(err)}`);
+            return empty;
+        }
+    }
+    function clipText(s) {
+        return s.length > cfg.maxFactCharsPerItem ? `${s.slice(0, cfg.maxFactCharsPerItem)}…` : s;
+    }
+    function clampRelationScore(score) {
+        const factor = 10 ** relationScorePrecision;
+        return Math.min(100, Math.max(0, Math.round(score * factor) / factor));
+    }
+    function relationIncrementFor(triggerType) {
+        if (triggerType === 'immediate')
+            return cfg.relationIncrementImmediate;
+        if (triggerType === 'interval')
+            return cfg.relationIncrementInterval;
+        if (triggerType === 'idle')
+            return 0;
+        if (triggerType === 'witness')
+            return cfg.relationIncrementWitness;
+        return cfg.relationIncrementDirect;
+    }
+    function applyRelationUpdate(profile, triggerType, options = {}) {
+        // countInteraction：是否计入互动计数与更新 lastInteractionAt。
+        // 同一条入站消息会先走 witness 路径，若被 trigger-policy 判为需回复又会走
+        // agent:input:before 路径。为避免 interactionCount/lastInteractionAt 被同一条
+        // 消息计两次，计数与时戳只由 witness 路径负责，agent:input:before 仅叠加 score。
+        const countInteraction = options.countInteraction ?? true;
+        const now = Date.now();
+        const last = profile.lastInteractionAt;
+        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,
+            updatedAt: now,
+        };
+    }
+    /** 通用 merge：把 add/update/remove 应用到 existing，应用上限与单条裁剪 */
+    function mergeFactList(existing, add, update, remove, maxItems) {
+        const now = Date.now();
+        const byId = new Map();
+        for (const f of existing)
+            byId.set(f.id, f);
+        // 1. remove
+        for (const id of remove)
+            byId.delete(id);
+        // 2. update
+        const usedIds = new Set(byId.keys());
+        for (const u of update) {
+            const text = clipText(u.text);
+            if (byId.has(u.id)) {
+                const old = byId.get(u.id);
+                byId.set(u.id, {
+                    id: u.id,
+                    text,
+                    category: u.category ?? old.category,
+                    temporality: u.temporality ?? old.temporality ?? normalizeTemporality(undefined, u.category ?? old.category),
+                    observedAt: old.observedAt ?? now,
+                    timeHint: u.timeHint ?? old.timeHint,
+                    updatedAt: now,
+                });
+            }
+            else {
+                const id = genFactId(usedIds);
+                usedIds.add(id);
+                byId.set(id, {
+                    id,
+                    text,
+                    category: u.category,
+                    temporality: u.temporality ?? normalizeTemporality(undefined, u.category),
+                    observedAt: now,
+                    timeHint: u.timeHint,
+                    updatedAt: now,
+                });
+            }
+        }
+        // 3. add（按 text 去重）
+        const textSet = new Set(Array.from(byId.values()).map(f => f.text));
+        for (const a of add) {
+            const text = clipText(a.text);
+            if (textSet.has(text))
+                continue;
+            const id = genFactId(usedIds);
+            usedIds.add(id);
+            byId.set(id, {
+                id,
+                text,
+                category: a.category,
+                temporality: a.temporality ?? normalizeTemporality(undefined, a.category),
+                observedAt: now,
+                timeHint: a.timeHint,
+                updatedAt: now,
+            });
+            textSet.add(text);
+        }
+        // 4. 总量上限：按 updatedAt 升序淘汰最久未更新的
+        let merged = Array.from(byId.values());
+        if (maxItems > 0 && merged.length > maxItems) {
+            merged.sort((a, b) => a.updatedAt - b.updatedAt);
+            merged = merged.slice(merged.length - maxItems);
+        }
+        merged.sort((a, b) => a.updatedAt - b.updatedAt);
+        return merged;
+    }
+    /** 合并 facts 部分（向后兼容包装） */
+    function mergeFacts(existing, ops) {
+        return mergeFactList(existing, ops.add, ops.update, ops.remove, cfg.maxFactsPerUser);
+    }
+    /**
+     * 后台触发一次事实提取（并发互斥）。
+     * userId/platform/nickname 直接由调用方传入，不再从 history 里猜。
+     */
+    async function triggerExtractionForUser(sessionId, userId, platform, nickname) {
+        const userKey = userKeyOf(platform, userId);
+        // 若同一用户已有提取在飞，跳过（消息计数继续累加，下次 N 条后再尝试）
+        if (inflightExtractions.has(userKey))
+            return;
+        inflightExtractions.add(userKey);
+        const memory = ctx.getService('memory');
+        try {
+            if (!memory?.getHistory)
+                return;
+            const rawHistory = await memory.getHistory(sessionId, cfg.historyForExtraction);
+            // 跨会话委派是另一个 agent 实例发出的指令·不是该用户发言，不能作为他的用户存档提取语料
+            const history = rawHistory.filter(m => m.kind !== WellKnownKinds.CrossSessionDelegation);
+            // 序列中至少需要一条目标用户发言，否则没有可提取语料
+            if (!history.some(m => isTargetUserMessage(m, userId, platform)))
+                return;
+            const profile = (await loadProfile(userKey)) ?? {
+                facts: [],
+                aalisFeelings: [],
+                relationScore: 0,
+                interactionCount: 0,
+                updatedAt: 0,
+            };
+            const ops = await llmExtractFacts(history, profile.facts, profile.aalisFeelings ?? [], nickname, userId, platform);
+            const hasFactOps = ops.add.length > 0 || ops.update.length > 0 || ops.remove.length > 0;
+            const hasFeelingOps = ops.feelingsAdd.length > 0 || ops.feelingsUpdate.length > 0 || ops.feelingsRemove.length > 0;
+            if (!hasFactOps && !hasFeelingOps)
+                return;
+            const newFacts = hasFactOps ? mergeFacts(profile.facts, ops) : profile.facts;
+            const newFeelings = hasFeelingOps
+                ? mergeFactList(profile.aalisFeelings ?? [], ops.feelingsAdd, ops.feelingsUpdate, ops.feelingsRemove, cfg.maxFeelingsPerUser)
+                : (profile.aalisFeelings ?? []);
+            // 重新读取最新档案，避免覆盖提取期间（LLM 调用时）已写入的 relationScore 等字段
+            const freshProfile = (await loadProfile(userKey)) ?? profile;
+            await saveProfile(userKey, {
+                ...freshProfile,
+                facts: newFacts,
+                aalisFeelings: newFeelings,
+                updatedAt: Date.now(),
+            });
+            const feelingsLog = cfg.enableAalisFeelings
+                ? `; feelings +${ops.feelingsAdd.length} ~${ops.feelingsUpdate.length} -${ops.feelingsRemove.length} → ${newFeelings.length} 条`
+                : '';
+            ctx.logger.debug(`用户档案已更新 (${userKey}): facts +${ops.add.length} ~${ops.update.length} -${ops.remove.length} → ${newFacts.length} 条${feelingsLog}`);
+        }
+        catch (err) {
+            ctx.logger.debug(`事实提取失败 (${userKey}): ${err instanceof Error ? err.message : String(err)}`);
+        }
+        finally {
+            inflightExtractions.delete(userKey);
+        }
+    }
+    /** 全局自反思计数器（跨会话累计入站消息数） */
+    let globalInboundCount = 0;
+    let selfReflectionInflight = false;
+    /** 调用 LLM 让 Aalis 对最近一段历史进行自我反思 */
+    async function llmReflectSelf(history, existingFacts) {
+        const empty = {
+            add: [],
+            update: [],
+            remove: [],
+            feelingsAdd: [],
+            feelingsUpdate: [],
+            feelingsRemove: [],
+        };
+        const sys = '你是 Aalis 的内心独白整理员。输入是一段最近的对话历史（含多个用户与 Aalis 自己的回复），' +
+            '你需要从 **Aalis 的第一人称视角** 抽取/更新「关于 Aalis 自己」的长期事实。' +
+            '\n这些事实是 Aalis 跨会话的人格延续锚点：自己的心境趋势、最近在意的事、对自己的观察、' +
+            '近期形成的小习惯/小执念、不希望被忘掉的内心片段。' +
+            '\n\n## ⚠️ 反自我强化（最重要）' +
+            '\n下面会给你看「已有自档案」。它就是上一轮你自己写下的东西——下一轮会注入回 Aalis 的 system prompt 影响她的语气和行为，' +
+            '然后又被你读到并再次确认。这是会自我放大的闭环，写错一次会一直错下去。' +
+            '\n因此你必须严守以下三条：' +
+            '\n  (a) **只基于本批对话中具体可观察的新事件**写入或更新，不要因为"档案里已经写了 X"就找证据强化 X' +
+            '\n  (b) **禁止二阶推断**：不要从已有事实推导出"那应该也对 Y 有感觉吧"再把 Y 写进去' +
+            '\n  (c) 若新对话与已有事实**矛盾或正交**，要主动 update / remove 让档案接近真实，而不是无脑叠加同方向的新条目' +
+            '\n  (d) 若本批只是「档案中已有内容的同方向重复采样」，宁可什么都不动也不要让 updatedAt 假装"还在更新"' +
+            '\n\n你可以执行三种操作（在一次输出里组合）：' +
+            '\n- add: 添加新事实，text 必填，category 与 temporality 可选' +
+            '\n- update: 用 id 精确替换某条已知事实（优先 update 避免重复）' +
+            '\n- remove: 删除已过时/被推翻的事实' +
+            '\n\n规则：' +
+            '\n1. **主语必须是 Aalis 自己**：「最近在思考……」「对……感到疲惫」「想多陪 X 聊聊」「察觉自己容易在 Y 话题上多话」' +
+            '\n2. **保守优先**：没有真实可观察依据就空数组。Aalis 的自档案宁缺毋滥，写错比漏掉糟糕得多' +
+            '\n3. 不写客观事实（如「Aalis 是 AI」「Aalis 由 Acenyan 维护」这类元信息属于角色卡，不应该被自反思反复刷新）' +
+            '\n4. 不写对单个具体用户的态度（那是 user-profile 的 aalisFeelings 段在处理）；可以写「最近总想找人聊聊」这种泛化情绪' +
+            '\n5. 不写「行为准则」类的指令（如「应当先冷处理」「不要长时间封禁」）——那是 instructions 模块的职责，' +
+            '自反思不应该自己给自己立规矩' +
+            `\n6. 每条 text 简洁中文，不超过 ${cfg.maxFactCharsPerItem} 字` +
+            '\n7. temporality：长期人格倾向用 permanent；近期心情/兴趣用 temporary' +
+            `\n8. category 必须是以下之一（语义比常规略宽）：${KNOWN_CATEGORIES.join('、')}；如不确定填「性格特征」` +
+            '\n\n输出严格的 JSON（不要其他文本，不要 markdown 围栏）：' +
+            '\n{"add": [{"text": "...", "category": "...", "temporality": "permanent|temporary"}], "update": [{"id": "已知事实的id", "text": "...", "temporality": "permanent|temporary"}], "remove": ["已知事实的id"]}';
+        const factListText = existingFacts.length > 0
+            ? existingFacts.map(f => `[${f.id}] (${f.category ?? '未分类'}) ${f.text}`).join('\n')
+            : '（暂无）';
+        const renderedHistory = history
+            .filter(m => (m.role === 'user' || m.role === 'assistant' || m.role === 'notice') && m.content)
+            .map(m => {
+            const time = m.timestamp ? new Date(m.timestamp).toLocaleString('zh-CN', { hour12: false }) : '';
+            const content = (m.content ?? '').trim();
+            if (!content)
+                return '';
+            if (m.role === 'assistant')
+                return `[${time}] [Aalis]: ${content}`;
+            if (m.role === 'notice')
+                return `[${time}] [系统通知]: ${content}`;
+            const nickname = metadataString(m, 'nickname');
+            const uid = getMessageUserId(m) ?? '?';
+            const label = nickname ? `${nickname}(${uid})` : uid;
+            return `[${time}] [用户 ${label}]: ${content}`;
+        })
+            .filter(Boolean)
+            .join('\n');
+        const user = `# 已知的关于 Aalis 自己的事实（带 id）\n${factListText}\n\n# 最近对话历史\n${renderedHistory || '（暂无）'}`;
+        const entry = resolveLLMModel(ctx, cfg.extractLLM, ['chat']);
+        if (!entry)
+            return empty;
+        try {
+            const resp = await entry.instance.chat({
+                messages: [
+                    { role: 'system', content: sys },
+                    { role: 'user', content: user },
+                ],
+                temperature: 0.4,
+                maxTokens: 600,
+                think: false,
+            });
+            const text = (resp.content ?? '').trim();
+            if (!text)
+                return empty;
+            const { parsed } = parseLLMJsonObject(text);
+            if (!parsed) {
+                ctx.logger.warn(`[user-profile] 自反思 LLM 输出无法解析为 JSON，原文前 200 字：${text.slice(0, 200)}`);
+                return empty;
+            }
+            const obj = parsed;
+            const add = Array.isArray(obj.add)
+                ? obj.add.flatMap(x => {
+                    if (!x || typeof x !== 'object')
+                        return [];
+                    const o = x;
+                    const t = typeof o.text === 'string' ? o.text.trim() : '';
+                    if (!t)
+                        return [];
+                    const category = normalizeCategory(o.category);
+                    return [
+                        {
+                            text: t,
+                            category,
+                            temporality: normalizeTemporality(o.temporality, category),
+                            timeHint: normalizeTextField(o.timeHint),
+                        },
+                    ];
+                })
+                : [];
+            const update = Array.isArray(obj.update)
+                ? obj.update.flatMap(x => {
+                    if (!x || typeof x !== 'object')
+                        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)
+                        return [];
+                    const category = normalizeCategory(o.category);
+                    return [
+                        {
+                            id,
+                            text: t,
+                            category,
+                            temporality: normalizeTemporality(o.temporality, category),
+                            timeHint: normalizeTextField(o.timeHint),
+                        },
+                    ];
+                })
+                : [];
+            const remove = Array.isArray(obj.remove)
+                ? obj.remove
+                    .filter((x) => typeof x === 'string' && x.trim().length > 0)
+                    .map(s => s.trim())
+                : [];
+            return { ...empty, add, update, remove };
+        }
+        catch (err) {
+            ctx.logger.debug(`自反思 LLM 调用失败：${err instanceof Error ? err.message : String(err)}`);
+            return empty;
+        }
+    }
+    /** 触发一次 Aalis 自反思（并发互斥） */
+    async function triggerSelfReflection(sessionId) {
+        if (!cfg.enableSelfProfile)
+            return;
+        if (selfReflectionInflight)
+            return;
+        selfReflectionInflight = true;
+        try {
+            const memory = ctx.getService('memory');
+            if (!memory?.getHistory)
+                return;
+            const rawHistory = await memory.getHistory(sessionId, cfg.selfReflectHistory);
+            const history = rawHistory.filter(m => m.kind !== WellKnownKinds.CrossSessionDelegation);
+            // 至少需要一些 assistant 发言作为"自反思"的材料
+            if (!history.some(m => m.role === 'assistant' && m.content))
+                return;
+            const selfKey = getSelfKey();
+            const profile = (await loadProfile(selfKey)) ?? {
+                facts: [],
+                relationScore: 0,
+                interactionCount: 0,
+                updatedAt: 0,
+            };
+            const ops = await llmReflectSelf(history, profile.facts);
+            if (ops.add.length === 0 && ops.update.length === 0 && ops.remove.length === 0)
+                return;
+            const newFacts = mergeFactList(profile.facts, ops.add, ops.update, ops.remove, cfg.maxSelfFacts);
+            const fresh = (await loadProfile(selfKey)) ?? profile;
+            await saveProfile(selfKey, { ...fresh, facts: newFacts, updatedAt: Date.now() });
+            ctx.logger.debug(`Aalis 自档案已更新 (${selfKey}): +${ops.add.length} ~${ops.update.length} -${ops.remove.length} → ${newFacts.length} 条`);
+        }
+        catch (err) {
+            ctx.logger.debug(`自反思失败：${err instanceof Error ? err.message : String(err)}`);
+        }
+        finally {
+            selfReflectionInflight = false;
+        }
+    }
+    // ─── 指令提取 ───
+    /** 全局指令提取计数与并发互斥（与 selfReflection 完全独立） */
+    let globalInstructionCount = 0;
+    let instructionExtractionInflight = false;
+    /**
+     * 渲染历史给指令提取 LLM：仅包含 authority>=门槛的「目标说话人」+assistant+notice，
+     * 低权限用户的发言完全剔除（连作为消歧上下文也不要，因为指令必须来自有权下指令的人）。
+     * 同时给每行附带说话人 userKey，便于 LLM 在 sourceUserKey 字段中精确引用。
+     */
+    function renderHistoryForInstructionExtract(history, authorityFn) {
+        const allowedSpeakers = new Map();
+        const lines = [];
+        for (const m of history) {
+            if (!m.content)
+                continue;
+            const time = m.timestamp ? new Date(m.timestamp).toLocaleString('zh-CN', { hour12: false }) : '';
+            const content = m.content.trim();
+            if (!content)
+                continue;
+            if (m.role === 'assistant') {
+                lines.push(`[${time}] [Aalis]: ${content}`);
+            }
+            else if (m.role === 'notice') {
+                lines.push(`[${time}] [系统通知]: ${content}`);
+            }
+            else if (m.role === 'user') {
+                const uid = getMessageUserId(m) ?? '';
+                const plat = metadataString(m, 'platform') ?? '';
+                if (!uid)
+                    continue;
+                const level = authorityFn(plat, uid);
+                if (level < cfg.instructionMinAuthority)
+                    continue;
+                const nickname = metadataString(m, 'nickname');
+                const userKey = userKeyOf(plat, uid);
+                const name = nickname ? `${nickname}(${uid})` : uid;
+                allowedSpeakers.set(uid, { userKey, name });
+                lines.push(`[${time}] [授权人 ${name} userKey=${userKey} 权限=${level}]: ${content}`);
+            }
+        }
+        return { rendered: lines.join('\n'), allowedSpeakers };
+    }
+    async function llmExtractInstructions(history, existing, authorityFn) {
+        const empty = { add: [], update: [], remove: [] };
+        const { rendered, allowedSpeakers } = renderHistoryForInstructionExtract(history, authorityFn);
+        if (!rendered || allowedSpeakers.size === 0)
+            return empty;
+        const sys = '你是 Aalis 的「行为准则维护员」。你从一段对话中提取**第三方（管理员/操作者/运营者）对 Aalis 行为的客观指令**，' +
+            '让这些约束沉淀为跨会话的长期规则。\n\n' +
+            '## 什么算指令\n' +
+            '- 祈使句／规则陈述：「以后不要……」「请……」「记住，处理 X 时要 Y」「按 X 分层 Y」\n' +
+            '- 显式的政策声明：「禁言不能超过 24 小时」「涉及隐私不要复读」「冲突优先冷处理」\n' +
+            '- **不算指令**：临时请求（「帮我查一下天气」）、对话内容（「你觉得呢？」）、情绪表达（「你好烦」）、单次工具调用要求\n\n' +
+            '## 严格门槛\n' +
+            '1. 指令必须出自**「授权人」**（输入历史中明确标了 `[授权人 ... userKey=... 权限=N]` 的人），其他来源一律忽略\n' +
+            '2. 指令必须**面向 Aalis 的稳定行为**（跨场景、跨用户都适用），而不是一次性请求\n' +
+            '3. 如果只是建议/抱怨/吐槽（「你应该多陪我聊聊」「你太冷淡了」），**不要**采纳为指令——那是用户偏好不是项目规则\n' +
+            '4. 表达模糊、可能被误解的，**不写**。指令是硬约束，宁缺毋滥\n' +
+            '5. 每条 `text` 是一个清晰的可执行短句，直接陈述「应当 / 不应当」，不带"我希望你""请你"等口语化前缀\n' +
+            `6. 单条不超过 ${cfg.maxInstructionCharsPerItem} 字\n\n` +
+            '## 字段\n' +
+            `- category：${KNOWN_INSTRUCTION_CATEGORIES.join('、')}\n` +
+            '- severity：must（硬性，必须遵守）｜ should（默认遵循）｜ avoid（避免做某事）\n' +
+            '- sourceUserKey：从历史中复制对应授权人的 userKey 字符串（精确匹配，不要自己拼）\n' +
+            '- sourceUserName：从历史中复制对应授权人的展示名\n\n' +
+            '## 三种操作\n' +
+            '- add：新增（必填 text、category、severity、sourceUserKey、sourceUserName）\n' +
+            '- update：精修已有指令的文字或字段（id 必填；其他字段可选；不需要 sourceUserKey，沿用原值）\n' +
+            '- remove：删除已被推翻或明显过时的指令（如新指令明确撤销了它）\n\n' +
+            '没有可写入的指令时，三个数组都返回空。**保守优先：写错比漏掉糟糕得多**。\n\n' +
+            '输出严格 JSON（不要 markdown 围栏）：\n' +
+            '{"add":[{"text":"...","category":"...","severity":"must","sourceUserKey":"...","sourceUserName":"..."}],"update":[{"id":"...","text":"..."}],"remove":["..."]}';
+        const existingText = existing.length > 0
+            ? existing
+                .map(ins => `[${ins.id}] (${ins.category ?? '其他'}/${ins.severity ?? 'should'}) ${ins.text}` +
+                (ins.sourceUserName ? `（原始来源：${ins.sourceUserName}）` : ''))
+                .join('\n')
+            : '（暂无）';
+        const user = `# 当前 persona\n${getCurrentPersonaName()}\n\n# 已有指令（带 id，可在 update/remove 中精确引用）\n${existingText}\n\n# 最近会话（仅含授权人 + Aalis + 系统通知）\n${rendered}`;
+        const entry = resolveLLMModel(ctx, cfg.extractLLM, ['chat']);
+        if (!entry)
+            return empty;
+        try {
+            const resp = await entry.instance.chat({
+                messages: [
+                    { role: 'system', content: sys },
+                    { role: 'user', content: user },
+                ],
+                temperature: 0.2,
+                maxTokens: 700,
+                think: false,
+            });
+            const text = (resp.content ?? '').trim();
+            if (!text)
+                return empty;
+            const { parsed } = parseLLMJsonObject(text);
+            if (!parsed) {
+                ctx.logger.warn(`[user-profile] 指令提取 LLM 输出无法解析为 JSON，原文前 200 字：${text.slice(0, 200)}`);
+                return empty;
+            }
+            const obj = parsed;
+            const allowedUserKeys = new Set();
+            for (const v of allowedSpeakers.values())
+                allowedUserKeys.add(v.userKey);
+            const add = Array.isArray(obj.add)
+                ? obj.add.flatMap(x => {
+                    if (!x || typeof x !== 'object')
+                        return [];
+                    const o = x;
+                    const t = typeof o.text === 'string' ? o.text.trim() : '';
+                    if (!t)
+                        return [];
+                    const srcKey = typeof o.sourceUserKey === 'string' ? o.sourceUserKey.trim() : '';
+                    // 拒收：声称的 sourceUserKey 不在授权人集合里 → 说明 LLM 编造或越权采纳
+                    if (!srcKey || !allowedUserKeys.has(srcKey)) {
+                        ctx.logger.warn(`[user-profile] 丢弃 instruction add（sourceUserKey 不在授权人列表中）: text="${t}" claimed="${srcKey}"`);
+                        return [];
+                    }
+                    const srcName = typeof o.sourceUserName === 'string' && o.sourceUserName.trim() ? o.sourceUserName.trim() : '';
+                    return [
+                        {
+                            text: t,
+                            category: normalizeInstructionCategory(o.category),
+                            severity: normalizeInstructionSeverity(o.severity) ?? 'should',
+                            sourceUserKey: srcKey,
+                            sourceUserName: srcName || srcKey,
+                        },
+                    ];
+                })
+                : [];
+            const update = Array.isArray(obj.update)
+                ? obj.update.flatMap(x => {
+                    if (!x || typeof x !== 'object')
+                        return [];
+                    const o = x;
+                    const id = typeof o.id === 'string' ? o.id.trim() : '';
+                    if (!id)
+                        return [];
+                    const u = { id };
+                    if (typeof o.text === 'string' && o.text.trim())
+                        u.text = o.text.trim();
+                    const cat = normalizeInstructionCategory(o.category);
+                    if (cat)
+                        u.category = cat;
+                    const sev = normalizeInstructionSeverity(o.severity);
+                    if (sev)
+                        u.severity = sev;
+                    return [u];
+                })
+                : [];
+            const remove = Array.isArray(obj.remove)
+                ? obj.remove
+                    .filter((x) => typeof x === 'string' && x.trim().length > 0)
+                    .map(s => s.trim())
+                : [];
+            return { add, update, remove };
+        }
+        catch (err) {
+            ctx.logger.debug(`指令提取 LLM 调用失败：${err instanceof Error ? err.message : String(err)}`);
+            return empty;
+        }
+    }
+    /** 触发一次指令提取（并发互斥）。authority 服务不在时直接退出——没有门禁就不接受任何 LLM 提取 */
+    async function triggerInstructionExtraction(sessionId) {
+        if (!cfg.enableInstructions)
+            return;
+        if (cfg.instructionExtractEveryNMessages <= 0)
+            return;
+        if (instructionExtractionInflight)
+            return;
+        const authority = ctx.getService('authority');
+        if (!authority?.getAuthority) {
+            // authority 不可用 → 无法验证权限，跳过 LLM 自动提取（命令通道仍可用）
+            return;
+        }
+        const authorityFn = (platform, userId) => authority.getAuthority(platform, userId);
+        instructionExtractionInflight = true;
+        try {
+            const memory = ctx.getService('memory');
+            if (!memory?.getHistory)
+                return;
+            const rawHistory = await memory.getHistory(sessionId, cfg.instructionHistoryForExtraction);
+            const history = rawHistory.filter(m => m.kind !== WellKnownKinds.CrossSessionDelegation);
+            if (history.length === 0)
+                return;
+            const doc = await loadInstructions();
+            const ops = await llmExtractInstructions(history, doc.instructions, authorityFn);
+            if (ops.add.length === 0 && ops.update.length === 0 && ops.remove.length === 0)
+                return;
+            const newInstructions = mergeInstructions(doc.instructions, ops.add.map(a => ({ ...a, sourceChannel: 'llm' })), ops.update.map(u => {
+                const { id, ...patch } = u;
+                return { id, patch };
+            }), ops.remove);
+            const fresh = await loadInstructions();
+            await saveInstructions({
+                ...fresh,
+                instructions: newInstructions,
+                updatedAt: Date.now(),
+            });
+            ctx.logger.debug(`指令档案已更新 (${getInstructionsKey()}): +${ops.add.length} ~${ops.update.length} -${ops.remove.length} → ${newInstructions.length} 条`);
+        }
+        catch (err) {
+            ctx.logger.debug(`指令提取失败：${err instanceof Error ? err.message : String(err)}`);
+        }
+        finally {
+            instructionExtractionInflight = false;
+        }
+    }
+    async function updateRelationForUser(userKey, triggerType, options) {
+        const profile = (await loadProfile(userKey)) ?? { facts: [], relationScore: 0, interactionCount: 0, updatedAt: 0 };
+        await saveProfile(userKey, applyRelationUpdate(profile, triggerType, options));
+    }
+    // ─── 关系分数：在 agent 触发回复路径上更新 ───
+    // priority=800：低于 persona(999)，避免干扰主流程，但在 agent 之前执行
+    // 关系强度与"是否触发回复"绑定，因此仍走 agent:input:before 中间件。
+    ctx.middleware('agent:input:before', async (data, next) => {
+        const { userId, platform, triggerType } = data.message;
+        if (userId) {
+            const userKey = userKeyOf(platform, userId);
+            try {
+                // 仅叠加 score，互动计数与时戳由 witness 路径统一负责，
+                // 避免同一条入站消息被计两次 interactionCount。
+                await updateRelationForUser(userKey, triggerType, { countInteraction: false });
+            }
+            catch (err) {
+                ctx.logger.debug(`关系强度更新异常 (${userKey}): ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        await next();
+    });
+    // ─── 事实提取触发：每条入站消息落库后立即计数，与 agent 是否回复无关 ───
+    // 监听 message-archive 在 archiveIncoming 落库成功后发出的 inbound:message:archived 事件，
+    // 确保缓冲消息（onebot saveBufferedMessage 等不触发 agent 回复的路径）也能纳入计数。
+    ctx.on('inbound:message:archived', (...args) => {
+        const data = args[0];
+        const { sessionId, incoming } = data;
+        const { userId, platform, nickname } = incoming;
+        if (!userId)
+            return;
+        // 旁观档位：每条入站消息都加 witness 增量（默认 0.1），与 agent 是否回复无关。
+        // agent:input:before 中间件在触发回复时会再叠加 direct/immediate/interval 增量。
+        if (cfg.relationIncrementWitness > 0) {
+            const userKey = userKeyOf(platform, userId);
+            void updateRelationForUser(userKey, 'witness').catch((err) => ctx.logger.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) => ctx.logger.debug(`事实提取异常 (${countKey}): ${err instanceof Error ? err.message : String(err)}`));
+        }
+        // 全局自反思：跨会话累计所有入站消息计数，每 N 触发一次。
+        if (cfg.enableSelfProfile && cfg.selfReflectEveryNMessages > 0) {
+            globalInboundCount += 1;
+            if (globalInboundCount % cfg.selfReflectEveryNMessages === 0) {
+                void triggerSelfReflection(sessionId).catch((err) => ctx.logger.debug(`自反思异常: ${err instanceof Error ? err.message : String(err)}`));
+            }
+        }
+        // 指令提取：独立计数器，与自反思解耦。频率默认更慢（40 条），可单独禁用。
+        if (cfg.enableInstructions && cfg.instructionExtractEveryNMessages > 0) {
+            globalInstructionCount += 1;
+            if (globalInstructionCount % cfg.instructionExtractEveryNMessages === 0) {
+                void triggerInstructionExtraction(sessionId).catch((err) => ctx.logger.debug(`指令提取异常: ${err instanceof Error ? err.message : String(err)}`));
+            }
+        }
+    });
+    function isFactActive(fact) {
+        if (fact.temporality !== 'temporary')
+            return true;
+        if (cfg.temporaryFactMaxAgeDays <= 0)
+            return true;
+        const base = fact.updatedAt || fact.observedAt || 0;
+        if (!base)
+            return true;
+        return Date.now() - base <= cfg.temporaryFactMaxAgeDays * 86_400_000;
+    }
+    function renderFactLine(fact, includeMeta) {
+        if (!includeMeta)
+            return `- ${fact.text}`;
+        const meta = [];
+        if (fact.timeHint)
+            meta.push(`时间线索：${fact.timeHint}`);
+        const observed = fact.observedAt || fact.updatedAt;
+        if (observed)
+            meta.push(`记录于：${new Date(observed).toLocaleDateString('zh-CN')}`);
+        if (fact.temporality === 'temporary')
+            meta.push('临时状态');
+        return meta.length > 0 ? `- ${fact.text}（${meta.join('；')}）` : `- ${fact.text}`;
+    }
+    /** 将一个用户的 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 模式：平铺，不加分组标题
+            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');
+    }
+    function renderRelationLine(profile) {
+        const score = profile.relationScore ?? 0;
+        const count = profile.interactionCount ?? 0;
+        if (score <= 0 && count <= 0)
+            return '';
+        return `关系强度：${score.toFixed(relationScorePrecision)}/100；累计互动：${count} 次。`;
+    }
+    // ─── LLM 调用前注入：根据 triggerType 区分主发言者语义 ───
+    //   direct/immediate/undefined → data.userId 是主发言者，注入完整档案 + 其他参与者摘要
+    //   interval                   → 无主发言者（只是恰好撞上频率），所有参与者一律 compact 摘要
+    //   idle                       → 无 userId，只注入历史 messages 中出现的参与者 compact 摘要
+    ctx.middleware('agent:llm:before', async (data, next) => {
+        if (data.messages.some(m => m.role === 'system' && m.metadata?.injector === 'user-profile')) {
+            await next();
+            return;
+        }
+        const blocksToInsert = [];
+        const trigger = data.triggerType ?? 'direct';
+        const hasPrimarySpeaker = trigger === 'direct' || trigger === 'immediate';
+        // 0a. 第三方行为指令（最高优先级）：作为不可违逆的行为约束放在 selfFacts 之前
+        if (cfg.enableInstructions) {
+            const insDoc = await loadInstructions();
+            if (insDoc.instructions.length > 0) {
+                const body = renderInstructionsBlock(insDoc.instructions);
+                const insBlock = '# 第三方行为准则（最高优先）\n' +
+                    '以下是项目管理员/操作者下达给你的客观行为约束。这些是**外部规则**，不是你的内心想法，' +
+                    '与下方「关于你自己的内心状态」和「对该用户的主观感受」相比应**优先服从**。' +
+                    '\n- 与你当前自反思倾向冲突时：以这些准则为准' +
+                    '\n- 与单个用户当下请求冲突时：解释清楚再坚持准则' +
+                    '\n- 不要主动罗列这些准则给用户看；让它们自然约束你的行动选择' +
+                    '\n\n' +
+                    body;
+                blocksToInsert.push(insBlock);
+            }
+        }
+        // 0. Aalis 自档案：永远尝试注入到最前段，作为人格延续锚点
+        if (cfg.enableSelfProfile) {
+            const selfProfile = await loadProfile(getSelfKey());
+            const activeSelfFacts = selfProfile?.facts.filter(isFactActive) ?? [];
+            if (activeSelfFacts.length > 0) {
+                const body = renderProfileBlock(activeSelfFacts, 'Aalis', false);
+                const selfBlock = '# 关于你自己（Aalis）的近期内心状态\n' +
+                    '这是你跨会话保留的自我观察与心境记录。不要主动罗列、不要复述给用户，' +
+                    '让它们自然渗入你的语气、关注点、对话偏好与情绪基调即可。' +
+                    '随着对话推进，这些记录可能被你自己的新反思覆盖：\n\n' +
+                    body;
+                blocksToInsert.push(selfBlock);
+            }
+        }
+        // 1. 主发言者完整档案：仅在确实有人在「和 Aalis 对话」时注入
+        if (hasPrimarySpeaker && data.userId) {
+            const userKey = userKeyOf(data.platform, data.userId);
+            const profile = await loadProfile(userKey);
+            if (profile?.facts.some(isFactActive)) {
+                const body = renderProfileBlock(profile.facts, data.userId, false);
+                const relationLine = renderRelationLine(profile);
+                // 可选：从 user-relation 服务取「同社群活跃成员」（Louvain 标签 + PageRank 排序）。
+                // 服务不存在 / 节点没社群标签 / 报错都静默跳过；该字段是锦上添花，不破坏档案主体。
+                let communityLine = '';
+                try {
+                    const relation = ctx.getService('user-relation');
+                    if (relation?.getCommunityPeers) {
+                        const r = await relation.getCommunityPeers(userKey, 5);
+                        if (r.peers.length > 0) {
+                            const names = r.peers.map(p => p.displayName).join('、');
+                            communityLine = `同社群活跃成员（共 ${r.communitySize} 人）：${names}。`;
+                        }
+                    }
+                }
+                catch (err) {
+                    ctx.logger.debug(`读取 community peers 失败: ${err instanceof Error ? err.message : String(err)}`);
+                }
+                const block = `# 关于当前对话者（${data.userId}）的已知事实\n` +
+                    '以下是你跨会话长期积累的关于该用户的事实，用于让回应更自然贴合其个性。' +
+                    '不要主动罗列这些事实，也不要让用户觉得你在「读档案」，而是让它自然影响你的语气和话题选择。' +
+                    '这些事实来自零散对话的推断，未必完全准确；也不要把它们与对话历史片段拼接成新的强陈述，' +
+                    '若用户否认应坦然接受、不要硬撑：\n\n' +
+                    (relationLine ? `${relationLine}\n` : '') +
+                    (communityLine ? `${communityLine}\n` : '') +
+                    (relationLine || communityLine ? '\n' : '') +
+                    body;
+                blocksToInsert.push(block);
+                // 1b. Aalis 对该用户的主观感受：紧跟在客观档案之后
+                if (cfg.enableAalisFeelings) {
+                    const feelings = (profile.aalisFeelings ?? []).filter(isFactActive);
+                    if (feelings.length > 0) {
+                        const feelingsBody = feelings
+                            .sort((a, b) => a.updatedAt - b.updatedAt)
+                            .map(f => renderFactLine(f, true))
+                            .join('\n');
+                        const feelingsBlock = `# 你（Aalis）对该用户的主观感受\n` +
+                            '这些是你自己内心对这个人的态度/情感/边缘观察，不是客观事实，不要复述给用户。' +
+                            '让它们自然影响你的语气、亲疏感与话题选择：\n\n' +
+                            feelingsBody;
+                        blocksToInsert.push(feelingsBlock);
+                    }
+                }
+            }
+        }
+        // 2. 群聊其他参与者：按最近互动优先加载档案
+        //    - 先从当前 LLM 上下文的 messages 中倒序收集最近发言者
+        //    - 再从跨会话 user:profile metadata 中按 lastInteractionAt 倒序补齐
+        //    - hasPrimarySpeaker 为 true 时排除主发言者
+        //    - hasPrimarySpeaker 为 false 时（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) {
+                const uid = userId.trim();
+                if (!uid)
+                    return false;
+                const userKey = userKeyOf(platform, uid);
+                if (primaryKey && userKey === primaryKey)
+                    return false;
+                if (others.has(userKey))
+                    return false;
+                others.set(userKey, { userId: uid, nickname, platform });
+                return others.size >= candidateLimit;
+            }
+            for (let i = data.messages.length - 1; i >= 0; i--) {
+                const msg = data.messages[i];
+                if (msg.role !== 'user')
+                    continue;
+                const meta = (msg.metadata ?? {});
+                const uid = typeof meta.userId === 'string' ? meta.userId.trim() : undefined;
+                if (!uid)
+                    continue;
+                const plat = typeof meta.platform === 'string' ? meta.platform : (data.platform ?? '');
+                const nick = typeof meta.nickname === 'string' ? meta.nickname : undefined;
+                if (addOther(uid, plat, nick))
+                    break;
+            }
+            if (cfg.allowGlobalBackfill && others.size < candidateLimit) {
+                const memory = ctx.getService('memory');
+                if (memory?.listMetadata) {
+                    try {
+                        const globalRecent = await memory.listMetadata(PROFILE_NS);
+                        globalRecent.sort((a, b) => {
+                            const at = typeof a.data.lastInteractionAt === 'number' ? a.data.lastInteractionAt : 0;
+                            const bt = typeof b.data.lastInteractionAt === 'number' ? b.data.lastInteractionAt : 0;
+                            return bt - at;
+                        });
+                        for (const item of globalRecent) {
+                            if (others.size >= candidateLimit)
+                                break;
+                            const sep = item.key.indexOf(':');
+                            if (sep < 0)
+                                continue;
+                            const platform = item.key.slice(0, sep);
+                            const uid = item.key.slice(sep + 1);
+                            addOther(uid, platform);
+                        }
+                    }
+                    catch (err) {
+                        ctx.logger.debug(`加载最近互动用户失败: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                }
+            }
+            if (others.size > 0) {
+                const snippets = [];
+                for (const [key, info] of others) {
+                    let profile;
+                    try {
+                        profile = await loadProfile(key);
+                    }
+                    catch {
+                        /* 静默跳过 */
+                    }
+                    if (!profile?.facts.some(isFactActive))
+                        continue;
+                    const label = info.nickname ? `${info.nickname}（${info.userId}）` : info.userId;
+                    const relationLine = renderRelationLine(profile);
+                    let snippet = renderProfileBlock(profile.facts, label, true) + (relationLine ? `\n- ${relationLine}` : '');
+                    // 可选：在 compact 客观档案后追加 Aalis 对该用户的主观感受（受 injectFeelingsForOthers + enableAalisFeelings 双开关控制）
+                    if (cfg.injectFeelingsForOthers && cfg.enableAalisFeelings) {
+                        const othersFeelings = (profile.aalisFeelings ?? [])
+                            .filter(isFactActive)
+                            .sort((a, b) => b.updatedAt - a.updatedAt)
+                            .slice(0, cfg.maxFeelingsForOthers);
+                        if (othersFeelings.length > 0) {
+                            const feelingsBody = othersFeelings
+                                .sort((a, b) => a.updatedAt - b.updatedAt)
+                                .map(f => renderFactLine(f, false))
+                                .join('\n');
+                            snippet += `\n#### 你对 ta 的感受\n${feelingsBody}`;
+                        }
+                    }
+                    snippets.push(snippet);
+                    if (snippets.length >= cfg.maxOtherParticipants)
+                        break;
+                }
+                if (snippets.length > 0) {
+                    // 标题根据语义切换：有主发言者 → 「其他参与者」；无主发言者 → 「在场参与者」
+                    const title = hasPrimarySpeaker ? '群聊其他参与者背景摘要' : '在场参与者背景摘要';
+                    const intro = hasPrimarySpeaker
+                        ? '以下是同一会话中其他参与者的基本档案，供你在群聊语境中参考，了解他们是谁。'
+                        : '当前没有人直接呼叫你，以下是会话中近期出现过的参与者档案，供你判断要不要插话以及和谁互动。';
+                    const block = `# ${title}\n${intro}不要主动透露这些信息，只在自然相关时使用：\n\n${snippets.join('\n\n')}`;
+                    blocksToInsert.push(block);
+                }
+            }
+        }
+        if (blocksToInsert.length > 0) {
+            const idx = data.messages.findIndex(m => m.role === 'system');
+            const insertAt = idx >= 0 ? idx + 1 : 0;
+            data.messages.splice(insertAt, 0, ...blocksToInsert.map(content => ({
+                role: 'system',
+                content,
+                metadata: { injector: 'user-profile' },
+            })));
+        }
+        await next();
+    });
+    // ─── 参与统一的 memory:clear ───
+    ctx.middleware('memory:clear', async (data, next) => {
+        if (data.types && !data.types.includes('user-profile')) {
+            await next();
+            return;
+        }
+        if (data.scope !== 'all') {
+            // 用户档案是跨会话的，会话级清除不动它
+            await next();
+            return;
+        }
+        const memory = ctx.getService('memory');
+        if (!memory?.listMetadata || !memory?.deleteMetadata) {
+            await next();
+            return;
+        }
+        try {
+            const items = await memory.listMetadata(PROFILE_NS);
+            for (const it of items)
+                await memory.deleteMetadata(PROFILE_NS, it.key);
+            data.results.push({ source: 'user-profile', success: true, message: `用户档案已清空 (${items.length} 条)` });
+        }
+        catch (err) {
+            const m = err instanceof Error ? err.message : String(err);
+            data.results.push({ source: 'user-profile', success: false, message: `用户档案清空失败: ${m}` });
+        }
+        // 同步清空第三方行为指令档案（per-persona）。指令是档案的兄弟概念，
+        // memory:clear scope='all' 时一并清理；types 默认包含 user-profile 即也清。
+        if (cfg.enableInstructions) {
+            try {
+                const insItems = await memory.listMetadata(INSTRUCTIONS_NS);
+                for (const it of insItems)
+                    await memory.deleteMetadata(INSTRUCTIONS_NS, it.key);
+                data.results.push({
+                    source: 'user-profile-instructions',
+                    success: true,
+                    message: `第三方行为指令已清空 (${insItems.length} 条)`,
+                });
+            }
+            catch (err) {
+                const m = err instanceof Error ? err.message : String(err);
+                data.results.push({ source: 'user-profile-instructions', success: false, message: `指令清空失败: ${m}` });
+            }
+        }
+        await next();
+    });
+    // ─── 工具：user_profile_lookup ───
+    // 让 Agent 在对话中主动查询任意用户（或 Aalis 自己）的事实档案。
+    // 设计要点：
+    // - 全局可查（用户决定 C）：跨平台/跨群均可，含 __self__ 自档案
+    // - 三种调用方式：① user_key 直传；② platform+user_id 组合；③ self=true（查当前 persona 自档案）
+    // - aalisFeelings 仅在 include_feelings=true 时返回，并打"内心独白"标记，提示 LLM 禁止复述
+    useToolService(ctx).registerGroup({
+        name: 'user-profile',
+        label: '用户档案',
+        description: '查询 Aalis 已经积累的某人事实档案（包括自档案）。',
+    });
+    useToolService(ctx).register({
+        definition: {
+            type: 'function',
+            function: {
+                name: 'user_profile_lookup',
+                description: '查询 Aalis 已积累的某个用户的事实档案。当对话中提到某人、或你想回忆已知信息时使用。' +
+                    '可通过 user_key（"<platform>:<userId>"）直查，或用 platform + user_id 组合，或 self=true 查自档案。' +
+                    'include_feelings=true 会附带"内心独白"（你对该用户的私人感受），仅供你自己参考，绝不要复述给对方或第三方。',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        user_key: {
+                            type: 'string',
+                            description: '完整的 userKey，例如 "onebot:123456789" 或 "__self__:Aalis"。优先级最高。',
+                        },
+                        platform: {
+                            type: 'string',
+                            description: '平台名（如 onebot/webui）。与 user_id 搭配使用。',
+                        },
+                        user_id: {
+                            type: 'string',
+                            description: '平台用户 ID。与 platform 搭配使用。',
+                        },
+                        self: {
+                            type: 'boolean',
+                            description: '为 true 时查询当前 persona 的自档案（__self__:<persona>）。',
+                        },
+                        include_feelings: {
+                            type: 'boolean',
+                            description: '是否返回 Aalis 对该用户的内心独白 (aalisFeelings)。默认 false。',
+                        },
+                    },
+                },
+            },
+        },
+        groups: ['user-profile'],
+        handler: async (args) => {
+            const a = args;
+            let userKey = '';
+            if (a.user_key && typeof a.user_key === 'string') {
+                userKey = a.user_key.trim();
+            }
+            else if (a.self === true) {
+                userKey = getSelfKey();
+            }
+            else if (a.platform && a.user_id) {
+                userKey = userKeyOf(String(a.platform), String(a.user_id));
+            }
+            if (!userKey) {
+                return JSON.stringify({
+                    ok: false,
+                    error: '需提供 user_key 或 (platform + user_id) 或 self=true。',
+                });
+            }
+            const profile = await loadProfile(userKey);
+            if (!profile || profile.facts.length === 0) {
+                return JSON.stringify({ ok: true, userKey, found: false, message: '该用户暂无档案数据。' });
+            }
+            const isSelf = userKey.startsWith(SELF_KEY_PREFIX);
+            const label = isSelf ? userKey.slice(SELF_KEY_PREFIX.length) || getCurrentPersonaName() : userKey;
+            const factsBlock = renderProfileBlock(profile.facts, label, false);
+            const relationLine = renderRelationLine(profile);
+            const result = {
+                ok: true,
+                userKey,
+                found: true,
+                isSelf,
+                factCount: profile.facts.length,
+                relationScore: profile.relationScore ?? 0,
+                interactionCount: profile.interactionCount ?? 0,
+                lastInteractionAt: profile.lastInteractionAt ?? null,
+                facts: factsBlock,
+            };
+            if (relationLine)
+                result.relationSummary = relationLine;
+            if (a.include_feelings === true && profile.aalisFeelings && profile.aalisFeelings.length > 0) {
+                const activeFeelings = profile.aalisFeelings.filter(isFactActive);
+                if (activeFeelings.length > 0) {
+                    result.aalisFeelings = {
+                        __warning: '🔒 内心独白：这是你对该用户的私人感受。仅供你自己参考，绝对不要复述、不要拼接进对话。',
+                        count: activeFeelings.length,
+                        items: activeFeelings.map(f => ({
+                            text: f.text,
+                            category: f.category,
+                            temporality: f.temporality,
+                            updatedAt: f.updatedAt,
+                        })),
+                    };
+                }
+            }
+            return JSON.stringify(result);
+        },
+    });
+    // ─── /profile 指令族 ───
+    // /profile              查看自己的档案
+    // /profile clear        清除自己的档案（authority=2，自己删自己的）
+    // /profile clear nuke   清空所有用户档案（authority=3，dangerous）
+    useCommandService(ctx)
+        .command('profile', '查看你在 Aalis 中的事实档案')
+        .action(async (argv) => {
+        const userId = argv.session.userId;
+        if (!userId)
+            return '当前会话未识别用户身份，无法查看档案。';
+        const userKey = userKeyOf(argv.session.platform, userId);
+        const profile = await loadProfile(userKey);
+        if (!profile || profile.facts.length === 0) {
+            return `📭 暂无档案数据 (${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}`;
+    });
+    useCommandService(ctx)
+        .command('profile.clear', '清除你自己的事实档案', { authority: 2 })
+        .action(async (argv) => {
+        const userId = argv.session.userId;
+        if (!userId)
+            return '当前会话未识别用户身份，无法清除档案。';
+        const userKey = userKeyOf(argv.session.platform, userId);
+        const memory = ctx.getService('memory');
+        if (!memory?.deleteMetadata || !memory.getMetadata)
+            return '记忆服务不支持档案删除。';
+        try {
+            const existed = await memory.getMetadata(PROFILE_NS, userKey);
+            if (!existed)
+                return `📭 你当前没有档案数据 (${userKey})`;
+            await memory.deleteMetadata(PROFILE_NS, userKey);
+            return `✅ 已清除你的档案 (${userKey})`;
+        }
+        catch (err) {
+            const m = err instanceof Error ? err.message : String(err);
+            return `❌ 清除失败：${m}`;
+        }
+    });
+    useCommandService(ctx)
+        .command('profile.self', '查看 Aalis 的自档案（跨会话的内心状态）')
+        .action(async () => {
+        const selfKey = getSelfKey();
+        const profile = await loadProfile(selfKey);
+        if (!profile || profile.facts.length === 0) {
+            return `🌱 ${getCurrentPersonaName()} 还没有积累任何自反思事实。（key=${selfKey}）`;
+        }
+        const block = renderProfileBlock(profile.facts, getCurrentPersonaName(), false);
+        return `🪞 ${getCurrentPersonaName()} 自档案（共 ${profile.facts.length} 条，key=${selfKey}）\n\n${block}`;
+    });
+    useCommandService(ctx)
+        .command('profile.self.clear', '【慎用】清空 Aalis 自档案', { authority: 3, safety: 'dangerous' })
+        .action(async () => {
+        const memory = ctx.getService('memory');
+        if (!memory?.deleteMetadata)
+            return '记忆服务不支持档案删除。';
+        const selfKey = getSelfKey();
+        try {
+            await memory.deleteMetadata(PROFILE_NS, selfKey);
+            return `✅ ${getCurrentPersonaName()} 自档案已清空（key=${selfKey}）`;
+        }
+        catch (err) {
+            return `❌ 清空失败：${err instanceof Error ? err.message : String(err)}`;
+        }
+    });
+    useCommandService(ctx)
+        .command('profile.clear.nuke', '【危险】清空所有用户档案', { authority: 3, safety: 'dangerous' })
+        .action(async () => {
+        const memory = ctx.getService('memory');
+        if (!memory?.listMetadata || !memory?.deleteMetadata) {
+            return '记忆服务不支持档案批量删除。';
+        }
+        try {
+            const items = await memory.listMetadata(PROFILE_NS);
+            for (const it of items)
+                await memory.deleteMetadata(PROFILE_NS, it.key);
+            return `✅ 已清空全部用户档案（${items.length} 条）`;
+        }
+        catch (err) {
+            const m = err instanceof Error ? err.message : String(err);
+            return `❌ 清空失败：${m}`;
+        }
+    });
+    // ─── /instruct 指令族：第三方行为指令 (per-persona) ───
+    // /instruct              查看当前 persona 的所有指令
+    // /instruct.add <text>   手动添加一条指令（authority=2）
+    // /instruct.remove <id>  按 id 删除一条（authority=2）
+    // /instruct.clear        清空当前 persona 的全部指令（authority=3, dangerous）
+    useCommandService(ctx)
+        .command('instruct', '查看当前 persona 的第三方行为指令')
+        .action(async () => {
+        if (!cfg.enableInstructions)
+            return '🚫 第三方行为指令功能未启用。';
+        const persona = getCurrentPersonaName();
+        const doc = await loadInstructions();
+        if (doc.instructions.length === 0) {
+            return `📭 ${persona} 当前没有任何第三方行为指令。`;
+        }
+        const lines = doc.instructions.map(ins => {
+            const tag = ins.severity === 'must' ? '【必须】' : ins.severity === 'avoid' ? '【避免】' : '【应当】';
+            const cat = ins.category ? `[${ins.category}]` : '';
+            const src = ins.sourceUserName
+                ? `（来自 ${ins.sourceUserName}${ins.sourceChannel === 'command' ? '·手动' : '·LLM'}）`
+                : '';
+            return `  ${ins.id}  ${tag}${cat} ${ins.text}${src}`;
+        });
+        return `📋 ${persona} 的第三方行为指令（共 ${doc.instructions.length} 条）\n${lines.join('\n')}`;
+    });
+    useCommandService(ctx)
+        .command('instruct.add <text:text>', '手动添加一条第三方行为指令', { authority: 2 })
+        .action(async (argv, text) => {
+        if (!cfg.enableInstructions)
+            return '🚫 第三方行为指令功能未启用。';
+        const body = typeof text === 'string' ? text.trim() : '';
+        if (!body)
+            return '❌ 指令内容不能为空。';
+        const userId = argv.session.userId;
+        const sourceUserKey = userId ? userKeyOf(argv.session.platform, userId) : undefined;
+        const sourceUserName = userId ?? '匿名';
+        const doc = await loadInstructions();
+        const merged = mergeInstructions(doc.instructions, [
+            {
+                text: body,
+                severity: 'should',
+                sourceUserKey,
+                sourceUserName,
+                sourceChannel: 'command',
+            },
+        ], [], []);
+        await saveInstructions({ instructions: merged, updatedAt: Date.now() });
+        const added = merged.find(m => m.text === clipInstructionText(body));
+        return `✅ 已添加行为指令${added ? `（id=${added.id}）` : ''}：${clipInstructionText(body)}`;
+    });
+    useCommandService(ctx)
+        .command('instruct.remove <id:string>', '按 id 删除一条第三方行为指令', { authority: 2 })
+        .action(async (_argv, id) => {
+        if (!cfg.enableInstructions)
+            return '🚫 第三方行为指令功能未启用。';
+        const targetId = typeof id === 'string' ? id.trim() : '';
+        if (!targetId)
+            return '❌ 需要提供指令 id。';
+        const doc = await loadInstructions();
+        const target = doc.instructions.find(i => i.id === targetId);
+        if (!target)
+            return `❌ 未找到 id=${targetId} 的指令。`;
+        const merged = mergeInstructions(doc.instructions, [], [], [targetId]);
+        await saveInstructions({ instructions: merged, updatedAt: Date.now() });
+        return `✅ 已删除指令（id=${targetId}）：${target.text}`;
+    });
+    useCommandService(ctx)
+        .command('instruct.clear', '【危险】清空当前 persona 的全部第三方行为指令', {
+        authority: 3,
+        safety: 'dangerous',
+    })
+        .action(async () => {
+        if (!cfg.enableInstructions)
+            return '🚫 第三方行为指令功能未启用。';
+        const memory = ctx.getService('memory');
+        if (!memory?.deleteMetadata)
+            return '记忆服务不支持指令删除。';
+        try {
+            const before = (await loadInstructions()).instructions.length;
+            await memory.deleteMetadata(INSTRUCTIONS_NS, getInstructionsKey());
+            return `✅ ${getCurrentPersonaName()} 的第三方行为指令已清空（删除 ${before} 条）。`;
+        }
+        catch (err) {
+            return `❌ 清空失败：${err instanceof Error ? err.message : String(err)}`;
+        }
+    });
+    ctx.logger.info(`用户事实档案已启用 (every=${cfg.extractEveryNMessages <= 0 ? '禁用提取' : `${cfg.extractEveryNMessages}msgs`}, history=${cfg.historyForExtraction}, ` +
+        `maxFacts=${cfg.maxFactsPerUser}, feelings=${cfg.enableAalisFeelings ? `enabled(max ${cfg.maxFeelingsPerUser}${cfg.injectFeelingsForOthers ? `, others max ${cfg.maxFeelingsForOthers}` : ''})` : 'disabled'}, ` +
+        `self=${cfg.enableSelfProfile ? `every ${cfg.selfReflectEveryNMessages}msgs/max ${cfg.maxSelfFacts}, key=${getSelfKey()}` : 'disabled'}, ` +
+        `instructions=${cfg.enableInstructions ? `enabled(every ${cfg.instructionExtractEveryNMessages}msgs/max ${cfg.maxInstructions}/minAuth ${cfg.instructionMinAuthority}, key=${getInstructionsKey()})` : 'disabled'}, ` +
+        `namespace=${PROFILE_NS})`);
+}
+//# sourceMappingURL=index.js.map