omnibase_infra 0.2.6__py3-none-any.whl

omnibase_infra/runtime/projector_plugin_loader.py

@@ -0,0 +1,1462 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Projector Plugin Loader for Contract-Based Discovery.
+
+This module provides ProjectorPluginLoader, which discovers and loads projectors
+from YAML contract definitions. It implements ProtocolProjectorLoader and supports
+two operation modes:
+- Strict mode (default): Raises on first error encountered
+- Graceful mode: Collects errors, continues discovery
+
+Part of OMN-1168: ProjectorPluginLoader contract discovery loading.
+
+Security Features:
+    - File size validation (max 10MB) to prevent memory exhaustion
+    - Symlink protection to prevent path traversal attacks
+    - Path sanitization for safe logging
+    - YAML safe_load to prevent arbitrary code execution
+
+See Also:
+    - ProtocolProjectorLoader: Protocol definition from omnibase_spi
+    - ModelProjectorContract: Contract model from omnibase_core
+    - ProtocolEventProjector: Protocol for loaded projectors
+
+.. versionadded:: 0.7.0
+    Created as part of OMN-1168 projector contract discovery.
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from pathlib import Path
+from typing import TYPE_CHECKING
+from uuid import UUID, uuid4
+
+import asyncpg
+import yaml
+from pydantic import ValidationError
+
+from omnibase_core.container import ModelONEXContainer
+from omnibase_core.enums.enum_core_error_code import EnumCoreErrorCode
+from omnibase_core.models.errors.model_onex_error import ModelOnexError
+from omnibase_core.models.projectors import ModelProjectorContract
+from omnibase_infra.models.projectors import (
+    ModelProjectorDiscoveryResult,
+    ModelProjectorValidationError,
+)
+from omnibase_infra.protocols import (
+    ProtocolEventProjector,
+    ProtocolProjectorSchemaValidator,
+)
+from omnibase_infra.runtime.models import ModelProjectorPluginLoaderConfig
+
+if TYPE_CHECKING:
+    from omnibase_core.models.events.model_event_envelope import ModelEventEnvelope
+    from omnibase_core.models.projectors import ModelProjectionResult
+
+logger = logging.getLogger(__name__)
+
+# Contract file patterns for projector discovery
+PROJECTOR_CONTRACT_PATTERNS = ("*_projector.yaml", "projector_contract.yaml")
+
+# Maximum contract file size (10MB) to prevent memory exhaustion
+MAX_CONTRACT_SIZE = 10 * 1024 * 1024
+
+# Maximum files to discover in a single operation to prevent DoS via filesystem-wide glob scans
+MAX_DISCOVERY_FILES = 10000
+
+
+# =============================================================================
+# ProjectorShell Import (OMN-1169)
+# =============================================================================
+from omnibase_infra.runtime.projector_shell import ProjectorShell
+
+# =============================================================================
+# Placeholder Projector (used when no database pool is provided)
+# =============================================================================
+
+
+class ProjectorShellPlaceholder:
+    """Placeholder projector shell used when no database pool is provided.
+
+    This class provides a stub implementation that holds contract metadata
+    but cannot actually project events. It is used by the loader for
+    discovery-only scenarios where database access is not needed.
+
+    For full projection functionality, provide a database pool to the
+    ProjectorPluginLoader constructor, which will instantiate ProjectorShell.
+
+    Note:
+        The project() and get_state() methods will raise NotImplementedError.
+        Use ProjectorShell with a database pool for actual projections.
+    """
+
+    def __init__(self, contract: ModelProjectorContract) -> None:
+        """Initialize placeholder with contract metadata.
+
+        Args:
+            contract: The parsed and validated projector contract.
+        """
+        self._contract = contract
+        logger.debug(
+            "ProjectorShellPlaceholder loaded for '%s' - "
+            "no database pool provided, projection methods will raise NotImplementedError",
+            contract.projector_id,
+        )
+
+    @property
+    def projector_id(self) -> str:
+        """Unique identifier from contract."""
+        return str(self._contract.projector_id)
+
+    @property
+    def aggregate_type(self) -> str:
+        """Aggregate type from contract."""
+        return str(self._contract.aggregate_type)
+
+    @property
+    def consumed_events(self) -> list[str]:
+        """Event types from contract."""
+        return list(self._contract.consumed_events)
+
+    @property
+    def contract(self) -> ModelProjectorContract:
+        """Access the underlying contract."""
+        return self._contract
+
+    @property
+    def is_placeholder(self) -> bool:
+        """Whether this is a placeholder implementation.
+
+        Returns:
+            True, as this is a placeholder that will raise NotImplementedError
+            on projection methods until OMN-1169 is implemented.
+        """
+        return True
+
+    async def project(
+        self,
+        event: ModelEventEnvelope,
+        correlation_id: UUID,
+    ) -> ModelProjectionResult:
+        """Placeholder - requires database pool for actual projections.
+
+        Args:
+            event: The event envelope to project.
+            correlation_id: Correlation ID for distributed tracing.
+
+        Raises:
+            NotImplementedError: Always, as this is a placeholder without DB access.
+        """
+        raise NotImplementedError(
+            f"ProjectorShellPlaceholder for '{self.projector_id}' cannot project events. "
+            "Provide a database pool to ProjectorPluginLoader to use ProjectorShell."
+        )
+
+    async def get_state(
+        self,
+        aggregate_id: UUID,
+        correlation_id: UUID,
+    ) -> object | None:
+        """Placeholder - requires database pool for state queries.
+
+        Args:
+            aggregate_id: The unique identifier of the aggregate.
+            correlation_id: Correlation ID for distributed tracing.
+
+        Raises:
+            NotImplementedError: Always, as this is a placeholder without DB access.
+        """
+        raise NotImplementedError(
+            f"ProjectorShellPlaceholder for '{self.projector_id}' cannot query state. "
+            "Provide a database pool to ProjectorPluginLoader to use ProjectorShell."
+        )
+
+    def __repr__(self) -> str:
+        """Return string representation."""
+        return (
+            f"ProjectorShellPlaceholder("
+            f"id={self.projector_id!r}, "
+            f"aggregate_type={self.aggregate_type!r}, "
+            f"events={len(self.consumed_events)})"
+        )
+
+
+# =============================================================================
+# ProjectorPluginLoader Implementation
+# Note: ONEX-PATTERN-001 exemption - loader requires multiple discovery methods
+# =============================================================================
+
+
+class ProjectorPluginLoader:
+    """Projector loader that discovers contracts from the filesystem.
+
+    This class implements the projector loader protocol by recursively scanning
+    configured paths for projector contract files, parsing them with YAML and
+    validating against ModelProjectorContract from omnibase_core.
+
+    Protocol Compliance:
+        This class implements the ProtocolProjectorLoader interface with
+        all required methods: load_from_contract(), load_from_directory(),
+        and discover_and_load().
+
+    The loader supports two operation modes:
+    - Strict mode (default): Raises ModelOnexError on first error
+    - Graceful mode: Collects all errors, continues discovery
+
+    Both modes return results for a consistent interface. In strict mode,
+    errors raise exceptions instead of being collected.
+
+    Security Features:
+        - File size validation (max 10MB) to prevent memory exhaustion
+        - Symlink protection to prevent path traversal attacks
+        - Path sanitization for safe logging (no full paths exposed)
+        - YAML safe_load to prevent arbitrary code execution
+
+    Example:
+        >>> # Strict mode loading (raises on error)
+        >>> loader = ProjectorPluginLoader(schema_manager=schema_mgr)
+        >>> projector = await loader.load_from_contract(Path("./orders_projector.yaml"))
+        >>> print(f"Loaded projector: {projector.projector_id}")
+
+        >>> # Graceful mode with error collection
+        >>> config = ModelProjectorPluginLoaderConfig(graceful_mode=True)
+        >>> loader = ProjectorPluginLoader(config=config, schema_manager=schema_mgr)
+        >>> result = await loader.discover_with_errors(Path("./projectors"))
+        >>> print(f"Found {result.success_count} projectors")
+        >>> print(f"Encountered {result.error_count} errors")
+
+    Performance Characteristics:
+        - File system scanning is O(n) where n is total files in paths
+        - YAML parsing is synchronous (consider aiofiles for high-throughput)
+        - Typical performance: 100-500 contracts/second on SSD
+        - Memory: ~1KB per contract retained
+
+    .. versionadded:: 0.7.0
+        Created as part of OMN-1168 projector contract discovery.
+    """
+
+    def __init__(
+        self,
+        config: ModelProjectorPluginLoaderConfig | None = None,
+        container: ModelONEXContainer | None = None,
+        schema_manager: ProtocolProjectorSchemaValidator | None = None,
+        pool: asyncpg.Pool | None = None,
+    ) -> None:
+        """Initialize the projector plugin loader.
+
+        Args:
+            config: Configuration for the loader. If None, uses default settings.
+            container: ONEX container for dependency injection. If provided,
+                can be used to resolve dependencies like schema_manager.
+            schema_manager: Schema validator for validating database schemas.
+                If None, schema validation is skipped during loading.
+            pool: Optional asyncpg connection pool for database access.
+                If provided, loaded projectors will be full ProjectorShell
+                instances capable of actual projections. If None (default),
+                loaded projectors will be ProjectorShellPlaceholder instances
+                that hold contract metadata but cannot perform projections.
+        """
+        self._config = config or ModelProjectorPluginLoaderConfig()
+        self._container = container
+        self._schema_manager = schema_manager
+        if schema_manager is not None:
+            logger.debug("Schema manager provided - will be used for schema validation")
+        self._pool = pool
+        if pool is not None:
+            logger.debug(
+                "Database pool provided - will create ProjectorShell instances"
+            )
+        else:
+            logger.debug(
+                "No database pool provided - will create placeholder instances"
+            )
+        self._graceful_mode = self._config.graceful_mode
+
+        # Security: Validate base_paths don't contain filesystem root
+        # to prevent DoS via filesystem-wide glob scanning
+        base_paths = self._config.base_paths
+        if base_paths:
+            for base_path in base_paths:
+                resolved = base_path.resolve()
+                # Reject root paths (/, /root, C:\, etc.)
+                if resolved == Path("/").resolve() or len(resolved.parts) <= 1:
+                    raise ModelOnexError(
+                        "Root or near-root path not allowed as base_path - "
+                        "would allow filesystem-wide scanning",
+                        error_code=EnumCoreErrorCode.VALIDATION_FAILED,
+                    )
+
+        self._base_paths = base_paths or []
+
+    def _create_projector(
+        self,
+        contract: ModelProjectorContract,
+    ) -> ProtocolEventProjector:
+        """Create a projector instance from a contract.
+
+        If a database pool was provided to the loader, creates a full
+        ProjectorShell instance. Otherwise, creates a placeholder.
+
+        Args:
+            contract: The validated projector contract.
+
+        Returns:
+            Either ProjectorShell (if pool available) or ProjectorShellPlaceholder.
+        """
+        if self._pool is not None:
+            return ProjectorShell(contract, self._pool)
+        return ProjectorShellPlaceholder(contract)
+
+    def _sanitize_path_for_logging(self, path: Path) -> str:
+        """Sanitize a file path for safe inclusion in logs and error messages.
+
+        In production environments, full paths may leak sensitive information
+        about directory structure. This method returns only the filename and
+        parent directory to provide context without exposing full paths.
+
+        Args:
+            path: The full path to sanitize.
+
+        Returns:
+            Sanitized path string showing only parent/filename.
+            For example: "/home/user/code/projectors/orders_projector.yaml"
+            becomes "projectors/orders_projector.yaml".
+        """
+        try:
+            return str(Path(path.parent.name) / path.name)
+        except (ValueError, AttributeError):
+            return path.name
+
+    def _format_file_size(self, size_bytes: int) -> str:
+        """Format file size with KB/MB granularity for safe logging.
+
+        Avoids exposing exact byte counts in error messages which could
+        leak storage implementation details.
+
+        Args:
+            size_bytes: The file size in bytes.
+
+        Returns:
+            Human-readable size string with KB/MB granularity.
+        """
+        if size_bytes < 1024:
+            return "less than 1 KB"
+        elif size_bytes < 1024 * 1024:
+            return f"{size_bytes // 1024} KB"
+        else:
+            return f"{size_bytes / (1024 * 1024):.1f} MB"
+
+    def _is_projector_contract(self, filename: str) -> bool:
+        """Check if a filename matches projector contract patterns.
+
+        Args:
+            filename: The filename to check.
+
+        Returns:
+            True if filename matches any projector contract pattern.
+        """
+        for pattern in PROJECTOR_CONTRACT_PATTERNS:
+            if pattern.startswith("*"):
+                suffix = pattern[1:]
+                if filename.endswith(suffix):
+                    return True
+            elif filename == pattern:
+                return True
+        return False
+
+    def _validate_file_security(
+        self,
+        contract_path: Path,
+        allowed_bases: list[Path],
+    ) -> tuple[bool, str | None]:
+        """Validate file security constraints.
+
+        Checks file size limits and symlink containment.
+
+        Args:
+            contract_path: Path to the contract file.
+            allowed_bases: List of allowed base directories.
+
+        Returns:
+            Tuple of (is_valid, error_message).
+            If valid, error_message is None.
+        """
+        resolved_path = contract_path.resolve()
+
+        # Symlink protection: verify resolved path is within allowed paths
+        if allowed_bases:
+            is_within_allowed = any(
+                resolved_path.is_relative_to(base.resolve()) for base in allowed_bases
+            )
+            if not is_within_allowed:
+                return (
+                    False,
+                    f"Contract file resolves outside allowed paths: {self._sanitize_path_for_logging(contract_path)}",
+                )
+
+        # File size check
+        try:
+            file_size = contract_path.stat().st_size
+            if file_size > MAX_CONTRACT_SIZE:
+                return (
+                    False,
+                    f"Contract file exceeds size limit: {self._format_file_size(file_size)} (max: {MAX_CONTRACT_SIZE // (1024 * 1024)} MB)",
+                )
+        except OSError as e:
+            # Use strerror to avoid leaking full path in error message
+            error_msg = e.strerror or "unknown error"
+            return (False, f"Failed to stat file: {error_msg}")
+
+        return (True, None)
+
+    def _load_contract(self, contract_path: Path) -> ModelProjectorContract:
+        """Parse and validate a contract file.
+
+        Args:
+            contract_path: Path to the projector contract YAML file.
+
+        Returns:
+            Validated ModelProjectorContract instance.
+
+        Raises:
+            ModelOnexError: If file exceeds size limit.
+            yaml.YAMLError: If YAML parsing fails.
+            ValidationError: If contract validation fails.
+            OSError: If file I/O fails.
+        """
+        # Validate file size before reading
+        file_size = contract_path.stat().st_size
+        if file_size > MAX_CONTRACT_SIZE:
+            raise ModelOnexError(
+                f"Contract file exceeds size limit: {self._format_file_size(file_size)} "
+                f"(max: {MAX_CONTRACT_SIZE // (1024 * 1024)} MB)",
+                error_code=EnumCoreErrorCode.VALIDATION_FAILED,
+            )
+
+        with contract_path.open("r", encoding="utf-8") as f:
+            raw_data = yaml.safe_load(f)
+
+        # Strip extension fields not in base ModelProjectorContract.
+        # partial_updates is an extension field for OMN-1170 that defines
+        # partial update operations. It is used by the runtime for optimized
+        # UPDATE statements but is not part of the core contract schema.
+        if isinstance(raw_data, dict):
+            raw_data.pop("partial_updates", None)
+
+            # Handle composite key fields: ModelProjectorContract expects strings,
+            # but the contract YAML uses lists for composite primary/upsert keys.
+            # Convert first element of list to string for model validation.
+            # The full composite key information is preserved in the SQL schema.
+            if isinstance(
+                raw_data.get("projection_schema", {}).get("primary_key"), list
+            ):
+                pk_list = raw_data["projection_schema"]["primary_key"]
+                raw_data["projection_schema"]["primary_key"] = (
+                    pk_list[0] if pk_list else "entity_id"
+                )
+
+            if isinstance(raw_data.get("behavior", {}).get("upsert_key"), list):
+                upsert_list = raw_data["behavior"]["upsert_key"]
+                raw_data["behavior"]["upsert_key"] = (
+                    upsert_list[0] if upsert_list else None
+                )
+
+        # Validate against ModelProjectorContract
+        contract = ModelProjectorContract.model_validate(raw_data)
+        return contract
+
+    def _create_parse_error(
+        self,
+        contract_path: Path,
+        error: yaml.YAMLError,
+        correlation_id: UUID | None = None,
+    ) -> ModelProjectorValidationError:
+        """Create a validation error for YAML parse failures.
+
+        Args:
+            contract_path: Path to the failing contract file.
+            error: The YAML parsing error.
+            correlation_id: Correlation ID for distributed tracing.
+
+        Returns:
+            ModelProjectorValidationError with parse error details.
+        """
+        return ModelProjectorValidationError(
+            error_type="CONTRACT_PARSE_ERROR",
+            contract_path=self._sanitize_path_for_logging(contract_path),
+            message=f"Failed to parse YAML in {self._sanitize_path_for_logging(contract_path)}: {error}",
+            remediation_hint="Check YAML syntax and ensure proper indentation",
+            correlation_id=correlation_id,
+        )
+
+    def _create_validation_error(
+        self,
+        contract_path: Path,
+        error: ValidationError,
+        correlation_id: UUID | None = None,
+    ) -> ModelProjectorValidationError:
+        """Create a validation error for contract validation failures.
+
+        Args:
+            contract_path: Path to the failing contract file.
+            error: The Pydantic validation error.
+            correlation_id: Correlation ID for distributed tracing.
+
+        Returns:
+            ModelProjectorValidationError with validation details.
+        """
+        error_details = error.errors()
+        if error_details:
+            first_error = error_details[0]
+            field_loc = " -> ".join(str(x) for x in first_error.get("loc", ()))
+            error_msg = str(first_error.get("msg", "validation failed"))
+        else:
+            field_loc = "unknown"
+            error_msg = "validation failed"
+
+        return ModelProjectorValidationError(
+            error_type="CONTRACT_VALIDATION_ERROR",
+            contract_path=self._sanitize_path_for_logging(contract_path),
+            message=f"Contract validation failed in {self._sanitize_path_for_logging(contract_path)}: {error_msg} at {field_loc}",
+            remediation_hint=f"Check the '{field_loc}' field in the contract",
+            correlation_id=correlation_id,
+        )
+
+    def _create_size_limit_error(
+        self,
+        contract_path: Path,
+        file_size: int,
+        correlation_id: UUID | None = None,
+    ) -> ModelProjectorValidationError:
+        """Create a validation error for file size limit violations.
+
+        Args:
+            contract_path: Path to the oversized contract file.
+            file_size: The actual file size in bytes.
+            correlation_id: Correlation ID for distributed tracing.
+
+        Returns:
+            ModelProjectorValidationError with size limit details.
+        """
+        return ModelProjectorValidationError(
+            error_type="SIZE_LIMIT_ERROR",
+            contract_path=self._sanitize_path_for_logging(contract_path),
+            message=(
+                f"Contract file {self._sanitize_path_for_logging(contract_path)} exceeds size limit: "
+                f"{self._format_file_size(file_size)} (max: {MAX_CONTRACT_SIZE // (1024 * 1024)} MB)"
+            ),
+            remediation_hint=(
+                f"Reduce contract file size to under {MAX_CONTRACT_SIZE // (1024 * 1024)} MB. "
+                "Consider splitting into multiple contracts if needed."
+            ),
+            correlation_id=correlation_id,
+        )
+
+    def _create_io_error(
+        self,
+        contract_path: Path,
+        error: OSError,
+        correlation_id: UUID | None = None,
+    ) -> ModelProjectorValidationError:
+        """Create a validation error for I/O failures.
+
+        Args:
+            contract_path: Path to the contract file that failed to read.
+            error: The I/O error encountered.
+            correlation_id: Correlation ID for distributed tracing.
+
+        Returns:
+            ModelProjectorValidationError with I/O error details.
+        """
+        # Use strerror to avoid leaking full paths, fallback to generic message
+        error_message = error.strerror or "I/O error occurred"
+
+        return ModelProjectorValidationError(
+            error_type="IO_ERROR",
+            contract_path=self._sanitize_path_for_logging(contract_path),
+            message=f"Failed to read contract file {self._sanitize_path_for_logging(contract_path)}: {error_message}",
+            remediation_hint="Check file permissions and ensure the file exists",
+            correlation_id=correlation_id,
+        )
+
+    def _create_security_error(
+        self,
+        contract_path: Path,
+        message: str,
+        correlation_id: UUID | None = None,
+    ) -> ModelProjectorValidationError:
+        """Create a validation error for security violations.
+
+        Args:
+            contract_path: Path to the contract file.
+            message: Security violation message.
+            correlation_id: Correlation ID for distributed tracing.
+
+        Returns:
+            ModelProjectorValidationError with security error details.
+        """
+        return ModelProjectorValidationError(
+            error_type="SECURITY_ERROR",
+            contract_path=self._sanitize_path_for_logging(contract_path),
+            message=message,
+            remediation_hint="Ensure contract files are within allowed directories and not symlinks to external locations",
+            correlation_id=correlation_id,
+        )
+
+    def _find_contract_files(self, base_path: Path) -> list[Path]:
+        """Find all projector contract files under a base path.
+
+        Uses specific glob patterns (e.g., "*_projector.yaml") to directly
+        discover contract files, avoiding post-filtering overhead. Patterns
+        are already specific enough that additional name validation is
+        redundant after rglob matching.
+
+        Args:
+            base_path: Directory to scan recursively.
+
+        Returns:
+            List of paths to projector contract files, deduplicated.
+        """
+        if base_path.is_file():
+            if self._is_projector_contract(base_path.name):
+                return [base_path]
+            return []
+
+        # Use a set to deduplicate files matched by multiple patterns
+        # (e.g., symlinks or overlapping patterns)
+        discovered: set[Path] = set()
+        for pattern in PROJECTOR_CONTRACT_PATTERNS:
+            # rglob with specific patterns like "*_projector.yaml" already
+            # filters to matching files - no need for redundant name filtering
+            discovered.update(base_path.rglob(pattern))
+
+        return list(discovered)
+
+    def _log_discovery_results(
+        self,
+        discovered_count: int,
+        failure_count: int,
+        duration_seconds: float,
+    ) -> None:
+        """Log discovery results with structured telemetry.
+
+        Args:
+            discovered_count: Number of successfully discovered contracts.
+            failure_count: Number of validation failures.
+            duration_seconds: Total discovery duration in seconds.
+        """
+        contracts_per_sec = (
+            discovered_count / duration_seconds if duration_seconds > 0 else 0.0
+        )
+
+        logger.info(
+            "Projector contract discovery completed: "
+            "discovered_count=%d, failure_count=%d, "
+            "graceful_mode=%s, duration_seconds=%.3f, contracts_per_second=%.1f",
+            discovered_count,
+            failure_count,
+            self._graceful_mode,
+            duration_seconds,
+            contracts_per_sec,
+            extra={
+                "discovered_count": discovered_count,
+                "failure_count": failure_count,
+                "graceful_mode": self._graceful_mode,
+                "duration_seconds": duration_seconds,
+                "contracts_per_second": contracts_per_sec,
+            },
+        )
+
+    async def load_from_contract(
+        self,
+        contract_path: Path,
+    ) -> ProtocolEventProjector:
+        """Load a projector from a YAML contract file.
+
+        Parses the contract, validates its structure and semantics,
+        and returns a configured projector instance.
+
+        Args:
+            contract_path: Path to the YAML contract file. Must exist
+                and be readable.
+
+        Returns:
+            A configured ProtocolEventProjector instance.
+            Note: Currently returns ProjectorShellPlaceholder until
+            OMN-1169 implements the full ProjectorShell.
+
+        Raises:
+            ModelOnexError: If contract parsing or validation fails.
+            FileNotFoundError: If contract_path does not exist.
+            PermissionError: If contract_path is not readable.
+        """
+        if not contract_path.exists():
+            raise FileNotFoundError(
+                f"Contract file does not exist: {self._sanitize_path_for_logging(contract_path)}"
+            )
+
+        # Validate security constraints
+        allowed_bases = self._base_paths if self._base_paths else [contract_path.parent]
+        is_valid, error_msg = self._validate_file_security(contract_path, allowed_bases)
+        if not is_valid:
+            raise ModelOnexError(
+                error_msg or "Security validation failed",
+                error_code=EnumCoreErrorCode.VALIDATION_FAILED,
+            )
+
+        try:
+            contract = self._load_contract(contract_path)
+        except yaml.YAMLError as e:
+            raise ModelOnexError(
+                f"Failed to parse YAML contract at {self._sanitize_path_for_logging(contract_path)}: {e}",
+                error_code=EnumCoreErrorCode.VALIDATION_FAILED,
+            ) from e
+        except ValidationError as e:
+            raise ModelOnexError(
+                f"Contract validation failed at {self._sanitize_path_for_logging(contract_path)}: {e}",
+                error_code=EnumCoreErrorCode.VALIDATION_FAILED,
+            ) from e
+        except OSError as e:
+            raise ModelOnexError(
+                f"Failed to read contract file at {self._sanitize_path_for_logging(contract_path)}: {e.strerror or e}",
+                error_code=EnumCoreErrorCode.VALIDATION_FAILED,
+            ) from e
+
+        logger.debug(
+            "Successfully loaded projector contract: %s",
+            self._sanitize_path_for_logging(contract_path),
+            extra={
+                "contract_path": self._sanitize_path_for_logging(contract_path),
+                "projector_id": contract.projector_id,
+                "aggregate_type": contract.aggregate_type,
+                "consumed_events": contract.consumed_events,
+            },
+        )
+
+        # Return placeholder until OMN-1169 implements ProjectorShell
+        return self._create_projector(contract)
+
+    async def load_from_directory(
+        self,
+        directory: Path,
+    ) -> list[ProtocolEventProjector]:
+        """Load all projectors from contracts in a directory.
+
+        Discovers all projector contract files in the specified directory
+        (recursively) and loads each as a projector.
+
+        Args:
+            directory: Directory containing contract files. Must exist
+                and be a directory.
+
+        Returns:
+            List of configured ProtocolEventProjector instances, one for
+            each valid contract file found.
+
+        Raises:
+            FileNotFoundError: If directory does not exist.
+            NotADirectoryError: If directory is not a directory.
+            ModelOnexError: If any contract file is invalid (in strict mode).
+        """
+        if not directory.exists():
+            raise FileNotFoundError(
+                f"Directory does not exist: {self._sanitize_path_for_logging(directory)}"
+            )
+
+        if not directory.is_dir():
+            raise NotADirectoryError(
+                f"Path is not a directory: {self._sanitize_path_for_logging(directory)}"
+            )
+
+        # Generate correlation_id for this discovery operation
+        discovery_correlation_id = uuid4()
+
+        start_time = time.perf_counter()
+        projectors: list[ProtocolEventProjector] = []
+        validation_errors: list[ModelProjectorValidationError] = []
+        discovered_paths: set[Path] = set()
+
+        allowed_bases = self._base_paths if self._base_paths else [directory]
+        contract_files = self._find_contract_files(directory)
+
+        logger.debug(
+            "Scanning directory for projector contracts: %s",
+            self._sanitize_path_for_logging(directory),
+            extra={
+                "directory": self._sanitize_path_for_logging(directory),
+                "contracts_found": len(contract_files),
+                "graceful_mode": self._graceful_mode,
+                "correlation_id": str(discovery_correlation_id),
+            },
+        )
+
+        for contract_file in contract_files:
+            resolved_path = contract_file.resolve()
+            if resolved_path in discovered_paths:
+                continue
+
+            discovered_paths.add(resolved_path)
+
+            # Security validation
+            is_valid, error_msg = self._validate_file_security(
+                contract_file, allowed_bases
+            )
+            if not is_valid:
+                if not self._graceful_mode:
+                    raise ModelOnexError(
+                        error_msg or "Security validation failed",
+                        error_code=EnumCoreErrorCode.VALIDATION_FAILED,
+                    )
+                logger.warning(
+                    "Security validation failed for %s, skipping",
+                    self._sanitize_path_for_logging(contract_file),
+                    extra={
+                        "contract_file": self._sanitize_path_for_logging(contract_file),
+                        "graceful_mode": self._graceful_mode,
+                        "correlation_id": str(discovery_correlation_id),
+                    },
+                )
+                validation_errors.append(
+                    self._create_security_error(
+                        contract_file, error_msg or "", discovery_correlation_id
+                    )
+                )
+                continue
+
+            try:
+                contract = self._load_contract(contract_file)
+                projector = self._create_projector(contract)
+                projectors.append(projector)
+                logger.debug(
+                    "Successfully parsed contract: %s",
+                    self._sanitize_path_for_logging(contract_file),
+                    extra={
+                        "contract_file": self._sanitize_path_for_logging(contract_file),
+                        "projector_id": contract.projector_id,
+                        "aggregate_type": contract.aggregate_type,
+                    },
+                )
+            except yaml.YAMLError as e:
+                error = self._create_parse_error(
+                    contract_file, e, discovery_correlation_id
+                )
+                if not self._graceful_mode:
+                    raise ModelOnexError(
+                        f"Failed to parse YAML contract at {self._sanitize_path_for_logging(contract_file)}: {e}",
+                        error_code=EnumCoreErrorCode.VALIDATION_FAILED,
+                    ) from e
+                logger.warning(
+                    "Failed to parse YAML contract in %s, continuing in graceful mode",
+                    self._sanitize_path_for_logging(contract_file),
+                    extra={
+                        "contract_file": self._sanitize_path_for_logging(contract_file),
+                        "error_type": "yaml_parse_error",
+                        "graceful_mode": self._graceful_mode,
+                        "correlation_id": str(discovery_correlation_id),
+                    },
+                )
+                validation_errors.append(error)
+            except ValidationError as e:
+                error = self._create_validation_error(
+                    contract_file, e, discovery_correlation_id
+                )
+                if not self._graceful_mode:
+                    raise ModelOnexError(
+                        f"Contract validation failed at {self._sanitize_path_for_logging(contract_file)}: {e}",
+                        error_code=EnumCoreErrorCode.VALIDATION_FAILED,
+                    ) from e
+                logger.warning(
+                    "Contract validation failed in %s, continuing in graceful mode",
+                    self._sanitize_path_for_logging(contract_file),
+                    extra={
+                        "contract_file": self._sanitize_path_for_logging(contract_file),
+                        "error_type": "validation_error",
+                        "error_count": len(e.errors()),
+                        "graceful_mode": self._graceful_mode,
+                        "correlation_id": str(discovery_correlation_id),
+                    },
+                )
+                validation_errors.append(error)
+            except ModelOnexError as e:
+                # In strict mode, always re-raise
+                if not self._graceful_mode:
+                    raise
+
+                # Graceful mode: collect all ONEX errors
+                error_code = getattr(e, "error_code", None)
+                error_message = str(e)
+                # Check specifically for size limit errors by both error_code AND message
+                is_size_limit_error = (
+                    error_code == EnumCoreErrorCode.VALIDATION_FAILED
+                    and "size limit" in error_message.lower()
+                )
+                if is_size_limit_error:
+                    # File size limit error
+                    try:
+                        file_size = contract_file.stat().st_size
+                    except OSError:
+                        file_size = 0
+                    error = self._create_size_limit_error(
+                        contract_file, file_size, discovery_correlation_id
+                    )
+                    logger.warning(
+                        "Contract file %s exceeds size limit, continuing in graceful mode",
+                        self._sanitize_path_for_logging(contract_file),
+                        extra={
+                            "contract_file": self._sanitize_path_for_logging(
+                                contract_file
+                            ),
+                            "error_type": "size_limit_error",
+                            "graceful_mode": self._graceful_mode,
+                            "correlation_id": str(discovery_correlation_id),
+                        },
+                    )
+                    validation_errors.append(error)
+                else:
+                    # Other ONEX errors - collect in graceful mode
+                    error = ModelProjectorValidationError(
+                        error_type="ONEX_ERROR",
+                        contract_path=self._sanitize_path_for_logging(contract_file),
+                        message=error_message,
+                        remediation_hint="Check the contract file for issues",
+                        correlation_id=discovery_correlation_id,
+                    )
+                    logger.warning(
+                        "ONEX error processing %s, continuing in graceful mode",
+                        self._sanitize_path_for_logging(contract_file),
+                        extra={
+                            "contract_file": self._sanitize_path_for_logging(
+                                contract_file
+                            ),
+                            "error_type": "onex_error",
+                            "graceful_mode": self._graceful_mode,
+                            "correlation_id": str(discovery_correlation_id),
+                        },
+                    )
+                    validation_errors.append(error)
+            except OSError as e:
+                if not self._graceful_mode:
+                    raise ModelOnexError(
+                        f"Failed to read contract file at {self._sanitize_path_for_logging(contract_file)}: {e}",
+                        error_code=EnumCoreErrorCode.VALIDATION_FAILED,
+                    ) from e
+                error = self._create_io_error(
+                    contract_file, e, discovery_correlation_id
+                )
+                logger.warning(
+                    "Failed to read contract file, continuing in graceful mode: %s",
+                    self._sanitize_path_for_logging(contract_file),
+                    extra={
+                        "contract_file": self._sanitize_path_for_logging(contract_file),
+                        "error_type": "io_error",
+                        # Use strerror to avoid leaking full paths
+                        "error_message": e.strerror or "unknown error",
+                        "graceful_mode": self._graceful_mode,
+                        "correlation_id": str(discovery_correlation_id),
+                    },
+                )
+                validation_errors.append(error)
+
+        duration_seconds = time.perf_counter() - start_time
+        self._log_discovery_results(
+            len(projectors), len(validation_errors), duration_seconds
+        )
+
+        return projectors
+
+    async def discover_and_load(
+        self,
+        patterns: list[str],
+    ) -> list[ProtocolEventProjector]:
+        """Discover contracts matching glob patterns and load projectors.
+
+        Supports flexible contract discovery using glob patterns,
+        enabling contracts to be organized in various directory structures.
+
+        Args:
+            patterns: List of glob patterns to match contract files.
+                Patterns are relative to the current working directory
+                unless absolute. Supports recursive patterns (**).
+
+                Examples:
+                - "contracts/*.yaml" - all YAML in contracts/
+                - "**/projectors/*.yaml" - recursive projector discovery
+                - "modules/*/projections.yml" - per-module contracts
+
+        Returns:
+            List of configured ProtocolEventProjector instances for all
+            contracts matching any of the patterns. Duplicates (same
+            file matched by multiple patterns) are deduplicated.
+
+        Raises:
+            ModelOnexError: If any matched contract is invalid (in strict mode).
+        """
+        # Generate correlation_id for this discovery operation
+        discovery_correlation_id = uuid4()
+
+        start_time = time.perf_counter()
+        projectors: list[ProtocolEventProjector] = []
+        validation_errors: list[ModelProjectorValidationError] = []
+        discovered_paths: set[Path] = set()
+
+        # Determine base paths from patterns for security validation
+        cwd = Path.cwd()
+        allowed_bases = self._base_paths if self._base_paths else [cwd]
+
+        logger.debug(
+            "Starting projector discovery with patterns",
+            extra={
+                "patterns": patterns,
+                "graceful_mode": self._graceful_mode,
+                "cwd": self._sanitize_path_for_logging(cwd),
+                "correlation_id": str(discovery_correlation_id),
+            },
+        )
+
+        # Phase 1: Collect all matched files from all patterns (for count-based DoS prevention)
+        unique_contract_files: list[Path] = []
+        seen_resolved: set[Path] = set()
+
+        for pattern in patterns:
+            pattern_path = Path(pattern)
+
+            # Use glob from cwd for relative patterns
+            if not pattern_path.is_absolute():
+                # Security: If base_paths is configured, ensure cwd is within allowed paths
+                # to prevent bypassing path restrictions with relative patterns
+                if self._base_paths:
+                    cwd_resolved = cwd.resolve()
+                    cwd_allowed = any(
+                        cwd_resolved.is_relative_to(base.resolve())
+                        for base in self._base_paths
+                    )
+                    if not cwd_allowed:
+                        raise ModelOnexError(
+                            "Relative patterns require cwd to be within allowed base_paths",
+                            error_code=EnumCoreErrorCode.VALIDATION_FAILED,
+                        )
+                matched_files = list(cwd.glob(pattern))
+            else:
+                # Reject absolute glob patterns unless explicit base_paths configured
+                if not self._base_paths:
+                    raise ModelOnexError(
+                        "Absolute glob patterns are not allowed without explicit base_paths",
+                        error_code=EnumCoreErrorCode.VALIDATION_FAILED,
+                    )
+
+                # Security: Explicitly reject patterns starting from root
+                # to prevent DoS via filesystem-wide glob scanning (e.g., "/**/foo.yaml")
+                pattern_resolved = pattern_path.resolve()
+                if (
+                    pattern_resolved == Path("/").resolve()
+                    or len(pattern_resolved.parts) <= 1
+                ):
+                    raise ModelOnexError(
+                        "Root-level absolute patterns are not allowed - "
+                        "would cause filesystem-wide scanning",
+                        error_code=EnumCoreErrorCode.VALIDATION_FAILED,
+                    )
+
+                # Security: Validate absolute pattern is under an allowed base path
+                # to prevent DoS via filesystem-wide glob scanning
+                allowed_base = None
+                for base in self._base_paths:
+                    try:
+                        base_resolved = base.resolve()
+                        # Check if pattern starts within this base (for glob patterns,
+                        # check the non-glob prefix)
+                        pattern_prefix = pattern_resolved
+                        # Find the first glob component to get the concrete prefix
+                        pattern_parts = pattern_path.parts
+                        concrete_parts: list[str] = []
+                        for part in pattern_parts:
+                            if "*" in part or "?" in part or "[" in part:
+                                break
+                            concrete_parts.append(part)
+                        if concrete_parts:
+                            pattern_prefix = Path(*concrete_parts).resolve()
+
+                        if pattern_prefix.is_relative_to(base_resolved):
+                            allowed_base = base_resolved
+                            break
+                    except (ValueError, OSError):
+                        continue
+
+                if allowed_base is None:
+                    raise ModelOnexError(
+                        "Absolute pattern not under allowed base_paths",
+                        error_code=EnumCoreErrorCode.VALIDATION_FAILED,
+                    )
+
+                # Glob from the allowed base, using relative pattern portion
+                try:
+                    # Use the resolved pattern_prefix (non-glob prefix) to compute
+                    # the relative path, then reconstruct the pattern
+                    relative_prefix = pattern_prefix.relative_to(allowed_base)
+                    # Get the glob suffix (parts after the concrete prefix)
+                    glob_suffix_parts = pattern_path.parts[len(concrete_parts) :]
+                    if glob_suffix_parts:
+                        relative_pattern = str(
+                            relative_prefix / Path(*glob_suffix_parts)
+                        )
+                    else:
+                        relative_pattern = str(relative_prefix)
+                except ValueError:
+                    # If relative_to fails even after is_relative_to succeeded,
+                    # this indicates a path resolution issue (e.g., symlinks)
+                    # Reject the pattern to prevent potential security bypass
+                    raise ModelOnexError(
+                        "Absolute pattern path resolution failed - "
+                        "possible symlink security issue",
+                        error_code=EnumCoreErrorCode.VALIDATION_FAILED,
+                    ) from None
+
+                matched_files = list(allowed_base.glob(relative_pattern))
+
+            # Filter to projector contracts
+            matched_files = [
+                f for f in matched_files if self._is_projector_contract(f.name)
+            ]
+
+            # Collect unique files (deduplicate by resolved path)
+            for contract_file in matched_files:
+                resolved_path = contract_file.resolve()
+                if resolved_path not in seen_resolved:
+                    seen_resolved.add(resolved_path)
+                    unique_contract_files.append(contract_file)
+
+        # Phase 2: Check file count to prevent DoS via expensive glob patterns
+        total_matched = len(unique_contract_files)
+        if total_matched > MAX_DISCOVERY_FILES:
+            raise ModelOnexError(
+                f"Discovery aborted: matched {total_matched} files (limit: {MAX_DISCOVERY_FILES}). "
+                "Use more specific patterns to reduce scope.",
+                error_code=EnumCoreErrorCode.VALIDATION_FAILED,
+            )
+
+        logger.debug(
+            "Discovery matched %d unique contract files",
+            total_matched,
+            extra={
+                "total_matched": total_matched,
+                "max_allowed": MAX_DISCOVERY_FILES,
+                "correlation_id": str(discovery_correlation_id),
+            },
+        )
+
+        # Phase 3: Process each collected file
+        for contract_file in unique_contract_files:
+            resolved_path = contract_file.resolve()
+            discovered_paths.add(resolved_path)
+
+            # Security validation
+            is_valid, error_msg = self._validate_file_security(
+                contract_file, allowed_bases
+            )
+            if not is_valid:
+                if not self._graceful_mode:
+                    raise ModelOnexError(
+                        error_msg or "Security validation failed",
+                        error_code=EnumCoreErrorCode.VALIDATION_FAILED,
+                    )
+                logger.warning(
+                    "Security validation failed for %s, skipping",
+                    self._sanitize_path_for_logging(contract_file),
+                    extra={"correlation_id": str(discovery_correlation_id)},
+                )
+                validation_errors.append(
+                    self._create_security_error(
+                        contract_file, error_msg or "", discovery_correlation_id
+                    )
+                )
+                continue
+
+            try:
+                contract = self._load_contract(contract_file)
+                projector = self._create_projector(contract)
+                projectors.append(projector)
+                logger.debug(
+                    "Successfully loaded contract from pattern: %s",
+                    self._sanitize_path_for_logging(contract_file),
+                    extra={
+                        "contract_file": self._sanitize_path_for_logging(contract_file),
+                        "projector_id": contract.projector_id,
+                        "correlation_id": str(discovery_correlation_id),
+                    },
+                )
+            except yaml.YAMLError as e:
+                error = self._create_parse_error(
+                    contract_file, e, discovery_correlation_id
+                )
+                if not self._graceful_mode:
+                    raise ModelOnexError(
+                        f"Failed to parse YAML contract at {self._sanitize_path_for_logging(contract_file)}: {e}",
+                        error_code=EnumCoreErrorCode.VALIDATION_FAILED,
+                    ) from e
+                validation_errors.append(error)
+            except ValidationError as e:
+                error = self._create_validation_error(
+                    contract_file, e, discovery_correlation_id
+                )
+                if not self._graceful_mode:
+                    raise ModelOnexError(
+                        f"Contract validation failed at {self._sanitize_path_for_logging(contract_file)}: {e}",
+                        error_code=EnumCoreErrorCode.VALIDATION_FAILED,
+                    ) from e
+                validation_errors.append(error)
+            except ModelOnexError as e:
+                # In strict mode, always re-raise
+                if not self._graceful_mode:
+                    raise
+
+                # Graceful mode: collect all ONEX errors
+                error_code = getattr(e, "error_code", None)
+                error_message = str(e)
+                # Check specifically for size limit errors by both error_code AND message
+                is_size_limit_error = (
+                    error_code == EnumCoreErrorCode.VALIDATION_FAILED
+                    and "size limit" in error_message.lower()
+                )
+                if is_size_limit_error:
+                    try:
+                        file_size = contract_file.stat().st_size
+                    except OSError:
+                        file_size = 0
+                    validation_errors.append(
+                        self._create_size_limit_error(
+                            contract_file, file_size, discovery_correlation_id
+                        )
+                    )
+                else:
+                    # Other ONEX errors - collect in graceful mode
+                    validation_errors.append(
+                        ModelProjectorValidationError(
+                            error_type="ONEX_ERROR",
+                            contract_path=self._sanitize_path_for_logging(
+                                contract_file
+                            ),
+                            message=error_message,
+                            remediation_hint="Check the contract file for issues",
+                            correlation_id=discovery_correlation_id,
+                        )
+                    )
+            except OSError as e:
+                if not self._graceful_mode:
+                    raise ModelOnexError(
+                        f"Failed to read contract file at {self._sanitize_path_for_logging(contract_file)}: {e}",
+                        error_code=EnumCoreErrorCode.VALIDATION_FAILED,
+                    ) from e
+                validation_errors.append(
+                    self._create_io_error(contract_file, e, discovery_correlation_id)
+                )
+
+        duration_seconds = time.perf_counter() - start_time
+        self._log_discovery_results(
+            len(projectors), len(validation_errors), duration_seconds
+        )
+
+        return projectors
+
+    async def discover_with_errors(
+        self,
+        directory: Path,
+    ) -> ModelProjectorDiscoveryResult:
+        """Discover projectors and return both successes and errors.
+
+        This method always operates in graceful mode, collecting all
+        errors rather than raising on the first failure.
+
+        Args:
+            directory: Directory to scan for contract files.
+
+        Returns:
+            ModelProjectorDiscoveryResult containing both loaded projectors
+            and validation errors.
+
+        Raises:
+            FileNotFoundError: If directory does not exist.
+            NotADirectoryError: If directory is not a directory.
+        """
+        if not directory.exists():
+            raise FileNotFoundError(
+                f"Directory does not exist: {self._sanitize_path_for_logging(directory)}"
+            )
+
+        if not directory.is_dir():
+            raise NotADirectoryError(
+                f"Path is not a directory: {self._sanitize_path_for_logging(directory)}"
+            )
+
+        # Generate correlation_id for this discovery operation
+        discovery_correlation_id = uuid4()
+
+        start_time = time.perf_counter()
+        projectors: list[ProtocolEventProjector] = []
+        validation_errors: list[ModelProjectorValidationError] = []
+        discovered_paths: set[Path] = set()
+
+        allowed_bases = self._base_paths if self._base_paths else [directory]
+        contract_files = self._find_contract_files(directory)
+
+        logger.debug(
+            "Scanning directory for projector contracts with error collection: %s",
+            self._sanitize_path_for_logging(directory),
+            extra={
+                "directory": self._sanitize_path_for_logging(directory),
+                "contracts_found": len(contract_files),
+                "correlation_id": str(discovery_correlation_id),
+            },
+        )
+
+        for contract_file in contract_files:
+            resolved_path = contract_file.resolve()
+            if resolved_path in discovered_paths:
+                continue
+
+            discovered_paths.add(resolved_path)
+
+            # Security validation
+            is_valid, error_msg = self._validate_file_security(
+                contract_file, allowed_bases
+            )
+            if not is_valid:
+                logger.warning(
+                    "Security validation failed for %s, collecting error",
+                    self._sanitize_path_for_logging(contract_file),
+                    extra={
+                        "contract_file": self._sanitize_path_for_logging(contract_file),
+                        "correlation_id": str(discovery_correlation_id),
+                    },
+                )
+                validation_errors.append(
+                    self._create_security_error(
+                        contract_file, error_msg or "", discovery_correlation_id
+                    )
+                )
+                continue
+
+            try:
+                contract = self._load_contract(contract_file)
+                projector = self._create_projector(contract)
+                projectors.append(projector)
+                logger.debug(
+                    "Successfully parsed contract: %s",
+                    self._sanitize_path_for_logging(contract_file),
+                    extra={
+                        "contract_file": self._sanitize_path_for_logging(contract_file),
+                        "projector_id": contract.projector_id,
+                        "aggregate_type": contract.aggregate_type,
+                        "correlation_id": str(discovery_correlation_id),
+                    },
+                )
+            except yaml.YAMLError as e:
+                error = self._create_parse_error(
+                    contract_file, e, discovery_correlation_id
+                )
+                logger.warning(
+                    "Failed to parse YAML contract in %s, collecting error",
+                    self._sanitize_path_for_logging(contract_file),
+                    extra={
+                        "contract_file": self._sanitize_path_for_logging(contract_file),
+                        "error_type": "yaml_parse_error",
+                        "correlation_id": str(discovery_correlation_id),
+                    },
+                )
+                validation_errors.append(error)
+            except ValidationError as e:
+                error = self._create_validation_error(
+                    contract_file, e, discovery_correlation_id
+                )
+                logger.warning(
+                    "Contract validation failed in %s, collecting error",
+                    self._sanitize_path_for_logging(contract_file),
+                    extra={
+                        "contract_file": self._sanitize_path_for_logging(contract_file),
+                        "error_type": "validation_error",
+                        "error_count": len(e.errors()),
+                        "correlation_id": str(discovery_correlation_id),
+                    },
+                )
+                validation_errors.append(error)
+            except ModelOnexError as e:
+                error_code = getattr(e, "error_code", None)
+                error_message = str(e)
+                # Check specifically for size limit errors by both error_code AND message
+                is_size_limit_error = (
+                    error_code == EnumCoreErrorCode.VALIDATION_FAILED
+                    and "size limit" in error_message.lower()
+                )
+                if is_size_limit_error:
+                    # File size limit error
+                    try:
+                        file_size = contract_file.stat().st_size
+                    except OSError:
+                        file_size = 0
+                    error = self._create_size_limit_error(
+                        contract_file, file_size, discovery_correlation_id
+                    )
+                    logger.warning(
+                        "Contract file %s exceeds size limit, collecting error",
+                        self._sanitize_path_for_logging(contract_file),
+                        extra={
+                            "contract_file": self._sanitize_path_for_logging(
+                                contract_file
+                            ),
+                            "error_type": "size_limit_error",
+                            "correlation_id": str(discovery_correlation_id),
+                        },
+                    )
+                    validation_errors.append(error)
+                else:
+                    # For other ModelOnexError types, create a generic validation error
+                    error = ModelProjectorValidationError(
+                        error_type="ONEX_ERROR",
+                        contract_path=self._sanitize_path_for_logging(contract_file),
+                        message=error_message,
+                        remediation_hint="Check the contract file for issues",
+                        correlation_id=discovery_correlation_id,
+                    )
+                    validation_errors.append(error)
+            except OSError as e:
+                error = self._create_io_error(
+                    contract_file, e, discovery_correlation_id
+                )
+                logger.warning(
+                    "Failed to read contract file, collecting error: %s",
+                    self._sanitize_path_for_logging(contract_file),
+                    extra={
+                        "contract_file": self._sanitize_path_for_logging(contract_file),
+                        "error_type": "io_error",
+                        # Use strerror to avoid leaking full paths
+                        "error_message": e.strerror or "unknown error",
+                        "correlation_id": str(discovery_correlation_id),
+                    },
+                )
+                validation_errors.append(error)
+
+        duration_seconds = time.perf_counter() - start_time
+        self._log_discovery_results(
+            len(projectors), len(validation_errors), duration_seconds
+        )
+
+        return ModelProjectorDiscoveryResult(
+            projectors=projectors,
+            validation_errors=validation_errors,
+            discovery_correlation_id=discovery_correlation_id,
+        )
+
+
+__all__ = [
+    "MAX_CONTRACT_SIZE",
+    "MAX_DISCOVERY_FILES",
+    "ModelProjectorDiscoveryResult",  # Re-exported from omnibase_infra.models.projectors
+    "ModelProjectorValidationError",  # Re-exported from omnibase_infra.models.projectors
+    "PROJECTOR_CONTRACT_PATTERNS",
+    "ProjectorPluginLoader",
+    "ProjectorShell",  # Full implementation with database access (OMN-1169)
+    "ProjectorShellPlaceholder",  # Placeholder when no pool is provided
+    "ProtocolEventProjector",  # Re-exported from omnibase_infra.protocols
+    "ProtocolProjectorSchemaValidator",  # Re-exported from omnibase_infra.protocols
+]