memleaf 0.2.2__tar.gz → 0.2.4__tar.gz

{memleaf-0.2.2 → memleaf-0.2.4}/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 All notable changes to memleaf are documented here.
 
+## 0.2.4 — 2026-09-01
+
+- Give `relative_time` retries explicit, actionable correction instructions so
+  the summarizer recalculates one-off dates from evidence timestamps, removes
+  relative wording, and resolves conflicting parenthesized dates before the
+  strict validator accepts the memory.
+- Preserve the `relative_time` validation detail across the Hermes provider
+  boundary instead of degrading it to `other_schema_violation` in diagnostics.
+
+## 0.2.3 — 2026-09-01
+
+- Preserve capture event timestamps in extraction prompts and resolve one-off
+  relative calendar dates against the supporting event timestamp as
+  `YYYY-MM-DD`; reject unresolved relative dates with bounded retries while
+  retaining the inbox turn after repeated failure.
+
 ## 0.2.2 — 2026-09-01
 
 - Publish GitHub Release and PyPI from the same wheel and source distribution

{memleaf-0.2.2 → memleaf-0.2.4}/PKG-INFO

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

{memleaf-0.2.2 → memleaf-0.2.4}/README.en.md

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

{memleaf-0.2.2 → memleaf-0.2.4}/README.md

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

{memleaf-0.2.2 → memleaf-0.2.4}/pyproject.toml

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

{memleaf-0.2.2 → memleaf-0.2.4}/src/memleaf/__init__.py

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

@@ -85,6 +85,7 @@ _MODEL_VALIDATION_DETAILS = frozenset(
         "reason_too_long",
         "source_shape",
         "todo_fields",
+        "relative_time",
         "other_schema_violation",
     }
 )

{memleaf-0.2.2 → memleaf-0.2.4}/src/memleaf/hermes_provider/plugin.yaml

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

{memleaf-0.2.2 → memleaf-0.2.4}/src/memleaf/processing.py

@@ -30,7 +30,14 @@ from .locking import atomic_write_json, atomic_write_text, read_json
 from .memory_writer import MemoryWriter
 from .models import Memory, utc_now
 from .native_index import NativeIndexer
-from .prompts import JSON_CORRECTION, GATE_SYSTEM, SUMMARIZE_SYSTEM, gate_prompt, summarize_prompt
+from .prompts import (
+    JSON_CORRECTION,
+    RELATIVE_TIME_CORRECTION,
+    GATE_SYSTEM,
+    SUMMARIZE_SYSTEM,
+    gate_prompt,
+    summarize_prompt,
+)
 from .redaction import redact_text
 from .retrieval import candidate_matches_query, filter_by_scope, normalize_term
 from .scope_state import ScopeError, normalize_scopes, register_scope_nodes
@@ -282,6 +289,7 @@ def _event_payload(turn: InboxTurn) -> list[dict[str, Any]]:
             "event_key": event.event_key,
             "role": event.role,
             "turn_id": event.turn_id or "",
+            "timestamp": event.timestamp,
             "content": event.content,
         }
         for event in turn.events
@@ -462,6 +470,15 @@ class Processor:
                 return reason
         return None
 
+    @staticmethod
+    def _correction_instruction(error: BaseException) -> Optional[str]:
+        hint = Processor._safe_correction_hint(error)
+        if hint == "relative_time":
+            return RELATIVE_TIME_CORRECTION
+        if hint is not None:
+            return f"Previous output violated: {hint}."
+        return None
+
     def _diagnostic_enabled(self) -> bool:
         try:
             config = self.service.vault.config()
@@ -619,10 +636,10 @@ class Processor:
                 except Exception:
                     pass
                 if self._allows_next_json_attempt(error, attempt_count):
-                    hint = self._safe_correction_hint(error)
                     correction_prompt = prompt + "\n\n" + JSON_CORRECTION
