dataface 0.2.1.dev647__py3-none-any.whl → 0.2.1.dev691__py3-none-any.whl

dataface/_docs_site.py

@@ -12,9 +12,7 @@ def docs_site_url() -> str:
 
     ``DFT_DOCS_URL`` overrides the shipped default when set to a non-empty
     value. Used by ``dft docs`` (web link on the topic index) and by structured
-    error ``doc_url``s. The playground gallery reads ``DFT_DOCS_URL`` directly
-    and hides its ``docs:`` links when unset, so it does not inherit this
-    default — see ``dataface_playground.routes.get_runtime_config``.
+    error ``doc_url``s.
     """
     raw = os.environ.get("DFT_DOCS_URL", DEFAULT_DOCS_SITE_URL).strip()
     if not raw:

dataface/_install_hint.py

@@ -57,8 +57,8 @@ def install_hint(extra: str | None = None) -> str:
     """Return the install one-liner that matches how this Dataface got installed.
 
     ``extra`` is an optional optional-dependency group (``"mcp"``,
-    ``"chat"``, ``"playground"``, ``"bigquery"``); when set, the
-    returned command installs Dataface with that extras bracket.
+    ``"playground"``, ``"bigquery"``); when set, the returned command
+    installs Dataface with that extras bracket.
     """
     spec = f"dataface[{extra}]" if extra else "dataface"
     if _is_uv_tool_install():

dataface/agent_api/_paths.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import os
 from dataclasses import dataclass
-from pathlib import Path
+from pathlib import Path, PurePosixPath
 
 # tach-ignore(agent_api->cli: runtime host-type guard in no_project_hint; the local-filesystem check needs a non-cli signal on Project — deferred)
 from dataface.cli.filesystem_project import FilesystemProject
@@ -75,40 +75,91 @@ def no_project_hint(project: Project) -> str:
     )
 
 
-def resolve_face_path(path: Path, project: Project) -> ProjectPath:
-    """User/agent-supplied face path -> ProjectPath.
+def resolve_face_relpath(relpath: PurePosixPath, project: Project) -> ProjectPath:
+    """Project-relative face identity -> ProjectPath, with the faces-first retry.
 
-    Absolute and ``..``-leading paths are explicit locations: they relativize
-    through the containment seam (``project.path_for_fspath``, a leading
-    ``..`` resolving against cwd for CLI shell-nav feel) and are returned
-    as-is — no ``faces/`` retry, even when the exact path doesn't exist. A
-    bare relative name (no explicit location) gets the faces-first retry: for
-    a relpath that doesn't exist in the project store and has no explicit
-    ``faces/`` prefix, retries under ``FACES_SUBDIR``. This lets a
-    ``search_dashboards`` ``face_path`` of ``'looker/x.yaml'`` (``faces/``
-    prefix stripped at search time) resolve to ``faces/looker/x.yaml``
-    without producing a ``faces/faces/...`` double prefix when the caller
-    already supplies the full ``faces/looker/x.yaml``.
+    The relpath-native counterpart to ``resolve_face_path``: for callers that
+    already hold a project-relative face identity (Cloud's context strings)
+    rather than a real filesystem path, this is the single owner of the
+    face-relative vs root-relative reconciliation — a bare name like
+    ``looker/x.yaml`` retries under ``FACES_SUBDIR`` when it doesn't exist at
+    root, without producing a ``faces/faces/...`` double prefix when the
+    caller already supplies the full ``faces/looker/x.yaml``.
 
     Existence is checked via ``project.exists(...)`` so it works for all
     ``Project`` implementations (FilesystemProject, CloudManagedProject
     git-blob store, etc.) — not just the local filesystem. Paths that exist
     at root resolve from root — non-faces paths like ``models/schema.sql``
-    are not rewritten under faces/.
+    are not rewritten under faces/. ``str`` is used only at the identity seam
+    (``project.path`` / ``project.exists``); everything else is real
+    ``PurePosixPath`` operations.
+    """
+    relpath_str = str(relpath)
+    assert_relpath(relpath_str)
+    if project.exists(relpath_str):
+        return project.path(relpath_str)
+    if not relpath.parts or relpath.parts[0] != FACES_SUBDIR:
+        candidate = PurePosixPath(FACES_SUBDIR) / relpath
+        candidate_str = str(candidate)
+        if project.exists(candidate_str):
+            return project.path(candidate_str)
+    return project.path(relpath_str)  # caller reports not-found
+
+
+def _relpath_for_fs_location(path: Path, project: Project) -> str:
+    """Relativize an absolute, on-disk face location against a local project root.
+
+    Absolute and ``..``-leading face paths are explicit filesystem locations —
+    the one place this boundary genuinely needs a real ``Path`` op. Only
+    ``FilesystemProject`` ever receives them: Cloud/MCP always supply
+    project-relative identity strings, never a real filesystem path, so any
+    other ``Project`` implementation here is a caller bug, not a store to
+    fall back through.
+
+    Two-try containment check (mirrors the pre-refactor behavior): ``resolve()``
+    follows symlinks (handles e.g. ``/var`` -> ``/private/var`` on macOS); a
+    symlink-blind ``normpath`` fallback accepts paths through intentional
+    project-internal symlinks (e.g. ``faces/tasks/`` -> ``../../tasks/``).
+    Raises ``ValueError`` if neither check places *path* inside the root.
+    """
+    if not isinstance(project, FilesystemProject):
+        raise ValueError(
+            "Absolute or '..'-relative face paths require a local filesystem "
+            f"project; got {type(project).__name__}."
+        )
+    root = project.root
+    resolved = path.resolve()
+    try:
+        return str(resolved.relative_to(root))
+    except ValueError:
+        pass
+    normalized = Path(os.path.normpath(path.absolute()))
+    try:
+        return str(normalized.relative_to(root))
+    except ValueError:
+        raise ValueError(f"Path {path!r} is outside project root {root!r}") from None
+
+
+def resolve_face_path(path: Path, project: Project) -> ProjectPath:
+    """User/agent-supplied filesystem-shaped face path -> ProjectPath.
+
+    Absolute and ``..``-leading paths are explicit locations: they relativize
+    against a concrete ``FilesystemProject`` root (``_relpath_for_fs_location``,
+    a leading ``..`` resolving against cwd for CLI shell-nav feel) and are
+    returned as-is — no ``faces/`` retry, even when the exact path doesn't
+    exist. A bare relative name (no explicit location) delegates to
+    ``resolve_face_relpath`` for the faces-first retry, which works against
+    any ``Project`` implementation.
     """
     if path.is_absolute():
