Skip to content

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

fix(memory): expose reasons for skipped empty-URI operations (#4168)

DuTao4369e28dcaeb
diff --git a/docs/design/traj-exp-experience-learning-redesign.md b/docs/design/traj-exp-experience-learning-redesign.md
index fa8b17968..19637571b 100644
--- a/docs/design/traj-exp-experience-learning-redesign.md
+++ b/docs/design/traj-exp-experience-learning-redesign.md
@@ -650,6 +650,7 @@ merge 输入/输出日志通过 `tracer.info(..., console=False)` 记录,避
"trace_id": "...",
"extracted_at": "...",
"operations": {...},
+ "skipped_operations": [...],
"summary": {...}
}
```
diff --git a/docs/en/api/05-sessions.md b/docs/en/api/05-sessions.md
index 46a45d9b0..ff707bd7a 100644
--- a/docs/en/api/05-sessions.md
+++ b/docs/en/api/05-sessions.md
@@ -1633,10 +1633,19 @@ When long-term memory extraction runs successfully, the commit writes a `memory_
}
]
},
+ "skipped_operations": [
+ {
+ "memory_type": "events",
+ "page_id": 101,
+ "reason_code": "invalid_ranges",
+ "reason": "No valid event range could be resolved"
+ }
+ ],
"summary": {
"total_adds": 1,
"total_updates": 1,
- "total_deletes": 1
+ "total_deletes": 1,
+ "total_skipped": 1
}
}
```
@@ -1648,11 +1657,13 @@ When long-term memory extraction runs successfully, the commit writes a `memory_
| `operations.adds` | array | New memories created (`uri`, `memory_type`, `after`) |
| `operations.updates` | array | Modified memories (`uri`, `memory_type`, `before`, `after`) |
| `operations.deletes` | array | Deleted memories (`uri`, `memory_type`, `deleted_content`) |
+| `skipped_operations` | array | Intentionally skipped operations and their stable reason codes; these do not represent file changes |
| `summary.total_adds` | int | Number of new memories |
| `summary.total_updates` | int | Number of modified memories |
| `summary.total_deletes` | int | Number of deleted memories |
+| `summary.total_skipped` | int | Number of intentionally skipped operations |
-An empty `memory_diff.json` (all counts zero) is written when long-term memory extraction runs but produces no memory operations.
+An empty `memory_diff.json` (all counts zero) is written when long-term memory extraction runs but produces no applied or intentionally skipped operations.
<a id="built-in-memory-types"></a>
diff --git a/docs/en/concepts/08-session.md b/docs/en/concepts/08-session.md
index 43606e189..cae9bf613 100644
--- a/docs/en/concepts/08-session.md
+++ b/docs/en/concepts/08-session.md
@@ -197,10 +197,19 @@ Each `session.commit()` writes a `memory_diff.json` to the archive directory, re
}
]
},
+ "skipped_operations": [
+ {
+ "memory_type": "events",
+ "page_id": 101,
+ "reason_code": "invalid_ranges",
+ "reason": "No valid event range could be resolved"
+ }
+ ],
"summary": {
"total_adds": 1,
"total_updates": 1,
- "total_deletes": 1
+ "total_deletes": 1,
+ "total_skipped": 1
}
}
```
@@ -212,9 +221,10 @@ Each `session.commit()` writes a `memory_diff.json` to the archive directory, re
| `operations.adds` | New memories created (no `before`) |
| `operations.updates` | Modified memories (with `before` and `after`) |
| `operations.deletes` | Deleted memories (with `deleted_content`) |
+| `skipped_operations` | Intentionally skipped operations and their stable reason codes; these are not file changes |
| `summary` | Counts per operation type |
-An empty `memory_diff.json` (all counts zero) is written even when no memory operations occurred.
+An empty `memory_diff.json` (all counts zero) is written when no applied or intentionally skipped operations occurred.
## Storage Structure
diff --git a/docs/zh/api/05-sessions.md b/docs/zh/api/05-sessions.md
index 2179eb3a9..e61ac1e16 100644
--- a/docs/zh/api/05-sessions.md
+++ b/docs/zh/api/05-sessions.md
@@ -1603,10 +1603,19 @@ viking://user/{user_id}/sessions/{session_id}/
}
]
},
+ "skipped_operations": [
+ {
+ "memory_type": "events",
+ "page_id": 101,
+ "reason_code": "invalid_ranges",
+ "reason": "无法解析出有效的事件范围"
+ }
+ ],
"summary": {
"total_adds": 1,
"total_updates": 1,
- "total_deletes": 1
+ "total_deletes": 1,
+ "total_skipped": 1
}
}
```
@@ -1618,11 +1627,13 @@ viking://user/{user_id}/sessions/{session_id}/
| `operations.adds` | array | 新增记忆(`uri`、`memory_type`、`after`) |
| `operations.updates` | array | 修改记忆(`uri`、`memory_type`、`before`、`after`) |
| `operations.deletes` | array | 删除记忆(`uri`、`memory_type`、`deleted_content`) |
+| `skipped_operations` | array | 策略性跳过的操作及稳定原因码;不代表文件变更 |
| `summary.total_adds` | int | 新增记忆数 |
| `summary.total_updates` | int | 修改记忆数 |
| `summary.total_deletes` | int | 删除记忆数 |
+| `summary.total_skipped` | int | 策略性跳过的操作数 |
-如果长记忆抽取已运行但没有产生记忆操作,也会写入空结构的 `memory_diff.json`(所有计数为零)。
+如果长记忆抽取已运行但没有产生实际变更或策略性跳过,也会写入空结构的 `memory_diff.json`(所有计数为零)。
<a id="内置记忆类型"></a>
diff --git a/docs/zh/concepts/08-session.md b/docs/zh/concepts/08-session.md
index 34cf5948c..ce8e266c7 100644
--- a/docs/zh/concepts/08-session.md
+++ b/docs/zh/concepts/08-session.md
@@ -197,10 +197,19 @@ LLM 去重决策 → candidate(skip/create/none) + item(merge/delete)
}
]
},
+ "skipped_operations": [
+ {
+ "memory_type": "events",
+ "page_id": 101,
+ "reason_code": "invalid_ranges",
+ "reason": "无法解析出有效的事件范围"
+ }
+ ],
"summary": {
"total_adds": 1,
"total_updates": 1,
- "total_deletes": 1
+ "total_deletes": 1,
+ "total_skipped": 1
}
}
```
@@ -212,9 +221,10 @@ LLM 去重决策 → candidate(skip/create/none) + item(merge/delete)
| `operations.adds` | 新增的记忆(无 `before`) |
| `operations.updates` | 修改的记忆(含 `before` 和 `after`) |
| `operations.deletes` | 删除的记忆(含 `deleted_content`) |
+| `skipped_operations` | 策略性跳过的操作及稳定原因码;不代表文件变更 |
| `summary` | 各操作类型的计数 |
-即使没有记忆操作,也会写入空结构的 `memory_diff.json`(所有计数为零)。
+如果没有实际变更或策略性跳过,也会写入空结构的 `memory_diff.json`(所有计数为零)。
## 存储结构
diff --git a/openviking/session/compressor_v3.py b/openviking/session/compressor_v3.py
index c568d3b86..bb9426441 100644
--- a/openviking/session/compressor_v3.py
+++ b/openviking/session/compressor_v3.py
@@ -346,6 +346,9 @@ class SessionCompressorV3:
adds=adds,
updates=updates,
deletes=deletes,
+ skipped_operations=_serialize_skipped_operations(
+ getattr(result, "skipped_operations", [])
+ ),
)
@tracer(ignore_result=True)
@@ -363,6 +366,7 @@ class SessionCompressorV3:
allow_self_memory: bool = True,
allowed_peer_ids: Optional[set[str]] = None,
event_search_tags: Optional[List[str]] = None,
+ peer_memory_enabled: bool = True,
):
if not agent_evolution_enabled:
effective_types = (
@@ -400,6 +404,7 @@ class SessionCompressorV3:
archive_uri=archive_uri,
allowed_memory_types=allowed_memory_types,
allow_self_memory=allow_self_memory,
+ peer_memory_enabled=peer_memory_enabled,
allowed_peer_ids=allowed_peer_ids,
event_search_tags=event_search_tags,
)
@@ -601,6 +606,7 @@ class SessionCompressorV3:
archive_uri: Optional[str] = None,
allowed_memory_types: Optional[set[str]] = None,
allow_self_memory: bool = True,
+ peer_memory_enabled: bool = True,
allowed_peer_ids: Optional[set[str]] = None,
event_search_tags: Optional[List[str]] = None,
) -> "_V3ExtractionResult":
@@ -642,6 +648,7 @@ class SessionCompressorV3:
allowed_memory_types=allowed_memory_types,
allow_self=allow_self_memory,
allowed_peer_ids=allowed_peer_ids,
+ peer_memory_enabled=peer_memory_enabled,
)
isolation_handler.prepare_messages()
context_provider._isolation_handler = isolation_handler
@@ -682,6 +689,7 @@ class SessionCompressorV3:
"allowed_memory_types": allowed_memory_types,
"allow_self": allow_self_memory,
"allowed_peer_ids": allowed_peer_ids,
+ "peer_memory_enabled": peer_memory_enabled,
},
metadata={
"source_extraction_id": extraction_id,
@@ -719,6 +727,9 @@ class SessionCompressorV3:
cases=canonical_cases,
memory_diff=memory_diff,
case_uri_by_name=_case_uri_by_name(canonical_cases, patch_operations, result),
+ skipped_operations=_serialize_skipped_operations(
+ getattr(result, "skipped_operations", [])
+ ),
)
def _session_skill_extraction_enabled(self) -> bool:
@@ -1223,6 +1234,7 @@ class _V3ExtractionResult:
cases: list[Case] = field(default_factory=list)
memory_diff: dict[str, Any] | None = None
case_uri_by_name: dict[str, str] = field(default_factory=dict)
+ skipped_operations: list[dict[str, Any]] = field(default_factory=list)
@dataclass(slots=True)
@@ -2041,6 +2053,22 @@ def _same_memory_file(before: Optional[MemoryFile], after: Optional[MemoryFile])
)
+def _serialize_skipped_operations(items: Any) -> list[dict[str, Any]]:
+ serialized: list[dict[str, Any]] = []
+ for item in list(items or []):
+ if isinstance(item, dict):
+ payload = dict(item)
+ else:
+ model_dump = getattr(item, "model_dump", None)
+ if not callable(model_dump):
+ continue
+ payload = model_dump(mode="json", exclude_none=True)
+ if isinstance(payload, dict):
+ payload.pop("source", None)
+ serialized.append(payload)
+ return serialized
+
+
def _v3_extraction_response(
*,
contexts: list[Context],
@@ -2051,10 +2079,9 @@ def _v3_extraction_response(
Historically ``extract_long_term_memories`` returned ``list[Context]`` and
a number of direct callers still index/compare the return value as a list.
- Commit orchestration now also understands the execution-memory style
- ``{"contexts": ..., "session_skills": ...}`` shape so it can count
- session skills. Preserve the old list shape unless there are actual
- session skills to report.
+ Commit orchestration also understands a structured response for session
+ skills. Preserve the old list shape unless there are actual session skills
+ to report.
"""
skill_dicts: list[dict[str, Any]] = []
seen: set[str] = set()
@@ -2075,7 +2102,9 @@ def _make_memory_diff(
adds: list[dict[str, Any]],
updates: list[dict[str, Any]],
deletes: list[dict[str, Any]],
+ skipped_operations: Optional[list[dict[str, Any]]] = None,
) -> dict[str, Any]:
+ skipped = list(skipped_operations or [])
return {
"archive_uri": archive_uri,
"trace_id": tracer.get_trace_id() or None,
@@ -2085,10 +2114,12 @@ def _make_memory_diff(
"updates": list(updates),
"deletes": list(deletes),
},
+ "skipped_operations": skipped,
"summary": {
"total_adds": len(adds),
"total_updates": len(updates),
"total_deletes": len(deletes),
+ "total_skipped": len(skipped),
},
}
@@ -2101,12 +2132,16 @@ def _merge_memory_diffs(
adds: list[dict[str, Any]] = []
updates: list[dict[str, Any]] = []
deletes: list[dict[str, Any]] = []
+ skipped_operations: list[dict[str, Any]] = []
trace_id = tracer.get_trace_id() or None
for diff in diffs:
if not isinstance(diff, dict):
continue
if trace_id is None and diff.get("trace_id"):
trace_id = str(diff.get("trace_id"))
+ skipped_operations.extend(
+ item for item in diff.get("skipped_operations", []) if isinstance(item, dict)
+ )
operations = diff.get("operations")
if not isinstance(operations, dict):
continue
@@ -2118,6 +2153,7 @@ def _merge_memory_diffs(
adds=adds,
updates=updates,
deletes=deletes,
+ skipped_operations=skipped_operations,
)
merged["trace_id"] = trace_id
return merged
@@ -2130,7 +2166,8 @@ def _memory_diff_has_changes(diff: Any) -> bool:
if not isinstance(summary, dict):
return False
return any(
- int(summary.get(key) or 0) > 0 for key in ("total_adds", "total_updates", "total_deletes")
+ int(summary.get(key) or 0) > 0
+ for key in ("total_adds", "total_updates", "total_deletes", "total_skipped")
)
diff --git a/openviking/session/memory/dataclass.py b/openviking/session/memory/dataclass.py
index 0d06ef6e4..3fd6ec4ae 100644
--- a/openviking/session/memory/dataclass.py
+++ b/openviking/session/memory/dataclass.py
@@ -169,6 +169,39 @@ class MemoryOperationSource(BaseModel):
extracted_at: Optional[str] = None
+class MemoryOperationSkipCode(str, Enum):
+ """Stable reason codes for intentionally skipped memory operations."""
+
+ MEMORY_TYPE_FILTERED = "memory_type_filtered"
+ SELF_MEMORY_DISABLED = "self_memory_disabled"
+ PEER_MEMORY_DISABLED = "peer_memory_disabled"
+ INVALID_PEER_ID = "invalid_peer_id"
+ PEER_NOT_ALLOWED = "peer_not_allowed"
+ INVALID_RANGES = "invalid_ranges"
+ AMBIGUOUS_TARGET = "ambiguous_target"
+ NO_WRITABLE_TARGET = "no_writable_target"
+
+
+class MemoryOperationSkip(BaseModel):
+ """Internal policy/validation decision explaining why no URI was produced."""
+
+ reason_code: MemoryOperationSkipCode
+ reason: str
+
+
+class SkippedMemoryOperation(BaseModel):
+ """Structured, task-visible record for one intentionally skipped operation."""
+
+ memory_type: str
+ page_id: Optional[int] = None
+ uri: Optional[str] = None
+ reason_code: MemoryOperationSkipCode
+ reason: str
+ # Source is used only to scope shared streaming-batch results back to the
+ # submitting commit. It must never be serialized into the public task result.
+ source: Optional[MemoryOperationSource] = Field(default=None, exclude=True)
+
+
# ============================================================================
# Memory Field and Schema Definitions
# ============================================================================
@@ -298,6 +331,9 @@ class ResolvedOperation(BaseModel):
uris: List[str]
page_id: Optional[int] = None # Temporary page_id for link resolution (not persisted)
source: Optional[MemoryOperationSource] = None
+ # Runtime-only resolution decision. It is deliberately excluded from model
+ # serialization so it cannot enter later LLM merge prompts or memory files.
+ resolution_skip: Optional[MemoryOperationSkip] = Field(default=None, exclude=True)
# Custom scalar tags (already normalized as "key=value") to attach to this
# operation's memories in the vector index. None means "no tags"; used by
# event-memory auto-tagging. Not persisted in the memory file content.
diff --git a/openviking/session/memory/extract_loop.py b/openviking/session/memory/extract_loop.py
index 81769c5fa..9a60811ee 100644
--- a/openviking/session/memory/extract_loop.py
+++ b/openviking/session/memory/extract_loop.py
@@ -16,6 +16,7 @@ from openviking.server.identity import RequestContext
from openviking.session.memory.dataclass import (
DeleteId,
MemoryFile,
+ MemoryOperationSkip,
ResolvedOperation,
ResolvedOperations,
StoredLink,
@@ -387,6 +388,17 @@ The final output of the model must strictly follow the JSON Schema format shown
for item in items:
item_dict = dict(item)
item_dict["memory_type"] = memory_type
+ identity_resolution_skip = None
+ classify_identity_fields = getattr(
+ self._isolation_handler,
+ "_classify_identity_fields",
+ None,
+ )
+ if callable(classify_identity_fields):
+ identity_resolution_skip = classify_identity_fields(
+ item_dict,
+ memory_type_schema=schema,
+ )
try:
self._isolation_handler.fill_identity_fields(
item_dict,
@@ -404,6 +416,8 @@ The final output of the model must strictly follow the JSON Schema format shown
item_dict,
role_scope=role_scope,
)
+ if not isinstance(identity_resolution_skip, MemoryOperationSkip):
+ identity_resolution_skip = None
page_id = item_dict.pop("page_id", None)
resolved_op = ResolvedOperation(
@@ -412,12 +426,17 @@ The final output of the model must strictly follow the JSON Schema format shown
memory_type=memory_type,
uris=[],
page_id=page_id,
+ resolution_skip=identity_resolution_skip,
)
if page_id is not None and page_id_map is not None:
resolved_uri = page_id_map.resolve(page_id)
if resolved_uri:
resolved_op.uris = [resolved_uri]
+ # Existing page IDs retain their historical precedence over
+ # an invalid peer hint. Keep the hint runtime-only and do
+ # not persist it into memory metadata.
+ resolved_op.resolution_skip = None
old_content = self.context_provider.read_file_contents.get(resolved_uri)
if old_content is not None:
resolved_op.old_memory_file_content = old_content
diff --git a/openviking/session/memory/memory_isolation_handler.py b/openviking/session/memory/memory_isolation_handler.py
index d7ffd2392..13d38527f 100644
--- a/openviking/session/memory/memory_isolation_handler.py
+++ b/openviking/session/memory/memory_isolation_handler.py
@@ -7,7 +7,12 @@ from typing import Any, Dict, List, Optional, Set
from openviking.core.peer_id import safe_peer_id
from openviking.server.identity import RequestContext
-from openviking.session.memory.dataclass import MemoryTypeSchema, ResolvedOperation
+from openviking.session.memory.dataclass import (
+ MemoryOperationSkip,
+ MemoryOperationSkipCode,
+ MemoryTypeSchema,
+ ResolvedOperation,
+)
from openviking.session.memory.memory_updater import ExtractContext
from openviking.session.memory.utils.uri import generate_uri, render_template
from openviking_cli.utils import get_logger
@@ -17,6 +22,29 @@ logger = get_logger(__name__)
_INTERNAL_MEMORY_TYPES = {"session_skills"}
_SELF_PEER_ID = "__self"
+_SKIP_REASON_MESSAGES = {
+ MemoryOperationSkipCode.MEMORY_TYPE_FILTERED: (
+ "Memory type is outside the allowed extraction scope"
+ ),
+ MemoryOperationSkipCode.SELF_MEMORY_DISABLED: "Self memory writes are disabled",
+ MemoryOperationSkipCode.PEER_MEMORY_DISABLED: "Peer memory writes are disabled",
+ MemoryOperationSkipCode.INVALID_PEER_ID: "Target peer ID is invalid",
+ MemoryOperationSkipCode.PEER_NOT_ALLOWED: ("Target peer is outside the allowed memory scope"),
+ MemoryOperationSkipCode.INVALID_RANGES: "Message ranges are malformed or out of bounds",
+ MemoryOperationSkipCode.AMBIGUOUS_TARGET: "Memory ownership cannot be resolved uniquely",
+ MemoryOperationSkipCode.NO_WRITABLE_TARGET: "No writable memory target could be resolved",
+}
+
+_SKIP_REASON_PRIORITY = {
+ MemoryOperationSkipCode.INVALID_PEER_ID: 0,
+ MemoryOperationSkipCode.INVALID_RANGES: 1,
+ MemoryOperationSkipCode.PEER_MEMORY_DISABLED: 2,
+ MemoryOperationSkipCode.PEER_NOT_ALLOWED: 3,
+ MemoryOperationSkipCode.SELF_MEMORY_DISABLED: 4,
+ MemoryOperationSkipCode.AMBIGUOUS_TARGET: 5,
+ MemoryOperationSkipCode.NO_WRITABLE_TARGET: 6,
+}
+
@dataclass
class RoleScope:
@@ -26,6 +54,12 @@ class RoleScope:
peer_ids: List[str] = field(default_factory=list)
+@dataclass(frozen=True)
+class _TargetResolution:
+ target_ids: List[str] = field(default_factory=list)
+ skip_code: Optional[MemoryOperationSkipCode] = None
+
+
def peer_user_space(user_space: str, peer_id: str) -> str:
"""Return the user-space fragment for memory about a stable peer."""
if peer_id == _SELF_PEER_ID:
@@ -43,6 +77,7 @@ class MemoryIsolationHandler:
allowed_memory_types: Optional[Set[str]] = None,
allow_self: bool = True,
allowed_peer_ids: Optional[Set[str]] = None,
+ peer_memory_enabled: Optional[bool] = None,
):
self.ctx = ctx
self._extract_context = extract_context
@@ -58,6 +93,9 @@ class MemoryIsolationHandler:
}
self.allow_self = bool(allow_self)
self.allowed_peer_ids = peer_ids
+ self.peer_memory_enabled = (
+ bool(peer_memory_enabled) if peer_memory_enabled is not None else True
+ )
self.allow_peer = bool(peer_ids)
def prepare_messages(self) -> None:
@@ -69,15 +107,30 @@ class MemoryIsolationHandler:
return messages if isinstance(messages, list) else []
def _message_target_id(self, msg: Any) -> Optional[str]:
+ resolution = self._message_target_resolution(msg)
+ return resolution.target_ids[0] if resolution.target_ids else None
+
+ def _message_target_resolution(self, msg: Any) -> _TargetResolution:
if not self._is_peer_owner_message(msg):
- return None
+ return _TargetResolution()
raw_peer_id = getattr(msg, "peer_id", None)
+ if raw_peer_id in (None, ""):
+ if self.allow_self:
+ return _TargetResolution([_SELF_PEER_ID])
+ return _TargetResolution(skip_code=MemoryOperationSkipCode.SELF_MEMORY_DISABLED)
peer_id = safe_peer_id(raw_peer_id)
- if peer_id and self._can_write_peer(peer_id):
- return peer_id
- if raw_peer_id in (None, "") and self.allow_self:
- return _SELF_PEER_ID
- return None
+ if not peer_id:
+ return _TargetResolution(skip_code=MemoryOperationSkipCode.INVALID_PEER_ID)
+ if peer_id == _SELF_PEER_ID:
+ # ``__self`` is an internal operation-target sentinel, not a valid
+ # message peer. Preserve the legacy behavior: an explicit message
+ # peer with this value does not resolve to a writable target.
+ return _TargetResolution(skip_code=MemoryOperationSkipCode.NO_WRITABLE_TARGET)
+ if not self.peer_memory_enabled:
+ return _TargetResolution(skip_code=MemoryOperationSkipCode.PEER_MEMORY_DISABLED)
+ if not self._can_write_peer(peer_id):
+ return _TargetResolution(skip_code=MemoryOperationSkipCode.PEER_NOT_ALLOWED)
+ return _TargetResolution([peer_id])
@staticmethod
def _is_peer_owner_message(msg: Any) -> bool:
@@ -121,6 +174,24 @@ class MemoryIsolationHandler:
else:
item_dict.pop("peer_id", None)
+ @staticmethod
+ def _classify_identity_fields(
+ item_dict: Dict[str, Any],
+ memory_type_schema: Optional[MemoryTypeSchema] = None,
+ ) -> Optional[MemoryOperationSkip]:
+ """Capture a diagnostic hint without changing identity-field normalization."""
+ if memory_type_schema is not None and not memory_type_schema.peer_enabled:
+ return None
+ raw_peer_id = item_dict.get("peer_id")
+ if raw_peer_id not in (None, "", _SELF_PEER_ID):
+ if safe_peer_id(raw_peer_id):
+ return None
+ return MemoryOperationSkip(
+ reason_code=MemoryOperationSkipCode.INVALID_PEER_ID,
+ reason=_SKIP_REASON_MESSAGES[MemoryOperationSkipCode.INVALID_PEER_ID],
+ )
+ return None
+
def allows_schema(self, memory_type_schema: MemoryTypeSchema) -> bool:
memory_type = getattr(memory_type_schema, "memory_type", "")
if memory_type in _INTERNAL_MEMORY_TYPES:
@@ -134,23 +205,11 @@ class MemoryIsolationHandler:
def _can_write_peer(self, peer_id: str) -> bool:
return self.allow_peer and peer_id in self.allowed_peer_ids
- def _unique_peer_target_id_in_messages(self) -> Optional[str]:
- targets = [
- peer_id
- for msg in self._messages()
- if (peer_id := safe_peer_id(getattr(msg, "peer_id", None)))
- and self._is_peer_owner_message(msg)
- and self._can_write_peer(peer_id)
- ]
- peer_ids = list(dict.fromkeys(targets))
- return peer_ids[0] if len(peer_ids) == 1 else None
-
- def _unique_target_id_in_messages(self) -> Optional[str]:
+ def _target_ids_in_messages(self) -> List[str]:
targets = [
target_id for msg in self._messages() if (target_id := self._message_target_id(msg))
]
- target_ids = list(dict.fromkeys(targets))
- return target_ids[0] if len(target_ids) == 1 else None
+ return list(dict.fromkeys(targets))
def _range_is_fully_in_bounds(self, ranges: Any) -> bool:
parts = str(ranges).split(",")
@@ -197,41 +256,93 @@ class MemoryIsolationHandler:
)
return directories
- def _range_targets(self, ranges: Any) -> tuple[List[str], bool]:
+ @staticmethod
+ def _preferred_skip_code(
+ skip_codes: List[MemoryOperationSkipCode],
+ ) -> MemoryOperationSkipCode:
+ if not skip_codes:
+ return MemoryOperationSkipCode.NO_WRITABLE_TARGET
+ return min(skip_codes, key=lambda code: _SKIP_REASON_PRIORITY.get(code, 999))
+
+ def _range_targets(self, ranges: Any) -> _TargetResolution:
if not ranges or not self._extract_context:
- return [], False
+ return _TargetResolution(skip_code=MemoryOperationSkipCode.INVALID_RANGES)
range_is_fully_in_bounds = self._range_is_fully_in_bounds(ranges)
try:
msg_range = self._extract_context.read_message_ranges(str(ranges))
except Exception:
logger.warning("Failed to parse memory ranges for peer memory: %s", ranges)
- return [], False
+ return _TargetResolution(skip_code=MemoryOperationSkipCode.INVALID_RANGES)
target_ids = []
has_message = False
has_user_message = False
+ skip_codes: List[MemoryOperationSkipCode] = []
for msg_group in getattr(msg_range, "elements", []) or []:
for msg in msg_group:
has_message = True
if self._is_peer_owner_message(msg):
has_user_message = True
- target_id = self._message_target_id(msg)
- if target_id:
- target_ids.append(target_id)
+ resolution = self._message_target_resolution(msg)
+ target_ids.extend(resolution.target_ids)
+ if resolution.skip_code is not None:
+ skip_codes.append(resolution.skip_code)
+ target_ids = list(dict.fromkeys(target_ids))
+ if target_ids:
+ return _TargetResolution(target_ids)
can_fallback = range_is_fully_in_bounds and has_message and not has_user_message
- return list(dict.fromkeys(target_ids)), can_fallback
-
- def _resolve_operation_target_id(self, raw_peer_id: Any) -> Optional[str]:
- peer_id = safe_peer_id(raw_peer_id)
- if peer_id == _SELF_PEER_ID and self.allow_self:
- return _SELF_PEER_ID
- if peer_id and self._can_write_peer(peer_id):
- return peer_id
+ if can_fallback:
+ fallback_targets = self._target_ids_in_messages()
+ if len(fallback_targets) == 1:
+ return _TargetResolution(fallback_targets)
+ if len(fallback_targets) > 1:
+ return _TargetResolution(skip_code=MemoryOperationSkipCode.AMBIGUOUS_TARGET)
+ if not range_is_fully_in_bounds:
+ return _TargetResolution(skip_code=MemoryOperationSkipCode.INVALID_RANGES)
+ if has_user_message:
+ return _TargetResolution(skip_code=self._preferred_skip_code(skip_codes))
+ return _TargetResolution(skip_code=MemoryOperationSkipCode.NO_WRITABLE_TARGET)
+
+ def _resolve_operation_target(self, raw_peer_id: Any) -> _TargetResolution:
if raw_peer_id not in (None, ""):
- return None
+ peer_id = safe_peer_id(raw_peer_id)
+ if not peer_id:
+ return _TargetResolution(skip_code=MemoryOperationSkipCode.INVALID_PEER_ID)
+ if peer_id == _SELF_PEER_ID:
+ if self.allow_self:
+ return _TargetResolution([_SELF_PEER_ID])
+ return _TargetResolution(skip_code=MemoryOperationSkipCode.SELF_MEMORY_DISABLED)
+ if not self.peer_memory_enabled:
+ return _TargetResolution(skip_code=MemoryOperationSkipCode.PEER_MEMORY_DISABLED)
+ if not self._can_write_peer(peer_id):
+ return _TargetResolution(skip_code=MemoryOperationSkipCode.PEER_NOT_ALLOWED)
+ return _TargetResolution([peer_id])
if self.allow_self:
- return _SELF_PEER_ID
- return self._unique_peer_target_id_in_messages()
+ return _TargetResolution([_SELF_PEER_ID])
+ peer_targets = list(
+ dict.fromkeys(
+ target
+ for msg in self._messages()
+ for target in self._message_target_resolution(msg).target_ids
+ if target != _SELF_PEER_ID
+ )
+ )
+ if len(peer_targets) == 1:
+ return _TargetResolution(peer_targets)
+ if len(peer_targets) > 1:
+ return _TargetResolution(skip_code=MemoryOperationSkipCode.AMBIGUOUS_TARGET)
+ return _TargetResolution(skip_code=MemoryOperationSkipCode.NO_WRITABLE_TARGET)
+
+ @staticmethod
+ def _skip_operation(
+ operation: ResolvedOperation,
+ reason_code: MemoryOperationSkipCode,
+ ) -> List[str]:
+ operation.resolution_skip = MemoryOperationSkip(
+ reason_code=reason_code,
+ reason=_SKIP_REASON_MESSAGES[reason_code],
+ )
+ return []
def calculate_memory_uris(
self,
@@ -239,8 +350,15 @@ class MemoryIsolationHandler:
operation: ResolvedOperation,
extract_context: ExtractContext,
):
+ identity_resolution_skip = operation.resolution_skip
+ operation.resolution_skip = None
if not self.allows_schema(memory_type_schema):
- return []
+ reason_code = (
+ MemoryOperationSkipCode.SELF_MEMORY_DISABLED
+ if not self.allow_self and not getattr(memory_type_schema, "peer_enabled", True)
+ else MemoryOperationSkipCode.MEMORY_TYPE_FILTERED
+ )
+ return self._skip_operation(operation, reason_code)
if not self.ctx or not self.ctx.user:
return []
@@ -249,25 +367,28 @@ class MemoryIsolationHandler:
operation.memory_fields["user_id"] = user_id
target_ids: List[str] = []
+ skip_code: Optional[MemoryOperationSkipCode] = None
has_ranges = operation.memory_fields.get("ranges") is not None
if 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 []
+ if self.allow_self:
+ target_ids = [_SELF_PEER_ID]
+ else:
+ skip_code = MemoryOperationSkipCode.SELF_MEMORY_DISABLED
elif operation.memory_fields.get("ranges") is not None:
- target_ids, can_fallback = self._range_targets(
+ resolution = self._range_targets(
operation.memory_fields.get("ranges"),
)
- if not target_ids and can_fallback:
- fallback_target = self._unique_target_id_in_messages()
- if fallback_target:
- target_ids = [fallback_target]
+ target_ids = resolution.target_ids
+ skip_code = resolution.skip_code
operation.memory_fields.pop("peer_id", None)
else:
- target_id = self._resolve_operation_target_id(
- operation.memory_fields.get("peer_id"),
- )
- if target_id:
- target_ids = [target_id]
+ resolution = self._resolve_operation_target(operation.memory_fields.get("peer_id"))
+ target_ids = resolution.target_ids
+ skip_code = resolution.skip_code
+ if not target_ids and identity_resolution_skip is not None:
+ skip_code = identity_resolution_skip.reason_code
+ target_id = target_ids[0] if len(target_ids) == 1 else None
if target_id == _SELF_PEER_ID:
operation.memory_fields.pop("peer_id", None)
elif target_id:
@@ -276,7 +397,10 @@ class MemoryIsolationHandler:
operation.memory_fields.pop("peer_id", None)
if not target_ids:
- return []
+ return self._skip_operation(
+ operation,
+ skip_code or MemoryOperationSkipCode.NO_WRITABLE_TARGET,
+ )
# 文件
uris = set()
diff --git a/openviking/session/memory/memory_updater.py b/openviking/session/memory/memory_updater.py
index f6414d0cc..93e0546c5 100644
--- a/openviking/session/memory/memory_updater.py
+++ b/openviking/session/memory/memory_updater.py
@@ -22,8 +22,10 @@ from openviking.message.part import TextPart
from openviking.server.identity import RequestContext
from openviking.session.memory.dataclass import (
MemoryFile,
+ MemoryOperationSkipCode,
ResolvedOperation,
ResolvedOperations,
+ SkippedMemoryOperation,
StoredLink,
)
from openviking.session.memory.memory_type_registry import MemoryTypeRegistry
@@ -711,6 +713,7 @@ class MemoryUpdateResult:
self.written_uris: List[str] = []
self.edited_uris: List[str] = []
self.deleted_uris: List[str] = []
+ self.skipped_operations: List[SkippedMemoryOperation] = []
self.errors: List[Tuple[str, Exception]] = []
def add_written(self, uri: str) -> None:
@@ -725,6 +728,9 @@ class MemoryUpdateResult:
def add_error(self, uri: str, error: Exception) -> None:
self.errors.append((uri, error))
+ def add_skipped(self, operation: SkippedMemoryOperation) -> None:
+ self.skipped_operations.append(operation)
+
def summary(self) -> str:
return (
f"Written: {len(self.written_uris)}, "
@@ -879,6 +885,32 @@ class MemoryUpdater:
continue
has_unresolved_upserts = True
error_target = f"{resolved_op.memory_type}(page_id={resolved_op.page_id})"
+ resolution_skip = getattr(resolved_op, "resolution_skip", None)
+ if resolution_skip is not None:
+ # Reporting-only: the operation remains unresolved, preserving
+ # the legacy delete-suppression behavior for direct mixed batches.
+ skipped = SkippedMemoryOperation(
+ memory_type=resolved_op.memory_type,
+ page_id=resolved_op.page_id,
+ reason_code=resolution_skip.reason_code,
+ reason=resolution_skip.reason,
+ source=resolved_op.source,
+ )
+ result.add_skipped(skipped)
+ message = (
+ "Skipping memory operation by resolution policy: "
+ f"memory_type={resolved_op.memory_type} "
+ f"page_id={resolved_op.page_id} "
+ f"reason_code={resolution_skip.reason_code.value}"
+ )
+ if resolution_skip.reason_code in {
+ MemoryOperationSkipCode.INVALID_PEER_ID,
+ MemoryOperationSkipCode.INVALID_RANGES,
+ }:
+ logger.warning(message)
+ else:
+ tracer.info(message)
+ continue
resolution_error = ValueError("Missing resolved URI")
result.add_error(error_target, resolution_error)
tracer.error(
diff --git a/openviking/session/memory/streaming_memory_updater.py b/openviking/session/memory/streaming_memory_updater.py
index 6c424c41c..4a214136e 100644
--- a/openviking/session/memory/streaming_memory_updater.py
+++ b/openviking/session/memory/streaming_memory_updater.py
@@ -26,6 +26,7 @@ from openviking.session.memory.dataclass import (
MemoryTypeSchema,
ResolvedOperation,
ResolvedOperations,
+ SkippedMemoryOperation,
StoredLink,
)
from openviking.session.memory.extract_loop import ExtractLoop
@@ -208,6 +209,7 @@ class StreamingMemoryUpdater:
f"written_uris={scoped_result.apply_result.written_uris} "
f"edited_uris={scoped_result.apply_result.edited_uris} "
f"deleted_uris={scoped_result.apply_result.deleted_uris} "
+ f"skipped_reason_codes={_skipped_reason_codes(scoped_result.apply_result)} "
f"errors={scoped_result.apply_result.errors}",
console=self.config.trace_console,
)
@@ -398,6 +400,7 @@ class StreamingMemoryUpdater:
f"written_uris={apply_result.written_uris} "
f"edited_uris={apply_result.edited_uris} "
f"deleted_uris={apply_result.deleted_uris} "
+ f"skipped_reason_codes={_skipped_reason_codes(apply_result)} "
f"errors={apply_result.errors}",
console=self.config.trace_console,
)
@@ -449,6 +452,7 @@ class StreamingMemoryUpdater:
f"written_uris={apply_result.written_uris} "
f"edited_uris={apply_result.edited_uris} "
f"deleted_uris={apply_result.deleted_uris} "
+ f"skipped_reason_codes={_skipped_reason_codes(apply_result)} "
f"errors={apply_result.errors}",
console=self.config.trace_console,
)
@@ -650,6 +654,9 @@ def split_request_by_merge_group(
)
if passthrough_upserts:
+ # Unresolved upserts keep their original standalone passthrough group.
+ # Deletes remain in their normal peer/type groups, including replacement
+ # metadata, so diagnostics cannot change write/delete ordering.
group_key = MemoryMergeGroupKey(peer_id=None, memory_type="")
grouped_requests.append(
(
@@ -1610,6 +1617,7 @@ def scope_memory_update_result_to_submitter(
scoped_apply_result = _scope_apply_result_to_uris(
result.apply_result,
scoped_uris=scoped_uris,
+ scope=scope,
)
metadata = dict(result.metadata or {})
metadata.update(
@@ -1717,6 +1725,7 @@ def _scope_apply_result_to_uris(
apply_result: MemoryUpdateResult,
*,
scoped_uris: set[str],
+ scope: _MemorySubmitterScope,
) -> MemoryUpdateResult:
scoped = MemoryUpdateResult()
scoped.written_uris = [
@@ -1733,9 +1742,41 @@ def _scope_apply_result_to_uris(
for error in list(getattr(apply_result, "errors", []) or [])
if _apply_error_matches_scoped_uris(error, scoped_uris=scoped_uris)
]
+ scoped.skipped_operations = [
+ operation
+ for operation in list(getattr(apply_result, "skipped_operations", []) or [])
+ if _skipped_operation_matches_scope(
+ operation,
+ scope=scope,
+ scoped_uris=scoped_uris,
+ )
+ ]
return scoped
+def _skipped_operation_matches_scope(
+ operation: SkippedMemoryOperation,
+ *,
+ scope: _MemorySubmitterScope,
+ scoped_uris: set[str],
+) -> bool:
+ source = getattr(operation, "source", None)
+ source_extraction_id = _optional_str(getattr(source, "extraction_id", None))
+ if scope.extraction_id and source_extraction_id:
+ return source_extraction_id == scope.extraction_id
+
+ source_archive_uri = _optional_str(getattr(source, "archive_uri", None))
+ if scope.archive_uri and source_archive_uri:
+ return source_archive_uri == scope.archive_uri
+
+ source_session_id = _optional_str(getattr(source, "session_id", None))
+ if scope.session_id and source_session_id:
+ return source_session_id == scope.session_id
+
+ uri = str(getattr(operation, "uri", None) or "")
+ return bool(uri and uri in scoped_uris)
+
+
def _operation_matches_scope(op: ResolvedOperation, *, scope: _MemorySubmitterScope) -> bool:
if scope.extraction_id and scope.extraction_id in _operation_source_extraction_ids(op):
return True
@@ -1894,6 +1935,7 @@ def combine_streaming_memory_results(
combined_apply_result.written_uris.extend(result.apply_result.written_uris)
combined_apply_result.edited_uris.extend(result.apply_result.edited_uris)
combined_apply_result.deleted_uris.extend(result.apply_result.deleted_uris)
+ combined_apply_result.skipped_operations.extend(result.apply_result.skipped_operations)
combined_apply_result.errors.extend(result.apply_result.errors)
for key in ("batch_id", "batch_trace_id"):
if result.metadata.get(key):
@@ -1965,6 +2007,7 @@ 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"),
+ peer_memory_enabled=options.get("peer_memory_enabled"),
)
@@ -1972,6 +2015,13 @@ def _operation_count(operations: ResolvedOperations) -> int:
return len(operations.upsert_operations or []) + len(operations.delete_file_contents or [])
+def _skipped_reason_codes(result: MemoryUpdateResult) -> list[str]:
+ return [
+ operation.reason_code.value
+ for operation in list(getattr(result, "skipped_operations", []) or [])
+ ]
+
+
def _operation_lock_paths(
operations: ResolvedOperations,
viking_fs: Any | None,
diff --git a/openviking/session/session.py b/openviking/session/session.py
index ac1e6e07a..7f08c4cb1 100644
--- a/openviking/session/session.py
+++ b/openviking/session/session.py
@@ -187,6 +187,7 @@ def _message_peer_ids(messages: List[Message]) -> set[str]:
@dataclass(frozen=True)
class _MemoryExtractionScope:
allow_self_memory: bool
+ peer_memory_enabled: bool
allowed_peer_ids: set[str]
include_session_skills: bool
memory_types: Optional[set[str]]
@@ -204,6 +205,7 @@ def _resolve_memory_extraction_scope(
return _MemoryExtractionScope(
allow_self_memory=allow_self_memory,
+ peer_memory_enabled=policy.peer_enabled,
allowed_peer_ids=allowed_peer_ids,
include_session_skills=config_session_skill_extraction_enabled and allow_self_memory,
memory_types=policy.memory_types,
@@ -2379,6 +2381,7 @@ class Session:
memories_extracted: Dict[str, int] = {}
usage_events_extracted = 0
extracted_skill_results: list[dict] = []
+ skipped_memory_operations: list[dict[str, Any]] = []
active_count_updated = 0
memory_diff_uri: Optional[str] = None
completed_memory_steps: Dict[str, set[str]] = {}
@@ -2563,6 +2566,7 @@ class Session:
),
)
self_memory_enabled = extraction_scope.allow_self_memory
+ peer_memory_enabled = extraction_scope.peer_memory_enabled
allowed_peer_ids = extraction_scope.allowed_peer_ids
long_term_memory_types = extraction_scope.memory_types
@@ -2610,6 +2614,7 @@ class Session:
allowed_memory_types=long_term_memory_types,
agent_evolution_enabled=agent_evolution_enabled,
allow_self_memory=self_memory_enabled,
+ peer_memory_enabled=peer_memory_enabled,
allowed_peer_ids=allowed_peer_ids,
event_search_tags=event_search_tags,
)
@@ -2647,14 +2652,6 @@ class Session:
if extraction_error is not None:
raise extraction_error
- if long_term_has_work and self._viking_fs:
- candidate_memory_diff_uri = f"{archive_uri}/memory_diff.json"
- if await self._viking_fs.exists(
- candidate_memory_diff_uri,
- ctx=self.ctx,
- ):
- memory_diff_uri = candidate_memory_diff_uri
-
total_extracted = 0
for label, result in zip(extraction_labels, _results, strict=True):
if label == "archive_summary":
@@ -2698,6 +2695,35 @@ class Session:
else:
await _run_archive_summary()
+ # A recovered Phase 2 run may have already completed the
+ # long-term step before a sibling step failed. Reuse its
+ # persisted diff instead of reporting an empty task result.
+ if completed_memory_steps.get("long_term") and self._viking_fs:
+ candidate_memory_diff_uri = f"{archive_uri}/memory_diff.json"
+ if await self._viking_fs.exists(
+ candidate_memory_diff_uri,
+ ctx=self.ctx,
+ ):
+ memory_diff_uri = candidate_memory_diff_uri
+ try:
+ raw_memory_diff = await self._viking_fs.read_file(
+ candidate_memory_diff_uri,
+ ctx=self.ctx,
+ )
+ memory_diff = json.loads(raw_memory_diff or "{}")
+ if isinstance(memory_diff, dict):
+ skipped_memory_operations.extend(
+ item
+ for item in memory_diff.get("skipped_operations", [])
+ if isinstance(item, dict)
+ )
+ except Exception as exc:
+ logger.warning(
+ "Failed to read skipped memory operations from %s: %s",
+ candidate_memory_diff_uri,
+ exc,
+ )
+
# Update active_count (using snapshot, not self._usage_records)
if self._vikingdb_manager:
uris = [u.uri for u in usage_records if u.uri]
@@ -2766,6 +2792,10 @@ class Session:
for item in extracted_skill_results
if isinstance(item, dict) and (item.get("uri") or item.get("root_uri"))
],
+ "memory_extraction": {
+ "skipped": len(skipped_memory_operations),
+ "skipped_operations": skipped_memory_operations,
+ },
"usage_events_extracted": usage_events_extracted,
"active_count_updated": active_count_updated,
"effective_memory_types": sorted(
diff --git a/tests/session/memory/test_memory_diff.py b/tests/session/memory/test_memory_diff.py
index a55bb0abd..6d6a2a844 100644
--- a/tests/session/memory/test_memory_diff.py
+++ b/tests/session/memory/test_memory_diff.py
@@ -477,7 +477,14 @@ class TestMemoryDiffStructure:
def test_memory_diff_structure(self):
"""Verify memory_diff.json structure."""
# This test validates the expected structure
- expected_keys = ["archive_uri", "trace_id", "extracted_at", "operations", "summary"]
+ expected_keys = [
+ "archive_uri",
+ "trace_id",
+ "extracted_at",
+ "operations",
+ "skipped_operations",
+ "summary",
+ ]
# We verify this through the actual implementation tests above
# This is a placeholder for documentation
@@ -487,6 +494,7 @@ class TestMemoryDiffStructure:
"trace_id",
"extracted_at",
"operations",
+ "skipped_operations",
"summary",
}
)
diff --git a/tests/session/memory/test_memory_isolation_handler.py b/tests/session/memory/test_memory_isolation_handler.py
index 1ec666af8..8e2186dad 100644
--- a/tests/session/memory/test_memory_isolation_handler.py
+++ b/tests/session/memory/test_memory_isolation_handler.py
@@ -11,6 +11,7 @@ import pytest
from openviking.message.message import Message
from openviking.message.part import TextPart
from openviking.server.identity import RequestContext, Role
+from openviking.session.memory.dataclass import MemoryOperationSkipCode
from openviking.session.memory.memory_isolation_handler import (
MemoryIsolationHandler,
)
@@ -83,6 +84,14 @@ class TestGetReadScope:
assert scope.user_ids == ["user_a"]
assert scope.peer_ids == []
+ def test_explicit_self_sentinel_message_is_not_a_writable_target(self):
+ ctx = create_ctx()
+ message = create_message("user", peer_id="__self")
+ extract_ctx = create_mock_extract_context([message])
+ handler = MemoryIsolationHandler(ctx, extract_ctx, allow_self=True)
+
+ assert handler._message_target_id(message) is None
+
def test_deduplicate_users(self):
"""Test that duplicate users are deduplicated."""
ctx = create_ctx()
@@ -292,6 +301,21 @@ class TestFillIdentityFields:
assert item_dict["user_id"] == "user_a"
assert item_dict["peer_id"] == "web-visitor-alice"
+ def test_invalid_peer_classification_does_not_change_identity_field_semantics(self):
+ ctx = create_ctx()
+ extract_ctx = create_mock_extract_context([create_message("user")])
+ handler = MemoryIsolationHandler(ctx, extract_ctx)
+ role_scope = handler.get_read_scope()
+
+ item_dict = {"peer_id": "web/visitor/alice"}
+ resolution_skip = handler._classify_identity_fields(item_dict)
+ result = handler.fill_identity_fields(item_dict, role_scope)
+
+ assert resolution_skip is not None
+ assert resolution_skip.reason_code == MemoryOperationSkipCode.INVALID_PEER_ID
+ assert result is None
+ assert item_dict == {"user_id": "user_a"}
+
class TestPrepareMessages:
"""Tests for prepare_messages under the user/peer model."""
@@ -876,9 +900,76 @@ class TestCalculateMemoryUris:
uris = handler.calculate_memory_uris(schema, operation, extract_ctx)
assert uris == []
+ assert operation.resolution_skip is not None
+ assert operation.resolution_skip.reason_code == MemoryOperationSkipCode.PEER_NOT_ALLOWED
assert "peer_id" not in operation.memory_fields
mock_generate_uri.assert_not_called()
+ def test_calculate_memory_uris_classifies_peer_policy_skip(self):
+ from openviking.session.memory.dataclass import MemoryTypeSchema, ResolvedOperation
+
+ ctx = create_ctx(user_id="support_bot")
+ extract_ctx = create_mock_extract_context(
+ [create_message("user", peer_id="web-visitor-alice")]
+ )
+ handler = MemoryIsolationHandler(
+ ctx,
+ extract_ctx,
+ allow_self=False,
+ allowed_peer_ids=set(),
+ peer_memory_enabled=False,
+ )
+ operation = ResolvedOperation(
+ old_memory_file_content=None,
+ memory_fields={"peer_id": "web-visitor-alice"},
+ memory_type="preferences",
+ uris=[],
+ )
+
+ uris = handler.calculate_memory_uris(
+ MemoryTypeSchema(
+ memory_type="preferences",
+ filename_template="preferences.md",
+ directory="viking://user/{user_space}/memories",
+ ),
+ operation,
+ extract_ctx,
+ )
+
+ assert uris == []
+ assert operation.resolution_skip is not None
+ assert operation.resolution_skip.reason_code == (
+ MemoryOperationSkipCode.PEER_MEMORY_DISABLED
+ )
+
+ def test_calculate_memory_uris_classifies_invalid_ranges(self):
+ from openviking.session.memory.dataclass import MemoryTypeSchema, ResolvedOperation
+
+ ctx = create_ctx(user_id="support_bot")
+ extract_ctx = create_mock_extract_context([create_message("user")])
+ handler = MemoryIsolationHandler(ctx, extract_ctx)
+ operation = ResolvedOperation(
+ old_memory_file_content=None,
+ memory_fields={"ranges": "10-20"},
+ memory_type="preferences",
+ uris=[],
+ )
+
+ uris = handler.calculate_memory_uris(
+ MemoryTypeSchema(
+ memory_type="preferences",
+ filename_template="preferences.md",
+ directory="viking://user/{user_space}/memories",
+ ),
+ operation,
+ extract_ctx,
+ )
+
+ assert uris == []
+ assert operation.resolution_skip is not None
+ assert operation.resolution_skip.reason_code == MemoryOperationSkipCode.INVALID_RANGES
+ extract_ctx.read_message_ranges.assert_called_once_with("10-20")
+
@patch("openviking.session.memory.memory_isolation_handler.generate_uri")
def test_calculate_memory_uris_missing_peer_id_prefers_self_when_allowed(
self, mock_generate_uri
@@ -1196,5 +1287,7 @@ class TestCalculateMemoryUris:
uris = handler.calculate_memory_uris(schema, operation, extract_ctx)
assert uris == []
+ assert operation.resolution_skip is not None
+ assert operation.resolution_skip.reason_code == MemoryOperationSkipCode.INVALID_PEER_ID
assert "peer_id" not in operation.memory_fields
mock_generate_uri.assert_not_called()
diff --git a/tests/session/memory/test_memory_react.py b/tests/session/memory/test_memory_react.py
index 30cfc4f3c..2c24785a5 100644
--- a/tests/session/memory/test_memory_react.py
+++ b/tests/session/memory/test_memory_react.py
@@ -7,6 +7,7 @@ Tests for memory ExtractLoop orchestrator.
from unittest.mock import AsyncMock, MagicMock
import pytest
+from pydantic import BaseModel, Field
from openviking.session.memory.dataclass import (
MemoryFile,
@@ -17,6 +18,7 @@ from openviking.session.memory.dataclass import (
from openviking.session.memory.extract_loop import (
ExtractLoop,
)
+from openviking.session.memory.memory_isolation_handler import MemoryIsolationHandler
from openviking.session.memory.merge_op import SearchReplaceBlock, StrPatch
from openviking.session.memory.schema_model_generator import SchemaModelGenerator
@@ -159,6 +161,89 @@ class TestAllowedDirectoriesList:
class TestExtractLoopFinalJsonRetry:
+ @staticmethod
+ def _invalid_peer_resolution_loop(target_uri=None):
+ schema = MemoryTypeSchema(
+ memory_type="preferences",
+ description="Preferences",
+ directory="viking://user/{{ user_space }}/memories",
+ filename_template="preferences.md",
+ fields=[],
+ )
+ context_provider = MagicMock()
+ context_provider.get_memory_schemas.return_value = [schema]
+ context_provider.read_file_contents = {}
+
+ ctx = MagicMock()
+ ctx.user.user_id = "user_a"
+ extract_context = MagicMock()
+ extract_context.messages = []
+ extract_context.page_id_map.resolve.return_value = target_uri
+
+ extract_loop = object.__new__(ExtractLoop)
+ extract_loop.ctx = ctx
+ extract_loop.context_provider = context_provider
+ extract_loop._extract_context = extract_context
+ extract_loop._isolation_handler = MemoryIsolationHandler(ctx, extract_context)
+ return extract_loop
+
+ @pytest.mark.asyncio
+ async def test_existing_page_id_keeps_write_target_without_invalid_peer_metadata(self):
+ class PreferenceItem(BaseModel):
+ page_id: int
+ peer_id: str
+
+ class Operations(BaseModel):
+ preferences: list[PreferenceItem]
+ delete_ids: list = Field(default_factory=list)
+
+ target_uri = "viking://user/user_a/memories/preferences.md"
+ extract_loop = self._invalid_peer_resolution_loop(target_uri)
+
+ resolved, _ = await extract_loop.resolve_operations(
+ Operations(
+ preferences=[
+ PreferenceItem(page_id=7, peer_id="web/visitor/alice"),
+ ]
+ )
+ )
+
+ operation = resolved.upsert_operations[0]
+ assert operation.uris == [target_uri]
+ assert operation.resolution_skip is None
+ assert operation.memory_fields == {
+ "memory_type": "preferences",
+ "user_id": "user_a",
+ }
+
+ @pytest.mark.asyncio
+ async def test_invalid_peer_hint_preserves_legacy_self_write_fallback(self):
+ class PreferenceItem(BaseModel):
+ page_id: int
+ peer_id: str
+
+ class Operations(BaseModel):
+ preferences: list[PreferenceItem]
+ delete_ids: list = Field(default_factory=list)
+
+ extract_loop = self._invalid_peer_resolution_loop()
+
+ resolved, _ = await extract_loop.resolve_operations(
+ Operations(
+ preferences=[
+ PreferenceItem(page_id=101, peer_id="web/visitor/alice"),
+ ]
+ )
+ )
+
+ operation = resolved.upsert_operations[0]
+ assert operation.uris == ["viking://user/user_a/memories/preferences.md"]
+ assert operation.resolution_skip is None
+ assert operation.memory_fields == {
+ "memory_type": "preferences",
+ "user_id": "user_a",
+ }
+
@pytest.mark.asyncio
async def test_structured_parser_preserves_delete_ids(self):
class FakeContextProvider:
diff --git a/tests/session/memory/test_memory_updater.py b/tests/session/memory/test_memory_updater.py
index 2de3d7dec..4dd7cd65c 100644
--- a/tests/session/memory/test_memory_updater.py
+++ b/tests/session/memory/test_memory_updater.py
@@ -15,6 +15,8 @@ from openviking.server.identity import RequestContext, Role
from openviking.session.memory.dataclass import (
MemoryField,
MemoryFile,
+ MemoryOperationSkip,
+ MemoryOperationSkipCode,
MemoryOperationSource,
MemoryTypeSchema,
ResolvedOperation,
@@ -480,6 +482,49 @@ class TestMemoryUpdater:
"Skipping unresolved memory operation: events(page_id=102): Missing resolved URI"
)
+ @pytest.mark.asyncio
+ async def test_apply_operations_reports_expected_empty_uri_as_skip(self):
+ updater = MemoryUpdater(registry=MagicMock())
+ updater._get_viking_fs = MagicMock(return_value=MagicMock())
+ updater._apply_upsert = AsyncMock(return_value=None)
+ updater._sync_resource_refs_for_result = AsyncMock()
+ updater._vectorize_memories = AsyncMock()
+ updater.generate_overview = AsyncMock()
+ operation = ResolvedOperation(
+ memory_fields={"peer_id": "web-visitor-alice"},
+ memory_type="preferences",
+ uris=[],
+ page_id=102,
+ resolution_skip=MemoryOperationSkip(
+ reason_code=MemoryOperationSkipCode.PEER_NOT_ALLOWED,
+ reason="Target peer is outside the allowed memory scope",
+ ),
+ )
+ operations = ResolvedOperations(
+ upsert_operations=[operation],
+ delete_file_contents=[],
+ errors=[],
+ )
+ ctx = RequestContext(user=UserIdentifier("acme", "alice"), role=Role.USER)
+
+ with (
+ patch("openviking.session.memory.memory_updater.tracer.info") as tracer_info,
+ patch("openviking.session.memory.memory_updater.tracer.error") as tracer_error,
+ ):
+ result = await updater.apply_operations(operations=operations, ctx=ctx)
+
+ assert result.errors == []
+ assert len(result.skipped_operations) == 1
+ assert result.skipped_operations[0].reason_code == (
+ MemoryOperationSkipCode.PEER_NOT_ALLOWED
+ )
+ updater._apply_upsert.assert_not_awaited()
+ tracer_error.assert_not_called()
+ tracer_info.assert_any_call(
+ "Skipping memory operation by resolution policy: "
+ "memory_type=preferences page_id=102 reason_code=peer_not_allowed"
+ )
+
@pytest.mark.asyncio
async def test_apply_operations_skips_deletes_when_replacement_uri_is_unresolved(self):
registry = MagicMock()
@@ -534,6 +579,46 @@ class TestMemoryUpdater:
]
updater._apply_delete.assert_not_awaited()
+ @pytest.mark.asyncio
+ async def test_apply_operations_preserves_legacy_delete_suppression_for_expected_skip(self):
+ updater = MemoryUpdater(registry=MagicMock())
+ updater._get_viking_fs = MagicMock(return_value=MagicMock())
+ updater._apply_upsert = AsyncMock(return_value=None)
+ updater._apply_delete = AsyncMock()
+ updater._sync_resource_refs_for_result = AsyncMock()
+ updater._vectorize_memories = AsyncMock()
+ updater.generate_overview = AsyncMock()
+ old_uri = "viking://user/alice/memories/preferences/old.md"
+ operations = ResolvedOperations(
+ upsert_operations=[
+ ResolvedOperation(
+ memory_fields={"ranges": "99"},
+ memory_type="preferences",
+ uris=[],
+ page_id=102,
+ resolution_skip=MemoryOperationSkip(
+ reason_code=MemoryOperationSkipCode.INVALID_RANGES,
+ reason="Message ranges are malformed or out of bounds",
+ ),
+ )
+ ],
+ delete_file_contents=[
+ MemoryFile(uri=old_uri, extra_fields={"memory_type": "preferences"})
+ ],
+ errors=[],
+ )
+ ctx = RequestContext(user=UserIdentifier("acme", "alice"), role=Role.USER)
+
+ result = await updater.apply_operations(operations=operations, ctx=ctx)
+
+ assert [(target, str(error)) for target, error in result.errors] == [
+ (old_uri, "Skipped delete because batch contains unresolved upsert URIs")
+ ]
+ assert [item.reason_code for item in result.skipped_operations] == [
+ MemoryOperationSkipCode.INVALID_RANGES,
+ ]
+ updater._apply_delete.assert_not_awaited()
+
@pytest.mark.asyncio
async def test_apply_operations_matches_overview_directory_from_resolved_user_uri(self):
"""Overview generation should use the resolved user memory directory."""
diff --git a/tests/session/memory/test_streaming_memory_updater.py b/tests/session/memory/test_streaming_memory_updater.py
index 3b2772a0c..0a2ff297a 100644
--- a/tests/session/memory/test_streaming_memory_updater.py
+++ b/tests/session/memory/test_streaming_memory_updater.py
@@ -13,10 +13,12 @@ from openviking.server.identity import RequestContext, Role
from openviking.session.memory.dataclass import (
MemoryField,
MemoryFile,
+ MemoryOperationSkipCode,
MemoryOperationSource,
MemoryTypeSchema,
ResolvedOperation,
ResolvedOperations,
+ SkippedMemoryOperation,
StoredLink,
)
from openviking.session.memory.memory_type_registry import MemoryTypeRegistry
@@ -715,8 +717,7 @@ async def test_merge_requests_merges_cross_session_operation_kinds_in_parallel(m
else:
kind = "update"
assert all(
- op.old_memory_file_content is not None
- for op in operations.upsert_operations
+ op.old_memory_file_content is not None for op in operations.upsert_operations
)
assert kwargs["force_merge"] is True
entered.add(kind)
@@ -795,6 +796,28 @@ def test_scope_memory_update_result_to_submitter_filters_shared_batch_by_source(
apply_result = MemoryUpdateResult()
apply_result.add_written(op_a.uris[0])
apply_result.add_written(op_b.uris[0])
+ apply_result.add_skipped(
+ SkippedMemoryOperation(
+ memory_type="preferences",
+ reason_code=MemoryOperationSkipCode.PEER_NOT_ALLOWED,
+ reason="Target peer is outside the allowed memory scope",
+ source=MemoryOperationSource(
+ extraction_id="extract_a",
+ session_id="session_a",
+ ),
+ )
+ )
+ apply_result.add_skipped(
+ SkippedMemoryOperation(
+ memory_type="preferences",
+ reason_code=MemoryOperationSkipCode.PEER_MEMORY_DISABLED,
+ reason="Peer memory writes are disabled",
+ source=MemoryOperationSource(
+ extraction_id="extract_b",
+ session_id="session_a",
+ ),
+ )
+ )
batch_result = StreamingMemoryUpdateResult(
operations=ResolvedOperations(
upsert_operations=[op_a, op_b],
@@ -822,6 +845,10 @@ def test_scope_memory_update_result_to_submitter_filters_shared_batch_by_source(
assert scoped.metadata["batch_request_count"] == 2
assert scoped.metadata["scoped_to_source_extraction_id"] == "extract_a"
assert scoped.apply_result.written_uris == [op_a.uris[0]]
+ assert len(scoped.apply_result.skipped_operations) == 1
+ assert scoped.apply_result.skipped_operations[0].reason_code == (
+ MemoryOperationSkipCode.PEER_NOT_ALLOWED
+ )
assert scoped.operations.upsert_operations == [op_a]
assert scoped.metadata["unscoped_written_uris"] == [op_a.uris[0], op_b.uris[0]]
@@ -866,6 +893,38 @@ def test_split_request_by_merge_group_groups_by_peer_and_memory_type():
]
+def test_split_request_keeps_unresolved_upserts_separate_from_delete_groups():
+ replacement = _note_op("replacement")
+ unresolved = _note_op("skipped")
+ unresolved.uris = []
+ old_file = _note_delete_file("old")
+ request = MemoryUpdateRequest(
+ operations=ResolvedOperations(
+ upsert_operations=[replacement, unresolved],
+ delete_file_contents=[old_file],
+ errors=[],
+ delete_replacements={old_file.uri: replacement.uris[0]},
+ ),
+ messages=[],
+ ctx=_ctx(),
+ )
+
+ grouped = split_request_by_merge_group(request)
+
+ assert len(grouped) == 2
+ replacement_key, replacement_request = grouped[0]
+ assert replacement_key == MemoryMergeGroupKey(peer_id=None, memory_type="notes")
+ assert replacement_request.operations.upsert_operations == [replacement]
+ assert replacement_request.operations.delete_file_contents == [old_file]
+ assert replacement_request.operations.delete_replacements == {old_file.uri: replacement.uris[0]}
+
+ unresolved_key, unresolved_request = grouped[1]
+ assert unresolved_key == MemoryMergeGroupKey(peer_id=None, memory_type="")
+ assert unresolved_request.operations.upsert_operations == [unresolved]
+ assert unresolved_request.operations.delete_file_contents == []
+ assert unresolved_request.operations.delete_replacements == {}
+
+
def test_split_request_by_merge_group_infers_peer_from_uri_when_field_missing():
peer_uri = "viking://user/u/peers/conv-42/memories/notes/peer_note.md"
op = ResolvedOperation(
diff --git a/tests/session/test_compressor_v3.py b/tests/session/test_compressor_v3.py
index be59bdb4c..0ef2080c8 100644
--- a/tests/session/test_compressor_v3.py
+++ b/tests/session/test_compressor_v3.py
@@ -3,6 +3,7 @@
from __future__ import annotations
+import inspect
from types import SimpleNamespace
from unittest.mock import AsyncMock
@@ -21,8 +22,10 @@ from openviking.session.compressor_v3 import (
)
from openviking.session.memory.dataclass import (
MemoryFile,
+ MemoryOperationSkipCode,
ResolvedOperation,
ResolvedOperations,
+ SkippedMemoryOperation,
StoredLink,
)
from openviking.session.memory.memory_updater import MemoryUpdateResult
@@ -95,6 +98,64 @@ def test_factory_ignores_deprecated_memory_version():
)
+def test_extract_long_term_memories_preserves_legacy_positional_parameter_order():
+ parameter_names = list(
+ inspect.signature(SessionCompressorV3.extract_long_term_memories).parameters
+ )
+
+ assert parameter_names[-4:] == [
+ "allow_self_memory",
+ "allowed_peer_ids",
+ "event_search_tags",
+ "peer_memory_enabled",
+ ]
+
+
+async def test_memory_diff_includes_intentionally_skipped_operations(monkeypatch):
+ monkeypatch.setattr(
+ "openviking.session.compressor_v3.get_viking_fs",
+ lambda: SimpleNamespace(),
+ )
+ compressor = SessionCompressorV3(vikingdb=None)
+ result = MemoryUpdateResult()
+ result.add_skipped(
+ SkippedMemoryOperation(
+ memory_type="events",
+ page_id=101,
+ reason_code=MemoryOperationSkipCode.INVALID_RANGES,
+ reason="No valid event range could be resolved",
+ )
+ )
+
+ diff = await compressor._build_memory_diff(
+ result=result,
+ operations=ResolvedOperations(
+ upsert_operations=[],
+ delete_file_contents=[],
+ errors=[],
+ ),
+ viking_fs=SimpleNamespace(),
+ ctx=_ctx(),
+ archive_uri="viking://user/u/sessions/s1/history/archive_001",
+ )
+
+ assert diff["skipped_operations"] == [
+ {
+ "memory_type": "events",
+ "page_id": 101,
+ "reason_code": "invalid_ranges",
+ "reason": "No valid event range could be resolved",
+ }
+ ]
+ assert diff["summary"] == {
+ "total_adds": 0,
+ "total_updates": 0,
+ "total_deletes": 0,
+ "total_skipped": 1,
+ }
+
+
@pytest.mark.asyncio
async def test_v3_skips_agent_training_when_agent_evolution_is_disabled(monkeypatch):
monkeypatch.setattr(
@@ -108,12 +169,19 @@ async def test_v3_skips_agent_training_when_agent_evolution_is_disabled(monkeypa
cases=[_training_case()],
memory_diff={"operations": {}},
case_uri_by_name={},
+ skipped_operations=[
+ {
+ "memory_type": "profile",
+ "reason_code": "peer_memory_disabled",
+ "reason": "Peer memory writes are disabled",
+ }
+ ],
)
)
compressor.train_from_extracted_cases = AsyncMock()
compressor._write_final_memory_diff = AsyncMock()
- await compressor.extract_long_term_memories(
+ result = await compressor.extract_long_term_memories(
messages=_messages(),
ctx=_ctx(),
allowed_memory_types={"cases", "profile"},
@@ -121,6 +189,7 @@ async def test_v3_skips_agent_training_when_agent_evolution_is_disabled(monkeypa
)
compressor.train_from_extracted_cases.assert_not_awaited()
+ assert result == []
@pytest.mark.asyncio
@@ -1065,7 +1134,20 @@ async def test_v3_fast_path_writes_final_memory_diff_with_case_traj_and_exp(monk
"updates": [],
"deletes": [],
},
- "summary": {"total_adds": 1, "total_updates": 0, "total_deletes": 0},
+ "skipped_operations": [
+ {
+ "memory_type": "preferences",
+ "page_id": 102,
+ "reason_code": "peer_not_allowed",
+ "reason": "Target peer is outside the allowed memory scope",
+ }
+ ],
+ "summary": {
+ "total_adds": 1,
+ "total_updates": 0,
+ "total_deletes": 0,
+ "total_skipped": 1,
+ },
},
)
@@ -1118,7 +1200,20 @@ async def test_v3_fast_path_writes_final_memory_diff_with_case_traj_and_exp(monk
"trajectories",
]
assert [item["memory_type"] for item in diff["operations"]["updates"]] == ["experiences"]
- assert diff["summary"] == {"total_adds": 2, "total_updates": 1, "total_deletes": 0}
+ assert diff["skipped_operations"] == [
+ {
+ "memory_type": "preferences",
+ "page_id": 102,
+ "reason_code": "peer_not_allowed",
+ "reason": "Target peer is outside the allowed memory scope",
+ }
+ ]
+ assert diff["summary"] == {
+ "total_adds": 2,
+ "total_updates": 1,
+ "total_deletes": 0,
+ "total_skipped": 1,
+ }
@pytest.mark.asyncio
@@ -1190,7 +1285,12 @@ async def test_v3_builds_training_memory_diff_from_streaming_result(monkeypatch)
archive_uri=archive_uri,
)
- assert diff["summary"] == {"total_adds": 1, "total_updates": 1, "total_deletes": 0}
+ assert diff["summary"] == {
+ "total_adds": 1,
+ "total_updates": 1,
+ "total_deletes": 0,
+ "total_skipped": 0,
+ }
assert diff["operations"]["adds"][0]["memory_type"] == "trajectories"
update = diff["operations"]["updates"][0]
assert update["memory_type"] == "experiences"
@@ -1287,7 +1387,12 @@ async def test_v3_training_memory_diff_filters_batch_items_by_current_analysis_t
archive_uri=archive_uri,
)
- assert diff["summary"] == {"total_adds": 2, "total_updates": 0, "total_deletes": 0}
+ assert diff["summary"] == {
+ "total_adds": 2,
+ "total_updates": 0,
+ "total_deletes": 0,
+ "total_skipped": 0,
+ }
assert [op["uri"] for op in diff["operations"]["adds"]] == [traj_a, exp_a]
diff --git a/tests/session/test_session_commit.py b/tests/session/test_session_commit.py
index 53030d4a9..640633d34 100644
--- a/tests/session/test_session_commit.py
+++ b/tests/session/test_session_commit.py
@@ -115,6 +115,133 @@ class TestCommit:
# Wait for semantic/embedding queues
await service.resources.wait_processed(timeout=60.0)
+ async def test_commit_task_reports_intentionally_skipped_memory_operations(
+ self,
+ session_with_messages: Session,
+ ):
+ async def extract_long_term_memories(**kwargs):
+ archive_uri = kwargs["archive_uri"]
+ await session_with_messages._viking_fs.write_file(
+ uri=f"{archive_uri}/memory_diff.json",
+ content=json.dumps(
+ {
+ "archive_uri": archive_uri,
+ "operations": {"adds": [], "updates": [], "deletes": []},
+ "summary": {
+ "total_adds": 0,
+ "total_updates": 0,
+ "total_deletes": 0,
+ "total_skipped": 1,
+ },
+ "skipped_operations": [
+ {
+ "memory_type": "preferences",
+ "page_id": 102,
+ "reason_code": "peer_not_allowed",
+ "reason": "Target peer is outside the allowed memory scope",
+ }
+ ],
+ }
+ ),
+ ctx=session_with_messages.ctx,
+ )
+ return []
+
+ session_with_messages._session_compressor.extract_long_term_memories = AsyncMock(
+ side_effect=extract_long_term_memories
+ )
+
+ commit_result = await session_with_messages.commit_async()
+ task_result = await _wait_for_task(commit_result["task_id"])
+
+ assert commit_result["status"] == "accepted"
+ assert task_result["status"] == "completed"
+ assert task_result["result"]["memory_extraction"] == {
+ "skipped": 1,
+ "skipped_operations": [
+ {
+ "memory_type": "preferences",
+ "page_id": 102,
+ "reason_code": "peer_not_allowed",
+ "reason": "Target peer is outside the allowed memory scope",
+ }
+ ],
+ }
+
+ async def test_recovered_commit_task_reads_existing_skipped_memory_operations(
+ self,
+ session_with_messages: Session,
+ monkeypatch,
+ ):
+ original_prepare = Session._prepare_phase2_archive_messages
+
+ async def prepare_with_completed_long_term(self, archive_uri, current_messages):
+ (
+ messages,
+ coverage_start_archive,
+ coverage_end_archive,
+ covered_failed_archives,
+ completed_memory_steps,
+ ) = await original_prepare(self, archive_uri, current_messages)
+ completed_memory_steps.setdefault("long_term", set()).update(
+ message.id for message in messages
+ )
+ await self._viking_fs.write_file(
+ uri=f"{archive_uri}/memory_diff.json",
+ content=json.dumps(
+ {
+ "archive_uri": archive_uri,
+ "operations": {"adds": [], "updates": [], "deletes": []},
+ "summary": {
+ "total_adds": 0,
+ "total_updates": 0,
+ "total_deletes": 0,
+ "total_skipped": 1,
+ },
+ "skipped_operations": [
+ {
+ "memory_type": "preferences",
+ "page_id": 102,
+ "reason_code": "peer_not_allowed",
+ "reason": "Target peer is outside the allowed memory scope",
+ }
+ ],
+ }
+ ),
+ ctx=self.ctx,
+ )
+ return (
+ messages,
+ coverage_start_archive,
+ coverage_end_archive,
+ covered_failed_archives,
+ completed_memory_steps,
+ )
+
+ monkeypatch.setattr(
+ Session,
+ "_prepare_phase2_archive_messages",
+ prepare_with_completed_long_term,
+ )
+ session_with_messages._session_compressor.extract_long_term_memories = AsyncMock()
+
+ commit_result = await session_with_messages.commit_async()
+ task_result = await _wait_for_task(commit_result["task_id"])
+
+ assert task_result["status"] == "completed"
+ assert task_result["result"]["memory_extraction"] == {
+ "skipped": 1,
+ "skipped_operations": [
+ {
+ "memory_type": "preferences",
+ "page_id": 102,
+ "reason_code": "peer_not_allowed",
+ "reason": "Target peer is outside the allowed memory scope",
+ }
+ ],
+ }
+ session_with_messages._session_compressor.extract_long_term_memories.assert_not_awaited()
+
async def test_commit_default_disables_agent_memory_but_keeps_archive(
self, session_with_messages: Session
):
@@ -365,6 +492,7 @@ class TestCommit:
ctx,
allowed_memory_types,
allow_self_memory=True,
+ peer_memory_enabled=True,
allowed_peer_ids=None,
**kwargs,
):
@@ -373,6 +501,7 @@ class TestCommit:
{
"allowed_memory_types": set(allowed_memory_types or set()),
"allow_self_memory": allow_self_memory,
+ "peer_memory_enabled": peer_memory_enabled,
"allowed_peer_ids": set(allowed_peer_ids or set()),
"roles": [message.role for message in messages],
"peer_ids": [message.peer_id for message in messages],
@@ -411,6 +540,7 @@ class TestCommit:
"profile",
},
"allow_self_memory": False,
+ "peer_memory_enabled": True,
"allowed_peer_ids": {"web-visitor-alice"},
"roles": ["user", "assistant"],
"peer_ids": ["web-visitor-alice", "web-visitor-alice"],