memleaf 0.2.90__tar.gz → 0.2.92__tar.gz

{memleaf-0.2.90 → memleaf-0.2.92}/CHANGELOG.md

@@ -4,6 +4,58 @@ All notable changes to memleaf are documented here.
 
 ## Unreleased
 
+
+## 0.2.92 — 2026-10-05
+
+### Preserve unresolved review outcomes and schedule bounded lifecycle maintenance
+
+- Retain source-bound DEFERRED when review rejects UPDATE, MERGE, or explicitly
+  requested CREATE, even if other NO_CHANGE candidates survive. Only a validated
+  same-target correction covering the evidence and fields can resolve a rejected
+  UPDATE. Unrelated candidates cannot consume an unresolved host retention intent.
+- Run deterministic history/provenance maintenance after normal process and
+  remember operations. Apply bounded version/age retention or keep_all, and
+  protect pending mutation and recovery dependencies without replaying old work.
+- Schedule at most one optional body-compaction request per processing batch
+  after the configured threshold is reached. Use a freshly completed turn's
+  remaining durable allowance, with extraction and maintenance sharing its
+  five-request limit; never reopen completed budgets or allocate a new allowance.
+- Persist recent input fingerprints and reservations before dispatch, including
+  no-op, failed and interrupted requests. Preserve compaction identity and all
+  metadata, serialize model ownership, recheck dependencies at commit, and report
+  maintenance status and observed token usage independently of committed facts.
+- Ordinary turns below the threshold and cached replays add no model calls.
+  No new user-facing tool or model-output protocol field is introduced.
+- Validation: 175 focused checks and seven isolated replay scenarios passed,
+  including the frozen real draft under approval and veto, host-intent retention,
+  process exit/restart, budget exhaustion, concurrent mutation protection, and
+  41 public-process updates retaining one identity, 32 historical versions and
+  cumulative source accounting. External model calls were zero; new live-model
+  acceptance remains separate.
+
+## 0.2.91 — 2026-10-05
+
+### Preserve historical reads in incremental comparison
+
+- Accept successfully read historical versions as read-only comparison context
+  instead of blocking the whole turn with required_target_unavailable. Preserve
+  every required read identity and include its current head only through a
+  validated exact link; missing or conflicting links remain unknown.
+- Keep historical versions outside operation targets and source evidence. Their
+  scopes do not grant write authority, and current heads retain existing scope
+  boundaries. Ordinary turns continue to scan current knowledge only.
+- Protect historical content and lifecycle links in planning snapshots and
+  preserve them through partial recovery with stable current-target references.
+  Existing snapshots without historical context retain their original digest.
+- No new model stage, model output field or tool is added. Only required archive
+  versions enter model input; a short prompt clarification distinguishes them
+  from current records and new evidence.
+- Validation: 189 focused checks passed, including 19 new history-context
+  regressions, plus isolated replay of the original 19-read real turn. Six
+  existing legacy-suite failures reproduce on 0.2.90 and are recorded locally.
+  Replay used supplied responses with zero external model calls and left the
+  formal Vault unchanged; new live-model acceptance remains separate.
+
 ## 0.2.90 — 2026-10-05
 
 ### Expose withdrawal state in explicit historical retrieval

{memleaf-0.2.90/src/memleaf.egg-info → memleaf-0.2.92}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 0.2.90
+Version: 0.2.92
 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.90。**
+> **版本：0.2.92。**
 > 自动提炼和复核共用同一条“未来记忆价值”标准：模型综合未来复用、信息增量、再次读取时的直接可用性和忘记成本，只保留对未来理解、判断或行动有实质影响的最小核心；没有明确价值的信息不提炼，不按具体业务场景硬编码排除。
 > 提炼先比较旧事项中的编号、目标、进展、责任和期限；补全未知信息也应维护原事项，另建独立待办不能替代项目事实更新。确认重复的记忆在现有处理请求中合并，保留历史与来源；项目和独立任务保持各自生命周期，Core 不按标题强行合并。
 > 新请求兼容等价的字段表示；未知执行人保持 `null`，新增或变更负责人和期限需要真实来源；等待条件在正文维护，不再提炼 `waiting_on`。行动及相关字段经过有界语义复核，提炼与复核共用每份工作的最多五次模型请求额度，成功即停止；复核失败不写入。来源时间用于解析相对日期，不补造事实日期。
