Skip to content

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

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

from __future__ import annotations

from typing import Any

import pytest
from test_fakes import fake_request_context

from openviking.session.memory.dataclass import MemoryFile, StoredLink
from openviking.session.memory.utils.memory_file_utils import MemoryFileUtils
from openviking.session.skill.session_skill_context_provider import (
    SESSION_SKILL_MEMORY_TYPE,
    load_skill_extract_registry,
)
from openviking.session.train import (
    ContentHashPolicySnapshotter,
    DryRunPolicyUpdater,
    Experience,
    ExperienceSet,
    ExperienceSetLoader,
    MemoryFilePolicyUpdater,
    PatchMergePolicyOptimizer,
    PatchMergePolicyOptimizerContext,
    PatchSemanticGradient,
    PolicyUpdatePlan,
)
from openviking.storage.errors import LockAcquisitionError


class FakePathlockClient:
    def __init__(self, acquire_error: Exception | None = None):
        self.acquire_error = acquire_error
        self.acquire_calls = []
        self.release_calls = []

    async def pathlock_acquire_exact_tree_batch(
        self,
        exact_paths,
        tree_paths,
        timeout_secs=0.0,
        owner_lease_ref=None,
    ):
        call = {
            "exact_paths": list(exact_paths),
            "tree_paths": list(tree_paths),
            "timeout_secs": timeout_secs,
            "owner_lease_ref": owner_lease_ref,
        }
        self.acquire_calls.append(call)
        if self.acquire_error is not None:
            raise self.acquire_error
        lease = {"lease_ref": f"combined-lease-{len(self.acquire_calls)}"}
        call["lease"] = lease
        return lease

    async def pathlock_release(self, lease):
        self.release_calls.append(lease)


class FakeVikingFS:
    def __init__(
        self,
        files: dict[str, str],
        *,
        lock_acquire_error: Exception | None = None,
    ):
        self.files = files
        self.rm_lock_handles = []
        self.write_lock_handles = []
        self._async_agfs = FakePathlockClient(lock_acquire_error)

    def _uri_to_path(self, uri: str, ctx=None) -> str:
        account_id = getattr(getattr(ctx, "user", None), "account_id", None) or "default"
        return f"/local/{account_id}/{uri.removeprefix('viking://')}"

    async def ls(self, uri: str, output: str = "original", ctx=None, **kwargs):
        del kwargs
        assert output == "original"
        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):
        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):
        self.write_lock_handles.append((uri, lease_ref))
        self.files[uri] = content

    async def rm(self, uri: str, recursive: bool = False, ctx=None, lease_ref=None):
        del recursive, ctx
        self.rm_lock_handles.append(lease_ref)
        self.files.pop(uri, None)
        return {"estimated_deleted_count": 1}


class FakeVikingDB:
    def __init__(self):
        self.embedding_messages = []

    async def enqueue_embedding_msg(self, embedding_msg):
        self.embedding_messages.append(embedding_msg)
        return True


def _experience_set() -> ExperienceSet:
    return ExperienceSet(
        root_uri="viking://user/u/memories/experiences",
        policies=[
            Experience(
                name="booking_duplicate_handling",
                uri="viking://user/u/memories/experiences/booking_duplicate_handling.md",
                version=1,
                status="production",
                content="content",
            )
        ],
    )


def _memory_file(
    *,
    name: str,
    uri: str | None,
    content: str,
    version: int | None = 1,
    status: str = "production",
) -> MemoryFile:
    fields: dict[str, Any] = {
        "memory_type": "experiences",
        "experience_name": name,
        "status": status,
    }
    if version is not None:
        fields["version"] = version
    return MemoryFile(
        uri=uri,
        content=content,
        memory_type="experiences",
        extra_fields=fields,
    )


def _patch_gradient(
    *,
    name: str = "booking_duplicate_handling",
    uri: str | None = "viking://user/u/memories/experiences/booking_duplicate_handling.md",
    before: str | None = "content",
    after: str = "new content",
    base_version: int | None = 1,
    rationale: str = "r",
    links: list[StoredLink] | None = None,
    confidence: float = 0.8,
    metadata: dict[str, Any] | None = None,
) -> PatchSemanticGradient:
    return PatchSemanticGradient(
        before_file=(
            _memory_file(name=name, uri=uri, content=before, version=base_version)
            if before is not None
            else None
        ),
        after_file=_memory_file(name=name, uri=uri, content=after, version=base_version),
        base_version=base_version,
        rationale=rationale,
        links=(
            links
            if links is not None
            else [
                StoredLink(
                    from_uri=uri or "",
                    to_uri="viking://user/u/memories/trajectories/traj1.md",
                    link_type="derived_from",
                    weight=1.0,
                )
            ]
        ),
        confidence=confidence,
        metadata=metadata or {},
    )


def _plan_from_gradient(gradient: PatchSemanticGradient) -> PolicyUpdatePlan:
    return PolicyUpdatePlan(
        items=[
            _plan_item_from_gradient(gradient),
        ]
    )


def _plan_item_from_gradient(gradient: PatchSemanticGradient):
    from openviking.session.train import PolicyPlanItem

    return PolicyPlanItem(
        kind="upsert",
        memory_type="experiences",
        target_name=gradient.target_name,
        target_uri=gradient.target_uri,
        before_content=(
            gradient.before_file.plain_content() if gradient.before_file is not None else None
        ),
        after_content=gradient.after_file.plain_content(),
        base_version=gradient.base_version,
        confidence=gradient.confidence,
        links=list(gradient.links),
        metadata={"rationale": gradient.rationale},
    )


