Skip to content

Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.

70.7 KB
Raw Blame
# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
# SPDX-License-Identifier: AGPL-3.0

from __future__ import annotations

import asyncio
from types import SimpleNamespace
from unittest.mock import AsyncMock

import pytest

from openviking.message import Message, TextPart
from openviking.server.identity import RequestContext, Role
from openviking.session.memory.dataclass import (
    MemoryField,
    MemoryFile,
    MemoryOperationSkipCode,
    MemoryOperationSource,
    MemoryTypeSchema,
    ResolvedOperation,
    ResolvedOperations,
    SkippedMemoryOperation,
    StoredLink,
)
from openviking.session.memory.memory_type_registry import MemoryTypeRegistry
from openviking.session.memory.memory_updater import ExtractContext, MemoryUpdateResult
from openviking.session.memory.merge_op.base import FieldType, MergeOp, SearchReplaceBlock, StrPatch
from openviking.session.memory.streaming_memory_updater import (
    MemoryMergeGroupKey,
    MemoryUpdateRequest,
    StreamingMemoryUpdater,
    StreamingMemoryUpdaterConfig,
    StreamingMemoryUpdateResult,
    acquire_memory_operation_lease,
    classify_memory_merge_mode,
    enforce_merge_group_peer_id,
    filter_valid_links,
    get_streaming_memory_updater,
    merge_memory_operations,
    merge_one_memory_type_operations,
    operation_to_patch,
    render_operation_after_file_content,
    split_request_by_merge_group,
)
from openviking.session.memory.utils.memory_file_utils import MemoryFileUtils
from openviking_cli.exceptions import ConflictError, NotFoundError, PermissionDeniedError
from openviking_cli.session.user_id import UserIdentifier


class _TestVLMResolver:
    model = "test-model"
    max_tokens = None

    async def get_vlm(self, account_id):
        del account_id
        return self


def _patch_language_config(monkeypatch):
    config = SimpleNamespace(
        output_language_override="",
        language_fallback="en",
        memory=SimpleNamespace(
            eager_prefetch=False,
            prefetch_search_topn=5,
            link_enabled=False,
        ),
    )
    monkeypatch.setattr(
        "openviking.session.memory.utils.language.get_openviking_config",
        lambda: config,
    )
    monkeypatch.setattr(
        "openviking.session.memory.session_extract_context_provider.get_openviking_config",
        lambda: config,
    )


class InMemoryVikingFS:
    def __init__(self, files: dict[str, str] | None = None):
        self.files = dict(files or {})
        self.writes = []

    async def ls(self, uri: str, output: str = "original", ctx=None):
        del output, ctx
        prefix = uri.rstrip("/") + "/"
        return [
            {"name": path.removeprefix(prefix), "uri": path, "isDir": False}
            for path in sorted(self.files)
            if path.startswith(prefix) and "/" not in path.removeprefix(prefix)
        ]

    async def read_file(self, uri: str, ctx=None):
        uri = _canonical_user_uri(uri, ctx)
        if uri not in self.files:
            raise FileNotFoundError(uri)
        return self.files[uri]

    async def write_file(self, uri: str, content: str, ctx=None, lease_ref=None):
        del lease_ref
        uri = _canonical_user_uri(uri, ctx)
        self.files[uri] = content
        self.writes.append((uri, content, ctx))

    async def rm(
        self,
        uri: str,
        recursive: bool = False,
        ctx=None,
        lock_handle=None,
        lease_ref=None,
    ):
        del recursive, lock_handle, lease_ref
        uri = _canonical_user_uri(uri, ctx)
        self.files.pop(uri, None)


class RecordingPathlockClient:
    def __init__(self, events: list[tuple]):
        self.events = events

    async def pathlock_acquire_exact_batch(self, paths, timeout_secs=0.0):
        lease_number = len([event for event in self.events if event[0] == "acquire"]) + 1
        lease_ref = (
            "memory-batch-lease" if lease_number == 1 else f"memory-batch-lease-{lease_number}"
        )
        lease = {"lease_ref": lease_ref}
        self.events.append(("acquire", tuple(paths), timeout_secs))
        return lease

    async def pathlock_acquire_exact_tree_batch(self, exact_paths, tree_paths, timeout_secs=0.0):
        lease = {"lease_ref": "memory-mixed-lease"}
        self.events.append(("acquire_mixed", tuple(exact_paths), tuple(tree_paths), timeout_secs))
        return lease

    async def pathlock_release(self, lease):
        self.events.append(("release", lease))


class PathlockedInMemoryVikingFS(InMemoryVikingFS):
    def __init__(self, files: dict[str, str] | None = None):
        super().__init__(files)
        self.events: list[tuple] = []
        self._async_agfs = RecordingPathlockClient(self.events)

    def _uri_to_path(self, uri: str, ctx=None) -> str:
        return "/" + _canonical_user_uri(uri, ctx).removeprefix("viking://")

    async def write_file(self, uri: str, content: str, ctx=None, lease_ref=None):
        self.events.append(("write", uri, lease_ref))
        return await super().write_file(uri, content, ctx=ctx, lease_ref=lease_ref)


def _canonical_user_uri(uri: str, ctx=None) -> str:
    if not uri.startswith("viking://user/memories/"):
        return uri
    user_id = getattr(getattr(ctx, "user", None), "user_id", None) or "u"
    return uri.replace("viking://user/memories/", f"viking://user/{user_id}/memories/", 1)


def _ctx() -> RequestContext:
    return RequestContext(user=UserIdentifier.the_default_user("u"), role=Role.ROOT)


def _registry() -> MemoryTypeRegistry:
    registry = MemoryTypeRegistry(load_schemas=False)
    registry.register(
        MemoryTypeSchema(
            memory_type="cases",
            description="case memory",
            directory="viking://user/{{ user_space }}/memories/cases",
            filename_template="{{ case_name }}.md",
            operation_mode="add_only",
            peer_enabled=False,
            fields=[
                MemoryField(
                    name="case_name",
                    field_type=FieldType.STRING,
                    merge_op=MergeOp.IMMUTABLE,
                ),
                MemoryField(
                    name="task_signature",
                    field_type=FieldType.STRING,
                    merge_op=MergeOp.IMMUTABLE,
                ),
                MemoryField(
                    name="input",
                    field_type=FieldType.STRING,
                    merge_op=MergeOp.IMMUTABLE,
                ),
                MemoryField(
                    name="rubric",
                    field_type=FieldType.STRING,
                    merge_op=MergeOp.IMMUTABLE,
                ),
            ],
        )
    )
    registry.register(
        MemoryTypeSchema(
            memory_type="notes",
            description="note memory",
            directory="viking://user/{{ user_space }}/memories/notes",
            filename_template="{{ note_name }}.md",
            operation_mode="upsert",
            fields=[
                MemoryField(
                    name="note_name",
                    field_type=FieldType.STRING,
                    merge_op=MergeOp.IMMUTABLE,
                ),
                MemoryField(
                    name="content",
                    field_type=FieldType.STRING,
                    merge_op=MergeOp.PATCH,
                ),
            ],
        )
    )
    return registry


def _case_op(name: str) -> ResolvedOperation:
    return ResolvedOperation(
        old_memory_file_content=None,
        memory_type="cases",
        uris=[f"viking://user/u/memories/cases/{name}.md"],
        memory_fields={
            "case_name": name,
            "task_signature": f"{name} signature",
            "input": '{"summary":"case input"}',
            "rubric": '{"criteria":[{"name":"done","description":"done","required":true,"weight":1.0}]}',
        },
    )


def _note_op(name: str) -> ResolvedOperation:
    return ResolvedOperation(
        old_memory_file_content=None,
        memory_type="notes",
        uris=[f"viking://user/u/memories/notes/{name}.md"],
        memory_fields={
            "note_name": name,
            "content": f"{name} content",
        },
    )


def _note_op_with_source(name: str, extraction_id: str) -> ResolvedOperation:
    op = _note_op(name)
    op.memory_fields["source_extraction_id"] = extraction_id
    return op


def _note_update_op(name: str) -> ResolvedOperation:
    uri = f"viking://user/u/memories/notes/{name}.md"
    old_file = MemoryFile(
        uri=uri,
        content=f"old {name}",
        memory_type="notes",
        extra_fields={"note_name": name},
    )
    return ResolvedOperation(
        old_memory_file_content=old_file,
        memory_type="notes",
        uris=[uri],
        memory_fields={
            "note_name": name,
            "content": StrPatch(
                blocks=[
                    SearchReplaceBlock(
                        search=f"old {name}",
                        replace=f"new {name}",
                    )
                ]
            ),
        },
    )


def _note_delete_file(name: str) -> MemoryFile:
    return MemoryFile(
        uri=f"viking://user/u/memories/notes/{name}.md",
        content=f"delete {name}",
        memory_type="notes",
        extra_fields={"note_name": name},
    )


def _peer_note_op(name: str, peer_id: str) -> ResolvedOperation:
    op = _note_op(name)
    op.memory_fields["peer_id"] = peer_id
    op.uris = [f"viking://user/u/peers/{peer_id}/memories/notes/{name}.md"]
    return op


async def test_operation_to_patch_omits_raw_operation_metadata():
    schema = _registry().get("notes")
    old_file = MemoryFile(
        uri="viking://user/u/memories/notes/note.md",
        content="old content",
        memory_type="notes",
        extra_fields={"note_name": "note"},
    )
    op = ResolvedOperation(
        old_memory_file_content=old_file,
        memory_type="notes",
        uris=["viking://user/u/memories/notes/note.md"],
        memory_fields={
            "note_name": "note",
            "content": StrPatch(
                blocks=[SearchReplaceBlock(search="old content", replace="new content")]
            ),
        },
    )

    patch = await operation_to_patch(op, schema=schema, extract_context=ExtractContext([]))

    assert patch.metadata == {}
    assert patch.after_file.content == "new content"


async def test_replacement_reacquires_persisted_relation_locks_before_writes(monkeypatch):
    deleted_uri = "viking://user/u/memories/notes/deleted.md"
    neighbor_uri = "viking://user/u/memories/notes/neighbor.md"
    replacement = _note_op("replacement")
    deleted_file = MemoryFile(
        uri=deleted_uri,
        content="deleted content",
        memory_type="notes",
        extra_fields={"note_name": "deleted"},
        links=[
            {
                "from_uri": deleted_uri,
                "to_uri": neighbor_uri,
                "link_type": "related_to",
            }
        ],
    )
    neighbor_file = MemoryFile(
        uri=neighbor_uri,
        content="neighbor content",
        memory_type="notes",
        extra_fields={"note_name": "neighbor"},
    )
    fs = PathlockedInMemoryVikingFS(
        {
            deleted_uri: MemoryFileUtils.write(deleted_file),
            neighbor_uri: MemoryFileUtils.write(neighbor_file),
        }
    )
    fs.search = AsyncMock(return_value=[])
    monkeypatch.setattr(
        "openviking.session.memory.streaming_memory_updater.get_viking_fs",
        lambda: fs,
    )
    monkeypatch.setattr(
        "openviking.session.memory.memory_updater.get_viking_fs",
        lambda: fs,
    )
    operations = ResolvedOperations(
        upsert_operations=[replacement],
        delete_file_contents=[deleted_file.model_copy(update={"links": []})],
        errors=[],
        delete_replacements={deleted_uri: replacement.uris[0]},
    )
    messages = [Message(id="m1", role="user", parts=[TextPart("replace note")])]

    await StreamingMemoryUpdater(registry=_registry())._apply_operations(
        operations=operations,
        request=MemoryUpdateRequest(operations=operations, messages=messages, ctx=_ctx()),
        messages=messages,
    )

    acquires = [event for event in fs.events if event[0] == "acquire"]
    writes = [event for event in fs.events if event[0] == "write"]
    assert len(acquires) == 2
    assert "/user/u/memories/notes/neighbor.md" not in acquires[0][1]
    assert "/user/u/memories/notes/neighbor.md" in acquires[1][1]
    assert writes
    assert all(event[2] == {"lease_ref": "memory-batch-lease-2"} for event in writes)
    assert fs.events.index(acquires[1]) < min(fs.events.index(event) for event in writes)


async def test_streaming_apply_migrates_uri_under_one_stable_lease(monkeypatch):
    source_uri = "viking://user/u/memories/notes/old.md"
    target_uri = "viking://user/u/memories/notes/new.md"
    old_file = MemoryFile(
        uri=source_uri,
        content="old content",
        memory_type="notes",
        extra_fields={"note_name": "old"},
    )
    fs = PathlockedInMemoryVikingFS({source_uri: MemoryFileUtils.write(old_file)})
    fs.search = AsyncMock(return_value=[])
    for module in ("streaming_memory_updater", "memory_updater"):
        monkeypatch.setattr(f"openviking.session.memory.{module}.get_viking_fs", lambda: fs)

    registry = _registry()
    registry.get("notes").fields[0].merge_op = MergeOp.REPLACE
    operations = ResolvedOperations(
        upsert_operations=[
            ResolvedOperation(
                old_memory_file_content=old_file,
                memory_type="notes",
                uris=[target_uri],
                memory_fields={"note_name": "new"},
            )
        ],
        delete_file_contents=[],
        errors=[],
    )
    messages = [Message(id="m1", role="user", parts=[TextPart("rename note")])]

    result = await StreamingMemoryUpdater(registry=registry)._apply_operations(
        operations=operations,
        request=MemoryUpdateRequest(
            operations=operations,
            messages=messages,
            ctx=_ctx(),
            memory_registry=registry,
        ),
        messages=messages,
    )

    assert result.written_uris == [target_uri]
    assert result.deleted_uris == [source_uri]
    assert source_uri not in fs.files
    assert MemoryFileUtils.read(fs.files[target_uri]).extra_fields["note_name"] == "new"
    acquire = next(event for event in fs.events if event[0] == "acquire")
    assert "/user/u/memories/notes/old.md" in acquire[1]
    assert "/user/u/memories/notes/new.md" in acquire[1]
    lease = {"lease_ref": "memory-batch-lease"}
    assert all(event[2] == lease for event in fs.events if event[0] == "write")
    assert fs.events[-1] == ("release", lease)


async def test_cross_directory_migration_tree_locks_old_parent():
    source_uri = "viking://user/u/memories/entities/人物/小美.md"
    target_uri = "viking://user/u/memories/entities/person/xiaomei.md"
    old_file = MemoryFile(
        uri=source_uri,
        content="小美",
        memory_type="entities",
        extra_fields={"category": "人物", "name": "小美"},
    )
    fs = PathlockedInMemoryVikingFS({source_uri: MemoryFileUtils.write(old_file)})
    operations = ResolvedOperations(
        upsert_operations=[
            ResolvedOperation(
                old_memory_file_content=old_file,
                memory_type="entities",
                uris=[target_uri],
                memory_fields={"category": "person", "name": "xiaomei"},
            )
        ],
        delete_file_contents=[],
        errors=[],
    )

    lease = await acquire_memory_operation_lease(operations, fs, _ctx())

    source_directory_path = "/user/u/memories/entities/人物"
    target_file_path = "/user/u/memories/entities/person/xiaomei.md"
    mixed = next(event for event in fs.events if event[0] == "acquire_mixed")
    assert mixed[2] == (source_directory_path,)
    assert target_file_path in mixed[1]
    assert not any(path.startswith(f"{source_directory_path}/") for path in mixed[1])
    assert lease == {"lease_ref": "memory-mixed-lease"}


async def test_same_directory_migration_keeps_exact_locks():
    source_uri = "viking://user/u/memories/entities/person/小美.md"
    target_uri = "viking://user/u/memories/entities/person/xiaomei.md"
    old_file = MemoryFile(
        uri=source_uri,
        content="小美",
        memory_type="entities",
        extra_fields={"category": "person", "name": "小美"},
    )
    fs = PathlockedInMemoryVikingFS({source_uri: MemoryFileUtils.write(old_file)})
    operations = ResolvedOperations(
        upsert_operations=[
            ResolvedOperation(
                old_memory_file_content=old_file,
                memory_type="entities",
                uris=[target_uri],
                memory_fields={"category": "person", "name": "xiaomei"},
            )
        ],
        delete_file_contents=[],
        errors=[],
    )

    lease = await acquire_memory_operation_lease(operations, fs, _ctx())

    assert not any(event[0] == "acquire_mixed" for event in fs.events)
    exact = next(event for event in fs.events if event[0] == "acquire")
    assert "/user/u/memories/entities/person/小美.md" in exact[1]
    assert "/user/u/memories/entities/person/xiaomei.md" in exact[1]
    assert lease == {"lease_ref": "memory-batch-lease"}


async def test_operation_to_patch_skips_failed_field_preview_update():
    schema = MemoryTypeSchema(
        memory_type="notes",
        description="note memory",
        directory="viking://user/{{ user_space }}/memories/notes",
        filename_template="{{ note_name }}.md",
        operation_mode="upsert",
        fields=[
            MemoryField(
                name="note_name",
                field_type=FieldType.STRING,
                merge_op=MergeOp.IMMUTABLE,
            ),
            MemoryField(
                name="content",
                field_type=FieldType.STRING,
                merge_op=MergeOp.PATCH,
            ),
            MemoryField(
                name="summary",
                field_type=FieldType.STRING,
                merge_op=MergeOp.PATCH,
            ),
        ],
    )
    old_file = MemoryFile(
        uri="viking://user/u/memories/notes/note.md",
        content="old content",
        memory_type="notes",
        extra_fields={
            "note_name": "note",
            "summary": "old summary",
        },
    )
    op = ResolvedOperation(
        old_memory_file_content=old_file,
        memory_type="notes",
        uris=["viking://user/u/memories/notes/note.md"],
        memory_fields={
            "note_name": "note",
            "content": StrPatch(
                blocks=[SearchReplaceBlock(search="old content", replace="new content")]
            ),
            "summary": StrPatch(
                blocks=[SearchReplaceBlock(search="missing summary", replace="new summary")]
            ),
        },
    )

    patch = await operation_to_patch(op, schema=schema, extract_context=ExtractContext([]))

    assert patch.after_file.content == "new content"
    assert patch.after_file.extra_fields["summary"] == "old summary"
    assert isinstance(op.memory_fields["summary"], StrPatch)


@pytest.mark.asyncio
async def test_streaming_memory_updater_submit_applies_fast_path(monkeypatch):
    fs = PathlockedInMemoryVikingFS({})
    fs.search = AsyncMock(return_value=[])
    monkeypatch.setattr(
        "openviking.session.memory.streaming_memory_updater.get_viking_fs",
        lambda: fs,
    )
    monkeypatch.setattr(
        "openviking.session.memory.memory_updater.get_viking_fs",
        lambda: fs,
    )

    updater = StreamingMemoryUpdater(
        registry=_registry(),
        config=StreamingMemoryUpdaterConfig(
            max_operations_per_update=8,
            max_wait_seconds=0.01,
            timer_check_interval_seconds=0.01,
        ),
    )
    result = await updater.submit(
        MemoryUpdateRequest(
            operations=ResolvedOperations(
                upsert_operations=[_case_op("重复预订处理")],
                delete_file_contents=[],
                errors=[],
            ),
            messages=[Message(id="m1", role="user", parts=[TextPart("处理重复预订")])],
            ctx=_ctx(),
        )
    )

    assert result.request_count == 1
    assert result.operations.upsert_operations[0].memory_type == "cases"
    written_uri = "viking://user/u/memories/cases/重复预订处理.md"
    assert result.apply_result.written_uris == [written_uri]
    assert fs.writes
    _, written_content, _ = fs.writes[0]
    assert "重复预订处理" in written_content
    lease = {"lease_ref": "memory-batch-lease"}
    assert fs.events[0] == (
        "acquire",
        (
            "/user/u/memories/cases/.overview.md",
            "/user/u/memories/cases/重复预订处理.md",
        ),
        300.0,
    )
    assert ("write", written_uri, lease) in fs.events
    assert fs.events[-1] == ("release", lease)


@pytest.mark.asyncio
async def test_cached_updater_restores_vectorization_for_tool_and_skill_memories(monkeypatch):
    fs = InMemoryVikingFS({})
    fs.search = AsyncMock(return_value=[])
    monkeypatch.setattr(
        "openviking.session.memory.streaming_memory_updater.get_viking_fs",
        lambda: fs,
    )
    monkeypatch.setattr(
        "openviking.session.memory.memory_updater.get_viking_fs",
        lambda: fs,
    )

    registry = _registry()
    for memory_type, name_field in (("tools", "tool_name"), ("skills", "skill_name")):
        registry.register(
            MemoryTypeSchema(
                memory_type=memory_type,
                description=f"{memory_type} memory",
                directory=f"viking://user/{{{{ user_space }}}}/memories/{memory_type}",
                filename_template=f"{{{{ {name_field} }}}}.md",
                operation_mode="add_only",
                content_template=f"{memory_type}: {{{{ {name_field} }}}}",
                fields=[
                    MemoryField(
                        name=name_field,
                        field_type=FieldType.STRING,
                        merge_op=MergeOp.IMMUTABLE,
                    )
                ],
            )
        )

    key = ("cached-updater-vectorization", id(fs))
    degraded = await get_streaming_memory_updater(
        key=key,
        registry=registry,
        vikingdb=None,
    )
    vikingdb = AsyncMock()
    vikingdb.enqueue_embedding_msg.return_value = True
    restored = await get_streaming_memory_updater(
        key=key,
        registry=registry,
        vikingdb=vikingdb,
    )

    assert restored is degraded
    assert restored.vikingdb is vikingdb

    operations = []
    for memory_type, name_field, name in (
        ("tools", "tool_name", "terminal"),
        ("skills", "skill_name", "analyze_code"),
    ):
        operations.append(
            ResolvedOperation(
                old_memory_file_content=None,
                memory_type=memory_type,
                uris=[f"viking://user/u/memories/{memory_type}/{name}.md"],
                memory_fields={name_field: name},
            )
        )

    result = await restored.submit(
        MemoryUpdateRequest(
            operations=ResolvedOperations(
                upsert_operations=operations,
                delete_file_contents=[],
                errors=[],
            ),
            messages=[Message(id="m1", role="user", parts=[TextPart("use tools and skills")])],
            ctx=_ctx(),
        )
    )

    assert sorted(result.apply_result.written_uris) == sorted(
        operation.uris[0] for operation in operations
    )
    assert vikingdb.enqueue_embedding_msg.await_count == 2


@pytest.mark.asyncio
async def test_streaming_memory_updater_fast_path_filters_links(monkeypatch):
    fs = InMemoryVikingFS(
        {
            "viking://user/u/memories/events/existing.md": (
                'existing\n<!-- MEMORY_FIELDS\n{"memory_type":"events","content":"existing"}\n-->'
            )
        }
    )
    fs.search = AsyncMock(return_value=[])
    monkeypatch.setattr(
        "openviking.session.memory.streaming_memory_updater.get_viking_fs",
        lambda: fs,
    )
    monkeypatch.setattr(
        "openviking.session.memory.memory_updater.get_viking_fs",
        lambda: fs,
    )

    updater = StreamingMemoryUpdater(
        registry=_registry(),
        config=StreamingMemoryUpdaterConfig(
            max_operations_per_update=8,
            max_wait_seconds=0.01,
            timer_check_interval_seconds=0.01,
        ),
    )
    op1 = _case_op("并发案例A")
    link = StoredLink(
        from_uri=op1.uris[0],
        to_uri="viking://user/u/memories/events/existing.md",
        link_type="related_to",
        weight=0.8,
        match_text="并发",
        description="valid link",
    )
    duplicate_link = link.model_copy(update={"weight": 0.6, "description": "short"})
    missing_link = StoredLink(
        from_uri=op1.uris[0],
        to_uri="viking://user/u/memories/events/missing.md",
        link_type="related_to",
        weight=0.9,
        match_text="缺失",
        description="invalid link",
    )

    result = await updater.submit(
        MemoryUpdateRequest(
            operations=ResolvedOperations(
                upsert_operations=[op1],
                delete_file_contents=[],
                errors=[],
                resolved_links=[link, duplicate_link, missing_link],
            ),
            messages=[Message(id="m1", role="user", parts=[TextPart("并发A")])],
            ctx=_ctx(),
        )
    )

    assert result.request_count == 1
    assert result.metadata["flush_reason"] == "append_only_fast_path"
    assert len(result.operations.upsert_operations) == 1
    assert len(result.operations.resolved_links) == 1
    assert result.operations.resolved_links[0].to_uri.endswith("/events/existing.md")
    assert result.apply_result.written_uris == [op1.uris[0]]


@pytest.mark.asyncio
async def test_streaming_memory_updater_batches_non_append_only_submits(monkeypatch):
    fs = InMemoryVikingFS({})
    fs.search = AsyncMock(return_value=[])
    monkeypatch.setattr(
        "openviking.session.memory.streaming_memory_updater.get_viking_fs",
        lambda: fs,
    )
    monkeypatch.setattr(
        "openviking.session.memory.memory_updater.get_viking_fs",
        lambda: fs,
    )

    updater = StreamingMemoryUpdater(
        registry=_registry(),
        config=StreamingMemoryUpdaterConfig(
            max_operations_per_update=2,
            max_wait_seconds=0.01,
            timer_check_interval_seconds=0.01,
        ),
    )
    op1 = _note_op("note_a")
    op2 = _note_op("note_b")

    result1, result2 = await asyncio.gather(
        updater.submit(
            MemoryUpdateRequest(
                operations=ResolvedOperations(
                    upsert_operations=[op1],
                    delete_file_contents=[],
                    errors=[],
                ),
                messages=[Message(id="m1", role="user", parts=[TextPart("note A")])],
                ctx=_ctx(),
            )
        ),
        updater.submit(
            MemoryUpdateRequest(
                operations=ResolvedOperations(
                    upsert_operations=[op2],
                    delete_file_contents=[],
                    errors=[],
                ),
                messages=[Message(id="m2", role="user", parts=[TextPart("note B")])],
                ctx=_ctx(),
            )
        ),
    )

    assert result1 is not result2
    assert result1.request_count == 1
    assert result2.request_count == 1
    assert result1.metadata["flush_reason"] == "count"
    assert result1.metadata["batch_request_count"] == 2
    assert result1.metadata["scoped_to_submitter"] is True
    assert result1.apply_result.written_uris == [op1.uris[0]]
    assert result2.apply_result.written_uris == [op2.uris[0]]
    assert sorted(result1.metadata["unscoped_written_uris"]) == sorted([op1.uris[0], op2.uris[0]])


