@aalis/plugin-user-profile 0.13.1 → 0.14.0

package/dist/index.js

@@ -1,14 +1,14 @@
-import { authority, DEFAULT_AUTHORITY } from '@aalis/api-authority';
 import { commands } from '@aalis/api-commands';
 import { contributions } from '@aalis/api-contributions';
 import { hooks } from '@aalis/api-hooks';
-import { llm, resolveLLMModel } from '@aalis/api-llm';
+import { lightestThinking, llm, resolveLLMModel } from '@aalis/api-llm';
 import { clearMetadataNamespaces, memory } from '@aalis/api-memory';
-import { persona } from '@aalis/api-persona';
 import { tools } from '@aalis/api-tools';
 import { userRelation } from '@aalis/api-user-relation';
+import { webuiServer } from '@aalis/api-webui';
 import { config, definePlugin, events, logger, optional } from '@aalis/core';
-import { WellKnownKinds } from '@aalis/schema-message';
+import { defineConfig, parseConfig } from '@aalis/schema-config';
+import { DIRECTIVE_KINDS, WellKnownMetadataKeys } from '@aalis/schema-message';
 import { parseLLMJsonObject } from '@aalis/util-json-repair';
 // ════════════════════════════════════════════════════════════
 // plugin-user-profile — 用户事实档案
@@ -34,18 +34,7 @@ import { parseLLMJsonObject } from '@aalis/util-json-repair';
 // 例：群聊纯旁观一条 = +0.1；群聊被 @ 并回复 = +0.1 + 1.5 = +1.6；私聊一条 = +0.1 + 1.0 = +1.1
 // ════════════════════════════════════════════════════════════
 const PROFILE_NS = 'user:profile';
