memleaf 0.2.87__tar.gz → 0.2.89__tar.gz

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

@@ -4,6 +4,56 @@ All notable changes to memleaf are documented here.
 
 ## Unreleased
 
+## 0.2.89 — 2026-10-04
+
+### Complete comparison context and bound tool continuation
+
+- Remove the 20-memory comparison ceiling and capture truncation. Keep all
+  required read, receipt and revision targets, limiting only optional recall
+  and the existing total request size. Preserve strict source, scope and
+  missing-target validation; incomplete historical capsules remain protected.
+- Use one discoverable Hermes MCP `save_turn` route for source-bound retention
+  and lifecycle requests. Stop exposing a competing native save schema while
+  preserving its legacy handler and internal completion interface. Queueing
+  remains idempotent and does not claim that changes have already been saved.
+- Bind long-body continuation to server-owned memory IDs, versions, offsets
+  and history flags. Clients follow `body_continuation` without copying record
+  tuples; version changes require an explicit restart of the same target.
+  Preserve direct versioned reads and strict current-turn checks.
+- Keep delivery dates and progress out of task titles, retaining years that
+  identify the subject. Verify body clauses against actual user-confirmed
+  facts and repair unsupported prose in the existing review pass without
+  changing evidence, ownership or deadlines. No model stage is added.
+- Validation: 411 affected local checks, an isolated replay of the real
+  21-action conversation, and three real DeepSeek extraction/review samples
+  passed. Formal Vault data and historical jobs were not changed; updated
+  Hermes desktop behavior still requires installation and a host restart.
+
+## 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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 0.2.87
+Version: 0.2.89
 Summary: A local-first Markdown memory core for AI agents
 Author: memleaf contributors
 License-Expression: MIT
@@ -23,7 +23,7 @@ Dynamic: license-file
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **版本：0.2.87。**
+> **版本：0.2.89。**
 > 自动提炼和复核共用同一条“未来记忆价值”标准：模型综合未来复用、信息增量、再次读取时的直接可用性和忘记成本，只保留对未来理解、判断或行动有实质影响的最小核心；没有明确价值的信息不提炼，不按具体业务场景硬编码排除。
 > 提炼先比较旧事项中的编号、目标、进展、责任和期限；补全未知信息也应维护原事项，另建独立待办不能替代项目事实更新。确认重复的记忆在现有处理请求中合并，保留历史与来源；项目和独立任务保持各自生命周期，Core 不按标题强行合并。
 > 新请求兼容等价的字段表示；未知执行人保持 `null`，新增或变更负责人和期限需要真实来源；等待条件在正文维护，不再提炼 `waiting_on`。行动及相关字段经过有界语义复核，提炼与复核共用每份工作的最多五次模型请求额度，成功即停止；复核失败不写入。来源时间用于解析相对日期，不补造事实日期。
@@ -166,13 +166,13 @@ 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 生命周期，以及绑定真实用户消息的 Hermes 原生保存工具；
+6. 配置 MCP lazy/idle 生命周期，以及绑定真实用户消息的 Hermes MCP 保存入口；
 7. 验证 MCP Server 能发现当前版本声明的全部工具；
 8. 写入本地 Agent 状态索引。
 
 完成后重启 Hermes。
 
-Hermes 显式保存使用原生 `memleaf_remember`：先绑定本轮并排队，轮次完成后再以真实用户消息提炼，排队不表示已保存。安装器会在 Hermes 中屏蔽独立 MCP `remember`，保留其他工具选择；Core/Python API 和其他客户端的 `remember` 继续可用。仅升级 pip 包不足以更新 Provider 和这项工具配置。
+Hermes 显式保存使用 MCP `save_turn`：先绑定本轮并排队，轮次完成后再以真实用户消息提炼，排队不表示已保存。它与检索工具共用 Hermes 的延迟工具入口，Provider 不再另外暴露原生保存工具。安装器会在 Hermes 中屏蔽独立 MCP `remember`，保留其他工具选择；Core/Python API 和其他客户端的 `remember` 继续可用。仅升级 pip 包不足以更新 Provider 和这项工具配置。
 
 如果没有检测到 Hermes、无法取得完整模型路由、Provider 激活失败或 MCP 工具发现验证失败，安装会明确返回失败，不会把未完成的接入报告为成功。
 

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

