Skip to content

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

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

import asyncio
import json
from types import SimpleNamespace
from unittest.mock import AsyncMock
from uuid import uuid4

import pytest

from openviking.message import Message, TextPart, ToolPart
from openviking.models.vlm.base import ToolCall, VLMResponse
from openviking.pyagfs import get_binding_client
from openviking.pyagfs.exceptions import AGFSIoError
from openviking.service.task_domain import TaskStatus
from openviking.service.task_store import PersistentTaskStore
from openviking.service.task_tracker import TaskTracker, get_task_tracker
from openviking.session import working_memory as wm
from openviking.session.checkpoints import (
    CheckpointPlanner,
)
from openviking.session.checkpoints import (
    CheckpointRequest as _CheckpointRequest,
)
from openviking.session.memory.constants import AGENT_EVOLUTION_MEMORY_TYPES
from openviking.session.session import Session, _ArchiveSummaryResult
from openviking.storage.viking_fs import VikingFS
from openviking_cli.exceptions import InternalError, UnavailableError


async def _write_archive(
    session,
    index: int,
    messages: list[Message],
    *,
    overview: str = "",
    done: dict | None = None,
    failed: bool = False,
    meta: dict | None = None,
) -> str:
    archive_id = f"archive_{index:03d}"
    archive_uri = f"{session.uri}/history/{archive_id}"
    await session._viking_fs.write_file(
        f"{archive_uri}/messages.jsonl",
        "\n".join(message.to_jsonl() for message in messages) + "\n",
        ctx=session.ctx,
    )
    if overview:
        await session._viking_fs.write_file(
            f"{archive_uri}/.overview.md", overview, ctx=session.ctx
        )
    if meta is not None:
        await session._viking_fs.write_file(
            f"{archive_uri}/.meta.json",
            json.dumps(meta),
            ctx=session.ctx,
        )
    if failed:
        await session._viking_fs.write_file(
            f"{archive_uri}/.failed.json",
            json.dumps({"error": "synthetic failure"}),
            ctx=session.ctx,
        )
    if done is not None:
        await session._viking_fs.write_file(
            f"{archive_uri}/.done",
            json.dumps(done),
            ctx=session.ctx,
        )
    return archive_uri


def _text_message(message_id: str, role: str, text: str) -> Message:
    return Message(id=message_id, role=role, parts=[TextPart(text)])


def test_checkpoint_record_respects_remaining_retained_budget():
    records = CheckpointPlanner.build_records(
        [
            _CheckpointRequest(
                turn_anchor_message_id="u1",
                source_message_ids=("a1",),
                retained_message_token_budget=20,
                estimated_active_tokens=15,
            )
        ],
        ("A" * 400,),
    )

    assert records[0]["estimated_tokens"] <= 5
    assert records[0]["checkpoint_version"] == 2


async def test_two_pending_archives_are_visible_independent_of_commit_count(
    client,
):
    session = client(session_id="two_pending_directory_state_test")
    await session.ensure_exists()
    await _write_archive(session, 1, [_text_message("u1", "user", "one")])
    await _write_archive(session, 2, [_text_message("u2", "user", "two")])
    session.meta.commit_count = 99
    await session._save_meta()

    context = await session.get_session_context()

    assert [message["id"] for message in context["messages"]] == ["u1", "u2"]
    assert context["latest_archive_overview"] == ""


async def test_session_context_enforces_hard_budget_without_mutating_archive_raw(
    client,
):
    session = client(session_id="session_context_hard_budget_test")
    await session.ensure_exists()
    archived = _text_message("u1", "user", "A" * 4000)
    await _write_archive(session, 1, [archived])
    live = _text_message("a1", "assistant", "B" * 4000)
    session._messages = [live]
    await session._write_to_agfs_async(messages=[live])

    context = await session.get_session_context(token_budget=100)
    raw = await session._archives.read_messages(f"{session.uri}/history/archive_001")

    assert context["estimatedTokens"] <= 100
    assert context["stats"]["activeTokens"] <= 100
    assert raw[0].content == "A" * 4000
    assert live.content == "B" * 4000


async def test_context_stops_at_newest_terminal_without_replaying_older_failed_raw(
    client,
):
    """The read path stops at archive_002 and never replays archive_001 raw."""
    session = client(session_id="failed_and_wm_disabled_archive_test")
    await session.ensure_exists()
    await _write_archive(
        session,
        1,
        [_text_message("u1", "user", "failed raw")],
        failed=True,
    )
    await _write_archive(
        session,
        2,
        [_text_message("u2", "user", "completed without overview")],
        done={"starting_message_id": "u2", "ending_message_id": "u2"},
    )

    context = await session.get_session_context()

    assert [message["id"] for message in context["messages"]] == []
    # archive_002 is the terminal: .done without a readable overview, so the
    # read path reports it as failed and injects no overview.
    assert context["latest_archive_overview"] == ""
    assert context["stats"]["failedArchives"] == 1


async def test_done_with_missing_required_overview_reports_failed_without_raw(
    client,
):
    """A required overview that is unreadable yields no overview and no raw."""
    session = client(session_id="missing_required_overview_test")
    await session.ensure_exists()
    await _write_archive(
        session,
        1,
        [_text_message("u1", "user", "required overview raw")],
        done={
            "starting_message_id": "u1",
            "ending_message_id": "u1",
            "enable_working_memory": True,
        },
    )

    context = await session.get_session_context()

    assert [message["id"] for message in context["messages"]] == []
    assert context["latest_archive_overview"] == ""
    assert context["stats"]["failedArchives"] == 1


async def test_legacy_done_marker_covers_only_its_own_archive(
    client,
):
    session = client(session_id="legacy_done_self_coverage_test")
    await session.ensure_exists()
    await _write_archive(
        session,
        1,
        [_text_message("u1", "user", "failed raw remains active")],
        failed=True,
    )
    await _write_archive(
        session,
        2,
        [_text_message("u2", "user", "legacy completed raw")],
        overview="# Session Summary\n\nlegacy archive two only",
        done={"starting_message_id": "u2", "ending_message_id": "u2"},
    )

    context = await session.get_session_context()

    assert context["latest_archive_overview"].endswith("legacy archive two only")
    # Terminal-stop read path: archive_001 sits at/older than the terminal.
    assert [message["id"] for message in context["messages"]] == []


async def test_coverage_metadata_cannot_hide_a_pending_archive(
    client,
):
    session = client(session_id="pending_not_explicitly_covered_test")
    await session.ensure_exists()
    await _write_archive(
        session,
        1,
        [_text_message("u1", "user", "still pending")],
    )
    await _write_archive(
        session,
        2,
        [_text_message("u2", "user", "completed two")],
        overview="# Session Summary\n\narchive two",
        done={
            "starting_message_id": "u2",
            "ending_message_id": "u2",
            "coverage_start_archive": "archive_001",
            "coverage_end_archive": "archive_002",
            "covered_failed_archives": ["archive_001"],
        },
    )

    # Phase 2 bookkeeping still refuses to treat a pending archive as covered.
    states = await session._archives.scan_states()
    covered = session._archives.covered_archive_ids(states)
    assert "archive_001" not in covered

    # The read path stops at the newest terminal, so the pending archive that is
    # older than it does not contribute raw messages either.
    context = await session.get_session_context()
    assert [message["id"] for message in context["messages"]] == []


async def test_later_coverage_absorbs_failed_raw_and_stable_deduplicates_root(
    client,
):
    session = client(session_id="failed_coverage_roll_forward_test")
    await session.ensure_exists()
    duplicate = _text_message("u1", "user", "failed raw")
    await _write_archive(session, 1, [duplicate], failed=True)
    await _write_archive(
        session,
        2,
        [_text_message("u2", "user", "current raw")],
        overview="# Session Summary\n\ncovered one and two",
        done={
            "starting_message_id": "u1",
            "ending_message_id": "u2",
            "coverage_start_archive": "archive_001",
            "coverage_end_archive": "archive_002",
            "covered_failed_archives": ["archive_001"],
        },
    )
    session._messages = [duplicate]
    await session._write_to_agfs_async(messages=session._messages)

    context = await session.get_session_context()

    assert context["latest_archive_overview"] == "# Session Summary\n\ncovered one and two"
    assert [message["id"] for message in context["messages"]] == ["u1"]


