memleaf 0.2.95__tar.gz → 0.2.96__tar.gz

{memleaf-0.2.95 → memleaf-0.2.96}/CHANGELOG.md

@@ -5,6 +5,31 @@ All notable changes to memleaf are documented here.
 ## Unreleased
 
 
+## 0.2.96 — 2026-10-06
+
+### Preserve existing information when replacing memory bodies
+
+- Expose omitted old prose to semantic review for UPDATE and every MERGE
+  member. Require dispositions bound to the final body or new user evidence;
+  boolean body approval alone cannot erase existing information. Unconfirmed
+  replacements remain DEFERRED with the previous memory preserved.
+- Allow the existing review to repair the full body while retaining candidate
+  identity, evidence and other fields. Check the final replacement, accept valid
+  redundant coverage, and isolate invalid optional maintenance corrections from
+  independently valid decisions. Protect manual partial repairs as well.
+- Reuse the existing review request for ongoing actions; add a second review
+  only where a previously unreviewed fact update could omit existing prose.
+  Ordinary fact additions and repeated no-change turns remain single-request.
+  No third review, automatic retry or request-budget increase is added.
+- Validation: 122 affected checks and isolated frozen-candidate replays passed.
+  The final three live Hermes turns preserved unchanged requirements, avoided
+  duplicate writes and applied only an explicitly withdrawn requirement:
+  five Memleaf requests, 30,821 observed tokens, no issues or unresolved items.
+  Intermediate development failures were preserved separately; historical raw
+  review responses were not reconstructed. Equivalence still relies on semantic
+  review, while Core verifies complete coverage and source/quote bindings.
+
+
 ## 0.2.95 — 2026-10-05
 
 ### Preserve turn identity around internal Hermes continuations

{memleaf-0.2.95/src/memleaf.egg-info → memleaf-0.2.96}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 0.2.95
+Version: 0.2.96
 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.95。**
+> **版本：0.2.96。**
 > 自动提炼和复核共用同一条“未来记忆价值”标准：模型综合未来复用、信息增量、再次读取时的直接可用性和忘记成本，只保留对未来理解、判断或行动有实质影响的最小核心；没有明确价值的信息不提炼，不按具体业务场景硬编码排除。
 > 提炼先比较旧事项中的编号、目标、进展、责任和期限；补全未知信息也应维护原事项，另建独立待办不能替代项目事实更新。确认重复的记忆在现有处理请求中合并，保留历史与来源；项目和独立任务保持各自生命周期，Core 不按标题强行合并。
 > 新请求兼容等价的字段表示；未知执行人保持 `null`，新增或变更负责人和期限需要真实来源；等待条件在正文维护，不再提炼 `waiting_on`。行动及相关字段经过有界语义复核，提炼与复核共用每份工作的最多五次模型请求额度，成功即停止；复核失败不写入。来源时间用于解析相对日期，不补造事实日期。

{memleaf-0.2.95 → memleaf-0.2.96}/README.en.md

