memleaf 0.2.26__tar.gz → 0.2.27__tar.gz

{memleaf-0.2.26 → memleaf-0.2.27}/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 All notable changes to memleaf are documented here.
 
+## 0.2.27 — 2026-09-05
+
+- Remove application-, document-, tool- and business-specific semantic classifiers from the Core admission/target path. The model owns future-use and atomicity judgments; Core retains source-neutral evidence, Scope, type, target, date, revision and conflict validation.
+- Bound per-memory provenance to 16 retained source rows while preserving cumulative source count/digest metadata, preventing repeated UPDATEs and copied history versions from growing `sources` without limit.
+- Retire completed/cancelled todos from active `knowledge/` after a configurable grace period (30 days by default) while keeping them queryable through historical todo enumeration.
+- Add bounded history retention (`3650` days and `32` complete versions per stable identity by default) with an explicit `keep_all` opt-out for audit-oriented Vaults.
+- Preserve an existing canonical memory identity during compaction instead of generating `mem-compact-*` IDs; rollback remains journaled and crash-safe.
+- Keep Markdown as the source of truth, retain zero runtime dependencies and no daemon, and preserve Hermes/Codex shared-Vault retrieval and write contracts.
+
 ## 0.2.26 — 2026-09-05
 
 - Refactor automatic processing into explicit model execution, planning, update coordination, commit, journal and audit owners while preserving Markdown Vaults, memory IDs, Hermes MemoryProvider and cross-Agent retrieval contracts. No runtime dependency or independent service is added.

