Skip to content

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

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

from __future__ import annotations

import inspect
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 import create_session_compressor
from openviking.session.compressor_v3 import (
    SessionCompressorV3,
    _commit_experience_snapshot,
    _experience_root_uri,
    _experience_snapshot_provenance,
    _experience_trajectory_map,
    _report_extraction_telemetry,
    _visible_experience_snapshot_uris,
)
from openviking.session.memory.dataclass import (
    MemoryFile,
    MemoryOperationSkipCode,
    ResolvedOperation,
    ResolvedOperations,
    SkippedMemoryOperation,
    StoredLink,
)
from openviking.session.memory.memory_updater import (
    MemoryReadError,
    MemoryUpdateError,
    MemoryUpdateResult,
)
from openviking.session.memory.utils.memory_file_utils import MemoryFileUtils
from openviking.session.train import (
    Case,
    ExperienceSet,
    PolicyApplyResult,
    PolicyPlanItem,
    PolicyUpdatePlan,
    Rollout,
    RolloutAnalysis,
    RolloutTrainingResult,
    Rubric,
    RubricCriterion,
    RubricEvaluation,
    StreamingPolicyTrainerConfig,
    Trajectory,
)
from openviking.session.train.components.session_commit import _case_spec_message_to_request
from openviking.telemetry import OperationTelemetry, bind_telemetry
from openviking_cli.exceptions import ConflictError
from openviking_cli.session.user_id import UserIdentifier


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


def _messages() -> list[Message]:
    return [
        Message(
            id="m1",
            role="user",
            parts=[TextPart("请处理重复预订,只取消确认是重复的那一单。")],
        ),
        Message(
            id="m2",
            role="assistant",
            parts=[TextPart("已读取两个预订,确认第二个是重复记录并取消。")],
        ),
    ]


def _case_operation() -> ResolvedOperation:
    return ResolvedOperation(
        old_memory_file_content=None,
        memory_type="cases",
        uris=["viking://user/u/memories/cases/重复预订处理.md"],
        memory_fields={
            "case_name": "重复预订处理",
            "task_signature": "处理重复预订并只取消确认重复的订单",
            "input": '{"summary":"用户要求处理重复预订","preconditions":["存在两个相似预订"]}',
            "rubric": '{"name":"重复预订处理Rubric","description":"成功且高效处理重复预订","criteria":[{"name":"先验证重复","description":"取消前必须确认哪一单是重复订单","required":true,"weight":0.6},{"name":"只取消重复项","description":"不得影响有效订单","required":true,"weight":0.4}]}',
            "evidence": "助手根据读取结果确认重复项并完成取消。",
        },
    )


def test_factory_defaults_to_v3():
    compressor = create_session_compressor(vikingdb=None)
    assert isinstance(compressor, SessionCompressorV3)


@pytest.mark.asyncio
async def test_commit_extraction_propagates_template_conflict():
    compressor = SessionCompressorV3(vikingdb=None, rollout_analyzer=SimpleNamespace())
    conflict = ConflictError("Conflicting memory template snapshots; Re-extract before retrying")
    compressor._extract_user_memories = AsyncMock(side_effect=conflict)
    compressor._write_final_memory_diff = AsyncMock()

    with pytest.raises(ConflictError) as raised:
        await compressor.extract_long_term_memories(
            messages=_messages(),
            ctx=_ctx(),
            allowed_memory_types={"profile"},
            # The Session commit worker uses this mode: a conflict must reach it,
            # not turn into an empty successful extraction or memory diff.
            strict_extract_errors=True,
        )
    assert raised.value is conflict
    compressor._write_final_memory_diff.assert_not_awaited()


def test_factory_ignores_deprecated_memory_version():
    assert isinstance(
        create_session_compressor(vikingdb=None, memory_version="v2"), SessionCompressorV3
    )
    assert isinstance(
        create_session_compressor(vikingdb=None, memory_version="unsupported"),
        SessionCompressorV3,
    )


def test_extract_long_term_memories_preserves_legacy_positional_parameter_order():
    parameter_names = list(
        inspect.signature(SessionCompressorV3.extract_long_term_memories).parameters
    )

    assert parameter_names[-4:] == [
        "allow_self_memory",
        "allowed_peer_ids",
        "event_search_tags",
        "peer_memory_enabled",
    ]


def test_report_extraction_telemetry_handles_placeholder_error_targets():
    operations = ResolvedOperations(
        upsert_operations=[
            ResolvedOperation(
                old_memory_file_content=None,
                memory_fields={},
                memory_type="events",
                uris=["unknown"],
            )
        ],
        delete_file_contents=[],
        errors=[],
    )
    result = MemoryUpdateResult()
    result.add_written("unknown")
    result.add_edited("viking://user/u/memories/preferences/pref.md")
    result.add_deleted("viking://user/u/memories/events/old.md")
    result.add_error("events(page_id=xyz)", ValueError("Missing resolved URI"))

    telemetry = OperationTelemetry(operation="session.commit", enabled=True)
    with bind_telemetry(telemetry):
        _report_extraction_telemetry(result, operations)

    summary = telemetry.finish().summary
    extract = summary["memory"]["extract"]
    assert extract["actions"] == {
        "created": 1,
        "merged": 1,
        "deleted": 1,
        "failed": 1,
    }
    assert extract["actions_by_type"] == {
        "events": {"created": 1, "deleted": 1},
        "preferences": {"merged": 1},
        "unknown": {"failed": 1},
    }


@pytest.mark.asyncio
async def test_memory_diff_includes_intentionally_skipped_operations(monkeypatch):
    monkeypatch.setattr(
        "openviking.session.compressor_v3.get_viking_fs",
        lambda: SimpleNamespace(),
    )
    compressor = SessionCompressorV3(vikingdb=None)
    result = MemoryUpdateResult()
    result.add_skipped(
        SkippedMemoryOperation(
            memory_type="events",
            page_id=101,
            reason_code=MemoryOperationSkipCode.INVALID_RANGES,
            reason="No valid event range could be resolved",
        )
    )

    diff = await compressor._build_memory_diff(
        result=result,
        operations=ResolvedOperations(
            upsert_operations=[],
            delete_file_contents=[],
            errors=[],
        ),
        viking_fs=SimpleNamespace(),
        ctx=_ctx(),
        archive_uri="viking://user/u/sessions/s1/history/archive_001",
    )

    assert diff["skipped_operations"] == [
        {
            "memory_type": "events",
            "page_id": 101,
            "reason_code": "invalid_ranges",
            "reason": "No valid event range could be resolved",
        }
    ]
    assert diff["summary"] == {
        "total_adds": 0,
        "total_updates": 0,
        "total_deletes": 0,
        "total_skipped": 1,
    }


@pytest.mark.asyncio
async def test_v3_skips_agent_training_when_agent_evolution_is_disabled(monkeypatch):
    monkeypatch.setattr(
        "openviking.session.compressor_v3.get_viking_fs",
        lambda: SimpleNamespace(),
    )
    compressor = SessionCompressorV3(vikingdb=None)
    compressor._extract_user_memories = AsyncMock(
        return_value=SimpleNamespace(
            contexts=[],
            cases=[_training_case()],
            memory_diff={"operations": {}},
            case_uri_by_name={},
            skipped_operations=[
                {
                    "memory_type": "profile",
                    "reason_code": "peer_memory_disabled",
                    "reason": "Peer memory writes are disabled",
                }
            ],
        )
    )
    compressor.train_from_extracted_cases = AsyncMock()
    compressor._write_final_memory_diff = AsyncMock()

    result = await compressor.extract_long_term_memories(
        messages=_messages(),
        ctx=_ctx(),
        allowed_memory_types={"cases", "profile"},
        agent_evolution_enabled=False,
    )

    compressor.train_from_extracted_cases.assert_not_awaited()
    assert result == []


