Merge 09e58d0294 into e5bbb85e54

reme/components/file_graph/base_file_graph.py

@@ -19,6 +19,25 @@ class BaseFileGraph(BaseComponent):
 
     component_type = ComponentEnum.FILE_GRAPH
 
+    @staticmethod
+    def normalize_path(path: str) -> str:
+        """Normalize persisted Windows separators to workspace-relative POSIX."""
+        return path.replace("\\", "/")
+
+    @classmethod
+    def canonical_node(cls, node: FileNode) -> FileNode:
+        """Return a node whose path and links use canonical POSIX separators."""
+        links = [
+            link.model_copy(
+                update={
+                    "source_path": cls.normalize_path(link.source_path),
+                    "target_path": cls.normalize_path(link.target_path),
+                },
+            )
+            for link in node.links
+        ]
+        return node.model_copy(update={"path": cls.normalize_path(node.path), "links": links})
+
     # -- Lifecycle ---------------------------------------------------------
 
     async def _start(self) -> None:

reme/components/file_graph/local_file_graph.py

@@ -33,7 +33,7 @@ class LocalFileGraph(BaseFileGraph):
         try:
             for line in read_jsonl_zst(self._graph_file):
                 if line.strip():
-                    node = FileNode.model_validate_json(line)
+                    node = self.canonical_node(FileNode.model_validate_json(line))
                     self._nodes[node.path] = node
             self.logger.debug(f"Loaded {len(self._nodes)} nodes from {self._graph_file}")
         except Exception as e:
@@ -78,7 +78,8 @@ class LocalFileGraph(BaseFileGraph):
     # -- Node CRUD ---------------------------------------------------------
 
     async def upsert_nodes(self, nodes: list[FileNode]) -> None:
-        for node in nodes:
+        for raw_node in nodes:
+            node = self.canonical_node(raw_node)
             path = node.path
             old = self._nodes.get(path)
             if old is not None:
@@ -92,7 +93,8 @@ class LocalFileGraph(BaseFileGraph):
                 self._inverse.setdefault(path, set()).update(promoted)
 
     async def delete_nodes(self, paths: list[str]) -> None:
-        for path in paths:
+        for raw_path in paths:
+            path = self.normalize_path(raw_path)
             node = self._nodes.pop(path, None)
             if node is None:
                 continue
@@ -105,7 +107,7 @@ class LocalFileGraph(BaseFileGraph):
     async def get_nodes(self, paths: list[str] | None = None) -> list[FileNode]:
         if paths is None:
             return list(self._nodes.values())
-        return [self._nodes[p] for p in paths if p in self._nodes]
+        return [self._nodes[self.normalize_path(p)] for p in paths if self.normalize_path(p) in self._nodes]
 
     async def rebuild_links(self) -> None:
         self._inverse.clear()
@@ -124,13 +126,14 @@ class LocalFileGraph(BaseFileGraph):
 
     async def get_outlinks(self, path: str, scope: LinkScopeEnum | str = LinkScopeEnum.REAL) -> list[FileLink]:
         scope = self._normalize_scope(scope)
-        node = self._nodes.get(path)
+        node = self._nodes.get(self.normalize_path(path))
         if node is None:
             return []
         return [lnk for lnk in node.links if lnk.target_path and self._scope_match(lnk.target_path, scope)]
 
     async def get_inlinks(self, path: str, scope: LinkScopeEnum | str = LinkScopeEnum.REAL) -> list[FileLink]:
         scope = self._normalize_scope(scope)
+        path = self.normalize_path(path)
         sources: set[str] = set()
         if scope in (LinkScopeEnum.REAL, LinkScopeEnum.ALL):
             sources |= self._inverse.get(path, set())

reme/components/file_graph/nx_file_graph.py

@@ -69,7 +69,8 @@ class NxFileGraph(BaseFileGraph):
     # -- Node CRUD ---------------------------------------------------------
 
     async def upsert_nodes(self, nodes: list[FileNode]) -> None:
-        for node in nodes:
+        for raw_node in nodes:
+            node = self.canonical_node(raw_node)
             path = node.path
             if self._graph.has_node(path):
                 self._graph.remove_edges_from(list(self._graph.out_edges(path, keys=True)))
@@ -77,7 +78,8 @@ class NxFileGraph(BaseFileGraph):
             self._graph.add_edges_from(self._edges_from(path, node))
 
     async def delete_nodes(self, paths: list[str]) -> None:
