回看 MemoryRecord（types.py:20），三种记忆的"料"全在一条里：

# types.py:20（挑出与三种记忆相关的字段）
class MemoryRecord(BaseModel):
    content: str                                  # 记忆正文
    importance: float = Field(default=0.5, ...)   # ★长期性：越高越该长期留存/优先召回
    created_at: datetime = Field(default_factory=datetime.utcnow)  # ★短期性：越新越"短期"
    last_accessed: datetime = ...                 # 最近被翻到的时间
    categories: list[str] = Field(default_factory=list)   # ★实体性：主题/类目标签
    metadata: dict[str, Any] = Field(default_factory=dict)  # ★实体性：entities/dates/topics 落在这

"短期"的本质是"越近的越该先看、越久越淡"。这正是复合评分里的 decay（types.py:364）：

# types.py:364（复合评分的新鲜度部分）
age_seconds = (datetime.utcnow() - record.created_at).total_seconds()
age_days = max(age_seconds / 86400.0, 0.0)
decay = 0.5 ** (age_days / config.recency_half_life_days)   # 半衰期默认 30 天
composite = (config.semantic_weight * semantic_score
             + config.recency_weight * decay             # ★新鲜度贡献
             + config.importance_weight * record.importance)

"长期"要解决两件事：重要的东西不因时间沉底、以及持久落盘不丢。前者靠 importance 权重顶住 decay，后者靠合并（consolidation）防止越攒越乱。合并计划的数据结构（analyze.py:124）：

# analyze.py:103
class ConsolidationAction(BaseModel):
    action: str = Field(description="One of 'keep', 'update', or 'delete'.")
    record_id: str = Field(...)
    new_content: str | None = Field(default=None)   # update 时的新内容
    reason: str = Field(default="")

# analyze.py:124
class ConsolidationPlan(BaseModel):
    actions: list[ConsolidationAction] = Field(default_factory=list)  # 对旧记录的动作
    insert_new: bool = Field(default=True)                            # 要不要同时存新的
    insert_reason: str = Field(default="")

实体记忆的载体是 ExtractedMetadata（analyze.py:18），存记忆时由 LLM 填充：

# analyze.py:18
class ExtractedMetadata(BaseModel):
    model_config = ConfigDict(extra="forbid")     # OpenAI 要求 additionalProperties:false
    entities: list[str] = Field(default_factory=list,
        description="Entities (people, orgs, places) mentioned in the content.")
    dates: list[str] = Field(default_factory=list,
        description="Dates or time references in the content.")
    topics: list[str] = Field(default_factory=list,
        description="Topics or themes in the content.")

# analyze.py:37
class MemoryAnalysis(BaseModel):
    suggested_scope: str                           # 建议归到哪个 scope
    categories: list[str] = Field(default_factory=list)   # 类目标签
    importance: float = Field(default=0.5, ge=0.0, le=1.0)
    extracted_metadata: ExtractedMetadata = Field(default_factory=ExtractedMetadata)  # ★实体

analyze_for_consolidation（analyze.py:321）是长期记忆保持整洁的关键：

# analyze.py:321（节选）
def analyze_for_consolidation(new_content, existing_records, llm) -> ConsolidationPlan:
    if not existing_records:
        return ConsolidationPlan(actions=[], insert_new=True)   # 没相似的→直接存
    records_lines = []
    for r in existing_records:
        created = r.created_at.isoformat() if r.created_at else ""
        records_lines.append(
            f"- id={r.id} | scope={r.scope} | importance={r.importance:.2f} | created={created}\n"
            f"  content: {r.content[:200]}...")
    user = _get_prompt("consolidation_user").format(
        new_content=new_content, records_summary="\n\n".join(records_lines))
    messages = [{"role": "system", "content": _get_prompt("consolidation_system")},
                {"role": "user", "content": user}]
    ...  # 让 LLM 输出 ConsolidationPlan（结构化）
    except Exception:
        return _CONSOLIDATION_DEFAULT      # 失败→安全默认：insert_new=True，不丢

用户其实很少直接 new Memory——通常是 Crew(memory=True)，crew 自动装配（crew.py:627）：

# crew.py:627（节选）
def create_crew_memory(self) -> Crew:
    from crewai.memory.utils import sanitize_scope_name
    crew_name = sanitize_scope_name(self.name or "crew")
    crew_root_scope = f"/crew/{crew_name}"          # ★每个 crew 一个命名空间

    if self.memory is True:
        from crewai.memory.unified_memory import Memory
        embedder = None
        if self.embedder is not None:
            embedder = build_embedder(cast(dict, self.embedder))
        memory_kwargs = {"embedder": embedder, "root_scope": crew_root_scope}
        memory_llm = self._memory_llm()             # 复用 chat_llm 或某个 agent 的 llm
        if memory_llm is not None:
            memory_kwargs["llm"] = memory_llm
        self._memory = Memory(**memory_kwargs)
    elif self.memory:                               # 用户传了 Memory/Scope/Slice 实例
        self._memory = self.memory                  # 尊重用户配置，不强塞 root_scope
    else:
        self._memory = None
    return self