mindforge-memory 6.4.1__py3-none-any.whl

mindforge/modules/__init__.py

@@ -0,0 +1,138 @@
+"""
+MindForge v5.0 功能模块
+知识图谱 · 记忆演化 · 人格化 · 多模态 · 联邦记忆 · 多Agent记忆空间
+"""
+
+from .recall import RecallEngine, RecallConfig
+from .knowledge_graph import KnowledgeGraph, KnowledgeEntity, KnowledgeRelation
+from .evolution import MemoryEvolution, ForgettingCurve
+from .personality import PersonalityEngine, UserProfile
+from .multimodal import MultimodalMemory, MultimodalType
+from .federated import FederatedMemory, FederatedPeer
+from .categorizer import TaxonomyManager
+from .privacy import PrivacyEngine, PrivacyScanResult
+from .integrator import MemoryIntegrator
+from .multi_agent import MultiAgentMemoryManager, AgentSpace, SpaceMember, SpaceRole
+# v5.3.9 新增五大能力
+from .intent_router import IntentRouter, IntentResult, INTENT_DEFS, DEFAULT_INTENT
+from .conflict_detector import ConflictDetector, ConflictPair, DecayAction, ANTONYM_PAIRS
+from .skill_extractor import SkillExtractor, SkillTemplate, SkillSlot
+from .hybrid_search import (QueryExpander, ExpansionResult,
+                            CrossEncoderReranker, RerankResult, RerankWeights)
+from .session_focus import SessionFocus, TopicCluster, FocusSummary
+# v5.4.2 新增两大能力
+from .federated_acl import FederatedACLManager
+from .share_conflict import SharedConflictResolver
+# v6.0.0 新增：一键导入 / 时间线可视化 / 技能包 / 演变 / 结果学习 / 护照 / 遗忘 / 收尾
+from .importer import import_chat_history, parse_export, detect_platform
+from .timeline_viz import build_timeline_visual
+from .skill_pack import export_skill_pack, validate_skill_pack, import_skill_pack
+from .outcome_learning import apply_outcome, outcome_stats, search_weighted
+from .memory_passport import (
+    export_passport, import_passport, revoke_passport, passport_status,
+)
+from .principled_forgetting import (
+    explain_forgetting, run_principled_gc, forgetting_stats,
+)
+from .follow_up import (
+    create_follow_up, list_due, resolve_follow_up, list_follow_ups,
+)
+# v6.0.0 扩展端口（多 Agent 协作 + 6G AI 记忆预览，正式发布）
+from .v6 import (
+    V6_TARGET_VERSION,
+    V6Capability,
+    V6Status,
+    V6Port,
+    MultiAgentCollaborationPort,
+    MultiAgentAdapterPort,
+    MemoryPreviewPort,
+    create_multi_agent_adapter,
+    register_v6_port,
+    unregister_v6_port,
+    get_v6_port,
+    list_v6_ports,
+    v6_status,
+)
+
+__all__ = [
+    "RecallEngine",
+    "RecallConfig",
+    "KnowledgeGraph",
+    "KnowledgeEntity",
+    "KnowledgeRelation",
+    "MemoryEvolution",
+    "ForgettingCurve",
+    "PersonalityEngine",
+    "UserProfile",
+    "MultimodalMemory",
+    "MultimodalType",
+    "FederatedMemory",
+    "FederatedPeer",
+    "TaxonomyManager",
+    "PrivacyEngine",
+    "PrivacyScanResult",
+    "MemoryIntegrator",
+    "MultiAgentMemoryManager",
+    "AgentSpace",
+    "SpaceMember",
+    "SpaceRole",
+    # v5.3.9
+    "IntentRouter",
+    "IntentResult",
+    "INTENT_DEFS",
+    "DEFAULT_INTENT",
+    "ConflictDetector",
+    "ConflictPair",
+    "DecayAction",
+    "ANTONYM_PAIRS",
+    "SkillExtractor",
+    "SkillTemplate",
+    "SkillSlot",
+    "QueryExpander",
+    "ExpansionResult",
+    "CrossEncoderReranker",
+    "RerankResult",
+    "RerankWeights",
+    "SessionFocus",
+    "TopicCluster",
+    "FocusSummary",
+    # v5.4.2
+    "FederatedACLManager",
+    "SharedConflictResolver",
+    # v6.0.0 功能 1-8
+    "import_chat_history",
+    "parse_export",
+    "detect_platform",
+    "build_timeline_visual",
+    "export_skill_pack",
+    "validate_skill_pack",
+    "import_skill_pack",
+    "apply_outcome",
+    "outcome_stats",
+    "search_weighted",
+    "export_passport",
+    "import_passport",
+    "revoke_passport",
+    "passport_status",
+    "explain_forgetting",
+    "run_principled_gc",
+    "forgetting_stats",
+    "create_follow_up",
+    "list_due",
+    "resolve_follow_up",
+    "list_follow_ups",
+    # v6.0.0 端口预留
+    "V6_TARGET_VERSION",
+    "V6Capability",
+    "V6Status",
+    "V6Port",
+    "MultiAgentCollaborationPort",
+    "MultiAgentAdapterPort",
+    "MemoryPreviewPort",
+    "create_multi_agent_adapter",
+    "register_v6_port",
+    "unregister_v6_port",
+    "get_v6_port",
+    "list_v6_ports",
+    "v6_status",
+]

