fix(providers): restore fulfillment_final semantics for async fleet handlers

The branch had inverted ``fulfillment_final`` from True to False for
EC2Fleet REQUEST/MAINTAIN, SpotFleet, ASG, and RunInstances on the
theory that the create call is not "final" until the underlying
instances are running.  That redefinition forced all async-provider
completion through the polling layer (``check_hosts_status`` →
``request_status_service.update_request_status``) and ran straight
into a known limitation of that layer: any transient ``partial`` or
``failed`` poll result terminates the request irrevocably, so a
healthy request that happens to be observed mid-launch flips to
``complete_with_error`` and the HostFactory wire status reports
non-success despite the fleet actually being fulfilled.

The semantic that actually fits the existing two-layer state machine
is the one main used: ``fulfillment_final`` reports whether the
provider's CREATE call is the final word from the provisioning layer.
Every fleet type returns a stable resource handle synchronously on
create; whether the resulting instances are running is a separate
``check_hosts_status`` concern that drives the request from
IN_PROGRESS to COMPLETED on the polling layer.  That keeps the
provisioning path and the polling path cleanly separated and lets
``_update_request_status`` stamp COMPLETED directly when the fleet
returns the full target capacity synchronously (INSTANT) or hand off
to the poller when it doesn't (REQUEST / MAINTAIN / ASG / SpotFleet /
RunInstances).

The ``if not fulfillment_final: IN_PROGRESS`` guards in
``request_status_management_service`` stay as a safety net for any
future provider that genuinely cannot signal a final CREATE-time
answer (e.g. one that returns ``RequiresFollowUp``).  They will not
fire for any provider in the current tree.

Author: fgogolli

src/orb/providers/aws/infrastructure/handlers/asg/handler.py

@@ -147,7 +147,7 @@ def _acquire_hosts_internal(
                 "success": True,
                 "resource_ids": [asg_name],
                 "instances": [],  # ASG instances come later
-                "provider_data": {"resource_type": "asg", "fulfillment_final": False},
+                "provider_data": {"resource_type": "asg", "fulfillment_final": True},
             }
         except Exception as e:
             return {

src/orb/providers/aws/infrastructure/handlers/ec2_fleet/handler.py

@@ -189,11 +189,14 @@ def _acquire_hosts_internal(
                     "resource_type": "ec2_fleet",
                     "fleet_type": fleet_type_value,
                     "fleet_errors": fleet_errors,
-                    # INSTANT fleets return running instances synchronously
-                    # in the create_fleet response, so the result is the
-                    # final word. MAINTAIN / REQUEST fleets stay open and
-                    # need check_hosts_status to confirm running_count.
-                    "fulfillment_final": fleet_type is AWSFleetType.INSTANT,
+                    # ``fulfillment_final`` reports whether the provider's
+                    # CREATE call is the final word from the provisioning
+                    # layer.  All fleet types return a stable fleet ID at
+                    # create time; whether instances are actually running is
+                    # a separate ``check_hosts_status`` polling concern that
+                    # drives the request from IN_PROGRESS to COMPLETED.  See
+                    # ``fulfilment-model.md`` for the two-layer design.
+                    "fulfillment_final": True,
                     "capacity_constrained": capacity_constrained,
                 },
             }

src/orb/providers/aws/infrastructure/handlers/run_instances/handler.py

@@ -143,12 +143,11 @@ def _acquire_hosts_internal(
                     "resource_type": "run_instances",
                     "reservation_id": resource_id,
                     "instance_ids": instance_ids,
-                    # RunInstances returns instance IDs synchronously but
-                    # instances are still 'pending' (booting). Mark
-                    # non-final so the request stays IN_PROGRESS until
-                    # ProviderFulfilment (check_hosts_status) confirms
-                    # running_count >= target.
-                    "fulfillment_final": False,
+                    # RunInstances returns instance IDs synchronously.  The
+                    # provider create-call is final; instance running-state
+                    # is driven by check_hosts_status from IN_PROGRESS to
+                    # COMPLETED on the polling layer.
+                    "fulfillment_final": True,
                 },
             }
         except Exception as e:

src/orb/providers/aws/infrastructure/handlers/spot_fleet/handler.py

@@ -145,7 +145,7 @@ def _acquire_hosts_internal(
                 "resource_ids": [fleet_id],
                 "instance_ids": [],  # SpotFleet doesn't return instance IDs immediately
                 "instances": instances,
-                "provider_data": {"resource_type": "spot_fleet", "fulfillment_final": False},
+                "provider_data": {"resource_type": "spot_fleet", "fulfillment_final": True},
             }
         except Exception as e:
             self._logger.error("SpotFleet creation failed: %s", e)