memleaf 0.2.16__tar.gz → 0.2.17__tar.gz

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

@@ -2,6 +2,16 @@
 
 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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 0.2.16
+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.16。**
-> 核心库、Vault、stdio MCP Server、初始化 CLI、模型路由、提炼流程、受控检索协议和宿主适配器已经实现。memleaf 0.2.16 通过 PyPI 分发。
+> **当前版本：0.2.17。**
+> 核心库、Vault、stdio MCP Server、初始化 CLI、模型路由、提炼流程、受控检索协议和宿主适配器已经实现。memleaf 0.2.17 通过 PyPI 分发。
 > **当前版本支持 Hermes 和 Codex。** Antigravity（反重力）不检测、不安装、不配置。
 
 ## 项目定位

{memleaf-0.2.16 → 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.16.**
-> The core library, Vault, stdio MCP server, initialization CLI, model routing, memory extraction, controlled retrieval protocol, and host adapters are implemented. memleaf 0.2.16 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.16 → 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.16。**
-> 核心库、Vault、stdio MCP Server、初始化 CLI、模型路由、提炼流程、受控检索协议和宿主适配器已经实现。memleaf 0.2.16 通过 PyPI 分发。
+> **当前版本：0.2.17。**
+> 核心库、Vault、stdio MCP Server、初始化 CLI、模型路由、提炼流程、受控检索协议和宿主适配器已经实现。memleaf 0.2.17 通过 PyPI 分发。
 > **当前版本支持 Hermes 和 Codex。** Antigravity（反重力）不检测、不安装、不配置。
 
 ## 项目定位

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

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

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

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

@@ -1,5 +1,5 @@
 name: memleaf
-version: 0.2.16
+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.16 → memleaf-0.2.17}/src/memleaf/processing.py

@@ -105,6 +105,100 @@ _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:
@@ -136,6 +230,71 @@ def _automatic_transient_memory(value: Any) -> bool:
     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")
 )
