memleaf 0.2.15__tar.gz → 0.2.16__tar.gz

{memleaf-0.2.15 → memleaf-0.2.16}/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 All notable changes to memleaf are documented here.
 
+## 0.2.16 — 2026-09-02
+
+- Keep read-only operational queries, derived overdue counters, and one-time
+  execution receipts out of permanent-memory extraction; preserve explicitly
+  confirmed durable facts and preferences.
+- Deduplicate Hermes tool observations across cumulative conversation payloads,
+  preventing historical reads from being re-audited as uncontrolled while
+  retaining diagnostics for genuinely mismatched current-turn reads.
+
 ## 0.2.15 — 2026-09-02
 
 - Recover a candidate whose `update_memory_id` has the wrong type at the

{memleaf-0.2.15/src/memleaf.egg-info → memleaf-0.2.16}/PKG-INFO

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

{memleaf-0.2.15 → memleaf-0.2.16}/README.en.md

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

{memleaf-0.2.15 → memleaf-0.2.16}/README.md

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

{memleaf-0.2.15 → memleaf-0.2.16}/pyproject.toml

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

{memleaf-0.2.15 → memleaf-0.2.16}/src/memleaf/__init__.py

@@ -1,6 +1,6 @@
 """Local-first Markdown memory core for AI agents."""
 
-__version__ = "0.2.15"
+__version__ = "0.2.16"
 
 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.15 → memleaf-0.2.16}/src/memleaf/hermes_provider/__init__.py

@@ -49,6 +49,7 @@ _MAX_PENDING_TURN_NUMBERS = 128
 _MAX_SESSION_ALIASES = 128
 _MAX_LINEAGE_RETRIES = 2
 _MAX_DEFERRED_PROCESS_SESSIONS = 128
+_MAX_OBSERVED_TOOL_CALL_KEYS = 2048
 _SAFE_COMPONENT_RE = re.compile(r"[^A-Za-z0-9_.-]+")
 _PROVIDER_VERSION_RE = re.compile(r"^version:\s*([^\s#]+)\s*(?:#.*)?$", re.MULTILINE)
 _ASCII_QUERY_TERM_RE = re.compile(r"[a-z0-9]+(?:[ ._-][a-z0-9]+)*")
