memleaf 0.2.86__tar.gz → 0.2.88__tar.gz

{memleaf-0.2.86 → memleaf-0.2.88}/CHANGELOG.md

@@ -4,6 +4,64 @@ All notable changes to memleaf are documented here.
 
 ## Unreleased
 
+## 0.2.88 — 2026-10-04
+
+### Reliable queued retention and bounded action queries
+
+- Use the processing timeout for Hermes whole-turn retention completion while
+  keeping queue operations short. Settle fully committed retention intents in
+  the same atomic ledger write as their receipts, including interrupted host
+  callbacks. Reconcile older matching committed intents without model calls;
+  partial, changed-source and revoked-authority intents remain protected.
+- Route conversational saves and lifecycle requests through Hermes's native
+  whole-turn retention tool. Hide bare `remember` and `update_memory` from the
+  Hermes MCP configuration while preserving those public tools for other
+  clients. Return a clear queued acknowledgement before background processing.
+- Add `list_todos(view=full)` with bounded action bodies and explicit versioned
+  continuation for long bodies. Server-managed clients can use `continue=true`
+  with their current retrieval identity instead of copying opaque cursors.
+  Preserve directory/cursor clients, host-owned read accounting and strict
+  stale-turn, cursor and filter validation.
+- Keep absent message times unknown. Explicitly supplied deadlines work without
+  message timestamps; no capture-time fallback or source-time repair is added.
+- Validation: affected local regressions, a zero-model-call replay of the actual
+  committed-intent failure, and isolated real DeepSeek save/deadline and global
+  action-pagination scenarios passed. No additional product model calls,
+  production Vault writes or historical model retries were introduced.
+
+## 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

{memleaf-0.2.86/src/memleaf.egg-info → memleaf-0.2.88}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 0.2.86
+Version: 0.2.88
 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.86。**
+> **版本：0.2.88。**
 > 自动提炼和复核共用同一条“未来记忆价值”标准：模型综合未来复用、信息增量、再次读取时的直接可用性和忘记成本，只保留对未来理解、判断或行动有实质影响的最小核心；没有明确价值的信息不提炼，不按具体业务场景硬编码排除。
-> 提炼先比较旧事项中的编号、目标、进展、责任和期限；补全未知信息也应维护原事项，另建独立待办不能替代项目事实更新。Core 不按标题强行合并。
-> 新请求兼容等价的字段表示；未知执行人保持 `null`，新增或变更负责人、等待方和期限需要真实来源。行动及相关字段经过有界语义复核，提炼与复核共用每份工作的最多两次模型请求额度；复核失败不写入。来源时间用于解析相对日期，不补造事实日期。
+> 提炼先比较旧事项中的编号、目标、进展、责任和期限；补全未知信息也应维护原事项，另建独立待办不能替代项目事实更新。确认重复的记忆在现有处理请求中合并，保留历史与来源；项目和独立任务保持各自生命周期，Core 不按标题强行合并。
+> 新请求兼容等价的字段表示；未知执行人保持 `null`，新增或变更负责人和期限需要真实来源；等待条件在正文维护，不再提炼 `waiting_on`。行动及相关字段经过有界语义复核，提炼与复核共用每份工作的最多五次模型请求额度，成功即停止；复核失败不写入。来源时间用于解析相对日期，不补造事实日期。
 > 待办 `due_date` 只表示待办动作本身明确声明的截止日；属于待办主题或预期结果的日期不会被误作截止日。项目归属由模型按语义判断，不要求项目名在证据里逐字出现。复核阶段会保留首轮已选定的更新目标，避免“状态变更”被降级成新增记忆。Markdown 仍是唯一事实源。
 > **当前版本支持 Hermes 和 Codex。** Antigravity（反重力）不检测、不安装、不配置。
 
@@ -285,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` | 重建可重建的本地派生索引 |
@@ -361,7 +361,7 @@ python -m memleaf.mcp_server --vault /path/to/your/vault \
 
 捕获、索引、目录检索和读取可离线运行；`process()`、`remember()` 和 `compact()` 需要可用的模型能力。
 
-包含行动或责任、期限变更的增量候选通常会追加一次语义复核；每份增量工作最多两次请求，格式修复也计入同一额度。
+包含行动或责任、期限变更的增量候选通常会追加一次语义复核；每份增量工作最多五次请求，格式修复与恢复也计入同一持久化额度，成功即停止。
 
 `llm.mode` 支持：
 

{memleaf-0.2.86 → memleaf-0.2.88}/README.en.md

@@ -4,10 +4,10 @@
 
 [中文](README.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **Version: 0.2.86.**
+> **Version: 0.2.88.**
 > 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 accept equivalent field representations. Unknown executors remain `null`; new or changed responsibility, dependencies and deadlines require actual source evidence. Proposed actions and related fields undergo bounded semantic verification within the existing two-request limit per work item; failed verification blocks writes. 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.
 
@@ -266,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.86 → memleaf-0.2.88}/README.md

@@ -4,10 +4,10 @@
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **版本：0.2.86。**
+> **版本：0.2.88。**
 > 自动提炼和复核共用同一条“未来记忆价值”标准：模型综合未来复用、信息增量、再次读取时的直接可用性和忘记成本，只保留对未来理解、判断或行动有实质影响的最小核心；没有明确价值的信息不提炼，不按具体业务场景硬编码排除。
-> 提炼先比较旧事项中的编号、目标、进展、责任和期限；补全未知信息也应维护原事项，另建独立待办不能替代项目事实更新。Core 不按标题强行合并。
-> 新请求兼容等价的字段表示；未知执行人保持 `null`，新增或变更负责人、等待方和期限需要真实来源。行动及相关字段经过有界语义复核，提炼与复核共用每份工作的最多两次模型请求额度；复核失败不写入。来源时间用于解析相对日期，不补造事实日期。
+> 提炼先比较旧事项中的编号、目标、进展、责任和期限；补全未知信息也应维护原事项，另建独立待办不能替代项目事实更新。确认重复的记忆在现有处理请求中合并，保留历史与来源；项目和独立任务保持各自生命周期，Core 不按标题强行合并。
+> 新请求兼容等价的字段表示；未知执行人保持 `null`，新增或变更负责人和期限需要真实来源；等待条件在正文维护，不再提炼 `waiting_on`。行动及相关字段经过有界语义复核，提炼与复核共用每份工作的最多五次模型请求额度，成功即停止；复核失败不写入。来源时间用于解析相对日期，不补造事实日期。
 > 待办 `due_date` 只表示待办动作本身明确声明的截止日；属于待办主题或预期结果的日期不会被误作截止日。项目归属由模型按语义判断，不要求项目名在证据里逐字出现。复核阶段会保留首轮已选定的更新目标，避免“状态变更”被降级成新增记忆。Markdown 仍是唯一事实源。
 > **当前版本支持 Hermes 和 Codex。** Antigravity（反重力）不检测、不安装、不配置。
 
@@ -266,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` | 重建可重建的本地派生索引 |
@@ -342,7 +342,7 @@ python -m memleaf.mcp_server --vault /path/to/your/vault \
 
 捕获、索引、目录检索和读取可离线运行；`process()`、`remember()` 和 `compact()` 需要可用的模型能力。
 
-包含行动或责任、期限变更的增量候选通常会追加一次语义复核；每份增量工作最多两次请求，格式修复也计入同一额度。
+包含行动或责任、期限变更的增量候选通常会追加一次语义复核；每份增量工作最多五次请求，格式修复与恢复也计入同一持久化额度，成功即停止。
 
 `llm.mode` 支持：
 

{memleaf-0.2.86 → memleaf-0.2.88}/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.86 → memleaf-0.2.88}/pyproject.toml

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

{memleaf-0.2.86 → memleaf-0.2.88}/src/memleaf/__init__.py

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

@@ -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.86 → memleaf-0.2.88}/src/memleaf/adapters/hermes.py

@@ -24,6 +24,7 @@ from .base import (
 
 
 _MCP_IDLE_TIMEOUT_SECONDS = 60
+_HOST_RETENTION_TOOLS = frozenset({"remember", "update_memory"})
 
 
 def expected_mcp_tool_count() -> int:
@@ -452,15 +453,15 @@ class HermesAdapter:
                 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"
+                known = [tool["name"] for tool in _TOOLS if tool["name"] not in _HOST_RETENTION_TOOLS
                     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 "*?[")]
