memleaf 0.2.87__tar.gz → 0.2.88__tar.gz

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 0.2.87
+Version: 0.2.88
 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.88。**
 > 自动提炼和复核共用同一条“未来记忆价值”标准：模型综合未来复用、信息增量、再次读取时的直接可用性和忘记成本，只保留对未来理解、判断或行动有实质影响的最小核心；没有明确价值的信息不提炼，不按具体业务场景硬编码排除。
 > 提炼先比较旧事项中的编号、目标、进展、责任和期限；补全未知信息也应维护原事项，另建独立待办不能替代项目事实更新。确认重复的记忆在现有处理请求中合并，保留历史与来源；项目和独立任务保持各自生命周期，Core 不按标题强行合并。
 > 新请求兼容等价的字段表示；未知执行人保持 `null`，新增或变更负责人和期限需要真实来源；等待条件在正文维护，不再提炼 `waiting_on`。行动及相关字段经过有界语义复核，提炼与复核共用每份工作的最多五次模型请求额度，成功即停止；复核失败不写入。来源时间用于解析相对日期，不补造事实日期。

{memleaf-0.2.87 → memleaf-0.2.88}/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.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. 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.

{memleaf-0.2.87 → memleaf-0.2.88}/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.88。**
 > 自动提炼和复核共用同一条“未来记忆价值”标准：模型综合未来复用、信息增量、再次读取时的直接可用性和忘记成本，只保留对未来理解、判断或行动有实质影响的最小核心；没有明确价值的信息不提炼，不按具体业务场景硬编码排除。
 > 提炼先比较旧事项中的编号、目标、进展、责任和期限；补全未知信息也应维护原事项，另建独立待办不能替代项目事实更新。确认重复的记忆在现有处理请求中合并，保留历史与来源；项目和独立任务保持各自生命周期，Core 不按标题强行合并。
 > 新请求兼容等价的字段表示；未知执行人保持 `null`，新增或变更负责人和期限需要真实来源；等待条件在正文维护，不再提炼 `waiting_on`。行动及相关字段经过有界语义复核，提炼与复核共用每份工作的最多五次模型请求额度，成功即停止；复核失败不写入。来源时间用于解析相对日期，不补造事实日期。

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

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

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

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

@@ -1,5 +1,5 @@
 name: memleaf
-version: 0.2.87
+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.87 → 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
@@ -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.88}/src/memleaf/incremental_commit.py

@@ -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.88}/src/memleaf/mcp_server.py

@@ -37,6 +37,7 @@ from .retrieval_gate import (
     observe_search,
     observe_todo_list,
     todo_filter_key,
+    todo_continuation,
     validate_current_turn,
     validate_turn,
 )