@@ -628,6 +629,45 @@ def _tool_result_for_call(
     return _CALL_FAILED
 
 
+def _tool_observation_key(call: Mapping[str, Any], ordinal: int) -> str:
+    """Build a stable in-memory identity for one visible tool call.
+
+    Hermes can pass the complete conversation back on every turn.  The
+    retrieval token and result status are turn-relative, so they must not be
+    part of the identity: otherwise an old successful read is reclassified as
+    ``uncontrolled_success`` when a newer token is observed.  Call ids are
+    stable when Hermes supplies them; the ordinal/arguments fallback keeps
+    anonymous calls distinct within the cumulative message list.
+    """
+
+    arguments = call.get("arguments")
+    try:
+        arguments_text = json.dumps(arguments, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+    except (TypeError, ValueError):
+        arguments_text = ""
+    call_id = call.get("call_id") if isinstance(call.get("call_id"), str) else ""
+    name = call.get("name") if isinstance(call.get("name"), str) else ""
+    if call_id:
+        identity = f"{name}\x00call-id\x00{call_id}"
+    else:
+        identity = f"{name}\x00anonymous\x00{ordinal}\x00{arguments_text}"
+    return sha256(identity.encode("utf-8")).hexdigest()
+
+
+def _record_tool_observation(seen: Any, key: str) -> bool:
+    """Record one observation key and report whether it was new."""
+
+    if seen is None:
+        return True
+    if key in seen:
+        return False
+    if isinstance(seen, set):
+        seen.add(key)
+    else:
+        seen[key] = None
+    return True
+
+
 def _hermes_read_status(value: Any) -> str:
     """Classify a visible read result without inspecting it in diagnostics."""
 
@@ -1125,6 +1165,7 @@ class MemleafMemoryProvider(MemoryProvider):
         self._gate_turn_ids: "OrderedDict[Tuple[str, int], str]" = OrderedDict()
         self._active_turn_numbers: "OrderedDict[str, int]" = OrderedDict()
         self._active_retrieval_ids: "OrderedDict[str, Optional[str]]" = OrderedDict()
+        self._observed_tool_call_keys: "OrderedDict[str, None]" = OrderedDict()
         self._version_warning_emitted = False
         # Hermes keeps one provider instance alive while compression rotates
         # the physical session id.  Keep only a bounded alias chain so a
@@ -1752,6 +1793,7 @@ class MemleafMemoryProvider(MemoryProvider):
             if not continuous:
                 self._pending_lineage.clear()
                 self._deferred_process_sessions.clear()
+                self._observed_tool_call_keys.clear()
             if _as_bool(reset, False) or _as_bool(rewound, False):
                 self._clear_session_turn_state(old_session_id or next_session_id)
                 for key in list(self._retrieval_ids_by_turn):
@@ -1826,6 +1868,7 @@ class MemleafMemoryProvider(MemoryProvider):
         self._gate_turn_ids.clear()
         self._active_turn_numbers.clear()
         self._active_retrieval_ids.clear()
+        self._observed_tool_call_keys.clear()
         self._session_aliases.clear()
         self._pending_lineage.clear()
         self._deferred_process_sessions.clear()
@@ -2073,6 +2116,7 @@ class MemleafMemoryProvider(MemoryProvider):
         session_id: str = "",
         turn_id: str = "",
         vault_root: Optional[Path] = None,
+        seen_call_keys: Any = None,
     ) -> str:
         """Observe explicit host MCP calls in public messages.
 
@@ -2087,25 +2131,32 @@ class MemleafMemoryProvider(MemoryProvider):
         results = _visible_tool_results(messages)
         statuses: list[str] = []
         search_results_used: set[int] = set()
+        search_ordinal = 0
         for call in calls:
             if call.get("name") != "mcp__memleaf__search":
                 continue
+            search_ordinal += 1
             arguments = call.get("arguments")
             if not isinstance(arguments, Mapping) or arguments.get("retrieval_id") != retrieval_id:
                 continue
             payload = _tool_result_for_call(call, calls, results, search_results_used)
             if payload is not _CALL_FAILED:
+                status = _hermes_search_status(payload)
+                observation_key = _tool_observation_key(call, search_ordinal)
+                if not _record_tool_observation(seen_call_keys, observation_key):
+                    continue
                 # Hermes has no public write-back hook for this soft observer.
                 # A valid current-turn result is enough to mark the local
                 # provider diagnostic; no Core ledger or body is touched here.
-                statuses.append(_hermes_search_status(payload))
+                statuses.append(status)
 
         read_results_used: set[int] = set()
         read_sequence = 0
+        read_ordinal = 0
         for call in calls:
             if call.get("name") != "mcp__memleaf__read":
                 continue
-            read_sequence += 1
+            read_ordinal += 1
             arguments = call.get("arguments")
             retrieval_present = isinstance(arguments, Mapping) and "retrieval_id" in arguments
             retrieval_match = bool(
@@ -2120,6 +2171,10 @@ class MemleafMemoryProvider(MemoryProvider):
                 # mismatched gate binding.  Do not make that look like a
                 # controlled success in the diagnostic stream.
                 result_status = "uncontrolled_success"
+            observation_key = _tool_observation_key(call, read_ordinal)
+            if not _record_tool_observation(seen_call_keys, observation_key):
+                continue
+            read_sequence += 1
             logger.info(
                 "memleaf retrieval-read source=hermes session=%s turn=%s read_seq=%d retrieval_present=%s retrieval_match=%s result=%s",
                 _safe_component(session_id, "none") if session_id else "none",
@@ -2286,7 +2341,10 @@ class MemleafMemoryProvider(MemoryProvider):
                         session_id=effective_session,
                         turn_id=turn_id,
                         vault_root=_resolve_vault(self._config()),
+                        seen_call_keys=self._observed_tool_call_keys,
                     )
+                    while len(self._observed_tool_call_keys) > _MAX_OBSERVED_TOOL_CALL_KEYS:
+                        self._observed_tool_call_keys.popitem(last=False)
                     self._last_retrieval_observation = observation
                 lineage_ready = self._retry_pending_lineage(effective_session)
                 for role, content in visible_events:

{memleaf-0.2.15 → memleaf-0.2.16}/src/memleaf/hermes_provider/plugin.yaml

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

{memleaf-0.2.15 → memleaf-0.2.16}/src/memleaf/processing.py

@@ -87,6 +87,55 @@ _DIAGNOSTIC_GATE_ALLOWED = frozenset(("candidates",))
 _DIAGNOSTIC_CANDIDATE_REQUIRED = frozenset(
     ("candidate_id", "memory", "evidence_event_ids", "duplicate", "worth", "type", "scopes", "scope_source")
 )
+
+_READ_ONLY_QUERY_MARKERS = (
+    "有没有", "有哪些", "是什么", "是谁", "多少", "查询", "查一下", "查下",
+    "看看", "查看", "汇总", "列出", "告诉我", "what", "which", "who", "show me",
+)
+_USER_ASSERTION_MARKERS = (
+    "已确认", "确认了", "已决定", "我决定", "改为", "更新为", "变更为", "以后",
+    "今后", "约定", "我的偏好", "我喜欢", "必须", "要求是", "截止日期为",
+    "负责人是", "负责人为",
+)
+_DERIVED_OVERDUE_RE = re.compile(
+    r"(?:逾期|超期|overdue)\s*\d+(?:\.\d+)?\s*(?:天|日|days?)",
+    re.IGNORECASE,
+)
+_EXECUTION_RECEIPT_RE = re.compile(
+    r"(?:核验归档|归档核验|服务器已接受(?:提交|投递)|server accepted)",
+    re.IGNORECASE,
+)
+
+
+def _automatic_read_only_query(events: Iterable[Mapping[str, Any]]) -> bool:
+    """Return true when the user only asks for information in this turn."""
+
+    user_text = "\n".join(
+        str(event.get("content", ""))
+        for event in events
+        if str(event.get("role", "")).casefold() == "user"
+    ).strip()
+    if not user_text:
+        return False
+    folded = user_text.casefold()
+    query_prefix = re.sub(r"^(?:请|帮我|麻烦|请帮我)\s*", "", folded)
+    asks = "?" in user_text or "？" in user_text or any(
+        query_prefix.startswith(marker) or query_prefix.startswith(f"我{marker}")
+        for marker in _READ_ONLY_QUERY_MARKERS
+    )
+    if not asks:
+        return False
+    return not any(marker in folded for marker in _USER_ASSERTION_MARKERS)
+
+
+def _automatic_transient_memory(value: Any) -> bool:
+    """Reject volatile counters and one-off execution receipts at write time."""
+
+    if not isinstance(value, str):
+        return False
+    return bool(_DERIVED_OVERDUE_RE.search(value) or _EXECUTION_RECEIPT_RE.search(value))
+
+
 _DIAGNOSTIC_CANDIDATE_ALLOWED = _DIAGNOSTIC_CANDIDATE_REQUIRED | frozenset(
     ("reason", "duplicate_memory_id", "update_memory_id")
 )
@@ -2268,9 +2317,14 @@ class Processor:
         )
         requests: list[dict[str, Any]] = []
         observed_scopes: list[str] = []
+        read_only_query = _automatic_read_only_query(events)
         for candidate in gate["candidates"]:
             candidate_id_key = str(candidate.get("candidate_id", "")).casefold()
             detached_update_target_id = detached_update_target_ids.get(candidate_id_key)
+            if candidate.get("worth") and (
+                read_only_query or _automatic_transient_memory(candidate.get("memory"))
+            ):
+                continue
             # A combined mailbox/daily digest is not an atomic memory.  If a
             # concrete action was worth retaining, the gate must emit it as
             # its own candidate; the aggregate shell itself is NO_CHANGE.
@@ -2566,6 +2620,10 @@ class Processor:
                 f"{summary.get('title', '')}\n{summary.get('body', '')}"
             ):
                 continue
+            if _automatic_transient_memory(
+                f"{summary.get('title', '')}\n{summary.get('body', '')}"
+            ):
+                continue
             if gate_update_target is not None:
                 summary_update_target = summary.get("update_memory_id")
                 if summary_update_target is None:

{memleaf-0.2.15 → memleaf-0.2.16/src/memleaf.egg-info}/PKG-INFO

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

{memleaf-0.2.15 → memleaf-0.2.16}/tests/test_admission_noise.py

@@ -305,7 +305,160 @@ class AdmissionFlowTests(unittest.TestCase):
         self.assertEqual(len(memories), 1)
         self.assertIn("交付延期风险", memories[0].memory.body)
 
-    def test_combined_orion_digest_is_dropped_but_atomic_action_is_kept(self):
+    def test_pure_operational_query_cannot_reingest_assistant_snapshot(self):
+        service = self.make_service("pure-operational-query")
+        existing = service.create_memory(
+            memory_id="mem-puyin-overdue",
+            title="浦银安盛测试数据",
+            body="浦银安盛需要提供一版可靠测试数据。",
+            tags=["project"],
+            type="todo",
+        )
+        backend = QueueBackend()
+        user_key, assistant_key = self.capture_turn(
+            service,
+            session="pure-operational-query",
+            turn="turn-1",
+            user="我有没有近期比较紧急的事情要处理？",
+            assistant=(
+                "巡检汇总：浦银安盛任务逾期5天；泰信基金任务逾期33天，"
+                "状态已驳回、无负责人；中银国际历史数据和附件需要全部迁移。"
+            ),
+        )
+        backend.responses.append(
+            gate(
+                [
+                    candidate(
+                        "repeated-task",
+                        [user_key, assistant_key],
+                        memory="浦银安盛需要提供一版可靠测试数据，逾期5天。",
+                        type="todo",
+                    ),
+                    candidate(
+                        "daily-overdue",
+                        [user_key, assistant_key],
+                        memory="泰信基金任务逾期33天，状态已驳回、无负责人。",
+                        type="todo",
+                    ),
+                    candidate(
+                        "assistant-only-plan",
+                        [user_key, assistant_key],
+                        memory="中银国际历史数据和附件需要全部迁移。",
+                        type="project",
+                    ),
+                ]
+            )
+        )
+
+        result = service.process(source="hermes", session_id="pure-operational-query", model=backend)
+
+        self.assertEqual(result["memory_ids"], [])
+        self.assertEqual(result["memories_written"], 0)
+        self.assertEqual(service.read(existing.memory_id).body, existing.body)
+        self.assertEqual([call["purpose"] for call in backend.calls], ["gate"])
+
+    def test_query_with_user_confirmed_durable_fact_remains_admissible(self):
+        service = self.make_service("query-with-confirmation")
+        backend = QueueBackend()
+        user_key, assistant_key = self.capture_turn(
+            service,
+            session="query-with-confirmation",
+            turn="turn-1",
+            user="以后处理项目邮件请保持简洁，可以吗？",
+            assistant="可以，之后项目邮件保持简洁。",
+        )
+        backend.responses.extend(
+            [
+                gate(
+                    [
+                        candidate(
+                            "confirmed-preference",
+                            [user_key, assistant_key],
+                            memory="用户偏好项目邮件保持简洁。",
+                            type="preference",
+                        )
+                    ]
+                ),
+                summary(
+                    user_key,
+                    title="项目邮件保持简洁",
+                    body="用户偏好项目邮件保持简洁。",
+                    type="preference",
+                ),
+            ]
+        )
+
+        result = service.process(source="hermes", session_id="query-with-confirmation", model=backend)
+
+        self.assertEqual(result["memories_written"], 1)
+        self.assertEqual(service._read_memories_unlocked("knowledge")[0].memory.type, "preference")
+
+    def test_dynamic_overdue_only_update_is_ignored(self):
+        service = self.make_service("dynamic-overdue-update")
+        old = service.create_memory(
+            memory_id="mem-taixin-overdue",
+            title="泰信基金申请日期展示问题",
+            body="泰信基金申请日期展示问题逾期26天。",
+            tags=["operational"],
+            type="todo",
+        )
+        backend = QueueBackend()
+        user_key, assistant_key = self.capture_turn(
+            service,
+            session="dynamic-overdue-update",
+            turn="turn-1",
+            user="查询泰信基金当前任务状态。",
+            assistant="泰信基金申请日期展示问题现在逾期33天。",
+        )
+        backend.responses.append(
+            gate(
+                [
+                    candidate(
+                        "taixin-status",
+                        [user_key, assistant_key],
+                        memory="泰信基金申请日期展示问题逾期33天。",
+                        type="todo",
+                        update_memory_id=old.memory_id,
+                    )
+                ]
+            )
+        )
+
+        result = service.process(source="hermes", session_id="dynamic-overdue-update", model=backend)
+
+        self.assertEqual(result["memory_ids"], [])
+        self.assertEqual(result["memories_written"], 0)
+        self.assertEqual(service.read(old.memory_id).body, old.body)
+
+    def test_one_time_execution_receipt_is_not_persisted(self):
+        service = self.make_service("execution-receipt")
+        backend = QueueBackend()
+        user_key, assistant_key = self.capture_turn(
+            service,
+            session="execution-receipt",
+            turn="turn-1",
+            user="把供数清单发给刘洋。",
+            assistant="邮件已发送，已归档核验，服务器已接受提交。",
+        )
+        backend.responses.append(
+            gate(
+                [
+                    candidate(
+                        "sent-receipt",
+                        [user_key, assistant_key],
+                        memory="供数清单邮件已发送并完成归档核验。",
+                        type="fact",
+                    )
+                ]
+            )
+        )
+
+        result = service.process(source="hermes", session_id="execution-receipt", model=backend)
+
+        self.assertEqual(result["memory_ids"], [])
+        self.assertEqual(result["memories_written"], 0)
+
+    def test_read_only_orion_digest_does_not_reingest_atomic_assistant_action(self):
         service = self.make_service("orion-digest")
         backend = QueueBackend()
         user_key, _ = self.capture_turn(
@@ -329,34 +482,14 @@ class AdmissionFlowTests(unittest.TestCase):
             type="todo",
         )
         atomic["scopes"] = ["project:orion"]
-        atomic_summary = json.loads(
-            summary(
-                user_key,
-                title="Orion提供旧版本生产取数脚本",
-                body="Orion需要提供旧版本生产取数脚本。",
-                type="todo",
-            )
-        )
-        atomic_summary.update(
-            {
-                "scopes": ["project:orion"],
-                "status": "active",
-            }
-        )
-        backend.responses.extend(
-            [gate([aggregate, atomic]), json.dumps(atomic_summary, ensure_ascii=False)]
-        )
+        backend.responses.append(gate([aggregate, atomic]))
 
         result = service.process(source="hermes", session_id="orion-digest", model=backend)
 
-        self.assertEqual(result["memories_written"], 1)
+        self.assertEqual(result["memories_written"], 0)
         self.assertEqual(result["deferred_candidates"], 0)
-        memories = service._read_memories_unlocked("knowledge")
-        self.assertEqual(len(memories), 1)
-        self.assertEqual(memories[0].memory.title, "Orion提供旧版本生产取数脚本")
-        self.assertNotIn("汇总", memories[0].memory.title)
-        self.assertNotIn("完成4条", memories[0].memory.body)
-        self.assertEqual([call["purpose"] for call in backend.calls], ["gate", "summarize"])
+        self.assertEqual(service._read_memories_unlocked("knowledge"), [])
+        self.assertEqual([call["purpose"] for call in backend.calls], ["gate"])
 
     def test_attachment_only_followup_is_dropped_before_summary(self):
         service = self.make_service("attachment-followup")
@@ -412,7 +545,7 @@ class AdmissionFlowTests(unittest.TestCase):
 
         self.assertEqual(result["memories_written"], 0)
         self.assertEqual(service._read_memories_unlocked("knowledge"), [])
-        self.assertEqual([call["purpose"] for call in backend.calls], ["gate", "summarize"])
+        self.assertEqual([call["purpose"] for call in backend.calls], ["gate"])
 
     def test_attachment_with_owner_deadline_and_remediation_remains_admissible(self):
         service = self.make_service("attachment-action")
@@ -421,8 +554,8 @@ class AdmissionFlowTests(unittest.TestCase):
             service,
             session="attachment-action",
             turn="turn-1",
-            user="鑫元基金SIT问题清单怎么处理？",
-            assistant="张三需在2026-09-03前逐项整改SIT问题清单。",
+            user="已确认张三需在2026-09-03前逐项整改鑫元基金SIT问题清单，还要补充什么吗？",
+            assistant="该负责人、期限和整改要求已经明确。",
         )
         item = candidate(
             "xinyuan-sit-remediation",

{memleaf-0.2.15 → memleaf-0.2.16}/tests/test_hermes_provider.py

@@ -303,11 +303,11 @@ class HermesProviderTests(unittest.TestCase):
 
     def test_provider_does_not_warn_when_core_versions_match(self) -> None:
         client = FakeClient(responses=[{"stats": True}])
-        client.server_version = "0.2.15"
+        client.server_version = "0.2.16"
         provider = provider_module.MemleafMemoryProvider()
         with patch.object(provider_module, "_resolve_command", return_value="memleaf-mcp"), \
              patch.object(provider_module, "_MCPClient", return_value=client), \
-             patch.object(provider_module, "_provider_manifest_version", return_value="0.2.15"), \
+             patch.object(provider_module, "_provider_manifest_version", return_value="0.2.16"), \
              patch.object(provider_module.logger, "warning") as warning:
             provider.initialize(
                 "version-match-session",
@@ -324,7 +324,7 @@ class HermesProviderTests(unittest.TestCase):
         provider = provider_module.MemleafMemoryProvider()
         with patch.object(provider_module, "_resolve_command", return_value="memleaf-mcp"), \
              patch.object(provider_module, "_MCPClient", return_value=client), \
-             patch.object(provider_module, "_provider_manifest_version", return_value="0.2.15"), \
+             patch.object(provider_module, "_provider_manifest_version", return_value="0.2.16"), \
              patch.object(provider_module.logger, "warning") as warning:
             provider.initialize(
                 "version-missing-session",
@@ -1481,7 +1481,7 @@ class HermesProviderTests(unittest.TestCase):
         )
         self.assertEqual(provider_module._hermes_read_status(empty), "missing_result")
 
-    def test_read_diagnostics_keep_token_after_client_reconnect_and_log_repeated_reads(self) -> None:
+    def test_read_diagnostics_keep_token_after_client_reconnect_without_relogging_history(self) -> None:
         provider = self.provider(
             responses=[{"stored": True}, {"stored": True}, {"processed_turns": 1}] * 2
         )
@@ -1538,11 +1538,82 @@ class HermesProviderTests(unittest.TestCase):
 
         output = "\n".join(call.args[0] % call.args[1:] for call in info.call_args_list)
         read_logs = [line for line in output.splitlines() if "retrieval-read" in line]
-        self.assertEqual(len(read_logs), 4)
+        self.assertEqual(len(read_logs), 2)
         self.assertTrue(all("retrieval_present=True" in line for line in read_logs))
         self.assertTrue(all("retrieval_match=True" in line for line in read_logs))
         self.assertNotIn("rtv-reconnect", output)
 
+    def test_read_diagnostics_skip_cumulative_history_but_keep_current_wrong_token(self) -> None:
+        old_call = {
+            "id": "read-old",
+            "function": {
+                "name": "mcp__memleaf__read",
+                "arguments": json.dumps(
+                    {"memory_id": "MEMORY_OLD", "retrieval_id": "rtv-old"}
+                ),
+            },
+        }
+        current_call = {
+            "id": "read-current",
+            "function": {
+                "name": "mcp__memleaf__read",
+                "arguments": json.dumps(
+                    {"memory_id": "MEMORY_CURRENT", "retrieval_id": "rtv-current"}
+                ),
+            },
+        }
+        wrong_token_call = {
+            "id": "read-current-wrong-token",
+            "function": {
+                "name": "mcp__memleaf__read",
+                "arguments": json.dumps(
+                    {"memory_id": "MEMORY_WRONG", "retrieval_id": "rtv-other"}
+                ),
+            },
+        }
+        first_messages = [
+            {"role": "assistant", "tool_calls": [old_call]},
+            {
+                "role": "tool",
+                "tool_call_id": "read-old",
+                "content": json.dumps({"memory_id": "MEMORY_OLD", "body": "old"}),
+            },
+        ]
+        cumulative_messages = [
+            *first_messages,
+            {"role": "assistant", "tool_calls": [current_call, wrong_token_call]},
+            {
+                "role": "tool",
+                "tool_call_id": "read-current",
+                "content": json.dumps({"memory_id": "MEMORY_CURRENT", "body": "current"}),
+            },
+            {
+                "role": "tool",
+                "tool_call_id": "read-current-wrong-token",
+                "content": json.dumps({"memory_id": "MEMORY_WRONG", "body": "wrong"}),
+            },
+        ]
+        seen_call_keys: set[str] = set()
+
+        with patch.object(provider_module.logger, "info") as info:
+            provider_module.MemleafMemoryProvider._observe_search_messages(
+                first_messages,
+                "rtv-old",
+                seen_call_keys=seen_call_keys,
+            )
+            provider_module.MemleafMemoryProvider._observe_search_messages(
+                cumulative_messages,
+                "rtv-current",
+                seen_call_keys=seen_call_keys,
+            )
+
+        output = "\n".join(call.args[0] % call.args[1:] for call in info.call_args_list)
+        read_logs = [line for line in output.splitlines() if "retrieval-read" in line]
+        self.assertEqual(len(read_logs), 3)
+        self.assertIn("retrieval_match=True result=ok", read_logs[0])
+        self.assertIn("retrieval_match=True result=ok", read_logs[1])
+        self.assertIn("retrieval_match=False result=uncontrolled_success", read_logs[2])
+
     def test_file_tools_only_mark_paths_inside_configured_vault_as_bypass(self) -> None:
         vault = self.root / "configured-vault"
         vault.mkdir()

{memleaf-0.2.15 → memleaf-0.2.16}/tests/test_pypi_install.py

@@ -81,7 +81,7 @@ class PyPIInstallTests(unittest.TestCase):
 
             self.assertTrue(target.is_dir())
             self.assertFalse(target.is_symlink())
-            self.assertIn("version: 0.2.15", (target / "plugin.yaml").read_text(encoding="utf-8"))
+            self.assertIn("version: 0.2.16", (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:
@@ -212,16 +212,16 @@ class PyPIInstallTests(unittest.TestCase):
             "status": "configured",
             "reason": "ok",
             "vault": "/tmp/memleaf-vault",
-            "core_version": "0.2.15",
-            "provider_version": "0.2.15",
+            "core_version": "0.2.16",
+            "provider_version": "0.2.16",
             "model": {"status": "configured"},
         }
         with mock.patch("memleaf.installer.install_hermes", return_value=result), \
              mock.patch("sys.stdout") as stdout:
             self.assertEqual(cli.main(["install"]), 0)
         output = "\n".join(str(call.args[0]) for call in stdout.write.call_args_list)
-        self.assertIn("core=0.2.15", output)
-        self.assertIn("Hermes provider=0.2.15", output)
+        self.assertIn("core=0.2.16", output)
+        self.assertIn("Hermes provider=0.2.16", output)
 
     def test_readmes_document_one_line_core_and_provider_upgrade(self) -> None:
         command = "python -m pip install -U memleaf && python -m memleaf install"

{memleaf-0.2.15 → memleaf-0.2.16}/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.15"},
+            {"name": "memleaf", "version": "0.2.16"},
         )
         return result
 

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