memleaf 0.2.15__tar.gz → 0.2.17__tar.gz

{memleaf-0.2.15 → memleaf-0.2.17}/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 All notable changes to memleaf are documented here.
 
+## 0.2.17 — 2026-09-02
+
+- Preserve explicit user-confirmed completion or cancellation of one uniquely
+  related active todo as an in-place state update, even when the gate omits the
+  candidate or the same message asks what remains.
+- Keep todo-state recovery deterministic and bounded: reuse the existing
+  memory ID, anchor `completed_at` to the user event, archive the old version,
+  and reject queries, negation, future intent, uncertainty, assistant-only
+  claims, and ambiguous targets.
+
+## 0.2.16 — 2026-09-02
+
+- Keep read-only operational queries, derived overdue counters, and one-time
+  execution receipts out of permanent-memory extraction; preserve explicitly
+  confirmed durable facts and preferences.
+- Deduplicate Hermes tool observations across cumulative conversation payloads,
+  preventing historical reads from being re-audited as uncontrolled while
+  retaining diagnostics for genuinely mismatched current-turn reads.
+
 ## 0.2.15 — 2026-09-02
 
 - Recover a candidate whose `update_memory_id` has the wrong type at the

{memleaf-0.2.15/src/memleaf.egg-info → memleaf-0.2.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 0.2.15
+Version: 0.2.17
 Summary: A local-first Markdown memory core for AI agents
 Author: memleaf contributors
 License-Expression: MIT
@@ -23,8 +23,8 @@ Dynamic: license-file
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **当前版本：0.2.15。**
-> 核心库、Vault、stdio MCP Server、初始化 CLI、模型路由、提炼流程、受控检索协议和宿主适配器已经实现。memleaf 0.2.15 通过 PyPI 分发。
+> **当前版本：0.2.17。**
+> 核心库、Vault、stdio MCP Server、初始化 CLI、模型路由、提炼流程、受控检索协议和宿主适配器已经实现。memleaf 0.2.17 通过 PyPI 分发。
 > **当前版本支持 Hermes 和 Codex。** Antigravity（反重力）不检测、不安装、不配置。
 
 ## 项目定位

{memleaf-0.2.15 → memleaf-0.2.17}/README.en.md

@@ -4,8 +4,8 @@
 
 [中文](README.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **Version: 0.2.15.**
-> The core library, Vault, stdio MCP server, initialization CLI, model routing, memory extraction, controlled retrieval protocol, and host adapters are implemented. memleaf 0.2.15 is distributed through PyPI.
+> **Version: 0.2.17.**
+> The core library, Vault, stdio MCP server, initialization CLI, model routing, memory extraction, controlled retrieval protocol, and host adapters are implemented. memleaf 0.2.17 is distributed through PyPI.
 > **The current release supports Hermes and Codex.** Antigravity is not detected, installed, or configured.
 
 ## Project scope

{memleaf-0.2.15 → memleaf-0.2.17}/README.md

@@ -4,8 +4,8 @@
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **当前版本：0.2.15。**
-> 核心库、Vault、stdio MCP Server、初始化 CLI、模型路由、提炼流程、受控检索协议和宿主适配器已经实现。memleaf 0.2.15 通过 PyPI 分发。
+> **当前版本：0.2.17。**
+> 核心库、Vault、stdio MCP Server、初始化 CLI、模型路由、提炼流程、受控检索协议和宿主适配器已经实现。memleaf 0.2.17 通过 PyPI 分发。
 > **当前版本支持 Hermes 和 Codex。** Antigravity（反重力）不检测、不安装、不配置。
 
 ## 项目定位

{memleaf-0.2.15 → memleaf-0.2.17}/pyproject.toml

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

{memleaf-0.2.15 → memleaf-0.2.17}/src/memleaf/__init__.py

@@ -1,6 +1,6 @@
 """Local-first Markdown memory core for AI agents."""
 
-__version__ = "0.2.15"
+__version__ = "0.2.17"
 
 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.15 → memleaf-0.2.17}/src/memleaf/hermes_provider/__init__.py

@@ -49,6 +49,7 @@ _MAX_PENDING_TURN_NUMBERS = 128
 _MAX_SESSION_ALIASES = 128
 _MAX_LINEAGE_RETRIES = 2
 _MAX_DEFERRED_PROCESS_SESSIONS = 128
+_MAX_OBSERVED_TOOL_CALL_KEYS = 2048
 _SAFE_COMPONENT_RE = re.compile(r"[^A-Za-z0-9_.-]+")
 _PROVIDER_VERSION_RE = re.compile(r"^version:\s*([^\s#]+)\s*(?:#.*)?$", re.MULTILINE)
 _ASCII_QUERY_TERM_RE = re.compile(r"[a-z0-9]+(?:[ ._-][a-z0-9]+)*")
@@ -628,6 +629,45 @@ def _tool_result_for_call(
     return _CALL_FAILED
 
 
+def _tool_observation_key(call: Mapping[str, Any], ordinal: int) -> str:
+    """Build a stable in-memory identity for one visible tool call.
+
+    Hermes can pass the complete conversation back on every turn.  The
+    retrieval token and result status are turn-relative, so they must not be
+    part of the identity: otherwise an old successful read is reclassified as
+    ``uncontrolled_success`` when a newer token is observed.  Call ids are
+    stable when Hermes supplies them; the ordinal/arguments fallback keeps
+    anonymous calls distinct within the cumulative message list.
+    """
+
+    arguments = call.get("arguments")
+    try:
+        arguments_text = json.dumps(arguments, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+    except (TypeError, ValueError):
+        arguments_text = ""
+    call_id = call.get("call_id") if isinstance(call.get("call_id"), str) else ""
+    name = call.get("name") if isinstance(call.get("name"), str) else ""
+    if call_id:
+        identity = f"{name}\x00call-id\x00{call_id}"
+    else:
+        identity = f"{name}\x00anonymous\x00{ordinal}\x00{arguments_text}"
+    return sha256(identity.encode("utf-8")).hexdigest()
+
+
+def _record_tool_observation(seen: Any, key: str) -> bool:
+    """Record one observation key and report whether it was new."""
+
+    if seen is None:
+        return True
+    if key in seen:
+        return False
+    if isinstance(seen, set):
+        seen.add(key)
+    else:
+        seen[key] = None
+    return True
+
+
 def _hermes_read_status(value: Any) -> str:
     """Classify a visible read result without inspecting it in diagnostics."""
 
@@ -1125,6 +1165,7 @@ class MemleafMemoryProvider(MemoryProvider):
         self._gate_turn_ids: "OrderedDict[Tuple[str, int], str]" = OrderedDict()
         self._active_turn_numbers: "OrderedDict[str, int]" = OrderedDict()
         self._active_retrieval_ids: "OrderedDict[str, Optional[str]]" = OrderedDict()
+        self._observed_tool_call_keys: "OrderedDict[str, None]" = OrderedDict()
         self._version_warning_emitted = False
         # Hermes keeps one provider instance alive while compression rotates
         # the physical session id.  Keep only a bounded alias chain so a
@@ -1752,6 +1793,7 @@ class MemleafMemoryProvider(MemoryProvider):
             if not continuous:
                 self._pending_lineage.clear()
                 self._deferred_process_sessions.clear()
+                self._observed_tool_call_keys.clear()
             if _as_bool(reset, False) or _as_bool(rewound, False):
                 self._clear_session_turn_state(old_session_id or next_session_id)
                 for key in list(self._retrieval_ids_by_turn):
@@ -1826,6 +1868,7 @@ class MemleafMemoryProvider(MemoryProvider):
         self._gate_turn_ids.clear()
         self._active_turn_numbers.clear()
         self._active_retrieval_ids.clear()
+        self._observed_tool_call_keys.clear()
         self._session_aliases.clear()
         self._pending_lineage.clear()
         self._deferred_process_sessions.clear()
@@ -2073,6 +2116,7 @@ class MemleafMemoryProvider(MemoryProvider):
         session_id: str = "",
         turn_id: str = "",
         vault_root: Optional[Path] = None,
+        seen_call_keys: Any = None,
     ) -> str:
         """Observe explicit host MCP calls in public messages.
 
@@ -2087,25 +2131,32 @@ class MemleafMemoryProvider(MemoryProvider):
         results = _visible_tool_results(messages)
         statuses: list[str] = []
         search_results_used: set[int] = set()
+        search_ordinal = 0
         for call in calls:
             if call.get("name") != "mcp__memleaf__search":
                 continue
+            search_ordinal += 1
             arguments = call.get("arguments")
             if not isinstance(arguments, Mapping) or arguments.get("retrieval_id") != retrieval_id:
                 continue
             payload = _tool_result_for_call(call, calls, results, search_results_used)
             if payload is not _CALL_FAILED:
+                status = _hermes_search_status(payload)
+                observation_key = _tool_observation_key(call, search_ordinal)
+                if not _record_tool_observation(seen_call_keys, observation_key):
+                    continue
                 # Hermes has no public write-back hook for this soft observer.
                 # A valid current-turn result is enough to mark the local
                 # provider diagnostic; no Core ledger or body is touched here.
-                statuses.append(_hermes_search_status(payload))
+                statuses.append(status)
 
         read_results_used: set[int] = set()
         read_sequence = 0
+        read_ordinal = 0
         for call in calls:
             if call.get("name") != "mcp__memleaf__read":
                 continue
-            read_sequence += 1
+            read_ordinal += 1
             arguments = call.get("arguments")
             retrieval_present = isinstance(arguments, Mapping) and "retrieval_id" in arguments
             retrieval_match = bool(
@@ -2120,6 +2171,10 @@ class MemleafMemoryProvider(MemoryProvider):
                 # mismatched gate binding.  Do not make that look like a
                 # controlled success in the diagnostic stream.
                 result_status = "uncontrolled_success"
+            observation_key = _tool_observation_key(call, read_ordinal)
+            if not _record_tool_observation(seen_call_keys, observation_key):
+                continue
+            read_sequence += 1
             logger.info(
                 "memleaf retrieval-read source=hermes session=%s turn=%s read_seq=%d retrieval_present=%s retrieval_match=%s result=%s",
                 _safe_component(session_id, "none") if session_id else "none",
@@ -2286,7 +2341,10 @@ class MemleafMemoryProvider(MemoryProvider):
                         session_id=effective_session,
                         turn_id=turn_id,
                         vault_root=_resolve_vault(self._config()),
+                        seen_call_keys=self._observed_tool_call_keys,
                     )
+                    while len(self._observed_tool_call_keys) > _MAX_OBSERVED_TOOL_CALL_KEYS:
+                        self._observed_tool_call_keys.popitem(last=False)
                     self._last_retrieval_observation = observation
                 lineage_ready = self._retry_pending_lineage(effective_session)
                 for role, content in visible_events:

{memleaf-0.2.15 → memleaf-0.2.17}/src/memleaf/hermes_provider/plugin.yaml

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

{memleaf-0.2.15 → memleaf-0.2.17}/src/memleaf/processing.py

@@ -87,6 +87,214 @@ _DIAGNOSTIC_GATE_ALLOWED = frozenset(("candidates",))
 _DIAGNOSTIC_CANDIDATE_REQUIRED = frozenset(
     ("candidate_id", "memory", "evidence_event_ids", "duplicate", "worth", "type", "scopes", "scope_source")
 )
+
+_READ_ONLY_QUERY_MARKERS = (
+    "有没有", "有哪些", "是什么", "是谁", "多少", "查询", "查一下", "查下",
+    "看看", "查看", "汇总", "列出", "告诉我", "what", "which", "who", "show me",
+)
+_USER_ASSERTION_MARKERS = (
+    "已确认", "确认了", "已决定", "我决定", "改为", "更新为", "变更为", "以后",
+    "今后", "约定", "我的偏好", "我喜欢", "必须", "要求是", "截止日期为",
+    "负责人是", "负责人为",
+)
+_DERIVED_OVERDUE_RE = re.compile(
+    r"(?:逾期|超期|overdue)\s*\d+(?:\.\d+)?\s*(?:天|日|days?)",
+    re.IGNORECASE,
+)
+_EXECUTION_RECEIPT_RE = re.compile(
+    r"(?:核验归档|归档核验|服务器已接受(?:提交|投递)|server accepted)",
+    re.IGNORECASE,
+)
+_TODO_COMPLETION_RE = re.compile(
+    r"(?:完成|做完|办完|搞定|处理完|closed|completed|finished|done)",
+    re.IGNORECASE,
+)
+_TODO_CANCEL_RE = re.compile(
+    r"(?:取消|作废|撤销|不做|不用做|不需要做|cancel(?:led|ed)?|abort(?:ed)?)",
+    re.IGNORECASE,
+)
+_TODO_NEGATION_MARKERS = (
+    "还没", "没有", "未", "尚未", "没", "not", "never", "will", "would", "准备", "打算", "计划", "将要", "会", "要",
+)
+_TODO_UNCERTAINTY_MARKERS = (
+    "应该", "可能", "大概", "似乎", "不确定", "也许", "好像", "probably", "perhaps", "maybe", "seems", "not sure",
+)
+_TODO_CONFIRMATION_RE = re.compile(
+    r"(?:对吗|对不对|是吗|正确吗|是不是|是否(?=(?:已|已经|完成|正确|这样|发|做|弄)))"
+)
+_TODO_QUERY_SUFFIXES = ("吗", "么", "？", "?", "呢")
+
+
+def _explicit_todo_state_change(
+    events: Iterable[Mapping[str, Any]],
+) -> tuple[str, list[str], str] | None:
+    """Detect one explicit user todo completion/cancellation declaration.
+
+    This intentionally reads user events only.  A completion marker is valid
+    only when it is declarative (not negated, future, or a question), so an
+    assistant recap or a trailing "what remains?" cannot manufacture a state
+    transition.
+    """
+
+    states: list[tuple[str, str, str]] = []
+    for event in events:
+        if str(event.get("role", "")).casefold() != "user":
+            continue
+        content = event.get("content")
+        event_key_value = event.get("event_key")
+        timestamp = event.get("timestamp")
+        if not isinstance(content, str) or not content.strip():
+            continue
+        if not isinstance(event_key_value, str) or not event_key_value:
+            continue
+        if not isinstance(timestamp, str) or _parse_time(timestamp) is None:
+            continue
+        folded = content.casefold()
+        event_states: set[str] = set()
+        for marker, state in (
+            (_TODO_COMPLETION_RE, "completed"),
+            (_TODO_CANCEL_RE, "cancelled"),
+        ):
+            for match in marker.finditer(folded):
+                start, end = match.span()
+                prefix = folded[max(0, start - 8) : start]
+                suffix = folded[end : end + 4]
+                if any(value in prefix for value in _TODO_NEGATION_MARKERS + _TODO_UNCERTAINTY_MARKERS):
+                    continue
+                if any(suffix.startswith(value) for value in _TODO_QUERY_SUFFIXES) or re.match(
+                    r"^(?:了|啦)?(?:吗|么|呢|[?？])", suffix
+                ):
+                    continue
+                # Confirmation questions may place the question marker after
+                # a comma ("已经完成了，对吗？").  Keep a follow-up about
+                # other work eligible; only direct confirmation wording is
+                # rejected here.
+                if _TODO_CONFIRMATION_RE.search(prefix) or _TODO_CONFIRMATION_RE.search(folded[end:]):
+                    continue
+                # A bare English "done"/"completed" is declarative.  For
+                # Chinese verbs require either a completion particle or an
+                # explicit completed-state prefix to avoid matching a future
+                # action such as "完成计划".
+                if state in {"completed", "cancelled"} and not (
+                    any(value in prefix for value in ("已", "已经", "刚刚", "刚才", "i ", "i've", "has ", "was "))
+                    or suffix.startswith(("了", "啦", ".", "!", "！", ",", "，", ";", "；"))
+                    or match.group(0).casefold() in {"completed", "finished", "done", "closed", "cancelled", "canceled", "aborted"}
+                ):
+                    continue
+                event_states.add(state)
+                break
+        states.extend((state, event_key_value, timestamp) for state in sorted(event_states))
+
+    if not states:
+        return None
+    distinct_states = {state for state, _event_key_value, _timestamp in states}
+    if len(distinct_states) != 1:
+        return None
+    state = states[0][0]
+    evidence_event_ids = list(dict.fromkeys(item[1] for item in states))
+    # Preserve the event timestamp's absolute instant as completed_at.  The
+    # parser accepts ISO-8601 strings; canonical UTC avoids offset ambiguity.
+    anchor = _parse_time(states[-1][2])
+    if anchor is None:
+        return None
+    completed_at = anchor.strftime("%Y-%m-%dT%H:%M:%SZ")
+    return state, evidence_event_ids, completed_at
+
+
+def _automatic_read_only_query(events: Iterable[Mapping[str, Any]]) -> bool:
+    """Return true when the user only asks for information in this turn."""
+
+    user_text = "\n".join(
+        str(event.get("content", ""))
+        for event in events
+        if str(event.get("role", "")).casefold() == "user"
+    ).strip()
+    if not user_text:
+        return False
+    folded = user_text.casefold()
+    query_prefix = re.sub(r"^(?:请|帮我|麻烦|请帮我)\s*", "", folded)
+    asks = "?" in user_text or "？" in user_text or any(
+        query_prefix.startswith(marker) or query_prefix.startswith(f"我{marker}")
+        for marker in _READ_ONLY_QUERY_MARKERS
+    )
+    if not asks:
+        return False
+    return not any(marker in folded for marker in _USER_ASSERTION_MARKERS)
+
+
+def _automatic_transient_memory(value: Any) -> bool:
+    """Reject volatile counters and one-off execution receipts at write time."""
+
+    if not isinstance(value, str):
+        return False
+    return bool(_DERIVED_OVERDUE_RE.search(value) or _EXECUTION_RECEIPT_RE.search(value))
+
+
+def _todo_state_recovery_candidate(
+    events: Iterable[Mapping[str, Any]],
+    related: Iterable[Mapping[str, Any]],
+) -> tuple[dict[str, Any], str, str, str] | None:
+    """Recover a missed todo transition from one explicit user declaration.
+
+    This is deliberately narrower than general admission: it only considers
+    active todo records already returned by the bounded related-memory query,
+    and proceeds only when exactly one record is lexically relevant to the
+    user's own completion/cancellation statement.
+    """
+
+    state_change = _explicit_todo_state_change(events)
+    if state_change is None:
+        return None
+    state, evidence_event_ids, completed_at = state_change
+    user_text = "\n".join(
+        str(event.get("content", ""))
+        for event in events
+        if str(event.get("role", "")).casefold() == "user"
+    ).strip()
+    matches: list[Memory] = []
+    seen_ids: set[str] = set()
+    for item in related:
+        if not isinstance(item, Mapping) or item.get("native") is True:
+            continue
+        if item.get("type") != "todo" or item.get("status") in {"completed", "cancelled"}:
+            continue
+        memory_id = item.get("memory_id")
+        if not isinstance(memory_id, str) or not memory_id or memory_id.casefold() in seen_ids:
+            continue
+        try:
+            memory = Memory.from_mapping(item)
+        except (TypeError, ValueError):
+            continue
+        if not candidate_matches_query(memory, user_text):
+            continue
+        seen_ids.add(memory_id.casefold())
+        matches.append(memory)
+    if len(matches) != 1:
+        return None
+    target = matches[0]
+    candidate_id_material = "|".join(
+        [target.memory_id, state, *sorted(item.casefold() for item in evidence_event_ids)]
+    )
+    candidate_id = "todo-state-" + hashlib.sha256(candidate_id_material.encode("utf-8")).hexdigest()[:16]
+    scopes = list(target.scopes) or ["global"]
+    scope_source = target.scope_source
+    if scope_source not in {"model", "user", "session_context", "insufficient_context"}:
+        scope_source = "model"
+    status_word = "completed" if state == "completed" else "cancelled"
+    candidate = {
+        "candidate_id": candidate_id,
+        "memory": f"{target.title} 用户已明确{status_word}。",
+        "evidence_event_ids": evidence_event_ids,
+        "duplicate": False,
+        "worth": True,
+        "type": "todo",
+        "scopes": scopes,
+        "scope_source": scope_source,
+        "update_memory_id": target.memory_id,
+    }
+    return candidate, state, target.memory_id, completed_at
+
+
 _DIAGNOSTIC_CANDIDATE_ALLOWED = _DIAGNOSTIC_CANDIDATE_REQUIRED | frozenset(
     ("reason", "duplicate_memory_id", "update_memory_id")
 )
@@ -2266,11 +2474,72 @@ class Processor:
                 "turn_index": turn.turn_index,
             },
         )
+        # A model may correctly treat the rest of a mixed turn as a query and
+        # still miss the user's explicit completion update. Recover only one
+        # uniquely related active todo; all other gate decisions stay intact.
+        todo_state_recovery = _todo_state_recovery_candidate(events, related)
+        recovery_by_candidate: dict[str, tuple[str, str, str]] = {}
+        if todo_state_recovery is not None:
+            recovery_candidate, recovery_state, recovery_target_id, recovery_completed_at = todo_state_recovery
+            matching_index = next(
+                (
+                    index
+                    for index, item in enumerate(gate["candidates"])
+                    if isinstance(item, Mapping)
+                    and (
+                        item.get("update_memory_id") == recovery_target_id
+                        or item.get("duplicate_memory_id") == recovery_target_id
+                    )
+                ),
+                None,
+            )
+            if matching_index is not None:
+                existing_candidate = gate["candidates"][matching_index]
+                if (
+                    isinstance(existing_candidate, Mapping)
+                    and existing_candidate.get("update_memory_id") == recovery_target_id
+                    and existing_candidate.get("type") == "todo"
+                    and existing_candidate.get("worth") is True
+                    and existing_candidate.get("duplicate") is False
+                ):
+                    recovery_by_candidate[str(existing_candidate["candidate_id"]).casefold()] = (
+                        recovery_state,
+                        recovery_target_id,
+                        recovery_completed_at,
+                    )
+                else:
+                    # A duplicate or mismatched candidate cannot represent a
+                    # state transition. Replace only that target's candidate.
+                    gate["candidates"] = [
+                        item
+                        for index, item in enumerate(gate["candidates"])
+                        if index != matching_index
+                    ]
+                    gate["candidates"].append(recovery_candidate)
+                    recovery_by_candidate[recovery_candidate["candidate_id"].casefold()] = (
+                        recovery_state,
+                        recovery_target_id,
+                        recovery_completed_at,
+                    )
+            else:
+                gate["candidates"].append(recovery_candidate)
+                recovery_by_candidate[recovery_candidate["candidate_id"].casefold()] = (
+                    recovery_state,
+                    recovery_target_id,
+                    recovery_completed_at,
+                )
         requests: list[dict[str, Any]] = []
         observed_scopes: list[str] = []
+        read_only_query = _automatic_read_only_query(events)
         for candidate in gate["candidates"]:
             candidate_id_key = str(candidate.get("candidate_id", "")).casefold()
+            recovery = recovery_by_candidate.get(candidate_id_key)
             detached_update_target_id = detached_update_target_ids.get(candidate_id_key)
+            if candidate.get("worth") and (
+                (read_only_query and recovery is None)
+                or _automatic_transient_memory(candidate.get("memory"))
+            ):
+                continue
             # A combined mailbox/daily digest is not an atomic memory.  If a
             # concrete action was worth retaining, the gate must emit it as
             # its own candidate; the aggregate shell itself is NO_CHANGE.
@@ -2359,6 +2628,15 @@ class Processor:
                     else None
                 ),
             )
+            if recovery is not None:
+                recovery_target = self._active_memory_by_id(recovery[1])
+                if recovery_target is not None and not any(
+                    isinstance(item, Mapping)
+                    and isinstance(item.get("memory_id"), str)
+                    and item["memory_id"].casefold() == recovery_target.memory_id.casefold()
+                    for item in candidate_related
+                ):
+                    candidate_related = [recovery_target.to_dict(), *candidate_related]
             if detached_update_target_id is not None:
                 candidate_related = [
                     item
@@ -2513,18 +2791,24 @@ class Processor:
                 )
 
             try:
-                summary = self._complete_json_stage(
-                    backend,
-                    summarize_prompt(
-                        candidate,
-                        events,
-                        related_memories=candidate_related,
-                        scope_background=candidate_scope_background,
-                        scope_registry=scope_registry,
-                    ),
-                    system=SUMMARIZE_SYSTEM,
-                    purpose="summarize",
-                    parser=lambda raw: parse_summarize_output(
+                def parse_summary(raw: str) -> dict[str, Any]:
+                    if recovery is not None and isinstance(raw, str):
+                        # Complete/cancel state is deterministic evidence from
+                        # the user event. Inject it before strict validation so
+                        # a model that omits status/completed_at cannot leave
+                        # the update active or fail the required-field check.
+                        parsed_raw = parse_strict_json(raw)
+                        if isinstance(parsed_raw, Mapping) and "decision" not in parsed_raw:
+                            state_change, target_id, completed_at = recovery
+                            parsed_raw = dict(parsed_raw)
+                            parsed_raw["update_memory_id"] = target_id
+                            parsed_raw["status"] = state_change
+                            if state_change == "completed":
+                                parsed_raw["completed_at"] = completed_at
+                            else:
+                                parsed_raw.pop("completed_at", None)
+                            raw = json.dumps(parsed_raw, ensure_ascii=False, separators=(",", ":"))
+                    parsed = parse_summarize_output(
                         _normalize_summary_dates(raw, turn, candidate),
                         current_event_keys=turn.event_keys,
                         related_native_ids=candidate_native_ids,
@@ -2532,15 +2816,29 @@ class Processor:
                         scope_registry=validation_scope_registry,
                         expected_scopes=candidate["scopes"],
                         expected_scope_source=candidate["scope_source"],
-                        allow_no_change=True,
+                        allow_no_change=recovery is None,
                         # The summarize stage may not reinterpret a gate
-                        # candidate, including CREATE candidates.  Updates
+                        # candidate, including CREATE candidates. Updates
                         # additionally retain the active target's immutable
                         # type below.
                         expected_type=candidate.get("type"),
                         expected_update_memory_id=gate_update_target,
                         expected_target_type=gate_target_type,
+                    )
+                    return parsed
+
+                summary = self._complete_json_stage(
+                    backend,
+                    summarize_prompt(
+                        candidate,
+                        events,
+                        related_memories=candidate_related,
+                        scope_background=candidate_scope_background,
+                        scope_registry=scope_registry,
                     ),
+                    system=SUMMARIZE_SYSTEM,
+                    purpose="summarize",
+                    parser=parse_summary,
                     diagnostic_context={
                         "source": turn.source,
                         "session_id": turn.session_id,
@@ -2566,6 +2864,10 @@ class Processor:
                 f"{summary.get('title', '')}\n{summary.get('body', '')}"
             ):
                 continue
+            if _automatic_transient_memory(
+                f"{summary.get('title', '')}\n{summary.get('body', '')}"
+            ):
+                continue
             if gate_update_target is not None:
                 summary_update_target = summary.get("update_memory_id")
                 if summary_update_target is None:

{memleaf-0.2.15 → memleaf-0.2.17}/src/memleaf/prompts.py

@@ -84,6 +84,15 @@ active memory, return candidates=[]; never set duplicate_memory_id or
 update_memory_id merely to record the query or append its source. A query turn
 that also contains a newly confirmed fact or state change remains eligible for
 that new information only.
+An explicit user statement that a related active todo is now completed or
+cancelled is a durable state change for the same future use, even when the
+statement also asks what remains. Emit one worthy todo UPDATE for the exact
+related active memory_id, keep type=todo, and make the candidate memory text
+state that the todo is completed or cancelled. The summary must set the
+corresponding status field; for status=completed it must also set completed_at
+from the supporting event timestamp. Do not treat "完成了吗？"/"是否完成" as completion, and do not
+infer completion from assistant-only text, a future promise ("我会完成"), or a
+negative statement ("还没完成").
 An explicit user request to remember, keep, or use a concrete object bypasses
 the worth test only in the actual explicit remember API path, and only for its
 requested content. In the automatic capture/process path, a request to invoke or test the remember tool
@@ -237,6 +246,13 @@ confirmed change, retain the existing memory unchanged (the gate should emit
 worth=false) rather than creating a sibling. When the current evidence is a
 customer/user request that is not confirmed implemented, state it as
 requested/proposed/pending and never as completed or deployed.
+When the current user explicitly confirms that a related active todo was
+completed or cancelled, this is a state update rather than a read-only query.
+Preserve the todo's same memory_id and type, set status=completed or cancelled,
+and for completed set completed_at to the timestamp of the supporting user
+event. A later question in the same user message does not erase that update.
+Never infer this transition from assistant-only text, "完成了吗？", "还没完成",
+or a future promise such as "准备完成"/"我会完成".
 fields and JSON types are title (string), body (string), tags (string list),
 type (one of preference, fact, project, todo, event, identity, other), scopes
 (non-empty string list), and sources (non-empty object list). scope_source, if