feat:客户agent以及记忆模块优化

service/client_agent/runtime.py

@@ -140,13 +140,9 @@ class MemoryAwareClientAgent:
 
         for index, candidate in enumerate(candidates):
             try:
+                evidence_count = 1
                 if candidate.get("signal_type") == "interest_query":
-                    count, reached = await self.memory_service.record_interest_signal(
-                        customer_id=customer_id,
-                        tag=candidate["tag"],
-                    )
-                    if not reached:
-                        continue
+                    # 兴趣主题首次出现即保存为候选，后续由长期记忆按精确内容合并证据。
                     candidate["memory_type"] = "CUSTOMER_PREFERENCE"
                     candidate["source"] = "dialogue_inferred"
                 memory = MemoryUnitDTO(
@@ -157,6 +153,7 @@ class MemoryAwareClientAgent:
                     content=candidate["content"],
                     source=candidate["source"],
                     evidence_ref=[{"session_id": session_id, "query": query}],
+                    evidence_count=evidence_count,
                 )
                 _, save_warnings = await self.memory_service.save_memory(
                     customer_id=customer_id,

service/memory/facade.py

@@ -70,6 +70,14 @@ class MemoryService:
         warnings.extend(self.short_term.last_warnings)
 
         async with self._db() as db:
+            try:
+                refresh_confidence = getattr(self.long_term, "refresh_confidence", None)
+                if refresh_confidence is not None:
+                    await refresh_confidence(
+                        db, customer_id, limit=max(limit, 10)
+                    )
+            except Exception as exc:
+                warnings.append(f"confidence_refresh_failed:{type(exc).__name__}")
             profile, profile_warnings = await self.profile.get(db, customer_id)
             warnings.extend(profile_warnings)
             try:

service/memory/long_term.py

@@ -39,11 +39,16 @@ class LongTermMemoryService:
             memory.customer_id,
             memory.memory_type.value,
             memory.tag,
-            memory.content,
         )
         warnings: list[str] = []
         if existing is not None:
-            existing = await repo.merge_evidence(existing)
+            existing = await repo.merge_evidence(
+                existing,
+                content=memory.content,
+                source=memory.source.value,
+                evidence_count=max(memory.evidence_count or 1, 1),
+                evidence_ref=memory.evidence_ref,
+            )
             entity = existing
         else:
             # final_score 是召回重排阶段的临时分数，不属于 MySQL 主体字段。
@@ -51,6 +56,9 @@ class LongTermMemoryService:
                 mode="json",
                 exclude={"id", "milvus_id", "graph_node_id", "final_score"},
             )
+            now = datetime.now()
+            values["last_verified_at"] = values.get("last_verified_at") or now
+            values["update_time"] = values.get("update_time") or now
             values["memory_type"] = memory.memory_type.value
             values["source"] = memory.source.value
             confidence_result, confidence_warning = self._calculate_confidence(memory)
@@ -116,7 +124,6 @@ class LongTermMemoryService:
                 tag=memory.tag,
                 source=source,
                 evidence_count=memory.evidence_count or 0,
-                conflict_count=memory.conflict_count or 0,
                 age_days=age_days,
                 memory_type=memory_type,
             )
@@ -147,6 +154,19 @@ class LongTermMemoryService:
         )
         return [self._to_dto(entity) for entity in entities], []
 
+    async def refresh_confidence(
+        self, db, customer_id: int, *, limit: int = 500
+    ) -> int:
+        """按当前时间刷新有效记忆的置信度并持久化结果。"""
+        repo = self.repository_factory(db)
+        entities = await repo.list_for_confidence_refresh(customer_id, limit=limit)
+        refreshed = 0
+        for entity in entities:
+            confidence_result, _ = self._calculate_confidence(entity)
+            await repo.update_confidence(entity.id, **confidence_result)
+            refreshed += 1
+        return refreshed
+
     async def retry_pending(self, db, *, limit: int = 100) -> dict[str, int]:
         """重试 MySQL 中缺少外部索引或同步失败的记忆。"""
         entities = await self.repository_factory(db).list_pending_sync(limit)
@@ -182,7 +202,6 @@ class LongTermMemoryService:
             "confidence_reason": getattr(entity, "confidence_reason", None),
             "confidence_update_time": getattr(entity, "confidence_update_time", None),
             "evidence_count": entity.evidence_count or 0,
-            "conflict_count": entity.conflict_count or 0,
             "recall_count": entity.recall_count or 0,
             "status": entity.status,
             "valid_from": entity.valid_from,

service/memory/schemas.py

@@ -80,7 +80,6 @@ class MemoryUnitDTO(BaseModel):
     confidence_update_time: datetime | None = None
     final_score: float | None = Field(default=None, ge=0.0, le=1.0)
     evidence_count: int = Field(default=0, ge=0)
-    conflict_count: int = Field(default=0, ge=0)
     recall_count: int = Field(default=0, ge=0)
     status: MemoryStatus = MemoryStatus.CANDIDATE
     valid_from: datetime | None = None