memleaf 0.2.67__tar.gz → 0.2.68__tar.gz

{memleaf-0.2.67 → memleaf-0.2.68}/CHANGELOG.md

@@ -4,6 +4,23 @@ All notable changes to memleaf are documented here.
 
 ## Unreleased
 
+## 0.2.68 — 2026-09-20
+
+### Hermes live-path hardening
+
+- Observe Hermes deferred `tool_call` single-entry `calls[]` wrappers so real
+  memleaf search results are recorded as `NO_MATCH`/found instead of
+  `SEARCH_UNKNOWN`.
+- Deterministically normalize only unambiguous flattened CREATE rows back into
+  the required `memory` object before the unchanged strict incremental validator;
+  malformed, incomplete and unknown-field variants remain fail-closed.
+- Strip the trailing Hermes `<!--CLEAN-->` control marker at the Provider capture
+  boundary so it does not enter Inbox or memory extraction input.
+- Validate the fixes with a real Hermes + DeepSeek Flash turn: retrieval audit
+  `NO_MATCH`, completed incremental extraction, three settled CREATE operations,
+  zero unresolved evidence and no CLEAN marker in Inbox.
+
+
 ## 0.2.67 — 2026-09-20
 
 ### Incremental-only processing and release integrity

{memleaf-0.2.67/src/memleaf.egg-info → memleaf-0.2.68}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 0.2.67
+Version: 0.2.68
 Summary: A local-first Markdown memory core for AI agents
 Author: memleaf contributors
 License-Expression: MIT

{memleaf-0.2.67 → memleaf-0.2.68}/pyproject.toml

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

{memleaf-0.2.67 → memleaf-0.2.68}/src/memleaf/__init__.py

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

@@ -19,6 +19,16 @@ except (ImportError, ValueError):
         _spec.loader.exec_module(_module)
     globals().update({name: getattr(_module, name) for name in getattr(_module, "__all__", ())})
 
