autosnippet 3.2.8 → 3.2.9

package/lib/service/{chat/ProjectSemanticMemory.js → agent/memory/PersistentMemory.js}

@@ -1,17 +1,17 @@
 /**
- * @deprecated Phase 5: 已由 PersistentMemory 继承增强。
- *   新代码请使用 `import { PersistentMemory } from './memory/PersistentMemory.js'`
- *   本文件保留作为 PersistentMemory 的父类，暂不删除。
+ * PersistentMemory — 持久化语义记忆 (Tier 3)
  *
- * ProjectSemanticMemory — 项目级永久语义记忆 (Tier 3)
- *
- * 替代/增强 Memory.js 的 JSONL 存储，使用 SQLite 提供:
+ * 统一的项目级永久记忆存储，使用 SQLite 提供:
  *   - 重要性评分 (importance 1.0-10.0)
  *   - 综合检索 (recency × importance × relevance)
  *   - Extract-Update 模式固化 (ADD / UPDATE / MERGE / NOOP)
+ *   - Mem0 风格冲突解决 (矛盾检测 + 自动替换)
  *   - TTL 自动过期 + 访问计数
  *   - 关联实体 + 关联记忆
  *   - 来源追溯 (sourceDimension + sourceEvidence)
+ *   - Legacy JSONL 迁移
+ *   - 向量嵌入预留接口
+ *   - 预算感知 toPromptSection
  *
  * 记忆类型:
  *   - fact:       项目事实 ("使用 BD 前缀命名", "有 200 个 ObjC 文件")
@@ -23,13 +23,21 @@
  *   - user:      用户对话中产生
  *   - system:    SignalCollector 等后台
  *
- * 兼容: 保留 toPromptSection() 接口，可无缝替代 Memory.js
+ * 算法参数 (Generative Agents 三维打分):
+ *   - 检索权重: RECENCY=0.2, IMPORTANCE=0.3, RELEVANCE=0.5
+ *   - 半衰期: RECENCY_HALF_LIFE_DAYS=7
+ *   - 固化阈值: SIMILARITY_UPDATE=0.85 (同义→UPDATE), SIMILARITY_MERGE=0.6 (相关→MERGE)
+ *   - 遗忘策略: ARCHIVE_DAYS=30 (降级), FORGET_DAYS=90 (删除), MAX_MEMORIES=500
+ *
+ * 兼容: 保留 toPromptSection() / load() / append() / size() 接口，可无缝替代 Memory.js
  *
- * @module ProjectSemanticMemory
+ * @module PersistentMemory
  */
 
+import fs from 'node:fs';
+import path from 'node:path';
 import { randomUUID } from 'node:crypto';
-import { jaccardSimilarity, tokenizeForSimilarity } from '../../shared/similarity.js';
+import { jaccardSimilarity, tokenizeForSimilarity } from '../../../shared/similarity.js';
 
 // ──────────────────────────────────────────────────────────────
 // 常量
@@ -55,37 +63,71 @@ const SIMILARITY_UPDATE = 0.85; // ≥85% 同义 → UPDATE
 const SIMILARITY_MERGE = 0.6; // ≥60% 相关 → MERGE
 
 // ──────────────────────────────────────────────────────────────
