memleaf 0.2.47__tar.gz → 0.2.49__tar.gz

{memleaf-0.2.47 → memleaf-0.2.49}/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 All notable changes to memleaf are documented here.
 
+## 0.2.49 — 2026-09-13
+
+- Restore candidate-local deferral to the B3 single-pass path. v0.2.26 established that an invalid proposal receives bounded model correction and then explicit candidate-local deferral while "valid siblings proceed", and v0.2.34 required that "candidate-local deferral and idempotent partial retries" be preserved so unresolved ownership, target, evidence or timing never fabricates a write. The B3 planner had lost that property: the first proposal Core rejected raised out of the parser and discarded every other verdict in the turn, so one model slip cost the whole turn even when six other candidates were sound. A proposal that Core can attribute to a single candidate is now deferred with a B3 defer reason and the rest of the turn still commits. Nothing is written for a deferred candidate, no extra model call is made, and the turn stays retryable with its already-settled units intact.
+- Keep the deferral boundary narrow and explicit. Only details that describe the candidate itself are converted: scope authorisation and update-target problems map to `scope_ambiguous` and `target_ambiguous`, while a malformed proposal (todo fields, ungrounded or malformed dates, type, source shape) maps to `maintenance_uncertain` and missing admitted evidence maps to `evidence_insufficient`. Every other failure — transport, truncation, envelope shape, evidence coverage, binding scope, and any detail Core does not recognise — still fails the whole turn closed, so a systemic fault cannot hide behind a deferral.
+- Make the deferral visible rather than silent. Each one is counted as `b3_candidate_deferred_count` on the turn, the cause is recorded against the candidate, and the deferred work continues to surface through `deferred_candidates`, `retryable_deferred_turns` and `coverage_status: partial` in the read-only processing status. The persisted cause is restricted to a bounded identifier so no model text can reach state files.
+- Keep the deferral from being mistaken for a collision. Same-target reconciliation groups items that reach a terminal disposition for one memory, and a deferred candidate reaches none: it writes nothing, carries no update target, and cannot conflict with an admitted update to the same memory. Only the candidates that actually reach UPDATE or NO_CHANGE are grouped now, so a turn that updates one memory and defers another does not spend its second request reconciling a candidate that was never admitted.
+
+Verification for this release repeated the same real-model replay used for 0.2.48 and added focused synthetic tests: 90 tests pass with no model call, covering the sibling-commits case, every deferrable detail and the reason it maps to, deferral being driven by an explicit allowlist, the optional argument for direct parser callers, a deferred member not being grouped as a same-target collision, and the turn-level failures that must still abort. Three further preview runs of the previously failing production session completed with `execution_status: ok` and `coverage_status: complete`. A deferral is a visible degradation rather than a success: the candidate is retried, not written, and a prompt or configuration fault that made every proposal invalid would now show up as a fully deferred turn rather than as a hard failure.
+
+## 0.2.48 — 2026-09-13
+
+- Restore same-target reconciliation in the B3 single-pass path. A real turn was discarded with `B3 target referenced more than once` whenever the model admitted two changes for one existing memory. One memory can only receive one terminal disposition per turn, because the writer archives the previous version and overwrites the same file, so the colliding items are now reconciled with one bounded call into a single current state and an unresolvable group is deferred as `target_ambiguous` instead of guessed. This is the capability the legacy staged path already had; it is not a new retry class, and the compact contract now tells the model to merge such changes into one UPDATE in the first place. The call is charged against the same two-request turn budget as the primary extraction and its structural repair, so a collision can never lengthen a turn: when a repair has already spent the budget, the group defers and every other item still commits. The strict "a target may be used once" rejection remains in the parser for direct callers.
+- Give the B3 planner the temporal anchor it was always assumed to have. The prompt contract promised that "an admitted visible-message timestamp may anchor a supported relative date" and Core grounded `due_date` against exactly that timestamp, but the evidence projection never showed it to the model. A yearless deadline such as "9 月 30 号" was therefore unanswerable: the model guessed a year, and the grounded-date gate correctly rejected the entire turn. Each projected evidence unit now carries its own event timestamp, a `DATES` section states that the anchor resolves only dates the unit's own text expresses, and a timestamp's own date is never content.
+- Stop treating a reworded yearless date as an invented one. Grounding compared raw surface text, so a faithful restatement of a source date that only changed its suffix, such as 号 -> 日, was rejected as ungrounded and cost the whole turn. A yearless date is now recognised by its month and day, which is the property the guard actually protects: no year is ever inferred, and a different month, day or full date is still refused.
+- State that `status`, `completed_at` and `due_date` are todo-only in the compact contract. The validator has always rejected a `status` on any other type, but the model was never told, so a correct-looking extraction failed with `invalid todo status`; the contract now also states that a todo UPDATE restates its status and that `completed` and `completed_at` require each other.
+- Resolve one bookkeeping contradiction instead of discarding the turn. A unit listed both as an item's evidence and as `no_memory` is self-contradictory, and the resolution is forced: an item already bound the unit, so the unit is not a no-memory unit. The redundant row is dropped, counted as `b3_normalization_count`, and no memory content, scope or evidence binding changes. Genuine omissions still fail closed as incomplete evidence coverage.
+- Stop the single-pass budget wrapper from erasing protocol capability. `SinglePassBudgetBackend` delegates by attribute name, and `ModelRouter` had gained `single_pass_safe` without `single_pass_protocol`, so a wrapped route that does speak `b3-single-pass-v1` read as incapable and every automatic turn failed in 0.000s with zero model calls. The router now answers both properties from the same resolved route.
+- Keep a clipped native memory from making the lookup look incomplete. Native sources are comparison context and can never be an UPDATE or NO_CHANGE target, but a native body shortened for the prompt budget was recorded as a dropped item and marked `lookup_complete=false`, which blocked every terminal decision in the turn. Only an item that is actually discarded for the budget can affect completeness now, and the prompt-length budget itself is unchanged.
+
+Verification for this release combined focused synthetic tests with one real-model replay. 84 tests pass with no model call, covering same-target reconciliation (merge, no-change, deferral, re-validation, evidence union, and a route-level assertion that a third provider request is never issued), the date anchor projection, yearless-date identity, the todo-field contract, redundant-row normalization, the wrapper capability properties and native clipping completeness. The real replay ran the previously failing production session against `deepseek-flash`: before these fixes every attempt failed in the planner, and after them five consecutive preview runs completed with `execution_status: ok` (four `coverage_status: complete`, one partial with a single deferred candidate), and the committed run wrote five memories into the live Vault with a todo carrying `status: active` and the correct grounded `due_date`. A single-candidate semantic rejection from the model still fails its turn closed; restoring per-candidate deferral or semantic retries for that case would be a deliberate design change and was not made here.
+
 ## 0.2.47 — 2026-09-12
 
 - Fix two satisfiability deadlocks in the public candidate filter that made every compound query carrying a punctuation-rich identifier return no_match. Word splitting turns `vX.Y.Z` into `vX` / `Y` / `Z`; those one-character fragments were collected as *required* ASCII components while the matching rule refused to treat anything shorter than three characters as a strong match, so the requirement could never be met. A fixed three-character bar had the same effect on a two-character CJK component whenever an ASCII component was present. A component that cannot reach its own bar no longer creates a requirement, and a CJK component's bar never exceeds its own length. Identifier strictness is unchanged: a short fragment still cannot stand in for a longer topic.

