memleaf 0.2.17__tar.gz → 0.2.18__tar.gz

{memleaf-0.2.17 → memleaf-0.2.18}/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 All notable changes to memleaf are documented here.
 
+## 0.2.18 — 2026-09-02
+
+- Register Hermes native `MEMORY.md` and `USER.md` as private, read-only native sources during supported install/upgrade flows while preserving custom native source configuration.
+- Harden cross-turn deduplication and UPDATE/NO_CHANGE decisions: split independent future-use clauses, reuse one unambiguous same-scope active target, treat exact active duplicates as deterministic no-ops, and keep crash replay idempotent.
+- Preserve the existing bounded Scope Map / metadata-directory retrieval flow without adding extra scope scans during automatic deduplication.
+- Distinguish Hermes controlled read audit states: record `FOUND_READ` only after a current-token successful read, and use `FOUND_NO_READ_UNDETERMINED` when a FOUND result has no provable controlled read instead of overstating Soft Gate guarantees.
+
 ## 0.2.17 — 2026-09-02
 
 - Preserve explicit user-confirmed completion or cancellation of one uniquely

{memleaf-0.2.17/src/memleaf.egg-info → memleaf-0.2.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 0.2.17
+Version: 0.2.18
 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.17。**
-> 核心库、Vault、stdio MCP Server、初始化 CLI、模型路由、提炼流程、受控检索协议和宿主适配器已经实现。memleaf 0.2.17 通过 PyPI 分发。
+> **当前版本：0.2.18。**
+> 核心库、Vault、stdio MCP Server、初始化 CLI、模型路由、提炼流程、受控检索协议和宿主适配器已经实现。memleaf 0.2.18 通过 PyPI 分发。
 > **当前版本支持 Hermes 和 Codex。** Antigravity（反重力）不检测、不安装、不配置。
 
 ## 项目定位

{memleaf-0.2.17 → memleaf-0.2.18}/README.en.md

@@ -4,8 +4,8 @@
 
 [中文](README.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **Version: 0.2.17.**
-> The core library, Vault, stdio MCP server, initialization CLI, model routing, memory extraction, controlled retrieval protocol, and host adapters are implemented. memleaf 0.2.17 is distributed through PyPI.
+> **Version: 0.2.18.**
+> The core library, Vault, stdio MCP server, initialization CLI, model routing, memory extraction, controlled retrieval protocol, and host adapters are implemented. memleaf 0.2.18 is distributed through PyPI.
 > **The current release supports Hermes and Codex.** Antigravity is not detected, installed, or configured.
 
 ## Project scope

{memleaf-0.2.17 → memleaf-0.2.18}/README.md

@@ -4,8 +4,8 @@
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **当前版本：0.2.17。**
-> 核心库、Vault、stdio MCP Server、初始化 CLI、模型路由、提炼流程、受控检索协议和宿主适配器已经实现。memleaf 0.2.17 通过 PyPI 分发。
+> **当前版本：0.2.18。**
+> 核心库、Vault、stdio MCP Server、初始化 CLI、模型路由、提炼流程、受控检索协议和宿主适配器已经实现。memleaf 0.2.18 通过 PyPI 分发。
 > **当前版本支持 Hermes 和 Codex。** Antigravity（反重力）不检测、不安装、不配置。
 
 ## 项目定位

{memleaf-0.2.17 → memleaf-0.2.18}/install.sh

@@ -347,6 +347,23 @@ PY
     die "Hermes memleaf MCP configuration/test failed"
   fi
 
+  # Register Hermes' own MEMORY.md and USER.md as private, read-only native
+  # sources only after both provider and MCP checks have succeeded. Missing
+  # files remain a valid indexed state and are never created by memleaf.
+  "$venv_path/bin/python" - "$vault_path" "$hermes_home" <<'PY'
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+from memleaf.native_registration import ensure_hermes_native_sources
+from memleaf.vault import Vault
+
+vault = Vault(Path(sys.argv[1]).expanduser().resolve())
+hermes_home = Path(sys.argv[2]).expanduser().resolve()
+ensure_hermes_native_sources(vault, hermes_home)
+PY
+
   # The MCP status is written only after its own official test succeeds.  This
   # merge changes no Provider or other host fields.
   "$venv_path/bin/python" - "$vault_path" <<'PY'

{memleaf-0.2.17 → memleaf-0.2.18}/pyproject.toml

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

{memleaf-0.2.17 → memleaf-0.2.18}/src/memleaf/__init__.py

@@ -1,6 +1,6 @@
 """Local-first Markdown memory core for AI agents."""
 
-__version__ = "0.2.17"
+__version__ = "0.2.18"
 
 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.17 → memleaf-0.2.18}/src/memleaf/hermes_provider/__init__.py

@@ -1181,6 +1181,7 @@ class MemleafMemoryProvider(MemoryProvider):
         # under the original session id after the chain is restored.
         self._deferred_process_sessions: "OrderedDict[str, None]" = OrderedDict()
         self._last_retrieval_observation = "unknown"
+        self._last_retrieval_audit = "SEARCH_UNKNOWN"
 
     @property
     def name(self) -> str:
@@ -1873,6 +1874,7 @@ class MemleafMemoryProvider(MemoryProvider):
         self._pending_lineage.clear()
         self._deferred_process_sessions.clear()
         self._last_retrieval_observation = "unknown"
+        self._last_retrieval_audit = "SEARCH_UNKNOWN"
         self._version_warning_emitted = False
         if self._client is not None:
             self._client.close()
@@ -2117,6 +2119,7 @@ class MemleafMemoryProvider(MemoryProvider):
         turn_id: str = "",
         vault_root: Optional[Path] = None,
         seen_call_keys: Any = None,
+        audit_state: Optional[dict[str, Any]] = None,
     ) -> str:
         """Observe explicit host MCP calls in public messages.
 
@@ -2152,6 +2155,7 @@ class MemleafMemoryProvider(MemoryProvider):
 
         read_results_used: set[int] = set()
         read_sequence = 0
+        controlled_reads = 0
         read_ordinal = 0
         for call in calls:
             if call.get("name") != "mcp__memleaf__read":
@@ -2175,6 +2179,8 @@ class MemleafMemoryProvider(MemoryProvider):
             if not _record_tool_observation(seen_call_keys, observation_key):
                 continue
             read_sequence += 1
+            if result_status == "ok" and retrieval_match:
+                controlled_reads += 1
             logger.info(
                 "memleaf retrieval-read source=hermes session=%s turn=%s read_seq=%d retrieval_present=%s retrieval_match=%s result=%s",
                 _safe_component(session_id, "none") if session_id else "none",
@@ -2202,12 +2208,39 @@ class MemleafMemoryProvider(MemoryProvider):
                 "detected" if bypass else "not_detected",
             )
         if not statuses:
-            return "unknown"
-        if "found" in statuses:
-            return "found"
-        if "no_match" in statuses:
-            return "no_match"
-        return "error"
+            search_status = "unknown"
+            audit_status = "SEARCH_UNKNOWN"
+        elif "found" in statuses:
+            search_status = "found"
+            # Hermes exposes no public pre-final hook and no reliable signal
+            # that proves whether an answer used historical memory when no
+            # controlled read occurred. Do not fabricate FOUND_NOT_USED or
+            # FOUND_REQUIRED_READ_MISSING; record the uncertainty explicitly.
+            audit_status = "FOUND_READ" if controlled_reads else "FOUND_NO_READ_UNDETERMINED"
+        elif "no_match" in statuses:
+            search_status = "no_match"
+            audit_status = "NO_MATCH"
+        else:
+            search_status = "error"
+            audit_status = "ERROR"
+        if isinstance(audit_state, dict):
+            audit_state.clear()
+            audit_state.update(
+                {
+                    "status": audit_status,
+                    "search_status": search_status,
+                    "controlled_reads": controlled_reads,
+                }
+            )
+        logger.info(
+            "memleaf retrieval-audit source=hermes session=%s turn=%s status=%s search=%s controlled_reads=%d",
+            _safe_component(session_id, "none") if session_id else "none",
+            _safe_component(turn_id, "none") if turn_id else "none",
+            audit_status,
+            search_status,
+            controlled_reads,
+        )
+        return search_status
 
     @staticmethod
     def _catalog_retrieval_id(value: Any) -> Optional[str]:
@@ -2335,6 +2368,7 @@ class MemleafMemoryProvider(MemoryProvider):
                 if retrieval_id is None and resolved_turn_number is None:
                     retrieval_id = self._current_gate_id(effective_session)
                 if self._gate_enabled:
+                    audit_state: dict[str, Any] = {}
                     observation = self._observe_search_messages(
                         messages,
                         retrieval_id,
@@ -2342,10 +2376,12 @@ class MemleafMemoryProvider(MemoryProvider):
                         turn_id=turn_id,
                         vault_root=_resolve_vault(self._config()),
                         seen_call_keys=self._observed_tool_call_keys,
+                        audit_state=audit_state,
                     )
                     while len(self._observed_tool_call_keys) > _MAX_OBSERVED_TOOL_CALL_KEYS:
                         self._observed_tool_call_keys.popitem(last=False)
                     self._last_retrieval_observation = observation
+                    self._last_retrieval_audit = str(audit_state.get("status") or "SEARCH_UNKNOWN")
                 lineage_ready = self._retry_pending_lineage(effective_session)
                 for role, content in visible_events:
                     if not self._capture_visible(

{memleaf-0.2.17 → memleaf-0.2.18}/src/memleaf/hermes_provider/plugin.yaml

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

{memleaf-0.2.17 → memleaf-0.2.18}/src/memleaf/installer.py

@@ -22,6 +22,7 @@ from .adapters.codex import CodexAdapter
 from .adapters.hermes import HermesAdapter, hermes_home_for_platform
 from .cli import _home_from_environment, _prepare_model_route
 from .locking import atomic_write_json
+from .native_registration import ensure_hermes_native_sources
 from .vault import Vault
 
 
@@ -415,6 +416,19 @@ def install_hermes(*, vault_path: Path | None = None) -> dict[str, Any]:
             "model": model,
         }
 
+    try:
+        native_registration = ensure_hermes_native_sources(vault, hermes_home)
+    except Exception:
+        return {
+            "status": "failure",
+            "reason": "Hermes native memory sources could not be registered safely",
+            "core_version": core_version,
+            "provider_version": provider_version,
+            "vault": str(vault.root),
+            "provider": str(provider_path),
+            "model": model,
+        }
+
     update_agents_index(
         vault.agents_index_path,
         {
@@ -443,6 +457,7 @@ def install_hermes(*, vault_path: Path | None = None) -> dict[str, Any]:
         "provider": str(provider_path),
         "mcp_command": str(command),
         "model": model,
+        "native_sources": native_registration,
     }
 
 

memleaf-0.2.18/src/memleaf/native_registration.py

@@ -0,0 +1,123 @@
+"""Host-native source registration helpers.
+
+This module owns only configuration of read-only native sources.  It never
+creates, writes, renames, or removes a host's native memory files.
+"""
+
+from __future__ import annotations
+
+from copy import deepcopy
+from pathlib import Path
+from typing import Any, Mapping
+
+from .config import save_config
+from .native_index import NativeIndexer, validate_native_sources
+
+
+_HERMES_SOURCES = (
+    ("hermes_memory", "hermes_memory_builtin", "MEMORY.md"),
+    ("hermes_user", "hermes_user_builtin", "USER.md"),
+)
+
+
+def _same_path(left: str | Path, right: str | Path) -> bool:
+    try:
+        return Path(left).expanduser().resolve(strict=False) == Path(right).expanduser().resolve(strict=False)
+    except (OSError, RuntimeError, ValueError):
+        return False
+
+
+def _desired(path: Path) -> dict[str, Any]:
+    return {
+        "agent": "hermes",
+        "path": str(path.expanduser().resolve(strict=False)),
+        "share": False,
+        "format": "markdown",
+    }
+
+
+def _safe_existing_for_hermes(source: Mapping[str, Any], path: Path) -> bool:
+    return (
+        source.get("agent") == "hermes"
+        and source.get("share") is False
+        and source.get("format", "markdown") == "markdown"
+        and _same_path(str(source.get("path", "")), path)
+    )
+
+
+def ensure_hermes_native_sources(vault: Any, hermes_home: Path | str) -> dict[str, Any]:
+    """Idempotently register Hermes MEMORY.md and USER.md as private sources.
+
+    Existing user-defined native sources are preserved.  A semantic conflict
+    fails closed instead of silently changing the user's source or exposing a
+    private Hermes file to another agent.
+    """
+
+    home = Path(hermes_home).expanduser().resolve(strict=False)
+    targets = [(canonical, fallback, home / "memories" / filename) for canonical, fallback, filename in _HERMES_SOURCES]
+
+    with vault.lock():
+        config = vault.config()
+        existing_value = config.get("native_sources", {})
+        if not isinstance(existing_value, Mapping):
+            raise RuntimeError("invalid native_sources configuration")
+        sources: dict[str, dict[str, Any]] = {
+            str(source_id): deepcopy(dict(source))
+            for source_id, source in existing_value.items()
+            if isinstance(source_id, str) and isinstance(source, Mapping)
+        }
+        # Validate before touching anything.  This also catches duplicate paths
+        # already present in a manually edited configuration.
+        validate_native_sources(sources, base_dir=vault.root)
+        changed = False
+        registered: dict[str, str] = {}
+
+        for canonical, fallback, path in targets:
+            desired = _desired(path)
+            path_owner = next(
+                (
+                    source_id
+                    for source_id, source in sources.items()
+                    if _same_path(str(source.get("path", "")), path)
+                ),
+                None,
+            )
+            if path_owner is not None:
+                current = sources[path_owner]
+                if not _safe_existing_for_hermes(current, path):
+                    raise RuntimeError(f"unsafe Hermes native source conflict: {path_owner}")
+                registered[canonical] = path_owner
+                continue
+
+            target_id = canonical
+            if target_id in sources:
+                if _safe_existing_for_hermes(sources[target_id], path):
+                    registered[canonical] = target_id
+                    continue
+                target_id = fallback
+                if target_id in sources and not _safe_existing_for_hermes(sources[target_id], path):
+                    raise RuntimeError(f"Hermes native source id conflict: {canonical}")
+
+            if target_id not in sources:
+                sources[target_id] = desired
+                changed = True
+            registered[canonical] = target_id
+
+        if changed:
+            updated = deepcopy(dict(config))
+            updated["native_sources"] = sources
+            save_config(vault.config_path, updated)
+
+        # Refresh the derived index under the same vault lock. Missing native
+        # files are a valid state and are represented as unavailable entries;
+        # this function never creates them.
+        index_summary = NativeIndexer(vault).refresh_unlocked()
+
+    return {
+        "changed": changed,
+        "sources": registered,
+        "index": index_summary,
+    }
+
+
+__all__ = ["ensure_hermes_native_sources"]

{memleaf-0.2.17 → memleaf-0.2.18}/src/memleaf/processing.py

@@ -230,6 +230,80 @@ def _automatic_transient_memory(value: Any) -> bool:
     return bool(_DERIVED_OVERDUE_RE.search(value) or _EXECUTION_RECEIPT_RE.search(value))
 
 
+_CANDIDATE_LOOKUP_SPLIT = re.compile(
+    r"[;；。！？!?\n]+|[,，]\s*(?=(?:后续|今后|以后|每次|所有后续|going forward|from now on))"
+    r"|(?:同时|另外|此外|其次|并且|并要求|还需|另需|in addition|separately)",
+    re.IGNORECASE,
+)
+
+
+def _candidate_lookup_queries(value: Any) -> list[str]:
+    """Return bounded candidate-level lookup variants for cross-turn dedupe."""
+
+    if not isinstance(value, str) or not value.strip():
+        return []
+    text = value.strip()
+    values = [text]
+    values.extend(part.strip() for part in _CANDIDATE_LOOKUP_SPLIT.split(text) if part.strip())
+    result: list[str] = []
+    seen: set[str] = set()
+    for item in values:
+        normalized = normalize_term(item)
+        if len(normalized) < 4 or normalized in seen:
+            continue
+        seen.add(normalized)
+        result.append(item)
+        if len(result) >= 8:
+            break
+    return result
+
+
+def _automatic_create_conflicts(
+    candidate: Mapping[str, Any],
+    summary: Mapping[str, Any],
+    related: Iterable[Mapping[str, Any]],
+    *,
+    ignore_memory_ids: Iterable[str] = (),
+) -> bool:
+    """Return true only when a finalized CREATE is already covered."""
+
+    candidate_text = str(candidate.get("memory", "")).strip()
+    queries = _candidate_lookup_queries(candidate_text)
+    summary_body = normalize_term(str(summary.get("body", "")))
+    candidate_type = candidate.get("type")
+    ignored = {
+        value.casefold() for value in ignore_memory_ids
+        if isinstance(value, str) and value
+    }
+    for raw in related:
+        if not isinstance(raw, Mapping):
+            continue
+        memory_id = raw.get("memory_id")
+        if isinstance(memory_id, str) and memory_id.casefold() in ignored:
+            # Requests already generated for this visible turn may have been
+            # partially persisted by a failed transaction. Ignore them here
+            # so replay can finish the remaining deterministic candidates.
+            continue
+        related_body = normalize_term(str(raw.get("body", "")))
+        if raw.get("native") is True:
+            related_text = normalize_term(
+                f"{raw.get('title', '')}\n{raw.get('body', '')}"
+            )
+            for query in queries:
+                normalized = normalize_term(query)
+                if len(normalized) >= 8 and related_text and (
+                    normalized in related_text
+                    or (len(related_text) >= 8 and related_text in normalized)
+                ):
+                    return True
+            continue
+        if raw.get("type") != candidate_type:
+            continue
+        if summary_body and related_body == summary_body:
+            return True
+    return False
+
+
 def _todo_state_recovery_candidate(
     events: Iterable[Mapping[str, Any]],
     related: Iterable[Mapping[str, Any]],
@@ -1450,7 +1524,7 @@ class Processor:
         self,
         turn: InboxTurn,
         state: Mapping[str, Any],
-        query: str,
+        query: str | Iterable[str],
         explicit_scope: Any = None,
         *,
         overlay: Iterable[Mapping[str, Any]] = (),
@@ -1464,7 +1538,15 @@ class Processor:
         list[dict[str, str]],
         Optional[tuple[list[Any], bool]],
     ]:
-        visible = query.strip() if isinstance(query, str) else ""
+        if isinstance(query, str):
+            query_value: str | list[str] = query.strip()
+        else:
+            query_value = [
+                str(item).strip()
+                for item in query
+                if isinstance(item, str) and item.strip()
+            ]
+        visible = query_value if isinstance(query_value, str) else " ".join(query_value)
         scope = _safe_scope_background(state, explicit_scope)
         local: list[dict[str, Any]] = []
         indexed_native: list[dict[str, Any]] = []
@@ -1495,7 +1577,7 @@ class Processor:
                 records = priority_records
             else:
                 records = self.service._search_unlocked(
-                    visible,
+                    query_value,
                     scope=scope if scope else None,
                     include_history=False,
                     todo_status="all",
@@ -1512,7 +1594,7 @@ class Processor:
                     records = [
                         record
                         for record in records
-                        if candidate_matches_query(record.memory, visible)
+                        if candidate_matches_query(record.memory, query_value)
                     ]
                 if visible and not records and not priority_records and self._has_specific_scope(scope):
                     scoped_records, ambiguous = self._scope_records_unlocked(scope)
@@ -1532,7 +1614,7 @@ class Processor:
             if visible:
                 if not priority_only:
                     indexed_native = NativeIndexer(self.service.vault).search_unlocked(
-                        visible,
+                        query_value,
                         target_agent=turn.source,
                         for_context=False,
                         limit=None,
@@ -1996,14 +2078,11 @@ class Processor:
         candidate: Mapping[str, Any],
         related: Iterable[Mapping[str, Any]],
     ) -> dict[str, Any]:
-        """Reuse one unambiguously matching project plan/constraint memory.
-
-        The gate remains authoritative when it names a target.  This narrow
-        fallback handles a common model omission: a project-plan candidate is
-        emitted as a new ``fact`` without ``update_memory_id`` even though the
-        same scoped plan is already active.  The active target's type is the
-        canonical type; it is copied before summary validation so the target
-        type invariant remains enforced.
+        """Reuse one unambiguous same-scope active memory before CREATE.
+
+        General same-type matching prevents a wrong gate target from escaping
+        into a sibling CREATE. Project-plan candidates retain the specialized
+        project-over-fact preference used by earlier maintenance behavior.
         """
 
         result = dict(candidate)
@@ -2014,14 +2093,52 @@ class Processor:
             or not isinstance(result.get("memory"), str)
         ):
             return result
-        if result.get("type") not in {"fact", "project"}:
-            return result
-        if not self._is_project_plan_title(result["memory"]):
-            return result
         project_keys = self._project_scope_keys(result.get("scopes"))
         if len(project_keys) != 1:
             return result
 
+        candidate_type = result.get("type")
+        candidate_text = result["memory"]
+        same_type_matches: list[Memory] = []
+        seen_same_type: set[str] = set()
+        for item in related:
+            if not isinstance(item, Mapping) or item.get("native") is True:
+                continue
+            memory_id = item.get("memory_id")
+            if (
+                not isinstance(memory_id, str)
+                or item.get("type") != candidate_type
+                or self._project_scope_keys(item.get("scopes")) != project_keys
+                or memory_id.casefold() in seen_same_type
+            ):
+                continue
+            try:
+                target = Memory.from_mapping(item)
+            except (TypeError, ValueError):
+                continue
+            target_title = normalize_term(target.title)
+            candidate_normalized = normalize_term(candidate_text)
+            if (
+                len(target_title) < 4
+                or target_title not in candidate_normalized
+                or not candidate_matches_query(target, candidate_text)
+            ):
+                continue
+            seen_same_type.add(memory_id.casefold())
+            same_type_matches.append(target)
+
+        specialized_plan = (
+            candidate_type in {"fact", "project"}
+            and self._is_project_plan_title(candidate_text)
+        )
+        if not specialized_plan:
+            if len(same_type_matches) > 1:
+                result["_defer_reason"] = "ambiguous_update_target"
+                return result
+            if len(same_type_matches) == 1:
+                result["update_memory_id"] = same_type_matches[0].memory_id
+            return result
+
         project_matches: list[Memory] = []
         fact_matches: list[Memory] = []
         seen: set[str] = set()