def _delete_plan(*, uri: str, before_content: str = "content") -> PolicyUpdatePlan:
    from openviking.session.train import PolicyPlanItem

    return PolicyUpdatePlan(
        items=[
            PolicyPlanItem(
                kind="delete",
                memory_type="experiences",
                target_name="booking_duplicate_handling",
                target_uri=uri,
                before_content=before_content,
                after_content=None,
                base_version=1,
                confidence=0.8,
                links=[
                    StoredLink(
                        from_uri=uri,
                        to_uri="viking://user/u/memories/trajectories/traj1.md",
                        link_type="derived_from",
                        weight=1.0,
                    )
                ],
                metadata={"rationale": "delete duplicate experience"},
            )
        ]
    )


@pytest.mark.asyncio
async def test_experience_set_loader_reads_memory_files():
    root = "viking://user/u/memories/experiences"
    fs = FakeVikingFS(
        {
            f"{root}/booking_duplicate_handling.md": '## Situation\n- test\n\n<!-- MEMORY_FIELDS\n{"memory_type": "experiences", "experience_name": "booking_duplicate_handling", "version": 3, "status": "staging"}\n-->',
            f"{root}/.overview.md": "hidden",
        }
    )

    ctx = fake_request_context()
    loaded = await ExperienceSetLoader(viking_fs=fs).load(root, ctx=ctx)

    assert loaded.root_uri == root
    assert loaded.viking_fs is fs
    assert loaded.request_context is ctx
    assert len(loaded.policies) == 1
    policy = loaded.policies[0]
    assert policy.name == "booking_duplicate_handling"
    assert policy.version == 3
    assert policy.status == "staging"
    assert policy.content == "## Situation\n- test"
    assert policy.metadata["memory_type"] == "experiences"


@pytest.mark.asyncio
async def test_experience_set_loader_requires_request_context():
    root = "viking://user/u/memories/experiences"
    fs = FakeVikingFS({})

    with pytest.raises(ValueError, match="requires request_context ctx"):
        await ExperienceSetLoader(viking_fs=fs).load(root)


@pytest.mark.asyncio
async def test_content_hash_snapshotter_is_deterministic():
    snapshotter = ContentHashPolicySnapshotter()
    policy_set = _experience_set()

    first = await snapshotter.snapshot(policy_set)
    second = await snapshotter.snapshot(policy_set)

    assert first == second
    assert first.startswith("policy-snapshot:")


@pytest.mark.asyncio
async def test_dry_run_policy_updater_does_not_mutate_policy_set():
    policy_set = _experience_set()
    plan = PolicyUpdatePlan(metadata={"hello": "world"})

    result = await DryRunPolicyUpdater().apply(plan, policy_set)

    assert result.updated_policy_set is policy_set
    assert result.written_uris == []
    assert result.deleted_uris == []
    assert result.metadata["dry_run"] is True
    assert result.metadata["simulated"] is True
    assert result.metadata["plan"] == {"hello": "world"}


@pytest.mark.asyncio
async def test_dry_run_policy_updater_simulates_patch_plan_items():
    policy_set = _experience_set()
    gradient = _patch_gradient(uri=policy_set.policies[0].uri, before="content", after="new content")
    plan = _plan_from_gradient(gradient)

    result = await DryRunPolicyUpdater().apply(plan, policy_set)

    assert result.updated_policy_set is not policy_set
    assert result.updated_policy_set.policies[0].content == "new content"
    assert result.updated_policy_set.policies[0].version == 2
    assert result.written_uris == []
    assert result.metadata["dry_run"] is True
    assert result.metadata["simulated"] is True


@pytest.mark.asyncio
async def test_dry_run_policy_updater_simulates_delete_plan_items():
    policy_set = _experience_set()
    plan = _delete_plan(uri=policy_set.policies[0].uri)

    result = await DryRunPolicyUpdater().apply(plan, policy_set)

    assert result.updated_policy_set is not policy_set
    assert result.updated_policy_set.policies == []
    assert result.written_uris == []
    assert result.deleted_uris == []
    assert result.metadata["dry_run"] is True
    assert result.metadata["simulated"] is True


@pytest.mark.asyncio
async def test_memory_file_policy_updater_writes_experience_files():
    policy_set = _experience_set()
    fs = FakeVikingFS({})
    gradient = _patch_gradient(
        uri=policy_set.policies[0].uri,
        before="content",
        after="new content",
        links=[],
    )
    plan = _plan_from_gradient(gradient)

    result = await MemoryFilePolicyUpdater(viking_fs=fs).apply(
        plan,
        policy_set,
        fake_request_context(),
    )

    assert result.errors == []
    assert result.written_uris == [policy_set.policies[0].uri]
    written = fs.files[policy_set.policies[0].uri]
    assert written.startswith("new content")
    assert '"memory_type": "experiences"' in written
    assert '"experience_name": "booking_duplicate_handling"' in written
    assert '"version": 2' in written


@pytest.mark.asyncio
async def test_memory_file_policy_updater_does_not_expand_lock_without_trajectory_links():
    policy_set = _experience_set()
    fs = FakeVikingFS({})
    lock_handle = object()
    gradient = _patch_gradient(
        uri=policy_set.policies[0].uri,
        before="content",
        after="new content",
        links=[],
    )
    plan = _plan_from_gradient(gradient)

    result = await MemoryFilePolicyUpdater(viking_fs=fs).apply(
        plan,
        policy_set,
        fake_request_context(),
        transaction_handle=lock_handle,
    )

    assert result.errors == []
    assert result.written_uris == [policy_set.policies[0].uri]
    assert (policy_set.policies[0].uri, lock_handle) in fs.write_lock_handles
    assert fs._async_agfs.acquire_calls == []
    assert fs._async_agfs.release_calls == []


@pytest.mark.asyncio
async def test_memory_file_policy_updater_vectorizes_written_experience_files():
    policy_set = _experience_set()
    fs = FakeVikingFS({})
    vikingdb = FakeVikingDB()
    gradient = _patch_gradient(
        uri=policy_set.policies[0].uri,
        before="content",
        after="new content",
        links=[],
    )
    plan = _plan_from_gradient(gradient)

    from openviking.server.identity import RequestContext, Role
    from openviking_cli.session.user_id import UserIdentifier

    result = await MemoryFilePolicyUpdater(viking_fs=fs, vikingdb=vikingdb).apply(
        plan,
        policy_set,
        RequestContext(user=UserIdentifier("default", "u"), role=Role.USER),
    )

    assert result.errors == []
    assert result.written_uris == [policy_set.policies[0].uri]
    assert len(vikingdb.embedding_messages) == 1
    embedding_msg = vikingdb.embedding_messages[0]
    assert embedding_msg.context_data["uri"] == policy_set.policies[0].uri
    assert embedding_msg.context_data["context_type"] == "memory"
    assert "new content" in embedding_msg.message


@pytest.mark.asyncio
async def test_memory_file_policy_updater_writes_v2_compatible_source_trajectory_links():
    policy_set = _experience_set()
    exp_uri = policy_set.policies[0].uri
    traj_uri = "viking://user/u/memories/trajectories/booking_duplicate.md"
    ctx = fake_request_context()
    transaction_lease = {"lease_ref": "experience-tree-lease"}
    fs = FakeVikingFS(
        {
            traj_uri: MemoryFileUtils.write(
                MemoryFile(
                    uri=traj_uri,
                    content="trajectory content",
                    memory_type="trajectories",
                    extra_fields={
                        "memory_type": "trajectories",
                        "trajectory_name": "booking_duplicate",
                    },
                )
            )
        }
    )
    gradient = _patch_gradient(
        uri=exp_uri,
        before="content",
        after="new content",
        links=[
            StoredLink(
                from_uri=exp_uri,
                to_uri=traj_uri,
                link_type="derived_from",
                weight=1.0,
            )
        ],
    )
    plan = _plan_from_gradient(gradient)

    result = await MemoryFilePolicyUpdater(viking_fs=fs).apply(
        plan,
        policy_set,
        ctx,
        transaction_handle=transaction_lease,
    )

    assert result.errors == []
    assert len(fs._async_agfs.acquire_calls) == 1
    acquire_call = fs._async_agfs.acquire_calls[0]
    assert acquire_call["exact_paths"] == [fs._uri_to_path(traj_uri, ctx=ctx)]
    assert acquire_call["tree_paths"] == [fs._uri_to_path(policy_set.root_uri, ctx=ctx)]
    assert acquire_call["timeout_secs"] == 300.0
    assert acquire_call["owner_lease_ref"] is transaction_lease
    combined_lease = acquire_call["lease"]
    assert fs._async_agfs.release_calls == [combined_lease]
    relevant_write_leases = [
        lease for uri, lease in fs.write_lock_handles if uri in {exp_uri, traj_uri}
    ]
    assert relevant_write_leases
    assert all(lease is combined_lease for lease in relevant_write_leases)

    exp_mf = MemoryFileUtils.read(fs.files[exp_uri], uri=exp_uri)
    assert any(
        link.get("from_uri") == exp_uri
        and link.get("to_uri") == traj_uri
        and link.get("link_type") == "derived_from"
        and link.get("match_text") is None
        and link.get("description") == ""
        for link in exp_mf.links
    )

    traj_mf = MemoryFileUtils.read(fs.files[traj_uri], uri=traj_uri)
    assert any(
        link.get("from_uri") == exp_uri
        and link.get("to_uri") == traj_uri
        and link.get("link_type") == "derived_from"
        and link.get("match_text") is None
        and link.get("description") == ""
        for link in traj_mf.backlinks
    )


@pytest.mark.asyncio
async def test_memory_file_policy_updater_locks_and_writes_multiple_trajectory_backlinks():
    policy_set = _experience_set()
    exp_uri = policy_set.policies[0].uri
    trajectory_uris = [
        "viking://user/u/memories/trajectories/traj1.md",
        "viking://user/u/memories/trajectories/traj2.md",
    ]
    ctx = fake_request_context()
    transaction_lease = {"lease_ref": "experience-tree-lease"}
    fs = FakeVikingFS(
        {
            uri: MemoryFileUtils.write(
                MemoryFile(
                    uri=uri,
                    content=f"trajectory content {index}",
                    memory_type="trajectories",
                    extra_fields={
                        "memory_type": "trajectories",
                        "trajectory_name": f"traj{index}",
                    },
                )
            )
            for index, uri in enumerate(trajectory_uris, start=1)
        }
    )
    gradient = _patch_gradient(
        uri=exp_uri,
        before="content",
        after="new content",
        links=[
            StoredLink(
                from_uri=exp_uri,
                to_uri=uri,
                link_type="derived_from",
                weight=1.0,
            )
            for uri in trajectory_uris
        ],
    )

    result = await MemoryFilePolicyUpdater(viking_fs=fs).apply(
        _plan_from_gradient(gradient),
        policy_set,
        ctx,
        transaction_handle=transaction_lease,
    )

    assert result.errors == []
    assert len(fs._async_agfs.acquire_calls) == 1
    acquire_call = fs._async_agfs.acquire_calls[0]
    assert acquire_call["exact_paths"] == sorted(
        fs._uri_to_path(uri, ctx=ctx) for uri in trajectory_uris
    )
    assert acquire_call["tree_paths"] == [fs._uri_to_path(policy_set.root_uri, ctx=ctx)]
    assert acquire_call["owner_lease_ref"] is transaction_lease
    combined_lease = acquire_call["lease"]
    assert fs._async_agfs.release_calls == [combined_lease]

    exp_mf = MemoryFileUtils.read(fs.files[exp_uri], uri=exp_uri)
    assert {link["to_uri"] for link in exp_mf.links} == set(trajectory_uris)
    for trajectory_uri in trajectory_uris:
        trajectory_mf = MemoryFileUtils.read(
            fs.files[trajectory_uri],
            uri=trajectory_uri,
        )
        assert any(
            link.get("from_uri") == exp_uri and link.get("to_uri") == trajectory_uri
            for link in trajectory_mf.backlinks
        )