@pytest.mark.asyncio
async def test_v3_extracts_session_skills_when_agent_evolution_is_disabled(monkeypatch):
    config = SimpleNamespace(
        memory=SimpleNamespace(session_skill_extraction_enabled=True),
    )
    monkeypatch.setattr(
        "openviking.session.compressor_v3.get_openviking_config",
        lambda: config,
    )
    monkeypatch.setattr(
        "openviking.session.compressor_v3.get_viking_fs",
        lambda: SimpleNamespace(),
    )
    compressor = SessionCompressorV3(
        vikingdb=None,
        skill_processor=SimpleNamespace(),
    )
    compressor._extract_user_memories = AsyncMock(
        return_value=SimpleNamespace(
            contexts=[],
            cases=[],
            memory_diff={"operations": {}},
            case_uri_by_name={},
        )
    )
    compressor.train_from_extracted_cases = AsyncMock()
    compressor.extract_session_skills = AsyncMock(
        return_value={
            "case_count": 0,
            "submitted": 0,
            "skill_submitted": 1,
            "skill_uris": ["viking://user/u/skills/code-review/SKILL.md"],
        }
    )
    compressor._write_final_memory_diff = AsyncMock()

    result = await compressor.extract_long_term_memories(
        messages=_messages(),
        ctx=_ctx(),
        allowed_memory_types={"profile", "preferences"},
        agent_evolution_enabled=False,
    )

    compressor.train_from_extracted_cases.assert_not_awaited()
    compressor.extract_session_skills.assert_awaited_once()
    assert result["session_skills"] == [
        {
            "uri": "viking://user/u/skills/code-review/SKILL.md",
            "archive_uri": "",
        }
    ]


@pytest.mark.asyncio
async def test_v3_skill_only_extraction_submits_gradients_without_agent_memories(monkeypatch):
    from openviking.session.train import PatchSemanticGradient

    skill_uri = "viking://user/u/skills/code-review/SKILL.md"
    gradient = PatchSemanticGradient(
        before_file=None,
        after_file=MemoryFile(
            uri=skill_uri,
            content="## Workflow\n- Read changed files first.",
            memory_type="skills",
            extra_fields={"skill_name": "code-review"},
        ),
        base_version=None,
        rationale="test",
        links=[],
        confidence=0.9,
        metadata={},
    )
    analyzer = SimpleNamespace(
        extract_trajectory_memories=AsyncMock(
            return_value={"contexts": [], "skill_gradients": [gradient]}
        )
    )
    trainer = SimpleNamespace(
        submit_gradients=AsyncMock(
            return_value=SimpleNamespace(apply_result=SimpleNamespace(written_uris=[skill_uri]))
        )
    )
    compressor = SessionCompressorV3(
        vikingdb=None,
        rollout_analyzer=analyzer,
        skill_processor=SimpleNamespace(),
    )
    compressor._session_skill_extraction_enabled = lambda: True
    compressor._get_session_skill_trainer = AsyncMock(return_value=trainer)
    monkeypatch.setattr(
        "openviking.session.compressor_v3.get_viking_fs",
        lambda: SimpleNamespace(),
    )

    result = await compressor.extract_session_skills(
        messages=_messages(),
        ctx=_ctx(),
        archive_uri="viking://user/u/sessions/s1/history/archive_001",
    )

    analyzer.extract_trajectory_memories.assert_awaited_once()
    assert analyzer.extract_trajectory_memories.await_args.kwargs["include_trajectories"] is False
    trainer.submit_gradients.assert_awaited_once_with([gradient])
    assert result == {
        "case_count": 0,
        "submitted": 0,
        "skill_submitted": 1,
        "skill_uris": [skill_uri],
    }


@pytest.mark.asyncio
async def test_v3_skips_agent_training_when_execution_memory_types_are_filtered(monkeypatch):
    monkeypatch.setattr(
        "openviking.session.compressor_v3.get_viking_fs",
        lambda: SimpleNamespace(),
    )
    compressor = SessionCompressorV3(vikingdb=None)
    compressor._extract_user_memories = AsyncMock(
        return_value=SimpleNamespace(
            contexts=[],
            cases=[_training_case()],
            memory_diff={"operations": {}},
            case_uri_by_name={},
        )
    )
    compressor.train_from_extracted_cases = AsyncMock()
    compressor._write_final_memory_diff = AsyncMock()

    await compressor.extract_long_term_memories(
        messages=_messages(),
        ctx=_ctx(),
        allowed_memory_types={"cases", "profile"},
        agent_evolution_enabled=True,
    )

    compressor.train_from_extracted_cases.assert_not_awaited()


@pytest.mark.asyncio
async def test_v3_passes_allowed_execution_types_to_agent_training(monkeypatch):
    monkeypatch.setattr(
        "openviking.session.compressor_v3.get_viking_fs",
        lambda: SimpleNamespace(),
    )
    compressor = SessionCompressorV3(vikingdb=None)
    compressor._extract_user_memories = AsyncMock(
        return_value=SimpleNamespace(
            contexts=[],
            cases=[_training_case()],
            memory_diff={"operations": {}},
            case_uri_by_name={},
        )
    )
    compressor.train_from_extracted_cases = AsyncMock(
        return_value={"case_count": 1, "submitted": 1}
    )
    compressor._write_final_memory_diff = AsyncMock()

    await compressor.extract_long_term_memories(
        messages=_messages(),
        ctx=_ctx(),
        allowed_memory_types={"cases", "trajectories"},
        agent_evolution_enabled=True,
    )

    assert compressor.train_from_extracted_cases.await_args.kwargs["allowed_memory_types"] == {
        "trajectories"
    }


@pytest.mark.asyncio
async def test_v3_initializes_only_allowed_memory_files(monkeypatch):
    initialized_with = []

    class DummyRegistry:
        async def initialize_memory_files(self, ctx, allowed_memory_types=None):
            del ctx
            initialized_with.append(allowed_memory_types)

    class DummyOrchestrator:
        async def run(self):
            return None, []

    compressor = SessionCompressorV3(vikingdb=None)
    compressor._get_or_create_react = lambda **kwargs: DummyOrchestrator()
    compressor._write_final_memory_diff = AsyncMock()
    monkeypatch.setattr(
        "openviking.session.compressor_v3.get_viking_fs",
        lambda: SimpleNamespace(),
    )
    monkeypatch.setattr(
        "openviking.session.compressor_v3.get_default_registry",
        lambda: DummyRegistry(),
    )

    await compressor.extract_long_term_memories(
        messages=_messages(),
        ctx=_ctx(),
        allowed_memory_types={"profile"},
        agent_evolution_enabled=False,
    )

    assert initialized_with == [{"profile"}]


def test_experience_root_uri_requires_request_user():
    with pytest.raises(ValueError, match="RequestContext.user.user_id is required"):
        _experience_root_uri(SimpleNamespace(user=None))