-                    if hint is not None:
-                        correction_prompt += f"\nPrevious output violated: {hint}."
+                    instruction = self._correction_instruction(error)
+                    if instruction is not None:
+                        correction_prompt += f"\n{instruction}"
                     continue
                 raise
             try:

{memleaf-0.2.2 → memleaf-0.2.4}/src/memleaf/prompts.py

@@ -38,6 +38,16 @@ Resolve an indirect reference only to one supplied active memory; otherwise
 return no candidate or leave it unscoped for retry. Never copy a related
 diagnostic/tool failure without a separate user-confirmed business fact, project
 risk, or durable lesson.
+Calendar dates are strict. Each event may include an ISO-8601 UTC timestamp.
+For a one-off relative date in a candidate or its later summary, use the
+timestamp of the evidence event that supports it as the calendar anchor and
+emit an absolute YYYY-MM-DD date. Resolve today/tomorrow/yesterday,
+今天/明天/昨天, 本周X/这周X/下周X/上周X, and this/next/last weekday;
+use Monday-Sunday calendar weeks for week expressions. Do not leave these
+strong relative forms in a worthy memory, and never guess without a timestamp:
+defer or omit a date-dependent candidate if its supporting event has no
+timestamp. Recurring schedules such as 每天、每周三, or every Wednesday are
+not one-off dates and may remain recurring.
 If supplied, a scope directory has only memory_id, title, type, and scopes for
 active memories in one inherited scope; it has no body, sources, or extra
 metadata and is not evidence. Use it only to choose an exact ID when the same
@@ -123,6 +133,15 @@ active memory; otherwise return no candidate or leave it unscoped for retry.
 For the same use, preserve still-valid facts, add confirmed progress, replace
 contradictions, and never reduce the memory to the latest operation or create a
 sibling with a new label.
+Calendar dates are strict. Each event may include an ISO-8601 UTC timestamp.
+For a one-off relative date in the summary title or body, use the timestamp of
+the supporting evidence event as the calendar anchor and emit an absolute
+YYYY-MM-DD date. Resolve today/tomorrow/yesterday,
+今天/明天/昨天, 本周X/这周X/下周X/上周X, and this/next/last weekday;
+use Monday-Sunday calendar weeks for week expressions. Never leave these
+strong relative forms in the summary, and never guess without a timestamp.
+Recurring schedules such as 每天、每周三, or every Wednesday are not one-off
+dates and may remain recurring.
 In automatic capture/process mode, a pure read-only query whose answer only
 restates a related active memory is not a new candidate. It must have been
 rejected by the gate; do not use duplicate_memory_id or update_memory_id to
@@ -176,6 +195,22 @@ JSON_CORRECTION = (
 )
 
 
