@scotthuang/engram 0.9.8 → 0.10.0

package/dist/profile.js

@@ -1,66 +1,200 @@
 /**
- * Memory System Plugin - Profile (三层语义画像)
+ * Memory System Plugin - Profile (四层语义画像)
  *
- * 三层架构：
+ * 四层架构：
  *   identity  — 核心身份（姓名/城市/职业/家人），几乎不变，不衰减
  *   pattern   — 行为模式（作息/饮食习惯/工作风格），统计驱动，慢衰减
  *   interest  — 动态兴趣（当前项目/近期关注），高频变化，快衰减
+ *   event     — 一次性事件（排查/bug/配置），带 TTL，短期内自动消除
  *
- * 画像 JSON 结构 + 读写 + 分层衰减 + 压缩摘要
+ * 画像 JSON 结构 + 读写 + 分层衰减 + 压缩摘要 + 受控维度 + LLM 自审
  */
 import { promises as fs } from "node:fs";
 import { logger } from "./logger.js";
 import { join } from "node:path";
-/** 各层的衰减因子和淘汰阈值 */
+/** 各层的衰减因子、淘汰阈值、TTL 天数 */
 const LAYER_CONFIG = {
-    identity: { decayFactor: 1.0, pruneThreshold: 0.1, defaultConfidence: 0.95 },
-    pattern: { decayFactor: 0.995, pruneThreshold: 0.3, defaultConfidence: 0.7 },
-    interest: { decayFactor: 0.95, pruneThreshold: 0.2, defaultConfidence: 0.7 },
+    identity: { decayFactor: 1.0, pruneThreshold: 0.1, defaultConfidence: 0.95, ttlDays: Infinity },
+    pattern: { decayFactor: 0.995, pruneThreshold: 0.3, defaultConfidence: 0.7, ttlDays: 180 },
+    interest: { decayFactor: 0.95, pruneThreshold: 0.25, defaultConfidence: 0.7, ttlDays: 30 },
+    event: { decayFactor: 0.85, pruneThreshold: 0.3, defaultConfidence: 0.55, ttlDays: 7 },
 };
