memleaf 0.2.22__tar.gz → 0.2.24__tar.gz

{memleaf-0.2.22 → memleaf-0.2.24}/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 All notable changes to memleaf are documented here.
 
+## 0.2.24 — 2026-09-04
+
+- Make Hermes MCP installation reliably persistent: write `mcp_servers.memleaf` through Hermes' canonical `config set` interface, disable the entry while command/arguments are updated, then read `config.yaml` back and require an exact command plus `--vault` match before reporting success.
+- Detect a same-Vault MCP entry that points at a different absolute memleaf runtime before changing Hermes. Add explicit `--mcp-runtime auto|current|existing` policies, prefer the current Python interpreter's scripts directory over `PATH`, and require an exact version check before retaining another environment.
+- Snapshot Hermes `config.yaml`, `memleaf.json`, and `plugins/memleaf` during installation; on a later failure, attempt every rollback target even when one restore fails, and report the failed paths together with the installation stage and recovery commands.
+- Improve human and JSON diagnostics for MCP persistence, runtime conflicts, lifecycle/test failures, and rollback results; document `memleaf-mcp --vault`, manual YAML, and the difference between Hermes connection discovery and final configuration persistence.
+- Make Windows CI fail immediately after every native command and keep POSIX command-rendering assertions platform-specific, preventing intermediate Windows test failures from being reported as green.
+- Leave memory extraction, CREATE/UPDATE/NO_CHANGE decisions, retrieval, injection, todo handling, and globally shared Vault visibility unchanged.
+
+## 0.2.23 — 2026-09-03
+
+- Add a strict `scope_correction` transaction for explicit cross-project corrections without weakening ordinary UPDATE scope isolation: uniquely recover the wrong active target, reuse its `memory_id` when appropriate, or retire it to history with `invalidated_reason: scope_correction` and `superseded_by` when a correct active survivor already exists.
+- Deterministically split same-project `mixed_future_use` candidates after bounded model retries only when every clause is safely classifiable as durable project/fact state or an unfinished todo; ambiguous fragments remain deferred and valid siblings continue independently.
+- Add bounded mail-tool evidence capture limited to message ID, subject, sender and sender domain, plus private per-scope domain identifiers; a unique domain/scope conflict defers extraction instead of writing a wrongly attributed project memory, while full tool output remains excluded.
+- Preserve global `list_todos` pagination and unlimited aggregate managed reads from 0.2.20; no source/session ownership filter or aggregate read quota is reintroduced.
+- Hermes still uses its existing Soft Gate in this package release. Generic fail-closed pre-final retrieval enforcement requires a Hermes host lifecycle hook and is tracked upstream in NousResearch/hermes-agent#101973.
+
 ## 0.2.22 — 2026-09-03
 
 - Safely split valid multi-project `unscoped` aggregate candidates using only

{memleaf-0.2.22/src/memleaf.egg-info → memleaf-0.2.24}/PKG-INFO

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

{memleaf-0.2.22 → memleaf-0.2.24}/README.en.md

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

{memleaf-0.2.22 → memleaf-0.2.24}/README.md

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

{memleaf-0.2.22 → memleaf-0.2.24}/pyproject.toml

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

{memleaf-0.2.22 → memleaf-0.2.24}/src/memleaf/__init__.py

@@ -1,6 +1,6 @@
 """Local-first Markdown memory core for AI agents."""
 
-__version__ = "0.2.22"
+__version__ = "0.2.24"
 
 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.22 → memleaf-0.2.24}/src/memleaf/capture.py

