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
feat(skill): Add extracting skills from session commit processing (#2182)
DuTao96431c17b458
diff --git a/examples/ov.conf.example b/examples/ov.conf.exampleindex 4860cbb07..e6254f63a 100644--- a/examples/ov.conf.example+++ b/examples/ov.conf.example@@ -155,7 +155,12 @@"default_search_limit": 3,"enable_memory_decay": true,"memory_decay_check_interval": 3600,- "memory": {"version": "v2", "extraction_enabled": true, "enable_role_id_memory_isolate": false},+ "memory": {+ "version": "v2",+ "extraction_enabled": true,+ "session_skill_extraction_enabled": false,+ "enable_role_id_memory_isolate": false,+ },"log": {"level": "INFO","format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s",diff --git a/openviking/core/skill_loader.py b/openviking/core/skill_loader.pyindex 4e85c8d07..1ee799b56 100644--- a/openviking/core/skill_loader.py+++ b/openviking/core/skill_loader.py@@ -66,6 +66,14 @@ class SkillLoader:"description": skill_dict.get("description", ""),}+ allowed_tools = skill_dict.get("allowed_tools") or skill_dict.get("allowed-tools") or []+ if allowed_tools:+ frontmatter["allowed-tools"] = allowed_tools++ tags = skill_dict.get("tags") or []+ if tags:+ frontmatter["tags"] = tags+yaml_str = yaml.dump(frontmatter, allow_unicode=True, sort_keys=False)return f"---\n{yaml_str}---\n\n{skill_dict.get('content', '')}"diff --git a/openviking/prompts/templates/skill_extract/session_skills.yaml b/openviking/prompts/templates/skill_extract/session_skills.yamlnew file mode 100644index 000000000..edbf8a0e5--- /dev/null+++ b/openviking/prompts/templates/skill_extract/session_skills.yaml@@ -0,0 +1,185 @@+memory_type: session_skills+description: |+ # 任务+ 你的任务是基于对话记录,记录下用户主动要求记录的会话技能,步骤规范如下:+ 一、提取内容的识别规则+ (一)显式指令识别规则+ 1. 触发词识别:识别 “以后”“今后”“每次” 等时间类触发词,判定为长期记忆指令。+ 2. 规范性表达识别:识别 “按照...”“遵循...” 等表述,提取其中的规范要求作为记忆规则。+ 3. 直接请求识别:识别 “记住”“别忘了” 等直接记忆请求,明确需记忆的核心内容。+ (二)隐式指令识别规则+ 1. 修正意图识别:从用户对之前回应的修正内容中,提取用户偏好并判定为可记忆规则。+ 2. 重复模式识别:当用户在不同时间(如不同日期)多次重复相同要求(≥3 次),自动识别为隐式记忆指令。+ (三)可记忆性判断规则+ 1. 时间 / 范围限定判断:含 “今天”“这次” 等一次性时间限定的为临时要求,不记忆;含 “所有”“每次” 等无时间限制或范围宽泛表述的为长期规范,需记忆。+ 2. 内容类型判断:具体题目答案、单次任务结果等具体内容不记忆;选择题标注答案、逐选项分析等通用规则需记忆。+ 3. 适用范围判断:表述模糊(如 “要详细一点”)、适用范围不明确的,需向用户确认后再判断是否记忆。+ (四)增量更新识别规则+ 1. 新增意图识别:通过 “对了” 等关键词识别用户追加规则的意图,检查与现有规则的兼容性后整合。+ 2. 修正意图识别:通过 “不对”“改一下” 等关键词识别规则修正意图,精准定位被修改的原规则。+ 3. 删除意图识别:通过 “不需要”“取消” 等关键词识别规则删除意图,同时检查被删除规则是否有依赖规则。+ (五)冲突识别规则+ 1. 直接矛盾识别:新规则与现有规则存在明显对立表述(如 “简洁” vs “详细”),判定为直接冲突。+ 2. 逻辑冲突识别:结合场景计算后出现矛盾(如单选项 100 字 + 要求与总解析 300 字限制),判定为逻辑冲突。+ 3. 范围冲突识别:全局规则与具体任务规则存在格式、要求等冲突(如全局 Markdown 格式与 PPT 制作的 PPTX 格式),判定为范围冲突。+ (六)任务匹配识别规则+ 1. 任务类型识别:明确当前任务的核心类型(如题目分析、周报撰写)和所属领域(如医学、财务),匹配对应记忆规则。+ 2. 相似度分级判断:任务类型与记忆规则完全一致(如医学题分析匹配医学题规则)为高相似度(95%+),直接应用;任务类型相似(如月度总结匹配周报规则)为中等相似度(60-80%),需用户确认后应用;任务类型无关(如写邮件匹配医学题规则)为低相似度(<30%),不应用。+ 二、提取内容的格式规范+ (一)指令提取格式规范+ 1. 约束条件格式:需明确 “约束类型 + 具体要求”,如 “语气约束:正式、专业”“表达约束:简洁,避免冗余”。+ 2. 格式要求格式:按 “格式类型 + 具体规范” 提取,如 “Markdown 格式:表格用三线表、代码需高亮”。+ 3. 处理步骤格式:按 “步骤序号 + 步骤内容” 提取,保持原顺序,标注 “处理流程类”,如 “步骤 1:识别题型;步骤 2:列知识点;步骤 3:逐步解析;步骤 4:给类似题”。+ 4. 质量标准格式:按 “标准类型 + 具体要求” 提取,标注 “质量标准类”,如 “清晰度标准:易懂、学生可理解;准确性标准:无错误”。+ (二)指令规范化格式规范+ 1. 口语化转标准化:将 “要那种正式的感觉” 转化为 “语气正式、专业”,“别太啰嗦” 转化为 “表达简洁,避免冗余”,去除口语化表述。+ 2. 模糊表述量化:对 “详细”“几个” 等模糊词,通过询问用户确认后量化,如 “详细→解析长度:80-150 字”“几个→2-3 个”。+ 3. 隐含信息显式化:识别 “上次” 等模糊指代,查找历史记录补全具体内容,明确完整规则,不保留模糊表述。+ 4. 冗余信息处理:合并重复表述,如 “每个选项都要分析,不要把选项混在一起,要一个一个分析” 合并为 “逐选项单独分析”,保留核心语义。+ (三)指令分类格式规范+ 1. 功能分类格式:按 “分类名称:规则内容” 分类,如 “输入处理类:2 条;核心逻辑类:4 条;输出格式类:3 条;约束禁忌类:1 条”。+ 2. 条件分支格式:按 “条件 + 执行动作” 表述,如 “条件 1:选择题→标注答案;条件 2:简答题→给要点”。+ (四)适用范围标注格式规范+ 1. 任务范围格式:明确 “规则内容 + 适用范围 + 排除范围”,如 “规则:标注知识点来源;适用范围:医学题;排除范围:编程题”。+ 2. 条件范围格式:按 “条件 + 规则内容” 表述,如 “条件:小学生作文→规则:鼓励性语言;条件:高中作文→规则:客观专业”。+ 3. 作用域格式:标注 “全局指令 / 具体意图指令”,明确层级关系,如 “全局指令:所有文档都用 Markdown;具体意图指令:周报要包含三部分”。+ (五)冲突解决格式规范+ 1. 条件分支解决格式:按 “场景 + 规则内容” 明确分支,如 “正确选项:简洁(30-50 字);错误选项:详细解释(80-120 字)”。+ 2. 优先级标注格式:明确 “优先级顺序:当前指令> 任务规则 > 全局规则”,标注执行方式和记忆保留策略。+ 3. 范围细化格式:细化规则条件和要求,确保无逻辑冲突,如 “关键选项(正确选项 + 易错选项):80 字;其他选项:40 字”。+ 三、例子+ (一)显式指令识别例子+ - 输入:“以后分析医学题时,都要标注知识点来源”+ - 识别结果:显式指令(触发词 “以后”),提取规则 “标注知识点来源”,判定可记忆,适用范围为医学题分析。+ (二)隐式指令识别例子+ - 输入:+ - 轮次 1 用户:“帮我分析这道题”+ - 轮次 1 Agent:[给出未解释错误选项的分析]+ - 轮次 2 用户:“不对,错误选项要解释为什么错”+ - 识别结果:隐式指令(用户修正),判定可记忆,询问用户 “您希望以后分析题目时,都这样处理错误选项吗?”+ (三)可记忆性判断例子+ - 例子 1(一次性要求):+ - 输入:“今天的报告要加上财务数据”+ - 判断结果:一次性要求(时间限定 “今天”),不记忆。+ - 例子 2(长期规范):+ - 输入:“所有报告都要包含财务数据”+ - 判断结果:长期规范(范围 “所有”),记忆。+ - 例子 3(模糊表述):+ - 输入:“要详细一点”+ - 判断结果:适用范围不明,询问用户 “您是指所有任务都要详细,还是只针对某类任务?”+ (四)指令提取与规范化例子+ - 输入:“要那种正式的感觉,别太啰嗦,重点突出”+ - 提取结果:+ - 规则 1:语气约束:正式、专业+ - 规则 2:表达约束:简洁,避免冗余+ - 规则 3:格式要求:重点内容前置或加粗强调+ - 规范化结果:去除口语化表述,明确约束类型和具体要求。+ (五)增量更新例子+ - 例子 1(新增规则):+ - 现有记忆:规则 1 “逐选项分析”,规则 2 “标注来源”+ - 输入:“对了,错误选项要指出常见误区”+ - 处理结果:识别追加意图,新增规则 3 “错误选项标注常见误区”,与现有规则无冲突,整合为规则 1-2-3。+ - 例子 2(修正规则):+ - 现有:“解析长度:50 字以内”+ - 输入:“不对,应该是 50-100 字”+ - 处理结果:识别修正意图,定位 “解析长度” 规则,替换为 “50-100 字”,验证与其他规则一致性。+ (六)冲突处理例子+ - 输入:+ - 现有:“解析要简洁”+ - 新增:“错误选项要详细解释”+ - 冲突检测:直接冲突(“简洁” vs “详细”)+ - 解决询问:“您之前要求简洁,现在又要详细解释错误选项,您希望:A. 只有错误选项详细,其他部分简洁;B. 根据情况灵活处理;C. 修改之前的 ' 简洁 ' 要求”+ - 最终规则(用户选 A):“正确选项:简洁(30-50 字);错误选项:详细解释(80-120 字)”+ (七)任务匹配与记忆应用例子+ - 例子 1(高相似度匹配):+ - 记忆:医学题分析规则(标注来源、逐选项分析等)+ - 输入:“帮我分析这道药理学题目”+ - 匹配结果:相似度 95%+,直接应用医学题分析规则。+ - 例子 2(跨会话一致性应用):+ - Day1:用户设定规则 “解析 50-100 字,标注来源”+ - Day3:输入 “分析这道新题”+ - Day7:输入 “再分析一道题”+ - 应用结果:Day3 和 Day7 自动应用 Day1 的规则,三次输出格式、细节保持一致。+directory: "viking://agent/{{ agent_space }}/skills"+filename_template: "{{ skill_name }}/SKILL.md"+enabled: true+fields:+ - name: skill_name+ type: string+ description: |+ # 内容+ 可应用上该可Skill的场景描述的中文名+ # 注意事项+ (1)要尽可能的精简,避免使用复杂的描述词汇。不超过12个字符;+ (2)不得为空。+ # 例子+ ## 好例子+ - 订单处理流程+ ## 坏例子+ - 订单处理的详细流程,尤其是退款订单+ merge_op: immutable++ - name: description+ type: string+ description: |+ # 内容 简要介绍该技能功能或应用场景+ # 注意事项 (1)输出必须是通用的,不涉及具体要求;(2)不超过30字符;+ # 例子+ ## 好例子+ - 分析用户常识问题时的详细步骤,尤其是地理问题 胃痛症状如何进行分析和处理,包括检查症状、咨询医生、建议治疗等步骤。+ ## 坏例子+ - 用户反馈快递未收到但系统显示已完成,要求解决问题(拿到货或退款),并询问订单12346配送情况+ merge_op: replace++ - name: content+ type: string+ description: |+ # 内容+ 该Skill的完整信息,必须与从用户和模型的对话记录中提取的信息保持一致。++ # 输出格式+ 1.必须以连续的Markdown字符串格式进行输出;+ 2.可参考给出的格式说明,部分章节可按情况调整++ # 详细格式和说明:参考如下<md>标签里的示例Markdown内容+ <md>+ [简要介绍该技能及其重要性]+ ## 核心规范+ - [核心主题 1]+ - [核心主题 2]+ ## 使用该Skill的场景+ - [场景 1]+ - [场景 2]+ ## 实现指南+ ### 先决条件+ - [所需的知识或者环境、配置]+ ### 技术和方法+ [详细说明如何运用此技能]+ ### 应用场景示例+ [来自原始材料的具体实例]+ ## 核心要点+ - [要点 1]+ - [要点 2]+ </md>++ # 正确输出参考如下<example>标签里的内容+ <example>+ 本技能用于规范物理电路计算题的解答流程,确保解答的准确性和规范性。+ ## 核心规范+ - 解答物理电路计算题需按标准格式进行+ - 标准格式包含电路分析、列公式、计算和输出结果四个步骤+ ## 使用该Skill的场景+ - 解答物理电路计算题时+ ## 实现指南+ ### 先决条件+ - 掌握物理电路的基本概念和公式+ ### 技术和方法+ 1. 【电路分析】:用文字描述连接方式(串联/并联);+ 2. 【公式】:列出使用的原始公式;+ ### 应用场景示例+ 当遇到物理电路计算题时,按照上述四个步骤进行解答。+ ## 核心要点+ - 严格按照四个步骤解答+ - 计算过程不带单位,结果带单位+ </example>+ merge_op: patchdiff --git a/openviking/service/core.py b/openviking/service/core.pyindex 2792143f1..8bdd91ef3 100644--- a/openviking/service/core.py+++ b/openviking/service/core.py@@ -321,7 +321,10 @@ class OpenVikingService:vikingdb=self._vikingdb_manager,privacy_config_service=self._privacy_config_service,)- self._session_compressor = create_session_compressor(vikingdb=self._vikingdb_manager)+ self._session_compressor = create_session_compressor(+ vikingdb=self._vikingdb_manager,+ skill_processor=self._skill_processor,+ )# Start LockManager if initializedif self._lock_manager:diff --git a/openviking/session/__init__.py b/openviking/session/__init__.pyindex 8d87f4a58..52d501c0f 100644--- a/openviking/session/__init__.py+++ b/openviking/session/__init__.py@@ -34,6 +34,7 @@ logger = get_logger(__name__)def create_session_compressor(vikingdb: VikingDBManager,memory_version: Optional[str] = None,+ skill_processor=None,) -> SessionCompressor:"""Create a SessionCompressor instance based on configuration.@@ -60,14 +61,14 @@ def create_session_compressor(try:from openviking.session.compressor_v2 import SessionCompressorV2- return SessionCompressorV2(vikingdb=vikingdb)+ return SessionCompressorV2(vikingdb=vikingdb, skill_processor=skill_processor)except Exception as e:logger.warning(f"Failed to load v2 compressor, falling back to v1: {e}")- return SessionCompressor(vikingdb=vikingdb)+ return SessionCompressor(vikingdb=vikingdb, skill_processor=skill_processor)# Default to v1logger.info("Using v1 memory compressor (legacy)")- return SessionCompressor(vikingdb=vikingdb)+ return SessionCompressor(vikingdb=vikingdb, skill_processor=skill_processor)__all__ = [diff --git a/openviking/session/compressor.py b/openviking/session/compressor.pyindex 0938155b8..22636aada 100644--- a/openviking/session/compressor.py+++ b/openviking/session/compressor.py@@ -18,6 +18,7 @@ from openviking.storage import VikingDBManagerfrom openviking.storage.viking_fs import get_viking_fsfrom openviking.telemetry import get_current_telemetryfrom openviking.telemetry.request_wait_tracker import get_request_wait_tracker+from openviking.utils.skill_processor import SkillProcessorfrom openviking_cli.session.user_id import UserIdentifierfrom openviking_cli.utils import get_logger@@ -64,11 +65,13 @@ class SessionCompressor:def __init__(self,vikingdb: VikingDBManager,+ skill_processor: Optional[SkillProcessor] = None,):"""Initialize session compressor."""self.vikingdb = vikingdbself.extractor = MemoryExtractor()self.deduplicator = MemoryDeduplicator(vikingdb=vikingdb)+ self.skill_processor = skill_processorself._pending_semantic_changes: Dict[str, Dict[str, set]] = {}def _record_semantic_change(diff --git a/openviking/session/compressor_v2.py b/openviking/session/compressor_v2.pyindex a00756ac6..9a4e6b3e3 100644--- a/openviking/session/compressor_v2.py+++ b/openviking/session/compressor_v2.py@@ -22,13 +22,16 @@ from openviking.server.identity import RequestContextfrom openviking.session.memory import ExtractLoop, MemoryUpdaterfrom openviking.session.memory.dataclass import ResolvedOperationsfrom openviking.session.memory.memory_isolation_handler import MemoryIsolationHandler-from openviking.session.memory.memory_updater import MemoryUpdateResult+from openviking.session.memory.memory_updater import ExtractContext, MemoryUpdateResultfrom openviking.session.memory.utils.json_parser import JsonUtilsfrom openviking.session.memory.utils.memory_file_utils import MemoryFileUtilsfrom openviking.session.memory.utils.uri import render_template+from openviking.session.skill import SkillOperationUpdater, dedup_session_skill_operations+from openviking.session.skill.session_skill_context_provider import SESSION_SKILL_MEMORY_TYPEfrom openviking.storage import VikingDBManagerfrom openviking.storage.viking_fs import VikingFS, get_viking_fsfrom openviking.telemetry import get_current_telemetry, tracer+from openviking.utils.skill_processor import SkillProcessorfrom openviking_cli.session.user_id import UserIdentifierfrom openviking_cli.utils import get_loggerfrom openviking_cli.utils.config import get_openviking_config@@ -120,9 +123,11 @@ class SessionCompressorV2:def __init__(self,vikingdb: VikingDBManager,+ skill_processor: Optional[SkillProcessor] = None,):"""Initialize session compressor."""self.vikingdb = vikingdb+ self.skill_processor = skill_processordef _get_or_create_react(self,@@ -172,6 +177,43 @@ class SessionCompressorV2:registry=registry, vikingdb=self.vikingdb, transaction_handle=transaction_handle)+ def _split_operations_by_memory_type(+ self,+ operations: ResolvedOperations,+ ) -> tuple[ResolvedOperations, ResolvedOperations, list[str]]:+ memory_upserts = []+ skill_upserts = []+ for operation in operations.upsert_operations:+ if operation.memory_type == SESSION_SKILL_MEMORY_TYPE:+ skill_upserts.append(operation)+ else:+ memory_upserts.append(operation)++ memory_deletes = []+ unsupported_skill_deletes = []+ for delete_file in operations.delete_file_contents:+ if delete_file.uri.endswith("/SKILL.md") and "/skills/" in delete_file.uri:+ unsupported_skill_deletes.append(delete_file.uri)+ else:+ memory_deletes.append(delete_file)++ operation_errors = list(getattr(operations, "errors", []))+ return (+ ResolvedOperations(+ upsert_operations=memory_upserts,+ delete_file_contents=memory_deletes,+ errors=list(operation_errors),+ resolved_links=list(getattr(operations, "resolved_links", [])),+ ),+ ResolvedOperations(+ upsert_operations=skill_upserts,+ delete_file_contents=[],+ errors=list(operation_errors),+ resolved_links=[],+ ),+ unsupported_skill_deletes,+ )+@tracer()async def extract_long_term_memories(self,@@ -406,20 +448,20 @@ class SessionCompressorV2:messages: List[Message],ctx: Optional[RequestContext] = None,strict_extract_errors: bool = False,- ) -> List[Context]:- """Two-phase agent-scope memory extraction (trajectory + experience).-- Phase 1: extract execution trajectories from the conversation and persist them.- Phase 2: for each newly written trajectory, decide whether to update an existing- experience, create a new one, or do nothing.-- Gated by `config.memory.agent_memory_enabled`. Returns [] when disabled.- """+ latest_archive_overview: str = "",+ archive_uri: str = "",+ ) -> Dict[str, List[Any]]:+ """Two-phase agent-scope extraction for trajectories, experiences, and session skills."""config = get_openviking_config()- if not getattr(config.memory, "agent_memory_enabled", False):- return []+ include_trajectories = bool(getattr(config.memory, "agent_memory_enabled", False))+ include_session_skills = bool(+ getattr(config.memory, "session_skill_extraction_enabled", False)+ )+ empty_result: Dict[str, List[Any]] = {"contexts": [], "session_skills": []}+ if not (include_trajectories or include_session_skills):+ return empty_resultif not messages or not ctx:- return []+ return empty_resultfrom openviking.session.memory.agent_experience_context_provider import (AgentExperienceContextProvider,@@ -429,9 +471,15 @@ class SessionCompressorV2:)contexts: List[Context] = []+ session_skill_results: List[Dict[str, Any]] = []- # Phase 1: trajectory extraction- traj_provider = AgentTrajectoryContextProvider(messages=messages)+ # Phase 1: trajectory extraction, optionally co-extracting session skills.+ traj_provider = AgentTrajectoryContextProvider(+ messages=messages,+ latest_archive_overview=latest_archive_overview,+ include_trajectories=include_trajectories,+ include_session_skills=include_session_skills,+ )traj_result = await self._run_extract_phase(provider=traj_provider,messages=messages,@@ -440,26 +488,32 @@ class SessionCompressorV2:phase_label="trajectory",)if traj_result is None:- return []+ return empty_result- written_trajectory_uris, _, traj_contexts, _ = traj_result+ written_trajectory_uris, _, traj_contexts, _, traj_skill_results = traj_resultcontexts.extend(traj_contexts)+ if archive_uri:+ for item in traj_skill_results:+ item["archive_uri"] = archive_uri+ session_skill_results.extend(traj_skill_results)# Deduplicate: LLM may output the same trajectory_name twice in one call,# producing identical URIs. Without this, experience extraction would run# once per duplicate and generate near-identical experiences.written_trajectory_uris = list(dict.fromkeys(written_trajectory_uris))- if not written_trajectory_uris:- tracer.info("No trajectories extracted; skipping experience phase")- return contexts+ if not include_trajectories or not written_trajectory_uris:+ if not written_trajectory_uris:+ tracer.info("No trajectories extracted; skipping experience phase")+ return {+ "contexts": contexts,+ "session_skills": session_skill_results,+ }# Phase 2: for each new trajectory, consolidate into experiences.viking_fs = get_viking_fs()for traj_uri in written_trajectory_uris:try:- from openviking.session.memory.utils.memory_file_utils import MemoryFileUtils-mf = MemoryFileUtils.read(await viking_fs.read_file(traj_uri, ctx=ctx) or "")traj_content = mf.contentexcept Exception as e:@@ -507,7 +561,6 @@ class SessionCompressorV2:phase_label=f"experience({traj_uri})",post_apply=_append_sources_before_unlock,)-if exp_result is None:fallback_uris = await self._single_existing_experience_uris(exp_dir=exp_dir,@@ -523,10 +576,12 @@ class SessionCompressorV2:)continue- _, _, exp_contexts, _ = exp_result+ _, _, exp_contexts, _, _ = exp_resultcontexts.extend(exp_contexts)-- return contexts+ return {+ "contexts": contexts,+ "session_skills": session_skill_results,+ }async def _resolve_source_target_experience_uris(self,@@ -604,13 +659,13 @@ class SessionCompressorV2:):"""Run one ExtractLoop phase with its own lock scope, then apply operations.- Returns (written_uris, edited_uris, contexts, inheritance_map) on success,- where inheritance_map maps new experience URI → inherited source_trajectory URIs- (only populated for experiences that supersede an existing one).+ Returns (written_uris, edited_uris, contexts, inheritance_map, session_skill_results)+ on success, where inheritance_map maps new experience URI → inherited+ source_trajectory URIs (only populated for experiences that supersede an+ existing one).Returns None on failure (unless strict_extract_errors is True, in which casethe exception is re-raised)."""- from openviking.session.memory.memory_updater import ExtractContextfrom openviking.storage.transaction import get_lock_manager, init_lock_managerconfig = get_openviking_config()@@ -645,7 +700,11 @@ class SessionCompressorV2:try:if lock_manager:- schemas = provider.get_memory_schemas(ctx)+ schemas = [+ schema+ for schema in provider.get_memory_schemas(ctx)+ if getattr(schema, "memory_type", None) != SESSION_SKILL_MEMORY_TYPE+ ]user_ids = [ctx.user.user_id] if ctx and ctx.user else ["default"]agent_ids = [ctx.user.agent_id] if ctx and ctx.user else ["default"]exact_lock_paths, tree_lock_dirs = _render_memory_schema_locks(@@ -690,7 +749,7 @@ class SessionCompressorV2:if operations is None:tracer.info(f"[{phase_label}] No memory operations generated")- return [], [], [], {}+ return [], [], [], {}, []# Log raw LLM operations before applying._op_items = [@@ -707,33 +766,78 @@ class SessionCompressorV2:# superseding experience inherits the old source_trajectories.inheritance_map = await self._resolve_supersedes(operations, ctx, viking_fs, provider)- registry = provider._get_registry()- updater = self._get_or_create_updater(registry, transaction_handle)- result = await updater.apply_operations(- operations,- ctx,- extract_context=extract_context,- isolation_handler=isolation_handler,+ memory_operations, skill_operations, unsupported_skill_deletes = (+ self._split_operations_by_memory_type(operations))+ if unsupported_skill_deletes:+ logger.warning(+ "[%s] Ignoring unsupported session skill deletes: %s",+ phase_label,+ unsupported_skill_deletes,+ )++ memory_result = MemoryUpdateResult()+ if (+ memory_operations.upsert_operations+ or memory_operations.delete_file_contents+ or memory_operations.errors+ ):+ registry = provider._get_registry()+ updater = self._get_or_create_updater(registry, transaction_handle)+ memory_result = await updater.apply_operations(+ memory_operations,+ ctx,+ extract_context=extract_context,+ isolation_handler=isolation_handler,+ )tracer.info(- f"[{phase_label}] Applied: written={len(result.written_uris)}, "- f"edited={len(result.edited_uris)}, deleted={len(result.deleted_uris)}, "- f"errors={len(result.errors)}"+ f"[{phase_label}] Applied memory ops: written={len(memory_result.written_uris)}, "+ f"edited={len(memory_result.edited_uris)}, deleted={len(memory_result.deleted_uris)}, "+ f"errors={len(memory_result.errors)}")if post_apply:- await post_apply(result, inheritance_map, transaction_handle)+ await post_apply(memory_result, inheritance_map, transaction_handle)++ skill_results: List[Dict[str, Any]] = []+ if skill_operations.upsert_operations:+ if not self.skill_processor:+ raise RuntimeError("SkillProcessor is required for session skill extraction")+ skill_operations = dedup_session_skill_operations(skill_operations)+ skill_updater = SkillOperationUpdater(+ registry=provider._get_registry(),+ skill_processor=self.skill_processor,+ viking_fs=viking_fs,+ )+ skill_result = await skill_updater.apply_operations(skill_operations, ctx)+ tracer.info(+ f"[{phase_label}] Applied session skill ops: written={len(skill_result.written_uris)}, "+ f"edited={len(skill_result.edited_uris)}, errors={len(skill_result.errors)}"+ )+ if skill_result.errors:+ logger.warning(+ "[%s] Session skill extraction completed with %d errors",+ phase_label,+ len(skill_result.errors),+ )+ skill_results = list(skill_result.operation_results)contexts: List[Context] = []- for uri in result.written_uris:+ for uri in memory_result.written_uris:contexts.append(Context(uri=uri, category="memory_write", context_type="memory"))- for uri in result.edited_uris:+ for uri in memory_result.edited_uris:contexts.append(Context(uri=uri, category="memory_edit", context_type="memory"))- for uri in result.deleted_uris:+ for uri in memory_result.deleted_uris:contexts.append(Context(uri=uri, category="memory_delete", context_type="memory"))- return list(result.written_uris), list(result.edited_uris), contexts, inheritance_map+ return (+ list(memory_result.written_uris),+ list(memory_result.edited_uris),+ contexts,+ inheritance_map,+ skill_results,+ )except Exception as e:logger.error(f"[{phase_label}] Failed to extract: {e}", exc_info=True)if strict_extract_errors:diff --git a/openviking/session/memory/agent_trajectory_context_provider.py b/openviking/session/memory/agent_trajectory_context_provider.pyindex 1b8cd42cf..37253f46c 100644--- a/openviking/session/memory/agent_trajectory_context_provider.py+++ b/openviking/session/memory/agent_trajectory_context_provider.py@@ -1,63 +1,126 @@# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.# SPDX-License-Identifier: AGPL-3.0"""-Agent Trajectory Context Provider - Phase 1 of agent-scope memory extraction.+Agent Trajectory Context Provider - Phase 1 of agent-scope extraction.-Extracts execution trajectory summaries from the conversation. Only the-`trajectory` schema participates; no existing memories are prefetched because-trajectories are add_only.+Extracts execution trajectories from the conversation and can optionally+co-extract reusable executable skills in the same ReAct pass."""+from __future__ import annotations+from typing import Any, Dict, Listfrom openviking.server.identity import RequestContext-from openviking.session.memory.session_extract_context_provider import (- SessionExtractContextProvider,+from openviking.session.memory.memory_type_registry import MemoryTypeRegistry+from openviking.session.memory.session_extract_context_provider import SessionExtractContextProvider+from openviking.session.skill.session_skill_context_provider import (+ SESSION_SKILL_MEMORY_TYPE,+ SessionSkillContextProvider,+ resolve_skill_extract_templates_dir,)from openviking_cli.utils import get_loggerlogger = get_logger(__name__)-TRAJECTORY_MEMORY_TYPE = "trajectories"class AgentTrajectoryContextProvider(SessionExtractContextProvider):- """Phase 1 provider: extract reusable trajectory-view memories."""+ """Phase 1 provider: extract trajectories and optional session skills."""++ _SHARED_SKILL_STATE = {+ "messages",+ "latest_archive_overview",+ "_output_language",+ "_extract_context",+ "_isolation_handler",+ "_read_file_contents",+ "_ctx",+ "_viking_fs",+ "_transaction_handle",+ }++ def __init__(+ self,+ *args,+ include_trajectories: bool = True,+ include_session_skills: bool = False,+ **kwargs,+ ):+ super().__init__(*args, **kwargs)+ self._include_trajectories = include_trajectories+ self._include_session_skills = include_session_skills+ self._skill_provider = SessionSkillContextProvider(*args, **kwargs)+ self._sync_skill_provider_state()++ def __setattr__(self, name: str, value: Any) -> None:+ super().__setattr__(name, value)+ if name not in self._SHARED_SKILL_STATE:+ return+ skill_provider = self.__dict__.get("_skill_provider")+ if skill_provider is not None:+ setattr(skill_provider, name, value)++ def _sync_skill_provider_state(self, *, include_extract_context: bool = False) -> None:+ skill_provider = getattr(self, "_skill_provider", None)+ if skill_provider is None:+ return+ if include_extract_context and self._extract_context is None:+ self.get_extract_context()+ for attr in self._SHARED_SKILL_STATE:+ setattr(skill_provider, attr, getattr(self, attr))def instruction(self) -> str:- output_language = self._output_language- return f"""You are a memory extraction agent. Convert this session into reusable trajectory-view memories.--Each memory is a compact operation contract for a future agent, not a transcript.-Capture trigger, prerequisites, verified boundaries, procedure, provenance,-anti-patterns, and applicability. Split separate intents, pivots, enabling writes,-and final writes into separate records; omit low-value side work. Use only schema-operation-family enum values, not compound labels. Generalize away raw identifiers,-names, exact dates, amounts, routes, and tool payloads. Do not let a later-operation in the session rename, narrow, or extend an earlier operation record.-Stop each record at its family boundary; do not include a second lifecycle--changing write in the same operation contract.--Output JSON only: {{"trajectories": [...]}}. Include items only for reusable-operation contracts supported by the session. Follow field descriptions in the-schema. All content fields must be written in {output_language}.-"""+ return (+ "You are an extraction agent. Analyze the archived conversation, use read when "+ "needed, and output only JSON that matches the schema descriptions."+ )def get_memory_schemas(self, ctx: RequestContext) -> List[Any]:- """Only expose the trajectory schema."""+ """Expose trajectory schema and optionally session skill schema."""+ del ctxregistry = self._get_registry()- schema = registry.get(TRAJECTORY_MEMORY_TYPE)- if schema is None or not schema.enabled:- return []- return [schema]-- async def prefetch(self) -> List[Dict]:- """Only inject the conversation. Trajectory is add_only so no ls/search."""- if not isinstance(self.messages, list):- logger.warning(f"Expected List[Message], got {type(self.messages)}")- return []- return [self._build_conversation_message()]+ memory_types: List[str] = []+ if self._include_trajectories:+ memory_types.append(TRAJECTORY_MEMORY_TYPE)+ if self._include_session_skills:+ memory_types.append(SESSION_SKILL_MEMORY_TYPE)++ schemas: List[Any] = []+ for memory_type in memory_types:+ schema = registry.get(memory_type)+ if schema is None or not schema.enabled:+ continue+ schemas.append(schema)+ return schemas++ async def prefetch(self) -> List[Dict[str, Any]]:+ if not self._include_session_skills:+ 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()++ async def execute_tool(self, tool_call) -> Any:+ if not self._include_session_skills:+ return await super().execute_tool(tool_call)+ self._sync_skill_provider_state(include_extract_context=True)+ return await self._skill_provider.execute_tool(tool_call)def get_tools(self) -> List[str]:- return []+ return ["read"] if self._include_session_skills else []++ def _get_registry(self) -> MemoryTypeRegistry:+ if self._registry is None:+ registry = MemoryTypeRegistry(load_schemas=self._include_trajectories)+ if self._include_session_skills:+ loaded = registry.load_from_directory(str(resolve_skill_extract_templates_dir()))+ if loaded == 0:+ raise RuntimeError(+ "No session skill schemas loaded from skill_extract templates"+ )+ self._registry = registry+ return self._registrydiff --git a/openviking/session/memory/extract_loop.py b/openviking/session/memory/extract_loop.pyindex 05701baa0..ecd039183 100644--- a/openviking/session/memory/extract_loop.py+++ b/openviking/session/memory/extract_loop.py@@ -166,6 +166,7 @@ class ExtractLoop:import jsonschema_str = json.dumps(json_schema, ensure_ascii=False)+ type_descriptions = self.schema_prompt_generator.generate_type_descriptions()messages = []page_id_rules = """@@ -187,6 +188,7 @@ class ExtractLoop:"role": "system","content": f"""{self.context_provider.instruction()}+{type_descriptions}{page_id_rules}{link_rules}## Read Format Rulesdiff --git a/openviking/session/session.py b/openviking/session/session.pyindex 616f004b5..2988fcac0 100644--- a/openviking/session/session.py+++ b/openviking/session/session.py@@ -1122,6 +1122,7 @@ class Session:request_wait_tracker = get_request_wait_tracker()memories_extracted: Dict[str, int] = {}+ extracted_skill_results: list[dict] = []active_count_updated = 0telemetry = OperationTelemetry(operation="session_commit_phase2", enabled=True)archive_index = self._archive_index_from_uri(archive_uri)@@ -1209,34 +1210,56 @@ class Session:# Summary generation, user memory and agent memory all run concurrently.ov_config = get_openviking_config()- if self._session_compressor and ov_config.memory.extraction_enabled:+ memory_extraction_enabled = ov_config.memory.extraction_enabled+ session_skill_extraction_enabled = (+ ov_config.memory.session_skill_extraction_enabled+ )+ if self._session_compressor and (+ memory_extraction_enabled or session_skill_extraction_enabled+ ):logger.info(- f"Starting memory extraction from {len(messages)} archived messages"+ "Starting post-commit extraction from %s archived messages",+ len(messages),)has_agent_memory = hasattr(self._session_compressor, "extract_agent_memories")- async def _noop_agent():+ async def _noop_list():return []- _results = await asyncio.gather(- _run_archive_summary(),- self._session_compressor.extract_long_term_memories(+ async def _noop_agent_result():+ return {"contexts": [], "session_skills": []}++ async def _run_long_term_memories():+ if not memory_extraction_enabled:+ return []+ return await self._session_compressor.extract_long_term_memories(messages=extraction_messages,user=self.user,session_id=self.session_id,ctx=self.ctx,latest_archive_overview=latest_archive_overview,archive_uri=archive_uri,- ),- self._session_compressor.extract_agent_memories(+ )++ async def _run_agent_memories():+ if not has_agent_memory:+ return {"contexts": [], "session_skills": []}+ if not (memory_extraction_enabled or session_skill_extraction_enabled):+ return {"contexts": [], "session_skills": []}+ return await self._session_compressor.extract_agent_memories(messages=extraction_messages,ctx=self.ctx,+ latest_archive_overview=latest_archive_overview,+ archive_uri=archive_uri,)- if has_agent_memory- else _noop_agent(),++ _results = await asyncio.gather(+ _run_archive_summary(),+ _run_long_term_memories(),+ _run_agent_memories() if has_agent_memory else _noop_agent_result(),return_exceptions=True,)summary_result, extracted_result, agent_result = _results@@ -1251,7 +1274,7 @@ class Session:f"User memory extraction failed: {extracted_result}",exc_info=extracted_result,)- extracted = []+ raise extracted_resultelse:extracted = extracted_result@@ -1261,15 +1284,18 @@ class Session:exc_info=agent_result,)agent_extracted = []+ session_skills = []else:- agent_extracted = agent_result+ agent_extracted = list(agent_result.get("contexts", []))+ session_skills = list(agent_result.get("session_skills", []))- logger.info(f"Extracted {len(extracted)} memories")- for ctx_item in extracted:- cat = getattr(ctx_item, "category", "") or "unknown"- memories_extracted[cat] = memories_extracted.get(cat, 0) + 1- self._stats.memories_extracted += len(extracted)- get_current_telemetry().set("memory.extracted", len(extracted))+ if memory_extraction_enabled:+ logger.info(f"Extracted {len(extracted)} memories")+ for ctx_item in extracted:+ cat = getattr(ctx_item, "category", "") or "unknown"+ memories_extracted[cat] = memories_extracted.get(cat, 0) + 1+ self._stats.memories_extracted += len(extracted)+ get_current_telemetry().set("memory.extracted", len(extracted))if agent_extracted:logger.info(f"Extracted {len(agent_extracted)} agent memories")@@ -1277,10 +1303,15 @@ class Session:cat = getattr(ctx_item, "category", "") or "unknown"memories_extracted[cat] = memories_extracted.get(cat, 0) + 1self._stats.memories_extracted += len(agent_extracted)+ if session_skills:+ logger.info(f"Extracted {len(session_skills)} session skills")+ extracted_skill_results = session_skillselse:if self._session_compressor:logger.info(- "Memory extraction is disabled by config (memory.extraction_enabled=false)"+ "Memory and session skill extraction are disabled by config "+ "(memory.extraction_enabled=false, "+ "memory.session_skill_extraction_enabled=false)")await _run_archive_summary()@@ -1349,6 +1380,12 @@ class Session:"session_id": self.session_id,"archive_uri": archive_uri,"memories_extracted": memories_extracted,+ "session_skills_extracted": len(extracted_skill_results),+ "session_skill_uris": [+ item.get("uri") or item.get("root_uri")+ for item in extracted_skill_results+ if isinstance(item, dict) and (item.get("uri") or item.get("root_uri"))+ ],"active_count_updated": active_count_updated,"token_usage": {"llm": dict(self._meta.llm_token_usage),diff --git a/openviking/session/skill/__init__.py b/openviking/session/skill/__init__.pynew file mode 100644index 000000000..06274d2f9--- /dev/null+++ b/openviking/session/skill/__init__.py@@ -0,0 +1,17 @@+# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.+# SPDX-License-Identifier: AGPL-3.0+"""Session skill extraction helpers."""++from openviking.session.skill.dedup import dedup_session_skill_operations+from openviking.session.skill.session_skill_context_provider import SessionSkillContextProvider+from openviking.session.skill.skill_operation_updater import (+ SkillOperationUpdater,+ SkillOperationUpdateResult,+)++__all__ = [+ "dedup_session_skill_operations",+ "SessionSkillContextProvider",+ "SkillOperationUpdater",+ "SkillOperationUpdateResult",+]diff --git a/openviking/session/skill/dedup.py b/openviking/session/skill/dedup.pynew file mode 100644index 000000000..b1cbb3b3c--- /dev/null+++ b/openviking/session/skill/dedup.py@@ -0,0 +1,90 @@+# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.+# SPDX-License-Identifier: AGPL-3.0+"""Lightweight batch dedup for session-derived skill operations."""++import re+from typing import Any, Optional++from openviking.session.memory.dataclass import ResolvedOperations+from openviking_cli.utils import get_logger++logger = get_logger(__name__)+_WHITESPACE_RE = re.compile(r"\s+")+++def dedup_session_skill_operations(operations: ResolvedOperations) -> ResolvedOperations:+ seen_signatures: dict[str, int] = {}+ deduped_operations = []+ duplicate_count = 0++ for op in operations.upsert_operations:+ signature = _build_session_skill_signature(op)+ if not signature:+ deduped_operations.append(op)+ continue++ existing_idx = seen_signatures.get(signature)+ if existing_idx is None:+ seen_signatures[signature] = len(deduped_operations)+ deduped_operations.append(op)+ continue++ duplicate_count += 1+ kept_op = deduped_operations[existing_idx]+ logger.info(+ "Deduplicated duplicate session skill candidate '%s' against '%s'",+ _skill_name(op),+ _skill_name(kept_op),+ )++ if duplicate_count == 0:+ return operations++ logger.info("Deduplicated %d duplicate session skill operations in batch", duplicate_count)+ return ResolvedOperations(+ upsert_operations=deduped_operations,+ delete_file_contents=operations.delete_file_contents,+ errors=operations.errors,+ )+++def _build_session_skill_signature(op) -> Optional[str]:+ if op.memory_type != "session_skills" or op.old_memory_file_content is not None:+ return None++ full_body = _extract_full_body(op.memory_fields.get("content"))+ if not full_body:+ return None++ normalized_body = _normalize_text(full_body)+ if not normalized_body:+ return None++ return f"session_skill_body:{normalized_body}"+++def _extract_full_body(content: Any) -> Optional[str]:+ if isinstance(content, str):+ return content++ if not isinstance(content, dict):+ return None++ blocks = content.get("blocks")+ if not isinstance(blocks, list) or len(blocks) != 1 or not isinstance(blocks[0], dict):+ return None++ search = str(blocks[0].get("search", "") or "")+ replace = str(blocks[0].get("replace", "") or "")+ if search.strip() or not replace.strip():+ return None++ return replace+++def _normalize_text(value: str) -> str:+ return _WHITESPACE_RE.sub(" ", value).strip().casefold()+++def _skill_name(op) -> str:+ return str(op.memory_fields.get("skill_name", "")).strip() or "<unknown>"diff --git a/openviking/session/skill/session_skill_context_provider.py b/openviking/session/skill/session_skill_context_provider.pynew file mode 100644index 000000000..01ebde1f9--- /dev/null+++ b/openviking/session/skill/session_skill_context_provider.py@@ -0,0 +1,182 @@+# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.+# SPDX-License-Identifier: AGPL-3.0+"""Session skill extraction provider for ReAct-based skill asset updates."""++from __future__ import annotations++from pathlib import Path+from typing import Any, Dict, List, Tuple++from openviking.core.namespace import canonical_agent_root+from openviking.core.skill_loader import SkillLoader+from openviking.prompts.manager import PromptManager+from openviking.session.memory.dataclass import MemoryFile+from openviking.session.memory.memory_type_registry import MemoryTypeRegistry+from openviking.session.memory.session_extract_context_provider import SessionExtractContextProvider+from openviking.session.memory.tools import add_tool_call_pair_to_messages+from openviking.session.memory.utils import add_line_numbers, line_count, slice_content_lines+from openviking.session.memory.utils.messages import parse_memory_file_with_fields+from openviking_cli.exceptions import NotFoundError+from openviking_cli.utils import get_logger++logger = get_logger(__name__)++SESSION_SKILL_MEMORY_TYPE = "session_skills"+++def resolve_skill_extract_templates_dir() -> Path:+ """Resolve the session skill schema directory."""+ return PromptManager._resolve_templates_dir(None) / "skill_extract"+++def load_skill_extract_registry() -> MemoryTypeRegistry:+ registry = MemoryTypeRegistry(load_schemas=False)+ loaded = registry.load_from_directory(str(resolve_skill_extract_templates_dir()))+ if loaded == 0:+ raise RuntimeError("No session skill schemas loaded from skill_extract templates")+ return registry+++def parse_skill_extract_file(raw_content: str) -> Dict[str, Any]:+ try:+ parsed = SkillLoader.parse(raw_content)+ return {+ "name": parsed.get("name", ""),+ "description": parsed.get("description", ""),+ "content": parsed.get("content", ""),+ "allowed_tools": parsed.get("allowed_tools", []),+ "tags": parsed.get("tags", []),+ }+ except Exception:+ return parse_memory_file_with_fields(raw_content)+++def build_skill_read_result(+ raw_content: str,+ *,+ uri: str,+ offset: int = 0,+ limit: int = -1,+) -> Tuple[Dict[str, Any], MemoryFile]:+ parsed = parse_skill_extract_file(raw_content)+ stored = MemoryFile.from_parsed(uri=uri, parsed=dict(parsed))++ llm_result = {+ "name": parsed.get("name", ""),+ "description": parsed.get("description", ""),+ "allowed_tools": parsed.get("allowed_tools", []),+ "tags": parsed.get("tags", []),+ }+ plain_content = parsed.get("content", "") or ""+ visible_content = slice_content_lines(plain_content, offset=offset, limit=limit)+ if visible_content:+ llm_result["content"] = add_line_numbers(visible_content, start_line=offset + 1)+ elif line_count(plain_content) == 0:+ llm_result["content"] = (+ "<system-reminder>Warning: the file exists but the contents are empty.</system-reminder>"+ )+ else:+ llm_result["content"] = (+ "<system-reminder>Warning: the file exists but is shorter than the provided "+ f"offset ({offset + 1}). The file has {line_count(plain_content)} lines.</system-reminder>"+ )+ return llm_result, stored+++class SessionSkillContextProvider(SessionExtractContextProvider):+ """Provider that reuses session ReAct extraction for real skill assets."""++ def instruction(self) -> str:+ return (+ "You are an extraction agent. Analyze the archived conversation, use read when "+ "needed, and output only JSON that matches the schema descriptions."+ )++ async def prefetch(self) -> List[Dict[str, Any]]:+ pre_fetch_messages = [self._build_conversation_message()]+ if not self._ctx or not self._viking_fs:+ return pre_fetch_messages++ skill_root_uri = f"{canonical_agent_root(self._ctx)}/skills"+ try:+ entries = await self._viking_fs.ls(+ skill_root_uri,+ output="agent",+ abs_limit=256,+ show_all_hidden=False,+ node_limit=1000,+ ctx=self._ctx,+ )+ listed_skills = []+ for entry in entries:+ if not entry.get("isDir", False):+ continue+ skill_root = (+ entry.get("uri") or f"{skill_root_uri.rstrip('/')}/{entry.get('name', '')}"+ )+ skill_name = entry.get("name") or skill_root.rstrip("/").split("/")[-1]+ listed_skills.append(+ {+ "skill_name": skill_name,+ "uri": f"{skill_root.rstrip('/')}/SKILL.md",+ "abstract": entry.get("abstract", ""),+ }+ )+ add_tool_call_pair_to_messages(+ messages=pre_fetch_messages,+ call_id=0,+ tool_name="ls",+ params={"uri": skill_root_uri},+ result=listed_skills+ if listed_skills+ else "Directory is empty. You can create a new skill if the conversation shows a reusable workflow.",+ )+ except Exception as exc:+ add_tool_call_pair_to_messages(+ messages=pre_fetch_messages,+ call_id=0,+ tool_name="ls",+ params={"uri": skill_root_uri},+ result={"error": str(exc)},+ )+ return pre_fetch_messages++ async def execute_tool(self, tool_call) -> Any:+ if tool_call.name != "read":+ return {"error": f"Unknown tool: {tool_call.name}"}+ arguments = tool_call.arguments or {}+ uri = arguments.get("uri", "")+ offset = arguments.get("offset", 0)+ limit = arguments.get("limit", -1)++ if not uri.endswith("/SKILL.md"):+ return await super().execute_tool(tool_call)++ try:+ raw_content = await self._viking_fs.read_file(uri, ctx=self._ctx)+ except NotFoundError as exc:+ logger.info("Session skill read not found: %s", uri)+ return {"error": str(exc)}+ except Exception as exc:+ logger.warning("Session skill read failed for %s: %s", uri, exc)+ return {"error": str(exc)}++ result, stored = build_skill_read_result(+ raw_content,+ uri=uri,+ offset=offset,+ limit=limit,+ )+ self._read_file_contents[uri] = stored+ return result++ def get_tools(self) -> List[str]:+ return ["read"]++ def get_schema_directories(self) -> List[str]:+ return [str(resolve_skill_extract_templates_dir())]++ def _get_registry(self) -> MemoryTypeRegistry:+ if self._registry is None:+ self._registry = load_skill_extract_registry()+ return self._registrydiff --git a/openviking/session/skill/skill_operation_updater.py b/openviking/session/skill/skill_operation_updater.pynew file mode 100644index 000000000..1e8ac242a--- /dev/null+++ b/openviking/session/skill/skill_operation_updater.py@@ -0,0 +1,230 @@+# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.+# SPDX-License-Identifier: AGPL-3.0+"""Apply session skill extraction operations to real skill assets."""++from __future__ import annotations++from dataclasses import dataclass, field+from typing import Any, Dict, List, Optional, Tuple++import yaml++from openviking.core.skill_loader import SkillLoader+from openviking.server.identity import RequestContext+from openviking.session.memory.dataclass import ResolvedOperation, ResolvedOperations+from openviking.session.memory.memory_type_registry import MemoryTypeRegistry+from openviking.session.memory.merge_op import MergeOpFactory+from openviking.storage.content_write import ContentWriteCoordinator+from openviking.storage.viking_fs import VikingFS, get_viking_fs+from openviking.utils.skill_processor import SkillProcessor+from openviking_cli.exceptions import NotFoundError+from openviking_cli.utils import get_logger++logger = get_logger(__name__)+++@dataclass+class SkillOperationUpdateResult:+ written_uris: List[str] = field(default_factory=list)+ edited_uris: List[str] = field(default_factory=list)+ errors: List[Tuple[str, Exception]] = field(default_factory=list)+ operation_results: List[Dict[str, Any]] = field(default_factory=list)++ def add_written(self, uri: str) -> None:+ self.written_uris.append(uri)++ def add_edited(self, uri: str) -> None:+ self.edited_uris.append(uri)++ def add_error(self, uri: str, error: Exception) -> None:+ self.errors.append((uri, error))++ def add_result(self, result: Dict[str, Any]) -> None:+ self.operation_results.append(result)+++class SkillOperationUpdater:+ """Create or update agent skills from resolved ReAct operations."""++ def __init__(+ self,+ registry: MemoryTypeRegistry,+ skill_processor: SkillProcessor,+ viking_fs: Optional[VikingFS] = None,+ ):+ self._registry = registry+ self._skill_processor = skill_processor+ self._viking_fs = viking_fs or get_viking_fs()++ async def apply_operations(+ self,+ operations: ResolvedOperations,+ ctx: RequestContext,+ ) -> SkillOperationUpdateResult:+ result = SkillOperationUpdateResult()+ if not self._viking_fs:+ raise RuntimeError("VikingFS is required for session skill updates")++ if operations.has_errors():+ for error in operations.errors:+ result.add_error("unknown", ValueError(error))+ return result++ for operation in operations.upsert_operations:+ try:+ op_result = await self._apply_upsert(operation, ctx)+ result.add_result(op_result)+ if op_result.get("action") == "create":+ result.add_written(op_result["skill_md_uri"])+ else:+ result.add_edited(op_result["skill_md_uri"])+ except Exception as exc:+ target_uri = (operation.uris or ["unknown"])[0]+ logger.error("Failed to apply session skill operation for %s: %s", target_uri, exc)+ result.add_error(target_uri, exc)++ return result++ async def _apply_upsert(+ self,+ operation: ResolvedOperation,+ ctx: RequestContext,+ ) -> Dict[str, Any]:+ if not operation.uris:+ raise ValueError("Session skill operation does not have a target URI")++ skill_md_uri = operation.uris[0]+ root_uri = self._root_uri_from_skill_md(skill_md_uri)+ existing_skill = await self._load_existing_skill(skill_md_uri, ctx)+ merged_skill = self._merge_skill(operation, existing_skill)++ if existing_skill is None:+ processor_result = await self._skill_processor.process_skill(+ data=merged_skill,+ viking_fs=self._viking_fs,+ ctx=ctx,+ allow_local_path_resolution=False,+ )+ created_root_uri = (+ processor_result.get("root_uri") or processor_result.get("uri") or root_uri+ )+ return {+ "status": "success",+ "action": "create",+ "root_uri": created_root_uri,+ "uri": created_root_uri,+ "skill_md_uri": f"{created_root_uri.rstrip('/')}/SKILL.md",+ "name": merged_skill["name"],+ }++ merged_skill = await self._skill_processor.sanitize_skill_privacy(merged_skill, ctx)+ serialized = SkillLoader.to_skill_md(merged_skill)+ write_result = await ContentWriteCoordinator(self._viking_fs).write(+ uri=skill_md_uri,+ content=serialized,+ ctx=ctx,+ mode="replace",+ )+ updated_root_uri = write_result.get("root_uri") or root_uri+ return {+ "status": "success",+ "action": "update",+ "root_uri": updated_root_uri,+ "uri": updated_root_uri,+ "skill_md_uri": skill_md_uri,+ "name": merged_skill["name"],+ }++ def _merge_skill(+ self,+ operation: ResolvedOperation,+ existing_skill: Optional[Dict[str, Any]],+ ) -> Dict[str, Any]:+ schema = self._registry.get(operation.memory_type)+ if not schema:+ raise ValueError(f"Unknown session skill schema: {operation.memory_type}")++ skill = {+ "name": (existing_skill or {}).get("name")+ or operation.memory_fields.get("skill_name", ""),+ "description": (existing_skill or {}).get("description", ""),+ "content": (existing_skill or {}).get("content"),+ "allowed_tools": list((existing_skill or {}).get("allowed_tools") or []),+ "tags": list(+ (existing_skill or {}).get("tags")+ or (["session-derived"] if existing_skill is None else [])+ ),+ }++ for schema_field in schema.fields:+ if schema_field.name not in operation.memory_fields:+ continue+ merge_op = MergeOpFactory.from_field(schema_field)+ patch_value = operation.memory_fields[schema_field.name]+ target_key = self._target_skill_key(schema_field.name)+ current_value = skill.get(target_key)+ skill[target_key] = merge_op.apply(current_value, patch_value)++ if not skill["name"]:+ raise ValueError("Session skill operation is missing skill_name")+ if not skill.get("description"):+ raise ValueError(f"Session skill '{skill['name']}' is missing description")+ if not skill.get("content"):+ raise ValueError(f"Session skill '{skill['name']}' is missing content")+ return skill++ async def _load_existing_skill(+ self,+ skill_md_uri: str,+ ctx: RequestContext,+ ) -> Optional[Dict[str, Any]]:+ try:+ raw_content = await self._viking_fs.read_file(skill_md_uri, ctx=ctx)+ except (FileNotFoundError, NotFoundError):+ return None++ try:+ return SkillLoader.parse(raw_content)+ except Exception:+ abstract_meta = await self._load_abstract_meta(+ self._root_uri_from_skill_md(skill_md_uri), ctx+ )+ if abstract_meta is None:+ raise+ return {+ "name": abstract_meta.get("name")+ or self._root_uri_from_skill_md(skill_md_uri).rstrip("/").split("/")[-1],+ "description": abstract_meta.get("description", ""),+ "content": raw_content.strip(),+ "allowed_tools": abstract_meta.get("allowed_tools")+ or abstract_meta.get("allowed-tools")+ or [],+ "tags": abstract_meta.get("tags") or [],+ }++ async def _load_abstract_meta(+ self,+ root_uri: str,+ ctx: RequestContext,+ ) -> Optional[Dict[str, Any]]:+ try:+ abstract = await self._viking_fs.read_file(+ f"{root_uri.rstrip('/')}/.abstract.md", ctx=ctx+ )+ except (FileNotFoundError, NotFoundError):+ return None+ parsed = yaml.safe_load(abstract)+ return parsed if isinstance(parsed, dict) else None++ @staticmethod+ def _target_skill_key(field_name: str) -> str:+ if field_name == "skill_name":+ return "name"+ return field_name++ @staticmethod+ def _root_uri_from_skill_md(skill_md_uri: str) -> str:+ suffix = "/SKILL.md"+ if skill_md_uri.endswith(suffix):+ return skill_md_uri[: -len(suffix)]+ return skill_md_uri.rstrip("/")diff --git a/openviking/utils/skill_processor.py b/openviking/utils/skill_processor.pyindex 0d1f8d81a..fbe35dfb5 100644--- a/openviking/utils/skill_processor.py+++ b/openviking/utils/skill_processor.py@@ -94,7 +94,7 @@ class SkillProcessor:"skill.parse.duration_ms", round((time.perf_counter() - parse_start) * 1000, 3))- skill_dict = await self._sanitize_skill_privacy(skill_dict, ctx)+ skill_dict = await self.sanitize_skill_privacy(skill_dict, ctx)skill_abstract = self._build_skill_abstract(skill_dict)context = Context(@@ -214,9 +214,37 @@ class SkillProcessor:else:raise ValueError(f"Unsupported data type: {type(data)}")+ skill_dict = self._normalize_skill_dict(skill_dict)self._validate_skill_dict(skill_dict)return skill_dict, auxiliary_files, base_path+ @staticmethod+ def _normalize_list_field(value: Any) -> Any:+ if value is None:+ return None+ if isinstance(value, list):+ return value+ if isinstance(value, (tuple, set)):+ return list(value)+ return [value]++ @staticmethod+ def _normalize_skill_dict(skill_dict: Dict[str, Any]) -> Dict[str, Any]:+ normalized = dict(skill_dict)++ allowed_tools = normalized.get("allowed_tools")+ if not allowed_tools:+ allowed_tools = normalized.get("allowed-tools")+ if allowed_tools is not None:+ normalized["allowed_tools"] = SkillProcessor._normalize_list_field(allowed_tools)+ normalized.pop("allowed-tools", None)++ tags = normalized.get("tags")+ if tags is not None:+ normalized["tags"] = SkillProcessor._normalize_list_field(tags)++ return normalized+@staticmethoddef _validate_skill_dict(skill_dict: Dict[str, Any]) -> None:"""Validate normalized skill metadata before storage/indexing."""@@ -247,6 +275,11 @@ class SkillProcessor:return yaml.safe_dump(abstract_meta, allow_unicode=True, sort_keys=False).strip()+ async def sanitize_skill_privacy(+ self, skill_dict: Dict[str, Any], ctx: RequestContext+ ) -> Dict[str, Any]:+ return await self._sanitize_skill_privacy(skill_dict, ctx)+async def _sanitize_skill_privacy(self, skill_dict: Dict[str, Any], ctx: RequestContext) -> Dict[str, Any]:@@ -300,7 +333,7 @@ class SkillProcessor:"""Write main skill content to VikingFS."""await viking_fs.write_context(uri=skill_dir_uri,- content=skill_dict.get("content", ""),+ content=SkillLoader.to_skill_md(skill_dict),abstract=abstract,overview=overview,content_filename="SKILL.md",diff --git a/openviking_cli/utils/config/memory_config.py b/openviking_cli/utils/config/memory_config.pyindex 130aea7c0..f46ff2fdf 100644--- a/openviking_cli/utils/config/memory_config.py+++ b/openviking_cli/utils/config/memory_config.py@@ -83,6 +83,14 @@ class MemoryConfig(BaseModel):"stateless deployments."),)+ session_skill_extraction_enabled: bool = Field(+ default=False,+ description=(+ "When enabled, session commit also extracts reusable skills from the archived "+ "conversation and writes them into the agent skill directory. Disabled by "+ "default."+ ),+ )enable_role_id_memory_isolate: bool = Field(default=False,description=(diff --git a/tests/session/test_commit_skill_inference.py b/tests/session/test_commit_skill_inference.pynew file mode 100644index 000000000..56cca1c3d--- /dev/null+++ b/tests/session/test_commit_skill_inference.py@@ -0,0 +1,643 @@+import json+from types import SimpleNamespace+from unittest.mock import AsyncMock, MagicMock++import pytest++from openviking.core.skill_loader import SkillLoader+from openviking.message import Message, TextPart, ToolPart+from openviking.server.identity import RequestContext, Role+from openviking.session.compressor_v2 import SessionCompressorV2+from openviking.session.memory.agent_trajectory_context_provider import (+ AgentTrajectoryContextProvider,+)+from openviking.session.memory.dataclass import ResolvedOperation, ResolvedOperations+from openviking.session.memory.memory_type_registry import MemoryTypeRegistry+from openviking.session.memory.schema_model_generator import SchemaPromptGenerator+from openviking.session.memory_extractor import MemoryCategory, MemoryExtractor+from openviking.session.skill.session_skill_context_provider import (+ SessionSkillContextProvider,+ resolve_skill_extract_templates_dir,+)+from openviking.session.skill.skill_operation_updater import (+ SkillOperationUpdater,+ SkillOperationUpdateResult,+)+from openviking.utils.skill_processor import SkillProcessor+from openviking_cli.session.user_id import UserIdentifier+++class _DummyVLM:+ def is_available(self):+ return True++ async def get_completion_async(self, _prompt):+ return json.dumps(+ {+ "skills": [+ {+ "situation": "代码审查与总结",+ "skill_name": "代码审查流程",+ "skill_content_reasoning": [+ "从对话中提炼稳定步骤",+ "保留可复用的检查顺序",+ ],+ "skill_content": "## 核心规范\n- 先阅读目标文件。\n- 基于证据总结问题。\n\n## 使用该Skill的场景\n- 代码审查\n\n## 实现指南\n### 先决条件\n- 能访问待审查代码\n### 技术和方法\n1. 先读文件。\n2. 再总结发现。\n### 应用场景示例\n- 阅读 README 后输出审查意见。\n\n## 核心要点\n- 先证据,后结论。",+ }+ ]+ }+ )+++def _mock_config():+ config = MagicMock()+ config.vlm = _DummyVLM()+ config.output_language_override = None+ return config+++def _build_skill_registry() -> MemoryTypeRegistry:+ registry = MemoryTypeRegistry(load_schemas=False)+ loaded = registry.load_from_directory(str(resolve_skill_extract_templates_dir()))+ assert loaded > 0+ return registry+++def _build_duplicate_session_skill_operations() -> ResolvedOperations:+ content = "## 核心规范\n- 分析常识题需按步骤执行\n- 输出答案"+ return ResolvedOperations(+ upsert_operations=[+ ResolvedOperation(+ old_memory_file_content=None,+ memory_fields={+ "skill_name": "常识题分析流程",+ "description": "规范常识题分析步骤,含选项分析、答案输出及知识点归纳",+ "content": content,+ },+ memory_type="session_skills",+ uris=["viking://agent/default/skills/general-knowledge-flow/SKILL.md"],+ ),+ ResolvedOperation(+ old_memory_file_content=None,+ memory_fields={+ "skill_name": "常识题分析步骤",+ "description": "按步骤分析常识题,含选项分析、答案输出及知识点归纳",+ "content": content,+ },+ memory_type="session_skills",+ uris=["viking://agent/default/skills/general-knowledge-steps/SKILL.md"],+ ),+ ],+ delete_file_contents=[],+ errors=[],+ )+++async def test_session_skill_schema_description_is_loaded_from_yaml():+ registry = _build_skill_registry()+ schema = registry.get("session_skills")+ assert schema is not None++ descriptions = SchemaPromptGenerator([schema]).generate_type_descriptions()++ assert "### session_skills" in descriptions+ assert "一、提取内容的识别规则" in descriptions+ assert "以后" in descriptions+++async def test_extract_does_not_inject_skill_memory_candidate(monkeypatch):+ extractor = MemoryExtractor()+ monkeypatch.setattr(+ "openviking.session.memory_extractor.get_openviking_config",+ _mock_config,+ )++ user = UserIdentifier.the_default_user()+ messages = [+ Message(+ id="m1",+ role="assistant",+ parts=[+ TextPart(+ "We should use code-review skill: first read the project files, then summarize findings before drafting output."+ ),+ ToolPart(+ tool_id="tool_1",+ tool_name="read",+ tool_uri="viking://session/test/tools/tool_1",+ tool_input={"file_path": "README.md"},+ tool_output="ok",+ tool_status="completed",+ duration_ms=12,+ ),+ ],+ )+ ]+ candidates = await extractor.extract(+ {+ "messages": messages,+ "summary": "",+ },+ user,+ "session-1",+ )++ skill_candidates = [c for c in candidates if c.category == MemoryCategory.SKILLS]+ assert skill_candidates == []+++async def test_session_compressor_v2_extract_agent_memories_returns_session_skills(monkeypatch):+ config = MagicMock()+ config.memory.agent_memory_enabled = False+ config.memory.session_skill_extraction_enabled = True++ async def _fake_run_extract_phase(+ self,+ provider,+ messages,+ ctx,+ strict_extract_errors,+ phase_label,+ post_apply=None,+ ):+ del self, messages, ctx, strict_extract_errors, post_apply+ assert phase_label == "trajectory"+ assert provider._include_trajectories is False+ assert provider._include_session_skills is True+ return (+ [],+ [],+ [],+ {},+ [+ {+ "status": "success",+ "action": "create",+ "uri": "viking://agent/default/skills/code-review",+ "root_uri": "viking://agent/default/skills/code-review",+ "skill_md_uri": "viking://agent/default/skills/code-review/SKILL.md",+ }+ ],+ )++ monkeypatch.setattr("openviking.session.compressor_v2.get_openviking_config", lambda: config)+ monkeypatch.setattr(SessionCompressorV2, "_run_extract_phase", _fake_run_extract_phase)++ compressor = SessionCompressorV2(vikingdb=MagicMock(), skill_processor=MagicMock())+ result = await compressor.extract_agent_memories(+ messages=[Message(id="m1", role="assistant", parts=[TextPart("Summarize a review flow")])],+ ctx=RequestContext(user=UserIdentifier.the_default_user(), role=Role.ROOT),+ latest_archive_overview="",+ archive_uri="viking://sessions/s1/history/archive_001",+ )++ assert result == {+ "contexts": [],+ "session_skills": [+ {+ "status": "success",+ "action": "create",+ "uri": "viking://agent/default/skills/code-review",+ "root_uri": "viking://agent/default/skills/code-review",+ "skill_md_uri": "viking://agent/default/skills/code-review/SKILL.md",+ "archive_uri": "viking://sessions/s1/history/archive_001",+ }+ ],+ }+++async def test_session_compressor_v2_run_extract_phase_dedups_duplicate_session_skill_creates(+ monkeypatch,+):+ config = MagicMock()+ config.vlm.get_vlm_instance.return_value = MagicMock(model="dummy-model")+ config.memory.v2_lock_retry_interval_seconds = 0+ config.memory.v2_lock_max_retries = 0+ viking_fs = MagicMock()+ viking_fs.agfs = None++ async def _fake_run(self):+ return _build_duplicate_session_skill_operations(), []++ async def _fake_apply(self, operations, ctx):+ del ctx+ assert len(operations.upsert_operations) == 1+ kept = operations.upsert_operations[0]+ assert kept.memory_fields["skill_name"] == "常识题分析流程"+ result = SkillOperationUpdateResult()+ result.add_result(+ {+ "status": "success",+ "action": "create",+ "uri": kept.uris[0].rsplit("/SKILL.md", 1)[0],+ "root_uri": kept.uris[0].rsplit("/SKILL.md", 1)[0],+ "skill_md_uri": kept.uris[0],+ }+ )+ return result++ monkeypatch.setattr("openviking.session.compressor_v2.get_openviking_config", lambda: config)+ monkeypatch.setattr("openviking.session.compressor_v2.get_viking_fs", lambda: viking_fs)+ monkeypatch.setattr("openviking.session.compressor_v2.ExtractLoop.run", _fake_run)+ monkeypatch.setattr(+ "openviking.session.skill.skill_operation_updater.SkillOperationUpdater.apply_operations",+ _fake_apply,+ )++ compressor = SessionCompressorV2(vikingdb=MagicMock(), skill_processor=MagicMock())+ messages = [Message(id="m1", role="assistant", parts=[TextPart("Summarize a workflow")])]+ provider = AgentTrajectoryContextProvider(+ messages=messages,+ latest_archive_overview="",+ include_trajectories=False,+ include_session_skills=True,+ )+ result = await compressor._run_extract_phase(+ provider=provider,+ messages=messages,+ ctx=RequestContext(user=UserIdentifier.the_default_user(), role=Role.ROOT),+ strict_extract_errors=True,+ phase_label="trajectory",+ )++ assert result is not None+ assert result[4][0]["uri"] == "viking://agent/default/skills/general-knowledge-flow"+++async def test_session_skill_context_provider_prefetch_lists_existing_skills():+ ctx = RequestContext(user=UserIdentifier.the_default_user(), role=Role.ROOT)+ viking_fs = MagicMock()+ viking_fs.ls = AsyncMock(+ return_value=[+ {+ "name": "code-review",+ "uri": "viking://agent/default/skills/code-review",+ "isDir": True,+ "abstract": "name: code-review\ndescription: Review code carefully",+ }+ ]+ )+ provider = SessionSkillContextProvider(+ messages=[+ Message(id="m1", role="assistant", parts=[TextPart("Summarize a reusable review flow")])+ ],+ latest_archive_overview="",+ ctx=ctx,+ viking_fs=viking_fs,+ )++ prefetched = await provider.prefetch()++ assert len(prefetched) == 2+ assert "Conversation History" in prefetched[0]["content"]+ assert "code-review" in prefetched[1]["content"]+ assert "SKILL.md" in prefetched[1]["content"]+++async def test_agent_trajectory_context_provider_without_session_skills_prefetches_history_only():+ provider = AgentTrajectoryContextProvider(+ messages=[+ Message(id="m1", role="assistant", parts=[TextPart("Summarize a reusable review flow")])+ ],+ latest_archive_overview="",+ include_trajectories=True,+ include_session_skills=False,+ )++ prefetched = await provider.prefetch()++ assert not isinstance(provider, SessionSkillContextProvider)+ assert len(prefetched) == 1+ assert "Conversation History" in prefetched[0]["content"]+ assert provider.get_tools() == []+++async def test_agent_trajectory_context_provider_delegates_skill_prefetch_and_read():+ ctx = RequestContext(user=UserIdentifier.the_default_user(), role=Role.ROOT)+ viking_fs = MagicMock()+ viking_fs.ls = AsyncMock(+ return_value=[+ {+ "name": "code-review",+ "uri": "viking://agent/default/skills/code-review",+ "isDir": True,+ "abstract": "name: code-review\ndescription: Review code carefully",+ }+ ]+ )+ viking_fs.read_file = AsyncMock(+ return_value="""---+name: code-review+description: Review code carefully+allowed-tools:+- Read+tags:+- session-derived+---++## 核心规范+- 先读文件+"""+ )+ provider = AgentTrajectoryContextProvider(+ messages=[+ Message(id="m1", role="assistant", parts=[TextPart("Summarize a reusable review flow")])+ ],+ latest_archive_overview="",+ include_trajectories=False,+ include_session_skills=True,+ )+ provider._ctx = ctx+ provider._viking_fs = viking_fs++ prefetched = await provider.prefetch()+ read_result = await provider.execute_tool(+ SimpleNamespace(+ name="read",+ arguments={"uri": "viking://agent/default/skills/code-review/SKILL.md"},+ )+ )++ assert len(prefetched) == 2+ assert "code-review" in prefetched[1]["content"]+ assert provider.get_tools() == ["read"]+ assert read_result["name"] == "code-review"+ assert "先读文件" in read_result["content"]+ assert "viking://agent/default/skills/code-review/SKILL.md" in provider.read_file_contents+ assert provider._skill_provider.read_file_contents is provider.read_file_contents+ assert provider._skill_provider._ctx is ctx+ assert provider._skill_provider._viking_fs is viking_fs+ assert provider._skill_provider._extract_context is provider.get_extract_context()+++async def test_skill_operation_updater_creates_skill_with_session_defaults():+ processor = MagicMock()+ processor.process_skill = AsyncMock(+ return_value={+ "status": "success",+ "uri": "viking://agent/default/skills/code-review",+ "root_uri": "viking://agent/default/skills/code-review",+ }+ )+ processor.sanitize_skill_privacy = AsyncMock(side_effect=lambda skill_dict, _ctx: skill_dict)+ viking_fs = MagicMock()+ viking_fs.read_file = AsyncMock(side_effect=FileNotFoundError())+ updater = SkillOperationUpdater(+ registry=_build_skill_registry(),+ skill_processor=processor,+ viking_fs=viking_fs,+ )+ uri = "viking://agent/default/skills/code-review/SKILL.md"+ operations = ResolvedOperations(+ upsert_operations=[+ ResolvedOperation(+ old_memory_file_content=None,+ memory_fields={+ "skill_name": "code-review",+ "description": "Review code from evidence",+ "content": {"blocks": [{"search": "", "replace": "## 核心规范\n- 先读文件"}]},+ },+ memory_type="session_skills",+ uris=[uri],+ )+ ],+ delete_file_contents=[],+ errors=[],+ )++ result = await updater.apply_operations(+ operations,+ RequestContext(user=UserIdentifier.the_default_user(), role=Role.ROOT),+ )++ processor.process_skill.assert_awaited_once()+ call = processor.process_skill.await_args.kwargs+ assert call["allow_local_path_resolution"] is False+ assert call["data"] == {+ "name": "code-review",+ "description": "Review code from evidence",+ "content": "## 核心规范\n- 先读文件",+ "allowed_tools": [],+ "tags": ["session-derived"],+ }+ assert result.written_uris == [uri]+ assert result.edited_uris == []+ assert result.operation_results[0]["action"] == "create"+++async def test_skill_operation_updater_updates_existing_skill(monkeypatch):+ existing_skill_md = """---+name: code-review+description: Review code carefully+allowed-tools:+- Read+tags:+- session-derived+---++## 核心规范+- 先读文件+"""+ viking_fs = MagicMock()+ viking_fs.read_file = AsyncMock(return_value=existing_skill_md)+ write_calls = {}++ class _FakeContentWriter:+ def __init__(self, _viking_fs):+ self._viking_fs = _viking_fs++ async def write(self, **kwargs):+ write_calls.update(kwargs)+ return {+ "uri": kwargs["uri"],+ "root_uri": kwargs["uri"].rsplit("/SKILL.md", 1)[0],+ }++ monkeypatch.setattr(+ "openviking.session.skill.skill_operation_updater.ContentWriteCoordinator",+ _FakeContentWriter,+ )++ processor = MagicMock()+ processor.sanitize_skill_privacy = AsyncMock(side_effect=lambda skill_dict, _ctx: skill_dict)+ updater = SkillOperationUpdater(+ registry=_build_skill_registry(),+ skill_processor=processor,+ viking_fs=viking_fs,+ )+ uri = "viking://agent/default/skills/code-review/SKILL.md"+ operations = ResolvedOperations(+ upsert_operations=[+ ResolvedOperation(+ old_memory_file_content=None,+ memory_fields={+ "skill_name": "code-review",+ "description": "Review code from evidence",+ "content": {+ "blocks": [+ {+ "search": "- 先读文件",+ "replace": "- 先读文件\n- 基于证据总结问题",+ }+ ]+ },+ },+ memory_type="session_skills",+ uris=[uri],+ )+ ],+ delete_file_contents=[],+ errors=[],+ )++ result = await updater.apply_operations(+ operations,+ RequestContext(user=UserIdentifier.the_default_user(), role=Role.ROOT),+ )++ assert result.written_uris == []+ assert result.edited_uris == [uri]+ assert result.operation_results[0]["action"] == "update"+ assert write_calls["uri"] == uri+ assert write_calls["mode"] == "replace"+ assert "allowed-tools:" in write_calls["content"]+ assert "tags:" in write_calls["content"]+ assert "Review code from evidence" in write_calls["content"]+ assert "- 基于证据总结问题" in write_calls["content"]+++async def test_skill_operation_updater_sanitizes_existing_skill_updates(monkeypatch):+ existing_skill_md = """---+name: code-review+description: Review code carefully+allowed-tools:+- Read+tags:+- session-derived+---++## 核心规范+- 先读文件+"""+ viking_fs = MagicMock()+ viking_fs.read_file = AsyncMock(return_value=existing_skill_md)+ write_calls = {}++ class _FakeContentWriter:+ def __init__(self, _viking_fs):+ self._viking_fs = _viking_fs++ async def write(self, **kwargs):+ write_calls.update(kwargs)+ return {+ "uri": kwargs["uri"],+ "root_uri": kwargs["uri"].rsplit("/SKILL.md", 1)[0],+ }++ monkeypatch.setattr(+ "openviking.session.skill.skill_operation_updater.ContentWriteCoordinator",+ _FakeContentWriter,+ )++ async def _fake_extract_skill_privacy_values(*, skill_name, skill_description, content):+ assert skill_name == "code-review"+ assert skill_description == "Review code from evidence"+ assert "api_key=secret-xyz" in content+ return SimpleNamespace(+ values={"api_key": "secret-xyz"},+ sanitized_content=content.replace(+ "api_key=secret-xyz",+ "api_key={{ov_privacy:skill:code-review:api_key}}",+ ),+ )++ monkeypatch.setattr(+ "openviking.utils.skill_processor.extract_skill_privacy_values",+ _fake_extract_skill_privacy_values,+ )++ privacy_config_service = MagicMock()+ privacy_config_service.upsert = AsyncMock()+ processor = SkillProcessor(+ vikingdb=MagicMock(),+ privacy_config_service=privacy_config_service,+ )+ updater = SkillOperationUpdater(+ registry=_build_skill_registry(),+ skill_processor=processor,+ viking_fs=viking_fs,+ )+ uri = "viking://agent/default/skills/code-review/SKILL.md"+ operations = ResolvedOperations(+ upsert_operations=[+ ResolvedOperation(+ old_memory_file_content=None,+ memory_fields={+ "skill_name": "code-review",+ "description": "Review code from evidence",+ "content": {+ "blocks": [+ {+ "search": "- 先读文件",+ "replace": "- 先读文件\napi_key=secret-xyz",+ }+ ]+ },+ },+ memory_type="session_skills",+ uris=[uri],+ )+ ],+ delete_file_contents=[],+ errors=[],+ )+ ctx = RequestContext(user=UserIdentifier.the_default_user(), role=Role.ROOT)++ result = await updater.apply_operations(operations, ctx)++ assert result.written_uris == []+ assert result.edited_uris == [uri]+ assert result.operation_results[0]["action"] == "update"+ assert "secret-xyz" not in write_calls["content"]+ assert "{{ov_privacy:skill:code-review:api_key}}" in write_calls["content"]+ privacy_config_service.upsert.assert_awaited_once_with(+ ctx=ctx,+ category="skill",+ target_key="code-review",+ values={"api_key": "secret-xyz"},+ updated_by=ctx.user.user_id,+ change_reason="auto-extracted from add_skill",+ )+++def test_skill_loader_to_skill_md_round_trip_with_lists():+ skill_md = SkillLoader.to_skill_md(+ {+ "name": "code-review",+ "description": "Review code from evidence",+ "content": "## 核心规范\n- 先读文件",+ "allowed_tools": ["Read"],+ "tags": ["session-derived"],+ }+ )++ parsed = SkillLoader.parse(skill_md)++ assert parsed == {+ "name": "code-review",+ "description": "Review code from evidence",+ "content": "## 核心规范\n- 先读文件",+ "source_path": "",+ "allowed_tools": ["Read"],+ "tags": ["session-derived"],+ }diff --git a/tests/session/test_session_commit.py b/tests/session/test_session_commit.pyindex 490710999..31eb4ded8 100644--- a/tests/session/test_session_commit.py+++ b/tests/session/test_session_commit.py@@ -5,7 +5,7 @@import asyncioimport json-from unittest.mock import MagicMock+from unittest.mock import AsyncMock, MagicMockimport pytest@@ -58,6 +58,62 @@ class TestCommit:# Wait for semantic/embedding queuesawait client.wait_processed(timeout=60.0)+ async def test_commit_reports_session_skills_separately(+ self, session_with_messages: Session, monkeypatch+ ):+ config = MagicMock()+ config.memory.extraction_enabled = False+ config.memory.session_skill_extraction_enabled = True+ monkeypatch.setattr("openviking.session.session.get_openviking_config", lambda: config)++ session_with_messages._session_compressor.extract_long_term_memories = AsyncMock(+ return_value=[]+ )+ if hasattr(session_with_messages._session_compressor, "extract_agent_memories"):+ session_with_messages._session_compressor.extract_agent_memories = AsyncMock(+ return_value={+ "contexts": [],+ "session_skills": [{"uri": "viking://account/test/agent/skills/code-review"}],+ }+ )++ result = await session_with_messages.commit_async()+ task_result = await _wait_for_task(result["task_id"])++ assert task_result["status"] == "completed"+ assert task_result["result"]["memories_extracted"] == {}+ assert task_result["result"]["session_skills_extracted"] == 1+ assert task_result["result"]["session_skill_uris"] == [+ "viking://account/test/agent/skills/code-review"+ ]+ session_with_messages._session_compressor.extract_long_term_memories.assert_not_awaited()+ session_with_messages._session_compressor.extract_agent_memories.assert_awaited_once()++ async def test_commit_skips_session_skill_extraction_when_disabled(+ self, session_with_messages: Session, monkeypatch+ ):+ config = MagicMock()+ config.memory.extraction_enabled = True+ config.memory.session_skill_extraction_enabled = False+ monkeypatch.setattr("openviking.session.session.get_openviking_config", lambda: config)++ session_with_messages._session_compressor.extract_long_term_memories = AsyncMock(+ return_value=[]+ )+ if hasattr(session_with_messages._session_compressor, "extract_agent_memories"):+ session_with_messages._session_compressor.extract_agent_memories = AsyncMock(+ return_value={"contexts": [], "session_skills": []}+ )++ result = await session_with_messages.commit_async()+ task_result = await _wait_for_task(result["task_id"])++ assert task_result["status"] == "completed"+ assert task_result["result"]["session_skills_extracted"] == 0+ assert task_result["result"]["session_skill_uris"] == []+ session_with_messages._session_compressor.extract_long_term_memories.assert_awaited_once()+ session_with_messages._session_compressor.extract_agent_memories.assert_awaited_once()+async def test_commit_archives_messages(self, session_with_messages: Session):"""Test commit archives messages"""initial_message_count = len(session_with_messages.messages)@@ -139,40 +195,7 @@ class TestCommit:assert seen["summary"] == previous_overviewassert seen["extract"] == previous_overview- async def test_commit_with_usage_records(self, client: AsyncOpenViking):- """Test commit with usage records"""- session = client.session(session_id="usage_commit_test")-- session.add_message("user", [TextPart("Test message")])- session.used(contexts=["viking://user/test/resources/doc.md"])- session.add_message("assistant", [TextPart("Response")])-- result = await session.commit_async()-- assert result.get("status") == "accepted"- assert result.get("task_id") is not None-- # active_count_updated is now in the background task result- task_result = await _wait_for_task(result["task_id"])- assert task_result["status"] == "completed"-async def test_active_count_incremented_after_commit(self, client_with_resource_sync: tuple):- """Regression test: active_count must actually increment after commit.-- Previously _update_active_counts() had three bugs:- 1. Called storage.update() with MongoDB-style kwargs (filter=, update=)- that don't match the actual signature update(collection, id, data),- causing a silent TypeError on every commit.- 2. Used $inc syntax which storage.update() does not support (merge semantics- require a plain value, not an increment operator).- 3. Used fetch_by_uri() to locate the record, but that method's path-field- filter returns the entire subtree (hierarchical match), so any URI that- has child records triggers a 'Duplicate records found' error and returns- None — leaving active_count un-updated even after fixes 1 and 2.-- Fix: use storage.filter() to look up the record by URI and read- its stored id, then call storage.update() with that id.- """client, uri = client_with_resource_syncvikingdb = client._client.service.vikingdb_manager# Use the client's own context to match the account_id used when adding the resourcediff --git a/tests/unit/test_skill_processor_none.py b/tests/unit/test_skill_processor_none.pyindex 7e054c88b..17337f9e0 100644--- a/tests/unit/test_skill_processor_none.py+++ b/tests/unit/test_skill_processor_none.py@@ -7,10 +7,14 @@ skill data is None, instead of falling through to the generic'Unsupported data type' error."""+from unittest.mock import AsyncMock, MagicMock+import pytest+from openviking.server.identity import RequestContext, Rolefrom openviking.utils.skill_processor import SkillProcessorfrom openviking_cli.exceptions import InvalidArgumentError+from openviking_cli.session.user_id import UserIdentifierclass TestParseSkillNoneData:@@ -39,6 +43,21 @@ class TestParseSkillNoneData:assert aux_files == []assert base_path is None+ def test_parse_skill_normalizes_hyphenated_allowed_tools(self):+ processor = SkillProcessor(vikingdb=None)+ skill_dict, _, _ = processor._parse_skill(+ {+ "name": "test-skill",+ "description": "A test skill",+ "allowed-tools": ["Read", "Write"],+ "tags": ["test"],+ }+ )++ assert skill_dict["allowed_tools"] == ["Read", "Write"]+ assert "allowed-tools" not in skill_dict+ assert skill_dict["tags"] == ["test"]+@pytest.mark.parametrize("skill_dict", [{}, {"description": "missing name"}])def test_validate_skill_dict_requires_name_field(self, skill_dict):"""Dict skill data should fail fast when required metadata is missing."""@@ -76,3 +95,41 @@ class TestParseSkillNoneData:with pytest.raises(OSError, match="File name too long"):processor._parse_skill(raw_skill)+++async def test_process_skill_preserves_hyphenated_allowed_tools_in_meta(monkeypatch):+ config = MagicMock()+ config.vlm.get_completion_async = AsyncMock(return_value="overview")+ monkeypatch.setattr(+ "openviking.utils.skill_processor.get_openviking_config",+ lambda: config,+ )++ vikingdb = MagicMock()+ vikingdb.enqueue_embedding_msg = AsyncMock(return_value=False)+ viking_fs = MagicMock()+ viking_fs.write_context = AsyncMock()++ processor = SkillProcessor(vikingdb=vikingdb)+ result = await processor.process_skill(+ data={+ "name": "dict-skill",+ "description": "Skill from dict",+ "content": "# Dict Skill",+ "allowed-tools": ["Read"],+ "tags": ["dict"],+ },+ viking_fs=viking_fs,+ ctx=RequestContext(user=UserIdentifier.the_default_user(), role=Role.ROOT),+ allow_local_path_resolution=False,+ )++ assert result["name"] == "dict-skill"+ written_content = viking_fs.write_context.await_args.kwargs["content"]+ assert "allowed-tools:" in written_content+ assert "- Read" in written_content+ assert "tags:" in written_content+ embedding_msg = vikingdb.enqueue_embedding_msg.await_args.args[0]+ assert embedding_msg.context_data["meta"]["allowed_tools"] == ["Read"]+ assert embedding_msg.context_data["meta"]["tags"] == ["dict"]