@pytest.mark.asyncio
async def test_merge_requests_skips_patch_merge_for_same_session(monkeypatch):
    merge_mock = AsyncMock()
    monkeypatch.setattr(
        "openviking.session.memory.streaming_memory_updater.merge_memory_operations",
        merge_mock,
    )
    updater = StreamingMemoryUpdater(registry=_registry())

    def make_request(suffix: str, extraction_id: str) -> MemoryUpdateRequest:
        return MemoryUpdateRequest(
            operations=ResolvedOperations(
                upsert_operations=[
                    _note_op(f"add_{suffix}"),
                    _note_update_op(f"update_{suffix}"),
                ],
                delete_file_contents=[_note_delete_file(f"delete_{suffix}")],
                errors=[],
            ),
            messages=[],
            ctx=_ctx(),
            metadata={
                "session_id": "same-session",
                "source_extraction_id": extraction_id,
            },
        )

    merged = await updater._merge_requests(
        [
            make_request("a", "extract-a"),
            make_request("b", "extract-b"),
        ]
    )

    merge_mock.assert_not_awaited()
    assert len(merged.upsert_operations) == 4
    assert len(merged.delete_file_contents) == 2


@pytest.mark.asyncio
async def test_merge_requests_merges_cross_session_operation_kinds_in_parallel(monkeypatch):
    entered: set[str] = set()
    all_entered = asyncio.Event()
    release = asyncio.Event()

    async def fake_merge_memory_operations(**kwargs):
        operations = kwargs["operations"]
        if operations.delete_file_contents:
            kind = "delete"
            assert not operations.upsert_operations
        elif all(op.old_memory_file_content is None for op in operations.upsert_operations):
            kind = "add"
        else:
            kind = "update"
            assert all(
                op.old_memory_file_content is not None for op in operations.upsert_operations
            )
        assert kwargs["force_merge"] is True
        entered.add(kind)
        if len(entered) == 3:
            all_entered.set()
        await release.wait()
        return operations

    monkeypatch.setattr(
        "openviking.session.memory.streaming_memory_updater.merge_memory_operations",
        fake_merge_memory_operations,
    )
    updater = StreamingMemoryUpdater(registry=_registry())

    def make_request(suffix: str, session_id: str) -> MemoryUpdateRequest:
        return MemoryUpdateRequest(
            operations=ResolvedOperations(
                upsert_operations=[
                    _note_op(f"add_{suffix}"),
                    _note_update_op(f"update_{suffix}"),
                ],
                delete_file_contents=[_note_delete_file(f"delete_{suffix}")],
                errors=[],
            ),
            messages=[],
            ctx=_ctx(),
            metadata={"session_id": session_id},
        )

    merge_task = asyncio.create_task(
        updater._merge_requests(
            [
                make_request("a", "session-a"),
                make_request("b", "session-b"),
            ]
        )
    )
    await asyncio.wait_for(all_entered.wait(), timeout=5)
    assert not merge_task.done()
    release.set()
    merged = await asyncio.wait_for(merge_task, timeout=5)

    assert entered == {"add", "update", "delete"}
    assert len(merged.upsert_operations) == 4
    assert len(merged.delete_file_contents) == 2


@pytest.mark.asyncio
async def test_merge_requests_rejects_uri_conflicts_between_operation_kinds():
    updater = StreamingMemoryUpdater(registry=_registry())
    request = MemoryUpdateRequest(
        operations=ResolvedOperations(
            upsert_operations=[_note_op("conflict")],
            delete_file_contents=[_note_delete_file("conflict")],
            errors=[],
        ),
        messages=[],
        ctx=_ctx(),
        metadata={"session_id": "session-a"},
    )

    merged = await updater._merge_requests([request])

    assert merged.upsert_operations == []
    assert merged.delete_file_contents == []
    assert "Conflicting add/update/delete results" in merged.errors[0]


def test_scope_memory_update_result_to_submitter_filters_shared_batch_by_source():
    from openviking.session.memory.streaming_memory_updater import (
        scope_memory_update_result_to_submitter,
    )

    op_a = _note_op_with_source("scoped_a", "extract_a")
    op_b = _note_op_with_source("scoped_b", "extract_b")
    apply_result = MemoryUpdateResult()
    apply_result.add_written(op_a.uris[0])
    apply_result.add_written(op_b.uris[0])
    apply_result.add_skipped(
        SkippedMemoryOperation(
            memory_type="preferences",
            reason_code=MemoryOperationSkipCode.PEER_NOT_ALLOWED,
            reason="Target peer is outside the allowed memory scope",
            source=MemoryOperationSource(
                extraction_id="extract_a",
                session_id="session_a",
            ),
        )
    )
    apply_result.add_skipped(
        SkippedMemoryOperation(
            memory_type="preferences",
            reason_code=MemoryOperationSkipCode.PEER_MEMORY_DISABLED,
            reason="Peer memory writes are disabled",
            source=MemoryOperationSource(
                extraction_id="extract_b",
                session_id="session_a",
            ),
        )
    )
    batch_result = StreamingMemoryUpdateResult(
        operations=ResolvedOperations(
            upsert_operations=[op_a, op_b],
            delete_file_contents=[],
            errors=[],
        ),
        apply_result=apply_result,
        request_count=2,
        metadata={"flush_reason": "count", "operation_count": 2},
    )
    request = MemoryUpdateRequest(
        operations=ResolvedOperations(
            upsert_operations=[op_a],
            delete_file_contents=[],
            errors=[],
        ),
        messages=[Message(id="m1", role="user", parts=[TextPart("note A")])],
        ctx=_ctx(),
        metadata={"source_extraction_id": "extract_a", "session_id": "session_a"},
    )

    scoped = scope_memory_update_result_to_submitter(batch_result, request)

    assert scoped.request_count == 1
    assert scoped.metadata["batch_request_count"] == 2
    assert scoped.metadata["scoped_to_source_extraction_id"] == "extract_a"
    assert scoped.apply_result.written_uris == [op_a.uris[0]]
    assert len(scoped.apply_result.skipped_operations) == 1
    assert scoped.apply_result.skipped_operations[0].reason_code == (
        MemoryOperationSkipCode.PEER_NOT_ALLOWED
    )
    assert scoped.operations.upsert_operations == [op_a]
    assert scoped.metadata["unscoped_written_uris"] == [op_a.uris[0], op_b.uris[0]]


def test_split_request_by_merge_group_keeps_rename_source_for_add_and_delete():
    old_uri = "viking://user/u/memories/notes/old.md"
    new_uri = "viking://user/u/memories/notes/new.md"
    old_file = MemoryFile(
        uri=old_uri,
        content="old body",
        memory_type="notes",
        extra_fields={"note_name": "old"},
    )
    rename_op = ResolvedOperation(
        old_memory_file_content=old_file,
        memory_type="notes",
        uris=[new_uri],
        memory_fields={"note_name": "new", "content": "old body"},
    )
    request = MemoryUpdateRequest(
        operations=ResolvedOperations(
            upsert_operations=[rename_op],
            delete_file_contents=[],
            errors=[],
        ),
        messages=[],
        ctx=_ctx(),
    )

    grouped = split_request_by_merge_group(request)

    [(_, group_request)] = grouped
    [cloned] = group_request.operations.upsert_operations
    assert cloned.uris == [new_uri]
    assert cloned.old_memory_file_content is not None
    assert cloned.old_memory_file_content.uri == old_uri