@@ -4,7 +4,7 @@
 
 [中文](README.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **Version: 0.2.87.**
+> **Version: 0.2.89.**
 > 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. 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.
@@ -147,13 +147,13 @@ 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 and the source-bound native Hermes retention tool.
+6. Configure MCP lazy/idle lifecycle settings and the source-bound Hermes MCP save route.
 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.
+Hermes uses MCP `save_turn` to queue a request bound to the current turn, then retain the actual user messages after the turn completes. Queued does not mean saved. It shares the deferred MCP tool space with retrieval; the Provider no longer exposes a separate native save schema. 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.
 

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

@@ -4,7 +4,7 @@
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **版本：0.2.87。**
+> **版本：0.2.89。**
 > 自动提炼和复核共用同一条“未来记忆价值”标准：模型综合未来复用、信息增量、再次读取时的直接可用性和忘记成本，只保留对未来理解、判断或行动有实质影响的最小核心；没有明确价值的信息不提炼，不按具体业务场景硬编码排除。
 > 提炼先比较旧事项中的编号、目标、进展、责任和期限；补全未知信息也应维护原事项，另建独立待办不能替代项目事实更新。确认重复的记忆在现有处理请求中合并，保留历史与来源；项目和独立任务保持各自生命周期，Core 不按标题强行合并。
 > 新请求兼容等价的字段表示；未知执行人保持 `null`，新增或变更负责人和期限需要真实来源；等待条件在正文维护，不再提炼 `waiting_on`。行动及相关字段经过有界语义复核，提炼与复核共用每份工作的最多五次模型请求额度，成功即停止；复核失败不写入。来源时间用于解析相对日期，不补造事实日期。
@@ -147,13 +147,13 @@ 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 生命周期，以及绑定真实用户消息的 Hermes 原生保存工具；
+6. 配置 MCP lazy/idle 生命周期，以及绑定真实用户消息的 Hermes MCP 保存入口；
 7. 验证 MCP Server 能发现当前版本声明的全部工具；
 8. 写入本地 Agent 状态索引。
 
 完成后重启 Hermes。
 
-Hermes 显式保存使用原生 `memleaf_remember`：先绑定本轮并排队，轮次完成后再以真实用户消息提炼，排队不表示已保存。安装器会在 Hermes 中屏蔽独立 MCP `remember`，保留其他工具选择；Core/Python API 和其他客户端的 `remember` 继续可用。仅升级 pip 包不足以更新 Provider 和这项工具配置。
+Hermes 显式保存使用 MCP `save_turn`：先绑定本轮并排队，轮次完成后再以真实用户消息提炼，排队不表示已保存。它与检索工具共用 Hermes 的延迟工具入口，Provider 不再另外暴露原生保存工具。安装器会在 Hermes 中屏蔽独立 MCP `remember`，保留其他工具选择；Core/Python API 和其他客户端的 `remember` 继续可用。仅升级 pip 包不足以更新 Provider 和这项工具配置。
 
 如果没有检测到 Hermes、无法取得完整模型路由、Provider 激活失败或 MCP 工具发现验证失败，安装会明确返回失败，不会把未完成的接入报告为成功。
 

{memleaf-0.2.87 → memleaf-0.2.89}/docs/hermes-source-comparison-context.md

@@ -40,9 +40,13 @@ assistant event, including the immutable capture receipt and payload digest.
 It accepts no caller-supplied list of IDs through this interface. The capsule is
 comparison metadata, not factual evidence, and its token is not projected into
 the model request. Automatic preparation gives these required targets priority
-alongside explicit-write receipts before filling the bounded candidate budget.
-A missing target or insufficient budget blocks preparation instead of silently
-replacing or dropping the required target. No model call is added to capture.
+alongside explicit-write receipts. There is no 20-ID truncation or target-count
+ceiling: required targets expand the preferred candidate count; optional recall
+only fills remaining slots. A missing target or an oversized request still blocks
+preparation instead of silently dropping required context. The existing request
+byte budget remains; no model call is added to capture. Legacy capsules already
+marked overflow remain incomplete and cannot be silently reconstructed from a
+later live gate.
 
 A delayed callback can use its own unexpired gate even after a later turn starts.
 Once the capsule is captured, gate expiry cannot erase it or break a duplicate

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

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

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

@@ -1,6 +1,6 @@
 """Local-first Markdown memory core for AI agents."""
 
-__version__ = "0.2.87"
+__version__ = "0.2.89"
 
 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.87 → memleaf-0.2.89}/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.87 → memleaf-0.2.89}/src/memleaf/hermes_provider/README.md

