memleaf 0.2.85__tar.gz → 0.2.87__tar.gz

{memleaf-0.2.85 → memleaf-0.2.87}/CHANGELOG.md

@@ -4,6 +4,75 @@ All notable changes to memleaf are documented here.
 
 ## Unreleased
 
+## 0.2.87 — 2026-10-04
+
+### Shared source-bound maintenance with bounded model cost
+
+- Allow up to five actual requests per incremental work item, stopping on
+  success. Extraction, format retries, review and recovery share the durable
+  allowance; older work retains its smaller creation-time limit.
+- Bind conversational lifecycle updates to the captured host turn. MCP
+  `update_memory` no longer accepts model-supplied source times or directly
+  commits rewritten facts when host-bound. Preserve the trusted Python API.
+- Retire `waiting_on` from extraction and model/read/list projections; maintain
+  dependencies in the current body. Legacy stored data remains readable.
+- Merge confirmed duplicate memories through the existing processing requests.
+  Preserve combined facts, provenance and history; reject incompatible targets.
+  Commit the survivor before retracting duplicates, with dependency revisions
+  checked at the final writer boundary and recoverable frozen operations.
+- Maintain shared facts across related project and task records using the
+  existing source-bound review. Independent lifecycles remain separate.
+- Retract withdrawn facts/preferences through validity, retaining their history;
+  explicit replacement preferences remain valid. Task cancellation is not a
+  substitute for preference withdrawal.
+- Reuse successful, verified full-turn host retention to settle automatic work
+  without another model request. Partial selected retention does not claim
+  complete automatic coverage. Record actual API token usage without extra
+  requests or counting cached replay usage again.
+- Count known provenance overlaps once; mark counts for truncated histories as
+  upper bounds when their unseen overlap cannot be reconstructed.
+- Validation: 483 affected regression and installation/acceptance checks passed;
+  nine isolated real DeepSeek scenarios and the installed Hermes background
+  callback with current source passed. Saved faulty time arguments were rejected
+  in an isolated zero-call replay. No production memory migration or historical
+  failed-run retry was performed.
+
+## 0.2.86 — 2026-10-04
+
+### Source-bound Hermes retention and general extraction compatibility
+
+- Queue Hermes explicit retention against a stable host turn, then use the
+  actual captured user messages, IDs, timestamps and order. Register the native
+  `memleaf_remember` tool before Provider initialization and configure Hermes to
+  exclude the unbound standalone MCP `remember` tool without changing the public
+  MCP tool list. Queued retention is not reported as a completed save.
+- Preserve bound intent identity across a unique declared compression lineage.
+  Atomically admit one run per intent and check recording authorization across
+  the whole lineage before model dispatch, commit and frozen-work recovery.
+  Unrelated sessions, stale live tokens and ambiguous lineage remain rejected.
+- Normalize equivalent flat/nested field representations with the same compiler
+  and review rules; reject conflicts, retain unknown fields as unknown, and store
+  retraction explanations separately from the empty retracted body.
+- Add a bounded semantic veto for proposed actions, responsibility and deadlines.
+  It can only reject unsupported proposals or remove unverified fields, never
+  invent facts or authorization. Extraction and verification share the existing
+  two-request limit; malformed verification blocks writes.
+- Rank existing comparison candidates using generic normalized terms and their
+  rarity. Keep scope, revision and candidate bounds; explicit write receipts
+  prioritize comparison without skipping independent new information or forcing
+  similar-title merges.
+- Maintain proven completed runtime records before admitting new work, using
+  existing lossless compaction under the writer lock. Preserve unresolved runs
+  and spent allowances. Return specific capacity errors and explicit partial or
+  stale-query guidance instead of implying all work completed.
+- Fix history source statistics double counting while retaining exact legacy
+  recovery compatibility. No historical memory or failed-run migration occurs.
+- Validation: 587 affected checks, 32 checks in the actual Hermes interpreter,
+  64 isolated real-model turns and 58 developer semantic checks passed. Native
+  Hermes MemoryManager/stdio MCP tests covered source times, compression,
+  cross-midnight updates and repeated callbacks. Full Desktop acceptance still
+  requires installation and a Hermes restart.
+
 ## 0.2.85 — 2026-10-03
 
 ### Incremental field protocol

{memleaf-0.2.85/src/memleaf.egg-info → memleaf-0.2.87}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 0.2.85
+Version: 0.2.87
 Summary: A local-first Markdown memory core for AI agents
 Author: memleaf contributors
 License-Expression: MIT
