memleaf 0.2.70__tar.gz → 0.2.71__tar.gz

{memleaf-0.2.70 → memleaf-0.2.71}/CHANGELOG.md

@@ -4,6 +4,17 @@ All notable changes to memleaf are documented here.
 
 ## Unreleased
 
+## 0.2.71 — 2026-09-21
+
+### Source-time and calendar grounding
+
+- Normalize native Hermes Unix timestamps using the host-local day while
+  rejecting non-finite and out-of-range numeric values.
+- Provide source-local calendar hints to incremental planning without using the
+  processing clock or making an additional model request.
+- Reject generated content dates that conflict with cited source dates or
+  same-clock relative-date evidence, while preserving existing target wording.
+
 ## 0.2.70 — 2026-09-21
 
 ### Public repository and artifact hygiene

{memleaf-0.2.70/src/memleaf.egg-info → memleaf-0.2.71}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 0.2.70
+Version: 0.2.71
 Summary: A local-first Markdown memory core for AI agents
 Author: memleaf contributors
 License-Expression: MIT
@@ -23,7 +23,7 @@ Dynamic: license-file
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **版本：0.2.70。**
+> **版本：0.2.71。**
 > 自动提炼和复核共用同一条“未来记忆价值”标准：模型综合未来复用、信息增量、再次读取时的直接可用性和忘记成本，只保留对未来理解、判断或行动有实质影响的最小核心；没有明确价值的信息不提炼，不按具体业务场景硬编码排除。
 > 提炼契约现在只有一份中文语义契约（旧版英文 B3 提示词已删除），首轮、主题选择、候选修复和 `semantic_maintenance` 使用同一套保留价值判断；同一件事只写一次。
 > Core 不再因为归属、日期、任务依据或跨项目而丢弃整条候选：归属缺失会归一到证据里唯一被点名的项目、否则落 `global`；日期只接受能在本候选证据里找到出处、且能锚定成 ISO 的写法（`明天`、`周五`、`月底` 都会被解析），无法解析时只丢掉日期字段，记忆照常写入；未获授权的改归属沿用目标原归属。

{memleaf-0.2.70 → memleaf-0.2.71}/README.en.md

@@ -4,7 +4,7 @@
 
 [中文](README.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **Version: 0.2.70.**
+> **Version: 0.2.71.**
 > Automatic extraction and review share one future-value standard: the model weighs likely reuse, information gain, direct usability when read again, and the cost of forgetting. It keeps only the smallest core that can materially help future understanding, decisions, or actions; information without clear value is not extracted, and no business-specific exclusion rule is hard-coded.
 > A single Chinese semantic contract is sent for extraction, topic selection, candidate repair, and `semantic_maintenance`; the older English B3 prompt has been deleted and B3 remains only as a compatibility read format. One topic is written once.
 > Core no longer discards a whole candidate over ownership, dates, task basis or cross-project wording. A missing owner normalizes to the single project named by that candidate's own evidence, otherwise `global`. A deadline is accepted only when it appears in the candidate's own evidence and can be anchored to ISO (`明天`, `周五`, `月底` all resolve); when it cannot, only the date field is dropped and the memory is still written. An unauthorized ownership change keeps the target's existing scope.

{memleaf-0.2.70 → memleaf-0.2.71}/README.md

@@ -4,7 +4,7 @@
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **版本：0.2.70。**
+> **版本：0.2.71。**
 > 自动提炼和复核共用同一条“未来记忆价值”标准：模型综合未来复用、信息增量、再次读取时的直接可用性和忘记成本，只保留对未来理解、判断或行动有实质影响的最小核心；没有明确价值的信息不提炼，不按具体业务场景硬编码排除。
 > 提炼契约现在只有一份中文语义契约（旧版英文 B3 提示词已删除），首轮、主题选择、候选修复和 `semantic_maintenance` 使用同一套保留价值判断；同一件事只写一次。
 > Core 不再因为归属、日期、任务依据或跨项目而丢弃整条候选：归属缺失会归一到证据里唯一被点名的项目、否则落 `global`；日期只接受能在本候选证据里找到出处、且能锚定成 ISO 的写法（`明天`、`周五`、`月底` 都会被解析），无法解析时只丢掉日期字段，记忆照常写入；未获授权的改归属沿用目标原归属。

{memleaf-0.2.70 → memleaf-0.2.71}/pyproject.toml

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

{memleaf-0.2.70 → memleaf-0.2.71}/src/memleaf/__init__.py

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

@@ -37,6 +37,7 @@ def _sync_source_metadata(messages: Any, user_content: str, assistant_content: s
     Strings supplied to sync_turn remain the only captured conversation bodies.
     """
     from datetime import datetime
+    from math import isfinite
 
     if not isinstance(messages, list) or not messages:
         return {}
@@ -55,8 +56,17 @@ def _sync_source_metadata(messages: Any, user_content: str, assistant_content: s
             value = item.get(name, item.get("id") if name == "message_id" else None)
             if isinstance(value, str) and 0 < len(value) <= 800 and not any(c in value for c in "\x00\r\n"):
                 row[name] = value
-        timestamp = item.get("source_time", item.get("timestamp"))
-        if isinstance(timestamp, str) and len(timestamp) <= 80:
+        timestamp = item.get("source_time")
+        if timestamp is None:
+            timestamp = item.get("timestamp")
+        if type(timestamp) in (int, float) and isfinite(timestamp) and 0 <= timestamp < 253402300800:
+            # Hermes persists Unix seconds (not an ISO string). Keep the host's
+            # local offset: a UTC rendering can shift "today" across midnight.
+            try:
+                row["source_time"] = datetime.fromtimestamp(timestamp).astimezone().isoformat()
+            except (OverflowError, OSError, ValueError):
+                pass
+        elif isinstance(timestamp, str) and len(timestamp) <= 80:
             try:
                 parsed = datetime.fromisoformat(timestamp.replace("Z", "+00:00"))
                 if parsed.tzinfo is not None and parsed.utcoffset() is not None:

{memleaf-0.2.70 → memleaf-0.2.71}/src/memleaf/hermes_provider/plugin.yaml

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

memleaf-0.2.71/src/memleaf/incremental_dates.py

@@ -0,0 +1,146 @@
+"""Calendar conversion for *model-selected* expressions, never deadline inference.
+
+The incremental compiler supplies an exact supported expression. This module
+retains it even outside the bounded calendar grammar; it never scans the whole
+message to guess which date is an action deadline.
+"""
+from __future__ import annotations
+
+import re
+from datetime import datetime
+from typing import Any, Mapping
+
+from .validation import calendar_tokens, normalize_relative_calendar_text, _RELATIVE_CALENDAR_EXPRESSION
+
+_CLOCK_AFTER_DATE = re.compile(r"\s*(?:(?:日|号|上午|下午|晚上|中午|凌晨|约|在|at|T)\s*){0,2}(\d{1,2}:[0-5]\d)(?!\d)", re.IGNORECASE)
+
+
+def _dated_clocks(text: str) -> set[tuple[str, str]]:
+    pairs = set()
+    for token in calendar_tokens(text):
+        clock = _CLOCK_AFTER_DATE.match(text, token.end)
+        if token.canonical and clock:
+            pairs.add((token.canonical, clock.group(1)))
+    return pairs
+
+
+def parse_source_time(value: Any) -> datetime | None:
+    if value is None:
+        return None
+    if not isinstance(value, str):
+        raise ValueError("invalid_source_time")
+    try:
+        result = datetime.fromisoformat(value.replace("Z", "+00:00"))
+    except ValueError:
+        raise ValueError("invalid_source_time") from None
+    if result.tzinfo is None or result.utcoffset() is None:
+        raise ValueError("invalid_source_time")
+    return result
+
+
+def reading_text(value: str) -> str:
+    # Presentation-only normalization. Keep parentheses, numbers and qualifiers.
+    return re.sub(r"\*\*|__|`", "", value)
+
+
+def source_basis(evidence: Mapping[str, Any]) -> dict[str, Any]:
+    value = {key: evidence[key] for key in (
+        "source", "session_id", "event_key", "message_id", "message_revision",
+        "source_time", "source_sequence",
+    ) if key in evidence and evidence[key] is not None}
+    if evidence.get("explicit_input") is not None:
+        from .explicit_text_source import validate_origin
+        origin = validate_origin(evidence["explicit_input"])
+        value.update(input_kind="explicit_text", origin_session_id=origin["session_id"],
+                     origin_turn_key=origin["turn_key"])
+    return value
+
+
+def calendar_hints(evidence: Mapping[str, Any]) -> list[dict[str, str]]:
+    """Small, source-local calendar facts for the same model call (no processing clock)."""
+    anchor = parse_source_time(evidence.get("source_time"))
+    if anchor is None:
+        return []
+    text = reading_text(str(evidence["text"]))
+    result: list[dict[str, str]] = []
+    for match in _RELATIVE_CALENDAR_EXPRESSION.finditer(text):
+        resolved = normalize_relative_calendar_text(match.group(), anchor.date())
+        if resolved and resolved != match.group():
+            hint = {"text": match.group(), "date": resolved}
+            if hint not in result:
+                result.append(hint)
+    return result[:20]
+
+
+def invalid_content_dates(fields: Mapping[str, Any], events: list[Mapping[str, Any]],
+                          preserved: Mapping[str, Any] | None = None) -> bool:
+    """Reject unsupported generated dates, including misdated relative clock pairs.
+
+    Only cited sources and the selected update target may ground new wording.
+    Existing memory wording is preserved without a new source claim.
+    """
+    from .process_common import _summary_date_grounding_violations
+
+    source_texts = [reading_text(str(event["text"])) for event in events]
+    grounded: set[str] = set()
+    clock_dates: dict[str, set[str]] = {}
+    for event, source in zip(events, source_texts):
+        anchor = parse_source_time(event.get("source_time"))
+        local_day = anchor.date() if anchor is not None else None
+        normalized = normalize_relative_calendar_text(source, local_day) if local_day else None
+        grounded.update(token.canonical for token in calendar_tokens(source, local_day) if token.canonical)
+        if normalized is not None:
+            grounded.update(token.canonical for token in calendar_tokens(normalized, local_day) if token.canonical)
+            for match in _RELATIVE_CALENDAR_EXPRESSION.finditer(source):
+                clock = _CLOCK_AFTER_DATE.match(source, match.end())
+                if clock:
+                    resolved = normalize_relative_calendar_text(match.group(), local_day)
+                    if resolved:
+                        clock_dates.setdefault(clock.group(1), set()).add(resolved)
+        # An explicit source date at the same clock makes a relative binding
+        # ambiguous; in that case the guard must not claim which event it is.
+        for date_value, clock_value in _dated_clocks(source):
+            clock_dates.setdefault(clock_value, set()).add(date_value)
+    prior = preserved or {}
+    texts = {key: fields[key] for key in ("title", "body") if key in fields}
+    if _summary_date_grounding_violations(texts, grounded_dates=grounded, source_texts=source_texts,
+                                          preserved_texts=[prior.get("title"), prior.get("body")]):
+        return True
+    preserved_pairs = set().union(*(_dated_clocks(text) for text in (prior.get("title"), prior.get("body"))
+                                    if isinstance(text, str)))
+    for value in texts.values():
+        for date_value, clock_value in _dated_clocks(value):
+            expected = clock_dates.get(clock_value, set())
+            if len(expected) == 1 and date_value not in expected and (date_value, clock_value) not in preserved_pairs:
+                return True
+    return False
+
+
+def selected_calendar(text: str, evidence: Mapping[str, Any]) -> dict[str, Any]:
+    """Return a lossless text/anchor projection plus an optional calendar date.
+
+    Pass a local *date* to the legacy calendar grammar, which otherwise converts
+    datetime anchors to UTC. A midnight-offset message must keep its source day.
+    No configured processing clock or capture time is used as a substitute.
+    """
+    if not isinstance(text, str) or not text.strip() or len(text) > 512:
+        raise ValueError("invalid_time_expression")
+    if reading_text(text) not in reading_text(str(evidence.get("text", ""))):
+        raise ValueError("unsupported_time_quote")
+    anchor = parse_source_time(evidence.get("source_time"))
+    local_day = anchor.date() if anchor is not None else None
+    view = reading_text(text)
+    converted = normalize_relative_calendar_text(view, local_day)
+    if local_day is None and not _RELATIVE_CALENDAR_EXPRESSION.search(view):
+        converted = view
+    tokens = calendar_tokens(converted if converted is not None else view, local_day)
+    dates = {token.canonical for token in tokens}
+    # Relative expressions which cannot be resolved must not borrow another date.
+    resolved = (converted is not None and bool(tokens)
+                and None not in dates and len(dates) == 1)
+    return {
+        "date": next(iter(dates)) if resolved else None,
+        "text": text,
+        "anchor": source_basis(evidence),
+        "status": "resolved" if resolved else "unresolved",
+    }

{memleaf-0.2.70 → memleaf-0.2.71}/src/memleaf/incremental_protocol.py

@@ -15,7 +15,8 @@ from copy import deepcopy
 from dataclasses import dataclass
 from typing import Any, Mapping
 
-from .incremental_dates import parse_source_time, reading_text, selected_calendar, source_basis
+from .incremental_dates import (calendar_hints, invalid_content_dates, parse_source_time,
+                                reading_text, selected_calendar, source_basis)
 from .models import Memory
 from .scope_state import validate_scope_key
 from .turn_plan import revision_digest
@@ -352,6 +353,13 @@ class PlanningSnapshot:
                     fields["observed"] = {}
             # No real memory IDs, revisions, local paths, source lists or journals.
             memories.append(fields)
+        projected_evidence = []
+        for event in state["evidence"]:
+            projection = {key: event[key] for key in ("ref", "use", "role", "text", "source_time", "source_sequence") if key in event}
+            hints = calendar_hints(event)
+            if hints:
+                projection["calendar_hints"] = hints
+            projected_evidence.append(projection)
         return {
             "protocol_version": PROTOCOL_VERSION, "request_kind": state["request_kind"],
             **({"retention_request": state["retention_request"]} if "retention_request" in state else {}),
@@ -359,8 +367,7 @@ class PlanningSnapshot:
             **({"scope_aliases": {reverse_scope[s]: a for s, a in state["scope_aliases"].items()}}
                if state.get("scope_aliases") else {}),
             "allow_new_scopes": state["allow_new_scopes"], "context_complete": state["context_complete"],
-            "evidence": [{key: e[key] for key in ("ref", "use", "role", "text", "source_time", "source_sequence") if key in e}
-                         for e in state["evidence"]], "memories": memories,
+            "evidence": projected_evidence, "memories": memories,
         }
 
 
@@ -495,6 +502,9 @@ def _parse_row(row: Any, state: Mapping[str, Any]) -> dict[str, Any]:
             if key in fields:
                 _text(fields[key], 256 if key == "title" else 16384,
                       empty=key == "body" and fields.get("validity") == "retracted")
+        if invalid_content_dates(fields, [evidence[ref] for ref in refs],
+                                 state["targets"][result["target_ref"]]["memory"] if action == "UPDATE" else None):
+            raise ValueError("ungrounded_content_date")
         if "status" in fields and fields["status"] not in ("active", "completed", "cancelled"):
             raise ValueError("invalid_status")
         if "validity" in fields and fields["validity"] not in ("valid", "retracted"):

{memleaf-0.2.70 → memleaf-0.2.71/src/memleaf.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 0.2.70
+Version: 0.2.71
 Summary: A local-first Markdown memory core for AI agents
 Author: memleaf contributors
 License-Expression: MIT
@@ -23,7 +23,7 @@ Dynamic: license-file
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **版本：0.2.70。**
+> **版本：0.2.71。**
 > 自动提炼和复核共用同一条“未来记忆价值”标准：模型综合未来复用、信息增量、再次读取时的直接可用性和忘记成本，只保留对未来理解、判断或行动有实质影响的最小核心；没有明确价值的信息不提炼，不按具体业务场景硬编码排除。
 > 提炼契约现在只有一份中文语义契约（旧版英文 B3 提示词已删除），首轮、主题选择、候选修复和 `semantic_maintenance` 使用同一套保留价值判断；同一件事只写一次。
 > Core 不再因为归属、日期、任务依据或跨项目而丢弃整条候选：归属缺失会归一到证据里唯一被点名的项目、否则落 `global`；日期只接受能在本候选证据里找到出处、且能锚定成 ISO 的写法（`明天`、`周五`、`月底` 都会被解析），无法解析时只丢掉日期字段，记忆照常写入；未获授权的改归属沿用目标原归属。

memleaf-0.2.70/src/memleaf/incremental_dates.py

@@ -1,75 +0,0 @@
-"""Calendar conversion for *model-selected* expressions, never deadline inference.
-
-The incremental compiler supplies an exact supported expression. This module
-retains it even outside the bounded calendar grammar; it never scans the whole
-message to guess which date is an action deadline.
-"""
-from __future__ import annotations
-
-import re
-from datetime import datetime
-from typing import Any, Mapping
-
-from .validation import calendar_tokens, normalize_relative_calendar_text, _RELATIVE_CALENDAR_EXPRESSION
-
-
-def parse_source_time(value: Any) -> datetime | None:
-    if value is None:
-        return None
-    if not isinstance(value, str):
-        raise ValueError("invalid_source_time")
-    try:
-        result = datetime.fromisoformat(value.replace("Z", "+00:00"))
-    except ValueError:
-        raise ValueError("invalid_source_time") from None
-    if result.tzinfo is None or result.utcoffset() is None:
-        raise ValueError("invalid_source_time")
-    return result
-
-
-def reading_text(value: str) -> str:
-    # Presentation-only normalization. Keep parentheses, numbers and qualifiers.
-    return re.sub(r"\*\*|__|`", "", value)
-
-
-def source_basis(evidence: Mapping[str, Any]) -> dict[str, Any]:
-    value = {key: evidence[key] for key in (
-        "source", "session_id", "event_key", "message_id", "message_revision",
-        "source_time", "source_sequence",
-    ) if key in evidence and evidence[key] is not None}
-    if evidence.get("explicit_input") is not None:
-        from .explicit_text_source import validate_origin
-        origin = validate_origin(evidence["explicit_input"])
-        value.update(input_kind="explicit_text", origin_session_id=origin["session_id"],
-                     origin_turn_key=origin["turn_key"])
-    return value
-
-
-def selected_calendar(text: str, evidence: Mapping[str, Any]) -> dict[str, Any]:
-    """Return a lossless text/anchor projection plus an optional calendar date.
-
-    Pass a local *date* to the legacy calendar grammar, which otherwise converts
-    datetime anchors to UTC. A midnight-offset message must keep its source day.
-    No configured processing clock or capture time is used as a substitute.
-    """
-    if not isinstance(text, str) or not text.strip() or len(text) > 512:
-        raise ValueError("invalid_time_expression")
-    if reading_text(text) not in reading_text(str(evidence.get("text", ""))):
-        raise ValueError("unsupported_time_quote")
-    anchor = parse_source_time(evidence.get("source_time"))
-    local_day = anchor.date() if anchor is not None else None
-    view = reading_text(text)
-    converted = normalize_relative_calendar_text(view, local_day)
-    if local_day is None and not _RELATIVE_CALENDAR_EXPRESSION.search(view):
-        converted = view
-    tokens = calendar_tokens(converted if converted is not None else view, local_day)
-    dates = {token.canonical for token in tokens}
-    # Relative expressions which cannot be resolved must not borrow another date.
-    resolved = (converted is not None and bool(tokens)
-                and None not in dates and len(dates) == 1)
-    return {
-        "date": next(iter(dates)) if resolved else None,
-        "text": text,
-        "anchor": source_basis(evidence),
-        "status": "resolved" if resolved else "unresolved",
-    }