@@ -10,14 +10,14 @@ 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.
-The native `memleaf_remember` tool queues explicit retention bound to the current
+The deferred MCP `save_turn` 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,
+The bound MCP 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;

{memleaf-0.2.87 → memleaf-0.2.89}/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.87 → memleaf-0.2.89}/src/memleaf/hermes_provider/_provider.py

@@ -1370,6 +1370,12 @@ class MemleafMemoryProvider(MemoryProvider):
             return ""
         return (
             "# Memleaf Memory\n"
+            "For a request to save, correct, complete, cancel, reopen, or withdraw memory, "
+            "discover and call the deferred MCP tool mcp__memleaf__save_turn once with this turn's retrieval_id, "
+            "using the exact name returned by tool_search through tool_call. 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 +1389,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; after list pagination, follow the returned body_continuation "
+            "with MCP read until it is absent. The server owns the memory ID, version and offset. "
             "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 +1411,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 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. "
+            "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,8 +2068,10 @@ 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", "update_memory"}:
+        if name not in {"search", "read", "list_todos", "scope_catalog", "remember", "update_memory", "save_turn"}:
             return None
+        if name == "save_turn" and (not self._write_enabled or not self._gate_enabled):
+            raise ValueError("memory_host_retention_disabled")
         turn_id = _host_turn_id(turn_context)
         session = turn_context.get("session_id") if isinstance(turn_context, Mapping) else None
         ordinal = turn_context.get("turn_number") if isinstance(turn_context, Mapping) else None
@@ -2098,13 +2108,11 @@ class MemleafMemoryProvider(MemoryProvider):
         return bound
 
     def get_tool_schemas(self) -> List[Dict[str, Any]]:
-        # 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}}]
+        # One discoverable MCP save_turn route avoids the host's split between
+        # native provider tools and deferred tool_call dispatch. Keep the old
+        # handler below for already registered native clients, without exposing
+        # two competing ways to save the same turn.
+        return []
 
     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

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

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

{memleaf-0.2.87 → memleaf-0.2.89}/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
@@ -158,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():

{memleaf-0.2.87 → memleaf-0.2.89}/src/memleaf/incremental_commit.py

