路径处理全靠 utils.py 三个纯函数（memory/utils.py:8）：

# memory/utils.py:8
def sanitize_scope_name(name: str) -> str:
    """把 crew名/agent角色 洗成安全的路径片段。"""
    if not name: return "unknown"
    name = name.lower().strip()
    name = re.sub(r"[^a-z0-9_-]", "-", name)   # 非字母数字下划线连字符 → 连字符
    name = re.sub(r"-+", "-", name)            # 连续连字符压成一个
    name = name.strip("-")
    return name or "unknown"

# memory/utils.py:39
def normalize_scope_path(path: str) -> str:
    if not path or path == "/": return "/"
    path = re.sub(r"/+", "/", path)            # 多个斜杠压成一个 //→/
    if not path.startswith("/"): path = "/" + path   # 保证前导斜杠
    if len(path) > 1: path = path.rstrip("/")  # 去尾部斜杠
    return path

# memory/utils.py:67
def join_scope_paths(root: str | None, inner: str | None) -> str:
    root = root.rstrip("/") if root else ""
    inner = inner.strip("/") if inner else ""
    if root and inner:  result = f"{root}/{inner}"
    elif root:          result = root
    elif inner:         result = f"/{inner}"
    else:               result = "/"
    return normalize_scope_path(result)

MemoryScope（memory_scope.py:38）是一个"薄视图"，持有底层 Memory + 一个根路径：

# memory_scope.py:38（节选）
class MemoryScope(BaseModel):
    memory_kind: Literal["scope"] = "scope"      # 判别器（D06 用于反序列化）
    root_path: str = Field(default="/")
    _memory: Memory | None = PrivateAttr(default=None)   # 底层真 Memory（不序列化）
    _root: str = PrivateAttr(default="")

    @model_validator(mode="wrap")
    @classmethod
    def _accept_memory(cls, data, handler) -> MemoryScope:
        if isinstance(data, MemoryScope): return data
        memory = data.pop("memory", None)        # ★从入参里抽出 memory 依赖
        instance = handler(data)                 # 正常校验剩下的字段
        if memory is not None: instance._memory = memory
        root = instance.root_path.rstrip("/") or ""
        if root and not root.startswith("/"): root = "/" + root
        instance._root = root                    # 规整后的根
        return instance

    def _scope_path(self, scope: str | None) -> str:   # ★核心：把相对 scope 拼成绝对
        if not scope or scope == "/": return self._root or "/"
        s = scope.rstrip("/")
        if not s.startswith("/"): s = "/" + s
        if not self._root: return s
        return f"{self._root.rstrip('/')}{s}"

视图的每个方法都先过 _scope_path 拼前缀再转发给底层（memory_scope.py:102）：

# memory_scope.py:102 / 148 / 217（节选）
def remember(self, content, scope="/", ...) -> MemoryRecord | None:
    path = self._scope_path(scope)                 # 相对 → 绝对
    return self._require_memory().remember(content, scope=path, ...)

def recall(self, query, scope=None, ..., depth="deep", ...) -> list[MemoryMatch]:
    search_scope = self._scope_path(scope) if scope else (self._root or "/")
    return self._require_memory().recall(query, scope=search_scope, ...)

def subscope(self, path: str) -> MemoryScope:      # ★往下再钻一层
    child = path.strip("/")
    if not child:
        return MemoryScope(memory=self._memory, root_path=self._root or "/")
    base = self._root.rstrip("/") or ""
    new_root = f"{base}/{child}" if base else f"/{child}"
    return MemoryScope(memory=self._memory, root_path=new_root)

有时你要"同时看几个不相邻的 scope"——这是 MemorySlice（memory_scope.py:227）：

# memory_scope.py:227 / 292（节选）
class MemorySlice(BaseModel):
    memory_kind: Literal["slice"] = "slice"
    scopes: list[str] = Field(default_factory=list)   # 要合看的多个路径
    categories: list[str] | None = Field(default=None)
    read_only: bool = Field(default=True)             # ★默认只读！

    def recall(self, query, ..., limit=10, ...) -> list[MemoryMatch]:
        cats = categories or self.categories
        all_matches = []
        for sc in self.scopes:                        # ★逐个 scope 检索
            matches = self._require_memory().recall(
                query, scope=sc, categories=cats,
                limit=limit * _RECALL_OVERSAMPLE_FACTOR, ...)   # 每个多取一些
            all_matches.extend(matches)
        seen_ids, unique = set(), []
        for m in sorted(all_matches, key=lambda x: x.score, reverse=True):  # 全局按分排
            if m.record.id not in seen_ids:
                seen_ids.add(m.record.id)
                unique.append(m)
                if len(unique) >= limit: break        # 截断到 limit
        return unique

视图能被存进检查点（Flow 持久化），但底层 Memory 存不了——所以要 bind 重连（memory_scope.py:68）：

# memory_scope.py:68
def bind(self, memory: Memory) -> Self:
    """Rebind the runtime Memory dependency after restore.
    Required after deserializing from a checkpoint, since the live Memory
    cannot be serialized."""
    self._memory = memory
    return self

# memory_scope.py:20 —— 老配置兼容：给缺判别器的旧字典补 memory_kind
def _ensure_memory_kind(value: Any) -> Any:
    if isinstance(value, dict) and "memory_kind" not in value:
        if "scopes" in value:      value["memory_kind"] = "slice"   # 有 scopes → slice
        elif "root_path" in value: value["memory_kind"] = "scope"   # 有 root_path → scope
        else:                      value["memory_kind"] = "memory"
    return value

视图是"外挂"的前缀；而 Memory 自己也有个 root_scope，在每个方法里统一处理（unified_memory.py:715）：

# unified_memory.py:715（recall 里的 scope 计算，forget/list_* 同款模式）
effective_scope = scope
if effective_scope is None and self.root_scope:
    effective_scope = self.root_scope                          # 没传 → 用根
elif effective_scope is not None and self.root_scope:
    effective_scope = join_scope_paths(self.root_scope, effective_scope)  # 传了 → 拼在根下
# ... 之后所有搜索/删除都用 effective_scope 当前缀