memleaf 0.2.0__tar.gz → 0.2.1__tar.gz

{memleaf-0.2.0 → memleaf-0.2.1}/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 All notable changes to memleaf are documented here.
 
+## 0.2.1 — 2026-08-31
+
+- Fixed the finalized `search → read` contract in both supported hosts: Codex `PostToolUse` and Hermes diagnostics now accept only `memory_id + title` search candidates, so a real `found` result no longer degrades to an error before `read`.
+- Enforced current-turn `retrieval_id` validation at the MCP boundary for both Codex and Hermes, preventing a still-present historical token from being reused for managed search/read after a newer turn begins.
+- Made Codex model discovery fail closed. Codex remains a host only; memleaf no longer reads or reuses Codex provider/model/auth configuration even if legacy discovery APIs are called explicitly.
+- Made multi-host Vault reuse compare physical paths rather than raw path strings, reducing false conflicts from equivalent host paths on Windows/macOS while still rejecting genuinely different Vaults.
+- Hardened forget failure recovery: linked history is deleted before active knowledge, partial filesystem failures rebuild derived indexes, and the active memory remains a retry anchor until linked history deletion succeeds.
+- Standardized Hermes installer subprocess decoding on UTF-8, matching the provider/Codex host boundaries and preventing non-ASCII CLI output from being corrupted by a Windows default code page.
+- Removed dead Codex-discovery helpers after the host/model boundary was made fail closed.
+- Re-ran the full Linux 3.11/3.12/3.13, Windows 3.11/3.12/3.13, macOS 3.11/3.13, native Codex Windows/macOS, package-build, wheel-install, and sdist-test release gates.
+
 ## 0.2.0 — 2026-08-31
 
 - Hardened the supported Codex integration against the official Codex CLI 0.151.0 on Windows and macOS, including `CODEX_HOME`, npm `codex.cmd` discovery, UTF-8 CLI output, idempotent `mcp add/get`, and quote-free Windows lifecycle commands carried through a UTF-16LE PowerShell `EncodedCommand` payload.

{memleaf-0.2.0 → memleaf-0.2.1}/PKG-INFO

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

{memleaf-0.2.0 → memleaf-0.2.1}/README.en.md

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

{memleaf-0.2.0 → memleaf-0.2.1}/README.md

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

{memleaf-0.2.0 → memleaf-0.2.1}/pyproject.toml

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

{memleaf-0.2.0 → memleaf-0.2.1}/src/memleaf/__init__.py

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

@@ -404,13 +404,11 @@ def _hermes_search_status(value: Any) -> str:
         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"))
-        and isinstance(item.get("scopes"), list)
-        and bool(item.get("scopes"))
-        and all(isinstance(scope, str) and bool(scope) for scope in item["scopes"])
         for item in results
     )
     if not valid_results:

{memleaf-0.2.0 → memleaf-0.2.1}/src/memleaf/hermes_provider/plugin.yaml

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

{memleaf-0.2.0 → memleaf-0.2.1}/src/memleaf/host_events.py

@@ -370,13 +370,11 @@ def _codex_search_status(value: Any) -> str:
         return "error"
     if not 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"))
-        and isinstance(item.get("scopes"), list)
-        and bool(item.get("scopes"))
-        and all(isinstance(scope, str) and bool(scope) for scope in item["scopes"])
         for item in results
     ):
         return "error"

{memleaf-0.2.0 → memleaf-0.2.1}/src/memleaf/installer.py