def test_split_request_by_merge_group_groups_by_peer_and_memory_type():
    self_op = _note_op("self_note")
    peer_op = _peer_note_op("peer_note", "web-visitor-alice")
    case_op = _case_op("case_note")
    link = StoredLink(
        from_uri=self_op.uris[0],
        to_uri=peer_op.uris[0],
        link_type="related_to",
        weight=0.8,
    )
    request = MemoryUpdateRequest(
        operations=ResolvedOperations(
            upsert_operations=[self_op, peer_op, case_op],
            delete_file_contents=[],
            errors=[],
            resolved_links=[link],
        ),
        messages=[],
        ctx=_ctx(),
    )

    grouped = split_request_by_merge_group(request)

    assert [key for key, _ in grouped] == [
        MemoryMergeGroupKey(peer_id=None, memory_type="notes"),
        MemoryMergeGroupKey(peer_id="web-visitor-alice", memory_type="notes"),
        MemoryMergeGroupKey(peer_id=None, memory_type="cases"),
    ]
    assert [len(group_request.operations.upsert_operations) for _, group_request in grouped] == [
        1,
        1,
        1,
    ]
    assert [len(group_request.operations.resolved_links) for _, group_request in grouped] == [
        0,
        0,
        0,
    ]


def test_split_request_keeps_unresolved_upserts_separate_from_delete_groups():
    replacement = _note_op("replacement")
    unresolved = _note_op("skipped")
    unresolved.uris = []
    old_file = _note_delete_file("old")
    request = MemoryUpdateRequest(
        operations=ResolvedOperations(
            upsert_operations=[replacement, unresolved],
            delete_file_contents=[old_file],
            errors=[],
            delete_replacements={old_file.uri: replacement.uris[0]},
        ),
        messages=[],
        ctx=_ctx(),
    )

    grouped = split_request_by_merge_group(request)

    assert len(grouped) == 2
    replacement_key, replacement_request = grouped[0]
    assert replacement_key == MemoryMergeGroupKey(peer_id=None, memory_type="notes")
    assert replacement_request.operations.upsert_operations == [replacement]
    assert replacement_request.operations.delete_file_contents == [old_file]
    assert replacement_request.operations.delete_replacements == {old_file.uri: replacement.uris[0]}

    unresolved_key, unresolved_request = grouped[1]
    assert unresolved_key == MemoryMergeGroupKey(peer_id=None, memory_type="")
    assert unresolved_request.operations.upsert_operations == [unresolved]
    assert unresolved_request.operations.delete_file_contents == []
    assert unresolved_request.operations.delete_replacements == {}


def test_split_request_by_merge_group_infers_peer_from_uri_when_field_missing():
    peer_uri = "viking://user/u/peers/conv-42/memories/notes/peer_note.md"
    op = ResolvedOperation(
        old_memory_file_content=None,
        memory_fields={"note_name": "peer_note", "content": "peer content"},
        memory_type="notes",
        uris=[peer_uri],
    )
    request = MemoryUpdateRequest(
        operations=ResolvedOperations(
            upsert_operations=[op],
            delete_file_contents=[],
            errors=[],
        ),
        messages=[],
        ctx=_ctx(),
    )

    grouped = split_request_by_merge_group(request)

    assert [key for key, _ in grouped] == [
        MemoryMergeGroupKey(peer_id="conv-42", memory_type="notes")
    ]


def test_enforce_merge_group_peer_id_rewrites_merged_output_scope():
    op = ResolvedOperation(
        old_memory_file_content=None,
        memory_fields={"note_name": "peer_note", "content": "peer content"},
        memory_type="notes",
        uris=["viking://user/u/memories/notes/peer_note.md"],
    )

    enforce_merge_group_peer_id(
        [op],
        peer_id="conv-42",
        memory_type="notes",
        registry=_registry(),
        ctx=_ctx(),
    )

    assert op.memory_fields["peer_id"] == "conv-42"
    assert op.uris == ["viking://user/u/peers/conv-42/memories/notes/peer_note.md"]


def test_enforce_merge_group_reapplies_portable_uri_without_changing_memory_name():
    op = ResolvedOperation(
        old_memory_file_content=None,
        memory_fields={"note_name": "Desktop /new", "content": "peer content"},
        memory_type="notes",
        uris=["viking://user/u/memories/notes/temporary.md"],
    )

    enforce_merge_group_peer_id(
        [op],
        peer_id="conv-42",
        memory_type="notes",
        registry=_registry(),
        ctx=_ctx(),
    )

    assert op.memory_fields["note_name"] == "Desktop /new"
    assert op.uris == ["viking://user/u/peers/conv-42/memories/notes/Desktop _new.md"]


def test_enforce_merge_group_self_scope_removes_peer_id():
    op = ResolvedOperation(
        old_memory_file_content=None,
        memory_fields={
            "note_name": "self_note",
            "content": "self content",
            "peer_id": "conv-42",
        },
        memory_type="notes",
        uris=["viking://user/u/peers/conv-42/memories/notes/self_note.md"],
    )

    enforce_merge_group_peer_id(
        [op],
        peer_id=None,
        memory_type="notes",
        registry=_registry(),
        ctx=_ctx(),
    )

    assert "peer_id" not in op.memory_fields
    assert op.uris == ["viking://user/u/memories/notes/self_note.md"]


def test_enforce_merge_group_peer_enabled_false_keeps_self_scope():
    op = ResolvedOperation(
        old_memory_file_content=None,
        memory_fields={
            "case_name": "case_note",
            "task_signature": "case signature",
            "input": "{}",
            "rubric": "{}",
            "peer_id": "conv-42",
        },
        memory_type="cases",
        uris=["viking://user/u/peers/conv-42/memories/cases/case_note.md"],
    )

    enforce_merge_group_peer_id(
        [op],
        peer_id="conv-42",
        memory_type="cases",
        registry=_registry(),
        ctx=_ctx(),
    )

    assert "peer_id" not in op.memory_fields
    assert op.uris == ["viking://user/u/memories/cases/case_note.md"]


@pytest.mark.asyncio
@pytest.mark.parametrize(
    "template_change",
    [
        "none",
        "unrelated_type",
        "description",
        "field_description",
        "body",
        "renderer",
    ],
)
async def test_template_snapshot_updates_same_uri(monkeypatch, template_change):
    uri = "viking://user/u/memories/notes/profile.md"
    original = "City: Beijing\nRole: engineer"
    expected = "City: Shanghai\nRole: scientist"
    old = MemoryFile(uri=uri, memory_type="notes", content=original)
    raw = MemoryFileUtils.write(old)
    fs = InMemoryVikingFS({uri: raw})
    for module in ("streaming_memory_updater", "memory_updater"):
        monkeypatch.setattr(f"openviking.session.memory.{module}.get_viking_fs", lambda: fs)
    requests = []
    for index, replacement in enumerate(
        ("City: Shanghai\nRole: engineer", "City: Beijing\nRole: scientist")
    ):
        registry = _registry()
        if index == 1:
            schema = registry.get("notes")
            if template_change == "unrelated_type":
                registry.get("cases").description = "Unrelated new description"
            elif template_change == "description":
                schema.description = "New description"
            elif template_change == "field_description":
                schema.fields[-1].description = "New field description"
            elif template_change == "body":
                schema.content_template = "# New body\n{{ content }}"
            elif template_change == "renderer":
                schema._account_content_template = True
        requests.append(
            MemoryUpdateRequest(
                operations=ResolvedOperations(
                    upsert_operations=[
                        ResolvedOperation(
                            memory_type="notes",
                            uris=[uri],
                            old_memory_file_content=old.model_copy(deep=True),
                            memory_fields={
                                "content": StrPatch(
                                    blocks=[
                                        SearchReplaceBlock(search=original, replace=replacement)
                                    ]
                                )
                            },
                        )
                    ],
                    delete_file_contents=[],
                    errors=[],
                ),
                messages=[],
                ctx=_ctx(),
                memory_registry=registry,
                metadata={"session_id": f"s{index}"},
            )
        )

    async def coordinated_merge(**kwargs):
        # Deterministic substitute for the LLM; the real updater still writes the file.
        assert kwargs["registry"] is requests[0].memory_registry
        assert len(kwargs["operations"].upsert_operations) == 2
        op = requests[0].operations.upsert_operations[0].model_copy(deep=True)
        op.memory_fields["content"] = StrPatch(
            blocks=[SearchReplaceBlock(search=original, replace=expected)]
        )
        return ResolvedOperations(upsert_operations=[op], delete_file_contents=[], errors=[])

    merge = AsyncMock(side_effect=coordinated_merge)
    monkeypatch.setattr(
        "openviking.session.memory.streaming_memory_updater.merge_memory_operations", merge
    )
    updater = StreamingMemoryUpdater(
        registry=_registry(),
        config=StreamingMemoryUpdaterConfig(max_operations_per_update=2),
    )
    try:
        results = await asyncio.gather(
            *(updater.submit(request) for request in requests), return_exceptions=True
        )
        if template_change in {"none", "unrelated_type"}:
            merge.assert_awaited_once()
            assert all(not result.apply_result.errors for result in results)
            assert MemoryFileUtils.read(fs.files[uri]).plain_content() == expected
        else:
            assert all(isinstance(result, ConflictError) for result in results)
            assert all(uri in str(result) and "Re-extract" in str(result) for result in results)
            merge.assert_not_awaited()
            assert fs.files == {uri: raw}
            assert not fs.writes
            # A new extraction with consistent current templates can be retried.
            requests[0].memory_registry = requests[1].memory_registry = _registry()
            retried = await asyncio.gather(*(updater.submit(request) for request in requests))
            assert all(not result.apply_result.errors for result in retried)
            assert MemoryFileUtils.read(fs.files[uri]).plain_content() == expected
    finally:
        await updater.close()