@@ -4,7 +4,7 @@
 
 [中文](README.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **Version: 0.2.95.**
+> **Version: 0.2.96.**
 > 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.
 > Extraction compares existing identifiers, objectives, progress, responsibility and deadlines first. Filling an unknown also maintains the original item; a separate task does not replace updating shared project facts. Confirmed duplicates can be merged in the existing processing requests with their sources and history preserved. Independent project and task lifecycles remain separate; Core does not merge matching titles.
 > New requests accept equivalent field representations. Unknown executors remain `null`; new or changed responsibility and deadlines require actual source evidence. Dependencies belong in the body; `waiting_on` is no longer extracted. Proposed actions and related fields undergo bounded semantic verification within a shared five-request limit per work item, stopping on success; failed verification blocks writes. Source time resolves relative dates without inventing factual dates.

{memleaf-0.2.95 → memleaf-0.2.96}/README.md

@@ -4,7 +4,7 @@
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **版本：0.2.95。**
+> **版本：0.2.96。**
 > 自动提炼和复核共用同一条“未来记忆价值”标准：模型综合未来复用、信息增量、再次读取时的直接可用性和忘记成本，只保留对未来理解、判断或行动有实质影响的最小核心；没有明确价值的信息不提炼，不按具体业务场景硬编码排除。
 > 提炼先比较旧事项中的编号、目标、进展、责任和期限；补全未知信息也应维护原事项，另建独立待办不能替代项目事实更新。确认重复的记忆在现有处理请求中合并，保留历史与来源；项目和独立任务保持各自生命周期，Core 不按标题强行合并。
 > 新请求兼容等价的字段表示；未知执行人保持 `null`，新增或变更负责人和期限需要真实来源；等待条件在正文维护，不再提炼 `waiting_on`。行动及相关字段经过有界语义复核，提炼与复核共用每份工作的最多五次模型请求额度，成功即停止；复核失败不写入。来源时间用于解析相对日期，不补造事实日期。

{memleaf-0.2.95 → memleaf-0.2.96}/pyproject.toml

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

{memleaf-0.2.95 → memleaf-0.2.96}/src/memleaf/__init__.py

@@ -1,6 +1,6 @@
 """Local-first Markdown memory core for AI agents."""
 
-__version__ = "0.2.95"
+__version__ = "0.2.96"
 
 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.96/src/memleaf/body_preservation.py

@@ -0,0 +1,112 @@
+"""Account for omitted old prose without guessing which facts remain valid.
+
+Text fragments are comparison aids, not a parser for facts. The existing
+semantic review judges equivalence or an authorized change; Core checks that
+every omission has a real, source-bound disposition for the final candidate.
+"""
+from __future__ import annotations
+
+import re
+
+
+def _compact(text):
+    return re.sub(r"\s+", "", text)
+
+
+def omissions(row, original):
+    if not isinstance(row, dict):
+        return []
+    action = row.get("action")
+    action = action.strip().upper() if isinstance(action, str) else ""
+    if action not in {"UPDATE", "MERGE"}:
+        return []
+    patch = row.get("patch")
+    if not isinstance(patch, dict):
+        return []
+    # Retraction erases the stored body even when the model omits patch.body.
+    body = "" if patch.get("validity") == "retracted" else patch.get("body")
+    if not isinstance(body, str):
+        return []
+    refs = [row.get("target")]
+    if action == "MERGE" and isinstance(row.get("duplicates"), list):
+        refs.extend(row["duplicates"])
+    refs = [ref.strip() for ref in refs if isinstance(ref, str)]
+    new = _compact(body)
+    missing = []
+    seen = set()
+    for memory in original.get("memories", []):
+        if memory.get("ref") not in refs or memory.get("validity", "valid") != "valid":
+            continue
+        old = memory.get("body", "")
+        if not isinstance(old, str):
+            continue
+        # Language-neutral punctuation/line boundaries. No names, keywords or
+        # expected facts influence the comparison. Short fragments count too.
+        for text in re.split(r"[。！？!?；;\n，,]+|(?<=\.)\s+", old):
+            text = text.strip()
+            key = (memory["ref"], text)
+            if text and _compact(text) not in new and key not in seen:
+                missing.append({"target": key[0], "old": text})
+                seen.add(key)
+    return missing
+
+
+def covered(row, original, coverage=None):
+    """Missing/malformed proofs defer this proposal, never erase the head."""
+    missing = omissions(row, original)
+    if not missing:
+        return True
+    if not isinstance(coverage, list):
+        return False
+    expected = {(part["target"], part["old"]) for part in missing}
+    # A reviewer may restore a fragment and still include its proof. Check
+    # against the real old fragments, not an exact output-count convention.
+    all_old = omissions({**row, "patch": {"body": ""}}, original)
+    allowed = {(part["target"], part["old"]) for part in all_old}
+    verified = set()
+    body = "" if row["patch"].get("validity") == "retracted" else row["patch"].get("body", "")
+    evidence = {e["ref"]: e for e in original.get("evidence", [])}
+    for proof in coverage:
+        if not isinstance(proof, dict):
+            return False
+        key = (proof.get("target"), proof.get("old"))
+        if not all(isinstance(value, str) for value in key) or key not in allowed or key in verified:
+            return False
+        if set(proof) == {"target", "old", "body"}:
+            quote = proof["body"]
+            if not isinstance(quote, str) or not quote.strip() or quote not in body:
+                return False
+        elif set(proof) == {"target", "old", "source"}:
+            selection = proof["source"]
+            if not isinstance(selection, dict) or set(selection) != {"ref", "text"}:
+                return False
+            if not isinstance(selection["ref"], str):
+                return False
+            event = evidence.get(selection.get("ref"))
+            quote = selection.get("text")
+            # An assistant suggestion cannot authorize discarding user facts.
+            if (event is None or event.get("use") != "new" or event.get("role") != "user"
+                    or event["ref"] not in row.get("evidence", [])
+                    or not isinstance(quote, str) or not quote.strip() or quote not in event.get("text", "")):
+                return False
+        else:
+            return False
+        verified.add(key)
+    return expected <= verified
+
+
+def defer_unreviewed(response, snapshot):
+    """A manual partial repair has no model reviewer; preserve unsafe heads."""
+    from .incremental_semantics import envelope
+    from .validation import parse_strict_json
+    from .incremental_protocol import compile_incremental
+    import json
+    draft = envelope(parse_strict_json(response))
+    original = snapshot.model_input()
+    for i, row in enumerate(draft["items"]):
+        if (omissions(row, original)
+                and not compile_incremental(json.dumps({"items": [row]}), snapshot)["issues"]):
+            draft["items"][i] = {"action": "DEFERRED", "evidence": row.get("evidence", []),
+                                 "reason": "missing_context",
+                                 "need": "The body replacement has unverified omissions from the previous memory."}
+    return json.dumps(draft, ensure_ascii=False, separators=(",", ":"))

{memleaf-0.2.95 → memleaf-0.2.96}/src/memleaf/hermes_provider/plugin.yaml

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

{memleaf-0.2.95 → memleaf-0.2.96}/src/memleaf/incremental_execution.py

@@ -232,11 +232,14 @@ def _drive(service, run_id, token, backend, calls, metric_ordinals):
                     return public_result(run, calls=calls[0], metric_ordinals=metric_ordinals)
                 if run["status"] in {"response_ready", "committing"}:
                     try:
+                        if (run.get("partial_used") and run.get("partial_recovery", {}).get("mode") == "repair"):
+                            from .body_preservation import defer_unreviewed
+                            run["response"] = defer_unreviewed(run["response"], snapshot)
                         compiled = compile_incremental(run["response"], snapshot)
                         from .incremental_semantics import needs_review, review_request
                         if (not (run.get("partial_used") and run.get("partial_recovery", {}).get("mode") == "repair")
                                 and run.get("semantic_stage") != "reviewed"
-                                and needs_review(compiled, run["response"])):
+                                and needs_review(compiled, run["response"], snapshot)):
                             if run["reserved_requests"] >= MAX_INCREMENTAL_REQUESTS:
                                 _finish(service, processed, run, "blocked", "semantic_review_budget_exhausted")
                                 return public_result(run, calls=calls[0], metric_ordinals=metric_ordinals)
