Version: 0.9.21.dev.260416

后端：
1. Memory 写入链路新增"召回→比对→汇总"去重决策层
- 新增决策流程：Runner 根据decision.enabled 配置走决策路径（语义召回候选 → Hash 精确命中 → LLM 逐对比对 → 汇总决策 → 执行 ADD/UPDATE/DELETE/NONE），默认关闭，旧路径完全保留
- 新增 LLMDecisionOrchestrator：单对关系判断编排器，输出 duplicate/update/conflict/unrelated 四种关系
- 新增 decision_flow / apply_actions：决策流程主循环与动作落地（新增、更新内容、软删除、跳过）
- 新增 aggregate_decision / decision_validate：汇总规则（按优先级判定动作）与 LLM 输出校验
- 新增 decision model：CandidateSnapshot / ComparisonResult / FinalDecision 等决策层核心类型
- ItemRepo 新增 FindActiveByHash / UpdateContentByID / SoftDeleteByID 三个决策层专用方法
- RAG Runtime / Pipeline / Service 新增 DeleteMemory 向量删除能力，MilvusStore 补充 duplicate collection 错误识别
- Runner 新增 syncVectorDeletes 处理决策层 DELETE 动作的向量清理
- config 新增 decision（enabled/candidateTopK/candidateMinScore/fallbackMode）和 write.mode 配置项，config_loader 增加默认值兜底
- 删除 HANDOFF-RAG复用后续实施计划.md 和旧 log.txt，新增 Log.txt 记录决策流程调试日志
- normalize_facts 导出 HashContent 供决策层复用，audit 新增 update 操作常量

前端：无 仓库：无

backend/memory/utils/aggregate_decision.go

@@ -0,0 +1,115 @@
+package utils
+
+import (
+	"fmt"
+
+	memorymodel "github.com/LoveLosita/smartflow/backend/memory/model"
+)
+
+// AggregateComparisons 把一轮 LLM 比对结果汇总为最终动作。
+//
+// 职责边界：
+// 1. 纯确定性逻辑，不调 LLM，不调外部服务；
+// 2. 按优先级从高到低判定：duplicate > update > conflict > unrelated；
+// 3. 多条 update 时选 Score 最高的候选执行 UPDATE。
+//
+// 汇总规则：
+// 1. 出现 duplicate → 最终动作 NONE（新 fact 完全重复，不需要写入）；
+// 2. 出现 update → 最终动作 UPDATE（更新 Score 最高的那条旧记忆）；
+// 3. 出现 conflict → 最终动作 DELETE + 后续按 ADD 处理（旧记忆过时，先删旧的再写新的）；
+// 4. 全部 unrelated → 最终动作 ADD（没有相关旧记忆，直接新增）。
+func AggregateComparisons(
+	fact memorymodel.NormalizedFact,
+	comparisons []memorymodel.ComparisonResult,
+	candidates []memorymodel.CandidateSnapshot,
+) *memorymodel.FinalDecision {
+	// 1. 无候选时直接 ADD，无需走任何判断。
+	if len(comparisons) == 0 {
+		return &memorymodel.FinalDecision{
+			Action: memorymodel.DecisionActionAdd,
+			Reason: "无相关旧记忆，直接新增",
+		}
+	}
+
+	// 2. 建立 memoryID → CandidateSnapshot 映射，用于查找 Score。
+	snapshotMap := make(map[int64]memorymodel.CandidateSnapshot, len(candidates))
+	for _, c := range candidates {
+		snapshotMap[c.MemoryID] = c
+	}
+
+	hasDuplicate := false
+	var bestUpdate *memorymodel.ComparisonResult
+	bestUpdateScore := -1.0
+	var conflictResult *memorymodel.ComparisonResult
+
+	for i := range comparisons {
+		comp := &comparisons[i]
+
+		switch comp.Relation {
+		case memorymodel.RelationDuplicate:
+			// 3. 出现一条 duplicate 即可确定最终动作为 NONE。
+			hasDuplicate = true
+
+		case memorymodel.RelationUpdate:
+			// 4. 多条 update 时，选 Score 最高的那条执行 UPDATE。
+			snapshot, ok := snapshotMap[comp.MemoryID]
+			score := 0.0
+			if ok {
+				score = snapshot.Score
+			}
+			if score > bestUpdateScore {
+				bestUpdateScore = score
+				bestUpdate = comp
+			}
+
+		case memorymodel.RelationConflict:
+			// 5. 记录第一条 conflict，用于后续 DELETE + ADD 处理。
+			if conflictResult == nil {
+				conflictResult = comp
+			}
+		}
+	}
+
+	// 6. 按优先级判定最终动作。
+	if hasDuplicate {
+		return &memorymodel.FinalDecision{
+			Action: memorymodel.DecisionActionNone,
+			Reason: "存在完全重复的旧记忆，跳过写入",
+		}
+	}
+
+	if bestUpdate != nil {
+		// 7. UPDATE 动作：使用 LLM 提供的合并后内容。
+		title := bestUpdate.UpdatedTitle
+		if title == "" {
+			title = fact.Title
+		}
+		content := bestUpdate.UpdatedContent
+		reason := bestUpdate.Reason
+		if reason == "" {
+			reason = "新事实是对旧记忆的修正或补充"
+		}
+		return &memorymodel.FinalDecision{
+			Action:   memorymodel.DecisionActionUpdate,
+			TargetID: bestUpdate.MemoryID,
+			Title:    title,
+			Content:  content,
+			Reason:   fmt.Sprintf("更新旧记忆(id=%d): %s", bestUpdate.MemoryID, reason),
+		}
+	}
+
+	if conflictResult != nil {
+		// 8. conflict → 先 DELETE 旧记忆，后续由上层按 ADD 写入新 fact。
+		return &memorymodel.FinalDecision{
+			Action:   memorymodel.DecisionActionDelete,
+			TargetID: conflictResult.MemoryID,
+			Reason:   fmt.Sprintf("旧记忆(id=%d)与新事实冲突，删除后新增: %s", conflictResult.MemoryID, conflictResult.Reason),
+		}
+	}
+
+	// 9. 全部 unrelated → 直接 ADD。
+	return &memorymodel.FinalDecision{
+		Action: memorymodel.DecisionActionAdd,
+		Reason: "无相关旧记忆，直接新增",
+	}
+}