-/** 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';
-const configSchema = {
+const configSchema = defineConfig({
     extractEveryNMessages: {
         type: 'number',
         label: '每 N 条消息提取一次',
@@ -125,74 +114,12 @@ const configSchema = {
     },
     allowGlobalBackfill: {
         type: 'boolean',
+        onInvalid: 'error',
         label: '允许跨会话补齐副档案',
         description: '当前群/会话中的候选不足时，是否允许从其他群、私聊等跨会话中选取最近互动过的用户来补全「其他参与者背景摘要」。关闭后仅限当前上下文内出现过的用户',
         default: false,
     },
-    enableSelfProfile: {
-        type: 'boolean',
-        label: '启用 Aalis 自档案',
-        description: '让 Aalis 周期性地反思自身，提炼「关于自己的事实」（近期心情走向、在意的事、自我观察）。注入到所有 LLM 调用的 system prompt 早段，提供跨会话的人格延续性。' +
-            '⚠️ 默认关闭：自档案是模型对自身输出的二次提炼，再注入会自我强化先前的臆测、随时间漂移并放大幻觉，不建议开启',
-        default: false,
-    },
-    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,
-    },
-};
+});
 const KNOWN_CATEGORIES = [
     '兴趣爱好',
     '职业身份',
@@ -204,23 +131,15 @@ const KNOWN_CATEGORIES = [
     '忌讳',
     '其他',
 ];
-const KNOWN_INSTRUCTION_CATEGORIES = [
-    '审核与处罚',
-    '隐私与边界',
-    '语气与表达',
-    '响应策略',
-    '安全',
-    '其他',
-];
-/** 生成稳定短 ID（6 字符 base36，对 30 条以内规模碰撞概率极低）；前缀 'f' 为事实、'i' 为指令 */
-function genShortId(prefix, existing) {
+/** 生成事实的稳定短 ID（前缀 f 加 5 位 base36，对 30 条以内规模碰撞概率极低） */
+function genShortId(existing) {
     for (let i = 0; i < 8; i++) {
-        const id = `${prefix}${Math.random().toString(36).slice(2, 7)}`;
+        const id = `f${Math.random().toString(36).slice(2, 7)}`;
         if (!existing.has(id))
             return id;
     }
     // 极端兜底：加时间戳后缀
-    return `${prefix}${Date.now().toString(36).slice(-5)}`;
+    return `f${Date.now().toString(36).slice(-5)}`;
 }
 function decimalPlaces(value) {
     if (!Number.isFinite(value))
@@ -240,7 +159,7 @@ function metadataString(message, key) {
     return typeof value === 'string' && value.trim() ? value.trim() : undefined;
 }
 function getMessageUserId(message) {
-    return metadataString(message, 'userId') ?? message.name;
+    return metadataString(message, WellKnownMetadataKeys.UserId) ?? message.name;
 }
 function isTargetUserMessage(message, userId, platform) {
     if (message.role !== 'user' || !message.content)
@@ -248,7 +167,7 @@ function isTargetUserMessage(message, userId, platform) {
     const msgUserId = getMessageUserId(message);
     if (msgUserId !== userId)
         return false;
-    const msgPlatform = metadataString(message, 'platform');
+    const msgPlatform = metadataString(message, WellKnownMetadataKeys.Platform);
     return !msgPlatform || !platform || msgPlatform === platform;
 }
 /**
@@ -292,9 +211,9 @@ function renderHistoryForExtract(history, userId, platform) {
             // 平台事件（群禁言 / 撤回 / 成员进出 / poke 等），供提取判断「用户被谁怎么了」之类上下文
             return `[${time}] [系统通知]: ${content}`;
         }
-        const nickname = metadataString(m, 'nickname');
+        const nickname = metadataString(m, WellKnownMetadataKeys.Nickname);
         const msgUserId = getMessageUserId(m) ?? '';
-        const msgPlatform = metadataString(m, 'platform');
+        const msgPlatform = metadataString(m, WellKnownMetadataKeys.Platform);
         const isTarget = msgUserId === userId && (!msgPlatform || !platform || msgPlatform === platform);
         const label = nickname ? `${nickname}(${msgUserId || '?'})` : msgUserId || '?';
         const tag = isTarget ? '目标用户' : '其他用户';
@@ -311,11 +230,11 @@ const uses = {
     contributions,
     config,
     logger,
-    authority: optional(authority),
     tools: optional(tools),
     commands: optional(commands),
-    persona: optional(persona),
     userRelation: optional(userRelation),
+    /** 档案页；不在时照常记档案 */
+    webui: optional(webuiServer),
 };
 export default definePlugin({
     name: '@aalis/plugin-user-profile',
@@ -325,37 +244,27 @@ export default definePlugin({
     uses,
     apply: registerUserProfile,
 });
-function registerUserProfile({ memory, llm, events, hooks, contributions, config, logger, authority, tools, commands, persona, userRelation, }) {
+function registerUserProfile({ memory, llm, events, hooks, contributions, config, logger, tools, commands, userRelation, webui, }) {
+    const parsed = parseConfig(configSchema, config.use, logger.use);
     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),
-        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
+        ...parsed,
+        historyForExtraction: Math.max(2, parsed.historyForExtraction),
+        maxFactsPerUser: Math.max(5, parsed.maxFactsPerUser),
+        maxFactCharsPerItem: Math.max(20, parsed.maxFactCharsPerItem),
+        maxOtherParticipants: Math.max(0, parsed.maxOtherParticipants),
+        maxFactsForOthers: Math.max(1, parsed.maxFactsForOthers),
+        temporaryFactMaxAgeDays: Math.max(0, parsed.temporaryFactMaxAgeDays),
+        relationScoreDecayPerDay: Math.max(0, parsed.relationScoreDecayPerDay),
+        relationIncrementDirect: Math.max(0, parsed.relationIncrementDirect),
+        relationIncrementImmediate: Math.max(0, parsed.relationIncrementImmediate),
+        relationIncrementInterval: Math.max(0, parsed.relationIncrementInterval),
+        relationIncrementWitness: Math.max(0, parsed.relationIncrementWitness),
+        extractLLM: parsed.extractLLM &&
+            typeof parsed.extractLLM === 'object' &&
+            parsed.extractLLM.provider &&
+            parsed.extractLLM.model
+            ? parsed.extractLLM
             : undefined,
-        allowGlobalBackfill: config.allowGlobalBackfill ?? false,
-        enableSelfProfile: config.enableSelfProfile ?? false,
-        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();
@@ -368,177 +277,6 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
     function extractionCountKeyOf(sessionId, platform, userId) {
         return `${sessionId}:${userKeyOf(platform, userId)}`;
     }
-    /** 返回当前活跃 persona 的 self key（运行时解析，跟随 persona 切换）。
-     *  若 persona 服务不可用或未配 name，回退到默认 `aalis`。 */
-    function getCurrentPersonaName() {
-        try {
-            const name = persona.current?.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;
-    }
-    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() : genShortId('i', usedIds);
-            while (usedIds.has(id))
-                id = genShortId('i', 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;
-    }
-    /**
-     * 读取指令档案（不存在返回空档案）。读失败原样抛出，理由同 {@link loadProfile}；
-     * 只读渲染走 {@link loadInstructionsLenient}。
-     * mem 由调用方传入：一次操作只认开头取到的实例，理由见 {@link loadProfile}
-     */
-    async function loadInstructions(mem) {
-        const empty = { instructions: [], updatedAt: 0 };
-        if (!mem)
-            return empty;
-        const doc = await mem.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 };
-    }
-    /** 只读渲染用：读失败按空档案处理，只记 debug（结果不会被写回） */
-    async function loadInstructionsLenient(mem) {
-        try {
-            return await loadInstructions(mem);
-        }
-        catch (err) {
-            logger.debug(`加载指令档案失败: ${err instanceof Error ? err.message : String(err)}`);
-            return { instructions: [], updatedAt: 0 };
-        }
-    }
-    async function saveInstructions(mem, doc) {
-        if (!mem)
-            return;
-        await mem.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 = genShortId('i', 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;
@@ -569,7 +307,7 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
             }
             let id = obj.id.trim();
             while (usedIds.has(id))
-                id = genShortId('f', usedIds);
+                id = genShortId(usedIds);
             usedIds.add(id);
             const cat = typeof obj.category === 'string' && KNOWN_CATEGORIES.includes(obj.category)
                 ? obj.category
@@ -586,14 +324,16 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
         }
         return facts;
     }
+    /** 一段先读后写或先查后删的操作固定在开头选中的那一家（见 {@link loadProfile}）；选不到时访问抛错，同 memory.use */
+    const pinnedMemory = () => memory.list().find(p => p.selected)?.use ?? memory.use;
     /**
      * 读取一个用户的现有档案（getMetadata 返回空才算不存在，返回 undefined）。
      *
-     * 读失败原样抛出：先读后改再写的一方（关系分、事实提取、自反思、定点删事实）据此中止本次写入。
+     * 读失败原样抛出：先读后改再写的一方（关系分、事实提取、定点删事实）据此中止本次写入。
      * 若把「读不出」当成「不存在」，调用方会用默认值覆盖写回，一次瞬时读错就清空整份档案。
      * 只读渲染走 {@link loadProfileLenient}。
      *
-     * 档案与指令的读写函数都由调用方传入 mem，一次操作（读 → 调 LLM → 重读 → 覆盖写）全程只认
+     * 档案的读写函数都由调用方传入 mem，一次操作（读 → 调 LLM → 重读 → 覆盖写）全程只认
      * 开头取到的实例：memory 胜者可能在 LLM 调用期间换人而本插件不重启，每步现取胜者会把 A 上
      * 合并出的整张表覆盖写进 B，B 原有的条目被删。
      */
@@ -601,11 +341,12 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
         if (!mem)
             return undefined;
         const doc = await mem.getMetadata(PROFILE_NS, userKey);
-        if (!doc)
-            return undefined;
-        const facts = Array.isArray(doc.facts) ? parseFactArray(doc.facts) : [];
+        return doc ? profileFrom(doc) : undefined;
+    }
+    /** 存着的档案文档按类型取出，读不懂的事实跳过 */
+    function profileFrom(doc) {
         return {
-            facts,
+            facts: Array.isArray(doc.facts) ? parseFactArray(doc.facts) : [],
             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,
@@ -618,7 +359,7 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
             return await loadProfile(mem, userKey);
         }
         catch (err) {
-            logger.debug(`加载用户档案失败 (${userKey}): ${err instanceof Error ? err.message : String(err)}`);
+            logger.use.debug(`加载用户档案失败 (${userKey}): ${err instanceof Error ? err.message : String(err)}`);
             return undefined;
         }
     }
@@ -635,12 +376,122 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
         };
         await mem.saveMetadata(PROFILE_NS, userKey, payload);
     }
+    // ─── 档案页：插件详情里查看与删除，只删不改。事实变了（这里、指令、提取、全局清理）就 invalidate ───
+    /** 事实那一行的 rowKey 是 [用户键, 事实 id] 的 JSON：行动作只收 rowKey，靠它找回是谁的哪一条 */
+    function parseFactRef(rowKey) {
+        let ref;
+        try {
+            ref = JSON.parse(rowKey);
+        }
+        catch {
+            ref = undefined;
+        }
+        if (!Array.isArray(ref) || ref.length !== 2 || !ref.every(part => typeof part === 'string')) {
+            throw new Error(`不认识的事实：${rowKey}`);
+        }
+        return ref;
+    }
+    const page = webui.use.definePage({
+        key: 'profiles',
+        title: '用户档案',
+        icon: 'contact',
+        actions: {
+            forgetFact: {
+                label: '删除',
+                effect: 'destructive',
+                confirm: '删掉后，以后的对话里不再带上这条事实。',
+                row: true,
+                async handler({ rowKey }) {
+                    const [userKey, factId] = parseFactRef(rowKey);
+                    const mem = pinnedMemory();
+                    const profile = await loadProfile(mem, userKey);
+                    const hit = profile?.facts.find(f => f.id === factId);
+                    if (!profile || !hit)
+                        throw new Error('这条事实已经不在档案里了');
+                    await saveProfile(mem, userKey, {
+                        ...profile,
+                        facts: profile.facts.filter(f => f !== hit),
+                        updatedAt: Date.now(),
+                    });
+                    page.invalidate();
+                    return `已删除：${hit.text}`;
+                },
+            },
+            clearProfile: {
+                label: '清空档案',
+                effect: 'destructive',
+                confirm: '这个人的全部事实连同关系强度、互动次数一起清空。',
+                row: true,
+                async handler({ rowKey }) {
+                    const mem = pinnedMemory();
+                    if (!(await mem.getMetadata(PROFILE_NS, rowKey)))
+                        throw new Error(`${rowKey} 已经没有档案了`);
+                    await mem.deleteMetadata(PROFILE_NS, rowKey);
+                    page.invalidate();
+                    return `已清空 ${rowKey} 的档案`;
+                },
+            },
+        },
+        content: [
+            {
+                type: 'table',
+                id: 'profiles',
+                rowKey: 'key',
+                description: '她从对话里记下的关于各人的事实，会带进以后的对话。这里只能删除，不能改写。',
+                empty: '还没有人的档案',
+                columns: [
+                    { key: 'key', label: '用户', primary: true },
+                    { key: 'facts', label: '事实', primary: true },
+                    { key: 'updatedAt', label: '最近记下', kind: 'time' },
+                ],
+                async data() {
+                    const entries = await memory.use.listMetadata(PROFILE_NS);
+                    return entries
+                        .flatMap(({ key, data }) => {
+                        const { facts } = profileFrom(data);
+                        if (facts.length === 0)
+                            return [];
+                        return [{ key, facts: facts.length, updatedAt: Math.max(...facts.map(f => f.updatedAt)) }];
+                    })
+                        .sort((a, b) => b.updatedAt - a.updatedAt);
+                },
+                detail: [
+                    {
+                        type: 'table',
+                        id: 'facts',
+                        rowKey: 'ref',
+                        empty: '这个人的档案里没有事实了',
+                        columns: [
+                            { key: 'text', label: '事实', primary: true },
+                            { key: 'category', label: '分类' },
+                            { key: 'temporality', label: '时效' },
+                            { key: 'updatedAt', label: '记下', kind: 'time' },
+                        ],
+                        rowActions: [{ action: 'forgetFact' }],
+                        async data({ rowKey }) {
+                            const facts = (await loadProfile(memory.use, rowKey))?.facts ?? [];
+                            return facts
+                                .sort((a, b) => b.updatedAt - a.updatedAt)
+                                .map(f => ({
+                                ref: JSON.stringify([rowKey, f.id]),
+                                text: f.text,
+                                category: f.category ?? '',
+                                temporality: f.temporality === 'temporary' ? '近期' : '长期',
+                                updatedAt: f.updatedAt,
+                            }));
+                        },
+                    },
+                    { type: 'actions', actions: ['clearProfile'] },
+                ],
+            },
+        ],
+    });
     function normalizeCategory(v) {
         if (typeof v !== 'string')
             return undefined;
         return KNOWN_CATEGORIES.includes(v) ? v : undefined;
     }
-    /** 解析 LLM 输出里的 add / update / remove 三类事实操作。sourceQuote 原样带出，是否校验由调用方决定；它不入库（mergeFactList 逐字段构造 Fact） */
+    /** 解析 LLM 输出里的 add / update / remove 三类事实操作。sourceQuote 原样带出，由调用方校验；它不入库（mergeFactList 逐字段构造 Fact） */
     function parseFactOps(parsed) {
         const obj = parsed;
         const add = Array.isArray(obj.add)
@@ -745,7 +596,7 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
         const entry = resolveLLMModel(llm, cfg.extractLLM, ['chat']);
         if (!entry)
             return empty;
-        const extractLlm = entry.instance;
+        const extractLlm = entry.use;
         try {
             const baseMessages = [
                 { role: 'system', content: sys },
@@ -755,7 +606,7 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
                 messages: baseMessages,
                 temperature: 0.2,
                 maxTokens: 800,
-                think: false,
+                think: lightestThinking(extractLlm),
             });
             let text = (resp.content ?? '').trim();
             if (!text)
@@ -764,7 +615,7 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
             if (!parsed) {
                 // util-json-repair 已尝试剥 fence + 修裸引号 + 补括号；仍失败 → 模型多半
                 // 写成了纯文本/markdown。给一次显式反馈再来一次，避免一次失败丢失整批事实。
-                logger.warn(`[user-profile] LLM 输出无法解析为 JSON，尝试重试一次。原文前 200 字：${text.slice(0, 200)}`);
+                logger.use.warn(`[user-profile] LLM 输出无法解析为 JSON，尝试重试一次。原文前 200 字：${text.slice(0, 200)}`);
                 const retryResp = await extractLlm.chat({
                     messages: [
                         ...baseMessages,
@@ -779,15 +630,15 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
                     ],
                     temperature: 0.2,
                     maxTokens: 800,
-                    think: false,
+                    think: lightestThinking(extractLlm),
                 });
                 text = (retryResp.content ?? '').trim();
                 ({ parsed } = parseLLMJsonObject(text));
                 if (!parsed) {
-                    logger.warn(`[user-profile] LLM 重试后仍无法解析 JSON，放弃本批次。重试原文前 200 字：${text.slice(0, 200)}`);
+                    logger.use.warn(`[user-profile] LLM 重试后仍无法解析 JSON，放弃本批次。重试原文前 200 字：${text.slice(0, 200)}`);
                     return empty;
                 }
-                logger.debug('[user-profile] LLM 重试后解析成功');
+                logger.use.debug('[user-profile] LLM 重试后解析成功');
             }
             const { add, update, remove } = parseFactOps(parsed);
             // sourceQuote 校验：quote 可能跨多条消息（LLM 用 \n 拼接），
@@ -797,7 +648,7 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
             const validateSourceQuote = (item, kind) => {
                 const q = item.sourceQuote?.trim() ?? '';
                 if (!q) {
-                    logger.warn(`[user-profile] 丢弃 ${kind} fact（未提供 sourceQuote）: ${item.text}`);
+                    logger.use.warn(`[user-profile] 丢弃 ${kind} fact（未提供 sourceQuote）: ${item.text}`);
                     return false;
                 }
                 const lines = q
@@ -810,7 +661,7 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
                     if (!normalized)
                         continue;
                     if (!targetCorpus.includes(normalized)) {
-                        logger.warn(`[user-profile] 丢弃 ${kind} fact（sourceQuote 片段不在目标用户 ${userId} 发言中）: text="${item.text}" fragment="${frag}"`);
+                        logger.use.warn(`[user-profile] 丢弃 ${kind} fact（sourceQuote 片段不在目标用户 ${userId} 发言中）: text="${item.text}" fragment="${frag}"`);
                         return false;
                     }
                 }
@@ -821,7 +672,7 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
             return { add: validatedAdd, update: validatedUpdate, remove };
         }
         catch (err) {
-            logger.debug(`事实提取 LLM 调用失败：${err instanceof Error ? err.message : String(err)}`);
+            logger.use.debug(`事实提取 LLM 调用失败：${err instanceof Error ? err.message : String(err)}`);
             return empty;
         }
     }
