fix(examples): isolate physical inputs and prompt state

Author: YAO-001

examples/optimization/eval_optimize_loop/eval_loop/artifacts.py

@@ -3,6 +3,8 @@
 from __future__ import annotations
 
 import re
+from collections.abc import Mapping
+from pathlib import Path
 from typing import Any
 
 
@@ -33,3 +35,67 @@ def validate_artifact_component(value: Any, *, context: str) -> str:
     if windows_stem in WINDOWS_RESERVED_NAMES:
         raise ValueError(f"unsafe {context}: {value!r} is reserved on Windows")
     return value
+
+
+def validate_distinct_file_paths(
+    paths: Mapping[str, str | Path],
+    *,
+    context: str,
+) -> None:
+    """Reject aliases using portable case-folding and physical file identity."""
+
+    resolved_keys: dict[str, str] = {}
+    physical_keys: dict[tuple[int, int], str] = {}
+    observed_paths: list[tuple[str, Path, bool]] = []
+    for label, raw_path in paths.items():
+        path = Path(raw_path)
+        try:
+            resolved = path.resolve(strict=False)
+        except OSError as error:
+            raise ValueError(f"{context} {label!r} cannot be resolved: {error}") from error
+
+        portable_key = str(resolved).casefold()
+        previous_label = resolved_keys.get(portable_key)
+        if previous_label is not None:
+            raise ValueError(
+                f"{context} must be different physical files; "
+                f"{previous_label!r} and {label!r} collide case-insensitively"
+            )
+
+        try:
+            metadata = path.stat()
+        except (FileNotFoundError, NotADirectoryError):
+            metadata = None
+        except OSError as error:
+            raise ValueError(f"{context} {label!r} is unavailable: {error}") from error
+
+        physical_key = (
+            (int(metadata.st_dev), int(metadata.st_ino))
+            if metadata is not None and int(metadata.st_ino) != 0
+            else None
+        )
+        if physical_key is not None and physical_key in physical_keys:
+            raise ValueError(
+                f"{context} must be different physical files; "
+                f"{physical_keys[physical_key]!r} and {label!r} are aliases"
+            )
+
+        for observed_label, observed_path, observed_exists in observed_paths:
+            if metadata is None or not observed_exists:
+                continue
+            try:
+                same_file = path.samefile(observed_path)
+            except (FileNotFoundError, NotADirectoryError):
+                same_file = False
+            except OSError as error:
+                raise ValueError(f"{context} {label!r} is unavailable: {error}") from error
+            if same_file:
+                raise ValueError(
+                    f"{context} must be different physical files; "
+                    f"{observed_label!r} and {label!r} are aliases"
+                )
+
+        resolved_keys[portable_key] = label
+        if physical_key is not None:
+            physical_keys[physical_key] = label
+        observed_paths.append((label, path, metadata is not None))

examples/optimization/eval_optimize_loop/eval_loop/backends.py

@@ -13,6 +13,7 @@
 from typing import Protocol
 
 from .diffing import make_unified_diff
+from .artifacts import validate_distinct_file_paths
 from .evaluator import ExampleEvaluator
 from .fake_judge import FakeJudge
 from .fake_model import FakeModel
@@ -532,9 +533,13 @@ def _load_required_call_agent(self, *, for_evaluation: bool):
         return _load_call_agent(self.call_agent_path)
 
     def _target_prompt_paths(self) -> dict[str, str | Path]:
-        if self.target_prompt_paths:
-            return dict(self.target_prompt_paths)
-        return {"system_prompt": self.prompt_path}
+        paths = (
+            dict(self.target_prompt_paths)
+            if self.target_prompt_paths
+            else {"system_prompt": self.prompt_path}
+        )
+        validate_distinct_file_paths(paths, context="SDK target prompt fields")
+        return paths
 
 
 def _required_system_prompt(prompts: dict[str, str], *, context: str) -> str:

examples/optimization/eval_optimize_loop/eval_loop/config.py

@@ -8,6 +8,7 @@
 from pathlib import Path
 from typing import Any
 
+from .artifacts import validate_distinct_file_paths
 from .schemas import EvalCase
 
 
@@ -141,10 +142,10 @@ def validate_inputs(
     validation_cases: list[EvalCase],
     config: OptimizerConfig,
 ) -> None:
-    train_resolved = Path(train_path).resolve()
-    val_resolved = Path(val_path).resolve()
-    if train_resolved == val_resolved:
-        raise ValueError(f"{train_path}: train and validation evalset paths must be different")
+    validate_distinct_file_paths(
+        {"train": train_path, "validation": val_path},
+        context="train and validation evalset paths",
+    )
 
     _validate_cases(train_cases, split="train", path=train_path)
     _validate_cases(validation_cases, split="validation", path=val_path)