Feature: Services __init__ lazy-import coverage (round 3)
  Exercise the lazy-loading __getattr__ in
  cleveragents.application.services.__init__ so that the previously
  uncovered lines (561-562, 564-565, 567-569) and the AttributeError
  branch are executed at runtime.

  # ---------- acms_advanced_strategies submodule ----------
  Scenario: svcov3 lazy-load ArceStrategy
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "ArceStrategy"
    Then svcov3 the attribute "ArceStrategy" should be resolved

  Scenario: svcov3 lazy-load PlanDecisionContextStrategy
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "PlanDecisionContextStrategy"
    Then svcov3 the attribute "PlanDecisionContextStrategy" should be resolved

  Scenario: svcov3 lazy-load TemporalArchaeologyStrategy
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "TemporalArchaeologyStrategy"
    Then svcov3 the attribute "TemporalArchaeologyStrategy" should be resolved

  # ---------- acms_phase2 submodule ----------
  Scenario: svcov3 lazy-load ContentHashDeduplicator
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "ContentHashDeduplicator"
    Then svcov3 the attribute "ContentHashDeduplicator" should be resolved

  Scenario: svcov3 lazy-load GreedyKnapsackPacker
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "GreedyKnapsackPacker"
    Then svcov3 the attribute "GreedyKnapsackPacker" should be resolved

  Scenario: svcov3 lazy-load MaxDepthResolver
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "MaxDepthResolver"
    Then svcov3 the attribute "MaxDepthResolver" should be resolved

  Scenario: svcov3 lazy-load ScorerWeights
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "ScorerWeights"
    Then svcov3 the attribute "ScorerWeights" should be resolved

  Scenario: svcov3 lazy-load WeightedCompositeScorer
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "WeightedCompositeScorer"
    Then svcov3 the attribute "WeightedCompositeScorer" should be resolved

  # ---------- acms_phase3 submodule ----------
  Scenario: svcov3 lazy-load ProvenancePreambleGenerator
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "ProvenancePreambleGenerator"
    Then svcov3 the attribute "ProvenancePreambleGenerator" should be resolved

  Scenario: svcov3 lazy-load RelevanceCoherenceOrderer
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "RelevanceCoherenceOrderer"
    Then svcov3 the attribute "RelevanceCoherenceOrderer" should be resolved

  # ---------- audit_event_subscriber ----------
  Scenario: svcov3 lazy-load AuditEventSubscriber
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "AuditEventSubscriber"
    Then svcov3 the attribute "AuditEventSubscriber" should be resolved

  # ---------- autonomy_controller ----------
  Scenario: svcov3 lazy-load AutonomyController
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "AutonomyController"
    Then svcov3 the attribute "AutonomyController" should be resolved

  # ---------- autonomy_guardrail_service ----------
  Scenario: svcov3 lazy-load AutonomyGuardrailService
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "AutonomyGuardrailService"
    Then svcov3 the attribute "AutonomyGuardrailService" should be resolved

  # ---------- config_service ----------
  Scenario: svcov3 lazy-load ConfigEntry
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "ConfigEntry"
    Then svcov3 the attribute "ConfigEntry" should be resolved

  Scenario: svcov3 lazy-load ConfigLevel
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "ConfigLevel"
    Then svcov3 the attribute "ConfigLevel" should be resolved

  Scenario: svcov3 lazy-load ConfigService
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "ConfigService"
    Then svcov3 the attribute "ConfigService" should be resolved

  Scenario: svcov3 lazy-load ResolvedValue
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "ResolvedValue"
    Then svcov3 the attribute "ResolvedValue" should be resolved

  # ---------- context_strategies ----------
  Scenario: svcov3 lazy-load BreadthDepthNavigatorStrategy
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "BreadthDepthNavigatorStrategy"
    Then svcov3 the attribute "BreadthDepthNavigatorStrategy" should be resolved

  Scenario: svcov3 lazy-load SemanticEmbeddingStrategy
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "SemanticEmbeddingStrategy"
    Then svcov3 the attribute "SemanticEmbeddingStrategy" should be resolved

  Scenario: svcov3 lazy-load SimpleKeywordStrategy
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "SimpleKeywordStrategy"
    Then svcov3 the attribute "SimpleKeywordStrategy" should be resolved

  # ---------- correction_service ----------
  Scenario: svcov3 lazy-load CorrectionService
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "CorrectionService"
    Then svcov3 the attribute "CorrectionService" should be resolved

  # ---------- cost_budget_service ----------
  Scenario: svcov3 lazy-load CostBudgetService
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "CostBudgetService"
    Then svcov3 the attribute "CostBudgetService" should be resolved

  # ---------- cross_plan_correction_service ----------
  Scenario: svcov3 lazy-load CrossPlanCorrectionService
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "CrossPlanCorrectionService"
    Then svcov3 the attribute "CrossPlanCorrectionService" should be resolved

  # ---------- decision_service ----------
  Scenario: svcov3 lazy-load DecisionNotFoundError
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "DecisionNotFoundError"
    Then svcov3 the attribute "DecisionNotFoundError" should be resolved

  Scenario: svcov3 lazy-load DecisionService
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "DecisionService"
    Then svcov3 the attribute "DecisionService" should be resolved

  Scenario: svcov3 lazy-load DuplicateDecisionError
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "DuplicateDecisionError"
    Then svcov3 the attribute "DuplicateDecisionError" should be resolved

  Scenario: svcov3 lazy-load SequenceConflictError
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "SequenceConflictError"
    Then svcov3 the attribute "SequenceConflictError" should be resolved

  Scenario: svcov3 lazy-load SnapshotStore
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "SnapshotStore"
    Then svcov3 the attribute "SnapshotStore" should be resolved

  # ---------- decomposition_clustering ----------
  Scenario: svcov3 lazy-load ClusteringStrategy
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "ClusteringStrategy"
    Then svcov3 the attribute "ClusteringStrategy" should be resolved

  # ---------- decomposition_graph ----------
  Scenario: svcov3 lazy-load DependencyClosureComputer
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "DependencyClosureComputer"
    Then svcov3 the attribute "DependencyClosureComputer" should be resolved

  # ---------- decomposition_models ----------
  Scenario: svcov3 lazy-load ClusterStrategy
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "ClusterStrategy"
    Then svcov3 the attribute "ClusterStrategy" should be resolved

  Scenario: svcov3 lazy-load DecompositionConfig
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "DecompositionConfig"
    Then svcov3 the attribute "DecompositionConfig" should be resolved

  Scenario: svcov3 lazy-load DecompositionNode
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "DecompositionNode"
    Then svcov3 the attribute "DecompositionNode" should be resolved

  Scenario: svcov3 lazy-load DecompositionResult
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "DecompositionResult"
    Then svcov3 the attribute "DecompositionResult" should be resolved

  Scenario: svcov3 lazy-load DependencyEdge
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "DependencyEdge"
    Then svcov3 the attribute "DependencyEdge" should be resolved

  Scenario: svcov3 lazy-load DependencyGraph
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "DependencyGraph"
    Then svcov3 the attribute "DependencyGraph" should be resolved

  Scenario: svcov3 lazy-load DependencyType
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "DependencyType"
    Then svcov3 the attribute "DependencyType" should be resolved

  # ---------- decomposition_service ----------
  Scenario: svcov3 lazy-load DecompositionService
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "DecompositionService"
    Then svcov3 the attribute "DecompositionService" should be resolved

  # ---------- execution_environment_resolver ----------
  Scenario: svcov3 lazy-load ContainerUnavailableError
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "ContainerUnavailableError"
    Then svcov3 the attribute "ContainerUnavailableError" should be resolved

  Scenario: svcov3 lazy-load ExecutionEnvironmentResolver
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "ExecutionEnvironmentResolver"
    Then svcov3 the attribute "ExecutionEnvironmentResolver" should be resolved

  # ---------- fix_then_revalidate ----------
  Scenario: svcov3 lazy-load FixAttemptRecord
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "FixAttemptRecord"
    Then svcov3 the attribute "FixAttemptRecord" should be resolved

  Scenario: svcov3 lazy-load FixThenRevalidateOrchestrator
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "FixThenRevalidateOrchestrator"
    Then svcov3 the attribute "FixThenRevalidateOrchestrator" should be resolved

  Scenario: svcov3 lazy-load FixThenRevalidateResult
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "FixThenRevalidateResult"
    Then svcov3 the attribute "FixThenRevalidateResult" should be resolved

  # ---------- fusion_engine ----------
  Scenario: svcov3 lazy-load FusionConfig
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "FusionConfig"
    Then svcov3 the attribute "FusionConfig" should be resolved

  Scenario: svcov3 lazy-load FusionEngine
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "FusionEngine"
    Then svcov3 the attribute "FusionEngine" should be resolved

  Scenario: svcov3 lazy-load FusionResult
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "FusionResult"
    Then svcov3 the attribute "FusionResult" should be resolved

  # ---------- invariant_service ----------
  Scenario: svcov3 lazy-load InvariantService
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "InvariantService"
    Then svcov3 the attribute "InvariantService" should be resolved

  # ---------- multi_project_service ----------
  Scenario: svcov3 lazy-load MultiProjectService
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "MultiProjectService"
    Then svcov3 the attribute "MultiProjectService" should be resolved

  # ---------- permission_service ----------
  Scenario: svcov3 lazy-load PermissionService
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "PermissionService"
    Then svcov3 the attribute "PermissionService" should be resolved

  Scenario: svcov3 lazy-load enforce_permission
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "enforce_permission"
    Then svcov3 the attribute "enforce_permission" should be resolved

  Scenario: svcov3 lazy-load get_default_permission_service
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "get_default_permission_service"
    Then svcov3 the attribute "get_default_permission_service" should be resolved

  Scenario: svcov3 lazy-load set_default_permission_service
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "set_default_permission_service"
    Then svcov3 the attribute "set_default_permission_service" should be resolved

  # ---------- plan_execution_context ----------
  Scenario: svcov3 lazy-load PlanExecutionContext
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "PlanExecutionContext"
    Then svcov3 the attribute "PlanExecutionContext" should be resolved

  Scenario: svcov3 lazy-load RuntimeExecuteActor
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "RuntimeExecuteActor"
    Then svcov3 the attribute "RuntimeExecuteActor" should be resolved

  Scenario: svcov3 lazy-load RuntimeExecuteResult
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "RuntimeExecuteResult"
    Then svcov3 the attribute "RuntimeExecuteResult" should be resolved

  # ---------- prompt_sanitizer ----------
  Scenario: svcov3 lazy-load PromptInjectionDetected
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "PromptInjectionDetected"
    Then svcov3 the attribute "PromptInjectionDetected" should be resolved

  Scenario: svcov3 lazy-load PromptSanitizer
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "PromptSanitizer"
    Then svcov3 the attribute "PromptSanitizer" should be resolved

  Scenario: svcov3 lazy-load SanitizationResult
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "SanitizationResult"
    Then svcov3 the attribute "SanitizationResult" should be resolved

  # ---------- repo_indexing_service ----------
  Scenario: svcov3 lazy-load RepoIndexingService
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "RepoIndexingService"
    Then svcov3 the attribute "RepoIndexingService" should be resolved

  # ---------- semantic_validation_rules ----------
  Scenario: svcov3 lazy-load APIMisuseRule
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "APIMisuseRule"
    Then svcov3 the attribute "APIMisuseRule" should be resolved

  Scenario: svcov3 lazy-load BrokenReferenceRule
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "BrokenReferenceRule"
    Then svcov3 the attribute "BrokenReferenceRule" should be resolved

  Scenario: svcov3 lazy-load DependencyCycleRule
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "DependencyCycleRule"
    Then svcov3 the attribute "DependencyCycleRule" should be resolved

  Scenario: svcov3 lazy-load DuplicateImportRule
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "DuplicateImportRule"
    Then svcov3 the attribute "DuplicateImportRule" should be resolved

  Scenario: svcov3 lazy-load MissingImportRule
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "MissingImportRule"
    Then svcov3 the attribute "MissingImportRule" should be resolved

  Scenario: svcov3 lazy-load MissingSymbolRule
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "MissingSymbolRule"
    Then svcov3 the attribute "MissingSymbolRule" should be resolved

  Scenario: svcov3 lazy-load SemanticCheckResult
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "SemanticCheckResult"
    Then svcov3 the attribute "SemanticCheckResult" should be resolved

  Scenario: svcov3 lazy-load SemanticValidationSeverity
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "SemanticValidationSeverity"
    Then svcov3 the attribute "SemanticValidationSeverity" should be resolved

  Scenario: svcov3 lazy-load SyntaxCheckRule
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "SyntaxCheckRule"
    Then svcov3 the attribute "SyntaxCheckRule" should be resolved

  # ---------- semantic_validation_service ----------
  Scenario: svcov3 lazy-load NormalisedOutputDict
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "NormalisedOutputDict"
    Then svcov3 the attribute "NormalisedOutputDict" should be resolved

  Scenario: svcov3 lazy-load PipelineResultDict
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "PipelineResultDict"
    Then svcov3 the attribute "PipelineResultDict" should be resolved

  Scenario: svcov3 lazy-load SemanticRuleRegistry
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "SemanticRuleRegistry"
    Then svcov3 the attribute "SemanticRuleRegistry" should be resolved

  Scenario: svcov3 lazy-load SemanticValidationCache
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "SemanticValidationCache"
    Then svcov3 the attribute "SemanticValidationCache" should be resolved

  Scenario: svcov3 lazy-load SemanticValidationRule
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "SemanticValidationRule"
    Then svcov3 the attribute "SemanticValidationRule" should be resolved

  Scenario: svcov3 lazy-load SemanticValidationService
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "SemanticValidationService"
    Then svcov3 the attribute "SemanticValidationService" should be resolved

  Scenario: svcov3 lazy-load create_default_registry
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "create_default_registry"
    Then svcov3 the attribute "create_default_registry" should be resolved

  Scenario: svcov3 lazy-load map_severity_to_mode
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "map_severity_to_mode"
    Then svcov3 the attribute "map_severity_to_mode" should be resolved

  Scenario: svcov3 lazy-load resolve_severity
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "resolve_severity"
    Then svcov3 the attribute "resolve_severity" should be resolved

  # ---------- service_retry_wiring ----------
  Scenario: svcov3 lazy-load ServiceRetryWiring
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "ServiceRetryWiring"
    Then svcov3 the attribute "ServiceRetryWiring" should be resolved

  # ---------- session_service ----------
  Scenario: svcov3 lazy-load PersistentSessionService
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "PersistentSessionService"
    Then svcov3 the attribute "PersistentSessionService" should be resolved

  # ---------- skeleton_compressor ----------
  Scenario: svcov3 lazy-load SkeletonCompressorService
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "SkeletonCompressorService"
    Then svcov3 the attribute "SkeletonCompressorService" should be resolved

  # ---------- skill_registry_service ----------
  Scenario: svcov3 lazy-load SkillRegistryService
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "SkillRegistryService"
    Then svcov3 the attribute "SkillRegistryService" should be resolved

  # ---------- strategy_coordinator ----------
  Scenario: svcov3 lazy-load CoordinationResult
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "CoordinationResult"
    Then svcov3 the attribute "CoordinationResult" should be resolved

  Scenario: svcov3 lazy-load CoordinatorConfig
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "CoordinatorConfig"
    Then svcov3 the attribute "CoordinatorConfig" should be resolved

  Scenario: svcov3 lazy-load StrategyCoordinator
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "StrategyCoordinator"
    Then svcov3 the attribute "StrategyCoordinator" should be resolved

  # ---------- strategy_registry ----------
  Scenario: svcov3 lazy-load StrategyNotFoundError
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "StrategyNotFoundError"
    Then svcov3 the attribute "StrategyNotFoundError" should be resolved

  Scenario: svcov3 lazy-load StrategyRegistrationError
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "StrategyRegistrationError"
    Then svcov3 the attribute "StrategyRegistrationError" should be resolved

  Scenario: svcov3 lazy-load StrategyRegistry
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "StrategyRegistry"
    Then svcov3 the attribute "StrategyRegistry" should be resolved

  # ---------- subplan_execution_service ----------
  Scenario: svcov3 lazy-load SubplanExecutionOutput
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "SubplanExecutionOutput"
    Then svcov3 the attribute "SubplanExecutionOutput" should be resolved

  Scenario: svcov3 lazy-load SubplanExecutionResult
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "SubplanExecutionResult"
    Then svcov3 the attribute "SubplanExecutionResult" should be resolved

  Scenario: svcov3 lazy-load SubplanExecutionService
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "SubplanExecutionService"
    Then svcov3 the attribute "SubplanExecutionService" should be resolved

  # ---------- subplan_merge_service ----------
  Scenario: svcov3 lazy-load FileMergeOutcome
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "FileMergeOutcome"
    Then svcov3 the attribute "FileMergeOutcome" should be resolved

  Scenario: svcov3 lazy-load MergeConflictError
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "MergeConflictError"
    Then svcov3 the attribute "MergeConflictError" should be resolved

  Scenario: svcov3 lazy-load SubplanMergeResult
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "SubplanMergeResult"
    Then svcov3 the attribute "SubplanMergeResult" should be resolved

  Scenario: svcov3 lazy-load SubplanMergeService
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "SubplanMergeService"
    Then svcov3 the attribute "SubplanMergeService" should be resolved

  # ---------- subplan_service ----------
  Scenario: svcov3 lazy-load SpawnEntry
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "SpawnEntry"
    Then svcov3 the attribute "SpawnEntry" should be resolved

  Scenario: svcov3 lazy-load SpawnMetadata
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "SpawnMetadata"
    Then svcov3 the attribute "SpawnMetadata" should be resolved

  Scenario: svcov3 lazy-load SpawnResult
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "SpawnResult"
    Then svcov3 the attribute "SpawnResult" should be resolved

  Scenario: svcov3 lazy-load SubplanSpawnError
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "SubplanSpawnError"
    Then svcov3 the attribute "SubplanSpawnError" should be resolved

  Scenario: svcov3 lazy-load SpawnValidationResult
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "SpawnValidationResult"
    Then svcov3 the attribute "SpawnValidationResult" should be resolved

  Scenario: svcov3 lazy-load SubplanService
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "SubplanService"
    Then svcov3 the attribute "SubplanService" should be resolved

  # ---------- temporal_service ----------
  Scenario: svcov3 lazy-load TemporalService
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "TemporalService"
    Then svcov3 the attribute "TemporalService" should be resolved

  # ---------- tool_registry_service ----------
  Scenario: svcov3 lazy-load ToolRegistryService
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "ToolRegistryService"
    Then svcov3 the attribute "ToolRegistryService" should be resolved

  # ---------- trace_service ----------
  Scenario: svcov3 lazy-load TraceService
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "TraceService"
    Then svcov3 the attribute "TraceService" should be resolved

  # ---------- uko_indexer ----------
  Scenario: svcov3 lazy-load UKOIndexer
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "UKOIndexer"
    Then svcov3 the attribute "UKOIndexer" should be resolved

  # ---------- uko_indexer_protocols ----------
  Scenario: svcov3 lazy-load ContentReader
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "ContentReader"
    Then svcov3 the attribute "ContentReader" should be resolved

  Scenario: svcov3 lazy-load DefaultLifecycleHook
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "DefaultLifecycleHook"
    Then svcov3 the attribute "DefaultLifecycleHook" should be resolved

  Scenario: svcov3 lazy-load IndexLifecycleHook
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "IndexLifecycleHook"
    Then svcov3 the attribute "IndexLifecycleHook" should be resolved

  Scenario: svcov3 lazy-load LocationContentReader
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "LocationContentReader"
    Then svcov3 the attribute "LocationContentReader" should be resolved

  # ---------- uko_loader ----------
  Scenario: svcov3 lazy-load UKOLoader
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "UKOLoader"
    Then svcov3 the attribute "UKOLoader" should be resolved

  Scenario: svcov3 lazy-load UKOValidationError
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "UKOValidationError"
    Then svcov3 the attribute "UKOValidationError" should be resolved

  # ---------- validation_apply ----------
  Scenario: svcov3 lazy-load ApplyValidationGate
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "ApplyValidationGate"
    Then svcov3 the attribute "ApplyValidationGate" should be resolved

  Scenario: svcov3 lazy-load ApplyValidationResult
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "ApplyValidationResult"
    Then svcov3 the attribute "ApplyValidationResult" should be resolved

  Scenario: svcov3 lazy-load ApplyValidationSummary
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "ApplyValidationSummary"
    Then svcov3 the attribute "ApplyValidationSummary" should be resolved

  Scenario: svcov3 lazy-load AttachmentScope
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "AttachmentScope"
    Then svcov3 the attribute "AttachmentScope" should be resolved

  Scenario: svcov3 lazy-load DefaultValidationRunner
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "DefaultValidationRunner"
    Then svcov3 the attribute "DefaultValidationRunner" should be resolved

  Scenario: svcov3 lazy-load ValidationAttachment
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "ValidationAttachment"
    Then svcov3 the attribute "ValidationAttachment" should be resolved

  Scenario: svcov3 lazy-load ValidationRunner
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "ValidationRunner"
    Then svcov3 the attribute "ValidationRunner" should be resolved

  # ---------- validation_pipeline ----------
  Scenario: svcov3 lazy-load ValidationCommand
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "ValidationCommand"
    Then svcov3 the attribute "ValidationCommand" should be resolved

  Scenario: svcov3 lazy-load ValidationPipeline
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "ValidationPipeline"
    Then svcov3 the attribute "ValidationPipeline" should be resolved

  Scenario: svcov3 lazy-load ValidationResult
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "ValidationResult"
    Then svcov3 the attribute "ValidationResult" should be resolved

  Scenario: svcov3 lazy-load ValidationSummary
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "ValidationSummary"
    Then svcov3 the attribute "ValidationSummary" should be resolved

  # ---------- error / edge-case paths ----------
  Scenario: svcov3 unknown attribute raises AttributeError
    Given svcov3 a fresh services module
    When svcov3 I access an unknown attribute "NoSuchSymbol_xyzzy"
    Then svcov3 an AttributeError should be stored for "NoSuchSymbol_xyzzy"

  Scenario: svcov3 __all__ matches _LAZY_IMPORTS keys
    Given svcov3 a fresh services module
    Then svcov3 __all__ should equal sorted _LAZY_IMPORTS keys

  Scenario: svcov3 cached attribute skips __getattr__ on second access
    Given svcov3 a fresh services module
    When svcov3 I access lazy attribute "ConfigEntry"
    And svcov3 I access lazy attribute "ConfigEntry" again
    Then svcov3 the attribute "ConfigEntry" should be resolved