@@ -23,10 +23,10 @@ Dynamic: license-file
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **版本：0.2.85。**
+> **版本：0.2.87。**
 > 自动提炼和复核共用同一条“未来记忆价值”标准：模型综合未来复用、信息增量、再次读取时的直接可用性和忘记成本，只保留对未来理解、判断或行动有实质影响的最小核心；没有明确价值的信息不提炼，不按具体业务场景硬编码排除。
-> 提炼先比较旧事项中的编号、目标、进展、责任和期限；补全未知信息也应维护原事项，另建独立待办不能替代项目事实更新。Core 不按标题强行合并。
-> 新请求使用 `field-reviewed-v1`：CREATE/UPDATE 显式判断结构化期限；未知执行人填 `null`，新增或变更非空负责人必须引用来源原文。Core 校验字段和来源，模型判断业务含义；非法行进入现有 partial 处理。来源时间用于解析相对日期，不补造事实日期。
+> 提炼先比较旧事项中的编号、目标、进展、责任和期限；补全未知信息也应维护原事项，另建独立待办不能替代项目事实更新。确认重复的记忆在现有处理请求中合并，保留历史与来源；项目和独立任务保持各自生命周期，Core 不按标题强行合并。
+> 新请求兼容等价的字段表示；未知执行人保持 `null`，新增或变更负责人和期限需要真实来源；等待条件在正文维护，不再提炼 `waiting_on`。行动及相关字段经过有界语义复核，提炼与复核共用每份工作的最多五次模型请求额度，成功即停止；复核失败不写入。来源时间用于解析相对日期，不补造事实日期。
 > 待办 `due_date` 只表示待办动作本身明确声明的截止日；属于待办主题或预期结果的日期不会被误作截止日。项目归属由模型按语义判断，不要求项目名在证据里逐字出现。复核阶段会保留首轮已选定的更新目标，避免“状态变更”被降级成新增记忆。Markdown 仍是唯一事实源。
 > **当前版本支持 Hermes 和 Codex。** Antigravity（反重力）不检测、不安装、不配置。
 
@@ -166,12 +166,14 @@ python -m pip install -U memleaf && python -m memleaf install
 3. 发现并保存可用的聊天模型路由；Hermes CLI 返回的脱敏凭证不会被当成真实 API key，而会继续尝试环境变量和 Hermes `.env`；已有有效 memleaf 路由会保留；
 4. 激活 `memory.provider=memleaf`；
 5. 通过 Hermes 官方 CLI 配置 memleaf MCP；
-6. 配置 MCP lazy/idle 生命周期；
+6. 配置 MCP lazy/idle 生命周期，以及绑定真实用户消息的 Hermes 原生保存工具；
 7. 验证 MCP Server 能发现当前版本声明的全部工具；
 8. 写入本地 Agent 状态索引。
 
 完成后重启 Hermes。
 
+Hermes 显式保存使用原生 `memleaf_remember`：先绑定本轮并排队，轮次完成后再以真实用户消息提炼，排队不表示已保存。安装器会在 Hermes 中屏蔽独立 MCP `remember`，保留其他工具选择；Core/Python API 和其他客户端的 `remember` 继续可用。仅升级 pip 包不足以更新 Provider 和这项工具配置。
+
 如果没有检测到 Hermes、无法取得完整模型路由、Provider 激活失败或 MCP 工具发现验证失败，安装会明确返回失败，不会把未完成的接入报告为成功。
 
 仓库中的 `install.sh` 保留给源码开发、离线源码安装和故障排查；普通 PyPI 用户不需要执行它。
@@ -283,7 +285,7 @@ python -m memleaf.mcp_server --vault "$HOME/.memleaf"
 | `process_status` | 只读查询异步处理 job 状态 |
 | `recover_failed_run` | 预览并显式恢复终态传输失败，保留原请求预算 |
 | `remember` | 用户明确要求时创建或更新记忆 |
-| `update_memory` | 携带当前 revision 办结、取消或重新激活任务，保留正文与历史 |
+| `update_memory` | 携带当前 revision 维护任务或撤回事实/偏好；宿主绑定的调用排队处理真实消息 |
 | `forget_memory` | 用户明确要求遗忘时，携带 `confirm_delete=true` 按精确 ID 永久删除 |
 | `forget_about` | 携带 `confirm_delete=true` 遗忘明确主题；有歧义时只返回候选 |
 | `rebuild_index` | 重建可重建的本地派生索引 |
