memleaf 0.2.9__tar.gz → 0.2.10__tar.gz

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

@@ -2,6 +2,18 @@
 
 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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 0.2.9
+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.9。**
-> 核心库、Vault、stdio MCP Server、初始化 CLI、模型路由、提炼流程、受控检索协议和宿主适配器已经实现。memleaf 0.2.9 通过 PyPI 分发。
+> **当前版本：0.2.10。**
+> 核心库、Vault、stdio MCP Server、初始化 CLI、模型路由、提炼流程、受控检索协议和宿主适配器已经实现。memleaf 0.2.10 通过 PyPI 分发。
 > **当前版本支持 Hermes 和 Codex。** Antigravity（反重力）不检测、不安装、不配置。
 
 ## 项目定位

{memleaf-0.2.9 → 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.9.**
-> The core library, Vault, stdio MCP server, initialization CLI, model routing, memory extraction, controlled retrieval protocol, and host adapters are implemented. memleaf 0.2.9 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.9 → 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.9。**
-> 核心库、Vault、stdio MCP Server、初始化 CLI、模型路由、提炼流程、受控检索协议和宿主适配器已经实现。memleaf 0.2.9 通过 PyPI 分发。
+> **当前版本：0.2.10。**
+> 核心库、Vault、stdio MCP Server、初始化 CLI、模型路由、提炼流程、受控检索协议和宿主适配器已经实现。memleaf 0.2.10 通过 PyPI 分发。
 > **当前版本支持 Hermes 和 Codex。** Antigravity（反重力）不检测、不安装、不配置。
 
 ## 项目定位

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

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

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

@@ -1,6 +1,6 @@
 """Local-first Markdown memory core for AI agents."""
 
-__version__ = "0.2.9"
+__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.9 → memleaf-0.2.10}/src/memleaf/hermes_provider/plugin.yaml

@@ -1,5 +1,5 @@
 name: memleaf
-version: 0.2.9
+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.9 → memleaf-0.2.10}/src/memleaf/processing.py

@@ -49,12 +49,17 @@ from .prompts import (
 )
 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,
 )
