Skip to content

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

feat(skill): Add extracting skills from session commit processing (#2182)

DuTao96431c17b458
diff --git a/examples/ov.conf.example b/examples/ov.conf.example
index 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.py
index 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.yaml
new file mode 100644
index 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: patch
diff --git a/openviking/service/core.py b/openviking/service/core.py
index 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 initialized
if self._lock_manager:
diff --git a/openviking/session/__init__.py b/openviking/session/__init__.py
index 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 v1
logger.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.py
index 0938155b8..22636aada 100644
--- a/openviking/session/compressor.py
+++ b/openviking/session/compressor.py
@@ -18,6 +18,7 @@ from openviking.storage import VikingDBManager
from openviking.storage.viking_fs import get_viking_fs
from openviking.telemetry import get_current_telemetry
from openviking.telemetry.request_wait_tracker import get_request_wait_tracker
+from openviking.utils.skill_processor import SkillProcessor
from openviking_cli.session.user_id import UserIdentifier
from 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 = vikingdb
self.extractor = MemoryExtractor()
self.deduplicator = MemoryDeduplicator(vikingdb=vikingdb)
+ self.skill_processor = skill_processor
self._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.py
index a00756ac6..9a4e6b3e3 100644
--- a/openviking/session/compressor_v2.py
+++ b/openviking/session/compressor_v2.py
@@ -22,13 +22,16 @@ from openviking.server.identity import RequestContext
from openviking.session.memory import ExtractLoop, MemoryUpdater
from openviking.session.memory.dataclass import ResolvedOperations
from openviking.session.memory.memory_isolation_handler import MemoryIsolationHandler
-from openviking.session.memory.memory_updater import MemoryUpdateResult
+from openviking.session.memory.memory_updater import ExtractContext, MemoryUpdateResult
from openviking.session.memory.utils.json_parser import JsonUtils
from openviking.session.memory.utils.memory_file_utils import MemoryFileUtils
from 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_TYPE
from openviking.storage import VikingDBManager
from openviking.storage.viking_fs import VikingFS, get_viking_fs
from openviking.telemetry import get_current_telemetry, tracer
+from openviking.utils.skill_processor import SkillProcessor
from openviking_cli.session.user_id import UserIdentifier
from openviking_cli.utils import get_logger
from 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_processor
def _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_result
if not messages or not ctx:
- return []
+ return empty_result
from 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_result
contexts.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.content
except 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_result
contexts.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 case
the exception is re-raised).
"""
- from openviking.session.memory.memory_updater import ExtractContext
from openviking.storage.transaction import get_lock_manager, init_lock_manager
config = 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.py
index 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, List
from 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_logger
logger = 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 ctx
registry = 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._registry
diff --git a/openviking/session/memory/extract_loop.py b/openviking/session/memory/extract_loop.py
index 05701baa0..ecd039183 100644
--- a/openviking/session/memory/extract_loop.py
+++ b/openviking/session/memory/extract_loop.py
@@ -166,6 +166,7 @@ class ExtractLoop:
import json
schema_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 Rules
diff --git a/openviking/session/session.py b/openviking/session/session.py
index 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 = 0
telemetry = 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_result
else:
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) + 1
self._stats.memories_extracted += len(agent_extracted)
+ if session_skills:
+ logger.info(f"Extracted {len(session_skills)} session skills")
+ extracted_skill_results = session_skills
else:
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__.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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._registry
diff --git a/openviking/session/skill/skill_operation_updater.py b/openviking/session/skill/skill_operation_updater.py
new file mode 100644
index 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.py
index 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
+
@staticmethod
def _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.py
index 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.py
new file mode 100644
index 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.py
index 490710999..31eb4ded8 100644
--- a/tests/session/test_session_commit.py
+++ b/tests/session/test_session_commit.py
@@ -5,7 +5,7 @@
import asyncio
import json
-from unittest.mock import MagicMock
+from unittest.mock import AsyncMock, MagicMock
import pytest
@@ -58,6 +58,62 @@ class TestCommit:
# Wait for semantic/embedding queues
await 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_overview
assert 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_sync
vikingdb = client._client.service.vikingdb_manager
# Use the client's own context to match the account_id used when adding the resource
diff --git a/tests/unit/test_skill_processor_none.py b/tests/unit/test_skill_processor_none.py
index 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, Role
from openviking.utils.skill_processor import SkillProcessor
from openviking_cli.exceptions import InvalidArgumentError
+from openviking_cli.session.user_id import UserIdentifier
class 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"]