@pytest.mark.asyncio
@pytest.mark.parametrize(
    "kinds", [("add", "add"), ("update", "delete"), ("delete", "update"), ("delete", "delete")]
)
async def test_template_snapshot_conflicts_cover_adds_and_deletes(monkeypatch, kinds):
    uri = "viking://user/u/memories/notes/profile.md"
    old = MemoryFile(uri=uri, memory_type="notes", content="Original")
    fs = InMemoryVikingFS({uri: MemoryFileUtils.write(old)} if "add" not in kinds else {})
    original_files = dict(fs.files)
    for module in ("streaming_memory_updater", "memory_updater"):
        monkeypatch.setattr(f"openviking.session.memory.{module}.get_viking_fs", lambda: fs)
    requests = []
    for index, kind in enumerate(kinds):
        registry = _registry()
        registry.get("notes").description = f"Version {index}"
        op = _note_op("profile")
        if kind == "update":
            op.old_memory_file_content = old.model_copy(deep=True)
        requests.append(
            MemoryUpdateRequest(
                operations=ResolvedOperations(
                    upsert_operations=[] if kind == "delete" else [op],
                    delete_file_contents=[old] if kind == "delete" else [],
                    errors=[],
                ),
                messages=[],
                ctx=_ctx(),
                memory_registry=registry,
                metadata={"session_id": f"s{index}"},
            )
        )
    updater = StreamingMemoryUpdater(
        registry=_registry(), config=StreamingMemoryUpdaterConfig(max_operations_per_update=2)
    )
    try:
        results = await asyncio.gather(
            *(updater.submit(request) for request in requests), return_exceptions=True
        )
        assert all(isinstance(result, ConflictError) for result in results)
        assert fs.files == original_files
        assert not fs.writes
    finally:
        await updater.close()


@pytest.mark.asyncio
@pytest.mark.parametrize("alias", ["viking://user/memories/notes/profile.md", "case_variant"])
async def test_template_snapshot_conflicts_compare_storage_paths(monkeypatch, alias):
    fs = PathlockedInMemoryVikingFS()
    monkeypatch.setattr(
        "openviking.session.memory.streaming_memory_updater.get_viking_fs", lambda: fs
    )
    requests = []
    for index in range(2):
        registry = _registry()
        registry.get("notes").description = f"Version {index}"
        op = _note_op("profile")
        if index:
            op.uris = [
                op.uris[0].replace("profile.md", "PROFILE.md") if alias == "case_variant" else alias
            ]
        requests.append(
            MemoryUpdateRequest(
                operations=ResolvedOperations(
                    upsert_operations=[op], delete_file_contents=[], errors=[]
                ),
                messages=[],
                ctx=_ctx(),
                memory_registry=registry,
            )
        )
    merge = AsyncMock()
    monkeypatch.setattr(StreamingMemoryUpdater, "_merge_requests", merge)
    updater = StreamingMemoryUpdater(registry=_registry())
    try:
        with pytest.raises(ConflictError):
            await updater._process_batch(MemoryMergeGroupKey(None, "notes"), requests, "count")
        merge.assert_not_awaited()
        assert not fs.writes
    finally:
        await updater.close()


@pytest.mark.asyncio
@pytest.mark.parametrize("target", ["shared_new_target", "note0"])
async def test_template_snapshot_conflicts_check_merged_targets_before_writes(monkeypatch, target):
    requests = []
    for index in range(2):
        registry = _registry()
        registry.get("notes").description = f"Version {index}"
        requests.append(
            MemoryUpdateRequest(
                operations=ResolvedOperations(
                    upsert_operations=[_note_op(f"note{index}")], delete_file_contents=[], errors=[]
                ),
                messages=[],
                ctx=_ctx(),
                memory_registry=registry,
            )
        )

    async def retarget_merge(batch):
        merged = batch[0].operations.model_copy(deep=True)
        merged.upsert_operations[0].uris = [f"viking://user/u/memories/notes/{target}.md"]
        return merged

    merge = AsyncMock(side_effect=retarget_merge)
    apply = AsyncMock()
    monkeypatch.setattr(StreamingMemoryUpdater, "_merge_requests", merge)
    monkeypatch.setattr(StreamingMemoryUpdater, "_apply_operations", apply)
    monkeypatch.setattr(
        "openviking.session.memory.streaming_memory_updater.get_viking_fs", lambda: None
    )
    updater = StreamingMemoryUpdater(registry=_registry())
    try:
        with pytest.raises(ConflictError):
            await updater._process_batch(MemoryMergeGroupKey(None, "notes"), requests, "count")
        assert merge.await_count == 2
        apply.assert_not_awaited()
    finally:
        await updater.close()


@pytest.mark.asyncio
async def test_streaming_memory_updater_separates_template_snapshots(monkeypatch):
    fs = InMemoryVikingFS({})
    for module in ("streaming_memory_updater", "memory_updater"):
        monkeypatch.setattr(f"openviking.session.memory.{module}.get_viking_fs", lambda: fs)
    updater = StreamingMemoryUpdater(
        registry=_registry(),
        config=StreamingMemoryUpdaterConfig(
            max_operations_per_update=2,
            max_wait_seconds=0.05,
            timer_check_interval_seconds=0.01,
        ),
    )
    requests = []
    for index in (1, 2):
        registry = _registry()
        registry.get("notes").content_template = f"# Version {index}\n{{{{ content }}}}"
        requests.append(
            MemoryUpdateRequest(
                operations=ResolvedOperations(
                    upsert_operations=[_note_op(f"note{index}")],
                    delete_file_contents=[],
                    errors=[],
                ),
                messages=[],
                ctx=_ctx(),
                memory_registry=registry,
                metadata={"session_id": f"s{index}"},
            )
        )
    try:
        results = await asyncio.gather(*(updater.submit(request) for request in requests))
    finally:
        await updater.close()
    for index, result in enumerate(results, 1):
        assert not result.apply_result.errors
        uri = f"viking://user/u/memories/notes/note{index}.md"
        content = MemoryFileUtils.read(fs.files[uri], uri=uri).content
        assert f"# Version {index}" in content
        assert f"# Version {3 - index}" not in content


@pytest.mark.asyncio
async def test_streaming_memory_updater_batches_per_merge_group(monkeypatch):
    fs = InMemoryVikingFS({})
    fs.search = AsyncMock(return_value=[])
    monkeypatch.setattr(
        "openviking.session.memory.streaming_memory_updater.get_viking_fs",
        lambda: fs,
    )
    monkeypatch.setattr(
        "openviking.session.memory.memory_updater.get_viking_fs",
        lambda: fs,
    )

    updater = StreamingMemoryUpdater(
        registry=_registry(),
        config=StreamingMemoryUpdaterConfig(
            max_operations_per_update=2,
            max_wait_seconds=0.05,
            timer_check_interval_seconds=0.01,
        ),
    )
    note_a = _note_op("note_group_a")
    note_b = _note_op("note_group_b")
    peer_note = _peer_note_op("note_peer", "web-visitor-alice")

    result1, result2, peer_result = await asyncio.gather(
        updater.submit(
            MemoryUpdateRequest(
                operations=ResolvedOperations(
                    upsert_operations=[note_a],
                    delete_file_contents=[],
                    errors=[],
                ),
                messages=[Message(id="m1", role="user", parts=[TextPart("note A")])],
                ctx=_ctx(),
            )
        ),
        updater.submit(
            MemoryUpdateRequest(
                operations=ResolvedOperations(
                    upsert_operations=[note_b],
                    delete_file_contents=[],
                    errors=[],
                ),
                messages=[Message(id="m2", role="user", parts=[TextPart("note B")])],
                ctx=_ctx(),
            )
        ),
        updater.submit(
            MemoryUpdateRequest(
                operations=ResolvedOperations(
                    upsert_operations=[peer_note],
                    delete_file_contents=[],
                    errors=[],
                ),
                messages=[Message(id="m3", role="user", parts=[TextPart("peer note")])],
                ctx=_ctx(),
            )
        ),
    )

    assert result1 is not result2
    assert result1.request_count == 1
    assert result2.request_count == 1
    assert result1.metadata["flush_reason"] == "count"
    assert result1.metadata["batch_request_count"] == 2
    assert result1.metadata["merge_group"] == "peer=self,memory_type=notes"
    assert result1.apply_result.written_uris == [note_a.uris[0]]
    assert result2.apply_result.written_uris == [note_b.uris[0]]

    assert peer_result is not result1
    assert peer_result.request_count == 1
    assert peer_result.metadata["flush_reason"] == "time"
    assert peer_result.metadata["merge_group"] == "peer=web-visitor-alice,memory_type=notes"
    assert peer_result.apply_result.written_uris == [peer_note.uris[0]]