@@ -56,7 +56,7 @@ def _arguments(source, session_id, turn_id, scope, priority_memory_ids, candidat
     source, session_id = safe_component(source, "source"), safe_component(session_id, "session id")
     if not isinstance(turn_id, str) or not turn_id or len(turn_id) > 800:
         raise ValueError("invalid_turn_id")
-    if type(candidate_limit) is not int or not 1 <= candidate_limit <= 20:
+    if type(candidate_limit) is not int or candidate_limit < 1:
         raise ValueError("invalid_candidate_limit")
     if type(allow_new_scopes) is not bool:
         raise ValueError("invalid_context_flags")
@@ -291,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"]:

{memleaf-0.2.87 → memleaf-0.2.89}/src/memleaf/incremental_preview.py

@@ -30,13 +30,14 @@ def _prepare_incremental_unlocked(service: Any, *, source: str, session_id: str,
 
     At this stage evidence units are complete visible messages, not per-sentence
     heuristic fragments. Caller-provided target IDs are required context and are
-    never dropped to fit the budget. Other candidates share the budget by query.
+    never dropped to fit a count limit. candidate_limit bounds optional recall;
+    required comparison targets expand that count within the request byte budget.
     """
     source = safe_component(source, "source")
     session_id = safe_component(session_id, "session id")
     if not isinstance(turn_id, str) or not turn_id:
         raise ValueError("invalid_turn_id")
-    if type(candidate_limit) is not int or not 1 <= candidate_limit <= 20:
+    if type(candidate_limit) is not int or candidate_limit < 1:
         raise ValueError("invalid_candidate_limit")
     from .incremental_scopes import registry_view, resolve_scope
     registry, scope_guard, scope_aliases = registry_view(service.vault.config())
@@ -47,8 +48,6 @@ def _prepare_incremental_unlocked(service: Any, *, source: str, session_id: str,
     if isinstance(priority_memory_ids, (str, bytes)):
         raise ValueError("invalid_priority_ids")
     priority = list(dict.fromkeys(priority_memory_ids))
-    if len(priority) > candidate_limit:
-        raise ValueError("blocked_context")
     for identity in priority:
         safe_component(identity, "memory id")
     # Do not use the mutation boundary: it would resume compaction writes.
@@ -149,15 +148,13 @@ def _prepare_incremental_unlocked(service: Any, *, source: str, session_id: str,
             if context.get("overflow") is not False:
                 raise ValueError("blocked_context")
             identities = context.get("memory_ids")
-            if not isinstance(identities, list) or len(identities) > 20:
+            if not isinstance(identities, list):
                 raise ValueError("invalid_comparison_context")
             for identity in identities:
                 safe_component(identity, "memory id")
             read_ids.extend(identities)
     priority = list(dict.fromkeys(explicit_ids + read_ids + priority))
     priority += sorted(x for x in prior_ids if x.casefold() in records and x not in priority)
-    if len(priority) > candidate_limit:
-        raise ValueError("blocked_context")
     chosen = []
     for identity in priority:
         if identity.casefold() not in records:
@@ -165,15 +162,19 @@ def _prepare_incremental_unlocked(service: Any, *, source: str, session_id: str,
         chosen.append(records[identity.casefold()])
     from .planning_candidates import ComparisonRanker
     ranker = ComparisonRanker(records)
+    # Required reads/receipts are supplied in full. Recall adds only enough
+    # optional targets to reach the caller's preferred count, without ranking
+    # unrelated memories when required context already exceeds it.
+    optional_limit = min(max(0, candidate_limit - len(chosen)), len(records))
+    seen = {memory.memory_id.casefold() for memory in chosen}
     query_rows = []
-    for event in evidence:
+    for event in evidence if optional_limit else ():
         for is_native in (False, True):
-            keys = [key for key in records if (key in native_keys) == is_native]
-            query_rows.append([records[key] for key in ranker.rank(event["text"], keys, candidate_limit)])
+            keys = [key for key in records if key not in seen and (key in native_keys) == is_native]
+            query_rows.append([records[key] for key in ranker.rank(event["text"], keys, optional_limit)])
     # Reuse the pure retrieval functions, not service._search_unlocked(),
     # whose index accessor may rebuild files or recover compaction.
-    seen = {memory.memory_id.casefold() for memory in chosen}
-    for rank in range(candidate_limit):
+    for rank in range(optional_limit):
         for candidates in query_rows:
             if len(chosen) >= candidate_limit:
                 break

{memleaf-0.2.87 → memleaf-0.2.89}/src/memleaf/incremental_prompts.py

@@ -6,9 +6,10 @@ INCREMENTAL_SYSTEM = """从完整可见对话提炼长期记忆，返回严格 J
 - 用户明确撤回旧事实或偏好：UPDATE 原 target，patch.validity=retracted；撤回说明转入历史，不作为仍有效的偏好保留。用户明确给出替代事实/新偏好：UPDATE 原 target 为新的有效内容。撤回后“需要时另说”不代表已建立替代偏好。
 - user 的已确认事实、决定、持续目标、责任、期限、进展、偏好可保留。临时操作请求及普通应答不自动产生长期待办。
 - assistant 仅能解释已确认事实、报告有依据的已执行结果。assistant 的建议、计划、推测、额外安排不产生用户/第三人义务、承诺、偏好或期限；用户确认一件事不等于确认回复的其他建议。不要把“建议以后做”改写成“需要做”。
+- 逐分句核验正文：assistant 增加的原因、影响、条件或后续步骤，user 未确认则省略；其余已确认事实保留。
 - use=new 是本轮变化依据；context、旧目标、explicit_writes 仅供比较，不能独立产生新事实。逐项核对证据是否支持拟写事实、归属、执行人和日期。
 
-维护前先比较 new 与目标 observed 的先后。new 已被较新 context/目标覆盖时，不重放较新变化，本轮无变化用 NO_CHANGE；不得借 context 推动 deadline 清空。按身份/编号、主体、目标和业务上下文比较所有候选旧事项，包含已完成项和跨会话来源。缺编号的旧目标得到编号、旧状态被纠正、结构字段得到明确依据，都 UPDATE 原目标；完整涵盖且无变化才 NO_CHANGE。独立新事项 CREATE，不凭同标题或词语相似合并。同一事实变更同步维护全部相关候选；项目/任务旧职责不能遗漏为 NO_CHANGE。项目与独立任务各自保留生命周期。只有确认为同一事项的重复记录才 MERGE，不凭标题相似合并。保留旧目标其余仍有效信息；当前正文表达当前状态，不追加日志。
+比较 new 与目标 observed 的先后；已被较新 context/目标覆盖的变化不重放，无变化 NO_CHANGE，不借 context 清空 deadline。按身份/编号、主体、目标和业务上下文比较全部候选，包含已完成项和跨会话来源。补编号、纠正状态、补有依据的结构字段均 UPDATE 原目标；完整覆盖才 NO_CHANGE。独立新事项 CREATE；同一变化同步维护全部相关候选，旧职责不可遗漏。项目与独立任务各保留生命周期；确为同一事项的重复记录才 MERGE，不凭标题相似合并。保留其余有效旧事实，正文表达当前状态，不追加日志。
 
 动作：
 CREATE：action、非空 evidence、memory；memory 必填 type/scope/title/body。
@@ -18,13 +19,13 @@ NO_CHANGE：action、非空 evidence、target；正文及结构化字段均已
 DEFERRED：action、非空 evidence、reason、need；reason=missing_identity|missing_context|conflict，need 说明无法确定的内容。
 NO_MEMORY：仅 action；自动模式整轮无值得维护/新增的内容时独占 items。
 每项 evidence 是引用字符串数组，例如 ["e1","e2"]，不能复制整个证据对象。至少一个 use=new 引用，必须实际支持本项，不要求覆盖每条消息。
-结构示例（省略号替换为实际内容）：
+结构示例：
 {"action":"CREATE","evidence":["e1"],"memory":{"type":"fact","scope":"unscoped","title":"…","body":"…"}}
 {"action":"UPDATE","evidence":["e1"],"target":"m1","patch":{"body":"…"}}
-{"action":"NO_CHANGE","evidence":["e1"],"target":"m1"}
 {"items":[{"action":"NO_MEMORY"}]}
 
 字段：
+title 标识事项，不放交期/发生日/进度，改存正文与结构字段；旧标题交期一并清理。名称固有年度等身份日期保留。
 type=fact|todo|preference|project|event|identity|other。有独立完成条件的持续行动设 actionable:true（todo 隐含）；事实类别与行动属性可分开表达。
 status=active|completed|cancelled；完成/取消/交接同时纠正冲突的 title/body；独立未完行动不能被兄弟项完成吞掉。重新开启 UPDATE 使用 reopen:true 和 patch.status=active，需要较新明确依据。
 assignee 是实际执行人，只有明确由用户本人执行才 user，其他执行人用明确名称，未知为 null。用户记录/转发/协调不证明本人执行。等待依赖、卡点仅在正文维护，按最新事实替换过时内容，不生成等待字段。

{memleaf-0.2.87 → memleaf-0.2.89}/src/memleaf/incremental_protocol.py

@@ -24,7 +24,7 @@ from .turn_plan import revision_digest
 from .validation import ModelOutputError, parse_strict_json
 
 PROTOCOL_VERSION = "incremental-items-v1"
-SEMANTIC_PROTOCOL = "incremental-turn-v16"
+SEMANTIC_PROTOCOL = "incremental-turn-v17"
 EXTRACTION_CONTRACT = "field-reviewed-v1"
 MAX_BYTES = 128 * 1024
 MAX_ITEMS = 64
@@ -341,7 +341,7 @@ class PlanningSnapshot:
                 for status in basis_statuses.values())):
             raise ValueError("invalid_basis_status")
         targets = targets or {}