@@ -391,7 +394,7 @@ def _drive(service, run_id, token, backend, calls, metric_ordinals):
             elif not run.get("partial_used"):
                 try:
                     from .incremental_semantics import needs_review
-                    run["semantic_review_required"] = needs_review(compile_incremental(response, snapshot), response)
+                    run["semantic_review_required"] = needs_review(compile_incremental(response, snapshot), response, snapshot)
                 except (ValueError, TypeError):
                     run["semantic_review_required"] = False
             save_run(service, processed, run)

{memleaf-0.2.95 → memleaf-0.2.96}/src/memleaf/incremental_semantics.py

@@ -10,8 +10,10 @@ from copy import deepcopy
 import json
 
 from .validation import parse_strict_json, ModelOutputError
+from .body_preservation import omissions, covered
 
-REVIEW_SYSTEM = """核验拟写入的持续行动。original_input 是唯一事实和权限来源；draft 是待审候选，不能当作事实。返回 JSON 对象，必填 decisions，值为数组；每项有 item（整数）、keep（布尔值）、field_support（对象）。按输入 fields_to_review 的实际字段填 field_support，不能复制其他事项的字段名。
+REVIEW_SYSTEM = """核验拟写入的记忆及持续行动。original_input 是唯一事实和权限来源；draft 是待审候选，不能当作事实。返回 JSON 对象，必填 decisions，值为数组；每项有 item（整数）、keep（布尔值）、field_support（对象）。按输入 fields_to_review 的实际字段填 field_support，不能复制其他事项的字段名。
+存在 body_omissions 时，keep:true 的 UPDATE/MERGE 必须逐项说明省略的去向；仅 body:true 不足以通过。body_omissions 按 item 列出拟议正文中不再原样出现的旧片段（比较辅助，不表示已经失效）。逐项核对完整含义，不能因主题相同、进展重复或用户未再次提及就删除。需要补回或修正文句时，直接在 decision 增加 body（修正后的完整正文字符串），field_support.body=true；不必复制 action、target、evidence，也不要把该 target 放入 updates。Core 沿用该候选的身份、证据和其他字段；已有 replace 方式仍可用，但不能同时使用 body 和 replace。对最终 UPDATE/MERGE（包括 body、replace 和 updates 修正）的剩余省略片段，在对应 decision/updates 项增加 body_coverage 数组：每项 {"target":"旧目标ref","old":"旧片段原文","body":"最终正文中完整承接该片段含义的逐字引文"}，或 {"target":"旧目标ref","old":"旧片段原文","source":{"ref":"new用户证据ref","text":"明确纠正/撤回该内容的逐字引文"}}。body 引文必须完整等价且真实存在于最终正文；不能只引用旧目标中的文字却忘了将它写入修正正文。source 不能引用旧上下文或助手建议。修正后原样保留的片段无需列入。MERGE 对所有被合并目标逐项核对，撤回整个目标也需明确用户依据。无法确认则 keep:false；不要猜测或提供主题相符但实际无关的引文。没有剩余省略时省略 body_coverage。
 每个 draft.items 都必须有且只有一个 decision，item 是从 0 开始的位置。keep 判断该事项本身是否由原文确立且持续值得保留。临时操作及助手额外建议不能产生用户长期待办，原话只证明另一个操作时 keep:false。独立事实不因其他候选有误而拒绝。
 keep:true 时，field_support 必须逐个列出候选 memory/patch 中的业务字段，每个布尔值判断该字段的拟议值是否受来源支持；不列 responsibility_basis、effective、at、reopen 等引用/控制字段。没有 replace 的 NO_CHANGE/DEFERRED/NO_MEMORY 的 field_support 为 {}。keep:false 时 field_support 为 {}。unverified_fields 是系统发现未能验证引用的可选责任字段，必须判为 false；不能补造引用。这不影响其他有依据的事实或任务。归属/客户尚未确定不自动表示行动被阻塞。
 不能仅检查引文存在：必须判断原话是否确立该具体行动、责任、状态和期限。assistant 的建议/计划不能赋予 user 新义务。转发、协调、记录不等于本人执行；支持旧任务不等于接受新安排。