@@ -2315,14 +2474,70 @@ 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 or _automatic_transient_memory(candidate.get("memory"))
+                (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
@@ -2413,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
@@ -2567,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,
@@ -2586,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,

{memleaf-0.2.16 → 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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 0.2.16
+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.16。**
-> 核心库、Vault、stdio MCP Server、初始化 CLI、模型路由、提炼流程、受控检索协议和宿主适配器已经实现。memleaf 0.2.16 通过 PyPI 分发。
+> **当前版本：0.2.17。**
+> 核心库、Vault、stdio MCP Server、初始化 CLI、模型路由、提炼流程、受控检索协议和宿主适配器已经实现。memleaf 0.2.17 通过 PyPI 分发。
 > **当前版本支持 Hermes 和 Codex。** Antigravity（反重力）不检测、不安装、不配置。
 
 ## 项目定位

{memleaf-0.2.16 → memleaf-0.2.17}/src/memleaf.egg-info/SOURCES.txt

@@ -93,6 +93,7 @@ tests/test_stage_b3d_scope_maintenance.py
 tests/test_stage_c1_mcp.py
 tests/test_stage_c2_init.py
 tests/test_stage_c3_packaging.py
+tests/test_todo_state_recovery.py
 tests/test_update_target_recovery.py
 tests/test_upgrade_preserves_vault.py
 tests/test_v2_gate_limits.py

{memleaf-0.2.16 → memleaf-0.2.17}/tests/test_hermes_provider.py

@@ -303,11 +303,11 @@ class HermesProviderTests(unittest.TestCase):
 
     def test_provider_does_not_warn_when_core_versions_match(self) -> None:
         client = FakeClient(responses=[{"stats": True}])
-        client.server_version = "0.2.16"
+        client.server_version = "0.2.17"
         provider = provider_module.MemleafMemoryProvider()
         with patch.object(provider_module, "_resolve_command", return_value="memleaf-mcp"), \
              patch.object(provider_module, "_MCPClient", return_value=client), \
-             patch.object(provider_module, "_provider_manifest_version", return_value="0.2.16"), \
+             patch.object(provider_module, "_provider_manifest_version", return_value="0.2.17"), \
              patch.object(provider_module.logger, "warning") as warning:
             provider.initialize(
                 "version-match-session",
@@ -324,7 +324,7 @@ class HermesProviderTests(unittest.TestCase):
         provider = provider_module.MemleafMemoryProvider()
         with patch.object(provider_module, "_resolve_command", return_value="memleaf-mcp"), \
              patch.object(provider_module, "_MCPClient", return_value=client), \
-             patch.object(provider_module, "_provider_manifest_version", return_value="0.2.16"), \
+             patch.object(provider_module, "_provider_manifest_version", return_value="0.2.17"), \
              patch.object(provider_module.logger, "warning") as warning:
             provider.initialize(
                 "version-missing-session",

{memleaf-0.2.16 → memleaf-0.2.17}/tests/test_pypi_install.py

@@ -81,7 +81,7 @@ class PyPIInstallTests(unittest.TestCase):
 
             self.assertTrue(target.is_dir())
             self.assertFalse(target.is_symlink())
-            self.assertIn("version: 0.2.16", (target / "plugin.yaml").read_text(encoding="utf-8"))
+            self.assertIn("version: 0.2.17", (target / "plugin.yaml").read_text(encoding="utf-8"))
 
     def test_windows_hermes_paths_follow_official_native_layout(self) -> None:
         with tempfile.TemporaryDirectory(prefix="memleaf-win-paths-") as temporary:
@@ -212,16 +212,16 @@ class PyPIInstallTests(unittest.TestCase):
             "status": "configured",
             "reason": "ok",
             "vault": "/tmp/memleaf-vault",
-            "core_version": "0.2.16",
-            "provider_version": "0.2.16",
+            "core_version": "0.2.17",
+            "provider_version": "0.2.17",
             "model": {"status": "configured"},
         }
         with mock.patch("memleaf.installer.install_hermes", return_value=result), \
              mock.patch("sys.stdout") as stdout:
             self.assertEqual(cli.main(["install"]), 0)
         output = "\n".join(str(call.args[0]) for call in stdout.write.call_args_list)
-        self.assertIn("core=0.2.16", output)
-        self.assertIn("Hermes provider=0.2.16", output)
+        self.assertIn("core=0.2.17", output)
+        self.assertIn("Hermes provider=0.2.17", output)
 
     def test_readmes_document_one_line_core_and_provider_upgrade(self) -> None:
         command = "python -m pip install -U memleaf && python -m memleaf install"

{memleaf-0.2.16 → memleaf-0.2.17}/tests/test_stage_c1_mcp.py

@@ -104,7 +104,7 @@ class StageC1MCPTest(unittest.TestCase):
         testcase.assertEqual(result["resultType"], "complete")
         testcase.assertEqual(
             result["_meta"]["io.modelcontextprotocol/serverInfo"],
-            {"name": "memleaf", "version": "0.2.16"},
+            {"name": "memleaf", "version": "0.2.17"},
         )
         return result
 

{memleaf-0.2.16 → memleaf-0.2.17}/tests/test_stage_c3_packaging.py

@@ -24,7 +24,7 @@ class StageC3PackagingTests(unittest.TestCase):
 
     def test_project_metadata_and_version_export(self) -> None:
         self.assertEqual(self.project["name"], "memleaf")
-        self.assertEqual(self.project["version"], "0.2.16")
+        self.assertEqual(self.project["version"], "0.2.17")
         self.assertEqual(self.project["requires-python"], ">=3.11")
         self.assertEqual(self.project["dependencies"], [])
         self.assertEqual(self.project["license"], "MIT")

memleaf-0.2.17/tests/test_todo_state_recovery.py

@@ -0,0 +1,165 @@
+import json
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+
+from memleaf import Memleaf
+from memleaf.index import event_key
+
+
+class QueueBackend:
+    def __init__(self, responses):
+        self.responses = list(responses)
+        self.calls = []
+
+    def complete(self, prompt, *, system="", purpose="", temperature=0.0):
+        self.calls.append({"prompt": prompt, "purpose": purpose})
+        return self.responses.pop(0)
+
+
+class TodoStateRecoveryTest(unittest.TestCase):
+    @staticmethod
+    def gate(candidates):
+        return json.dumps({"candidates": candidates}, ensure_ascii=False)
+
+    @staticmethod
+    def summary(event_key_value):
+        # Deliberately omit update_memory_id/status/completed_at.  The user
+        # declaration is the source of those deterministic state fields.
+        return json.dumps(
+            {
+                "title": "鑫元基金架构评审文档修改与反馈",
+                "body": "架构评审文档已完成并发出。",
+                "tags": ["todo"],
+                "type": "todo",
+                "scopes": ["project:鑫元基金"],
+                "scope_source": "model",
+                "sources": [{"event_key": event_key_value}],
+            },
+            ensure_ascii=False,
+        )
+
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.vault = Path(self.tmp.name) / "vault"
+
+    def tearDown(self):
+        self.tmp.cleanup()
+
+    def add_todo(self, service, memory_id="todo-1", title="鑫元基金架构评审文档修改与反馈"):
+        return service.create_memory(
+            memory_id=memory_id,
+            title=title,
+            body="需按要求修改并反馈。",
+            tags=["todo"],
+            type="todo",
+            scopes=["project:鑫元基金"],
+            scope_source="model",
+        )
+
+    def add_turn(self, service, user, *, assistant="已收到。"):
+        service.capture("hermes", "session", "turn-1", "user", user, event_id="todo-user")
+        service.capture("hermes", "session", "turn-1", "assistant", assistant, event_id="todo-assistant")
+        return event_key("todo-user")
+
+    def test_gate_empty_recovers_completion_in_place_and_anchors_timestamp(self):
+        backend = QueueBackend([])
+        service = Memleaf(self.vault, model=backend)
+        old = self.add_todo(service)
+        with patch("memleaf.capture._timestamp", return_value="2026-09-02T09:21:51Z"):
+            user_key = self.add_turn(
+                service,
+                "鑫元基金的架构评审文档我已经完成了，发给他们了。还有什么事情要完成",
+            )
+        backend.responses.extend([self.gate([]), self.summary(user_key)])
+
+        result = service.process(source="hermes", session_id="session", model=backend)
+
+        self.assertEqual(result["memory_ids"], [old.memory_id])
+        active = service.read(old.memory_id)
+        self.assertEqual(active.status, "completed")
+        self.assertEqual(active.completed_at, "2026-09-02T09:21:51Z")
+        self.assertEqual(len(service._read_memories_unlocked("knowledge")), 1)
+        history = service._read_memories_unlocked("history")
+        self.assertEqual(len(history), 1)
+        self.assertEqual(history[0].memory.extra["active_memory_id"], old.memory_id)
+        self.assertEqual([call["purpose"] for call in backend.calls], ["gate", "summarize"])
+
+    def assert_no_transition(self, text, *, assistant="已收到。", name="no-transition"):
+        backend = QueueBackend([self.gate([])])
+        service = Memleaf(Path(self.tmp.name) / name, model=backend)
+        old = self.add_todo(service)
+        self.add_turn(service, text, assistant=assistant)
+        result = service.process(source="hermes", session_id="session", model=backend)
+        active = service.read(old.memory_id)
+        self.assertEqual(result["memories_written"], 0)
+        self.assertIn(active.status, (None, "active"))
+        self.assertEqual(service._read_memories_unlocked("history"), [])
+        self.assertEqual([call["purpose"] for call in backend.calls], ["gate"])
+
+    def test_query_does_not_complete(self):
+        self.assert_no_transition("鑫元基金的架构评审文档完成了吗？", name="query")
+
+    def test_confirmation_and_uncertain_completion_do_not_complete(self):
+        for index, text in enumerate(
+            (
+                "鑫元基金的架构评审文档已经完成了，对吗？",
+                "鑫元基金的架构评审文档应该已经完成了",
+                "鑫元基金的架构评审文档可能已经完成了",
+                "鑫元基金的架构评审文档是否已经完成？",
+            )
+        ):
+            with self.subTest(text=text):
+                self.assert_no_transition(text, name=f"confirmation-{index}")
+
+    def test_negative_and_future_statements_do_not_complete(self):
+        for index, text in enumerate(("鑫元基金的架构评审文档还没完成", "鑫元基金的架构评审文档准备完成", "鑫元基金的架构评审文档我会完成")):
+            with self.subTest(text=text):
+                self.assert_no_transition(text, name=f"future-{index}")
+
+    def test_assistant_only_completion_does_not_complete(self):
+        self.assert_no_transition(
+            "鑫元基金的架构评审文档现在是什么状态？",
+            assistant="鑫元基金的架构评审文档已经完成了。",
+            name="assistant-only",
+        )
+
+    def test_ambiguous_same_topic_todos_do_not_guess(self):
+        backend = QueueBackend([self.gate([])])
+        service = Memleaf(Path(self.tmp.name) / "ambiguous", model=backend)
+        self.add_todo(service, memory_id="todo-a")
+        service.create_memory(
+            memory_id="todo-b",
+            title="鑫元基金架构评审文档修改与反馈",
+            body="需按另一份要求修改并反馈。",
+            tags=["todo"],
+            type="todo",
+            scopes=["project:鑫元基金"],
+            scope_source="model",
+        )
+        self.add_turn(service, "鑫元基金的架构评审文档我已经完成了。")
+
+        result = service.process(source="hermes", session_id="session", model=backend)
+
+        self.assertEqual(result["memories_written"], 0)
+        self.assertTrue(all(item.memory.status in (None, "active") for item in service._read_memories_unlocked("knowledge")))
+        self.assertEqual(service._read_memories_unlocked("history"), [])
+
+    def test_cancelled_state_is_recovered_in_place(self):
+        backend = QueueBackend([])
+        service = Memleaf(Path(self.tmp.name) / "cancelled", model=backend)
+        old = self.add_todo(service)
+        with patch("memleaf.capture._timestamp", return_value="2026-09-02T09:21:51Z"):
+            user_key = self.add_turn(service, "鑫元基金的架构评审文档不用做了。")
+        backend.responses.extend([self.gate([]), self.summary(user_key)])
+
+        result = service.process(source="hermes", session_id="session", model=backend)
+
+        self.assertEqual(result["memory_ids"], [old.memory_id])
+        self.assertEqual(service.read(old.memory_id).status, "cancelled")
+        self.assertIsNone(service.read(old.memory_id).completed_at)
+
+
+if __name__ == "__main__":
+    unittest.main()