memleaf 0.2.8__tar.gz → 0.2.9__tar.gz

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

@@ -2,6 +2,17 @@
 
 All notable changes to memleaf are documented here.
 
+## 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.9}/PKG-INFO

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

{memleaf-0.2.8 → memleaf-0.2.9}/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.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.
 > **The current release supports Hermes and Codex.** Antigravity is not detected, installed, or configured.
 
 ## Project scope

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

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

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

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

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

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

@@ -42,6 +42,7 @@ from .prompts import (
     SUMMARY_TARGET_CORRECTION,
     SUMMARY_TYPE_CORRECTION,
     SUMMARIZE_SYSTEM,
+    TARGET_RELEVANCE_CORRECTION,
     UPDATE_TARGET_TYPE_CORRECTION,
     gate_prompt,
     summarize_prompt,
@@ -493,6 +494,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 +1422,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 +1797,60 @@ 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,
+            )
+            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 +1863,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 +1912,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.9}/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.9}/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",

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

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

{memleaf-0.2.8 → memleaf-0.2.9}/tests/test_maintenance_v2.py

@@ -326,7 +326,7 @@ class MaintenanceV2Tests(unittest.TestCase):
                         candidate(
                             "priority-update",
                             [user_event, assistant_event],
-                            "priority project 状态更新",
+                            "priority project plan 状态更新",
                             scopes=["project:priority"],
                             type="project",
                             update_memory_id=target.memory_id,
@@ -1026,24 +1026,37 @@ class MaintenanceV2Tests(unittest.TestCase):
             "alpha 项目负责人更新为乙。",
             "已确认 alpha 负责人为乙；beta 项目负责人仍为丙。",
         )