@@ -45,15 +47,23 @@ def fields(row):
     return {key for key in payload if key not in _METADATA} if isinstance(payload, dict) else set()
 
 
-def needs_review(compiled, response=None):
+def needs_review(compiled, response=None, snapshot=None):
     if response is not None:
         rows = envelope(parse_strict_json(response))["items"]
+        original = snapshot.model_input() if snapshot is not None else None
+        update_ids = {op.get("target") for op in compiled["operations"] if op["action"] == "UPDATE"}
+        writable_updates = ({ref for ref, target in snapshot.state()["targets"].items()
+                             if target["memory"]["memory_id"] in update_ids} if snapshot is not None else set())
         actions = {str(row.get("action", "")).strip().upper() for row in rows if isinstance(row, dict)}
         if "MERGE" in actions or {"UPDATE", "NO_CHANGE"} <= actions:
             return True
         for row in rows:
             if not isinstance(row, dict):
                 continue
+            target = row.get("target")
+            if (original is not None and isinstance(target, str) and target.strip() in writable_updates
+                    and omissions(row, original)):
+                return True
             action = row.get("action")
             action = action.strip().upper() if isinstance(action, str) else ""
             payload = row.get("memory") if action == "CREATE" else row.get("patch")
@@ -118,10 +128,12 @@ def review_request(original, response, snapshot=None):
             row["action"] = row["action"].strip().upper()
         rows.append(row)
     draft["items"] = rows
+    missing = [omissions(row, source) for row in rows]
     return {"system": REVIEW_SYSTEM,
             "user": json.dumps({"original_input": source, "draft": draft,
                                 "fields_to_review": [sorted(fields(row)) for row in draft["items"]],
                                 "unverified_fields": [unverified_fields(row, source) for row in draft["items"]],
+                                **({"body_omissions": missing} if any(missing) else {}),
                                 **({"invalid_representation_items": invalid} if invalid else {})},
                                ensure_ascii=False, separators=(",", ":"))}
 
@@ -164,7 +176,7 @@ def apply_review(request, response):
                 rejected.append(deepcopy(row))
         for decision in decisions:
             if (not isinstance(decision, dict) or not {"item", "keep", "field_support"} <= set(decision)
-                    or set(decision) - {"item", "keep", "field_support", "replace"}):
+                    or set(decision) - {"item", "keep", "field_support", "replace", "body", "body_coverage"}):
                 raise ValueError
             i = decision["item"]
             if type(i) is not int or not 0 <= i < len(rows) or i in positions or type(decision["keep"]) is not bool:
