memleaf 0.2.88__tar.gz → 0.2.89__tar.gz

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

@@ -4,6 +4,31 @@ 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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 0.2.88
+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.88。**
+> **版本：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.88 → 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.88.**
+> **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.88 → 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.88。**
+> **版本：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.88 → 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.88 → memleaf-0.2.89}/pyproject.toml

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

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

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

@@ -1371,7 +1371,8 @@ class MemleafMemoryProvider(MemoryProvider):
         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 "
+            "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"
@@ -1390,8 +1391,8 @@ class MemleafMemoryProvider(MemoryProvider):
             "todos, all unfinished work, urgent work, or work due in a time range, call memleaf MCP "
             "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. "
+            "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 "
@@ -2067,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
@@ -2105,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": "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}}]
+        # 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.88 → memleaf-0.2.89}/src/memleaf/hermes_provider/plugin.yaml

@@ -1,5 +1,5 @@
 name: memleaf
-version: 0.2.88
+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.88 → 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")

{memleaf-0.2.88 → 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.88 → 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.88 → 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.88 → 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:

{memleaf-0.2.88 → memleaf-0.2.89}/src/memleaf/mcp_server.py

@@ -34,6 +34,7 @@ from .retrieval_gate import (
     RetrievalGateError,
     begin_turn,
     guarded_read,
+    body_continuation,
     observe_search,
     observe_todo_list,
     todo_filter_key,
@@ -80,7 +81,7 @@ INSTRUCTIONS = (
     "and a current FOUND search or list_todos result; NO_MATCH, ERROR, and DEGRADED turns cannot read. "
     "For global current-action questions use list_todos rather than relevance search, omit scope to cover "
     "all scopes. Use view=full on server-managed turns, follow returned continuation arguments "
-    "until has_more=false, and read only truncated bodies using body_next_offset/version. "
+    "until has_more=false, then follow body_continuation with read until it is absent. "
     "Directory clients pass next_cursor as cursor, then read each relevant action body. "
     "For 'my work' use list_todos responsibility=mine; use delegated or all for others' work. "
     "Unassigned ownership is uncertain. A dependency alone does not create a user follow-up task; "
@@ -103,7 +104,7 @@ INSTRUCTIONS = (
     "Use remember only when the user explicitly asks to remember something. If the user has "
     "previously or currently explicitly said not to record corresponding text, skip capture for it. "
     "For conversation-based memory corrections, task completion/cancellation/reopening or "
-    "withdrawal of a fact/preference, use the host's memleaf_remember with its current retrieval_id. "
+    "withdrawal of a fact/preference in Hermes, use MCP save_turn with its current retrieval_id. "
     "It binds the actual user request and preserves history. If unavailable, update_memory "
     "with retrieval_id queues the same source-bound edit. Bare explicit edits may omit the token. "
     "Withdraw facts/preferences with validity=retracted, not task status=cancelled. "
@@ -270,7 +271,7 @@ _TOOLS: tuple[dict[str, Any], ...] = (
             "page; memleaf returns one that must be reused for pagination and read. Server-managed clients continue with "
             "continue=true with only retrieval_id until has_more=false; the server carries the exact cursor and filters. "
             "Use view=full to receive bounded action bodies in the list; read only rows with body_has_more=true "
-            "using offset=body_next_offset and expected_version=version. Directory clients may copy next_cursor into cursor, then read the matching action bodies with the same "
+            "by following body_continuation with read(continue=true,retrieval_id); the server binds the exact memory, version and offset. Directory clients may copy next_cursor into cursor, then read the matching action bodies with the same "
             "retrieval_id. Displayed list numbers are turn-local; resolve a later numbered update "
             "against the previously shown title and memory_id, and clarify if that mapping is ambiguous. "
             "responsibility=mine selects only explicit assignee=user; delegated selects other named owners, "
@@ -305,6 +306,8 @@ _TOOLS: tuple[dict[str, Any], ...] = (
             "characters and contains only identifiers, scopes, body, and paging/version fields; "
             "retrieval_id is required, and the retrieval turn must have a current FOUND search; "
             "NO_MATCH, ERROR, and DEGRADED turns are rejected. "
+            "Prefer returned body_continuation: pass only continue=true and retrieval_id to read the next unfinished body, with its ID/version/offset held by the server. "
+            "On memory_version_changed, add restart=true to that continuation to restart the same bound memory at offset 0 with its new version. "
             "continue with next_offset only when has_more is true, passing the returned version "
             "as expected_version. If the version changes, restart at offset=0 without it."
         ),
@@ -315,11 +318,18 @@ _TOOLS: tuple[dict[str, Any], ...] = (
                 "offset": {"type": "integer", "minimum": 0},
                 "max_chars": {"type": "integer", "minimum": 1},
                 "expected_version": {"type": "string"},
+                "continue": {"type": "boolean", "description": "Use only continue=true and retrieval_id to follow a returned body_continuation."},
+                "restart": {"type": "boolean", "description": "With continue=true only, restart the bound unfinished body at offset 0 after memory_version_changed."},
                 "retrieval_id": {"type": "string"},
             },
-            required=["memory_id"],
+            any_of=[{"required": ["memory_id"]}, {"required": ["continue"]}],
         ),
     },
+    {
+        "name": "save_turn",
+        "description": "Hermes only: queue the actual user turn to save/correct memory, complete/cancel/reopen an action or withdraw a preference. Call once with the current retrieval_id. No rewritten text or target IDs. Return user_message as the acknowledgement; queued is not completed. This is a deferred MCP tool, invoked with the exact name returned by tool_search.",
+        "inputSchema": _object_schema({"retrieval_id": {"type": "string"}}, required=["retrieval_id"]),
+    },
     {
         "name": "process",
         "description": "Process complete inbox turns using the configured Core model route.",
@@ -1152,10 +1162,36 @@ def _invoke_tool(
             if args.get("view") == "full":
                 for row in value["results"]:
                     guarded_read(service.vault, retrieval_id, row["memory_id"],
-                        lambda allowed, row=row: {"body": row["body"]}, current_source=managed_state["source"])
+                        lambda allowed, row=row: {"body": row["body"], "has_more": row["body_has_more"],
+                            "next_offset": row["body_next_offset"], "version": row["version"], "history": row["history"]},
+                        current_source=managed_state["source"])
+                if body_continuation(service.vault, retrieval_id, current_source=managed_state["source"]):
+                    value["body_continuation"] = {"continue": True, "retrieval_id": retrieval_id}
             if value.get("has_more") and managed_state is not None:
                 value["continuation"] = {"continue": True, "retrieval_id": retrieval_id}
         elif name == "read":
+            continuation = args.pop("continue", False)
+            restart = args.pop("restart", False)
+            retrieval_id = args.pop("retrieval_id")
+            state = validate_turn(service.vault, retrieval_id)
+            current_source = state.get("source")
+            if not isinstance(current_source, str) or not current_source:
+                raise RetrievalGateError("retrieval_identity_invalid")
+            expected = None
+            if continuation:
+                if args:
+                    raise RetrievalGateError("retrieval_body_continuation_mismatch")
+                expected = body_continuation(service.vault, retrieval_id, current_source=current_source)
+                if expected is None:
+                    raise RetrievalGateError("retrieval_body_continuation_mismatch")
+                args = dict(expected)
+                if restart:
+                    args["offset"] = 0
+                    args.pop("expected_version")
+            elif restart:
+                raise RetrievalGateError("retrieval_body_continuation_mismatch")
+            elif "memory_id" not in args:
+                raise ValueError("memory_id_required")
             # Keep the protocol boundary hard-capped even if a caller sends a
             # larger value.  Core read_page performs the same authoritative
             # validation; this prevents a future adapter regression from
@@ -1165,23 +1201,29 @@ def _invoke_tool(
                 args["max_chars"] = min(requested_max_chars, _MAX_READ_PAGE_CHARS)
             else:
                 args["max_chars"] = _MAX_READ_PAGE_CHARS
-            retrieval_id = args.pop("retrieval_id")
 
             def read_page(allowed_chars: int) -> dict[str, Any] | None:
                 page_args = {**args, "max_chars": min(args["max_chars"], allowed_chars)}
-                return _read_page_result(service.read_page(**page_args))
+                page = _read_page_result(service.read_page(**page_args))
+                if page is not None:
+                    page["history"] = page_args.get("include_history") is True
+                return page
 
-            state = validate_turn(service.vault, retrieval_id)
-            current_source = state.get("source")
-            if not isinstance(current_source, str) or not current_source:
-                raise RetrievalGateError("retrieval_identity_invalid")
             value = guarded_read(
                 service.vault,
                 retrieval_id,
                 args["memory_id"],
                 read_page,
                 current_source=current_source,
+                expected_continuation=expected,
             )
+            if value is not None:
+                value.pop("history", None)
+            if value is not None and body_continuation(service.vault, retrieval_id, current_source=current_source):
+                value["body_continuation"] = {"continue": True, "retrieval_id": retrieval_id}
+        elif name == "save_turn":
+            from .host_retention import remember_turn
+            value = remember_turn(service, phase="queue", retrieval_id=args["retrieval_id"])
         elif name == "process":
             background = args.pop("background", False)
             if background is True: