memleaf 0.2.86__tar.gz → 0.2.87__tar.gz

{memleaf-0.2.86 → memleaf-0.2.87}/CHANGELOG.md

@@ -4,6 +4,39 @@ All notable changes to memleaf are documented here.
 
 ## Unreleased
 
+## 0.2.87 — 2026-10-04
+
+### Shared source-bound maintenance with bounded model cost
+
+- Allow up to five actual requests per incremental work item, stopping on
+  success. Extraction, format retries, review and recovery share the durable
+  allowance; older work retains its smaller creation-time limit.
+- Bind conversational lifecycle updates to the captured host turn. MCP
+  `update_memory` no longer accepts model-supplied source times or directly
+  commits rewritten facts when host-bound. Preserve the trusted Python API.
+- Retire `waiting_on` from extraction and model/read/list projections; maintain
+  dependencies in the current body. Legacy stored data remains readable.
+- Merge confirmed duplicate memories through the existing processing requests.
+  Preserve combined facts, provenance and history; reject incompatible targets.
+  Commit the survivor before retracting duplicates, with dependency revisions
+  checked at the final writer boundary and recoverable frozen operations.
+- Maintain shared facts across related project and task records using the
+  existing source-bound review. Independent lifecycles remain separate.
+- Retract withdrawn facts/preferences through validity, retaining their history;
+  explicit replacement preferences remain valid. Task cancellation is not a
+  substitute for preference withdrawal.
+- Reuse successful, verified full-turn host retention to settle automatic work
+  without another model request. Partial selected retention does not claim
+  complete automatic coverage. Record actual API token usage without extra
+  requests or counting cached replay usage again.
+- Count known provenance overlaps once; mark counts for truncated histories as
+  upper bounds when their unseen overlap cannot be reconstructed.
+- Validation: 483 affected regression and installation/acceptance checks passed;
+  nine isolated real DeepSeek scenarios and the installed Hermes background
+  callback with current source passed. Saved faulty time arguments were rejected
+  in an isolated zero-call replay. No production memory migration or historical
+  failed-run retry was performed.
+
 ## 0.2.86 — 2026-10-04
 
 ### Source-bound Hermes retention and general extraction compatibility

{memleaf-0.2.86/src/memleaf.egg-info → memleaf-0.2.87}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 0.2.86
+Version: 0.2.87
 Summary: A local-first Markdown memory core for AI agents
 Author: memleaf contributors
 License-Expression: MIT
@@ -23,10 +23,10 @@ Dynamic: license-file
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **版本：0.2.86。**
+> **版本：0.2.87。**
 > 自动提炼和复核共用同一条“未来记忆价值”标准：模型综合未来复用、信息增量、再次读取时的直接可用性和忘记成本，只保留对未来理解、判断或行动有实质影响的最小核心；没有明确价值的信息不提炼，不按具体业务场景硬编码排除。
-> 提炼先比较旧事项中的编号、目标、进展、责任和期限；补全未知信息也应维护原事项，另建独立待办不能替代项目事实更新。Core 不按标题强行合并。
-> 新请求兼容等价的字段表示；未知执行人保持 `null`，新增或变更负责人、等待方和期限需要真实来源。行动及相关字段经过有界语义复核，提炼与复核共用每份工作的最多两次模型请求额度；复核失败不写入。来源时间用于解析相对日期，不补造事实日期。
+> 提炼先比较旧事项中的编号、目标、进展、责任和期限；补全未知信息也应维护原事项，另建独立待办不能替代项目事实更新。确认重复的记忆在现有处理请求中合并，保留历史与来源；项目和独立任务保持各自生命周期，Core 不按标题强行合并。
+> 新请求兼容等价的字段表示；未知执行人保持 `null`，新增或变更负责人和期限需要真实来源；等待条件在正文维护，不再提炼 `waiting_on`。行动及相关字段经过有界语义复核，提炼与复核共用每份工作的最多五次模型请求额度，成功即停止；复核失败不写入。来源时间用于解析相对日期，不补造事实日期。
 > 待办 `due_date` 只表示待办动作本身明确声明的截止日；属于待办主题或预期结果的日期不会被误作截止日。项目归属由模型按语义判断，不要求项目名在证据里逐字出现。复核阶段会保留首轮已选定的更新目标，避免“状态变更”被降级成新增记忆。Markdown 仍是唯一事实源。
 > **当前版本支持 Hermes 和 Codex。** Antigravity（反重力）不检测、不安装、不配置。
 
@@ -285,7 +285,7 @@ python -m memleaf.mcp_server --vault "$HOME/.memleaf"
 | `process_status` | 只读查询异步处理 job 状态 |
 | `recover_failed_run` | 预览并显式恢复终态传输失败，保留原请求预算 |
 | `remember` | 用户明确要求时创建或更新记忆 |
-| `update_memory` | 携带当前 revision 办结、取消或重新激活任务，保留正文与历史 |
+| `update_memory` | 携带当前 revision 维护任务或撤回事实/偏好；宿主绑定的调用排队处理真实消息 |
 | `forget_memory` | 用户明确要求遗忘时，携带 `confirm_delete=true` 按精确 ID 永久删除 |
 | `forget_about` | 携带 `confirm_delete=true` 遗忘明确主题；有歧义时只返回候选 |
 | `rebuild_index` | 重建可重建的本地派生索引 |
@@ -361,7 +361,7 @@ python -m memleaf.mcp_server --vault /path/to/your/vault \
 
 捕获、索引、目录检索和读取可离线运行；`process()`、`remember()` 和 `compact()` 需要可用的模型能力。
 
-包含行动或责任、期限变更的增量候选通常会追加一次语义复核；每份增量工作最多两次请求，格式修复也计入同一额度。
+包含行动或责任、期限变更的增量候选通常会追加一次语义复核；每份增量工作最多五次请求，格式修复与恢复也计入同一持久化额度，成功即停止。
 
 `llm.mode` 支持：
 

{memleaf-0.2.86 → memleaf-0.2.87}/README.en.md

@@ -4,10 +4,10 @@
 
 [中文](README.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **Version: 0.2.86.**
+> **Version: 0.2.87.**
 > 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. Core does not merge matching titles.
-> New requests accept equivalent field representations. Unknown executors remain `null`; new or changed responsibility, dependencies and deadlines require actual source evidence. Proposed actions and related fields undergo bounded semantic verification within the existing two-request limit per work item; failed verification blocks writes. Source time resolves relative dates without inventing factual dates.
+> 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.
 > A todo's `due_date` means only the explicit deadline of the todo action; dates describing its subject or desired outcome are not deadlines. Project ownership remains the model's semantic judgement and needs no literal name match. The review stage now keeps the update target chosen by the first pass, so a state change is no longer downgraded into a new memory. Markdown remains the sole source of truth.
 > **The current release supports Hermes and Codex.** Antigravity is not detected, installed, or configured.
 
@@ -266,7 +266,7 @@ The server exposes the following tools:
 | `process_status` | Read the status of a background processing job |
 | `recover_failed_run` | Preview and explicitly recover terminal transport failures within the original request budget |
 | `remember` | Create or update memory after an explicit request |
-| `update_memory` | Complete, cancel or reopen a task using its current revision; retain body and history |
+| `update_memory` | Maintain tasks or retract facts/preferences using their current revision; host-bound calls queue actual source messages |
 | `forget_memory` | Permanently delete an exact ID after explicit user forgetting, with `confirm_delete=true` |
 | `forget_about` | Forget an unambiguous topic with `confirm_delete=true`; return candidates when ambiguous |
 | `rebuild_index` | Rebuild local derived indexes |

{memleaf-0.2.86 → memleaf-0.2.87}/README.md

@@ -4,10 +4,10 @@
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **版本：0.2.86。**
+> **版本：0.2.87。**
 > 自动提炼和复核共用同一条“未来记忆价值”标准：模型综合未来复用、信息增量、再次读取时的直接可用性和忘记成本，只保留对未来理解、判断或行动有实质影响的最小核心；没有明确价值的信息不提炼，不按具体业务场景硬编码排除。
-> 提炼先比较旧事项中的编号、目标、进展、责任和期限；补全未知信息也应维护原事项，另建独立待办不能替代项目事实更新。Core 不按标题强行合并。
-> 新请求兼容等价的字段表示；未知执行人保持 `null`，新增或变更负责人、等待方和期限需要真实来源。行动及相关字段经过有界语义复核，提炼与复核共用每份工作的最多两次模型请求额度；复核失败不写入。来源时间用于解析相对日期，不补造事实日期。
+> 提炼先比较旧事项中的编号、目标、进展、责任和期限；补全未知信息也应维护原事项，另建独立待办不能替代项目事实更新。确认重复的记忆在现有处理请求中合并，保留历史与来源；项目和独立任务保持各自生命周期，Core 不按标题强行合并。
+> 新请求兼容等价的字段表示；未知执行人保持 `null`，新增或变更负责人和期限需要真实来源；等待条件在正文维护，不再提炼 `waiting_on`。行动及相关字段经过有界语义复核，提炼与复核共用每份工作的最多五次模型请求额度，成功即停止；复核失败不写入。来源时间用于解析相对日期，不补造事实日期。
 > 待办 `due_date` 只表示待办动作本身明确声明的截止日；属于待办主题或预期结果的日期不会被误作截止日。项目归属由模型按语义判断，不要求项目名在证据里逐字出现。复核阶段会保留首轮已选定的更新目标，避免“状态变更”被降级成新增记忆。Markdown 仍是唯一事实源。
 > **当前版本支持 Hermes 和 Codex。** Antigravity（反重力）不检测、不安装、不配置。
 
@@ -266,7 +266,7 @@ python -m memleaf.mcp_server --vault "$HOME/.memleaf"
 | `process_status` | 只读查询异步处理 job 状态 |
 | `recover_failed_run` | 预览并显式恢复终态传输失败，保留原请求预算 |
 | `remember` | 用户明确要求时创建或更新记忆 |
-| `update_memory` | 携带当前 revision 办结、取消或重新激活任务，保留正文与历史 |
+| `update_memory` | 携带当前 revision 维护任务或撤回事实/偏好；宿主绑定的调用排队处理真实消息 |
 | `forget_memory` | 用户明确要求遗忘时，携带 `confirm_delete=true` 按精确 ID 永久删除 |
 | `forget_about` | 携带 `confirm_delete=true` 遗忘明确主题；有歧义时只返回候选 |
 | `rebuild_index` | 重建可重建的本地派生索引 |
@@ -342,7 +342,7 @@ python -m memleaf.mcp_server --vault /path/to/your/vault \
 
 捕获、索引、目录检索和读取可离线运行；`process()`、`remember()` 和 `compact()` 需要可用的模型能力。
 
-包含行动或责任、期限变更的增量候选通常会追加一次语义复核；每份增量工作最多两次请求，格式修复也计入同一额度。
+包含行动或责任、期限变更的增量候选通常会追加一次语义复核；每份增量工作最多五次请求，格式修复与恢复也计入同一持久化额度，成功即停止。
 
 `llm.mode` 支持：
 

{memleaf-0.2.86 → memleaf-0.2.87}/examples/incremental_acceptance.json

@@ -31,7 +31,7 @@
           "expected": {
             "execution_status": "completed",
             "coverage_status": "complete",
-            "max_calls": 1,
+            "max_calls": 2,
             "count": 1,
             "required": [
               {
@@ -215,14 +215,13 @@
           "expected": {
             "execution_status": "completed",
             "coverage_status": "complete",
-            "max_calls": 1,
+            "max_calls": 2,
             "count": 1,
             "required": [
               {
                 "memory_id": "mem-report",
                 "status": "active",
                 "assignee": "林工",
-                "waiting_on": "客户验收",
                 "due_date": "2026-09-25"
               }
             ]
@@ -330,7 +329,7 @@
           "expected": {
             "execution_status": "completed",
             "coverage_status": "complete",
-            "max_calls": 1,
+            "max_calls": 2,
             "required": [
               {
                 "memory_id": "mem-report",
@@ -421,7 +420,7 @@
           "expected": {
             "execution_status": "completed",
             "coverage_status": "complete",
-            "max_calls": 1,
+            "max_calls": 2,
             "count": 2,
             "required": [
               {
@@ -471,7 +470,7 @@
           "expected": {
             "execution_status": "completed",
             "coverage_status": "complete",
-            "max_calls": 1,
+            "max_calls": 2,
             "count": 1,
             "required": [
               {
@@ -524,7 +523,7 @@
           "expected": {
             "execution_status": "completed",
             "coverage_status": "complete",
-            "max_calls": 1,
+            "max_calls": 2,
             "count": 1,
             "required": [
               {
@@ -564,7 +563,7 @@
           "expected": {
             "execution_status": "completed",
             "coverage_status": "complete",
-            "max_calls": 1,
+            "max_calls": 2,
             "count": 1,
             "required": [
               {
@@ -665,7 +664,7 @@
           "expected": {
             "execution_status": "completed",
             "coverage_status": "complete",
-            "max_calls": 1,
+            "max_calls": 2,
             "count": 2,
             "required": [
               {
@@ -732,7 +731,7 @@
           "expected": {
             "execution_status": "completed",
             "coverage_status": "complete",
-            "max_calls": 1,
+            "max_calls": 2,
             "count": 1,
             "required": [
               {

{memleaf-0.2.86 → memleaf-0.2.87}/pyproject.toml

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

{memleaf-0.2.86 → memleaf-0.2.87}/src/memleaf/__init__.py

@@ -1,6 +1,6 @@
 """Local-first Markdown memory core for AI agents."""
 
-__version__ = "0.2.86"
+__version__ = "0.2.87"
 
 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.86 → memleaf-0.2.87}/src/memleaf/acceptance.py

@@ -327,7 +327,7 @@ def _checks(expected: dict, records: list[dict], observations: list[dict], calls
         else:  # forbidden
             good = all(not any(matches(r, forbidden) for r in records) for forbidden in value)
         results.append({"check": key, "passed": good})
-    results.append({"check": "per_work_request_cap", "passed": result.get("reserved_requests", 0) <= 2})
+    results.append({"check": "per_work_request_cap", "passed": result.get("reserved_requests", 0) <= result["request_limit"]})
     return results
 
 

{memleaf-0.2.86 → memleaf-0.2.87}/src/memleaf/compaction.py

@@ -427,7 +427,7 @@ class Compactor:
         value = _content_mapping(candidate.memory)
         value["memory_id"] = candidate.memory.memory_id
         value["validity"] = candidate.memory.validity
-        for key in ("assignee", "waiting_on", "due_text"):
+        for key in ("assignee", "due_text"):
             if key in candidate.memory.extra:
                 value[key] = deepcopy(candidate.memory.extra[key])
         return value

{memleaf-0.2.86 → memleaf-0.2.87}/src/memleaf/extraction_budget.py

@@ -14,6 +14,8 @@ from .llm import ModelError
 
 
 MAX_MODEL_REQUESTS = 3
+# Incremental drafting, format repair and review share one durable allowance.
+MAX_INCREMENTAL_REQUESTS = 5
 TARGET_TOTAL_SECONDS = 10.0
 
 
@@ -205,6 +207,7 @@ def budget_single_pass_backend(
 
 __all__ = [
     "MAX_MODEL_REQUESTS",
+    "MAX_INCREMENTAL_REQUESTS",
     "TARGET_TOTAL_SECONDS",
     "ExtractionTiming",
     "aggregate_extraction_metrics",

{memleaf-0.2.86 → memleaf-0.2.87}/src/memleaf/extraction_work_state.py

@@ -17,7 +17,7 @@ from pathlib import Path
 from typing import Any, Mapping
 
 from .locking import atomic_write_json, read_json
-from .extraction_budget import MAX_MODEL_REQUESTS
+from .extraction_budget import MAX_MODEL_REQUESTS, MAX_INCREMENTAL_REQUESTS
 from .validation import parse_strict_json
 
 
@@ -307,7 +307,7 @@ def reserve_model_request(
         raise ExtractionWorkStateError("invalid extraction work id")
     if not _valid_identifier(turn_id, maximum=800):
         raise ExtractionWorkStateError("invalid extraction turn id")
-    if type(request_limit) is not int or not 1 <= request_limit <= MAX_MODEL_REQUESTS:
+    if type(request_limit) is not int or not 1 <= request_limit <= max(MAX_MODEL_REQUESTS, MAX_INCREMENTAL_REQUESTS):
         raise ExtractionWorkStateError("invalid extraction request limit")
     if type(legacy_source_unchanged) is not bool:
         raise ExtractionWorkStateError("invalid legacy source compatibility flag")

{memleaf-0.2.86 → memleaf-0.2.87}/src/memleaf/hermes_provider/README.md

@@ -17,6 +17,13 @@ A queued response is not a saved memory. The installer excludes standalone MCP
 supports `remember` for other clients, plus `forget` and maintenance operations.
 This is a Soft Gate, not a guarantee that every answer has performed retrieval.
 
+The bound native route also handles conversational corrections, completion,
+cancellation, reopening and withdrawal. A successful full-turn retention receipt
+settles automatic extraction without another model request. Partial selections
+remain separate. MCP lifecycle updates do not accept model-supplied source times;
+trusted Python callers keep their explicit metadata API. Restart Hermes after
+upgrading to load the current Provider.
+
 Hermes discovers this directory when it is installed as:
 
 ```text

{memleaf-0.2.86 → memleaf-0.2.87}/src/memleaf/hermes_provider/_provider.py

@@ -1403,7 +1403,7 @@ class MemleafMemoryProvider(MemoryProvider):
             "file writes to simulate success, and do not infer automatic success merely because "
             "active or history files exist. Automatic recall is a directory of "
             "scope identifiers, hierarchy, and aliases only; it never contains "
-            "memory IDs, titles, or bodies. For explicit retention use memleaf_remember with the current retrieval_id; it retains verified user messages after the complete turn is captured. Pending means not yet saved. Do not submit assistant-written facts through legacy MCP remember. "
+            "memory IDs, titles, or bodies. For explicit retention or corrections, task completion/cancellation/reopening, and withdrawing a fact/preference, use memleaf_remember with the current retrieval_id. It processes the actual complete turn and preserves audit history. Do not perform a conversational lifecycle edit through an unbound MCP update or infer message time from a deadline. Pending means not yet saved. Do not submit assistant-written facts through legacy MCP remember. "
             "Use deliberate remember/forget tools "
             "only when the user explicitly asks for that operation. Automatic "
             "capture and processing use only visible user and assistant text; "
@@ -2060,7 +2060,7 @@ class MemleafMemoryProvider(MemoryProvider):
         if not tool_name.startswith(prefix):
             return None
         name = tool_name[len(prefix):]
-        if name not in {"search", "read", "list_todos", "scope_catalog", "remember"}:
+        if name not in {"search", "read", "list_todos", "scope_catalog", "remember", "update_memory"}:
             return None
         turn_id = _host_turn_id(turn_context)
         session = turn_context.get("session_id") if isinstance(turn_context, Mapping) else None
@@ -2102,7 +2102,7 @@ class MemleafMemoryProvider(MemoryProvider):
         # gated by the initialized host identity and write policy.
         if not self._write_enabled:
             return []
-        return [{"name": "memleaf_remember", "description": "Use only for an explicit user request to remember. Bind the actual complete user turn; never submit rewritten facts or scopes. Returns pending until the turn is captured and processed.",
+        return [{"name": "memleaf_remember", "description": "Use for an explicit user request to remember or maintain existing memory: corrections, task completion/cancellation/reopening, or withdrawal of a fact/preference. Bind the actual complete user turn; never submit rewritten facts, dates or scopes. Returns pending until the turn is captured and processed.",
                  "parameters": {"type": "object", "properties": {"retrieval_id": {"type": "string"}},
                                 "required": ["retrieval_id"], "additionalProperties": False}}]
 

{memleaf-0.2.86 → memleaf-0.2.87}/src/memleaf/hermes_provider/plugin.yaml

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

{memleaf-0.2.86 → memleaf-0.2.87}/src/memleaf/host_retention.py

@@ -138,7 +138,10 @@ def remember_turn(service, *, phase, retrieval_id=None, source=None, session_id=
         turn, _ = _window(service, source, session_id, turn_key(turn_id))
         users = [event for event in turn.events if event.role == "user"]
         request = "\n\n".join(event.content for event in users)
-        refs = [event.event_key for event in users]
+        # One host completion evaluates the entire captured turn. The actual
+        # user request still bounds explicit retention; the assistant remains
+        # a visible source, never authority for new user obligations.
+        refs = [event.event_key for event in turn.events]
         selection, request = bind_selection(intent, refs, request)
         run = load_run(processed, explicit_run_id(source, session_id, selection))
     if run is not None and run["status"] in {"completed", "completed_with_unresolved", "blocked", "failed", "cancelled"}:
@@ -165,3 +168,16 @@ def complete_for_captured_turn(service, turn, *, model=None, router=None):
     _, row = bound
     return remember_turn(service, phase="complete", source=turn.source, session_id=turn.session_id,
                          turn_id=row["turn_id"], model=model, router=router)
+
+
+def covers_complete_turn(service, turn, result):
+    """Only a verified immutable full-source commit may replace automatic work."""
+    from .incremental_journal import load_work
+    from .turn_plan import input_digest
+    with service.vault.lock():
+        processed = _read_processed(service.vault.processed_state_path)
+        work = load_work(processed, result.get('commit_work_id', ''))
+        if (work is None or not work.get('host_retention_origin') or not work['receipt_settled']
+                or work['source_digest'] != input_digest(turn)):
+            return False
+        return {e['event_key'] for e in work['evidence'] if e['use'] == 'new'} == set(turn.event_keys)

{memleaf-0.2.86 → memleaf-0.2.87}/src/memleaf/incremental_commit.py

@@ -105,7 +105,7 @@ def _freeze_operation(proposal: dict[str, Any], snapshot: Any, now: str, active:
     else:
         value.update(memory_id=before.memory_id, created=before.created, updated=now)
     after = Memory.from_mapping(value)
-    if before is not None and dedup_digest(before.to_dict()) == dedup_digest(after.to_dict()):
+    if before is not None and not op.get("merge_from") and dedup_digest(before.to_dict()) == dedup_digest(after.to_dict()):
         op.update(action="NO_CHANGE", expected_revision=revision_digest(before))
         return op
     if before is None:
@@ -118,8 +118,14 @@ def _freeze_operation(proposal: dict[str, Any], snapshot: Any, now: str, active:
             return op
     from .incremental_dates import source_basis
     provenance = [source_basis(e) for e in state["evidence"] if e["ref"] in op["evidence"]]
-    after.sources, source_meta = merge_sources(before.sources if before else [], provenance,
-                                               extra=before.extra if before else {})
+    old_sources, old_meta = (before.sources, before.extra) if before else ([], {})
+    if op.get("merge_from"):
+        from .source_policy import merge_memory_provenance
+        peers = [Memory.from_mapping(t["memory"]) for t in state["targets"].values()
+                 if t["memory"]["memory_id"] in op["merge_from"]]
+        old_sources, old_meta = merge_memory_provenance([before, *peers])
+        op["merge_revisions"] = {m.memory_id: revision_digest(m) for m in peers}
+    after.sources, source_meta = merge_sources(old_sources, provenance, extra=old_meta)
     after.extra.update(source_meta)
     after.extra["incremental_operation_id"] = op["operation_id"]
     if any(t["memory"]["memory_id"] == op["memory_id"] and t.get("basis_status") == "external_change_detected"
@@ -162,8 +168,17 @@ def _source_valid(service, processed, work):
 
 
 def _settle_source(service, processed, work, *, source_valid):
+    whole_host_turn = False
+    if source_valid and work.get("host_retention_origin") is not None:
+        # A scoped selection alone cannot prove whole-turn coverage. Only a
+        # verified host intent, evaluated against every current source event,
+        # may settle the automatic route as well.
+        turn, _ = _window(service, work["source"], work["session_id"], work["turn_key"])
+        selected = work.get("binding", {}).get("arguments", {}).get("selection", {})
+        whole_host_turn = (set(selected.get("source_refs", [])) == set(turn.event_keys)
+                           == {e["event_key"] for e in work["evidence"] if e["use"] == "new"})
     if (work.get("request_kind", "automatic") == "explicit_remember"
-            and not any(e.get("explicit_input") for e in work["evidence"])):
+            and not whole_host_turn and not any(e.get("explicit_input") for e in work["evidence"])):
         # This authorization only selected some material. Its own work receipt
         # settles it; it never consumes the automatic turn or changes cleanup.
         return
@@ -232,6 +247,18 @@ def _resume_unlocked(service, processed, work):
                     if not guard_matches(current_guard, work["scope_guard"], applied_additions(work)):
                         raise ValueError("scope_registry_changed")
                 if op["action"] in {"CREATE", "UPDATE"}:
+                    if op.get("merged_into"):
+                        survivor = next((item for item in work["operations"]
+                                         if item.get("memory_id") == op["merged_into"]), None)
+                        current, _ = service._revision_target_unlocked(op["merged_into"])
+                        if (survivor is None or survivor["state"] not in {"applied", "settled"}
+                                or current is None or revision_digest(current.memory) != survivor.get("replacement_revision")):
+                            raise ValueError("merge_survivor_not_committed")
+                        op["merge_revisions"] = {op["merged_into"]: survivor["replacement_revision"]}
+                    for identity, expected in op.get("merge_revisions", {}).items():
+                        current, _ = service._revision_target_unlocked(identity)
+                        if current is None or revision_digest(current.memory) != expected:
+                            raise ValueError("merge_target_changed")
                     # Pin the configuration already authorized above through
                     # the shared writer's history/head boundary as well.
                     guarded_op = {**op, "scope_guard": current_guard} if work.get("scope_guard") is not None else op