fix(machines): route provider identifier to start/stop so operations don't all-fail

StartMachinesOrchestrator / StopMachinesOrchestrator built
ExecuteProviderOperationCommand without a strategy_override. The handler
requires an explicit provider identifier and raises ConfigurationError
without one; the error was swallowed into command.result, so every
machine was reported failed even on success. Both CLI (machines
start/stop) and the MCP tools hit this path.

Resolve the effective provider from the orchestrator input
(provider_name > provider_type > active provider) and pass it as
strategy_override. Add real-path tests (previously the orchestrator was
fully mocked, which is why the bug shipped).

Author: fgogolli

src/orb/application/services/orchestration/start_machines.py

@@ -9,6 +9,7 @@
 from orb.application.provider.commands import ExecuteProviderOperationCommand
 from orb.application.services.orchestration.base import OrchestratorBase
 from orb.application.services.orchestration.dtos import StartMachinesInput, StartMachinesOutput
+from orb.application.services.provider_registry_service import ProviderRegistryService
 from orb.domain.base.operations import (
     Operation as ProviderOperation,
     OperationType as ProviderOperationType,
@@ -20,11 +21,16 @@ class StartMachinesOrchestrator(OrchestratorBase[StartMachinesInput, StartMachin
     """Orchestrator for starting machines via the provider layer."""
 
     def __init__(
-        self, command_bus: CommandBusPort, query_bus: QueryBusPort, logger: LoggingPort
+        self,
+        command_bus: CommandBusPort,
+        query_bus: QueryBusPort,
+        logger: LoggingPort,
+        provider_registry_service: ProviderRegistryService,
     ) -> None:
         self._command_bus = command_bus
         self._query_bus = query_bus
         self._logger = logger
+        self._provider_registry_service = provider_registry_service
 
     async def execute(self, input: StartMachinesInput) -> StartMachinesOutput:  # type: ignore[return]
         self._logger.info(
@@ -57,11 +63,35 @@ async def execute(self, input: StartMachinesInput) -> StartMachinesOutput:  # ty
                 message="No machines to start",
             )
 
+        # Resolve the effective provider identifier so the command handler can
+        # route the operation to the correct provider strategy.  Preference
+        # order: explicit name > explicit type > active provider from registry.
+        if input.provider_name:
+            strategy_override = input.provider_name
+        elif input.provider_type:
+            strategy_override = input.provider_type
+        else:
+            try:
+                selection = self._provider_registry_service.select_active_provider()
+                strategy_override = selection.provider_name
+            except Exception as exc:
+                self._logger.error(
+                    "StartMachinesOrchestrator: cannot resolve active provider: %s", exc
+                )
+                return StartMachinesOutput(
+                    started_machines=[],
+                    failed_machines=list(machine_ids),
+                    success=False,
+                    message=f"Cannot resolve active provider: {exc}",
+                )
+
         provider_op = ProviderOperation(
             operation_type=ProviderOperationType.START_INSTANCES,
             parameters={"instance_ids": machine_ids},
         )
-        command = ExecuteProviderOperationCommand(operation=provider_op)
+        command = ExecuteProviderOperationCommand(
+            operation=provider_op, strategy_override=strategy_override
+        )
         await self._command_bus.execute(command)
 
         if command.result and command.result.get("success"):

src/orb/application/services/orchestration/stop_machines.py

@@ -9,6 +9,7 @@
 from orb.application.provider.commands import ExecuteProviderOperationCommand
 from orb.application.services.orchestration.base import OrchestratorBase
 from orb.application.services.orchestration.dtos import StopMachinesInput, StopMachinesOutput
+from orb.application.services.provider_registry_service import ProviderRegistryService
 from orb.domain.base.operations import (
     Operation as ProviderOperation,
     OperationType as ProviderOperationType,
@@ -20,11 +21,16 @@ class StopMachinesOrchestrator(OrchestratorBase[StopMachinesInput, StopMachinesO
     """Orchestrator for stopping machines via the provider layer."""
 
     def __init__(
-        self, command_bus: CommandBusPort, query_bus: QueryBusPort, logger: LoggingPort
+        self,
+        command_bus: CommandBusPort,
+        query_bus: QueryBusPort,
+        logger: LoggingPort,
+        provider_registry_service: ProviderRegistryService,
     ) -> None:
         self._command_bus = command_bus
         self._query_bus = query_bus
         self._logger = logger
+        self._provider_registry_service = provider_registry_service
 
     async def execute(self, input: StopMachinesInput) -> StopMachinesOutput:  # type: ignore[return]
         self._logger.info(
@@ -58,11 +64,35 @@ async def execute(self, input: StopMachinesInput) -> StopMachinesOutput:  # type
                 message="No machines to stop",
             )
 
+        # Resolve the effective provider identifier so the command handler can
+        # route the operation to the correct provider strategy.  Preference
+        # order: explicit name > explicit type > active provider from registry.
+        if input.provider_name:
+            strategy_override = input.provider_name
+        elif input.provider_type:
+            strategy_override = input.provider_type
+        else:
+            try:
+                selection = self._provider_registry_service.select_active_provider()
+                strategy_override = selection.provider_name
+            except Exception as exc:
+                self._logger.error(
+                    "StopMachinesOrchestrator: cannot resolve active provider: %s", exc
+                )
+                return StopMachinesOutput(
+                    stopped_machines=[],
+                    failed_machines=list(machine_ids),
+                    success=False,
+                    message=f"Cannot resolve active provider: {exc}",
+                )
+
         operation = ProviderOperation(
             operation_type=ProviderOperationType.STOP_INSTANCES,
             parameters={"instance_ids": machine_ids},
         )
-        command = ExecuteProviderOperationCommand(operation=operation)
+        command = ExecuteProviderOperationCommand(
+            operation=operation, strategy_override=strategy_override
+        )
         await self._command_bus.execute(command)
 
         if command.result and command.result.get("success"):

src/orb/bootstrap/orchestrator_registry.py

@@ -210,21 +210,27 @@ def register_orchestrators(container: DIContainer) -> None:
             ),
         )
     if not container.is_registered(StopMachinesOrchestrator):
+        from orb.application.services.provider_registry_service import ProviderRegistryService
+
         container.register_singleton(
             StopMachinesOrchestrator,
             lambda c: StopMachinesOrchestrator(
                 command_bus=c.get(CommandBus),
                 query_bus=c.get(QueryBus),
                 logger=c.get(LoggingPort),
+                provider_registry_service=c.get(ProviderRegistryService),
             ),
         )
     if not container.is_registered(StartMachinesOrchestrator):
+        from orb.application.services.provider_registry_service import ProviderRegistryService
+
         container.register_singleton(
             StartMachinesOrchestrator,
             lambda c: StartMachinesOrchestrator(
                 command_bus=c.get(CommandBus),
                 query_bus=c.get(QueryBus),
                 logger=c.get(LoggingPort),
+                provider_registry_service=c.get(ProviderRegistryService),
             ),
         )
     if not container.is_registered(GetProviderHealthOrchestrator):

tests/unit/application/services/orchestration/test_start_machines_orchestrator.py

@@ -50,11 +50,27 @@ def mock_logger():
 
 
 @pytest.fixture
-def orchestrator(mock_command_bus, mock_query_bus, mock_logger):
+def mock_provider_registry_service():
+    from orb.application.services.provider_registry_service import ProviderRegistryService
+    from orb.domain.base.results import ProviderSelectionResult
+
+    svc = MagicMock(spec=ProviderRegistryService)
+    svc.select_active_provider.return_value = ProviderSelectionResult(
+        provider_type="aws",
+        provider_name="aws-default",
+        selection_reason="test_fixture",
+        confidence=1.0,
+    )
+    return svc
+
+
+@pytest.fixture
+def orchestrator(mock_command_bus, mock_query_bus, mock_logger, mock_provider_registry_service):
     return StartMachinesOrchestrator(
         command_bus=mock_command_bus,
         query_bus=mock_query_bus,
         logger=mock_logger,
+        provider_registry_service=mock_provider_registry_service,
     )
 
 

tests/unit/application/services/orchestration/test_stop_machines_orchestrator.py

@@ -52,11 +52,27 @@ def mock_logger():
 
 
 @pytest.fixture
-def orchestrator(mock_command_bus, mock_query_bus, mock_logger):
+def mock_provider_registry_service():
+    from orb.application.services.provider_registry_service import ProviderRegistryService
+    from orb.domain.base.results import ProviderSelectionResult
+
+    svc = MagicMock(spec=ProviderRegistryService)
+    svc.select_active_provider.return_value = ProviderSelectionResult(
+        provider_type="aws",
+        provider_name="aws-default",
+        selection_reason="test_fixture",
+        confidence=1.0,
+    )
+    return svc
+
+
+@pytest.fixture
+def orchestrator(mock_command_bus, mock_query_bus, mock_logger, mock_provider_registry_service):
     return StopMachinesOrchestrator(
         command_bus=mock_command_bus,
         query_bus=mock_query_bus,
         logger=mock_logger,
+        provider_registry_service=mock_provider_registry_service,
     )