@@ -106,6 +106,22 @@ def _select_vault_path(
     return (home / ".memleaf").resolve(), "default"
 
 
+def _vault_paths_equivalent(left: Path, right: Path) -> bool:
+    """Return whether two host Vault paths identify the same location."""
+
+    try:
+        if left.exists() and right.exists():
+            return os.path.samefile(left, right)
+    except OSError:
+        pass
+    try:
+        left_value = os.path.normcase(str(left.expanduser().resolve()))
+        right_value = os.path.normcase(str(right.expanduser().resolve()))
+    except (OSError, RuntimeError):
+        return False
+    return left_value == right_value
+
+
 def _select_codex_vault_path(
     *,
     home: Path,
@@ -130,12 +146,12 @@ def _select_codex_vault_path(
     codex_vault = adapter.configured_vault(detection)
     if codex_vault is not None:
         existing.append(("codex_config", codex_vault))
-    unique = {str(path): path for _, path in existing}
-    if len(unique) > 1:
-        raise RuntimeError("vault_conflict: existing memleaf hosts use different Vaults")
     if existing:
+        reference = existing[0][1]
+        if any(not _vault_paths_equivalent(reference, path) for _, path in existing[1:]):
+            raise RuntimeError("vault_conflict: existing memleaf hosts use different Vaults")
         sources = "+".join(source for source, _ in existing)
-        return existing[0][1], sources
+        return reference, sources
 
     environment = os.environ if env is None else env
     configured = environment.get("MEMLEAF_VAULT")
@@ -252,6 +268,8 @@ def _run(command: list[str]) -> subprocess.CompletedProcess[str]:
         env=os.environ.copy(),
         capture_output=True,
         text=True,
+        encoding="utf-8",
+        errors="strict",
         check=False,
     )
 

{memleaf-0.2.0 → memleaf-0.2.1}/src/memleaf/mcp_server.py

@@ -668,14 +668,19 @@ def _managed_search_state(
     service: Memleaf,
     retrieval_id: str | None,
 ) -> dict[str, Any] | None:
-    """Return validated Hermes state; Codex observation remains in hooks."""
+    """Validate the current host turn; Hermes additionally records MCP results."""
 
     if retrieval_id is None:
         return None
     state = validate_turn(service.vault, retrieval_id)
-    if state.get("source") != "hermes":
-        return None
-    return validate_current_turn(service.vault, retrieval_id, "hermes")
+    source = state.get("source")
+    if not isinstance(source, str) or not source:
+        raise RetrievalGateError("retrieval_identity_invalid")
+    current = validate_current_turn(service.vault, retrieval_id, source)
+    # Codex records real search outcomes from PostToolUse so the stdio server
+    # must not double-count them. Current-turn validation is authoritative for
+    # every host token before the search itself is allowed to run.
+    return current if source == "hermes" else None
 
 
 def _observe_mcp_search(
@@ -785,7 +790,9 @@ def _invoke_tool(
                 return _read_page_result(service.read_page(**page_args))
 
             state = validate_turn(service.vault, retrieval_id)
-            current_source = "hermes" if state.get("source") == "hermes" else None
+            current_source = state.get("source")
+            if not isinstance(current_source, str) or not current_source:
+                raise RetrievalGateError("retrieval_identity_invalid")
             value = guarded_read(
                 service.vault,
                 retrieval_id,

{memleaf-0.2.0 → memleaf-0.2.1}/src/memleaf/model_discovery.py

@@ -19,7 +19,6 @@ import os
 from pathlib import Path
 import re
 import shutil
-import tomllib
 from typing import Any, Callable, Iterable, Mapping, Sequence
 from urllib.parse import urlsplit
 
@@ -160,18 +159,6 @@ def _safe_text(value: Any) -> str | None:
     return None
 
 
-def _configured_directory(home: Path, value: Any, default_name: str) -> Path:
-    configured = _safe_text(value)
-    if configured is None:
-        return (home / default_name).resolve()
-    if configured == "~":
-        return home.resolve()
-    if configured.startswith("~/"):
-        return (home / configured[2:]).resolve()
-    path = Path(configured)
-    return (path if path.is_absolute() else home / path).resolve()
-
-
 def _valid_base_url(value: Any) -> str | None:
     text = _safe_text(value)
     if text is None:
@@ -568,96 +555,23 @@ def discover_hermes(
     return candidates, diagnostics
 
 
-def _codex_env_values(document: Mapping[str, Any]) -> Mapping[str, Any]:
-    policy = document.get("shell_environment_policy")
-    if not isinstance(policy, Mapping):
-        return {}
-    values = policy.get("set")
-    return values if isinstance(values, Mapping) else {}
-
-
 def discover_codex(
     *,
     home: Path | str | None = None,
     env: Mapping[str, str] | None = None,
     config_path: Path | str | None = None,
 ) -> tuple[list[ModelCandidate], list[str]]:
-    """Discover only Codex providers with a chat-completions route.
+    """Keep the legacy API fail-closed without reading Codex model settings.
 
-    Codex's documented ``responses`` wire API is not silently treated as
-    OpenAI chat completions.  Until memleaf has a tested Responses backend,
-    those routes are reported as unsupported and skipped.
+    Codex is a memleaf host, never an extraction-model source.  Retaining this
+    callable avoids breaking imports from early 0.x builds while ensuring an
+    accidental caller cannot read or reuse Codex provider/auth configuration.
     """
 
-    effective_home = adapter_home(home)
-    environment = adapter_environment(env)
-    if config_path is not None:
-        path = Path(config_path).expanduser()
-    else:
-        codex_home = _configured_directory(effective_home, environment.get("CODEX_HOME"), ".codex")
-        path = codex_home / "config.toml"
-    if path.is_symlink() or not path.is_file():
-        return [], ["codex: user config.toml was not found"]
-    try:
-        document = tomllib.loads(path.read_text(encoding="utf-8"))
-    except (OSError, UnicodeError, tomllib.TOMLDecodeError):
-        return [], ["codex: config.toml could not be parsed"]
-    providers = document.get("model_providers")
-    if not isinstance(providers, Mapping):
-        return [], ["codex: no reusable model provider configuration found"]
-    selected_name = _safe_text(document.get("model_provider"))
-    top_model = _safe_text(document.get("model"))
-    shell_values = _codex_env_values(document)
-    candidates: list[ModelCandidate] = []
-    diagnostics: list[str] = []
-    for name, raw_item in providers.items():
-        if not isinstance(name, str) or not isinstance(raw_item, Mapping):
-            continue
-        wire_api = (_safe_text(raw_item.get("wire_api")) or "").casefold().replace("-", "_")
-        if wire_api != "chat_completions":
-            if wire_api == "responses":
-                diagnostics.append(f"codex: provider {name} uses unsupported responses wire API")
-            else:
-                diagnostics.append(f"codex: provider {name} has no supported chat wire API")
-            continue
-        provider = _safe_text(raw_item.get("name")) or name
-        model_ids: list[str] = []
-        for key in ("model", "default_model"):
-            value = _safe_text(raw_item.get(key))
-            if value:
-                model_ids.append(value)
-        if selected_name == name and top_model:
-            model_ids.append(top_model)
-        if isinstance(raw_item.get("models"), list):
-            model_ids.extend(item for item in raw_item["models"] if isinstance(item, str) and item.strip())
-        if not model_ids:
-            diagnostics.append(f"codex: provider {name} has no model name")
-            continue
-        seen: set[str] = set()
-        for model_id in model_ids:
-            if model_id.casefold() in seen:
-                continue
-            seen.add(model_id.casefold())
-            item = dict(raw_item)
-            found, reason = _candidate(
-                source="codex",
-                provider=provider,
-                protocol="openai",
-                base_url=raw_item.get("base_url"),
-                model=model_id,
-                item=item,
-                env=environment,
-                extra_env=shell_values,
-                source_detail="selected provider" if selected_name == name else "model provider",
-            )
-            if found:
-                candidates.append(found)
-            elif reason != "non-chat model":
-                diagnostics.append(f"codex: provider {name} unavailable ({reason})")
-    if top_model and not selected_name:
-        diagnostics.append("codex: top-level model has no selected reusable provider")
-    return candidates, diagnostics
-
+    del home, env, config_path
+    return [], [
+        "codex: model discovery is disabled; configure an independent memleaf Model Route"
+    ]
 
 def discover_models(
     *,
@@ -682,8 +596,8 @@ def discover_models(
         candidates.extend(found)
         diagnostics.extend(messages)
     if include_codex:
-        found, messages = discover_codex(home=home, env=env)
-        candidates.extend(found)
+        # Compatibility flag only.  Codex is a host, not a model source.
+        _, messages = discover_codex(home=home, env=env)
         diagnostics.extend(messages)
     selected = select_lightest(candidates)
     if selected is None:

{memleaf-0.2.0 → memleaf-0.2.1}/src/memleaf/retrieval_gate.py

@@ -388,8 +388,9 @@ def validate_current_turn(
 ) -> dict[str, Any]:
     """Validate a token belongs to the newest live turn for its host session.
 
-    This is used only for Hermes' managed MCP path.  Ordinary ``validate_turn``
-    remains available for Codex Stop continuation and historical inspection.
+    MCP uses this for every host token before search/read.  Ordinary
+    ``validate_turn`` remains available for Stop continuation and historical
+    inspection where "current turn" is not the question.
     """
 
     retrieval_id = _retrieval_id(retrieval_id)

{memleaf-0.2.0 → memleaf-0.2.1}/src/memleaf/service.py

@@ -1348,7 +1348,9 @@ class Memleaf:
             return fit_directory_items(entries, limit=bounded_limit)
 
     def _delete_records_unlocked(self, records: Iterable[_Record]) -> list[str]:
-        deleted: list[str] = []
+        # Preflight every target before mutating anything, then keep active
+        # knowledge as the retry anchor until all linked history is gone.
+        unique: list[_Record] = []
         seen_paths: set[Path] = set()
         for record in records:
             if record.path in seen_paths:
@@ -1356,11 +1358,27 @@ class Memleaf:
             seen_paths.add(record.path)
             if record.path.is_symlink():
                 raise ValueError("unsafe memory path")
-            try:
-                record.path.unlink()
-            except FileNotFoundError:
-                continue
-            deleted.append(record.memory.memory_id)
+            unique.append(record)
+        unique.sort(key=lambda record: (record.area == "knowledge", str(record.path)))
+
+        deleted: list[str] = []
+        try:
+            for record in unique:
+                try:
+                    record.path.unlink()
+                except FileNotFoundError:
+                    continue
+                deleted.append(record.memory.memory_id)
+        except Exception:
+            if deleted:
+                # The Markdown files are source of truth.  Keep derived indexes
+                # synchronized after a partial filesystem mutation before the
+                # original deletion error is surfaced to the caller.
+                try:
+                    self._rebuild_index_unlocked()
+                except Exception:
+                    pass
+            raise
         if deleted:
             self._rebuild_index_unlocked()
         return sorted(set(deleted))

{memleaf-0.2.0 → memleaf-0.2.1}/src/memleaf.egg-info/PKG-INFO

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

{memleaf-0.2.0 → memleaf-0.2.1}/tests/test_codex_install.py

@@ -7,6 +7,7 @@ import stat
 import subprocess
 import tempfile
 import unittest
+from unittest import mock
 
 from memleaf.adapters.base import CommandResult, host_event_command, mcp_command, merge_hook_config
 from memleaf.adapters.codex import CodexAdapter, _codex_hook_definition, _entry_matches
@@ -305,6 +306,25 @@ class CodexInstallTests(unittest.TestCase):
         self.assertEqual(hermes_vault.resolve(), selected)
         self.assertEqual("hermes_config+codex_config", source)
 
+        alias = self.root / "same-physical-alias"
+        with mock.patch(
+            "memleaf.installer._existing_hermes_vault",
+            return_value=hermes_vault.resolve(),
+        ), mock.patch(
+            "memleaf.installer._vault_paths_equivalent",
+            return_value=True,
+        ) as equivalent:
+            selected, source = _select_codex_vault_path(
+                home=self.home,
+                hermes_home=hermes_home,
+                adapter=ExistingVaultAdapter(alias),
+                detection=object(),
+                env={},
+            )
+        self.assertEqual(hermes_vault.resolve(), selected)
+        self.assertEqual("hermes_config+codex_config", source)
+        equivalent.assert_called_once()
+
         with self.assertRaisesRegex(RuntimeError, "vault_conflict"):
             _select_codex_vault_path(
                 home=self.home,

{memleaf-0.2.0 → memleaf-0.2.1}/tests/test_hermes_provider.py

@@ -510,7 +510,7 @@ class HermesProviderTests(unittest.TestCase):
                     {
                         "status": "found",
                         "results": [
-                            {"memory_id": "mem-alpha", "title": "Alpha", "scopes": ["project:alpha"]}
+                            {"memory_id": "mem-alpha", "title": "Alpha"}
                         ],
                     }
                 ),
@@ -1201,11 +1201,17 @@ class HermesProviderTests(unittest.TestCase):
         )
 
     def test_search_status_rejects_malformed_v2_envelopes(self) -> None:
-        valid = {"memory_id": "mem-1", "title": "Memory", "scopes": ["global"]}
+        valid = {"memory_id": "mem-1", "title": "Memory"}
         cases = [
             ({"status": "found", "results": []}, "error"),
             ({"status": "no_match", "results": [valid]}, "error"),
-            ({"status": "found", "results": [dict(valid, scopes=[])]}, "error"),
+            (
+                {
+                    "status": "found",
+                    "results": [dict(valid, scopes=["global"])],
+                },
+                "error",
+            ),
             ({"status": "found", "results": [valid], "error": {"code": "failed"}}, "error"),
             ({"status": "found", "results": [valid]}, "found"),
             ({"status": "no_match", "results": []}, "no_match"),

{memleaf-0.2.0 → memleaf-0.2.1}/tests/test_model_discovery.py

@@ -197,54 +197,39 @@ class ModelDiscoveryTests(unittest.TestCase):
             router = ModelRouter.from_config(load_config(path, vault=root))
             self.assertIsNone(router.api)
 
-    def test_codex_responses_route_is_skipped_and_chat_route_is_callable(self):
-        with tempfile.TemporaryDirectory() as temporary:
+    def test_codex_model_discovery_is_fail_closed_and_does_not_read_config(self):
+        with tempfile.TemporaryDirectory(prefix="memleaf-codex-model-disabled-") as temporary:
             home = Path(temporary)
-            config = home / ".codex" / "config.toml"
-            config.parent.mkdir()
+            codex_home = home / ".codex"
+            codex_home.mkdir()
+            config = codex_home / "config.toml"
             config.write_text(
-                'model = "codex-mini"\n'
-                'model_provider = "chat"\n'
-                '[model_providers.responses]\n'
-                'base_url = "https://responses.example.test"\n'
-                'wire_api = "responses"\n'
-                'model = "codex-mini"\n'
-                'experimental_bearer_token = "responses-secret"\n'
-                '[model_providers.chat]\n'
-                'base_url = "https://chat.example.test/v1"\n'
-                'wire_api = "chat_completions"\n'
-                'model = "codex-mini"\n'
-                'env_key = "CODEX_CHAT_KEY"\n',
+                'model = "sensitive-model"\nmodel_provider = "private"\n',
                 encoding="utf-8",
             )
-            candidates, diagnostics = discover_codex(home=home, env={"CODEX_CHAT_KEY": "chat-secret"})
-            self.assertEqual(len(candidates), 1)
-            self.assertEqual(candidates[0].model, "codex-mini")
-            self.assertTrue(any("responses" in item for item in diagnostics))
-            self.assertNotIn("chat-secret", " ".join(diagnostics))
-            self.assertNotIn("responses-secret", " ".join(diagnostics))
+            with patch.object(Path, "read_text", side_effect=AssertionError("must not read Codex config")):
+                candidates, diagnostics = discover_codex(
+                    home=home,
+                    env={"CODEX_HOME": str(codex_home), "PRIVATE_KEY": "SECRET"},
+                )
+        self.assertEqual([], candidates)
+        self.assertTrue(any("disabled" in item for item in diagnostics))
+        self.assertNotIn("SECRET", repr(diagnostics))
 
-    def test_codex_home_is_respected(self):
-        with tempfile.TemporaryDirectory() as temporary:
-            home = Path(temporary)
-            codex_home = home / "custom-codex"
-            codex_home.mkdir()
-            (codex_home / "config.toml").write_text(
-                'model = "custom-mini"\n'
-                'model_provider = "custom"\n'
-                '[model_providers.custom]\n'
-                'base_url = "https://chat.example.test/v1"\n'
-                'wire_api = "chat_completions"\n'
-                'model = "custom-mini"\n'
-                'experimental_bearer_token = "custom-secret"\n',
-                encoding="utf-8",
-            )
-            candidates, diagnostics = discover_codex(
-                home=home,
-                env={"CODEX_HOME": str(codex_home)},
+    def test_include_codex_flag_is_compatibility_noop(self):
+        with patch(
+            "memleaf.model_discovery.discover_codex",
+            return_value=([], ["codex: model discovery is disabled"]),
+        ) as codex:
+            result = discover_models(
+                home=Path("/tmp/isolated-home"),
+                env={},
+                include_hermes=False,
+                include_codex=True,
             )
-            self.assertEqual([item.model for item in candidates], ["custom-mini"])
-            self.assertNotIn("custom-secret", " ".join(diagnostics))
+        codex.assert_called_once()
+        self.assertIsNone(result.selected)
+        self.assertTrue(any("disabled" in item for item in result.diagnostics))
 
     def test_direct_key_is_written_with_restricted_permissions_and_router_uses_it(self):
         with tempfile.TemporaryDirectory() as temporary:

{memleaf-0.2.0 → memleaf-0.2.1}/tests/test_pypi_install.py

@@ -9,7 +9,7 @@ from unittest import mock
 
 from memleaf import cli
 from memleaf.adapters.hermes import HermesAdapter
-from memleaf.installer import _copy_provider, _hermes_home, _write_provider_config, install_codex
+from memleaf.installer import _copy_provider, _hermes_home, _run, _write_provider_config, install_codex
 
 
 class PyPIInstallTests(unittest.TestCase):
@@ -39,7 +39,7 @@ class PyPIInstallTests(unittest.TestCase):
 
             self.assertTrue(target.is_dir())
             self.assertFalse(target.is_symlink())
-            self.assertIn("version: 0.2.0", (target / "plugin.yaml").read_text(encoding="utf-8"))
+            self.assertIn("version: 0.2.1", (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:
@@ -83,6 +83,15 @@ class PyPIInstallTests(unittest.TestCase):
             self.assertEqual("high", detection.confidence)
             self.assertEqual(str(launcher.resolve()), detection.executable)
 
+    def test_installer_host_cli_output_is_decoded_as_utf8(self) -> None:
+        completed = SimpleNamespace(returncode=0, stdout="中文", stderr="")
+        with mock.patch("memleaf.installer.subprocess.run", return_value=completed) as run:
+            result = _run(["hermes", "memory", "status"])
+        self.assertIs(result, completed)
+        self.assertEqual(run.call_args.kwargs["encoding"], "utf-8")
+        self.assertEqual(run.call_args.kwargs["errors"], "strict")
+        self.assertTrue(run.call_args.kwargs["text"])
+
     def test_provider_config_uses_absolute_vault_on_all_platforms(self) -> None:
         with tempfile.TemporaryDirectory(prefix="memleaf-provider-config-") as temporary:
             root = Path(temporary)

{memleaf-0.2.0 → memleaf-0.2.1}/tests/test_stage_a.py

@@ -3,6 +3,7 @@ import hashlib
 import tempfile
 import threading
 import unittest
+from unittest import mock
 from concurrent.futures import ThreadPoolExecutor
 from pathlib import Path
 
@@ -280,6 +281,59 @@ class StageATest(unittest.TestCase):
         self.assertFalse((self.vault_path / "knowledge" / "m-two-versions.md").exists())
         self.assertFalse((self.vault_path / "history" / "m-two-versions.md").exists())
 
+    def test_forget_partial_failure_keeps_active_retry_anchor_and_rebuilds_index(self):
+        active = self.service.create_memory(
+            memory_id="m-retry-anchor",
+            title="Retry anchor",
+            body="current",
+            tags=["retry-delete"],
+        )
+        first_history = self.service.create_memory(
+            memory_id="hist-retry-a",
+            title="Old A",
+            body="old-a",
+            tags=["retry-delete"],
+            area="history",
+            active_memory_id=active.memory_id,
+        )
+        second_history = self.service.create_memory(
+            memory_id="hist-retry-b",
+            title="Old B",
+            body="old-b",
+            tags=["retry-delete"],
+            area="history",
+            active_memory_id=active.memory_id,
+        )
+        active_path = self.vault_path / "knowledge" / f"{active.memory_id}.md"
+        first_path = self.vault_path / "history" / f"{first_history.memory_id}.md"
+        second_path = self.vault_path / "history" / f"{second_history.memory_id}.md"
+        original_unlink = Path.unlink
+        attempted: list[str] = []
+
+        def flaky_unlink(path, *args, **kwargs):
+            attempted.append(path.name)
+            if path == second_path:
+                raise PermissionError("simulated history delete failure")
+            return original_unlink(path, *args, **kwargs)
+
+        with mock.patch.object(
+            self.service,
+            "_rebuild_index_unlocked",
+            wraps=self.service._rebuild_index_unlocked,
+        ) as rebuild, mock.patch.object(Path, "unlink", new=flaky_unlink):
+            with self.assertRaises(PermissionError):
+                self.service.forget_memory(active.memory_id)
+            self.assertGreaterEqual(rebuild.call_count, 1)
+
+        self.assertFalse(first_path.exists())
+        self.assertTrue(second_path.exists())
+        self.assertTrue(active_path.exists())
+        self.assertNotIn(active_path.name, attempted)
+
+        self.assertTrue(self.service.forget_memory(active.memory_id))
+        self.assertFalse(second_path.exists())
+        self.assertFalse(active_path.exists())
+
     def test_sensitive_event_id_uses_stable_digest_after_rebuild(self):
         raw_event_id = "session/password=top-secret-token"
         result = self.service.capture(

{memleaf-0.2.0 → memleaf-0.2.1}/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.0"},
+            {"name": "memleaf", "version": "0.2.1"},
         )
         return result
 

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

{memleaf-0.2.0 → memleaf-0.2.1}/tests/test_v2_host_flow.py

@@ -144,6 +144,59 @@ class V2HostFlowTest(unittest.TestCase):
         self.assertEqual(state["status"], "NO_MATCH")
         self.assertEqual(state["search_attempts"], 4)
 
+    def test_found_search_uses_finalized_directory_shape_and_allows_read(self):
+        memory = self.service.create_memory(
+            memory_id="found-contract",
+            title="Found contract",
+            body="FOUND_PRIVATE_BODY",
+        )
+        self.event("UserPromptSubmit", prompt="Found contract")
+        retrieval_id = find_turn(
+            self.service.vault, "codex", "isolated-session", "user-turn"
+        )
+
+        search_pre = self.event(
+            "PreToolUse",
+            tool_name="mcp__memleaf__search",
+            tool_input={"query": "Found contract"},
+        )
+        search_args = search_pre["hookSpecificOutput"]["updatedInput"]
+        actual = self.process.send({
+            "jsonrpc": "2.0",
+            "id": 91,
+            "method": "tools/call",
+            "params": {"name": "search", "arguments": search_args},
+        })["result"]
+        self.assertFalse(actual["isError"], actual)
+        results = actual["structuredContent"]["results"]
+        self.assertTrue(results)
+        self.assertEqual(set(results[0]), {"memory_id", "title"})
+        self.assertNotIn("FOUND_PRIVATE_BODY", json.dumps(actual))
+
+        self.event(
+            "PostToolUse",
+            tool_name="mcp__memleaf__search",
+            tool_use_id="found-call",
+            tool_input=search_args,
+            tool_response=actual,
+        )
+        self.assertEqual(validate_turn(self.service.vault, retrieval_id)["status"], "FOUND")
+
+        read_pre = self.event(
+            "PreToolUse",
+            tool_name="mcp__memleaf__read",
+            tool_input={"memory_id": memory.memory_id},
+        )
+        read_args = read_pre["hookSpecificOutput"]["updatedInput"]
+        read = self.process.send({
+            "jsonrpc": "2.0",
+            "id": 92,
+            "method": "tools/call",
+            "params": {"name": "read", "arguments": read_args},
+        })["result"]
+        self.assertFalse(read["isError"], read)
+        self.assertEqual(read["structuredContent"]["body"], "FOUND_PRIVATE_BODY")
+
     def test_scope_deferred_processing_is_reported_as_incomplete(self):
         self.event("UserPromptSubmit", prompt="你好")
         retrieval_id = find_turn(self.service.vault, "codex", "isolated-session", "user-turn")

{memleaf-0.2.0 → memleaf-0.2.1}/tests/test_v2_mcp_flow.py

@@ -284,6 +284,43 @@ class V2MCPFlowTest(unittest.TestCase):
         )
         self.assertEqual(ledger["entries"][retrieval_id]["seen_call_hashes"], [])
 
+    def test_old_codex_token_is_rejected_for_search_and_read(self):
+        memory = self.service.create_memory(
+            memory_id="old-codex-memory",
+            title="Old Codex",
+            body="OLD_CODEX_BODY",
+        )
+        old_id = begin_turn(self.service.vault, "codex", "same-codex-session", "turn-1")
+        observe_search(self.service.vault, old_id, "found", "old-codex-search")
+        current_id = begin_turn(
+            self.service.vault, "codex", "same-codex-session", "turn-2"
+        )
+        self.assertNotEqual(old_id, current_id)
+
+        stale_search = self.call(
+            "search",
+            query="Old Codex",
+            retrieval_id=old_id,
+        )
+        self.assertTrue(stale_search["isError"], stale_search)
+        self.assertEqual(
+            stale_search["structuredContent"]["error"]["code"],
+            "retrieval_turn_mismatch",
+        )
+
+        stale_read = self.call(
+            "read",
+            memory_id=memory.memory_id,
+            retrieval_id=old_id,
+        )
+        self.assertTrue(stale_read["isError"], stale_read)
+        self.assertEqual(
+            stale_read["structuredContent"]["error"]["code"],
+            "retrieval_turn_mismatch",
+        )
+        self.assertEqual(validate_turn(self.service.vault, old_id)["read_count"], 0)
+        self.assertEqual(self.service.read(memory.memory_id).hit_count, 0)
+
     def test_hermes_search_observation_failure_cannot_return_success(self):
         retrieval_id = begin_turn(self.service.vault, "hermes", "session", "turn")
         with patch(