Skip to content

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

41.0 KB
Raw Blame
# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
# SPDX-License-Identifier: AGPL-3.0
"""
Tests for memory ExtractLoop orchestrator.
"""

from types import SimpleNamespace
from unittest.mock import AsyncMock, MagicMock, patch

import pytest
from pydantic import BaseModel, Field

from openviking.session.memory.dataclass import (
    MemoryField,
    MemoryFile,
    MemoryOperationSkipCode,
    MemoryTypeSchema,
    ResolvedOperation,
    ResolvedOperations,
)
from openviking.session.memory.extract_loop import (
    ExtractLoop,
)
from openviking.session.memory.memory_isolation_handler import MemoryIsolationHandler
from openviking.session.memory.memory_updater import MemoryUpdater
from openviking.session.memory.merge_op import (
    FieldType,
    MergeOp,
    SearchReplaceBlock,
    StrPatch,
)
from openviking.session.memory.page_id_map import PageIdMap
from openviking.session.memory.schema_model_generator import SchemaModelGenerator


class TestPreFetchFileFiltering:
    """Tests for the file filtering logic in pre-fetch."""

    def test_only_abstract_and_overview_are_read_when_both_exist(self):
        """Test that from a directory listing, only .abstract.md and .overview.md are selected when both exist."""
        # Mock directory entries - both .abstract.md and .overview.md exist
        test_entries = [
            {"name": ".abstract.md", "isDir": False},
            {"name": ".overview.md", "isDir": False},
            {"name": "regular-file.md", "isDir": False},
            {"name": "another-file.md", "isDir": False},
            {"name": "subdir", "isDir": True},
            {"name": ".gitkeep", "isDir": False},
            {"name": "data.json", "isDir": False},
        ]

        dir_uri = "viking://user/default/memories/preferences"
        single_file_schemas = set()

        # Apply the filtering logic manually (replicate what _pre_fetch_context does)
        md_files = list(single_file_schemas)

        for entry in test_entries:
            name = entry.get("name", "")
            if not entry.get("isDir", False):
                # Only read .abstract.md and .overview.md from multi-file schema directories
                # (only if they actually exist in the directory listing)
                if name == ".abstract.md" or name == ".overview.md":
                    file_uri = f"{dir_uri}/{name}"
                    if file_uri not in md_files:
                        md_files.append(file_uri)

        # Verify only the two special files are included
        assert len(md_files) == 2
        assert f"{dir_uri}/.abstract.md" in md_files
        assert f"{dir_uri}/.overview.md" in md_files

        # Verify regular .md files are NOT included
        assert f"{dir_uri}/regular-file.md" not in md_files
        assert f"{dir_uri}/another-file.md" not in md_files

    def test_only_read_existing_files(self):
        """Test that only existing files are read - when only one exists or none exist."""
        dir_uri = "viking://user/default/memories/preferences"
        single_file_schemas = set()

        # Case 1: Only .abstract.md exists
        test_entries1 = [
            {"name": ".abstract.md", "isDir": False},
            {"name": "regular-file.md", "isDir": False},
        ]
        md_files1 = list(single_file_schemas)
        for entry in test_entries1:
            name = entry.get("name", "")
            if not entry.get("isDir", False):
                if name == ".abstract.md" or name == ".overview.md":
                    file_uri = f"{dir_uri}/{name}"
                    if file_uri not in md_files1:
                        md_files1.append(file_uri)
        assert len(md_files1) == 1
        assert f"{dir_uri}/.abstract.md" in md_files1
        assert f"{dir_uri}/.overview.md" not in md_files1

        # Case 2: Only .overview.md exists
        test_entries2 = [
            {"name": ".overview.md", "isDir": False},
            {"name": "regular-file.md", "isDir": False},
        ]
        md_files2 = list(single_file_schemas)
        for entry in test_entries2:
            name = entry.get("name", "")
            if not entry.get("isDir", False):
                if name == ".abstract.md" or name == ".overview.md":
                    file_uri = f"{dir_uri}/{name}"
                    if file_uri not in md_files2:
                        md_files2.append(file_uri)
        assert len(md_files2) == 1
        assert f"{dir_uri}/.overview.md" in md_files2
        assert f"{dir_uri}/.abstract.md" not in md_files2

        # Case 3: Neither exists
        test_entries3 = [
            {"name": "regular-file.md", "isDir": False},
        ]
        md_files3 = list(single_file_schemas)
        for entry in test_entries3:
            name = entry.get("name", "")
            if not entry.get("isDir", False):
                if name == ".abstract.md" or name == ".overview.md":
                    file_uri = f"{dir_uri}/{name}"
                    if file_uri not in md_files3:
                        md_files3.append(file_uri)
        assert len(md_files3) == 0

    def test_schema_type_detection_logic(self):
        """Test the logic for determining if a schema is multi-file or single-file."""
        # Test cases: (filename_template, expected_has_variables)
        test_cases = [
            ("{topic}.md", True),
            ("static.md", False),
            ("{tool_name}.md", True),
            ("profile.md", False),
            ("", False),  # empty template
            ("{entity_name}-details.md", True),
            ("fixed-filename.md", False),
            ("{a}/{b}.md", True),
        ]

        for filename_template, expected_has_variables in test_cases:
            # Replicate the logic from _pre_fetch_context
            has_variables = False
            if filename_template:
                has_variables = "{" in filename_template and "}" in filename_template

            assert has_variables == expected_has_variables, (
                f"Template '{filename_template}': expected has_variables={expected_has_variables}"
            )


class TestAllowedDirectoriesList:
    """Tests for _get_allowed_directories_list method."""

    @pytest.fixture
    def mock_vlm(self):
        """Create a mock VLM."""
        vlm = MagicMock()
        vlm.model = "test-model"
        vlm.max_retries = 2
        vlm.get_completion_async = AsyncMock()
        return vlm

    @pytest.fixture
    def mock_viking_fs(self):
        """Create a mock VikingFS."""
        return MagicMock()


class TestExtractLoopFinalJsonRetry:
    @staticmethod
    def _invalid_peer_resolution_loop(target_uri=None):
        schema = MemoryTypeSchema(
            memory_type="preferences",
            description="Preferences",
            directory="viking://user/{{ user_space }}/memories",
            filename_template="preferences.md",
            fields=[],
        )
        context_provider = MagicMock()
        context_provider.get_memory_schemas.return_value = [schema]
        context_provider.read_file_contents = {}

        ctx = MagicMock()
        ctx.user.user_id = "user_a"
        extract_context = MagicMock()
        extract_context.messages = []
        extract_context.page_id_map.resolve.return_value = target_uri

        extract_loop = object.__new__(ExtractLoop)
        extract_loop.ctx = ctx
        extract_loop.context_provider = context_provider
        extract_loop._extract_context = extract_context
        extract_loop._isolation_handler = MemoryIsolationHandler(ctx, extract_context)
        return extract_loop

    @pytest.mark.asyncio
    async def test_unrenderable_uri_skips_only_bad_item_and_reports_it(self):
        class EventItem(BaseModel):
            event_name: str | None = None

        class Operations(BaseModel):
            events: list[EventItem]

        schema = MemoryTypeSchema(
            memory_type="events",
            operation_mode="add_only",
            directory="viking://user/{{ user_space }}/memories/events",
            filename_template="{{ event_name }}.md",
            fields=[],
        )
        loop = self._invalid_peer_resolution_loop()
        loop.context_provider.get_memory_schemas.return_value = [schema]
        loop._extract_context.page_id_map = PageIdMap()
        resolved, _ = await loop.resolve_operations(
            Operations(events=[EventItem(), EventItem(event_name="kickoff")])
        )

        updater = MemoryUpdater(registry=MagicMock())
        updater._get_viking_fs = MagicMock(return_value=MagicMock())
        updater._apply_upsert = AsyncMock()
        updater._sync_resource_refs_for_result = AsyncMock()
        updater._vectorize_memories = AsyncMock()
        updater.generate_overview = AsyncMock()
        result = await updater.apply_operations(operations=resolved, ctx=loop.ctx)

        assert result.written_uris == ["viking://user/user_a/memories/events/kickoff.md"]
        assert result.errors == []
        assert len(result.skipped_operations) == 1
        assert result.skipped_operations[0].reason_code == (
            MemoryOperationSkipCode.INVALID_URI_TEMPLATE_VARS
        )
        assert "event_name" in result.skipped_operations[0].reason

    @pytest.mark.asyncio
    async def test_existing_page_id_keeps_write_target_without_invalid_peer_metadata(self):
        class PreferenceItem(BaseModel):
            page_id: int
            peer_id: str

        class Operations(BaseModel):
            preferences: list[PreferenceItem]
            delete_ids: list = Field(default_factory=list)

        target_uri = "viking://user/user_a/memories/preferences.md"
        extract_loop = self._invalid_peer_resolution_loop(target_uri)

        resolved, _ = await extract_loop.resolve_operations(
            Operations(
                preferences=[
                    PreferenceItem(page_id=7, peer_id="web/visitor/alice"),
                ]
            )
        )

        operation = resolved.upsert_operations[0]
        assert operation.uris == [target_uri]
        assert operation.resolution_skip is None
        assert operation.memory_fields == {
            "memory_type": "preferences",
            "user_id": "user_a",
        }

    @pytest.mark.asyncio
    async def test_existing_page_id_recomputes_uri_for_mutable_identity_fields(self):
        class EntityItem(BaseModel):
            page_id: int
            category: str
            name: str

        class Operations(BaseModel):
            entities: list[EntityItem]
            delete_ids: list = Field(default_factory=list)

        source_uri = "viking://user/user_a/memories/entities/person/阿珍.md"
        target_uri = "viking://user/user_a/memories/entities/person/陈静娴.md"
        schema = MemoryTypeSchema(
            memory_type="entities",
            directory="viking://user/{{ user_space }}/memories/entities",
            filename_template="{{ category|lower }}/{{ name|lower }}.md",
            fields=[
                MemoryField(
                    name="category",
                    field_type=FieldType.STRING,
                    merge_op=MergeOp.REPLACE,
                ),
                MemoryField(
                    name="name",
                    field_type=FieldType.STRING,
                    merge_op=MergeOp.REPLACE,
                ),
            ],
        )
        old_file = MemoryFile(
            uri=source_uri,
            memory_type="entities",
            content="大学室友",
            extra_fields={"category": "person", "name": "阿珍"},
        )
        context_provider = MagicMock()
        context_provider.get_memory_schemas.return_value = [schema]
        context_provider.read_file_contents = {source_uri: old_file}
        ctx = MagicMock()
        ctx.user.user_id = "user_a"
        extract_context = MagicMock()
        extract_context.messages = []
        extract_context.page_id_map = PageIdMap()
        page_id = extract_context.page_id_map.get_page_id(source_uri)
        loop = object.__new__(ExtractLoop)
        loop.ctx = ctx
        loop.context_provider = context_provider
        loop._extract_context = extract_context
        loop._isolation_handler = MemoryIsolationHandler(ctx, extract_context)

        resolved, _ = await loop.resolve_operations(
            Operations(entities=[EntityItem(page_id=page_id, category="person", name="陈静娴")])
        )

        operation = resolved.upsert_operations[0]
        assert operation.uris == [target_uri]
        assert operation.old_memory_file_content is old_file

    @pytest.mark.asyncio
    async def test_existing_update_preserves_omitted_mutable_identity_fields(self):
        class EntityItem(BaseModel):
            page_id: int
            category: str | None = None
            name: str | None = None
            content: str | None = None

        class Operations(BaseModel):
            entities: list[EntityItem]
            delete_ids: list = Field(default_factory=list)

        source_uri = "viking://user/user_a/memories/entities/person/阿珍.md"
        schema = MemoryTypeSchema(
            memory_type="entities",
            directory="viking://user/{{ user_space }}/memories/entities",
            filename_template="{{ category|lower }}/{{ name|lower }}.md",
            fields=[
                MemoryField(
                    name="category",
                    field_type=FieldType.STRING,
                    merge_op=MergeOp.REPLACE,
                ),
                MemoryField(
                    name="name",
                    field_type=FieldType.STRING,
                    merge_op=MergeOp.REPLACE,
                ),
                MemoryField(
                    name="content",
                    field_type=FieldType.STRING,
                    merge_op=MergeOp.REPLACE,
                ),
            ],
        )
        old_file = MemoryFile(
            uri=source_uri,
            memory_type="entities",
            content="大学室友",
            extra_fields={"category": "person", "name": "阿珍"},
        )
        context_provider = MagicMock()
        context_provider.get_memory_schemas.return_value = [schema]
        context_provider.read_file_contents = {source_uri: old_file}
        ctx = MagicMock()
        ctx.user.user_id = "user_a"
        extract_context = MagicMock()
        extract_context.messages = []
        extract_context.page_id_map = PageIdMap()
        page_id = extract_context.page_id_map.get_page_id(source_uri)
        loop = object.__new__(ExtractLoop)
        loop.ctx = ctx
        loop.context_provider = context_provider
        loop._extract_context = extract_context
        loop._isolation_handler = MemoryIsolationHandler(ctx, extract_context)

        resolved, _ = await loop.resolve_operations(
            Operations(entities=[EntityItem(page_id=page_id, content="精简后的正文")])
        )

        operation = resolved.upsert_operations[0]
        assert operation.uris == [source_uri]
        assert operation.memory_fields["category"] == "person"
        assert operation.memory_fields["name"] == "阿珍"

    @pytest.mark.asyncio
    async def test_existing_update_keeps_legacy_case_uri_when_only_content_changes(self):
        class PreferenceItem(BaseModel):
            page_id: int
            user: str | None = None
            topic: str | None = None
            content: str | None = None

        class Operations(BaseModel):
            preferences: list[PreferenceItem]
            delete_ids: list = Field(default_factory=list)

        source_uri = "viking://user/user_a/memories/preferences/Alice/food.md"
        schema = MemoryTypeSchema(
            memory_type="preferences",
            directory="viking://user/{{ user_space }}/memories/preferences",
            filename_template="{{ user|lower }}/{{ topic|lower }}.md",
            fields=[
                MemoryField(
                    name="user",
                    field_type=FieldType.STRING,
                    merge_op=MergeOp.IMMUTABLE,
                ),
                MemoryField(
                    name="topic",
                    field_type=FieldType.STRING,
                    merge_op=MergeOp.IMMUTABLE,
                ),
                MemoryField(
                    name="content",
                    field_type=FieldType.STRING,
                    merge_op=MergeOp.REPLACE,
                ),
            ],
        )
        old_file = MemoryFile(
            uri=source_uri,
            memory_type="preferences",
            content="- 喜欢辣的",
            extra_fields={"user": "Alice", "topic": "food"},
        )
        context_provider = MagicMock()
        context_provider.get_memory_schemas.return_value = [schema]
        context_provider.read_file_contents = {source_uri: old_file}
        ctx = MagicMock()
        ctx.user.user_id = "user_a"
        extract_context = MagicMock()
        extract_context.messages = []
        extract_context.page_id_map = PageIdMap()
        page_id = extract_context.page_id_map.get_page_id(source_uri)
        loop = object.__new__(ExtractLoop)
        loop.ctx = ctx
        loop.context_provider = context_provider
        loop._extract_context = extract_context
        loop._isolation_handler = MemoryIsolationHandler(ctx, extract_context)

        resolved, _ = await loop.resolve_operations(
            Operations(preferences=[PreferenceItem(page_id=page_id, content="- 微辣")])
        )

        operation = resolved.upsert_operations[0]
        assert operation.uris == [source_uri]
        assert operation.old_memory_file_content is old_file
        assert not MemoryUpdater._is_uri_migration(operation)

    @pytest.mark.asyncio
    async def test_rename_conflict_refetches_target_then_requires_explicit_merge(self):
        source_uri = "viking://user/user_a/memories/entities/person/阿珍.md"
        target_uri = "viking://user/user_a/memories/entities/person/陈静娴.md"
        source_file = MemoryFile(
            uri=source_uri,
            memory_type="entities",
            content="大学室友",
            extra_fields={"category": "person", "name": "阿珍"},
        )
        target_file = MemoryFile(
            uri=target_uri,
            memory_type="entities",
            content="上海 UI 设计师",
            extra_fields={"category": "person", "name": "陈静娴"},
        )
        schema = MemoryTypeSchema(
            memory_type="entities",
            directory="viking://user/{{ user_space }}/memories/entities",
            filename_template="{{ category|lower }}/{{ name|lower }}.md",
            fields=[
                MemoryField(
                    name="category",
                    field_type=FieldType.STRING,
                    merge_op=MergeOp.REPLACE,
                ),
                MemoryField(
                    name="name",
                    field_type=FieldType.STRING,
                    merge_op=MergeOp.REPLACE,
                ),
                MemoryField(
                    name="content",
                    field_type=FieldType.STRING,
                    merge_op=MergeOp.PATCH,
                ),
            ],
        )
        extract_context = SimpleNamespace(messages=[], page_id_map=PageIdMap())

        class FakeContextProvider:
            def __init__(self):
                self.read_file_contents = {source_uri: source_file}
                self.read_uris = []

            def get_memory_schemas(self, ctx):
                del ctx
                return [schema]

            def get_tools(self):
                return []

            def get_extract_context(self):
                return extract_context

            def get_output_language(self):
                return "zh-CN"

            def instruction(self):
                return "Merge aliases without losing facts."

            async def prefetch(self):
                return []

            async def execute_tool(self, tool_call):
                uri = tool_call.arguments["uri"]
                self.read_uris.append(uri)
                assert uri == target_uri
                self.read_file_contents[uri] = target_file
                return {
                    **target_file.to_metadata(),
                    "page_id": extract_context.page_id_map.get_page_id(uri),
                }

        class FakeVLM:
            model = "test-model"

            def __init__(self):
                self.responses = iter(
                    [
                        "entities_1.update(name='陈静娴')\nsdk.commit()",
                        (
                            "entities_2.content.update('大学室友;上海 UI 设计师')\n"
                            "entities_1.delete(replacement=entities_2)\n"
                            "sdk.commit()"
                        ),
                    ]
                )

            async def get_completion_async(self, **kwargs):
                del kwargs
                return next(self.responses)

        provider = FakeContextProvider()
        ctx = MagicMock()
        ctx.user.user_id = "user_a"
        config = SimpleNamespace(
            memory=SimpleNamespace(link_enabled=False, extraction_output_format="python"),
            vlm=SimpleNamespace(max_tokens=None),
        )
        loop = ExtractLoop(
            vlm=FakeVLM(),
            viking_fs=MagicMock(),
            ctx=ctx,
            context_provider=provider,
            isolation_handler=MemoryIsolationHandler(ctx, extract_context),
            max_iterations=2,
        )

        with (
            patch(
                "openviking.session.memory.extract_loop.get_openviking_config",
                return_value=config,
            ),
            patch(
                "openviking_cli.utils.config.get_openviking_config",
                return_value=config,
            ),
        ):
            operations, _ = await loop.run()

        assert provider.read_uris == [target_uri]
        assert [operation.uris for operation in operations.upsert_operations] == [[target_uri]]
        assert [file.uri for file in operations.delete_file_contents] == [source_uri]
        assert operations.delete_replacements == {source_uri: target_uri}

    @pytest.mark.asyncio
    async def test_invalid_peer_hint_preserves_legacy_self_write_fallback(self):
        class PreferenceItem(BaseModel):
            page_id: int
            peer_id: str

        class Operations(BaseModel):
            preferences: list[PreferenceItem]
            delete_ids: list = Field(default_factory=list)

        extract_loop = self._invalid_peer_resolution_loop()

        resolved, _ = await extract_loop.resolve_operations(
            Operations(
                preferences=[
                    PreferenceItem(page_id=101, peer_id="web/visitor/alice"),
                ]
            )
        )

        operation = resolved.upsert_operations[0]
        assert operation.uris == ["viking://user/user_a/memories/preferences.md"]
        assert operation.resolution_skip is None
        assert operation.memory_fields == {
            "memory_type": "preferences",
            "user_id": "user_a",
        }

    @pytest.mark.asyncio
    async def test_structured_parser_preserves_delete_ids(self):
        class FakeContextProvider:
            read_file_contents = {}

            def get_memory_schemas(self, ctx):
                return [
                    MemoryTypeSchema(
                        memory_type="preferences",
                        description="Preferences",
                        directory="viking://user/{user_space}/memories/preferences",
                        filename_template="{topic}.md",
                        fields=[],
                    )
                ]

            def get_tools(self):
                return []

            def get_extract_context(self):
                return MagicMock()

            def get_output_language(self):
                return "en"

            def instruction(self):
                return "Extract memory operations."

            async def prefetch(self):
                return []

        vlm = MagicMock()
        vlm.model = "test-model"
        vlm.get_completion_async = AsyncMock(
            return_value='{"delete_ids": [{"delete_page_id": 7, "replacement_page_id": 11}]}'
        )
        # decision_reasoning response retained for when the schema field is re-enabled:
        # return_value=(
        #     '{"delete_ids": [{"delete_page_id": 7, "replacement_page_id": 11}], '
        #     '"decision_reasoning": [{"page_id": 7, "remove": [], '
        #     '"has_unaffected_facts": false, "action": "DELETE"}]}'
        # )
        extract_loop = ExtractLoop(
            vlm=vlm,
            viking_fs=MagicMock(),
            context_provider=FakeContextProvider(),
            max_iterations=1,
        )
        resolved = ResolvedOperations(
            upsert_operations=[],
            delete_file_contents=[],
            errors=[],
        )
        extract_loop.resolve_operations = AsyncMock(return_value=(resolved, []))
        extract_loop._check_unread_existing_files = AsyncMock(return_value={})
        extract_loop._validate_patch_operations = AsyncMock(return_value=[])
        extract_loop.finalize_operations = AsyncMock()
        config = SimpleNamespace(
            memory=SimpleNamespace(link_enabled=False, extraction_output_format="json")
        )

        with patch(
            "openviking.session.memory.extract_loop.get_openviking_config",
            return_value=config,
        ):
            await extract_loop.run()

        parsed_operations = extract_loop.resolve_operations.await_args.args[0]
        assert len(parsed_operations.delete_ids) == 1
        assert parsed_operations.delete_ids[0].delete_page_id == 7
        assert parsed_operations.delete_ids[0].replacement_page_id == 11
        # assert parsed_operations.decision_reasoning[0].action == "DELETE"
        # assert parsed_operations.decision_reasoning[0].remove == []

    def test_add_only_contract_does_not_allow_delete_ids(self):
        schema = MemoryTypeSchema(
            memory_type="trajectories",
            description="Trajectories",
            directory="viking://agent/{agent_space}/memories/trajectories",
            filename_template="{task}.md",
            fields=[],
            operation_mode="add_only",
        )
        generator = SchemaModelGenerator([schema], template_context={"language": "en"})

        operations_model = generator.create_structured_operations_model()
        fields = operations_model.model_fields
        assert "decision_reasoning" not in fields
        assert "delete_ids" not in fields

        # decision_reasoning schema tests retained for when the field is re-enabled:
        # assert next(iter(fields)) == "decision_reasoning"
        # description = fields["decision_reasoning"].description
        # assert "one decision for every related read page" in description
        # decisions = operations_model.model_validate(
        #     {
        #         "decision_reasoning": [
        #             {
        #                 "page_id": 7,
        #                 "remove": ["- affected fact"],
        #                 "has_unaffected_facts": True,
        #                 "action": "UPDATE",
        #             }
        #         ]
        #     }
        # ).decision_reasoning
        # assert decisions[0].has_unaffected_facts is True
        # assert operations_model.model_validate({}).decision_reasoning == []
        # with pytest.raises(ValueError):
        #     operations_model.model_validate(
        #         {
        #             "decision_reasoning": [
        #                 {
        #                     "page_id": 7,
        #                     "remove": [],
        #                     "has_unaffected_facts": True,
        #                     "action": "REMOVE",
        #                 }
        #             ]
        #         }
        #     )
        # merge_fields = (
        #     SchemaModelGenerator([schema], include_decision_reasoning=False)
        #     .create_structured_operations_model()
        #     .model_fields
        # )
        # assert "decision_reasoning" not in merge_fields

    @pytest.mark.asyncio
    async def test_patch_validation_uses_plain_and_sequential_content(self):
        target_uri = "viking://user/default/memories/profile.md"
        old_file = MemoryFile(
            uri=target_uri,
            content="# A\n- [Shared](./shared.md)\n\n# B\n- Shared",
        )
        operation = ResolvedOperation(
            old_memory_file_content=old_file,
            memory_type="profile",
            uris=[target_uri],
            memory_fields={
                "content": StrPatch(
                    blocks=[
                        SearchReplaceBlock(
                            search="# A\n- Shared",
                            replace="# A\n- A-only",
                        ),
                        SearchReplaceBlock(search="- Shared", replace="- B-only"),
                        SearchReplaceBlock(search="- Missing", replace="- Added"),
                    ]
                )
            },
        )
        extract_loop = object.__new__(ExtractLoop)
        extract_loop.context_provider = MagicMock(read_file_contents={target_uri: old_file})

        errors = await extract_loop._validate_patch_operations(
            ResolvedOperations(
                upsert_operations=[operation],
                delete_file_contents=[],
                errors=[],
            )
        )

        assert errors == [
            {
                "uri": target_uri,
                "page_id": None,
                "field": "content",
                "block_index": 3,
                "search": "- Missing",
                "reason": "not_found",
                "match_count": 0,
                "found_in_other_uris": [],
            }
        ]

    @pytest.mark.asyncio
    async def test_final_unparseable_response_raises_instead_of_empty_success(self):
        class FakeVLM:
            model = "test-model"

            def __init__(self):
                self.seen_messages = []

            async def get_completion_async(self, **kwargs):
                self.seen_messages.append(list(kwargs["messages"]))
                return "this is not json"

        class FakeContextProvider:
            read_file_contents = {}

            def get_memory_schemas(self, ctx):
                return [
                    MemoryTypeSchema(
                        memory_type="preferences",
                        description="Preferences",
                        directory="viking://user/{user_space}/memories/preferences",
                        filename_template="{topic}.md",
                        fields=[],
                    )
                ]

            def get_tools(self):
                return []

            def get_extract_context(self):
                return MagicMock()

            def get_output_language(self):
                return "en"

            def instruction(self):
                return "Extract memory operations."

            async def prefetch(self):
                return []

        vlm = FakeVLM()
        extract_loop = ExtractLoop(
            vlm=vlm,
            viking_fs=MagicMock(),
            context_provider=FakeContextProvider(),
            max_iterations=1,
        )
        config = SimpleNamespace(
            memory=SimpleNamespace(link_enabled=False, extraction_output_format="json")
        )

        with patch(
            "openviking.session.memory.extract_loop.get_openviking_config",
            return_value=config,
        ):
            with pytest.raises(RuntimeError, match="Final response could not be parsed"):
                await extract_loop.run()

        final_prompts = [
            message["content"]
            for messages in vlm.seen_messages
            for message in messages
            if message.get("role") == "user"
            and "maximum number of tool call iterations" in message.get("content", "")
        ]
        assert final_prompts
        assert '"delete_ids": []' in final_prompts[-1]
        assert '"preferences": []' in final_prompts[-1]

        system_prompts = [
            message["content"]
            for messages in vlm.seen_messages
            for message in messages
            if message.get("role") == "system"
        ]
        assert system_prompts
        initial_system_prompt = system_prompts[0]
        assert "`delete_ids` deletes the whole item" in initial_system_prompt
        assert "only if every substantive fact is in scope" in initial_system_prompt
        assert "rewrite the complete affected field" in initial_system_prompt
        assert "DELETE blocks" not in initial_system_prompt
        assert "never infer scope from the file name/topic" in initial_system_prompt

    @pytest.mark.asyncio
    async def test_python_protocol_retries_then_raises_on_empty_response(self):
        class FakeVLM:
            model = "test-model"

            def __init__(self):
                self.seen_messages = []

            async def get_completion_async(self, **kwargs):
                self.seen_messages.append(list(kwargs["messages"]))
                return ""

        class FakeContextProvider:
            read_file_contents = {}

            def get_memory_schemas(self, ctx):
                return [
                    MemoryTypeSchema(
                        memory_type="preferences",
                        description="Preferences",
                        directory="viking://user/{user_space}/memories/preferences",
                        filename_template="{topic}.md",
                        fields=[],
                    )
                ]

            def get_tools(self):
                return []

            def get_extract_context(self):
                return SimpleNamespace(page_id_map=PageIdMap())

            def get_output_language(self):
                return "en"

            def instruction(self):
                return "Extract memory operations and output ONLY a JSON object (no extra text before or after)."

            async def prefetch(self):
                return []

        vlm = FakeVLM()
        extract_loop = ExtractLoop(
            vlm=vlm,
            viking_fs=MagicMock(),
            context_provider=FakeContextProvider(),
            max_iterations=1,
        )
        config = SimpleNamespace(
            memory=SimpleNamespace(link_enabled=False, extraction_output_format="python")
        )

        with (
            patch(
                "openviking.session.memory.extract_loop.get_openviking_config",
                return_value=config,
            ),
            patch(
                "openviking_cli.utils.config.get_openviking_config",
                return_value=config,
            ),
            patch("openviking.session.memory.extract_loop.tracer.error") as tracer_error,
            patch("openviking.session.memory.extract_loop.logger.warning") as logger_warning,
        ):
            extract_loop._check_unread_existing_files = AsyncMock(return_value={})
            extract_loop._validate_patch_operations = AsyncMock(return_value=[])
            extract_loop.finalize_operations = AsyncMock()

            with pytest.raises(RuntimeError, match="failure_kind=empty_response"):
                await extract_loop.run()

        extract_loop.finalize_operations.assert_not_awaited()

        assert len(vlm.seen_messages) == 2
        system_prompt = vlm.seen_messages[0][0]["content"]
        assert "restricted Python memory SDK" in system_prompt
        assert "output ONLY a JSON object" not in system_prompt
        assert any(
            "not a valid restricted Python memory SDK program" in message.get("content", "")
            for message in vlm.seen_messages[-1]
        )
        assert tracer_error.call_count == 1
        assert logger_warning.call_count == 0

    @pytest.mark.asyncio
    async def test_python_protocol_parse_retry_success_does_not_log_error(self):
        class FakeVLM:
            model = "test-model"

            def __init__(self):
                self.responses = iter(
                    ["sdk.create_profile(content='Engineer')\nsdk.commit()", "sdk.commit()"]
                )

            async def get_completion_async(self, **kwargs):
                del kwargs
                return next(self.responses)

        class FakeContextProvider:
            read_file_contents = {}

            def get_memory_schemas(self, ctx):
                del ctx
                return [
                    MemoryTypeSchema(
                        memory_type="profile",
                        description="Profile",
                        directory="viking://user/{user_space}/memories",
                        filename_template="profile.md",
                        fields=[],
                    )
                ]

            def get_tools(self):
                return []

            def get_extract_context(self):
                return SimpleNamespace(page_id_map=PageIdMap())

            def get_output_language(self):
                return "en"

            def instruction(self):
                return "Extract memory operations."

            async def prefetch(self):
                return []

        config = SimpleNamespace(
            memory=SimpleNamespace(link_enabled=False, extraction_output_format="python")
        )
        extract_loop = ExtractLoop(
            vlm=FakeVLM(),
            viking_fs=MagicMock(),
            context_provider=FakeContextProvider(),
            max_iterations=1,
        )
        empty_operations = ResolvedOperations(
            upsert_operations=[], delete_file_contents=[], errors=[]
        )
        extract_loop.resolve_operations = AsyncMock(return_value=(empty_operations, []))
        extract_loop._check_unread_existing_files = AsyncMock(return_value={})

        with (
            patch(
                "openviking.session.memory.extract_loop.get_openviking_config",
                return_value=config,
            ),
            patch(
                "openviking_cli.utils.config.get_openviking_config",
                return_value=config,
            ),
            patch("openviking.session.memory.extract_loop.tracer.error") as tracer_error,
            patch("openviking.session.memory.extract_loop.logger.warning") as logger_warning,
        ):
            operations, _ = await extract_loop.run()

        assert operations is empty_operations
        assert tracer_error.call_count == 0
        assert logger_warning.call_count == 0

    @pytest.mark.asyncio
    async def test_python_protocol_resets_format_retry_after_refetch(self):
        class FakeVLM:
            model = "test-model"

            def __init__(self):
                self.responses = iter(
                    [
                        "sdk.create_profile(content='invalid')\nsdk.commit()",
                        "sdk.commit()",
                        "# Caroline\n- Transgender woman (as of 2023-06-09)",
                        "sdk.commit()",
                    ]
                )
                self.call_count = 0

            async def get_completion_async(self, **kwargs):
                del kwargs
                self.call_count += 1
                return next(self.responses)

        class FakeContextProvider:
            read_file_contents = {}

            def get_memory_schemas(self, ctx):
                del ctx
                return [
                    MemoryTypeSchema(
                        memory_type="profile",
                        description="Profile",
                        directory="viking://user/{user_space}/memories",
                        filename_template="profile.md",
                        fields=[],
                    )
                ]

            def get_tools(self):
                return []

            def get_extract_context(self):
                return SimpleNamespace(page_id_map=PageIdMap())

            def get_output_language(self):
                return "en"

            def instruction(self):
                return "Extract memory operations."

            async def prefetch(self):
                return []

        config = SimpleNamespace(
            memory=SimpleNamespace(link_enabled=False, extraction_output_format="python")
        )
        vlm = FakeVLM()
        extract_loop = ExtractLoop(
            vlm=vlm,
            viking_fs=MagicMock(),
            context_provider=FakeContextProvider(),
            max_iterations=2,
        )
        empty_operations = ResolvedOperations(
            upsert_operations=[], delete_file_contents=[], errors=[]
        )
        extract_loop.resolve_operations = AsyncMock(return_value=(empty_operations, []))
        extract_loop._check_unread_existing_files = AsyncMock(
            side_effect=[{"viking://user/default/memories/profile.md": {}}, {}]
        )
        extract_loop._add_refetch_results_to_messages = AsyncMock()

        with (
            patch(
                "openviking.session.memory.extract_loop.get_openviking_config",
                return_value=config,
            ),
            patch(
                "openviking_cli.utils.config.get_openviking_config",
                return_value=config,
            ),
            patch("openviking.session.memory.extract_loop.tracer.error") as tracer_error,
            patch("openviking.session.memory.extract_loop.logger.warning") as logger_warning,
        ):
            operations, _ = await extract_loop.run()

        assert operations is empty_operations
        assert vlm.call_count == 4
        assert extract_loop._add_refetch_results_to_messages.await_count == 1
        assert tracer_error.call_count == 0
        assert logger_warning.call_count == 0