{memleaf-0.2.26/src/memleaf.egg-info → memleaf-0.2.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 0.2.26
+Version: 0.2.27
 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.26。**
-> 核心库、Vault、stdio MCP Server、初始化 CLI、模型路由、提炼流程、受控检索协议和宿主适配器已经实现。本版完成共享记忆核心重构；真实模型语义效果仍需结合本地模型和业务样本验收。
+> **版本：0.2.27。**
+> 核心库、Vault、stdio MCP Server、初始化 CLI、模型路由、提炼流程、受控检索协议和宿主适配器已经实现。本版收口长期运行治理：Core 语义判断保持 source-neutral，并为来源、关闭待办、历史版本和压缩身份增加有界生命周期。真实模型语义效果仍需结合本地模型和代表性样本验收。
 > **当前版本支持 Hermes 和 Codex。** Antigravity（反重力）不检测、不安装、不配置。
 
 ## 项目定位
@@ -417,6 +417,28 @@ $HOME/.memleaf/
 
 `knowledge/` 和 `history/` 是可读数据；`_index/` 主要是派生索引或运行状态。删除或直接修改 `_index/` 可能丢失处理水位、Hook 游标或当前检索账本；需要重建时优先使用 `rebuild_index()`。
 
+### 长期运行与保留策略
+
+默认配置对长期增长做三层治理，而不引入后台服务：
+
+```yaml
+process:
+  memory_compact_threshold_tokens: 100000
+  memory_compact_candidate_ratio: 0.30
+  inbox_cleanup_hours: 24
+  closed_todo_retention_days: 30
+history:
+  policy: bounded
+  retention_days: 3650
+  max_versions_per_memory: 32
+```
+
+- active Markdown 每条最多保留 16 个来源明细，同时记录累计 `source_count`、`source_digest` 和省略数量，避免 UPDATE 让 `sources` 无限膨胀；
+- 已完成/已取消 todo 默认在 30 天后退出 `knowledge/` 并进入 `history/`；`list_todos(status=completed|cancelled|all)` 仍可枚举这些历史待办；
+- `history.policy: bounded` 默认每个稳定记忆身份最多保留 32 个完整历史版本，且超过 3650 天的版本可被维护流程淘汰；需要永久审计时可显式设置 `history.policy: keep_all`；
+- compaction 会保留一个既有 canonical `memory_id`，不会再为整理结果创建新的 `mem-compact-*` 身份；单条精简保持原 ID，多条合并选择一个稳定 survivor。
+- 这些维护动作在正常 `process()` / `remember()` / `compact()` 生命周期中执行，不需要 daemon；普通只读检索本身不触发维护写入。
+
 默认目录尽量使用 `0700`，文件默认明文保存。memleaf 没有内置加密层，请自行保护 Vault、备份和模型调用凭证。
 
 ## 隐私与安全边界
@@ -457,7 +479,7 @@ python -m build --wheel --sdist
 - 没有模型路由时只能捕获和检索，不能完成自动提炼、显式记忆或压缩；
 - 真实宿主长期运行效果仍取决于本机 Agent 版本、配置、重启和模型可用性；
 - 不提供 Obsidian 插件、Web 管理界面、云同步或透明加密层；
-- `history/` 的批量清理不会被普通检索自动执行，删除操作需要明确调用维护接口。
+- 普通只读检索不会触发保留策略写入；历史淘汰和关闭待办退休只在正常处理/维护生命周期中执行。
 
 
 ## License
@@ -468,7 +490,7 @@ MIT，见 [LICENSE](LICENSE)。
 *Your memories, in files you own.*
 
 
-## 通用处理与只读验收（0.2.26）
+## 通用处理与只读验收（0.2.27）
 
 邮件、日历、工单、文件、浏览器与普通对话共用证据准入、覆盖检查和写入路径。
 自动摘要只能使用获准引用的原文；助手复述和旧记忆回读不能单独授权新增写入。

{memleaf-0.2.26 → memleaf-0.2.27}/README.en.md

@@ -4,8 +4,8 @@
 
 [中文](README.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **Version: 0.2.26.**
-> The core library, Vault, stdio MCP server, initialization CLI, model routing, memory extraction, controlled retrieval protocol, and host adapters are implemented. This version completes the shared memory core refactor; real-model semantics still require local acceptance with the selected model and representative inputs.
+> **Version: 0.2.27.**
+> The core library, Vault, stdio MCP server, initialization CLI, model routing, memory extraction, controlled retrieval protocol, and host adapters are implemented. This release closes long-run lifecycle gaps: Core semantic decisions remain source-neutral, while provenance, closed todos, history versions, and compaction identity are bounded. Real-model semantics still require local acceptance with the selected model and representative inputs.
 > **The current release supports Hermes and Codex.** Antigravity is not detected, installed, or configured.
 
 ## Project scope
@@ -400,6 +400,28 @@ $HOME/.memleaf/
 
 `knowledge/` and `history/` are human-readable data. `_index/` contains derived indexes and runtime state. Deleting or editing it directly can lose processing watermarks, host cursors, or the current retrieval ledger; use `rebuild_index()` when a rebuild is needed.
 
+### Long-run retention
+
+The default configuration bounds long-run growth without adding a background service:
+
+```yaml
+process:
+  memory_compact_threshold_tokens: 100000
+  memory_compact_candidate_ratio: 0.30
+  inbox_cleanup_hours: 24
+  closed_todo_retention_days: 30
+history:
+  policy: bounded
+  retention_days: 3650
+  max_versions_per_memory: 32
+```
+
+- Each active Markdown memory retains at most 16 detailed provenance rows while tracking cumulative `source_count`, `source_digest`, and omitted rows, so repeated UPDATEs cannot grow `sources` without bound.
+- Completed/cancelled todos leave `knowledge/` after 30 days by default and move to `history/`; `list_todos(status=completed|cancelled|all)` can still enumerate retired todos.
+- With `history.policy: bounded`, each stable memory identity keeps at most 32 full historical versions, and versions older than 3650 days are eligible for pruning. Set `history.policy: keep_all` explicitly when permanent audit retention is required.
+- Compaction preserves an existing canonical `memory_id` instead of creating a new `mem-compact-*` identity; a single-memory rewrite keeps its ID and a multi-memory merge chooses one stable survivor.
+- Maintenance runs through normal `process()` / `remember()` / `compact()` lifecycle calls and requires no daemon. Ordinary read-only retrieval does not trigger maintenance writes.
+
 Directories are normally created with mode `0700`, and files are stored as plaintext by default. memleaf has no built-in encryption layer; protect the Vault, backups, and model credentials yourself.
 
 ## Privacy and security boundaries
@@ -440,7 +462,7 @@ The following should not be interpreted as delivered capabilities:
 - Without a model route, memleaf can capture and retrieve but cannot perform automatic extraction, explicit model-backed memory, or compaction.
 - Long-running real-host behavior still depends on the local Agent version, configuration, restart, and model availability.
 - There is no Obsidian plugin, web management UI, cloud sync, or transparent encryption layer.
-- Routine retrieval never performs batch history cleanup; deletion requires an explicit maintenance operation.
+- Routine read-only retrieval never performs retention writes; history pruning and closed-todo retirement run only during normal processing/maintenance lifecycle calls.
 
 
 ## License
@@ -452,7 +474,7 @@ MIT; see [LICENSE](LICENSE).
 *Your memories, in files you own.*
 
 
-## General processing and read-only inspection (0.2.26 candidate)
+## General processing and read-only inspection (0.2.27)
 
 Dialogue, calendars, tickets, files, web results and other tools share the evidence, coverage and write path.
 Models interpret semantics; Core validates physical provenance and exact original quotations.

{memleaf-0.2.26 → memleaf-0.2.27}/README.md

@@ -4,8 +4,8 @@
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **版本：0.2.26。**
-> 核心库、Vault、stdio MCP Server、初始化 CLI、模型路由、提炼流程、受控检索协议和宿主适配器已经实现。本版完成共享记忆核心重构；真实模型语义效果仍需结合本地模型和业务样本验收。
+> **版本：0.2.27。**
+> 核心库、Vault、stdio MCP Server、初始化 CLI、模型路由、提炼流程、受控检索协议和宿主适配器已经实现。本版收口长期运行治理：Core 语义判断保持 source-neutral，并为来源、关闭待办、历史版本和压缩身份增加有界生命周期。真实模型语义效果仍需结合本地模型和代表性样本验收。
 > **当前版本支持 Hermes 和 Codex。** Antigravity（反重力）不检测、不安装、不配置。
 
 ## 项目定位
@@ -398,6 +398,28 @@ $HOME/.memleaf/
 
 `knowledge/` 和 `history/` 是可读数据；`_index/` 主要是派生索引或运行状态。删除或直接修改 `_index/` 可能丢失处理水位、Hook 游标或当前检索账本；需要重建时优先使用 `rebuild_index()`。
 
+### 长期运行与保留策略
+
+默认配置对长期增长做三层治理，而不引入后台服务：
+
+```yaml
+process:
+  memory_compact_threshold_tokens: 100000
+  memory_compact_candidate_ratio: 0.30
+  inbox_cleanup_hours: 24
+  closed_todo_retention_days: 30
+history:
+  policy: bounded
+  retention_days: 3650
+  max_versions_per_memory: 32
+```
+
+- active Markdown 每条最多保留 16 个来源明细，同时记录累计 `source_count`、`source_digest` 和省略数量，避免 UPDATE 让 `sources` 无限膨胀；
+- 已完成/已取消 todo 默认在 30 天后退出 `knowledge/` 并进入 `history/`；`list_todos(status=completed|cancelled|all)` 仍可枚举这些历史待办；
+- `history.policy: bounded` 默认每个稳定记忆身份最多保留 32 个完整历史版本，且超过 3650 天的版本可被维护流程淘汰；需要永久审计时可显式设置 `history.policy: keep_all`；
+- compaction 会保留一个既有 canonical `memory_id`，不会再为整理结果创建新的 `mem-compact-*` 身份；单条精简保持原 ID，多条合并选择一个稳定 survivor。
+- 这些维护动作在正常 `process()` / `remember()` / `compact()` 生命周期中执行，不需要 daemon；普通只读检索本身不触发维护写入。
+
 默认目录尽量使用 `0700`，文件默认明文保存。memleaf 没有内置加密层，请自行保护 Vault、备份和模型调用凭证。
 
 ## 隐私与安全边界
@@ -438,7 +460,7 @@ python -m build --wheel --sdist
 - 没有模型路由时只能捕获和检索，不能完成自动提炼、显式记忆或压缩；
 - 真实宿主长期运行效果仍取决于本机 Agent 版本、配置、重启和模型可用性；
 - 不提供 Obsidian 插件、Web 管理界面、云同步或透明加密层；
-- `history/` 的批量清理不会被普通检索自动执行，删除操作需要明确调用维护接口。
+- 普通只读检索不会触发保留策略写入；历史淘汰和关闭待办退休只在正常处理/维护生命周期中执行。
 
 
 ## License
@@ -449,7 +471,7 @@ MIT，见 [LICENSE](LICENSE)。
 *Your memories, in files you own.*
 
 
-## 通用处理与只读验收（0.2.26）
+## 通用处理与只读验收（0.2.27）
 
 邮件、日历、工单、文件、浏览器与普通对话共用证据准入、覆盖检查和写入路径。
 自动摘要只能使用获准引用的原文；助手复述和旧记忆回读不能单独授权新增写入。

{memleaf-0.2.26 → memleaf-0.2.27}/docs/general-processing.md

@@ -1,4 +1,4 @@
-# General processing reliability contract — 0.2.26 candidate
+# General processing reliability contract — 0.2.27
 
 This is source-neutral processing, not a mail extractor. Dialogue, documents,
 calendars, issue trackers and terminal/tool observations use the same admission

{memleaf-0.2.26 → memleaf-0.2.27}/pyproject.toml

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

{memleaf-0.2.26 → memleaf-0.2.27}/src/memleaf/__init__.py

@@ -1,6 +1,6 @@
 """Local-first Markdown memory core for AI agents."""
 
-__version__ = "0.2.26"
+__version__ = "0.2.27"
 
 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.26 → memleaf-0.2.27}/src/memleaf/compaction.py

@@ -14,6 +14,8 @@ from typing import Any, Iterable, Mapping
 from .llm import CallableBackend, ModelError, ModelRouter, ModelUnavailable
 from .locking import atomic_unlink, atomic_write_json, atomic_write_text, read_json
 from .models import Memory, utc_now
+from .source_policy import merge_memory_provenance, merge_sources
+from .retention import RetentionManager, RetentionError
 from .prompts import COMPACT_SYSTEM, compact_prompt
 from .validation import ModelOutputError, parse_compact_output
 from .vault import safe_component
@@ -330,31 +332,44 @@ class Compactor:
         staging = self._staging_dir_unlocked(transaction_id, create=False)
         if staging.is_symlink() or not staging.exists() or not staging.is_dir():
             raise CompactionError("missing compaction staging")
+        replacement_hashes = {
+            entry["memory_id"]: entry["sha256"] for entry in journal["replacements"]
+        }
+        source_ids = {entry["memory_id"] for entry in journal["sources"]}
         for entry in journal["sources"]:
             source_path = self.service.vault.memory_path(entry["memory_id"], "knowledge")
             if source_path.is_symlink():
                 raise CompactionError("unsafe active memory path during recovery")
+            staged_path = staging / entry["staging_file"]
+            if staged_path.is_symlink() or not staged_path.exists():
+                raise CompactionError("missing staged active memory")
+            try:
+                original = staged_path.read_text(encoding="utf-8")
+            except (OSError, UnicodeError) as error:
+                raise CompactionError("cannot read staged active memory") from error
+            if _sha256(original) != entry["sha256"]:
+                raise CompactionError("staged active memory hash mismatch")
             if source_path.exists():
                 try:
                     current = source_path.read_text(encoding="utf-8")
                 except (OSError, UnicodeError) as error:
                     raise CompactionError("cannot read active memory during recovery") from error
-                # A user edit is preserved; the transaction additions below
-                # are still removed so the vault returns to a stable old view.
-                if _sha256(current) != entry["sha256"]:
+                current_hash = _sha256(current)
+                if current_hash == entry["sha256"]:
                     continue
-            else:
-                staged_path = staging / entry["staging_file"]
-                if staged_path.is_symlink() or not staged_path.exists():
-                    raise CompactionError("missing staged active memory")
-                try:
-                    original = staged_path.read_text(encoding="utf-8")
-                except (OSError, UnicodeError) as error:
-                    raise CompactionError("cannot read staged active memory") from error
-                if _sha256(original) != entry["sha256"]:
-                    raise CompactionError("staged active memory hash mismatch")
-                atomic_write_text(source_path, original)
+                # A canonical survivor is replaced in-place. If the file is
+                # exactly our staged replacement, restore its original source.
+                if replacement_hashes.get(entry["memory_id"]) == current_hash:
+                    atomic_write_text(source_path, original)
+                    continue
+                # Preserve an unrelated user edit rather than overwriting it.
+                continue
+            atomic_write_text(source_path, original)
+        # Backward-compatible cleanup for pre-0.2.27 journals whose
+        # replacement ID was not one of the consumed source IDs.
         for entry in journal["replacements"]:
+            if entry["memory_id"] in source_ids:
+                continue
             path = self.service.vault.memory_path(entry["memory_id"], "knowledge")
             if self._read_expected_file_unlocked(path, entry["sha256"], "compaction replacement") is not None:
                 atomic_unlink(path)
@@ -408,30 +423,26 @@ class Compactor:
         return value
 
     @staticmethod
-    def _replacement_id(summary: Mapping[str, Any], source_ids: Iterable[str]) -> str:
-        material = {
-            "source_memory_ids": sorted({item.casefold() for item in source_ids}),
-            "replacement": {
-                key: summary.get(key)
-                for key in (
-                    "title",
-                    "body",
-                    "tags",
-                    "type",
-                    "scopes",
-                    "scope_source",
-                    "aliases",
-                    "keywords",
-                    "status",
-                    "completed_at",
-                    "due_date",
-                )
-            },
-        }
-        digest = hashlib.sha256(
-            json.dumps(material, ensure_ascii=False, sort_keys=True, separators=(",", ":")).encode("utf-8")
-        ).hexdigest()
-        return f"mem-compact-{digest[:24]}"
+    def _canonical_candidate(source_candidates: list[_Candidate]) -> _Candidate:
+        if not source_candidates:
+            raise CompactionError("compaction replacement has no sources")
+        # Preserve the identity with the strongest prior user/reference value.
+        # Ties choose the oldest stable identity, then lexical ID.
+        def key(candidate: _Candidate) -> tuple[int, int, datetime, str]:
+            memory = candidate.memory
+            created = _parse_time(memory.created) or datetime.max.replace(tzinfo=timezone.utc)
+            return (
+                0 if memory.extra.get("explicit_remember") is True else 1,
+                -memory.hit_count,
+                created,
+                memory.memory_id.casefold(),
+            )
+        return min(source_candidates, key=key)
+
+    @classmethod
+    def _replacement_id(cls, summary: Mapping[str, Any], source_candidates: list[_Candidate]) -> str:
+        del summary
+        return cls._canonical_candidate(source_candidates).memory.memory_id
 
     @staticmethod
     def _history_id(source: Memory, replacement_id: str, source_hash: str) -> str:
@@ -445,21 +456,12 @@ class Compactor:
         ).hexdigest()
         return f"hist-{digest[:24]}"
 