-        if len(targets) > 20 or (writable and set(writable) - set(targets)):
+        if writable and set(writable) - set(targets):
             raise ValueError("invalid_targets")
         for ref, memory in targets.items():
             if not re.fullmatch(r"m[1-9][0-9]*", ref) or not isinstance(memory, Memory):

{memleaf-0.2.87 → memleaf-0.2.89}/src/memleaf/incremental_semantics.py

@@ -15,10 +15,11 @@ REVIEW_SYSTEM = """核验拟写入的持续行动。original_input 是唯一事
 每个 draft.items 都必须有且只有一个 decision，item 是从 0 开始的位置。keep 判断该事项本身是否由原文确立且持续值得保留。临时操作及助手额外建议不能产生用户长期待办，原话只证明另一个操作时 keep:false。独立事实不因其他候选有误而拒绝。
 keep:true 时，field_support 必须逐个列出候选 memory/patch 中的业务字段，每个布尔值判断该字段的拟议值是否受来源支持；不列 responsibility_basis、effective、at、reopen 等引用/控制字段。没有 replace 的 NO_CHANGE/DEFERRED/NO_MEMORY 的 field_support 为 {}。keep:false 时 field_support 为 {}。unverified_fields 是系统发现未能验证引用的可选责任字段，必须判为 false；不能补造引用。这不影响其他有依据的事实或任务。归属/客户尚未确定不自动表示行动被阻塞。
 不能仅检查引文存在：必须判断原话是否确立该具体行动、责任、状态和期限。assistant 的建议/计划不能赋予 user 新义务。转发、协调、记录不等于本人执行；支持旧任务不等于接受新安排。
+body 必须逐个事实分句核验；assistant 自行增加的原因、影响判断、条件或后续步骤不受 user 原话支持，不能因整段主题相符就判 true。剔除无依据分句，保留其余已确认事实，可用 replace 修正 CREATE 的 title/body；没有修正时 body:false。title 只标识事项，交期/发生日/进度放正文与结构字段；名称固有的年度等身份信息保留。UPDATE/NO_CHANGE 的旧标题仍含交期时，在现有 replace/updates 中一起维护。
 尤其检查拟改 deadline：依赖条件、交接执行人、进度、尚未完成都不证明原期限已取消；只有明确取消/替换这个期限才支持变更。没有明确期限变化时 deadline:false，原期限沿用。卡点和等待条件仅在正文中维护，并清除已经解决的旧卡点。
 新引用只能来自 new；context 和旧目标只供比较，不能重新推动旧变化。候选若仅重新陈述旧目标已覆盖的内容，不应作为新 UPDATE。同一事项补充/纠正维护原目标，独立事项允许 CREATE，不能凭标题相似合并。
 逐字段判断后输出 decisions；对共同事实变更，检查所有候选记忆中是否仍有旧职责或旧状态，不能认可只更新一条而遗留冲突。确认 MERGE 各方确为同一事项且完整保留有效内容；独立生命周期的项目/任务不可合并。
-修正遗漏时，decision 可增加 replace（同 target 的完整 UPDATE），field_support 判断替换后的字段；不得替换 DEFERRED，也不得新增义务或猜测未知。还可输出 updates:[{"row":UPDATE,"field_support":{...}}] 更新原 draft 未涉及的可写候选目标，证据仍只取原输入 new。没有修正就省略 replace/updates。每条修正必须保留仍有效的旧事实与原期限；撤回用 validity=retracted。不要输出解释。
+修正遗漏时，decision 可增加 replace（同 target 的完整 UPDATE，或原 CREATE 仅改 title/body 的完整副本），field_support 判断替换后的字段；CREATE 修正不得改变其 evidence、scope、type、责任、期限或引用。不得替换 DEFERRED，也不得新增义务或猜测未知。还可输出 updates:[{"row":UPDATE,"field_support":{...}}] 更新原 draft 未涉及的可写候选目标，证据仍只取原输入 new。没有修正就省略 replace/updates。每条修正必须保留仍有效的旧事实与原期限；撤回用 validity=retracted。不要输出解释。
 """
 
 _METADATA = {"responsibility_basis", "effective", "at", "reopen"}