+const LAYER_PRIORITY = {
+    identity: 4,
+    pattern: 3,
+    interest: 2,
+    event: 1,
+};
+// ============================================================================
+// 受控维度表（Canonical Vocabulary）
+// ============================================================================
+/**
+ * 受控维度表：settle 时 LLM 只能从这些维度里选
+ * 目的：消除"技术/技术调试/技术运维/技术/调试"等近义维度碎片
+ */
+export const CANONICAL_DIMENSIONS = [
+    "身份", // 姓名、职业、家人
+    "作息", // 睡眠/饮食/运动规律
+    "技术", // 编程、技术栈、工具偏好
+    "项目", // 在做的/长期的项目
+    "兴趣", // 爱好、关注领域
+    "偏好", // 交互风格、决策模式
+    "人际", // 家庭、重要联系人
+];
+/**
+ * 维度别名映射：旧维度名（LLM 自由发挥产生的碎片）→ 受控维度
+ * 用于历史清理 + 兼容 LLM 偶尔的越界产出
+ */
+const DIMENSION_ALIAS = {
+    // 技术族
+    技术行为: "技术",
+    技术工具: "技术",
+    技术方向: "技术",
+    技术开发: "技术",
+    技术排查: "技术",
+    技术领域: "技术",
+    技术配置: "技术",
+    技术问题排查: "技术",
+    技术调试: "技术",
+    技术运维: "技术",
+    技术操作: "技术",
+    技术测试: "技术",
+    技术探索: "技术",
+    技术实践: "技术",
+    技术活动: "技术",
+    技术文档: "技术",
+    "技术/开发": "技术",
+    "技术/运维": "技术",
+    "技术/调试": "技术",
+    "技术/项目": "项目",
+    配置优化: "技术",
+    系统维护: "技术",
+    系统配置: "技术",
+    自动化运维: "技术",
+    功能规则: "技术",
+    新闻工具: "技术",
+    数据分析: "技术",
+    网络工具: "技术",
+    通信技术: "技术",
+    配置文件管理: "技术",
+    调试: "技术",
+    "调试/排查": "技术",
+    问题修复: "技术",
+    系统清理: "技术",
+    工具: "技术",
+    "工具/平台": "技术",
+    "工具/框架": "技术",
+    AI工具: "技术",
+    AI平台: "技术",
+    AI模型: "技术",
+    AI技术: "技术",
+    "AI/产品": "技术",
+    AI: "技术",
+    // 项目族
+    应用场景: "项目",
+    任务类型: "项目",
+    协作规划: "项目",
+    规划: "项目",
+    活动: "项目",
+    // 作息族
+    生活作息: "作息",
+    个人习惯: "作息",
+    // 兴趣族
+    兴趣爱好: "兴趣",
+    新闻资讯: "兴趣",
+    金融资讯: "兴趣",
+    科技新闻: "兴趣",
+    行业新闻: "兴趣",
+    资讯: "兴趣",
+    热点资讯: "兴趣",
+    信息获取: "兴趣",
+    投资: "兴趣",
+    // 偏好族
+    决策风格: "偏好",
+    生活: "偏好",
+    // 人际族
+    家庭: "人际",
+    // 非画像（降级为 event 或丢弃）
+    出行: "项目",
+    交通: "项目",
+    "生活/计划": "项目",
+    出行计划: "项目",
+    旅行出行: "项目",
+    地域活动: "项目",
+    地点关注: "项目",
+    工作动态: "项目",
+    // 位置类（会被特殊处理到 locations 字段，保留为 project 兜底）
+    位置: "项目",
+};
+/**
+ * 识别"事件类"关键词：命中时强制降级为 event 层
+ * 解决一次性排查/修复被误写成长期 interest 的问题
+ */
+const EVENT_KEYWORDS = [
+    "排查",
+    "修复",
+    "bug",
+    "Bug",
+    "BUG",
+    "调试",
+    "debug",
+    "验证",
+    "测试",
+    "超时",
+    "SIGTERM",
+    "报错",
+    "故障",
+    "异常",
+    "清理",
+    "恢复",
+];
+export function isLikelyEvent(value) {
+    return EVENT_KEYWORDS.some((kw) => value.includes(kw));
+}
+/**
+ * 受控维度规范化：将任意维度名映射到 CANONICAL_DIMENSIONS
+ * - 完全匹配 → 直接返回
+ * - 有别名 → 返回别名映射
+ * - 前缀匹配受控维度 → 映射到该维度
+ * - 其他 → 返回 null，由调用方决定丢弃或归为"其他"
+ */
+export function canonicalizeDimension(dim) {
+    const trimmed = dim.trim();
+    if (CANONICAL_DIMENSIONS.includes(trimmed)) {
+        return trimmed;
+    }
+    if (DIMENSION_ALIAS[trimmed])
+        return DIMENSION_ALIAS[trimmed];
+    // 前缀匹配：例如"技术/xxx"、"项目/xxx"
+    for (const canon of CANONICAL_DIMENSIONS) {
+        if (trimmed.startsWith(canon))
+            return canon;
+    }
+    return null;
+}
 export const EMPTY_PROFILE = {
     summary: "",
     coreTags: [],
     tags: {},
+    locations: { recent: [] },
     updatedAt: new Date().toISOString(),
 };
+// ============================================================================
+// 工具函数
+// ============================================================================
 /** 获取标签的 layer（兼容旧数据） */
 function getLayer(tag) {
     return tag.layer || "interest";
 }
-// ---- 维度归一化规则 ----
-/** 维度合并：源维度 → 目标维度（碎片化的近义维度归一化到标准维度） */
-const DIMENSION_MERGE_RULES = {
-    "技术行为": "技术",
-    "技术工具": "技术",
-    "技术方向": "技术",
-    "技术开发": "技术",
-    "技术排查": "技术",
-    "技术项目": "项目",
-    "技术领域": "技术",
-    "技术配置": "技术",
-    "技术问题排查": "技术",
-    "配置优化": "技术",
-    "系统维护": "技术",
-    "自动化运维": "技术",
-    "功能规则": "技术",
-    "新闻工具": "技术",
-    "数据分析": "技术",
-    "出行计划": "出行",
-    "旅行出行": "出行",
-    "生活作息": "作息",
-    "个人习惯": "生活",
-    "决策风格": "生活",
-    "应用场景": "项目",
-};
-/** 语义去重组：[保留项, ...要合并删除的等价项] */
-const DEDUP_GROUPS = [
-    ["talk-to-shadow", "talk-to-shadow语音交互项目", "talk-to-shadow方案"],
-    ["声纹识别", "声纹识别逻辑修正", "置信度阈值调试"],
-    ["语音交互/声纹识别", "TTS语音合成", "语音系统优化", "语音引擎切换"],
-    ["家庭成员身份识别", "家庭成员声纹识别", "陌生人识别规则优化"],
-    ["news-knowledge-base", "新闻知识库开发维护", "新闻知识库项目管理者", "AI-Agent新闻整理"],
-    ["AI记忆系统研究者", "LLM应用技术关注者"],
-];
+/** 计算两个 ISO 日期之间的天数差 */
+function daysBetween(iso1, iso2 = new Date().toISOString()) {
+    const d1 = new Date(iso1).getTime();
+    const d2 = new Date(iso2).getTime();
+    return Math.max(0, (d2 - d1) / 86400000);
+}
+// ============================================================================
+// ProfileManager
+// ============================================================================
 export class ProfileManager {
     profile = null;
     profilePath;
@@ -75,14 +209,18 @@ export class ProfileManager {
             return this.profile;
         try {
             const raw = await fs.readFile(this.profilePath, "utf-8");
-            this.profile = JSON.parse(raw);
+            const parsed = JSON.parse(raw);
+            // 向后兼容：旧文件没有 locations 字段
+            if (!parsed.locations)
+                parsed.locations = { recent: [] };
+            this.profile = parsed;
             const tagCount = Object.values(this.profile.tags).reduce((sum, tags) => sum + tags.length, 0);
             const layerCounts = this.countByLayer(this.profile);
-            logger.info(`[engram:profile] Loaded profile: ${tagCount} tags (identity=${layerCounts.identity} pattern=${layerCounts.pattern} interest=${layerCounts.interest}), ${Object.keys(this.profile.tags).length} dimensions, coreTags=[${this.profile.coreTags.join(", ")}]`);
+            logger.info(`[engram:profile] Loaded profile: ${tagCount} tags (identity=${layerCounts.identity} pattern=${layerCounts.pattern} interest=${layerCounts.interest} event=${layerCounts.event}), ${Object.keys(this.profile.tags).length} dimensions, coreTags=[${this.profile.coreTags.join(", ")}]`);
         }
         catch {
             logger.info(`[engram:profile] Profile not found at ${this.profilePath}, using empty profile`);
-            this.profile = { ...EMPTY_PROFILE };
+            this.profile = { ...EMPTY_PROFILE, locations: { recent: [] } };
         }
         return this.profile;
     }
@@ -101,7 +239,12 @@ export class ProfileManager {
     }
     /** 统计各层标签数量 */
     countByLayer(profile) {
-        const counts = { identity: 0, pattern: 0, interest: 0 };
+        const counts = {
+            identity: 0,
+            pattern: 0,
+            interest: 0,
+            event: 0,
+        };
         for (const tags of Object.values(profile.tags)) {
             for (const t of tags) {
                 counts[getLayer(t)]++;
@@ -111,16 +254,19 @@ export class ProfileManager {
     }
     /**
      * 获取召回用的摘要信息（控制 token 消耗）
-     * 优先展示 identity + pattern，interest 按 confidence 排
+     * 优先展示 summary + locations + coreTags
      */
     getRecallContext(profile) {
-        if (!profile.summary && profile.coreTags.length === 0) {
+        if (!profile.summary && profile.coreTags.length === 0 && !profile.locations?.primary) {
             return "";
         }
         const parts = [];
         if (profile.summary) {
             parts.push(`【用户画像】${profile.summary}`);
         }
+        if (profile.locations?.primary) {
+            parts.push(`【常驻地】${profile.locations.primary}`);
+        }
         if (profile.coreTags.length > 0) {
             parts.push(`【核心标签】${profile.coreTags.join(", ")}`);
         }
@@ -128,95 +274,122 @@ export class ProfileManager {
     }
     /**
      * 添加标签（增量更新，默认 layer="interest"）
+     * 新增：
+     *   - 若 dimension 不在受控词表里，尝试 canonicalize，失败则丢弃
+     *   - 若 value 命中事件关键词，强制降级为 event 层
      */
     addTag(profile, dimension, value, layer = "interest") {
-        if (!profile.tags[dimension]) {
-            profile.tags[dimension] = [];
+        // 受控维度规范化
+        const canon = canonicalizeDimension(dimension);
+        if (!canon) {
+            logger.info(`[engram:profile] addTag: skip uncontrolled dimension "${dimension}" for value "${value}"`);
+            return profile;
         }
-        const existing = profile.tags[dimension].find(t => t.value === value);
+        // 事件类关键词强制降级为 event 层（除非 LLM 明确声明 identity/pattern）
+        let finalLayer = layer;
+        if (layer === "interest" && isLikelyEvent(value)) {
+            finalLayer = "event";
+            logger.info(`[engram:profile] addTag: "${value}" demoted to event layer (keyword match)`);
+        }
+        if (!profile.tags[canon]) {
+            profile.tags[canon] = [];
+        }
+        const existing = profile.tags[canon].find((t) => t.value === value);
         if (existing) {
             existing.confidence = Math.min(1.0, existing.confidence + 0.1);
             existing.lastSeen = new Date().toISOString();
-            // 如果已有标签被提升层级（如 interest → identity），更新 layer
             const existingLayer = getLayer(existing);
-            const layerPriority = { identity: 3, pattern: 2, interest: 1 };
-            if (layerPriority[layer] > layerPriority[existingLayer]) {
-                existing.layer = layer;
-                logger.info(`[engram:profile] Tag "${value}" promoted: ${existingLayer} → ${layer}`);
+            if (LAYER_PRIORITY[finalLayer] > LAYER_PRIORITY[existingLayer]) {
+                existing.layer = finalLayer;
+                logger.info(`[engram:profile] Tag "${value}" promoted: ${existingLayer} → ${finalLayer}`);
             }
         }
         else {
-            const cfg = LAYER_CONFIG[layer];
-            profile.tags[dimension].push({
+            const cfg = LAYER_CONFIG[finalLayer];
+            profile.tags[canon].push({
                 value,
                 confidence: cfg.defaultConfidence,
                 lastSeen: new Date().toISOString(),
-                layer,
+                layer: finalLayer,
             });
         }
         return profile;
     }
     /**
      * 分层衰减标签置信度
-     * identity 不衰减，pattern 慢衰减(0.995)，interest 快衰减(0.95)
+     * identity 不衰减，pattern 慢衰减(0.995)，interest 快衰减(0.95)，event 最快(0.85)
+     * 同时基于 TTL 清理过期条目（event: 7d, interest: 30d, pattern: 180d）
      */
     decayTags(profile, factor) {
         let decayed = 0;
-        let pruned = 0;
+        let prunedByConfidence = 0;
+        let prunedByTtl = 0;
         const layerStats = {
-            identity: { decayed: 0, pruned: 0 },
-            pattern: { decayed: 0, pruned: 0 },
-            interest: { decayed: 0, pruned: 0 },
+            identity: 0,
+            pattern: 0,
+            interest: 0,
+            event: 0,
         };
         for (const dimension of Object.keys(profile.tags)) {
             const before = profile.tags[dimension].length;
             profile.tags[dimension] = profile.tags[dimension]
-                .map(t => {
+                .map((t) => {
                 const layer = getLayer(t);
                 const cfg = LAYER_CONFIG[layer];
-                // 如果调用方传了 factor，对 interest 用 factor，其他层用各自配置
-                // 如果没传 factor，全部用各层配置
+                // 调用方传了 factor 时仅对 interest 生效
                 const actualFactor = factor !== undefined && layer === "interest" ? factor : cfg.decayFactor;
                 return { ...t, confidence: t.confidence * actualFactor };
             })
-                .filter(t => {
+                .filter((t) => {
                 const layer = getLayer(t);
                 const cfg = LAYER_CONFIG[layer];
-                return t.confidence > cfg.pruneThreshold;
+                // TTL 剪枝
+                if (Number.isFinite(cfg.ttlDays) && daysBetween(t.lastSeen) > cfg.ttlDays) {
+                    prunedByTtl++;
+                    return false;
+                }
+                // 置信度剪枝
+                if (t.confidence <= cfg.pruneThreshold) {
+                    prunedByConfidence++;
+                    return false;
+                }
+                return true;
             });
-            // 统计
             for (const t of profile.tags[dimension]) {
-                layerStats[getLayer(t)].decayed++;
+                layerStats[getLayer(t)]++;
             }
-            const prunedCount = before - profile.tags[dimension].length;
-            pruned += prunedCount;
             decayed += profile.tags[dimension].length;
             if (profile.tags[dimension].length === 0) {
                 delete profile.tags[dimension];
             }
+            void before;
         }
-        logger.info(`[engram:profile] decayTags: identity=${layerStats.identity.decayed}(kept) pattern=${layerStats.pattern.decayed}(kept) interest=${layerStats.interest.decayed}(kept), pruned=${pruned} low-confidence tags`);
+        logger.info(`[engram:profile] decayTags: kept identity=${layerStats.identity} pattern=${layerStats.pattern} interest=${layerStats.interest} event=${layerStats.event}, pruned=${prunedByConfidence}(low-conf) + ${prunedByTtl}(TTL)`);
+        void decayed;
         return profile;
     }
     /**
-     * 生成 coreTags：优先 identity → pattern → interest，每层取 confidence 最高的
+     * 生成 coreTags：优先 identity → pattern → interest，event 不计入
+     * 同时跳过纯经纬度和地址（交由 locations 字段独立展示）
      */
     generateCoreTags(profile) {
         const allTags = [];
         for (const tags of Object.values(profile.tags)) {
             for (const t of tags) {
-                allTags.push({ value: t.value, confidence: t.confidence, layer: getLayer(t) });
+                const layer = getLayer(t);
+                if (layer === "event")
+                    continue; // event 不参与 coreTags
+                if (isLikelyCoordinate(t.value))
+                    continue; // 过滤纯经纬度
+                allTags.push({ value: t.value, confidence: t.confidence, layer });
             }
         }
-        // 排序：identity 优先 > pattern > interest，同层内按 confidence 降序
-        const layerPriority = { identity: 3, pattern: 2, interest: 1 };
         allTags.sort((a, b) => {
-            const layerDiff = layerPriority[b.layer] - layerPriority[a.layer];
+            const layerDiff = LAYER_PRIORITY[b.layer] - LAYER_PRIORITY[a.layer];
             if (layerDiff !== 0)
                 return layerDiff;
             return b.confidence - a.confidence;
         });
-        // 去重，取前 10 个
         const seen = new Set();
         const result = [];
         for (const t of allTags) {
@@ -224,37 +397,40 @@ export class ProfileManager {
                 continue;
             seen.add(t.value);
             result.push(t.value);
-            if (result.length >= 10)
-                break;
+            if (result.length >= 8)
+                break; // 从 10 收紧到 8
         }
         return result;
     }
     /**
-     * 维度归一化：合并碎片维度 + 语义去重 + 清理空维度
-     * 在月度 settle 中调用，防止 interest 更新时 LLM 自由发挥维度名导致碎片化
+     * 维度归一化：合并碎片维度 + 按受控表收敛 + 清理空维度
      *
-     * @returns 统计信息 { merged, deduped, emptied }
+     * @returns 统计信息 { merged, deduped, emptied, demotedToEvent }
      */
     normalizeDimensions(profile) {
         let merged = 0;
         let deduped = 0;
         let emptied = 0;
-        // ---- 维度合并规则 ----
-        for (const [srcDim, targetDim] of Object.entries(DIMENSION_MERGE_RULES)) {
-            if (!profile.tags[srcDim] || srcDim === targetDim)
+        let demotedToEvent = 0;
+        // ---- 1. 维度合并到受控表 ----
+        const dimsToProcess = Object.keys(profile.tags);
+        for (const srcDim of dimsToProcess) {
+            const targetDim = canonicalizeDimension(srcDim);
+            if (!targetDim || targetDim === srcDim)
                 continue;
             if (!profile.tags[targetDim])
                 profile.tags[targetDim] = [];
             for (const tag of profile.tags[srcDim]) {
-                const existing = profile.tags[targetDim].find(t => t.value === tag.value);
+                const existing = profile.tags[targetDim].find((t) => t.value === tag.value);
                 if (existing) {
                     if (tag.confidence > existing.confidence) {
                         existing.confidence = tag.confidence;
                         existing.lastSeen = tag.lastSeen;
                     }
-                    const lp = { identity: 3, pattern: 2, interest: 1 };
-                    if ((lp[tag.layer || "interest"] || 1) > (lp[existing.layer || "interest"] || 1)) {
-                        existing.layer = tag.layer;
+                    const tagLayer = tag.layer || "interest";
+                    const existingLayer = existing.layer || "interest";
+                    if (LAYER_PRIORITY[tagLayer] > LAYER_PRIORITY[existingLayer]) {
+                        existing.layer = tagLayer;
                     }
                 }
                 else {
@@ -264,46 +440,266 @@ export class ProfileManager {
             }
             delete profile.tags[srcDim];
         }
-        // ---- 语义去重 ----
-        for (const group of DEDUP_GROUPS) {
-            const [keepValue, ...removeValues] = group;
-            const removeSet = new Set(removeValues);
-            for (const [dim, tags] of Object.entries(profile.tags)) {
-                const keepTag = tags.find(t => t.value === keepValue);
-                const removeTags = tags.filter(t => removeSet.has(t.value));
-                if (removeTags.length > 0) {
-                    if (keepTag) {
-                        for (const rt of removeTags) {
-                            if (rt.confidence > keepTag.confidence)
-                                keepTag.confidence = rt.confidence;
-                            if (rt.lastSeen > keepTag.lastSeen)
-                                keepTag.lastSeen = rt.lastSeen;
-                            const lp = { identity: 3, pattern: 2, interest: 1 };
-                            if ((lp[rt.layer || "interest"] || 1) > (lp[keepTag.layer || "interest"] || 1)) {
-                                keepTag.layer = rt.layer;
-                            }
-                        }
-                    }
-                    profile.tags[dim] = tags.filter(t => !removeSet.has(t.value));
-                    deduped += removeTags.length;
+        // ---- 2. 事件类关键词降级：interest → event ----
+        for (const dim of Object.keys(profile.tags)) {
+            for (const tag of profile.tags[dim]) {
+                if ((tag.layer || "interest") === "interest" && isLikelyEvent(tag.value)) {
+                    tag.layer = "event";
+                    tag.confidence = Math.min(tag.confidence, LAYER_CONFIG.event.defaultConfidence);
+                    demotedToEvent++;
                 }
             }
         }
-        // ---- 清理空维度 ----
+        // ---- 3. 清理非受控维度 + 空维度 ----
         for (const dim of Object.keys(profile.tags)) {
+            if (!CANONICAL_DIMENSIONS.includes(dim)) {
+                // 不在受控表也没别名映射 → 丢弃
+                logger.info(`[engram:profile] normalize: dropping uncontrolled dimension [${dim}] with ${profile.tags[dim].length} tags`);
+                deduped += profile.tags[dim].length;
+                delete profile.tags[dim];
+                continue;
+            }
             if (profile.tags[dim].length === 0) {
                 delete profile.tags[dim];
                 emptied++;
             }
         }
-        // ---- 各维度内按 confidence 降序排列 ----
+        // ---- 4. 各维度内按 confidence 降序排列 ----
         for (const dim of Object.keys(profile.tags)) {
             profile.tags[dim].sort((a, b) => b.confidence - a.confidence);
         }
-        if (merged > 0 || deduped > 0 || emptied > 0) {
-            logger.info(`[engram:profile] normalizeDimensions: merged=${merged} deduped=${deduped} emptied=${emptied}`);
+        if (merged > 0 || deduped > 0 || emptied > 0 || demotedToEvent > 0) {
+            logger.info(`[engram:profile] normalizeDimensions: merged=${merged} deduped=${deduped} emptied=${emptied} demotedToEvent=${demotedToEvent}`);
         }
-        return { merged, deduped, emptied };
+        return { merged, deduped, emptied, demotedToEvent };
+    }
+    /**
+     * 更新位置信息
+     * - primary 由长期记忆或 LLM 自审确定（本函数不主动设）
+     * - recent 只保留最近的 3 个，按 updatedAt 排序
+     */
+    updateRecentLocation(profile, place) {
+        if (!profile.locations)
+            profile.locations = { recent: [] };
+        const now = new Date().toISOString();
+        const existing = profile.locations.recent.find((r) => r.place === place);
+        if (existing) {
+            existing.updatedAt = now;
+        }
+        else {
+            profile.locations.recent.push({ place, updatedAt: now });
+        }
+        profile.locations.recent.sort((a, b) => (a.updatedAt < b.updatedAt ? 1 : -1));
+        profile.locations.recent = profile.locations.recent.slice(0, 3);
+        return profile;
+    }
+    /**
+     * LLM 自审：月度兜底清理，交由 LLM 发现 hard-coded 规则遗漏的问题
+     *
+     * @param profile 当前画像
+     * @param llmCall LLM 调用函数
+     * @returns 应用的变更统计
+     */
+    async llmSelfAudit(profile, llmCall) {
+        const compactView = Object.entries(profile.tags)
+            .map(([dim, tags]) => `${dim}: ${tags.map((t) => `${t.value}(${t.layer ?? "interest"})`).join(" | ")}`)
+            .join("\n");
+        if (!compactView) {
+            return { mergedGroups: 0, demoted: 0, coreTagsRewritten: false };
+        }
+        const systemPrompt = `你是一个用户画像审核专家。分析当前画像，找出以下问题：
+
+1. **语义重复的 tag**：同一意思的不同写法（如 "ACP subagent开发测试" 和 "ACP子代理spawn测试"）。
+   对每组重复，挑选最规范的一条作为 keep，其他作为 remove。
+
+2. **错误分层的 tag**：一次性事件（排查/bug/超时/配置修改）被错误地标为 interest 层，应该降级为 event。
+   罗列这些 tag 的 value。
+
+3. **重写 coreTags**：从当前画像中挑选最代表用户身份和长期特征的 5 个 tag。
+   跳过经纬度、纯地址字符串、一次性事件。
+
+只输出 JSON，不要任何解释：
+{
+  "merges": [{"keep": "标准写法", "remove": ["变体1", "变体2"]}],
+  "demotions": ["事件类tag值", ...],
+  "newCoreTags": ["tag1", "tag2", ...]
+}
+
+如果某项无需变动，对应数组留空即可。`;
+        logger.info(`[engram:profile] llmSelfAudit: calling LLM (${compactView.length} chars of profile view)`);
+        let raw;
+        try {
+            raw = await llmCall(compactView, systemPrompt);
+        }
+        catch (err) {
+            logger.error(`[engram:profile] llmSelfAudit: LLM call failed: ${err}`);
+            return { mergedGroups: 0, demoted: 0, coreTagsRewritten: false };
+        }
+        // 容错 JSON 解析（移除 markdown code fence）
+        const cleaned = raw.replace(/^```(?:json)?\s*/i, "").replace(/\s*```\s*$/i, "").trim();
+        let audit;
+        try {
+            audit = JSON.parse(cleaned);
+        }
+        catch (err) {
+            logger.error(`[engram:profile] llmSelfAudit: JSON parse failed: ${err}, raw="${raw.slice(0, 200)}"`);
+            return { mergedGroups: 0, demoted: 0, coreTagsRewritten: false };
+        }
+        let mergedGroups = 0;
+        let demoted = 0;
+        // 应用合并
+        for (const group of audit.merges ?? []) {
+            if (!group.keep || !Array.isArray(group.remove) || group.remove.length === 0)
+                continue;
+            const removeSet = new Set(group.remove);
+            let applied = false;
+            for (const dim of Object.keys(profile.tags)) {
+                const keepTag = profile.tags[dim].find((t) => t.value === group.keep);
+                const removeTags = profile.tags[dim].filter((t) => removeSet.has(t.value));
+                if (removeTags.length === 0)
+                    continue;
+                if (keepTag) {
+                    for (const rt of removeTags) {
+                        if (rt.confidence > keepTag.confidence)
+                            keepTag.confidence = rt.confidence;
+                        if (rt.lastSeen > keepTag.lastSeen)
+                            keepTag.lastSeen = rt.lastSeen;
+                    }
+                }
+                profile.tags[dim] = profile.tags[dim].filter((t) => !removeSet.has(t.value));
+                applied = true;
+            }
+            if (applied)
+                mergedGroups++;
+        }
+        // 应用降级
+        const demoteSet = new Set(audit.demotions ?? []);
+        if (demoteSet.size > 0) {
+            for (const dim of Object.keys(profile.tags)) {
+                for (const tag of profile.tags[dim]) {
+                    if (demoteSet.has(tag.value) && (tag.layer ?? "interest") !== "event") {
+                        tag.layer = "event";
+                        tag.confidence = Math.min(tag.confidence, LAYER_CONFIG.event.defaultConfidence);
+                        demoted++;
+                    }
+                }
+            }
+        }
+        // 应用 coreTags 重写
+        let coreTagsRewritten = false;
+        if (Array.isArray(audit.newCoreTags) && audit.newCoreTags.length > 0) {
+            profile.coreTags = audit.newCoreTags.slice(0, 8);
+            coreTagsRewritten = true;
+        }
+        logger.info(`[engram:profile] llmSelfAudit: mergedGroups=${mergedGroups} demoted=${demoted} coreTagsRewritten=${coreTagsRewritten}`);
+        return { mergedGroups, demoted, coreTagsRewritten };
+    }
+    /**
+     * 基于 embedding 的同维度内语义去重
+     *
+     * 对每个维度内的 tag 两两计算 cosine 相似度，>= threshold 的合并为一组，
+     * 组内保留 confidence 最高的作为 canonical，其他并入（取 max confidence + 最新 lastSeen）。
+     *
+     * @param profile 当前画像
+     * @param embedder 将文本 -> 向量的函数
+     * @param threshold cosine 相似度阈值（默认 0.88）
+     */
+    async dedupByEmbedding(profile, embedder, threshold = 0.88) {
+        let merged = 0;
+        for (const dim of Object.keys(profile.tags)) {
+            const tags = profile.tags[dim];
+            if (tags.length < 2)
+                continue;
+            // 批量 embed（串行，避免 API QPS 限制）
+            const vectors = [];
+            for (const t of tags) {
+                try {
+                    vectors.push(await embedder(t.value));
+                }
+                catch (err) {
+                    logger.error(`[engram:profile] dedupByEmbedding: embed failed for "${t.value}": ${err}`);
+                    vectors.push([]); // 占位，跳过相似度计算
+                }
+            }
+            // 并查集式分组
+            const parent = tags.map((_, i) => i);
+            const find = (x) => (parent[x] === x ? x : (parent[x] = find(parent[x])));
+            const union = (a, b) => {
+                const ra = find(a);
+                const rb = find(b);
+                if (ra !== rb)
+                    parent[ra] = rb;
+            };
+            for (let i = 0; i < tags.length; i++) {
+                if (vectors[i].length === 0)
+                    continue;
+                for (let j = i + 1; j < tags.length; j++) {
+                    if (vectors[j].length === 0)
+                        continue;
+                    const sim = cosineSimilarity(vectors[i], vectors[j]);
+                    if (sim >= threshold)
+                        union(i, j);
+                }
+            }
+            // 按组合并
+            const groups = new Map();
+            for (let i = 0; i < tags.length; i++) {
+                const root = find(i);
+                if (!groups.has(root))
+                    groups.set(root, []);
+                groups.get(root).push(i);
+            }
+            const keptTags = [];
+            for (const idxs of groups.values()) {
+                if (idxs.length === 1) {
+                    keptTags.push(tags[idxs[0]]);
+                    continue;
+                }
+                // 组内合并：选 confidence 最高的为 canonical
+                idxs.sort((a, b) => tags[b].confidence - tags[a].confidence);
+                const canonical = { ...tags[idxs[0]] };
+                for (let k = 1; k < idxs.length; k++) {
+                    const t = tags[idxs[k]];
+                    if (t.confidence > canonical.confidence)
+                        canonical.confidence = t.confidence;
+                    if (t.lastSeen > canonical.lastSeen)
+                        canonical.lastSeen = t.lastSeen;
+                    const tLayer = t.layer || "interest";
+                    const cLayer = canonical.layer || "interest";
+                    if (LAYER_PRIORITY[tLayer] > LAYER_PRIORITY[cLayer])
+                        canonical.layer = tLayer;
+                }
+                logger.info(`[engram:profile] dedupByEmbedding [${dim}] merge: keep="${canonical.value}", drop=[${idxs.slice(1).map((i) => `"${tags[i].value}"`).join(", ")}]`);
+                keptTags.push(canonical);
+                merged += idxs.length - 1;
+            }
+            profile.tags[dim] = keptTags;
+        }
+        logger.info(`[engram:profile] dedupByEmbedding: merged ${merged} tags`);
+        return { merged };
+    }
+}
+// ============================================================================
+// 辅助函数
+// ============================================================================
+/** 判断字符串是否像纯经纬度 */
+function isLikelyCoordinate(s) {
+    return /^-?\d+\.\d+\s*,\s*-?\d+\.\d+$/.test(s.trim());
+}
+/** cosine 相似度 */
+function cosineSimilarity(a, b) {
+    if (a.length !== b.length || a.length === 0)
+        return 0;
+    let dot = 0;
+    let na = 0;
+    let nb = 0;
+    for (let i = 0; i < a.length; i++) {
+        dot += a[i] * b[i];
+        na += a[i] * a[i];
+        nb += b[i] * b[i];
     }
+    if (na === 0 || nb === 0)
+        return 0;
+    return dot / (Math.sqrt(na) * Math.sqrt(nb));
 }
 //# sourceMappingURL=profile.js.map