memleaf 1.0.1__tar.gz → 1.0.2__tar.gz

{memleaf-1.0.1 → memleaf-1.0.2}/CHANGELOG.md

@@ -5,6 +5,30 @@ All notable changes to memleaf are documented here.
 ## Unreleased
 
 
+## 1.0.2 — 2026-10-08
+
+### Reliable host recovery and Codex todo retrieval
+
+- Freeze host write groups only after every member is serialized and validated.
+  Reject empty/incomplete recovery groups and impossible legacy saved receipts;
+  verify actual heads and history before settlement, including Owner accounting.
+- Preserve multiline evidence in Markdown metadata through escaped quoted
+  strings, with lossless LF/CR/CRLF and Unicode line-separator round trips.
+- Include `list_todos` in Codex retrieval Hooks and accept its current directory
+  fields. Reinstallation safely upgrades known older matchers with backup;
+  unrelated or shared third-party Hook groups are preserved.
+- Validate the installed host workflow with multiline evidence in the existing
+  cross-platform wheel/source-distribution matrix. All 24 added regressions and
+  152 existing host checks passed locally, including real stdio/Hook subprocesses
+  and isolated installed-package checks. One additional historical assertion
+  failed identically on the original 1.0.1 baseline and remains outside this fix.
+- No model call or retry was added. This patch used deterministic synthetic
+  acceptance; the earlier 1.0.1 macOS live-client evidence remains historical,
+  and no new real-model or production-Vault acceptance is claimed.
+- Existing Codex model-profile installations need the installer run again to
+  update their known old Hook matchers, followed by the existing Hook review and
+  trust flow. Updating the Python package alone does not rewrite host settings.
+
 ## 1.0.1 — 2026-10-08
 
 ### Optional host-model MCP workflow for Codex