@@ -2051,10 +2168,6 @@ class Processor:
             else:
                 fact_matches.append(target)
 
-        # Prefer a project target over a same-topic fact.  If there are
-        # multiple project targets, defer rather than creating a sibling by
-        # guessing; the same conservative rule applies when only multiple
-        # durable fact targets remain.
         if len(project_matches) > 1 or (not project_matches and len(fact_matches) > 1):
             result["_defer_reason"] = "ambiguous_update_target"
             return result
@@ -2065,8 +2178,6 @@ class Processor:
         else:
             return result
         result["update_memory_id"] = target.memory_id
-        # The update target's type is immutable.  Correct a model's fact-vs-
-        # project label only after the same-use target was identified.
         result["type"] = target.type
         return result
 
@@ -2530,6 +2641,7 @@ class Processor:
                 )
         requests: list[dict[str, Any]] = []
         observed_scopes: list[str] = []
+        current_turn_request_ids: set[str] = set()
         read_only_query = _automatic_read_only_query(events)
         for candidate in gate["candidates"]:
             candidate_id_key = str(candidate.get("candidate_id", "")).casefold()
@@ -2614,7 +2726,7 @@ class Processor:
             candidate_related, candidate_scope_background, candidate_native_refs, _ = self._related_query(
                 turn,
                 state,
-                str(candidate.get("memory", "")).strip(),
+                _candidate_lookup_queries(candidate.get("memory")),
                 candidate_scopes,
                 overlay=self._planned_related,
                 priority_memory_ids=[
@@ -2895,15 +3007,26 @@ class Processor:
                     scope_source=summary.get("scope_source"),
                 )
                 continue
-            requests.append(
-                self._request(
-                    summary,
-                    turn,
-                    candidate_id=str(candidate["candidate_id"]),
-                    conversation_title=title,
-                    native_refs=candidate_native_refs,
-                )
+            pending_request = self._request(
+                summary,
+                turn,
+                candidate_id=str(candidate["candidate_id"]),
+                conversation_title=title,
+                native_refs=candidate_native_refs,
             )
+            current_turn_request_ids.add(pending_request["memory_id"].casefold())
+            summary_update_target = summary.get("update_memory_id")
+            final_is_create = not (
+                isinstance(summary_update_target, str) and summary_update_target
+            )
+            if final_is_create and _automatic_create_conflicts(
+                candidate,
+                summary,
+                candidate_related,
+                ignore_memory_ids=current_turn_request_ids,
+            ):
+                continue
+            requests.append(pending_request)
             for observed_scope in summary["scopes"]:
                 if (
                     isinstance(observed_scope, str)