async def test_phase2_skips_failed_and_completed_archives_without_replay(
    client,
):
    session = client(session_id="phase2_failed_replay_test")
    await session.ensure_exists()
    await _write_archive(
        session,
        1,
        [_text_message("u1", "user", "failed one")],
        failed=True,
    )
    await _write_archive(
        session,
        2,
        [_text_message("u2", "user", "completed without overview")],
        done={"starting_message_id": "u2", "ending_message_id": "u2"},
    )
    current_uri = await _write_archive(
        session,
        3,
        [_text_message("u3", "user", "current three")],
    )

    messages, start, end, failed, completed_steps = await session._prepare_phase2_archive_messages(
        current_uri,
        [_text_message("u3", "user", "current three")],
    )

    assert [message.id for message in messages] == ["u3"]
    assert start == "archive_003"
    assert end == "archive_003"
    assert failed == []
    assert completed_steps == {}


async def test_phase2_defers_live_predecessor_and_skips_missing_queue_work(
    client,
    monkeypatch,
):
    session = client(session_id="phase2_predecessor_queue_work_test")
    await session.ensure_exists()
    await _write_archive(
        session,
        1,
        [_text_message("u1", "user", "pending one")],
        meta={
            "phase1": {
                "status": "ready",
                "queue_message": {"task_id": "task-1"},
            }
        },
    )
    second_uri = await _write_archive(
        session,
        2,
        [_text_message("u2", "user", "pending two")],
        meta={
            "phase1": {
                "status": "ready",
                "queue_message": {"task_id": "task-2"},
            }
        },
    )
    tracker = get_task_tracker()
    live_work = {"task-1", "task-2"}
    monkeypatch.setattr(tracker, "has_work", AsyncMock(side_effect=live_work.__contains__))

    assert not await session._can_run_archive(3)

    live_work.remove("task-2")
    assert await session._can_run_archive(3)
    failed = json.loads(
        await session._viking_fs.read_file(f"{second_uri}/.failed.json", ctx=session.ctx)
    )
    assert failed["stage"] == "queue_missing"
    assert not await session._viking_fs.exists(f"{session.uri}/history/archive_001/.failed.json")


async def test_missing_previous_archive_directory_allows_phase2(
    client,
):
    session = client(session_id="missing_previous_archive_test")
    await session.ensure_exists()
    await _write_archive(
        session,
        2,
        [_text_message("u2", "user", "archive two")],
    )

    assert await session._can_run_archive(2)


async def test_phase2_processes_only_current_archive(
    client,
    monkeypatch,
):
    session = client(session_id="phase2_roll_forward_end_to_end_test")
    await session.ensure_exists()
    await _write_archive(
        session,
        1,
        [_text_message("u1", "user", "failed one")],
        failed=True,
        meta={"agent_evolution": {"enabled": False}},
    )
    current = _text_message("u2", "user", "current two")
    current_uri = await _write_archive(
        session,
        2,
        [current],
        meta={"agent_evolution": {"enabled": True}},
    )
    seen_message_ids: list[list[str]] = []

    async def fake_summary(messages, latest_archive_overview=""):
        assert latest_archive_overview == ""
        seen_message_ids.append([message.id for message in messages])
        return "# Session Summary\n\n## Current State\nCurrent archive is covered."

    config = SimpleNamespace(
        memory=SimpleNamespace(
            extraction_enabled=False,
            session_skill_extraction_enabled=False,
        )
    )
    monkeypatch.setattr("openviking.session.session.get_openviking_config", lambda: config)
    monkeypatch.setattr(session, "_generate_archive_summary_async", fake_summary)

    task_id = str(uuid4())
    await get_task_tracker().create(
        "session_commit",
        resource_id=session.session_id,
        account_id=session.ctx.account_id,
        user_id=session.ctx.user.user_id,
        task_id=task_id,
    )
    await session._run_memory_extraction(
        task_id=task_id,
        archive_uri=current_uri,
        messages=[current],
        first_message_id=current.id,
        last_message_id=current.id,
        memory_policy={"working_memory": {"enabled": True}},
        agent_evolution_enabled=True,
    )

    done = json.loads(await session._viking_fs.read_file(f"{current_uri}/.done", ctx=session.ctx))
    task = await get_task_tracker().get(task_id)
    context = await session.get_session_context()
    assert seen_message_ids == [["u2"]]
    assert task.result["agent_evolution_enabled"] is True
    assert done["coverage_start_archive"] == "archive_002"
    assert done["coverage_end_archive"] == "archive_002"
    assert done["covered_failed_archives"] == []
    assert context["latest_archive_overview"].endswith("Current archive is covered.")
    assert context["messages"] == []


async def test_phase2_retry_does_not_repeat_completed_current_archive_steps(
    client,
    monkeypatch,
):
    session = client(session_id="phase2_memory_step_idempotency_test")
    await session.ensure_exists()
    first = _text_message("u1", "user", "already extracted")
    await _write_archive(
        session,
        1,
        [first],
        failed=True,
        meta={"completed_memory_steps": {"long_term": ["u1"]}},
    )
    current = _text_message("u2", "user", "extract this once")
    current_uri = await _write_archive(
        session,
        2,
        [current],
        meta={"completed_memory_steps": {"long_term": ["u2"]}},
    )
    summary_inputs: list[list[str]] = []
    long_term_inputs: list[list[str]] = []

    async def fake_summary(messages, latest_archive_overview=""):
        assert latest_archive_overview == ""
        summary_inputs.append([message.id for message in messages])
        return "# Session Summary\n\n## Current State\nCurrent message is summarized."

    async def fake_long_term(*, messages, **_kwargs):
        long_term_inputs.append([message.id for message in messages])
        return []

    config = SimpleNamespace(
        memory=SimpleNamespace(
            extraction_enabled=True,
            session_skill_extraction_enabled=False,
        )
    )
    monkeypatch.setattr("openviking.session.session.get_openviking_config", lambda: config)
    monkeypatch.setattr(session, "_generate_archive_summary_async", fake_summary)
    monkeypatch.setattr(
        session._session_compressor,
        "extract_long_term_memories",
        fake_long_term,
    )

    task_id = str(uuid4())
    await get_task_tracker().create(
        "session_commit",
        resource_id=session.session_id,
        account_id=session.ctx.account_id,
        user_id=session.ctx.user.user_id,
        task_id=task_id,
    )
    await session._run_memory_extraction(
        task_id=task_id,
        archive_uri=current_uri,
        messages=[current],
        first_message_id=current.id,
        last_message_id=current.id,
        memory_policy={
            "self": {"enabled": True},
            "peer": {"enabled": False},
            "memory_types": ["profile"],
            "working_memory": {"enabled": True},
        },
    )

    done = json.loads(await session._viking_fs.read_file(f"{current_uri}/.done", ctx=session.ctx))
    assert summary_inputs == [["u2"]]
    assert long_term_inputs == []
    assert done["completed_memory_steps"]["long_term"] == ["u2"]


async def test_completed_partial_turn_inserts_checkpoint_after_user_anchor(
    client,
):
    session = client(session_id="partial_turn_checkpoint_test")
    await session.ensure_exists()
    anchor = _text_message("u1", "user", "investigate the outage")
    early = _text_message("a1", "assistant", "checking the first signal")
    tail = _text_message("a2", "assistant", "the latest raw step")
    overview = """# Session Summary

## Current State
Connection pool exhaustion is confirmed.

## Key Facts & Decisions
- Keep the user query as the Turn anchor.

## Open Issues
- Validate the recycle configuration.
"""
    archive_uri = await _write_archive(
        session,
        1,
        [anchor, early],
        overview=overview,
        meta={
            "retention_plan": {
                "mode": "turn_budget",
                "partial_turn": True,
                "turn_anchor_message_id": "u1",
                "checkpoint_source_message_ids": ["a1"],
                "raw_tail_start_message_id": "a2",
                "retained_message_token_budget": 12_000,
            },
            "checkpoints": [
                {
                    "turn_anchor_message_id": "u1",
                    "source_message_ids": ["a1"],
                    "abstract": "Checked the first signal and found pool saturation.",
                    "estimated_tokens": 12,
                }
            ],
        },
        done={
            "starting_message_id": "u1",
            "ending_message_id": "a1",
            "coverage_start_archive": "archive_001",
            "coverage_end_archive": "archive_001",
            "covered_failed_archives": [],
        },
    )
    session._messages = [anchor, tail]
    await session._write_to_agfs_async(messages=session._messages)
    # The retained-message budget belongs to commit planning. Context reads
    # must use their own request budget instead of silently reusing this value.
    session.meta.retention_mode = "turn_budget"
    session.meta.retained_message_token_budget = 1

    context = await session.get_session_context(token_budget=128_000)

    assert [message["id"] for message in context["messages"]] == [
        "u1",
        "checkpoint_archive_001_u1",
        "a2",
    ]
    checkpoint = context["messages"][1]
    assert checkpoint["message_kind"] == "checkpoint"
    assert "peer_id" not in checkpoint
    assert checkpoint["source_message_ids"] == ["a1"]
    assert checkpoint["parts"][0]["uri"] == archive_uri
    assert checkpoint["parts"][0]["abstract"] == (
        "Checked the first signal and found pool saturation."
    )


async def test_legacy_partial_turn_does_not_derive_checkpoint_from_overview(
    client,
):
    session = client(session_id="legacy_partial_turn_without_checkpoint_test")
    await session.ensure_exists()
    anchor = _text_message("u1", "user", "investigate the outage")
    early = _text_message("a1", "assistant", "checking the first signal")
    tail = _text_message("a2", "assistant", "the latest raw step")
    await _write_archive(
        session,
        1,
        [anchor, early],
        overview="# Working Memory\n\n## Current State\nPool exhaustion was found.",
        meta={
            "retention_plan": {
                "mode": "turn_budget",
                "partial_turn": True,
                "turn_anchor_message_id": "u1",
                "checkpoint_source_message_ids": ["a1"],
                "retained_message_token_budget": 12_000,
            }
        },
        done={"starting_message_id": "u1", "ending_message_id": "a1"},
    )
    session._messages = [anchor, tail]
    await session._write_to_agfs_async(messages=session._messages)

    context = await session.get_session_context()

    assert [message["id"] for message in context["messages"]] == ["u1", "a2"]


async def test_phase2_persists_checkpoint_from_same_summary_call(
    client,
    monkeypatch,
):
    session = client(session_id="phase2_checkpoint_product_test")
    await session.ensure_exists()
    anchor = _text_message("u1", "user", "investigate the outage")
    early = _text_message("a1", "assistant", "checking the first signal")
    tail = _text_message("a2", "assistant", "the latest raw step")
    archive_uri = await _write_archive(
        session,
        1,
        [anchor, early],
        meta={
            "retention_plan": {
                "mode": "turn_budget",
                "partial_turn": True,
                "turn_anchor_message_id": "u1",
                "checkpoint_source_message_ids": ["a1"],
                "raw_tail_start_message_id": "a2",
                "retained_message_token_budget": 6000,
                "estimated_active_tokens": 100,
            }
        },
    )
    session._messages = [anchor, tail]
    await session._write_to_agfs_async(messages=session._messages)
    calls = 0

    async def fake_summary(
        messages,
        latest_archive_overview="",
        checkpoint_requests=None,
    ):
        nonlocal calls
        calls += 1
        assert latest_archive_overview == ""
        assert [message.id for message in messages] == ["u1", "a1"]
        assert checkpoint_requests is not None
        assert len(checkpoint_requests) == 1
        assert checkpoint_requests[0].turn_anchor_message_id == "u1"
        assert checkpoint_requests[0].source_message_ids == ("a1",)
        return _ArchiveSummaryResult(
            overview="# Working Memory\n\n## Current State\nPool saturation confirmed.",
            checkpoint_summaries=("Checked the first signal; pool saturation was confirmed.",),
        )

    config = SimpleNamespace(
        memory=SimpleNamespace(
            extraction_enabled=False,
            session_skill_extraction_enabled=False,
        )
    )
    monkeypatch.setattr("openviking.session.session.get_openviking_config", lambda: config)
    monkeypatch.setattr(session, "_generate_archive_summary_async", fake_summary)

    task_id = str(uuid4())
    await get_task_tracker().create(
        "session_commit",
        resource_id=session.session_id,
        account_id=session.ctx.account_id,
        user_id=session.ctx.user.user_id,
        task_id=task_id,
    )
    await session._run_memory_extraction(
        task_id=task_id,
        archive_uri=archive_uri,
        messages=[anchor, early],
        first_message_id="u1",
        last_message_id="a1",
        memory_policy={"working_memory": {"enabled": True}},
    )

    meta = json.loads(
        await session._viking_fs.read_file(f"{archive_uri}/.meta.json", ctx=session.ctx)
    )
    context = await session.get_session_context()
    assert calls == 1
    assert meta["checkpoints"][0]["checkpoint_version"] == 2
    assert meta["checkpoints"][0]["turn_anchor_message_id"] == "u1"
    assert meta["checkpoints"][0]["source_message_ids"] == ["a1"]
    assert meta["checkpoints"][0]["abstract"] == (
        "Checked the first signal; pool saturation was confirmed."
    )
    assert meta["checkpoints"][0]["estimated_tokens"] > 0
    assert [message["id"] for message in context["messages"]] == [
        "u1",
        "checkpoint_archive_001_u1",
        "a2",
    ]


async def test_wm_creation_returns_two_products_in_one_model_call(
    client,
    monkeypatch,
):
    session = client(session_id="single_call_checkpoint_generation_test")
    calls: list[dict] = []

    class FakeVLM:
        @staticmethod
        def is_available() -> bool:
            return True

        async def get_completion_async(self, **kwargs):
            calls.append(kwargs)
            return VLMResponse(
                tool_calls=[
                    ToolCall(
                        id="tool-call-1",
                        name="create_working_memory",
                        arguments={
                            "working_memory": (
                                "# Working Memory\n\n## Current State\nInvestigation continues."
                            ),
                            "checkpoint_summaries": [
                                "Queried the service and found pool saturation."
                            ],
                        },
                    )
                ],
                finish_reason="tool_calls",
            )

    vlm = FakeVLM()
    session._vlm_resolver = SimpleNamespace(get_vlm=AsyncMock(return_value=vlm))
    monkeypatch.setattr(
        "openviking.session.session.get_openviking_config",
        lambda: SimpleNamespace(vlm=vlm),
    )
    anchor = _text_message("secret-anchor-id", "user", "investigate the outage")
    source = _text_message("secret-source-id", "assistant", "queried the service")
    result = await session._generate_archive_summary_async(
        [anchor, source],
        checkpoint_requests=[
            _CheckpointRequest(
                turn_anchor_message_id=anchor.id,
                source_message_ids=(source.id,),
                retained_message_token_budget=6000,
                estimated_active_tokens=100,
            )
        ],
    )

    assert isinstance(result, _ArchiveSummaryResult)
    assert result.checkpoint_summaries == ("Queried the service and found pool saturation.",)
    assert len(calls) == 1
    assert calls[0]["tools"][0]["function"]["name"] == "create_working_memory"
    assert '<checkpoint_source index="0">' in calls[0]["prompt"]
    assert calls[0]["prompt"].count("queried the service") == 1
    assert "secret-anchor-id" not in calls[0]["prompt"]
    assert "secret-source-id" not in calls[0]["prompt"]


async def test_wm_creation_passes_configured_output_language_to_prompt(client, monkeypatch):
    session = client(session_id="wm_output_language_prompt_test")
    prompts: list[dict] = []

    class FakeVLM:
        @staticmethod
        def is_available() -> bool:
            return True

        async def get_completion_async(self, prompt, **kwargs):
            prompts.append({"prompt": prompt, **kwargs})
            return "# Working Memory"

    vlm = FakeVLM()
    session._vlm_resolver = SimpleNamespace(get_vlm=AsyncMock(return_value=vlm))
    monkeypatch.setattr(
        "openviking.session.session.get_openviking_config",
        lambda: SimpleNamespace(vlm=vlm, output_language_override="zh-CN"),
    )

    result = await session._generate_archive_summary_async(
        [_text_message("zh-user", "user", "请总结当前部署状态")]
    )

    assert result == "# Working Memory"
    assert len(prompts) == 1
    assert "zh-CN" in prompts[0]["prompt"]


async def test_wm_creation_detects_language_from_multiline_user_message(client, monkeypatch):
    session = client(session_id="wm_multiline_output_language_detection_test")
    prompts: list[dict] = []

    class FakeVLM:
        @staticmethod
        def is_available() -> bool:
            return True

        async def get_completion_async(self, prompt, **kwargs):
            prompts.append({"prompt": prompt, **kwargs})
            return "# Working Memory"

    vlm = FakeVLM()
    session._vlm_resolver = SimpleNamespace(get_vlm=AsyncMock(return_value=vlm))
    monkeypatch.setattr(
        "openviking.session.session.get_openviking_config",
        lambda: SimpleNamespace(vlm=vlm),
    )

    result = await session._generate_archive_summary_async(
        [
            _text_message(
                "multiline-user",
                "user",
                "Task details:\n当前生产环境已经完成部署。\n请用中文总结当前状态和后续风险。",
            )
        ]
    )

    assert result == "# Working Memory"
    assert len(prompts) == 1
    assert "zh-CN" in prompts[0]["prompt"]


async def test_wm_update_returns_two_products_in_one_model_call(
    client,
    monkeypatch,
):
    session = client(session_id="single_call_checkpoint_update_test")
    calls: list[dict] = []

    class FakeVLM:
        @staticmethod
        def is_available() -> bool:
            return True

        async def get_completion_async(self, **kwargs):
            calls.append(kwargs)
            return VLMResponse(
                tool_calls=[
                    ToolCall(
                        id="tool-call-1",
                        name="update_working_memory",
                        arguments={
                            "sections": {
                                name: {"op": "KEEP"}
                                for name in (
                                    "Session Title",
                                    "Current State",
                                    "Task & Goals",
                                    "Key Facts & Decisions",
                                    "Files & Context",
                                    "Errors & Corrections",
                                    "Open Issues",
                                )
                            },
                            "checkpoint_summaries": [
                                "Compared logs and ruled out the network path."
                            ],
                        },
                    )
                ],
                finish_reason="tool_calls",
            )

    vlm = FakeVLM()
    session._vlm_resolver = SimpleNamespace(get_vlm=AsyncMock(return_value=vlm))
    monkeypatch.setattr(
        "openviking.session.session.get_openviking_config",
        lambda: SimpleNamespace(vlm=vlm),
    )
    source = _text_message("source-id", "assistant", "compared the logs")
    prior = """# Working Memory

## Session Title
Outage investigation

## Current State
Investigation continues.

## Task & Goals
Find the outage cause.

## Key Facts & Decisions
None.

## Files & Context
None.

## Errors & Corrections
None.

## Open Issues
Confirm the database state.
"""
    result = await session._generate_archive_summary_async(
        [source],
        latest_archive_overview=prior,
        checkpoint_requests=[
            _CheckpointRequest(
                turn_anchor_message_id="anchor-id",
                source_message_ids=(source.id,),
                retained_message_token_budget=6000,
                estimated_active_tokens=100,
                previous_checkpoint_abstract=("Queried the service and found pool saturation."),
                previous_checkpoint_source_message_ids=("older-source-id",),
            )
        ],
    )

    assert isinstance(result, _ArchiveSummaryResult)
    assert result.checkpoint_summaries == ("Compared logs and ruled out the network path.",)
    assert "Investigation continues." in result.overview
    assert len(calls) == 1
    assert calls[0]["tools"][0]["function"]["name"] == "update_working_memory"
    assert "checkpoint_summaries" in calls[0]["prompt"]
    assert '<checkpoint_previous index="0">' in calls[0]["prompt"]
    assert "Queried the service and found pool saturation." in calls[0]["prompt"]
    assert "Never return only the new delta" in calls[0]["prompt"]


async def test_roll_forward_collects_multiple_checkpoint_requests(
    client,
):
    session = client(session_id="multiple_roll_forward_checkpoint_test")
    await session.ensure_exists()
    first_anchor = _text_message("u1", "user", "first investigation")
    first_source = _text_message("a1", "assistant", "first archived step")
    second_anchor = _text_message("u2", "user", "second investigation")
    second_source = _text_message("a2", "assistant", "second archived step")
    await _write_archive(
        session,
        1,
        [first_anchor, first_source],
        failed=True,
        meta={
            "retention_plan": {
                "partial_turn": True,
                "turn_anchor_message_id": "u1",
                "checkpoint_source_message_ids": ["a1"],
                "retained_message_token_budget": 6000,
                "estimated_active_tokens": 100,
            }
        },
    )
    await _write_archive(
        session,
        2,
        [second_anchor, second_source],
        failed=True,
        meta={
            "retention_plan": {
                "partial_turn": True,
                "turn_anchor_message_id": "u2",
                "checkpoint_source_message_ids": ["a2"],
                "retained_message_token_budget": 6000,
                "estimated_active_tokens": 120,
            }
        },
    )
    current = _text_message("u3", "user", "current work")
    current_uri = await _write_archive(session, 3, [current], meta={})
    combined = [first_anchor, first_source, second_anchor, second_source, current]

    requests = await session._checkpoints.collect_requests_for_phase2(
        current_uri,
        ["archive_001", "archive_002"],
        combined,
    )
    formatted = wm.format_messages_for_wm(combined, requests)

    assert [request.turn_anchor_message_id for request in requests] == ["u1", "u2"]
    assert [request.source_message_ids for request in requests] == [("a1",), ("a2",)]
    assert formatted.count('<checkpoint_source index="0">') == 1
    assert formatted.count('<checkpoint_source index="1">') == 1


async def test_phase2_rolls_previous_cumulative_checkpoint_into_v2_record(
    client,
):
    session = client(session_id="cumulative_checkpoint_roll_forward_test")
    await session.ensure_exists()
    anchor = _text_message("u1", "user", "investigate the outage")
    await _write_archive(
        session,
        1,
        [anchor, _text_message("a1", "assistant", "first archived step")],
        overview="# Working Memory\n\n## Current State\nFirst prefix covered.",
        meta={
            "checkpoints": [
                {
                    "checkpoint_version": 2,
                    "turn_anchor_message_id": "u1",
                    "source_message_ids": ["a1"],
                    "abstract": "Pool saturation was confirmed.",
                    "estimated_tokens": 7,
                }
            ]
        },
        done={"starting_message_id": "u1", "ending_message_id": "a1"},
    )
    current_source = _text_message("a2", "assistant", "second archived step")
    current_uri = await _write_archive(
        session,
        2,
        [anchor, current_source],
        meta={
            "retention_plan": {
                "partial_turn": True,
                "turn_anchor_message_id": "u1",
                "checkpoint_source_message_ids": ["a2"],
                "retained_message_token_budget": 6000,
                "estimated_active_tokens": 100,
            }
        },
    )

    requests = await session._checkpoints.collect_requests_for_phase2(
        current_uri,
        [],
        [anchor, current_source],
    )

    assert len(requests) == 1
    assert requests[0].source_message_ids == ("a2",)
    assert requests[0].previous_checkpoint_source_message_ids == ("a1",)
    assert requests[0].previous_checkpoint_abstract == "Pool saturation was confirmed."
    records = session._checkpoints.build_records(
        requests,
        ("Pool saturation was confirmed; the network path was ruled out.",),
    )
    assert records == [
        {
            "checkpoint_version": 2,
            "turn_anchor_message_id": "u1",
            "source_message_ids": ["a1", "a2"],
            "abstract": ("Pool saturation was confirmed; the network path was ruled out."),
            "estimated_tokens": records[0]["estimated_tokens"],
        }
    ]


async def test_phase2_migrates_legacy_checkpoint_deltas_to_cumulative_v2(
    client,
):
    session = client(session_id="legacy_checkpoint_migration_test")
    await session.ensure_exists()
    anchor = _text_message("u1", "user", "investigate the outage")
    for index, source_id, abstract in (
        (1, "a1", "Pool saturation was confirmed."),
        (2, "a2", "The network path was ruled out."),
    ):
        await _write_archive(
            session,
            index,
            [anchor, _text_message(source_id, "assistant", f"archived step {index}")],
            overview=f"# Working Memory\n\n## Current State\nPrefix {index} covered.",
            meta={
                "checkpoints": [
                    {
                        # Missing checkpoint_version means legacy delta semantics.
                        "turn_anchor_message_id": "u1",
                        "source_message_ids": [source_id],
                        "abstract": abstract,
                    }
                ]
            },
            done={"starting_message_id": "u1", "ending_message_id": source_id},
        )
    current_source = _text_message("a3", "assistant", "third archived step")
    current_uri = await _write_archive(
        session,
        3,
        [anchor, current_source],
        meta={
            "retention_plan": {
                "partial_turn": True,
                "turn_anchor_message_id": "u1",
                "checkpoint_source_message_ids": ["a3"],
                "retained_message_token_budget": 6000,
                "estimated_active_tokens": 100,
            }
        },
    )

    requests = await session._checkpoints.collect_requests_for_phase2(
        current_uri,
        [],
        [anchor, current_source],
    )

    assert requests[0].previous_checkpoint_source_message_ids == ("a1", "a2")
    assert requests[0].previous_checkpoint_abstract == (
        "Pool saturation was confirmed.\n\nThe network path was ruled out."
    )
    record = session._checkpoints.build_records(
        requests,
        (
            "Pool saturation was confirmed, the network was ruled out, "
            "and the database remains under investigation.",
        ),
    )[0]
    assert record["checkpoint_version"] == 2
    assert record["source_message_ids"] == ["a1", "a2", "a3"]


async def test_checkpoint_request_rejects_user_or_cross_turn_sources(
    client,
):
    session = client(session_id="invalid_checkpoint_source_test")
    await session.ensure_exists()
    anchor = _text_message("u1", "user", "first query")
    assistant = _text_message("a1", "assistant", "first response")
    archive_uri = await _write_archive(
        session,
        1,
        [anchor, assistant],
        meta={
            "retention_plan": {
                "partial_turn": True,
                "turn_anchor_message_id": "u1",
                "checkpoint_source_message_ids": ["u1"],
                "retained_message_token_budget": 6000,
                "estimated_active_tokens": 100,
            }
        },
    )

    with pytest.raises(ValueError, match="outside its Assistant/Tool prefix"):
        await session._checkpoints.collect_requests_for_phase2(
            archive_uri,
            [],
            [anchor, assistant],
        )


async def test_missing_required_checkpoint_keeps_archive_raw_uncovered(
    client,
    monkeypatch,
):
    session = client(session_id="missing_required_checkpoint_test")
    await session.ensure_exists()
    anchor = _text_message("u1", "user", "investigate the outage")
    early = _text_message("a1", "assistant", "checking the first signal")
    tail = _text_message("a2", "assistant", "the latest raw step")
    archive_uri = await _write_archive(
        session,
        1,
        [anchor, early],
        meta={
            "retention_plan": {
                "mode": "turn_budget",
                "partial_turn": True,
                "turn_anchor_message_id": "u1",
                "checkpoint_source_message_ids": ["a1"],
                "retained_message_token_budget": 6000,
                "estimated_active_tokens": 100,
            }
        },
    )
    session._messages = [anchor, tail]
    await session._write_to_agfs_async(messages=session._messages)

    async def fake_summary(*_args, **_kwargs):
        # Simulate an old/malformed implementation that returns only overview.
        return "# Working Memory\n\n## Current State\nPool saturation confirmed."

    config = SimpleNamespace(
        memory=SimpleNamespace(
            extraction_enabled=False,
            session_skill_extraction_enabled=False,
        )
    )
    monkeypatch.setattr("openviking.session.session.get_openviking_config", lambda: config)
    monkeypatch.setattr(session, "_generate_archive_summary_async", fake_summary)

    task_id = str(uuid4())
    await get_task_tracker().create(
        "session_commit",
        resource_id=session.session_id,
        account_id=session.ctx.account_id,
        user_id=session.ctx.user.user_id,
        task_id=task_id,
    )
    await session._run_memory_extraction(
        task_id=task_id,
        archive_uri=archive_uri,
        messages=[anchor, early],
        first_message_id="u1",
        last_message_id="a1",
        memory_policy={"working_memory": {"enabled": True}},
    )

    assert not await session._viking_fs.exists(f"{archive_uri}/.done", ctx=session.ctx)
    assert await session._viking_fs.exists(f"{archive_uri}/.failed.json", ctx=session.ctx)
    # A missing required checkpoint keeps the archive uncovered and durable on
    # disk. The terminal-stop read path no longer replays its raw messages, so
    # the archived step ``a1`` is gone while the retained anchor and live tail
    # stay, and no checkpoint is synthesized.
    raw = await session._archives.read_messages(archive_uri)
    assert [message.id for message in raw] == ["u1", "a1"]
    context = await session.get_session_context()
    assert [message["id"] for message in context["messages"]] == ["u1", "a2"]
    assert not any(message.get("message_kind") == "checkpoint" for message in context["messages"])


async def test_working_memory_disabled_does_not_generate_or_restore_checkpoint(
    client,
    monkeypatch,
):
    session = client(session_id="wm_disabled_partial_checkpoint_test")
    await session.ensure_exists()
    anchor = _text_message("u1", "user", "investigate the outage")
    early = _text_message("a1", "assistant", "checking the first signal")
    tail = _text_message("a2", "assistant", "the latest raw step")
    archive_uri = await _write_archive(
        session,
        1,
        [anchor, early],
        meta={
            "retention_plan": {
                "mode": "turn_budget",
                "partial_turn": True,
                "turn_anchor_message_id": "u1",
                "checkpoint_source_message_ids": ["a1"],
                "retained_message_token_budget": 6000,
                "estimated_active_tokens": 100,
            }
        },
    )
    session._messages = [anchor, tail]
    await session._write_to_agfs_async(messages=session._messages)

    async def unexpected_summary(*_args, **_kwargs):
        raise AssertionError("Working Memory generation must stay disabled")

    config = SimpleNamespace(
        memory=SimpleNamespace(
            extraction_enabled=False,
            session_skill_extraction_enabled=False,
        )
    )
    monkeypatch.setattr("openviking.session.session.get_openviking_config", lambda: config)
    monkeypatch.setattr(session, "_generate_archive_summary_async", unexpected_summary)

    task_id = str(uuid4())
    await get_task_tracker().create(
        "session_commit",
        resource_id=session.session_id,
        account_id=session.ctx.account_id,
        user_id=session.ctx.user.user_id,
        task_id=task_id,
    )
    await session._run_memory_extraction(
        task_id=task_id,
        archive_uri=archive_uri,
        messages=[anchor, early],
        first_message_id="u1",
        last_message_id="a1",
        memory_policy={
            "working_memory": {"enabled": False},
            "self": {"enabled": False},
            "peer": {"enabled": False},
        },
    )

    assert await session._viking_fs.exists(f"{archive_uri}/.done", ctx=session.ctx)
    context = await session.get_session_context()
    assert [message["id"] for message in context["messages"]] == ["u1", "a2"]


async def test_covered_failed_partial_turn_checkpoint_points_to_covering_overview(
    client,
):
    session = client(session_id="covered_failed_partial_checkpoint_test")
    await session.ensure_exists()
    anchor = _text_message("u1", "user", "investigate the outage")
    early = _text_message("a1", "assistant", "checking an early signal")
    tail = _text_message("a2", "assistant", "the latest raw step")
    await _write_archive(
        session,
        1,
        [anchor, early],
        failed=True,
        meta={
            "retention_plan": {
                "mode": "turn_budget",
                "partial_turn": True,
                "turn_anchor_message_id": "u1",
                "checkpoint_source_message_ids": ["a1"],
                "raw_tail_start_message_id": "a2",
                "retained_message_token_budget": 12_000,
            }
        },
    )
    covering_uri = await _write_archive(
        session,
        2,
        [_text_message("u2", "user", "a later query")],
        overview="# Session Summary\n\n## Current State\nThe early signal is covered.",
        meta={
            "checkpoints": [
                {
                    "turn_anchor_message_id": "u1",
                    "source_message_ids": ["a1"],
                    "abstract": "The early signal ruled out a network failure.",
                    "estimated_tokens": 11,
                }
            ]
        },
        done={
            "starting_message_id": "u1",
            "ending_message_id": "u2",
            "coverage_start_archive": "archive_001",
            "coverage_end_archive": "archive_002",
            "covered_failed_archives": ["archive_001"],
        },
    )
    session._messages = [anchor, tail]
    await session._write_to_agfs_async(messages=session._messages)

    context = await session.get_session_context()

    checkpoint = context["messages"][1]
    assert checkpoint["id"] == "checkpoint_archive_002_u1"
    assert checkpoint["parts"][0]["uri"] == covering_uri
    assert checkpoint["source_message_ids"] == ["a1"]


async def test_failed_terminal_checkpoint_metadata_is_never_restored(
    client,
):
    session = client(session_id="failed_terminal_checkpoint_test")
    await session.ensure_exists()
    anchor = _text_message("u1", "user", "investigate the outage")
    tail = _text_message("a3", "assistant", "latest raw step")
    await _write_archive(
        session,
        1,
        [anchor, _text_message("a1", "assistant", "completed prefix")],
        overview="# Working Memory\n\n## Current State\nCompleted prefix.",
        meta={
            "checkpoints": [
                {
                    "checkpoint_version": 2,
                    "turn_anchor_message_id": "u1",
                    "source_message_ids": ["a1"],
                    "abstract": "Completed prefix.",
                }
            ]
        },
        done={"starting_message_id": "u1", "ending_message_id": "a1"},
    )
    await _write_archive(
        session,
        2,
        [anchor, _text_message("a2", "assistant", "failed prefix")],
        failed=True,
        meta={
            "checkpoints": [
                {
                    "checkpoint_version": 2,
                    "turn_anchor_message_id": "u1",
                    "source_message_ids": ["a1", "a2"],
                    "abstract": "This incomplete checkpoint must not be visible.",
                }
            ]
        },
    )
    session._messages = [anchor, tail]
    await session._write_to_agfs_async(messages=session._messages)

    context = await session.get_session_context()

    assert [message["id"] for message in context["messages"]] == ["u1", "a3"]
    assert not any(message.get("message_kind") == "checkpoint" for message in context["messages"])


async def test_repeated_legacy_partial_commits_merge_checkpoint_deltas(
    client,
):
    """Legacy records have no version marker, so older deltas remain readable."""
    session = client(session_id="repeated_partial_checkpoint_merge_test")
    await session.ensure_exists()
    anchor = _text_message("u1", "user", "investigate the outage")
    tail = _text_message("a3", "assistant", "latest raw step")
    await _write_archive(
        session,
        1,
        [anchor, _text_message("a1", "assistant", "first old step")],
        overview="# Working Memory\n\n## Current State\nFirst prefix covered.",
        meta={
            "checkpoints": [
                {
                    "turn_anchor_message_id": "u1",
                    "source_message_ids": ["a1"],
                    "abstract": "First prefix found pool saturation.",
                    "estimated_tokens": 9,
                }
            ]
        },
        done={"starting_message_id": "u1", "ending_message_id": "a1"},
    )
    second_uri = await _write_archive(
        session,
        2,
        [anchor, _text_message("a2", "assistant", "second old step")],
        overview="# Working Memory\n\n## Current State\nSecond prefix covered.",
        meta={
            "checkpoints": [
                {
                    "turn_anchor_message_id": "u1",
                    "source_message_ids": ["a2"],
                    "abstract": "Second prefix ruled out the network path.",
                    "estimated_tokens": 11,
                }
            ]
        },
        done={"starting_message_id": "u1", "ending_message_id": "a2"},
    )
    session._messages = [anchor, tail]
    await session._write_to_agfs_async(messages=session._messages)

    context = await session.get_session_context()

    assert [message["id"] for message in context["messages"]] == [
        "u1",
        "checkpoint_archive_002_u1",
        "a3",
    ]
    checkpoint = context["messages"][1]
    assert checkpoint["source_message_ids"] == ["a1", "a2"]
    assert checkpoint["parts"][0]["uri"] == second_uri
    assert checkpoint["parts"][0]["abstract"] == (
        "First prefix found pool saturation.\n\nSecond prefix ruled out the network path."
    )


async def test_repeated_v2_partial_commits_restore_newest_cumulative_checkpoint_only(
    client,
    monkeypatch,
):
    """The newest v2 record is complete, so context does not read older archives."""
    session = client(session_id="repeated_cumulative_checkpoint_test")
    await session.ensure_exists()
    anchor = _text_message("u1", "user", "investigate the outage")
    tail = _text_message("a3", "assistant", "latest raw step")
    await _write_archive(
        session,
        1,
        [anchor, _text_message("a1", "assistant", "first old step")],
        overview="# Working Memory\n\n## Current State\nFirst prefix covered.",
        meta={
            "checkpoints": [
                {
                    "checkpoint_version": 2,
                    "turn_anchor_message_id": "u1",
                    "source_message_ids": ["a1"],
                    "abstract": "First prefix found pool saturation.",
                    "estimated_tokens": 9,
                }
            ]
        },
        done={"starting_message_id": "u1", "ending_message_id": "a1"},
    )
    second_uri = await _write_archive(
        session,
        2,
        [anchor, _text_message("a2", "assistant", "second old step")],
        overview="# Working Memory\n\n## Current State\nSecond prefix covered.",
        meta={
            "checkpoints": [
                {
                    "checkpoint_version": 2,
                    "turn_anchor_message_id": "u1",
                    "source_message_ids": ["a1", "a2"],
                    "abstract": ("Pool saturation was found, then the network path was ruled out."),
                    "estimated_tokens": 15,
                }
            ]
        },
        done={"starting_message_id": "u1", "ending_message_id": "a2"},
    )
    session._messages = [anchor, tail]
    await session._write_to_agfs_async(messages=session._messages)

    touched: list[str] = []
    original_read_file = session._viking_fs.read_file

    async def tracking_read_file(*args, **kwargs):
        uri = args[0] if args else kwargs.get("uri")
        touched.append(uri)
        return await original_read_file(*args, **kwargs)

    monkeypatch.setattr(session._viking_fs, "read_file", tracking_read_file)
    context = await session.get_session_context()

    checkpoint = context["messages"][1]
    assert checkpoint["source_message_ids"] == ["a1", "a2"]
    assert checkpoint["parts"][0]["uri"] == second_uri
    assert checkpoint["parts"][0]["abstract"] == (
        "Pool saturation was found, then the network path was ruled out."
    )
    assert not any(isinstance(uri, str) and "archive_001" in uri for uri in touched)


async def test_commit_externalizes_tool_outputs_across_the_whole_turn(
    client,
):
    session = client(session_id="turn_wide_externalization_test")
    await session.ensure_exists()
    session.add_message("user", [TextPart("inspect all files")])
    for index in range(10):
        session.add_message(
            "assistant",
            [
                TextPart(f"step {index}"),
                ToolPart(
                    tool_id=f"tool-{index}",
                    tool_name="read",
                    tool_output=str(index) * 10_000,
                    tool_status="completed",
                ),
            ],
        )

    result = await session.commit_async(
        retention_mode="turn_budget",
        keep_recent_turn_count=1,
        retained_message_token_budget=50_000,
    )

    tool_parts = [
        part for message in session.messages for part in message.parts if isinstance(part, ToolPart)
    ]
    assert result["archived"] is False
    assert any(part.tool_output_ref for part in tool_parts)
    assert all(part.tool_output_group_original_chars == 100_000 for part in tool_parts)
    assert any(part.tool_output_externalized_reason == "turn_budget" for part in tool_parts)


async def test_turn_budget_commit_archives_complete_old_turn_and_keeps_latest_user(
    client,
):
    session = client(session_id="turn_budget_phase1_boundary_test")
    await session.ensure_exists()
    session.add_message("user", [TextPart("first query")])
    session.add_message("assistant", [TextPart("first answer")])
    session.add_message("user", [TextPart("latest query")])
    session.add_message("assistant", [TextPart("latest answer")])

    result = await session.commit_async(
        retention_mode="turn_budget",
        keep_recent_turn_count=1,
        retained_message_token_budget=12_000,
        memory_policy={
            "working_memory": {"enabled": False},
            "self": {"enabled": False},
            "peer": {"enabled": False},
        },
    )
    archived = await session._archives.read_messages(result["archive_uri"])

    assert [message.content for message in archived] == ["first query", "first answer"]
    assert [message.content for message in session.messages] == ["latest query", "latest answer"]
    assert result["estimated_active_tokens"] > 0
    assert result["budget_exceeded"] is False


async def test_concurrent_stale_session_instances_use_one_authoritative_phase1_snapshot(
    client,
):
    session_a = client(session_id="multi_worker_phase1_snapshot_test")
    await session_a.ensure_exists()
    session_a.add_message("user", [TextPart("only once")])
    session_b = client(session_id=session_a.session_id)
    await session_b.load()
    disabled_policy = {
        "working_memory": {"enabled": False},
        "self": {"enabled": False},
        "peer": {"enabled": False},
    }

    results = await asyncio.gather(
        session_a.commit_async(memory_policy=disabled_policy),
        session_b.commit_async(memory_policy=disabled_policy),
    )

    assert sum(result["archived"] is True for result in results) == 1
    assert len(await session_a._archives.list_refs()) == 1
    assert await session_a._read_live_messages_strict() == []


async def test_concurrent_stale_workers_append_without_losing_messages(
    client,
):
    session_a = client(session_id="multi_worker_append_lock_test")
    await session_a.ensure_exists()
    session_b = client(session_id=session_a.session_id)
    await session_b.load()

    await asyncio.gather(
        asyncio.to_thread(session_a.add_message, "user", [TextPart("from worker a")]),
        asyncio.to_thread(session_b.add_message, "user", [TextPart("from worker b")]),
    )

    fresh = client(session_id=session_a.session_id)
    await fresh.load()
    assert sorted(message.content for message in fresh.messages) == [
        "from worker a",
        "from worker b",
    ]


async def test_session_state_lock_serializes_root_meta_without_blocking_archive_write(
    client,
    monkeypatch,
):
    initial = client(session_id="phase2_meta_append_lock_test")
    await initial.ensure_exists()
    await initial.add_message_async("user", [TextPart("first")])

    phase2 = client(session_id=initial.session_id)
    appending = client(session_id=initial.session_id)
    await appending.load()

    phase2_inside_save = asyncio.Event()
    allow_phase2_save = asyncio.Event()
    original_save_meta = phase2._save_meta

    async def delayed_save_meta(*, lease_ref=None):
        phase2_inside_save.set()
        await allow_phase2_save.wait()
        await original_save_meta(lease_ref=lease_ref)

    monkeypatch.setattr(phase2, "_save_meta", delayed_save_meta)
    merge_task = asyncio.create_task(
        phase2._merge_and_save_commit_meta(
            archive_index=1,
            memories_extracted={},
            telemetry_snapshot=None,
        )
    )
    await phase2_inside_save.wait()

    memory_diff_uri = f"{initial._session_uri}/history/archive_001/memory_diff.json"
    await asyncio.wait_for(
        phase2._viking_fs.write_file(memory_diff_uri, "{}", ctx=phase2.ctx),
        timeout=1.0,
    )

    append_task = asyncio.create_task(
        appending.add_message_async("assistant", [TextPart("second")])
    )
    await asyncio.sleep(0.05)
    assert not append_task.done()

    allow_phase2_save.set()
    await asyncio.gather(merge_task, append_task)

    fresh = client(session_id=initial.session_id)
    await fresh.load()
    assert await fresh._viking_fs.read_file(memory_diff_uri, ctx=fresh.ctx) == "{}"
    assert [message.content for message in fresh.messages] == ["first", "second"]
    assert fresh.meta.message_count == 2
    assert fresh.meta.total_message_count == 2
    assert fresh.meta.commit_count == 1


async def test_add_waits_for_commit_root_rewrite_and_remains_live(
    client,
    monkeypatch,
):
    committing = client(session_id="add_during_commit_lock_test")
    await committing.ensure_exists()
    committing.add_message("user", [TextPart("archive me")])
    adding = client(session_id=committing.session_id)
    await adding.load()
    commit_inside_rewrite = asyncio.Event()
    allow_commit_rewrite = asyncio.Event()
    original_write = committing._write_to_agfs_async

    async def delayed_root_write(messages, *, lease_ref=None):
        commit_inside_rewrite.set()
        await allow_commit_rewrite.wait()
        await original_write(messages, lease_ref=lease_ref)

    class CapturingQueueManager:
        async def enqueue(self, *_args, **_kwargs):
            return None

    monkeypatch.setattr(committing, "_write_to_agfs_async", delayed_root_write)
    monkeypatch.setattr(
        "openviking.storage.queuefs.get_queue_manager",
        lambda: CapturingQueueManager(),
    )
    disabled_policy = {
        "working_memory": {"enabled": False},
        "self": {"enabled": False},
        "peer": {"enabled": False},
    }

    commit_task = asyncio.create_task(committing.commit_async(memory_policy=disabled_policy))
    await commit_inside_rewrite.wait()
    add_task = asyncio.create_task(
        asyncio.to_thread(adding.add_message, "assistant", [TextPart("keep me live")])
    )
    await asyncio.sleep(0.05)
    assert not add_task.done()
    allow_commit_rewrite.set()
    await asyncio.gather(commit_task, add_task)

    fresh = client(session_id=committing.session_id)
    await fresh.load()
    context = await fresh.get_session_context()
    assert [message.content for message in fresh.messages] == ["keep me live"]
    assert [message["parts"][0]["text"] for message in context["messages"]] == [
        "archive me",
        "keep me live",
    ]


async def test_queue_enqueue_failure_keeps_published_archive_and_fails_task(
    client,
    monkeypatch,
):
    session = client(session_id="queue_enqueue_failure_recovery_test")
    await session.ensure_exists()
    session.add_message("user", [TextPart("do not lose me")])

    class FailingQueueManager:
        async def enqueue(self, _queue_name, data):
            raise RuntimeError("queue unavailable")

    monkeypatch.setattr(
        "openviking.storage.queuefs.get_queue_manager",
        lambda: FailingQueueManager(),
    )

    with pytest.raises(InternalError, match="queue unavailable") as error:
        await session.commit_async(record_idle_commit_success=True)

    states = await session._archives.scan_states()
    task = await get_task_tracker().get(
        error.value.details["task_id"],
        account_id=session.ctx.account_id,
        user_id=session.ctx.user.user_id,
    )
    assert error.value.details["archived"] is True
    assert error.value.details["stage"] == "queue_enqueue"
    assert task is not None and task.status is TaskStatus.FAILED
    assert states[0].state == "pending"
    assert (await session._read_phase1_meta(states[0].archive_uri))["status"] == "ready"
    raw = await session._archives.read_messages(states[0].archive_uri)
    assert [message.content for message in raw] == ["do not lose me"]
    assert await session._read_live_messages_strict() == []
    assert not await session._viking_fs.exists(
        f"{states[0].archive_uri}/.failed.json",
        ctx=session.ctx,
    )


async def test_phase1_root_rewrite_failure_marks_orphan_archive_failed(
    client,
    monkeypatch,
):
    session = client(session_id="phase1_root_failure_recovery_test")
    await session.ensure_exists()
    session.add_message("user", [TextPart("archive candidate")])
    session.add_message("assistant", [TextPart("retained tail")])
    original_write = session._write_to_agfs_async

    async def write_then_fail(messages, *, lease_ref=None):
        await original_write(messages, lease_ref=lease_ref)
        raise RuntimeError("synthetic root rewrite failure")

    monkeypatch.setattr(session, "_write_to_agfs_async", write_then_fail)

    with pytest.raises(RuntimeError, match="synthetic root rewrite failure"):
        await session.commit_async(keep_recent_count=1)

    states = await session._archives.scan_states()
    failed = json.loads(
        await session._viking_fs.read_file(
            f"{states[0].archive_uri}/.failed.json",
            ctx=session.ctx,
        )
    )
    fresh = client(session_id=session.session_id)
    await fresh.load()
    context = await fresh.get_session_context()
    assert states[0].state == "failed"
    assert failed["stage"] == "phase1_persist"
    # The orphan archive keeps its raw messages durable on disk and Phase 2 can
    # still roll them forward. The terminal-stop read path, however, no longer
    # replays them as logical live, so only the retained tail is assembled.
    raw = await fresh._archives.read_messages(states[0].archive_uri)
    assert [message.content for message in raw] == ["archive candidate"]
    assert [message["parts"][0]["text"] for message in context["messages"]] == ["retained tail"]


async def test_commit_publication_failure_does_not_block_following_archive(tmp_path, monkeypatch):
    client_type, _ = get_binding_client()
    agfs = client_type()
    agfs.mount("localfs", "/local", {"local_dir": str(tmp_path)})
    agfs.mount("queuefs", "/queue", {"backend": "memory"})
    fs = VikingFS(agfs=agfs)
    tracker = TaskTracker(PersistentTaskStore(agfs))
    monkeypatch.setattr("openviking.service.task_tracker._instance", tracker)
    monkeypatch.setattr("openviking.session.session._enabled_memory_types", lambda: set())
    from openviking.storage.queuefs.queue_manager import QueueManager

    manager = QueueManager(agfs)
    queue = manager.get_queue("SessionCommit", allow_create=True)
    monkeypatch.setattr("openviking.storage.queuefs.get_queue_manager", lambda: manager)
    first = Session(viking_fs=fs, session_id="publication_failure")
    await first.ensure_exists()
    await first.add_message_async("user", [TextPart("archive me")])
    creating, release = asyncio.Event(), asyncio.Event()
    original_create = tracker._store.create

    async def fail_first_registration(task, **kwargs):
        if not creating.is_set():
            creating.set()
            await release.wait()
            raise AGFSIoError("task store unavailable")
        return await original_create(task, **kwargs)

    monkeypatch.setattr(tracker._store, "create", fail_first_registration)
    first_commit = asyncio.create_task(first.commit_async())
    try:
        await asyncio.wait_for(creating.wait(), 2)
        assert await first._read_live_messages_strict() == []
        second = Session(viking_fs=fs, session_id=first.session_id)
        await second.load()
        await second.add_message_async("user", [TextPart("follow-up archive")])
        result = await second.commit_async()
        assert result["status"] == "accepted"
        assert result["archive_uri"].endswith("/archive_002")
        assert len(await queue.snapshot()) == 1
        assert not await second._can_run_archive(2)
        first_archive = f"{first.uri}/history/archive_001"
        assert not await fs.exists(f"{first_archive}/.failed.json", ctx=first.ctx)

        release.set()
        with pytest.raises(UnavailableError, match="task store unavailable") as error:
            await first_commit
        assert error.value.details["archived"] is True
        assert error.value.details["stage"] == "task_tracker_create"
        assert error.value.details["archive_uri"] == first_archive
        assert [
            message.content for message in await first._archives.read_messages(first_archive)
        ] == ["archive me"]
        # The same predecessor must become skippable after its publisher fails.
        assert await second._can_run_archive(2)
        failed = json.loads(await fs.read_file(f"{first_archive}/.failed.json", ctx=first.ctx))
        assert failed["stage"] == "queue_missing"
    finally:
        release.set()
        if not first_commit.done():
            first_commit.cancel()
        await asyncio.gather(first_commit, return_exceptions=True)
        agfs.close()


async def test_interrupted_phase1_recovers_when_root_rewrite_is_durable(
    client,
    monkeypatch,
):
    session = client(session_id="phase1_reconcile_durable_root_test")
    await session.ensure_exists()
    session.meta.memory_policy = {"memory_types": ["profile"]}
    legacy_meta = session.meta.to_dict()
    legacy_meta.update(
        pending_tokens="123", keep_recent_count="1", memories_extracted={"total": "4"}
    )
    await session._viking_fs.write_file(
        f"{session.uri}/.meta.json", json.dumps(legacy_meta), ctx=session.ctx
    )
    original = [
        _text_message("u1", "user", "archive me"),
        _text_message("a1", "assistant", "retain me"),
    ]
    session._messages = original
    await session._write_to_agfs_async(messages=original)
    archive_uri = await _write_archive(session, 1, [original[0]])
    await session._write_phase1_marker(
        archive_uri,
        queue_message={"task_id": "synthetic", "record_auto_commit_success": True},
        original_messages=original,
        archived_messages=[original[0]],
        retained_messages=[original[1]],
        keep_recent_count=1,
        retention_mode=None,
        keep_recent_turn_count=0,
        retained_message_token_budget=0,
        min_raw_tail_steps=1,
    )
    await session._write_to_agfs_async(messages=[original[1]])
    monkeypatch.setattr(
        get_task_tracker(),
        "has_work",
        AsyncMock(side_effect=lambda task_id: task_id == "synthetic"),
    )

    recovering = client(session_id=session.session_id)
    original_read = recovering._viking_fs.read_file
    failed_once = False

    async def transient_meta_read(uri, *args, **kwargs):
        nonlocal failed_once
        if uri == f"{session.uri}/.meta.json" and not failed_once:
            failed_once = True
            raise AGFSIoError("temporary metadata read failure")
        return await original_read(uri, *args, **kwargs)

    monkeypatch.setattr(recovering._viking_fs, "read_file", transient_meta_read)
    assert await recovering._ensure_phase1_ready(archive_uri)
    assert (await recovering._read_phase1_meta(archive_uri))["status"] == "ready"
    assert recovering.meta.message_count == 1
    assert recovering.meta.memory_policy == {"memory_types": ["profile"]}
    assert recovering.meta.memories_extracted == {"total": 4}
    assert recovering.meta.last_auto_commit_at
    persisted = json.loads(
        await recovering._viking_fs.read_file(f"{session.uri}/.meta.json", ctx=recovering.ctx)
    )
    assert persisted["last_auto_commit_at"] == recovering.meta.last_auto_commit_at


async def test_interrupted_phase1_before_root_rewrite_becomes_failed(
    client,
):
    session = client(session_id="phase1_reconcile_original_root_test")
    await session.ensure_exists()
    original = [_text_message("u1", "user", "still live")]
    session._messages = original
    await session._write_to_agfs_async(messages=original)
    archive_uri = await _write_archive(session, 1, original)
    await session._write_phase1_marker(
        archive_uri,
        queue_message={"task_id": "synthetic"},
        original_messages=original,
        archived_messages=original,
        retained_messages=[],
        keep_recent_count=0,
        retention_mode=None,
        keep_recent_turn_count=0,
        retained_message_token_budget=0,
        min_raw_tail_steps=1,
    )

    assert not await session._ensure_phase1_ready(archive_uri)
    states = await session._archives.scan_states()
    context = await session.get_session_context()
    failed = json.loads(
        await session._viking_fs.read_file(f"{archive_uri}/.failed.json", ctx=session.ctx)
    )
    assert states[0].state == "failed"
    assert failed["error"] == "Phase 1 has no QueueFS work to resume"
    assert [message["id"] for message in context["messages"]] == ["u1"]


async def test_stale_worker_uses_lock_snapshot_memory_policy_for_queue_message(
    client,
    monkeypatch,
):
    stale_session = client(session_id="stale_memory_policy_snapshot_test")
    await stale_session.ensure_exists()
    stale_session._agent_evolution_enabled_provider = lambda: False
    stale_session.add_message("user", [TextPart("archive with persisted policy")])
    updater = client(session_id=stale_session.session_id)
    await updater.load()
    updater.meta.memory_policy = {
        "working_memory": {"enabled": False},
        "self": {"enabled": False},
        "peer": {"enabled": False},
    }
    await updater._save_meta()
    queued: list[dict] = []

    class CapturingQueueManager:
        async def enqueue(self, _queue_name, data):
            queued.append(data)

    monkeypatch.setattr(
        "openviking.storage.queuefs.get_queue_manager",
        lambda: CapturingQueueManager(),
    )

    result = await stale_session.commit_async()

    assert result["archived"] is True
    queued_policy = queued[0]["memory_policy"]
    assert {
        key: queued_policy[key] for key in updater.meta.memory_policy
    } == updater.meta.memory_policy
    assert set(queued_policy["memory_types"]).isdisjoint(AGENT_EVOLUTION_MEMORY_TYPES)
    assert "agent_evolution_enabled" not in queued[0]
    archive_meta = json.loads(
        await stale_session._viking_fs.read_file(
            f"{result['archive_uri']}/.meta.json",
            ctx=stale_session.ctx,
        )
    )
    assert archive_meta["agent_evolution"]["enabled"] is False