memleaf 0.2.54__tar.gz → 0.2.55__tar.gz

{memleaf-0.2.54 → memleaf-0.2.55}/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to memleaf are documented here.
 
+## 0.2.55 — 2026-09-14
+
+- Classify memory candidates by future reuse with a shorter B3 instruction: point-in-time counts and snapshots without a trend, threshold, obligation, decision or later comparison are `no_future_value`, while future-use facts remain eligible. Project ownership now has a conservative Core guard: an explicit single-project label cannot silently persist as `global`, but ordinary platform, product and vendor mentions still do not establish ownership. Self-contained memories refer to the conversation person as the user rather than as an owner. The B3 system prompt shrinks from 6395 to 5686 UTF-8 bytes.
+- Preserve candidate-local date authority while improving structured todo deadlines. A legal `whole_unit` claim continues through the existing binding validator as one canonical full-text quote; no second evidence path was added. Core fills `due_date` only when that candidate's own admitted user/assistant evidence establishes one unambiguous deadline, never from sibling evidence, and exposes ambiguous deadline counts in total, stage and operation metrics instead of guessing.
+- Normalize compact date-time text without corrupting adjacent content: a resolved ISO date next to a valid clock gains one separating space, existing spacing remains unchanged, and non-date words such as `本周日报` remain ordinary text. Deadline recognition uses boundary-safe English cues, accepts slash dates before sentence punctuation, and rejects word-suffix and decimal false positives.
+
+Verification for this release used eight local synthetic regression tests with no model call and no production Vault write. They cover whole-unit/exact-quote equivalence, candidate date isolation, date-time boundaries, future-value protocol outcomes, explicit-project/global conflicts, platform-only mentions, unique and ambiguous todo deadlines, deadline word boundaries and metric visibility. Python 3.11 compilation and imports pass, as does `git diff --check`. The repository intentionally ignores `/tests/`, so these local tests are not part of the source distribution; real-model adherence and a newly installed Hermes replay remain post-release runtime acceptance.
+
 ## 0.2.54 — 2026-09-14
 
 - Judge automatic memories by future reuse rather than speaker identity. Visible assistant final reports may establish facts learned from external sources, while transient tool failures, one-time fallbacks and routine checks with no issue or follow-up are `no_future_value`. The B3 system prompt and compact contract were rewritten rather than extended: together they shrink from 9469 to 9331 bytes, and the normal path still uses one model request.

{memleaf-0.2.54/src/memleaf.egg-info → memleaf-0.2.55}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 0.2.54
+Version: 0.2.55
 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.54。**
+> **版本：0.2.55。**
 > 记忆只从用户与 Agent 的可见对话提炼。Agent 已在回复中整理的事实、项目进展和明确待办可作为来源；邮件、附件、网页和终端等工具原文不进入记忆提炼。模型负责保留原话中的不确定性，现有记忆仅用于比较、去重和更新。Markdown 仍是唯一事实源。
 > **当前版本支持 Hermes 和 Codex。** Antigravity（反重力）不检测、不安装、不配置。
 

{memleaf-0.2.54 → memleaf-0.2.55}/README.en.md

@@ -4,7 +4,7 @@
 
 [中文](README.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **Version: 0.2.54.**
+> **Version: 0.2.55.**
 > Automatic extraction now uses only the current turn's visible user input and final assistant reply. Raw tool output, attachments, web/file/terminal payloads and legacy tool-evidence bodies are not new source evidence; existing or retrieved memory remains comparison context rather than source authority. Background processing is persisted as a local job and can be checked through the read-only `process_status` MCP tool; failed work remains retryable and fail closed. The release also tightens source/date grounding, target reconciliation, duplicate/no-op handling and semantic review before writes. Markdown remains the sole source of truth with no SQLite runtime dependency. Acceptance covers deterministic regression suites and synthetic inputs; it does not claim real-mail or customer-business acceptance.
 > **The current release supports Hermes and Codex.** Antigravity is not detected, installed, or configured.
 

{memleaf-0.2.54 → memleaf-0.2.55}/README.md

@@ -4,7 +4,7 @@
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **版本：0.2.54。**
+> **版本：0.2.55。**
 > 记忆只从用户与 Agent 的可见对话提炼。Agent 已在回复中整理的事实、项目进展和明确待办可作为来源；邮件、附件、网页和终端等工具原文不进入记忆提炼。模型负责保留原话中的不确定性，现有记忆仅用于比较、去重和更新。Markdown 仍是唯一事实源。
 > **当前版本支持 Hermes 和 Codex。** Antigravity（反重力）不检测、不安装、不配置。
 

{memleaf-0.2.54 → memleaf-0.2.55}/pyproject.toml

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

{memleaf-0.2.54 → memleaf-0.2.55}/src/memleaf/__init__.py

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

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

{memleaf-0.2.54 → memleaf-0.2.55}/src/memleaf/model_execution.py

@@ -56,7 +56,7 @@ _METRIC_EVENT_FIELDS = frozenset({
     # first two were emitted but silently dropped here, which made the
     # "visible rather than silent" claim in their release notes untrue.
     "b3_normalization_count", "b3_candidate_deferred_count",
-    "b3_ungrounded_scope_dropped_count",
+    "b3_ungrounded_scope_dropped_count", "b3_due_date_ambiguous_count",
 })
 _THINKING_OBSERVATION_SOURCES = frozenset({
     "request_parameter", "reasoning_tokens", "reasoning_content", "unavailable",
@@ -91,6 +91,7 @@ def _metric_bucket() -> dict[str, Any]:
         "b3_normalization_count": 0,
         "b3_candidate_deferred_count": 0,
         "b3_ungrounded_scope_dropped_count": 0,
+        "b3_due_date_ambiguous_count": 0,
         "_first_started": None,
         "_last_finished": None,
     }
@@ -515,6 +516,7 @@ class ModelExecutor:
             "repair_rejected_semantic_drift_count": int(bucket.get("repair_rejected_semantic_drift_count", 0)),
             "parse_accepted_count": int(bucket.get("parse_accepted_count", 0)),
             "decision_case_normalization_count": int(bucket.get("decision_case_normalization_count", 0)),
+            "b3_due_date_ambiguous_count": int(bucket.get("b3_due_date_ambiguous_count", 0)),
         }
         for field in _PROVIDER_METRIC_FIELDS:
             result[field] = int(bucket.get(field, 0))

{memleaf-0.2.54 → memleaf-0.2.55}/src/memleaf/process_common.py

@@ -16,6 +16,7 @@ from .llm import MODEL_ERROR_CODES, MODEL_VALIDATION_REASONS, ModelUnavailable
 from .locking import read_json
 from .models import Memory, utc_now
 from .retrieval import candidate_matches_query, normalize_term
+from .scope_state import project_scope_matches_text
 from .validation import MODEL_EVIDENCE_CHECKS, MODEL_VALIDATION_DETAILS, ModelOutputError, parse_strict_json, normalize_relative_calendar_text, safe_evidence_context, safe_schema_context
 
 _PROCESSING_LEASE_SECONDS = 3600
@@ -73,6 +74,26 @@ _SUMMARY_CHINESE_CALENDAR_DATE_RE = re.compile(
     r"(?![A-Za-z\d])"
 )
 
+_SLASH_CALENDAR_DATE_RE = re.compile(
+    r"(?<![\d./-])(?:(?P<year>\d{4})/)?(?P<month>\d{1,2})/(?P<day>\d{1,2})(?![\d/-]|\.\d)"
+)
+_DEADLINE_PREFIX_RE = re.compile(
+    r"(?:截止(?:日期|时间)?|截至(?:日期|时间)?|不晚于|不得晚于|\bdeadline\b|\bdue(?:\s+date)?\b|\bby\b|\bbefore\b)"
+    r"\s*(?:为|是|[:：])?\s*$",
+    re.IGNORECASE,
+)
+_DEADLINE_SUFFIX_RE = re.compile(
+    r"^\s*(?:(?:[01]?\d|2[0-3]):[0-5]\d\s*)?(?:前|之前|为止|截止|截至|不晚于|不得晚于|before\b|deadline\b|due\b)",
+    re.IGNORECASE,
+)
+_EXPLICIT_PROJECT_LABEL_RE = re.compile(
+    r"(?<![A-Za-z0-9_])project\s*:\s*(?P<colon>[^\s,，;；。！？:：]{1,64})"
+    r"|(?<![A-Za-z0-9_])project\s+(?P<english>[^\s,，;；。！？:：]{1,64})\s*[:：—–-]"
+    r"|(?:^|[\s(（\[{,，])项目\s*[:：]\s*(?P<chinese>[^\s,，;；。！？:：]{1,64})"
+    r"|(?:^|[\s(（\[{,，])(?P<suffix>[^\s,，;；。！？:：]{1,64})\s*项目\s*[:：]",
+    re.IGNORECASE,
+)
+
 
 
 
@@ -141,6 +162,71 @@ def _project_scope_occurrences(
     return selected
 
 
+def _explicit_project_scope_labels(
+    texts: Iterable[Any],
+    scope_registry: Mapping[str, Any] | None,
+) -> list[str]:
+    """Find project scopes explicitly written as project labels in candidate text.
+
+    A registered project name appearing as an ordinary noun is insufficient;
+    this recognizes only explicit forms such as ``project:Alpha`` or
+    ``Alpha 项目``. It supports a conservative global-scope guard without
+    treating a platform, product, or vendor mention as ownership.
+    """
+
+    rows = [text for text in texts if isinstance(text, str) and text.strip()]
+    if not rows:
+        return []
+    registry = scope_registry if isinstance(scope_registry, Mapping) else {}
+    try:
+        matches = {
+            scope
+            for text in rows
+            for scope in project_scope_matches_text(text, {"scopes": registry})
+        }
+    except (TypeError, ValueError):
+        return []
+    labeled: set[str] = set()
+    for scope in matches:
+        node = registry.get(scope)
+        terms = [scope.partition(":")[2]]
+        if isinstance(node, Mapping) and isinstance(node.get("aliases"), list):
+            terms.extend(value for value in node["aliases"] if isinstance(value, str))
+        for text in rows:
+            for raw_term in terms:
+                term = re.sub(r"\\\s+", r"\\s+", re.escape(raw_term.strip()))
+                if not term:
+                    continue
+                patterns = (
+                    rf"(?<![A-Za-z0-9_])project\s*:\s*{term}(?![A-Za-z0-9_])",
+                    rf"(?<![A-Za-z0-9_])project\s+{term}(?![A-Za-z0-9_])",
+                    rf"(?:^|[\s(（\[,，:：])项目\s*[:：]?\s*{term}(?=$|[\s，。,:：\-—])",
+                    rf"(?:^|[\s(（\[,，:：]){term}\s*(?:项目|project)(?=$|[\s，。,:：\-—])",
+                )
+                if any(re.search(pattern, text, re.IGNORECASE) for pattern in patterns):
+                    labeled.add(scope)
+                    break
+            if scope in labeled:
+                break
+    for text in rows:
+        for match in _EXPLICIT_PROJECT_LABEL_RE.finditer(text):
+            raw_name = next((value for value in match.groupdict().values() if value), "")
+            if not raw_name:
+                continue
+            try:
+                resolved = project_scope_matches_text(raw_name, {"scopes": registry})
+            except (TypeError, ValueError):
+                resolved = []
+            if len(resolved) == 1:
+                labeled.add(resolved[0])
+            else:
+                # An explicit but unregistered project label is still enough
+                # to reject a silent global attribution; the candidate is
+                # deferred because Core must not invent the project's scope.
+                labeled.add("project-label:" + raw_name.casefold())
+    return sorted(labeled, key=str.casefold)
+
+
 def _automatic_read_only_query(events: Iterable[Mapping[str, Any]]) -> bool:
     return read_only_turn(analyze_turn_evidence(events))
 
@@ -867,6 +953,72 @@ def _grounded_due_dates(
     return result
 
 
+def _grounded_deadline_dates(
+    evidence_events: Iterable[Mapping[str, Any]],
+) -> set[str]:
+    """Return only dates explicitly tied to a deadline in this evidence set.
+
+    Relative dates use the cited event's own timestamp. Yearless calendar dates
+    use that same timestamp only when one is available. No other turn content
+    or retrieval timestamp participates.
+    """
+
+    result: set[str] = set()
+    for event in evidence_events:
+        if not isinstance(event, Mapping) or event.get("role") not in {"user", "assistant"}:
+            continue
+        content = event.get("content")
+        if not isinstance(content, str) or not content:
+            continue
+        timestamp = _parse_time(event.get("timestamp"))
+        text = normalize_relative_calendar_text(content, timestamp) if timestamp is not None else content
+        if text is None:
+            text = content
+        tokens: list[tuple[int, int, str]] = []
+
+        for match in _ISO_CALENDAR_DATE_RE.finditer(text):
+            try:
+                canonical = datetime.strptime(match.group(1), "%Y-%m-%d").date().isoformat()
+            except ValueError:
+                continue
+            tokens.append((match.start(), match.end(), canonical))
+
+        for match in _SUMMARY_CHINESE_CALENDAR_DATE_RE.finditer(text):
+            try:
+                year = int(match.group("year")) if match.group("year") else (
+                    timestamp.year if timestamp is not None else None
+                )
+                if year is None:
+                    continue
+                canonical = datetime(
+                    year, int(match.group("month")), int(match.group("day")), tzinfo=timezone.utc
+                ).date().isoformat()
+            except ValueError:
+                continue
+            tokens.append((match.start(), match.end(), canonical))
+
+        for match in _SLASH_CALENDAR_DATE_RE.finditer(text):
+            try:
+                year = int(match.group("year")) if match.group("year") else (
+                    timestamp.year if timestamp is not None else None
+                )
+                if year is None:
+                    continue
+                canonical = datetime(
+                    year, int(match.group("month")), int(match.group("day")), tzinfo=timezone.utc
+                ).date().isoformat()
+            except ValueError:
+                continue
+            tokens.append((match.start(), match.end(), canonical))
+
+        for start, end, canonical in tokens:
+            prefix = text[max(0, start - 32):start]
+            suffix = text[end:end + 24]
+            if _DEADLINE_PREFIX_RE.search(prefix) or _DEADLINE_SUFFIX_RE.search(suffix):
+                result.add(canonical)
+    return result
+
+
 def _native_result(value: Any) -> list[dict[str, Any]]:
     if value is None:
         return []

{memleaf-0.2.54 → memleaf-0.2.55}/src/memleaf/single_pass_memory_planner.py

@@ -24,6 +24,8 @@ from .process_common import (
     ProcessingError,
     _automatic_create_conflicts,
     _event_payload,
+    _explicit_project_scope_labels,
+    _grounded_deadline_dates,
     _grounded_due_dates,
     _normalize_summary_dates,
     _summary_date_grounding_violations,
@@ -58,7 +60,7 @@ def _claim_date_evidence(
     by_unit: Mapping[str, Any],
     events: Iterable[Mapping[str, Any]],
 ) -> list[dict[str, Any]]:
-    """Project dates from this candidate's exact validated quotes only."""
+    """Project dates from this candidate's canonical validated exact quotes only."""
 
     event_by_key = {
         event.get("event_key"): event
@@ -73,7 +75,7 @@ def _claim_date_evidence(
         unit_id = claim.get("unit_id")
         quote = claim.get("quote")
         unit = by_unit.get(unit_id) if isinstance(unit_id, str) else None
-        if not isinstance(quote, str) or unit is None:
+        if not isinstance(quote, str) or not quote or unit is None:
             continue
         event = event_by_key.get(getattr(unit, "event_key", None))
         if event is None or getattr(unit, "source_role", None) not in {"user", "assistant"}:
@@ -83,6 +85,7 @@ def _claim_date_evidence(
             continue
         seen.add(identity)
         result.append({
+            "unit_id": unit_id,
             "event_key": getattr(unit, "event_key", None),
             "role": getattr(unit, "source_role", None),
             "timestamp": event.get("timestamp"),
@@ -91,6 +94,48 @@ def _claim_date_evidence(
     return result
 
 
+def _fill_unambiguous_todo_deadline(
+    memory_type: Any,
+    summary: Mapping[str, Any],
+    deadline_dates: Iterable[str],
+) -> tuple[dict[str, Any], bool]:
+    """Fill an omitted todo date only when candidate evidence proves one deadline."""
+
+    normalized = dict(summary)
+    dates = {value for value in deadline_dates if isinstance(value, str)}
+    if memory_type != "todo" or normalized.get("due_date") is not None:
+        return normalized, False
+    if len(dates) == 1:
+        normalized["due_date"] = next(iter(dates))
+        return normalized, False
+    return normalized, len(dates) > 1
+
+
+def _global_scope_conflicts_with_candidate_evidence(
+    scopes: Iterable[Any],
+    candidate_evidence: Iterable[Mapping[str, Any]],
+    by_unit: Mapping[str, Any],
+    scope_registry: Mapping[str, Any] | None,
+) -> bool:
+    """Detect a global choice contradicted by one explicit project label."""
+
+    scope_values = {value.casefold() for value in scopes if isinstance(value, str)}
+    if "global" not in scope_values or any(value.startswith("project:") for value in scope_values):
+        return False
+    texts: list[str] = []
+    for event in candidate_evidence:
+        if not isinstance(event, Mapping):
+            continue
+        unit = by_unit.get(event.get("unit_id"))
+        section_path = getattr(unit, "section_path", ())
+        if isinstance(section_path, (list, tuple)):
+            texts.extend(value for value in section_path if isinstance(value, str))
+        content = event.get("content")
+        if isinstance(content, str):
+            texts.append(content)
+    return len(_explicit_project_scope_labels(texts, scope_registry)) == 1
+
+
 class SinglePassMemoryPlanner(MemoryPlanner):
     """One semantic model call for an ordinary automatic turn."""
 
@@ -388,6 +433,7 @@ class SinglePassMemoryPlanner(MemoryPlanner):
         no_memory_by_unit: dict[str, str] = {}
         observed_scopes: list[str] = []
         requests: list[dict[str, Any]] = []
+        ambiguous_todo_deadlines: set[str] = set()
 
         if not planning_units:
             self._finalize_evidence_audit(
@@ -481,6 +527,18 @@ class SinglePassMemoryPlanner(MemoryPlanner):
             }
             if decision == "UPDATE" and isinstance(target_id, str):
                 candidate["update_memory_id"] = target_id
+
+            candidate_evidence = _claim_date_evidence(claims, by_unit, events)
+            if _global_scope_conflicts_with_candidate_evidence(
+                scopes, candidate_evidence, by_unit, validation_scope_registry
+            ):
+                # The evidence explicitly labels one project, but Core cannot
+                # safely rewrite the model's chosen scope. Defer only this
+                # candidate rather than persist it globally.
+                raise ModelOutputError(
+                    "global scope conflicts with an explicit project label",
+                    validation_detail="scope_not_grounded",
+                )
             if decision in {"CREATE", "UPDATE"} and not _model_project_scope_is_source_grounded(
                 candidate,
                 planning_units,
@@ -538,8 +596,10 @@ class SinglePassMemoryPlanner(MemoryPlanner):
                 event["event_key"] for event in admitted_events
                 if isinstance(event, Mapping) and isinstance(event.get("event_key"), str)
             ))
-            candidate_date_evidence = _claim_date_evidence(claims, by_unit, events)
+            candidate_date_evidence = candidate_evidence
             grounded_dates = _grounded_due_dates(turn, evidence_events=candidate_date_evidence)
+            deadline_dates = _grounded_deadline_dates(candidate_date_evidence)
+            grounded_dates.update(deadline_dates)
             summary = dict(proposed)
             if decision == "UPDATE" and target_memory is not None:
                 summary.setdefault("title", target_memory.title)
@@ -551,6 +611,11 @@ class SinglePassMemoryPlanner(MemoryPlanner):
                 summary["update_memory_id"] = target_memory.memory_id
             else:
                 summary.setdefault("tags", [])
+            summary, deadline_is_ambiguous = _fill_unambiguous_todo_deadline(
+                memory_type, summary, deadline_dates
+            )
+            if deadline_is_ambiguous:
+                ambiguous_todo_deadlines.add(candidate_id)
             summary["type"] = memory_type
             summary["scopes"] = scopes
             if isinstance(scope_source, str) and scope_source:
@@ -574,7 +639,7 @@ class SinglePassMemoryPlanner(MemoryPlanner):
                 expected_target_type=target_memory.type if target_memory is not None else None,
                 expected_scopes=scopes,
                 expected_scope_source=scope_source if isinstance(scope_source, str) else None,
-                allowed_due_dates=grounded_dates,
+                allowed_due_dates=(deadline_dates or grounded_dates),
                 allow_no_change=False,
                 allow_update_target=target_memory is not None,
             )
@@ -619,6 +684,15 @@ class SinglePassMemoryPlanner(MemoryPlanner):
             },
         )
 
+        if ambiguous_todo_deadlines:
+            metric = getattr(self.model, "_record_metric_event", None)
+            if callable(metric):
+                for _ in ambiguous_todo_deadlines:
+                    metric(
+                        {"stage": "single_pass", "operation": "single_pass_primary"},
+                        "b3_due_date_ambiguous_count",
+                    )
+
         fallback_scopes, fallback_scope_source = self._fallback_scopes(scope_background)
         for row in result["items"]:
             candidate_id = row["candidate_id"]

{memleaf-0.2.54 → memleaf-0.2.55}/src/memleaf/single_pass_plan.py

@@ -142,16 +142,14 @@ SOURCE
 Use current_evidence only. User messages and assistant final reports may support facts, including facts obtained from external sources. Do not turn your own advice, plans or inferences into user intent unless accepted. Never invent facts, dates, numbers, ownership or IDs. local_memory_catalog is comparison context; native memory is never an UPDATE/NO_CHANGE target.
 
 TASK
-Keep independently retrievable facts useful for future answers, actions, commitments, status tracking or avoiding repeated research. Prefer stable facts, decisions, open work and deadlines; skip transient tool/execution failures, one-time fallbacks and routine checks with no issue or follow-up (no_future_value). Preserve future-use facts in final reports and keep independent topics separate. Preserve entity, condition, polarity, uncertainty, ownership, state and meaning-critical numbers/codes. CREATE only if no local memory represents the information; UPDATE only for a proven change to one target; NO_CHANGE only for the same future-use item with no semantic change; DEFERRED for an unsafe terminal decision. Scope ownership separately from platform/system names. Do not use NO_CHANGE to hide ambiguity.
+Keep independently retrievable facts useful for future answers, actions, commitments, status tracking or avoiding repeated research. Prefer stable facts, decisions, open work and deadlines; skip transient failures, one-time fallbacks, routine checks with no follow-up, and point-in-time counts or snapshots unless needed for a trend, threshold, obligation, decision or later comparison. Preserve future-use facts in final reports and keep independent topics separate. Preserve entity, condition, polarity, uncertainty, ownership, state and meaning-critical numbers/codes. Use self-contained wording; call the conversation person “the user” (用户), never “owner” (主人). CREATE only if no local memory represents the information; UPDATE only for a proven change to one target; NO_CHANGE only for the same future-use item with no semantic change; DEFERRED for an unsafe terminal decision. Do not use NO_CHANGE to hide ambiguity.
 
 SCOPES
 Legal values: global | domain:<name> | portfolio:<name> | project:<name> | unscoped. scopes is a nonempty array; at most one project:<name> per memory; unscoped must be the only value, and Core then records insufficient_context.
-When a candidate concerns one distinct project the user is working on -- a type=project memory, or the work, decisions, state or deadlines that belong to that project -- scope it to that project as project:<name>, using the name the evidence itself uses. The project does not need to be registered first; scope_registry only lists what already exists.
-Ground the name in this candidate's own cited evidence, or in a project scope explicitly supplied for this turn. Never edit, translate or combine the evidence's words into a name that does not appear there, and choose the shortest term that does appear and names the project: the thing described as "记账的小玩意儿" is project:记账, not project:记账小玩意儿 and not project:记账的小玩意儿. An ungrounded name is rejected and its memory is deferred instead of written. A product, platform, system, vendor, notification source, comparison or implementation context is not ownership by name alone.
-Use global only for a fact that no single project owns: a standing personal preference, a machine-wide or tool-wide rule, or an environment fact. Never invent, translate or borrow a project name.
+Scope to one project only when this candidate's evidence identifies it as owner of the work, decision, state or deadline; use a name present in that evidence, whether or not registered. A platform, product or vendor mention alone is not ownership; defer when ownership is unclear. Use global for cross-project facts, standing preferences and environment-wide rules.
 
 DATES
-An evidence unit may carry an ISO-8601 UTC timestamp. Use it ONLY to resolve a relative, partial or yearless date that the unit's own text expresses; never borrow another unit's timestamp and never guess a missing year. The timestamp is an anchor, not content: never write its own date into a memory, and add no date the evidence text does not state. A date literal in a memory must appear in that memory's cited evidence, either verbatim or as the same month and day. Write due_date as YYYY-MM-DD. A todo declares status, and due_date only when its own evidence establishes a deadline: otherwise omit due_date, or set it to null when the deadline itself is still unresolved. Any memory carrying a date that no admitted evidence grounds is rejected and costs the whole turn, so defer instead of approximating.
+An evidence unit may carry an ISO-8601 UTC timestamp. Use it ONLY to resolve a relative, partial or yearless date that the unit's own text expresses; never borrow another unit's timestamp and never guess a missing year. The timestamp is an anchor, not content: never write its own date into a memory, and add no date the evidence text does not state. A date literal in a memory must appear in that memory's cited evidence, either verbatim or as the same month and day. Write due_date as YYYY-MM-DD; a todo with one unambiguous evidence-grounded deadline must include it. Omit due_date when no deadline is stated or it cannot be resolved. Any memory carrying a date that no admitted evidence grounds is rejected and costs the whole turn, so defer instead of approximating.
 
 {B3_COMPACT_CONTRACT}"""
 

{memleaf-0.2.54 → memleaf-0.2.55}/src/memleaf/validation.py

@@ -364,6 +364,9 @@ _ISO_CALENDAR_DATE = re.compile(
     r"(?<![A-Za-z\d./-])\d{4}-(?:0?[1-9]|1[0-2])-(?:0?[1-9]|[12]\d|3[01])"
     r"(?![A-Za-z\d./-])"
 )
+_ISO_DATE_FOLLOWED_BY_CLOCK = re.compile(
+    r"(?P<date>\d{4}-\d{2}-\d{2})(?=(?:[01]?\d|2[0-3]):[0-5]\d(?::[0-5]\d)?(?!\d))"
+)
 _EMPTY_ISO_DATE_PARENTHESIS = re.compile(
     r"(?P<date>\d{4}-(?:0?[1-9]|1[0-2])-(?:0?[1-9]|[12]\d|3[01]))"
     r"[ \t]*(?:\([ \t]*[)）]|（[ \t]*[)）])"
@@ -605,6 +608,18 @@ def _normalize_relative_calendar_text(
     normalized = _RELATIVE_CALENDAR_EXPRESSION.sub(replace_token, text)
     if relative_replaced:
         normalized = _collapse_duplicate_calendar_dates(normalized)
+    # A relative date can be adjacent to a clock in compact source text (for
+    # example, "today10:30"). Keep the date and time as separate values after
+    # normalization, while leaving already-spaced dates unchanged.
+    def separate_date_from_clock(match: re.Match[str]) -> str:
+        value = match.group("date")
+        try:
+            datetime.strptime(value, "%Y-%m-%d")
+        except ValueError:
+            return match.group(0)
+        return value + " "
+
+    normalized = _ISO_DATE_FOLLOWED_BY_CLOCK.sub(separate_date_from_clock, normalized)
     normalized = _strip_empty_iso_date_parenthesis(normalized)
     return normalized, safe
 

{memleaf-0.2.54 → memleaf-0.2.55/src/memleaf.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 0.2.54
+Version: 0.2.55
 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.54。**
+> **版本：0.2.55。**
 > 记忆只从用户与 Agent 的可见对话提炼。Agent 已在回复中整理的事实、项目进展和明确待办可作为来源；邮件、附件、网页和终端等工具原文不进入记忆提炼。模型负责保留原话中的不确定性，现有记忆仅用于比较、去重和更新。Markdown 仍是唯一事实源。
 > **当前版本支持 Hermes 和 Codex。** Antigravity（反重力）不检测、不安装、不配置。