@@ -462,8 +462,9 @@ history:
 - active Markdown 每条最多保留 16 个来源明细，同时记录累计 `source_count`、`source_digest` 和省略数量，避免 UPDATE 让 `sources` 无限膨胀；
 - 已完成/已取消 todo 保留在 `knowledge/` 中作为稳定当前身份，默认 active 清单不展示，但 `list_todos(status=completed|cancelled|all)` 和后续维护仍可按原 ID 定位；`closed_todo_retention_days` 仅作为旧配置兼容项保留；
 - `history.policy: bounded` 默认每个稳定记忆身份最多保留 32 个完整历史版本，且超过 3650 天的版本可被维护流程淘汰；需要永久审计时可显式设置 `history.policy: keep_all`；
-- compaction 会保留一个既有 canonical `memory_id`，不会再为整理结果创建新的 `mem-compact-*` 身份；单条精简保持原 ID，多条合并选择一个稳定 survivor。
-- 这些维护动作在正常 `process()` / `remember()` / `compact()` 生命周期中执行，不需要 daemon；普通只读检索本身不触发维护写入。
+- 正文 compaction 逐条精简，保持原 `memory_id` 和来源、责任、状态、期限，不合并独立身份；同一事项的语义合并由提炼协议的 `MERGE` 处理。
+- 正常 `process()` / `remember()` 结束后执行确定性历史维护；有未完成写入或恢复依赖时推迟维护，保留恢复输入。普通只读检索不触发维护写入。
+- 新完成的轮次达到正文压缩阈值时，每批最多一次压缩调用，与该轮提炼共用不超过 5 次的持久额度。低于阈值、缓存重放、近期相同输入已尝试时不增加调用；持久保留最近 64 个输入指纹，压缩无收益、失败或进程中断也计入去重。维护结果独立报告，不将已提交的事实回滚。显式 `compact()` 仍只执行正文压缩，不隐式清理历史；无需 daemon。
 
 默认目录尽量使用 `0700`，文件默认明文保存。memleaf 没有内置加密层，请自行保护 Vault、备份和模型调用凭证。
 

{memleaf-0.2.90 → memleaf-0.2.92}/README.en.md

