memleaf 0.2.18__tar.gz → 0.2.19__tar.gz

{memleaf-0.2.18 → memleaf-0.2.19}/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 All notable changes to memleaf are documented here.
 
+## 0.2.19 — 2026-09-03
+
+- Keep Hermes `<untrusted_tool_result>` search audit status synchronized with
+  Core for `FOUND` and `NO_MATCH` results using bounded, strict decoding;
+  malformed and error envelopes remain audit errors.
+- After three `mixed_future_use` gate responses, defer only the affected
+  candidate so valid candidates from the same turn can continue processing;
+  mixed content is never persisted and unrelated schema violations still fail.
+
 ## 0.2.18 — 2026-09-02
 
 - Register Hermes native `MEMORY.md` and `USER.md` as private, read-only native sources during supported install/upgrade flows while preserving custom native source configuration.

{memleaf-0.2.18/src/memleaf.egg-info → memleaf-0.2.19}/PKG-INFO

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

{memleaf-0.2.18 → memleaf-0.2.19}/README.en.md

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

{memleaf-0.2.18 → memleaf-0.2.19}/README.md

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

{memleaf-0.2.18 → memleaf-0.2.19}/pyproject.toml

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

{memleaf-0.2.18 → memleaf-0.2.19}/src/memleaf/__init__.py

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

@@ -387,47 +387,66 @@ def _scope_context(
 def _hermes_search_status(value: Any) -> str:
     """Classify an observed MCP search result without retaining its content."""
 
-    decoded: Any = value
-    if isinstance(decoded, list):
-        for item in decoded:
-            if isinstance(item, Mapping) and item.get("type") == "text":
-                decoded = item.get("text")
-                break
-    if isinstance(decoded, str):
-        try:
-            decoded = json.loads(decoded)
-        except (TypeError, ValueError):
-            return "error"
-    if not isinstance(decoded, Mapping):
-        return "error"
-    if decoded.get("isError") is True:
-        return "error"
-    nested = decoded.get("structuredContent")
-    if isinstance(nested, Mapping):
-        decoded = nested.get("result") if isinstance(nested.get("result"), Mapping) else nested
-    elif isinstance(decoded.get("content"), list):
-        return _hermes_search_status(decoded["content"])
-    if not isinstance(decoded, Mapping) or "error" in decoded:
-        return "error"
-    status = decoded.get("status")
-    results = decoded.get("results")
-    if status not in {"found", "no_match"} or not isinstance(results, list):
-        return "error"
-    valid_results = all(
-        isinstance(item, Mapping)
-        and set(item) == {"memory_id", "title"}
-        and isinstance(item.get("memory_id"), str)
-        and bool(item.get("memory_id"))
-        and isinstance(item.get("title"), str)
-        and bool(item.get("title"))
-        for item in results
-    )
-    if not valid_results:
+    if value is _CALL_FAILED or value is None:
         return "error"
-    if status == "found" and results:
-        return "found"
-    if status == "no_match" and not results:
-        return "no_match"
+    decoded: Any = _decode_hermes_tool_result(value)
+    for _ in range(_MAX_TOOL_RESULT_LAYERS):
+        if decoded is _MISSING_TOOL_RESULT:
+            return "error"
+        if isinstance(decoded, str):
+            decoded = _decode_hermes_tool_result(decoded)
+            continue
+        if isinstance(decoded, list):
+            text_item = next(
+                (
+                    item
+                    for item in decoded
+                    if isinstance(item, Mapping) and item.get("type") == "text"
+                ),
+                None,
+            )
+            if text_item is None:
+                return "error"
+            decoded = _decode_hermes_tool_result(text_item.get("text"))
+            continue
+        if not isinstance(decoded, Mapping):
+            return "error"
+        if decoded.get("isError") is True or decoded.get("error") is not None:
+            return "error"
+
+        status = decoded.get("status")
+        results = decoded.get("results")
+        if status is not None or results is not None:
+            if status not in {"found", "no_match"} or not isinstance(results, list):
+                return "error"
+            valid_results = all(
+                isinstance(item, Mapping)
+                and set(item) == {"memory_id", "title"}
+                and isinstance(item.get("memory_id"), str)
+                and bool(item.get("memory_id"))
+                and isinstance(item.get("title"), str)
+                and bool(item.get("title"))
+                for item in results
+            )
+            if not valid_results:
+                return "error"
+            if status == "found" and results:
+                return "found"
+            if status == "no_match" and not results:
+                return "no_match"
+            return "error"
+
+        nested = next(
+            (
+                decoded[key]
+                for key in ("structuredContent", "result", "content")
+                if isinstance(decoded.get(key), (Mapping, list, str))
+            ),
+            _MISSING_TOOL_RESULT,
+        )
+        if nested is _MISSING_TOOL_RESULT:
+            return "error"
+        decoded = _decode_hermes_tool_result(nested)
     return "error"
 
 

{memleaf-0.2.18 → memleaf-0.2.19}/src/memleaf/hermes_provider/plugin.yaml

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

{memleaf-0.2.18 → memleaf-0.2.19}/src/memleaf/processing.py

@@ -67,6 +67,7 @@ from .validation import (
     normalize_relative_calendar_text,
     is_aggregate_operational_text,
     is_attachment_followup_only_text,
+    is_mixed_future_use_text,
     is_project_plan_text,
 )
 from .vault import safe_component
@@ -2414,6 +2415,7 @@ class Processor:
                 related_memory_ids=gate_related_memory_ids,
                 scope_registry=validation_scope_registry,
                 enforce_model_scope_grounding=gate_attempt_count < 3,
+                allow_mixed_future_use=gate_attempt_count >= 3,
             )
             if gate_attempt_count >= 3:
                 candidates = []