-        return project.path_for_fspath(path)
-    if ".." in path.parts:
-        return project.path_for_fspath(Path(os.path.normpath(Path.cwd() / path)))
-    relpath = str(path)
-    assert_relpath(relpath)
-    if project.exists(relpath):
-        return project.path(relpath)
-    if not relpath.startswith(f"{FACES_SUBDIR}/"):
-        candidate = f"{FACES_SUBDIR}/{relpath}"
-        if project.exists(candidate):
-            return project.path(candidate)
-    return project.path(relpath)  # caller reports not-found
+        relpath = _relpath_for_fs_location(path, project)
+    elif ".." in path.parts:
+        relpath = _relpath_for_fs_location(
+            Path(os.path.normpath(Path.cwd() / path)), project
+        )
+    else:
+        return resolve_face_relpath(PurePosixPath(path), project)
+    return project.path(relpath)
 
 
 def resolve_face_or_error(path: Path, project: Project) -> FaceFile | Diagnostic:

dataface/agent_api/cache.py

@@ -21,7 +21,6 @@ if TYPE_CHECKING:
 __all__ = [
     "TrivialDuckDBCache",
     "open_cache",
-    "open_project_cache",
     "project_cache_ctx",
 ]
 
@@ -32,18 +31,19 @@ def open_cache(path: Path | None) -> TrivialDuckDBCache:
     ``path=None`` opens an in-memory cache — ephemeral, discarded when closed.
     A path opens (or creates, if absent) a persistent DuckDB file, reused
     across invocations. Callers own the returned cache's lifecycle (close it).
-    Does not consult project config — use ``open_project_cache`` for that.
+    Does not consult project config — use ``project_cache_ctx`` for that.
     """
     return TrivialDuckDBCache(db_path=path)
 
 
-def open_project_cache(
+@contextmanager
+def project_cache_ctx(
     project: FilesystemProject,
     *,
     no_cache: bool = False,
     cache_path: Path | None = None,
-) -> TrivialDuckDBCache | None:
-    """Open the query-result cache honoring project config, with overrides.
+) -> Generator[TrivialDuckDBCache | None]:
+    """Open the query-result cache honoring project config, closing it on exit.
 
     The caller owns the project instance. Pair this with
     ``ProjectSession.from_project(project, cache=...)`` rather than
@@ -59,23 +59,12 @@ def open_project_cache(
     to off without closing the door on a nearer scope's opt-in, so it still
     opens a store; the resolved per-query policy decides what gets written.
 
-    Returns:
+    Yields:
         ``None`` only when ``no_cache=True`` — callers pass this straight
         through as ``ProjectSession(cache=...)``.
     """
     boot = resolve_cache_boot(project, no_cache=no_cache, cache_path=cache_path)