-        for path in paths:
+        for raw_path in paths:
+            path = self.normalize_path(raw_path)
             if not self._graph.has_node(path):
                 continue
             self._graph.remove_edges_from(list(self._graph.out_edges(path, keys=True)))
@@ -89,14 +91,19 @@ class NxFileGraph(BaseFileGraph):
         view = self._graph.nodes
         if paths is None:
             return [d["node"] for _, d in view(data=True) if "node" in d]
-        return [view[p]["node"] for p in paths if p in view and "node" in view[p]]
+        normalized = [self.normalize_path(p) for p in paths]
+        return [view[p]["node"] for p in normalized if p in view and "node" in view[p]]
 
     async def rebuild_links(self) -> None:
-        self._graph.remove_edges_from(list(self._graph.edges(keys=True)))
-        virtual = [n for n, d in self._graph.nodes(data=True) if "node" not in d]
-        self._graph.remove_nodes_from(virtual)
-        for path, data in list(self._graph.nodes(data=True)):
-            self._graph.add_edges_from(self._edges_from(path, data["node"]))
+        canonical = {
+            self.normalize_path(data["node"].path): self.canonical_node(data["node"])
+            for _, data in self._graph.nodes(data=True)
+            if "node" in data
+        }
+        self._graph.clear()
+        for node in canonical.values():
+            self._graph.add_node(node.path, node=node)
+            self._graph.add_edges_from(self._edges_from(node.path, node))
 
     async def clear(self):
         self._graph.clear()
@@ -105,6 +112,7 @@ class NxFileGraph(BaseFileGraph):
     # -- Link access -------------------------------------------------------
 
     async def get_outlinks(self, path: str, scope: LinkScopeEnum = LinkScopeEnum.REAL) -> list[FileLink]:
+        path = self.normalize_path(path)
         view = self._graph.nodes
         if path not in view or "node" not in view[path]:
             return []
@@ -115,6 +123,7 @@ class NxFileGraph(BaseFileGraph):
         ]
 
     async def get_inlinks(self, path: str, scope: LinkScopeEnum = LinkScopeEnum.REAL) -> list[FileLink]:
+        path = self.normalize_path(path)
         view = self._graph.nodes
         if path not in view or not self._scope_match(path, scope):
             return []

reme/components/tag_index/local_tag_index.py

@@ -1,7 +1,7 @@
 """In-memory tag index derived from ``FileNode.front_matter``."""
 
 import asyncio
-from pathlib import PurePosixPath
+from pathlib import PurePosixPath, PureWindowsPath
 
 from .base_tag_index import BaseTagIndex, TagListItem, TagListResult, TagOrder, TagOrderBy
 from ..component_registry import R
@@ -63,12 +63,18 @@ class LocalTagIndex(BaseTagIndex):
 
     @staticmethod
     def _validate_path(path: str) -> str:
-        if not isinstance(path, str) or not path or "\\" in path:
+        if not isinstance(path, str) or not path:
             raise ValueError(f"Invalid workspace-relative tag-index path: {path!r}")
-        pure = PurePosixPath(path)
-        if pure.is_absolute() or path != pure.as_posix() or any(part in ("", ".", "..") for part in pure.parts):
+        normalized = path.replace("\\", "/")
+        pure = PurePosixPath(normalized)
+        if (
+            pure.is_absolute()
+            or PureWindowsPath(path).anchor
+            or normalized != pure.as_posix()
+            or any(part in ("", ".", "..") for part in pure.parts)
+        ):
             raise ValueError(f"Invalid workspace-relative tag-index path: {path!r}")
-        return path
+        return normalized
 
     def _prepare_nodes(self, nodes: list[FileNode]) -> list[tuple[str, tuple[str, ...]]]:
         prepared: list[tuple[str, tuple[str, ...]]] = []

reme/steps/evolve/auto_tag.py

@@ -1,8 +1,10 @@
 """Generate entity-oriented memory tags for added or modified Markdown files."""
 
 from dataclasses import dataclass
+import json
 from typing import Literal
 
+from agentscope.message import SystemMsg, UserMsg
 import frontmatter
 
 from ._evolve import agent_reply_result_text