-// ProjectSemanticMemory 类
+// 矛盾检测模式 (Mem0 风格冲突解决)
+// ──────────────────────────────────────────────────────────────
+
+/** 中文否定/禁止模式 */
+const NEGATION_PATTERNS_ZH =
+  /不(再)?使用|不(再)?用|禁止|废弃|移除|取消|停止|不要|不采用|弃用|淘汰/;
+
+/** 英文否定/禁止模式 */
+const NEGATION_PATTERNS_EN =
+  /\b(don'?t|do\s+not|never|no\s+longer|removed?|deprecated?|stop|avoid|disable|abandon|drop)\b/i;
+
+/** 共享词语最少匹配数 — 用于判断两条记忆是否讨论同一主题 */
+const MIN_TOPIC_OVERLAP_WORDS = 2;
+
+/** 共享词语比例阈值 — 低于此值视为不同主题 */
+const MIN_TOPIC_OVERLAP_RATIO = 0.3;
+
+// ──────────────────────────────────────────────────────────────
+// PersistentMemory
 // ──────────────────────────────────────────────────────────────
 
-export class ProjectSemanticMemory {
+export class PersistentMemory {
   /** @type {import('better-sqlite3').Database} */
   #db;
 
-  /** @type {import('../../infrastructure/logging/Logger.js').default|null} */
+  /** @type {object|null} */
   #logger;
 
-  // 预编译 SQL Statements (lazy init)
+  /** 预编译 SQL Statements */
   #stmts = null;
 
+  /**
+   * 向量嵌入函数 (预留接口)
+   *
+   * 签名: (queryText: string, contentText: string) => number (0.0-1.0)
+   * 当前: null → 使用 Jaccard + 子串匹配
+   * 未来: ADR-3 — 当嵌入模型可用时，通过 setEmbeddingFunction() 注入
+   *
+   * @type {Function|null}
+   */
+  #embeddingFn;
+
   /**
    * @param {import('better-sqlite3').Database} db — better-sqlite3 实例
    * @param {object} [opts]
-   * @param {object} [opts.logger] — Logger 实例
+   * @param {object}   [opts.logger]       — Logger 实例
+   * @param {Function} [opts.embeddingFn]  — 向量嵌入函数 (预留)
    */
-  constructor(db, { logger } = {}) {
+  constructor(db, opts = {}) {
+    const { logger, embeddingFn } = typeof opts === 'object' && opts !== null ? opts : {};
     if (!db) {
-      throw new Error('ProjectSemanticMemory requires a database instance');
+      throw new Error('PersistentMemory requires a database instance');
     }
     this.#db = typeof db?.getDb === 'function' ? db.getDb() : db;
     this.#logger = logger || null;
+    this.#embeddingFn = typeof embeddingFn === 'function' ? embeddingFn : null;
 
     // 确保表存在 (如果 migration 未运行)
     this.#ensureTable();
     this.#prepareStatements();
   }
 
-  // ─── 基本 CRUD ──────────────────────────────────────────
+  // ═══════════════════════════════════════════════════════════
+  // 基本 CRUD
+  // ═══════════════════════════════════════════════════════════
 
   /**
    * 添加一条记忆
@@ -208,25 +250,32 @@ export class ProjectSemanticMemory {
     return row ? this.#deserialize(row) : null;
   }
 
-  // ─── 智能存储: Extract-Update Consolidation ──────────
+  // ═══════════════════════════════════════════════════════════
+  // 智能存储: Extract-Update Consolidation + 冲突预解决
+  // ═══════════════════════════════════════════════════════════
 
   /**
-   * 智能固化: 对候选记忆执行 ADD / UPDATE / MERGE / NOOP
+   * 智能固化: 先执行冲突检测 (Mem0 风格)，再执行 ADD / UPDATE / MERGE / NOOP
    *
-   * 借鉴 Mem0 的 Extract-Update pipeline:
-   *   1. 对每条候选记忆，搜索相似的现有记忆
-   *   2. 根据相似度决策: ADD / UPDATE / MERGE / NOOP
+   * 冲突解决逻辑:
+   *   1. 对每条候选记忆，在现有库中搜索相似记忆
+   *   2. 如果发现同类型 + 矛盾内容 → 直接 REPLACE (新信息更可信)
+   *   3. 未冲突的候选走正常 ADD/UPDATE/MERGE 流程
    *
    * @param {Array<object>} candidateMemories — 候选记忆列表
    * @param {object} [opts]
    * @param {string} [opts.bootstrapSession] — Bootstrap session ID
-   * @returns {{ added: number, updated: number, merged: number, skipped: number }}
+   * @returns {{ added: number, updated: number, merged: number, skipped: number, replaced?: number }}
    */
   consolidate(candidateMemories, { bootstrapSession } = {}) {
+    // Phase 1: 冲突预解决
+    const { processed, replaced } = this.#preResolveConflicts(candidateMemories);
+
+    // Phase 2: 正常 consolidate 流程
     const stats = { added: 0, updated: 0, merged: 0, skipped: 0 };
 
     const runConsolidate = this.#db.transaction(() => {
-      for (const candidate of candidateMemories) {
+      for (const candidate of processed) {
         const content = (candidate.content || '').trim();
         if (!content || content.length < 5) {
           stats.skipped++;
@@ -285,10 +334,16 @@ export class ProjectSemanticMemory {
     // 容量控制
     this.#enforceCapacity();
 
+    if (replaced > 0) {
+      stats.replaced = replaced;
+    }
+
     return stats;
   }
 
-  // ─── 综合检索 ─────────────────────────────────────────
+  // ═══════════════════════════════════════════════════════════
+  // 综合检索
+  // ═══════════════════════════════════════════════════════════
 
   /**
    * 综合检索: recency × importance × relevance
@@ -363,23 +418,29 @@ export class ProjectSemanticMemory {
     return results.map((r) => this.#deserialize(r));
   }
 
-  // ─── Prompt 生成 (兼容 Memory.js) ──────────────────────
+  // ═══════════════════════════════════════════════════════════
+  // Prompt 生成 (兼容 Memory.js) — 预算感知
+  // ═══════════════════════════════════════════════════════════
 
   /**
-   * 生成供系统提示词的记忆摘要
-   *
-   * 兼容 Memory.toPromptSection() 接口:
-   *   memory.toPromptSection({ source: 'user' })
-   *
-   * 增强: 使用综合检索 (recency + importance + relevance)
+   * 生成供系统提示词的记忆摘要 (预算感知)
    *
    * @param {object} [opts]
    * @param {string} [opts.source] — 过滤 source (user/system/bootstrap)
    * @param {string} [opts.query]  — 查询上下文 (用于 relevance 打分)
    * @param {number} [opts.limit=15]
+   * @param {number} [opts.tokenBudget] — token 预算 (由 MemoryCoordinator 分配)
    * @returns {string} Markdown 格式
    */
-  toPromptSection({ source, query, limit = 15 } = {}) {
+  toPromptSection({ source, query, limit = 15, tokenBudget } = {}) {
+    // 预算感知: 根据 tokenBudget 限制条数
+    if (tokenBudget && tokenBudget > 0) {
+      const EST_TOKENS_PER_MEMORY = 30;
+      const HEADER_TOKENS = 15;
+      const maxByBudget = Math.max(3, Math.floor((tokenBudget - HEADER_TOKENS) / EST_TOKENS_PER_MEMORY));
+      limit = Math.min(limit, maxByBudget);
+    }
+
     let memories;
 
     if (query) {
@@ -409,7 +470,9 @@ export class ProjectSemanticMemory {
     return `\n## 项目记忆 (${memories.length} 条最相关)\n${lines.join('\n')}\n`;
   }
 
-  // ─── Memory.js 兼容层 ──────────────────────────────────
+  // ═══════════════════════════════════════════════════════════
+  // Memory.js 兼容层
+  // ═══════════════════════════════════════════════════════════
 
   /**
    * 兼容 Memory.load() — 返回最近 N 条记忆
@@ -485,7 +548,9 @@ export class ProjectSemanticMemory {
     return this.#db.prepare('SELECT COUNT(*) as cnt FROM semantic_memories').get()?.cnt || 0;
   }
 
-  // ─── 维护: 过期清理 + 容量控制 ────────────────────────
+  // ═══════════════════════════════════════════════════════════
+  // 维护: 过期清理 + 容量控制
+  // ═══════════════════════════════════════════════════════════
 
   /**
    * 执行维护: 清理过期记忆 + 容量控制
@@ -534,7 +599,9 @@ export class ProjectSemanticMemory {
     return stats;
   }
 
-  // ─── 统计 ─────────────────────────────────────────────
+  // ═══════════════════════════════════════════════════════════
+  // 统计
+  // ═══════════════════════════════════════════════════════════
 
   /**
    * 获取统计信息
@@ -571,7 +638,256 @@ export class ProjectSemanticMemory {
     return result.changes;
   }
 
-  // ─── 内部方法 ─────────────────────────────────────────
+  // ═══════════════════════════════════════════════════════════
+  // Legacy Migration (Memory.js JSONL → SQLite)
+  // ═══════════════════════════════════════════════════════════
+
+  /**
+   * 从旧版 Memory.js JSONL 文件迁移数据到 SQLite
+   *
+   * 流程:
+   *   1. 读取 .autosnippet/memory.jsonl (逐行 JSON)
+   *   2. 映射 type: preference→preference, decision→fact, 其他→fact
+   *   3. 通过 consolidate() 智能去重合并
+   *   4. 成功后将旧文件重命名为 .migrated
+   *
+   * @param {string} projectRoot — 用户项目根目录
+   * @returns {Promise<{ migrated: number, skipped: number, error?: string }>}
+   */
+  async migrateFromLegacy(projectRoot) {
+    const legacyPath = path.join(projectRoot, '.autosnippet', 'memory.jsonl');
+
+    if (!fs.existsSync(legacyPath)) {
+      return { migrated: 0, skipped: 0 };
+    }
+
+    try {
+      const raw = fs.readFileSync(legacyPath, 'utf-8').trim();
+      if (!raw) {
+        return { migrated: 0, skipped: 0 };
+      }
+
+      const lines = raw.split('\n').filter(Boolean);
+      const candidates = lines
+        .map((line) => {
+          try {
+            return JSON.parse(line);
+          } catch {
+            return null;
+          }
+        })
+        .filter(Boolean)
+        .map((m) => ({
+          type: PersistentMemory.#mapLegacyType(m.type),
+          content: (m.content || '').trim(),
+          source: m.source || 'user',
+          importance: m.type === 'decision' ? 7 : 5,
+        }))
+        .filter((m) => m.content.length >= 5);
+
+      if (candidates.length === 0) {
+        return { migrated: 0, skipped: lines.length };
+      }
+
+      const result = this.consolidate(candidates, {
+        bootstrapSession: 'legacy-migration',
+      });
+
+      // 迁移成功 → 重命名旧文件 (保留备份)
+      try {
+        fs.renameSync(legacyPath, `${legacyPath}.migrated`);
+      } catch {
+        // 重命名失败不影响迁移结果
+      }
+
+      const migrated = result.added + result.merged;
+      this.#log(
+        `Legacy migration: ${migrated} migrated (${result.added} added, ${result.merged} merged), ${result.skipped} skipped from ${legacyPath}`
+      );
+
+      return { migrated, skipped: result.skipped };
+    } catch (err) {
+      this.#log(`Legacy migration failed: ${err.message}`);
+      return { migrated: 0, skipped: 0, error: err.message };
+    }
+  }
+
+  // ═══════════════════════════════════════════════════════════
+  // 向量嵌入接口 (ADR-3 预留)
+  // ═══════════════════════════════════════════════════════════
+
+  /**
+   * 设置向量嵌入函数
+   * @param {Function|null} fn — (query: string, content: string) => number (0.0-1.0)
+   */
+  setEmbeddingFunction(fn) {
+    this.#embeddingFn = typeof fn === 'function' ? fn : null;
+  }
+
+  /**
+   * 获取当前嵌入函数 (用于检测是否已配置)
+   * @returns {Function|null}
+   */
+  getEmbeddingFunction() {
+    return this.#embeddingFn;
+  }
+
+  /**
+   * 使用嵌入函数计算语义相关性 (如已设置)
+   *
+   * @param {string} query
+   * @param {string} content
+   * @returns {number|null} — 0.0-1.0 或 null (无嵌入函数)
+   */
+  computeEmbeddingRelevance(query, content) {
+    if (!this.#embeddingFn) return null;
+    try {
+      return this.#embeddingFn(query, content);
+    } catch {
+      return null;
+    }
+  }
+
+  // ═══════════════════════════════════════════════════════════
+  // Private: 冲突预解决 (Mem0 风格)
+  // ═══════════════════════════════════════════════════════════
+
+  /**
+   * 在 consolidate 主流程前检测并解决矛盾
+   *
+   * @param {Array<object>} candidates
+   * @returns {{ processed: Array<object>, replaced: number }}
+   */
+  #preResolveConflicts(candidates) {
+    if (!candidates || candidates.length === 0) {
+      return { processed: [], replaced: 0 };
+    }
+
+    const processed = [];
+    let replaced = 0;
+
+    for (const candidate of candidates) {
+      const content = (candidate.content || '').trim();
+      if (!content || content.length < 5) {
+        processed.push(candidate);
+        continue;
+      }
+
+      try {
+        const similar = this.search(content, { limit: 3 });
+        let conflictResolved = false;
+
+        for (const existing of similar) {
+          if (existing.type === (candidate.type || 'fact')) {
+            const isContradiction = PersistentMemory.#detectContradiction(
+              existing.content,
+              content
+            );
+
+            if (isContradiction) {
+              this.update(existing.id, {
+                content: content.substring(0, 500),
+                importance: Math.max(existing.importance || 5, candidate.importance || 5),
+              });
+              conflictResolved = true;
+              replaced++;
+              this.#log(
+                `Conflict resolved: replaced "${existing.content.substring(0, 50)}..." with "${content.substring(0, 50)}..."`
+              );
+              break;
+            }
+          }
+        }
+
+        if (!conflictResolved) {
+          processed.push(candidate);
+        }
+      } catch {
+        processed.push(candidate);
+      }
+    }
+
+    return { processed, replaced };
+  }
+
+  /**
+   * 检测两段记忆内容是否矛盾
+   *
+   * @param {string} contentA — 现有记忆内容
+   * @param {string} contentB — 候选记忆内容
+   * @returns {boolean}
+   */
+  static #detectContradiction(contentA, contentB) {
+    if (!contentA || !contentB) return false;
+
+    const aNeg =
+      NEGATION_PATTERNS_ZH.test(contentA) || NEGATION_PATTERNS_EN.test(contentA);
+    const bNeg =
+      NEGATION_PATTERNS_ZH.test(contentB) || NEGATION_PATTERNS_EN.test(contentB);
+
+    if (aNeg === bNeg) return false;
+
+    const wordsA = PersistentMemory.#extractTopicWords(contentA);
+    const wordsB = PersistentMemory.#extractTopicWords(contentB);
+
+    let overlap = 0;
+    for (const w of wordsA) {
+      if (wordsB.has(w)) overlap++;
+    }
+
+    const minSize = Math.min(wordsA.size, wordsB.size);
+    if (minSize === 0) return false;
+
+    return overlap >= MIN_TOPIC_OVERLAP_WORDS || overlap / minSize >= MIN_TOPIC_OVERLAP_RATIO;
+  }
+
+  /**
+   * 提取主题词 (去停用词 + 短词)
+   * @param {string} text
+   * @returns {Set<string>}
+   */
+  static #extractTopicWords(text) {
+    if (!text) return new Set();
+
+    const tokens = text
+      .toLowerCase()
+      .split(/[\s,;:!?。，；：！？\-_/\\|()[\]{}'"<>·、]+/)
+      .filter((t) => t.length >= 2);
+
+    const stopWords = new Set([
+      '我们', '使用', '项目', '需要', '可以', '应该', '建议', '目前',
+      '已经', '这个', '那个', '一个', '进行', '通过', '对于',
+      'the', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
+      'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would',
+      'could', 'should', 'may', 'might', 'shall', 'can', 'this',
+      'that', 'these', 'those', 'with', 'from', 'for', 'and',
+      'but', 'not', 'all', 'any', 'each', 'every', 'some',
+    ]);
+
+    return new Set(tokens.filter((t) => !stopWords.has(t)));
+  }
+
+  /**
+   * 从 Memory.js 的 type 映射到 PersistentMemory 的 type
+   * @param {string} legacyType
+   * @returns {string}
+   */
+  static #mapLegacyType(legacyType) {
+    switch (legacyType) {
+      case 'preference':
+        return 'preference';
+      case 'decision':
+        return 'fact';
+      case 'context':
+        return 'fact';
+      default:
+        return 'fact';
+    }
+  }
+
+  // ═══════════════════════════════════════════════════════════
+  // Private: DB / SQL 基础设施
+  // ═══════════════════════════════════════════════════════════
 
   /**
    * 确保表存在 (用于 migration 未运行的情况)
@@ -679,9 +995,6 @@ export class ProjectSemanticMemory {
     };
   }
 
-  /**
-   * 获取所有活跃记忆 (未过期)
-   */
   #getAllActive({ source, type } = {}) {
     const now = new Date().toISOString();
     if (source && type) {
@@ -696,9 +1009,6 @@ export class ProjectSemanticMemory {
     return this.#stmts.getAllActive.all({ now });
   }
 
-  /**
-   * 更新访问计数和最后访问时间
-   */
   #touchAccess(id) {
     try {
       this.#stmts.touchAccess.run({ id, now: new Date().toISOString() });
@@ -709,11 +1019,6 @@ export class ProjectSemanticMemory {
 
   /**
    * 查找相似记忆 (基于 token overlap)
-   *
-   * @param {string} content
-   * @param {string|null} type
-   * @param {number} limit
-   * @returns {Array<object & { similarity: number }>}
    */
   #findSimilar(content, type, limit) {
     const now = new Date().toISOString();
@@ -735,14 +1040,6 @@ export class ProjectSemanticMemory {
     return scored.slice(0, limit);
   }
 
-  /**
-   * 计算两段文本的相似度 (Jaccard + 子串) — 委托共享 similarity 模块
-   *
-   * @param {Set<string>} tokensA — 预分词的 token 集合
-   * @param {string} lowerA — 小写原文
-   * @param {string} contentB — 原始文本 B
-   * @returns {number} 0.0-1.0
-   */
   #computeSimilarity(tokensA, lowerA, contentB) {
     const lowerB = (contentB || '').toLowerCase();
     const tokensB = tokenizeForSimilarity(lowerB);
@@ -755,21 +1052,11 @@ export class ProjectSemanticMemory {
     }
 
     const jaccard = jaccardSimilarity(tokensA, tokensB);
-
-    // 子串包含加分
     const containsBonus = lowerA.includes(lowerB) || lowerB.includes(lowerA) ? 0.3 : 0;
 
     return Math.min(1.0, jaccard + containsBonus);
   }
 
-  /**
-   * 计算查询与记忆内容的相关性 (用于检索打分)
-   *
-   * @param {string} lowerQuery
-   * @param {Set<string>} queryTokens
-   * @param {string} content
-   * @returns {number} 0.0-1.0
-   */
   #computeRelevance(lowerQuery, queryTokens, content) {
     if (!lowerQuery || !content) {
       return 0;
@@ -782,7 +1069,6 @@ export class ProjectSemanticMemory {
       return 0;
     }
 
-    // Token overlap
     let matchCount = 0;
     for (const t of queryTokens) {
       if (contentTokens.has(t)) {
@@ -791,10 +1077,8 @@ export class ProjectSemanticMemory {
     }
     const tokenOverlap = matchCount / queryTokens.size;
 
-    // 子串匹配
     const substringMatch = lowerContent.includes(lowerQuery) ? 0.4 : 0;
 
-    // 关键词部分匹配
     let partialMatch = 0;
     for (const qt of queryTokens) {
       if (qt.length >= 3 && lowerContent.includes(qt)) {
@@ -806,11 +1090,6 @@ export class ProjectSemanticMemory {
     return Math.min(1.0, tokenOverlap * 0.5 + substringMatch + partialMatch);
   }
 
-  /**
-   * 分词 (按空格/标点分割, 去短词) — 用于 relevance 计算
-   * @param {string} text
-   * @returns {Set<string>}
-   */
   #tokenizeWords(text) {
     if (!text) {
       return new Set();
@@ -823,9 +1102,6 @@ export class ProjectSemanticMemory {
     );
   }
 
-  /**
-   * 反序列化 DB 行为 JS 对象
-   */
   #deserialize(row) {
     return {
       id: row.id,
@@ -847,9 +1123,6 @@ export class ProjectSemanticMemory {
     };
   }
 
-  /**
-   * 安全 JSON 解析
-   */
   #safeParseJSON(str, fallback) {
     try {
       return str ? JSON.parse(str) : fallback;
@@ -858,9 +1131,6 @@ export class ProjectSemanticMemory {
     }
   }
 
-  /**
-   * 容量控制: 超过 MAX_MEMORIES 时删除最不重要的
-   */
   #enforceCapacity() {
     const count = this.#db.prepare('SELECT COUNT(*) as cnt FROM semantic_memories').get()?.cnt || 0;
     if (count <= MAX_MEMORIES) {
@@ -881,15 +1151,15 @@ export class ProjectSemanticMemory {
     this.#log(`Capacity enforced: removed ${excess} lowest-priority memories`);
   }
 
-  /**
-   * 日志输出
-   */
   #log(msg) {
-    const formatted = `[SemanticMemory] ${msg}`;
-    if (this.#logger) {
+    const formatted = `[PersistentMemory] ${msg}`;
+    if (this.#logger?.info) {
       this.#logger.info(formatted);
     }
   }
 }
 
-export default ProjectSemanticMemory;
+// ── 向后兼容: 使用旧名称导入时仍可用 ──
+export { PersistentMemory as ProjectSemanticMemory };
+
+export default PersistentMemory;

package/lib/service/{chat → agent}/memory/SessionStore.js

@@ -519,7 +519,7 @@ export class SessionStore {
   }
 
   // ═══════════════════════════════════════════════════════
-  // §7: 蒸馏上下文 (新: for ProducerAgent, B2 fix)
+  // §7: 蒸馏上下文 (for PipelineStrategy produce 阶段)
   // ═══════════════════════════════════════════════════════
 
   /**

package/lib/service/{chat → agent}/memory/index.js

@@ -4,7 +4,7 @@
  * Phase 2: MemoryCoordinator + legacy module re-exports
  * Phase 3: ActiveContext (合并 WorkingMemory + ReasoningTrace)
  * Phase 4: SessionStore (合并 EpisodicMemory + ToolResultCache)
- * Phase 5: PersistentMemory (继承 ProjectSemanticMemory + 增强)
+ * Phase 5: PersistentMemory (统一的持久化语义记忆)
  */
 
 export { MemoryCoordinator } from './MemoryCoordinator.js';