{memleaf-0.2.47/src/memleaf.egg-info → memleaf-0.2.49}/PKG-INFO

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

{memleaf-0.2.47 → memleaf-0.2.49}/README.en.md

@@ -4,7 +4,7 @@
 
 [中文](README.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **Version: 0.2.47.**
+> **Version: 0.2.49.**
 > 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.47 → memleaf-0.2.49}/README.md

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

{memleaf-0.2.47 → memleaf-0.2.49}/pyproject.toml

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

{memleaf-0.2.47 → memleaf-0.2.49}/src/memleaf/__init__.py

@@ -1,6 +1,6 @@
 """Local-first Markdown memory core for AI agents."""
 
-__version__ = "0.2.47"
+__version__ = "0.2.49"
 
 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.47 → memleaf-0.2.49}/src/memleaf/extraction_budget.py

@@ -24,6 +24,9 @@ class SinglePassBudgetBackend:
     hidden host-to-API fallback. The optional durable reservation preserves
     consumed attempts across worker restarts. Neither the first request nor
     its repair overrides the transport's configured ``llm.request_timeout``.
+    The second request is spent on whichever bounded follow-up the planner
+    actually needs -- a structural repair or a same-target reconciliation --
+    so a collision between two admitted items can never extend the turn.
     """
 
     def __init__(

{memleaf-0.2.47 → memleaf-0.2.49}/src/memleaf/hermes_provider/plugin.yaml

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

{memleaf-0.2.47 → memleaf-0.2.49}/src/memleaf/llm/router.py

@@ -84,6 +84,22 @@ class ModelRouter:
             return getattr(self.api, "single_pass_safe", False) is True
         return False
 
+    @property
+    def single_pass_protocol(self) -> bool:
+        """Expose B3 protocol capability symmetrically with ``single_pass_safe``.
+
+        Request-budget wrappers forward capability by attribute name.  A router
+        that exposed only ``single_pass_safe`` therefore read as protocol
+        incapable the moment it was wrapped, which made automatic extraction
+        fail on exactly the routes that were safe enough to be wrapped.
+        """
+
+        if self.mode == "api":
+            return getattr(self.api, "single_pass_protocol", False) is True
+        if self.mode == "auto" and self.host is None:
+            return getattr(self.api, "single_pass_protocol", False) is True
+        return False
+
     @staticmethod
     def _coerce_host(value: Any) -> Optional[ModelBackend]:
         if value is None:

{memleaf-0.2.47 → memleaf-0.2.49}/src/memleaf/planning_context.py

@@ -315,17 +315,36 @@ class PlanningContext:
         selected: list[dict[str, Any]] = []
         used = 2
         complete = True
-        for value in values:
-            if len(selected) >= _RELATED_MAX_ITEMS:
+
+        def _drop(item: Mapping[str, Any]) -> None:
+            """Record one related record that could not be projected verbatim.
+
+            ``complete`` answers one question only: can Core still prove that no
+            **local** record was withheld, so that an absent UPDATE target and a
+            create-safe lookup remain provable?  Native sources are read-only
+            host files that are never an UPDATE or NO_CHANGE target and are only
+            ever referenced through ``shadow_native_ids``, so clipping one must
+            not make the whole lookup unprovable.  Treating a long host memory
+            file as a failed proof would block every automatic extraction with no
+            way for the user to recover except shrinking a file they own.
+            """
+
+            nonlocal complete
+            if item.get("native") is not True:
                 complete = False
+
+        for index, value in enumerate(values):
+            if len(selected) >= _RELATED_MAX_ITEMS:
+                for item in values[index:]:
+                    _drop(item)
                 break
             body = value.get("body")
             if isinstance(body, str) and len(body) > _RELATED_MAX_BODY_CHARS:
                 value["body"] = body[: _RELATED_MAX_BODY_CHARS - 1].rstrip() + "…"
-                complete = False
+                _drop(value)
             size = cls._related_payload_size(value)
             if size < 0:
-                complete = False
+                _drop(value)
                 continue
             additional = size + (1 if selected else 0)
             if used + additional > _RELATED_MAX_CHARS:
@@ -334,7 +353,7 @@ class PlanningContext:
                     isinstance(memory_id, str)
                     and memory_id.casefold() in priority
                 ):
-                    complete = False
+                    _drop(value)
                     continue
                 minimal = {
                     key: value[key]
@@ -343,15 +362,13 @@ class PlanningContext:
                 }
                 size = cls._related_payload_size(minimal)
                 if size < 0 or used + size + (1 if selected else 0) > _RELATED_MAX_CHARS:
-                    complete = False
+                    _drop(value)
                     continue
                 value = minimal
                 additional = size + (1 if selected else 0)
-                complete = False
+                _drop(value)
             selected.append(value)
             used += additional
-        if len(selected) != len(values):
-            complete = False
         return selected, complete
 
     @classmethod

{memleaf-0.2.47 → memleaf-0.2.49}/src/memleaf/process_common.py

@@ -683,16 +683,19 @@ def _add_external_due_dates(result: set[str], content: Any) -> None:
         result.add(parsed.isoformat())
 
 
-def _summary_calendar_tokens(content: Any) -> tuple[tuple[str, str | None], ...]:
-    """Return source-neutral calendar literals and canonical full dates.
+def _summary_calendar_tokens(content: Any) -> tuple[tuple[str, str | None, str | None], ...]:
+    """Return source-neutral calendar literals, canonical dates and month/day.
 
     A ``None`` canonical value is intentional for yearless or invalid text;
-    callers must not fill its year from a retrieval timestamp.
+    callers must not fill its year from a retrieval timestamp.  The third item
+    is the yearless ``MM-DD`` identity of a token that carries no year, so a
+    faithful restatement of the same month and day can be recognized without
+    ever granting that token a year.
     """
 
     if not isinstance(content, str):
         return ()
-    tokens: list[tuple[str, str | None]] = []
+    tokens: list[tuple[str, str | None, str | None]] = []
     seen: set[str] = set()
     for raw in _ISO_CALENDAR_DATE_RE.findall(content):
         if raw in seen:
@@ -702,27 +705,25 @@ def _summary_calendar_tokens(content: Any) -> tuple[tuple[str, str | None], ...]
             canonical = datetime.strptime(raw, "%Y-%m-%d").date().isoformat()
         except ValueError:
             canonical = None
-        tokens.append((raw, canonical))
+        tokens.append((raw, canonical, None))
     for match in _SUMMARY_CHINESE_CALENDAR_DATE_RE.finditer(content):
         raw = match.group("raw")
         if raw in seen:
             continue
         seen.add(raw)
         year = match.group("year")
+        month = int(match.group("month"))
+        day = int(match.group("day"))
         try:
             canonical = (
-                datetime(
-                    int(year),
-                    int(match.group("month")),
-                    int(match.group("day")),
-                    tzinfo=timezone.utc,
-                ).date().isoformat()
+                datetime(year and int(year), month, day, tzinfo=timezone.utc).date().isoformat()
                 if year
                 else None
             )
         except ValueError:
             canonical = None
-        tokens.append((raw, canonical))
+        monthday = f"{month:02d}-{day:02d}" if 1 <= month <= 12 and 1 <= day <= 31 else None
+        tokens.append((raw, canonical, monthday))
     return tuple(tokens)
 
 
@@ -738,7 +739,9 @@ def _summary_date_grounding_violations(
     ``grounded_dates`` is the canonical date set from the current admitted
     evidence. ``source_texts`` must contain only the current candidate's
     admitted evidence projection text.  A source date without a year may be
-    retained verbatim, but it never authorizes a year to be inferred.
+    retained verbatim, but it never authorizes a year to be inferred; the same
+    month and day restated in another surface form is still that source date,
+    because the guard forbids inventing a year, not rewording a suffix.
     ``preserved_texts`` must contain only the selected update target's existing
     title/body/due-date text.  Existing target literals may be retained
     verbatim; dates from unrelated memories are never accepted.
@@ -761,33 +764,45 @@ def _summary_date_grounding_violations(
             allowed_dates.add(value)
 
     source_tokens: set[str] = set()
+    source_monthdays: set[str] = set()
     source_values = (source_texts,) if isinstance(source_texts, str) else source_texts
     for text in source_values:
-        for raw, canonical in _summary_calendar_tokens(text):
+        for raw, canonical, monthday in _summary_calendar_tokens(text):
             source_tokens.add(raw)
+            if monthday is not None and canonical is None:
+                source_monthdays.add(monthday)
             if canonical is not None:
                 allowed_dates.add(canonical)
 
     preserved_tokens: set[str] = set()
+    preserved_monthdays: set[str] = set()
     preserved_values = (preserved_texts,) if isinstance(preserved_texts, str) else preserved_texts
     for text in preserved_values:
-        for raw, canonical in _summary_calendar_tokens(text):
+        for raw, canonical, monthday in _summary_calendar_tokens(text):
             preserved_tokens.add(raw)
+            if monthday is not None and canonical is None:
+                preserved_monthdays.add(monthday)
             if canonical is not None:
                 allowed_dates.add(canonical)
 
+    yearless_monthdays = source_monthdays | preserved_monthdays
     violations: list[str] = []
     seen: set[str] = set()
     for field in ("title", "body"):
-        for raw, canonical in _summary_calendar_tokens(summary.get(field)):
+        for raw, canonical, monthday in _summary_calendar_tokens(summary.get(field)):
             if raw in source_tokens or raw in preserved_tokens:
                 continue
             value = canonical or raw
             if value in seen:
                 continue
-            if canonical is None or canonical not in allowed_dates:
-                seen.add(value)
-                violations.append(value)
+            if canonical is not None and canonical in allowed_dates:
+                continue
+            if canonical is None and monthday is not None and monthday in yearless_monthdays:
+                # Same month and day as a yearless source date: the wording
+                # changed, the date did not, and no year was invented.
+                continue
+            seen.add(value)
+            violations.append(value)
     return tuple(violations)
 
 

{memleaf-0.2.47 → memleaf-0.2.49}/src/memleaf/single_pass_memory_planner.py

@@ -541,6 +541,11 @@ class SinglePassMemoryPlanner(MemoryPlanner):
                 "session_id": turn.session_id,
                 "turn_index": turn.turn_index,
             },
+            evidence_timestamps={
+                event["event_key"]: event.get("timestamp")
+                for event in events
+                if isinstance(event.get("event_key"), str)
+            },
         )
 
         fallback_scopes, fallback_scope_source = self._fallback_scopes(scope_background)