+def _capture_assistant_text(value: str) -> str:
+    """Remove Hermes' terminal internal cleanliness marker from memory input."""
+    import re
+
+    if not isinstance(value, str):
+        return value
+    return re.sub(r"(?:\r?\n)?\s*<!--\s*CLEAN\s*-->\s*$", "", value,
+                  flags=re.IGNORECASE)
+
+
 def _sync_source_metadata(messages: Any, user_content: str, assistant_content: str) -> dict[str, dict[str, Any]]:
     """Read optional host metadata only from the exact visible tail pair.
 
@@ -1618,9 +1628,11 @@ class MemleafMemoryProvider(MemoryProvider):
         # Never capture the raw message list as business conversation content.
         if not self._write_enabled or self._client is None:
             return
+        raw_assistant_content = assistant_content
+        captured_assistant_content = _capture_assistant_text(assistant_content)
         visible_events = [
             ("user", user_content),
-            ("assistant", assistant_content),
+            ("assistant", captured_assistant_content),
         ]
         if any(not isinstance(content, str) or not content.strip() for _, content in visible_events):
             return
@@ -1640,9 +1652,9 @@ class MemleafMemoryProvider(MemoryProvider):
                     effective_session,
                     resolved_turn_number,
                     user_content,
-                    assistant_content,
+                    captured_assistant_content,
                 )
-                source_metadata = _sync_source_metadata(messages, user_content, assistant_content)
+                source_metadata = _sync_source_metadata(messages, user_content, raw_assistant_content)
                 user_source_id = source_metadata.get("user", {}).get("message_id")
                 if user_source_id:
                     # Stable host identity survives a revised body/final reply.

{memleaf-0.2.67 → memleaf-0.2.68}/src/memleaf/hermes_provider/_shared.py

@@ -568,8 +568,26 @@ def _tool_call_parts(value: Any) -> Optional[dict[str, Any]]:
         wrapper = _decode_tool_value(arguments)
         if not isinstance(wrapper, Mapping):
             return None
-        name = wrapper.get("name")
-        arguments = wrapper.get("arguments")
+        # Hermes' deferred-tool bridge advertises a batch envelope even for one
+        # local tool: {"calls": [{"name": ..., "arguments": ...}]}. Local
+        # deferred tools are one entry per outer tool_call, so only unwrap a
+        # single-entry batch. Multi-entry wrapper results cannot be correlated
+        # safely to one inner call and therefore remain diagnostic-unknown.
+        raw_calls = _decode_tool_value(wrapper.get("calls")) if "calls" in wrapper else None
+        if raw_calls is not None:
+            if isinstance(raw_calls, Mapping):
+                raw_calls = [raw_calls]
+            if not isinstance(raw_calls, list) or len(raw_calls) != 1 or not isinstance(raw_calls[0], Mapping):
+                return None
+            inner = raw_calls[0]
+            name = inner.get("name")
+            arguments = inner.get("arguments")
+            inner_id = inner.get("id") or inner.get("call_id")
+            if isinstance(inner_id, str) and inner_id:
+                call_id = inner_id
+        else:
+            name = wrapper.get("name")
+            arguments = wrapper.get("arguments")
     if not isinstance(name, str):
         return None
     arguments = _decode_tool_value(arguments)

{memleaf-0.2.67 → memleaf-0.2.68}/src/memleaf/hermes_provider/plugin.yaml

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

{memleaf-0.2.67 → memleaf-0.2.68}/src/memleaf/incremental_protocol.py

@@ -36,6 +36,30 @@ _BRANCHES = {
     "NO_MEMORY": (set(), set()),
     "DEFERRED": ({"reason", "need"}, {"reason", "need"}),
 }
+
+_CREATE_ROW_META = frozenset(("action", "evidence", "at", "effective"))
+
+
+def _normalize_flat_create_row(row: Any) -> tuple[Any, bool]:
+    """Repair one unambiguous model-only CREATE wrapper mistake.
+
+    This is structural normalization only: it never invents fields, changes
+    values, widens allowed keys, or bypasses the strict CREATE validator.
+    """
+    if not isinstance(row, dict) or "memory" in row:
+        return row, False
+    action = row.get("action")
+    if not isinstance(action, str) or action.strip().upper() != "CREATE":
+        return row, False
+    memory_keys = set(row) & set(_CREATE)
+    required = {"type", "scope", "title", "body"}
+    if not required <= memory_keys:
+        return row, False
+    if set(row) - (_CREATE_ROW_META | set(_CREATE)):
+        return row, False
+    normalized = {key: deepcopy(value) for key, value in row.items() if key not in _CREATE}
+    normalized["memory"] = {key: deepcopy(row[key]) for key in row if key in _CREATE}
+    return normalized, True
 _GROUP = {"status": "status", "validity": "validity", "scopes": "scope",
           "assignee": "responsibility", "waiting_on": "responsibility",
           "deadline": "deadline", "title": "content", "body": "content"}
@@ -553,7 +577,11 @@ def compile_incremental(raw: str, snapshot: PlanningSnapshot) -> dict[str, Any]:
         issues.append({"row": index, "code": code, "evidence": list(dict.fromkeys(refs))})
     for index, row in enumerate(value["items"]):
         try:
-            parsed.append((index, _parse_row(row, state)))
+            normalized_row, normalized = _normalize_flat_create_row(row)
+            parsed_row = _parse_row(normalized_row, state)
+            if normalized:
+                parsed_row.setdefault("warnings", []).append("create_memory_wrapper_normalized")
+            parsed.append((index, parsed_row))
         except (ValueError, TypeError) as error:
             problem(index, str(error) if isinstance(error, ValueError) else "invalid_fields", row)
             if isinstance(row, dict) and isinstance(row.get("target"), str) and row["target"].strip() in state["targets"]:

{memleaf-0.2.67 → memleaf-0.2.68/src/memleaf.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 0.2.67
+Version: 0.2.68
 Summary: A local-first Markdown memory core for AI agents
 Author: memleaf contributors
 License-Expression: MIT

{memleaf-0.2.67 → memleaf-0.2.68}/tests_public/test_hermes_source_metadata.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import importlib
+import json
 import sys
 import tempfile
 import types
@@ -99,6 +100,89 @@ class HermesMetadataTests(unittest.TestCase):
         for invocation in call.call_args_list:
             self.assertNotIn('source_time', invocation.args[1])
 
+    def test_single_entry_tool_call_batch_is_observed_as_no_match(self):
+        retrieval_id = 'retrieval-1'
+        messages = [
+            {
+                'role': 'assistant',
+                'tool_calls': [{
+                    'id': 'bridge-call',
+                    'function': {
+                        'name': 'tool_call',
+                        'arguments': json.dumps({
+                            'calls': [{
+                                'name': 'mcp__memleaf__search',
+                                'arguments': {'query': 'mail status', 'retrieval_id': retrieval_id},
+                            }]
+                        }),
+                    },
+                }],
+            },
+            {
+                'role': 'tool',
+                'tool_call_id': 'bridge-call',
+                'content': json.dumps({'status': 'no_match', 'results': []}),
+            },
+        ]
+        audit = {}
+        status = self.module.MemleafMemoryProvider._observe_search_messages(
+            messages, retrieval_id, audit_state=audit,
+        )
+        self.assertEqual(status, 'no_match')
+        self.assertEqual(audit['status'], 'NO_MATCH')
+
+    def test_multi_entry_tool_call_batch_is_not_misattributed(self):
+        retrieval_id = 'retrieval-1'
+        messages = [
+            {
+                'role': 'assistant',
+                'tool_calls': [{
+                    'id': 'bridge-call',
+                    'function': {
+                        'name': 'tool_call',
+                        'arguments': json.dumps({
+                            'calls': [
+                                {'name': 'mcp__memleaf__search',
+                                 'arguments': {'query': 'mail status', 'retrieval_id': retrieval_id}},
+                                {'name': 'another_tool', 'arguments': {}},
+                            ]
+                        }),
+                    },
+                }],
+            },
+            {
+                'role': 'tool',
+                'tool_call_id': 'bridge-call',
+                'content': json.dumps({'status': 'no_match', 'results': []}),
+            },
+        ]
+        audit = {}
+        status = self.module.MemleafMemoryProvider._observe_search_messages(
+            messages, retrieval_id, audit_state=audit,
+        )
+        self.assertEqual(status, 'unknown')
+        self.assertEqual(audit['status'], 'SEARCH_UNKNOWN')
+
+    def test_clean_marker_is_removed_before_assistant_capture(self):
+        with tempfile.TemporaryDirectory() as root:
+            service = Memleaf.initialize(Path(root) / 'vault')
+            provider = self.module.MemleafMemoryProvider()
+            provider._client = object(); provider._auto_process = False
+            raw_final = 'No new mail.\n\n<!--CLEAN-->'
+            rows = [
+                dict(role='user', content='Check mail', id='u', source_sequence=1),
+                dict(role='assistant', content=raw_final, id='a', source_sequence=2),
+            ]
+            def call(name, args, **kw):
+                self.assertEqual(name, 'capture')
+                result = service.capture(**args)
+                return {'stored': result.stored, 'duplicate': result.duplicate}
+            with patch.object(provider, '_call', side_effect=call):
+                provider.sync_turn('Check mail', raw_final, session_id='s', turn_number=3, messages=rows)
+            turn = parse_inbox(service.vault)[0]
+            self.assertEqual(turn.events[1].content, 'No new mail.')
+            self.assertNotIn('<!--CLEAN-->', turn.events[1].content)
+
 
 if __name__ == '__main__':
     unittest.main()

{memleaf-0.2.67 → memleaf-0.2.68}/tests_public/test_incremental_protocol.py

@@ -117,6 +117,40 @@ class IncrementalProtocolTests(unittest.TestCase):
         op = self.run_rows(self.create(type="todo", status="active", assignee="user:1", waiting_on=None))["operations"][0]
         self.assertEqual(op["memory"]["assignee"], "user:1")
 
+    def test_flattened_create_wrapper_is_normalized_before_strict_validation(self):
+        row = {
+            "action": "CREATE", "evidence": ["e1"],
+            "type": "fact", "scope": "s1",
+            "title": "Known requirement", "body": "Keep this requirement.",
+        }
+        out = self.run_rows(row)
+        self.assertFalse(out["issues"])
+        self.assertEqual(len(out["operations"]), 1)
+        op = out["operations"][0]
+        self.assertEqual(op["memory"]["type"], "fact")
+        self.assertEqual(op["memory"]["scopes"], ["project:Atlas"])
+        self.assertIn("create_memory_wrapper_normalized", op["warnings"])
+
+    def test_flattened_create_with_unknown_field_stays_rejected(self):
+        row = {
+            "action": "CREATE", "evidence": ["e1"],
+            "type": "fact", "scope": "s1",
+            "title": "Known requirement", "body": "Keep this requirement.",
+            "unexpected": "must not be accepted",
+        }
+        out = self.run_rows(row)
+        self.assertFalse(out["operations"])
+        self.assertEqual(out["issues"][0]["code"], "invalid_fields")
+
+    def test_flattened_create_missing_required_field_stays_rejected(self):
+        row = {
+            "action": "CREATE", "evidence": ["e1"],
+            "type": "fact", "scope": "s1", "title": "Known requirement",
+        }
+        out = self.run_rows(row)
+        self.assertFalse(out["operations"])
+        self.assertEqual(out["issues"][0]["code"], "invalid_fields")
+
     def test_target_type_cannot_be_reclassified_in_patch(self):
         out = self.run_rows(self.update(type="fact", status="completed"))
         self.assertFalse(out["operations"])

{memleaf-0.2.67 → memleaf-0.2.68}/tests_public/test_provider_compatibility.py

@@ -283,7 +283,7 @@ class ServerCompatibilityTests(unittest.TestCase):
         with patch.object(self.service,'stats',side_effect=AssertionError('must not scan')):
             result=self.hello(self.good)['result']
         self.assertEqual(result['_meta'][BUILD_META],self.good)
-        self.assertEqual(result['serverInfo']['version'],'0.2.67')
+        self.assertEqual(result['serverInfo']['version'],'0.2.68')
 
     def test_compatible_bridge_dispatches_capture(self):
         self.hello(self.good)