@pytest.mark.asyncio
async def test_streaming_memory_updater_submit_waits_for_all_merge_groups(monkeypatch):
    fs = InMemoryVikingFS({})
    fs.search = AsyncMock(return_value=[])
    monkeypatch.setattr(
        "openviking.session.memory.streaming_memory_updater.get_viking_fs",
        lambda: fs,
    )
    monkeypatch.setattr(
        "openviking.session.memory.memory_updater.get_viking_fs",
        lambda: fs,
    )

    updater = StreamingMemoryUpdater(
        registry=_registry(),
        config=StreamingMemoryUpdaterConfig(
            max_operations_per_update=8,
            max_wait_seconds=0.01,
            timer_check_interval_seconds=0.01,
        ),
    )
    self_op = _note_op("multi_self")
    peer_op = _peer_note_op("multi_peer", "web-visitor-alice")

    result = await updater.submit(
        MemoryUpdateRequest(
            operations=ResolvedOperations(
                upsert_operations=[self_op, peer_op],
                delete_file_contents=[],
                errors=[],
            ),
            messages=[Message(id="m1", role="user", parts=[TextPart("multi group")])],
            ctx=_ctx(),
        )
    )

    assert result.metadata["combined_result"] is True
    assert result.request_count == 1
    assert result.metadata["batch_request_count"] == 2
    assert sorted(result.apply_result.written_uris) == sorted([self_op.uris[0], peer_op.uris[0]])
    assert self_op.uris[0] in fs.files
    assert peer_op.uris[0] in fs.files


@pytest.mark.asyncio
async def test_streaming_memory_updater_applies_cross_group_links_after_all_groups(monkeypatch):
    fs = PathlockedInMemoryVikingFS({})
    fs.search = AsyncMock(return_value=[])
    monkeypatch.setattr(
        "openviking.session.memory.streaming_memory_updater.get_viking_fs",
        lambda: fs,
    )
    monkeypatch.setattr(
        "openviking.session.memory.memory_updater.get_viking_fs",
        lambda: fs,
    )

    updater = StreamingMemoryUpdater(
        registry=_registry(),
        config=StreamingMemoryUpdaterConfig(
            max_operations_per_update=8,
            max_wait_seconds=0.01,
            timer_check_interval_seconds=0.01,
        ),
    )
    self_op = _note_op("linked_self")
    peer_op = _peer_note_op("linked_peer", "web-visitor-alice")
    link = StoredLink(
        from_uri=self_op.uris[0],
        to_uri=peer_op.uris[0],
        link_type="related_to",
        weight=0.8,
        match_text="linked",
    )

    result = await updater.submit(
        MemoryUpdateRequest(
            operations=ResolvedOperations(
                upsert_operations=[self_op, peer_op],
                delete_file_contents=[],
                errors=[],
                resolved_links=[link],
            ),
            messages=[Message(id="m1", role="user", parts=[TextPart("cross group link")])],
            ctx=_ctx(),
        )
    )

    self_file = MemoryFileUtils.read(fs.files[self_op.uris[0]], uri=self_op.uris[0])
    peer_file = MemoryFileUtils.read(fs.files[peer_op.uris[0]], uri=peer_op.uris[0])

    assert len(result.operations.resolved_links) == 1
    assert self_file.links[0]["to_uri"] == peer_op.uris[0]
    assert peer_file.backlinks[0]["from_uri"] == self_op.uris[0]
    post_link_acquire = [event for event in fs.events if event[0] == "acquire"][-1]
    assert post_link_acquire[1] == (
        "/user/u/memories/notes/linked_self.md",
        "/user/u/peers/web-visitor-alice/memories/notes/linked_peer.md",
    )
    post_link_events = fs.events[fs.events.index(post_link_acquire) :]
    post_link_lease = post_link_events[-1][1]
    assert post_link_events[-1] == ("release", post_link_lease)
    assert {event[1] for event in post_link_events if event[0] == "write"} == {
        self_op.uris[0],
        peer_op.uris[0],
    }
    assert all(event[2] == post_link_lease for event in post_link_events if event[0] == "write")


async def test_classify_memory_merge_mode_forces_cross_extraction_merge():
    op1 = _note_op_with_source("note_a", "extract_a")
    op2 = _note_op_with_source("note_b", "extract_b")

    fast_path, reason = await classify_memory_merge_mode(
        [op1, op2], schema=_registry().get("notes")
    )

    assert fast_path is False
    assert reason == "cross_extraction_batch"


async def test_classify_memory_merge_mode_treats_noop_str_patch_as_unchanged():
    old_file = MemoryFile(
        uri="viking://user/u/memories/notes/note.md",
        content="old content",
        memory_type="notes",
        extra_fields={"note_name": "note"},
    )
    op = ResolvedOperation(
        old_memory_file_content=old_file,
        memory_type="notes",
        uris=["viking://user/u/memories/notes/note.md"],
        memory_fields={
            "note_name": "note",
            "content": StrPatch(
                blocks=[SearchReplaceBlock(search="old content", replace="old content")]
            ),
        },
    )

    fast_path, reason = await classify_memory_merge_mode([op], schema=_registry().get("notes"))

    assert fast_path is True
    assert reason == "single_existing_content_unchanged"


async def test_classify_memory_merge_mode_detects_changed_str_patch_after_preview():
    old_file = MemoryFile(
        uri="viking://user/u/memories/notes/note.md",
        content="old content",
        memory_type="notes",
        extra_fields={"note_name": "note"},
    )
    op = ResolvedOperation(
        old_memory_file_content=old_file,
        memory_type="notes",
        uris=["viking://user/u/memories/notes/note.md"],
        memory_fields={
            "note_name": "note",
            "content": StrPatch(
                blocks=[SearchReplaceBlock(search="old content", replace="new content")]
            ),
        },
    )

    fast_path, reason = await classify_memory_merge_mode([op], schema=_registry().get("notes"))

    assert fast_path is False
    assert reason == "single_existing_content_changed"


@pytest.mark.asyncio
async def test_streaming_memory_updater_persists_source_extraction_id_trace_id_and_hides_from_read(
    monkeypatch,
):
    fs = InMemoryVikingFS({})
    fs.search = AsyncMock(return_value=[])
    monkeypatch.setattr(
        "openviking.session.memory.streaming_memory_updater.get_viking_fs",
        lambda: fs,
    )
    monkeypatch.setattr(
        "openviking.session.memory.memory_updater.get_viking_fs",
        lambda: fs,
    )

    updater = StreamingMemoryUpdater(
        registry=_registry(),
        config=StreamingMemoryUpdaterConfig(
            max_operations_per_update=8,
            max_wait_seconds=0.01,
            timer_check_interval_seconds=0.01,
        ),
    )
    op = _note_op("note_source")
    result = await updater.submit(
        MemoryUpdateRequest(
            operations=ResolvedOperations(
                upsert_operations=[op],
                delete_file_contents=[],
                errors=[],
            ),
            messages=[Message(id="m1", role="user", parts=[TextPart("note source")])],
            ctx=_ctx(),
            metadata={"source_extraction_id": "extract_1", "trace_id": "trace_1"},
        )
    )

    assert result.apply_result.written_uris == [op.uris[0]]
    assert '"source_extraction_id": "extract_1"' in fs.files[op.uris[0]]
    assert '"last_update_trace_id": "trace_1"' in fs.files[op.uris[0]]

    from openviking.server.identity import ToolContext
    from openviking.session.memory.tools import MemoryReadTool

    read_result = await MemoryReadTool().execute(
        ToolContext(viking_fs=fs, request_ctx=_ctx(), read_file_contents={}),
        uri=op.uris[0],
    )

    assert "source_extraction_id" not in read_result
    assert "last_update_trace_id" not in read_result