@@ -1808,7 +1813,51 @@ class Processor:
                 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 = {

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

@@ -258,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 = {
@@ -277,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
@@ -311,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",
@@ -502,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."""
 
@@ -642,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:
@@ -660,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)
@@ -675,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.9 → memleaf-0.2.10/src/memleaf.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 0.2.9
+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.9。**
-> 核心库、Vault、stdio MCP Server、初始化 CLI、模型路由、提炼流程、受控检索协议和宿主适配器已经实现。memleaf 0.2.9 通过 PyPI 分发。
+> **当前版本：0.2.10。**
+> 核心库、Vault、stdio MCP Server、初始化 CLI、模型路由、提炼流程、受控检索协议和宿主适配器已经实现。memleaf 0.2.10 通过 PyPI 分发。
 > **当前版本支持 Hermes 和 Codex。** Antigravity（反重力）不检测、不安装、不配置。
 
 ## 项目定位

{memleaf-0.2.9 → memleaf-0.2.10}/tests/test_pypi_install.py

@@ -39,7 +39,7 @@ class PyPIInstallTests(unittest.TestCase):
 
             self.assertTrue(target.is_dir())
             self.assertFalse(target.is_symlink())
-            self.assertIn("version: 0.2.9", (target / "plugin.yaml").read_text(encoding="utf-8"))
+            self.assertIn("version: 0.2.10", (target / "plugin.yaml").read_text(encoding="utf-8"))
 
     def test_windows_hermes_paths_follow_official_native_layout(self) -> None:
         with tempfile.TemporaryDirectory(prefix="memleaf-win-paths-") as temporary:

{memleaf-0.2.9 → memleaf-0.2.10}/tests/test_stage_b2a.py

@@ -266,6 +266,279 @@ class StageB2ATest(unittest.TestCase):
         self.assertNotIn("project:浙江东方", state.get("scopes", []))
         self.assertNotIn("project:浙江东方", service.vault.config()["scopes"])
 
+    def test_gate_scope_not_grounded_final_retry_corrects_by_unique_memory_match(self):
+        backend = QueueBackend()
+        service = self.service(backend, name="scope-final-correct")
+        config = service.vault.config()
+        config["scopes"] = {
+            "project:zhongyin": {"aliases": ["中银国际"]},
+            "project:金元顺安": {"aliases": ["金元顺安"]},
+        }
+        save_config(service.vault.config_path, config)
+        user_key, _ = self.capture_turn(
+            service,
+            turn="scope-final-correct",
+            user_event="scope-final-correct-user",
+            assistant_event="scope-final-correct-assistant",
+            user="中银国际实施计划需要更新。",
+            assistant="确认中银国际计划更新。",
+        )
+        wrong = self.candidate(
+            "wrong-zg-scope",
+            [user_key],
+            memory="中银国际实施计划需要更新。",
+            type="project",
+        )
+        wrong["scopes"] = ["project:金元顺安"]
+        backend.responses.extend(
+            [
+                self.gate([wrong]),
+                self.gate([wrong]),
+                self.gate([wrong]),
+                self.summary(
+                    user_key,
+                    title="中银国际实施计划",
+                    body="中银国际实施计划需要更新。",
+                    type="project",
+                    scopes=["project:zhongyin"],
+                ),
+            ]
+        )
+
+        result = service.process(source="codex", session_id="s", model=backend)
+
+        self.assertEqual(result["memories_written"], 1)
+        self.assertEqual([call["purpose"] for call in backend.calls], ["gate", "gate", "gate", "summarize"])
+        self.assertIn("Previous output violated: scope_not_grounded.", backend.calls[1]["prompt"])
+        self.assertEqual(self.knowledge(service)[0].memory.scopes, ["project:zhongyin"])
+        self.assertIn("project:zhongyin", service.vault.config()["scopes"])
+
+    def test_scope_not_grounded_final_retry_keeps_other_valid_candidates(self):
+        backend = QueueBackend()
+        service = self.service(backend, name="scope-final-keep-valid")
+        config = service.vault.config()
+        config["scopes"] = {
+            "project:zhongyin": {"aliases": ["中银国际"]},
+            "project:xinyuan": {"aliases": ["鑫元基金"]},
+        }
+        save_config(service.vault.config_path, config)
+        user_key, assistant_key = self.capture_turn(
+            service,
+            turn="scope-final-keep-valid",
+            user_event="scope-final-keep-valid-user",
+            assistant_event="scope-final-keep-valid-assistant",
+            user="中银国际计划已更新；鑫元待反馈。",
+            assistant="待确认中银国际与鑫元相关事项。",
+        )
+
+        valid = self.candidate(
+            "zhongyin-plan",
+            [user_key],
+            memory="中银国际计划已更新。",
+            type="project",
+        )
+        valid["scopes"] = ["project:zhongyin"]
+        bad = self.candidate(
+            "xinyuan-ambiguous",
+            [assistant_key],
+            memory="鑫元 待反馈。",
+            type="event",
+        )
+        bad["scopes"] = ["project:xinyuan"]
+        backend.responses.extend(
+            [
+                self.gate([bad, valid]),
+                self.gate([bad, valid]),
+                self.gate([bad, valid]),
+                self.summary(
+                    user_key,
+                    title="中银国际计划",
+                    body="中银国际计划已更新。",
+                    type="project",
+                    scopes=["project:zhongyin"],
+                ),
+            ]
+        )
+
+        result = service.process(source="codex", session_id="s", model=backend)
+
+        self.assertEqual(result["memories_written"], 1)
+        self.assertEqual([call["purpose"] for call in backend.calls], ["gate", "gate", "gate", "summarize"])
+        self.assertIn("Previous output violated: scope_not_grounded.", backend.calls[1]["prompt"])
+        self.assertEqual(len(self.knowledge(service)), 1)
+        self.assertEqual(self.knowledge(service)[0].memory.scopes, ["project:zhongyin"])
+        turn_entry = self.processed(service)["sessions"]["codex/s"]["processed_turns"][0]
+        deferred = turn_entry["deferred_candidates"]
+        self.assertEqual(len(deferred), 1)
+        self.assertEqual(deferred[0]["candidate_id"], "xinyuan-ambiguous")
+        self.assertNotIn("鑫元", "\n".join(record.memory.body for record in self.knowledge(service)))
+
+    def test_scope_not_grounded_final_retry_ambiguous_mention_no_write(self):
+        backend = QueueBackend()
+        service = self.service(backend, name="scope-final-ambiguous")
+        config = service.vault.config()
+        config["scopes"] = {
+            "project:zhongyin": {"aliases": ["中银国际"]},
+            "project:jinyuan": {"aliases": ["金元顺安"]},
+        }
+        save_config(service.vault.config_path, config)
+        user_key, _ = self.capture_turn(
+            service,
+            turn="scope-final-ambiguous",
+            user_event="scope-final-ambiguous-user",
+            assistant_event="scope-final-ambiguous-assistant",
+            user="中银国际和金元顺安均有更新。",
+            assistant="已确认两个项目的进展。",
+        )
+        wrong = self.candidate(
+            "both-mentioned",
+            [user_key],
+            memory="中银国际和金元顺安均有更新。",
+            type="fact",
+        )
+        wrong["scopes"] = ["project:zhongyin"]
+        backend.responses.extend([self.gate([wrong]), self.gate([wrong]), self.gate([wrong])])
+
+        result = service.process(source="codex", session_id="s", model=backend)
+
+        self.assertEqual(result["memories_written"], 0)
+        self.assertEqual([call["purpose"] for call in backend.calls], ["gate", "gate", "gate"])
+        self.assertEqual(self.knowledge(service), [])
+        turn_entry = self.processed(service)["sessions"]["codex/s"]["processed_turns"][0]
+        deferred = turn_entry["deferred_candidates"]
+        self.assertEqual(len(deferred), 1)
+        self.assertEqual(deferred[0]["candidate_id"], "both-mentioned")
+        self.assertEqual(deferred[0]["reason"], "scope_required")
+        self.assertEqual(self.processed(service)["sessions"]["codex/s"]["processing"]["status"], "idle")
+
+    def test_scope_not_grounded_final_retry_wrong_scope_and_wrong_update_target_is_safe(self):
+        backend = QueueBackend()
+        service = self.service(backend, name="scope-final-wrong-scope-target")
+        config = service.vault.config()
+        config["scopes"] = {
+            "project:alpha": {"aliases": ["阿尔法"]},
+            "project:beta": {"aliases": ["贝塔"]},
+        }
+        save_config(service.vault.config_path, config)
+        old = service.create_memory(
+            memory_id="alpha-existing",
+            title="阿尔法 项目负责人",
+            body="阿尔法 项目负责人当前为甲。",
+            type="identity",
+            scopes=["project:alpha"],
+        )
+        user_key, _ = self.capture_turn(
+            service,
+            turn="scope-final-wrong-scope-target",
+            user_event="scope-final-wrong-scope-target-user",
+            assistant_event="scope-final-wrong-scope-target-assistant",
+            user="阿尔法 项目负责人当前为甲；贝塔 项目负责人更新为乙。",
+            assistant="已确认两个项目的负责人信息。",
+        )
+        wrong = self.candidate(
+            "wrong-scope-target",
+            [user_key],
+            memory="贝塔 项目负责人更新为乙。",
+            type="identity",
+            update_memory_id=old.memory_id,
+        )
+        wrong["scopes"] = ["project:alpha"]
+        backend.responses.extend(
+            [
+                self.gate([wrong]),
+                self.gate([wrong]),
+                self.gate([wrong]),
+                self.summary(
+                    user_key,
+                    title="贝塔 项目负责人",
+                    body="贝塔 项目负责人更新为乙。",
+                    type="identity",
+                    scopes=["project:beta"],
+                ),
+            ]
+        )
+
+        result = service.process(source="codex", session_id="s", model=backend)
+
+        self.assertEqual(result["memories_written"], 1)
+        self.assertEqual([call["purpose"] for call in backend.calls], ["gate", "gate", "gate", "summarize"])
+        self.assertIn("Previous output violated: scope_not_grounded.", backend.calls[1]["prompt"])
+        self.assertEqual(service.read(old.memory_id).body, old.body)
+        self.assertEqual(len(self.knowledge(service)), 2)
+        self.assertIn(
+            "贝塔 项目负责人更新为乙。",
+            "\n".join(record.memory.body for record in self.knowledge(service)),
+        )
+        self.assertEqual(
+            {
+                tuple(record.memory.scopes): record.memory.body
+                for record in self.knowledge(service)
+            }[("project:beta",)],
+            "贝塔 项目负责人更新为乙。",
+        )
+
+    def test_scope_not_grounded_final_retry_preserves_unregistered_project_scope(self):
+        backend = QueueBackend()
+        service = self.service(backend, name="scope-final-unregistered-legal")
+        config = service.vault.config()
+        config["scopes"] = {
+            "project:alpha": {"aliases": ["阿尔法"]},
+        }
+        save_config(service.vault.config_path, config)
+        old = service.create_memory(
+            memory_id="alpha-existing",
+            title="阿尔法 项目状态",
+            body="阿尔法 项目状态保持不变。",
+            type="project",
+            scopes=["project:alpha"],
+        )
+        user_key, _ = self.capture_turn(
+            service,
+            turn="scope-final-unregistered-legal",
+            user_event="scope-final-unregistered-legal-user",
+            assistant_event="scope-final-unregistered-legal-assistant",
+            user="阿尔法项目状态不变；浙江东方实施计划待确认。",
+            assistant="已确认两个项目的状态。",
+        )
+        wrong = self.candidate(
+            "new-unregistered-final-retry",
+            [user_key],
+            memory="浙江东方实施计划待确认。",
+            type="project",
+            update_memory_id=old.memory_id,
+        )
+        wrong["scopes"] = ["project:浙江东方"]
+        backend.responses.extend(
+            [
+                self.gate([wrong]),
+                self.gate([wrong]),
+                self.gate([wrong]),
+                self.summary(
+                    user_key,
+                    title="浙江东方实施计划",
+                    body="浙江东方实施计划待确认。",
+                    type="project",
+                    scopes=["project:浙江东方"],
+                ),
+            ]
+        )
+
+        result = service.process(source="codex", session_id="s", model=backend)
+
+        self.assertEqual(result["processed_turns"], 1)
+        self.assertEqual(result["memories_written"], 1)
+        self.assertEqual([call["purpose"] for call in backend.calls], ["gate", "gate", "gate", "summarize"])
+        self.assertIn("Previous output violated: target_not_relevant.", backend.calls[1]["prompt"])
+        self.assertEqual(service.read(old.memory_id).body, old.body)
+        self.assertEqual(len(self.knowledge(service)), 2)
+        unregistered = [
+            record
+            for record in self.knowledge(service)
+            if record.memory.scopes == ["project:浙江东方"]
+        ]
+        self.assertEqual(len(unregistered), 1)
+        self.assertEqual(unregistered[0].memory.body, "浙江东方实施计划待确认。")
+
     def test_summary_scope_drift_retries_before_writing(self):
         backend = QueueBackend()
         service = self.service(backend, name="summary-scope-drift")

{memleaf-0.2.9 → memleaf-0.2.10}/tests/test_stage_c1_mcp.py

@@ -104,7 +104,7 @@ class StageC1MCPTest(unittest.TestCase):
         testcase.assertEqual(result["resultType"], "complete")
         testcase.assertEqual(
             result["_meta"]["io.modelcontextprotocol/serverInfo"],
-            {"name": "memleaf", "version": "0.2.9"},
+            {"name": "memleaf", "version": "0.2.10"},
         )
         return result
 

{memleaf-0.2.9 → memleaf-0.2.10}/tests/test_stage_c3_packaging.py

@@ -24,7 +24,7 @@ class StageC3PackagingTests(unittest.TestCase):
 
     def test_project_metadata_and_version_export(self) -> None:
         self.assertEqual(self.project["name"], "memleaf")
-        self.assertEqual(self.project["version"], "0.2.9")
+        self.assertEqual(self.project["version"], "0.2.10")
         self.assertEqual(self.project["requires-python"], ">=3.11")
         self.assertEqual(self.project["dependencies"], [])
         self.assertEqual(self.project["license"], "MIT")