@@ -4,7 +4,7 @@
 
 [中文](README.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **Version: 0.2.90.**
+> **Version: 0.2.92.**
 > 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.
@@ -442,8 +442,9 @@ history:
 - Each active Markdown memory retains at most 16 detailed provenance rows while tracking cumulative `source_count`, `source_digest`, and omitted rows, so repeated UPDATEs cannot grow `sources` without bound.
 - Completed/cancelled todos remain in `knowledge/` as stable current identities. The default active view hides them, while `list_todos(status=completed|cancelled|all)` and later maintenance can still resolve the original ID. `closed_todo_retention_days` remains only as a legacy configuration key.
 - With `history.policy: bounded`, each stable memory identity keeps at most 32 full historical versions, and versions older than 3650 days are eligible for pruning. Set `history.policy: keep_all` explicitly when permanent audit retention is required.
-- Compaction preserves an existing canonical `memory_id` instead of creating a new `mem-compact-*` identity; a single-memory rewrite keeps its ID and a multi-memory merge chooses one stable survivor.
-- Maintenance runs through normal `process()` / `remember()` / `compact()` lifecycle calls and requires no daemon. Ordinary read-only retrieval does not trigger maintenance writes.
+- Body compaction shortens each memory independently, preserving its ID, provenance, responsibility, status and deadline. Semantic consolidation of the same matter uses the extraction protocol's `MERGE` operation.
+- Normal `process()` / `remember()` calls perform deterministic history maintenance after processing. Pending mutations and recovery dependencies postpone maintenance and preserve recovery inputs. Read-only retrieval does not trigger maintenance writes.
+- Freshly completed turns can schedule at most one compaction request per batch when the configured threshold is reached, sharing that turn's durable five-request allowance with extraction. Below-threshold turns, cached replays and recently attempted identical inputs add no calls. The latest 64 input fingerprints are persisted, including no-op, failed and interrupted attempts. Maintenance results are reported separately without undoing committed facts. Explicit `compact()` remains body-only and does not implicitly prune history. No daemon is required.
 
 Directories are normally created with mode `0700`, and files are stored as plaintext by default. memleaf has no built-in encryption layer; protect the Vault, backups, and model credentials yourself.
 

{memleaf-0.2.90 → memleaf-0.2.92}/README.md

@@ -4,7 +4,7 @@
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **版本：0.2.90。**
+> **版本：0.2.92。**
 > 自动提炼和复核共用同一条“未来记忆价值”标准：模型综合未来复用、信息增量、再次读取时的直接可用性和忘记成本，只保留对未来理解、判断或行动有实质影响的最小核心；没有明确价值的信息不提炼，不按具体业务场景硬编码排除。
 > 提炼先比较旧事项中的编号、目标、进展、责任和期限；补全未知信息也应维护原事项，另建独立待办不能替代项目事实更新。确认重复的记忆在现有处理请求中合并，保留历史与来源；项目和独立任务保持各自生命周期，Core 不按标题强行合并。
 > 新请求兼容等价的字段表示；未知执行人保持 `null`，新增或变更负责人和期限需要真实来源；等待条件在正文维护，不再提炼 `waiting_on`。行动及相关字段经过有界语义复核，提炼与复核共用每份工作的最多五次模型请求额度，成功即停止；复核失败不写入。来源时间用于解析相对日期，不补造事实日期。
@@ -443,8 +443,9 @@ history:
 - active Markdown 每条最多保留 16 个来源明细，同时记录累计 `source_count`、`source_digest` 和省略数量，避免 UPDATE 让 `sources` 无限膨胀；
 - 已完成/已取消 todo 保留在 `knowledge/` 中作为稳定当前身份，默认 active 清单不展示，但 `list_todos(status=completed|cancelled|all)` 和后续维护仍可按原 ID 定位；`closed_todo_retention_days` 仅作为旧配置兼容项保留；
 - `history.policy: bounded` 默认每个稳定记忆身份最多保留 32 个完整历史版本，且超过 3650 天的版本可被维护流程淘汰；需要永久审计时可显式设置 `history.policy: keep_all`；
-- compaction 会保留一个既有 canonical `memory_id`，不会再为整理结果创建新的 `mem-compact-*` 身份；单条精简保持原 ID，多条合并选择一个稳定 survivor。
-- 这些维护动作在正常 `process()` / `remember()` / `compact()` 生命周期中执行，不需要 daemon；普通只读检索本身不触发维护写入。
+- 正文 compaction 逐条精简，保持原 `memory_id` 和来源、责任、状态、期限，不合并独立身份；同一事项的语义合并由提炼协议的 `MERGE` 处理。
+- 正常 `process()` / `remember()` 结束后执行确定性历史维护；有未完成写入或恢复依赖时推迟维护，保留恢复输入。普通只读检索不触发维护写入。
+- 新完成的轮次达到正文压缩阈值时，每批最多一次压缩调用，与该轮提炼共用不超过 5 次的持久额度。低于阈值、缓存重放、近期相同输入已尝试时不增加调用；持久保留最近 64 个输入指纹，压缩无收益、失败或进程中断也计入去重。维护结果独立报告，不将已提交的事实回滚。显式 `compact()` 仍只执行正文压缩，不隐式清理历史；无需 daemon。
 
 默认目录尽量使用 `0700`，文件默认明文保存。memleaf 没有内置加密层，请自行保护 Vault、备份和模型调用凭证。
 

{memleaf-0.2.90 → memleaf-0.2.92}/pyproject.toml

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

{memleaf-0.2.90 → memleaf-0.2.92}/src/memleaf/__init__.py

@@ -1,6 +1,6 @@
 """Local-first Markdown memory core for AI agents."""
 
-__version__ = "0.2.90"
+__version__ = "0.2.92"
 
 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.90 → memleaf-0.2.92}/src/memleaf/compaction.py

@@ -605,10 +605,13 @@ class Compactor:
         replacements: list[_Replacement],
         *,
         now: str,
+        before_commit: Any = None,
     ) -> tuple[list[str], list[str]]:
         replacement_ids = [replacement.memory.memory_id for replacement in replacements]
         selected_by_id = {candidate.memory.memory_id: candidate for candidate in selected}
         with self.service._mutation_boundary():
+            if before_commit is not None:
+                before_commit()
             current_scan = scan_memories(self.service.vault)
             if current_scan.issues:
                 raise CompactionError("current-memory scan changed during compaction")
@@ -737,7 +740,8 @@ class Compactor:
             "history_written": [],
         }
 
-    def _run(self, *, model: Any = None, router: Any = None, explicit: bool) -> dict[str, Any]:
+    def _run(self, *, model: Any = None, router: Any = None, explicit: bool,
+             admit: Any = None, before_commit: Any = None) -> dict[str, Any]:
         threshold, ratio = self._config()
         now = _clock_now(getattr(self.service, "clock", None))
         selected, all_active, active_tokens = self._snapshot(threshold, ratio)