-        backend = QueueBackend(
+        invalid_gate = gate(
             [
-                gate(
-                    [
-                        candidate(
-                            "wrong-target",
-                            [user_event, assistant_event],
-                            "alpha 项目负责人更新为乙。",
-                            scopes=["project:alpha"],
-                            update_memory_id="mem-beta-owner",
-                        )
-                    ]
+                candidate(
+                    "wrong-target",
+                    [user_event, assistant_event],
+                    "alpha 项目负责人更新为乙。",
+                    scopes=["project:alpha"],
+                    update_memory_id="mem-beta-owner",
                 )
             ]
         )
+        backend = QueueBackend(
+            [
+                invalid_gate,
+                invalid_gate,
+                invalid_gate,
+                summary(
+                    user_event,
+                    "alpha 项目负责人更新为乙。",
+                    title="alpha 项目负责人",
+                    scopes=["project:alpha"],
+                ),
+            ]
+        )
+
+        result = self.service.process(source="hermes", session_id="isolation", model=backend)
 
-        with self.assertRaises(ValueError):
-            self.service.process(source="hermes", session_id="isolation", 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: target_not_relevant.", backend.calls[1]["prompt"])
+        self.assertEqual(self.processed()["sessions"]["hermes/isolation"]["processing"]["status"], "idle")
 
         self.assertEqual(self.service.read("mem-alpha-owner").body, "alpha 项目负责人是甲。")
         self.assertEqual(self.service.read("mem-beta-owner").body, "beta 项目负责人是丙。")

{memleaf-0.2.8 → memleaf-0.2.9}/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.8", (target / "plugin.yaml").read_text(encoding="utf-8"))
+            self.assertIn("version: 0.2.9", (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.8 → memleaf-0.2.9}/tests/test_stage_b2a.py

@@ -873,6 +873,215 @@ class StageB2ATest(unittest.TestCase):
         self.assertEqual(service.read(other.memory_id).body, other.body)
         self.assertEqual(len(service.vault.list_markdown("history")), 1)
 
+    def test_same_project_different_future_use_target_retries_then_creates(self):
+        backend = QueueBackend()
+        service = self.service(backend, name="same-project-wrong-target")
+        old = service.create_memory(
+            memory_id="mem-orion-sync",
+            title="金元顺安项目任务同步到 Orion 系统",
+            body=(
+                "金元顺安项目任务已同步到 Orion；里程碑包含信创环境搭建、"
+                "功能验证测试和上线安排。"
+            ),
+            type="todo",
+            scopes=["project:金元顺安"],
+        )
+        user_key, assistant_key = self.capture_turn(
+            service,
+            turn="same-project-wrong-target",
+            user_event="same-project-wrong-target-user",
+            assistant_event="same-project-wrong-target-assistant",
+            user="金元顺安实施计划六项建议；同时需要查看 Orion 任务同步。",
+            assistant="已整理金元顺安实施计划与 Orion 任务同步。",
+        )
+        wrong = self.candidate(
+            "wrong-jinyuan-target",
+            [user_key, assistant_key],
+            memory="金元顺安实施计划六项建议含里程碑、信创环境、测试和上线安排。",
+            type="todo",
+            update_memory_id=old.memory_id,
+        )
+        wrong["scopes"] = ["project:金元顺安"]
+        corrected = dict(wrong, candidate_id="jinyuan-independent")
+        corrected.pop("update_memory_id")
+        backend.responses.extend(
+            [
+                self.gate([wrong]),
+                self.gate([corrected]),
+                self.summary(
+                    user_key,
+                    title="金元顺安实施计划六项建议",
+                    body="金元顺安实施计划六项建议含里程碑、信创环境、测试和上线安排。",
+                    type="todo",
+                    scopes=["project:金元顺安"],
+                    status="active",
+                ),
+            ]
+        )
+
+        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", "summarize"])
+        self.assertIn("Previous output violated: target_not_relevant.", backend.calls[1]["prompt"])
+        self.assertEqual(service.read(old.memory_id).title, old.title)
+        self.assertEqual(service.read(old.memory_id).body, old.body)
+        self.assertEqual(len(service.vault.list_markdown("history")), 0)
+        active = service._read_memories_unlocked("knowledge")
+        self.assertEqual(len(active), 2)
+        self.assertIn(
+            "金元顺安实施计划六项建议含里程碑、信创环境、测试和上线安排。",
+            "\n".join(item.memory.body for item in active),
+        )
+
+    def test_same_project_same_future_use_target_remains_valid(self):
+        backend = QueueBackend()
+        service = self.service(backend, name="same-project-valid-target")
+        old = service.create_memory(
+            memory_id="mem-jinyuan-plan",
+            title="金元顺安实施计划",
+            body="金元顺安实施计划按原方案执行。",
+            type="project",
+            scopes=["project:金元顺安"],
+        )
+        user_key, assistant_key = self.capture_turn(
+            service,
+            turn="same-project-valid-target",
+            user_event="same-project-valid-target-user",
+            assistant_event="same-project-valid-target-assistant",
+            user="金元顺安实施计划新增部署要求。",
+            assistant="已确认金元顺安实施计划需要纳入部署要求。",
+        )
+        candidate = self.candidate(
+            "valid-jinyuan-target",
+            [user_key, assistant_key],
+            memory="金元顺安实施计划新增部署要求。",
+            type="project",
+            update_memory_id=old.memory_id,
+        )
+        candidate["scopes"] = ["project:金元顺安"]
+        backend.responses.extend(
+            [
+                self.gate([candidate]),
+                self.summary(
+                    user_key,
+                    title="金元顺安实施计划",
+                    body="金元顺安实施计划新增部署要求。",
+                    type="project",
+                    scopes=["project:金元顺安"],
+                    update_memory_id=old.memory_id,
+                ),
+            ]
+        )
+
+        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", "summarize"])
+        self.assertEqual(service.read(old.memory_id).body, "金元顺安实施计划新增部署要求。")
+        self.assertEqual(len(service.vault.list_markdown("history")), 1)
+
+    def test_same_project_wrong_update_target_final_retry_becomes_create(self):
+        backend = QueueBackend()
+        service = self.service(backend, name="same-project-wrong-target-final-retry")
+        old = service.create_memory(
+            memory_id="mem-beta-owner-final-retry",
+            title="beta 项目负责人",
+            body="beta 项目负责人是丙。",
+            type="identity",
+            scopes=["project:beta"],
+        )
+        user_key, assistant_key = self.capture_turn(
+            service,
+            turn="same-project-wrong-target-final-retry",
+            user_event="same-project-wrong-target-final-retry-user",
+            assistant_event="same-project-wrong-target-final-retry-assistant",
+            user="alpha 项目负责人更新为乙；beta 项目负责人仍为丙。",
+            assistant="已确认 alpha 负责人为乙，beta 负责人仍为丙。",
+        )
+        wrong = self.candidate(
+            "wrong-target-final-retry",
+            [user_key, assistant_key],
+            memory="alpha 项目负责人更新为乙。",
+            type="identity",
+            update_memory_id=old.memory_id,
+        )
+        wrong["scopes"] = ["project:alpha"]
+        invalid_gate = self.gate([wrong])
+        backend.responses.extend(
+            [
+                invalid_gate,
+                invalid_gate,
+                invalid_gate,
+                self.summary(
+                    user_key,
+                    title="alpha 项目负责人",
+                    body="alpha 项目负责人已更新为乙。",
+                    type="identity",
+                    scopes=["project:alpha"],
+                ),
+            ]
+        )
+
+        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(service.vault.list_markdown("history")), 0)
+        self.assertEqual(self.processed(service)["sessions"]["codex/s"]["processing"]["status"], "idle")
+        self.assertIn(
+            "alpha 项目负责人已更新为乙。",
+            "\n".join(record.memory.body for record in service._read_memories_unlocked("knowledge")),
+        )
+
+    def test_same_project_wrong_duplicate_target_final_retry_is_dropped(self):
+        backend = QueueBackend()
+        service = self.service(backend, name="same-project-wrong-duplicate-final-retry")
+        old = service.create_memory(
+            memory_id="mem-beta-duplicate-final-retry",
+            title="beta 项目状态",
+            body="beta 项目状态保持不变。",
+            type="fact",
+            scopes=["project:beta"],
+        )
+        user_key, assistant_key = self.capture_turn(
+            service,
+            turn="same-project-wrong-duplicate-final-retry",
+            user_event="same-project-wrong-duplicate-final-retry-user",
+            assistant_event="same-project-wrong-duplicate-final-retry-assistant",
+            user="alpha 项目状态保持不变；beta 项目状态也保持不变。",
+            assistant="已确认两个项目状态均未变化。",
+        )
+        wrong = self.candidate(
+            "wrong-duplicate-final-retry",
+            [user_key, assistant_key],
+            memory="alpha 项目状态保持不变。",
+            duplicate=True,
+            worth=False,
+            type="fact",
+        )
+        wrong["duplicate_memory_id"] = old.memory_id
+        wrong["scopes"] = ["project:alpha"]
+        invalid_gate = self.gate([wrong])
+        backend.responses.extend([invalid_gate, invalid_gate, invalid_gate])
+
+        result = service.process(source="codex", session_id="s", model=backend)
+
+        self.assertEqual(result["processed_turns"], 1)
+        self.assertEqual(result["memories_written"], 0)
+        self.assertEqual([call["purpose"] for call in backend.calls], ["gate", "gate", "gate"])
+        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(service._read_memories_unlocked("knowledge")), 1)
+        self.assertEqual(len(service.vault.list_markdown("history")), 0)
+        self.assertEqual(self.processed(service)["sessions"]["codex/s"]["processing"]["status"], "idle")
+
     def test_gate_and_summary_update_target_mismatch_fails_after_bounded_retries(self):
         backend = QueueBackend()
         service = self.service(backend, name="email-update-mismatch-failure")

{memleaf-0.2.8 → memleaf-0.2.9}/tests/test_stage_b2b.py

@@ -150,7 +150,12 @@ class StageB2BTest(unittest.TestCase):
             user=f"user {turn} b2b{related_context}",
             assistant=f"assistant {turn}",
         )
-        candidate = self.candidate("candidate-" + turn, [user_key], type=type)
+        candidate = self.candidate(
+            "candidate-" + turn,
+            [user_key],
+            memory=f"{active.title} {active.body}",
+            type=type,
+        )
         summary_extra = dict(extra or {})
         summary_extra["update_memory_id"] = active_id
         backend.responses.extend(
@@ -333,7 +338,9 @@ class StageB2BTest(unittest.TestCase):
             assistant_event="a2",
             user="user t2 old",
         )
-        candidate = self.candidate("candidate-t2", [user_key])
+        candidate = self.candidate(
+            "candidate-t2", [user_key], memory=f"{active.title} {active.body}"
+        )
         responses = [
             self.gate([candidate]),
             self.summary(user_key, title="Updated", body="new", update_memory_id=active.memory_id),
@@ -373,7 +380,9 @@ class StageB2BTest(unittest.TestCase):
             assistant_event="a2",
             user="user t2 b2b old",
         )
-        candidate = self.candidate("candidate-t2", [user_key])
+        candidate = self.candidate(
+            "candidate-t2", [user_key], memory=f"{active.title} {active.body}"
+        )
         responses = [self.gate([candidate]), self.summary(user_key, title="Updated", body="b2b new", update_memory_id=active.memory_id)]
 
         backend.responses.extend(responses)
@@ -405,7 +414,9 @@ class StageB2BTest(unittest.TestCase):
             assistant_event="p-a2",
             user="user t2 b2b old",
         )