+RELATIVE_TIME_CORRECTION = (
+    "Previous output violated: relative_time. Re-read the evidence events and use "
+    "the timestamp of the event supporting each date as the anchor; recompute "
+    "each one-off relative date from that timestamp and the stated weekday "
+    "semantics. In the summary title and body, every one-off calendar date must "
+    "be written only as YYYY-MM-DD: remove forms such as today/tomorrow/yesterday, "
+    "今天/明天/昨天, 本周三/这周三/下周三/上周三, and this/next/last Wednesday. "
+    "If a relative weekday is followed by a parenthesized numeric date and they "
+    "conflict, trust the event timestamp plus the weekday meaning, replace the "
+    "numeric date with the computed YYYY-MM-DD, and remove the relative wording "
+    "and conflicting parenthetical date. Do not guess when no supporting timestamp "
+    "exists; omit or defer the date-dependent detail. Recurring schedules such as "
+    "每天、每周三, or every Wednesday are allowed. Return only the strict JSON object."
+)
+
+
 COMPACT_SYSTEM = """You are memleaf's memory compactor. Return JSON only.
 Merge only the supplied low-priority memories when they express compatible
 information. Return an object with a memories array; [] is a safe no-op.

{memleaf-0.2.2 → memleaf-0.2.4}/src/memleaf/validation.py

@@ -61,10 +61,20 @@ MODEL_VALIDATION_DETAILS = frozenset(
         "reason_too_long",
         "source_shape",
         "todo_fields",
+        "relative_time",
         "other_schema_violation",
     )
 )
 _SCOPE_NAME = re.compile(r"^[^\s/\\:\x00\r\n]+$")
+_RELATIVE_CALENDAR_EXPRESSION = re.compile(
+    r"(?:"
+    r"(?<![A-Za-z])(?:today|tomorrow|yesterday)(?![A-Za-z])"
+    r"|(?<![A-Za-z])(?:this|next|last)\s+(?:monday|tuesday|wednesday|thursday|friday|saturday|sunday)(?![A-Za-z])"
+    r"|(?:本|这|下|上)(?:个)?(?:周|星期|礼拜)\s*(?:一|二|三|四|五|六|日|天|末|[1-7])"
+    r"|(?:今天|明天|昨天)"
+    r")",
+    re.IGNORECASE,
+)
 _SOURCE_FIELDS = frozenset(("event_key", "session_id", "turn_id", "conversation_title", "evidence_event_ids"))
 _COMPACT_FIELDS = frozenset(
     (
@@ -167,6 +177,27 @@ def _string_list(
     return result
 
 
+def _reject_relative_calendar_expression(item: Mapping[str, Any]) -> None:
+    """Reject unresolved one-off calendar expressions without parsing dates.
+
+    The event timestamp is supplied to the model in the prompt, where the
+    model can resolve the expression.  This validator only catches the small
+    set of strong relative forms; recurring language such as 每周三 and
+    every Wednesday is intentionally outside the expression.
+    """
+
+    text = "\n".join(
+        value
+        for field in ("title", "body")
+        if isinstance(value := item.get(field), str)
+    )
+    if _RELATIVE_CALENDAR_EXPRESSION.search(text):
+        raise ModelOutputError(
+            "summary contains an unresolved relative calendar date",
+            validation_detail="relative_time",
+        )
+
+
 def _scopes(value: Any, scope_source: Any) -> list[str]:
     result = _string_list(value, "scopes", validation_detail="invalid_scope")
     for scope in result:
@@ -579,6 +610,7 @@ def validate_summarize_output(
     item = dict(value)
     _string(item["title"], "title")
     _string(item["body"], "body", multiline=True)
+    _reject_relative_calendar_expression(item)
     item["tags"] = _string_list(item["tags"], "tags")
     candidate_type = item["type"]
     if not isinstance(candidate_type, str) or candidate_type not in MEMORY_TYPES:

{memleaf-0.2.2 → memleaf-0.2.4}/src/memleaf.egg-info/PKG-INFO

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

{memleaf-0.2.2 → memleaf-0.2.4}/tests/test_hermes_provider.py

@@ -1717,6 +1717,44 @@ class HermesProviderTests(unittest.TestCase):
         self.assertIsNotNone(fields)
         self.assertEqual(fields[4], "invalid_update_target")
 
+    def test_relative_time_validation_detail_is_preserved_and_logged(self) -> None:
+        value = {
+            "isError": True,
+            "structuredContent": {
+                "error": {
+                    "code": "model_invalid_response",
+                    "stage": "summarize",
+                    "validation_reason": "schema_violation",
+                    "validation_detail": "relative_time",
+                    "attempt_count": 3,
+                }
+            },
+        }
+        fields = provider_module._mcp_error_fields(value)
+        self.assertIsNotNone(fields)
+        self.assertEqual(fields[4], "relative_time")
+        error = provider_module._MCPToolError(
+            code="model_invalid_response",
+            stage="summarize",
+            validation_reason="schema_violation",
+            validation_detail="relative_time",
+            attempt_count=3,
+        )
+        self.assertEqual(error.validation_detail, "relative_time")
+
+        provider = self.provider(
+            responses=[
+                {"stored": True},
+                {"stored": True},
+                value,
+            ]
+        )
+        with patch.object(provider_module.logger, "info") as info:
+            provider.sync_turn("visible user", "visible assistant", session_id="relative-time-session")
+        output = "\n".join(call.args[0] % call.args[1:] for call in info.call_args_list)
+        self.assertIn("validation_detail=relative_time", output)
+        self.assertIn("attempt_count=3", output)
+
     def test_capture_failure_skips_process_and_does_not_escape_provider(self) -> None:
         provider = self.provider(responses=[{"stored": True}, RuntimeError("capture unavailable")])
         with patch.object(provider_module.logger, "warning") as warning:

{memleaf-0.2.2 → memleaf-0.2.4}/tests/test_pypi_install.py

@@ -39,7 +39,7 @@ class PyPIInstallTests(unittest.TestCase):
 
             self.assertTrue(target.is_dir())
             self.assertFalse(target.is_symlink())
-            self.assertIn("version: 0.2.2", (target / "plugin.yaml").read_text(encoding="utf-8"))
+            self.assertIn("version: 0.2.4", (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:

{memleaf-0.2.2 → memleaf-0.2.4}/tests/test_stage_b1.py

@@ -4,11 +4,18 @@ import tempfile
 import urllib.error
 import unittest
 from pathlib import Path
+from unittest import mock
 
 from memleaf import Memleaf
 from memleaf.config import default_config, load_config, save_config
 from memleaf.inbox import complete_turns, parse_inbox
-from memleaf.prompts import GATE_SYSTEM, SUMMARIZE_SYSTEM, gate_prompt, summarize_prompt
+from memleaf.prompts import (
+    GATE_SYSTEM,
+    RELATIVE_TIME_CORRECTION,
+    SUMMARIZE_SYSTEM,
+    gate_prompt,
+    summarize_prompt,
+)
 from memleaf.validation import ModelOutputError
 from memleaf.index import event_key, turn_key
 from memleaf.llm import (
@@ -21,7 +28,7 @@ from memleaf.llm import (
     ModelUnavailable,
     OpenAICompatibleBackend,
 )
-from memleaf.processing import Processor
+from memleaf.processing import Processor, _event_payload
 from memleaf.validation import parse_gate_output, parse_summarize_output
 
 
@@ -139,6 +146,207 @@ class StageB1Test(unittest.TestCase):
         self.assertTrue(turns[0].complete)
         self.assertEqual(complete_turns(self.service.vault), turns)
 
+    def test_event_timestamp_is_preserved_in_extraction_payload_and_prompts(self):
+        anchor = "2026-09-01T02:01:41Z"
+        with mock.patch("memleaf.capture._timestamp", return_value=anchor):
+            self.service.capture("codex", "calendar", "turn-1", "user", "Finish before Wednesday", event_id="calendar-user")
+            self.service.capture(
+                "codex",
+                "calendar",
+                "turn-1",
+                "assistant",
+                "I will track the deadline.",
+                event_id="calendar-assistant",
+            )
+
+        turn = parse_inbox(self.service.vault)[0]
+        events = _event_payload(turn)
+        self.assertEqual([event["timestamp"] for event in events], [anchor, anchor])
+        candidate = {
+            "candidate_id": "calendar-deadline",
+            "memory": "Finish before Wednesday",
+            "evidence_event_ids": [event_key("calendar-user")],
+            "duplicate": False,
+            "worth": True,
+            "type": "todo",
+            "scopes": ["global"],
+            "scope_source": "model",
+        }
+        gate_text = gate_prompt(events)
+        summary_text = summarize_prompt(candidate, events)
+        self.assertIn(anchor, gate_text)
+        self.assertIn(anchor, summary_text)
+        for prompt_system in (GATE_SYSTEM, SUMMARIZE_SYSTEM):
+            self.assertIn("ISO-8601 UTC timestamp", prompt_system)
+            self.assertIn("YYYY-MM-DD", prompt_system)
+            self.assertIn("本周X/这周X/下周X/上周X", prompt_system)
+            self.assertIn("every Wednesday", prompt_system)
+
+    def test_relative_summary_is_rejected_then_absolute_retry_is_committed(self):
+        anchor = "2026-09-01T02:01:41Z"
+        evidence_key = event_key("relative-retry-user")
+        gate = {
+            "candidates": [{
+                "candidate_id": "relative-deadline",
+                "memory": "Complete before Wednesday",
+                "evidence_event_ids": [evidence_key],
+                "duplicate": False,
+                "worth": True,
+                "type": "todo",
+                "scopes": ["global"],
+                "scope_source": "model",
+            }]
+        }
+
+        def summary(body):
+            return {
+                "title": "Project deadline",
+                "body": body,
+                "tags": ["deadline"],
+                "type": "todo",
+                "scopes": ["global"],
+                "scope_source": "model",
+                "sources": [{"event_key": evidence_key}],
+                "status": "active",
+            }
+
+        responses = [
+            json.dumps(gate),
+            json.dumps(summary("在本周三（9/3）前完成。")),
+            json.dumps(summary("在2026-09-02前完成。")),
+        ]
+        calls = []
+
+        def callback(prompt, **kwargs):
+            calls.append((prompt, kwargs["purpose"]))
+            return responses.pop(0)
+
+        with mock.patch("memleaf.capture._timestamp", return_value=anchor):
+            self.service.capture("codex", "relative-retry", "turn-1", "user", "Finish before Wednesday", event_id="relative-retry-user")
+            self.service.capture(
+                "codex",
+                "relative-retry",
+                "turn-1",
+                "assistant",
+                "The deadline is confirmed.",
+                event_id="relative-retry-assistant",
+            )
+
+        result = self.service.process(
+            source="codex",
+            session_id="relative-retry",
+            model=FakeBackend(callback, model="relative-retry"),
+        )
+        self.assertEqual(result["processed_turns"], 1)
+        self.assertEqual(len(calls), 3)
+        self.assertEqual([purpose for _, purpose in calls], ["gate", "summarize", "summarize"])
+        self.assertIn(anchor, calls[0][0])
+        self.assertIn(RELATIVE_TIME_CORRECTION, calls[2][0])
+        self.assertIn("event supporting each date as the anchor", calls[2][0])
+        self.assertIn("every one-off calendar date must be written only as YYYY-MM-DD", calls[2][0])
+        self.assertIn("parenthesized numeric date", calls[2][0])
+        self.assertIn("trust the event timestamp plus the weekday meaning", calls[2][0])
+        self.assertIn("Previous output violated: relative_time.", calls[2][0])
+        memory = self.service.read(result["memory_ids"][0])
+        self.assertIsNotNone(memory)
+        self.assertIn("2026-09-02", memory.body)
+        self.assertNotIn("本周三", memory.body)
+
+    def test_recurring_weekday_expression_is_not_rejected_as_relative_date(self):
+        for body in (
+            "每周三例会。",
+            "The recurring meeting is every Wednesday.",
+            "会议时间：2026-09-01（周二）16:30。",
+        ):
+            with self.subTest(body=body):
+                summary = {
+                    "title": "Recurring meeting",
+                    "body": body,
+                    "tags": ["meeting"],
+                    "type": "event",
+                    "scopes": ["global"],
+                    "sources": [{"event_key": "event-a"}],
+                }
+                parsed = parse_summarize_output(json.dumps(summary), current_event_keys=["event-a"])
+                self.assertEqual(parsed["body"], body)
+
+    def test_relative_summary_without_timestamp_is_rejected_and_only_title_body_are_scanned(self):
+        relative = {
+            "title": "截止今天",
+            "body": "完成项目交付。",
+            "tags": [],
+            "type": "project",
+            "scopes": ["global"],
+            "sources": [{"event_key": "event-a", "conversation_title": "今天的会话"}],
+        }
+        with self.assertRaises(ModelOutputError) as raised:
+            parse_summarize_output(json.dumps(relative), current_event_keys=["event-a"])
+        self.assertEqual(raised.exception.validation_detail, "relative_time")
+
+        recurring_metadata = dict(relative, title="交付安排", body="每周三例会。")
+        parsed = parse_summarize_output(json.dumps(recurring_metadata), current_event_keys=["event-a"])
+        self.assertEqual(parsed["sources"][0]["conversation_title"], "今天的会话")
+
+    def test_three_relative_summary_failures_keep_watermark_and_inbox(self):
+        anchor = "2026-09-01T02:01:41Z"
+        evidence_key = event_key("relative-failure-user")
+        gate = {
+            "candidates": [{
+                "candidate_id": "relative-failure",
+                "memory": "Complete before Wednesday",
+                "evidence_event_ids": [evidence_key],
+                "duplicate": False,
+                "worth": True,
+                "type": "todo",
+                "scopes": ["global"],
+                "scope_source": "model",
+            }]
+        }
+        relative_summary = {
+            "title": "Project deadline",
+            "body": "在本周三前完成。",
+            "tags": ["deadline"],
+            "type": "todo",
+            "scopes": ["global"],
+            "scope_source": "model",
+            "sources": [{"event_key": evidence_key}],
+            "status": "active",
+        }
+        responses = [json.dumps(gate)] + [json.dumps(relative_summary)] * 3
+        calls = []
+
+        def callback(prompt, **kwargs):
+            calls.append(kwargs["purpose"])
+            return responses.pop(0)
+
+        with mock.patch("memleaf.capture._timestamp", return_value=anchor):
+            self.service.capture("codex", "relative-failure", "turn-1", "user", "Finish before Wednesday", event_id="relative-failure-user")
+            self.service.capture(
+                "codex",
+                "relative-failure",
+                "turn-1",
+                "assistant",
+                "The deadline is confirmed.",
+                event_id="relative-failure-assistant",
+            )
+
+        with self.assertRaises(ModelOutputError) as raised:
+            self.service.process(
+                source="codex",
+                session_id="relative-failure",
+                model=FakeBackend(callback, model="relative-failure"),
+            )
+        self.assertEqual(raised.exception.validation_detail, "relative_time")
+        self.assertEqual(raised.exception.attempt_count, 3)
+        self.assertEqual(calls, ["gate", "summarize", "summarize", "summarize"])
+        processed = json.loads(self.service.vault.processed_index_path.read_text(encoding="utf-8"))
+        state = processed["sessions"]["codex/relative-failure"]
+        self.assertEqual(state.get("watermark", 0), 0)
+        self.assertEqual(state["processing"]["status"], "failed")
+        inbox = self.vault_path / "inbox" / "codex" / "relative-failure.md"
+        self.assertTrue(inbox.is_file())
+        self.assertIn("Finish before Wednesday", inbox.read_text(encoding="utf-8"))
+
     def test_process_retries_schema_violation_until_third_gate_attempt_and_commits(self):
         responses = [
             json.dumps({"candidates": "invalid"}),

{memleaf-0.2.2 → memleaf-0.2.4}/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.2"},
+            {"name": "memleaf", "version": "0.2.4"},
         )
         return result
 

{memleaf-0.2.2 → memleaf-0.2.4}/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.2")
+        self.assertEqual(self.project["version"], "0.2.4")
         self.assertEqual(self.project["requires-python"], ">=3.11")
         self.assertEqual(self.project["dependencies"], [])
         self.assertEqual(self.project["license"], "MIT")