{memleaf-1.0.1/src/memleaf.egg-info → memleaf-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 1.0.1
+Version: 1.0.2
 Summary: A local-first Markdown memory core for AI agents
 Author: memleaf contributors
 License-Expression: MIT
@@ -24,7 +24,7 @@ Dynamic: license-file
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **稳定版：1.0.1。** 支持 Hermes 和 Codex；版本与兼容范围见[稳定性约定](docs/stability.md)。
+> **稳定版：1.0.2。** 支持 Hermes 和 Codex；版本与兼容范围见[稳定性约定](docs/stability.md)。
 > **Codex 可通过 `--profile host` 使用当前宿主模型完成记忆闭环，无需另配 Memleaf 模型 API Key。** 本地 Owner 仍需配置客户端身份、读写权限及来源信任；客户端主动调用工具，不代表每轮自动记忆。
 > host profile 支持独立于内容类型的 `actionable` 和结构化 `waiting_on`，每份 work 默认最多三次被接受的 submit；Memleaf 负责确定性校验、落盘与恢复。
 > 默认 `model` profile 和 Hermes 原生接入继续使用独立 Model Route，提炼与语义复核共用每份工作的最多五次模型请求。旧接口、现有记忆和默认入口保留，升级无需正式 Vault 迁移。Antigravity（反重力）当前不支持。

{memleaf-1.0.1 → memleaf-1.0.2}/README.en.md

@@ -4,7 +4,7 @@
 
 [中文](README.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **Stable release: 1.0.1.** Hermes and Codex are supported; see the [stability policy](docs/stability.md) for compatibility scope.
+> **Stable release: 1.0.2.** Hermes and Codex are supported; see the [stability policy](docs/stability.md) for compatibility scope.
 > **Codex can complete the memory workflow with its current host model through `--profile host`, without a separate Memleaf model API key.** A local Owner still configures client identity, permissions and source trust. Clients invoke the tools deliberately; this does not enable automatic memory on every turn.
 > The host profile supports `actionable` independently of content type and structured `waiting_on`, with at most three accepted submits per work by default. Memleaf validates, persists and recovers deterministically.
 > The default `model` profile and native Hermes integration retain their independent Model Route and shared five-request extraction/review budget. Existing interfaces, memories and default entry points remain; no formal Vault migration is required. Antigravity is not supported.

{memleaf-1.0.1 → memleaf-1.0.2}/README.md

@@ -4,7 +4,7 @@
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **稳定版：1.0.1。** 支持 Hermes 和 Codex；版本与兼容范围见[稳定性约定](docs/stability.md)。
+> **稳定版：1.0.2。** 支持 Hermes 和 Codex；版本与兼容范围见[稳定性约定](docs/stability.md)。
 > **Codex 可通过 `--profile host` 使用当前宿主模型完成记忆闭环，无需另配 Memleaf 模型 API Key。** 本地 Owner 仍需配置客户端身份、读写权限及来源信任；客户端主动调用工具，不代表每轮自动记忆。
 > host profile 支持独立于内容类型的 `actionable` 和结构化 `waiting_on`，每份 work 默认最多三次被接受的 submit；Memleaf 负责确定性校验、落盘与恢复。
 > 默认 `model` profile 和 Hermes 原生接入继续使用独立 Model Route，提炼与语义复核共用每份工作的最多五次模型请求。旧接口、现有记忆和默认入口保留，升级无需正式 Vault 迁移。Antigravity（反重力）当前不支持。

{memleaf-1.0.1 → memleaf-1.0.2}/docs/stability.md

@@ -30,15 +30,24 @@ scope. An internal protocol change may fence pending model responses and require
 an explicit recovery action; it must not silently reinterpret saved work, erase
 unresolved outcomes or reset consumed request budgets.
 
-## Upgrade to 1.0.1
+## Upgrade to 1.0.2
 
-The 1.0.1 release preserves the 1.0.0 public interfaces, existing Model Routes,
+The 1.0.2 release preserves the 1.0.0 public interfaces, existing Model Routes,
 default entry points and Markdown/history formats. The new host-model MCP route
 is optional and selected with `--profile host`; upgrading does not convert an
 existing Codex or Hermes connection to it. No formal Vault migration is required.
 The host contract identifier remains `memleaf-host-v2.0-rc1`; protocol identity
 and package release numbers are separate.
 
+Version 1.0.2 fixes incomplete host freezing/recovery, multiline evidence
+serialization and Codex todo retrieval Hooks. Complete older frozen groups
+remain recoverable; incomplete groups and impossible saved receipts fail closed
+without inventing writes or refunding processing budgets. Existing model-profile
+Codex users should rerun the installer to update known old Hook matchers, then
+follow Codex's Hook review/trust flow. Shared third-party Hook groups are preserved
+and reported for explicit resolution. A package upgrade alone does not alter
+host configuration.
+
 The host route uses the running Agent model and does not require a separate
 Memleaf model API key. A local Owner still supplies client credentials,
 read/write scopes, permissions and acceptable source trust. `host-grant` emits
@@ -96,3 +105,8 @@ independent Memleaf model calls; host requests and token usage remain separate.
 Corrections and explicit Owner-approved budgets were part of acceptance. This
 evidence does not certify every model/client or live Windows/Linux model use;
 native installation and package CI are distinct from real-model acceptance.
+
+For 1.0.2, 24 new deterministic regressions and all 152 existing host checks
+passed, including isolated installed-package and real stdio/Hook subprocess
+checks. No new real Codex/Hermes model session or production-Vault migration was
+performed for this patch; those scopes remain distinct from native package CI.

{memleaf-1.0.1 → memleaf-1.0.2}/pyproject.toml

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

{memleaf-1.0.1 → memleaf-1.0.2}/src/memleaf/__init__.py

@@ -1,6 +1,6 @@
 """Local-first Markdown memory core for AI agents."""
 
-__version__ = "1.0.1"
+__version__ = "1.0.2"
 
 from .config import DEFAULT_CONFIG, default_config, load_config, save_config
 from .frontmatter import FrontmatterError, dump_frontmatter, dump_yaml, load_yaml, parse_frontmatter

{memleaf-1.0.1 → memleaf-1.0.2}/src/memleaf/adapters/base.py

@@ -592,6 +592,7 @@ def merge_hook_config(
     *,
     container_key: str | None = None,
     dry_run: bool = False,
+    matcher_upgrades: Mapping[str, Mapping[str, str]] | None = None,
 ) -> HookMergeResult:
     """Merge command handlers into a host hook JSON file.
 
@@ -599,6 +600,8 @@ def merge_hook_config(
     a top-level ``hooks`` object and passes ``container_key="hooks"``.
     Existing handlers are left untouched; a matching memleaf command is
     idempotent and a different memleaf command is treated as a conflict.
+    An adapter may explicitly migrate known old matchers on groups owned
+    entirely by the matching command; unrelated groups stay unchanged.
     """
 
     target = Path(path)
@@ -659,6 +662,23 @@ def merge_hook_config(
                 command = requested_handler.get("command")
                 if not isinstance(command, str) or not command:
                     return HookMergeResult("diagnostic", "hook command is invalid; unchanged")
+                # Upgrade only an explicitly recognized old matcher belonging
+                # entirely to this command. Never rewrite a shared host group
+                # whose matcher also controls unrelated hooks.
+                upgrades = (matcher_upgrades or {}).get(event, {})
+                for index, item in enumerate(existing_items):
+                    if not isinstance(item, Mapping) or not isinstance(item.get("matcher"), str):
+                        continue
+                    replacement = upgrades.get(item["matcher"])
+                    hooks = item.get("hooks") if container_key == "hooks" else None
+                    if replacement is None or not isinstance(hooks, list) or not hooks:
+                        continue
+                    if not any(isinstance(hook, Mapping) and hook.get("command") == command for hook in hooks):
+                        continue
+                    if not all(isinstance(hook, Mapping) and hook.get("command") == command for hook in hooks):
+                        return HookMergeResult("diagnostic", "existing memleaf matcher shares unrelated hooks; unchanged")
+                    existing_items[index] = {**item, "matcher": replacement}
+                    updated = True
                 matching, conflict = _hook_command_state(existing_items, command, event, container_key)
                 if conflict:
                     return HookMergeResult("diagnostic", "existing memleaf hook conflicts; unchanged")

{memleaf-1.0.1 → memleaf-1.0.2}/src/memleaf/adapters/codex.py

@@ -484,6 +484,10 @@ def _configure_codex_hooks(
         definition,
         container_key="hooks",
         dry_run=dry_run,
+        matcher_upgrades={
+            "PreToolUse": {r"^mcp__memleaf__(search|read)$": r"^mcp__memleaf__(search|list_todos|read)$"},
+            "PostToolUse": {r"^mcp__memleaf__search$": r"^mcp__memleaf__(search|list_todos)$"},
+        },
     )
 
 
@@ -513,13 +517,13 @@ def _codex_hook_definition(
         "UserPromptSubmit": [{"hooks": [user_prompt]}],
         "PreToolUse": [
             {
-                "matcher": r"^mcp__memleaf__(search|read)$",
+                "matcher": r"^mcp__memleaf__(search|list_todos|read)$",
                 "hooks": [pre_tool],
             }
         ],
         "PostToolUse": [
             {
-                "matcher": r"^mcp__memleaf__search$",
+                "matcher": r"^mcp__memleaf__(search|list_todos)$",
                 "hooks": [post_tool],
             }
         ],

{memleaf-1.0.1 → memleaf-1.0.2}/src/memleaf/frontmatter.py

@@ -307,9 +307,13 @@ def _dump_scalar(value: Any) -> str:
     if isinstance(value, (int, float)) and not isinstance(value, bool):
         return str(value)
     if isinstance(value, str):
-        if "\n" in value or "\r" in value:
-            raise FrontmatterError("multiline strings are not supported")
-        return json.dumps(value, ensure_ascii=False)
+        # JSON escapes retain line breaks in a single YAML quoted scalar.
+        # Escape the remaining Unicode line separators too: splitlines() is
+        # used by the restricted parser and must not split inside a scalar.
+        return (json.dumps(value, ensure_ascii=False)
+                .replace("\u0085", "\\u0085")
+                .replace("\u2028", "\\u2028")
+                .replace("\u2029", "\\u2029"))
     raise FrontmatterError("unsupported value type")
 
 

{memleaf-1.0.1 → memleaf-1.0.2}/src/memleaf/hermes_provider/plugin.yaml

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

{memleaf-1.0.1 → memleaf-1.0.2}/src/memleaf/host_events.py

@@ -403,7 +403,11 @@ def _codex_todo_result(value: Any) -> tuple[str, bool, str | None]:
         return "error", False, None
     if not all(
         isinstance(item, Mapping)
-        and set(item) == {"memory_id", "title", "due_date"}
+        # Directory rows also carry status, ownership, scope and history
+        # metadata. Only the identity/date fields are required to observe
+        # retrieval; rejecting those additive fields would mark real lists
+        # as errors and block the following bounded read.
+        and {"memory_id", "title", "due_date"}.issubset(item)
         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 (item.get("due_date") is None or isinstance(item.get("due_date"), str))

{memleaf-1.0.1 → memleaf-1.0.2}/src/memleaf/host_v2.py

@@ -58,6 +58,18 @@ class HostMemory:
                 raise ValueError()
             if any(not isinstance(payload[k], dict) for k in ("works", "sources", "requests", "cursors", "plans")):
                 raise ValueError()
+            # Reject impossible saved receipts left by older interrupted
+            # freezing, including cached replay of a false completion.
+            for work in payload["works"].values():
+                for entry in work["items"].values():
+                    receipt = entry["receipt"]
+                    if receipt["status"] == "saved":
+                        ids = receipt["memory_ids"]
+                        committed = receipt["committed_revisions"]
+                        if (not ids or len(ids) != len(set(ids))
+                                or [row["memory_id"] for row in committed] != ids
+                                or receipt["applied"] is not True or receipt["settled"] is not True):
+                            raise ValueError()
             return payload
         except (OSError, ValueError, KeyError, TypeError) as exc:
             raise V2Error("STATE_CORRUPT", "Host work ledger cannot be verified") from exc
@@ -561,16 +573,20 @@ class HostMemory:
                     self.auth.check(context, "memory.maintain", work=work)
                 if item.get("update_kind") == "retract_memory" or any(p.get("op") == "retract" for p in item.get("body_patch", [])):
                     self.auth.check(context, "memory.retract", work=work)
-                self._freeze(entry, plan, snapshot)
+                frozen_entry = deepcopy(entry)
+                self._freeze(frozen_entry, plan, snapshot)
                 if item["action"] == "COMPACT":
                     approval_plan = plan.get("approval_plan")
                     if approval_plan is None:
                         approval_plan = {"target": item["target"], "revision": snapshot["targets"][item["target"]]["revision"],
                                          "new_body": item["new_body"], "mapping": item["mapping"]}
                     self.auth.consume_approval(context, item["approval_ref"], "body_compaction", "sha256:" + digest(approval_plan), work_id=work["work_id"], locked=True)
+                entry.update(frozen_entry)
                 entry["removed_ranges"] = plan.get("removed_ranges", {})
                 proposals.append(entry)
-            except V2Error as exc:
+            except ValueError as exc:
+                if not isinstance(exc, V2Error):
+                    exc = V2Error("INVALID_SCHEMA", "Memory cannot be serialized into a valid frozen group")
                 exc.budget_charged = True
                 receipt["error"] = exc.public()
         # Reject implicit dependencies across independently submitted Items.
@@ -589,12 +605,15 @@ class HostMemory:
         if receipt["action"] == "DEFERRED":
             receipt["status"] = "deferred"
             return
-        receipt.update(operation_id=_id("op_"), group_id=_id("group_") if plan["changes"] else None, status="prepared")
+        # Publish prepared only after every group member can be serialized and
+        # validated. A later member failure must leave no executable prefix.
+        operation_id = _id("op_")
+        operations = []
         now = utc_now()
         for change in plan["changes"]:
             before = Memory.from_mapping(change["before"]) if change.get("before") else None
             after = Memory.from_mapping(change["after"])
-            after.extra["incremental_operation_id"] = receipt["operation_id"]
+            after.extra["incremental_operation_id"] = operation_id
             after.updated = now
             if before:
                 after.created = before.created
@@ -604,15 +623,71 @@ class HostMemory:
                             "message_revision": source["revision"], "trust": source["trust"], "role": source["role"]}
                 if evidence not in after.sources:
                     after.sources.append(evidence)
-            entry["operations"].append({"action": "UPDATE" if before else "CREATE", "memory_id": after.memory_id,
-                                         "operation_id": receipt["operation_id"], "prepared_at": now,
+            operations.append({"action": "UPDATE" if before else "CREATE", "memory_id": after.memory_id,
+                                         "operation_id": operation_id, "prepared_at": now,
                                          "before": before.to_markdown() if before else None, "after": after.to_markdown(),
                                          "expected_revision": revision(before).removeprefix("sha256:") if before else None,
                                          "replacement_revision": revision(after).removeprefix("sha256:"), "applied": False})
-        receipt["memory_ids"] = [c["memory_id"] for c in entry["operations"]]
+        frozen_receipt = {**receipt, "operation_id": operation_id,
+                          "group_id": _id("group_") if operations else None,
+                          "status": "prepared", "memory_ids": [c["memory_id"] for c in operations]}
         if not plan["changes"]:
-            receipt["memory_ids"] = [snapshot["targets"][r]["memory"]["memory_id"] for r in plan.get("target_refs", [])]
-            receipt.update(status="not_recorded" if receipt["action"] == "NO_MEMORY" else "unchanged", settled=True)
+            if receipt["action"] not in {"NO_CHANGE", "NO_MEMORY"}:
+                raise V2Error("STATE_CORRUPT", "A write requires a complete frozen operation group")
+            frozen_receipt["memory_ids"] = [snapshot["targets"][r]["memory"]["memory_id"] for r in plan.get("target_refs", [])]
+            frozen_receipt.update(status="not_recorded" if receipt["action"] == "NO_MEMORY" else "unchanged", settled=True)
+        else:
+            self._validate_frozen({**entry, "receipt": frozen_receipt, "operations": operations}, snapshot)
+        entry.update(operations=operations, frozen_digest=self._frozen_digest(operations))
+        receipt.update(frozen_receipt)
+
+    @staticmethod
+    def _frozen_digest(operations: list[dict[str, Any]]) -> str:
+        # Application bookkeeping changes during recovery; frozen payloads do not.
+        fields = ("action", "memory_id", "operation_id", "prepared_at", "before", "after",
+                  "expected_revision", "replacement_revision")
+        return digest([{key: operation[key] for key in fields} for operation in operations])
+
+    def _validate_frozen(self, entry: dict[str, Any], snapshot: dict[str, Any]) -> None:
+        """Prove complete membership and payloads before any write or settlement.
+
+        Old complete groups have no digest but retain their full receipt IDs and
+        proposal participants. Old incomplete groups fail closed without repair
+        from an inferred/recompiled plan.
+        """
+        try:
+            receipt, operations = entry["receipt"], entry["operations"]
+            ids = [op["memory_id"] for op in operations]
+            if not ids or len(ids) != len(set(ids)) or ids != receipt["memory_ids"]:
+                raise ValueError()
+            proposal = entry["proposal"]
+            action = receipt["action"]
+            if proposal["action"] != action or action not in {"CREATE", "UPDATE", "MERGE", "COMPACT"}:
+                raise ValueError()
+            if action == "CREATE":
+                if len(operations) != 1 or operations[0]["action"] != "CREATE":
+                    raise ValueError()
+            else:
+                refs = [proposal["target"], *proposal.get("duplicates", [])]
+                expected = [snapshot["targets"][ref]["memory"]["memory_id"] for ref in refs]
+                if ids != expected or any(op["action"] != "UPDATE" for op in operations):
+                    raise ValueError()
+            if "frozen_digest" in entry and entry["frozen_digest"] != self._frozen_digest(operations):
+                raise ValueError()
+            for op in operations:
+                after = Memory.from_markdown(op["after"])
+                before = Memory.from_markdown(op["before"]) if op["before"] is not None else None
+                if (op["operation_id"] != receipt["operation_id"]
+                        or after.memory_id != op["memory_id"]
+                        or after.extra.get("incremental_operation_id") != op["operation_id"]
+                        or revision(after) != "sha256:" + op["replacement_revision"]
+                        or (op["action"] == "CREATE" and (before is not None or op["expected_revision"] is not None))
+                        or (op["action"] == "UPDATE" and (before is None or before.memory_id != after.memory_id
+                            or revision(before) != "sha256:" + op["expected_revision"]))):
+                    raise ValueError()
+        except (KeyError, TypeError, ValueError) as exc:
+            raise V2Error("RECOVERY_REQUIRED", "Frozen operation group is incomplete or invalid",
+                          next_action="contact_owner") from exc
 
     def _verify_source(self, state: dict[str, Any], work: dict[str, Any]) -> None:
         for source in work["snapshot"]["sources"].values():
@@ -661,19 +736,26 @@ class HostMemory:
             try:
                 if entry.get("deleted_dependency_ids"):
                     raise V2Error("RECOVERY_REQUIRED", "A deleted dependency requires an exact new owner disposition", next_action="contact_owner")
+                self._validate_frozen(entry, work["snapshot"])
                 self.auth.check(context, "memory.write", work=work)
                 # Guard every member before beginning a multi-file dependency group.
                 for op in entry["operations"]:
                     actual = self._applied(op)
                     if actual is None:
                         raise V2Error("REVISION_CONFLICT", retryable=True, next_action="contact_owner")
+                    if actual is False and op.get("applied") is True:
+                        raise V2Error("RECOVERY_REQUIRED", "Previously applied content is no longer present", next_action="contact_owner")
                     self.auth.check(context, "memory.write", scopes=Memory.from_markdown(op["after"]).scopes, work=work)
                 for op in entry["operations"]:
                     self.auth.check(context, "memory.write", work=work)
                     if self._applied(op) is not True:
                         writer.write_frozen_unlocked(op)
+                    if self._applied(op) is not True:
+                        raise V2Error("IO_INTERRUPTED", "Frozen write cannot be confirmed on disk", retryable=True, next_action="resume")
                     op["applied"] = True
                     self._save(state)
+                if not all(self._applied(op) is True for op in entry["operations"]):
+                    raise V2Error("RECOVERY_REQUIRED", "Complete group persistence cannot be confirmed", next_action="contact_owner")
                 r.update(status="saved", applied=True, settled=True, error=None,
                          committed_revisions=[{"memory_id": o["memory_id"], "revision": "sha256:" + o["replacement_revision"]} for o in entry["operations"]])
                 for key, ranges in entry.get("removed_ranges", {}).items():

{memleaf-1.0.1 → memleaf-1.0.2}/src/memleaf/host_v2_owner.py

@@ -56,12 +56,19 @@ def account_work(host: Any, work_id: str) -> dict[str, Any]:
                 continue
             operations = entry.get("operations", [])
             actual = [host._applied(operation) for operation in operations]
+            complete = False
+            if operations and not entry.get("deleted_dependency_ids"):
+                try:
+                    host._validate_frozen(entry, work["snapshot"])
+                    complete = True
+                except V2Error:
+                    pass
             for operation, applied in zip(operations, actual):
                 # Keep a remembered application true even if a later external
                 # deletion makes the current CREATE head absent. Do not revive.
                 if applied is not False or not operation.get("applied"):
                     operation["applied"] = applied
-            if operations and all(applied is True for applied in actual):
+            if complete and all(applied is True for applied in actual):
                 receipt.update(status="saved", applied=True, settled=True, error=None,
                     committed_revisions=[{"memory_id": operation["memory_id"],
                         "revision": "sha256:" + operation["replacement_revision"]}
@@ -170,6 +177,8 @@ def _check_recovery_resources(host: Any, state: dict[str, Any], context: dict[st
     for entry in work["items"].values():
         if entry["receipt"]["status"] in _FINAL:
             continue
+        if entry.get("operations"):
+            host._validate_frozen(entry, work["snapshot"])
         if entry["receipt"]["action"] in {"MERGE", "COMPACT"}:
             host.auth.check(context, "memory.maintain")
         proposal = entry.get("proposal", {})

{memleaf-1.0.1 → memleaf-1.0.2/src/memleaf.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 1.0.1
+Version: 1.0.2
 Summary: A local-first Markdown memory core for AI agents
 Author: memleaf contributors
 License-Expression: MIT
@@ -24,7 +24,7 @@ Dynamic: license-file
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **稳定版：1.0.1。** 支持 Hermes 和 Codex；版本与兼容范围见[稳定性约定](docs/stability.md)。
+> **稳定版：1.0.2。** 支持 Hermes 和 Codex；版本与兼容范围见[稳定性约定](docs/stability.md)。
 > **Codex 可通过 `--profile host` 使用当前宿主模型完成记忆闭环，无需另配 Memleaf 模型 API Key。** 本地 Owner 仍需配置客户端身份、读写权限及来源信任；客户端主动调用工具，不代表每轮自动记忆。
 > host profile 支持独立于内容类型的 `actionable` 和结构化 `waiting_on`，每份 work 默认最多三次被接受的 submit；Memleaf 负责确定性校验、落盘与恢复。
 > 默认 `model` profile 和 Hermes 原生接入继续使用独立 Model Route，提炼与语义复核共用每份工作的最多五次模型请求。旧接口、现有记忆和默认入口保留，升级无需正式 Vault 迁移。Antigravity（反重力）当前不支持。