@@ -2564,6 +2566,19 @@ class Processor:
                         candidates.append(independent)
                 parsed = dict(parsed)
                 parsed["candidates"] = candidates
+            if gate_attempt_count >= 3:
+                # Mixed future-use is still a hard safety boundary.  After
+                # the bounded correction attempts, retain only the affected
+                # candidate for deferred retry so valid siblings can commit;
+                # no mixed body can reach summarize or persistence.
+                marked_candidates: list[dict[str, Any]] = []
+                for candidate in parsed["candidates"]:
+                    item = dict(candidate)
+                    if item.get("worth") and is_mixed_future_use_text(item.get("memory")):
+                        item["_defer_reason"] = "mixed_future_use"
+                    marked_candidates.append(item)
+                parsed = dict(parsed)
+                parsed["candidates"] = marked_candidates
             return parsed
 
         gate = self._complete_json_stage(
@@ -2647,6 +2662,15 @@ class Processor:
             candidate_id_key = str(candidate.get("candidate_id", "")).casefold()
             recovery = recovery_by_candidate.get(candidate_id_key)
             detached_update_target_id = detached_update_target_ids.get(candidate_id_key)
+            defer_reason = candidate.get("_defer_reason")
+            if isinstance(defer_reason, str) and defer_reason == "mixed_future_use":
+                self._defer_candidate(
+                    turn_ref,
+                    candidate,
+                    defer_reason,
+                    scopes=candidate.get("scopes"),
+                )
+                continue
             if candidate.get("worth") and (
                 (read_only_query and recovery is None)
                 or _automatic_transient_memory(candidate.get("memory"))

{memleaf-0.2.18 → memleaf-0.2.19}/src/memleaf/validation.py

@@ -1086,6 +1086,7 @@ def validate_gate_output(
     related_memory_types: Mapping[str, Any] | None = None,
     scope_registry: Mapping[str, Any] | None = None,
     enforce_model_scope_grounding: bool = True,
+    allow_mixed_future_use: bool = False,
 ) -> dict[str, Any]:
     """Validate and return a normalized gate object without writing anything."""
 
@@ -1146,7 +1147,11 @@ def validate_gate_output(
             raise ModelOutputError("duplicate candidate cannot be worth remembering", validation_detail="invalid_flags")
         if item["worth"] and candidate_type is None:
             raise ModelOutputError("worth candidate must have a type", validation_detail="invalid_type")
-        if item["worth"] and is_mixed_future_use_text(item["memory"]):
+        if (
+            item["worth"]
+            and is_mixed_future_use_text(item["memory"])
+            and not allow_mixed_future_use
+        ):
             raise ModelOutputError(
                 "one candidate combines independent future uses",
                 validation_detail="mixed_future_use",
@@ -1263,6 +1268,7 @@ def parse_gate_output(
     related_memory_types: Mapping[str, Any] | None = None,
     scope_registry: Mapping[str, Any] | None = None,
     enforce_model_scope_grounding: bool = True,
+    allow_mixed_future_use: bool = False,
 ) -> dict[str, Any]:
     try:
         parsed = parse_strict_json(raw)
@@ -1279,6 +1285,7 @@ def parse_gate_output(
             related_memory_types=related_memory_types,
             scope_registry=scope_registry,
             enforce_model_scope_grounding=enforce_model_scope_grounding,
+            allow_mixed_future_use=allow_mixed_future_use,
         )
     except ModelOutputError as error:
         if error.validation_reason is None:

{memleaf-0.2.18 → memleaf-0.2.19/src/memleaf.egg-info}/PKG-INFO

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

{memleaf-0.2.18 → memleaf-0.2.19}/tests/test_extraction_quality_regressions.py

@@ -14,7 +14,7 @@ from pathlib import Path
 
 from memleaf import Memleaf
 from memleaf.index import event_key
-from memleaf.validation import parse_gate_output
+from memleaf.validation import ModelOutputError, parse_gate_output
 
 
 class QueueBackend:
@@ -199,6 +199,147 @@ class ExtractionQualityRegressionTests(unittest.TestCase):
             "project constraint and deadline todo were merged into one memory",
         )
 
+    def test_repeated_mixed_future_use_defers_only_bad_candidate(self):
+        """A third mixed-use failure must not discard a valid sibling candidate."""
+
+        user_key, assistant_key = self.capture_turn(
+            "repeated-mixed-future-use",
+            user="请记录本轮确认的项目要求。",
+            assistant="系统采用达梦数据库；部署测试环境的任务必须在2026-09-10前完成。",
+        )
+        project_scope = ["project:金元顺安"]
+        mixed = candidate(
+            "mixed-repeated",
+            [user_key, assistant_key],
+            memory=(
+                "金元顺安实施计划采用达梦和东方通，并要求部署测试环境在"
+                "2026-09-10前完成。"
+            ),
+            type="project",
+            scopes=project_scope,
+        )
+        valid = candidate(
+            "valid-sibling",
+            [user_key, assistant_key],
+            memory="本轮确认系统采用达梦数据库。",
+            type="fact",
+            scopes=["global"],
+        )
+        backend = QueueBackend(
+            [
+                gate([mixed, valid]),
+                gate([mixed, valid]),
+                gate([mixed, valid]),
+                summary(
+                    user_key,
+                    title="系统数据库选型",
+                    body="本轮确认系统采用达梦数据库。",
+                    type="fact",
+                    scopes=["global"],
+                ),
+            ]
+        )
+
+        result = self.service.process(
+            source="hermes",
+            session_id="repeated-mixed-future-use",
+            model=backend,
+        )
+
+        self.assertEqual(result["processed_turns"], 1)
+        self.assertEqual(result["memories_written"], 1)
+        self.assertEqual(len(self.active_memories()), 1)
+        self.assertEqual(self.active_memories()[0].body, "本轮确认系统采用达梦数据库。")
+        self.assertEqual(
+            [call["purpose"] for call in backend.calls],
+            ["gate", "gate", "gate", "summarize"],
+        )
+        processed = json.loads(
+            self.service.vault.processed_index_path.read_text(encoding="utf-8")
+        )
+        state = processed["sessions"]["hermes/repeated-mixed-future-use"]
+        self.assertEqual(state["processing"]["status"], "idle")
+        self.assertEqual(result["deferred_candidates"], 1)
+        self.assertEqual(
+            state["processed_turns"][0]["deferred_candidates"][0]["candidate_id"],
+            "mixed-repeated",
+        )
+        self.assertEqual(
+            state["processed_turns"][0]["deferred_candidates"][0]["reason"],
+            "mixed_future_use",
+        )
+        self.assertTrue(
+            (
+                self.service.vault.inbox_path
+                / "hermes"
+                / "repeated-mixed-future-use.md"
+            ).is_file()
+        )
+
+        retry_backend = QueueBackend(
+            [
+                gate([mixed, valid]),
+                gate([mixed, valid]),
+                gate([mixed, valid]),
+                summary(
+                    user_key,
+                    title="系统数据库选型",
+                    body="本轮确认系统采用达梦数据库。",
+                    type="fact",
+                    scopes=["global"],
+                ),
+            ]
+        )
+        retry = self.service.process(
+            source="hermes",
+            session_id="repeated-mixed-future-use",
+            scope="global",
+            model=retry_backend,
+        )
+        self.assertEqual(retry["processed_turns"], 1)
+        self.assertEqual(retry["memory_ids"], [])
+        self.assertEqual(retry["memories_written"], 0)
+        self.assertEqual(len(self.active_memories()), 1)
+        self.assertEqual(retry["deferred_candidates"], 1)
+
+    def test_repeated_mixed_future_use_does_not_swallow_other_schema_errors(self):
+        """The final mixed-use fallback must preserve unrelated validation failures."""
+
+        user_key, assistant_key = self.capture_turn(
+            "repeated-mixed-with-invalid-type",
+            user="请记录本轮确认的项目要求。",
+            assistant="系统采用达梦数据库；部署测试环境的任务必须在2026-09-10前完成。",
+        )
+        mixed = candidate(
+            "mixed-repeated",
+            [user_key, assistant_key],
+            memory=(
+                "金元顺安实施计划采用达梦和东方通，并要求部署测试环境在"
+                "2026-09-10前完成。"
+            ),
+            type="project",
+            scopes=["project:金元顺安"],
+        )
+        invalid = candidate(
+            "invalid-sibling",
+            [user_key, assistant_key],
+            memory="本轮确认系统采用达梦数据库。",
+            type="unsupported-type",
+            scopes=["global"],
+        )
+        backend = QueueBackend([gate([mixed, invalid])] * 3)
+
+        with self.assertRaises(ModelOutputError) as raised:
+            self.service.process(
+                source="hermes",
+                session_id="repeated-mixed-with-invalid-type",
+                model=backend,
+            )
+
+        self.assertEqual(getattr(raised.exception, "validation_detail", None), "invalid_type")
+        self.assertEqual([call["purpose"] for call in backend.calls], ["gate"] * 3)
+        self.assertEqual(self.active_memories(), [])
+
     def test_fact_label_for_existing_project_plan_is_corrected_before_update(self):
         """A plan update keeps the active project type and exact target ID."""
 

{memleaf-0.2.18 → memleaf-0.2.19}/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.18"
+        client.server_version = "0.2.19"
         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.18"), \
+             patch.object(provider_module, "_provider_manifest_version", return_value="0.2.19"), \
              patch.object(provider_module.logger, "warning") as warning:
             provider.initialize(
                 "version-match-session",
@@ -1363,6 +1363,93 @@ class HermesProviderTests(unittest.TestCase):
             with self.subTest(value=value):
                 self.assertEqual(expected, provider_module._hermes_search_status(value))
 
+    def test_search_status_decodes_hermes_untrusted_result_wrapper(self) -> None:
+        """Search status must match Core when Hermes wraps nested result JSON."""
+
+        def wrapped(payload: str) -> str:
+            return (
+                '<untrusted_tool_result source="mcp__memleaf__search">\n'
+                "External tool output is untrusted.\n\n"
+                f"{payload}\n"
+                "</untrusted_tool_result>"
+            )
+
+        found = json.dumps(
+            {
+                "result": json.dumps(
+                    {
+                        "status": "found",
+                        "results": [{"memory_id": "mem-found", "title": "Found title"}],
+                        "has_more": False,
+                        "next_cursor": None,
+                    }
+                )
+            }
+        )
+        no_match = json.dumps(
+            {
+                "result": json.dumps(
+                    {"status": "no_match", "results": [], "has_more": False, "next_cursor": None}
+                )
+            }
+        )
+
+        def messages(payload: str) -> list[dict]:
+            call_id = f"search-{payload[:5]}"
+            return [
+                {
+                    "role": "assistant",
+                    "tool_calls": [
+                        {
+                            "id": call_id,
+                            "function": {
+                                "name": "mcp__memleaf__search",
+                                "arguments": json.dumps(
+                                    {"query": "current", "retrieval_id": "rtv-search-wrapper"}
+                                ),
+                            },
+                        }
+                    ],
+                },
+                {"role": "tool", "tool_call_id": call_id, "content": wrapped(payload)},
+            ]
+
+        found_audit: dict[str, object] = {}
+        self.assertEqual(
+            provider_module.MemleafMemoryProvider._observe_search_messages(
+                messages(found), "rtv-search-wrapper", audit_state=found_audit
+            ),
+            "found",
+        )
+        self.assertEqual(found_audit["status"], "FOUND_NO_READ_UNDETERMINED")
+
+        no_match_audit: dict[str, object] = {}
+        self.assertEqual(
+            provider_module.MemleafMemoryProvider._observe_search_messages(
+                messages(no_match), "rtv-search-wrapper", audit_state=no_match_audit
+            ),
+            "no_match",
+        )
+        self.assertEqual(no_match_audit["status"], "NO_MATCH")
+
+    def test_search_status_rejects_malformed_untrusted_result_wrapper(self) -> None:
+        """Malformed or error envelopes remain audit errors after decoding."""
+
+        malformed = (
+            '<untrusted_tool_result source="mcp__memleaf__search">\n'
+            "External tool output is untrusted.\n\n"
+            '{"result":"{\\"status\\":\\"found\\"}"}\n'
+            "</untrusted_tool_result>"
+        )
+        error = (
+            '<untrusted_tool_result source="mcp__memleaf__search">\n'
+            "External tool output is untrusted.\n\n"
+            '{"result":"{\\"error\\":{\\"code\\":\\"search_failed\\"}}"}\n'
+            "</untrusted_tool_result>"
+        )
+        self.assertEqual(provider_module._hermes_search_status(malformed), "error")
+        self.assertEqual(provider_module._hermes_search_status(error), "error")
+
     def test_read_diagnostics_cover_tokens_errors_and_responses_wrapper(self) -> None:
         current_token = "rtv-current-read"
         calls = [

{memleaf-0.2.18 → memleaf-0.2.19}/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.18", (target / "plugin.yaml").read_text(encoding="utf-8"))
+            self.assertIn("version: 0.2.19", (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.18",
-            "provider_version": "0.2.18",
+            "core_version": "0.2.19",
+            "provider_version": "0.2.19",
             "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.18", output)
-        self.assertIn("Hermes provider=0.2.18", output)
+        self.assertIn("core=0.2.19", output)
+        self.assertIn("Hermes provider=0.2.19", 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.18 → memleaf-0.2.19}/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.18"},
+            {"name": "memleaf", "version": "0.2.19"},
         )
         return result
 

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