+
     @staticmethod
     def _merge_sources(memories: Iterable[Memory]) -> list[dict[str, Any]]:
-        result: list[dict[str, Any]] = []
-        seen: set[str] = set()
-        for memory in memories:
-            for source in memory.sources:
-                if not isinstance(source, Mapping):
-                    continue
-                value = dict(source)
-                key = json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
-                if key in seen:
-                    continue
-                seen.add(key)
-                result.append(value)
-        return result
+        """Compatibility projection using the shared bounded provenance policy."""
+
+        return merge_memory_provenance(memories)[0]
 
     @staticmethod
     def _first_created(memories: Iterable[Memory], now: str) -> str:
@@ -486,14 +488,18 @@ class Compactor:
     ) -> _Replacement:
         source_memories = [candidate.memory for candidate in source_candidates]
         source_ids = tuple(memory.memory_id for memory in source_memories)
-        replacement_id = self._replacement_id(summary, source_ids)
+        canonical = self._canonical_candidate(source_candidates).memory
+        replacement_id = self._replacement_id(summary, source_candidates)
         status = summary.get("status")
         if summary["type"] == "todo" and status is None:
             status = "active"
-        extra = {
+        sources, source_metadata = merge_memory_provenance(source_memories)
+        extra = dict(canonical.extra)
+        extra.update(source_metadata)
+        extra.update({
             "compaction_source_ids": list(source_ids),
             "compacted_at": now,
-        }
+        })
         if any(memory.extra.get("explicit_remember") is True for memory in source_memories):
             extra["explicit_remember"] = True
         memory = Memory(
@@ -506,8 +512,8 @@ class Compactor:
             scope_source=summary["scope_source"],
             aliases=list(summary["aliases"]),
             keywords=list(summary["keywords"]),
-            sources=self._merge_sources(source_memories),
-            created=self._first_created(source_memories, now),
+            sources=sources,
+            created=canonical.created,
             updated=now,
             hit_count=sum(memory.hit_count for memory in source_memories),
             last_hit_at=self._last_hit(source_memories),
@@ -561,8 +567,10 @@ class Compactor:
             if replacement.memory.memory_id in replacement_ids:
                 raise CompactionError("duplicate compaction replacement id")
             replacement_ids.add(replacement.memory.memory_id)
-            if replacement.memory.memory_id in active_ids:
-                raise CompactionError("compaction replacement id collides with active memory")
+            if replacement.memory.memory_id not in replacement.source_ids:
+                raise CompactionError("compaction replacement must preserve one source identity")
+            if replacement.memory.memory_id not in active_ids:
+                raise CompactionError("compaction canonical survivor is not active")
             for source_id in replacement.source_ids:
                 if source_id in consumed:
                     raise CompactionError("compaction source memory is consumed twice")
@@ -581,8 +589,8 @@ class Compactor:
             raise CompactionError("compaction source is outside the candidate set")
         for replacement in replacements:
             path = self.service.vault.memory_path(replacement.memory.memory_id, "knowledge")
-            if path.is_symlink() or path.exists():
-                raise CompactionError("compaction replacement exists without a pending transaction")
+            if path.is_symlink() or not path.exists():
+                raise CompactionError("compaction canonical survivor is unavailable")
 
     def _build_plan(
         self,
@@ -601,6 +609,8 @@ class Compactor:
                 source_candidates = [by_id[source_id.casefold()] for source_id in source_ids]
             except KeyError as error:
                 raise CompactionError("compaction source is outside the snapshot") from error
+            if any(candidate.memory.type != summary.get("type") for candidate in source_candidates):
+                raise CompactionError("compaction cannot change memory type")
             replacement = self._build_replacement(summary, source_candidates, now=now)
             if replacement.replacement_tokens >= replacement.source_tokens:
                 raise CompactionError("compaction replacement is not smaller than its sources")
@@ -616,6 +626,8 @@ class Compactor:
     ) -> tuple[str, Memory, str]:
         history_id = self._history_id(source.memory, replacement.memory.memory_id, source.raw_hash)
         extra = dict(source.memory.extra)
+        history_sources, source_metadata = merge_sources([], source.memory.sources, extra=extra)
+        extra.update(source_metadata)
         extra.update(
             {
                 "reason": "compaction",
@@ -637,7 +649,7 @@ class Compactor:
             scope_source=source.memory.scope_source,
             aliases=list(source.memory.aliases),
             keywords=list(source.memory.keywords),
-            sources=[dict(item) for item in source.memory.sources],
+            sources=history_sources,
             created=source.memory.created,
             updated=source.memory.updated,
             hit_count=source.memory.hit_count,
@@ -741,12 +753,22 @@ class Compactor:
                 self._write_journal_unlocked(journal)
                 for replacement in replacements:
                     path = self.service.vault.memory_path(replacement.memory.memory_id, "knowledge")
-                    if path.exists() or path.is_symlink():
-                        raise CompactionError("compaction replacement exists without a pending transaction")
+                    if path.is_symlink() or not path.exists():
+                        raise CompactionError("compaction canonical survivor disappeared")
+                    canonical_source = selected_by_id[replacement.memory.memory_id]
+                    try:
+                        current = path.read_text(encoding="utf-8")
+                    except (OSError, UnicodeError) as error:
+                        raise CompactionError("cannot read compaction canonical survivor") from error
+                    if _sha256(current) != canonical_source.raw_hash:
+                        raise CompactionError("compaction canonical survivor changed before replacement")
                     atomic_write_text(path, replacement.raw)
                 journal = dict(journal, phase="replacements")
                 self._write_journal_unlocked(journal)
+                survivor_ids = {replacement.memory.memory_id for replacement in replacements}
                 for source in consumed_candidates:
+                    if source.memory.memory_id in survivor_ids:
+                        continue
                     if source.path.is_symlink():
                         raise CompactionError("unsafe active memory path")
                     try:
@@ -792,8 +814,16 @@ class Compactor:
 
     def _run(self, *, model: Any = None, router: Any = None, explicit: bool) -> dict[str, Any]:
         threshold, ratio = self._config()
+        now = _clock_now(getattr(self.service, "clock", None))
+        try:
+            retention = RetentionManager(self.service).maintain(now)
+        except RetentionError as error:
+            if explicit:
+                raise CompactionError("retention maintenance failed") from error
+            return {"status": "failed", "error": "retention maintenance failed"}
         selected, all_active, active_tokens = self._snapshot(threshold, ratio)
         result = self._base_result(selected, all_active, active_tokens, threshold, ratio)
+        result["retention"] = retention
         if not selected:
             return result
         try:
@@ -818,7 +848,6 @@ class Compactor:
             if not output["memories"]:
                 result["status"] = "noop"
                 return result
-            now = _clock_now(getattr(self.service, "clock", None))
             replacements = self._build_plan(output, selected, now=now)
             self._preflight(selected, all_active, replacements)
             history_ids, replacement_ids = self._commit(

{memleaf-0.2.26 → memleaf-0.2.27}/src/memleaf/config.py

@@ -43,6 +43,12 @@ DEFAULT_CONFIG: dict[str, Any] = {
         "memory_compact_threshold_tokens": 100000,
         "memory_compact_candidate_ratio": 0.30,
         "inbox_cleanup_hours": 24,
+        "closed_todo_retention_days": 30,
+    },
+    "history": {
+        "policy": "bounded",
+        "retention_days": 3650,
+        "max_versions_per_memory": 32,
     },
     "capture": {
         "visible_messages_only": True,
@@ -118,6 +124,18 @@ def load_config(path: Path | str, *, vault: Path | str | None = None) -> dict[st
     cleanup_hours = process.get("inbox_cleanup_hours") if isinstance(process, Mapping) else None
     if type(cleanup_hours) is not int or cleanup_hours < 0:
         raise ValueError("invalid memleaf process.inbox_cleanup_hours")
+    closed_todo_days = process.get("closed_todo_retention_days") if isinstance(process, Mapping) else None
+    if type(closed_todo_days) is not int or closed_todo_days < 0:
+        raise ValueError("invalid memleaf process.closed_todo_retention_days")
+    history = merged.get("history")
+    if not isinstance(history, Mapping):
+        raise ValueError("invalid memleaf history settings")
+    if history.get("policy") not in {"bounded", "keep_all"}:
+        raise ValueError("invalid memleaf history.policy")
+    if type(history.get("retention_days")) is not int or history["retention_days"] < 1:
+        raise ValueError("invalid memleaf history.retention_days")
+    if type(history.get("max_versions_per_memory")) is not int or history["max_versions_per_memory"] < 1:
+        raise ValueError("invalid memleaf history.max_versions_per_memory")
     llm = merged.get("llm")
     if not isinstance(llm, Mapping):
         raise ValueError("invalid memleaf llm settings")

{memleaf-0.2.26 → memleaf-0.2.27}/src/memleaf/hermes_provider/__init__.py

@@ -108,11 +108,6 @@ _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."""
 
@@ -1180,83 +1175,6 @@ 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
-
-
 def _bounded_current_tool_evidence(messages: Optional[List[Dict[str, Any]]], *, vault_root: Optional[Path] = None) -> list[dict[str, str]]:
     """Match current-turn results strictly by call ID, not tool name/order.
 

{memleaf-0.2.26 → memleaf-0.2.27}/src/memleaf/hermes_provider/plugin.yaml

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