@@ -6,7 +6,7 @@ import json
 import re
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Optional
+from typing import Any, Mapping, Optional
 
 from .index import (
     EVENT_CONTENT,
@@ -28,6 +28,45 @@ def _timestamp() -> str:
     return datetime.now(timezone.utc).isoformat(timespec="seconds").replace("+00:00", "Z")
 
 
+
+_MAIL_EVIDENCE_FIELDS = frozenset({"message_id", "subject", "sender", "domain"})
+_MAIL_DOMAIN_RE = re.compile(r"^(?=.{1,253}$)(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,63}$", re.IGNORECASE)
+_MAX_MAIL_EVIDENCE_ITEMS = 8
+_MAX_MAIL_EVIDENCE_TEXT = 320
+
+
+def _normalize_tool_evidence(value: Any) -> list[dict[str, str]]:
+    if value is None:
+        return []
+    if not isinstance(value, (list, tuple)):
+        raise ValueError("tool evidence must be a list")
+    result: list[dict[str, str]] = []
+    seen: set[tuple[tuple[str, str], ...]] = set()
+    for raw in list(value)[:_MAX_MAIL_EVIDENCE_ITEMS]:
+        if not isinstance(raw, Mapping) or set(raw) - _MAIL_EVIDENCE_FIELDS:
+            raise ValueError("invalid tool evidence record")
+        item: dict[str, str] = {}
+        for key in _MAIL_EVIDENCE_FIELDS:
+            field = raw.get(key)
+            if field is None:
+                continue
+            if not isinstance(field, str) or not field.strip() or any(ch in field for ch in "\x00\r\n"):
+                raise ValueError("invalid tool evidence field")
+            text = redact_text(field.strip())[:_MAX_MAIL_EVIDENCE_TEXT]
+            if key == "domain":
+                text = text.casefold().lstrip("@")
+                if not _MAIL_DOMAIN_RE.fullmatch(text):
+                    raise ValueError("invalid tool evidence domain")
+            item[key] = text
+        if not item:
+            continue
+        fingerprint = tuple(sorted(item.items()))
+        if fingerprint in seen:
+            continue
+        seen.add(fingerprint)
+        result.append(item)
+    return result
+
 def _event_id(source: str, session_id: str, turn_id: str, role: str, event_id: Optional[str]) -> str:
     if event_id is not None:
         if not isinstance(event_id, str) or not event_id or "\x00" in event_id or "\n" in event_id or "\r" in event_id:
@@ -149,6 +188,7 @@ def _append_event(
     event_digest: str,
     event_turn_key: str,
     turn_index: int,
+    tool_evidence: list[dict[str, str]] | None = None,
 ) -> str:
     timestamp = _timestamp()
     if not existing:
@@ -168,6 +208,8 @@ def _append_event(
         "turn_index": turn_index,
         "timestamp": timestamp,
     }
+    if tool_evidence:
+        metadata["tool_evidence"] = [dict(item) for item in tool_evidence]
     metadata_line = json.dumps(metadata, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
     return (
         f"{updated}{EVENT_START}\n"
@@ -207,6 +249,7 @@ def capture_event(
     event_id: Optional[str] = None,
     record: bool = True,
     visible: bool = True,
+    tool_evidence: Any = None,
 ) -> CaptureResult:
     """Capture one visible event; all persisted text is redacted first."""
 
@@ -222,6 +265,7 @@ def capture_event(
     resolved_turn_key = turn_key(turn_id)
     persisted_turn_id = _safe_turn_id(turn_id)
     safe_content = escape_event_markers(redact_text(content))
+    safe_tool_evidence = _normalize_tool_evidence(tool_evidence)
     if not record or not visible or role not in ("user", "assistant"):
         return CaptureResult(resolved_event_id, stored=False, duplicate=False, content=safe_content)
 
@@ -266,6 +310,7 @@ def capture_event(
             resolved_event_key,
             resolved_turn_key,
             turn_index,
+            safe_tool_evidence,
         )
         atomic_write_text(path, updated)
 

{memleaf-0.2.22 → memleaf-0.2.24}/src/memleaf/cli.py

@@ -6,6 +6,8 @@ import argparse
 import getpass
 import json
 import os
+import shlex
+import subprocess
 import sys
 from pathlib import Path
 from typing import Sequence
@@ -65,6 +67,15 @@ def build_parser() -> argparse.ArgumentParser:
         help="host to configure (default: hermes)",
     )
     install.add_argument("--vault", type=Path, default=None, help="vault directory")
+    install.add_argument(
+        "--mcp-runtime",
+        choices=("auto", "current", "existing"),
+        default="auto",
+        help=(
+            "Hermes only: fail on a second memleaf runtime (auto), migrate to "
+            "this installation (current), or retain a version-matched configured runtime (existing)"
+        ),
+    )
     install.add_argument("--json", action="store_true", help="emit one JSON result")
     host_event = commands.add_parser(
         "host-event",
@@ -87,6 +98,96 @@ def _configure_stdio_utf8() -> None:
             continue
 
 
+def _format_command(command: Sequence[object]) -> str:
+    values = [str(item) for item in command]
+    return subprocess.list2cmdline(values) if os.name == "nt" else shlex.join(values)
+
+
+def _print_install_failure(output: dict, *, host: str) -> None:
+    print(
+        f"memleaf install failed: {output.get('reason', 'unknown error')}",
+        file=sys.stderr,
+    )
+    stage = output.get("stage")
+    if isinstance(stage, str) and stage:
+        print(f"failed stage: {stage}", file=sys.stderr)
+
+    if host == "hermes" and output.get("core_version") is not None:
+        provider_version = output.get("provider_version")
+        if output.get("provider_updated"):
+            provider_text = provider_version or "unknown"
+        elif provider_version:
+            provider_text = f"not changed (rejected candidate {provider_version})"
+        else:
+            provider_text = "not changed"
+        print(
+            "memleaf versions: "
+            f"core={output.get('core_version') or 'unknown'}, "
+            f"Hermes provider={provider_text}",
+            file=sys.stderr,
+        )
+
+    runtime = output.get("mcp_runtime")
+    if isinstance(runtime, dict):
+        config_path = runtime.get("config_path")
+        configured = runtime.get("configured_command")
+        current = runtime.get("current_command") or runtime.get("expected_command")
+        existing_version = runtime.get("existing_version")
+        if config_path:
+            print(f"Hermes config: {config_path}", file=sys.stderr)
+        if configured:
+            print(f"configured MCP runtime: {configured}", file=sys.stderr)
+        if current:
+            print(f"current memleaf runtime: {current}", file=sys.stderr)
+        if existing_version:
+            print(f"configured MCP version: {existing_version}", file=sys.stderr)
+
+    mcp = output.get("mcp")
+    if isinstance(mcp, dict):
+        mcp_reason = mcp.get("reason")
+        if isinstance(mcp_reason, str) and mcp_reason and mcp_reason != output.get("reason"):
+            print(f"MCP detail: {mcp_reason}", file=sys.stderr)
+        config_path = mcp.get("config_path")
+        if config_path and not (
+            isinstance(runtime, dict) and config_path == runtime.get("config_path")
+        ):
+            print(f"Hermes config: {config_path}", file=sys.stderr)
+        backup_path = mcp.get("backup_path")
+        if backup_path:
+            print(f"config backup: {backup_path}", file=sys.stderr)
+
+    rollback = output.get("rollback_status")
+    if rollback == "completed":
+        print("Hermes configuration was restored to its pre-install state.", file=sys.stderr)
+    elif rollback == "failed":
+        print(
+            "WARNING: automatic rollback failed; inspect the reported Hermes paths before restarting.",
+            file=sys.stderr,
+        )
+
+    user_action = output.get("user_action")
+    if output.get("user_action_required") and isinstance(user_action, str) and user_action:
+        print(f"action required: {user_action}", file=sys.stderr)
+
+    commands = output.get("recovery_commands")
+    if isinstance(commands, list) and commands:
+        print("recovery commands:", file=sys.stderr)
+        for command in commands:
+            if isinstance(command, list) and command:
+                print(f"  {_format_command(command)}", file=sys.stderr)
+
+    diagnostic = ["python", "-m", "memleaf", "install", "--host", host]
+    if host == "hermes" and isinstance(runtime, dict):
+        policy = runtime.get("policy")
+        if policy in {"current", "existing"}:
+            diagnostic.extend(["--mcp-runtime", policy])
+    diagnostic.append("--json")
+    print(
+        f"Run `{_format_command(diagnostic)}` for the complete diagnostic result.",
+        file=sys.stderr,
+    )
+
+
 def main(argv: Sequence[str] | None = None) -> int:
     _configure_stdio_utf8()
     parser = build_parser()
@@ -96,8 +197,22 @@ def main(argv: Sequence[str] | None = None) -> int:
             output = _init(args)
         elif args.command == "install":
             from .installer import install_codex, install_hermes
-            installer = install_codex if args.host == "codex" else install_hermes
-            output = installer(vault_path=args.vault)
+
+            if args.host == "codex":
+                if args.mcp_runtime != "auto":
+                    output = {
+                        "status": "failure",
+                        "stage": "arguments",
+                        "reason": "--mcp-runtime applies only to Hermes installations",
+                        "vault": str(args.vault) if args.vault is not None else None,
+                    }
+                else:
+                    output = install_codex(vault_path=args.vault)
+            else:
+                install_kwargs = {"vault_path": args.vault}
+                if args.mcp_runtime != "auto":
+                    install_kwargs["mcp_runtime"] = args.mcp_runtime
+                output = install_hermes(**install_kwargs)
         elif args.command == "host-event":
             output = _host_event(args)
         else:  # pragma: no cover - argparse requires a known subcommand.
@@ -116,7 +231,8 @@ def main(argv: Sequence[str] | None = None) -> int:
         if getattr(args, "json", False):
             print(json.dumps({"error": "initialization failed"}, ensure_ascii=False))
         else:
-            print("memleaf init failed", file=sys.stderr)
+            action = getattr(args, "command", "init")
+            print(f"memleaf {action} failed unexpectedly", file=sys.stderr)
         return 1
 
     if args.command == "host-event":
@@ -139,22 +255,16 @@ def main(argv: Sequence[str] | None = None) -> int:
             if output.get("vault_source") == "hermes_config":
                 print("Preserved the Vault from the existing Hermes memleaf configuration.")
             if args.host == "hermes":
+                runtime = output.get("mcp_runtime")
+                if isinstance(runtime, dict) and runtime.get("selected_command"):
+                    print(f"Hermes MCP runtime: {runtime['selected_command']}")
                 print("Restart Hermes to use memleaf.")
             elif output.get("user_action_required"):
                 print(f"Codex action required: {output.get('user_action')}")
             if output.get("model", {}).get("status") == "not_configured":
                 print("Configure a memleaf model route before using automatic processing.")
         else:
-            if args.host == "hermes" and (
-                output.get("core_version") is not None
-                or output.get("provider_version") is not None
-            ):
-                print(
-                    "memleaf versions: "
-                    f"core={output.get('core_version') or 'unknown'}, "
-                    f"Hermes provider={output.get('provider_version') or 'unknown'}"
-                )
-            print(f"memleaf install failed: {output.get('reason', 'unknown error')}", file=sys.stderr)
+            _print_install_failure(output, host=args.host)
         return 0 if output.get("status") in {"configured", "already_configured"} else 2
     if args.json:
         print(json.dumps(output, ensure_ascii=False, sort_keys=True))
@@ -309,7 +419,7 @@ def _prepare_model_route(
     candidate = discovery.selected
     diagnostics = list(discovery.diagnostics)
     if candidate is None:
-        # An existing direct route is a safe idempotency fallback.  It is not
+        # An existing direct route is a safe idempotency fallback. It is not
         # reported as a host discovery result and never appears with its key.
         candidate = _existing_memleaf_route(requested_vault / "config.yaml")
     if candidate is None and not dry_run and not non_interactive and sys.stdin.isatty():

{memleaf-0.2.22 → memleaf-0.2.24}/src/memleaf/hermes_provider/README.md

@@ -1,8 +1,8 @@
 # Memleaf memory provider for Hermes
 
 This is a Hermes user-level memory-provider plugin for the local memleaf vault.
-It is separate from the `memleaf-mcp` MCP server, but uses the same
-`~/.memleaf` directory and executable.
+It is separate from the `memleaf-mcp` MCP server, but uses the same Vault and
+must use a version-compatible memleaf runtime.
 
 The native provider supplies a bounded Scope Map (no memory titles or bodies),
 captures visible Hermes turns, and automatically processes complete turns.
@@ -28,12 +28,36 @@ The optional provider config is `~/.hermes/memleaf.json`:
 ```json
 {
   "vault": "~/.memleaf",
-  "command": "memleaf-mcp",
+  "command": "/absolute/path/to/memleaf-mcp",
   "timeout": 5,
-  "process_timeout": 300
+  "process_timeout": 300,
+  "auto_process": true
 }
 ```
 
+The separate persisted MCP entry uses the same executable and Vault:
+
+```yaml
+mcp_servers:
+  memleaf:
+    command: /absolute/path/to/memleaf-mcp
+    args:
+      - --vault
+      - /absolute/path/to/vault
+    enabled: true
+    lazy: true
+    idle_timeout_seconds: 60
+```
+
+Use `python -m memleaf install` to configure both entries. The installer writes
+the MCP entry through `hermes config set`, reads `config.yaml` back, and tests
+that all 12 tools are discoverable before it reports success. When two memleaf
+virtual environments are present, use `--mcp-runtime current` to migrate to the
+runtime executing the installer or `--mcp-runtime existing` to retain an
+already configured executable after an exact version check. See the
+[Hermes MCP runtime guide](https://github.com/miffyblueboo/memleaf/blob/main/docs/hermes-mcp-runtime.md)
+for the full multi-environment and manual-recovery procedure.
+
 Capture, stats, and context calls use the short `timeout`; model-backed
 processing uses `process_timeout` so a slow local model does not get mistaken
 for a dead MCP worker. A failed or timed-out request closes the MCP process;

{memleaf-0.2.22 → memleaf-0.2.24}/src/memleaf/hermes_provider/__init__.py

@@ -108,6 +108,11 @@ _UNTRUSTED_TOOL_RESULT_TAG = "<untrusted_tool_result"
 _UNTRUSTED_TOOL_RESULT_END = "</untrusted_tool_result>"
 
 
+_MAX_MAIL_EVIDENCE_ITEMS = 8
+_MAIL_ADDRESS_RE = re.compile(r"(?i)([A-Z0-9._%+-]+@([A-Z0-9.-]+\.[A-Z]{2,63}))")
+_MAIL_TOOL_RE = re.compile(r"(?:gmail|outlook|mail|email)", re.IGNORECASE)
+
+
 class _MCPToolError(RuntimeError):
     """Safe structured model error returned by the local MCP boundary."""
 
@@ -1152,6 +1157,83 @@ def _resolve_command(config: Mapping[str, Any]) -> Optional[str]:
     )
 
 
+def _bounded_mail_evidence(messages: Optional[List[Dict[str, Any]]]) -> list[dict[str, str]]:
+    """Extract only message id/subject/sender/domain from visible mail tool results."""
+
+    calls = _visible_tool_calls(messages)
+    results = _visible_tool_results(messages)
+    used: set[int] = set()
+    output: list[dict[str, str]] = []
+    seen: set[tuple[tuple[str, str], ...]] = set()
+
+    def add_record(mapping: Mapping[str, Any]) -> None:
+        if len(output) >= _MAX_MAIL_EVIDENCE_ITEMS:
+            return
+        lowered = {str(key).casefold(): value for key, value in mapping.items()}
+        message_id = next((lowered.get(key) for key in ("message_id", "messageid", "id") if isinstance(lowered.get(key), (str, int))), None)
+        subject = next((lowered.get(key) for key in ("subject", "title") if isinstance(lowered.get(key), str)), None)
+        sender = next((lowered.get(key) for key in ("sender", "from", "from_address", "from_email", "email") if isinstance(lowered.get(key), str)), None)
+        domain = next((lowered.get(key) for key in ("domain", "sender_domain") if isinstance(lowered.get(key), str)), None)
+        if isinstance(sender, str):
+            match = _MAIL_ADDRESS_RE.search(sender)
+            if match and not domain:
+                domain = match.group(2)
+        item: dict[str, str] = {}
+        for key, value, limit in (
+            ("message_id", message_id, 160),
+            ("subject", subject, 320),
+            ("sender", sender, 320),
+            ("domain", domain, 253),
+        ):
+            if value is None:
+                continue
+            text = str(value).strip()
+            if not text or any(ch in text for ch in "\x00\r\n"):
+                continue
+            if key == "domain":
+                text = text.casefold().lstrip("@")
+                if not re.fullmatch(r"(?=.{1,253}$)(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,63}", text):
+                    continue
+            item[key] = text[:limit]
+        if "domain" not in item:
+            return
+        fingerprint = tuple(sorted(item.items()))
+        if fingerprint not in seen:
+            seen.add(fingerprint)
+            output.append(item)
+
+    def visit(value: Any, depth: int = 0) -> None:
+        if depth > 4 or len(output) >= _MAX_MAIL_EVIDENCE_ITEMS:
+            return
+        decoded = _decode_hermes_tool_result(value)
+        if decoded is _MISSING_TOOL_RESULT:
+            return
+        if decoded is not value:
+            visit(decoded, depth + 1)
+            return
+        if isinstance(value, Mapping):
+            add_record(value)
+            for child in value.values():
+                if isinstance(child, (Mapping, list, tuple)):
+                    visit(child, depth + 1)
+        elif isinstance(value, (list, tuple)):
+            for child in value:
+                visit(child, depth + 1)
+
+    ordinal = 0
+    for call in calls:
+        name = call.get("name")
+        if not isinstance(name, str) or not _MAIL_TOOL_RE.search(name):
+            continue
+        ordinal += 1
+        payload = _tool_result_for_call(call, calls, results, used)
+        if payload is not _CALL_FAILED:
+            visit(payload)
+        if len(output) >= _MAX_MAIL_EVIDENCE_ITEMS:
+            break
+    return output
+
+
 class MemleafMemoryProvider(MemoryProvider):
     """Use the local memleaf vault as Hermes' single external provider."""
 
@@ -2115,7 +2197,15 @@ class MemleafMemoryProvider(MemoryProvider):
         )
         return result
 
-    def _capture_visible(self, *, session_id: str, turn_id: str, role: str, content: str) -> bool:
+    def _capture_visible(
+        self,
+        *,
+        session_id: str,
+        turn_id: str,
+        role: str,
+        content: str,
+        tool_evidence: Optional[List[Dict[str, str]]] = None,
+    ) -> bool:
         result = self._call(
             "capture",
             {
@@ -2126,6 +2216,7 @@ class MemleafMemoryProvider(MemoryProvider):
                 "content": content,
                 "record": True,
                 "visible": True,
+                **({"tool_evidence": tool_evidence} if tool_evidence else {}),
             },
             stage=f"capture_{role}",
             session_id=session_id,
@@ -2414,12 +2505,14 @@ class MemleafMemoryProvider(MemoryProvider):
                     self._last_retrieval_observation = observation
                     self._last_retrieval_audit = str(audit_state.get("status") or "SEARCH_UNKNOWN")
                 lineage_ready = self._retry_pending_lineage(effective_session)
+                mail_evidence = _bounded_mail_evidence(messages)
                 for role, content in visible_events:
                     if not self._capture_visible(
                         session_id=effective_session,
                         turn_id=turn_id,
                         role=role,
                         content=content,
+                        tool_evidence=mail_evidence if role == "assistant" else None,
                     ):
                         return
                 if not self._auto_process:

{memleaf-0.2.22 → memleaf-0.2.24}/src/memleaf/hermes_provider/plugin.yaml

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