async def test_render_operation_after_file_content_persists_source_trace_id():
    schema = _registry().get("notes")
    op = _note_op("note_trace")
    op.source = MemoryOperationSource(extraction_id="extract_2", trace_id="trace_2")

    rendered = await render_operation_after_file_content(
        op,
        schema=schema,
        extract_context=ExtractContext([]),
    )

    assert '"source_extraction_id": "extract_2"' in rendered
    assert '"last_update_trace_id": "trace_2"' in rendered


@pytest.mark.asyncio
async def test_cross_extraction_merge_preserves_existing_uri_without_explicit_delete(monkeypatch):
    _patch_language_config(monkeypatch)
    existing_uri = "viking://user/u/memories/notes/existing.md"
    winner_uri = "viking://user/u/memories/notes/winner.md"
    old_file = __import__(
        "openviking.session.memory.dataclass", fromlist=["MemoryFile"]
    ).MemoryFile(
        uri=existing_uri,
        content="old",
        memory_type="notes",
        extra_fields={"note_name": "existing"},
    )
    existing_op = ResolvedOperation(
        old_memory_file_content=old_file,
        memory_type="notes",
        uris=[existing_uri],
        memory_fields={
            "note_name": "existing",
            "content": {"blocks": [{"search": "old", "replace": "old updated"}]},
            "source_extraction_id": "extract_a",
        },
    )
    new_op = ResolvedOperation(
        old_memory_file_content=None,
        memory_type="notes",
        uris=[winner_uri],
        memory_fields={
            "note_name": "winner",
            "content": "merged content",
            "source_extraction_id": "extract_b",
        },
    )

    async def fake_run(self):
        assert isinstance(self.context_provider._vlm_config, _TestVLMResolver)
        return (
            ResolvedOperations(
                upsert_operations=[new_op],
                delete_file_contents=[],
                errors=[],
            ),
            [],
        )

    monkeypatch.setattr(
        "openviking.session.memory.streaming_memory_updater.ExtractLoop.run",
        fake_run,
    )
    fs = InMemoryVikingFS({existing_uri: "old"})
    fs.search = AsyncMock(return_value=[])
    monkeypatch.setattr(
        "openviking.session.memory.streaming_memory_updater.get_viking_fs",
        lambda: fs,
    )
    monkeypatch.setattr(
        "openviking.session.memory.memory_updater.get_viking_fs",
        lambda: fs,
    )

    merged = await merge_one_memory_type_operations(
        memory_type="notes",
        operations=[existing_op, new_op],
        messages=[],
        ctx=_ctx(),
        registry=_registry(),
        vlm_resolver=_TestVLMResolver(),
    )

    assert [op.uris for op in merged.upsert_operations] == [[winner_uri]]
    assert merged.delete_file_contents == []


@pytest.mark.asyncio
async def test_force_merge_sends_delete_only_group_through_patch_merge(monkeypatch):
    _patch_language_config(monkeypatch)
    delete_file = _note_delete_file("obsolete")
    replacement_uri = "viking://user/u/memories/notes/replacement.md"
    merge_called = False

    async def fake_run(self):
        nonlocal merge_called
        assert isinstance(self.context_provider._vlm_config, _TestVLMResolver)
        merge_called = True
        return (
            ResolvedOperations(
                upsert_operations=[],
                delete_file_contents=[delete_file],
                errors=[],
            ),
            [],
        )

    monkeypatch.setattr(
        "openviking.session.memory.streaming_memory_updater.ExtractLoop.run",
        fake_run,
    )
    fs = InMemoryVikingFS({delete_file.uri: delete_file.content})
    fs.search = AsyncMock(return_value=[])
    monkeypatch.setattr(
        "openviking.session.memory.streaming_memory_updater.get_viking_fs",
        lambda: fs,
    )

    merged = await merge_memory_operations(
        operations=ResolvedOperations(
            upsert_operations=[],
            delete_file_contents=[delete_file],
            errors=[],
            delete_replacements={delete_file.uri: replacement_uri},
        ),
        messages=[],
        ctx=_ctx(),
        registry=_registry(),
        force_merge=True,
        vlm_resolver=_TestVLMResolver(),
    )

    assert merge_called is True
    assert merged.delete_file_contents == [delete_file]
    assert merged.delete_replacements == {delete_file.uri: replacement_uri}


@pytest.mark.asyncio
async def test_force_merge_does_not_drop_add_only_delete():
    delete_file = MemoryFile(
        uri="viking://user/u/memories/cases/obsolete.md",
        content="obsolete",
        memory_type="cases",
        extra_fields={"case_name": "obsolete"},
    )

    merged = await merge_one_memory_type_operations(
        memory_type="cases",
        operations=[],
        delete_files=[delete_file],
        messages=[],
        ctx=_ctx(),
        registry=_registry(),
        force_merge=True,
    )

    assert merged.delete_file_contents == [delete_file]


@pytest.mark.asyncio
async def test_patch_merge_uses_original_messages_for_output_language(monkeypatch):
    _patch_language_config(monkeypatch)
    existing_uri = "viking://user/u/memories/notes/code.md"
    old_file = MemoryFile(
        uri=existing_uri,
        content="old",
        memory_type="notes",
        extra_fields={"memory_type": "notes", "topic": "code"},
    )
    existing_op = ResolvedOperation(
        old_memory_file_content=old_file,
        memory_fields={"topic": "code", "content": "older"},
        memory_type="notes",
        uris=[existing_uri],
    )
    new_op = ResolvedOperation(
        old_memory_file_content=None,
        memory_fields={"topic": "code", "content": "new"},
        memory_type="notes",
        uris=["viking://user/u/memories/notes/code_new.md"],
    )
    captured_languages = []

    async def fake_run(self):
        assert isinstance(self.context_provider._vlm_config, _TestVLMResolver)
        captured_languages.append(self.context_provider.get_output_language())
        return (
            ResolvedOperations(
                upsert_operations=[existing_op],
                delete_file_contents=[],
                errors=[],
            ),
            [],
        )

    monkeypatch.setattr(
        "openviking.session.memory.streaming_memory_updater.ExtractLoop.run",
        fake_run,
    )
    fs = InMemoryVikingFS({existing_uri: "old"})
    fs.search = AsyncMock(return_value=[])
    monkeypatch.setattr(
        "openviking.session.memory.streaming_memory_updater.get_viking_fs",
        lambda: fs,
    )
    monkeypatch.setattr(
        "openviking.session.memory.memory_updater.get_viking_fs",
        lambda: fs,
    )

    await merge_one_memory_type_operations(
        memory_type="notes",
        operations=[existing_op, new_op],
        messages=[Message(id="m1", role="user", parts=[TextPart("请保持中文记忆")])],
        ctx=_ctx(),
        registry=_registry(),
        vlm_resolver=_TestVLMResolver(),
    )

    assert captured_languages == ["zh-CN"]


class TestFilterValidLinksTransientErrors:
    """Endpoint existence probes must not drop links on transient faults."""

    def _ops(self, from_uri):
        return [
            ResolvedOperation(
                memory_fields={"case_name": "case"},
                memory_type="cases",
                uris=[from_uri],
            )
        ]

    async def _filter(self, monkeypatch, read_file):
        fs = SimpleNamespace(read_file=AsyncMock(side_effect=read_file))
        monkeypatch.setattr(
            "openviking.session.memory.streaming_memory_updater.safe_get_viking_fs",
            lambda: fs,
        )
        return await filter_valid_links(
            [StoredLink(from_uri="viking://user/u/memories/cases/a.md",
                        to_uri="viking://user/u/memories/cases/b.md")],
            upsert_operations=self._ops("viking://user/u/memories/cases/a.md"),
            delete_file_contents=[],
            ctx=_ctx(),
        )

    @pytest.mark.asyncio
    async def test_transient_read_error_keeps_link(self, monkeypatch):
        async def read_file(uri, ctx=None):
            raise PermissionDeniedError("storage hiccup")

        # The to-endpoint probe failed transiently: the link must survive so
        # the rewrite can surface the real failure, not be dropped forever.
        valid = await self._filter(monkeypatch, read_file)
        assert len(valid) == 1

    @pytest.mark.asyncio
    async def test_missing_endpoint_still_drops_link(self, monkeypatch):
        async def read_file(uri, ctx=None):
            raise NotFoundError(uri, "memory")

        valid = await self._filter(monkeypatch, read_file)
        assert valid == []

    @pytest.mark.asyncio
    async def test_empty_endpoint_still_drops_link(self, monkeypatch):
        async def read_file(uri, ctx=None):
            return ""

        valid = await self._filter(monkeypatch, read_file)
        assert valid == []