Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.
Python agent-contextagent-memoryagent-pluginsagentic-ragcontext-databasedsh-pluginknowledge-basememorymemory-managementself-evolvingvector-database
fix(memory): event_overview_refresh_bug (#2678)
fujiajie666ccb2924011f6
diff --git a/openviking/prompts/templates/memory/entities.yaml b/openviking/prompts/templates/memory/entities.yamlindex 2e4c5c0ea..4c1a4db94 100644--- a/openviking/prompts/templates/memory/entities.yaml+++ b/openviking/prompts/templates/memory/entities.yaml@@ -15,9 +15,9 @@ embedding_template: |-overview_template: |-# Entities Overview- {% if items %}**Category:** {{ items[0].file_content.category }}{% endif %}+ {% if items %}**Category:** {{ items[0].file_content.category|default(directory_name, true) }}{% endif %}{% for item in items %}- - [{{ item.file_content.name }}](./{{ item.file_name }})+ - [{{ item.file_content.name|default(item.file_name, true) }}](./{{ item.file_name }}){% endfor %}fields:diff --git a/openviking/prompts/templates/memory/events.yaml b/openviking/prompts/templates/memory/events.yamlindex 1cb6c1f9f..7837cdc97 100644--- a/openviking/prompts/templates/memory/events.yaml+++ b/openviking/prompts/templates/memory/events.yaml@@ -107,9 +107,8 @@ embedding_template: |-{{ content }}overview_template: |-# Events Overview- {% if items %}**Date:** {{ extract_context.get_year(items[0].file_content.ranges|default(''))|default('') }}/{{ extract_context.get_month(items[0].file_content.ranges|default(''))|default('') }}/{{ extract_context.get_day(items[0].file_content.ranges|default(''))|default('') }}{% endif %}{% for item in items %}- - [{{ item.file_content.summary }}](./{{ item.file_name }})+ - [{{ item.file_content.summary|default(item.file_name, true) }}](./{{ item.file_name }}){% endfor %}fields:diff --git a/openviking/prompts/templates/memory/preferences.yaml b/openviking/prompts/templates/memory/preferences.yamlindex 6c89a5386..65bbfadb4 100644--- a/openviking/prompts/templates/memory/preferences.yaml+++ b/openviking/prompts/templates/memory/preferences.yaml@@ -20,10 +20,10 @@ embedding_template: |-overview_template: |-# Preferences Overview- {% if items %}**User:** {{ items[0].file_content.user }}- **Topic:** {{ items[0].file_content.topic }}{% endif %}+ {% if items %}**User:** {{ items[0].file_content.user|default(directory_name, true) }}+ **Topic:** {{ items[0].file_content.topic|default(items[0].file_name, true) }}{% endif %}{% for item in items %}- - [{{ item.file_content.topic }}](./{{ item.file_name }})+ - [{{ item.file_content.topic|default(item.file_name, true) }}](./{{ item.file_name }}){% endfor %}fields:diff --git a/openviking/service/resource_memory_link_service.py b/openviking/service/resource_memory_link_service.pyindex 07a311ff5..5280f1ede 100644--- a/openviking/service/resource_memory_link_service.py+++ b/openviking/service/resource_memory_link_service.py@@ -9,6 +9,7 @@ files' MEMORY_FIELDS metadata.from __future__ import annotationsimport asyncio+import refrom dataclasses import dataclassfrom datetime import datetime, timezonefrom typing import TYPE_CHECKING, Any, Dict, List, Optional, Sequence@@ -24,16 +25,13 @@ from openviking.core.peer_id import normalize_peer_idfrom openviking.message.part import TextPartfrom openviking.server.identity import RequestContextfrom openviking.session.memory.dataclass import MemoryFile-from openviking.session.memory.memory_updater import (- MemoryUpdater,- MemoryUpdateResult,-)+from openviking.session.memory.memory_updater import MemoryUpdateResultfrom openviking.session.memory.utils.memory_file_utils import MemoryFileUtilsfrom openviking.session.memory.utils.resource_refs import (content_references_resource,extract_resource_uris,- remove_resource_references_from_memory,resource_ref_matches,+ unlink_resource_references_from_memory,)from openviking.storage import VikingDBManagerfrom openviking.storage.viking_fs import VikingFS, get_viking_fs@@ -47,6 +45,7 @@ logger = get_logger(__name__)_RESOURCE_REASON_SESSION_ID = "__openviking_resource_reason__"_RESOURCE_REASON_MEMORY_TYPES = ["entities", "events", "preferences"]+_RESOURCE_DELETION_MEMORY_TYPES = ["entities", "preferences"]_RESOURCE_REASON_COMMIT_TIMEOUT_SECONDS = 1800.0_RESOURCE_ABSTRACT_MAX_CHARS = 200_ABSTRACT_NOT_READY_MARKERS = (@@ -55,15 +54,34 @@ _ABSTRACT_NOT_READY_MARKERS = ()-def _resource_reason_memory_policy(target_peer_id: Optional[str] = None) -> Dict[str, Any]:+def _resource_memory_policy(+ *,+ memory_types: Sequence[str],+ target_peer_id: Optional[str] = None,+) -> Dict[str, Any]:peer_targeted = bool(target_peer_id)return {"self": {"enabled": not peer_targeted},"peer": {"enabled": peer_targeted},- "memory_types": list(_RESOURCE_REASON_MEMORY_TYPES),+ "memory_types": list(memory_types),}+def _resource_reason_memory_policy(target_peer_id: Optional[str] = None) -> Dict[str, Any]:+ return _resource_memory_policy(+ memory_types=_RESOURCE_REASON_MEMORY_TYPES,+ target_peer_id=target_peer_id,+ )+++def _resource_deletion_memory_policy(target_peer_id: Optional[str] = None) -> Dict[str, Any]:+ # Events are append-only, so deletion commits update only mutable memory types.+ return _resource_memory_policy(+ memory_types=_RESOURCE_DELETION_MEMORY_TYPES,+ target_peer_id=target_peer_id,+ )++def _resource_reason_peer_id(ctx: RequestContext, resource_uri: str) -> Optional[str]:actor_peer_id = normalize_peer_id(ctx.actor_peer_id)if actor_peer_id:@@ -197,6 +215,72 @@ class ResourceMemoryLinkService:"commit_task": task_result,}+ async def on_resource_deleted(+ self,+ *,+ ctx: RequestContext,+ resource_uri: str,+ memory_uris: Sequence[str],+ recursive: bool = False,+ timeout: Optional[float] = None,+ ) -> Dict[str, Any]:+ """Bridge resource deletion through normal session commit for mutable memories."""+ if not resource_uri:+ return {"status": "skipped", "reason": "empty_resource_uri"}+ if not self._session_service:+ return {"status": "skipped", "reason": "session_service_unavailable"}++ deleted_at = datetime.now(timezone.utc).isoformat()+ session_id = _RESOURCE_REASON_SESSION_ID+ target_peer_id = _resource_reason_peer_id(ctx, resource_uri)+ commit_result: Dict[str, Any] = {}+ task_result: Optional[Dict[str, Any]] = None++ async with self._reason_session_lock:+ session = await self._session_service.get(+ session_id,+ ctx,+ auto_create=True,+ )+ session.meta.memory_policy = _resource_deletion_memory_policy(target_peer_id)+ message_spec: Dict[str, Any] = {+ "role": "user",+ "parts": [+ TextPart(+ text=self._build_resource_deletion_message(+ resource_uri=resource_uri,+ deleted_at=deleted_at,+ memory_uris=memory_uris,+ recursive=recursive,+ )+ )+ ],+ "created_at": deleted_at,+ }+ if target_peer_id:+ message_spec["peer_id"] = target_peer_id+ session.add_messages([message_spec])+ commit_result = await self._session_service.commit_async(+ session_id,+ ctx,+ keep_recent_count=0,+ )++ task_id = commit_result.get("task_id")+ if task_id:+ task_result = await self._wait_for_commit_task(+ task_id=str(task_id),+ ctx=ctx,+ timeout=timeout,+ )+ return {+ "status": "success",+ "session_id": session_id,+ "commit_task_id": task_id,+ "archive_uri": commit_result.get("archive_uri"),+ "commit_task": task_result,+ }+@staticmethoddef _build_resource_addition_message(*,@@ -215,6 +299,28 @@ class ResourceMemoryLinkService:f"User reason: {reason}")+ @staticmethod+ def _build_resource_deletion_message(+ *,+ resource_uri: str,+ deleted_at: str,+ memory_uris: Sequence[str],+ recursive: bool,+ ) -> str:+ affected = "\n".join(f"- {uri}" for uri in dict.fromkeys(memory_uris))+ if not affected:+ affected = "- N/A"+ recursive_text = "true" if recursive else "false"+ return (+ "## Resource Deletion\n"+ f"Resource URI: {resource_uri}\n"+ f"Deleted at: {deleted_at or 'N/A'}\n"+ f"Recursive delete: {recursive_text}\n"+ "Affected memory URIs:\n"+ f"{affected}\n\n"+ "Update existing mutable memories that mention or depend on this resource."+ )+async def _wait_for_commit_task(self,*,@@ -253,7 +359,7 @@ class ResourceMemoryLinkService:resource_uri: str,recursive: bool = False,) -> Dict[str, Any]:- """Remove references from user memories before deleting a resource."""+ """Commit mutable memory updates and unlink stale references to a deleted resource."""if context_type_for_uri(resource_uri) != "resource":return {"status": "skipped", "reason": "not_resource"}@@ -265,34 +371,42 @@ class ResourceMemoryLinkService:if not matches:return {"status": "no_references", "memory_uris": []}+ memory_uris = self._memory_uris_from_matches(matches)+ try:+ commit_result = await self.on_resource_deleted(+ ctx=ctx,+ resource_uri=resource_uri,+ memory_uris=memory_uris,+ recursive=recursive,+ )+ except Exception as exc:+ logger.warning("Resource deletion memory commit failed for %s: %s", resource_uri, exc)+ commit_result = {"status": "failed", "error": str(exc)}++ post_commit_matches = await self._find_referencing_memories(+ ctx=ctx,+ resource_uri=resource_uri,+ recursive=recursive,+ )+cleaned: List[str] = []deleted: List[str] = []errors: List[str] = []- grouped = self._group_matches_by_memory(matches)+ grouped = self._group_matches_by_memory(post_commit_matches)for memory_uri, memory_matches in grouped.items():first = memory_matches[0]- reason = str(first.resource_ref.get("reason") or "")try:- cleanup_result = await self._cleanup_memory_reference(+ cleanup_result = await self._unlink_memory_reference(ctx=ctx,memory_uri=memory_uri,memory_file=first.memory_file,resource_uri=resource_uri,- reason=reason,recursive=recursive,)cleaned.extend(cleanup_result.written_uris + cleanup_result.edited_uris)deleted.extend(cleanup_result.deleted_uris)if memory_uri in cleanup_result.deleted_uris:continue- if not cleanup_result.has_changes():- await self._remove_resource_refs(- memory_uri,- resource_uri,- ctx,- recursive=recursive,- )- cleaned.append(memory_uri)await self._assert_resource_unlinked(memory_uri,resource_uri,@@ -312,19 +426,18 @@ class ResourceMemoryLinkService:"status": "success","memory_uris": list(dict.fromkeys(cleaned)),"deleted_memory_uris": list(dict.fromkeys(deleted)),+ "memory_commit": commit_result,}- async def _cleanup_memory_reference(+ async def _unlink_memory_reference(self,*,ctx: RequestContext,memory_uri: str,memory_file: MemoryFile,resource_uri: str,- reason: str,recursive: bool = False,) -> MemoryUpdateResult:- del reasonviking_fs = self._get_viking_fs()current = memory_filetry:@@ -335,7 +448,7 @@ class ResourceMemoryLinkService:result.add_deleted(memory_uri)return result- changed = remove_resource_references_from_memory(+ changed = unlink_resource_references_from_memory(current,resource_uri,recursive=recursive,@@ -346,67 +459,77 @@ class ResourceMemoryLinkService:await viking_fs.write_file(memory_uri, MemoryFileUtils.write(current), ctx=ctx)result.add_edited(memory_uri)- if await self._delete_empty_cleanup_memory(memory_uri, ctx):- self._mark_result_deleted(result, memory_uri)return result- async def _delete_empty_cleanup_memory(self, memory_uri: str, ctx: RequestContext) -> bool:- """Delete memory files whose visible content was emptied by resource cleanup."""- if context_type_for_uri(memory_uri) != "memory":- return False- viking_fs = self._get_viking_fs()- try:- raw = await viking_fs.read_file(memory_uri, ctx=ctx)- except (NotFoundError, FileNotFoundError):- return True- mf = MemoryFileUtils.read(raw, uri=memory_uri)- if (mf.content or "").strip():- return False- directory_uri = memory_uri.rsplit("/", 1)[0]- await viking_fs.rm(memory_uri, recursive=False, ctx=ctx)- await MemoryUpdater.refresh_schema_overview(- viking_fs=viking_fs,- directory_uri=directory_uri,+ async def _find_referencing_memories(+ self,+ *,+ ctx: RequestContext,+ resource_uri: str,+ recursive: bool,+ ) -> List[_MemoryRefMatch]:+ candidate_uris = await self._grep_candidate_memory_uris(ctx=ctx,+ resource_uri=resource_uri,+ )+ if candidate_uris is None:+ logger.warning(+ "Skipping resource memory reference scan for %s because grep is unavailable",+ resource_uri,+ )+ return []+ return await self._read_referencing_memory_matches(+ candidate_uris,+ ctx=ctx,+ resource_uri=resource_uri,+ recursive=recursive,)- logger.info("Deleted empty memory after resource cleanup: %s", memory_uri)- return True-- @staticmethod- def _mark_result_deleted(result: MemoryUpdateResult, uri: str) -> None:- result.written_uris = [item for item in result.written_uris if item != uri]- result.edited_uris = [item for item in result.edited_uris if item != uri]- if uri not in result.deleted_uris:- result.add_deleted(uri)- async def _remove_resource_refs(+ async def _grep_candidate_memory_uris(self,- memory_uri: str,- resource_uri: str,- ctx: RequestContext,*,- recursive: bool,- ) -> None:+ ctx: RequestContext,+ resource_uri: str,+ ) -> Optional[List[str]]:+ """Use backend grep to avoid reading every memory file when supported."""viking_fs = self._get_viking_fs()- raw = await viking_fs.read_file(memory_uri, ctx=ctx)- mf = MemoryFileUtils.read(raw, uri=memory_uri)- refs = [- ref- for ref in self._coerce_resource_refs(mf.extra_fields.get("resource_refs"))- if not self._resource_ref_matches(- ref.get("resource_uri"),- resource_uri,- recursive=recursive,- )- ]- if refs:- mf.extra_fields["resource_refs"] = refs- else:- mf.extra_fields.pop("resource_refs", None)- await viking_fs.write_file(memory_uri, MemoryFileUtils.write(mf), ctx=ctx)+ if not hasattr(viking_fs, "grep"):+ return None- async def _find_referencing_memories(+ search_needle = self._resource_uri_search_needle(resource_uri)+ if not search_needle:+ return []++ candidate_uris: List[str] = []+ for memory_root in _memory_roots_for_resource_refs(ctx, resource_uri):+ try:+ result = await viking_fs.grep(+ memory_root,+ pattern=re.escape(search_needle),+ ctx=ctx,+ node_limit=None,+ level_limit=None,+ )+ except (NotFoundError, FileNotFoundError):+ continue+ except Exception as exc:+ logger.debug(+ "Resource memory grep failed for %s, skipping reference scan: %s",+ memory_root,+ exc,+ )+ return None++ for match in result.get("matches", []):+ uri = match.get("uri", "")+ if self._is_memory_markdown_file(uri):+ candidate_uris.append(uri)++ return list(dict.fromkeys(candidate_uris))++ async def _read_referencing_memory_matches(self,+ candidate_uris: Sequence[str],*,ctx: RequestContext,resource_uri: str,@@ -414,38 +537,30 @@ class ResourceMemoryLinkService:) -> List[_MemoryRefMatch]:viking_fs = self._get_viking_fs()matches: List[_MemoryRefMatch] = []- entries: List[Dict[str, Any]] = []- for memory_root in _memory_roots_for_resource_refs(ctx, resource_uri):+ search_needle = self._resource_uri_search_needle(resource_uri)+ for uri in candidate_uris:try:- entries.extend(- await viking_fs.tree(- memory_root,- ctx=ctx,- node_limit=1000000,- level_limit=None,- )- )+ raw = await viking_fs.read_file(uri, ctx=ctx)+ raw_text = raw if isinstance(raw, str) else str(raw or "")except Exception:continue-- for entry in entries:- uri = entry.get("uri", "")- rel_path = entry.get("rel_path", "")- if entry.get("isDir") or not uri.endswith(".md"):- continue- if rel_path.endswith("/.abstract.md") or rel_path.endswith("/.overview.md"):+ if search_needle and search_needle not in raw_text:continue+try:- raw = await viking_fs.read_file(uri, ctx=ctx)- mf = MemoryFileUtils.read(raw, uri=uri)+ mf = MemoryFileUtils.read(raw_text, uri=uri)except Exception:continue++ matched = Falsefor ref in self._coerce_resource_refs(mf.extra_fields.get("resource_refs")):if self._resource_ref_matches(ref.get("resource_uri"), resource_uri, recursive):matches.append(_MemoryRefMatch(uri, mf, ref))- if not any(- match.memory_uri == uri for match in matches- ) and content_references_resource(+ matched = True+ if matched:+ continue++ if content_references_resource(mf.content,resource_uri,recursive=recursive,@@ -470,6 +585,19 @@ class ResourceMemoryLinkService:)return matches+ @staticmethod+ def _resource_uri_search_needle(resource_uri: str) -> str:+ return (resource_uri or "").strip().rstrip("/")++ @staticmethod+ def _is_memory_markdown_file(uri: str) -> bool:+ return (+ isinstance(uri, str)+ and uri.endswith(".md")+ and not uri.endswith("/.abstract.md")+ and not uri.endswith("/.overview.md")+ )+async def _read_resource_directory_abstract(self,resource_uri: str,@@ -558,6 +686,10 @@ class ResourceMemoryLinkService:grouped.setdefault(match.memory_uri, []).append(match)return grouped+ @staticmethod+ def _memory_uris_from_matches(matches: Sequence[_MemoryRefMatch]) -> List[str]:+ return list(dict.fromkeys(match.memory_uri for match in matches))+@staticmethoddef _resource_ref_matches(ref_uri: Any,diff --git a/openviking/session/memory/memory_updater.py b/openviking/session/memory/memory_updater.pyindex b3de674d0..f4ede2412 100644--- a/openviking/session/memory/memory_updater.py+++ b/openviking/session/memory/memory_updater.py@@ -1228,12 +1228,6 @@ class MemoryUpdater:# Extract filename from pathfilename = file_path.split("/")[-1]metadata = mf.to_metadata()- self._fill_overview_fallback_fields(- memory_type=memory_type,- directory=directory,- filename=filename,- metadata=metadata,- )items.append({@@ -1249,14 +1243,17 @@ class MemoryUpdater:logger.debug(f"No valid memory files parsed in {directory}")return+ overview_context = {+ "memory_type": memory_type,+ "directory_name": directory.rstrip("/").split("/")[-1],+ "items": items,+ }+# Render the templatetry:rendered = render_template(schema.overview_template,- {- "memory_type": memory_type,- "items": items,- },+ overview_context,extract_context=extract_context,)except Exception as e:@@ -1269,20 +1266,3 @@ class MemoryUpdater:await viking_fs.write_file(overview_path, rendered, ctx=ctx)except Exception as e:tracer.error(f"Failed to write overview {overview_path}: {e}")-- @staticmethod- def _fill_overview_fallback_fields(- *,- memory_type: str,- directory: str,- filename: str,- metadata: Dict[str, Any],- ) -> None:- stem = filename.removesuffix(".md")- parent_name = directory.rstrip("/").split("/")[-1]- if memory_type == "entities":- metadata.setdefault("category", parent_name)- metadata.setdefault("name", stem)- elif memory_type == "preferences":- metadata.setdefault("user", parent_name)- metadata.setdefault("topic", stem)diff --git a/openviking/session/memory/session_extract_context_provider.py b/openviking/session/memory/session_extract_context_provider.pyindex 5dbdcb18d..d6d35d28b 100644--- a/openviking/session/memory/session_extract_context_provider.py+++ b/openviking/session/memory/session_extract_context_provider.py@@ -186,18 +186,25 @@ class SessionExtractContextProvider(ExtractContextProvider):def instruction(self) -> str:output_language = self._output_language+ contains_resource_uri = self._conversation_contains_resource_uri()resource_uri_handling = ("""## Resource URI Handling- If the conversation contains a resource URI (`viking://resources/...`, `viking://user/{user_id}/resources/...`, or `viking://user/{user_id}/peers/{peer_id}/resources/...`) and the user says a durable fact, judgment, preference, or event about it, extract that memory into the appropriate normal memory type such as entities, events, or preferences.-- Preserve resource references as markdown links in visible memory content when useful. Example: user said "用户保存了越前龙马照片 viking://resources/images/ryoma" -> write "用户保存了[越前龙马照片](viking://resources/images/ryoma)".+- Preserve resource references as markdown links in visible memory content when useful. Example: user said "The user saved a Ryoma Echizen photo viking://resources/images/ryoma" -> write "The user saved a [Ryoma Echizen photo](viking://resources/images/ryoma)".- For `## Resource Addition` blocks, use `User reason` as the user's intent and `Resource abstract` only as optional context. Do not copy raw fields such as `Resource URI`, `Added at`, `Resource abstract`, or `User reason` into visible memory content.-- Use descriptive link text such as `[越前龙马照片](viking://resources/...)`; avoid visible wording like `资源URI为` or `Resource URI`.+- For `## Resource Deletion` blocks, update existing mutable memories that mention or depend on the deleted resource. Do not create a new event solely for this maintenance action.+- Use descriptive link text such as `[Ryoma Echizen photo](viking://resources/...)`; avoid visible wording like `resource URI is` or `Resource URI`.- If the user already wrote a markdown link to a resource URI, keep the same resource link intent.- Do NOT claim you inspected, summarized, OCRed, or opened the resource file unless the conversation explicitly provides that fact."""- if self._conversation_contains_resource_uri()+ if contains_resource_uri+ else ""+ )+ resource_deletion_read_source = (+ ", or listed under the system-generated `## Resource Deletion` block's `Affected memory URIs`"+ if contains_resource_urielse "")goal = f"""You are a memory extraction agent. Your task is to analyze conversations and update memories.@@ -210,7 +217,7 @@ class SessionExtractContextProvider(ExtractContextProvider):## Critical- ONLY read and search tools are available - DO NOT use write tool- Before editing ANY existing memory file, you MUST first read its complete content-- ONLY read URIs that are explicitly listed in ls tool results or returned by previous tool calls+- ONLY read URIs that are explicitly listed in ls/search tool results, returned by previous tool calls{resource_deletion_read_source}## Target Output LanguageAll memory content MUST be written in {output_language}.diff --git a/openviking/session/memory/utils/resource_refs.py b/openviking/session/memory/utils/resource_refs.pyindex d80e0d8ee..02f441d2e 100644--- a/openviking/session/memory/utils/resource_refs.py+++ b/openviking/session/memory/utils/resource_refs.py@@ -6,7 +6,7 @@ from __future__ import annotationsimport refrom datetime import datetime, timezone-from typing import Any, Dict, Iterable, List, Optional, Sequence+from typing import Any, Dict, List, Optional, Sequencefrom openviking.session.memory.dataclass import MemoryFile@@ -32,13 +32,6 @@ _INLINE_CODE_RE = re.compile(r"`[^`\n]+`")_TRAILING_URI_PUNCTUATION = ".,;:!?,。;:!?、)】》"_SENTENCE_BOUNDARIES = "。!?.!?\n"_MAX_LINKIFIED_SENTENCE_CHARS = 160-_RESOURCE_CLEANUP_ARTIFACT_LINE_RE = re.compile(- r"(?m)^(?:None ChatLog:|Original reason:\s*|Memory URI:\s*viking://user/[^\n]*)\n?"-)-_RESOURCE_URI_MARKER_RE = re.compile(- r"[,,;;::\s]*(?:资源\s*URI\s*为|资源\s*URI|Resource\s+URI)\s*[::为]?\s*$",- re.IGNORECASE,-)def sync_memory_resource_refs(@@ -109,17 +102,17 @@ def extract_resource_uris(content: str) -> List[str]:return list(dict.fromkeys(uris))-def remove_resource_references_from_memory(+def unlink_resource_references_from_memory(mf: MemoryFile,resource_uri: str,*,recursive: bool = False,) -> bool:- """Remove visible references and MEMORY_FIELDS.resource_refs for one resource."""+ """Remove stale resource link targets while preserving visible memory text."""before_content = mf.contentbefore_refs = _coerce_resource_refs(mf.extra_fields.get("resource_refs"))- mf.content = remove_resource_references_from_content(+ mf.content = unlink_resource_references_from_content(mf.content,resource_uri,recursive=recursive,@@ -137,24 +130,17 @@ def remove_resource_references_from_memory(return before_content != mf.content or before_refs != refs-def remove_resource_references_from_content(+def unlink_resource_references_from_content(content: str,resource_uri: str,*,recursive: bool = False,) -> str:- """Remove sentences/list lines that contain matching resource URI references."""+ """Turn matching resource links into plain text and remove bare resource URIs."""text = content or ""- spans = _matching_resource_reference_spans(text, resource_uri, recursive=recursive)- if not spans:- return text-- sentence_spans = _merge_spans(- _expand_to_sentence_span(text, start, end) for start, end in spans- )- for start, end in reversed(sentence_spans):- text = text[:start] + text[end:]- return _normalize_removed_reference_text(text)+ text = _unlink_matching_markdown_resource_links(text, resource_uri, recursive=recursive)+ text = _remove_matching_bare_resource_uris(text, resource_uri, recursive=recursive)+ return _normalize_unlinked_reference_text(text)def resource_ref_matches(@@ -199,6 +185,39 @@ def _extract_markdown_resource_refs(return refs, link_spans+def _unlink_matching_markdown_resource_links(+ content: str,+ resource_uri: str,+ *,+ recursive: bool,+) -> str:+ def replacement(match: re.Match[str]) -> str:+ label = match.group(1).strip()+ linked_uri = match.group(2)+ if resource_ref_matches(linked_uri, resource_uri, recursive=recursive):+ return label+ return match.group(0)++ return _MARKDOWN_RESOURCE_LINK_RE.sub(replacement, content or "")+++def _remove_matching_bare_resource_uris(+ content: str,+ resource_uri: str,+ *,+ recursive: bool,+) -> str:+ text = content or ""+ for match in reversed(list(_RESOURCE_URI_RE.finditer(text))):+ matched_uri = _trim_resource_uri(match.group(0))+ if not resource_ref_matches(matched_uri, resource_uri, recursive=recursive):+ continue+ start = match.start()+ end = start + len(matched_uri)+ text = text[:start] + text[end:]+ return text++def _linkify_bare_resource_uris(content: str,protected_spans: Sequence[tuple[int, int]],@@ -227,16 +246,6 @@ def _linkify_bare_resource_uris(anchor_start = sentence_startanchor_end = sentence_endanchor = updated[anchor_start:anchor_end]- marker_span = _resource_uri_marker_span(anchor)- if marker_span:- label_span = _resource_clause_span_before_marker(- updated,- sentence_start,- sentence_start + marker_span[0],- )- if label_span:- anchor_start, anchor_end = label_span- anchor = updated[anchor_start:anchor_end]if contains_resource_uri(anchor) or "](" in anchor:continuerefs[-1]["match_text"] = anchor@@ -347,96 +356,9 @@ def _trim_resource_uri(resource_uri: str) -> str:return (resource_uri or "").rstrip(_TRAILING_URI_PUNCTUATION)-def _matching_resource_reference_spans(- content: str,- resource_uri: str,- *,- recursive: bool,-) -> List[tuple[int, int]]:- spans: List[tuple[int, int]] = []- markdown_spans: List[tuple[int, int]] = []- for match in _MARKDOWN_RESOURCE_LINK_RE.finditer(content or ""):- markdown_spans.append((match.start(), match.end()))- if resource_ref_matches(match.group(2), resource_uri, recursive=recursive):- spans.append((match.start(), match.end()))-- for match in _RESOURCE_URI_RE.finditer(content or ""):- resource_end = match.start() + len(_trim_resource_uri(match.group(0)))- if _overlaps_spans(match.start(), resource_end, markdown_spans):- continue- if resource_ref_matches(match.group(0), resource_uri, recursive=recursive):- spans.append((match.start(), resource_end))- return spans---def _resource_uri_marker_span(anchor: str) -> Optional[tuple[int, int]]:- match = _RESOURCE_URI_MARKER_RE.search(anchor)- if not match:- return None- return match.start(), match.end()---def _resource_clause_span_before_marker(- content: str,- sentence_start: int,- marker_start: int,-) -> Optional[tuple[int, int]]:- prefix = content[sentence_start:marker_start].rstrip(",,;;:: ")- if not prefix:- return None-- pieces = list(re.finditer(r"[^,,;;。.!??]+$", prefix))- if not pieces:- return None- label_start = sentence_start + pieces[-1].start()- label_end = sentence_start + pieces[-1].end()- if _valid_resource_clause(content[label_start:label_end]):- return label_start, label_end- return None---def _valid_resource_clause(clause: str) -> bool:- clause = clause.strip()- return bool(clause) and len(clause) <= 120 and "\n" not in clause and "](" not in clause---def _expand_to_sentence_span(content: str, start: int, end: int) -> tuple[int, int]:- span_start = start- for idx in range(start - 1, -1, -1):- if content[idx] in _SENTENCE_BOUNDARIES:- span_start = idx + 1- break- else:- span_start = 0-- span_end = end- for idx in range(end, len(content)):- if content[idx] in _SENTENCE_BOUNDARIES:- span_end = idx + 1- break- else:- span_end = len(content)-- while span_start < span_end and content[span_start].isspace():- span_start += 1- while span_end < len(content) and content[span_end].isspace():- span_end += 1- return span_start, span_end---def _merge_spans(spans: Iterable[tuple[int, int]]) -> List[tuple[int, int]]:- merged: List[tuple[int, int]] = []- for start, end in sorted(spans):- if not merged or start > merged[-1][1]:- merged.append((start, end))- else:- merged[-1] = (merged[-1][0], max(merged[-1][1], end))- return merged---def _normalize_removed_reference_text(content: str) -> str:- content = _RESOURCE_CLEANUP_ARTIFACT_LINE_RE.sub("", content)+def _normalize_unlinked_reference_text(content: str) -> str:text = re.sub(r"[ \t]+([,。;:!?,.!?;:])", r"\1", content)+ text = re.sub(r"[ \t]{2,}", " ", text)text = re.sub(r"\n{3,}", "\n\n", text)return text.strip()diff --git a/tests/service/test_resource_memory_link_service.py b/tests/service/test_resource_memory_link_service.pyindex 45b12e32d..8b6a204e8 100644--- a/tests/service/test_resource_memory_link_service.py+++ b/tests/service/test_resource_memory_link_service.py@@ -2,8 +2,8 @@# SPDX-License-Identifier: AGPL-3.0"""Tests for resource-memory linking service."""+import refrom types import SimpleNamespace-from unittest.mock import AsyncMockimport pytest@@ -13,7 +13,6 @@ from openviking.service.resource_memory_link_service import (ResourceMemoryLinkService,)from openviking.session.memory.dataclass import MemoryFile-from openviking.session.memory.memory_updater import MemoryUpdateResultfrom openviking.session.memory.utils.memory_file_utils import MemoryFileUtilsfrom openviking_cli.session.user_id import UserIdentifier@@ -22,8 +21,11 @@ class _FakeVikingFS:def __init__(self, store):self.store = storeself.rm_calls = []+ self.read_calls = []+ self.tree_calls = []async def read_file(self, uri, ctx=None):+ self.read_calls.append(uri)return self.store[uri]async def write_file(self, uri, content, ctx=None):@@ -34,6 +36,13 @@ class _FakeVikingFS:self.store.pop(uri, None)async def tree(self, uri, ctx=None, node_limit=None, level_limit=None):+ self.tree_calls.append(+ {+ "uri": uri,+ "node_limit": node_limit,+ "level_limit": level_limit,+ }+ )prefix = uri.rstrip("/") + "/"return [{@@ -45,6 +54,80 @@ class _FakeVikingFS:if item_uri.startswith(prefix)]+ async def grep(+ self,+ uri,+ pattern,+ exclude_uri=None,+ case_insensitive=False,+ node_limit=None,+ level_limit=None,+ ctx=None,+ ):+ del exclude_uri, case_insensitive, level_limit, ctx+ prefix = uri.rstrip("/") + "/"+ matches = [+ {+ "uri": item_uri,+ "line": 1,+ "content": content,+ }+ for item_uri, content in self.store.items()+ if item_uri.startswith(prefix) and re.search(pattern, content)+ ]+ if node_limit is not None:+ matches = matches[:node_limit]+ return {+ "matches": matches,+ "count": len(matches),+ "match_count": len(matches),+ "files_scanned": len(self.store),+ }+++class _FakeGrepVikingFS(_FakeVikingFS):+ def __init__(self, store, grep_uris):+ super().__init__(store)+ self.grep_uris = grep_uris+ self.grep_calls = []++ async def grep(+ self,+ uri,+ pattern,+ exclude_uri=None,+ case_insensitive=False,+ node_limit=None,+ level_limit=None,+ ctx=None,+ ):+ self.grep_calls.append(+ {+ "uri": uri,+ "pattern": pattern,+ "exclude_uri": exclude_uri,+ "case_insensitive": case_insensitive,+ "node_limit": node_limit,+ "level_limit": level_limit,+ }+ )+ return {+ "matches": [+ {+ "uri": match_uri,+ "line": 1,+ "content": self.store.get(match_uri, ""),+ }+ for match_uri in self.grep_uris+ ],+ "count": len(self.grep_uris),+ "match_count": len(self.grep_uris),+ "files_scanned": len(self.store),+ }++ async def tree(self, uri, ctx=None, node_limit=None, level_limit=None):+ raise AssertionError("grep path should not fall back to tree")+class _ReadFailVikingFS:async def read_file(self, uri, ctx=None):@@ -266,6 +349,37 @@ async def test_on_resource_added_routes_peer_resource_uri_to_peer(request_contexassert session_service.session.messages[0]["peer_id"] == "web-visitor-alice"+async def test_on_resource_deleted_bridges_through_fixed_session(request_context):+ resource_uri = "viking://resources/images/2026/06/11/yueqian_jpeg"+ memory_uri = "viking://user/alice/memories/entities/photos.md"+ session_service = _FakeSessionService()+ service = ResourceMemoryLinkService(+ viking_fs=_FakeVikingFS({}),+ session_service=session_service,+ )++ result = await service.on_resource_deleted(+ ctx=request_context,+ resource_uri=resource_uri,+ memory_uris=[memory_uri],+ recursive=True,+ )++ assert result["status"] == "success"+ assert result["session_id"] == _RESOURCE_REASON_SESSION_ID+ assert session_service.session.meta.memory_policy == {+ "self": {"enabled": True},+ "peer": {"enabled": False},+ "memory_types": ["entities", "preferences"],+ }+ message_text = session_service.session.messages[0]["parts"][0].text+ assert "## Resource Deletion" in message_text+ assert resource_uri in message_text+ assert memory_uri in message_text+ assert "Do not create a new event" in message_text++@pytest.mark.asyncioasync def test_read_resource_directory_abstract_uses_parent_abstract(request_context):service = ResourceMemoryLinkService(@@ -341,6 +455,59 @@ async def test_find_referencing_memories_uses_memory_refs(request_context):assert matches[0].resource_ref["resource_uri"] == resource_uri+async def test_find_referencing_memories_uses_grep_candidates_without_tree_scan(request_context):+ memory_uri = "viking://user/alice/memories/entities/wang.md"+ unrelated_uri = "viking://user/alice/memories/entities/unrelated.md"+ overview_uri = "viking://user/alice/memories/entities/.overview.md"+ resource_uri = "viking://resources/docs/id_card.pdf"+ raw = MemoryFileUtils.write(+ MemoryFile(+ uri=memory_uri,+ content="王大锤资料。",+ extra_fields={+ "resource_refs": [+ {+ "resource_uri": resource_uri,+ "reason": "这是王大锤的身份证",+ }+ ]+ },+ )+ )+ store = {+ memory_uri: raw,+ unrelated_uri: "不会命中的普通记忆",+ overview_uri: f"- [王大锤]({memory_uri})",+ }+ viking_fs = _FakeGrepVikingFS(+ store,+ grep_uris=[memory_uri, memory_uri, overview_uri],+ )+ service = ResourceMemoryLinkService(viking_fs=viking_fs)++ matches = await service._find_referencing_memories(+ ctx=request_context,+ resource_uri=resource_uri,+ recursive=False,+ )++ assert len(matches) == 1+ assert matches[0].memory_uri == memory_uri+ assert viking_fs.grep_calls == [+ {+ "uri": "viking://user/alice/memories",+ "pattern": re.escape(resource_uri),+ "exclude_uri": None,+ "case_insensitive": False,+ "node_limit": None,+ "level_limit": None,+ }+ ]+ assert viking_fs.read_calls == [memory_uri]+ assert viking_fs.tree_calls == []++@pytest.mark.asyncioasync def test_find_referencing_memories_scans_actor_peer_memory(request_context):peer_ctx = RequestContext(@@ -377,7 +544,7 @@ async def test_find_referencing_memories_scans_actor_peer_memory(request_context@pytest.mark.asyncio-async def test_before_resource_delete_removes_refs_when_cleanup_has_no_changes(request_context):+async def test_before_resource_delete_commits_then_unlinks_stale_refs(request_context):memory_uri = "viking://user/alice/memories/entities/wang.md"resource_uri = "viking://resources/id_card.pdf"raw = (@@ -393,8 +560,11 @@ async def test_before_resource_delete_removes_refs_when_cleanup_has_no_changes(r"}\n""-->")- service = ResourceMemoryLinkService(viking_fs=_FakeVikingFS({memory_uri: raw}))- service._cleanup_memory_reference = AsyncMock(return_value=MemoryUpdateResult())+ session_service = _FakeSessionService()+ service = ResourceMemoryLinkService(+ viking_fs=_FakeVikingFS({memory_uri: raw}),+ session_service=session_service,+ )result = await service.before_resource_delete(ctx=request_context,@@ -402,12 +572,20 @@ async def test_before_resource_delete_removes_refs_when_cleanup_has_no_changes(r)assert result["status"] == "success"+ assert result["memory_commit"]["status"] == "success"+ assert session_service.committed == [+ {+ "ctx": request_context,+ "session_id": _RESOURCE_REASON_SESSION_ID,+ "keep_recent_count": 0,+ }+ ]mf = MemoryFileUtils.read(service._get_viking_fs().store[memory_uri], uri=memory_uri)assert "resource_refs" not in mf.extra_fields@pytest.mark.asyncio-async def test_cleanup_memory_reference_does_not_introduce_schema_metadata(request_context):+async def test_unlink_memory_reference_keeps_visible_text_and_no_schema_metadata(request_context):memory_uri = "viking://user/ryoma/memories/entities/动漫角色/不二周助-write-test3.md"resource_uri = "viking://resources/images/2026/06/10/不二周助_jpeg"original_raw = MemoryFileUtils.write(@@ -427,27 +605,25 @@ async def test_cleanup_memory_reference_does_not_introduce_schema_metadata(requestore = {memory_uri: original_raw}service = ResourceMemoryLinkService(viking_fs=_FakeVikingFS(store))- result = await service._cleanup_memory_reference(+ result = await service._unlink_memory_reference(ctx=request_context,memory_uri=memory_uri,memory_file=MemoryFileUtils.read(original_raw, uri=memory_uri),resource_uri=resource_uri,- reason="",)assert result.edited_uris == [memory_uri]mf = MemoryFileUtils.read(store[memory_uri], uri=memory_uri)- assert mf.content == "今天是清明节。"+ assert mf.content == "今天是清明节。用户保存了一张不二周助的照片"assert mf.extra_fields == {}assert mf.memory_type is None@pytest.mark.asyncio-async def test_cleanup_memory_reference_deletes_empty_memory_shell(+async def test_unlink_memory_reference_does_not_delete_event_memory(request_context,- monkeypatch,):- memory_uri = "viking://user/ryoma/memories/entities/动漫角色/越前龙马.md"+ memory_uri = "viking://user/ryoma/memories/events/2026/06/11/越前龙马.md"resource_uri = "viking://resources/images/2026/06/11/yueqian_jpeg"original_raw = MemoryFileUtils.write(MemoryFile(@@ -463,31 +639,25 @@ async def test_cleanup_memory_reference_deletes_empty_memory_shell()store = {memory_uri: original_raw}service = ResourceMemoryLinkService(viking_fs=_FakeVikingFS(store))- refresh_overview = AsyncMock()- monkeypatch.setattr(- "openviking.service.resource_memory_link_service.MemoryUpdater.refresh_schema_overview",- refresh_overview,- )- result = await service._cleanup_memory_reference(+ result = await service._unlink_memory_reference(ctx=request_context,memory_uri=memory_uri,memory_file=MemoryFileUtils.read(original_raw, uri=memory_uri),resource_uri=resource_uri,- reason="这是越前龙马的照片",)- assert memory_uri not in store- assert service._get_viking_fs().rm_calls == [(memory_uri, False)]- assert result.edited_uris == []- assert result.deleted_uris == [memory_uri]- refresh_overview.assert_awaited_once()+ assert memory_uri in store+ assert service._get_viking_fs().rm_calls == []+ assert result.edited_uris == [memory_uri]+ assert result.deleted_uris == []+ mf = MemoryFileUtils.read(store[memory_uri], uri=memory_uri)+ assert mf.content == "用户保存了一张越前龙马的照片"@pytest.mark.asyncioasync def test_before_resource_delete_cleans_visible_uri_without_resource_refs(request_context,- monkeypatch,):memory_uri = "viking://user/alice/memories/events/2026/06/11/yueqian.md"resource_uri = "viking://resources/images/2026/06/12/yueqian_jpeg"@@ -502,11 +672,6 @@ async def test_before_resource_delete_cleans_visible_uri_without_resource_refs()store = {memory_uri: raw}service = ResourceMemoryLinkService(viking_fs=_FakeVikingFS(store))- refresh_overview = AsyncMock()- monkeypatch.setattr(- "openviking.service.resource_memory_link_service.MemoryUpdater.refresh_schema_overview",- refresh_overview,- )result = await service.before_resource_delete(ctx=request_context,@@ -516,7 +681,7 @@ async def test_before_resource_delete_cleans_visible_uri_without_resource_refs(assert result["status"] == "success"assert result["memory_uris"] == [memory_uri]mf = MemoryFileUtils.read(store[memory_uri], uri=memory_uri)- assert mf.content == "今天是清明节。"+ assert mf.content == "今天是清明节。\n用户昨晚查看了越前龙马照片,之后可参考该资源。"assert "resource_refs" not in mf.extra_fields@@ -553,50 +718,12 @@ async def test_before_resource_delete_exact_keeps_child_resource_refs(assert result["status"] == "success"mf = MemoryFileUtils.read(store[memory_uri], uri=memory_uri)assert f"[相册资源]({resource_uri})" not in mf.content+ assert "用户保存了相册资源。" in mf.contentassert f"[相册里的子图]({child_uri})" in mf.contentrefs = mf.extra_fields["resource_refs"]assert refs == [{"resource_uri": child_uri, "source": "content.write"}]-async def test_before_resource_delete_deletes_previous_failed_cleanup_artifact(- request_context,- monkeypatch,-):- memory_uri = "viking://user/alice/memories/events/2026/06/11/yueqian.md"- resource_uri = "viking://resources/images/2026/06/12/yueqian_jpeg"- raw = MemoryFileUtils.write(- MemoryFile(- uri=memory_uri,- content=(- f"Summary: 用户查看了[越前龙马照片]({resource_uri})。\n"- "None ChatLog:\n"- f"[[user]: Deleted resource URI:]({resource_uri})\n"- "Original reason: \n"- f"Memory URI: {memory_uri}"- ),- extra_fields={"memory_type": "events"},- )- )- store = {memory_uri: raw}- service = ResourceMemoryLinkService(viking_fs=_FakeVikingFS(store))- refresh_overview = AsyncMock()- monkeypatch.setattr(- "openviking.service.resource_memory_link_service.MemoryUpdater.refresh_schema_overview",- refresh_overview,- )-- result = await service.before_resource_delete(- ctx=request_context,- resource_uri=resource_uri,- )-- assert result["status"] == "success"- assert result["deleted_memory_uris"] == [memory_uri]- assert memory_uri not in store- refresh_overview.assert_awaited_once()--@pytest.mark.asyncioasync def test_assert_resource_unlinked_propagates_non_not_found_errors(request_context):service = ResourceMemoryLinkService(viking_fs=_ReadFailVikingFS())diff --git a/tests/session/memory/test_memory_react_system_prompt.py b/tests/session/memory/test_memory_react_system_prompt.pyindex 26a1a6ab9..32b2c3c43 100644--- a/tests/session/memory/test_memory_react_system_prompt.py+++ b/tests/session/memory/test_memory_react_system_prompt.py@@ -26,7 +26,7 @@ class TestProviderInstruction:in instruction)assert (- "ONLY read URIs that are explicitly listed in ls tool results or returned by previous tool calls"+ "ONLY read URIs that are explicitly listed in ls/search tool results, returned by previous tool calls"in instruction)@@ -58,6 +58,7 @@ class TestProviderInstruction:instruction = provider.instruction()assert "Resource URI Handling" not in instruction+ assert "Affected memory URIs" not in instructiondef test_instruction_includes_resource_uri_handling_for_user_scoped_resource_uri(self):provider = SessionExtractContextProvider(@@ -80,6 +81,9 @@ class TestProviderInstruction:assert "Resource URI Handling" in instructionassert "viking://user/{user_id}/resources/..." in instructionassert "viking://user/{user_id}/peers/{peer_id}/resources/..." in instruction+ assert (+ "system-generated `## Resource Deletion` block's `Affected memory URIs`" in instruction+ )class TestSkillToolCallExposure:diff --git a/tests/session/memory/test_memory_updater.py b/tests/session/memory/test_memory_updater.pyindex 1a548c2c7..5f6d11486 100644--- a/tests/session/memory/test_memory_updater.py+++ b/tests/session/memory/test_memory_updater.py@@ -238,6 +238,124 @@ class TestMemoryUpdater:assert viking_fs.rm_calls == []+ @pytest.mark.asyncio+ async def test_generate_events_overview_without_extract_context_uses_summary_or_filename(self):+ schema = MemoryTypeSchema(+ memory_type="events",+ description="event memory",+ directory="viking://user/{{ user_space }}/memories/events",+ filename_template="{{ event_name }}.md",+ fields=[],+ overview_template=(+ "# Events Overview\n"+ "{% for item in items %}\n"+ "- [{{ item.file_content.summary|default(item.file_name, true) }}](./{{ item.file_name }})\n"+ "{% endfor %}"+ ),+ )+ registry = MagicMock()+ registry.get.return_value = schema++ directory = "viking://user/alice/memories/events/2026/06/16"+ event_uri = f"{directory}/kept_event.md"+ plain_event_uri = f"{directory}/plain_event.md"+ overview_uri = f"{directory}/.overview.md"++ class FakeVikingFS:+ def __init__(self):+ self.store = {+ event_uri: MemoryFileUtils.write(+ MemoryFile(+ uri=event_uri,+ content="Summary: kept event",+ memory_type="events",+ extra_fields={+ "event_name": "kept_event",+ "summary": "kept event",+ "ranges": "0",+ },+ )+ ),+ plain_event_uri: "Plain event first sentence. More detail on the same line.",+ overview_uri: (+ "# Events Overview\n"+ "**Date:** 2026/06/16\n"+ "- [deleted event](./deleted_event.md)\n"+ ),+ }++ async def ls(self, uri, show_all_hidden=False, ctx=None):+ return [+ {"name": "kept_event.md", "isDir": False},+ {"name": "plain_event.md", "isDir": False},+ {"name": ".overview.md", "isDir": False},+ ]++ async def read_file(self, uri, ctx=None):+ return self.store[uri]++ async def write_file(self, uri, content, ctx=None):+ self.store[uri] = content++ viking_fs = FakeVikingFS()+ updater = MemoryUpdater(registry=registry)+ updater._get_viking_fs = MagicMock(return_value=viking_fs)+ ctx = RequestContext(user=UserIdentifier("acme", "alice"), role=Role.USER)++ await updater.generate_overview("events", directory, ctx, extract_context=None)++ assert "**Date:**" not in viking_fs.store[overview_uri]+ assert "- [kept event](./kept_event.md)" in viking_fs.store[overview_uri]+ assert "- [plain_event.md](./plain_event.md)" in viking_fs.store[overview_uri]+ assert "deleted_event.md" not in viking_fs.store[overview_uri]++ @pytest.mark.asyncio+ async def test_generate_overview_template_fallbacks_for_preferences_and_entities(self):+ registry = MemoryTypeRegistry(load_schemas=False)+ registry.load_from_yaml("openviking/prompts/templates/memory/entities.yaml")+ registry.load_from_yaml("openviking/prompts/templates/memory/preferences.yaml")++ entity_dir = "viking://user/alice/memories/entities/动漫角色"+ entity_uri = f"{entity_dir}/越前龙马.md"+ entity_overview_uri = f"{entity_dir}/.overview.md"+ preference_dir = "viking://user/alice/memories/preferences/alice"+ preference_uri = f"{preference_dir}/workflow.md"+ preference_overview_uri = f"{preference_dir}/.overview.md"++ class FakeVikingFS:+ def __init__(self):+ self.store = {+ entity_uri: "A tennis character.",+ preference_uri: "Prefers concise updates.",+ }++ async def ls(self, uri, show_all_hidden=False, ctx=None):+ if uri == entity_dir:+ return [{"name": "越前龙马.md", "isDir": False}]+ if uri == preference_dir:+ return [{"name": "workflow.md", "isDir": False}]+ return []++ async def read_file(self, uri, ctx=None):+ return self.store[uri]++ async def write_file(self, uri, content, ctx=None):+ self.store[uri] = content++ viking_fs = FakeVikingFS()+ updater = MemoryUpdater(registry=registry)+ updater._get_viking_fs = MagicMock(return_value=viking_fs)+ ctx = RequestContext(user=UserIdentifier("acme", "alice"), role=Role.USER)++ await updater.generate_overview("entities", entity_dir, ctx, extract_context=None)+ await updater.generate_overview("preferences", preference_dir, ctx, extract_context=None)++ assert "**Category:** 动漫角色" in viking_fs.store[entity_overview_uri]+ assert "- [越前龙马.md](./越前龙马.md)" in viking_fs.store[entity_overview_uri]+ assert "**User:** alice" in viking_fs.store[preference_overview_uri]+ assert "**Topic:** workflow.md" in viking_fs.store[preference_overview_uri]+ assert "- [workflow.md](./workflow.md)" in viking_fs.store[preference_overview_uri]+@pytest.mark.asyncioasync def test_apply_operations_preserves_pre_resolved_multi_uris_for_new_page_ids(self):registry = MagicMock()diff --git a/tests/session/memory/test_resource_refs.py b/tests/session/memory/test_resource_refs.pyindex ae9933f11..541b1cc73 100644--- a/tests/session/memory/test_resource_refs.py+++ b/tests/session/memory/test_resource_refs.py@@ -6,6 +6,7 @@ from openviking.session.memory.utils.resource_refs import (contains_resource_uri,extract_resource_uris,sync_memory_resource_refs,+ unlink_resource_references_from_memory,)@@ -87,3 +88,39 @@ def test_sync_memory_resource_refs_keeps_bare_uri_clean_before_chinese_punctuati"match_text": "昨天晚上我看了",}]+++def test_unlink_resource_references_preserves_visible_markdown_text():+ resource_uri = "viking://resources/images/2026/06/12/yueqian_jpeg"+ child_uri = f"{resource_uri}/child.jpeg"+ mf = MemoryFile(+ content=(f"用户保存了[越前龙马照片]({resource_uri})。\n用户也保存了[子图]({child_uri})。"),+ extra_fields={+ "resource_refs": [+ {"resource_uri": resource_uri, "source": "content.write"},+ {"resource_uri": child_uri, "source": "content.write"},+ ]+ },+ )++ changed = unlink_resource_references_from_memory(mf, resource_uri, recursive=False)++ assert changed is True+ assert mf.content == f"用户保存了越前龙马照片。\n用户也保存了[子图]({child_uri})。"+ assert mf.extra_fields["resource_refs"] == [+ {"resource_uri": child_uri, "source": "content.write"}+ ]+++def test_unlink_resource_references_removes_bare_uri_but_keeps_sentence():+ resource_uri = "viking://resources/images/2026/06/12/yueqian_jpeg"+ mf = MemoryFile(+ content=f"用户保存了越前龙马照片 {resource_uri}。",+ extra_fields={"resource_refs": [{"resource_uri": resource_uri}]},+ )++ changed = unlink_resource_references_from_memory(mf, resource_uri)++ assert changed is True+ assert mf.content == "用户保存了越前龙马照片。"+ assert "resource_refs" not in mf.extra_fields