@@ -863,8 +714,8 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
             updatedAt: now,
         };
     }
-    /** 通用 merge：把 add/update/remove 应用到 existing，应用上限与单条裁剪 */
-    function mergeFactList(existing, add, update, remove, maxItems) {
+    /** 把 add/update/remove 应用到 existing，应用单用户上限与单条裁剪 */
+    function mergeFactList(existing, add, update, remove) {
         const now = Date.now();
         const byId = new Map();
         for (const f of existing)
@@ -889,7 +740,7 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
                 });
             }
             else {
-                const id = genShortId('f', usedIds);
+                const id = genShortId(usedIds);
                 usedIds.add(id);
                 byId.set(id, {
                     id,
@@ -908,7 +759,7 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
             const text = clipText(a.text);
             if (textSet.has(text))
                 continue;
-            const id = genShortId('f', usedIds);
+            const id = genShortId(usedIds);
             usedIds.add(id);
             byId.set(id, {
                 id,
@@ -923,9 +774,9 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
         }
         // 4. 总量上限：按 updatedAt 升序淘汰最久未更新的
         let merged = Array.from(byId.values());
-        if (maxItems > 0 && merged.length > maxItems) {
+        if (merged.length > cfg.maxFactsPerUser) {
             merged.sort((a, b) => a.updatedAt - b.updatedAt);
-            merged = merged.slice(merged.length - maxItems);
+            merged = merged.slice(merged.length - cfg.maxFactsPerUser);
         }
         merged.sort((a, b) => a.updatedAt - b.updatedAt);
         return merged;
@@ -949,13 +800,15 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
         if (inflightExtractions.has(userKey))
             return;
         inflightExtractions.add(userKey);
-        const mem = memory.current;
+        // 读档案、等模型、重读再写回固定同一家记忆后端：途中换了人也不会读一家、写另一家
+        const mem = memory.list().find(p => p.selected)?.use;
         try {
             if (!mem)
                 return;
             const rawHistory = await mem.getHistory(sessionId, cfg.historyForExtraction);
-            // 跨会话委派是另一个 agent 实例发出的指令·不是该用户发言，不能作为他的用户存档提取语料
-            const history = rawHistory.filter(m => m.kind !== WellKnownKinds.CrossSessionDelegation);
+            // 指令类消息（proactive 代发任务、宿主通知）是宿主或系统撰写的，不是任何人的发言，
+            // 不能作为用户存档的提取语料
+            const history = rawHistory.filter(m => !DIRECTIVE_KINDS.includes(m.kind ?? ''));
             // 序列中至少需要一条目标用户发言，否则没有可提取语料
             if (!history.some(m => isTargetUserMessage(m, userId, platform)))
                 return;
@@ -967,352 +820,24 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
             // 以 LLM 返回后重读的档案为合并基底：调用期间档案可能被清空或删了事实，以调用前的快照
             // 为基底会把删掉的内容整份写回；重读也保住期间写入的 relationScore 等字段
             const fresh = (await loadProfile(mem, userKey)) ?? { facts: [], updatedAt: 0 };
-            const newFacts = mergeFactList(fresh.facts, ops.add, dropUpdatesOfDeletedFacts(ops.update, snapshotFacts, fresh.facts), ops.remove, cfg.maxFactsPerUser);
+            const newFacts = mergeFactList(fresh.facts, ops.add, dropUpdatesOfDeletedFacts(ops.update, snapshotFacts, fresh.facts), ops.remove);
             await saveProfile(mem, userKey, {
                 ...fresh,
                 facts: newFacts,
                 updatedAt: Date.now(),
             });
-            logger.debug(`用户档案已更新 (${userKey}): facts +${ops.add.length} ~${ops.update.length} -${ops.remove.length} → ${newFacts.length} 条`);
+            page.invalidate();
+            logger.use.debug(`用户档案已更新 (${userKey}): facts +${ops.add.length} ~${ops.update.length} -${ops.remove.length} → ${newFacts.length} 条`);
         }
         catch (err) {
-            logger.debug(`事实提取失败 (${userKey}): ${err instanceof Error ? err.message : String(err)}`);
+            logger.use.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: [],
-        };
-        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. 不写对单个具体用户的态度；可以写「最近总想找人聊聊」这种泛化情绪' +
-            '\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(llm, 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) {
-                logger.warn(`[user-profile] 自反思 LLM 输出无法解析为 JSON，原文前 200 字：${text.slice(0, 200)}`);
-                return empty;
-            }
-            return parseFactOps(parsed);
-        }
-        catch (err) {
-            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 mem = memory.current;
-            if (!mem)
-                return;
-            const rawHistory = await mem.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 snapshotFacts = (await loadProfile(mem, selfKey))?.facts ?? [];
-            const ops = await llmReflectSelf(history, snapshotFacts);
-            if (ops.add.length === 0 && ops.update.length === 0 && ops.remove.length === 0)
-                return;
-            // 合并基底取重读结果，理由同 triggerExtractionForUser
-            const fresh = (await loadProfile(mem, selfKey)) ?? { facts: [], updatedAt: 0 };
-            const newFacts = mergeFactList(fresh.facts, ops.add, dropUpdatesOfDeletedFacts(ops.update, snapshotFacts, fresh.facts), ops.remove, cfg.maxSelfFacts);
-            await saveProfile(mem, selfKey, { ...fresh, facts: newFacts, updatedAt: Date.now() });
-            logger.debug(`Aalis 自档案已更新 (${selfKey}): +${ops.add.length} ~${ops.update.length} -${ops.remove.length} → ${newFacts.length} 条`);
-        }
-        catch (err) {
-            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(llm, 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) {
-                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)) {
-                        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) {
-            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;
-        // 指令只采信有权下指令的人，门槛是发言人的数字权限等级（owner 视为无穷大）
-        const auth = authority.current;
-        if (!auth)
-            return;
-        const authorityFn = (platform, userId) => auth.isOwner(platform, userId)
-            ? Number.POSITIVE_INFINITY
-            : (auth.listUsers().find(u => u.platform === platform && u.userId === userId)?.level ?? DEFAULT_AUTHORITY);
-        instructionExtractionInflight = true;
-        try {
-            const mem = memory.current;
-            if (!mem)
-                return;
-            const rawHistory = await mem.getHistory(sessionId, cfg.instructionHistoryForExtraction);
-            const history = rawHistory.filter(m => m.kind !== WellKnownKinds.CrossSessionDelegation);
-            if (history.length === 0)
-                return;
-            const doc = await loadInstructions(mem);
-            const ops = await llmExtractInstructions(history, doc.instructions, authorityFn);
-            if (ops.add.length === 0 && ops.update.length === 0 && ops.remove.length === 0)
-                return;
-            // 合并基底取 LLM 返回后重读的指令表：调用期间被清掉或删掉的指令不随调用前的快照写回；
-            // update 指向已不在的 id 时 mergeInstructions 本就跳过
-            const fresh = await loadInstructions(mem);
-            const newInstructions = mergeInstructions(fresh.instructions, ops.add.map(a => ({ ...a, sourceChannel: 'llm' })), ops.update.map(u => {
-                const { id, ...patch } = u;
-                return { id, patch };
-            }), ops.remove);
-            await saveInstructions(mem, { instructions: newInstructions, updatedAt: Date.now() });
-            logger.debug(`指令档案已更新 (${getInstructionsKey()}): +${ops.add.length} ~${ops.update.length} -${ops.remove.length} → ${newInstructions.length} 条`);
-        }
-        catch (err) {
-            logger.debug(`指令提取失败：${err instanceof Error ? err.message : String(err)}`);
-        }
-        finally {
-            instructionExtractionInflight = false;
-        }
-    }
     async function updateRelationForUser(userKey, triggerType, options) {
-        const mem = memory.current;
+        const mem = memory.list().find(p => p.selected)?.use;
         const profile = (await loadProfile(mem, userKey)) ?? {
             facts: [],
             relationScore: 0,
@@ -1325,7 +850,7 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
     // 注:钩子无优先级机制,同相位 handler 按插件激活序执行;本 handler 只做副作用
     // (更新关系分数)不改消息,与其它 handler 顺序无关。
     // 关系强度与"是否触发回复"绑定，因此仍走 agent:input:before 中间件。
-    hooks.middleware('agent:input:before', async (data, next) => {
+    hooks.use.middleware('agent:input:before', async (data, next) => {
         const { userId, platform, triggerType } = data.message;
         if (userId) {
             const userKey = userKeyOf(platform, userId);
@@ -1335,7 +860,7 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
                 await updateRelationForUser(userKey, triggerType, { countInteraction: false });
             }
             catch (err) {
-                logger.debug(`关系强度更新异常 (${userKey}): ${err instanceof Error ? err.message : String(err)}`);
+                logger.use.debug(`关系强度更新异常 (${userKey}): ${err instanceof Error ? err.message : String(err)}`);
             }
         }
         await next();
@@ -1343,7 +868,7 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
     // ─── 事实提取触发：每条入站消息落库后立即计数，与 agent 是否回复无关 ───
     // 监听 message-archive 在 archiveIncoming 落库成功后发出的 inbound:message:archived 事件，
     // 确保缓冲消息（onebot saveBufferedMessage 等不触发 agent 回复的路径）也能纳入计数。
-    events.on('inbound:message:archived', data => {
+    events.use.on('inbound:message:archived', data => {
         const { sessionId, incoming } = data;
         const { userId, platform, nickname } = incoming;
         if (!userId)
@@ -1354,26 +879,12 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
         // lastInteractionAt 的唯一写点，设门会连带关掉计数与时戳（衰减基准、最近互动
         // 排序全失效）。增量为 0 时 relationIncrementFor 自然返回 0，不加分即可。
         const userKey = userKeyOf(platform, userId);
-        void updateRelationForUser(userKey, 'witness').catch((err) => logger.debug(`witness 关系更新异常 (${userKey}): ${err instanceof Error ? err.message : String(err)}`));
+        void updateRelationForUser(userKey, 'witness').catch((err) => logger.use.debug(`witness 关系更新异常 (${userKey}): ${err instanceof Error ? err.message : String(err)}`));
         const countKey = extractionCountKeyOf(sessionId, platform, userId);
         const count = (userMessageCount.get(countKey) ?? 0) + 1;
         userMessageCount.set(countKey, count);
         if (cfg.extractEveryNMessages > 0 && count % cfg.extractEveryNMessages === 0) {
-            void triggerExtractionForUser(sessionId, userId, platform ?? '', nickname).catch((err) => logger.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) => 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) => logger.debug(`指令提取异常: ${err instanceof Error ? err.message : String(err)}`));
-            }
+            void triggerExtractionForUser(sessionId, userId, platform ?? '', nickname).catch((err) => logger.use.debug(`事实提取异常 (${countKey}): ${err instanceof Error ? err.message : String(err)}`));
         }
     });
     function isFactActive(fact) {
@@ -1436,48 +947,18 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
     //   direct/immediate/undefined → view.userId 是主发言者，注入完整档案 + 其他参与者摘要
     //   interval                   → 无主发言者（只是恰好撞上频率），所有参与者一律 compact 摘要
     //   idle                       → 无 userId，只注入历史 messages 中出现的参与者 compact 摘要
-    // 多块返回保序共键：准则 → 自档案 → 主发言者档案 → 其他参与者。
-    contributions.contribute('agent:prompt', {
+    // 多块返回保序共键：主发言者档案 → 其他参与者。
+    contributions.use.contribute('agent:prompt', {
         id: 'user-profile',
         anchor: 'turn-context',
         async build(data) {
             // 干跑(token 快照)跳过档案加载——该路径 userId 为空串,加载既昂贵又无意义
             if (data.dryRun)
                 return null;
-            const mem = memory.current;
+            const mem = memory.present ? memory.use : undefined;
             const blocksToInsert = [];
             const trigger = data.triggerType ?? 'direct';
             const hasPrimarySpeaker = trigger === 'direct' || trigger === 'immediate';
-            // 0a. 第三方行为指令（最高优先级）：作为不可违逆的行为约束放在 selfFacts 之前
-            if (cfg.enableInstructions) {
-                const insDoc = await loadInstructionsLenient(mem);
-                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 loadProfileLenient(mem, 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);
@@ -1489,7 +970,7 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
                     // 服务不存在 / 节点没社群标签 / 报错都静默跳过；该字段是锦上添花，不破坏档案主体。
                     let communityLine = '';
                     try {
-                        const relation = userRelation.current;
+                        const relation = userRelation.present ? userRelation.use : undefined;
                         if (relation) {
                             const r = await relation.getCommunityPeers(userKey, 5);
                             if (r.peers.length > 0) {
@@ -1499,7 +980,7 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
                         }
                     }
                     catch (err) {
-                        logger.debug(`读取 community peers 失败: ${err instanceof Error ? err.message : String(err)}`);
+                        logger.use.debug(`读取 community peers 失败: ${err instanceof Error ? err.message : String(err)}`);
                     }
                     const block = `# 关于当前对话者（${data.userId}）的已知事实\n` +
                         '以下是你跨会话长期积累的关于该用户的事实，用于让回应更自然贴合其个性。' +
@@ -1538,12 +1019,11 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
                     const msg = data.messages[i];
                     if (msg.role !== 'user')
                         continue;
-                    const meta = (msg.metadata ?? {});
-                    const uid = typeof meta.userId === 'string' ? meta.userId.trim() : undefined;
+                    const uid = metadataString(msg, WellKnownMetadataKeys.UserId);
                     if (!uid)
                         continue;
-                    const plat = typeof meta.platform === 'string' ? meta.platform : (data.platform ?? '');
-                    const nick = typeof meta.nickname === 'string' ? meta.nickname : undefined;
+                    const plat = metadataString(msg, WellKnownMetadataKeys.Platform) ?? data.platform ?? '';
+                    const nick = metadataString(msg, WellKnownMetadataKeys.Nickname);
                     if (addOther(uid, plat, nick))
                         break;
                 }
@@ -1559,19 +1039,18 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
                             for (const item of globalRecent) {
                                 if (others.size >= candidateLimit)
                                     break;
-                                // self 自档案（__self__:<persona>）是私密人格延续锚点，不可作为『群其他参与者』注入 prompt。
-                                if (item.key.startsWith(SELF_KEY_PREFIX))
-                                    continue;
                                 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);
+                                // 平台段以 __ 开头的是保留键（如旧版本留下的人格档案），不是真实用户
+                                if (platform.startsWith('__'))
+                                    continue;
+                                addOther(item.key.slice(sep + 1), platform);
                             }
                         }
                         catch (err) {
-                            logger.debug(`加载最近互动用户失败: ${err instanceof Error ? err.message : String(err)}`);
+                            logger.use.debug(`加载最近互动用户失败: ${err instanceof Error ? err.message : String(err)}`);
                         }
                     }
                 }
@@ -1603,7 +1082,7 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
         },
     });
     // ─── 参与统一的 memory:clear ───
-    hooks.middleware('memory:clear', async (data, next) => {
+    hooks.use.middleware('memory:clear', async (data, next) => {
         if (data.types && !data.types.includes('user-profile')) {
             await next();
             return;
@@ -1613,17 +1092,17 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
             await next();
             return;
         }
-        const mem = memory.current;
-        if (!mem) {
+        if (!memory.present) {
             await next();
             return;
         }
+        const mem = pinnedMemory();
         try {
             // 批量提交：逐条 delete 中途失败会留下「删了一半」的档案，而用户看到的是报了成功。
             // 注意 commitMetadata 的原子性**按后端分档**（见 api-memory 契约）——sqlite/inmemory
             // 是真原子，mongodb 只保证按序执行遇错即停，仍可能停在半新半旧。批量的确定收益是
             // 一次往返 + 遇错即停，不是无条件的「要么全成」。读不出的条目一并删除，计入条数。
-            const [keys] = await clearMetadataNamespaces(mem, [PROFILE_NS], logger);
+            const [keys] = await clearMetadataNamespaces(mem, [PROFILE_NS], logger.use);
             data.results.push({
                 source: 'user-profile',
                 type: 'user-profile',
@@ -1640,52 +1119,32 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
                 message: `用户档案清空失败: ${m}`,
             });
         }
-        // 同步清空第三方行为指令档案（per-persona）。指令是档案的兄弟概念，
-        // memory:clear scope='all' 时一并清理；types 默认包含 user-profile 即也清。
-        // 不看 enableInstructions：开关管功能用不用，不管已有数据能不能清。
-        try {
-            const [insKeys] = await clearMetadataNamespaces(mem, [INSTRUCTIONS_NS], logger);
-            data.results.push({
-                source: 'user-profile-instructions',
-                type: 'user-profile',
-                success: true,
-                message: `第三方行为指令已清空 (${insKeys.length} 条)`,
-            });
-        }
-        catch (err) {
-            const m = err instanceof Error ? err.message : String(err);
-            data.results.push({
-                source: 'user-profile-instructions',
-                type: 'user-profile',
-                success: false,
-                message: `指令清空失败: ${m}`,
-            });
-        }
+        page.invalidate();
         await next();
     });
     // ─── 工具：user_profile_lookup ───
-    // 让 Agent 在对话中主动查询任意用户（或 Aalis 自己）的事实档案。
+    // 让 Agent 在对话中主动查询任意用户的事实档案。
     // 设计要点：
-    // - 全局可查（用户决定 C）：跨平台/跨群均可，含 __self__ 自档案
-    // - 三种调用方式：① user_key 直传；② platform+user_id 组合；③ self=true（查当前 persona 自档案）
-    tools.registerGroup({
+    // - 全局可查（用户决定 C）：跨平台/跨群均可
+    // - 两种调用方式：① user_key 直传；② platform+user_id 组合
+    tools.use.registerGroup({
         name: 'user-profile',
         label: '用户档案',
-        description: '查询 Aalis 已经积累的某人事实档案（包括自档案）。',
+        description: '查询 Aalis 已经积累的某人事实档案。',
     });
-    tools.register({
+    tools.use.register({
         definition: {
             type: 'function',
             function: {
                 name: 'user_profile_lookup',
                 description: '查询 Aalis 已积累的某个用户的事实档案。当对话中提到某人、或你想回忆已知信息时使用。' +
-                    '可通过 user_key（"<platform>:<userId>"）直查，或用 platform + user_id 组合，或 self=true 查自档案。',
+                    '可通过 user_key（"<platform>:<userId>"）直查，或用 platform + user_id 组合。',
                 parameters: {
                     type: 'object',
                     properties: {
                         user_key: {
                             type: 'string',
-                            description: '完整的 userKey，例如 "onebot:123456789" 或 "__self__:Aalis"。优先级最高。',
+                            description: '完整的 userKey，例如 "onebot:123456789"。优先级最高。',
                         },
                         platform: {
                             type: 'string',
@@ -1695,10 +1154,6 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
                             type: 'string',
                             description: '平台用户 ID。与 platform 搭配使用。',
                         },
-                        self: {
-                            type: 'boolean',
-                            description: '为 true 时查询当前 persona 的自档案（__self__:<persona>）。',
-                        },
                     },
                 },
             },
@@ -1710,31 +1165,25 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
             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。',
+                    error: '需提供 user_key 或 (platform + user_id)。',
                 });
             }
-            const profile = await loadProfileLenient(memory.current, userKey);
+            const profile = await loadProfileLenient(memory.present ? memory.use : undefined, 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 factsBlock = renderProfileBlock(profile.facts, userKey, 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,
@@ -1750,12 +1199,12 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
     // /profile              查看自己的档案
     // /profile clear        清除自己的档案（authority=2，自己删自己的）
     // /profile clear nuke   清空所有用户档案（authority=3，dangerous）
-    commands.command('profile', '查看你在 Aalis 中的事实档案').action(async (argv) => {
+    commands.use.command('profile', '查看你在 Aalis 中的事实档案').action(async (argv) => {
         const userId = argv.session.userId;
         if (!userId)
             return '当前会话未识别用户身份，无法查看档案。';
         const userKey = userKeyOf(argv.session.platform, userId);
-        const profile = await loadProfileLenient(memory.current, userKey);
+        const profile = await loadProfileLenient(memory.present ? memory.use : undefined, userKey);
         if (!profile || profile.facts.length === 0) {
             return `📭 暂无档案数据 (${userKey})`;
         }
@@ -1763,19 +1212,18 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
         const meta = `关系强度：${(profile.relationScore ?? 0).toFixed(relationScorePrecision)}/100，互动次数：${profile.interactionCount ?? 0}`;
         return `📇 你的档案 (${userKey})\n${meta}\n\n${block}`;
     });
-    commands.command('profile.clear', '清除你自己的事实档案', { visibility: 'restricted' }).action(async (argv) => {
+    commands.use.command('profile.clear', '清除你自己的事实档案', { visibility: 'restricted' }).action(async (argv) => {
         const userId = argv.session.userId;
         if (!userId)
             return '当前会话未识别用户身份，无法清除档案。';
         const userKey = userKeyOf(argv.session.platform, userId);
-        const mem = memory.current;
-        if (!mem)
-            return '记忆服务不支持档案删除。';
+        const mem = pinnedMemory();
         try {
             const existed = await mem.getMetadata(PROFILE_NS, userKey);
             if (!existed)
                 return `📭 你当前没有档案数据 (${userKey})`;
             await mem.deleteMetadata(PROFILE_NS, userKey);
+            page.invalidate();
             return `✅ 已清除你的档案 (${userKey})`;
         }
         catch (err) {
@@ -1784,10 +1232,10 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
         }
     });
     // 定点除毒入口（2026-08 群主档案投毒事件的运维刚需）：此前删单条事实只能
-    // mongosh 手术或 nuke 全清。dangerous → 等级 2 + confirm，与同族 self.clear/nuke 对齐
-    //（它改的是**他人**档案，且 target 含冒号时直传 key、可触及 __self__ 自档案，
-    // 必须与 self.clear 同样上确认闸）。id 未命中时列出前若干条供定位。
-    commands
+    // mongosh 手术或 nuke 全清。dangerous → 等级 2 + confirm，与同族 nuke 对齐
+    //（它改的是**他人**档案，且 target 含冒号时直传 key、可触及任意一份档案）。
+    // id 未命中时列出前若干条供定位。
+    commands.use
         .command('profile.forget <target:string> <factId:string>', '定点删除某用户档案中的一条事实（运维除毒）', {
         risk: 'dangerous',
     })
@@ -1795,7 +1243,7 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
         const target = String(targetArg ?? '');
         const factId = String(factIdArg ?? '');
         const userKey = target.includes(':') ? target : userKeyOf(argv.session.platform, target);
-        const mem = memory.current;
+        const mem = memory.list().find(p => p.selected)?.use;
         try {
             const profile = await loadProfile(mem, userKey);
             if (!profile || profile.facts.length === 0)
@@ -1813,41 +1261,18 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
                 facts: profile.facts.filter(f => f.id !== factId),
                 updatedAt: Date.now(),
             });
+            page.invalidate();
             return `✅ 已删除 ${userKey} 的事实 [${factId}]：${hit.text.slice(0, 60)}`;
         }
         catch (err) {
             return `❌ 删除失败：${err instanceof Error ? err.message : String(err)}`;
         }
     });
-    commands.command('profile.self', '查看 Aalis 的自档案（跨会话的内心状态）').action(async () => {
-        const selfKey = getSelfKey();
-        const profile = await loadProfileLenient(memory.current, 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}`;
-    });
-    commands.command('profile.self.clear', '【慎用】清空 Aalis 自档案', { risk: 'dangerous' }).action(async () => {
-        const mem = memory.current;
-        if (!mem)
-            return '记忆服务不支持档案删除。';
-        const selfKey = getSelfKey();
+    commands.use.command('profile.clear.nuke', '【危险】清空所有用户档案', { risk: 'dangerous' }).action(async () => {
+        const mem = pinnedMemory();
         try {
-            await mem.deleteMetadata(PROFILE_NS, selfKey);
-            return `✅ ${getCurrentPersonaName()} 自档案已清空（key=${selfKey}）`;
-        }
-        catch (err) {
-            return `❌ 清空失败：${err instanceof Error ? err.message : String(err)}`;
-        }
-    });
-    commands.command('profile.clear.nuke', '【危险】清空所有用户档案', { risk: 'dangerous' }).action(async () => {
-        const mem = memory.current;
-        if (!mem) {
-            return '记忆服务不支持档案批量删除。';
-        }
-        try {
-            const [keys] = await clearMetadataNamespaces(mem, [PROFILE_NS], logger);
+            const [keys] = await clearMetadataNamespaces(mem, [PROFILE_NS], logger.use);
+            page.invalidate();
             return `✅ 已清空全部用户档案（${keys.length} 条）`;
         }
         catch (err) {
@@ -1855,105 +1280,8 @@ function registerUserProfile({ memory, llm, events, hooks, contributions, config
             return `❌ 清空失败：${m}`;
         }
     });
-    // ─── /instruct 指令族：第三方行为指令 (per-persona) ───
-    // /instruct              查看当前 persona 的所有指令
-    // /instruct.add <text>   手动添加一条指令（authority=2）
-    // /instruct.remove <id>  按 id 删除一条（authority=2）
-    // /instruct.clear        清空当前 persona 的全部指令（authority=3, dangerous）
-    commands.command('instruct', '查看当前 persona 的第三方行为指令').action(async () => {
-        if (!cfg.enableInstructions)
-            return '🚫 第三方行为指令功能未启用。';
-        const personaName = getCurrentPersonaName();
-        const doc = await loadInstructionsLenient(memory.current);
-        if (doc.instructions.length === 0) {
-            return `📭 ${personaName} 当前没有任何第三方行为指令。`;
-        }
-        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 `📋 ${personaName} 的第三方行为指令（共 ${doc.instructions.length} 条）\n${lines.join('\n')}`;
-    });
-    commands
-        .command('instruct.add <text:text>', '手动添加一条第三方行为指令', { visibility: 'restricted' })
-        .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 mem = memory.current;
-        try {
-            const doc = await loadInstructions(mem);
-            const merged = mergeInstructions(doc.instructions, [
-                {
-                    text: body,
-                    severity: 'should',
-                    sourceUserKey,
-                    sourceUserName,
-                    sourceChannel: 'command',
-                },
-            ], [], []);
-            await saveInstructions(mem, { instructions: merged, updatedAt: Date.now() });
-            const added = merged.find(m => m.text === clipInstructionText(body));
-            return `✅ 已添加行为指令${added ? `（id=${added.id}）` : ''}：${clipInstructionText(body)}`;
-        }
-        catch (err) {
-            return `❌ 添加失败：${err instanceof Error ? err.message : String(err)}`;
-        }
-    });
-    commands
-        .command('instruct.remove <id:string>', '按 id 删除一条第三方行为指令', { visibility: 'restricted' })
-        .action(async (_argv, id) => {
-        if (!cfg.enableInstructions)
-            return '🚫 第三方行为指令功能未启用。';
-        const targetId = typeof id === 'string' ? id.trim() : '';
-        if (!targetId)
-            return '❌ 需要提供指令 id。';
-        const mem = memory.current;
-        try {
-            const doc = await loadInstructions(mem);
-            const target = doc.instructions.find(i => i.id === targetId);
-            if (!target)
-                return `❌ 未找到 id=${targetId} 的指令。`;
-            const merged = mergeInstructions(doc.instructions, [], [], [targetId]);
-            await saveInstructions(mem, { instructions: merged, updatedAt: Date.now() });
-            return `✅ 已删除指令（id=${targetId}）：${target.text}`;
-        }
-        catch (err) {
-            return `❌ 删除失败：${err instanceof Error ? err.message : String(err)}`;
-        }
-    });
-    commands
-        .command('instruct.clear', '【危险】清空当前 persona 的全部第三方行为指令', {
-        visibility: 'restricted',
-    })
-        .action(async () => {
-        if (!cfg.enableInstructions)
-            return '🚫 第三方行为指令功能未启用。';
-        const mem = memory.current;
-        if (!mem)
-            return '记忆服务不支持指令删除。';
-        try {
-            const before = (await loadInstructionsLenient(mem)).instructions.length;
-            await mem.deleteMetadata(INSTRUCTIONS_NS, getInstructionsKey());
-            return `✅ ${getCurrentPersonaName()} 的第三方行为指令已清空（删除 ${before} 条）。`;
-        }
-        catch (err) {
-            return `❌ 清空失败：${err instanceof Error ? err.message : String(err)}`;
-        }
-    });
-    logger.info(`用户事实档案已启用 (every=${cfg.extractEveryNMessages <= 0 ? '禁用提取' : `${cfg.extractEveryNMessages}msgs`}, history=${cfg.historyForExtraction}, ` +
+    logger.use.info(`用户事实档案已启用 (every=${cfg.extractEveryNMessages <= 0 ? '禁用提取' : `${cfg.extractEveryNMessages}msgs`}, history=${cfg.historyForExtraction}, ` +
         `maxFacts=${cfg.maxFactsPerUser}, ` +
-        `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