fix(cli): preserve unresolved paths and deterministic YAML sets

Signed-off-by: phernandez <paul@basicmachines.co>

Author: phernandez

src/basic_memory/okf/render.py

@@ -24,6 +24,18 @@
 from basic_memory.okf.validation import Document, parse_document
 
 
+class ExportDumper(yaml.SafeDumper):
+    """Retain YAML mapping order while making unordered sets deterministic."""
+
+
+def represent_set(dumper: ExportDumper, values: set[object]) -> yaml.nodes.MappingNode:
+    ordered = sorted(values, key=lambda value: yaml.safe_dump(value, sort_keys=True))
+    return dumper.represent_mapping("tag:yaml.org,2002:set", [(value, None) for value in ordered])
+
+
+ExportDumper.add_representer(set, represent_set)
+
+
 @dataclass(frozen=True)
 class ExportFile:
     path: str
@@ -107,6 +119,10 @@ def wikilink(state: StateInline, silent: bool) -> bool:
         # Explicit relative links bind to their source directory before semantic aliases.
         # Wikilink paths are literal identifiers, so URL decoding must round-trip them.
         relative = markdown_link_target(quote(target, safe="/"), source)
+        # A root-relative URI with escaping dot segments could normalize to a real note.
+        # Keep that unresolved reference literal rather than inventing a portable edge.
+        if relative is None and ".." in PurePosixPath(target).parts:
+            return False
         if (
             include_project
             and "/" in target
@@ -131,7 +147,15 @@ def wikilink(state: StateInline, silent: bool) -> bool:
             resolved = title_targets.get(target)
         if not rooted and resolved is None:
             resolved = targets.get(target)
-        if not rooted and resolved is None and target not in ambiguous_aliases:
+        if (
+            not rooted
+            and resolved is None
+            and (
+                target not in ambiguous_aliases
+                or "/" in target
+                or target.casefold().endswith(".md")
+            )
+        ):
             # Forgiving filename spelling is a last resort after exact identities.
             candidates = ([relative] if relative and "/" in target else []) + [target]
             for candidate in candidates:
@@ -285,7 +309,9 @@ def render_bundle(snapshot: ExportSnapshot) -> tuple[ExportFile, ...]:
             permalinks=permalinks,
             title_targets=title_targets,
         )
-        content = "---\n" + yaml.safe_dump(metadata, allow_unicode=True, sort_keys=False)
+        content = "---\n" + yaml.dump(
+            metadata, Dumper=ExportDumper, allow_unicode=True, sort_keys=False
+        )
         content += "---\n" + body
         output.append(ExportFile(file.path, content.encode("utf-8")))
 

tests/okf/test_okf.py

@@ -736,3 +736,64 @@ def test_permalink_compatibility_candidates_are_not_filename_aliases(test_projec
     )
     source = next(file.content for file in render_bundle(snapshot) if file.path == "source.md")
     assert b"[p/foo](/p/foo) and [foo](/foo.md)" in source
+
+
+def test_escaping_wikilink_stays_literal_instead_of_normalizing_to_a_real_note():
+    body = "[[../../a.md]] and [[../a.md]]"
+    assert convert_wikilinks(body, "folder/source.md", {"a.md": "a.md"}, "p") == (
+        "[[../../a.md]] and [../a.md](/a.md)"
+    )
+
+
+def test_ambiguous_slash_title_still_allows_exact_filename_inference(test_project):
+    from basic_memory.models import Entity
+    from basic_memory.services.bulk_link_resolver import ProjectEntityIdentityIndex
+
+    owner = Entity(title="p/foo", file_path="p/foo.md")
+    index = ProjectEntityIdentityIndex.from_entities(
+        test_project, [owner, Entity(title="p/foo", file_path="other.md")]
+    )
+    assert (
+        index.resolve_strict(
+            "p/foo", include_project_permalinks=True, workspace_permalink=None
+        ).entity
+        is owner
+    )
+    snapshot = ExportSnapshot(
+        "p",
+        (
+            ExportFile("p/foo.md", b"---\ntitle: p/foo\n---\n"),
+            ExportFile("other.md", b"---\ntitle: p/foo\n---\n"),
+            ExportFile("source.md", b"[[p/foo]]"),
+        ),
+    )
+    source = next(file.content for file in render_bundle(snapshot) if file.path == "source.md")
+    assert b"[p/foo](/p/foo.md)" in source
+
+
+def test_yaml_sets_are_deterministic_across_processes():
+    import os
+    import subprocess
+    import sys
+
+    source = b"---\ntype: note\ncustom: !!set {alpha: null, beta: null, gamma: null}\n---\n"
+    expected = next(
+        file.content.decode()
+        for file in render_bundle(ExportSnapshot("p", (ExportFile("a.md", source),)))
+        if file.path == "a.md"
+    )
+    script = (
+        "from basic_memory.okf.render import ExportFile, ExportSnapshot, render_bundle\n"
+        f"source = {source!r}\n"
+        "print(next(f.content.decode() for f in render_bundle(ExportSnapshot('p', "
+        "(ExportFile('a.md', source),))) if f.path == 'a.md'))\n"
+    )
+    outputs = [
+        subprocess.check_output(
+            [sys.executable, "-c", script], env={**os.environ, "PYTHONHASHSEED": seed}, text=True
+        )
+        for seed in ("1", "2")
+    ]
+    assert outputs[0] == outputs[1] == expected + "\n"
+    assert parse_document(outputs[0]).metadata["custom"] == {"alpha", "beta", "gamma"}
+    assert outputs[0].index("type: note") < outputs[0].index("custom:")