@@ -165,11 +166,30 @@ def apply_review(request, response):
                 raise ValueError
             row = rows[i]
             if "replace" in decision:
-                if (i in data.get("invalid_representation_items", []) or not decision["keep"]
-                        or row.get("action") not in {"UPDATE", "NO_CHANGE"}):
+                if i in data.get("invalid_representation_items", []) or not decision["keep"]:
                     raise ValueError
-                replacement = _maintenance_update(decision["replace"], support, data["original_input"])
-                if replacement["target"] != row["target"]:
+                if row.get("action") == "CREATE":
+                    replacement = deepcopy(decision["replace"])
+                    if (not isinstance(replacement, dict) or replacement.get("action") != "CREATE"
+                            or not isinstance(replacement.get("memory"), dict)
+                            or not isinstance(row.get("memory"), dict)
+                            or set(support) != fields(replacement)
+                            or any(v is not True for v in support.values())):
+                        raise ValueError
+                    # Review can repair prose, not rewrite the draft's source,
+                    # authority, identity, lifecycle or field annotations.
+                    def without_prose(value):
+                        value = deepcopy(value)
+                        for key in ("title", "body"):
+                            value["memory"].pop(key, None)
+                        return value
+                    if without_prose(row) != without_prose(replacement):
+                        raise ValueError
+                elif row.get("action") in {"UPDATE", "NO_CHANGE"}:
+                    replacement = _maintenance_update(decision["replace"], support, data["original_input"])
+                    if replacement["target"] != row["target"]:
+                        raise ValueError
+                else:
                     raise ValueError
                 row = rows[i] = replacement
                 data.get("unverified_fields", [[] for _ in rows])[i] = []
@@ -224,7 +244,8 @@ def apply_review(request, response):
                 rows[i] = None
         rows = [r for r in rows if r is not None]
         additions = review.get("updates", [])
-        if not isinstance(additions, list) or len(additions) > 20:
+        from .incremental_protocol import MAX_ITEMS
+        if not isinstance(additions, list) or len(rows) + len(additions) > MAX_ITEMS:
             raise ValueError
         used = {row.get("target") for row in rows if isinstance(row, dict)}
         for entry in additions: