memleaf 0.2.55__tar.gz → 0.2.57__tar.gz

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

@@ -2,6 +2,20 @@
 
 All notable changes to memleaf are documented here.
 
+## 0.2.57 — 2026-09-14
+
+- Let the model decide project ownership, and stop Core deciding it by string. Core required a model-selected project name to occur literally in the candidate's evidence, which cannot work: two descriptions of one project need share no substring, so "记录账单的项目" can never match a registered `记账`, and a literal test rejects a correct answer. It also cost whole memories. The reproduced turn is "跟你分享一下，最近在弄个记账的小玩意儿，就扔家里那台 N100 上跑，没打算上云"; the model named the project `记账小玩意儿`, the user wrote `记账的小玩意儿`, the literal test failed, and the candidate was deferred -- so the N100 deployment and the no-cloud decision were lost with the name. Deferring did not recover it either: deferred candidates are replayed from the journal rather than re-attempted, so a preview of that session makes zero model calls and processes zero turns. The guard is removed; a project name is a label, not a fact, and the model judges the ownership.
+- State the rule generally, with no worked instance. The contract now says ownership is judged by meaning and never by wording, that a scope already listed in `scope_registry` is reused when the evidence means it even if the wording differs, and that a name does not have to appear in the evidence. A deferral is reserved for the case where the evidence is about a project but which project it is cannot be determined; a fact that simply has no project is `global` and is never deferred. An earlier draft stated that clause backwards and would have deferred every standing preference and environment fact. An earlier draft also carried a worked example naming one real project; an instance only ever helps the project it names, so it was removed and the same stability was obtained from the directive itself.
+- Verification used the real model. 115 tests pass with no model call. Replaying the reproduced turn now writes the memory in both variants (with and without the assistant's reply). Four sentences were run against a registry holding one project: the same wording, a paraphrase ("我那个记录账单的小项目，部署挪到 Mac mini 上了"), an indirect reference, and an unrelated new project -- the first three all landed on the existing scope and the fourth correctly minted its own, so paraphrase is recognised and distinct projects are not merged. Six sentences carrying no project (a rule, a preference, an environment fact, a bare product mention) still resolved to `global` rather than deferring.
+
+## 0.2.56 — 2026-09-14
+
+- Keep assistant reports source-safe at candidate granularity. Markdown headings, paragraphs and list items become exact immutable evidence units with section context; broad whole-report `whole_unit` claims are deferred, while short unstructured replies remain intact. An assistant-only offer, question or forward commitment cannot establish user intent, but a factual report can still be admitted when its evidence and future value are independently grounded.
+- Ground project Scope from the candidate's own admitted claims, including their exact quote and section context. An explicit project label makes a `global` answer unsafe, and an ungrounded project Scope defers only that candidate instead of silently dropping the Scope or losing the source-backed memory. Candidate-level validation details are persisted through the bounded audit path.
+- Share one boundary-safe calendar-token grammar across summary grounding and todo deadline checks. Standalone ISO, Chinese and numeric dates reject identifiers, decimals and invalid values; scheduling cues such as planned, target and scheduled now authorize deadline dates, while an ambiguous candidate-local deadline is reported and never guessed.
+
+Verification for this release used 18 local synthetic regression tests with no model call and no production Vault write. Python 3.11 compilation/imports and `git diff --check` pass, and the release metadata is synchronized across the package, Hermes provider, READMEs and changelog. Real-model adherence and a newly installed Hermes replay remain post-release runtime acceptance.
+
 ## 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.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 0.2.55
+Version: 0.2.57
 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.55。**
-> 记忆只从用户与 Agent 的可见对话提炼。Agent 已在回复中整理的事实、项目进展和明确待办可作为来源；邮件、附件、网页和终端等工具原文不进入记忆提炼。模型负责保留原话中的不确定性，现有记忆仅用于比较、去重和更新。Markdown 仍是唯一事实源。
+> **版本：0.2.57。**
+> 自动提取按助手回复中的 Markdown 结构建立候选级来源，过宽的整段引用和未被用户接受的助手意图不会形成记忆。项目归属由模型按语义判断，不再要求项目名在证据里逐字出现：同一个项目换个说法也能落到已有 Scope 上，名字也不再决定这条记忆的生死。日期和截止日期使用统一的边界安全解析，todo 只在候选自己的证据给出唯一明确截止日时填充。Markdown 仍是唯一事实源。
 > **当前版本支持 Hermes 和 Codex。** Antigravity（反重力）不检测、不安装、不配置。
 
 ## 项目定位

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

@@ -4,8 +4,8 @@
 
 [中文](README.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **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.
+> **Version: 0.2.57.**
+> Automatic extraction now creates candidate-local source units from Markdown structure in assistant replies; broad whole-report citations and assistant-only intent are not allowed to create memories. Project ownership is the model's semantic judgement and no longer requires the project name to appear literally in the evidence: one project referred to in different words lands on the existing Scope, and the name no longer decides whether the memory survives. Dates and deadlines use one boundary-safe parser, and a todo receives a due date only when its own evidence supplies one unambiguous deadline. 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.
 
 ## Project scope

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

@@ -4,8 +4,8 @@
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **版本：0.2.55。**
-> 记忆只从用户与 Agent 的可见对话提炼。Agent 已在回复中整理的事实、项目进展和明确待办可作为来源；邮件、附件、网页和终端等工具原文不进入记忆提炼。模型负责保留原话中的不确定性，现有记忆仅用于比较、去重和更新。Markdown 仍是唯一事实源。
+> **版本：0.2.57。**
+> 自动提取按助手回复中的 Markdown 结构建立候选级来源，过宽的整段引用和未被用户接受的助手意图不会形成记忆。项目归属由模型按语义判断，不再要求项目名在证据里逐字出现：同一个项目换个说法也能落到已有 Scope 上，名字也不再决定这条记忆的生死。日期和截止日期使用统一的边界安全解析，todo 只在候选自己的证据给出唯一明确截止日时填充。Markdown 仍是唯一事实源。
 > **当前版本支持 Hermes 和 Codex。** Antigravity（反重力）不检测、不安装、不配置。
 
 ## 项目定位

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

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

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

@@ -1,6 +1,6 @@
 """Local-first Markdown memory core for AI agents."""
 
-__version__ = "0.2.55"
+__version__ = "0.2.57"
 
 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.55 → memleaf-0.2.57}/src/memleaf/admission.py

@@ -16,11 +16,13 @@ from typing import Any, Iterable, Mapping
 from .validation import ModelOutputError, parse_strict_json
 from .evidence_syntax import (
     _BULLET, _CLOSED_TASK, _EXAMPLE, _EXTERNAL_OWNER, _HEADING, _NEGATIVE_TASK,
-    _POLITE, _QUERY_START, _QUERY_WORD, _READ_ONLY_CONTROL, _clauses, _query,
+    _POLITE, _QUERY_START, _QUERY_WORD, _READ_ONLY_CONTROL, _assistant_intent_only,
+    _clauses, _query,
 )
 from .evidence_structure import (
     MAX_EXTERNAL_UNIT_BYTES, _EXTERNAL_MARKER, _external_blocks,
-    _has_external_structure, _structured_external_blocks,
+    _has_external_structure, _has_markdown_structure, _markdown_blocks,
+    _structured_external_blocks, _whole_unit_is_safe,
 )
 
 
@@ -173,9 +175,14 @@ def analyze_turn_evidence(events: Iterable[Mapping[str, Any]]) -> tuple[Evidence
     def inventory(key: str, role: str, text: str, meta: Mapping[str, Any] | None = None) -> None:
         meta = meta or {}
         if role == "assistant":
-            # Preserve the complete visible reply so headings, qualifications,
-            # project names and findings stay together in one model input.
-            fragments = [(0, len(text), text, "plain", ())] if text.strip() else []
+            # Keep an unstructured short reply intact, but account for explicit
+            # Markdown blocks independently so one long report cannot authorize
+            # unrelated sibling facts through a whole-unit claim.
+            fragments = (
+                _markdown_blocks(text)
+                if text.strip() and _has_markdown_structure(text)
+                else ([(0, len(text), text, "plain", ())] if text.strip() else [])
+            )
         elif role == "external":
             # A tool result is one physical source record.  Splitting it on
             # punctuation made JSON/document bodies look like thousands of
@@ -251,7 +258,9 @@ def _canonical_text(text: str) -> str:
 
 
 def validate_bindings(value: Any, units: Iterable[EvidenceUnit],
-                      candidates: Iterable[Mapping[str, Any]]) -> dict[str, list[dict[str, Any]]]:
+                      candidates: Iterable[Mapping[str, Any]], *,
+                      allow_broad_whole_unit_candidates: Iterable[str] = (),
+                      ) -> dict[str, list[dict[str, Any]]]:
     """Validate model judgments against exact immutable source fragments.
 
     Matching a quotation proves provenance, not the truth of a proposition.
@@ -260,6 +269,11 @@ def validate_bindings(value: Any, units: Iterable[EvidenceUnit],
     """
     by_unit = {u.unit_id: u for u in units}
     by_candidate = {c["candidate_id"]: c for c in candidates}
+    allowed_broad_candidates = {
+        value.casefold()
+        for value in allow_broad_whole_unit_candidates
+        if isinstance(value, str) and value
+    }
     if not isinstance(value, list):
         raise ModelOutputError("evidence_bindings must be a list", validation_detail="invalid_evidence",
                                evidence_check="binding_shape")
@@ -299,6 +313,16 @@ def validate_bindings(value: Any, units: Iterable[EvidenceUnit],
                 if claim["whole_unit"] is not True:
                     raise ModelOutputError("whole_unit must be true", validation_detail="invalid_evidence",
                                            evidence_check="binding_shape")
+                if (
+                    cid.casefold() not in allowed_broad_candidates
+                    and unit.source_role == "assistant"
+                    and not _whole_unit_is_safe(unit.text)
+                ):
+                    raise ModelOutputError(
+                        "whole_unit is too broad for a structured assistant report",
+                        validation_detail="whole_unit_too_broad",
+                        evidence_check="invalid_span",
+                    )
                 # Explicitly selecting one supplied immutable source unit is
                 # equivalent to quoting that whole unit. Never repair a bad
                 # quote or resolve an ID outside this invocation's inventory.
@@ -422,6 +446,11 @@ def admission_reason(candidate: Mapping[str, Any], units: Iterable[EvidenceUnit]
     support = supporting_units(candidate, units)
     if not support:
         return "evidence_not_supported", ()
+    if candidate.get("_evidence_bindings") and all(
+        unit.source_role == "assistant" and _assistant_intent_only(unit.text)
+        for unit in support
+    ):
+        return "assistant_restatement", support
     if candidate.get("type") == "todo":
         # Negative or third-party facts may still be retained as facts or used
         # for a verified state update. They must not become a new active task.

{memleaf-0.2.55 → memleaf-0.2.57}/src/memleaf/evidence_structure.py

@@ -6,6 +6,9 @@ import re
 from typing import Iterable
 
 MAX_EXTERNAL_UNIT_BYTES = 32 * 1024
+# Keep whole-unit admission bounded even when a source has no explicit Markdown
+# marker.  The threshold is a structural safety limit, not a topic heuristic.
+MAX_WHOLE_UNIT_CHARS = 512
 
 def _external_blocks(text: str) -> Iterable[tuple[int, int, str, str, tuple[str, ...]]]:
     """Yield deterministic, exact source blocks for one external record.
@@ -88,6 +91,152 @@ def _external_blocks(text: str) -> Iterable[tuple[int, int, str, str, tuple[str,
         start = end
 
 _EXTERNAL_MARKER = re.compile(r"^\s*(?:#{1,6}\s+|[-*+•]\s+|\d+[.)、]\s+)")
+_MARKDOWN_HEADING = re.compile(r"^\s{0,3}(?P<marks>#{1,6})\s+(?P<label>.+?)\s*$")
+_MARKDOWN_ITEM = re.compile(r"^\s*(?:[-*+•]|\d+[.)、])\s+")
+
+
+def _has_markdown_structure(text: str) -> bool:
+    """Return whether a conversation reply has explicit block structure."""
+
+    if "\n\n" in text or "\r\n\r\n" in text:
+        return True
+    return any(
+        _MARKDOWN_HEADING.match(line) is not None
+        or _MARKDOWN_ITEM.match(line) is not None
+        for line in text.splitlines()
+    )
+
+
+def _whole_unit_is_safe(text: str) -> bool:
+    """Return whether selecting one assistant unit is structurally narrow."""
+
+    if not isinstance(text, str) or not text.strip():
+        return False
+    if len(text) > MAX_WHOLE_UNIT_CHARS:
+        return False
+    if not _has_markdown_structure(text):
+        return True
+    return sum(1 for _ in _markdown_blocks(text)) <= 1
+
+
+def _markdown_blocks(
+    text: str,
+) -> Iterable[tuple[int, int, str, str, tuple[str, ...]]]:
+    """Yield exact Markdown headings, list items and paragraphs.
+
+    The splitter is layout based only.  Every emitted span is a contiguous
+    slice of ``text``; heading labels are carried as section context for later
+    blocks so a candidate can cite independent facts without inheriting a
+    sibling's body or date.
+    """
+
+    lines: list[tuple[int, int, str]] = []
+    cursor = 0
+    for raw in text.splitlines(True):
+        line_end = cursor + len(raw)
+        body = raw[:-1] if raw.endswith("\n") else raw
+        if body.endswith("\r"):
+            body = body[:-1]
+        lines.append((cursor, line_end, body))
+        cursor = line_end
+    if cursor < len(text):
+        lines.append((cursor, len(text), text[cursor:]))
+    if not lines:
+        return
+
+    headings: list[tuple[int, str]] = []
+    item_context: list[tuple[int, str]] = []
+    current_start: int | None = None
+    current_end: int | None = None
+    current_section: tuple[str, ...] = ()
+    current_syntax = "markdown_paragraph"
+    current_kind = ""
+
+    def emit() -> tuple[int, int, str, str, tuple[str, ...]] | None:
+        if current_start is None or current_end is None or current_start >= current_end:
+            return None
+        return current_start, current_end, text[current_start:current_end], current_syntax, current_section
+
+    def flush() -> tuple[int, int, str, str, tuple[str, ...]] | None:
+        nonlocal current_start, current_end, current_section, current_syntax, current_kind
+        value = emit()
+        current_start = current_end = None
+        current_section = ()
+        current_syntax = "markdown_paragraph"
+        current_kind = ""
+        return value
+
+    for line_start, line_end, body in lines:
+        left = len(body) - len(body.lstrip())
+        right = len(body.rstrip())
+        value = body.strip()
+        if not value:
+            value = flush()
+            if value is not None:
+                yield value
+            continue
+
+        heading = _MARKDOWN_HEADING.match(body)
+        item = _MARKDOWN_ITEM.match(body)
+        if heading:
+            value_before = flush()
+            if value_before is not None:
+                yield value_before
+            item_context.clear()
+            level = len(heading.group("marks"))
+            headings = [(depth, label) for depth, label in headings if depth < level]
+            section = tuple(label for _, label in headings)
+            current_start = line_start + left
+            current_end = line_start + right
+            current_section = section
+            current_syntax = "markdown_heading"
+            current_kind = "heading"
+            # Store the heading itself as a logical structural unit, then use
+            # it as context for following siblings.
+            emitted = flush()
+            if emitted is not None:
+                yield emitted
+            headings.append((level, heading.group("label").strip()))
+            continue
+
+        if item:
+            item_indent = left
+            while item_context and item_indent <= item_context[-1][0]:
+                item_context.pop()
+            if current_kind == "item":
+                value_before = flush()
+                if value_before is not None:
+                    yield value_before
+            elif current_kind in {"heading", "paragraph"}:
+                value_before = flush()
+                if value_before is not None:
+                    yield value_before
+            current_start = line_start + left
+            current_end = line_start + right
+            current_section = tuple(label for _, label in headings) + tuple(
+                label for _, label in item_context
+            )
+            current_syntax = "markdown_item"
+            current_kind = "item"
+            item_context.append((item_indent, body[item.end():].strip()))
+            continue
+
+        # A heading is always a complete block.  A following ordinary line is
+        # therefore a paragraph under that heading, even without a blank line.
+        if current_kind == "heading":
+            value_before = flush()
+            if value_before is not None:
+                yield value_before
+        if current_start is None:
+            current_start = line_start + left
+            current_section = tuple(label for _, label in headings)
+            current_syntax = "markdown_paragraph"
+            current_kind = "paragraph"
+        current_end = line_start + right
+
+    value = flush()
+    if value is not None:
+        yield value
 
 def _has_external_structure(text: str) -> bool:
     """Recognize structural boundaries without treating every line as one."""

{memleaf-0.2.55 → memleaf-0.2.57}/src/memleaf/evidence_syntax.py

@@ -38,6 +38,49 @@ _CLOSED_TASK = re.compile(r"(?:已|已经).{0,4}(?:全部|均)?(?:完成|取消|
 _EXTERNAL_OWNER = re.compile(r"(?:客户|供应商|第三方)(?:自行|自己)?(?:需要|需|负责|必须|应当|要(?!求))|"
                             r"\b(?:customer|vendor|supplier|third party)\s+(?:must|needs? to|is responsible)\b", re.I)
 
+# Speech-act shape only.  This recognizes an assistant-only offer, question or
+# forward commitment without naming a domain, tool or business workflow.  A
+# factual lead such as "I can confirm ..." remains eligible as an external
+# report; the caller still validates its evidence and future value.
+_ASSISTANT_INTENT = re.compile(
+    r"^(?:would\s+you\s+like\s+me\s+to|do\s+you\s+want\s+me\s+to|shall\s+i|let\s+me|"
+    r"i\s+(?:can|could|will|would|shall|may)|"
+    r"要我|是否需要我|需要我|我(?:可以|能|会|将|来))\s*(?P<body>.+)$",
+    re.IGNORECASE,
+)
+_ASSISTANT_ASSERTIVE = re.compile(
+    r"^(?:confirm|verify|report|explain|answer|summari[sz]e|describe|state|note|"
+    r"observe|see|found|find|确认|核对|报告|说明|解释|回答|总结|描述|观察|发现|指出)",
+    re.IGNORECASE,
+)
+
+
+def _assistant_intent_only(text: str) -> bool:
+    """Recognize a standalone assistant offer/question/commitment.
+
+    The result is deliberately conservative: mixed report text and factual
+    assertions stay eligible for semantic future-value review.  Only a whole
+    candidate quote whose speech act is an unaccepted offer is blocked.
+    """
+
+    if not isinstance(text, str):
+        return False
+    value = text.strip().strip("` ")
+    value = re.sub(r"^(?:[-*+•]|\d+[.)、])\s+", "", value)
+    if not value or "\n" in value:
+        return False
+    match = _ASSISTANT_INTENT.fullmatch(value.rstrip("。.!！?？"))
+    if match is None:
+        return False
+    body = match.group("body").lstrip()
+    if _ASSISTANT_ASSERTIVE.match(body):
+        # A future-tense commitment remains an intent even when its verb is
+        # epistemic (for example, "I will verify ...").  Present capability
+        # statements such as "I can confirm ..." remain report evidence.
+        lead = value[:match.start("body")]
+        return bool(re.search(r"\b(?:will|would|shall)\b|我(?:会|将|来)", lead, re.I))
+    return True
+
 def _query(text: str) -> bool:
     text = _POLITE.sub("", text.strip())
     control = text.rstrip("。！？!?；;.! ")

{memleaf-0.2.55 → memleaf-0.2.57}/src/memleaf/hermes_provider/plugin.yaml

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

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

@@ -516,6 +516,9 @@ 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_normalization_count": int(bucket.get("b3_normalization_count", 0)),
+            "b3_candidate_deferred_count": int(bucket.get("b3_candidate_deferred_count", 0)),
+            "b3_ungrounded_scope_dropped_count": int(bucket.get("b3_ungrounded_scope_dropped_count", 0)),
             "b3_due_date_ambiguous_count": int(bucket.get("b3_due_date_ambiguous_count", 0)),
         }
         for field in _PROVIDER_METRIC_FIELDS: