回顾 Day 19 的字段声明（crew.py:225）与它的前置处理器（memory/memory_scope.py:20）：

# crew.py:225
memory: Annotated[
    bool | Annotated[Memory | MemoryScope | MemorySlice, Field(discriminator="memory_kind")] | None,
    BeforeValidator(_ensure_memory_kind),
] = Field(default=False, description="Enable crew memory. Pass True for default Memory(), "
          "or a Memory/MemoryScope/MemorySlice instance for custom configuration.")

# memory/memory_scope.py:20  兼容老配置：给旧 dict 补上 memory_kind
def _ensure_memory_kind(value: Any) -> Any:
    """Backfill ``memory_kind`` on legacy dicts that predate the discriminator.
    Inference: ``scopes`` key → ``slice``; ``root_path`` → ``scope``; else ``memory``."""
    if isinstance(value, dict) and "memory_kind" not in value:
        if "scopes" in value:      value["memory_kind"] = "slice"
        elif "root_path" in value: value["memory_kind"] = "scope"
        else:                       value["memory_kind"] = "memory"
    return value                    # 非 dict（实例/bool/None）原样放行

核心校验器（crew.py:627）：

# crew.py:627
@model_validator(mode="after")
def create_crew_memory(self) -> Crew:
    """Initialize unified memory, respecting crew embedder config."""
    from crewai.memory.utils import sanitize_scope_name
    crew_name = sanitize_scope_name(self.name or "crew")
    crew_root_scope = f"/crew/{crew_name}"          # ① 命名空间（L04）

    if self.memory is True:                          # —— 传 True：自动造 ——
        from crewai.memory.unified_memory import Memory
        embedder = None
        if self.embedder is not None:                # ② 配了 embedder 就建向量化器
            from crewai.rag.embeddings.factory import build_embedder
            embedder = build_embedder(cast(dict[str, Any], self.embedder))
        memory_kwargs = {"embedder": embedder, "root_scope": crew_root_scope}
        memory_llm = self._memory_llm()              # ③ 选分析用 LLM（L05）
        if memory_llm is not None:
            memory_kwargs["llm"] = memory_llm
        self._memory = Memory(**memory_kwargs)       # ★造好挂到私有 _memory
    elif self.memory:                                # —— 传了实例：尊重用户配置 ——
        # 不自动设 root_scope，用户自己的配置说了算
        self._memory = self.memory
    else:                                            # —— False/None：关闭 ——
        self._memory = None
    return self

命名空间由 crew 名清洗而来（memory/utils.py:8）：

# memory/utils.py:8
def sanitize_scope_name(name: str) -> str:
    """Sanitize a name for use in hierarchical scope paths.
    Converts to lowercase, replaces non-alphanumeric chars (except underscore
    and hyphen) with hyphens, collapses multiple hyphens, strips leading/trailing
    hyphens. ... Returns 'unknown' if the result would be empty."""
    ...

# 回到 crew.py:634 —— 拼成层级路径
crew_name = sanitize_scope_name(self.name or "crew")   # "研究 Crew!" → "研究-crew"
crew_root_scope = f"/crew/{crew_name}"                   # → "/crew/研究-crew"

记忆也要用 LLM（做摘要/分析），没配就兜底（crew.py:664）：

# crew.py:664
def _memory_llm(self) -> str | BaseLLM | None:
    """Return the LLM auto-created memory should use for analysis."""
    if self.chat_llm is not None:
        return self.chat_llm                     # ① 优先用 chat_llm
    for agent in self.agents:
        agent_llm = getattr(agent, "llm", None)
        if agent_llm is not None:
            return agent_llm                     # ② 否则借第一个 agent 的 llm
    return None                                  # ③ 都没有 → None（记忆用它自己的默认）

恢复检查点时的重绑逻辑，暴露了两者的分工（crew.py:514）：

# crew.py:514
def _rebind_memory_views(self) -> None:
    """Reattach a live ``Memory`` to restored ``MemoryScope``/``MemorySlice`` views.
    ... Prefer the crew's restored ``Memory`` (from ``create_crew_memory``
    or a ``Crew.memory=Memory(...)`` instance) so all views share one
    backing store; fall back to a fresh ``Memory()`` only if nothing available."""
    backing: Memory | None = None
    if isinstance(self._memory, Memory):        # 优先私有 _memory（自动造的）
        backing = self._memory
    elif isinstance(self.memory, Memory):        # 其次公开 memory（用户传的实例）
        backing = self.memory
    def _ensure(view):
        ...
        if backing is None:
            backing = Memory()                   # 兜底：新建一个
        view.bind(backing)                       # ★让 scope/slice 视图绑到同一个底层 Memory
    _ensure(self.memory)
    for agent in self.agents:
        _ensure(agent.memory)                    # 每个 agent 的记忆视图也绑到同一底层

回顾 Day 22 的 _drain_memory_writes（crew.py:1848），从"配置层"再看一遍它收集了谁：

# crew.py:1848
def _drain_memory_writes(self) -> None:
    """Block until all pending background memory saves have completed."""
    seen = set()
    candidates = [self._memory, self.memory,                     # crew 自己的（真身+意图）
                  getattr(self.manager_agent, "memory", None),   # 经理的
                  *(getattr(agent, "memory", None) for agent in self.agents)]  # 每个 agent 的
    for mem in candidates:
        if mem is None or isinstance(mem, bool):
            continue                          # None / bool 跳过（bool 是"意图"不是真身）
        backing = getattr(mem, "_memory", None) or mem   # 视图→取其底层 Memory
        if id(backing) in seen:
            continue                          # 同一底层只 drain 一次
        seen.add(id(backing))
        drain = getattr(backing, "drain_writes", None)
        if callable(drain):
            drain()                           # ★阻塞等后台写入落盘