-    return open_cache(boot.path) if boot.enabled else None
-
-
-@contextmanager
-def project_cache_ctx(
-    project: FilesystemProject,
-    *,
-    no_cache: bool = False,
-    cache_path: Path | None = None,
-) -> Generator[TrivialDuckDBCache | None]:
-    """Context-managed ``open_project_cache``; closes the cache on exit if opened."""
-    cache = open_project_cache(project, no_cache=no_cache, cache_path=cache_path)
+    cache = open_cache(boot.path) if boot.enabled else None
     try:
         yield cache
     finally:

dataface/agent_api/data_paths.py

@@ -83,9 +83,7 @@ def data_alias_errors_for_file(
     """
     from dataface.core.serve.alias_index import read_aliases_from_file
 
-    # path_for_fspath raises ValueError when face_file is outside project.root —
-    # that is a caller bug, not a parse error, and must NOT be swallowed.
-    project_path = project.path_for_fspath(face_file)
+    project_path = project.path(face_file.as_posix())
     try:
         aliases = read_aliases_from_file(project_path)
     except ValueError:

dataface/agent_api/describe.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from pathlib import Path
+from pathlib import Path, PurePosixPath
 from typing import Any
 
 from pydantic import BaseModel, ConfigDict, Field
@@ -22,7 +22,7 @@ from dataface.core.diagnostics import (
     ERR_INTERNAL,
     Diagnostic,
 )
-from dataface.core.project import Project
+from dataface.core.project import Project, ProjectPath
 
 # Chart-encoding fields surfaced to agents. Covers the stable channel fields
 # across chart families. `label` is excluded — it's a KPI-specific render hint,
@@ -99,7 +99,7 @@ class DescribeFaceResult(BaseModel):
     model_config = ConfigDict(frozen=True)
 
     success: bool
-    path: Path
+    path: Path = Field(description="Project-relative path to the described face.")
     title: str | None = None
     description: str | None = None
     queries: list[QueryDescription] = Field(
@@ -183,8 +183,7 @@ def _encoding_for_chart(chart: Chart) -> dict[str, Any]:
 
 def describe_face(path: Path, *, project: Project) -> DescribeFaceResult:
     """Describe the structure of a face: queries, charts, variables, layout."""
-    from dataface.agent_api._paths import no_project_hint, resolve_face_path
-    from dataface.core.compile.compiler import compile_file
+    from dataface.agent_api._paths import resolve_face_path
     from dataface.core.diagnostics.base import DatafaceError
 
     try:
@@ -198,12 +197,22 @@ def describe_face(path: Path, *, project: Project) -> DescribeFaceResult:
             ],
         )
 
-    resolved_display = project.root / resolved.relpath
+    return _describe_resolved(resolved, project=project)
+
+
+def _describe_resolved(
+    resolved: ProjectPath, *, project: Project
+) -> DescribeFaceResult:
+    """Describe an already-resolved face path — no re-resolution."""
+    from dataface.agent_api._paths import no_project_hint
+    from dataface.core.compile.compiler import compile_file
+    from dataface.core.diagnostics.base import DatafaceError
+
     if not resolved.exists():
         hint = no_project_hint(project)
         return DescribeFaceResult(
             success=False,
-            path=path,
+            path=Path(resolved.relpath),
             errors=[
                 DatafaceError.from_code(
                     ERR_FILE_NOT_FOUND,
@@ -218,7 +227,7 @@ def describe_face(path: Path, *, project: Project) -> DescribeFaceResult:
     except OSError as exc:
         return DescribeFaceResult(
             success=False,
-            path=resolved_display,
+            path=Path(resolved.relpath),
             errors=[
                 DatafaceError.from_code(ERR_INTERNAL, message=str(exc)).to_diagnostic(
                     file=resolved.relpath
@@ -229,7 +238,7 @@ def describe_face(path: Path, *, project: Project) -> DescribeFaceResult:
     if result.errors:
         return DescribeFaceResult(
             success=False,
-            path=resolved_display,
+            path=Path(resolved.relpath),
             errors=list(result.errors),
         )
 
@@ -237,7 +246,7 @@ def describe_face(path: Path, *, project: Project) -> DescribeFaceResult:
     if face is None:
         return DescribeFaceResult(
             success=False,
-            path=resolved_display,
+            path=Path(resolved.relpath),
             errors=[
                 DatafaceError.from_code(
                     ERR_INTERNAL, message="Compilation produced no face"
@@ -285,7 +294,7 @@ def describe_face(path: Path, *, project: Project) -> DescribeFaceResult:
 
     return DescribeFaceResult(
         success=True,
-        path=resolved_display,
+        path=Path(resolved.relpath),
         title=face.title or None,
         description=face.description or None,
         queries=query_descs,
@@ -339,28 +348,33 @@ def _describe_one_path(
             )
         ]
 
-    resolved_display = project.root / resolved.relpath
-    if not resolved_display.is_dir():
-        return [describe_face(resolved_display, project=project)]
+    if resolved.is_yaml:
+        return [_describe_resolved(resolved, project=project)]
 
     faces = sorted(
-        project.root / pf.relpath
-        for pf in project.iter_faces(under=resolved.relpath, recursive=True)
-        if pf.is_yaml
-        and not pf.is_private
-        and not (pf.parent / INSPECT_TEMPLATE_MANIFEST).exists()
+        (
+            pf
+            for pf in project.iter_faces(under=resolved.relpath, recursive=True)
+            if pf.is_yaml
+            and not pf.is_private
+            and not (pf.parent / INSPECT_TEMPLATE_MANIFEST).exists()
+        ),
+        # Relpaths under `under` share a common prefix, so a PurePosixPath key
+        # reproduces the old absolute-Path sort order exactly on 3.10 and
+        # 3.13 — don't "simplify" this to a str/.parts key.
+        key=lambda pf: PurePosixPath(pf.relpath),
     )
     if not faces:
         return [
             DescribeFaceResult(
                 success=False,
-                path=resolved_display,
+                path=Path(resolved.relpath),
                 errors=[
                     DatafaceError.from_code(
                         ERR_INTERNAL,
-                        message=f"No face files found in {resolved_display}",
+                        message=f"No face files found in {resolved.relpath}",
                     ).to_diagnostic()
                 ],
             )
         ]
-    return [describe_face(f, project=project) for f in faces]
+    return [_describe_resolved(pf, project=project) for pf in faces]

dataface/agent_api/docs/yaml-reference.md

@@ -10,7 +10,6 @@ AuthoredFace (dataface) definition from YAML.
 | `description` | str | ✓ | Description text for the dashboard. |
 | `tags` | list[str] | ✓ | Tags for categorization and search. |
 | `aliases` | list[str] | ✓ | Additional URLs that redirect to this face's canonical file-path URL. Each entry must be absolute (leading /). Requests to these URLs are redirected (302) to the face's real path, query string preserved. Valid on .yml, .yaml, .md, and folder index.* faces. |
-| `docs` | str | ✓ | Relative path under the docs site for the canonical doc page that explains this face. Surfaced as a 'Docs →' link in the playground gallery when DFT_DOCS_URL is set. |
 | `text` | str | ✓ | Markdown text content for text-only sections. |
 | `allow_html` | bool | ✓ | Render the face's body text as raw HTML via foreignObject instead of markdown. TRUSTED-CONTENT ONLY: the HTML (including any Jinja-interpolated values) is rendered as-authored — this is NOT a security sandbox. mdsvg strips <script>/event-handlers as a best-effort guard, not a guarantee. Enable only on first-party faces you fully control. |
 | `source` | str | ✓ | Default source name for all queries in this face. Inheritable via meta.yaml cascade. |

dataface/agent_api/project_session.py

@@ -120,7 +120,7 @@ class ProjectSession:
         (or another cache backend) when caching is desired, otherwise omit and the
         project will run uncached. ``close()`` does not touch the cache — whoever
         opened it closes it. A caller deriving the cache from project config via
-        ``open_project_cache(project)`` already holds a project — use
+        ``project_cache_ctx(project)`` already holds a project — use
         ``from_project`` instead, or this builds a second one.
 
         The adapter registry is built lazily on first access to ``adapter_registry``.

dataface/agent_api/query.py

@@ -1,6 +1,6 @@
 """Typed query verbs for the agent API."""
 
-from pathlib import Path
+from pathlib import Path, PurePosixPath
 from typing import Any
 
 from pydantic import BaseModel, ConfigDict, Field
@@ -233,7 +233,7 @@ class QueryFaceResult(BaseModel):
 
     success: bool
     name: str
-    path: Path
+    path: PurePosixPath
     query_type: str | None = None
     sql: str | None = None
     columns: list[str] = []
@@ -245,7 +245,10 @@ class QueryFaceResult(BaseModel):
 
 
 def _fail(
-    name: str, path: Path, errors: list[str], available: list[str] | None = None
+    name: str,
+    path: PurePosixPath,
+    errors: list[str],
+    available: list[str] | None = None,
 ) -> QueryFaceResult:
     return QueryFaceResult(
         success=False,
@@ -271,9 +274,11 @@ def query_face(
     try:
         file_path = resolve_face_path(path, project)
     except ValueError as e:
-        return _fail(name, path, [str(e)])
+        # Raw-input echo — resolution failed, so this is the caller's rejected
+        # path, not a validated project-relative identity.
+        return _fail(name, PurePosixPath(path), [str(e)])
 
-    resolved_display = project.root / file_path.relpath
+    resolved_display = PurePosixPath(file_path.relpath)
     if not file_path.exists():
         from dataface.agent_api._paths import no_project_hint
 

dataface/agent_api/validate.py

@@ -5,7 +5,7 @@ No warehouse connection, no query execution.
 
 from __future__ import annotations
 
-from pathlib import Path
+from pathlib import Path, PurePosixPath
 from typing import TYPE_CHECKING
 
 from pydantic import BaseModel, ConfigDict, Field
@@ -21,7 +21,7 @@ from dataface.core.diagnostics import (
     Diagnostic,
 )
 from dataface.core.diagnostics.base import DatafaceError
-from dataface.core.project import FACES_SUBDIR, META_FILENAMES, Project
+from dataface.core.project import FACES_SUBDIR, META_FILENAMES, Project, ProjectPath
 
 if TYPE_CHECKING:
     from dataface.agent_api.project_session import ProjectSession
@@ -49,7 +49,7 @@ class ValidateResult(BaseModel):
     model_config = ConfigDict(frozen=True)
 
     success: bool
-    path: Path
+    path: Path = Field(description="Project-relative path to the validated face.")
     errors: list[Diagnostic] = Field(
         default_factory=list, description="Validation errors found in the face file."
     )
@@ -131,35 +131,40 @@ def _validate_one_path(
             )
         ]
 
-    resolved_display = project.root / resolved.relpath
-    if not resolved_display.is_dir():
-        return [validate(resolved_display, project=project)]
+    if resolved.is_yaml:
+        return [_validate_resolved(resolved, project=project)]
 
     faces = sorted(
-        project.root / pf.relpath
-        for pf in project.iter_faces(under=resolved.relpath, recursive=True)
-        if pf.is_yaml
-        and not pf.is_private
-        and Path(pf.relpath).name not in META_FILENAMES
-        and not (pf.parent / INSPECT_TEMPLATE_MANIFEST).exists()
+        (
+            pf
+            for pf in project.iter_faces(under=resolved.relpath, recursive=True)
+            if pf.is_yaml
+            and not pf.is_private
+            and PurePosixPath(pf.relpath).name not in META_FILENAMES
+            and not (pf.parent / INSPECT_TEMPLATE_MANIFEST).exists()
+        ),
+        # Relpaths under `under` share a common prefix, so a PurePosixPath key
+        # reproduces the old absolute-Path sort order exactly on 3.10 and
+        # 3.13 — don't "simplify" this to a str/.parts key.
+        key=lambda pf: PurePosixPath(pf.relpath),
     )
     if not faces:
         return [
             ValidateResult(
                 success=False,
-                path=resolved_display,
+                path=Path(resolved.relpath),
                 errors=[
                     DatafaceError.from_code(
                         ERR_INTERNAL,
-                        message=f"No face files found in {resolved_display}",
+                        message=f"No face files found in {resolved.relpath}",
                     ).to_diagnostic()
                 ],
             )
         ]
-    return [validate(f, project=project) for f in faces]
+    return [_validate_resolved(pf, project=project) for pf in faces]
 
 
-def _validate_meta_file(path: Path, *, project: Project) -> ValidateResult:
+def _validate_meta_file(resolved: ProjectPath) -> ValidateResult:
     """Validate a meta.yaml as a FacePatch fragment — no layout required."""
     from pydantic import ValidationError as PydanticValidationError
 
@@ -167,16 +172,17 @@ def _validate_meta_file(path: Path, *, project: Project) -> ValidateResult:
     from dataface.core.compile.meta import load_meta_file
     from dataface.core.compile.models.face.patch import FacePatch
 
+    relpath = resolved.relpath
     try:
-        meta_data, _ = load_meta_file(project.path_for_fspath(path))
+        meta_data, _ = load_meta_file(resolved)
     except CompilationError as exc:
         return ValidateResult(
             success=False,
-            path=path,
+            path=Path(relpath),
             errors=[
                 DatafaceError.from_code(
                     ERR_META_SCHEMA, message=str(exc)
-                ).to_diagnostic(file=str(path))
+                ).to_diagnostic(file=relpath)
             ],
         )
 
@@ -191,18 +197,16 @@ def _validate_meta_file(path: Path, *, project: Project) -> ValidateResult:
                     if e["loc"]
                     else e["msg"]
                 ),
-            ).to_diagnostic(file=str(path))
+            ).to_diagnostic(file=relpath)
             for e in exc.errors()
         ]
-        return ValidateResult(success=False, path=path, errors=errors)
+        return ValidateResult(success=False, path=Path(relpath), errors=errors)
 
-    return ValidateResult(success=True, path=path)
+    return ValidateResult(success=True, path=Path(relpath))
 
 
 def validate(path: Path, *, project: Project) -> ValidateResult:
     """Fast YAML schema + cross-reference validation. No warehouse, no execute."""
-    from dataface.core.compile.compiler import compile_file
-
     try:
         resolved = resolve_face_path(path, project)
     except ValueError as exc:
@@ -214,11 +218,18 @@ def validate(path: Path, *, project: Project) -> ValidateResult:
             ],
         )
 
+    return _validate_resolved(resolved, project=project)
+
+
+def _validate_resolved(resolved: ProjectPath, *, project: Project) -> ValidateResult:
+    """Validate an already-resolved face path — no re-resolution."""
+    from dataface.core.compile.compiler import compile_file
+
     if not resolved.exists():
         hint = no_project_hint(project)
         return ValidateResult(
             success=False,
-            path=path,
+            path=Path(resolved.relpath),
             errors=[
                 DatafaceError.from_code(
                     ERR_FILE_NOT_FOUND,
@@ -228,16 +239,15 @@ def validate(path: Path, *, project: Project) -> ValidateResult:
             ],
         )
 
-    resolved_display = project.root / resolved.relpath
-    if resolved_display.name in META_FILENAMES:
-        return _validate_meta_file(resolved_display, project=project)
+    if PurePosixPath(resolved.relpath).name in META_FILENAMES:
+        return _validate_meta_file(resolved)
 
     try:
         result = compile_file(resolved.read_face())
     except OSError as exc:
         return ValidateResult(
             success=False,
-            path=resolved_display,
+            path=Path(resolved.relpath),
             errors=[
                 DatafaceError.from_code(ERR_INTERNAL, message=str(exc)).to_diagnostic(
                     file=resolved.relpath
@@ -248,7 +258,7 @@ def validate(path: Path, *, project: Project) -> ValidateResult:
     errors = list(result.errors)
     return ValidateResult(
         success=len(errors) == 0,
-        path=resolved_display,
+        path=Path(resolved.relpath),
         errors=errors,
         warnings=list(result.warnings),
     )
@@ -297,18 +307,17 @@ def annotate_with_data_lint(
 
     annotated: list[ValidateResult] = []
     for result in results:
+        project_path = project_session.project.path(result.path.as_posix())
         try:
-            project_path = project_session.project.path_for_fspath(result.path)
+            path_exists = project_path.exists()
         except ValueError:
             # Fires for a genuine root-escape (an earlier resolve_face_path
-            # failure) AND for a valid project-relative result.path — e.g. the
-            # original caller-supplied path on a not-found result — whose
-            # cwd-anchored resolution inside path_for_fspath just doesn't land
-            # under project.root. Either way there's nothing to lint through
-            # the seam; keep the result unchanged.
+            # failure) or a not-found result echoing a raw caller-supplied
+            # path that isn't project-relative. Either way there's nothing to
+            # lint through the seam; keep the result unchanged.
             annotated.append(result)
             continue
-        if not project_path.exists():
+        if not path_exists:
             annotated.append(result)
             continue
         alias_msgs = data_alias_errors_for_file(