Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.
Python agent-contextagent-memoryagent-pluginsagentic-ragcontext-databasedsh-pluginknowledge-basememorymemory-managementself-evolvingvector-database
fix(session): avoid duplicate trajectory extraction across cases (#6273)
DuTao3ef6c5f7f6ff
diff --git a/openviking/prompts/templates/memory/trajectories.yaml b/openviking/prompts/templates/memory/trajectories.yamlindex d912beab1..cb2ba82cf 100644--- a/openviking/prompts/templates/memory/trajectories.yaml+++ b/openviking/prompts/templates/memory/trajectories.yaml@@ -35,6 +35,16 @@ fields:Use exactly one of: success, failure, partial, unfinished, unknown.merge_op: immutable+ - name: related_case_ids+ type: string_list+ description: |+ When Candidate Cases are provided, return the IDs of the cases supported by this trajectory in the same extraction response.+ Use only IDs from Candidate Cases; multiple IDs are allowed. Return [] when none match.+ Use the candidate task descriptions only for association. Derive the trajectory from the archived conversation, never invent actions to match a case.+ Do not link every case merely because they share an archive.+ When Candidate Cases are absent, return [] without choosing cases; the system handles single-case association.+ merge_op: immutable+- name: task_querytype: stringdescription: |diff --git a/openviking/session/compressor_v3.py b/openviking/session/compressor_v3.pyindex 698f8c200..cb0e89fbb 100644--- a/openviking/session/compressor_v3.py+++ b/openviking/session/compressor_v3.py@@ -14,7 +14,7 @@ from __future__ import annotationsimport jsonimport re-from dataclasses import dataclass, field+from dataclasses import asdict, dataclass, field, replacefrom datetime import datetime, timezonefrom typing import TYPE_CHECKING, Any, List, Optionalfrom uuid import uuid4@@ -86,6 +86,7 @@ from openviking.session.train import (get_streaming_policy_trainer,make_streaming_policy_trainer_key,)+from openviking.session.train.components.trajectory_analyzer import _evaluation_feedback_messagefrom openviking.storage.viking_fs import get_viking_fsfrom openviking.telemetry import get_current_telemetry, tracerfrom openviking_cli.utils import get_logger@@ -1043,77 +1044,117 @@ class SessionCompressorV3:)case_uri_map = dict(case_uri_by_name or {})-+ evaluator = getattr(self.rollout_analyzer, "evaluator", None)+ extraction_groups: dict[str, list[Rollout]] = {}+ candidates_by_name = {+ case.name: {+ "id": f"c{index + 1}",+ "name": case.name,+ "task_signature": case.task_signature,+ "input": case.input,+ "uri": _case_uri_for_case(case, case_uri_map),+ }+ for index, case in enumerate(cases)+ }for case in cases:- case_uri = _case_uri_for_case(case, case_uri_map)rollout = Rollout(case=case,messages=list(messages),policy_snapshot_id=policy_snapshot_id,)- # Analyze once — trajectories + skill patches co-extracted- analysis = await self.rollout_analyzer.analyze(rollout, analysis_context)-- # Experience path: estimate gradients, then submit to exp trainer- exp_gradients = []- if experiences_allowed:- exp_gradients = await ExperienceGradientEstimator(- viking_fs=viking_fs,- vlm_resolver=self.vlm_resolver,- ).estimate(analysis, exp_trainer.policy_set, gradient_context)- exp_training_result = _trajectory_only_training_result(- analysis=analysis,- rollout=rollout,- policy_set=exp_trainer.policy_set,- )- if exp_gradients:- fallback_trajectory_uris = {- uri- for trajectory in analysis.trajectories- if (uri := str(getattr(trajectory, "uri", "") or ""))- }-- async def commit_experience_batch(- batch_result: RolloutTrainingResult,- *,- _fallback_trajectory_uris: set[str] = fallback_trajectory_uris,- ) -> None:- persisted_result = (- getattr(batch_result, "batch_result", None) or batch_result- )- snapshot_apply_result, experience_trajectory_map = (- _experience_snapshot_provenance(- batch_result,- fallback_trajectory_uris=_fallback_trajectory_uris,- )- )- await _commit_experience_snapshot(- viking_fs,- ctx=ctx,- experience_uris=_visible_experience_snapshot_uris(- plan=persisted_result.plan,- apply_result=snapshot_apply_result,+ if evaluator is not None:+ rollout.evaluation = await evaluator.evaluate(+ rollout, analysis_context.evaluator_context+ )+ feedback = ""+ if rollout.evaluation is not None and analysis_context.inject_evaluation_feedback:+ feedback = _evaluation_feedback_message(rollout.evaluation).content+ extraction_groups.setdefault(feedback, []).append(rollout)++ reported_trajectory_uris: set[str] = set()+ for rollouts in extraction_groups.values():+ rollout = rollouts[0]+ candidates = [candidates_by_name[item.case.name] for item in rollouts]+ case_context = replace(analysis_context, case_candidates=candidates)+ analysis = await self.rollout_analyzer.analyze(rollout, case_context)+ analysis.metadata["case_associations_required"] = len(candidates) > 1+ if collect_memory_diff:+ # Keep every extracted trajectory, including those with no matching case.+ memory_diffs.append(+ await self._build_training_memory_diff(+ training_result=_trajectory_only_training_result(+ analysis=analysis,+ rollout=rollout,+ policy_set=exp_trainer.policy_set,),+ viking_fs=viking_fs,+ ctx=ctx,archive_uri=archive_uri,- experience_trajectory_map=experience_trajectory_map,+ reported_trajectory_uris=reported_trajectory_uris,)+ )- exp_training_result = await exp_trainer.submit_gradients(- exp_gradients,- analysis=analysis,- rollout=rollout,- batch_finalizer=commit_experience_batch,+ # Sharing extraction does not discard case-specific scores used by training.+ training_groups: dict[str, list[Rollout]] = {}+ for item in rollouts:+ evaluation_key = json.dumps(+ asdict(item.evaluation) if item.evaluation is not None else None,+ sort_keys=True,+ default=str,)- if case_uri:- await self._link_case_to_training_outputs(- analysis=analysis,- case_uri=case_uri,- plan=exp_training_result.plan,- apply_result=exp_training_result.apply_result,- ctx=ctx,+ training_groups.setdefault(evaluation_key, []).append(item)++ for training_rollouts in training_groups.values():+ training_rollout = training_rollouts[0]+ trajectories = analysis.trajectories+ if len(training_rollouts) < len(rollouts):+ case_uris = {+ candidates_by_name[item.case.name]["uri"] for item in training_rollouts+ }+ trajectories = [+ trajectory+ for trajectory in trajectories+ if case_uris.intersection(trajectory.metadata.get("case_uris", []))+ ]+ training_analysis = replace(+ analysis,+ evaluation=training_rollout.evaluation or analysis.evaluation,+ trajectories=trajectories,+ )+ exp_training_result = await self._train_commit_analysis(+ analysis=training_analysis,+ rollout=training_rollout,+ trainer=exp_trainer,+ gradient_context=gradient_context,+ experiences_allowed=experiences_allowed,viking_fs=viking_fs,+ ctx=ctx,+ archive_uri=archive_uri,)- # Skill path: co-extracted skill gradients go directly to skill trainer+ for item in training_rollouts:+ case_uri = candidates_by_name[item.case.name]["uri"]+ if case_uri:+ await self._link_case_to_training_outputs(+ analysis=training_analysis,+ case_uri=case_uri,+ plan=exp_training_result.plan,+ apply_result=exp_training_result.apply_result,+ ctx=ctx,+ viking_fs=viking_fs,+ )+ submitted += len(training_rollouts)+ if collect_memory_diff:+ memory_diff = await self._build_training_memory_diff(+ training_result=exp_training_result,+ viking_fs=viking_fs,+ ctx=ctx,+ archive_uri=archive_uri,+ reported_trajectory_uris=reported_trajectory_uris,+ )+ if _memory_diff_has_changes(memory_diff):+ memory_diffs.append(memory_diff)++ # Co-extracted skills are submitted once for this extraction result.if skill_trainer is not None and analysis.gradients:skill_gradients = [g for g in analysis.gradients if _gradient_memory_type(g) == "skills"@@ -1131,25 +1172,10 @@ class SessionCompressorV3:if uri:skill_uris.append(str(uri))- submitted += 1-- if collect_memory_diff:- # Build diff from the strongly typed training result returned by- # submit_gradients. Do not use exp_trainer.last_apply_result here:- # it is only a PolicyApplyResult and does not carry analyses/plan,- # so trajectory and experience diffs would be lost.- memory_diff = await self._build_training_memory_diff(- training_result=exp_training_result,- viking_fs=viking_fs,- ctx=ctx,- archive_uri=archive_uri,- )- if _memory_diff_has_changes(memory_diff):- memory_diffs.append(memory_diff)-tracer.info("Submitted commit case memories to streaming train: "f"case_count={len(cases)} submitted={submitted} "+ f"analysis_count={len(extraction_groups)} "f"skill_submitted={skill_submitted}",console=self.streaming_trainer_config.trace_console,)@@ -1172,6 +1198,55 @@ class SessionCompressorV3:raisereturn {"case_count": len(cases), "submitted": 0, "error": str(exc)}+ async def _train_commit_analysis(+ self,+ *,+ analysis: RolloutAnalysis,+ rollout: Rollout,+ trainer: Any,+ gradient_context: ExperienceGradientContext,+ experiences_allowed: bool,+ viking_fs: Any,+ ctx: RequestContext,+ archive_uri: str,+ ) -> RolloutTrainingResult:+ gradients = []+ if experiences_allowed:+ gradients = await ExperienceGradientEstimator(+ viking_fs=viking_fs,+ vlm_resolver=self.vlm_resolver,+ ).estimate(analysis, trainer.policy_set, gradient_context)+ if not gradients:+ return _trajectory_only_training_result(+ analysis=analysis,+ rollout=rollout,+ policy_set=trainer.policy_set,+ )++ async def commit_experience_batch(batch_result: RolloutTrainingResult) -> None:+ persisted_result = getattr(batch_result, "batch_result", None) or batch_result+ snapshot_apply_result, experience_trajectory_map = _experience_snapshot_provenance(+ batch_result,+ fallback_trajectory_uris={trajectory.uri for trajectory in analysis.trajectories},+ )+ await _commit_experience_snapshot(+ viking_fs,+ ctx=ctx,+ experience_uris=_visible_experience_snapshot_uris(+ plan=persisted_result.plan,+ apply_result=snapshot_apply_result,+ ),+ archive_uri=archive_uri,+ experience_trajectory_map=experience_trajectory_map,+ )++ return await trainer.submit_gradients(+ gradients,+ analysis=analysis,+ rollout=rollout,+ batch_finalizer=commit_experience_batch,+ )+async def _build_training_memory_diff(self,*,@@ -1179,6 +1254,7 @@ class SessionCompressorV3:viking_fs: Any,ctx: RequestContext,archive_uri: str,+ reported_trajectory_uris: set[str] | None = None,) -> dict[str, Any]:adds: list[dict[str, Any]] = []updates: list[dict[str, Any]] = []@@ -1191,6 +1267,10 @@ class SessionCompressorV3:if not uri or uri in seen_trajectory_uris:continueseen_trajectory_uris.add(uri)+ if reported_trajectory_uris is not None:+ if uri in reported_trajectory_uris:+ continue+ reported_trajectory_uris.add(uri)adds.append({"uri": uri,@@ -1845,6 +1925,12 @@ def _case_trajectory_links() -> list[StoredLink]:links: list[StoredLink] = []for trajectory in getattr(analysis, "trajectories", []) or []:+ case_uris = trajectory.metadata.get("case_uris")+ if case_uris is not None:+ if case_uri not in case_uris:+ continue+ elif analysis.metadata.get("case_associations_required"):+ continueuri = str(getattr(trajectory, "uri", "") or "")if not uri or "/memories/trajectories/" not in uri:continuediff --git a/openviking/session/memory/agent_trajectory_context_provider.py b/openviking/session/memory/agent_trajectory_context_provider.pyindex c60015fed..e73a6d980 100644--- a/openviking/session/memory/agent_trajectory_context_provider.py+++ b/openviking/session/memory/agent_trajectory_context_provider.py@@ -9,6 +9,7 @@ co-extract reusable executable skills in the same ReAct pass.from __future__ import annotations+import jsonfrom typing import Any, Dict, Listfrom openviking.server.identity import RequestContext@@ -49,11 +50,13 @@ class AgentTrajectoryContextProvider(SessionExtractContextProvider):*args,include_trajectories: bool = True,include_session_skills: bool = False,+ case_candidates: list[dict[str, Any]] | None = None,**kwargs,):super().__init__(*args, **kwargs)self._include_trajectories = include_trajectoriesself._include_session_skills = include_session_skills+ self.case_candidates = list(case_candidates or [])self._skill_provider = SessionSkillContextProvider(*args, **kwargs)self._sync_skill_provider_state()@@ -103,9 +106,22 @@ class AgentTrajectoryContextProvider(SessionExtractContextProvider):if not isinstance(self.messages, list):logger.warning(f"Expected List[Message], got {type(self.messages)}")return []- return [self._build_conversation_message()]- self._sync_skill_provider_state()- return await self._skill_provider.prefetch()+ messages = [self._build_conversation_message()]+ else:+ self._sync_skill_provider_state()+ messages = await self._skill_provider.prefetch()+ if len(self.case_candidates) > 1:+ candidates = [+ {key: case[key] for key in ("id", "name", "task_signature", "input")}+ for case in self.case_candidates+ ]+ messages.append(+ {+ "role": "user",+ "content": "## Candidate Cases\n" + json.dumps(candidates, ensure_ascii=False),+ }+ )+ return messagesasync def execute_tool(self, tool_call) -> Any:if not self._include_session_skills:diff --git a/openviking/session/memory/extraction_output_protocol/python_protocol.py b/openviking/session/memory/extraction_output_protocol/python_protocol.pyindex 0bce203d6..a697c4084 100644--- a/openviking/session/memory/extraction_output_protocol/python_protocol.py+++ b/openviking/session/memory/extraction_output_protocol/python_protocol.py@@ -1576,6 +1576,7 @@ def _field_type_name(field_type: FieldType) -> str:FieldType.INT64: "int",FieldType.FLOAT32: "float",FieldType.BOOL: "bool",+ FieldType.STRING_LIST: "list[str]",}.get(field_type, "object")diff --git a/openviking/session/memory/memory_updater.py b/openviking/session/memory/memory_updater.pyindex 9aac1d6b1..7e629563a 100644--- a/openviking/session/memory/memory_updater.py+++ b/openviking/session/memory/memory_updater.py@@ -221,6 +221,7 @@ class ExtractContext:*,split_long_text_messages: bool = True,source_archive_uri: str = "",+ extraction_scope: str = "",):if chunk_meta is None:if split_long_text_messages:@@ -232,6 +233,7 @@ class ExtractContext:self.chunk_meta = chunk_metaself.page_id_map = PageIdMap()self.source_archive_uri = (source_archive_uri or "").rstrip("/")+ self.extraction_scope = extraction_scope@classmethoddef _build_extraction_messages(@@ -411,15 +413,18 @@ class ExtractContext:return datetime.now().strftime("%Y%m%d%H%M%S")def get_source_archive_suffix(self) -> str:- """Namespace filenames by their full source archive without exposing its path.+ """Namespace filenames by archive and optional extraction input scope.- Keep legacy naming for callers outside session commits that have no archive.- The suffix is stable across retries, not a new random record identifier.+ Preserve the existing suffix when no scope is supplied. Different scopes+ can hold distinct analyses of the same archive, while retries stay stable."""- if not self.source_archive_uri:+ if not self.source_archive_uri and not self.extraction_scope:return ""- digest = hashlib.sha256(self.source_archive_uri.encode("utf-8")).hexdigest()[:16]- return f"_{digest}"+ digest = hashlib.sha256(self.source_archive_uri.encode("utf-8"))+ if self.extraction_scope:+ digest.update(b"\0")+ digest.update(self.extraction_scope.encode("utf-8"))+ return f"_{digest.hexdigest()[:16]}"def get_event_content(self, ranges_str: str, summary: str | None, ratio_threshold: float = 0.2diff --git a/openviking/session/memory/merge_op/base.py b/openviking/session/memory/merge_op/base.pyindex 413ac6c28..7ba6e2886 100644--- a/openviking/session/memory/merge_op/base.py+++ b/openviking/session/memory/merge_op/base.py@@ -18,6 +18,7 @@ class FieldType(str, Enum):INT64 = "int64"FLOAT32 = "float32"BOOL = "bool"+ STRING_LIST = "string_list"# ============================================================================@@ -29,6 +30,7 @@ _FIELD_TYPE_TO_PYTHON: Dict[FieldType, Type[Any]] = {FieldType.INT64: int,FieldType.FLOAT32: float,FieldType.BOOL: bool,+ FieldType.STRING_LIST: List[str],}@@ -40,7 +42,7 @@ def get_python_type_for_field(field_type: FieldType, default: Type[Any] = str) -default: Default type if field_type is not recognizedReturns:- Corresponding Python type (str, int, float, or bool)+ Corresponding Python type (str, int, float, bool, or List[str])"""return _FIELD_TYPE_TO_PYTHON.get(field_type, default)diff --git a/openviking/session/memory/session_extract_context_provider.py b/openviking/session/memory/session_extract_context_provider.pyindex ef3020e60..58e1fd1d7 100644--- a/openviking/session/memory/session_extract_context_provider.py+++ b/openviking/session/memory/session_extract_context_provider.py@@ -71,10 +71,12 @@ class SessionExtractContextProvider(ExtractContextProvider):vlm_config: Optional["VLMHandle"] = None,*,source_archive_uri: str = "",+ extraction_scope: str = "",):self.messages = list(messages) if isinstance(messages, list) else messagesself.latest_archive_overview = latest_archive_overviewself._source_archive_uri = source_archive_uri+ self._extraction_scope = extraction_scopeself._output_language = self._detect_language()self._registry = memory_registry # Lazy defaults if no account snapshot was supplied.self._schema_directories = None@@ -119,6 +121,7 @@ class SessionExtractContextProvider(ExtractContextProvider):self.messages if isinstance(self.messages, list) else [],split_long_text_messages=self.split_long_text_messages_for_extraction,source_archive_uri=self._source_archive_uri,+ extraction_scope=self._extraction_scope,)return self._extract_contextdiff --git a/openviking/session/train/components/trajectory_analyzer.py b/openviking/session/train/components/trajectory_analyzer.pyindex 6066d670b..ce3e00b38 100644--- a/openviking/session/train/components/trajectory_analyzer.py+++ b/openviking/session/train/components/trajectory_analyzer.py@@ -4,7 +4,7 @@from __future__ import annotations-from dataclasses import dataclass+from dataclasses import dataclass, fieldfrom typing import Anyfrom openviking.config.vlm import VLMResolver@@ -60,6 +60,7 @@ class TrajectoryAnalyzerContext:inject_evaluation_feedback: bool = Trueinclude_session_skills: bool = Falsesource_archive_uri: str = ""+ case_candidates: list[dict[str, Any]] = field(default_factory=list)@dataclass(slots=True)@@ -87,10 +88,11 @@ class TrajectoryRolloutAnalyzer:raise ValueError("TrajectoryAnalyzerContext.request_context is required")evaluation = await self._evaluate_rollout(rollout, context)+ feedback_injected = evaluation is not None and context.inject_evaluation_feedbackextraction_messages = _messages_with_evaluation_feedback(rollout.messages,evaluation=evaluation,- enabled=evaluation is not None and context.inject_evaluation_feedback,+ enabled=feedback_injected,)result = await self.extract_trajectory_memories(messages=extraction_messages,@@ -100,6 +102,9 @@ class TrajectoryRolloutAnalyzer:include_session_skills=context.include_session_skills,case_name=getattr(rollout.case, "name", ""),source_archive_uri=context.source_archive_uri,+ case_candidates=context.case_candidates,+ # Only feedback present in the extraction input changes trajectory identity.+ extraction_scope=extraction_messages[-1].content if feedback_injected else "",)contexts = list((result or {}).get("contexts", []))skill_gradients = list((result or {}).get("skill_gradients", []))@@ -149,6 +154,8 @@ class TrajectoryRolloutAnalyzer:include_session_skills: bool = False,case_name: str = "",source_archive_uri: str = "",+ case_candidates: list[dict[str, Any]] | None = None,+ extraction_scope: str = "",) -> dict[str, list[Any]]:"""Extract trajectory and/or reusable skill operations from rollout messages.@@ -179,6 +186,8 @@ class TrajectoryRolloutAnalyzer:include_session_skills=include_session_skills,vlm_config=vlm_config,source_archive_uri=source_archive_uri,+ case_candidates=case_candidates,+ extraction_scope=extraction_scope,)consumed_experience_uris = collect_read_experience_uris(messages, ctx=ctx)phase_result = await self._run_trajectory_extract_phase(@@ -270,7 +279,11 @@ class TrajectoryRolloutAnalyzer:ctx=ctx,)- _ensure_trajectory_case_name(traj_ops, case_name=case_name)+ _bind_trajectory_cases(+ traj_ops,+ case_name=case_name,+ case_candidates=provider.case_candidates,+ )_apply_trajectory_source_archive_uri(traj_ops, source_archive_uri)memory_result = MemoryUpdateResult()@@ -412,16 +425,37 @@ def _evaluation_from_trajectories(trajectories: list[Trajectory]) -> RubricEvalu)-def _ensure_trajectory_case_name(operations: ResolvedOperations, *, case_name: str) -> None:- case_name = str(case_name or "").strip()- if not case_name:- return+def _bind_trajectory_cases(+ operations: ResolvedOperations,+ *,+ case_name: str,+ case_candidates: list[dict[str, Any]],+) -> None:+ cases_by_id = {case["id"]: case for case in case_candidates}for op in getattr(operations, "upsert_operations", []) or []:if getattr(op, "memory_type", None) != _TRAJECTORY_MEMORY_TYPE:continue- fields = getattr(op, "memory_fields", None)- if isinstance(fields, dict):- fields["case_name"] = case_name+ fields = op.memory_fields+ related_ids = fields.pop("related_case_ids", None) or []+ if not case_candidates:+ if case_name:+ fields["case_name"] = case_name+ continue+ if len(case_candidates) == 1:+ related_ids = list(cases_by_id)+ fields["case_name"] = case_candidates[0]["name"]+ else:+ fields.pop("case_name", None)+ unknown_ids = set(related_ids) - cases_by_id.keys()+ if unknown_ids:+ logger.warning("Ignoring unknown trajectory case IDs: %s", sorted(unknown_ids))+ fields["case_uris"] = list(+ dict.fromkeys(+ cases_by_id[case_id]["uri"]+ for case_id in related_ids+ if case_id in cases_by_id and cases_by_id[case_id]["uri"]+ )+ )def _apply_trajectory_source_archive_uri(diff --git a/tests/session/test_compressor_v3.py b/tests/session/test_compressor_v3.pyindex 81f5ff378..1e11015f3 100644--- a/tests/session/test_compressor_v3.py+++ b/tests/session/test_compressor_v3.py@@ -720,84 +720,6 @@ async def test_train_from_extracted_cases_skips_experience_updates_when_not_alloestimate.assert_not_awaited()-async def test_train_from_extracted_multiple_case_memories_analyzes_bound_rollouts(monkeypatch):- seen_rollouts = []- rollout_messages = _messages()-- class FakeTrainer:- policy_set = ExperienceSet(- root_uri="viking://user/u/memories/experiences",- policies=[],- )-- class FakeAnalyzer:- async def analyze(self, rollout, context):- del context- seen_rollouts.append(rollout)- return RolloutAnalysis(- evaluation=RubricEvaluation(- passed=True,- score=1.0,- criterion_results=[],- feedback=[],- ),- trajectories=[],- gradients=[],- )-- async def fake_estimate_exp_gradients(self, *args, **kwargs):- return []-- 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,- )-- case_a = _training_case()- case_b = Case(- name="case_b",- task_signature="Handle a second extracted case.",- input={"summary": "second case"},- rubric=case_a.rubric,- )-- compressor = SessionCompressorV3(- vikingdb=None,- rollout_analyzer=FakeAnalyzer(),- streaming_trainer_config=StreamingPolicyTrainerConfig(- max_wait_seconds=60,- max_gradients_per_update=8,- ),- )-- result = await compressor.train_from_extracted_cases(- cases=[case_a, case_b],- messages=rollout_messages,- ctx=_ctx(),- session_id="s1",- )-- assert result["case_count"] == 2- assert result["submitted"] == 2- assert [rollout.case.name for rollout in seen_rollouts] == [- "duplicate_booking",- "case_b",- ]- assert [rollout.messages for rollout in seen_rollouts] == [- rollout_messages,- rollout_messages,- ]--@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):diff --git a/tests/session/train/test_commit_case_trajectories.py b/tests/session/train/test_commit_case_trajectories.pynew file mode 100644index 000000000..6d6580460--- /dev/null+++ b/tests/session/train/test_commit_case_trajectories.py@@ -0,0 +1,369 @@+# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.+# SPDX-License-Identifier: AGPL-3.0+"""Core commit outcomes: shared extraction, precise links, and per-case evaluation."""++import json+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.compressor_v3 import SessionCompressorV3+from openviking.session.memory.dataclass import MemoryFile, ResolvedOperation, ResolvedOperations+from openviking.session.memory.utils.memory_file_utils import MemoryFileUtils+from openviking.session.train import (+ Case,+ ExperienceSet,+ PolicyApplyResult,+ PolicyPlanItem,+ PolicyUpdatePlan,+ RolloutTrainingResult,+ Rubric,+ RubricEvaluation,+)+from openviking.session.train.components.trajectory_analyzer import (+ TrajectoryAnalyzerContext,+ TrajectoryRolloutAnalyzer,+)+from openviking_cli.session.user_id import UserIdentifier+++class CommitFS:+ agfs = None++ def __init__(self):+ self.files = {}++ async def read_file(self, uri, ctx=None):+ if uri not in self.files:+ raise FileNotFoundError(uri)+ return self.files[uri]++ async def write_file(self, uri, content, ctx=None, **kwargs):+ self.files[uri] = content++ async def ls(self, *args, **kwargs):+ return []+++class CommitTrainer:+ def __init__(self, fs):+ self.fs = fs+ self.policy_set = ExperienceSet(+ root_uri="viking://user/u/memories/experiences", policies=[]+ )+ self.calls = []++ async def submit_gradients(self, gradients, *, analysis, rollout, batch_finalizer=None):+ self.calls.append((analysis, gradients))+ items = []+ for gradient in gradients:+ after = MemoryFileUtils.write(gradient.after_file)+ uri = gradient.target_uri+ items.append(+ PolicyPlanItem(+ kind="upsert",+ memory_type=gradient.after_file.memory_type,+ target_name=gradient.target_name,+ target_uri=uri,+ before_content=self.fs.files.get(uri),+ after_content=after,+ links=gradient.links,+ )+ )+ self.fs.files[uri] = after+ result = RolloutTrainingResult(+ analyses=[analysis],+ gradients=gradients,+ plan=PolicyUpdatePlan(items=items),+ apply_result=PolicyApplyResult(+ updated_policy_set=self.policy_set,+ written_uris=[item.target_uri for item in items],+ ),+ )+ if batch_finalizer:+ await batch_finalizer(result)+ return result+++def commit_runtime(monkeypatch):+ config = SimpleNamespace(+ output_language_override="",+ language_fallback="en",+ memory=SimpleNamespace(+ eager_prefetch=False,+ prefetch_search_topn=5,+ link_enabled=False,+ custom_templates_dir=None,+ experimental_memory_switch=False,+ maintenance_review_tokens=4096,+ extraction_output_format="json",+ session_skill_extraction_enabled=False,+ ),+ )+ for module in (+ "openviking_cli.utils.config",+ "openviking.session.memory.utils.language",+ "openviking.session.memory.session_extract_context_provider",+ "openviking.session.memory.extract_loop",+ "openviking.session.compressor_v3",+ ):+ monkeypatch.setattr(f"{module}.get_openviking_config", lambda: config)+ fs = CommitFS()+ trainer, skill_trainer = CommitTrainer(fs), CommitTrainer(fs)+ monkeypatch.setattr("openviking.session.compressor_v3.get_viking_fs", lambda: fs)+ monkeypatch.setattr(+ "openviking.session.compressor_v3.get_streaming_policy_trainer",+ AsyncMock(return_value=trainer),+ )+ monkeypatch.setattr(+ SessionCompressorV3, "_get_session_skill_trainer", AsyncMock(return_value=skill_trainer)+ )++ async def experience_output(self, trajectory, context):+ return ResolvedOperations(+ upsert_operations=[+ ResolvedOperation(+ memory_type="experiences",+ uris=[f"{trainer.policy_set.root_uri}/{trajectory.name}.md"],+ old_memory_file_content=None,+ memory_fields={"experience_name": trajectory.name, "content": "Learned lesson"},+ )+ ],+ delete_file_contents=[],+ errors=[],+ )++ monkeypatch.setattr(+ "openviking.session.train.components.gradient_estimator.ExperienceGradientEstimator._run_extract_loop",+ experience_output,+ )+ ctx = RequestContext(user=UserIdentifier.the_default_user("u"), role=Role.ROOT)+ cases = [+ Case(+ name=name,+ task_signature=name,+ input={"summary": name},+ rubric=Rubric(name="r", description="task completed", criteria=[]),+ )+ for name in ("book", "cancel")+ ]+ case_uris = {case.name: f"viking://user/u/memories/cases/{case.name}.md" for case in cases}+ for case in cases:+ uri = case_uris[case.name]+ fs.files[uri] = MemoryFileUtils.write(+ MemoryFile(+ uri=uri,+ memory_type="cases",+ content=case.name,+ extra_fields={"case_name": case.name},+ )+ )+ return SimpleNamespace(+ config=config,+ fs=fs,+ trainer=trainer,+ skill_trainer=skill_trainer,+ ctx=ctx,+ cases=cases,+ case_uris=case_uris,+ )+++def _model_response(rows, output_format, *, skill=False):+ operations = {"trajectories": []}+ for index, (name, ids) in enumerate(rows):+ fields = {+ "trajectory_name": name,+ "outcome": "success",+ "task_query": "Book and cancel",+ "retrieval_anchor": name,+ "content": f"# {name}\nExecution steps",+ "related_case_ids": ids or [],+ }+ operations["trajectories"].append({"page_id": 100 + index, **fields})+ if skill:+ operations["session_skills"] = [+ {+ "page_id": 200,+ "skill_name": "booking",+ "description": "Booking workflow",+ "content": "## Workflow\nVerify the booking first.",+ }+ ]+ if output_format == "json":+ return json.dumps(operations)+ return "\n".join(+ [+ f"sdk.create_{kind}("+ + ", ".join(f"{key}={value!r}" for key, value in fields.items() if key != "page_id")+ + ")"+ for kind, items in operations.items()+ for fields in items+ ]+ + ["sdk.commit()"]+ )+++async def _commit(+ runtime, rows, *, evaluator=None, single=False, output_format="json", skill=False+):+ runtime.config.memory.extraction_output_format = output_format+ runtime.config.memory.session_skill_extraction_enabled = skill+ responses = iter(rows)+ model = SimpleNamespace(+ model="test",+ get_completion_async=AsyncMock(+ side_effect=lambda **kwargs: _model_response(+ next(responses), output_format, skill=skill+ )+ ),+ )+ analyzer = TrajectoryRolloutAnalyzer(viking_fs=runtime.fs, vlm=model, evaluator=evaluator)+ compressor = SessionCompressorV3(+ vikingdb=None,+ rollout_analyzer=analyzer,+ skill_processor=object() if skill else None,+ )+ result = await compressor.train_from_extracted_cases(+ cases=runtime.cases[:1] if single else runtime.cases,+ case_uri_by_name=runtime.case_uris,+ messages=[+ Message(+ id="m",+ role="user",+ parts=[TextPart("Book a trip, then cancel it.")],+ created_at="2026-10-19T00:00:00",+ )+ ],+ ctx=runtime.ctx,+ archive_uri="viking://user/u/sessions/s/history/archive_001",+ collect_memory_diff=True,+ strict_extract_errors=True,+ )+ return result, model.get_completion_async++[email protected]("output_format", ["json", "python"])[email protected]("single", [True, False])+async def test_commit_extracts_once_and_persists_precise_case_links(+ commit_runtime, output_format, single+):+ runtime = commit_runtime+ rows = (+ [("book", None)]+ if single+ else [+ ("book", ["c1"]),+ ("cancel", ["c2"]),+ ("shared", ["c1", "c2"]),+ ("other", []),+ ]+ )+ result, model = await _commit(+ runtime, [rows], single=single, output_format=output_format, skill=True+ )++ assert result["submitted"] == (1 if single else 2)+ assert model.await_count == len(runtime.trainer.calls) == len(runtime.skill_trainer.calls) == 1+ files = {uri: MemoryFileUtils.read(raw, uri=uri) for uri, raw in runtime.fs.files.items()}+ trajectories = {+ mf.extra_fields["trajectory_name"]: mf+ for uri, mf in files.items()+ if "/memories/trajectories/" in uri+ }+ assert set(trajectories) == {name for name, _ in rows}+ for case in runtime.cases[:1] if single else runtime.cases:+ names = {"book"} if single else {case.name, "shared"}+ targets = {link["to_uri"] for link in files[runtime.case_uris[case.name]].links}+ assert targets == {trajectories[name].uri for name in names} | {+ f"{runtime.trainer.policy_set.root_uri}/{name}.md" for name in names+ }+ assert all(+ any(link["from_uri"] == runtime.case_uris[case.name] for link in files[uri].backlinks)+ for uri in targets+ )+ assert all("related_case_ids" not in mf.extra_fields for mf in trajectories.values())+ adds = result["memory_diff"]["operations"]["adds"]+ assert len({item["uri"] for item in adds if item["memory_type"] == "trajectories"}) == len(rows)+ assert len([item for item in adds if item["memory_type"] == "trajectories"]) == len(rows)++[email protected]("evaluation_mode", ["same", "different_feedback", "scores_only"])+async def test_commit_preserves_evaluator_training_semantics(+ commit_runtime, monkeypatch, evaluation_mode+):+ runtime = commit_runtime+ same = evaluation_mode == "same"+ evaluations = [+ RubricEvaluation(passed=True, score=1.0, criterion_results=[], feedback=[]),+ RubricEvaluation(+ passed=same, score=1.0 if same else 0.0, criterion_results=[], feedback=[]+ ),+ ]+ evaluator = SimpleNamespace(evaluate=AsyncMock(side_effect=evaluations))+ if evaluation_mode == "scores_only":+ monkeypatch.setattr(+ "openviking.session.compressor_v3.TrajectoryAnalyzerContext",+ lambda **kwargs: TrajectoryAnalyzerContext(**kwargs, inject_evaluation_feedback=False),+ )+ separate_extraction = evaluation_mode == "different_feedback"+ rows = (+ [[("shared", None)], [("shared", None)]]+ if separate_extraction+ else [+ [+ ("book", ["c1"]),+ ("cancel", ["c2"]),+ ("shared", ["c1", "c2"]),+ ("other", []),+ ]+ ]+ )+ result, model = await _commit(runtime, rows, evaluator=evaluator)++ assert result["submitted"] == evaluator.evaluate.await_count == 2+ assert model.await_count == (2 if separate_extraction else 1)+ calls = runtime.trainer.calls+ assert [analysis.evaluation.score for analysis, _ in calls] == ([1.0] if same else [1.0, 0.0])+ assert [gradients[0].confidence for _, gradients in calls] == pytest.approx(+ [0.9] if same else [0.9, 0.7]+ )+ expected_training = (+ [{"book", "cancel", "shared", "other"}]+ if same+ else (+ [{"shared"}, {"shared"}]+ if separate_extraction+ else [{"book", "shared"}, {"cancel", "shared"}]+ )+ )+ assert [{t.name for t in analysis.trajectories} for analysis, _ in calls] == expected_training+ adds = result["memory_diff"]["operations"]["adds"]+ assert len([item for item in adds if item["memory_type"] == "trajectories"]) == sum(+ map(len, rows)+ )+ case_trajectories = []+ for case in runtime.cases:+ uri = runtime.case_uris[case.name]+ mf = MemoryFileUtils.read(runtime.fs.files[uri], uri=uri)+ expected_names = {"shared"} if separate_extraction else {case.name, "shared"}+ assert {+ link["to_uri"] for link in mf.links if "/memories/experiences/" in link["to_uri"]+ } == {f"{runtime.trainer.policy_set.root_uri}/{name}.md" for name in expected_names}+ trajectory_uris = {+ link["to_uri"] for link in mf.links if "/memories/trajectories/" in link["to_uri"]+ }+ case_trajectories.append(trajectory_uris)+ if separate_extraction:+ assert len(trajectory_uris) == 1+ trajectory_uri = next(iter(trajectory_uris))+ trajectory = MemoryFileUtils.read(runtime.fs.files[trajectory_uri], uri=trajectory_uri)+ assert trajectory.extra_fields["case_uris"] == [uri]+ if separate_extraction:+ assert case_trajectories[0].isdisjoint(case_trajectories[1])