def test_case_experience_links_require_policy_root_uri():
    traj_uri = "viking://user/u/memories/trajectories/t.md"
    plan = PolicyUpdatePlan(
        items=[
            PolicyPlanItem(
                kind="upsert",
                memory_type="experiences",
                target_name="exp",
                target_uri=None,
                before_content=None,
                after_content="exp",
                links=[
                    StoredLink(
                        from_uri="",
                        to_uri=traj_uri,
                        link_type="derived_from",
                        weight=1.0,
                    )
                ],
            )
        ]
    )
    apply_result = PolicyApplyResult(
        updated_policy_set=ExperienceSet(root_uri="", policies=[]),
        written_uris=["viking://user/u/memories/experiences/exp.md"],
    )

    from openviking.session.compressor_v3 import _case_experience_links_via_trajectories

    with pytest.raises(ValueError, match="updated_policy_set.root_uri is required"):
        _case_experience_links_via_trajectories(
            case_uri="viking://user/u/memories/cases/case.md",
            trajectory_uris={traj_uri},
            plan=plan,
            apply_result=apply_result,
        )


def test_case_experience_links_exclude_experiences_that_failed_to_persist():
    traj_uri = "viking://user/u/memories/trajectories/t.md"
    exp_uri = "viking://user/u/memories/experiences/exp.md"
    plan = PolicyUpdatePlan(
        items=[
            PolicyPlanItem(
                kind="upsert",
                memory_type="experiences",
                target_name="exp",
                target_uri=exp_uri,
                before_content=None,
                after_content="exp",
                links=[
                    StoredLink(
                        from_uri=exp_uri,
                        to_uri=traj_uri,
                        link_type="derived_from",
                        weight=1.0,
                    )
                ],
            )
        ]
    )
    apply_result = PolicyApplyResult(
        updated_policy_set=ExperienceSet(
            root_uri="viking://user/u/memories/experiences",
            policies=[],
        ),
        written_uris=[],
        errors=[f"{exp_uri}: failed to acquire encrypted write lock"],
    )

    from openviking.session.compressor_v3 import _case_experience_links_via_trajectories

    assert (
        _case_experience_links_via_trajectories(
            case_uri="viking://user/u/memories/cases/case.md",
            trajectory_uris={traj_uri},
            plan=plan,
            apply_result=apply_result,
        )
        == []
    )


@pytest.mark.asyncio
async def test_train_from_extracted_cases_submits_streaming_rollout(monkeypatch):
    submitted_gradients = []
    submitted_analyses = []

    class FakeTrainer:
        policy_set = ExperienceSet(
            root_uri="viking://user/u/memories/experiences",
            policies=[],
        )

        async def submit_gradients(self, gradients, *, analysis=None, rollout=None):
            submitted_gradients.append(gradients)
            submitted_analyses.append(analysis)
            return RolloutTrainingResult(
                analyses=[analysis] if analysis else [],
                gradients=list(gradients),
                plan=PolicyUpdatePlan(items=[], metadata={}),
                apply_result=PolicyApplyResult(
                    updated_policy_set=self.policy_set,
                    written_uris=[],
                    errors=[],
                ),
                metadata={},
            )

    class FakeAnalyzer:
        async def analyze(self, rollout, context):
            return RolloutAnalysis(
                evaluation=RubricEvaluation(
                    passed=True,
                    score=1.0,
                    criterion_results=[],
                    feedback=[],
                ),
                trajectories=[
                    Trajectory(
                        name="duplicate_booking",
                        uri="viking://user/u/memories/trajectories/t1.md",
                        content="trajectory content",
                        outcome="success",
                        retrieval_anchor="",
                    )
                ],
                gradients=[],
            )

    async def fake_estimate_exp_gradients(self, *args, **kwargs):
        # Return one dummy gradient so we can verify submission
        from openviking.session.memory.dataclass import MemoryFile
        from openviking.session.train import PatchSemanticGradient

        return [
            PatchSemanticGradient(
                before_file=None,
                after_file=MemoryFile(
                    uri="viking://user/u/memories/experiences/e1.md",
                    content="new exp",
                    memory_type="experiences",
                    extra_fields={"experience_name": "e1"},
                ),
                base_version=1,
                rationale="test",
                links=[],
                confidence=0.9,
                metadata={},
            )
        ]

    monkeypatch.setattr(
        "openviking.session.compressor_v3.get_viking_fs",
        lambda: SimpleNamespace(ls=AsyncMock(return_value=[])),
    )
    monkeypatch.setattr(
        "openviking.session.compressor_v3.get_streaming_policy_trainer",
        AsyncMock(return_value=FakeTrainer()),
    )
    monkeypatch.setattr(
        "openviking.session.train.components.gradient_estimator.ExperienceGradientEstimator.estimate",
        fake_estimate_exp_gradients,
    )

    compressor = SessionCompressorV3(
        vikingdb=None,
        rollout_analyzer=FakeAnalyzer(),
        streaming_trainer_config=StreamingPolicyTrainerConfig(
            max_wait_seconds=60,
            max_gradients_per_update=8,
        ),
    )
    cases = [_training_case()]
    result = await compressor.train_from_extracted_cases(
        cases=cases,
        messages=_messages(),
        ctx=_ctx(),
        session_id="s1",
    )

    assert result["case_count"] == 1
    assert result["submitted"] == 1
    assert len(submitted_gradients) == 1
    assert len(submitted_gradients[0]) == 1  # one exp gradient per case
    # Verify analysis was used
    assert submitted_analyses[0] is not None
    assert submitted_analyses[0].trajectories[0].name == "duplicate_booking"
    assert cases[0].name == "duplicate_booking"


@pytest.mark.asyncio
async def test_train_from_extracted_cases_skips_experience_updates_when_not_allowed(monkeypatch):
    analyzed = []

    class FakeTrainer:
        policy_set = ExperienceSet(
            root_uri="viking://user/u/memories/experiences",
            policies=[],
        )

    class FakeAnalyzer:
        async def analyze(self, rollout, context):
            del context
            analyzed.append(rollout)
            return RolloutAnalysis(
                evaluation=RubricEvaluation(
                    passed=True,
                    score=1.0,
                    criterion_results=[],
                    feedback=[],
                ),
                trajectories=[
                    Trajectory(
                        name="duplicate_booking",
                        uri="viking://user/u/memories/trajectories/t1.md",
                        content="trajectory content",
                        outcome="success",
                        retrieval_anchor="",
                    )
                ],
                gradients=[],
            )

    estimate = AsyncMock(side_effect=AssertionError("experience estimation must be skipped"))
    monkeypatch.setattr(
        "openviking.session.compressor_v3.get_viking_fs",
        lambda: SimpleNamespace(ls=AsyncMock(return_value=[])),
    )
    monkeypatch.setattr(
        "openviking.session.compressor_v3.get_streaming_policy_trainer",
        AsyncMock(return_value=FakeTrainer()),
    )
    monkeypatch.setattr(
        "openviking.session.train.components.gradient_estimator.ExperienceGradientEstimator.estimate",
        estimate,
    )

    compressor = SessionCompressorV3(vikingdb=None, rollout_analyzer=FakeAnalyzer())
    result = await compressor.train_from_extracted_cases(
        cases=[_training_case()],
        messages=_messages(),
        ctx=_ctx(),
        session_id="s1",
        allowed_memory_types={"trajectories"},
    )

    assert len(analyzed) == 1
    assert result["submitted"] == 1
    estimate.assert_not_awaited()


@pytest.mark.asyncio
@pytest.mark.parametrize("apply_error", [False, True, "links"])
async def test_v3_extract_uses_patch_merge_without_directory_lock(monkeypatch, apply_error):
    applied_operations = []
    trained_cases = []
    uri = _case_operation().uris[0]
    link = StoredLink(from_uri=uri, to_uri=uri + ".other.md", link_type="related_to")

    class DummyRegistry:
        async def initialize_memory_files(self, ctx, allowed_memory_types=None):
            del ctx, allowed_memory_types
            return None

    class DummyOrchestrator:
        async def run(self):
            return (
                ResolvedOperations(
                    upsert_operations=[_case_operation()],
                    delete_file_contents=[],
                    errors=[],
                    resolved_links=[link] if apply_error == "links" else [],
                ),
                [],
            )

    class FakeStreamingUpdater:
        async def submit(self, request):
            applied_operations.append(request.operations)
            result = MemoryUpdateResult()
            if apply_error:
                result.add_error(uri, MemoryReadError(uri, TimeoutError("read timeout")))
            else:
                result.add_written(uri)
            return SimpleNamespace(operations=request.operations, apply_result=result)

    compressor = SessionCompressorV3(
        vikingdb=None,
        rollout_analyzer=SimpleNamespace(),
        vlm_resolver=SimpleNamespace(get_vlm=AsyncMock(return_value=SimpleNamespace())),
    )
    compressor._get_or_create_react = lambda **kwargs: DummyOrchestrator()

    async def fake_train_from_extracted_cases(**kwargs):
        trained_cases.extend(kwargs["cases"])
        return {"case_count": len(kwargs["cases"]), "submitted": len(kwargs["cases"])}

    compressor.train_from_extracted_cases = fake_train_from_extracted_cases

    monkeypatch.setattr(
        "openviking.session.compressor_v3.get_viking_fs",
        lambda: SimpleNamespace(write_file=AsyncMock()),
    )
    monkeypatch.setattr(
        "openviking.session.compressor_v3.get_default_registry",
        lambda: DummyRegistry(),
    )
    monkeypatch.setattr(
        "openviking.session.memory.account_templates.resolve_account_memory_registry",
        AsyncMock(return_value=DummyRegistry()),
    )
    monkeypatch.setattr(
        "openviking.session.compressor_v3.get_streaming_memory_updater",
        AsyncMock(return_value=FakeStreamingUpdater()),
    )

    extraction = compressor.extract_long_term_memories(
        messages=_messages(),
        ctx=_ctx(),
        allowed_memory_types={"cases", "profile", "trajectories", "experiences"},
        strict_extract_errors=True,
    )
    if apply_error:
        with pytest.raises(MemoryUpdateError):
            await extraction
        assert trained_cases == []
        return
    contexts = await extraction

    assert len(applied_operations) == 1
    assert applied_operations[0].upsert_operations[0].memory_type == "cases"
    assert [case.name for case in trained_cases] == ["重复预订处理"]
    assert contexts[0].uri.endswith("重复预订处理.md")


@pytest.mark.asyncio
async def test_v3_extract_trains_only_canonical_case_after_patch_merge(monkeypatch):
    trained_kwargs = []
    canonical_uri = "viking://user/u/memories/cases/duplicate_booking.md"
    loser_uri = "viking://user/u/memories/cases/duplicate_booking_duplicate.md"
    canonical_fields = {
        "case_name": "duplicate_booking",
        "task_signature": "Handle duplicate bookings safely.",
        "input": '{"summary":"cancel only the confirmed duplicate booking"}',
        "rubric": (
            '{"name":"duplicate_booking_rubric","description":"Verify duplicate handling",'
            '"criteria":[{"name":"verify_duplicate","description":"The assistant verifies '
            'which booking is duplicate before cancellation.","required":true,"weight":1.0}]}'
        ),
        "evidence": "Canonical merged case evidence.",
    }

    def case_op(uri: str, name: str) -> ResolvedOperation:
        fields = dict(canonical_fields)
        fields["case_name"] = name
        return ResolvedOperation(
            old_memory_file_content=None,
            memory_type="cases",
            uris=[uri],
            memory_fields=fields,
        )

    class DummyRegistry:
        async def initialize_memory_files(self, ctx, allowed_memory_types=None):
            del ctx, allowed_memory_types
            return None

    class DummyOrchestrator:
        async def run(self):
            return (
                ResolvedOperations(
                    upsert_operations=[
                        case_op(canonical_uri, "duplicate_booking"),
                        case_op(loser_uri, "duplicate_booking_duplicate"),
                    ],
                    delete_file_contents=[],
                    errors=[],
                ),
                [],
            )

    class FakeFS:
        async def read_file(self, uri, ctx=None):
            del ctx
            if uri != canonical_uri:
                raise FileNotFoundError(uri)
            return MemoryFileUtils.write(
                MemoryFile(
                    uri=canonical_uri,
                    content="",
                    memory_type="cases",
                    extra_fields=dict(canonical_fields),
                )
            )

        async def write_file(self, uri, content, ctx=None):
            del uri, content, ctx

    class FakeStreamingUpdater:
        async def submit(self, request):
            del request
            result = MemoryUpdateResult()
            result.add_written(canonical_uri)
            return SimpleNamespace(
                operations=ResolvedOperations(
                    upsert_operations=[case_op(canonical_uri, "duplicate_booking")],
                    delete_file_contents=[],
                    errors=[],
                ),
                apply_result=result,
            )

    compressor = SessionCompressorV3(vikingdb=None)
    compressor._get_or_create_react = lambda **kwargs: DummyOrchestrator()

    async def fake_train_from_extracted_cases(**kwargs):
        trained_kwargs.append(kwargs)
        return {"case_count": len(kwargs["cases"]), "submitted": len(kwargs["cases"])}

    compressor.train_from_extracted_cases = fake_train_from_extracted_cases

    monkeypatch.setattr("openviking.session.compressor_v3.get_viking_fs", lambda: FakeFS())
    monkeypatch.setattr(
        "openviking.session.compressor_v3.get_default_registry",
        lambda: DummyRegistry(),
    )
    monkeypatch.setattr(
        "openviking.session.compressor_v3.get_streaming_memory_updater",
        AsyncMock(return_value=FakeStreamingUpdater()),
    )

    contexts = await compressor.extract_long_term_memories(
        messages=_messages(),
        ctx=_ctx(),
        allowed_memory_types={"cases", "profile", "trajectories", "experiences"},
    )

    assert [context.uri for context in contexts] == [canonical_uri]
    assert len(trained_kwargs) == 1
    assert [case.name for case in trained_kwargs[0]["cases"]] == ["duplicate_booking"]
    assert trained_kwargs[0]["cases"][0].metadata["case_uris"] == [canonical_uri]
    assert trained_kwargs[0]["case_uri_by_name"] == {"duplicate_booking": canonical_uri}