@@ -758,6 +762,11 @@ class Compactor:
                 raise CompactionError("compaction input exceeds size limit")
             result["request_bytes"] = request_bytes
             backend = self._resolve_backend(model=model, router=router)
+            if admit is not None:
+                reason = admit(selected, threshold, ratio)
+                if reason is not None:
+                    result.update(status="deferred", code=reason)
+                    return result
             try:
                 result["backend_calls"] += 1
                 raw = backend.complete(
@@ -788,6 +797,7 @@ class Compactor:
                 all_active,
                 replacements,
                 now=now,
+                before_commit=before_commit,
             )
             with self.service.vault.lock():
                 active_after = [record.memory for record in self.service._read_memories_unlocked("knowledge")]
@@ -826,9 +836,11 @@ class Compactor:
     def compact(self, *, model: Any = None, router: Any = None) -> dict[str, Any]:
         return self._run(model=model, router=router, explicit=True)
 
-    def auto(self, *, model: Any = None, router: Any = None) -> dict[str, Any]:
+    def auto(self, *, model: Any = None, router: Any = None,
+             admit: Any = None, before_commit: Any = None) -> dict[str, Any]:
         try:
-            return self._run(model=model, router=router, explicit=False)
+            return self._run(model=model, router=router, explicit=False,
+                             admit=admit, before_commit=before_commit)
         except Exception as error:
             status = _error_kind(error)
             return {

{memleaf-0.2.90 → memleaf-0.2.92}/src/memleaf/extraction_work_state.py

@@ -28,6 +28,7 @@ _MAX_BUDGET_BYTES = 8 * 1024 * 1024
 _PROCESS_JOB_VERSION = 1
 _MAX_WORKS = 128
 _MAX_TURNS_PER_WORK = 64
+_MAX_MAINTENANCE_SNAPSHOTS = 64
 
 
 class ExtractionWorkStateError(RuntimeError):
@@ -95,11 +96,15 @@ def _normalize_turn_state(value: Any) -> dict[str, Any]:
     completed = value.get("completed", False)
     if not isinstance(completed, bool):
         raise ExtractionWorkStateError("invalid extraction request budget completion")
+    maintenance_reserved = value.get("maintenance_reserved", False)
+    if type(maintenance_reserved) is not bool or (maintenance_reserved and not completed):
+        raise ExtractionWorkStateError("invalid maintenance request reservation")
     return {
         "requests": requests,
         "started_at_epoch": float(started) if started is not None else None,
         "request_limit_at_creation": stored_limit,
         "completed": completed,
+        **({"maintenance_reserved": True} if maintenance_reserved else {}),
     }
 
 
@@ -164,7 +169,13 @@ def _read_budget_state_unlocked(vault: Any) -> dict[str, Any]:
     retired_count = sum(w.get("retired", False) for w in normalized_works.values())
     if len(normalized_works) - retired_count > _MAX_WORKS or retired_count > _MAX_RETIRED_WORKS:
         raise ExtractionWorkStateError("extraction request budget state exceeds bound")
-    return {"version": value["version"], "works": normalized_works, "order": normalized_order}
+    snapshots = value.get("maintenance_snapshots", [])
+    if (not isinstance(snapshots, list) or len(snapshots) > _MAX_MAINTENANCE_SNAPSHOTS
+            or any(not isinstance(s, str) or re.fullmatch(r"[0-9a-f]{64}", s) is None for s in snapshots)
+            or len(set(snapshots)) != len(snapshots)):
+        raise ExtractionWorkStateError("invalid maintenance snapshots")
+    return {"version": value["version"], "works": normalized_works, "order": normalized_order,
+            **({"maintenance_snapshots": snapshots} if snapshots else {})}
 
 
 def _save_budget_state_unlocked(vault: Any, state: dict[str, Any]) -> None:
@@ -401,6 +412,42 @@ def complete_turn_budget(vault: Any, *, work_id: str, turn_id: str) -> bool:
         return False
 
 
+def _remember_maintenance_snapshot_unlocked(vault: Any, state: dict[str, Any], snapshot: str) -> None:
+    if not isinstance(snapshot, str) or re.fullmatch(r"[0-9a-f]{64}", snapshot) is None:
+        raise ExtractionWorkStateError("invalid maintenance snapshot")
+    snapshots = [s for s in state.get("maintenance_snapshots", []) if s != snapshot]
+    state["maintenance_snapshots"] = (snapshots + [snapshot])[-_MAX_MAINTENANCE_SNAPSHOTS:]
+    _save_budget_state_unlocked(vault, state)
+
+
+def _reserve_maintenance_unlocked(vault: Any, *, work_id: str, turn_id: str,
+                                  snapshot: str, minimum_requests: int = 0) -> tuple[int | None, str | None]:
+    """Caller holds the lock and proves the linked run fully committed.
+
+    Only one optional maintenance call can use the remaining allowance of a
+    completed turn. Completion stays sealed; extraction can never resume from
+    this reservation. Count and input deduplication precede outbound IO in the
+    same atomic file write, including uncertain process exits.
+    """
+    state = _read_budget_state_unlocked(vault)
+    work = state["works"].get(work_id)
+    turn = work.get("turns", {}).get(turn_id) if work else None
+    if not turn or not turn["completed"] or work.get("retired"):
+        return None, "maintenance_budget_unavailable"
+    if turn["requests"] < minimum_requests:
+        raise ExtractionWorkStateError("maintenance budget evidence incomplete")
+    if snapshot in state.get("maintenance_snapshots", []):
+        return None, "maintenance_snapshot_already_attempted"
+    if turn.get("maintenance_reserved"):
+        return None, "maintenance_already_reserved"
+    if turn["requests"] >= min(turn["request_limit_at_creation"], MAX_INCREMENTAL_REQUESTS):
+        return None, "request_budget_exhausted"
+    turn["requests"] += 1
+    turn["maintenance_reserved"] = True
+    _remember_maintenance_snapshot_unlocked(vault, state, snapshot)
+    return turn["requests"], None
+
+
 __all__ = [
     "ExtractionWorkStateError",
     "active_background_work_id",

{memleaf-0.2.90 → memleaf-0.2.92}/src/memleaf/hermes_provider/plugin.yaml

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

memleaf-0.2.92/src/memleaf/historical_context.py

@@ -0,0 +1,83 @@
+"""Read-only historical comparisons, separate from actionable memory targets."""
+from collections.abc import Mapping
+from copy import deepcopy
+from typing import Any
+
+from .models import Memory
+from .retrieval_lifecycle import project_lifecycle
+from .turn_plan import revision_digest
+from .vault import safe_component
+
+
+def freeze_history(value: Any, targets: Mapping[str, dict[str, Any]]) -> dict[str, Any]:
+    if value is None:
+        return {}
+    if not isinstance(value, Mapping):
+        raise ValueError("invalid_history_context")
+    current = {t["memory"]["memory_id"]: t for t in targets.values()}
+    identities = {identity.casefold() for identity in current}
+    result = {}
+    for identity, item in value.items():
+        if (not isinstance(identity, str) or not isinstance(item, Mapping)
+                or set(item) != {"memory", "lifecycle"}
+                or not isinstance(item["memory"], Memory)
+                or identity != item["memory"].memory_id):
+            raise ValueError("invalid_history_context")
+        safe_component(identity, "memory id")
+        if identity.casefold() in identities:
+            raise ValueError("duplicate_memory_id")
+        identities.add(identity.casefold())
+        life = project_lifecycle(item["lifecycle"])
+        if not life["historical"]:
+            raise ValueError("invalid_history_context")
+        head = current.get(life.get("active_memory_id"))
+        validity = head["memory"].get("validity", "valid") if head and "native" not in head else None
+        if life["current_validity"] != validity:
+            raise ValueError("invalid_history_context")
+        result[identity] = {"memory": item["memory"].to_dict(),
+                            "revision": revision_digest(item["memory"]), "lifecycle": life}
+    return result
+
+
+def thaw_history(value: Any) -> dict[str, Any] | None:
+    if value is None:
+        return None
+    if not isinstance(value, Mapping):
+        raise ValueError("invalid_history_context")
+    result = {}
+    for identity, item in value.items():
+        if (not isinstance(item, Mapping) or set(item) != {"memory", "revision", "lifecycle"}
+                or not isinstance(item["memory"], Mapping)):
+            raise ValueError("invalid_history_context")
+        memory = Memory.from_mapping(item["memory"])
+        if revision_digest(memory) != item["revision"]:
+            raise ValueError("invalid_history_context")
+        result[identity] = {"memory": memory, "lifecycle": item["lifecycle"]}
+    return result
+
+
+def history_signature(state: Mapping[str, Any]) -> dict[str, Any]:
+    # Current validity is derived from targets, whose changes (including this
+    # work's own writes) are already checked by partial recovery.
+    return {identity: {"revision": item["revision"],
+                       "lifecycle": {k: v for k, v in item["lifecycle"].items()
+                                     if k != "current_validity"}}
+            for identity, item in state.get("history_context", {}).items()}
+
+
+def project_history(state: Mapping[str, Any], scope_refs: Mapping[str, str]) -> list[dict[str, Any]]:
+    targets = {t["memory"]["memory_id"]: ref for ref, t in state["targets"].items()
+               if "native" not in t}
+    result = []
+    for item in state.get("history_context", {}).values():
+        memory = item["memory"]
+        row = {key: deepcopy(memory[key]) for key in (
+            "type", "title", "body", "status", "validity", "actionable", "assignee",
+            "due_date", "due_text", "due_status", "completed_at") if key in memory}
+        scopes = memory.get("scopes", ["global"])
+        row["scope"] = scope_refs.get(scopes[0], scopes[0]) if len(scopes) == 1 else scopes
+        life = dict(item["lifecycle"])
+        row["current_target"] = targets.get(life.pop("active_memory_id", None))
+        row["lifecycle"] = life
+        result.append(row)
+    return result

{memleaf-0.2.90 → memleaf-0.2.92}/src/memleaf/incremental_preview.py

@@ -155,6 +155,37 @@ def _prepare_incremental_unlocked(service: Any, *, source: str, session_id: str,
             read_ids.extend(identities)
     priority = list(dict.fromkeys(explicit_ids + read_ids + priority))
     priority += sorted(x for x in prior_ids if x.casefold() in records and x not in priority)
+    historical = {}
+    explicit_keys = {identity.casefold() for identity in explicit_ids}
+    if any(identity.casefold() not in records for identity in priority):
+        # Ordinary turns keep their knowledge-only scan. Read/caller-required
+        # identities that are absent there may be exact historical versions.
+        # Reuse the public scanner's duplicate, path and generation checks.
+        library = scan_memories(service.vault, include_history=True)
+        if library.ambiguous or native_keys.intersection(r.memory.memory_id.casefold() for r in library.records):
+            raise ValueError("duplicate_memory_id")
+        if library.issues:
+            raise ValueError("incomplete_library")
+        records = {r.memory.memory_id.casefold(): r.memory for r in library.area("knowledge")}
+        records.update({key.casefold(): memory for key, memory in native.memories.items()})
+        archives = {r.memory.memory_id.casefold(): r for r in library.area("history")}
+        from .retrieval_lifecycle import current_validities, lifecycle
+        current = current_validities(library)
+        current_priority = []
+        for identity in priority:
+            if identity.casefold() in records:
+                current_priority.append(identity)
+                continue
+            archive = archives.get(identity.casefold())
+            if archive is None or identity.casefold() in explicit_keys:
+                raise ValueError("required_target_unavailable")
+            life = lifecycle(archive, current)
+            historical[archive.memory.memory_id] = {"memory": archive.memory, "lifecycle": life}
+            # A stored unambiguous local link supplies comparison context, not
+            # new write authority; the existing scope boundary still applies.
+            if life["current_validity"] is not None:
+                current_priority.append(life["active_memory_id"])
+        priority = list(dict.fromkeys(current_priority))
     chosen = []
     for identity in priority:
         if identity.casefold() not in records:
@@ -202,6 +233,7 @@ def _prepare_incremental_unlocked(service: Any, *, source: str, session_id: str,
     return PlanningSnapshot.build(evidence=evidence, targets=targets, scopes=scope_refs,
                                   write_scopes=boundary, writable=writable,
                                   allow_new_scopes=allow_new_scopes, native_targets=native_targets,
+                                  history_context=historical,
                                   native_guard=native.guard if native.guard["sources"] else None,
                                   request_kind="explicit_remember" if selection else "automatic",
                                   retention_request=retention_request, scope_guard=scope_guard,

{memleaf-0.2.90 → memleaf-0.2.92}/src/memleaf/incremental_prompts.py

@@ -39,4 +39,5 @@ patch 只含 title/body/scope/status/actionable/assignee/deadline/validity；typ
 request_kind=explicit_remember：所选 new 有保留授权，仍按用户实际要求选择内容并整理去重，不得 NO_MEMORY；独立不被要求保留的内容不强行建项。
 仅 whole_host_turn=true 的宿主完整回合显式请求：遵守用户指定的保存/排除范围，同时按自动记忆标准处理整轮其余有价值的独立新信息；不要因已保存一项而跳过其他。助手建议仍不能变成用户义务。
 explicit_writes 是系统核验的已写目标关联，不是新证据或整轮已覆盖声明：先比较当前目标与 new，完整无变化 NO_CHANGE，同一事项新增 UPDATE，独立新事项仍 CREATE。不用旧回执覆盖较新目标。
+history_context 是已读历史版本，只供比较，不是新事实或操作 target；current_target 指向当前候选，current_validity=null 表示未知。历史正文及当时状态不覆盖当前候选。
 """

{memleaf-0.2.90 → memleaf-0.2.92}/src/memleaf/incremental_protocol.py

@@ -287,6 +287,7 @@ class PlanningSnapshot:
               allow_new_scopes: bool = False, context_complete: bool = True,
               native_targets: Mapping[str, dict[str, Any]] | None = None,
               native_guard: dict[str, Any] | None = None,
+              history_context: Mapping[str, Any] | None = None,
               retention_request: str | None = None, scope_guard: dict[str, Any] | None = None,
               scope_aliases: Mapping[str, list[str]] | None = None,
               basis_statuses: Mapping[str, str] | None = None,
@@ -371,6 +372,10 @@ class PlanningSnapshot:
         state = {"protocol_version": PROTOCOL_VERSION, "evidence": evidence, "targets": target_values,
                  "scopes": scopes, "write_scopes": write_scopes, "request_kind": request_kind,
                  "allow_new_scopes": allow_new_scopes, "context_complete": context_complete}
+        from .historical_context import freeze_history
+        historical = freeze_history(history_context, target_values)
+        if historical:
+            state["history_context"] = historical
         if extraction_contract is not None:
             state["extraction_contract"] = extraction_contract
         from .incremental_explicit import validate_links
@@ -415,6 +420,9 @@ class PlanningSnapshot:
         state["targets"] = {ref: {"revision": item["revision"], "writable": item["writable"],
                                   **({"native": item["native"]} if "native" in item else {})}
                             for ref, item in state["targets"].items()}
+        if "history_context" in state:
+            state["history_context"] = {identity: {"revision": item["revision"], "lifecycle": item["lifecycle"]}
+                                        for identity, item in state["history_context"].items()}
         return hashlib.sha256(_json(state).encode("utf-8")).hexdigest()
 
     def state(self) -> dict[str, Any]:
@@ -454,6 +462,7 @@ class PlanningSnapshot:
                 projection["calendar_hints"] = hints
             projected_evidence.append(projection)
         from .incremental_explicit import project_links
+        from .historical_context import project_history
         return {
             "protocol_version": PROTOCOL_VERSION, "request_kind": state["request_kind"],
             **({"extraction_contract": state["extraction_contract"]} if "extraction_contract" in state else {}),
@@ -463,6 +472,7 @@ class PlanningSnapshot:
                if state.get("scope_aliases") else {}),
             "allow_new_scopes": state["allow_new_scopes"], "context_complete": state["context_complete"],
             "evidence": projected_evidence, "memories": memories,
+            **({"history_context": project_history(state, reverse_scope)} if state.get("history_context") else {}),
             **({"explicit_writes": project_links(state["explicit_writes"], state["targets"])}
                if state.get("explicit_writes") else {}),
         }

{memleaf-0.2.90 → memleaf-0.2.92}/src/memleaf/incremental_recovery.py

@@ -12,6 +12,7 @@ from typing import Any
 from .incremental_protocol import PlanningSnapshot, MAX_ITEMS
 from .models import Memory
 from .validation import parse_strict_json
+from .historical_context import thaw_history, history_signature
 
 RECOVERY_SYSTEM = "\n本次仅重规划未结算的 new；settled 只读，不重出、不改写。新增前文和已有记忆仅帮助理解原事项，不据此新建无关事项。沿用 JSON 协议。\n"
 
@@ -36,6 +37,7 @@ def restore_snapshot(state: Any) -> PlanningSnapshot:
             vault_binding=state.get("vault_binding"),
             explicit_writes=state.get("explicit_writes"),
             extraction_contract=state.get("extraction_contract"),
+            history_context=thaw_history(state.get("history_context")),
         )
     except (KeyError, TypeError) as error:
         raise ValueError("invalid_partial_snapshot") from error
@@ -175,6 +177,7 @@ def context_changed(original: PlanningSnapshot, current: PlanningSnapshot, work:
     new_e = {e["event_key"]: {k: v for k, v in e.items() if k != "ref"} for e in new["evidence"]}
     from .incremental_scopes import guard_matches, applied_additions
     if (old_e != new_e or old.get("native_guard") != new.get("native_guard")
+            or history_signature(old) != history_signature(new)
             or not guard_matches(new.get("scope_guard"), old.get("scope_guard"), applied_additions(work))):
         return True
     expected = {t["memory"]["memory_id"]: t["revision"] for t in old["targets"].values()}
@@ -247,6 +250,8 @@ def recovery_snapshot(original: PlanningSnapshot, current: PlanningSnapshot, wor
             raise ValueError("repair_context_changed")
         if old.get("native_guard") != new.get("native_guard"):
             raise ValueError("repair_context_changed")
+        if history_signature(old) != history_signature(new):
+            raise ValueError("repair_context_changed")
         # A structural repair may not silently adapt any referenced target's
         # earlier business decision to a different complete target snapshot.
         for row in work.get("_repair_rows", []):
@@ -270,6 +275,7 @@ def recovery_snapshot(original: PlanningSnapshot, current: PlanningSnapshot, wor
                                   scope_guard=new.get("scope_guard"), scope_aliases=new.get("scope_aliases"),
                                   basis_statuses=statuses, vault_binding=new.get("vault_binding"),
                                   explicit_writes=explicit_links,
+                                  history_context=thaw_history(new.get("history_context")),
                                   extraction_contract=(old if mode == "repair" else new).get("extraction_contract"))
 
 

{memleaf-0.2.90 → memleaf-0.2.92}/src/memleaf/incremental_semantics.py

@@ -153,6 +153,15 @@ def apply_review(request, response):
         if set(review) - {"decisions", "updates"} or not isinstance(decisions, list) or len(decisions) != len(rows):
             raise ValueError
         positions = set()
+        rejected = []
+        def discard(row):
+            # A rejected maintenance proposal is not proof that the source
+            # needs no change. Keep its unresolved disposition even when other
+            # candidates survive the review. Ordinary rejected automatic
+            # CREATEs can still mean there was no durable fact to retain.
+            if (row.get("action") in {"UPDATE", "MERGE"}
+                    or data["original_input"].get("request_kind") == "explicit_remember"):
+                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"}):
@@ -206,6 +215,7 @@ def apply_review(request, response):
             if isinstance(row, dict) and row.get("action") in {"NO_CHANGE", "NO_MEMORY", "DEFERRED"}:
                 continue  # Review cannot erase an unresolved control disposition.
             if not decision["keep"] or any(not support.get(k, True) for k in _REQUIRED.get(row["action"].upper(), set())):
+                discard(row)
                 rows[i] = None
                 continue
             payload = row.get("memory" if row["action"].upper() == "CREATE" else "patch", {})
@@ -241,6 +251,7 @@ def apply_review(request, response):
                     if name == "deadline":
                         row.pop("deadline_decision", None)
             if row["action"].upper() == "UPDATE" and not payload:
+                discard(row)
                 rows[i] = None
         rows = [r for r in rows if r is not None]
         additions = review.get("updates", [])
@@ -256,6 +267,21 @@ def apply_review(request, response):
                 raise ValueError
             rows.append(row)
             used.add(row["target"])
+        for rejected_row in rejected:
+            # The same review can supply a complete, independently validated
+            # correction for this target. An unrelated NO_CHANGE cannot cover
+            # a rejected proposal, nor can UPDATE stand in for a rejected MERGE.
+            if rejected_row.get("action") == "UPDATE" and any(
+                    row.get("action") == "UPDATE" and row.get("target") == rejected_row.get("target")
+                    and set(rejected_row.get("evidence", [])) <= set(row.get("evidence", []))
+                    and fields(rejected_row) <= fields(row)
+                    for row in rows):
+                continue
+            rows.append({"action": "DEFERRED", "evidence": rejected_row.get("evidence", []),
+                         "reason": "missing_context",
+                         "need": "The proposed retention or maintenance was rejected by source review."})
+        if len(rows) > MAX_ITEMS:
+            raise ValueError
         if not rows:
             original = data["original_input"]
             if original.get("request_kind") == "explicit_remember":