memleaf 0.2.8__tar.gz → 0.2.10__tar.gz

{memleaf-0.2.8 → memleaf-0.2.10}/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 All notable changes to memleaf are documented here.
 
+## 0.2.10 — 2026-09-01
+
+- Keep strict candidate-local project Scope grounding for the first two gate
+  attempts, then isolate a persistently invalid candidate instead of failing
+  the entire mailbox turn.
+- Correct a final-attempt model Scope only when the candidate text identifies
+  exactly one registered project name or alias; defer zero-match and
+  multi-project candidates as insufficient context without writing memory.
+- Preserve valid sibling candidates, new explicitly named project Scopes, and
+  the existing update-target relevance guard when Scope and target errors occur
+  together.
+
+## 0.2.9 — 2026-09-01
+
+- Reject update and duplicate targets that are relevant only to another item
+  in the same aggregate turn, preventing cross-project memory overwrites.
+- Retry an unrelated gate target with an explicit correction, then recover
+  deterministically after the bounded final attempt: preserve unrelated
+  updates as independent candidates and discard unsafe duplicate claims.
+- Query related memories from each candidate's own complete topic instead of
+  the whole mailbox turn, while allowing the remaining valid candidates to be
+  processed without holding the retained inbox turn hostage.
+
 ## 0.2.8 — 2026-09-01
 
 - Let the automatic summarizer independently reject an over-admitted gate

{memleaf-0.2.8/src/memleaf.egg-info → memleaf-0.2.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 0.2.8
+Version: 0.2.10
 Summary: A local-first Markdown memory core for AI agents
 Author: memleaf contributors
 License-Expression: MIT
@@ -23,8 +23,8 @@ Dynamic: license-file
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **当前版本：0.2.8。**
-> 核心库、Vault、stdio MCP Server、初始化 CLI、模型路由、提炼流程、受控检索协议和宿主适配器已经实现。memleaf 0.2.8 通过 PyPI 分发。
+> **当前版本：0.2.10。**
+> 核心库、Vault、stdio MCP Server、初始化 CLI、模型路由、提炼流程、受控检索协议和宿主适配器已经实现。memleaf 0.2.10 通过 PyPI 分发。
 > **当前版本支持 Hermes 和 Codex。** Antigravity（反重力）不检测、不安装、不配置。
 
 ## 项目定位

{memleaf-0.2.8 → memleaf-0.2.10}/README.en.md

@@ -4,8 +4,8 @@
 
 [中文](README.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **Version: 0.2.4.**
-> The core library, Vault, stdio MCP server, initialization CLI, model routing, memory extraction, controlled retrieval protocol, and host adapters are implemented. memleaf 0.2.4 is distributed through PyPI.
+> **Version: 0.2.10.**
+> The core library, Vault, stdio MCP server, initialization CLI, model routing, memory extraction, controlled retrieval protocol, and host adapters are implemented. memleaf 0.2.10 is distributed through PyPI.
 > **The current release supports Hermes and Codex.** Antigravity is not detected, installed, or configured.
 
 ## Project scope

{memleaf-0.2.8 → memleaf-0.2.10}/README.md

@@ -4,8 +4,8 @@
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **当前版本：0.2.8。**
-> 核心库、Vault、stdio MCP Server、初始化 CLI、模型路由、提炼流程、受控检索协议和宿主适配器已经实现。memleaf 0.2.8 通过 PyPI 分发。
+> **当前版本：0.2.10。**
+> 核心库、Vault、stdio MCP Server、初始化 CLI、模型路由、提炼流程、受控检索协议和宿主适配器已经实现。memleaf 0.2.10 通过 PyPI 分发。
 > **当前版本支持 Hermes 和 Codex。** Antigravity（反重力）不检测、不安装、不配置。
 
 ## 项目定位

{memleaf-0.2.8 → memleaf-0.2.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "memleaf"
-version = "0.2.8"
+version = "0.2.10"
 description = "A local-first Markdown memory core for AI agents"
 readme = "README.md"
 requires-python = ">=3.11"

{memleaf-0.2.8 → memleaf-0.2.10}/src/memleaf/__init__.py

@@ -1,6 +1,6 @@
 """Local-first Markdown memory core for AI agents."""
 
-__version__ = "0.2.8"
+__version__ = "0.2.10"
 
 from .config import DEFAULT_CONFIG, default_config, load_config, save_config
 from .frontmatter import FrontmatterError, dump_frontmatter, dump_yaml, load_yaml, parse_frontmatter

{memleaf-0.2.8 → memleaf-0.2.10}/src/memleaf/hermes_provider/__init__.py

@@ -78,6 +78,7 @@ _MODEL_VALIDATION_DETAILS = frozenset(
         "duplicate_update_target",
         "mixed_project_scopes",
         "update_target_type_mismatch",
+        "target_not_relevant",
         "scope_not_grounded",
         "scope_drift",
         "invalid_evidence",

{memleaf-0.2.8 → memleaf-0.2.10}/src/memleaf/hermes_provider/plugin.yaml

@@ -1,5 +1,5 @@
 name: memleaf
-version: 0.2.8
+version: 0.2.10
 description: "Hermes-native external MemoryProvider for local-first Markdown memory shared with the memleaf MCP server."
 hooks:
   - prefetch

{memleaf-0.2.8 → memleaf-0.2.10}/src/memleaf/processing.py

@@ -42,18 +42,24 @@ from .prompts import (
     SUMMARY_TARGET_CORRECTION,
     SUMMARY_TYPE_CORRECTION,
     SUMMARIZE_SYSTEM,
+    TARGET_RELEVANCE_CORRECTION,
     UPDATE_TARGET_TYPE_CORRECTION,
     gate_prompt,
     summarize_prompt,
 )
 from .redaction import redact_text
 from .retrieval import candidate_matches_query, filter_by_scope, normalize_term
-from .scope_state import ScopeError, normalize_scopes, register_scope_nodes
+from .scope_state import (
+    ScopeError,
+    normalize_scopes,
+    register_scope_nodes,
+)
 from .scope_maintenance import ScopeMaintainer, ScopeMaintenanceError, scope_registry_projection
 from .validation import (
     MODEL_VALIDATION_DETAILS,
     ModelOutputError,
     NO_CHANGE_DECISION,
+    _model_scope_grounding_evidence,
     parse_gate_output,
     parse_summarize_output,
 )
@@ -493,6 +499,8 @@ class Processor:
             return GATE_TYPE_CORRECTION
         if stage == "gate" and hint == "scope_not_grounded":
             return SCOPE_GROUNDING_CORRECTION
+        if stage == "gate" and hint == "target_not_relevant":
+            return TARGET_RELEVANCE_CORRECTION
         if stage == "summarize" and hint == "scope_drift":
             return SUMMARY_SCOPE_CORRECTION
         if hint == "relative_time":
@@ -1419,6 +1427,157 @@ class Processor:
             strict_relevance=True,
         )
 
+    def _target_is_relevant_to_candidate(
+        self,
+        turn: InboxTurn,
+        candidate: Mapping[str, Any],
+        *,
+        scope_directory: Optional[list[dict[str, Any]]] = None,
+        scope_directory_complete: bool = True,
+    ) -> bool:
+        """Check a model-selected target against the candidate topic only.
+
+        The ordinary related-memory prompt may include several independent
+        items from one mailbox turn.  Target selection must not inherit that
+        aggregate relevance: only the candidate's own extracted topic may
+        make an active target eligible.  A complete scope directory remains a
+        bounded escape hatch for an explicitly indirect user/session scope;
+        it never turns the target into an unconditional priority hit for a
+        direct model-attributed candidate.
+        """
+
+        target = next(
+            (
+                candidate.get(field)
+                for field in ("duplicate_memory_id", "update_memory_id")
+                if isinstance(candidate.get(field), str) and candidate.get(field)
+            ),
+            None,
+        )
+        memory = candidate.get("memory")
+        candidate_scopes = candidate.get("scopes")
+        if (
+            not isinstance(target, str)
+            or not isinstance(memory, str)
+            or not isinstance(candidate_scopes, list)
+        ):
+            return False
+
+        target_key = target.casefold()
+        candidate_scope_source = candidate.get("scope_source")
+
+        # A complete bounded directory is the existing indirect resolution
+        # path.  It contains only active IDs from the requested inherited
+        # scope, so preserve its exact-ID selection semantics rather than
+        # forcing a body relevance check that the directory intentionally
+        # cannot provide.
+        if scope_directory is not None:
+            if not scope_directory_complete:
+                return False
+            selected = next(
+                (
+                    item
+                    for item in scope_directory
+                    if isinstance(item, Mapping)
+                    and isinstance(item.get("memory_id"), str)
+                    and item["memory_id"].casefold() == target_key
+                ),
+                None,
+            )
+            if selected is not None and selected.get("type") == candidate.get("type"):
+                return True
+
+        # Model-attributed, directly named scopes must match the active
+        # target's stable topic title.  Matching the whole old body is too
+        # permissive: two different project memories can share implementation
+        # details such as milestones while serving different future uses.
+        if candidate_scope_source == "model":
+            scope_terms: list[str] = []
+            try:
+                scope_config = self.service.vault.config()
+                configured_scopes = scope_config.get("scopes", {})
+            except (OSError, UnicodeError, ValueError, TypeError):
+                scope_config = {}
+                configured_scopes = {}
+            for candidate_scope in candidate_scopes:
+                if not isinstance(candidate_scope, str) or not candidate_scope.startswith("project:"):
+                    continue
+                scope_terms.append(candidate_scope.partition(":")[2])
+                metadata = (
+                    configured_scopes.get(candidate_scope)
+                    if isinstance(configured_scopes, Mapping)
+                    else None
+                )
+                aliases = metadata.get("aliases") if isinstance(metadata, Mapping) else None
+                if isinstance(aliases, list):
+                    scope_terms.extend(
+                        alias for alias in aliases if isinstance(alias, str) and alias
+                    )
+
+            # The regression is project-scope drift inside aggregate turns.
+            # Global/domain/portfolio targets keep their established semantic
+            # gate behavior because there is no project identity to remove
+            # before comparing stable topics.
+            if not scope_terms:
+                return True
+
+            visible_turn = " ".join(
+                event.content for event in turn.events if isinstance(event.content, str)
+            )
+            if scope_terms and not any(
+                normalize_term(term) in normalize_term(visible_turn) for term in scope_terms
+            ):
+                # The visible turn is elliptical (for example, "this
+                # project"); the inherited scope and bounded related context
+                # already resolved its target.
+                return True
+
+            target_memory = None
+            with self.service.vault.lock():
+                for record in self.service._read_memories_unlocked("knowledge"):
+                    if record.memory.memory_id.casefold() == target_key:
+                        target_memory = record.memory
+                        break
+            if target_memory is None:
+                for item in self._planned_related:
+                    if (
+                        isinstance(item, Mapping)
+                        and isinstance(item.get("memory_id"), str)
+                        and item["memory_id"].casefold() == target_key
+                    ):
+                        try:
+                            target_memory = Memory.from_mapping(item)
+                        except (TypeError, ValueError):
+                            target_memory = None
+                        break
+            if target_memory is None:
+                return False
+            if not filter_by_scope([target_memory], candidate_scopes, scope_config):
+                return False
+
+            def without_scope_terms(value: str) -> str:
+                result = value
+                for term in sorted(set(scope_terms), key=len, reverse=True):
+                    result = re.sub(re.escape(term), "", result, flags=re.IGNORECASE)
+                return result.strip()
+
+            topic_title = without_scope_terms(target_memory.title)
+            topic_query = without_scope_terms(memory)
+            if not topic_title or not topic_query:
+                return False
+            topic_memory = Memory(
+                memory_id=target_memory.memory_id,
+                title=topic_query,
+                body="",
+                type=target_memory.type,
+                scopes=target_memory.scopes,
+            )
+            return candidate_matches_query(topic_memory, topic_title)
+
+        # User/session scopes are authoritative indirect context.  The base
+        # parser has already limited the target to an active related memory.
+        return candidate_scope_source in {"user", "session_context"}
+
     def _defer_candidate(
         self,
         turn_ref: tuple[str, str, str],
@@ -1643,6 +1802,104 @@ class Processor:
                 list(summary["scopes"]),
             )
 
+        gate_attempt_count = 0
+
+        def parse_gate(raw: str) -> dict[str, Any]:
+            nonlocal gate_attempt_count
+            gate_attempt_count += 1
+            parsed = parse_gate_output(
+                raw,
+                current_event_keys=turn.event_keys,
+                related_memory_ids=gate_related_memory_ids,
+                related_memory_types=gate_related_memory_types,
+                scope_registry=validation_scope_registry,
+                enforce_model_scope_grounding=gate_attempt_count < 3,
+            )
+            if gate_attempt_count >= 3:
+                candidates = []
+                for candidate in parsed["candidates"]:
+                    candidate_scopes = [
+                        item
+                        for item in candidate.get("scopes", [])
+                        if isinstance(item, str)
+                    ]
+                    if (
+                        candidate.get("scope_source") == "model"
+                        and candidate.get("worth") is True
+                        and any(item.partition(":")[0] == "project" for item in candidate_scopes)
+                    ):
+                        selected_owners, matches = _model_scope_grounding_evidence(
+                            str(candidate.get("memory", "")),
+                            candidate_scopes,
+                            validation_scope_registry,
+                        )
+                        candidate = dict(candidate)
+                        if not selected_owners:
+                            candidates.append(candidate)
+                            continue
+                        if len(matches) == 1:
+                            grounded_scope = next(iter(matches.values()))
+                            if grounded_scope.casefold() not in set(selected_owners.values()):
+                                non_project_scopes = [
+                                    item
+                                    for item in candidate_scopes
+                                    if item.partition(":")[0] != "project"
+                                ]
+                                if all(
+                                    item.casefold() != grounded_scope.casefold()
+                                    for item in non_project_scopes
+                                ):
+                                    non_project_scopes.append(grounded_scope)
+                                candidate["scopes"] = non_project_scopes
+                        else:
+                            candidate["scopes"] = ["unscoped"]
+                            candidate["scope_source"] = "insufficient_context"
+                    candidates.append(candidate)
+                parsed = dict(parsed)
+                parsed["candidates"] = candidates
+
+            invalid_targets: dict[str, set[str]] = {}
+            for candidate in parsed["candidates"]:
+                target_fields = {
+                    field
+                    for field in ("duplicate_memory_id", "update_memory_id")
+                    if isinstance(candidate.get(field), str) and candidate.get(field)
+                }
+                if target_fields and not self._target_is_relevant_to_candidate(
+                    turn,
+                    candidate,
+                    scope_directory=scope_directory,
+                    scope_directory_complete=scope_directory_complete,
+                ):
+                    invalid_targets[candidate["candidate_id"].casefold()] = target_fields
+
+            if invalid_targets and gate_attempt_count < 3:
+                raise ModelOutputError(
+                    "selected target is not relevant to the candidate topic",
+                    validation_detail="target_not_relevant",
+                )
+
+            if invalid_targets:
+                # A persistently non-converging model must not hold an entire
+                # inbox turn hostage.  An unrelated update target can safely
+                # become an independent CREATE candidate; an unrelated
+                # duplicate has no independent fact to write and is dropped.
+                candidates: list[dict[str, Any]] = []
+                for candidate in parsed["candidates"]:
+                    fields = invalid_targets.get(candidate["candidate_id"].casefold())
+                    if not fields:
+                        candidates.append(candidate)
+                        continue
+                    if "duplicate_memory_id" in fields:
+                        continue
+                    if "update_memory_id" in fields and candidate.get("worth"):
+                        independent = dict(candidate)
+                        independent.pop("update_memory_id", None)
+                        candidates.append(independent)
+                parsed = dict(parsed)
+                parsed["candidates"] = candidates
+            return parsed
+
         gate = self._complete_json_stage(
             backend,
             gate_prompt(
@@ -1655,13 +1912,7 @@ class Processor:
             ),
             system=GATE_SYSTEM,
             purpose="gate",
-            parser=lambda raw: parse_gate_output(
-                raw,
-                current_event_keys=turn.event_keys,
-                related_memory_ids=gate_related_memory_ids,
-                related_memory_types=gate_related_memory_types,
-                scope_registry=validation_scope_registry,
-            ),
+            parser=parse_gate,
             diagnostic_context={
                 "source": turn.source,
                 "session_id": turn.session_id,
@@ -1710,15 +1961,7 @@ class Processor:
             candidate_related, candidate_scope_background, candidate_native_refs, _ = self._related_query(
                 turn,
                 state,
-                (
-                    str(candidate.get("memory", ""))
-                    + "\n"
-                    + " ".join(
-                        event.get("content", "")
-                        for event in events
-                        if isinstance(event.get("content"), str)
-                    )
-                ).strip(),
+                str(candidate.get("memory", "")).strip(),
                 candidate_scopes,
                 overlay=self._planned_related,
                 priority_memory_ids=[

{memleaf-0.2.8 → memleaf-0.2.10}/src/memleaf/prompts.py

@@ -335,6 +335,18 @@ SUMMARY_SCOPE_CORRECTION = (
 )
 
 
+TARGET_RELEVANCE_CORRECTION = (
+    "Previous output violated: target_not_relevant. An update or duplicate "
+    "target must match the candidate's own memory topic through the supplied "
+    "active memory; do not borrow relevance from another event in the same "
+    "mailbox turn, aggregate context, or a priority ID. For a different "
+    "future use, remove the target and emit a separate atomic candidate. An "
+    "indirect same-use update may use a complete scope directory or session "
+    "context only when exactly one supplied active target is clear; otherwise "
+    "leave the target unset or defer it. Return only the strict gate JSON object."
+)
+
+
 SCOPE_GROUNDING_CORRECTION = (
     "Previous output violated: scope_not_grounded. For each worthy candidate "
     "with scope_source=model, choose a project scope named by that candidate's "

{memleaf-0.2.8 → memleaf-0.2.10}/src/memleaf/validation.py

@@ -60,6 +60,7 @@ MODEL_VALIDATION_DETAILS = frozenset(
         "duplicate_update_target",
         "mixed_project_scopes",
         "update_target_type_mismatch",
+        "target_not_relevant",
         "scope_not_grounded",
         "scope_drift",
         "invalid_evidence",
@@ -257,17 +258,16 @@ def _reject_mixed_project_scopes(scopes: Iterable[str]) -> None:
         )
 
 
-def _reject_ungrounded_project_scope(
+def _model_scope_grounding_evidence(
     memory: str,
     scopes: Iterable[str],
     scope_registry: Mapping[str, Any] | None,
-) -> None:
-    """Require model-attributed project scopes to be named by this candidate.
+) -> tuple[dict[str, str], dict[str, str]]:
+    """Return model scope ownership and memory-grounded matches.
 
-    The gate's memory text is the only candidate-local attribution evidence.
-    Session background, other events, and related-memory bodies are
-    intentionally excluded so an aggregate mailbox turn cannot lend a
-    project name to an unrelated candidate.
+    Returns a tuple of:
+      - selected project scopes -> selected owner scope (casefold)
+      - grounded project scope matches from candidate memory (casefold -> canonical)
     """
 
     selected = {
@@ -276,16 +276,14 @@ def _reject_ungrounded_project_scope(
         if isinstance(scope, str) and scope.partition(":")[0] == "project"
     }
     if not selected:
-        return
+        return {}, {}
     try:
         registry = validate_scope_registry(scope_registry or {})
     except ScopeError as error:
         raise ModelOutputError("invalid scope registry", validation_detail="invalid_scope") from error
 
-    # Resolve a selected project key through a registered canonical scope when
-    # it is an alias (including the full ``project:...`` spelling).  A merged
-    # source may remain selectable as an alias of its target; treating both as
-    # separate projects would incorrectly reject that otherwise valid update.
+    # Resolve each selected project scope to its canonical owner when it is an
+    # alias of a registered project scope.
     selected_owners: dict[str, str] = {}
     for selected_scope in selected.values():
         selected_owner = selected_scope
@@ -310,19 +308,42 @@ def _reject_ungrounded_project_scope(
         selected_owners[selected_scope.casefold()] = selected_owner.casefold()
 
     # Include unregistered selections as temporary nodes: new scopes must be
-    # grounded by their own project name, while registered scopes also accept
-    # their configured aliases.  All known projects are checked to reject an
-    # otherwise ambiguous candidate that names multiple projects.
+    # grounded by their own project name. All known projects are still checked
+    # to reject ambiguous memory wording.
     candidate_registry = dict(registry)
-    for scope in selected.values():
-        owner = selected_owners[scope.casefold()]
+    for selected_scope in selected.values():
+        owner = selected_owners[selected_scope.casefold()]
         if owner not in {registered.casefold() for registered in registry}:
-            candidate_registry.setdefault(scope, {})
+            candidate_registry.setdefault(selected_scope, {})
+
     matches = {
-        scope.casefold()
+        scope.casefold(): scope
         for scope in project_scope_matches_text(memory, {"scopes": candidate_registry})
     }
-    if len(matches) != 1 or not matches.intersection(selected_owners.values()):
+    return selected_owners, matches
+
+
+def _reject_ungrounded_project_scope(
+    memory: str,
+    scopes: Iterable[str],
+    scope_registry: Mapping[str, Any] | None,
+) -> None:
+    """Require model-attributed project scopes to be named by this candidate.
+
+    The gate's memory text is the only candidate-local attribution evidence.
+    Session background, other events, and related-memory bodies are
+    intentionally excluded so an aggregate mailbox turn cannot lend a
+    project name to an unrelated candidate.
+    """
+
+    selected_owners, matches = _model_scope_grounding_evidence(
+        memory,
+        scopes,
+        scope_registry,
+    )
+    if not selected_owners:
+        return
+    if len(matches) != 1 or matches.keys().isdisjoint(set(selected_owners.values())):
         raise ModelOutputError(
             "model project scope is not grounded by this candidate",
             validation_detail="scope_not_grounded",
@@ -501,6 +522,7 @@ def validate_gate_output(
     related_memory_ids: Iterable[Any] | None = None,
     related_memory_types: Mapping[str, Any] | None = None,
     scope_registry: Mapping[str, Any] | None = None,
+    enforce_model_scope_grounding: bool = True,
 ) -> dict[str, Any]:
     """Validate and return a normalized gate object without writing anything."""
 
@@ -641,7 +663,8 @@ def validate_gate_output(
         if item["worth"]:
             _reject_mixed_project_scopes(item["scopes"])
             if item["scope_source"] == "model":
-                _reject_ungrounded_project_scope(item["memory"], item["scopes"], scope_registry)
+                if enforce_model_scope_grounding:
+                    _reject_ungrounded_project_scope(item["memory"], item["scopes"], scope_registry)
         if "reason" in item:
             _string(item["reason"], "reason", nonempty=False)
             if len(item["reason"]) > 30:
@@ -659,6 +682,7 @@ def parse_gate_output(
     related_memory_ids: Iterable[Any] | None = None,
     related_memory_types: Mapping[str, Any] | None = None,
     scope_registry: Mapping[str, Any] | None = None,
+    enforce_model_scope_grounding: bool = True,
 ) -> dict[str, Any]:
     try:
         parsed = parse_strict_json(raw)
@@ -674,6 +698,7 @@ def parse_gate_output(
             related_memory_ids=related_memory_ids,
             related_memory_types=related_memory_types,
             scope_registry=scope_registry,
+            enforce_model_scope_grounding=enforce_model_scope_grounding,
         )
     except ModelOutputError as error:
         if error.validation_reason is None:

{memleaf-0.2.8 → memleaf-0.2.10/src/memleaf.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 0.2.8
+Version: 0.2.10
 Summary: A local-first Markdown memory core for AI agents
 Author: memleaf contributors
 License-Expression: MIT
@@ -23,8 +23,8 @@ Dynamic: license-file
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **当前版本：0.2.8。**
-> 核心库、Vault、stdio MCP Server、初始化 CLI、模型路由、提炼流程、受控检索协议和宿主适配器已经实现。memleaf 0.2.8 通过 PyPI 分发。
+> **当前版本：0.2.10。**
+> 核心库、Vault、stdio MCP Server、初始化 CLI、模型路由、提炼流程、受控检索协议和宿主适配器已经实现。memleaf 0.2.10 通过 PyPI 分发。
 > **当前版本支持 Hermes 和 Codex。** Antigravity（反重力）不检测、不安装、不配置。
 
 ## 项目定位