-        candidate2 = self.candidate("candidate-t2", [user_key2])
+        candidate2 = self.candidate(
+            "candidate-t2", [user_key2], memory=f"{active2.title} {active2.body}"
+        )
         responses2 = [self.gate([candidate2]), self.summary(user_key2, title="Updated", body="b2b new", update_memory_id=active2.memory_id)]
         backend2.responses.extend(responses2)
         import memleaf.processing as processing_module
@@ -543,7 +554,10 @@ class StageB2BTest(unittest.TestCase):
             assistant_event="a2",
             user="user t2 b2b old",
         )
-        candidates = [self.candidate("c1", [user_key]), self.candidate("c2", [user_key], memory="second")]
+        candidates = [
+            self.candidate("c1", [user_key], memory=f"{active.title} {active.body}"),
+            self.candidate("c2", [user_key], memory=f"{active.title} {active.body} second"),
+        ]
         backend.responses.extend(
             [
                 self.gate(candidates),

{memleaf-0.2.8 → memleaf-0.2.9}/tests/test_stage_b3b_native_context.py

@@ -56,10 +56,10 @@ class StageB3BNativeContextTest(unittest.TestCase):
         return json.dumps({"candidates": [candidate] if candidate is not None else []})
 
     @staticmethod
-    def candidate(event_key_value, *, duplicate=False, worth=True):
+    def candidate(event_key_value, *, memory="new state", duplicate=False, worth=True):
         return {
             "candidate_id": "candidate-1",
-            "memory": "new state",
+            "memory": memory,
             "evidence_event_ids": [event_key_value],
             "duplicate": duplicate,
             "worth": worth,
@@ -188,7 +188,7 @@ class StageB3BNativeContextTest(unittest.TestCase):
         event_key_value = self.capture_turn(user="legacy status is now replaced", assistant="confirmed")
         invalid = QueueBackend(
             [
-                self.gate(self.candidate(event_key_value)),
+                self.gate(self.candidate(event_key_value, memory="legacy status is now replaced")),
                 self.summary(event_key_value, "new status", shadow=["native-not-related"]),
                 self.summary(event_key_value, "new status", shadow=["native-not-related"]),
                 self.summary(event_key_value, "new status", shadow=["native-not-related"]),
@@ -200,7 +200,7 @@ class StageB3BNativeContextTest(unittest.TestCase):
 
         backend = QueueBackend(
             [
-                self.gate(self.candidate(event_key_value)),
+                self.gate(self.candidate(event_key_value, memory="legacy status is now replaced")),
                 self.summary(event_key_value, "new status", shadow=[native_id]),
             ]
         )
@@ -239,9 +239,9 @@ class StageB3BNativeContextTest(unittest.TestCase):
 
         event_key_value = self.capture_turn(user="legacy retry status is replaced", assistant="confirmed")
         responses = [
-            self.gate(self.candidate(event_key_value)),
+            self.gate(self.candidate(event_key_value, memory="legacy retry status is replaced")),
             self.summary(event_key_value, "retry status", shadow=[native_id]),
-            self.gate(self.candidate(event_key_value)),
+            self.gate(self.candidate(event_key_value, memory="legacy retry status is replaced")),
             self.summary(event_key_value, "retry status", shadow=[native_id]),
         ]
         backend = QueueBackend(responses)

{memleaf-0.2.8 → memleaf-0.2.9}/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.8"},
+            {"name": "memleaf", "version": "0.2.9"},
         )
         return result
 

{memleaf-0.2.8 → memleaf-0.2.9}/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.8")
+        self.assertEqual(self.project["version"], "0.2.9")
         self.assertEqual(self.project["requires-python"], ">=3.11")
         self.assertEqual(self.project["dependencies"], [])
         self.assertEqual(self.project["license"], "MIT")