@@ -174,6 +186,14 @@ def apply_review(request, response):
             if not isinstance(support, dict) or any(type(v) is not bool for v in support.values()):
                 raise ValueError
             row = rows[i]
+            if "body" in decision:
+                if (not decision["keep"] or "replace" in decision
+                        or i in data.get("invalid_representation_items", [])
+                        or row.get("action") not in {"CREATE", "UPDATE", "MERGE"}
+                        or "body" not in fields(row) or support.get("body") is not True
+                        or not isinstance(decision["body"], str)):
+                    raise ValueError
+                row["memory" if row["action"] == "CREATE" else "patch"]["body"] = decision["body"]
             if "replace" in decision:
                 if i in data.get("invalid_representation_items", []) or not decision["keep"]:
                     raise ValueError
@@ -253,6 +273,9 @@ def apply_review(request, response):
             if row["action"].upper() == "UPDATE" and not payload:
                 discard(row)
                 rows[i] = None
+            elif not covered(row, data["original_input"], decision.get("body_coverage")):
+                discard(row)
+                rows[i] = None
         rows = [r for r in rows if r is not None]
         additions = review.get("updates", [])
         from .incremental_protocol import MAX_ITEMS
@@ -260,12 +283,24 @@ def apply_review(request, response):
             raise ValueError
         used = {row.get("target") for row in rows if isinstance(row, dict)}
         for entry in additions:
-            if not isinstance(entry, dict) or set(entry) != {"row", "field_support"}:
-                raise ValueError
-            row = _maintenance_update(entry["row"], entry["field_support"], data["original_input"])
-            if row["target"] in used:
-                raise ValueError
-            rows.append(row)
+            try:
+                if (not isinstance(entry, dict) or not {"row", "field_support"} <= set(entry)
+                        or set(entry) - {"row", "field_support", "body_coverage"}):
+                    raise ValueError
+                row = _maintenance_update(entry["row"], entry["field_support"], data["original_input"])
+                if row["target"] in used:
+                    raise ValueError
+            except (KeyError, TypeError, ValueError):
+                # Optional correction is not an authority grant. Reject it
+                # explicitly without erasing independently valid decisions.
+                rows.append({"action": "DEFERRED", "evidence": [e["ref"] for e in data["original_input"]["evidence"]
+                             if e["use"] == "new"], "reason": "missing_context",
+                             "need": "The additional maintenance correction is not source-verified."})
+                continue
+            if covered(row, data["original_input"], entry.get("body_coverage")):
+                rows.append(row)
+            else:
+                discard(row)
             used.add(row["target"])
         for rejected_row in rejected:
             # The same review can supply a complete, independently validated

{memleaf-0.2.95 → memleaf-0.2.96/src/memleaf.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 0.2.95
+Version: 0.2.96
 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.95。**
+> **版本：0.2.96。**
 > 自动提炼和复核共用同一条“未来记忆价值”标准：模型综合未来复用、信息增量、再次读取时的直接可用性和忘记成本，只保留对未来理解、判断或行动有实质影响的最小核心；没有明确价值的信息不提炼，不按具体业务场景硬编码排除。
 > 提炼先比较旧事项中的编号、目标、进展、责任和期限；补全未知信息也应维护原事项，另建独立待办不能替代项目事实更新。确认重复的记忆在现有处理请求中合并，保留历史与来源；项目和独立任务保持各自生命周期，Core 不按标题强行合并。
 > 新请求兼容等价的字段表示；未知执行人保持 `null`，新增或变更负责人和期限需要真实来源；等待条件在正文维护，不再提炼 `waiting_on`。行动及相关字段经过有界语义复核，提炼与复核共用每份工作的最多五次模型请求额度，成功即停止；复核失败不写入。来源时间用于解析相对日期，不补造事实日期。

{memleaf-0.2.95 → memleaf-0.2.96}/src/memleaf.egg-info/SOURCES.txt

@@ -55,6 +55,7 @@ src/memleaf/__main__.py
 src/memleaf/acceptance.py
 src/memleaf/admission.py
 src/memleaf/batch_review.py
+src/memleaf/body_preservation.py
 src/memleaf/budget.py
 src/memleaf/capture.py
 src/memleaf/cli.py