def _training_case() -> Case:
    return Case(
        name="duplicate_booking",
        task_signature="Handle duplicate bookings safely.",
        input={"summary": "cancel only the duplicate booking", "task_id": "task-1"},
        rubric=Rubric(
            name="duplicate_booking_rubric",
            description="Verify duplicates before cancellation.",
            criteria=[
                RubricCriterion(
                    name="verify_duplicate",
                    description="The assistant verifies which booking is the duplicate before acting.",
                    required=True,
                    weight=1.0,
                )
            ],
        ),
        metadata={"evidence": "The rollout contains duplicate-booking handling evidence."},
    )


def _case_spec_message(case: Case | None = None) -> Message:
    rollout = Rollout(
        case=case or _training_case(),
        messages=[],
        policy_snapshot_id="snapshot-1",
    )
    request = _case_spec_message_to_request(rollout)
    return Message(
        id="case-spec",
        role="system",
        parts=[TextPart(text=request["parts"][0]["text"])],
    )


@pytest.mark.asyncio
async def test_v3_training_case_spec_fast_path_skips_user_memory_extraction_and_strips_control_message():
    case_spec = _case_spec_message()
    rollout_messages = _messages()
    written = []
    trained = []

    compressor = SessionCompressorV3(vikingdb=None, rollout_analyzer=SimpleNamespace())

    async def fail_extract_user_memories(**kwargs):
        raise AssertionError("fast path must not run LLM user-memory extraction")

    async def fake_write_training_case_memory(**kwargs):
        written.append(kwargs["case"])
        result = MemoryUpdateResult()
        result.add_written("viking://user/u/memories/cases/duplicate_booking.md")
        return result

    async def fake_train_from_extracted_cases(**kwargs):
        trained.append(kwargs)
        return {"case_count": len(kwargs["cases"]), "submitted": len(kwargs["cases"])}

    compressor._extract_user_memories = fail_extract_user_memories
    compressor._write_training_case_memory = fake_write_training_case_memory
    compressor.train_from_extracted_cases = fake_train_from_extracted_cases
    compressor._write_final_memory_diff = AsyncMock()

    contexts = await compressor.extract_long_term_memories(
        messages=[case_spec, *rollout_messages],
        ctx=_ctx(),
        session_id="s1",
        archive_uri="viking://user/u/sessions/s1/history/archive_001",
        allowed_memory_types={"cases", "trajectories", "experiences"},
    )

    assert [case.name for case in written] == ["duplicate_booking"]
    assert [case.name for case in trained[0]["cases"]] == ["duplicate_booking"]
    assert trained[0]["messages"] == rollout_messages
    assert contexts[0].uri == "viking://user/u/memories/cases/duplicate_booking.md"


@pytest.mark.asyncio
async def test_v3_training_case_spec_does_not_write_case_when_evolution_disabled():
    compressor = SessionCompressorV3(vikingdb=None, rollout_analyzer=SimpleNamespace())
    compressor._extract_user_memories = AsyncMock(
        return_value=SimpleNamespace(
            contexts=[],
            cases=[],
            memory_diff=None,
            case_uri_by_name={},
        )
    )
    compressor._write_training_case_memory = AsyncMock()
    compressor.train_from_extracted_cases = AsyncMock()
    compressor._write_final_memory_diff = AsyncMock()

    contexts = await compressor.extract_long_term_memories(
        messages=[_case_spec_message(), *_messages()],
        ctx=_ctx(),
        session_id="s1",
        archive_uri="viking://user/u/sessions/s1/history/archive_001",
        allowed_memory_types={"cases", "trajectories", "experiences"},
        agent_evolution_enabled=False,
    )

    assert contexts == []
    compressor._write_training_case_memory.assert_not_awaited()
    compressor.train_from_extracted_cases.assert_not_awaited()
    assert compressor._extract_user_memories.await_args.kwargs["allowed_memory_types"] == set()


@pytest.mark.asyncio
async def test_v3_training_case_spec_fast_path_not_used_with_user_memory_policy():
    extracted = False
    trained = []

    compressor = SessionCompressorV3(vikingdb=None, rollout_analyzer=SimpleNamespace())

    async def fake_extract_user_memories(**kwargs):
        nonlocal extracted
        extracted = True
        return SimpleNamespace(contexts=[], cases=[])

    async def fake_train_from_extracted_cases(**kwargs):
        trained.append(kwargs)
        return {"case_count": 0, "submitted": 0}

    compressor._extract_user_memories = fake_extract_user_memories
    compressor.train_from_extracted_cases = fake_train_from_extracted_cases

    contexts = await compressor.extract_long_term_memories(
        messages=[_case_spec_message(), *_messages()],
        ctx=_ctx(),
        allowed_memory_types={"cases", "profile"},
    )

    assert contexts == []
    assert extracted is True
    assert trained == []


@pytest.mark.asyncio
async def test_v3_training_case_spec_fast_path_rejects_invalid_protocol():
    message = _case_spec_message()
    assert isinstance(message.parts[0], TextPart)
    message.parts[0].text = message.parts[0].text.replace(
        "openviking.batch_train.case_spec.v1",
        "openviking.batch_train.case_spec.v0",
    )
    compressor = SessionCompressorV3(vikingdb=None, rollout_analyzer=SimpleNamespace())

    with pytest.raises(ValueError, match="protocol mismatch"):
        await compressor.extract_long_term_memories(
            messages=[message, *_messages()],
            ctx=_ctx(),
            allowed_memory_types={"cases", "trajectories", "experiences"},
        )


def test_training_case_spec_message_uses_fast_path_protocol():
    message = _case_spec_message()
    part = message.parts[0]
    assert isinstance(part, TextPart)
    text = part.text

    assert text.startswith("# OpenViking Batch Training CaseSpec v1")
    assert "openviking.batch_train.case_spec.v1" in text
    assert "duplicate_booking_rubric" in text


def test_training_case_spec_message_uses_original_case_name_for_trials():
    case = _training_case()
    case.name = "tau2_airline_train_1_t0"
    case.task_signature = "tau2:airline:train:1:trial:0"
    case.input.update(
        {
            "domain": "airline",
            "split": "train",
            "data_split": "airline_train",
            "task_id": "1",
            "task_no": 1,
            "train_trial": 0,
            "original_case_name": "tau2_airline_train_1",
        }
    )
    message = _case_spec_message(case)
    payload = __import__(
        "openviking.session.compressor_v3", fromlist=["_training_case_spec_payload_from_message"]
    )._training_case_spec_payload_from_message(message)

    assert payload["case"]["name"] == "tau2_airline_train_1"
    assert payload["case"]["task_signature"] == "tau2:airline:train:1"
    assert payload["case"]["metadata"]["rollout_case_name"] == "tau2_airline_train_1_t0"