@@ -359,6 +361,8 @@ python -m memleaf.mcp_server --vault /path/to/your/vault \
 
 捕获、索引、目录检索和读取可离线运行；`process()`、`remember()` 和 `compact()` 需要可用的模型能力。
 
+包含行动或责任、期限变更的增量候选通常会追加一次语义复核；每份增量工作最多五次请求，格式修复与恢复也计入同一持久化额度，成功即停止。
+
 `llm.mode` 支持：
 
 - `auto`：优先使用显式注入的 host backend，失败后回退到完整 API 路由；

{memleaf-0.2.85 → memleaf-0.2.87}/README.en.md

@@ -4,10 +4,10 @@
 
 [中文](README.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **Version: 0.2.85.**
+> **Version: 0.2.87.**
 > Automatic extraction and review share one future-value standard: the model weighs likely reuse, information gain, direct usability when read again, and the cost of forgetting. It keeps only the smallest core that can materially help future understanding, decisions, or actions; information without clear value is not extracted, and no business-specific exclusion rule is hard-coded.
-> Extraction compares existing identifiers, objectives, progress, responsibility and deadlines first. Filling an unknown also maintains the original item; a separate task does not replace updating shared project facts. Core does not merge matching titles.
-> New requests use `field-reviewed-v1`: CREATE/UPDATE explicitly decide structural deadlines; unknown executors use `null`, and new or changed non-null responsibility requires a source quote. Core validates fields and provenance while the model judges business meaning; invalid rows use existing partial handling. Source time resolves relative dates without inventing factual dates.
+> Extraction compares existing identifiers, objectives, progress, responsibility and deadlines first. Filling an unknown also maintains the original item; a separate task does not replace updating shared project facts. Confirmed duplicates can be merged in the existing processing requests with their sources and history preserved. Independent project and task lifecycles remain separate; Core does not merge matching titles.
+> New requests accept equivalent field representations. Unknown executors remain `null`; new or changed responsibility and deadlines require actual source evidence. Dependencies belong in the body; `waiting_on` is no longer extracted. Proposed actions and related fields undergo bounded semantic verification within a shared five-request limit per work item, stopping on success; failed verification blocks writes. Source time resolves relative dates without inventing factual dates.
 > A todo's `due_date` means only the explicit deadline of the todo action; dates describing its subject or desired outcome are not deadlines. Project ownership remains the model's semantic judgement and needs no literal name match. The review stage now keeps the update target chosen by the first pass, so a state change is no longer downgraded into a new memory. Markdown remains the sole source of truth.
 > **The current release supports Hermes and Codex.** Antigravity is not detected, installed, or configured.
 
@@ -147,12 +147,14 @@ Both installation paths automatically:
 3. Discover and save a callable chat-model route. Redacted credentials returned by the Hermes CLI are never treated as real API keys; discovery falls through to environment variables and Hermes `.env`, while preserving an existing valid memleaf route.
 4. Activate `memory.provider=memleaf`.
 5. Configure the memleaf MCP entry through Hermes' official CLI.
-6. Configure MCP lazy/idle lifecycle settings.
+6. Configure MCP lazy/idle lifecycle settings and the source-bound native Hermes retention tool.
 7. Verify that the MCP server exposes all tools declared by the installed version.
 8. Record the local Agent integration status.
 
 Restart Hermes after installation.
 
+Hermes uses native `memleaf_remember` to queue a request bound to the current turn, then retain the actual user messages after the turn completes. Queued does not mean saved. The installer excludes standalone MCP `remember` in Hermes while preserving other tool choices; the Core/Python API and other clients keep `remember`. Upgrading only the pip package does not refresh the Provider or this tool configuration.
+
 If Hermes cannot be detected, no complete model route can be configured, Provider activation fails, or MCP tool-discovery verification fails, the installer returns an explicit failure rather than reporting an incomplete integration as successful.
 
 The repository `install.sh` remains for source development, offline source installation, and troubleshooting. Normal PyPI users do not need to run it.
@@ -264,7 +266,7 @@ The server exposes the following tools:
 | `process_status` | Read the status of a background processing job |
 | `recover_failed_run` | Preview and explicitly recover terminal transport failures within the original request budget |
 | `remember` | Create or update memory after an explicit request |
-| `update_memory` | Complete, cancel or reopen a task using its current revision; retain body and history |
+| `update_memory` | Maintain tasks or retract facts/preferences using their current revision; host-bound calls queue actual source messages |
 | `forget_memory` | Permanently delete an exact ID after explicit user forgetting, with `confirm_delete=true` |
 | `forget_about` | Forget an unambiguous topic with `confirm_delete=true`; return candidates when ambiguous |
 | `rebuild_index` | Rebuild local derived indexes |

{memleaf-0.2.85 → memleaf-0.2.87}/README.md

@@ -4,10 +4,10 @@
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **版本：0.2.85。**
+> **版本：0.2.87。**
 > 自动提炼和复核共用同一条“未来记忆价值”标准：模型综合未来复用、信息增量、再次读取时的直接可用性和忘记成本，只保留对未来理解、判断或行动有实质影响的最小核心；没有明确价值的信息不提炼，不按具体业务场景硬编码排除。
-> 提炼先比较旧事项中的编号、目标、进展、责任和期限；补全未知信息也应维护原事项，另建独立待办不能替代项目事实更新。Core 不按标题强行合并。
-> 新请求使用 `field-reviewed-v1`：CREATE/UPDATE 显式判断结构化期限；未知执行人填 `null`，新增或变更非空负责人必须引用来源原文。Core 校验字段和来源，模型判断业务含义；非法行进入现有 partial 处理。来源时间用于解析相对日期，不补造事实日期。
+> 提炼先比较旧事项中的编号、目标、进展、责任和期限；补全未知信息也应维护原事项，另建独立待办不能替代项目事实更新。确认重复的记忆在现有处理请求中合并，保留历史与来源；项目和独立任务保持各自生命周期，Core 不按标题强行合并。
+> 新请求兼容等价的字段表示；未知执行人保持 `null`，新增或变更负责人和期限需要真实来源；等待条件在正文维护，不再提炼 `waiting_on`。行动及相关字段经过有界语义复核，提炼与复核共用每份工作的最多五次模型请求额度，成功即停止；复核失败不写入。来源时间用于解析相对日期，不补造事实日期。
 > 待办 `due_date` 只表示待办动作本身明确声明的截止日；属于待办主题或预期结果的日期不会被误作截止日。项目归属由模型按语义判断，不要求项目名在证据里逐字出现。复核阶段会保留首轮已选定的更新目标，避免“状态变更”被降级成新增记忆。Markdown 仍是唯一事实源。
 > **当前版本支持 Hermes 和 Codex。** Antigravity（反重力）不检测、不安装、不配置。
 
@@ -147,12 +147,14 @@ python -m pip install -U memleaf && python -m memleaf install
 3. 发现并保存可用的聊天模型路由；Hermes CLI 返回的脱敏凭证不会被当成真实 API key，而会继续尝试环境变量和 Hermes `.env`；已有有效 memleaf 路由会保留；
 4. 激活 `memory.provider=memleaf`；
 5. 通过 Hermes 官方 CLI 配置 memleaf MCP；
-6. 配置 MCP lazy/idle 生命周期；
+6. 配置 MCP lazy/idle 生命周期，以及绑定真实用户消息的 Hermes 原生保存工具；
 7. 验证 MCP Server 能发现当前版本声明的全部工具；
 8. 写入本地 Agent 状态索引。
 
 完成后重启 Hermes。
 
+Hermes 显式保存使用原生 `memleaf_remember`：先绑定本轮并排队，轮次完成后再以真实用户消息提炼，排队不表示已保存。安装器会在 Hermes 中屏蔽独立 MCP `remember`，保留其他工具选择；Core/Python API 和其他客户端的 `remember` 继续可用。仅升级 pip 包不足以更新 Provider 和这项工具配置。
+
 如果没有检测到 Hermes、无法取得完整模型路由、Provider 激活失败或 MCP 工具发现验证失败，安装会明确返回失败，不会把未完成的接入报告为成功。
 
 仓库中的 `install.sh` 保留给源码开发、离线源码安装和故障排查；普通 PyPI 用户不需要执行它。
@@ -264,7 +266,7 @@ python -m memleaf.mcp_server --vault "$HOME/.memleaf"
 | `process_status` | 只读查询异步处理 job 状态 |
 | `recover_failed_run` | 预览并显式恢复终态传输失败，保留原请求预算 |
 | `remember` | 用户明确要求时创建或更新记忆 |
-| `update_memory` | 携带当前 revision 办结、取消或重新激活任务，保留正文与历史 |
+| `update_memory` | 携带当前 revision 维护任务或撤回事实/偏好；宿主绑定的调用排队处理真实消息 |
 | `forget_memory` | 用户明确要求遗忘时，携带 `confirm_delete=true` 按精确 ID 永久删除 |
 | `forget_about` | 携带 `confirm_delete=true` 遗忘明确主题；有歧义时只返回候选 |
 | `rebuild_index` | 重建可重建的本地派生索引 |
@@ -340,6 +342,8 @@ python -m memleaf.mcp_server --vault /path/to/your/vault \
 
 捕获、索引、目录检索和读取可离线运行；`process()`、`remember()` 和 `compact()` 需要可用的模型能力。
 
+包含行动或责任、期限变更的增量候选通常会追加一次语义复核；每份增量工作最多五次请求，格式修复与恢复也计入同一持久化额度，成功即停止。
+
 `llm.mode` 支持：
 
 - `auto`：优先使用显式注入的 host backend，失败后回退到完整 API 路由；

{memleaf-0.2.85 → memleaf-0.2.87}/examples/incremental_acceptance.json

@@ -31,7 +31,7 @@
           "expected": {
             "execution_status": "completed",
             "coverage_status": "complete",
-            "max_calls": 1,
+            "max_calls": 2,
             "count": 1,
             "required": [
               {
@@ -215,14 +215,13 @@
           "expected": {
             "execution_status": "completed",
             "coverage_status": "complete",
-            "max_calls": 1,
+            "max_calls": 2,
             "count": 1,
             "required": [
               {
                 "memory_id": "mem-report",
                 "status": "active",
                 "assignee": "林工",
-                "waiting_on": "客户验收",
                 "due_date": "2026-09-25"
               }
             ]
@@ -330,7 +329,7 @@
           "expected": {
             "execution_status": "completed",
             "coverage_status": "complete",
-            "max_calls": 1,
+            "max_calls": 2,
             "required": [
               {
                 "memory_id": "mem-report",
@@ -421,7 +420,7 @@
           "expected": {
             "execution_status": "completed",
             "coverage_status": "complete",
-            "max_calls": 1,
+            "max_calls": 2,
             "count": 2,
             "required": [
               {
@@ -471,7 +470,7 @@
           "expected": {
             "execution_status": "completed",
             "coverage_status": "complete",
-            "max_calls": 1,
+            "max_calls": 2,
             "count": 1,
             "required": [
               {
@@ -524,7 +523,7 @@
           "expected": {
             "execution_status": "completed",
             "coverage_status": "complete",
-            "max_calls": 1,
+            "max_calls": 2,
             "count": 1,
             "required": [
               {
@@ -564,7 +563,7 @@
           "expected": {
             "execution_status": "completed",
             "coverage_status": "complete",
-            "max_calls": 1,
+            "max_calls": 2,
             "count": 1,
             "required": [
               {
@@ -665,7 +664,7 @@
           "expected": {
             "execution_status": "completed",
             "coverage_status": "complete",
-            "max_calls": 1,
+            "max_calls": 2,
             "count": 2,
             "required": [
               {
@@ -732,7 +731,7 @@
           "expected": {
             "execution_status": "completed",
             "coverage_status": "complete",
-            "max_calls": 1,
+            "max_calls": 2,
             "count": 1,
             "required": [
               {

{memleaf-0.2.85 → memleaf-0.2.87}/pyproject.toml

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

{memleaf-0.2.85 → memleaf-0.2.87}/src/memleaf/__init__.py

@@ -1,6 +1,6 @@
 """Local-first Markdown memory core for AI agents."""
 
-__version__ = "0.2.85"
+__version__ = "0.2.87"
 
 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.85 → memleaf-0.2.87}/src/memleaf/acceptance.py

@@ -196,7 +196,7 @@ def plan_suite(suite: dict, *, repeats: int = 5) -> dict:
     turns = sum(len(c["turns"]) for c in suite["cases"])
     return {"version": VERSION, "suite_id": suite["suite_id"], "suite_sha256": _hash(_canonical(suite)),
             "cases": len(suite["cases"]), "turns_per_repeat": turns, "repeats": repeats,
-            "normal_request_upper_bound": turns * repeats,
+            "normal_request_upper_bound": turns * repeats * 2,
             "recovery_request_upper_bound": turns * repeats * 2,
             "model_calls": 0, "mode": "plan", "semantic_status": "not_run",
             "switch_authorized": False, "prompt_sha256": _hash(INCREMENTAL_SYSTEM.encode("utf-8")),
@@ -327,7 +327,7 @@ def _checks(expected: dict, records: list[dict], observations: list[dict], calls
         else:  # forbidden
             good = all(not any(matches(r, forbidden) for r in records) for forbidden in value)
         results.append({"check": key, "passed": good})
-    results.append({"check": "per_work_request_cap", "passed": result.get("reserved_requests", 0) <= 2})
+    results.append({"check": "per_work_request_cap", "passed": result.get("reserved_requests", 0) <= result["request_limit"]})
     return results
 
 

{memleaf-0.2.85 → memleaf-0.2.87}/src/memleaf/adapters/hermes.py

@@ -420,6 +420,58 @@ class HermesAdapter:
                 return False
         return True
 
+    def configure_retention_tools(self, detection=None):
+        """Keep one host-bound retention entry, preserving unrelated tool choices."""
+        import fnmatch
+        detection = detection or self.detect()
+        if detection.confidence != "high" or not detection.executable:
+            return False
+        key = "mcp_servers.memleaf.tools"
+        command = [detection.executable, "config", "get", key, "--json"]
+        try:
+            result = run_argv(self.runner, command, env=self.env)
+            if result.returncode == 0:
+                filters = json.loads(result.stdout)
+                if not isinstance(filters, dict):
+                    return False
+            elif "Config key not set: " + key in result.stdout + result.stderr:
+                filters = {}
+            else:
+                return False
+            updated = dict(filters)
+            from ..mcp_server import _TOOLS
+            def patterns(value):
+                if isinstance(value, str):
+                    return [value]
+                if isinstance(value, list) and all(isinstance(x, str) for x in value):
+                    return value
+                raise ValueError("invalid tool filter")
+            if "include" in updated:
+                selected = patterns(updated["include"])
+                managed = updated.pop("memleaf_bound_retention", None)
+                if (isinstance(managed, dict) and set(managed) == {"patterns", "applied"}
+                        and managed["applied"] == selected):
+                    selected = patterns(managed["patterns"])
+                known = [tool["name"] for tool in _TOOLS if tool["name"] != "remember"
+                    and any(fnmatch.fnmatchcase(tool["name"], pattern) for pattern in selected)]
+                # Retain explicit future names and original wildcard intent so
+                # reinstalling a newer declaration set does not freeze it.
+                literal = [name for name in selected if name != "remember" and not any(c in name for c in "*?[")]
+                updated["include"] = list(dict.fromkeys([*known, *literal]))
+                updated["memleaf_bound_retention"] = {"patterns": selected, "applied": updated["include"]}
+            else:
+                updated["exclude"] = list(dict.fromkeys([*patterns(updated.get("exclude", [])), "remember"]))
+            if updated == filters:
+                return True
+            written = run_argv(self.runner, [detection.executable, "config", "set", key,
+                json.dumps(updated, ensure_ascii=False)], env=self.env)
+            if written.returncode != 0:
+                return False
+            confirmed = run_argv(self.runner, command, env=self.env)
+            return confirmed.returncode == 0 and json.loads(confirmed.stdout) == updated
+        except (OSError, ValueError, TypeError):
+            return False
+
     def test_mcp(
         self,
         detection: Detection | None = None,

{memleaf-0.2.85 → memleaf-0.2.87}/src/memleaf/compaction.py

@@ -427,7 +427,7 @@ class Compactor:
         value = _content_mapping(candidate.memory)
         value["memory_id"] = candidate.memory.memory_id
         value["validity"] = candidate.memory.validity
-        for key in ("assignee", "waiting_on", "due_text"):
+        for key in ("assignee", "due_text"):
             if key in candidate.memory.extra:
                 value[key] = deepcopy(candidate.memory.extra[key])
         return value

{memleaf-0.2.85 → memleaf-0.2.87}/src/memleaf/extraction_budget.py

@@ -14,6 +14,8 @@ from .llm import ModelError
 
 
 MAX_MODEL_REQUESTS = 3
+# Incremental drafting, format repair and review share one durable allowance.
+MAX_INCREMENTAL_REQUESTS = 5
 TARGET_TOTAL_SECONDS = 10.0
 
 
@@ -205,6 +207,7 @@ def budget_single_pass_backend(
 
 __all__ = [
     "MAX_MODEL_REQUESTS",
+    "MAX_INCREMENTAL_REQUESTS",
     "TARGET_TOTAL_SECONDS",
     "ExtractionTiming",
     "aggregate_extraction_metrics",

{memleaf-0.2.85 → memleaf-0.2.87}/src/memleaf/extraction_work_state.py

@@ -17,7 +17,7 @@ from pathlib import Path
 from typing import Any, Mapping
 
 from .locking import atomic_write_json, read_json
-from .extraction_budget import MAX_MODEL_REQUESTS
+from .extraction_budget import MAX_MODEL_REQUESTS, MAX_INCREMENTAL_REQUESTS
 from .validation import parse_strict_json
 
 
@@ -307,7 +307,7 @@ def reserve_model_request(
         raise ExtractionWorkStateError("invalid extraction work id")
     if not _valid_identifier(turn_id, maximum=800):
         raise ExtractionWorkStateError("invalid extraction turn id")
-    if type(request_limit) is not int or not 1 <= request_limit <= MAX_MODEL_REQUESTS:
+    if type(request_limit) is not int or not 1 <= request_limit <= max(MAX_MODEL_REQUESTS, MAX_INCREMENTAL_REQUESTS):
         raise ExtractionWorkStateError("invalid extraction request limit")
     if type(legacy_source_unchanged) is not bool:
         raise ExtractionWorkStateError("invalid legacy source compatibility flag")

{memleaf-0.2.85 → memleaf-0.2.87}/src/memleaf/hermes_provider/README.md

@@ -10,9 +10,20 @@ Automatic capture and processing use only the visible user and assistant text.
 Tool calls and results, email or attachment bodies, and other hidden payloads are
 not automatic memory input.
 Hermes uses MCP `search` and `read` with the current `retrieval_id` for recall.
-MCP also supports explicit `remember`, `forget`, and maintenance operations.
+The native `memleaf_remember` tool queues explicit retention bound to the current
+turn; the completed capture supplies the original user messages and source times.
+A queued response is not a saved memory. The installer excludes standalone MCP
+`remember` in Hermes while preserving other configured tool choices. MCP still
+supports `remember` for other clients, plus `forget` and maintenance operations.
 This is a Soft Gate, not a guarantee that every answer has performed retrieval.
 
+The bound native route also handles conversational corrections, completion,
+cancellation, reopening and withdrawal. A successful full-turn retention receipt
+settles automatic extraction without another model request. Partial selections
+remain separate. MCP lifecycle updates do not accept model-supplied source times;
+trusted Python callers keep their explicit metadata API. Restart Hermes after
+upgrading to load the current Provider.
+
 Hermes discovers this directory when it is installed as:
 
 ```text

{memleaf-0.2.85 → memleaf-0.2.87}/src/memleaf/hermes_provider/_provider.py

@@ -1380,6 +1380,7 @@ class MemleafMemoryProvider(MemoryProvider):
             "current turn's retrieval_id exactly as supplied; a missing or mismatched "
             "token is a read failure, never a reason to fall back to a file tool. "
             "Read more only if needed; for ordinary relevance queries, do not read all entries to filter unrelated items. "
+            "When pipeline_status is pending/unknown, memory can lag recent conversation: qualify current-state claims. For partial or completed_with_unresolved writes, report only the individually committed changes, and say which remain unresolved; never claim the entire request succeeded. "
             "When the user asks for current "
             "todos, all unfinished work, urgent work, or work due in a time range, call memleaf MCP "
             "list_todos instead of relevance search; omit scope for a global query, follow every "
@@ -1390,7 +1391,7 @@ class MemleafMemoryProvider(MemoryProvider):
             "turns are durably captured into the local memleaf inbox. Automatic "
             "capture → process runs after your final answer and is authoritative: "
             "a capture only proves that the inbox received the turn. Until a "
-            "successful explicit remember or update tool result is visible, never "
+            "explicit tool result proves execution_status=completed and complete coverage, never "
             "say that the turn was saved to permanent memory, persisted, or "
             "记好了/已落库. For automatic handling, say only that you will process "
             "it through the workflow or that it is recorded in the current "
@@ -1402,7 +1403,8 @@ class MemleafMemoryProvider(MemoryProvider):
             "file writes to simulate success, and do not infer automatic success merely because "
             "active or history files exist. Automatic recall is a directory of "
             "scope identifiers, hierarchy, and aliases only; it never contains "
-            "memory IDs, titles, or bodies. Use deliberate remember/forget tools "
+            "memory IDs, titles, or bodies. For explicit retention or corrections, task completion/cancellation/reopening, and withdrawing a fact/preference, use memleaf_remember with the current retrieval_id. It processes the actual complete turn and preserves audit history. Do not perform a conversational lifecycle edit through an unbound MCP update or infer message time from a deadline. Pending means not yet saved. Do not submit assistant-written facts through legacy MCP remember. "
+            "Use deliberate remember/forget tools "
             "only when the user explicitly asks for that operation. Automatic "
             "capture and processing use only visible user and assistant text; "
             "tool calls/results, email or attachment bodies, and other hidden "
@@ -2027,6 +2029,10 @@ class MemleafMemoryProvider(MemoryProvider):
                         retrieval_turn_id=retrieval_turn_id if role == "assistant" else None,
                     ):
                         return
+                if self._gate_enabled:
+                    self._call("remember_turn", {"phase": "complete", "source": "hermes",
+                        "session_id": effective_session, "turn_id": turn_id},
+                        stage="remember_turn", session_id=effective_session, turn_id=turn_id)
                 if not self._auto_process:
                     return
                 if not lineage_ready:
@@ -2054,7 +2060,7 @@ class MemleafMemoryProvider(MemoryProvider):
         if not tool_name.startswith(prefix):
             return None
         name = tool_name[len(prefix):]
-        if name not in {"search", "read", "list_todos", "scope_catalog", "remember"}:
+        if name not in {"search", "read", "list_todos", "scope_catalog", "remember", "update_memory"}:
             return None
         turn_id = _host_turn_id(turn_context)
         session = turn_context.get("session_id") if isinstance(turn_context, Mapping) else None
@@ -2072,9 +2078,9 @@ class MemleafMemoryProvider(MemoryProvider):
             bound.update(source="hermes", session_id=session, turn_id=turn_id,
                          intent_id="host-op-" + sha256((turn_id + "/" + tool_call_id + "/" + name).encode()).hexdigest())
             bound.pop("event_id", None)
-            # No source timestamp is assigned to an assistant-written composite
-            # explicit request; only the submitted text itself is its evidence.
-            bound.pop("source_time", None)
+            # New hosts route retention to the source-bound lifecycle tool.
+            # Never authorize the model's rewritten text as user evidence.
+            raise ValueError("memory_host_retention_requires_bound_tool")
         elif name == "scope_catalog":
             bound.update(source="hermes", session_id=session, turn_id=turn_id)
         else:
@@ -2092,10 +2098,25 @@ class MemleafMemoryProvider(MemoryProvider):
         return bound
 
     def get_tool_schemas(self) -> List[Dict[str, Any]]:
-        # memleaf-mcp remains configured separately for deliberate search,
-        # remember, and forget operations. The native provider owns automatic
-        # recall/capture only, avoiding duplicate tool names in Hermes.
-        return []
+        # Hermes registers schemas before initialize_all. Execution remains
+        # gated by the initialized host identity and write policy.
+        if not self._write_enabled:
+            return []
+        return [{"name": "memleaf_remember", "description": "Use for an explicit user request to remember or maintain existing memory: corrections, task completion/cancellation/reopening, or withdrawal of a fact/preference. Bind the actual complete user turn; never submit rewritten facts, dates or scopes. Returns pending until the turn is captured and processed.",
+                 "parameters": {"type": "object", "properties": {"retrieval_id": {"type": "string"}},
+                                "required": ["retrieval_id"], "additionalProperties": False}}]
+
+    def handle_tool_call(self, tool_name: str, args: Dict[str, Any], **kwargs: Any) -> str:
+        if (tool_name != "memleaf_remember" or not self._write_enabled or not self._gate_enabled
+                or not isinstance(args, dict) or set(args) != {"retrieval_id"}):
+            return json.dumps({"error": {"code": "invalid_host_retention_request"}})
+        session = self._canonical_session_id(self._session_id)
+        if not isinstance(args["retrieval_id"], str) or args["retrieval_id"] != self._current_gate_id(session):
+            return json.dumps({"error": {"code": "host_retention_turn_mismatch"}, "saved": False})
+        result = self._call("remember_turn", {"phase": "queue", "retrieval_id": args["retrieval_id"]}, stage="remember_turn")
+        if result is _CALL_FAILED:
+            return json.dumps({"error": {"code": "host_retention_not_queued"}, "saved": False})
+        return json.dumps(result, ensure_ascii=False)
 
     def shutdown(self) -> None:
         with self._sync_lock:

{memleaf-0.2.85 → memleaf-0.2.87}/src/memleaf/hermes_provider/plugin.yaml

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