@@ -53,9 +55,18 @@ def normalize_memory_tags(
 class AutoTagStep(BaseStep):
     """Update memory tags for Markdown files described by the common ``changes`` contract."""
 
-    def __init__(self, **kwargs):
+    def __init__(
+        self,
+        direct_llm: bool = False,
+        direct_excerpt_chars: int = 4500,
+        direct_candidate_tags: int = 80,
+        **kwargs,
+    ):
         super().__init__(**kwargs)
         self.tools = ["read", "list_tags", "frontmatter_read", "frontmatter_update"]
+        self.direct_llm = direct_llm
+        self.direct_excerpt_chars = max(500, direct_excerpt_chars)
+        self.direct_candidate_tags = max(0, direct_candidate_tags)
 
     def _targets(self) -> tuple[list[_TagTarget], list[dict[str, str]]]:
         """Validate, normalize, and de-duplicate added/modified Markdown changes."""
@@ -101,6 +112,140 @@ class AutoTagStep(BaseStep):
             targets[path] = _TagTarget(change=normalized_change, path=path)
         return list(targets.values()), ignored
 
+    @staticmethod
+    def _document_excerpt(content: str, max_chars: int) -> str:
+        """Keep the title-adjacent text and heading outline within a local model budget."""
+        if len(content) <= max_chars:
+            return content
+        headings = [
+            line.strip()
+            for line in content.splitlines()
+            if line.lstrip().startswith("#") and line.strip()
+        ]
+        heading_text = "\n".join(headings)
+        if len(heading_text) > max_chars // 3:
+            heading_text = heading_text[: max_chars // 3]
+        body_budget = max(0, max_chars - len(heading_text) - 64)
+        head = content[: body_budget // 2]
+        tail = content[-(body_budget - len(head)) :] if body_budget > len(head) else ""
+        return f"{head}\n\n[Headings]\n{heading_text}\n\n[Tail]\n{tail}"
+
+    @staticmethod
+    def _evidence_key(text: str) -> str:
+        """Normalize text for conservative evidence checks."""
+        return "".join(char.casefold() for char in text if char.isalnum())
+
+    async def _direct_tags(self, target: _TagTarget) -> list[str]:
+        """Generate tags in one structured call without an agent tool loop."""
+        wrapper = self.agent_wrapper
+        model = getattr(getattr(wrapper, "as_llm", None), "model", None)
+        if model is None:
+            raise RuntimeError("Direct auto-tag mode requires an agent wrapper with a bound LLM")
+        file_store = self.file_store
+        tag_index = file_store.require_tag_index()
+        tag_key = tag_index.tag_key
+        path = self.workspace_path / target.path
+        post = frontmatter.loads(path.read_text(encoding="utf-8"))
+        metadata = post.metadata or {}
+
+        candidates: list[str] = []
+        if self.direct_candidate_tags:
+            page = await tag_index.list_tags(
+                order_by="file_count",
+                order="desc",
+                page_size=self.direct_candidate_tags,
+            )
+            candidates = [item[0] for item in page["items"]]
+
+        excerpt = self._document_excerpt(post.content, self.direct_excerpt_chars)
+        metadata_hint = {
+            key: metadata[key]
+            for key in ("name", "description", "kind")
+            if key in metadata
+        }
+        messages = [
+            SystemMsg(
+                name="system",
+                content=self.prompt_format(
+                    "direct_system_prompt",
+                    tag_key=tag_key,
+                    max_tags_per_file=tag_index.max_tags_per_file,
+                    existing_tags=", ".join(candidates) or "(none)",
+                ),
+            ),
+            UserMsg(
+                name="user",
+                content=self.prompt_format(
+                    "direct_user_message",
+                    path=target.path,
+                    metadata_json=json.dumps(metadata_hint, ensure_ascii=False, indent=2),
+                    excerpt=excerpt,
+                ),
+            ),
+        ]
+        schema = {
+            "type": "object",
+            "properties": {
+                "entity_type": {
+                    "type": "string",
+                    "enum": [
+                        "none",
+                        "person",
+                        "organization",
+                        "product",
+                        "place",
+                        "asset",
+                        "named_project",
+                    ],
+                },
+                "evidence": {
+                    "type": "string",
+                    "description": "Exact short quote from the document body or description supporting the entity",
+                },
+                tag_key: {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "maxItems": tag_index.max_tags_per_file,
+                },
+            },
+            "required": ["entity_type", "evidence", tag_key],
+            "additionalProperties": False,
+        }
+        response = await model.generate_structured_output(
+            messages=messages,
+            structured_model=schema,
+        )
+        content = response.content
+        if hasattr(content, "model_dump"):
+            content = content.model_dump()
+        if not isinstance(content, dict):
+            raise RuntimeError("Direct auto-tag model did not return an object")
+        normalized = normalize_memory_tags(
+            content.get(tag_key),
+            max_tags_per_file=tag_index.max_tags_per_file,
+            max_tag_length=tag_index.max_tag_length,
+        )
+        if str(content.get("entity_type") or "").strip().lower() == "none":
+            return []
+        evidence = str(content.get("evidence") or "").strip()
+        body_without_headings = "\n".join(
+            line for line in post.content.splitlines() if not line.lstrip().startswith("#")
+        )
+        searchable = "\n".join(
+            value
+            for value in (str(metadata.get("description") or ""), body_without_headings)
+            if value
+        )
+        evidence_key = self._evidence_key(evidence)
+        searchable_key = self._evidence_key(searchable)
+        if not evidence_key or evidence_key not in searchable_key:
+            self.logger.warning(f"[{self.name}] rejected unsupported tag evidence path={target.path}")
+            return []
+        supported = [tag for tag in normalized if self._evidence_key(tag) in evidence_key]
+        if len(supported) != len(normalized):
+            self.logger.warning(f"[{self.name}] rejected tags without evidence path={target.path}")
+        return supported
+
     async def _process_target(self, target: _TagTarget) -> str:
         file_store = self.file_store
         tag_index = file_store.require_tag_index()
@@ -110,26 +255,33 @@ class AutoTagStep(BaseStep):
             "_allowed_paths": [target.path],
             "_allowed_frontmatter_keys": [tag_key],
         }
-        result = await self.agent_wrapper.reply(
-            self.prompt_format("user_message", path=target.path, change=target.change, tag_key=tag_key),
-            system_prompt=self.prompt_format(
-                "system_prompt",
-                tag_key=tag_key,
-                max_tags_per_file=tag_index.max_tags_per_file,
-            ),
-            job_tools=self.tools,
-            injected_job_kwargs=tool_context,
-        )
+        if self.direct_llm:
+            generated_tags = await self._direct_tags(target)
+            result_text = f"Generated tags: {json.dumps(generated_tags, ensure_ascii=False)}"
+        else:
+            result = await self.agent_wrapper.reply(
+                self.prompt_format("user_message", path=target.path, change=target.change, tag_key=tag_key),
+                system_prompt=self.prompt_format(
+                    "system_prompt",
+                    tag_key=tag_key,
+                    max_tags_per_file=tag_index.max_tags_per_file,
+                ),
+                job_tools=self.tools,
+                injected_job_kwargs=tool_context,
+            )
 
         path = self.workspace_path / target.path
         metadata = dict(frontmatter.loads(path.read_text(encoding="utf-8")).metadata or {})
-        if tag_key not in metadata:
+        if self.direct_llm:
+            normalized = generated_tags
+        elif tag_key not in metadata:
             raise RuntimeError(f"Auto-tag agent did not write the required {tag_key!r} field")
-        normalized = normalize_memory_tags(
-            metadata.get(tag_key),
-            max_tags_per_file=tag_index.max_tags_per_file,
-            max_tag_length=tag_index.max_tag_length,
-        )
+        else:
+            normalized = normalize_memory_tags(
+                metadata.get(tag_key),
+                max_tags_per_file=tag_index.max_tags_per_file,
+                max_tag_length=tag_index.max_tag_length,
+            )
         if metadata.get(tag_key) != normalized:
             response = await self.run_job(
                 "frontmatter_update",
@@ -139,7 +291,7 @@ class AutoTagStep(BaseStep):
             )
             if not response.success:
                 raise RuntimeError(str(response.answer))
-        return agent_reply_result_text(result)
+        return result_text if self.direct_llm else agent_reply_result_text(result)
 
     async def execute(self):
         assert self.context is not None

reme/steps/evolve/auto_tag.yaml

@@ -33,6 +33,66 @@ system_prompt_zh: |
   只选择实体，不要使用宽泛主题、行为、属性、日期或普通关键词。每个实体使用一个简洁、规范的现实名称。
   多个实体必须保存为独立的 YAML 列表项，例如 `[宁德时代, 黄金]`；不要把它们拼成一个逗号分隔的字符串。
   不要为已有实体创造别名或近似拼写。只能更新 `{tag_key}`，绝不能修改正文或其他 frontmatter 字段。
+direct_system_prompt: |
+  You assign entity-oriented memory tags to one Markdown note in a single pass.
+
+  The `{tag_key}` field must name the central real-world entity: a person, organization, product,
+  place, asset, or named project. Do not tag broad topics, capabilities, tasks, workflows, dates,
+  attributes, or generic keywords. If no named entity is central, return an empty list.
+
+  Also return `entity_type` and a short exact `evidence` quote from the document body or description.
+  The evidence must explicitly contain every returned entity name. If the evidence only proves a
+  capability, request, workflow, error, title, or filename, return `entity_type="none"`, `evidence=""`,
+  and an empty list.
+
+  Prefer an existing tag when it names the same entity. Tags must not contain spaces; replace spaces
+  with underscores. Return at most {max_tags_per_file} tags.
+
+  Counterexamples:
+  - "A request to list controllable desktop applications" -> []
+  - "Notes about code review in general" -> []
+  - "OpenAI releases a new API" -> ["OpenAI"]
+  - "Sam Altman discusses agent safety" -> ["sam_altman"]
+
+  Existing workspace tags, ordered by usage:
+  {existing_tags}
+direct_system_prompt_zh: |
+  你需要在一次调用内为一份 Markdown 记忆生成以实体为中心的记忆标签。
+
+  `{tag_key}` 字段只能填写文档真正围绕的现实实体：人物、组织、产品、地点、资产或具名项目。
+  不要标记宽泛主题、能力、任务、流程、日期、属性或普通关键词。如果文档没有核心具名实体，返回空列表。
+
+  同时返回 `entity_type` 和文档正文或 description 中一段简短的原文 `evidence`。evidence 必须明确
+  包含每一个返回的实体；如果证据只能说明能力、请求、流程、错误、标题或文件名，必须返回
+  `entity_type="none"`、`evidence=""` 和空列表。
+
+  同一实体已有标签时必须优先复用。标签不能包含空格，空格必须替换为下划线。最多返回
+  {max_tags_per_file} 个标签。
+
+  反例：
+  - “列出可控制的桌面应用” -> []
+  - “关于代码审查的一般经验” -> []
+  - “OpenAI 发布新 API” -> ["OpenAI"]
+  - “Sam Altman 讨论智能体安全” -> ["sam_altman"]
+
+  工作区已有标签（按使用频率排序）：
+  {existing_tags}
+direct_user_message: |
+  Path: {path}
+
+  Frontmatter metadata:
+  {metadata_json}
+
+  Document excerpt:
+  {excerpt}
+direct_user_message_zh: |
+  路径：{path}
+
+  Frontmatter 元数据：
+  {metadata_json}
+
+  文档摘录：
+  {excerpt}
 user_message: |
   Change: {change}
   Target path: {path}

tests/unit/test_auto_tag.py

@@ -3,6 +3,7 @@
 # pylint: disable=missing-function-docstring
 
 from pathlib import Path
+from types import SimpleNamespace
 from unittest.mock import AsyncMock
 
 import frontmatter
@@ -45,6 +46,12 @@ class _TaggingWrapper(BaseAgentWrapper):
         return {"result": f"tagged {path}", "last_message": {}}
 
 
+class _DirectTaggingWrapper(_TaggingWrapper):
+    def __init__(self, workspace: Path, model) -> None:
+        super().__init__(workspace)
+        self.as_llm = SimpleNamespace(model=model)
+
+
 def _write_note(path: Path) -> None:
     path.parent.mkdir(parents=True, exist_ok=True)
     path.write_text("---\nname: note\ndescription: useful note\n---\nbody\n", encoding="utf-8")
@@ -226,3 +233,68 @@ async def test_auto_tag_uses_configured_key_and_normalizes_agent_output(tmp_path
         "宁德时代",
     ]
     assert wrapper.calls[0][1]["injected_job_kwargs"]["file_store"] == "archive"
+
+
+@pytest.mark.asyncio
+async def test_auto_tag_direct_llm_uses_one_structured_call_and_normalizes_output(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    note = tmp_path / "memory/note.md"
+    note.parent.mkdir(parents=True, exist_ok=True)
+    note.write_text(
+        "---\n"
+        "name: note\n"
+        "description: OpenAI and Sam Altman are central to this note.\n"
+        "---\n"
+        "OpenAI and Sam Altman are central to this note.\n",
+        encoding="utf-8",
+    )
+
+    class _StructuredTagModel:
+        def __init__(self) -> None:
+            self.calls: list[dict] = []
+
+        async def generate_structured_output(self, **kwargs):
+            self.calls.append(kwargs)
+            return SimpleNamespace(
+                content={
+                    "entity_type": "organization",
+                    "evidence": "OpenAI and Sam Altman are central to this note.",
+                    "keywords": ["OpenAI", "openai", "Sam   Altman", "++"],
+                },
+            )
+
+    model = _StructuredTagModel()
+    store = _file_store(name="archive", tag_key="keywords", max_tags_per_file=2, max_tag_length=12)
+    wrapper = _DirectTaggingWrapper(tmp_path, model)
+    step = AutoTagStep(
+        agent_wrapper=wrapper,
+        direct_llm=True,
+        direct_candidate_tags=0,
+        file_store=store,
+    )
+
+    async def update_frontmatter(name, /, **kwargs):
+        assert name == "frontmatter_update"
+        assert kwargs["_allowed_frontmatter_keys"] == ["keywords"]
+        assert kwargs["file_store"] == "archive"
+        post = frontmatter.loads(note.read_text(encoding="utf-8"))
+        post.metadata.update(kwargs["metadata"])
+        note.write_text(frontmatter.dumps(post), encoding="utf-8")
+        return Response(answer="updated")
+
+    monkeypatch.setattr(step, "run_job", update_frontmatter)
+
+    response = await step(RuntimeContext(changes=[{"change": "modified", "path": "memory/note.md"}]))
+
+    assert response.metadata["auto_tag"]["succeeded"] == 1
+    assert frontmatter.loads(note.read_text(encoding="utf-8")).metadata["keywords"] == [
+        "OpenAI",
+        "Sam_Altman",
+    ]
+    assert len(model.calls) == 1
+    assert model.calls[0]["structured_model"]["required"] == [
+        "entity_type",
+        "evidence",
+        "keywords",
+    ]
+    assert "Frontmatter metadata" in str(model.calls[0]["messages"][1].content)

tests/unit/test_file_graph.py

@@ -101,6 +101,38 @@ async def test_upsert_replaces_old_links(backend_cls):
         await graph.close()
 
 
+@pytest.mark.parametrize("backend_cls", BACKENDS)
+@pytest.mark.asyncio
+async def test_windows_separator_paths_are_canonicalized(backend_cls):
+    """Persisted Windows paths and POSIX wikilink targets form one graph."""
+
+    with tempfile.TemporaryDirectory() as tmpdir, temp_chdir(tmpdir):
+        graph = backend_cls()
+        await graph.start()
+        await graph.upsert_nodes(
+            [
+                make_node(r"daily\2026-10-27\a.md", [(r"daily\2026-10-27\b.md", None)]),
+                make_node(r"daily\2026-10-27\b.md"),
+            ],
+        )
+
+        assert {node.path for node in await graph.get_nodes()} == {
+            "daily/2026-10-27/a.md",
+            "daily/2026-10-27/b.md",
+        }
+        assert {
+            link.target_path
+            for link in await graph.get_outlinks(r"daily\2026-10-27\a.md", scope=LinkScopeEnum.ALL)
+        } == {"daily/2026-10-27/b.md"}
+        assert {
+            link.source_path
+            for link in await graph.get_inlinks(r"daily\2026-10-27\b.md", scope=LinkScopeEnum.ALL)
+        } == {"daily/2026-10-27/a.md"}
+        assert await graph.get_outlinks(r"daily\2026-10-27\a.md", scope=LinkScopeEnum.VIRTUAL) == []
+
+        await graph.close()
+
+
 @pytest.mark.parametrize("backend_cls", BACKENDS)
 @pytest.mark.asyncio
 async def test_outlinks_include_virtual_targets(backend_cls):

tests/unit/test_tag_index.py

@@ -56,6 +56,18 @@ async def test_tag_normalization_and_bidirectional_mutations() -> None:
     await index.close()
 
 
+@pytest.mark.asyncio
+async def test_tag_index_normalizes_windows_separators() -> None:
+    """Migrate persisted Windows paths to the canonical POSIX key."""
+
+    index = LocalTagIndex()
+    await index.rebuild([_node(r"daily\2026-10-27\note.md", ["ReMe"])])
+
+    assert await index.tags_for_path(r"daily\2026-10-27\note.md") == ["reme"]
+    assert await index.paths_for_tags(["reme"]) == ["daily/2026-10-27/note.md"]
+    assert index.path_to_tags == {"daily/2026-10-27/note.md": ("reme",)}
+
+
 @pytest.mark.asyncio
 async def test_rebuild_is_atomic_and_supports_all_or_any_queries() -> None:
     """Publish complete rebuilds atomically and support intersection and union lookup."""