@pytest.mark.asyncio
async def test_v3_fast_path_writes_final_memory_diff_with_case_traj_and_exp(monkeypatch):
    archive_uri = "viking://user/u/sessions/s1/history/archive_001"
    writes: dict[str, str] = {}

    class FakeFS:
        async def write_file(self, uri, content, ctx=None):
            del ctx
            writes[uri] = content

        async def read_file(self, uri, ctx=None):
            del ctx
            if uri.endswith("/cases/duplicate_booking.md"):
                return "# duplicate_booking\n\n<!-- MEMORY_FIELDS\n{}\n-->"
            if uri.endswith("/experiences/booking_duplicate_handling.md"):
                return "new exp content\n\n<!-- MEMORY_FIELDS\n{}\n-->"
            raise FileNotFoundError(uri)

    compressor = SessionCompressorV3(vikingdb=None, rollout_analyzer=SimpleNamespace())

    async def fake_write_training_case_memory(**kwargs):
        result = MemoryUpdateResult()
        result.add_written("viking://user/u/memories/cases/duplicate_booking.md")
        return SimpleNamespace(
            result=result,
            memory_diff={
                "archive_uri": archive_uri,
                "trace_id": None,
                "extracted_at": "now",
                "operations": {
                    "adds": [
                        {
                            "uri": "viking://user/u/memories/cases/duplicate_booking.md",
                            "memory_type": "cases",
                            "after": "# duplicate_booking",
                        }
                    ],
                    "updates": [],
                    "deletes": [],
                },
                "skipped_operations": [
                    {
                        "memory_type": "preferences",
                        "page_id": 102,
                        "reason_code": "peer_not_allowed",
                        "reason": "Target peer is outside the allowed memory scope",
                    }
                ],
                "summary": {
                    "total_adds": 1,
                    "total_updates": 0,
                    "total_deletes": 0,
                    "total_skipped": 1,
                },
            },
        )

    async def fake_train_from_extracted_cases(**kwargs):
        return {
            "case_count": 1,
            "submitted": 1,
            "memory_diff": {
                "archive_uri": archive_uri,
                "trace_id": None,
                "extracted_at": "now",
                "operations": {
                    "adds": [
                        {
                            "uri": "viking://user/u/memories/trajectories/duplicate_booking.md",
                            "memory_type": "trajectories",
                            "after": "trajectory content",
                        }
                    ],
                    "updates": [
                        {
                            "uri": "viking://user/u/memories/experiences/booking_duplicate_handling.md",
                            "memory_type": "experiences",
                            "before": "old exp content",
                            "after": "new exp content",
                        }
                    ],
                    "deletes": [],
                },
                "summary": {"total_adds": 1, "total_updates": 1, "total_deletes": 0},
            },
        }

    compressor._write_training_case_memory = fake_write_training_case_memory
    compressor.train_from_extracted_cases = fake_train_from_extracted_cases
    monkeypatch.setattr("openviking.session.compressor_v3.get_viking_fs", lambda: FakeFS())

    contexts = await compressor.extract_long_term_memories(
        messages=[_case_spec_message(), *_messages()],
        ctx=_ctx(),
        session_id="s1",
        archive_uri=archive_uri,
        allowed_memory_types={"cases", "trajectories", "experiences"},
    )

    assert contexts[0].uri.endswith("/cases/duplicate_booking.md")
    diff = __import__("json").loads(writes[f"{archive_uri}/memory_diff.json"])
    assert [item["memory_type"] for item in diff["operations"]["adds"]] == [
        "cases",
        "trajectories",
    ]
    assert [item["memory_type"] for item in diff["operations"]["updates"]] == ["experiences"]
    assert diff["skipped_operations"] == [
        {
            "memory_type": "preferences",
            "page_id": 102,
            "reason_code": "peer_not_allowed",
            "reason": "Target peer is outside the allowed memory scope",
        }
    ]
    assert diff["summary"] == {
        "total_adds": 2,
        "total_updates": 1,
        "total_deletes": 0,
        "total_skipped": 1,
    }


@pytest.mark.asyncio
async def test_v3_builds_training_memory_diff_from_streaming_result(monkeypatch):
    archive_uri = "viking://user/u/sessions/s1/history/archive_001"

    class FakeFS:
        async def read_file(self, uri, ctx=None):
            del ctx
            assert uri.endswith("/experiences/booking_duplicate_handling.md")
            return "new exp content\n\n<!-- MEMORY_FIELDS\n{}\n-->"

    compressor = SessionCompressorV3(vikingdb=None, rollout_analyzer=SimpleNamespace())
    plan = PolicyUpdatePlan(
        items=[
            PolicyPlanItem(
                kind="upsert",
                memory_type="experiences",
                target_name="booking_duplicate_handling",
                target_uri="viking://user/u/memories/experiences/booking_duplicate_handling.md",
                before_content="old exp content",
                after_content="new exp content fallback",
                links=[
                    StoredLink(
                        from_uri="viking://user/u/memories/experiences/booking_duplicate_handling.md",
                        to_uri="viking://user/u/memories/trajectories/duplicate_booking.md",
                        link_type="derived_from",
                        weight=1.0,
                    )
                ],
            )
        ]
    )
    training_result = RolloutTrainingResult(
        analyses=[
            RolloutAnalysis(
                evaluation=RubricEvaluation(
                    passed=True,
                    score=1.0,
                    criterion_results=[],
                    feedback=[],
                ),
                trajectories=[
                    Trajectory(
                        name="duplicate_booking",
                        uri="viking://user/u/memories/trajectories/duplicate_booking.md",
                        content="trajectory content",
                        outcome="success",
                        retrieval_anchor="Stage: final",
                    )
                ],
            )
        ],
        gradients=[],
        plan=plan,
        apply_result=PolicyApplyResult(
            updated_policy_set=ExperienceSet(
                root_uri="viking://user/u/memories/experiences",
                policies=[],
            ),
            written_uris=["viking://user/u/memories/experiences/booking_duplicate_handling.md"],
        ),
    )

    diff = await compressor._build_training_memory_diff(
        training_result=training_result,
        viking_fs=FakeFS(),
        ctx=_ctx(),
        archive_uri=archive_uri,
    )

    assert diff["summary"] == {
        "total_adds": 1,
        "total_updates": 1,
        "total_deletes": 0,
        "total_skipped": 0,
    }
    assert diff["operations"]["adds"][0]["memory_type"] == "trajectories"
    update = diff["operations"]["updates"][0]
    assert update["memory_type"] == "experiences"
    assert update["before"] == "old exp content"
    assert update["after"] == "new exp content"


@pytest.mark.asyncio
async def test_v3_training_memory_diff_filters_batch_items_by_current_analysis_trajectory(
    monkeypatch,
):
    archive_uri = "viking://user/u/sessions/s1/history/archive_001"
    traj_a = "viking://user/u/memories/trajectories/traj_a.md"
    traj_b = "viking://user/u/memories/trajectories/traj_b.md"
    exp_a = "viking://user/u/memories/experiences/exp_a.md"
    exp_b = "viking://user/u/memories/experiences/exp_b.md"

    class FakeFS:
        async def read_file(self, uri, ctx=None):
            del ctx
            return {
                exp_a: "exp a\n\n<!-- MEMORY_FIELDS\n{}\n-->",
                exp_b: "exp b\n\n<!-- MEMORY_FIELDS\n{}\n-->",
            }[uri]

    compressor = SessionCompressorV3(vikingdb=None, rollout_analyzer=SimpleNamespace())
    training_result = RolloutTrainingResult(
        analyses=[
            RolloutAnalysis(
                evaluation=RubricEvaluation(
                    passed=True, score=1.0, criterion_results=[], feedback=[]
                ),
                trajectories=[
                    Trajectory(
                        name="traj_a",
                        uri=traj_a,
                        content="trajectory a",
                        outcome="success",
                        retrieval_anchor="",
                    )
                ],
            )
        ],
        gradients=[],
        plan=PolicyUpdatePlan(
            items=[
                PolicyPlanItem(
                    kind="upsert",
                    memory_type="experiences",
                    target_name="exp_a",
                    target_uri=exp_a,
                    before_content=None,
                    after_content="exp a fallback",
                    links=[
                        StoredLink(
                            from_uri=exp_a,
                            to_uri=traj_a,
                            link_type="derived_from",
                            weight=1.0,
                        )
                    ],
                ),
                PolicyPlanItem(
                    kind="upsert",
                    memory_type="experiences",
                    target_name="exp_b",
                    target_uri=exp_b,
                    before_content=None,
                    after_content="exp b fallback",
                    links=[
                        StoredLink(
                            from_uri=exp_b,
                            to_uri=traj_b,
                            link_type="derived_from",
                            weight=1.0,
                        )
                    ],
                ),
            ]
        ),
        apply_result=PolicyApplyResult(
            updated_policy_set=ExperienceSet(
                root_uri="viking://user/u/memories/experiences",
                policies=[],
            ),
            written_uris=[exp_a, exp_b],
        ),
    )

    diff = await compressor._build_training_memory_diff(
        training_result=training_result,
        viking_fs=FakeFS(),
        ctx=_ctx(),
        archive_uri=archive_uri,
    )

    assert diff["summary"] == {
        "total_adds": 2,
        "total_updates": 0,
        "total_deletes": 0,
        "total_skipped": 0,
    }
    assert [op["uri"] for op in diff["operations"]["adds"]] == [traj_a, exp_a]