+                literal = [name for name in selected if name not in _HOST_RETENTION_TOOLS 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"]))
+                updated["exclude"] = list(dict.fromkeys([*patterns(updated.get("exclude", [])), *sorted(_HOST_RETENTION_TOOLS)]))
             if updated == filters:
                 return True
             written = run_argv(self.runner, [detection.executable, "config", "set", key,

{memleaf-0.2.86 → memleaf-0.2.88}/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.86 → memleaf-0.2.88}/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.86 → memleaf-0.2.88}/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.86 → memleaf-0.2.88}/src/memleaf/hermes_provider/README.md

@@ -17,6 +17,13 @@ A queued response is not a saved memory. The installer excludes standalone MCP
 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.86 → memleaf-0.2.88}/src/memleaf/hermes_provider/_mcp_client.py

@@ -236,7 +236,9 @@ class _MCPClient:
                 result = self._request_locked(
                     "tools/call",
                     {"name": name, "arguments": dict(arguments)},
-                    timeout=self.process_timeout if name == "process" else self.timeout,
+                    timeout=(self.process_timeout if name == "process"
+                             or name == "remember_turn" and arguments.get("phase") == "complete"
+                             else self.timeout),
                 )
             except _MCPToolError as error:
                 # A local compatibility gate refusal is not a transport failure.

{memleaf-0.2.86 → memleaf-0.2.88}/src/memleaf/hermes_provider/_provider.py