@@ -78,7 +79,9 @@ INSTRUCTIONS = (
     "at the execution boundary (supplied by a bound host or explicitly by a bare client), "
     "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, follow next_cursor until has_more=false, then read each relevant action body. "
+    "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. "
+    "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; "
     "an active item is not automatically the user's personal work. "
@@ -264,8 +267,10 @@ _TOOLS: tuple[dict[str, Any], ...] = (
         "description": (
             "Enumerate explicitly tracked actions (including non-todo memories with status) by status/date across all scopes. "
             "This is not relevance search. A bare MCP client may omit retrieval_id only on the first "
-            "page; memleaf returns one that must be reused for pagination and read. Continue with "
-            "next_cursor until has_more=false, then read the matching action bodies with the same "
+            "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 "
             "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, "
@@ -286,6 +291,8 @@ _TOOLS: tuple[dict[str, Any], ...] = (
                 "include_overdue": {"type": "boolean"},
                 "include_unscheduled": {"type": "boolean"},
                 "cursor": {"type": "string"},
+                "continue": {"type": "boolean", "description": "Fetch the next page of this turn's last list_todos query; pass only retrieval_id with continue=true."},
+                "view": {"type": "string", "enum": ["directory", "full"], "description": "Full bundles bounded bodies for server-managed Hermes/bare MCP turns. Host-observed turns retain directory pagination and read accounting."},
                 "limit": {"type": "integer", "minimum": 1},
                 "retrieval_id": {"type": "string"},
             },
@@ -791,6 +798,9 @@ def _tool_result(value: Any, *, is_error: bool = False) -> dict[str, Any]:
     if not isinstance(structured, dict):
         structured = {"result": structured}
     status = structured.get("execution_status")
+    if status == "queued":
+        structured["outcome"] = {"complete": False,
+            "guidance": "The request is queued; acknowledge user_message. No saved or completed change is confirmed by this result."}
     if status in {"completed", "completed_with_unresolved", "partial", "blocked", "failed", "retryable", "recovery_required", "cancelled"}:
         commit = structured.get("commit") or {}
         unresolved = status != "completed" or commit.get("coverage_status") == "partial"
@@ -1017,6 +1027,7 @@ def _observe_mcp_todos(
             if state.get("source") in {"hermes", "mcp"}
             else "hermes"
         ),
+        query_arguments={k: v for k, v in arguments.items() if k != "cursor"},
     )
 
 
@@ -1104,12 +1115,22 @@ def _invoke_tool(
             value = dict(value)
             value["retrieval_id"] = retrieval_id
         elif name == "list_todos":
+            continuation = args.pop("continue", False)
             retrieval_id = args.pop("retrieval_id", None)
             if retrieval_id is None:
-                if args.get("cursor") is not None:
+                if continuation or args.get("cursor") is not None:
                     raise RetrievalGateError("retrieval_id_required")
                 retrieval_id = _open_mcp_retrieval_turn(service, request_id)
             managed_state = _managed_search_state(service, retrieval_id)
+            if continuation:
+                if args or managed_state is None:
+                    raise RetrievalGateError("retrieval_todo_pagination_mismatch")
+                args = todo_continuation(service.vault, retrieval_id, current_source=managed_state["source"])
+            # Host-owned observers retain their existing search/read contract.
+            # Full bodies are bundled only where the server owns accounting.
+            directory_fallback = managed_state is None and args.get("view") == "full"
+            if directory_fallback:
+                args["view"] = "directory"
             observed_args = dict(args)
             try:
                 value = service.list_todos(**args)
@@ -1125,6 +1146,15 @@ def _invoke_tool(
                 return _tool_error(error)
             value = dict(value)
             value["retrieval_id"] = retrieval_id
+            if directory_fallback:
+                value["view"] = "directory"
+                value["answer_guidance"] = "This host observes directory results. Pass next_cursor as cursor until has_more=false, then read matching bodies with the same retrieval_id."
+            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"])
+            if value.get("has_more") and managed_state is not None:
+                value["continuation"] = {"continue": True, "retrieval_id": retrieval_id}
         elif name == "read":
             # Keep the protocol boundary hard-capped even if a caller sends a
             # larger value.  Core read_page performs the same authoritative

{memleaf-0.2.87 → memleaf-0.2.88}/src/memleaf/processing_route.py

@@ -68,6 +68,22 @@ def _snapshot(service, source, session_id):
     runs = {k: load_run(processed, k) for k in processed.get(RUN_KEY, {})}
     works = {k: load_work(processed, k) for k in processed.get(COMMIT_KEY, {})}
     grouped = journal._turns_by_session()
+    # A process can stop after its committed receipt but before the old host
+    # completion returned. Clear only a verified full-source intent, without
+    # selecting the completed turn for another model request.
+    from .host_retention import settle_completed_intent_unlocked
+    retention_works = {}
+    for work in works.values():
+        if work.get("host_retention_origin") is not None:
+            retention_works.setdefault((work["source"], work["session_id"], work["turn_key"]), []).append(work)
+    settled = False
+    for turns in grouped.values():
+        for turn in turns:
+            if turn.complete and turn.processable and _matches(source, session_id, vars(turn)):
+                for work in retention_works.get((turn.source, turn.session_id, turn.turn_key), ()):
+                    settled = settle_completed_intent_unlocked(processed, work, turn) or settled
+    if settled:
+        journal._write_processed_unlocked(processed)
     actions, skipped = [], []
     available_identities = set()
     for _, available in sorted(grouped.items()):

{memleaf-0.2.87 → memleaf-0.2.88}/src/memleaf/retrieval_gate.py

@@ -495,6 +495,7 @@ def observe_todo_list(
     has_more: bool,
     next_cursor: str | None,
     current_source: str | None = None,
+    query_arguments: Mapping[str, Any] | None = None,
 ) -> None:
     """Record one real list_todos page and enforce a single current-turn cursor chain."""
 
@@ -539,6 +540,9 @@ def observe_todo_list(
             entry["todo_list_pages"] = int(entry.get("todo_list_pages", 0) or 0) + 1
             entry["todo_list_pending"] = bool(has_more)
             entry["todo_list_expected_cursor_hash"] = next_hash if has_more else ""
+            if query_arguments is not None:
+                entry["todo_list_next_cursor"] = next_cursor if has_more else None
+                entry["todo_list_query_arguments"] = dict(query_arguments) if has_more else None
         entry["status"] = {"found": "FOUND", "no_match": "NO_MATCH", "error": "ERROR"}[status]
         seen = [item for item in seen if isinstance(item, str)][-255:]
         seen.append(call_hash)
@@ -549,6 +553,26 @@ def observe_todo_list(
         _write_ledger(path, ledger)
 
 
+def todo_continuation(vault, retrieval_id, *, current_source):
+    """Return only this live turn's last server-issued page, never a model's cursor rewrite."""
+    retrieval_id = _retrieval_id(retrieval_id)
+    root = _coerce_vault(vault)
+    with _with_lock(root):
+        ledger = _read_ledger(_ledger_path(root))
+        entry = _entry_for(ledger, retrieval_id)
+        if not _is_current_entry(ledger["entries"], retrieval_id, entry, current_source):
+            raise RetrievalGateError("retrieval_turn_mismatch")
+        cursor = entry.get("todo_list_next_cursor")
+        arguments = entry.get("todo_list_query_arguments")
+        if (entry.get("todo_list_pending") is not True or not isinstance(cursor, str)
+                or not isinstance(arguments, dict)
+                or _optional_hash(cursor) != entry.get("todo_list_expected_cursor_hash")
+                or hashlib.sha256(todo_filter_key(arguments).encode()).hexdigest()
+                   != entry.get("todo_list_filter_hash")):
+            raise RetrievalGateError("retrieval_todo_pagination_mismatch")
+        return {**arguments, "cursor": cursor}
+
+
 def request_gate_retry(vault: Vault | Path | str, retrieval_id: str) -> int:
     """Record one Stop continuation request and return its 1-based count."""
 
@@ -719,6 +743,7 @@ __all__ = [
     "observe_search",
     "observe_todo_list",
     "todo_filter_key",
+    "todo_continuation",
     "request_gate_retry",
     "validate_current_turn",
     "validate_turn",

{memleaf-0.2.87 → memleaf-0.2.88}/src/memleaf/service.py

@@ -1368,7 +1368,18 @@ class Memleaf:
             }
             if payload_chars(proposed) > MAX_SEARCH_CANDIDATE_CHARS:
                 if not selected:
-                    raise RetrievalError("search_result_too_large", "todo result exceeds the response budget")
+                    # Full views keep the same response cap. A long body is
+                    # explicitly paged instead of hiding or skipping the row.
+                    row = dict(candidates[index])
+                    while isinstance(row.get("body"), str) and len(row["body"]) > 1:
+                        row["body"] = row["body"][:len(row["body"]) // 2]
+                        row.update(body_has_more=True, body_next_offset=len(row["body"]))
+                        if payload_chars({**proposed, "results": [row]}) <= MAX_SEARCH_CANDIDATE_CHARS:
+                            candidates[index] = row
+                            break
+                    else:
+                        raise RetrievalError("search_result_too_large", "todo result exceeds the response budget")
+                    continue
                 break
             selected.append(candidates[index])
             index = next_index
@@ -1395,6 +1406,7 @@ class Memleaf:
         limit: int | None = None,
         as_of: str | None = None,
         timezone: str | None = None,
+        view: str = "directory",
     ) -> dict[str, Any]:
         """Enumerate explicitly tracked actions, including legacy todo memories."""
 
@@ -1402,6 +1414,8 @@ class Memleaf:
             raise ValueError("invalid todo status")
         if responsibility not in {"all", "mine", "delegated", "unassigned"}:
             raise ValueError("invalid todo responsibility")
+        if view not in {"directory", "full"}:
+            raise ValueError("invalid todo view")
         if type(include_overdue) is not bool or type(include_unscheduled) is not bool:
             raise ValueError("todo inclusion flags must be booleans")
         lower = self._todo_date(due_from, "due_from")
@@ -1484,6 +1498,10 @@ class Memleaf:
                     "assignee": record.memory.extra.get("assignee"),
                     "responsibility": _todo_responsibility(record.memory),
                     "history": record.area == "history",
+                    **({"body": record.memory.body[:512],
+                        "body_has_more": len(record.memory.body) > 512,
+                        "body_next_offset": 512 if len(record.memory.body) > 512 else None,
+                        "version": _memory_version(record.memory)} if view == "full" else {}),
                     **(
                         {"active_memory_id": record.memory.extra.get("active_memory_id")}
                         if record.area == "history" and isinstance(record.memory.extra.get("active_memory_id"), str)
@@ -1504,6 +1522,7 @@ class Memleaf:
                         "include_unscheduled": include_unscheduled,
                         "clock": clock,
                         "generation": snapshot.generation,
+                        **({"view": view} if view == "full" else {}),
                     },
                     "records": [
                         {

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 0.2.87
+Version: 0.2.88
 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.88。**
 > 自动提炼和复核共用同一条“未来记忆价值”标准：模型综合未来复用、信息增量、再次读取时的直接可用性和忘记成本，只保留对未来理解、判断或行动有实质影响的最小核心；没有明确价值的信息不提炼，不按具体业务场景硬编码排除。
 > 提炼先比较旧事项中的编号、目标、进展、责任和期限；补全未知信息也应维护原事项，另建独立待办不能替代项目事实更新。确认重复的记忆在现有处理请求中合并，保留历史与来源；项目和独立任务保持各自生命周期，Core 不按标题强行合并。
 > 新请求兼容等价的字段表示；未知执行人保持 `null`，新增或变更负责人和期限需要真实来源；等待条件在正文维护，不再提炼 `waiting_on`。行动及相关字段经过有界语义复核，提炼与复核共用每份工作的最多五次模型请求额度，成功即停止；复核失败不写入。来源时间用于解析相对日期，不补造事实日期。