mindforge/modules/categorizer.py

@@ -0,0 +1,151 @@
+"""
+MindForge v5.0 分类管理模块
+"""
+
+import re
+from dataclasses import dataclass, field
+from typing import List, Dict, Optional
+
+
+@dataclass
+class CategoryNode:
+    name: str
+    parent: Optional[str] = None
+    children: List[str] = field(default_factory=list)
+    keywords: List[str] = field(default_factory=list)
+    description: str = ""
+
+
+DEFAULT_TAXONOMY = {
+    "work": {
+        "name": "工作",
+        "keywords": ["工作", "项目", "任务", "会议", "报告", "同事", "老板", "公司", "业务"],
+        "children": ["tech", "project", "meeting"],
+    },
+    "tech": {
+        "name": "技术",
+        "keywords": ["技术", "编程", "代码", "开发", "bug", "算法", "架构", "设计"],
+        "parent": "work",
+        "children": ["programming", "devops", "design"],
+    },
+    "programming": {
+        "name": "编程开发",
+        "keywords": ["python", "java", "javascript", "函数", "类", "接口", "api"],
+        "parent": "tech",
+    },
+    "life": {
+        "name": "生活",
+        "keywords": ["生活", "吃饭", "睡觉", "家庭", "朋友", "旅行", "美食", "电影"],
+        "children": ["health", "hobby"],
+    },
+    "health": {
+        "name": "健康",
+        "keywords": ["健康", "运动", "健身", "饮食", "睡眠", "体检", "疾病"],
+        "parent": "life",
+    },
+    "learning": {
+        "name": "学习",
+        "keywords": ["学习", "研究", "阅读", "书籍", "课程", "笔记", "知识"],
+        "children": [],
+    },
+    "idea": {
+        "name": "创意",
+        "keywords": ["创意", "想法", "灵感", "设计", "发明", "创新", "产品"],
+        "children": [],
+    },
+    "personal": {
+        "name": "个人",
+        "keywords": ["我", "自己", "个人", "隐私", "秘密", "想法", "感受"],
+        "children": [],
+    },
+}
+
+
+class TaxonomyManager:
+    """分类管理器"""
+
+    def __init__(self, taxonomy: Optional[Dict] = None):
+        self.taxonomy = taxonomy or DEFAULT_TAXONOMY
+        self._build_keyword_index()
+
+    def _build_keyword_index(self):
+        self._keyword_map: Dict[str, str] = {}
+        for cat_id, cat_data in self.taxonomy.items():
+            for keyword in cat_data.get("keywords", []):
+                self._keyword_map[keyword.lower()] = cat_id
+
+    def suggest_category(self, content: str) -> str:
+        """建议分类"""
+        content_lower = content.lower()
+        scores: Dict[str, int] = {}
+
+        for keyword, cat_id in self._keyword_map.items():
+            if keyword in content_lower:
+                scores[cat_id] = scores.get(cat_id, 0) + 1
+
+        if not scores:
+            return "general"
+
+        best_category = max(scores.items(), key=lambda x: x[1])[0]
+        return best_category
+
+    def suggest_tags(self, content: str, max_tags: int = 5) -> List[str]:
+        """建议标签"""
+        content_lower = content.lower()
+        tags = []
+
+        for keyword, cat_id in self._keyword_map.items():
+            if keyword in content_lower:
+                if keyword not in tags:
+                    tags.append(keyword)
+
+        words = re.findall(r'[\w\u4e00-\u9fff]+', content_lower)
+        from collections import Counter
+        word_counts = Counter(words)
+        for word, count in word_counts.most_common(10):
+            if len(word) > 2 and word not in tags and count >= 1:
+                tags.append(word)
+                if len(tags) >= max_tags:
+                    break
+
+        return tags[:max_tags]
+
+    def get_category_info(self, category_id: str) -> Optional[Dict]:
+        """获取分类信息"""
+        return self.taxonomy.get(category_id)
+
+    def get_all_categories(self) -> Dict[str, Dict]:
+        """获取所有分类"""
+        return self.taxonomy
+
+    def get_subcategories(self, parent_id: str) -> List[str]:
+        """获取子分类"""
+        parent = self.taxonomy.get(parent_id)
+        if parent:
+            return parent.get("children", [])
+        return []
+
+    def get_parent_category(self, category_id: str) -> Optional[str]:
+        """获取父分类"""
+        cat = self.taxonomy.get(category_id)
+        if cat:
+            return cat.get("parent")
+        return None
+
+    def add_category(self, category_id: str, name: str,
+                     keywords: Optional[List[str]] = None,
+                     parent: Optional[str] = None):
+        """添加分类"""
+        self.taxonomy[category_id] = {
+            "name": name,
+            "keywords": keywords or [],
+            "parent": parent,
+            "children": [],
+        }
+
+        if parent and parent in self.taxonomy:
+            if category_id not in self.taxonomy[parent]["children"]:
+                self.taxonomy[parent]["children"].append(category_id)
+
+        for keyword in keywords or []:
+            self._keyword_map[keyword.lower()] = category_id

mindforge/modules/conflict_detector.py

@@ -0,0 +1,356 @@
+"""
+MindForge 矛盾检测 + 自动衰减引擎
+========================================
+三类检测：
+  A. 直接反义对（词级别，如 启用 / 禁用）
+  B. 属性值冲突（"价格是 X" vs "价格是 Y, X≠Y"）
+  C. 时间线冲突（"已于周一完成" vs "预计周三完成"）
+
+自动衰减策略：
+  - 同主体冲突 → 老记忆重要性衰减、tag 标记 conflict
+  - 显式 resolve 后，胜出记忆 +0.08 重要性（构造参数
+    `auto_boost_resolve_winner`，v6.1.2 校正：文档原写 +0.1，与代码默认值不符），
+    失败方 -0.20（`auto_decay_resolve_loser`）
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Tuple
+
+# ---------------------------------------------------------------------------
+# 反义词典（内置常见技术/生活反义对）
+# ---------------------------------------------------------------------------
+
+ANTONYM_PAIRS: List[Tuple[str, str]] = [
+    ("启用", "禁用"), ("开启", "关闭"), ("打开", "关闭"), ("启动", "停止"),
+    ("允许", "禁止"), ("允许", "拒绝"), ("通过", "驳回"), ("成功", "失败"),
+    ("新增", "删除"), ("添加", "移除"), ("增加", "减少"), ("上升", "下降"),
+    ("提高", "降低"), ("支持", "反对"), ("兼容", "不兼容"), ("安全", "危险"),
+    ("公开", "私有"), ("加密", "明文"), ("同步", "异步"), ("阻塞", "非阻塞"),
+    ("真", "假"), ("是", "否"), ("对", "错"), ("正确", "错误"),
+    ("稳定", "不稳定"), ("可用", "不可用"), ("正常", "异常"), ("存在", "不存在"),
+    ("完成", "未完成"), ("已", "未"), ("可以", "不能"), ("应该", "不该"),
+    # v5.4.7 修复：添加常见技术偏好反义对
+    ("vim", "vscode"), ("vim", "vs code"), ("emacs", "vim"),
+    ("python", "java"), ("javascript", "typescript"), ("react", "vue"),
+    ("mac", "windows"), ("linux", "windows"), ("ios", "android"),
+    ("git", "svn"), ("docker", "vm"), ("kubernetes", "docker swarm"),
+    ("rest", "graphql"), ("sql", "nosql"), ("mongodb", "postgresql"),
+]
+
+# 属性抽取正则：<属性名> 是/为/=/: <值>
+_ATTR_RE = re.compile(
+    r"([\u4e00-\u9fa5A-Za-z][\u4e00-\u9fa5A-Za-z0-9_\+\-\.\*#]{0,19})"
+    r"\s*(?:是|为|=|等于|：|:)\s*"
+    r"([\u4e00-\u9fa5A-Za-z0-9_\-\+\.\*#/%@\$]{1,40})"
+)
+
+# v5.4.7 修复：添加偏好抽取正则，检测 "喜欢/偏好 X" 模式
+_PREFERENCE_RE = re.compile(
+    r"(?:喜欢|偏好|爱用|常用|主要用|习惯用)\s*"
+    r"([\u4e00-\u9fa5A-Za-z0-9_\-\+\.\*#/%@\$]{1,40})"
+)
+
+# 时间词
+_TIME_WORDS = {
+    "周一": 1, "周二": 2, "周三": 3, "周四": 4, "周五": 5, "周六": 6, "周日": 7, "周天": 7,
+    "星期一": 1, "星期二": 2, "星期三": 3, "星期四": 4, "星期五": 5, "星期六": 6, "星期日": 7,
+    "一月": 1, "二月": 2, "三月": 3, "四月": 4, "五月": 5, "六月": 6, "七月": 7,
+    "八月": 8, "九月": 9, "十月": 10, "十一月": 11, "十二月": 12,
+    "今天": 0, "明天": 1, "后天": 2, "昨天": -1, "前天": -2,
+}
+_STATUS_PATTERNS = [
+    (re.compile(r"(已|已经|早就|完成了|做完了|搞定了)\s*[^\s，,。；;]{0,10}(完成|做完|上线|发布|提交|合并)"), "done"),
+    (re.compile(r"(预计|计划|准备|将于|要|还没|尚未|未完成|待办|准备)\s*[^\s，,。；;]{0,10}(完成|上线|发布|提交|合并|做|弄)"), "pending"),
+]
+
+
+# ---------------------------------------------------------------------------
+# 数据类
+# ---------------------------------------------------------------------------
+
+@dataclass
+class ConflictPair:
+    memory_id_a: str
+    memory_id_b: str
+    conflict_type: str       # antonym / attribute / timeline
+    severity: float          # 0.0 ~ 1.0
+    evidence: Dict[str, Any] = field(default_factory=dict)
+    suggestion: str = ""
+    resolution: str = "unresolved"   # unresolved / a_wins / b_wins / both_deprecated
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "memory_id_a": self.memory_id_a,
+            "memory_id_b": self.memory_id_b,
+            "conflict_type": self.conflict_type,
+            "severity": round(self.severity, 3),
+            "evidence": self.evidence,
+            "suggestion": self.suggestion,
+            "resolution": self.resolution,
+        }
+
+
+@dataclass
+class DecayAction:
+    memory_id: str
+    delta_importance: float        # 例如 -0.15
+    added_tags: List[str] = field(default_factory=list)
+    reason: str = ""
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "memory_id": self.memory_id,
+            "delta_importance": round(self.delta_importance, 3),
+            "added_tags": self.added_tags,
+            "reason": self.reason,
+        }
+
+
+# ---------------------------------------------------------------------------
+# 引擎
+# ---------------------------------------------------------------------------
+
+class ConflictDetector:
+    """纯 CPU 实现的矛盾检测 + 自动衰减。无外部依赖。"""
+
+    def __init__(self,
+                 storage_or_antonym_pairs=None,
+                 antonym_threshold: int = 1,
+                 attr_match_min_length: int = 2,
+                 auto_decay_old: float = 0.12,
+                 auto_decay_resolve_loser: float = 0.20,
+                 auto_boost_resolve_winner: float = 0.08):
+        # v5.4.7 修复：兼容 README 示例中的 ConflictDetector(storage) 用法
+        # 如果第一个参数是 StorageEngine 实例，则忽略它（当前版本不需要）
+        # 如果是 list/tuple，则作为反义词对列表
+        if storage_or_antonym_pairs is None:
+            antonym_pairs = None
+        elif isinstance(storage_or_antonym_pairs, (list, tuple)):
+            antonym_pairs = storage_or_antonym_pairs
+        else:
+            # 假设是 storage 或其他对象，忽略
+            antonym_pairs = None
+
+        self.antonyms = list(antonym_pairs or ANTONYM_PAIRS)
+        self.antonym_threshold = antonym_threshold
+        self.attr_min_len = attr_match_min_length
+        self.auto_decay_old = auto_decay_old
+        self.auto_decay_loser = auto_decay_resolve_loser
+        self.auto_boost_winner = auto_boost_resolve_winner
+
+    # -- detector primitives -----------------------------------------------
+
+    @staticmethod
+    def _tokens(text: str) -> set:
+        # 简单中文切词：按标点/空白 + 2-gram 组合 + 中文 2~4 字片段
+        raw = re.sub(r"[\s，,。；;：:!！？?、()（）\[\]【】\"'《》\-—/\\]+", " ", text)
+        parts = [p for p in raw.split() if p]
+        bag = set(parts)
+        for p in parts:
+            if len(p) >= 2:
+                for n in (2, 3):
+                    for i in range(0, len(p) - n + 1):
+                        bag.add(p[i:i + n])
+        return bag
+
+    def _antonym_hit(self, a: str, b: str) -> Tuple[int, List[str]]:
+        count = 0
+        pairs_hit: List[str] = []
+        ta, tb = self._tokens(a), self._tokens(b)
+        for x, y in self.antonyms:
+            if (x in ta and y in tb) or (y in ta and x in tb):
+                count += 1
+                pairs_hit.append(f"{x}↔{y}")
+        return count, pairs_hit
+
+    def _extract_attrs(self, text: str) -> Dict[str, str]:
+        attrs: Dict[str, str] = {}
+        for m in _ATTR_RE.finditer(text):
+            name, value = m.group(1).strip(), m.group(2).strip()
+            if len(name) >= self.attr_min_len and len(value) >= 1:
+                attrs[name] = value
+        return attrs
+
+    def _extract_preferences(self, text: str) -> List[str]:
+        """v5.4.7 修复：抽取偏好项，如 '喜欢 Vim' -> ['vim']"""
+        prefs = []
+        for m in _PREFERENCE_RE.finditer(text):
+            pref = m.group(1).strip().lower()
+            if len(pref) >= 2:
+                prefs.append(pref)
+        return prefs
+
+    def _timeline_status(self, text: str) -> Optional[str]:
+        for pattern, status in _STATUS_PATTERNS:
+            if pattern.search(text):
+                return status
+        return None
+
+    # -- public API --------------------------------------------------------
+
+    def detect_antonym(self, text_a: str, text_b: str,
+                       id_a: str, id_b: str) -> Optional[ConflictPair]:
+        cnt, pairs = self._antonym_hit(text_a, text_b)
+        if cnt < self.antonym_threshold:
+            return None
+        severity = min(0.35 + cnt * 0.20, 1.0)
+        return ConflictPair(
+            memory_id_a=id_a, memory_id_b=id_b,
+            conflict_type="antonym", severity=severity,
+            evidence={"antonym_pairs": pairs, "hit_count": cnt},
+            suggestion="反义词同现，建议人工核验以较新记忆或上下文一致者为准",
+        )
+
+    def detect_preference(self, text_a: str, text_b: str,
+                          id_a: str, id_b: str) -> Optional[ConflictPair]:
+        """v5.4.7 修复：检测偏好冲突，如 '喜欢 Vim' vs '喜欢 VS Code'"""
+        prefs_a = self._extract_preferences(text_a)
+        prefs_b = self._extract_preferences(text_b)
+        if not prefs_a or not prefs_b:
+            return None
+        # 检查是否有不同的偏好项
+        set_a, set_b = set(prefs_a), set(prefs_b)
+        if set_a == set_b:
+            return None  # 相同偏好，不冲突
+        # 检查是否有交集（同一类别但不同选择）
+        # 例如：都提到编辑器但选择不同
+        conflicts = []
+        for pa in set_a:
+            for pb in set_b:
+                if pa != pb:
+                    # v5.4.8 P3-001 修复：收紧长度差阈值，添加额外启发式
+                    # 1. 长度差 <= 2（更严格）
+                    # 2. 首字母相同（同类事物的常见模式）
+                    # 3. 一个包含另一个（如 vim/vimrc）
+                    len_diff_ok = abs(len(pa) - len(pb)) <= 2
+                    same_first_letter = pa[0] == pb[0] if pa and pb else False
+                    substring_rel = pa in pb or pb in pa
+
+                    if len_diff_ok or same_first_letter or substring_rel:
+                        conflicts.append((pa, pb))
+        if not conflicts:
+            return None
+        severity = min(0.40 + 0.10 * len(conflicts), 0.90)
+        return ConflictPair(
+            memory_id_a=id_a, memory_id_b=id_b,
+            conflict_type="preference", severity=severity,
+            evidence={"preference_conflicts": conflicts, "count": len(conflicts)},
+            suggestion=f"偏好不一致：{', '.join(f'{a} vs {b}' for a, b in conflicts[:3])}",
+        )
+
+    def detect_attribute(self, text_a: str, text_b: str,
+                         id_a: str, id_b: str) -> Optional[ConflictPair]:
+        a_attrs = self._extract_attrs(text_a)
+        b_attrs = self._extract_attrs(text_b)
+        shared = [k for k in a_attrs if k in b_attrs and a_attrs[k] != b_attrs[k]]
+        if not shared:
+            return None
+        conflicts = {k: (a_attrs[k], b_attrs[k]) for k in shared}
+        severity = min(0.30 + 0.12 * len(shared), 0.95)
+        return ConflictPair(
+            memory_id_a=id_a, memory_id_b=id_b,
+            conflict_type="attribute", severity=severity,
+            evidence={"attribute_conflicts": conflicts, "count": len(shared)},
+            suggestion=f"以下 {len(shared)} 个属性取值不一致：{', '.join(shared)}",
+        )
+
+    def detect_timeline(self, text_a: str, text_b: str,
+                        id_a: str, id_b: str) -> Optional[ConflictPair]:
+        sa, sb = self._timeline_status(text_a), self._timeline_status(text_b)
+        if not sa or not sb or sa == sb:
+            return None
+        if {sa, sb} == {"done", "pending"}:
+            severity = 0.65
+            return ConflictPair(
+                memory_id_a=id_a, memory_id_b=id_b,
+                conflict_type="timeline", severity=severity,
+                evidence={"status_a": sa, "status_b": sb},
+                suggestion="同一件事出现『已完成』vs『待完成』矛盾，请以最近时间戳或显式更新者为准",
+            )
+        return None
+
+    # -- batch scan --------------------------------------------------------
+
+    def scan_memories(self,
+                      memories: List[Dict[str, Any]],
+                      max_pairs: int = 1000) -> List[ConflictPair]:
+        """扫描一批记忆并返回所有冲突对。
+        memories: 每一项必须至少含 id, content 字段，可选 created_at。
+        """
+        results: List[ConflictPair] = []
+        n = len(memories)
+        # 两两比较，O(n^2)，对大样本先按标签/关键词分桶以减少比较
+        checked = 0
+        for i in range(n):
+            mi = memories[i]
+            for j in range(i + 1, n):
+                mj = memories[j]
+                checked += 1
+                if checked > max_pairs:
+                    return results
+                ta, tb = str(mi.get("content", "")), str(mj.get("content", ""))
+                id_a, id_b = str(mi.get("id", i)), str(mj.get("id", j))
+                for detector in (self.detect_antonym, self.detect_attribute, self.detect_timeline, self.detect_preference):
+                    pair = detector(ta, tb, id_a, id_b)
+                    if pair is not None:
+                        results.append(pair)
+        # 按严重度排序
+        results.sort(key=lambda p: p.severity, reverse=True)
+        return results
+
+    # -- auto decay --------------------------------------------------------
+
+    def plan_decay(self, conflicts: List[ConflictPair],
+                   memories_by_id: Dict[str, Dict[str, Any]]) -> List[DecayAction]:
+        """基于冲突结果生成衰减动作。未 resolve 的双方，老的那条减去 auto_decay_old，并打上 conflict 标签。"""
+        actions: Dict[str, DecayAction] = {}
+
+        def _get(mid: str) -> Dict[str, Any]:
+            return memories_by_id.get(mid, {"id": mid, "created_at": None})
+
+        for c in conflicts:
+            a, b = c.memory_id_a, c.memory_id_b
+            if c.resolution == "unresolved":
+                # 谁老谁减
+                ca_time = _get(a).get("created_at") or 0
+                cb_time = _get(b).get("created_at") or 0
+                if ca_time and cb_time:
+                    older = a if ca_time < cb_time else b
+                else:
+                    older = a if len(a) < len(b) else b
+                self._merge_action(actions, older, -self.auto_decay_old, ["conflict"],
+                                   reason=f"与{('b' if older==a else 'a')}冲突类型={c.conflict_type}")
+            elif c.resolution == "a_wins":
+                self._merge_action(actions, a, +self.auto_boost_winner, [], reason=f"冲突胜出: {c.conflict_type}")
+                self._merge_action(actions, b, -self.auto_decay_loser, ["conflict-deprecated"],
+                                   reason=f"冲突失败: {c.conflict_type}")
+            elif c.resolution == "b_wins":
+                self._merge_action(actions, b, +self.auto_boost_winner, [], reason=f"冲突胜出: {c.conflict_type}")
+                self._merge_action(actions, a, -self.auto_decay_loser, ["conflict-deprecated"],
+                                   reason=f"冲突失败: {c.conflict_type}")
+            elif c.resolution == "both_deprecated":
+                self._merge_action(actions, a, -self.auto_decay_loser, ["conflict-deprecated"],
+                                   reason=f"双方均弃用: {c.conflict_type}")
+                self._merge_action(actions, b, -self.auto_decay_loser, ["conflict-deprecated"],
+                                   reason=f"双方均弃用: {c.conflict_type}")
+        return list(actions.values())
+
+    @staticmethod
+    def _merge_action(bucket: Dict[str, DecayAction], mid: str,
+                      delta: float, tags: List[str], reason: str):
+        if mid not in bucket:
+            bucket[mid] = DecayAction(memory_id=mid, delta_importance=0.0, added_tags=[], reason="")
+        a = bucket[mid]
+        a.delta_importance += delta
+        for t in tags:
+            if t not in a.added_tags:
+                a.added_tags.append(t)
+        if a.reason:
+            a.reason += " | " + reason
+        else:
+            a.reason = reason
+
+
+__all__ = ["ConflictDetector", "ConflictPair", "DecayAction", "ANTONYM_PAIRS"]