def test_v3_maps_each_written_experience_to_its_source_trajectories():
    traj_a = "viking://user/u/memories/trajectories/traj_a.md"
    traj_b = "viking://user/u/memories/trajectories/traj_b.md"
    exp_a = "viking://user/u/memories/experiences/exp_a.md"
    exp_b = "viking://user/u/memories/experiences/exp_b.md"
    plan = PolicyUpdatePlan(
        items=[
            PolicyPlanItem(
                kind="upsert",
                memory_type="experiences",
                target_name="exp_a",
                target_uri=exp_a,
                before_content=None,
                after_content="exp a",
                links=[
                    StoredLink(
                        from_uri=exp_a,
                        to_uri=traj_a,
                        link_type="derived_from",
                        weight=1.0,
                    )
                ],
            ),
            PolicyPlanItem(
                kind="upsert",
                memory_type="experiences",
                target_name="exp_b",
                target_uri=exp_b,
                before_content=None,
                after_content="exp b",
                links=[
                    StoredLink(
                        from_uri=exp_b,
                        to_uri=traj_b,
                        link_type="derived_from",
                        weight=1.0,
                    )
                ],
            ),
        ]
    )
    apply_result = PolicyApplyResult(
        updated_policy_set=ExperienceSet(
            root_uri="viking://user/u/memories/experiences",
            policies=[],
        ),
        written_uris=[exp_a, exp_b],
    )

    assert _experience_trajectory_map(
        plan=plan,
        apply_result=apply_result,
        trajectory_uris={traj_a, traj_b},
    ) == {
        exp_a: [traj_a],
        exp_b: [traj_b],
    }


def test_v3_snapshot_provenance_uses_complete_shared_batch_result():
    traj_a = "viking://user/u/memories/trajectories/traj_a.md"
    traj_b = "viking://user/u/memories/trajectories/traj_b.md"
    exp_a = "viking://user/u/memories/experiences/exp_a.md"
    exp_b = "viking://user/u/memories/experiences/exp_b.md"

    def plan_item(experience_uri: str, trajectory_uri: str) -> PolicyPlanItem:
        return PolicyPlanItem(
            kind="upsert",
            memory_type="experiences",
            target_name=experience_uri.rsplit("/", 1)[-1].removesuffix(".md"),
            target_uri=experience_uri,
            before_content=None,
            after_content="updated",
            links=[
                StoredLink(
                    from_uri=experience_uri,
                    to_uri=trajectory_uri,
                    link_type="derived_from",
                    weight=1.0,
                )
            ],
        )

    root = "viking://user/u/memories/experiences"
    batch_result = SimpleNamespace(
        analyses=[
            SimpleNamespace(trajectories=[SimpleNamespace(uri=traj_a)]),
            SimpleNamespace(trajectories=[SimpleNamespace(uri=traj_b)]),
        ],
        plan=PolicyUpdatePlan(items=[plan_item(exp_a, traj_a), plan_item(exp_b, traj_b)]),
        apply_result=PolicyApplyResult(
            updated_policy_set=ExperienceSet(root_uri=root, policies=[]),
            written_uris=[exp_a, exp_b],
        ),
    )
    scoped_result = SimpleNamespace(
        analyses=[batch_result.analyses[0]],
        plan=PolicyUpdatePlan(items=[batch_result.plan.items[0]]),
        apply_result=PolicyApplyResult(
            updated_policy_set=ExperienceSet(root_uri=root, policies=[]),
            written_uris=[exp_a],
        ),
        batch_result=batch_result,
    )

    apply_result, trajectory_map = _experience_snapshot_provenance(scoped_result)

    assert apply_result is batch_result.apply_result
    assert trajectory_map == {
        exp_a: [traj_a],
        exp_b: [traj_b],
    }


def test_visible_experience_snapshot_uris_only_returns_applied_body_changes():
    root = "viking://user/u/memories/experiences"
    changed_uri = f"{root}/changed.md"
    metadata_only_uri = f"{root}/metadata_only.md"
    failed_uri = f"{root}/failed.md"
    deleted_uri = f"{root}/deleted.md"
    content_write_uri = f"{root}/content_write.md"
    plan = PolicyUpdatePlan(
        items=[
            PolicyPlanItem(
                kind="upsert",
                memory_type="experiences",
                target_name="changed",
                target_uri=changed_uri,
                before_content="before",
                after_content="after",
            ),
            PolicyPlanItem(
                kind="upsert",
                memory_type="experiences",
                target_name="metadata_only",
                target_uri=metadata_only_uri,
                before_content="unchanged",
                after_content="unchanged",
            ),
            PolicyPlanItem(
                kind="upsert",
                memory_type="experiences",
                target_name="failed",
                target_uri=failed_uri,
                before_content="before",
                after_content="after",
            ),
            PolicyPlanItem(
                kind="delete",
                memory_type="experiences",
                target_name="deleted",
                target_uri=deleted_uri,
                before_content="old content",
                after_content=None,
            ),
        ]
    )
    apply_result = PolicyApplyResult(
        updated_policy_set=ExperienceSet(root_uri=root, policies=[]),
        written_uris=[changed_uri, metadata_only_uri, content_write_uri],
        deleted_uris=[deleted_uri],
    )

    assert _visible_experience_snapshot_uris(
        plan=plan,
        apply_result=apply_result,
    ) == [changed_uri, deleted_uri]


@pytest.mark.asyncio
async def test_commit_experience_snapshot_skips_when_no_visible_content_changed():
    viking_fs = SimpleNamespace(commit=AsyncMock())

    await _commit_experience_snapshot(
        viking_fs,
        ctx=_ctx(),
        experience_uris=[],
        archive_uri="viking://user/u/sessions/session-1/history/archive_001",
    )

    viking_fs.commit.assert_not_awaited()


@pytest.mark.asyncio
async def test_v3_training_links_case_to_trajectory_and_experience_via_trajectory(monkeypatch):
    case_uri = "viking://user/u/memories/cases/duplicate_booking.md"
    traj_uri = "viking://user/u/memories/trajectories/duplicate_booking.md"
    exp_uri = "viking://user/u/memories/experiences/booking_duplicate_handling.md"
    deleted_exp_uri = "viking://user/u/memories/experiences/legacy_booking_handling.md"

    class FakeFS:
        def __init__(self):
            self.commits = []
            self.files = {
                case_uri: MemoryFileUtils.write(
                    MemoryFile(
                        uri=case_uri,
                        content="# duplicate_booking",
                        memory_type="cases",
                        extra_fields={"memory_type": "cases", "case_name": "duplicate_booking"},
                    ),
                    content_template=(
                        "# {{ case_name }}\n\n"
                        "## Linked Experiences\n"
                        "{% for link in links or [] %}"
                        "{% set target_uri = link.to_uri or '' %}"
                        "{% if '/memories/experiences/' in target_uri %}"
                        "- [{{ uri_basename(target_uri) }}]({{ link_target(target_uri) }})\n"
                        "{% endif %}"
                        "{% endfor %}"
                    ),
                ),
                traj_uri: MemoryFileUtils.write(
                    MemoryFile(
                        uri=traj_uri,
                        content="trajectory content",
                        memory_type="trajectories",
                        extra_fields={
                            "memory_type": "trajectories",
                            "trajectory_name": "duplicate_booking",
                        },
                        backlinks=[
                            StoredLink(
                                from_uri=exp_uri,
                                to_uri=traj_uri,
                                link_type="derived_from",
                                weight=1.0,
                                match_text=None,
                                description="",
                            ).model_dump()
                        ],
                    )
                ),
                exp_uri: MemoryFileUtils.write(
                    MemoryFile(
                        uri=exp_uri,
                        content="old exp content",
                        memory_type="experiences",
                        extra_fields={
                            "memory_type": "experiences",
                            "experience_name": "booking_duplicate_handling",
                        },
                    )
                ),
            }

        async def read_file(self, uri, ctx=None):
            del ctx
            return self.files[uri]

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

        async def ls(self, uri, output="original", ctx=None):
            del uri, output, ctx
            return []

        async def commit(self, **kwargs):
            self.commits.append(kwargs)

    class FakeTrainer:
        policy_set = ExperienceSet(root_uri="viking://user/u/memories/experiences", policies=[])

        async def submit_gradients(
            self,
            gradients,
            *,
            analysis=None,
            rollout=None,
            batch_finalizer=None,
        ):
            del gradients, analysis, rollout
            plan = PolicyUpdatePlan(
                items=[
                    PolicyPlanItem(
                        kind="upsert",
                        memory_type="experiences",
                        target_name="booking_duplicate_handling",
                        target_uri=exp_uri,
                        before_content="old exp content",
                        after_content="new exp content",
                        links=[
                            StoredLink(
                                from_uri=exp_uri,
                                to_uri=traj_uri,
                                link_type="derived_from",
                                weight=1.0,
                                match_text=None,
                                description="",
                            )
                        ],
                    ),
                    PolicyPlanItem(
                        kind="delete",
                        memory_type="experiences",
                        target_name="legacy_booking_handling",
                        target_uri=deleted_exp_uri,
                        before_content="legacy exp content",
                        after_content=None,
                    ),
                ]
            )
            result = RolloutTrainingResult(
                analyses=[],
                gradients=[],
                plan=plan,
                apply_result=PolicyApplyResult(
                    updated_policy_set=ExperienceSet(
                        root_uri="viking://user/u/memories/experiences",
                        policies=[],
                    ),
                    written_uris=[exp_uri],
                    deleted_uris=[deleted_exp_uri],
                    errors=[],
                ),
                metadata={},
            )
            if batch_finalizer is not None:
                await batch_finalizer(result)
            return result

    class FakeAnalyzer:
        async def analyze(self, rollout, context):
            del rollout, context
            return RolloutAnalysis(
                evaluation=RubricEvaluation(
                    passed=True, score=1.0, criterion_results=[], feedback=[]
                ),
                trajectories=[
                    Trajectory(
                        name="duplicate_booking",
                        uri=traj_uri,
                        content="trajectory content",
                        outcome="success",
                        retrieval_anchor="",
                    )
                ],
                gradients=[],
            )

    async def fake_estimate_exp_gradients(self, *args, **kwargs):
        from openviking.session.train import PatchSemanticGradient

        return [
            PatchSemanticGradient(
                before_file=None,
                after_file=MemoryFile(
                    uri=exp_uri,
                    content="new exp content",
                    memory_type="experiences",
                    extra_fields={"experience_name": "booking_duplicate_handling"},
                ),
                base_version=1,
                rationale="test",
                links=[],
                confidence=0.9,
                metadata={},
            )
        ]

    fs = FakeFS()
    monkeypatch.setattr("openviking.session.compressor_v3.get_viking_fs", lambda: fs)
    monkeypatch.setattr(
        "openviking.session.compressor_v3.get_streaming_policy_trainer",
        AsyncMock(return_value=FakeTrainer()),
    )
    monkeypatch.setattr(
        "openviking.session.train.components.gradient_estimator.ExperienceGradientEstimator.estimate",
        fake_estimate_exp_gradients,
    )

    compressor = SessionCompressorV3(vikingdb=None, rollout_analyzer=FakeAnalyzer())
    result = await compressor.train_from_extracted_cases(
        cases=[_training_case()],
        case_uri_by_name={"duplicate_booking": case_uri},
        messages=_messages(),
        ctx=_ctx(),
        session_id="session-1",
        archive_uri="viking://user/u/sessions/session-1/history/archive_001",
    )

    assert result["submitted"] == 1
    case_file = MemoryFileUtils.read(fs.files[case_uri], uri=case_uri)
    assert any(
        link["to_uri"] == traj_uri
        and link["link_type"] == "related_to"
        and link.get("match_text") is None
        and link.get("description") == ""
        for link in case_file.links
    )
    assert any(
        link["to_uri"] == exp_uri
        and link["link_type"] == "related_to"
        and link.get("match_text") is None
        and link.get("description") == ""
        for link in case_file.links
    )
    linked_experiences_section = (
        fs.files[case_uri].split("## Linked Experiences", 1)[1].split("<!-- MEMORY_FIELDS", 1)[0]
    )
    assert (
        "[booking_duplicate_handling](../experiences/booking_duplicate_handling.md)"
        in linked_experiences_section
    )
    assert "duplicate_booking.md" not in linked_experiences_section
    traj_file = MemoryFileUtils.read(fs.files[traj_uri], uri=traj_uri)
    assert any(link["from_uri"] == case_uri for link in traj_file.backlinks)
    exp_file = MemoryFileUtils.read(fs.files[exp_uri], uri=exp_uri)
    assert any(link["from_uri"] == case_uri for link in exp_file.backlinks)
    assert fs.commits == [
        {
            "message": (
                "Update experience memories from session commit "
                "viking://user/u/sessions/session-1/history/archive_001\n"
                "OpenViking-Experience-Trajectory-Map: "
                '{"viking://user/u/memories/experiences/booking_duplicate_handling.md":'
                '["viking://user/u/memories/trajectories/duplicate_booking.md"]}'
            ),
            "paths": [exp_uri, deleted_exp_uri],
            "ctx": _ctx(),
        }
    ]