@pytest.mark.asyncio
async def test_memory_file_policy_updater_propagates_combined_lock_failure_before_writes():
    policy_set = _experience_set()
    exp_uri = policy_set.policies[0].uri
    traj_uri = "viking://user/u/memories/trajectories/traj1.md"
    initial_files = {
        exp_uri: MemoryFileUtils.write(
            _memory_file(
                name="booking_duplicate_handling",
                uri=exp_uri,
                content="content",
                version=1,
            )
        ),
        traj_uri: MemoryFileUtils.write(
            MemoryFile(
                uri=traj_uri,
                content="trajectory content",
                memory_type="trajectories",
                extra_fields={"memory_type": "trajectories", "trajectory_name": "traj1"},
            )
        ),
    }
    fs = FakeVikingFS(
        dict(initial_files),
        lock_acquire_error=LockAcquisitionError("combined lock timed out"),
    )
    gradient = _patch_gradient(
        uri=exp_uri,
        before="content",
        after="new content",
        links=[
            StoredLink(
                from_uri=exp_uri,
                to_uri=traj_uri,
                link_type="derived_from",
                weight=1.0,
            )
        ],
    )

    with pytest.raises(LockAcquisitionError, match="combined lock timed out"):
        await MemoryFilePolicyUpdater(viking_fs=fs).apply(
            _plan_from_gradient(gradient),
            policy_set,
            fake_request_context(),
            transaction_handle={"lease_ref": "experience-tree-lease"},
        )

    assert len(fs._async_agfs.acquire_calls) == 1
    assert fs._async_agfs.release_calls == []
    assert fs.write_lock_handles == []
    assert fs.files == initial_files
    persisted_exp = MemoryFileUtils.read(fs.files[exp_uri], uri=exp_uri)
    assert persisted_exp.content == "content"
    assert persisted_exp.extra_fields["version"] == 1


@pytest.mark.asyncio
async def test_memory_file_policy_updater_deletes_experience_files():
    policy_set = _experience_set()
    uri = policy_set.policies[0].uri
    fs = FakeVikingFS({uri: "content"})
    plan = _delete_plan(uri=uri)
    lock_handle = object()

    result = await MemoryFilePolicyUpdater(viking_fs=fs).apply(
        plan,
        policy_set,
        transaction_handle=lock_handle,
    )

    assert result.errors == []
    assert result.written_uris == []
    assert result.deleted_uris == [uri]
    assert result.updated_policy_set.policies == []
    assert uri not in fs.files
    assert fs.rm_lock_handles == [lock_handle]


@pytest.mark.asyncio
async def test_memory_file_policy_updater_detects_base_content_mismatch():
    policy_set = _experience_set()
    fs = FakeVikingFS({})
    gradient = _patch_gradient(
        uri=policy_set.policies[0].uri,
        before="stale content",
        after="new content",
    )
    plan = _plan_from_gradient(gradient)

    result = await MemoryFilePolicyUpdater(viking_fs=fs).apply(plan, policy_set)

    assert result.written_uris == []
    assert result.errors == [
        "base content mismatch for booking_duplicate_handling: expected gradient before_content"
    ]
    assert policy_set.policies[0].uri not in fs.files


@pytest.mark.asyncio
async def test_patch_merge_policy_optimizer_runs_patch_merge_extract_loop(monkeypatch):
    from openviking.session.memory.dataclass import (
        MemoryFile,
        ResolvedOperation,
        ResolvedOperations,
    )

    policy_set = _experience_set()
    gradient = _patch_gradient(
        uri=policy_set.policies[0].uri,
        before="stale content",
        after="merged content",
    )
    captured = {}

    class FakeExtractLoop:
        def __init__(self, **kwargs):
            captured.update(kwargs)

        async def run(self):
            provider = captured["context_provider"]
            captured["prefetch_messages"] = await provider.prefetch()
            return (
                ResolvedOperations(
                    upsert_operations=[
                        ResolvedOperation(
                            old_memory_file_content=MemoryFile(
                                uri=policy_set.policies[0].uri,
                                content="content",
                                memory_type="experiences",
                                extra_fields={
                                    "experience_name": "booking_duplicate_handling",
                                    "version": 1,
                                },
                            ),
                            memory_fields={
                                "experience_name": "booking_duplicate_handling",
                                "content": "merged content",
                            },
                            memory_type="experiences",
                            uris=[policy_set.policies[0].uri],
                        )
                    ],
                    delete_file_contents=[],
                    errors=[],
                ),
                [],
            )

    monkeypatch.setattr(
        "openviking.session.train.components.policy_optimizer.ExtractLoop",
        FakeExtractLoop,
    )

    plan = await PatchMergePolicyOptimizer(viking_fs=FakeVikingFS({}), vlm=object()).plan(
        [gradient],
        policy_set,
        PatchMergePolicyOptimizerContext(request_context=fake_request_context()),
    )

    assert plan.metadata["optimizer"] == "patch_merge"
    assert plan.items[0].kind == "upsert"
    assert plan.items[0].target_uri == policy_set.policies[0].uri
    assert plan.items[0].before_content == "content"
    assert plan.items[0].after_content == "merged content"
    assert [link.to_uri for link in plan.items[0].links] == [
        "viking://user/u/memories/trajectories/traj1.md"
    ]
    assert captured["context_provider"].__class__.__name__ == "PatchMergeContextProvider"
    assert captured["context_provider"].get_tools() == []
    assert "Patch 1" in captured["prefetch_messages"][-1]["content"]
    assert "  content:" in captured["prefetch_messages"][-1]["content"]
    assert "-stale content" in captured["prefetch_messages"][-1]["content"]
    assert "+merged content" in captured["prefetch_messages"][-1]["content"]