@@ -1370,6 +1370,11 @@ class MemleafMemoryProvider(MemoryProvider):
             return ""
         return (
             "# Memleaf Memory\n"
+            "For a request to save, correct, complete, cancel, reopen, or withdraw memory, "
+            "call memleaf_remember once with this turn's retrieval_id. It queues the actual "
+            "whole turn; no rewritten content, target revision, or message time is needed. "
+            "Use the returned user_message as the save acknowledgement. A queued request "
+            "starts processing only after your final reply, so its changes are pending.\n"
             "Memleaf is the active local-first memory provider. Each visible user "
             "turn must call the configured memleaf MCP search tool at least once "
             "before answering, including ordinary greetings; a no-match result is "
@@ -1383,8 +1388,10 @@ class MemleafMemoryProvider(MemoryProvider):
             "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 "
-            "next_cursor until has_more=false, and read every matching todo body with the same retrieval_id. "
+            "list_todos(view=full) instead of relevance search; omit scope for a global query. "
+            "Use the returned continuation arguments until has_more=false, without copying a cursor. "
+            "Each row includes a body; read only truncated rows with offset=body_next_offset "
+            "and expected_version=version, following their remaining body pages. "
             "Never exclude a todo because another Hermes session or another Agent created it. Hermes has a soft "
             "observer only: do not claim a search happened unless the visible tool "
             "messages show it. Visible Hermes "
@@ -1403,7 +1410,7 @@ 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. For explicit retention use memleaf_remember with the current retrieval_id; it retains verified user messages after the complete turn is captured. Pending means not yet saved. Do not submit assistant-written facts through legacy MCP remember. "
+            "memory IDs, titles, or bodies. Do not infer message time from a deadline or 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; "
@@ -2060,7 +2067,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
@@ -2102,7 +2109,7 @@ class MemleafMemoryProvider(MemoryProvider):
         # gated by the initialized host identity and write policy.
         if not self._write_enabled:
             return []
-        return [{"name": "memleaf_remember", "description": "Use only for an explicit user request to remember. Bind the actual complete user turn; never submit rewritten facts or scopes. Returns pending until the turn is captured and processed.",
+        return [{"name": "memleaf_remember", "description": "Queue the actual complete user turn for a request to save/correct memory, complete/cancel/reopen a task, or withdraw a fact/preference. Call once, with only the current retrieval_id. Reply with the returned user_message to acknowledge the queued request; processing starts after the final reply, so no changes are completed yet.",
                  "parameters": {"type": "object", "properties": {"retrieval_id": {"type": "string"}},
                                 "required": ["retrieval_id"], "additionalProperties": False}}]
 

{memleaf-0.2.86 → memleaf-0.2.88}/src/memleaf/hermes_provider/plugin.yaml

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

{memleaf-0.2.86 → memleaf-0.2.88}/src/memleaf/host_retention.py

@@ -11,6 +11,7 @@ from .retrieval_gate import validate_turn, validate_current_turn
 KEY = "host_retention_intents"
 MAX_PENDING = 128
 INTENT_PREFIX = "host-retain-"
+PENDING_MESSAGE = "保存请求已排队，后台处理完成后生效。"
 
 
 def pending_intents(processed):
@@ -122,7 +123,8 @@ def remember_turn(service, *, phase, retrieval_id=None, source=None, session_id=
             processed[KEY] = pending
             atomic_write_json(service.vault.processed_state_path, processed)
             return {"execution_status": "queued", "saved": False,
-                    "guidance": "The actual user messages will be retained after this turn finishes. Do not claim permanent memory was saved yet."}
+                    "user_message": PENDING_MESSAGE,
+                    "guidance": "Acknowledge only that the request is queued. Use user_message for the save acknowledgement; do not report any change as completed. Processing starts after your final reply."}
         if bound is None:
             return {"execution_status": "not_requested", "saved": False, "model_calls": 0}
         # A started intent already owns its source and allowance. Compression
@@ -138,7 +140,10 @@ def remember_turn(service, *, phase, retrieval_id=None, source=None, session_id=
         turn, _ = _window(service, source, session_id, turn_key(turn_id))
         users = [event for event in turn.events if event.role == "user"]
         request = "\n\n".join(event.content for event in users)
-        refs = [event.event_key for event in users]
+        # One host completion evaluates the entire captured turn. The actual
+        # user request still bounds explicit retention; the assistant remains
+        # a visible source, never authority for new user obligations.
+        refs = [event.event_key for event in turn.events]
         selection, request = bind_selection(intent, refs, request)
         run = load_run(processed, explicit_run_id(source, session_id, selection))
     if run is not None and run["status"] in {"completed", "completed_with_unresolved", "blocked", "failed", "cancelled"}:
@@ -155,6 +160,32 @@ def remember_turn(service, *, phase, retrieval_id=None, source=None, session_id=
     return result
 
 
+def settle_completed_intent_unlocked(processed, work, turn):
+    """Consume only the matching, committed full-turn authority in the same ledger write."""
+    from .incremental_journal import public_result
+    from .turn_plan import input_digest
+    origin = work.get("host_retention_origin")
+    if (origin is None or not work.get("receipt_settled")
+            or public_result(work)["execution_status"] != "completed"
+            or (work["source"], work["session_id"], work["turn_key"])
+               != (turn.source, turn.session_id, turn.turn_key)
+            or work["source_digest"] != input_digest(turn)
+            or {e["event_key"] for e in work["evidence"] if e["use"] == "new"} != set(turn.event_keys)):
+        return False
+    identity = digest([origin[k] for k in ("source", "session_id", "turn_id")])
+    pending = pending_intents(processed)
+    if pending.get(identity) != origin:
+        return False
+    try:
+        check_run_authority(processed, work)
+    except ValueError as error:
+        if str(error) != "source_recording_revoked":
+            raise
+        return False
+    pending.pop(identity)
+    return True
+
+
 def complete_for_captured_turn(service, turn, *, model=None, router=None):
     """Resume durable queued intent after host restart, without borrowing a newer turn."""
     with service.vault.lock():
@@ -165,3 +196,16 @@ def complete_for_captured_turn(service, turn, *, model=None, router=None):
     _, row = bound
     return remember_turn(service, phase="complete", source=turn.source, session_id=turn.session_id,
                          turn_id=row["turn_id"], model=model, router=router)
+
+
+def covers_complete_turn(service, turn, result):
+    """Only a verified immutable full-source commit may replace automatic work."""
+    from .incremental_journal import load_work
+    from .turn_plan import input_digest
+    with service.vault.lock():
+        processed = _read_processed(service.vault.processed_state_path)
+        work = load_work(processed, result.get('commit_work_id', ''))
+        if (work is None or not work.get('host_retention_origin') or not work['receipt_settled']
+                or work['source_digest'] != input_digest(turn)):
+            return False
+        return {e['event_key'] for e in work['evidence'] if e['use'] == 'new'} == set(turn.event_keys)

{memleaf-0.2.86 → memleaf-0.2.88}/src/memleaf/incremental_commit.py

@@ -105,7 +105,7 @@ def _freeze_operation(proposal: dict[str, Any], snapshot: Any, now: str, active:
     else:
         value.update(memory_id=before.memory_id, created=before.created, updated=now)
     after = Memory.from_mapping(value)
-    if before is not None and dedup_digest(before.to_dict()) == dedup_digest(after.to_dict()):
+    if before is not None and not op.get("merge_from") and dedup_digest(before.to_dict()) == dedup_digest(after.to_dict()):
         op.update(action="NO_CHANGE", expected_revision=revision_digest(before))
         return op
     if before is None:
@@ -118,8 +118,14 @@ def _freeze_operation(proposal: dict[str, Any], snapshot: Any, now: str, active:
             return op
     from .incremental_dates import source_basis
     provenance = [source_basis(e) for e in state["evidence"] if e["ref"] in op["evidence"]]
-    after.sources, source_meta = merge_sources(before.sources if before else [], provenance,
-                                               extra=before.extra if before else {})
+    old_sources, old_meta = (before.sources, before.extra) if before else ([], {})
+    if op.get("merge_from"):
+        from .source_policy import merge_memory_provenance
+        peers = [Memory.from_mapping(t["memory"]) for t in state["targets"].values()
+                 if t["memory"]["memory_id"] in op["merge_from"]]
+        old_sources, old_meta = merge_memory_provenance([before, *peers])
+        op["merge_revisions"] = {m.memory_id: revision_digest(m) for m in peers}
+    after.sources, source_meta = merge_sources(old_sources, provenance, extra=old_meta)
     after.extra.update(source_meta)
     after.extra["incremental_operation_id"] = op["operation_id"]
     if any(t["memory"]["memory_id"] == op["memory_id"] and t.get("basis_status") == "external_change_detected"
@@ -162,8 +168,17 @@ def _source_valid(service, processed, work):
 
 
 def _settle_source(service, processed, work, *, source_valid):
+    whole_host_turn = False
+    if source_valid and work.get("host_retention_origin") is not None:
+        # A scoped selection alone cannot prove whole-turn coverage. Only a
+        # verified host intent, evaluated against every current source event,
+        # may settle the automatic route as well.
+        turn, _ = _window(service, work["source"], work["session_id"], work["turn_key"])
+        selected = work.get("binding", {}).get("arguments", {}).get("selection", {})
+        whole_host_turn = (set(selected.get("source_refs", [])) == set(turn.event_keys)
+                           == {e["event_key"] for e in work["evidence"] if e["use"] == "new"})
     if (work.get("request_kind", "automatic") == "explicit_remember"
-            and not any(e.get("explicit_input") for e in work["evidence"])):
+            and not whole_host_turn and not any(e.get("explicit_input") for e in work["evidence"])):
         # This authorization only selected some material. Its own work receipt
         # settles it; it never consumes the automatic turn or changes cleanup.
         return
@@ -232,6 +247,18 @@ def _resume_unlocked(service, processed, work):
                     if not guard_matches(current_guard, work["scope_guard"], applied_additions(work)):
                         raise ValueError("scope_registry_changed")
                 if op["action"] in {"CREATE", "UPDATE"}:
+                    if op.get("merged_into"):
+                        survivor = next((item for item in work["operations"]
+                                         if item.get("memory_id") == op["merged_into"]), None)
+                        current, _ = service._revision_target_unlocked(op["merged_into"])
+                        if (survivor is None or survivor["state"] not in {"applied", "settled"}
+                                or current is None or revision_digest(current.memory) != survivor.get("replacement_revision")):
+                            raise ValueError("merge_survivor_not_committed")
+                        op["merge_revisions"] = {op["merged_into"]: survivor["replacement_revision"]}
+                    for identity, expected in op.get("merge_revisions", {}).items():
+                        current, _ = service._revision_target_unlocked(identity)
+                        if current is None or revision_digest(current.memory) != expected:
+                            raise ValueError("merge_target_changed")
                     # Pin the configuration already authorized above through
                     # the shared writer's history/head boundary as well.
                     guarded_op = {**op, "scope_guard": current_guard} if work.get("scope_guard") is not None else op
@@ -264,6 +291,10 @@ def _resume_unlocked(service, processed, work):
         # These two changes share the final atomic ledger replacement.
         work["receipt_settled"] = True
         _settle_source(service, processed, work, source_valid=source_valid)
+        if source_valid and work.get("host_retention_origin") is not None:
+            from .host_retention import settle_completed_intent_unlocked
+            turn, _ = _window(service, work["source"], work["session_id"], work["turn_key"])
+            settle_completed_intent_unlocked(processed, work, turn)
         save_work(service, processed, work)
     except OSError as error:
         for op in work["operations"]: