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: add user-scoped memory extraction policies (#3906)
agent6fc4d8fa57a1
diff --git a/docs/en/api/01-overview.md b/docs/en/api/01-overview.mdindex f2f95f049..0dab5dee4 100644--- a/docs/en/api/01-overview.md+++ b/docs/en/api/01-overview.md@@ -484,6 +484,8 @@ This catalog follows the routes actually mounted by the server. Each group headi| DELETE | `/api/v1/admin/accounts/{account_id}` | Delete an account || POST | `/api/v1/admin/accounts/{account_id}/users` | Register a user || GET | `/api/v1/admin/accounts/{account_id}/users` | List users |+| GET | `/api/v1/admin/accounts/{account_id}/users/{user_id}/settings` | Get a user's memory policy |+| PATCH | `/api/v1/admin/accounts/{account_id}/users/{user_id}/settings` | Update a user's memory policy || DELETE | `/api/v1/admin/accounts/{account_id}/users/{user_id}` | Remove a user || PUT | `/api/v1/admin/accounts/{account_id}/users/{user_id}/role` | Promote a user to ADMIN || POST | `/api/v1/admin/accounts/{account_id}/users/{user_id}/key` | Regenerate a user key |diff --git a/docs/en/api/05-sessions.md b/docs/en/api/05-sessions.mdindex 4f2b1b853..a2222c627 100644--- a/docs/en/api/05-sessions.md+++ b/docs/en/api/05-sessions.md@@ -1405,6 +1405,11 @@ Commit a session. Message archiving (Phase 1) completes immediately. Summary gen| session_id | str | Yes | - | Session ID to commit || keep_recent_count | int | No | 0 | Number of recent live messages to retain (kept live, not archived) after commit. `0` (default) archives all messages. |+The effective policy is resolved in this order: Session `.meta.json`, latest+`settings/user_config.json`, then the kernel default. The fully resolved policy+is stored in the queued task before Phase 2 starts. A completed task returns+`effective_memory_policy` and `memory_policy_source` for diagnostics.+#### 3. Usage Examples**HTTP API**diff --git a/docs/en/api/08-admin.md b/docs/en/api/08-admin.mdindex dc9499ec5..08f76c38d 100644--- a/docs/en/api/08-admin.md+++ b/docs/en/api/08-admin.md@@ -117,6 +117,33 @@ Content-Type: application/jsonBefore an existing setting is replaced, it is backed up to`/local/{account_id}/_system/setting.backup.json`.+### user_settings++ROOT can manage any User and ADMIN can manage Users in its own account. The+User settings endpoint currently allowlists only `memory_policy`. Each target+has its own `enabled` switch and `memory_types` filter. Agent memory types are+self-only; configuring them for `peer` is rejected.++```http+GET /api/v1/admin/accounts/{account_id}/users/{user_id}/settings+PATCH /api/v1/admin/accounts/{account_id}/users/{user_id}/settings+Content-Type: application/json++{+ "memory_policy": {+ "self": {"enabled": true, "memory_types": ["profile", "experiences"]},+ "peer": {"enabled": false, "memory_types": []}+ }+}+```++The response contains the User-level `memory_policy`, expanded with its default+memory types and Agent-memory dependencies. It is independent of the+account-level Agent Evolution switch, which is managed through the dedicated+account endpoint. Updates are backed up to the User's+`settings/user_config.backup.json` before replacement. A Session without an+explicit policy reads the latest User policy when it is committed.+---### create_accountdiff --git a/docs/zh/api/01-overview.md b/docs/zh/api/01-overview.mdindex 7bb23870a..970c2dd02 100644--- a/docs/zh/api/01-overview.md+++ b/docs/zh/api/01-overview.md@@ -479,6 +479,8 @@ JSON 输出 - 错误:| DELETE | `/api/v1/admin/accounts/{account_id}` | 删除账号 || POST | `/api/v1/admin/accounts/{account_id}/users` | 注册用户 || GET | `/api/v1/admin/accounts/{account_id}/users` | 列出用户 |+| GET | `/api/v1/admin/accounts/{account_id}/users/{user_id}/settings` | 获取用户记忆策略 |+| PATCH | `/api/v1/admin/accounts/{account_id}/users/{user_id}/settings` | 更新用户记忆策略 || DELETE | `/api/v1/admin/accounts/{account_id}/users/{user_id}` | 移除用户 || PUT | `/api/v1/admin/accounts/{account_id}/users/{user_id}/role` | 将用户提升为 ADMIN || POST | `/api/v1/admin/accounts/{account_id}/users/{user_id}/key` | 重新生成用户 Key |diff --git a/docs/zh/api/05-sessions.md b/docs/zh/api/05-sessions.mdindex 9ceef9439..78ceb9e24 100644--- a/docs/zh/api/05-sessions.md+++ b/docs/zh/api/05-sessions.md@@ -1377,6 +1377,10 @@ curl -X POST http://localhost:1933/api/v1/sessions/a1b2c3d4/used \| session_id | str | 是 | - | 要提交的会话 ID || keep_recent_count | int | 否 | 0 | 提交后保留为 live 状态的最近消息数 (保持 live, 不归档)。`0` (默认) 归档全部消息。 |+有效策略按 Session `.meta.json`、最新 `settings/user_config.json`、内核默认值的+顺序解析。Phase 2 开始前会将完整有效策略固化到异步任务。任务完成结果返回+`effective_memory_policy` 和 `memory_policy_source`,用于排障。+#### 3. 使用示例**HTTP API**diff --git a/docs/zh/api/08-admin.md b/docs/zh/api/08-admin.mdindex 52967bce0..35a7dfdc3 100644--- a/docs/zh/api/08-admin.md+++ b/docs/zh/api/08-admin.md@@ -115,6 +115,30 @@ Content-Type: application/json覆盖已有配置前,内核会先备份到`/local/{account_id}/_system/setting.backup.json`。+### user_settings++ROOT 可管理任意 User,ADMIN 仅可管理所属 account 内的 User。User 配置接口当前+仅允许修改 `memory_policy`。`self` 和 `peer` 分别配置 `enabled` 与+`memory_types`;Agent 记忆只允许写入 self,peer 配置 Agent 记忆类型会被拒绝。++```http+GET /api/v1/admin/accounts/{account_id}/users/{user_id}/settings+PATCH /api/v1/admin/accounts/{account_id}/users/{user_id}/settings+Content-Type: application/json++{+ "memory_policy": {+ "self": {"enabled": true, "memory_types": ["profile", "experiences"]},+ "peer": {"enabled": false, "memory_types": []}+ }+}+```++响应直接返回 User 级 `memory_policy`,并展开默认记忆类型和 Agent 记忆依赖;+该结果不受 account 级 Agent 进化开关影响,Account 开关由独立接口管理。+更新前会备份到该 User 的 `settings/user_config.backup.json`。未显式配置策略的+Session 在 commit 时读取该 User 最新策略。+---### create_accountdiff --git a/openviking/server/config.py b/openviking/server/config.pyindex 0bdd74889..501094350 100644--- a/openviking/server/config.py+++ b/openviking/server/config.py@@ -3,7 +3,7 @@"""Server configuration for OpenViking HTTP Server."""import sys-from typing import Dict, List, Literal, Optional+from typing import Any, Dict, List, Literal, Optionalfrom pydantic import BaseModel, Field, ValidationError, field_validator@@ -103,6 +103,7 @@ class UserConfig(BaseModel):"""User configuration values that can be defaulted or initialized."""add_targets: AddTargetsConfig = Field(default_factory=AddTargetsConfig)+ memory_policy: Optional[Dict[str, Any]] = Noneagent_evolution: DeprecatedUserAgentEvolutionConfig = Field(default_factory=DeprecatedUserAgentEvolutionConfig,exclude=True,@@ -110,6 +111,15 @@ class UserConfig(BaseModel):model_config = {"extra": "forbid"}+ @field_validator("memory_policy", mode="before")+ @classmethod+ def validate_memory_policy(cls, value: Any) -> Optional[Dict[str, Any]]:+ if value is None:+ return None+ from openviking.session.memory_policy import MemoryPolicy++ return MemoryPolicy.from_dict(value).to_dict()+class MetricsAccountDimensionConfig(BaseModel):"""Account-dimension configuration for metrics label injection."""diff --git a/openviking/server/routers/admin.py b/openviking/server/routers/admin.pyindex df626ea19..aa6ca8c4a 100644--- a/openviking/server/routers/admin.py+++ b/openviking/server/routers/admin.py@@ -25,7 +25,13 @@ from openviking.server.config import ServerConfig, UserConfigfrom openviking.server.dependencies import get_servicefrom openviking.server.identity import RequestContext, Rolefrom openviking.server.models import Response-from openviking.server.user_config import validate_add_targets, write_user_config+from openviking.server.user_config import (+ read_user_config,+ validate_add_targets,+ validate_user_memory_policy,+ write_user_config,+ write_user_memory_policy,+)from openviking.service.legacy_migration import LegacyDataMigrationfrom openviking.service.task_store import (SYSTEM_TASK_ACCOUNT_ID,@@ -34,6 +40,8 @@ from openviking.service.task_store import (from openviking.service.task_tracker import (get_task_tracker,)+from openviking.session.memory.memory_type_registry import MemoryTypeRegistry+from openviking.session.memory_policy import MemoryPolicyfrom openviking.storage.viking_fs import get_viking_fsfrom openviking_cli.exceptions import (FailedPreconditionError,@@ -80,6 +88,12 @@ class SetAgentEvolutionRequest(BaseModel):enabled: bool+class UserSettingsPatch(BaseModel):+ memory_policy: dict++ model_config = {"extra": "forbid"}++def _agent_evolution_account_id(ctx: RequestContext) -> str:if ctx.role == Role.ROOT:return get_openviking_config().default_account@@ -177,7 +191,7 @@ def _has_add_targets(user_config: UserConfig | None) -> bool:def _has_initial_user_config(user_config: UserConfig | None) -> bool:- return _has_add_targets(user_config)+ return bool(_has_add_targets(user_config) or (user_config and user_config.memory_policy))def _validate_initial_user_config(@@ -185,15 +199,18 @@ def _validate_initial_user_config(user_ctx: RequestContext,user_config: UserConfig | None,) -> None:- if not _has_add_targets(user_config):+ if not _has_initial_user_config(user_config):returnif service.viking_fs is None:raise FailedPreconditionError("OpenViking service is not initialized.")- validate_add_targets(- user_config.add_targets,- ctx=user_ctx,- viking_fs=service.viking_fs,- )+ if _has_add_targets(user_config):+ validate_add_targets(+ user_config.add_targets,+ ctx=user_ctx,+ viking_fs=service.viking_fs,+ )+ if user_config is not None:+ validate_user_memory_policy(user_config.memory_policy)async def _write_initial_user_config(@@ -206,6 +223,31 @@ async def _write_initial_user_config(await write_user_config(service.viking_fs, user_ctx, user_config)+def _check_user_exists(request: Request, account_id: str, user_id: str) -> None:+ manager = _get_api_key_manager(request)+ if not manager.has_user(account_id, user_id):+ raise NotFoundError(user_id, "user")+++def _user_settings_result(+ account_id: str,+ user_id: str,+ user_config: UserConfig,+) -> dict:+ policy = MemoryPolicy.from_dict(user_config.memory_policy)+ known_memory_types = set(MemoryTypeRegistry().list_names(include_disabled=False))+ policy.validate_memory_types(known_memory_types)+ memory_policy = policy.resolve(+ known_memory_types,+ agent_evolution_enabled=True,+ )+ return {+ "account_id": account_id,+ "user_id": user_id,+ "memory_policy": memory_policy.to_dict(),+ }++async def _run_legacy_migration_task(task_id: str,migration: LegacyDataMigration,@@ -467,6 +509,60 @@ async def list_users(return Response(status="ok", result=users)[email protected]("/accounts/{account_id}/users/{user_id}/settings")+@require_auth_root_or_admin+async def get_user_settings(+ request: Request,+ account_id: str = Path(..., description="Account ID"),+ user_id: str = Path(..., description="User ID"),+ ctx: RequestContext = Depends(get_request_context),+):+ """Return the configured and effective memory policy for one User."""+ _check_account_access(ctx, account_id)+ _check_account_exists(request, account_id)+ _check_user_exists(request, account_id, user_id)+ service = get_service()+ if service.viking_fs is None:+ raise FailedPreconditionError("OpenViking service is not initialized.")+ user_ctx = RequestContext(+ user=UserIdentifier(account_id, user_id),+ role=Role.USER,+ )+ user_config = await read_user_config(service.viking_fs, user_ctx)+ return Response(+ status="ok",+ result=_user_settings_result(account_id, user_id, user_config),+ )++[email protected]("/accounts/{account_id}/users/{user_id}/settings")+@require_auth_root_or_admin+async def patch_user_settings(+ body: UserSettingsPatch,+ request: Request,+ account_id: str = Path(..., description="Account ID"),+ user_id: str = Path(..., description="User ID"),+ ctx: RequestContext = Depends(get_request_context),+):+ """Update the allowlisted User memory policy without restarting the server."""+ _check_account_access(ctx, account_id)+ _check_account_exists(request, account_id)+ _check_user_exists(request, account_id, user_id)+ service = get_service()+ if service.viking_fs is None:+ raise FailedPreconditionError("OpenViking service is not initialized.")+ user_ctx = RequestContext(+ user=UserIdentifier(account_id, user_id),+ role=Role.USER,+ )+ await write_user_memory_policy(service.viking_fs, user_ctx, body.memory_policy)+ user_config = await read_user_config(service.viking_fs, user_ctx)+ return Response(+ status="ok",+ result=_user_settings_result(account_id, user_id, user_config),+ )++@router.delete("/accounts/{account_id}/users/{user_id}", status_code=202)@require_auth_root_or_adminasync def remove_user(diff --git a/openviking/server/user_config.py b/openviking/server/user_config.pyindex 908d5a858..02380ebff 100644--- a/openviking/server/user_config.py+++ b/openviking/server/user_config.py@@ -33,6 +33,10 @@ def user_config_uri(ctx: RequestContext) -> str:return f"{canonical_user_root(ctx)}/settings/user_config.json"+def user_config_backup_uri(ctx: RequestContext) -> str:+ return f"{canonical_user_root(ctx)}/settings/user_config.backup.json"++@asynccontextmanagerasync def _user_config_lock(viking_fs: VikingFS,@@ -69,6 +73,17 @@ def _ensure_mutable(viking_fs: VikingFS, uri: str, ctx: RequestContext) -> None:ensure(uri, ctx)+def validate_user_memory_policy(memory_policy: Optional[dict[str, Any]]) -> None:+ if memory_policy is None:+ return+ from openviking.session.memory.memory_type_registry import MemoryTypeRegistry+ from openviking.session.memory_policy import MemoryPolicy++ MemoryPolicy.from_dict(memory_policy).validate_memory_types(+ set(MemoryTypeRegistry().list_names(include_disabled=False))+ )++def validate_resource_add_target(uri: str,*,@@ -151,17 +166,33 @@ async def update_user_config(before = current.model_dump()result = updater(current)validate_add_targets(current.add_targets, ctx=ctx, viking_fs=viking_fs)+ validate_user_memory_policy(current.memory_policy)if current.model_dump() != before:+ before_content = json.dumps(before, ensure_ascii=False, sort_keys=True)await viking_fs.write_file(- uri,- json.dumps(- current.model_dump(exclude_none=True),- ensure_ascii=False,- sort_keys=True,- ),+ user_config_backup_uri(ctx),+ before_content,ctx=ctx,- lease_ref=handle,)+ try:+ await viking_fs.write_file(+ uri,+ json.dumps(+ current.model_dump(exclude_none=True),+ ensure_ascii=False,+ sort_keys=True,+ ),+ ctx=ctx,+ lease_ref=handle,+ )+ except Exception:+ await viking_fs.write_file(+ uri,+ before_content,+ ctx=ctx,+ lease_ref=handle,+ )+ raisereturn result@@ -171,6 +202,7 @@ async def write_user_config(user_config: UserConfig,) -> ResolvedAddTargets:runtime = validate_add_targets(user_config.add_targets, ctx=ctx, viking_fs=viking_fs)+ validate_user_memory_policy(user_config.memory_policy)uri = user_config_uri(ctx)async with _user_config_lock(viking_fs, uri, ctx) as handle:await viking_fs.write_file(@@ -221,6 +253,30 @@ async def delete_user_add_targets(viking_fs: VikingFS, ctx: RequestContext) -> Nawait update_user_config(viking_fs, ctx, _clear)+async def read_user_memory_policy(+ viking_fs: VikingFS,+ ctx: RequestContext,+) -> Optional[dict[str, Any]]:+ return (await read_user_config(viking_fs, ctx)).memory_policy+++async def write_user_memory_policy(+ viking_fs: VikingFS,+ ctx: RequestContext,+ memory_policy: dict[str, Any],+) -> dict[str, Any]:+ normalized = UserConfig(memory_policy=memory_policy).memory_policy+ if normalized is None:+ raise InvalidArgumentError("memory_policy must be an object")+ validate_user_memory_policy(normalized)++ def _set(user_config: UserConfig) -> None:+ user_config.memory_policy = normalized++ await update_user_config(viking_fs, ctx, _set)+ return normalized++async def effective_resource_add_target(*,viking_fs: VikingFS,diff --git a/openviking/service/session_service.py b/openviking/service/session_service.pyindex 0273a1ba8..9953572d6 100644--- a/openviking/service/session_service.py+++ b/openviking/service/session_service.py@@ -15,6 +15,7 @@ from openviking.core.namespace import canonical_session_urifrom openviking.server.agent_evolution_config import AgentEvolutionConfigProviderfrom openviking.server.config import AgentEvolutionConfig, ToolOutputExternalizationConfigfrom openviking.server.identity import RequestContext+from openviking.server.user_config import read_user_configfrom openviking.service.session_auto_commit import (compute_next_check_at,get_idle_timeout_seconds,@@ -200,9 +201,15 @@ class SessionService:agent_evolution_enabled_provider=lambda: self.get_agent_evolution_enabled(ctx.account_id),+ memory_policy_provider=lambda: self._get_user_memory_policy(ctx),usage_reporter=self._usage_reporter,)+ async def _get_user_memory_policy(self, ctx: RequestContext) -> Optional[Dict[str, Any]]:+ """Read the latest persisted User policy at commit time."""+ config = await read_user_config(self._viking_fs, ctx)+ return config.memory_policy+async def create(self,ctx: RequestContext,@@ -240,7 +247,14 @@ class SessionService:policy.validate_memory_types(set(MemoryTypeRegistry().list_names(include_disabled=False)))- session.meta.memory_policy = policy.to_dict()+ has_target_memory_types = not isinstance(memory_policy, dict) or any(+ isinstance(memory_policy.get(target), dict)+ and "memory_types" in memory_policy[target]+ for target in ("self", "peer")+ )+ session.meta.memory_policy = (+ policy.to_dict() if has_target_memory_types else policy.to_legacy_dict()+ )# Auto-commit is enabled when the caller supplies a policy, or when# the server default turns it on. Absent both, it stays disabled.if update_auto_commit_policy and auto_commit_policy is None:diff --git a/openviking/session/compressor_v3.py b/openviking/session/compressor_v3.pyindex c568d3b86..22840e3f3 100644--- a/openviking/session/compressor_v3.py+++ b/openviking/session/compressor_v3.py@@ -359,6 +359,8 @@ class SessionCompressorV3:latest_archive_overview: str = "",archive_uri: Optional[str] = None,allowed_memory_types: Optional[set[str]] = None,+ allowed_self_memory_types: Optional[set[str]] = None,+ allowed_peer_memory_types: Optional[set[str]] = None,agent_evolution_enabled: bool = True,allow_self_memory: bool = True,allowed_peer_ids: Optional[set[str]] = None,@@ -371,12 +373,22 @@ class SessionCompressorV3:else set(allowed_memory_types))allowed_memory_types = effective_types - AGENT_EVOLUTION_MEMORY_TYPES+ if allowed_self_memory_types is not None:+ allowed_self_memory_types = (+ set(allowed_self_memory_types) - AGENT_EVOLUTION_MEMORY_TYPES+ )+ if allowed_peer_memory_types is not None:+ allowed_peer_memory_types = (+ set(allowed_peer_memory_types) - AGENT_EVOLUTION_MEMORY_TYPES+ )message_list = list(messages)- fast_path_case = _training_case_from_first_message(- message_list,- allowed_memory_types,+ self_types = (+ allowed_self_memory_types+ if allowed_self_memory_types is not None+ else allowed_memory_types)+ fast_path_case = _training_case_from_first_message(message_list, self_types)try:if fast_path_case is not None:return await self._commit_training_case_fast_path(@@ -387,7 +399,7 @@ class SessionCompressorV3:archive_uri=archive_uri or "",strict_extract_errors=strict_extract_errors,agent_evolution_enabled=agent_evolution_enabled,- allowed_memory_types=allowed_memory_types,+ allowed_memory_types=self_types,)result = await self._extract_user_memories(@@ -399,14 +411,14 @@ class SessionCompressorV3:latest_archive_overview=latest_archive_overview,archive_uri=archive_uri,allowed_memory_types=allowed_memory_types,+ allowed_self_memory_types=allowed_self_memory_types,+ allowed_peer_memory_types=allowed_peer_memory_types,allow_self_memory=allow_self_memory,allowed_peer_ids=allowed_peer_ids,event_search_tags=event_search_tags,)- agent_memory_types = _allowed_agent_memory_types(allowed_memory_types)- cases_allowed = (- allowed_memory_types is None or _CASES_MEMORY_TYPE in allowed_memory_types- )+ agent_memory_types = _allowed_agent_memory_types(self_types)+ cases_allowed = self_types is None or _CASES_MEMORY_TYPE in self_typessession_skills_enabled = self._session_skill_extraction_enabled()if (agent_evolution_enabled@@ -600,6 +612,8 @@ class SessionCompressorV3:latest_archive_overview: str = "",archive_uri: Optional[str] = None,allowed_memory_types: Optional[set[str]] = None,+ allowed_self_memory_types: Optional[set[str]] = None,+ allowed_peer_memory_types: Optional[set[str]] = None,allow_self_memory: bool = True,allowed_peer_ids: Optional[set[str]] = None,event_search_tags: Optional[List[str]] = None,@@ -623,7 +637,11 @@ class SessionCompressorV3:if allow_self_memory:await registry.initialize_memory_files(ctx,- allowed_memory_types=allowed_memory_types,+ allowed_memory_types=(+ allowed_self_memory_types+ if allowed_self_memory_types is not None+ else allowed_memory_types+ ),)context_provider = SessionExtractContextProvider(@@ -642,6 +660,8 @@ class SessionCompressorV3:allowed_memory_types=allowed_memory_types,allow_self=allow_self_memory,allowed_peer_ids=allowed_peer_ids,+ allowed_self_memory_types=allowed_self_memory_types,+ allowed_peer_memory_types=allowed_peer_memory_types,)isolation_handler.prepare_messages()context_provider._isolation_handler = isolation_handler@@ -682,6 +702,8 @@ class SessionCompressorV3:"allowed_memory_types": allowed_memory_types,"allow_self": allow_self_memory,"allowed_peer_ids": allowed_peer_ids,+ "allowed_self_memory_types": allowed_self_memory_types,+ "allowed_peer_memory_types": allowed_peer_memory_types,},metadata={"source_extraction_id": extraction_id,diff --git a/openviking/session/memory/memory_isolation_handler.py b/openviking/session/memory/memory_isolation_handler.pyindex d7ffd2392..180922013 100644--- a/openviking/session/memory/memory_isolation_handler.py+++ b/openviking/session/memory/memory_isolation_handler.py@@ -43,6 +43,8 @@ class MemoryIsolationHandler:allowed_memory_types: Optional[Set[str]] = None,allow_self: bool = True,allowed_peer_ids: Optional[Set[str]] = None,+ allowed_self_memory_types: Optional[Set[str]] = None,+ allowed_peer_memory_types: Optional[Set[str]] = None,):self.ctx = ctxself._extract_context = extract_context@@ -51,6 +53,16 @@ class MemoryIsolationHandler:if allowed_memory_types is not Noneelse None)+ self.allowed_self_memory_types = (+ {str(item) for item in allowed_self_memory_types}+ if allowed_self_memory_types is not None+ else self.allowed_memory_types+ )+ self.allowed_peer_memory_types = (+ {str(item) for item in allowed_peer_memory_types}+ if allowed_peer_memory_types is not None+ else self.allowed_memory_types+ )peer_ids = {itemfor item in (safe_peer_id(item) for item in allowed_peer_ids or set())@@ -125,11 +137,23 @@ class MemoryIsolationHandler:memory_type = getattr(memory_type_schema, "memory_type", "")if memory_type in _INTERNAL_MEMORY_TYPES:return True- if self.allowed_memory_types is not None and memory_type not in self.allowed_memory_types:- return False- if not self.allow_self and not getattr(memory_type_schema, "peer_enabled", True):- return False- return True+ self_allowed = self.allow_self and self._allows_self_type(memory_type)+ peer_allowed = (+ self.allow_peer+ and getattr(memory_type_schema, "peer_enabled", True)+ and self._allows_peer_type(memory_type)+ )+ return self_allowed or peer_allowed++ def _allows_self_type(self, memory_type: str) -> bool:+ return (+ self.allowed_self_memory_types is None or memory_type in self.allowed_self_memory_types+ )++ def _allows_peer_type(self, memory_type: str) -> bool:+ return (+ self.allowed_peer_memory_types is None or memory_type in self.allowed_peer_memory_types+ )def _can_write_peer(self, peer_id: str) -> bool:return self.allow_peer and peer_id in self.allowed_peer_ids@@ -180,9 +204,14 @@ class MemoryIsolationHandler:user_id = self.ctx.user.user_id if self.ctx and self.ctx.user else "default"user_space = user_iduser_spaces: List[str] = []- if self.allow_self:+ memory_type = getattr(memory_type_schema, "memory_type", "")+ if self.allow_self and self._allows_self_type(memory_type):user_spaces.append(user_space)- if self.allow_peer and getattr(memory_type_schema, "peer_enabled", True):+ if (+ self.allow_peer+ and getattr(memory_type_schema, "peer_enabled", True)+ and self._allows_peer_type(memory_type)+ ):for peer_id in sorted(self.allowed_peer_ids):user_spaces.append(peer_user_space(user_space, peer_id))@@ -247,12 +276,15 @@ class MemoryIsolationHandler:user_id = self.ctx.user.user_idoperation.memory_fields["user_id"] = user_id+ memory_type = getattr(memory_type_schema, "memory_type", "")target_ids: List[str] = []has_ranges = operation.memory_fields.get("ranges") is not Noneif not getattr(memory_type_schema, "peer_enabled", True):operation.memory_fields.pop("peer_id", None)- target_ids = [_SELF_PEER_ID] if self.allow_self else []+ target_ids = (+ [_SELF_PEER_ID] if self.allow_self and self._allows_self_type(memory_type) else []+ )elif operation.memory_fields.get("ranges") is not None:target_ids, can_fallback = self._range_targets(operation.memory_fields.get("ranges"),@@ -263,9 +295,11 @@ class MemoryIsolationHandler:target_ids = [fallback_target]operation.memory_fields.pop("peer_id", None)else:- target_id = self._resolve_operation_target_id(- operation.memory_fields.get("peer_id"),- )+ raw_peer_id = operation.memory_fields.get("peer_id")+ if raw_peer_id in (None, "") and not self._allows_self_type(memory_type):+ target_id = self._unique_peer_target_id_in_messages()+ else:+ target_id = self._resolve_operation_target_id(raw_peer_id)if target_id:target_ids = [target_id]if target_id == _SELF_PEER_ID:@@ -278,6 +312,15 @@ class MemoryIsolationHandler:if not target_ids:return []+ target_ids = [+ target_id+ for target_id in target_ids+ if (target_id == _SELF_PEER_ID and self._allows_self_type(memory_type))+ or (target_id != _SELF_PEER_ID and self._allows_peer_type(memory_type))+ ]+ if not target_ids:+ return []+# 文件uris = set()user_space = user_iddiff --git a/openviking/session/memory/streaming_memory_updater.py b/openviking/session/memory/streaming_memory_updater.pyindex 05c6e087b..67153a72b 100644--- a/openviking/session/memory/streaming_memory_updater.py+++ b/openviking/session/memory/streaming_memory_updater.py@@ -1836,6 +1836,8 @@ def _make_isolation_handler(allowed_memory_types=options.get("allowed_memory_types"),allow_self=options.get("allow_self", True),allowed_peer_ids=options.get("allowed_peer_ids"),+ allowed_self_memory_types=options.get("allowed_self_memory_types"),+ allowed_peer_memory_types=options.get("allowed_peer_memory_types"),)diff --git a/openviking/session/memory_policy.py b/openviking/session/memory_policy.pyindex a56ffec76..71a375cb2 100644--- a/openviking/session/memory_policy.py+++ b/openviking/session/memory_policy.py@@ -15,10 +15,14 @@ from openviking.session.memory.constants import (from openviking_cli.exceptions import InvalidArgumentError_POLICY_KEYS = {"self", "peer", "memory_types", "working_memory"}-_TARGET_KEYS = {"enabled"}+_TARGET_KEYS = {"enabled", "memory_types"}+_WORKING_MEMORY_KEYS = {"enabled"}_TRUE_STRINGS = {"1", "true", "yes", "on"}_FALSE_STRINGS = {"", "0", "false", "no", "off"}+AGENT_MEMORY_TYPES = {"cases", "trajectories", "experiences"}+_EXPERIENCE_DEPENDENCIES = AGENT_MEMORY_TYPES+def _memory_policy_shape_error(key: str) -> str:if key == "working_memory":@@ -29,7 +33,7 @@ def _memory_policy_shape_error(key: str) -> str:def _memory_policy_keys_error(key: str) -> str:if key == "working_memory":return "memory_policy.working_memory supports only: enabled"- return "memory_policy target supports only: enabled"+ return "memory_policy target supports only: enabled, memory_types"def _parse_enabled(value: Any, *, key: str) -> bool:@@ -48,51 +52,78 @@ def _parse_enabled(value: Any, *, key: str) -> bool:if normalized in _FALSE_STRINGS:return False- # Preserve the permissive pre-v0.5 behavior for uncommon legacy values.- # This avoids breaking persisted policy dictionaries while callers migrate- # to genuine JSON booleans.return bool(value)-def _target_enabled(data: Any, *, default_enabled: bool, key: str = "target") -> bool:- if data is None:- return default_enabled- if not isinstance(data, dict):- raise InvalidArgumentError(_memory_policy_shape_error(key))- extra_keys = set(data) - _TARGET_KEYS- if extra_keys:- raise InvalidArgumentError(_memory_policy_keys_error(key))- if "enabled" not in data:- return default_enabled- return _parse_enabled(data["enabled"], key=key)---def _parse_memory_types(data: Any) -> Optional[set[str]]:+def _parse_memory_types(+ data: Any,+ *,+ field: str,+ normalize_agent_dependencies: bool = False,+) -> Optional[set[str]]:if data is None:return Noneif not isinstance(data, list):- raise InvalidArgumentError("memory_policy.memory_types must be a list")+ raise InvalidArgumentError(f"{field} must be a list")memory_types = set()for item in data:if not isinstance(item, str) or not item:- raise InvalidArgumentError("memory_policy.memory_types must contain non-empty strings")+ raise InvalidArgumentError(f"{field} must contain non-empty strings")memory_types.add(item)- if EXPERIENCE_MEMORY_TYPE in memory_types:- memory_types.update(AGENT_EVOLUTION_MEMORY_TYPES)- else:- memory_types.difference_update(AGENT_EVOLUTION_MEMORY_TYPES)+ if normalize_agent_dependencies:+ if EXPERIENCE_MEMORY_TYPE in memory_types:+ memory_types.update(AGENT_EVOLUTION_MEMORY_TYPES)+ else:+ memory_types.difference_update(AGENT_EVOLUTION_MEMORY_TYPES)return memory_types+def _parse_target(+ data: Any,+ *,+ default_enabled: bool,+ key: str,+) -> tuple[bool, Optional[set[str]], bool]:+ if data is None:+ return default_enabled, None, False+ if not isinstance(data, dict):+ raise InvalidArgumentError(_memory_policy_shape_error(key))+ allowed_keys = _WORKING_MEMORY_KEYS if key == "working_memory" else _TARGET_KEYS+ extra_keys = set(data) - allowed_keys+ if extra_keys:+ raise InvalidArgumentError(_memory_policy_keys_error(key))+ enabled = _parse_enabled(data["enabled"], key=key) if "enabled" in data else default_enabled+ if key == "working_memory":+ return enabled, None, False+ has_memory_types = "memory_types" in data+ memory_types = _parse_memory_types(+ data.get("memory_types"),+ field=f"memory_policy.{key}.memory_types",+ )+ return enabled, memory_types, has_memory_types++@dataclassclass MemoryPolicy:- """Effective memory policy for one commit."""+ """Effective memory policy for one commit.++ ``self`` and ``peer`` have independent type filters. The legacy top-level+ ``memory_types`` input is still accepted and normalized into this shape.+ """self_enabled: bool = Truepeer_enabled: bool = True- memory_types: Optional[set[str]] = None+ self_memory_types: Optional[set[str]] = None+ peer_memory_types: Optional[set[str]] = Noneworking_memory_enabled: bool = True+ @property+ def memory_types(self) -> Optional[set[str]]:+ """Compatibility view used by callers that only need the union."""+ if self.self_memory_types is None or self.peer_memory_types is None:+ return None+ return set(self.self_memory_types) | set(self.peer_memory_types)+@classmethoddef default(cls) -> "MemoryPolicy":return cls()@@ -110,31 +141,107 @@ class MemoryPolicy:raise InvalidArgumentError("memory_policy supports only: " + ", ".join(sorted(_POLICY_KEYS)))++ self_enabled, self_types, self_types_explicit = _parse_target(+ data.get("self"), default_enabled=True, key="self"+ )+ peer_enabled, peer_types, peer_types_explicit = _parse_target(+ data.get("peer"), default_enabled=True, key="peer"+ )+ working_enabled, _, _ = _parse_target(+ data.get("working_memory"), default_enabled=True, key="working_memory"+ )++ legacy_types = _parse_memory_types(+ data.get("memory_types"),+ field="memory_policy.memory_types",+ normalize_agent_dependencies=True,+ )+ if not self_types_explicit:+ self_types = None if legacy_types is None else set(legacy_types)+ if not peer_types_explicit:+ peer_types = None if legacy_types is None else set(legacy_types) - AGENT_MEMORY_TYPES++ if peer_types and peer_types & AGENT_MEMORY_TYPES:+ raise InvalidArgumentError(+ "memory_policy.peer.memory_types does not support agent memory types: "+ + ", ".join(sorted(peer_types & AGENT_MEMORY_TYPES))+ )+return cls(- self_enabled=_target_enabled(data.get("self"), default_enabled=True, key="self"),- peer_enabled=_target_enabled(data.get("peer"), default_enabled=True, key="peer"),- memory_types=_parse_memory_types(data.get("memory_types")),- working_memory_enabled=_target_enabled(- data.get("working_memory"), default_enabled=True, key="working_memory"- ),+ self_enabled=self_enabled,+ peer_enabled=peer_enabled,+ self_memory_types=self_types,+ peer_memory_types=peer_types,+ working_memory_enabled=working_enabled,)def validate_memory_types(self, known_memory_types: set[str]) -> None:- if self.memory_types is None:- return- unknown = self.memory_types - known_memory_types+ configured = set()+ if self.self_memory_types is not None:+ configured.update(self.self_memory_types)+ if self.peer_memory_types is not None:+ configured.update(self.peer_memory_types)+ unknown = configured - known_memory_typesif unknown:raise InvalidArgumentError(- "Unknown memory_policy.memory_types: " + ", ".join(sorted(unknown))+ "Unknown memory_policy memory types: " + ", ".join(sorted(unknown)))+ def resolve(+ self,+ known_memory_types: set[str],+ *,+ agent_evolution_enabled: bool,+ ) -> "MemoryPolicy":+ """Expand defaults and apply the account-scoped Agent switch."""+ self_types = (+ set(known_memory_types)+ if self.self_memory_types is None+ else set(self.self_memory_types)+ )+ if "experiences" in self_types:+ self_types.update(_EXPERIENCE_DEPENDENCIES)+ else:+ self_types.difference_update(AGENT_MEMORY_TYPES)+ peer_types = (+ set(known_memory_types) - AGENT_MEMORY_TYPES+ if self.peer_memory_types is None+ else set(self.peer_memory_types)+ )+ if not agent_evolution_enabled:+ self_types -= AGENT_MEMORY_TYPES+ return MemoryPolicy(+ self_enabled=self.self_enabled,+ peer_enabled=self.peer_enabled,+ self_memory_types=self_types,+ peer_memory_types=peer_types,+ working_memory_enabled=self.working_memory_enabled,+ )+def to_dict(self) -> dict[str, Any]:+ self_target: dict[str, Any] = {"enabled": self.self_enabled}+ peer_target: dict[str, Any] = {"enabled": self.peer_enabled}+ if self.self_memory_types is not None:+ self_target["memory_types"] = sorted(self.self_memory_types)+ if self.peer_memory_types is not None:+ peer_target["memory_types"] = sorted(self.peer_memory_types)+ data: dict[str, Any] = {+ "self": self_target,+ "peer": peer_target,+ }+ if not self.working_memory_enabled:+ data["working_memory"] = {"enabled": False}+ return data++ def to_legacy_dict(self) -> dict[str, Any]:+ """Serialize a policy parsed from the legacy shared memory_types shape."""data: dict[str, Any] = {"self": {"enabled": self.self_enabled},"peer": {"enabled": self.peer_enabled},}if not self.working_memory_enabled:data["working_memory"] = {"enabled": False}- if self.memory_types is not None:- data["memory_types"] = sorted(self.memory_types)+ if self.self_memory_types is not None:+ data["memory_types"] = sorted(self.self_memory_types)return datadiff --git a/openviking/session/session.py b/openviking/session/session.pyindex f395da841..d3fa58d7d 100644--- a/openviking/session/session.py+++ b/openviking/session/session.py@@ -105,8 +105,6 @@ def _enabled_memory_types() -> set[str]:def _validate_memory_policy_types(policy: MemoryPolicy) -> None:- if policy.memory_types is None:- returnpolicy.validate_memory_types(_enabled_memory_types())@@ -115,24 +113,30 @@ def _apply_agent_evolution_setting(*,agent_evolution_enabled: bool,) -> MemoryPolicy:- if agent_evolution_enabled:- return policy- effective_types = (- _enabled_memory_types() if policy.memory_types is None else set(policy.memory_types)- )- effective_types -= AGENT_EVOLUTION_MEMORY_TYPES- return MemoryPolicy(- self_enabled=policy.self_enabled,- peer_enabled=policy.peer_enabled,- memory_types=effective_types,- working_memory_enabled=policy.working_memory_enabled,+ return policy.resolve(+ _enabled_memory_types(),+ agent_evolution_enabled=agent_evolution_enabled,)-def _effective_memory_types(policy: MemoryPolicy) -> set[str]:- if policy.memory_types is None:+def _effective_self_memory_types(policy: MemoryPolicy) -> set[str]:+ if not policy.self_enabled:+ return set()+ if policy.self_memory_types is None:return _enabled_memory_types()- return set(policy.memory_types)+ return set(policy.self_memory_types)+++def _effective_peer_memory_types(policy: MemoryPolicy) -> set[str]:+ if not policy.peer_enabled:+ return set()+ if policy.peer_memory_types is None:+ return _enabled_memory_types() - AGENT_EVOLUTION_MEMORY_TYPES+ return set(policy.peer_memory_types)+++def _effective_memory_types(policy: MemoryPolicy) -> set[str]:+ return _effective_self_memory_types(policy) | _effective_peer_memory_types(policy)def _agent_memory_skip_reason(@@ -186,6 +190,8 @@ class _MemoryExtractionScope:allow_self_memory: boolallowed_peer_ids: set[str]include_session_skills: bool+ self_memory_types: set[str]+ peer_memory_types: set[str]memory_types: Optional[set[str]]@@ -198,12 +204,29 @@ def _resolve_memory_extraction_scope() -> _MemoryExtractionScope:allow_self_memory = policy.self_enabledallowed_peer_ids = _message_peer_ids(messages) if policy.peer_enabled else set()+ configured_scope_types: list[Optional[set[str]]] = []+ if allow_self_memory:+ configured_scope_types.append(policy.self_memory_types)+ if allowed_peer_ids:+ configured_scope_types.append(policy.peer_memory_types)+ if not configured_scope_types:+ combined_memory_types: Optional[set[str]] = set()+ elif any(memory_types is None for memory_types in configured_scope_types):+ combined_memory_types = None+ else:+ combined_memory_types = set().union(+ *(memory_types or set() for memory_types in configured_scope_types)+ )return _MemoryExtractionScope(allow_self_memory=allow_self_memory,allowed_peer_ids=allowed_peer_ids,include_session_skills=config_session_skill_extraction_enabled and allow_self_memory,- memory_types=policy.memory_types,+ self_memory_types=(_effective_self_memory_types(policy) if allow_self_memory else set()),+ peer_memory_types=(+ _effective_peer_memory_types(policy) if allowed_peer_ids else set()+ ),+ memory_types=combined_memory_types,)@@ -595,6 +618,7 @@ class Session:agent_evolution_enabled: bool = True,usage_reporter: Optional["UsageReporter"] = None,agent_evolution_enabled_provider: Optional[Callable[[], bool | Awaitable[bool]]] = None,+ memory_policy_provider: Optional[Callable[[], Any | Awaitable[Any]]] = None,):self._viking_fs = viking_fsself._vikingdb_manager = vikingdb_manager@@ -627,8 +651,15 @@ class Session:)self._agent_evolution_enabled = agent_evolution_enabledself._agent_evolution_enabled_provider = agent_evolution_enabled_provider+ self._memory_policy_provider = memory_policy_providerself._usage_reporter = usage_reporter+ async def _provided_memory_policy(self) -> Any:+ if self._memory_policy_provider is None:+ return None+ provided = self._memory_policy_provider()+ return await provided if inspect.isawaitable(provided) else provided+async def load(self):"""Load session data from storage."""if self._loaded:@@ -1852,9 +1883,15 @@ class Session:if turn_mode and effective_token_budget <= 0:raise ValueError("retained_message_token_budget must be greater than 0")in_memory_default_memory_policy = self._meta.memory_policy- effective_policy = MemoryPolicy.from_dict(- memory_policy if memory_policy is not None else self._meta.memory_policy- )+ initial_policy = memory_policy+ memory_policy_source = "commit"+ if initial_policy is None:+ initial_policy = self._meta.memory_policy+ memory_policy_source = "session"+ if initial_policy is None:+ initial_policy = await self._provided_memory_policy()+ memory_policy_source = "user" if initial_policy is not None else "default"+ effective_policy = MemoryPolicy.from_dict(initial_policy)_validate_memory_policy_types(effective_policy)agent_evolution_enabled = self._agent_evolution_enabledif self._agent_evolution_enabled_provider is not None:@@ -1869,10 +1906,9 @@ class Session:agent_evolution_enabled=agent_evolution_enabled,)effective_memory_policy = effective_policy.to_dict()- effective_memory_types = sorted(_effective_memory_types(effective_policy))agent_memory_skip_reason = _agent_memory_skip_reason(agent_evolution_enabled=agent_evolution_enabled,- effective_memory_types=set(effective_memory_types),+ effective_memory_types=_effective_self_memory_types(effective_policy),)logger.info(f"[TRACER] session_commit started, trace_id={trace_id}, "@@ -1930,17 +1966,21 @@ class Session:# messages being archived, unless this commit supplied an explicit# override.if memory_policy is None:- effective_policy = MemoryPolicy.from_dict(self._meta.memory_policy)+ resolved_policy = self._meta.memory_policy+ memory_policy_source = "session"+ if resolved_policy is None:+ resolved_policy = await self._provided_memory_policy()+ memory_policy_source = "user" if resolved_policy is not None else "default"+ effective_policy = MemoryPolicy.from_dict(resolved_policy)_validate_memory_policy_types(effective_policy)effective_policy = _apply_agent_evolution_setting(effective_policy,agent_evolution_enabled=agent_evolution_enabled,)effective_memory_policy = effective_policy.to_dict()- effective_memory_types = sorted(_effective_memory_types(effective_policy))agent_memory_skip_reason = _agent_memory_skip_reason(agent_evolution_enabled=agent_evolution_enabled,- effective_memory_types=set(effective_memory_types),+ effective_memory_types=_effective_self_memory_types(effective_policy),)self._compression.compression_index = max(@@ -2045,6 +2085,7 @@ class Session:archive_uri=archive_uri,user=self.ctx.user.to_dict(),memory_policy=effective_memory_policy,+ memory_policy_source=memory_policy_source,usage_uris=list(dict.fromkeys(u.uri for u in usage_snapshot if u.uri)),record_auto_commit_success=record_auto_commit_success,event_search_tags=list(effective_event_tags),@@ -2309,7 +2350,8 @@ class Session:usage_records=[Usage(uri=uri, type="context") for uri in msg.usage_uris],first_message_id=archive_messages[0].id,last_message_id=archive_messages[-1].id,- memory_policy=msg.memory_policy,+ memory_policy=queued_policy.to_dict(),+ memory_policy_source=msg.memory_policy_source,agent_evolution_enabled=agent_evolution_enabled,agent_memory_skip_reason=agent_memory_skip_reason,user_config_error=user_config_error,@@ -2350,6 +2392,7 @@ class Session:first_message_id: str,last_message_id: str,memory_policy: Optional[Dict[str, Any]],+ memory_policy_source: str = "unknown",agent_evolution_enabled: bool = True,agent_memory_skip_reason: Optional[str] = None,user_config_error: Optional[str] = None,@@ -2552,6 +2595,8 @@ class Session:)self_memory_enabled = extraction_scope.allow_self_memoryallowed_peer_ids = extraction_scope.allowed_peer_ids+ self_long_term_memory_types = extraction_scope.self_memory_types+ peer_long_term_memory_types = extraction_scope.peer_memory_typeslong_term_memory_types = extraction_scope.memory_typeslong_term_messages = [@@ -2596,6 +2641,8 @@ class Session:latest_archive_overview=latest_archive_overview,archive_uri=archive_uri,allowed_memory_types=long_term_memory_types,+ allowed_self_memory_types=self_long_term_memory_types,+ allowed_peer_memory_types=peer_long_term_memory_types,agent_evolution_enabled=agent_evolution_enabled,allow_self_memory=self_memory_enabled,allowed_peer_ids=allowed_peer_ids,@@ -2769,6 +2816,8 @@ class Session:"effective_memory_types": sorted(_effective_memory_types(MemoryPolicy.from_dict(memory_policy))),+ "effective_memory_policy": MemoryPolicy.from_dict(memory_policy).to_dict(),+ "memory_policy_source": memory_policy_source,"agent_evolution_enabled": agent_evolution_enabled,"agent_memory_skip_reason": agent_memory_skip_reason,"token_usage": {diff --git a/openviking/storage/queuefs/session_commit_msg.py b/openviking/storage/queuefs/session_commit_msg.pyindex b4ab6170f..820d56fc9 100644--- a/openviking/storage/queuefs/session_commit_msg.py+++ b/openviking/storage/queuefs/session_commit_msg.py@@ -14,6 +14,7 @@ class SessionCommitMsg:archive_uri: struser: Dict[str, str]memory_policy: Dict[str, Any] = field(default_factory=dict)+ memory_policy_source: str = "unknown"usage_uris: List[str] = field(default_factory=list)# When True, Phase 2's final meta merge also clears the auto-commit error# fields and stamps last_auto_commit_at. Defaults keep old producers working.diff --git a/tests/server/test_admin_api.py b/tests/server/test_admin_api.pyindex 82b378ab5..873d72999 100644--- a/tests/server/test_admin_api.py+++ b/tests/server/test_admin_api.py@@ -22,7 +22,11 @@ from openviking.server.config import ServerConfigfrom openviking.server.dependencies import set_servicefrom openviking.server.identity import RequestContext, Rolefrom openviking.server.models import ERROR_CODE_TO_HTTP_STATUS, ErrorInfo, Response-from openviking.server.user_config import read_user_add_targets, read_user_config+from openviking.server.user_config import (+ read_user_add_targets,+ read_user_config,+ user_config_backup_uri,+)from openviking.service.core import OpenVikingServicefrom openviking.service.task_store import (SYSTEM_TASK_ACCOUNT_ID,@@ -82,6 +86,7 @@ class _FakeVikingFS:def __init__(self):self.agfs = _FakeAGFS()self.files = {}+ self.writes = []async def read_file(self, uri, **_kwargs):if uri not in self.files:@@ -89,6 +94,7 @@ class _FakeVikingFS:return self.files[uri]async def write_file(self, uri, content, **_kwargs):+ self.writes.append(uri)self.files[uri] = contentasync def rm(self, uri, **_kwargs):@@ -98,6 +104,11 @@ class _FakeVikingFS:class _FakeService:def __init__(self):self.viking_fs = _FakeVikingFS()+ self.sessions = self++ async def get_agent_evolution_enabled(self, account_id):+ del account_id+ return Trueasync def initialize_account_directories(self, ctx):return None@@ -324,6 +335,84 @@ async def test_create_user_paths_accept_initial_user_config(assert bob_settings.resource_uri == "viking://user/resources/bob"+async def test_user_memory_policy_can_be_initialized_and_hot_updated(+ lightweight_admin_client: httpx.AsyncClient,+ lightweight_admin_app: FastAPI,+):+ acct = _uid()+ create_account = await lightweight_admin_client.post(+ "/api/v1/admin/accounts",+ json={"account_id": acct, "admin_user_id": "alice"},+ headers=root_headers(),+ )+ assert create_account.status_code == 200, create_account.text++ create_user = await lightweight_admin_client.post(+ f"/api/v1/admin/accounts/{acct}/users",+ json={+ "user_id": "bob",+ "role": "user",+ "user_config": {+ "memory_policy": {+ "self": {"enabled": True, "memory_types": ["profile"]},+ "peer": {"enabled": False, "memory_types": []},+ }+ },+ },+ headers=root_headers(),+ )+ assert create_user.status_code == 200, create_user.text++ get_settings = await lightweight_admin_client.get(+ f"/api/v1/admin/accounts/{acct}/users/bob/settings",+ headers=root_headers(),+ )+ assert get_settings.status_code == 200, get_settings.text+ assert get_settings.json()["result"]["memory_policy"]["self"] == {+ "enabled": True,+ "memory_types": ["profile"],+ }++ patch_settings = await lightweight_admin_client.patch(+ f"/api/v1/admin/accounts/{acct}/users/bob/settings",+ json={+ "memory_policy": {+ "self": {"enabled": True, "memory_types": ["experiences"]},+ "peer": {"enabled": True, "memory_types": ["events"]},+ }+ },+ headers=root_headers(),+ )+ assert patch_settings.status_code == 200, patch_settings.text+ memory_policy = patch_settings.json()["result"]["memory_policy"]+ assert memory_policy["self"]["memory_types"] == [+ "cases",+ "experiences",+ "trajectories",+ ]+ assert memory_policy["peer"]["memory_types"] == ["events"]++ viking_fs = lightweight_admin_app.state.fake_service.viking_fs+ persisted = await read_user_config(+ viking_fs,+ RequestContext(user=UserIdentifier(acct, "bob"), role=Role.USER),+ )+ assert persisted.memory_policy["self"]["memory_types"] == ["experiences"]+ assert persisted.memory_policy["peer"]["memory_types"] == ["events"]+ user_ctx = RequestContext(user=UserIdentifier(acct, "bob"), role=Role.USER)+ backup = json.loads(viking_fs.files[user_config_backup_uri(user_ctx)])+ assert backup["memory_policy"]["self"]["memory_types"] == ["profile"]++ writes_before_noop = len(viking_fs.writes)+ noop_patch = await lightweight_admin_client.patch(+ f"/api/v1/admin/accounts/{acct}/users/bob/settings",+ json={"memory_policy": persisted.memory_policy},+ headers=root_headers(),+ )+ assert noop_patch.status_code == 200, noop_patch.text+ assert len(viking_fs.writes) == writes_before_noop++async def test_create_user_paths_ignore_deprecated_agent_evolution_config(lightweight_admin_client: httpx.AsyncClient,lightweight_admin_app: FastAPI,diff --git a/tests/server/test_api_sessions.py b/tests/server/test_api_sessions.pyindex f1dd8a246..f5d0cc260 100644--- a/tests/server/test_api_sessions.py+++ b/tests/server/test_api_sessions.py@@ -169,6 +169,47 @@ async def test_get_session(client: httpx.AsyncClient):assert body["result"]["uri"] == session_uri+async def test_get_session_preserves_legacy_memory_policy_shape(client: httpx.AsyncClient):+ create_resp = await client.post(+ "/api/v1/sessions",+ json={"memory_policy": {"memory_types": ["profile"]}},+ )+ session_id = create_resp.json()["result"]["session_id"]++ resp = await client.get(f"/api/v1/sessions/{session_id}")++ assert resp.status_code == 200+ assert resp.json()["result"]["memory_policy"] == {+ "self": {"enabled": True},+ "peer": {"enabled": True},+ "memory_types": ["profile"],+ }+++async def test_get_session_preserves_disabled_legacy_agent_policy_shape(+ client: httpx.AsyncClient,+):+ create_resp = await client.post(+ "/api/v1/sessions",+ json={+ "memory_policy": {+ "self": {"enabled": False},+ "memory_types": ["experiences"],+ }+ },+ )+ session_id = create_resp.json()["result"]["session_id"]++ resp = await client.get(f"/api/v1/sessions/{session_id}")++ assert resp.status_code == 200+ assert resp.json()["result"]["memory_policy"] == {+ "self": {"enabled": False},+ "peer": {"enabled": True},+ "memory_types": ["cases", "experiences", "trajectories"],+ }++async def test_legacy_session_uri_alias_reads_current_user_session(client: httpx.AsyncClient):session_id = "legacy-alias-read"await client.post("/api/v1/sessions", json={"session_id": session_id})diff --git a/tests/session/test_memory_extraction_scope.py b/tests/session/test_memory_extraction_scope.pyindex ded2bcba9..7133c03c8 100644--- a/tests/session/test_memory_extraction_scope.py+++ b/tests/session/test_memory_extraction_scope.py@@ -67,3 +67,50 @@ def test_actor_memory_extraction_scope_still_uses_policy_and_messages():assert scope.allow_self_memory is Trueassert scope.allowed_peer_ids == {"bob"}assert scope.include_session_skills is True+++def test_memory_extraction_scope_keeps_self_and_peer_type_filters_separate():+ scope = _resolve_memory_extraction_scope(+ _ctx(),+ MemoryPolicy.from_dict(+ {+ "self": {"memory_types": ["profile", "experiences"]},+ "peer": {"memory_types": ["events"]},+ }+ ).resolve(+ {"cases", "events", "experiences", "profile", "trajectories"},+ agent_evolution_enabled=True,+ ),+ [_message("alice")],+ config_session_skill_extraction_enabled=True,+ )++ assert scope.self_memory_types == {+ "cases",+ "experiences",+ "profile",+ "trajectories",+ }+ assert scope.peer_memory_types == {"events"}+++def test_disabled_peer_types_do_not_expand_the_active_extraction_scope():+ scope = _resolve_memory_extraction_scope(+ _ctx(),+ MemoryPolicy.from_dict(+ {+ "self": {"memory_types": ["experiences"]},+ "peer": {+ "enabled": False,+ "memory_types": ["profile", "events"],+ },+ }+ ).resolve(+ {"cases", "events", "experiences", "profile", "trajectories"},+ agent_evolution_enabled=True,+ ),+ [_message("alice")],+ config_session_skill_extraction_enabled=True,+ )++ assert scope.memory_types == {"cases", "experiences", "trajectories"}diff --git a/tests/session/test_session_commit.py b/tests/session/test_session_commit.pyindex 969b8ce55..f780919a7 100644--- a/tests/session/test_session_commit.py+++ b/tests/session/test_session_commit.py@@ -164,7 +164,36 @@ class TestCommit:session_with_messages._session_compressor.extract_long_term_memories.call_args.kwargs)assert call_kwargs["agent_evolution_enabled"] is True- assert call_kwargs["allowed_memory_types"] is None+ assert call_kwargs["allowed_memory_types"] == set(+ task_result["result"]["effective_memory_types"]+ )++ async def test_commit_reads_latest_user_memory_policy_when_session_has_no_override(+ self, session_with_messages: Session+ ):+ session_with_messages._memory_policy_provider = lambda: {+ "self": {"enabled": True, "memory_types": ["profile"]},+ "peer": {"enabled": False, "memory_types": []},+ }+ session_with_messages._session_compressor.extract_long_term_memories = AsyncMock(+ return_value=[]+ )++ 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"]["memory_policy_source"] == "user"+ assert task_result["result"]["effective_memory_policy"] == {+ "self": {"enabled": True, "memory_types": ["profile"]},+ "peer": {"enabled": False, "memory_types": []},+ }+ call_kwargs = (+ session_with_messages._session_compressor.extract_long_term_memories.call_args.kwargs+ )+ assert call_kwargs["allowed_self_memory_types"] == {"profile"}+ assert call_kwargs["allowed_peer_memory_types"] == set()+ assert call_kwargs["allowed_peer_ids"] == set()async def test_disabled_agent_evolution_keeps_working_memory(self, session_with_messages: Session, monkeypatch@@ -228,7 +257,9 @@ class TestCommit:call_kwargs = (session_with_messages._session_compressor.extract_long_term_memories.call_args.kwargs)- assert call_kwargs["allowed_memory_types"] is None+ assert call_kwargs["allowed_memory_types"] == set(+ task_result["result"]["effective_memory_types"]+ )async def test_commit_skips_session_skills_without_execution_memory_type(self, session_with_messages: Session, monkeypatchdiff --git a/tests/session/test_session_retention_integration.py b/tests/session/test_session_retention_integration.pyindex 0979be0d2..a40b4b39f 100644--- a/tests/session/test_session_retention_integration.py+++ b/tests/session/test_session_retention_integration.py@@ -1860,10 +1860,11 @@ async def test_stale_worker_uses_lock_snapshot_memory_policy_for_queue_message(assert result["archived"] is Truequeued_policy = queued[0]["memory_policy"]- assert {- key: queued_policy[key] for key in updater.meta.memory_policy- } == updater.meta.memory_policy- assert set(queued_policy["memory_types"]).isdisjoint(AGENT_EVOLUTION_MEMORY_TYPES)+ assert queued_policy["working_memory"] == {"enabled": False}+ assert queued_policy["self"]["enabled"] is False+ assert queued_policy["peer"]["enabled"] is False+ assert set(queued_policy["self"]["memory_types"]).isdisjoint(AGENT_EVOLUTION_MEMORY_TYPES)+ assert queued[0]["memory_policy_source"] == "session"assert "agent_evolution_enabled" not in queued[0]archive_meta = json.loads(await stale_session._viking_fs.read_file(diff --git a/tests/unit/session/test_memory_policy.py b/tests/unit/session/test_memory_policy.pyindex ca1a8fb7e..85cf786ec 100644--- a/tests/unit/session/test_memory_policy.py+++ b/tests/unit/session/test_memory_policy.py@@ -11,6 +11,7 @@ from openviking.session.memory.dataclass import MemoryField, MemoryTypeSchemafrom openviking.session.memory.memory_type_registry import MemoryTypeRegistryfrom openviking.session.memory.merge_op.base import FieldTypefrom openviking.session.memory_policy import MemoryPolicy+from openviking.session.session import _effective_memory_types, _effective_self_memory_typesfrom openviking_cli.exceptions import InvalidArgumentError@@ -30,6 +31,18 @@ def test_memory_policy_can_disable_peer_memory():assert policy.peer_enabled is False+def test_effective_memory_types_respect_disabled_targets():+ policy = MemoryPolicy.from_dict(+ {+ "self": {"enabled": False, "memory_types": ["experiences"]},+ "peer": {"enabled": False, "memory_types": ["profile"]},+ }+ )++ assert _effective_self_memory_types(policy) == set()+ assert _effective_memory_types(policy) == set()++def test_memory_policy_uses_top_level_memory_types():policy = MemoryPolicy.from_dict({@@ -43,12 +56,31 @@ def test_memory_policy_uses_top_level_memory_types():assert policy.peer_enabled is Trueassert policy.memory_types == {"profile", "events"}assert policy.to_dict() == {+ "self": {"enabled": False, "memory_types": ["events", "profile"]},+ "peer": {"enabled": True, "memory_types": ["events", "profile"]},+ }+ assert policy.to_legacy_dict() == {"self": {"enabled": False},"peer": {"enabled": True},"memory_types": ["events", "profile"],}+def test_memory_policy_legacy_serialization_preserves_types_when_self_is_disabled():+ policy = MemoryPolicy.from_dict(+ {+ "self": {"enabled": False},+ "memory_types": ["experiences"],+ }+ )++ assert policy.to_legacy_dict() == {+ "self": {"enabled": False},+ "peer": {"enabled": True},+ "memory_types": ["cases", "experiences", "trajectories"],+ }++def test_memory_policy_can_disable_working_memory():policy = MemoryPolicy.from_dict({"working_memory": {"enabled": False}})@@ -95,6 +127,32 @@ def test_memory_policy_rejects_invalid_memory_types():with pytest.raises(InvalidArgumentError, match="missing"):policy.validate_memory_types({"profile"})+ policy = MemoryPolicy.from_dict({"self": {"enabled": True, "memory_types": ["experiences"]}})+ assert policy.self_memory_types == {"experiences"}+ assert policy.resolve(+ {"cases", "events", "experiences", "profile", "trajectories"},+ agent_evolution_enabled=True,+ ).self_memory_types == {"cases", "experiences", "trajectories"}+++def test_memory_policy_supports_independent_self_and_peer_types():+ policy = MemoryPolicy.from_dict(+ {+ "self": {"enabled": True, "memory_types": ["profile", "experiences"]},+ "peer": {"enabled": True, "memory_types": ["events"]},+ }+ )++ assert policy.self_memory_types == {"experiences", "profile"}+ assert policy.peer_memory_types == {"events"}+++def test_memory_policy_rejects_agent_types_for_peer_memory():+ with pytest.raises(InvalidArgumentError, match="does not support agent memory types"):+ MemoryPolicy.from_dict({"peer": {"enabled": True, "memory_types": ["experiences"]}})+++def test_memory_policy_legacy_agent_dependencies():evolution_policy = MemoryPolicy.from_dict({"memory_types": ["profile", "experiences"]})assert evolution_policy.memory_types == {"profile",diff --git a/tests/unit/session/test_session_commit_resume.py b/tests/unit/session/test_session_commit_resume.pyindex cdebae0f7..7c0d4bdd9 100644--- a/tests/unit/session/test_session_commit_resume.py+++ b/tests/unit/session/test_session_commit_resume.py@@ -73,7 +73,10 @@ async def test_resume_queued_commit_continues_phase2(monkeypatch):session_uri=session_uri,archive_uri=archive_uri,user={"account_id": "default", "user_id": "default"},- memory_policy={"memory_types": []},+ memory_policy={+ "self": {"enabled": True, "memory_types": ["events"]},+ "peer": {"enabled": False, "memory_types": []},+ },)try:@@ -84,6 +87,10 @@ async def test_resume_queued_commit_continues_phase2(monkeypatch):session._run_memory_extraction.assert_awaited_once()assert session._run_memory_extraction.await_args.kwargs["task_id"] == "task-1"assert session._run_memory_extraction.await_args.kwargs["agent_evolution_enabled"] is True+ assert session._run_memory_extraction.await_args.kwargs["memory_policy"] == {+ "self": {"enabled": True, "memory_types": ["events"]},+ "peer": {"enabled": False, "memory_types": []},+ }assert [item.id for item in session._run_memory_extraction.await_args.kwargs["messages"]] == ["archived"]