@pytest.mark.asyncio
async def test_patch_merge_policy_optimizer_thinking_defaults_to_config_passthrough(
    monkeypatch,
):
    """The optimizer must not force per-call thinking for experiences/trajectories.

    Regression test for issue #6096: an operator-configured ``thinking=False`` VLM
    still received ``thinking=True`` on every patch-merge call.
    """
    from openviking.session.memory.dataclass import ResolvedOperations

    captured = {}

    class FakeExtractLoop:
        def __init__(self, **kwargs):
            captured.update(kwargs)

        async def run(self):
            return ResolvedOperations(upsert_operations=[], delete_file_contents=[], errors=[]), []

    monkeypatch.setattr(
        "openviking.session.train.components.policy_optimizer.ExtractLoop",
        FakeExtractLoop,
    )

    policy_set = _experience_set()
    gradient = _patch_gradient(
        uri=policy_set.policies[0].uri,
        before="stale content",
        after="merged content",
    )
    await PatchMergePolicyOptimizer(viking_fs=FakeVikingFS({}), vlm=object()).plan(
        [gradient],
        policy_set,
        PatchMergePolicyOptimizerContext(request_context=fake_request_context()),
    )

    assert captured["thinking"] is None


@pytest.mark.asyncio
@pytest.mark.parametrize("thinking", [True, False])
async def test_patch_merge_policy_optimizer_explicit_thinking_is_forwarded(monkeypatch, thinking):
    from openviking.session.memory.dataclass import ResolvedOperations

    captured = {}

    class FakeExtractLoop:
        def __init__(self, **kwargs):
            captured.update(kwargs)

        async def run(self):
            return ResolvedOperations(upsert_operations=[], delete_file_contents=[], errors=[]), []

    monkeypatch.setattr(
        "openviking.session.train.components.policy_optimizer.ExtractLoop",
        FakeExtractLoop,
    )

    policy_set = _experience_set()
    gradient = _patch_gradient(
        uri=policy_set.policies[0].uri,
        before="stale content",
        after="merged content",
    )
    optimizer = PatchMergePolicyOptimizer(
        viking_fs=FakeVikingFS({}),
        vlm=object(),
        thinking=thinking,
    )
    await optimizer.plan(
        [gradient],
        policy_set,
        PatchMergePolicyOptimizerContext(request_context=fake_request_context()),
    )

    assert captured["thinking"] is thinking


@pytest.mark.asyncio
async def test_patch_merge_policy_optimizer_merges_all_patch_gradients_once(monkeypatch):
    from openviking.session.memory.dataclass import (
        ResolvedOperation,
        ResolvedOperations,
    )

    policy_set = _experience_set()
    root = policy_set.root_uri
    gradients = [
        _patch_gradient(
            name="重复预订处理",
            uri=f"{root}/重复预订处理.md",
            before=None,
            after="核对订单后只取消重复订单",
            base_version=None,
            rationale="r1",
            links=[
                StoredLink(
                    from_uri=f"{root}/重复预订处理.md",
                    to_uri="viking://user/u/memories/trajectories/traj1.md",
                    link_type="derived_from",
                    weight=1.0,
                )
            ],
            confidence=0.8,
        ),
        _patch_gradient(
            name="处理酒店重复预订",
            uri=f"{root}/处理酒店重复预订.md",
            before=None,
            after="识别有效订单并取消重复订单",
            base_version=None,
            rationale="r2",
            links=[
                StoredLink(
                    from_uri=f"{root}/处理酒店重复预订.md",
                    to_uri="viking://user/u/memories/trajectories/traj2.md",
                    link_type="derived_from",
                    weight=1.0,
                )
            ],
            confidence=0.9,
        ),
    ]
    captured = {"constructed": 0}

    class FakeExtractLoop:
        def __init__(self, **kwargs):
            captured["constructed"] += 1
            captured.update(kwargs)

        async def run(self):
            provider = captured["context_provider"]
            captured["prefetch_messages"] = await provider.prefetch()
            return (
                ResolvedOperations(
                    upsert_operations=[
                        ResolvedOperation(
                            old_memory_file_content=None,
                            memory_fields={
                                "experience_name": "重复预订处理",
                                "content": "合并后的重复预订处理经验",
                            },
                            memory_type="experiences",
                            uris=[f"{root}/重复预订处理.md"],
                        )
                    ],
                    delete_file_contents=[],
                    errors=[],
                ),
                [],
            )

    monkeypatch.setattr("openviking.session.train.components.policy_optimizer.ExtractLoop", FakeExtractLoop)

    plan = await PatchMergePolicyOptimizer(viking_fs=FakeVikingFS({}), vlm=object()).plan(
        gradients,
        policy_set,
        PatchMergePolicyOptimizerContext(request_context=fake_request_context()),
    )

    assert captured["constructed"] == 1
    provider = captured["context_provider"]
    assert provider.required_file_uris == [
        f"{root}/重复预订处理.md",
        f"{root}/处理酒店重复预订.md",
    ]
    assert len(provider.patches) == 2
    assert captured["prefetch_messages"][-1]["content"].count("\nPatch ") == 2
    assert plan.metadata["optimizer"] == "patch_merge"
    assert plan.metadata["patch_gradient_count"] == 2
    assert len(plan.items) == 1
    assert plan.items[0].target_name == "重复预订处理"
    assert [link.to_uri for link in plan.items[0].links] == [
        "viking://user/u/memories/trajectories/traj1.md",
        "viking://user/u/memories/trajectories/traj2.md",
    ]
    assert {link.from_uri for link in plan.items[0].links} == {f"{root}/重复预订处理.md"}


@pytest.mark.asyncio
async def test_patch_merge_policy_optimizer_keeps_distinct_output_source_links_scoped(monkeypatch):
    from openviking.session.memory.dataclass import (
        ResolvedOperation,
        ResolvedOperations,
    )

    policy_set = ExperienceSet(root_uri="viking://user/u/memories/experiences", policies=[])
    root = policy_set.root_uri
    gradients = [
        _patch_gradient(
            name="取消资格核验",
            uri=f"{root}/取消资格核验.md",
            before=None,
            after="取消前核验资格",
            base_version=None,
            links=[
                StoredLink(
                    from_uri=f"{root}/取消资格核验.md",
                    to_uri="viking://user/u/memories/trajectories/traj_cancel.md",
                    link_type="derived_from",
                    weight=1.0,
                )
            ],
        ),
        _patch_gradient(
            name="退款总额传达",
            uri=f"{root}/退款总额传达.md",
            before=None,
            after="多笔退款后传达总额",
            base_version=None,
            links=[
                StoredLink(
                    from_uri=f"{root}/退款总额传达.md",
                    to_uri="viking://user/u/memories/trajectories/traj_refund.md",
                    link_type="derived_from",
                    weight=1.0,
                )
            ],
        ),
    ]

    class FakeExtractLoop:
        def __init__(self, **kwargs):
            pass

        async def run(self):
            return (
                ResolvedOperations(
                    upsert_operations=[
                        ResolvedOperation(
                            old_memory_file_content=None,
                            memory_fields={
                                "experience_name": "取消资格核验",
                                "content": "取消前核验资格",
                            },
                            memory_type="experiences",
                            uris=[f"{root}/取消资格核验.md"],
                        ),
                        ResolvedOperation(
                            old_memory_file_content=None,
                            memory_fields={
                                "experience_name": "退款总额传达",
                                "content": "多笔退款后传达总额",
                            },
                            memory_type="experiences",
                            uris=[f"{root}/退款总额传达.md"],
                        ),
                    ],
                    delete_file_contents=[],
                    errors=[],
                ),
                [],
            )

    monkeypatch.setattr("openviking.session.train.components.policy_optimizer.ExtractLoop", FakeExtractLoop)

    plan = await PatchMergePolicyOptimizer(viking_fs=FakeVikingFS({}), vlm=object()).plan(
        gradients,
        policy_set,
        PatchMergePolicyOptimizerContext(request_context=fake_request_context()),
    )

    links_by_name = {item.target_name: {link.to_uri for link in item.links} for item in plan.items}
    assert links_by_name == {
        "取消资格核验": {"viking://user/u/memories/trajectories/traj_cancel.md"},
        "退款总额传达": {"viking://user/u/memories/trajectories/traj_refund.md"},
    }


@pytest.mark.asyncio
@pytest.mark.parametrize("supersedes", [None, "", "older_pattern"])
async def test_patch_merge_policy_optimizer_single_canonical_output_inherits_all_source_links(
    monkeypatch, supersedes
):
    from openviking.session.memory.dataclass import (
        ResolvedOperation,
        ResolvedOperations,
    )

    policy_set = ExperienceSet(root_uri="viking://user/u/memories/experiences", policies=[])
    root = policy_set.root_uri
    old_uri = f"{root}/older_pattern.md"
    old_history = "viking://user/u/memories/trajectories/older.md"
    policy_set.policies.append(
        Experience(
            name="older_pattern",
            uri=old_uri,
            version=1,
            content="old insight",
            status="production",
            links=[StoredLink(from_uri=old_uri, to_uri=old_history, link_type="derived_from")],
        )
    )
    gradients = [
        _patch_gradient(
            name="重复预订处理",
            uri=f"{root}/重复预订处理.md",
            before=None,
            after="核对订单后只取消重复订单",
            base_version=None,
            links=[
                StoredLink(
                    from_uri=f"{root}/重复预订处理.md",
                    to_uri="viking://user/u/memories/trajectories/traj1.md",
                    link_type="derived_from",
                    weight=1.0,
                )
            ],
        ),
        _patch_gradient(
            name="处理酒店重复预订",
            uri=f"{root}/处理酒店重复预订.md",
            before=None,
            after="识别有效订单并取消重复订单",
            base_version=None,
            links=[
                StoredLink(
                    from_uri=f"{root}/处理酒店重复预订.md",
                    to_uri="viking://user/u/memories/trajectories/traj2.md",
                    link_type="derived_from",
                    weight=1.0,
                )
            ],
        ),
    ]

    if supersedes is not None:
        gradients[0].after_file.extra_fields["supersedes"] = supersedes

    class FakeExtractLoop:
        def __init__(self, **kwargs):
            pass

        async def run(self):
            return (
                ResolvedOperations(
                    upsert_operations=[
                        ResolvedOperation(
                            old_memory_file_content=None,
                            memory_fields={
                                "experience_name": "重复预订处理",
                                "content": "合并后的重复预订处理经验",
                            },
                            memory_type="experiences",
                            uris=[f"{root}/重复预订处理.md"],
                        )
                    ],
                    delete_file_contents=[],
                    errors=[],
                ),
                [],
            )

    monkeypatch.setattr(
        "openviking.session.train.components.policy_optimizer.ExtractLoop", FakeExtractLoop
    )

    plan = await PatchMergePolicyOptimizer(viking_fs=FakeVikingFS({}), vlm=object()).plan(
        gradients,
        policy_set,
        PatchMergePolicyOptimizerContext(request_context=fake_request_context()),
    )

    upserts = [item for item in plan.items if item.kind == "upsert"]
    deletes = [item for item in plan.items if item.kind == "delete"]
    assert [item.target_uri for item in deletes] == ([old_uri] if supersedes else [])
    assert len(upserts) == 1
    assert {link.to_uri for link in upserts[0].links} == {
        "viking://user/u/memories/trajectories/traj1.md",
        "viking://user/u/memories/trajectories/traj2.md",
    } | ({old_history} if supersedes else set())


@pytest.mark.asyncio
async def test_patch_merge_policy_optimizer_runs_llm_for_single_patch(monkeypatch):
    from openviking.session.memory.dataclass import (
        MemoryFile,
        ResolvedOperation,
        ResolvedOperations,
    )

    policy_set = _experience_set()
    gradient = _patch_gradient(
        uri=policy_set.policies[0].uri,
        before="content",
        after="merged update",
    )
    captured = {"constructed": False}

    class FakeExtractLoop:
        def __init__(self, **kwargs):
            captured["constructed"] = True
            captured.update(kwargs)

        async def run(self):
            return (
                ResolvedOperations(
                    upsert_operations=[
                        ResolvedOperation(
                            old_memory_file_content=MemoryFile(
                                uri=policy_set.policies[0].uri,
                                content="content",
                                memory_type="experiences",
                                extra_fields={
                                    "experience_name": "booking_duplicate_handling",
                                    "version": 1,
                                },
                            ),
                            memory_fields={
                                "experience_name": "booking_duplicate_handling",
                                "content": "merged update",
                            },
                            memory_type="experiences",
                            uris=[policy_set.policies[0].uri],
                        )
                    ],
                    delete_file_contents=[],
                    errors=[],
                ),
                [],
            )

    monkeypatch.setattr("openviking.session.train.components.policy_optimizer.ExtractLoop", FakeExtractLoop)

    plan = await PatchMergePolicyOptimizer(viking_fs=FakeVikingFS({}), vlm=object()).plan(
        [gradient],
        policy_set,
        PatchMergePolicyOptimizerContext(request_context=fake_request_context()),
    )

    assert captured["constructed"] is True
    assert plan.metadata["patch_gradient_count"] == 1
    assert plan.items[0].after_content == "merged update"


@pytest.mark.asyncio
@pytest.mark.parametrize("existing", [False, True], ids=["create", "update"])
async def test_patch_merge_policy_optimizer_uses_session_skill_registry(monkeypatch, existing):
    from openviking.core.skill_loader import SkillLoader
    from openviking.session.memory.dataclass import (
        ResolvedOperation,
        ResolvedOperations,
    )
    from openviking.session.train.components.skill_policy_updater import SkillPolicyUpdater

    skill_uri = "viking://user/u/skills/code-review/SKILL.md"
    old_skill = {
        "name": "code-review",
        "description": "Old description",
        "content": "Old content.",
    }

    class SkillFS(FakeVikingFS):
        async def search(self, *args, **kwargs):
            from types import SimpleNamespace

            return SimpleNamespace(to_dict=lambda: {"memories": [], "resources": [], "skills": []})

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

    fs = SkillFS({skill_uri: SkillLoader.to_skill_md(old_skill)} if existing else {})

    class FakeProcessor:
        async def process_skill(self, *, data, **kwargs):
            await fs.write_file(skill_uri, SkillLoader.to_skill_md(data))
            return {"root_uri": skill_uri.removesuffix("/SKILL.md")}

        async def sanitize_skill_privacy(self, skill, ctx):
            return skill

    policy_set = ExperienceSet(
        root_uri="viking://user/u/skills",
        policies=[
            Experience(
                name=old_skill["name"],
                uri=skill_uri,
                version=1,
                status="production",
                content=old_skill["content"],
                metadata={"description": old_skill["description"]},
            )
        ]
        if existing
        else [],
    )
    gradient = PatchSemanticGradient(
        before_file=None,
        after_file=MemoryFile(
            uri=skill_uri,
            content="Use this skill to review code changes.",
            memory_type=SESSION_SKILL_MEMORY_TYPE,
            extra_fields={
                "memory_type": SESSION_SKILL_MEMORY_TYPE,
                "skill_name": "code-review",
            },
        ),
        base_version=None,
        rationale="test",
        links=[],
        confidence=0.9,
        metadata={},
    )
    captured = {}

    class FakeExtractLoop:
        def __init__(self, **kwargs):
            captured.update(kwargs)

        async def run(self):
            return (
                ResolvedOperations(
                    upsert_operations=[
                        ResolvedOperation(
                            old_memory_file_content=None,
                            memory_fields={
                                "skill_name": "code-review",
                                "description": "Review code changes",
                                "content": "Merged skill content.",
                            },
                            memory_type=SESSION_SKILL_MEMORY_TYPE,
                            uris=[skill_uri],
                        )
                    ],
                    delete_file_contents=[],
                    errors=[],
                ),
                [],
            )

    monkeypatch.setattr(
        "openviking.session.train.components.policy_optimizer.ExtractLoop",
        FakeExtractLoop,
    )

    plan = await PatchMergePolicyOptimizer(
        viking_fs=fs,
        vlm=object(),
        memory_type=SESSION_SKILL_MEMORY_TYPE,
        memory_registry=load_skill_extract_registry(),
    ).plan(
        [gradient],
        policy_set,
        PatchMergePolicyOptimizerContext(request_context=fake_request_context()),
    )

    assert captured["isolation_handler"].allowed_memory_types == {SESSION_SKILL_MEMORY_TYPE}
    assert len(plan.items) == 1
    assert plan.items[0].memory_type == SESSION_SKILL_MEMORY_TYPE
    assert plan.items[0].target_name == "code-review"
    assert plan.items[0].target_uri == skill_uri
    assert plan.items[0].after_content == "Merged skill content."

    result = await SkillPolicyUpdater(skill_processor=FakeProcessor(), viking_fs=fs).apply(
        plan, policy_set, fake_request_context()
    )
    assert result.errors == []
    assert result.written_uris == [skill_uri]
    saved = SkillLoader.parse(await fs.read_file(skill_uri))
    assert saved["description"] == "Review code changes"
    assert saved["content"] == "Merged skill content."
    assert result.updated_policy_set.policies[0].metadata["description"] == saved["description"]
    if existing:
        assert policy_set.policies[0].metadata["description"] == "Old description"


@pytest.mark.asyncio
@pytest.mark.parametrize("locked", [False, True], ids=["standalone", "outer-tree-lock"])
async def test_skill_policy_creation_preserves_lock_ownership(tmp_path, monkeypatch, locked):
    from contextlib import nullcontext
    from types import SimpleNamespace
    from unittest.mock import AsyncMock

    from openviking.core.skill_loader import SkillLoader
    from openviking.server.identity import RequestContext, Role
    from openviking.session.train.components.skill_policy_updater import SkillPolicyUpdater
    from openviking.session.train.domain import PolicyPlanItem
    from openviking.storage.viking_fs import VikingFS
    from openviking.utils.agfs_utils import RagfsBindingConfig, create_agfs_client
    from openviking.utils.skill_processor import SkillProcessor
    from openviking_cli.session.user_id import UserIdentifier
    from openviking_cli.utils.config.agfs_config import AGFSConfig

    agfs = create_agfs_client(RagfsBindingConfig(agfs=AGFSConfig(path=str(tmp_path))))
    fs = VikingFS(agfs=agfs)
    ctx = RequestContext(user=UserIdentifier.the_default_user(), role=Role(Role.ROOT))
    root = "viking://user/default/skills"
    uri = f"{root}/code-review/SKILL.md"
    processor = SkillProcessor(vikingdb=AsyncMock())
    queue = SimpleNamespace(enqueue=AsyncMock())
    manager = SimpleNamespace(SEMANTIC="Semantic", get_queue=lambda *args, **kwargs: queue)
    monkeypatch.setattr("openviking.storage.queuefs.get_queue_manager", lambda: manager)
    policy_set = ExperienceSet(root_uri=root, policies=[], viking_fs=fs, request_context=ctx)
    updater = SkillPolicyUpdater(skill_processor=processor, viking_fs=fs)
    plan = PolicyUpdatePlan(
        items=[
            PolicyPlanItem(
                kind="upsert",
                memory_type=SESSION_SKILL_MEMORY_TYPE,
                target_name="code-review",
                target_uri=uri,
                before_content=None,
                after_content="Review steps.",
                metadata={"merge_memory_fields": {"description": "Review code changes"}},
            )
        ]
    )
    try:
        async with policy_set.lock() if locked else nullcontext() as lease:
            result = await updater.apply(plan, policy_set, ctx, transaction_handle=lease)
            assert result.errors == []
            assert result.written_uris == [uri]
            assert SkillLoader.parse(await fs.read_file(uri, ctx=ctx))["content"] == "Review steps."
            for filename in (".abstract.md", ".overview.md"):
                assert await fs.read_file(f"{root}/code-review/{filename}", ctx=ctx)
            if locked:
                # The callee must not release the caller's tree lock.
                with pytest.raises(LockAcquisitionError):
                    await fs._async_agfs.pathlock_acquire_exact(fs._uri_to_path(uri, ctx=ctx))
        # Queued indexing keeps its own package lease after the caller exits.
        with pytest.raises(LockAcquisitionError):
            await fs._async_agfs.pathlock_acquire_exact(fs._uri_to_path(uri, ctx=ctx))
        msg = queue.enqueue.await_args.args[0]
        worker_lease = await fs._async_agfs.pathlock_adopt(msg.lock_handoff)
        await fs._async_agfs.pathlock_release(worker_lease)
        lease = await fs._async_agfs.pathlock_acquire_tree(fs._uri_to_path(root, ctx=ctx))
        await fs._async_agfs.pathlock_release(lease)
    finally:
        from openviking.telemetry import unregister_telemetry

        if queue.enqueue.await_args:
            msg = queue.enqueue.await_args.args[0]
            unregister_telemetry(msg.telemetry_id)
        agfs.close()