diff --git a/src/openutm_verification/core/clients/air_traffic/air_traffic_client.py b/src/openutm_verification/core/clients/air_traffic/air_traffic_client.py
index 75ce3215..11718678 100644
--- a/src/openutm_verification/core/clients/air_traffic/air_traffic_client.py
+++ b/src/openutm_verification/core/clients/air_traffic/air_traffic_client.py
@@ -14,6 +14,7 @@
     BaseBlenderAPIClient,
 )
 from openutm_verification.core.execution.scenario_runner import scenario_step
+from openutm_verification.core.flight_phase import FlightPhase
 from openutm_verification.simulator.geo_json_telemetry import (
     GeoJSONAirtrafficSimulator,
 )
@@ -33,7 +34,7 @@ def __init__(self, settings: AirTrafficSettings):
         # but we inherit from it. Ideally, we should refactor to composition over inheritance.
         BaseBlenderAPIClient.__init__(self, base_url="", credentials={})
 
-    @scenario_step("Fetch Session IDs")
+    @scenario_step("Fetch Session IDs", phase=FlightPhase.PRE_FLIGHT)
     async def get_configured_session_ids(
         self,
     ) -> list[UUID]:
@@ -54,7 +55,7 @@ async def get_configured_session_ids(
             raise
         return session_ids
 
-    @scenario_step("Generate Simulated Air Traffic Data")
+    @scenario_step("Generate Simulated Air Traffic Data", phase=FlightPhase.PRE_FLIGHT)
     async def generate_simulated_air_traffic_data(
         self,
         config_path: str | None = None,
@@ -105,7 +106,7 @@ async def generate_simulated_air_traffic_data(
             logger.error(f"Failed to generate telemetry states from {config_path}: {exc}")
             raise
 
-    @scenario_step("Generate Simulated Air Traffic Data with Latency")
+    @scenario_step("Generate Simulated Air Traffic Data with Latency", phase=FlightPhase.PRE_FLIGHT)
     async def generate_simulated_air_traffic_data_with_latency(
         self,
         config_path: str | None = None,
diff --git a/src/openutm_verification/core/clients/air_traffic/bayesian_air_traffic_client.py b/src/openutm_verification/core/clients/air_traffic/bayesian_air_traffic_client.py
index afe1ded6..eeb6cd08 100644
--- a/src/openutm_verification/core/clients/air_traffic/bayesian_air_traffic_client.py
+++ b/src/openutm_verification/core/clients/air_traffic/bayesian_air_traffic_client.py
@@ -18,6 +18,7 @@
     BaseBlenderAPIClient,
 )
 from openutm_verification.core.execution.scenario_runner import scenario_step
+from openutm_verification.core.flight_phase import FlightPhase
 from openutm_verification.simulator.models.flight_data_types import FlightObservationSchema
 
 
@@ -42,7 +43,7 @@ def __init__(self, settings: BayesianAirTrafficSettings):
         # but we inherit from it. Ideally, we should refactor to composition over inheritance.
         BaseBlenderAPIClient.__init__(self, base_url="", credentials={})
 
-    @scenario_step("Fetch Session IDs for Bayesian Simulation")
+    @scenario_step("Fetch Session IDs for Bayesian Simulation", phase=FlightPhase.PRE_FLIGHT)
     async def get_configured_bayesian_session_ids(
         self,
     ) -> list[UUID]:
@@ -65,7 +66,7 @@ async def get_configured_bayesian_session_ids(
             raise
         return session_ids
 
-    @scenario_step("Generate Bayesian Simulation Air Traffic Data")
+    @scenario_step("Generate Bayesian Simulation Air Traffic Data", phase=FlightPhase.PRE_FLIGHT)
     async def generate_bayesian_sim_air_traffic_data(
         self,
         config_path: str | None = None,
@@ -206,7 +207,7 @@ def _convert_track_to_observations(
 
         return observations
 
-    @scenario_step("Generate Bayesian Simulation Air Traffic Data with latency issues")
+    @scenario_step("Generate Bayesian Simulation Air Traffic Data with latency issues", phase=FlightPhase.PRE_FLIGHT)
     async def generate_bayesian_sim_air_traffic_data_with_sensor_latency_issues(
         self,
         config_path: str | None = None,
diff --git a/src/openutm_verification/core/clients/air_traffic/blue_sky_client.py b/src/openutm_verification/core/clients/air_traffic/blue_sky_client.py
index d63f0bbe..0e7e6659 100644
--- a/src/openutm_verification/core/clients/air_traffic/blue_sky_client.py
+++ b/src/openutm_verification/core/clients/air_traffic/blue_sky_client.py
@@ -21,6 +21,7 @@
     BaseBlenderAPIClient,
 )
 from openutm_verification.core.execution.scenario_runner import scenario_step
+from openutm_verification.core.flight_phase import FlightPhase
 from openutm_verification.simulator.models.flight_data_types import (
     FlightObservationSchema,
 )
@@ -36,7 +37,7 @@ def __init__(self, settings: BlueSkyAirTrafficSettings):
         # but we inherit from it. Ideally, we should refactor to composition over inheritance.
         BaseBlenderAPIClient.__init__(self, base_url="", credentials={})
 
-    @scenario_step("Generate BlueSky Simulation Air Traffic Data")
+    @scenario_step("Generate BlueSky Simulation Air Traffic Data", phase=FlightPhase.PRE_FLIGHT)
     async def generate_bluesky_sim_air_traffic_data(
         self,
         config_path: str | None = None,
@@ -141,7 +142,7 @@ async def generate_bluesky_sim_air_traffic_data(
                 all_obs.extend(results_by_acid[acid])
             return all_obs
 
-    @scenario_step("Generate BlueSky Simulation Air Traffic Data with latency issues")
+    @scenario_step("Generate BlueSky Simulation Air Traffic Data with latency issues", phase=FlightPhase.PRE_FLIGHT)
     async def generate_bluesky_sim_air_traffic_data_with_sensor_latency_issues(
         self,
         config_path: str | None = None,
diff --git a/src/openutm_verification/core/clients/amqp/amqp_client.py b/src/openutm_verification/core/clients/amqp/amqp_client.py
index 6972682a..fb094720 100644
--- a/src/openutm_verification/core/clients/amqp/amqp_client.py
+++ b/src/openutm_verification/core/clients/amqp/amqp_client.py
@@ -18,6 +18,7 @@
 from pydantic import BaseModel
 
 from openutm_verification.core.execution.scenario_runner import scenario_step
+from openutm_verification.core.flight_phase import FlightPhase
 
 if TYPE_CHECKING:
     from openutm_verification.core.execution.config_models import AMQPConfig
@@ -246,7 +247,7 @@ def _consumer_loop(
                     pass
             logger.info("AMQP consumer stopped")
 
-    @scenario_step("Start AMQP Queue Monitor")
+    @scenario_step("Start AMQP Queue Monitor", phase=FlightPhase.PRE_FLIGHT)
     async def start_queue_monitor(
         self,
         queue_name: str | None = None,
@@ -295,7 +296,7 @@ async def start_queue_monitor(
             "duration": duration,
         }
 
-    @scenario_step("Stop AMQP Queue Monitor")
+    @scenario_step("Stop AMQP Queue Monitor", phase=FlightPhase.POST_FLIGHT)
     async def stop_queue_monitor(self) -> dict[str, Any]:
         """Stop the AMQP queue monitor.
 
@@ -321,7 +322,7 @@ async def stop_queue_monitor(self) -> dict[str, Any]:
             "error": self._state.error,
         }
 
-    @scenario_step("Get AMQP Messages")
+    @scenario_step("Get AMQP Messages", phase=FlightPhase.CRUISE)
     async def get_received_messages(
         self,
         routing_key_filter: str | None = None,
@@ -353,7 +354,7 @@ async def get_received_messages(
 
         return [m.to_dict() for m in messages]
 
-    @scenario_step("Wait for AMQP Messages")
+    @scenario_step("Wait for AMQP Messages", phase=FlightPhase.CRUISE)
     async def wait_for_messages(
         self,
         count: int = 1,
@@ -395,7 +396,7 @@ async def wait_for_messages(
             "error": f"Timed out waiting for {count} messages, got {len(messages)}",
         }
 
-    @scenario_step("Clear AMQP Messages")
+    @scenario_step("Clear AMQP Messages", phase=FlightPhase.POST_FLIGHT)
     async def clear_messages(self) -> dict[str, Any]:
         """Clear the collected messages buffer.
 
@@ -409,7 +410,7 @@ async def clear_messages(self) -> dict[str, Any]:
         logger.info(f"Cleared {count} AMQP messages")
         return {"cleared_count": count}
 
-    @scenario_step("Check AMQP Connection")
+    @scenario_step("Check AMQP Connection", phase=FlightPhase.PRE_FLIGHT)
     async def check_connection(self) -> dict[str, Any]:
         """Check if AMQP connection can be established.
 
diff --git a/src/openutm_verification/core/clients/flight_blender/flight_blender_client.py b/src/openutm_verification/core/clients/flight_blender/flight_blender_client.py
index b14903ef..8f978bb8 100644
--- a/src/openutm_verification/core/clients/flight_blender/flight_blender_client.py
+++ b/src/openutm_verification/core/clients/flight_blender/flight_blender_client.py
@@ -22,6 +22,7 @@
     ScenarioContext,
     scenario_step,
 )
+from openutm_verification.core.flight_phase import FlightPhase
 from openutm_verification.core.reporting.reporting_models import (
     Status,
     StepResult,
@@ -133,7 +134,7 @@ async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
 
         return await super().__aexit__(exc_type, exc_val, exc_tb)
 
-    @scenario_step("Upload Geo Fence")
+    @scenario_step("Upload Geo Fence", phase=FlightPhase.PRE_FLIGHT)
     async def upload_geo_fence(self, filename: str | None = None) -> dict[str, Any]:
         """Upload an Area-of-Interest (Geo Fence) to Flight Blender.
 
@@ -165,7 +166,7 @@ async def upload_geo_fence(self, filename: str | None = None) -> dict[str, Any]:
             logger.warning("Failed to extract geo-fence ID from response")
         return body
 
-    @scenario_step("Get Geo Fence")
+    @scenario_step("Get Geo Fence", phase=FlightPhase.PRE_FLIGHT)
     async def get_geo_fence(self) -> dict[str, Any]:
         """Retrieve the details of the most recently uploaded geo-fence.
 
@@ -183,7 +184,7 @@ async def get_geo_fence(self) -> dict[str, Any]:
         logger.info(f"Retrieved geo-fence details for ID: {geo_fence_id}")
         return response.json()
 
-    @scenario_step("Delete Geo Fence")
+    @scenario_step("Delete Geo Fence", phase=FlightPhase.POST_FLIGHT)
     async def delete_geo_fence(self, geo_fence_id: str | None = None) -> dict[str, Any]:
         """Delete a geo-fence by ID.
 
@@ -221,7 +222,7 @@ async def delete_geo_fence(self, geo_fence_id: str | None = None) -> dict[str, A
             logger.warning(f"Non-JSON response on geo-fence deletion, status: {response.status_code}")
             return {"deleted": response.status_code in (200, 204), "id": op_id}
 
-    @scenario_step("Upload Flight Declaration")
+    @scenario_step("Upload Flight Declaration", phase=FlightPhase.PRE_FLIGHT)
     async def upload_flight_declaration(self, declaration: str | BaseModel) -> dict[str, Any]:
         """Upload a flight declaration to the Flight Blender API.
 
@@ -273,7 +274,7 @@ async def upload_flight_declaration(self, declaration: str | BaseModel) -> dict[
 
         return response_json
 
-    @scenario_step("Bulk Upload Flight Declarations")
+    @scenario_step("Bulk Upload Flight Declarations", phase=FlightPhase.PRE_FLIGHT)
     async def upload_multiple_flight_declarations(self, declarations: list[BaseModel]) -> dict[str, Any]:
         """
         Upload multiple flight declarations to Flight Blender.
@@ -318,7 +319,7 @@ async def upload_multiple_flight_declarations(self, declarations: list[BaseModel
             logger.warning("Failed to extract flight declaration IDs from response")
         return response_json
 
-    @scenario_step("Upload Flight Declaration Via Operational Intent")
+    @scenario_step("Upload Flight Declaration Via Operational Intent", phase=FlightPhase.PRE_FLIGHT)
     async def upload_flight_declaration_via_operational_intent(self, declaration: str | BaseModel) -> dict[str, Any]:
         """Upload a flight declaration to the Flight Blender API.
 
@@ -371,7 +372,7 @@ async def upload_flight_declaration_via_operational_intent(self, declaration: st
 
         return response_json
 
-    @scenario_step("Upload two Flight Declarations Via Operational Intent")
+    @scenario_step("Upload two Flight Declarations Via Operational Intent", phase=FlightPhase.PRE_FLIGHT)
     async def upload_multiple_flight_declarations_via_operational_intents(self, declarations: list[BaseModel]) -> dict[str, Any]:
         endpoint = "/flight_declaration_ops/set_operational_intents_bulk"
 
@@ -406,7 +407,7 @@ async def wait_for_user_input(self, prompt: str = "Press Enter to continue...")
         """
         return input(prompt)
 
-    @scenario_step("Update Operation State")
+    @scenario_step("Update Operation State", phase=FlightPhase.CRUISE)
     async def update_operation_state(self, state: OperationState, duration: str | int | float = 0) -> dict[str, Any]:
         """Update the state of a flight operation.
 
@@ -434,7 +435,7 @@ async def update_operation_state(self, state: OperationState, duration: str | in
             await asyncio.sleep(duration_seconds)
         return response.json()
 
-    @scenario_step("Update Operation State of declaration")
+    @scenario_step("Update Operation State of declaration", phase=FlightPhase.CRUISE)
     async def update_operation_state_of_declaration(
         self, state: OperationState, declaration_id: str, duration: str | int | float = 0
     ) -> dict[str, Any]:
@@ -542,7 +543,7 @@ async def _submit_telemetry_states_impl(self, states: list[RIDAircraftState], du
         logger.info("Telemetry submission completed")
         return last_response
 
-    @scenario_step("Submit Telemetry (from file)")
+    @scenario_step("Submit Telemetry (from file)", phase=FlightPhase.CRUISE)
     async def submit_telemetry_from_file(self, filename: str, duration: str | int | float = 0) -> dict[str, Any] | None:
         """Submit telemetry data for a flight operation.
 
@@ -563,7 +564,7 @@ async def submit_telemetry_from_file(self, filename: str, duration: str | int |
         states = self._load_telemetry_file(filename)
         return await self._submit_telemetry_states_impl(states, duration)
 
-    @scenario_step("Submit Telemetry")
+    @scenario_step("Submit Telemetry", phase=FlightPhase.CRUISE)
     async def submit_telemetry(self, states: list[RIDAircraftState] | None = None, duration: str | int | float = 0) -> dict[str, Any] | None:
         """Submit telemetry data for a flight operation from in-memory states.
 
@@ -587,7 +588,7 @@ async def submit_telemetry(self, states: list[RIDAircraftState] | None = None, d
 
         return await self._submit_telemetry_states_impl(telemetry_states, duration)
 
-    @scenario_step("Check Operation State")
+    @scenario_step("Check Operation State", phase=FlightPhase.CRUISE)
     async def check_operation_state(
         self,
         expected_state: OperationState,
@@ -612,7 +613,7 @@ async def check_operation_state(
         logger.info(f"Flight state check for {self.latest_flight_declaration_id} completed (simulated).")
         return f"Waited for Flight Blender to process {expected_state} state."
 
-    @scenario_step("Check Operation State Connected")
+    @scenario_step("Check Operation State Connected", phase=FlightPhase.CRUISE)
     async def check_operation_state_connected(
         self,
         expected_state: OperationState,
@@ -653,7 +654,7 @@ async def check_operation_state_connected(
             f"Operation {self.latest_flight_declaration_id} did not reach expected state {expected_state.name} within {duration_seconds} seconds"
         )
 
-    @scenario_step("Cleanup Flight Declarations")
+    @scenario_step("Cleanup Flight Declarations", phase=FlightPhase.POST_FLIGHT)
     async def cleanup_flight_declarations(self) -> dict[str, Any]:
         """Specific cleanup for flight declarations in the active volume.
 
@@ -704,7 +705,7 @@ async def cleanup_flight_declarations(self) -> dict[str, Any]:
             logger.error(f"Error during flight declaration cleanup: {e}")
             return {"cleaned": False, "error": str(e)}
 
-    @scenario_step("Delete Flight Declaration")
+    @scenario_step("Delete Flight Declaration", phase=FlightPhase.POST_FLIGHT)
     async def delete_flight_declaration(self, flight_declaration_id: str | None = None) -> dict[str, Any]:
         """Delete a flight declaration by ID.
 
@@ -738,7 +739,7 @@ async def delete_flight_declaration(self, flight_declaration_id: str | None = No
             logger.warning(f"Non-JSON response on flight declaration deletion, status: {response.status_code}")
             return {"deleted": response.status_code in (200, 204), "id": op_id}
 
-    @scenario_step("Submit Simulated Air Traffic")
+    @scenario_step("Submit Simulated Air Traffic", phase=FlightPhase.CRUISE)
     async def submit_simulated_air_traffic(
         self,
         observations: list[FlightObservationSchema],
@@ -840,7 +841,7 @@ async def submit_simulated_air_traffic(
             "simulation_duration": (simulation_end - simulation_start).total_seconds(),
         }
 
-    @scenario_step("Submit Simulated Air Traffic at varying refresh rates")
+    @scenario_step("Submit Simulated Air Traffic at varying refresh rates", phase=FlightPhase.CRUISE)
     async def submit_simulated_air_traffic_at_random_refresh_rates(
         self,
         observations: list[FlightObservationSchema],
@@ -1010,7 +1011,7 @@ def _validate_reported_metrics(
             errors.append("aggregate_health is empty")
         return errors
 
-    @scenario_step("Verify Reported Metrics in Flight Blender")
+    @scenario_step("Verify Reported Metrics in Flight Blender", phase=FlightPhase.POST_FLIGHT)
     async def verify_reported_metrics_in_flight_blender(self, observations: list[FlightObservationSchema], session_id: uuid.UUID | None = None):
         """
         Queries the SDSP metrics endpoint and verifies reported values against expected values
@@ -1077,7 +1078,7 @@ async def verify_reported_metrics_in_flight_blender(self, observations: list[Fli
             error_message=None if not errors else "; ".join(errors),
         )
 
-    @scenario_step("Submit Air Traffic")
+    @scenario_step("Submit Air Traffic", phase=FlightPhase.CRUISE)
     async def submit_air_traffic(self, observations: list[FlightObservationSchema], session_id: uuid.UUID = uuid.uuid4()) -> dict[str, Any]:
         """Submit air traffic observations to the Flight Blender API.
 
@@ -1101,7 +1102,7 @@ async def submit_air_traffic(self, observations: list[FlightObservationSchema],
         logger.info(f"Air traffic observations submitted successfully for session {session_id}")
         return response.json()
 
-    @scenario_step("Get Active Sensors from SDSP")
+    @scenario_step("Get Active Sensors from SDSP", phase=FlightPhase.PRE_FLIGHT)
     async def get_active_sensors(self):
         endpoint = "/surveillance_monitoring_ops/list_surveillance_sensors"
         response = await self.get(endpoint)
@@ -1113,7 +1114,7 @@ async def get_active_sensors(self):
             logger.error(f"Failed to retrieve active sensors. Response: {response.text}")
             raise FlightBlenderError("Failed to retrieve active sensors from SDSP")
 
-    @scenario_step("Set Sensor Failure in SDSP")
+    @scenario_step("Set Sensor Failure in SDSP", phase=FlightPhase.CRUISE)
     async def set_sensor_failure(self, sensor_id: str):
         endpoint = f"/surveillance_monitoring_ops/update_sensor_health/{sensor_id}"
         new_status_payload = {"status": "outage"}
@@ -1125,7 +1126,7 @@ async def set_sensor_failure(self, sensor_id: str):
             logger.error(f"Failed to update sensor {sensor_id} status. Response: {response.text}")
             raise FlightBlenderError(f"Failed to update sensor {sensor_id} status to outage")
 
-    @scenario_step("List Sensor Failure Notifications from SDSP")
+    @scenario_step("List Sensor Failure Notifications from SDSP", phase=FlightPhase.CRUISE)
     async def list_sensor_failure_notifications(self) -> StepResult:
         endpoint = "/surveillance_monitoring_ops/list_sensor_health_notifications"
         response = await self.get(endpoint)
@@ -1184,7 +1185,7 @@ async def initialize_track_websocket_connection(self, session_id: str) -> Client
         ws = await self.create_websocket_connection(endpoint=endpoint)
         return ws
 
-    @scenario_step("Verify SDSP Track")
+    @scenario_step("Verify SDSP Track", phase=FlightPhase.CRUISE)
     async def initialize_verify_sdsp_track(
         self,
         expected_track_interval_seconds: int,
@@ -1246,7 +1247,7 @@ async def initialize_verify_sdsp_track(
                 duration=duration,
             )
 
-    @scenario_step("Verify SDSP Heartbeat")
+    @scenario_step("Verify SDSP Heartbeat", phase=FlightPhase.CRUISE)
     async def initialize_verify_sdsp_heartbeat(
         self,
         expected_heartbeat_interval_seconds: int,
@@ -1318,12 +1319,12 @@ async def initialize_verify_sdsp_heartbeat(
     async def close_heartbeat_websocket_connection(self, ws_connection: ClientConnection) -> None:
         await ws_connection.close()
 
-    @scenario_step("Teardown Flight Declaration")
+    @scenario_step("Teardown Flight Declaration", phase=FlightPhase.POST_FLIGHT)
     async def teardown_flight_declaration(self, flight_declaration_id: str | None = None) -> dict[str, Any]:
         logger.info("Tearing down flight declaration...")
         await self.delete_flight_declaration(flight_declaration_id=flight_declaration_id)
 
-    @scenario_step("Setup Flight Declaration via Operational Intent")
+    @scenario_step("Setup Flight Declaration via Operational Intent", phase=FlightPhase.PRE_FLIGHT)
     async def setup_flight_declaration_via_operational_intent(
         self,
         flight_declaration_via_operational_intent_path: str,
@@ -1371,7 +1372,7 @@ async def setup_flight_declaration_via_operational_intent(
             "end_datetime": flight_declaration.end_datetime,
         }
 
-    @scenario_step("Setup Flight Declaration")
+    @scenario_step("Setup Flight Declaration", phase=FlightPhase.PRE_FLIGHT)
     async def setup_flight_declaration(
         self,
         flight_declaration_path: str | None = None,
@@ -1429,7 +1430,7 @@ async def setup_flight_declaration(
             "end_datetime": flight_declaration.end_datetime,
         }
 
-    @scenario_step("Setup Two Flight Declarations")
+    @scenario_step("Setup Two Flight Declarations", phase=FlightPhase.PRE_FLIGHT)
     async def setup_two_flight_declarations(
         self,
         flight_declaration_path: str | None = None,
@@ -1492,7 +1493,7 @@ async def setup_two_flight_declarations(
 
         return asdict(all_declaration_details)
 
-    @scenario_step("Setup Two Operational Intents")
+    @scenario_step("Setup Two Operational Intents", phase=FlightPhase.PRE_FLIGHT)
     async def setup_two_flight_declarations_via_operational_intents(
         self,
         flight_declaration_via_operational_intent_path: str | None = None,
diff --git a/src/openutm_verification/core/clients/opensky/opensky_client.py b/src/openutm_verification/core/clients/opensky/opensky_client.py
index 0519d116..728f7a75 100644
--- a/src/openutm_verification/core/clients/opensky/opensky_client.py
+++ b/src/openutm_verification/core/clients/opensky/opensky_client.py
@@ -6,6 +6,7 @@
     OpenSkySettings,
 )
 from openutm_verification.core.execution.scenario_runner import scenario_step
+from openutm_verification.core.flight_phase import FlightPhase
 from openutm_verification.simulator.models.flight_data_types import (
     FlightObservationSchema,
 )
@@ -102,7 +103,7 @@ async def fetch_and_process_data(self) -> list[FlightObservationSchema] | None:
 
         return self.process_flight_data(flight_df)
 
-    @scenario_step("Fetch OpenSky Data")
+    @scenario_step("Fetch OpenSky Data", phase=FlightPhase.CRUISE)
     async def fetch_data(self) -> list[FlightObservationSchema] | None:
         """Fetch and process live flight data from OpenSky Network.
 
diff --git a/src/openutm_verification/core/execution/scenario_runner.py b/src/openutm_verification/core/execution/scenario_runner.py
index 40422f0c..7d992d91 100644
--- a/src/openutm_verification/core/execution/scenario_runner.py
+++ b/src/openutm_verification/core/execution/scenario_runner.py
@@ -22,6 +22,7 @@
 
 from openutm_verification.core.clients.opensky.base_client import OpenSkyError
 from openutm_verification.core.execution.dependency_resolution import DEPENDENCIES
+from openutm_verification.core.flight_phase import FlightPhase
 from openutm_verification.core.reporting.reporting_models import (
     ScenarioResult,
     Status,
@@ -191,10 +192,11 @@ def air_traffic_data(self) -> list[FlightObservationSchema]:
 
 
 class ScenarioStepDescriptor:
-    def __init__(self, func: Callable[..., Awaitable[Any]], step_name: str):
+    def __init__(self, func: Callable[..., Awaitable[Any]], step_name: str, phase: FlightPhase | None = None):
         self.func = func
         self.step_name = step_name
-        self.wrapper = self._create_wrapper(func, step_name)
+        self.phase = phase
+        self.wrapper = self._create_wrapper(func, step_name, phase)
         self.param_model = self._create_param_model(func, step_name)
 
     def _create_param_model(self, func: Callable[..., Any], step_name: str) -> type[BaseModel]:
@@ -225,17 +227,20 @@ def _create_param_model(self, func: Callable[..., Any], step_name: str) -> type[
             **fields,
         )
 
-    def _create_wrapper(self, func: Callable[..., Awaitable[Any]], step_name: str) -> Callable[..., Awaitable[Any]]:
+    def _create_wrapper(self, func: Callable[..., Awaitable[Any]], step_name: str, phase: FlightPhase | None = None) -> Callable[..., Awaitable[Any]]:
         def handle_result(result: Any, start_time: float) -> StepResult[Any]:
             duration = time.time() - start_time
             logger.info(f"Step '{step_name}' successful in {duration:.2f} seconds.")
 
             step_result: StepResult[Any]
             if isinstance(result, StepResult):
+                if result.phase is None and phase is not None:
+                    result.phase = phase
                 step_result = result
             else:
                 step_result = StepResult(
                     name=step_name,
+                    phase=phase,
                     status=Status.PASS,
                     duration=duration,
                     result=result,
@@ -251,6 +256,7 @@ def handle_exception(e: Exception, start_time: float) -> StepResult[Any]:
                 logger.error(f"Step '{step_name}' failed after {duration:.2f} seconds: {e}")
                 step_result = StepResult(
                     name=step_name,
+                    phase=phase,
                     status=Status.FAIL,
                     duration=duration,
                     error_message=str(e),
@@ -259,6 +265,7 @@ def handle_exception(e: Exception, start_time: float) -> StepResult[Any]:
                 logger.error(f"Step '{step_name}' encountered an unexpected error after {duration:.2f} seconds: {e}")
                 step_result = StepResult(
                     name=step_name,
+                    phase=phase,
                     status=Status.FAIL,
                     duration=duration,
                     error_message=f"Unexpected error: {e}",
@@ -303,6 +310,7 @@ def log_filter(record):
         # Attach metadata for introspection
         setattr(async_wrapper, "_is_scenario_step", True)
         setattr(async_wrapper, "_step_name", step_name)
+        setattr(async_wrapper, "_step_phase", phase)
 
         return async_wrapper
 
@@ -323,8 +331,8 @@ def __call__(self, *args: Any, **kwargs: Any):
         return self.wrapper(*args, **kwargs)
 
 
-def scenario_step(step_name: str) -> Callable[[Callable[..., Awaitable[Any]]], Any]:
+def scenario_step(step_name: str, phase: FlightPhase | None = None) -> Callable[[Callable[..., Awaitable[Any]]], Any]:
     def decorator(func: Callable[..., Awaitable[Any]]) -> Any:
-        return ScenarioStepDescriptor(func, step_name)
+        return ScenarioStepDescriptor(func, step_name, phase)
 
     return decorator
diff --git a/src/openutm_verification/core/flight_phase.py b/src/openutm_verification/core/flight_phase.py
new file mode 100644
index 00000000..92f544d0
--- /dev/null
+++ b/src/openutm_verification/core/flight_phase.py
@@ -0,0 +1,89 @@
+"""
+Flight phase taxonomy for verification step annotations.
+
+Phases are optional annotations on scenario steps that allow grouping
+related steps in reports and the UI.
+"""
+
+from enum import StrEnum
+
+
+class FlightPhase(StrEnum):
+    """Flight phase categories for annotating verification steps."""
+
+    FLIGHT_PLANNING = "FPL"
+    """Flight planning phase."""
+
+    PRE_FLIGHT = "PRF"
+    """Pre-flight checks and setup."""
+
+    ENGINE_START = "ESD"
+    """Engine start / depart phase."""
+
+    TAXI_OUT = "TXO"
+    """Taxi-out phase."""
+
+    TAKEOFF = "TOF"
+    """Takeoff phase."""
+
+    REJECTED_TAKEOFF = "RTO"
+    """Rejected takeoff phase."""
+
+    INITIAL_CLIMB = "ICL"
+    """Initial climb phase."""
+
+    EN_ROUTE_CLIMB = "ERC"
+    """En route climb phase."""
+
+    CRUISE = "CRZ"
+    """Cruise phase."""
+
+    DESCENT = "DES"
+    """Descent phase."""
+
+    APPROACH = "APR"
+    """Approach phase."""
+
+    GO_AROUND = "GAR"
+    """Go-around phase."""
+
+    LANDING = "LDG"
+    """Landing phase."""
+
+    TAXI_IN = "TXI"
+    """Taxi-in phase."""
+
+    ARRIVAL = "AES"
+    """Arrival / engine shutdown phase."""
+
+    POST_FLIGHT = "PST"
+    """Post-flight phase."""
+
+    FLIGHT_CLOSE = "FCL"
+    """Flight close phase."""
+
+    GROUND_SERVICES = "GND"
+    """Ground services phase."""
+
+
+# Human-readable labels for display
+FLIGHT_PHASE_LABELS: dict[FlightPhase, str] = {
+    FlightPhase.FLIGHT_PLANNING: "Flight Planning",
+    FlightPhase.PRE_FLIGHT: "Pre-flight",
+    FlightPhase.ENGINE_START: "Engine Start / Depart",
+    FlightPhase.TAXI_OUT: "Taxi Out",
+    FlightPhase.TAKEOFF: "Takeoff",
+    FlightPhase.REJECTED_TAKEOFF: "Rejected Takeoff",
+    FlightPhase.INITIAL_CLIMB: "Initial Climb",
+    FlightPhase.EN_ROUTE_CLIMB: "En Route Climb",
+    FlightPhase.CRUISE: "Cruise",
+    FlightPhase.DESCENT: "Descent",
+    FlightPhase.APPROACH: "Approach",
+    FlightPhase.GO_AROUND: "Go-around",
+    FlightPhase.LANDING: "Landing",
+    FlightPhase.TAXI_IN: "Taxi In",
+    FlightPhase.ARRIVAL: "Arrival / Engine Shutdown",
+    FlightPhase.POST_FLIGHT: "Post-flight",
+    FlightPhase.FLIGHT_CLOSE: "Flight Close",
+    FlightPhase.GROUND_SERVICES: "Ground Services",
+}
diff --git a/src/openutm_verification/core/reporting/reporting.py b/src/openutm_verification/core/reporting/reporting.py
index 455567e1..33988687 100644
--- a/src/openutm_verification/core/reporting/reporting.py
+++ b/src/openutm_verification/core/reporting/reporting.py
@@ -10,6 +10,7 @@
 from loguru import logger
 
 from openutm_verification.core.execution.config_models import AppConfig, ReportingConfig
+from openutm_verification.core.flight_phase import FLIGHT_PHASE_LABELS
 from openutm_verification.core.reporting.reporting_models import (
     ReportData,
     ReportSummary,
@@ -189,9 +190,13 @@ def _generate_html_report(report_data: ReportData, output_dir: Path, base_filena
         autoescape=select_autoescape(enabled_extensions=("html", "xml"), default_for_string=True, default=True),
     )
     env.filters["markdown"] = lambda text: markdown.markdown(text) if text else ""
+    env.filters["default_phase"] = lambda steps: [{**s, "phase": s.get("phase") or ""} for s in steps]
     template = env.get_template("report_template.html")
 
-    html_content = template.render(report_data=report_data.model_dump(mode="json"))
+    html_content = template.render(
+        report_data=report_data.model_dump(mode="json"),
+        phase_labels={k.value: v for k, v in FLIGHT_PHASE_LABELS.items()},
+    )
 
     report_path = output_dir / f"{base_filename}.html"
     with open(report_path, "w", encoding="utf-8") as f:
diff --git a/src/openutm_verification/core/reporting/reporting_models.py b/src/openutm_verification/core/reporting/reporting_models.py
index 42b29572..430d171c 100644
--- a/src/openutm_verification/core/reporting/reporting_models.py
+++ b/src/openutm_verification/core/reporting/reporting_models.py
@@ -10,6 +10,7 @@
 from uas_standards.astm.f3411.v22a.api import RIDAircraftState
 
 from openutm_verification.core.execution.config_models import DeploymentDetails
+from openutm_verification.core.flight_phase import FlightPhase
 from openutm_verification.simulator.models.declaration_models import (
     FlightDeclaration,
     FlightDeclarationViaOperationalIntent,
@@ -37,6 +38,7 @@ class StepResult(BaseModel, Generic[T]):
 
     id: str | None = None
     name: str
+    phase: FlightPhase | None = None
     status: Status
     duration: float
     result: T = None  # type: ignore
diff --git a/src/openutm_verification/core/steps/air_traffic_step.py b/src/openutm_verification/core/steps/air_traffic_step.py
index a7a47069..2128d4de 100644
--- a/src/openutm_verification/core/steps/air_traffic_step.py
+++ b/src/openutm_verification/core/steps/air_traffic_step.py
@@ -11,6 +11,7 @@
 from openutm_verification.core.execution.config_models import get_settings
 from openutm_verification.core.execution.dependency_resolution import CONTEXT
 from openutm_verification.core.execution.scenario_runner import scenario_step
+from openutm_verification.core.flight_phase import FlightPhase
 from openutm_verification.core.providers import DataQualityType, ProviderType, create_provider
 from openutm_verification.core.streamers import RefreshModeType, StreamResult, TargetType, create_streamer
 
@@ -141,8 +142,8 @@ def _apply_config_defaults(
             duration = 30
 
         return (duration, config_path, number_of_aircraft, sensor_ids, session_ids)
-
-    @scenario_step("Stream Air Traffic")
+    
+    @scenario_step("Stream Air Traffic", phase=FlightPhase.CRUISE)
     async def stream_air_traffic(
         self,
         provider: ProviderType,
diff --git a/src/openutm_verification/core/templates/report_template.html b/src/openutm_verification/core/templates/report_template.html
index bce14b43..cfc34d48 100644
--- a/src/openutm_verification/core/templates/report_template.html
+++ b/src/openutm_verification/core/templates/report_template.html
@@ -50,6 +50,9 @@
             color: #495057;
         }
         .toggle-btn:hover { background-color: rgba(222, 226, 230, 0.95); }
+        .phase-group { margin-bottom: 15px; }
+        .phase-header { background-color: #e9ecef; padding: 8px 12px; border-radius: 4px; font-weight: bold; margin-bottom: 5px; display: flex; align-items: center; gap: 8px; }
+        .phase-badge { font-size: 11px; padding: 2px 8px; border-radius: 10px; background-color: #6c757d; color: white; font-weight: normal; }
     </style>
 </head>
 <body>
@@ -125,6 +128,45 @@ <h4>Documentation:</h4>
                 </div>
                 {% endif %}
                 <h4>Steps:</h4>
+                {% set has_phases = result.steps | selectattr('phase') | list | length > 0 %}
+                {% if has_phases %}
+                    {% for phase_group in result.steps | default_phase | groupby('phase') %}
+                    {% set phase_index = loop.index %}
+                    <div class="phase-group">
+                        {% if phase_group.grouper %}
+                        <div class="phase-header">
+                            <span class="phase-badge">{{ phase_group.grouper }}</span>
+                            {{ (phase_labels or {}).get(phase_group.grouper, phase_group.grouper) }}
+                        </div>
+                        {% else %}
+                        <div class="phase-header">Other Steps</div>
+                        {% endif %}
+                        <table class="steps-table">
+                        <thead><tr><th>Step Name</th><th>Status</th><th>Duration (s)</th><th>Result</th></tr></thead>
+                        <tbody>
+                        {% for step in phase_group.list %}
+                            {% set result_json = step.result | tojson(indent=2) %}
+                            {% set line_count = result_json.split('\n') | length %}
+                            <tr>
+                                <td>{{ step.name }}</td>
+                                <td><span class="status status-{{ step.status }}">{{ step.status }}</span></td>
+                                <td>{{ "%.2f"|format(step.duration) }}</td>
+                                <td>
+                                    {% if line_count > 10 %}
+                                    <div class="result-wrapper">
+                                        <pre class="result-collapsed" id="result-{{ scenario_index }}-{{ phase_index }}-{{ loop.index }}">{{ result_json }}</pre>
+                                        <button class="toggle-btn" onclick="toggleResult('result-{{ scenario_index }}-{{ phase_index }}-{{ loop.index }}', this)">Show more</button>
+                                    </div>
+                                    {% else %}
+                                    <pre>{{ result_json }}</pre>
+                                    {% endif %}
+                                </td>
+                            </tr>
+                        {% endfor %}
+                        </tbody></table>
+                    </div>
+                    {% endfor %}
+                {% else %}
                 <table class="steps-table">
                     <thead>
                         <tr>
@@ -156,6 +198,7 @@ <h4>Steps:</h4>
                         {% endfor %}
                     </tbody>
                 </table>
+                {% endif %}
             </div>
         </details>
     </div>
diff --git a/src/openutm_verification/server/introspection.py b/src/openutm_verification/server/introspection.py
index 4d669807..af9a6b47 100644
--- a/src/openutm_verification/server/introspection.py
+++ b/src/openutm_verification/server/introspection.py
@@ -117,4 +117,5 @@ def process_method(client_class: Type, method: Any) -> Dict[str, Any] | None:
         "category": client_class.__name__,
         "description": inspect.getdoc(method) or "",
         "parameters": parameters,
+        "phase": getattr(method, "_step_phase", None),
     }
diff --git a/tests/test_flight_phase.py b/tests/test_flight_phase.py
new file mode 100644
index 00000000..58fb9197
--- /dev/null
+++ b/tests/test_flight_phase.py
@@ -0,0 +1,87 @@
+"""Tests for flight phase annotations on scenario steps."""
+
+import pytest
+
+from openutm_verification.core.execution.scenario_runner import (
+    ScenarioContext,
+    ScenarioState,
+    scenario_step,
+)
+from openutm_verification.core.flight_phase import FlightPhase
+from openutm_verification.core.reporting.reporting_models import Status, StepResult
+
+
+class DummyClient:
+    """Minimal client class for testing phase propagation."""
+
+    @scenario_step("Phase step", phase=FlightPhase.PRE_FLIGHT)
+    async def step_with_phase(self):
+        return {"ok": True}
+
+    @scenario_step("No phase step")
+    async def step_without_phase(self):
+        return {"ok": True}
+
+    @scenario_step("Returns StepResult", phase=FlightPhase.CRUISE)
+    async def step_returning_step_result(self):
+        return StepResult(name="Returns StepResult", status=Status.PASS, duration=0.0, result={"custom": True})
+
+    @scenario_step("Returns StepResult with phase", phase=FlightPhase.CRUISE)
+    async def step_returning_step_result_with_own_phase(self):
+        return StepResult(
+            name="Returns StepResult with phase", phase=FlightPhase.POST_FLIGHT, status=Status.PASS, duration=0.0, result={"custom": True}
+        )
+
+
+class TestPhaseIntrospection:
+    """Tests that _step_phase metadata is correctly set on step wrappers."""
+
+    def test_step_has_phase_metadata(self):
+        method = DummyClient.step_with_phase
+        assert getattr(method, "_step_phase", None) == FlightPhase.PRE_FLIGHT
+
+    def test_step_without_phase_has_none_metadata(self):
+        method = DummyClient.step_without_phase
+        assert getattr(method, "_step_phase", None) is None
+
+    def test_step_has_step_name_metadata(self):
+        method = DummyClient.step_with_phase
+        assert getattr(method, "_step_name", None) == "Phase step"
+
+    def test_step_is_scenario_step(self):
+        method = DummyClient.step_with_phase
+        assert getattr(method, "_is_scenario_step", False) is True
+
+
+class TestPhaseInStepResult:
+    """Tests that phase is correctly propagated to StepResult."""
+
+    @pytest.mark.asyncio
+    async def test_raw_return_gets_phase(self):
+        client = DummyClient()
+        with ScenarioContext(ScenarioState(active=True)):
+            result = await client.step_with_phase()
+        assert result.phase == FlightPhase.PRE_FLIGHT
+
+    @pytest.mark.asyncio
+    async def test_raw_return_without_phase(self):
+        client = DummyClient()
+        with ScenarioContext(ScenarioState(active=True)):
+            result = await client.step_without_phase()
+        assert result.phase is None
+
+    @pytest.mark.asyncio
+    async def test_step_result_return_inherits_decorator_phase(self):
+        """When step returns StepResult without phase, decorator phase is applied."""
+        client = DummyClient()
+        with ScenarioContext(ScenarioState(active=True)):
+            result = await client.step_returning_step_result()
+        assert result.phase == FlightPhase.CRUISE
+
+    @pytest.mark.asyncio
+    async def test_step_result_return_keeps_own_phase(self):
+        """When step returns StepResult with its own phase, it is preserved."""
+        client = DummyClient()
+        with ScenarioContext(ScenarioState(active=True)):
+            result = await client.step_returning_step_result_with_own_phase()
+        assert result.phase == FlightPhase.POST_FLIGHT
diff --git a/tests/test_reporting_output.py b/tests/test_reporting_output.py
index 61d40d7c..277bc6a5 100644
--- a/tests/test_reporting_output.py
+++ b/tests/test_reporting_output.py
@@ -14,13 +14,13 @@
     OpenSkyConfig,
     ReportingConfig,
 )
+from openutm_verification.core.flight_phase import FlightPhase
 from openutm_verification.core.reporting.reporting import create_report_data, generate_reports
 from openutm_verification.core.reporting.reporting_models import ScenarioResult, Status, StepResult
 
 
-def test_report_outputs_use_result(tmp_path: Path):
-    # Minimal AppConfig
-    app_config = AppConfig(
+def _make_app_config(tmp_path: Path) -> AppConfig:
+    return AppConfig(
         version="1.0",
         run_id="test-run",
         flight_blender=FlightBlenderConfig(url="http://localhost:8000", auth=AuthConfig()),
@@ -39,6 +39,10 @@ def test_report_outputs_use_result(tmp_path: Path):
         reporting=ReportingConfig(output_dir=str(tmp_path), formats=["json", "html"], deployment_details=DeploymentDetails()),
     )
 
+
+def test_report_outputs_use_result(tmp_path: Path):
+    app_config = _make_app_config(tmp_path)
+
     # Build a simple scenario result with a single step
     step = StepResult(id="Generate UUID", name="Generate UUID", status=Status.PASS, duration=0.01, result={"uuid": "abc-123"})
     scenario_result = ScenarioResult(
@@ -84,3 +88,163 @@ def test_report_outputs_use_result(tmp_path: Path):
     html = html_path.read_text(encoding="utf-8")
     assert "<th>Result</th>" in html
     assert "abc-123" in html
+
+
+def test_report_html_groups_steps_by_phase(tmp_path: Path):
+    app_config = _make_app_config(tmp_path)
+
+    steps = [
+        StepResult(id="s1", name="Setup geo fence", status=Status.PASS, duration=0.01, result={}, phase=FlightPhase.PRE_FLIGHT),
+        StepResult(id="s2", name="Upload declaration", status=Status.PASS, duration=0.02, result={}, phase=FlightPhase.PRE_FLIGHT),
+        StepResult(id="s3", name="Stream telemetry", status=Status.PASS, duration=1.0, result={}, phase=FlightPhase.CRUISE),
+        StepResult(id="s4", name="Cleanup", status=Status.PASS, duration=0.01, result={}, phase=FlightPhase.POST_FLIGHT),
+    ]
+    scenario_result = ScenarioResult(
+        name="phased_scenario",
+        suite_name=None,
+        status=Status.PASS,
+        duration=1.04,
+        steps=steps,
+        error_message=None,
+        flight_declaration_filename=None,
+        telemetry_filename=None,
+        flight_declaration_data=None,
+        flight_declaration_via_operational_intent_data=None,
+        telemetry_data=None,
+        air_traffic_data=None,
+        visualization_2d_path=None,
+        visualization_3d_path=None,
+        docs=None,
+    )
+
+    report_data = create_report_data(
+        config=app_config,
+        config_path="config/default.yaml",
+        results=[scenario_result],
+        start_time=datetime.now(UTC),
+        end_time=datetime.now(UTC),
+        run_id="test-run",
+        docs_dir=None,
+    )
+    generate_reports(report_data, app_config.reporting, base_filename="report")
+
+    html_path = next(tmp_path.rglob("report.html"))
+    html = html_path.read_text(encoding="utf-8")
+
+    # Phase headers should appear with human-readable labels
+    assert "Pre-flight" in html
+    assert "Cruise" in html
+    assert "Post-flight" in html
+
+    # Phase badges should contain the codes
+    assert ">PRF<" in html
+    assert ">CRZ<" in html
+    assert ">PST<" in html
+
+    # All steps should be present
+    assert "Setup geo fence" in html
+    assert "Upload declaration" in html
+    assert "Stream telemetry" in html
+    assert "Cleanup" in html
+
+
+def test_report_html_no_phases_renders_flat_table(tmp_path: Path):
+    app_config = _make_app_config(tmp_path)
+
+    steps = [
+        StepResult(id="s1", name="Step A", status=Status.PASS, duration=0.01, result={}),
+        StepResult(id="s2", name="Step B", status=Status.PASS, duration=0.02, result={}),
+    ]
+    scenario_result = ScenarioResult(
+        name="flat_scenario",
+        suite_name=None,
+        status=Status.PASS,
+        duration=0.03,
+        steps=steps,
+        error_message=None,
+        flight_declaration_filename=None,
+        telemetry_filename=None,
+        flight_declaration_data=None,
+        flight_declaration_via_operational_intent_data=None,
+        telemetry_data=None,
+        air_traffic_data=None,
+        visualization_2d_path=None,
+        visualization_3d_path=None,
+        docs=None,
+    )
+
+    report_data = create_report_data(
+        config=app_config,
+        config_path="config/default.yaml",
+        results=[scenario_result],
+        start_time=datetime.now(UTC),
+        end_time=datetime.now(UTC),
+        run_id="test-run",
+        docs_dir=None,
+    )
+    generate_reports(report_data, app_config.reporting, base_filename="report")
+
+    html_path = next(tmp_path.rglob("report.html"))
+    html = html_path.read_text(encoding="utf-8")
+
+    # No phase group headers in content (CSS rule may still exist in <style>)
+    assert 'class="phase-header"' not in html
+    # Steps still render
+    assert "Step A" in html
+    assert "Step B" in html
+
+
+def test_report_html_mixed_phases_and_none(tmp_path: Path):
+    """Regression: steps mixing phase=None and phase=<value> must not crash groupby."""
+    app_config = _make_app_config(tmp_path)
+
+    steps = [
+        StepResult(id="s1", name="Setup", status=Status.PASS, duration=0.01, result={}, phase=FlightPhase.PRE_FLIGHT),
+        StepResult(id="s2", name="Generate UUID", status=Status.PASS, duration=0.01, result={}),  # phase=None
+        StepResult(id="s3", name="Stream", status=Status.PASS, duration=1.0, result={}, phase=FlightPhase.CRUISE),
+        StepResult(id="s4", name="Cleanup", status=Status.PASS, duration=0.01, result={}),  # phase=None
+    ]
+    scenario_result = ScenarioResult(
+        name="mixed_phases",
+        suite_name=None,
+        status=Status.PASS,
+        duration=1.03,
+        steps=steps,
+        error_message=None,
+        flight_declaration_filename=None,
+        telemetry_filename=None,
+        flight_declaration_data=None,
+        flight_declaration_via_operational_intent_data=None,
+        telemetry_data=None,
+        air_traffic_data=None,
+        visualization_2d_path=None,
+        visualization_3d_path=None,
+        docs=None,
+    )
+
+    report_data = create_report_data(
+        config=app_config,
+        config_path="config/default.yaml",
+        results=[scenario_result],
+        start_time=datetime.now(UTC),
+        end_time=datetime.now(UTC),
+        run_id="test-run",
+        docs_dir=None,
+    )
+
+    # Must not raise TypeError from groupby sorting None vs str
+    generate_reports(report_data, app_config.reporting, base_filename="report")
+
+    html_path = next(tmp_path.rglob("report.html"))
+    html = html_path.read_text(encoding="utf-8")
+
+    # Phased steps grouped under phase headers
+    assert "Pre-flight" in html
+    assert "Cruise" in html
+    # Unphased steps grouped under "Other Steps"
+    assert "Other Steps" in html
+    # All step names present
+    assert "Setup" in html
+    assert "Generate UUID" in html
+    assert "Stream" in html
+    assert "Cleanup" in html
diff --git a/web-editor/src/components/ScenarioEditor.tsx b/web-editor/src/components/ScenarioEditor.tsx
index b8ec44b4..cae55b9c 100644
--- a/web-editor/src/components/ScenarioEditor.tsx
+++ b/web-editor/src/components/ScenarioEditor.tsx
@@ -23,11 +23,12 @@ import { BottomPanel } from './ScenarioEditor/BottomPanel';
 import { Header } from './ScenarioEditor/Header';
 import { ScenarioInfoPanel } from './ScenarioEditor/ScenarioInfoPanel';
 
-import { useScenarioGraph } from '../hooks/useScenarioGraph';
+import { useScenarioGraph, getLayoutedElements } from '../hooks/useScenarioGraph';
 import { useScenarioRunner } from '../hooks/useScenarioRunner';
 import { useScenarioFile } from '../hooks/useScenarioFile';
 import { convertGraphToYaml, convertYamlToGraph } from '../utils/scenarioConversion';
 import { createWaitEdge } from '../utils/edgeStyles';
+import { applyPhaseGrouping } from '../utils/phaseGrouping';
 
 const nodeTypes: NodeTypes = {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -128,6 +129,12 @@ const ScenarioEditorContent = () => {
     const [scenarioListRefreshKey, setScenarioListRefreshKey] = useState(0);
     const [isDirty, setIsDirty] = useState(initialState.isDirty);
     const [reportError, setReportError] = useState<{ title: string; message: string } | null>(null);
+    const [groupedByPhase, setGroupedByPhase] = useState(false);
+    const groupedByPhaseRef = useRef(groupedByPhase);
+
+    useEffect(() => {
+        groupedByPhaseRef.current = groupedByPhase;
+    }, [groupedByPhase]);
 
     const incrementScenarioListRefreshKey = useCallback(() => {
         setScenarioListRefreshKey(prev => prev + 1);
@@ -202,8 +209,13 @@ const ScenarioEditorContent = () => {
     );
 
     const loadScenarioFromYaml = useCallback((newNodes: Node<NodeData>[], newEdges: Edge[], newConfig?: ScenarioConfig, newGroups?: Record<string, GroupDefinition>, newDescription?: string) => {
-        setNodes(newNodes);
         setEdges(newEdges);
+        // If phase grouping is active, apply it to the incoming nodes
+        if (groupedByPhaseRef.current) {
+            setNodes(applyPhaseGrouping(newNodes, newEdges));
+        } else {
+            setNodes(newNodes);
+        }
         if (newConfig) {
             setCurrentScenarioConfig(newConfig);
         }
@@ -676,6 +688,61 @@ const ScenarioEditorContent = () => {
         setIsDirty(true);
     }, [selectedNodes, edges, operations, nodes, setNodes, setEdges, setCurrentScenarioGroups]);
 
+    const toggleGroupByPhase = useCallback(() => {
+        setGroupedByPhase(prev => {
+            const willGroup = !prev;
+
+            if (willGroup) {
+                setNodes(currentNodes => {
+                    return applyPhaseGrouping(currentNodes, edgesRef.current);
+                });
+
+                globalThis.requestAnimationFrame(() => {
+                    reactFlowInstance?.fitView({ padding: 0.2, duration: 400 });
+                });
+            } else {
+                // Ungroup: remove phase containers, restore nodes to top-level
+                setNodes(currentNodes => {
+                    const phaseContainerIds = new Set(
+                        currentNodes.filter(n => n.data.isPhaseContainer).map(n => n.id)
+                    );
+
+                    if (phaseContainerIds.size === 0) return currentNodes;
+
+                    const result: Node<NodeData>[] = [];
+                    for (const node of currentNodes) {
+                        if (node.data.isPhaseContainer) continue; // remove phase containers
+
+                        if (node.parentId && phaseContainerIds.has(node.parentId)) {
+                            // Restore to top-level with absolute position
+                            const parent = currentNodes.find(n => n.id === node.parentId);
+                            const absX = (parent?.position.x ?? 0) + node.position.x;
+                            const absY = (parent?.position.y ?? 0) + node.position.y;
+                            result.push({
+                                ...node,
+                                parentId: undefined,
+                                position: { x: absX, y: absY },
+                            });
+                        } else {
+                            result.push(node);
+                        }
+                    }
+
+                    // Re-layout ungrouped nodes
+                    const currentEdges = edgesRef.current;
+                    const { nodes: layoutedNodes } = getLayoutedElements(result, currentEdges, 'TB');
+                    return layoutedNodes;
+                });
+
+                globalThis.requestAnimationFrame(() => {
+                    reactFlowInstance?.fitView({ padding: 0.2, duration: 400 });
+                });
+            }
+
+            return willGroup;
+        });
+    }, [setNodes, reactFlowInstance]);
+
     const onDragOver = useCallback((event: React.DragEvent) => {
         event.preventDefault();
         event.dataTransfer.dropEffect = 'move';
@@ -1046,6 +1113,8 @@ const ScenarioEditorContent = () => {
                 onRun={handleRun}
                 onStop={handleStop}
                 isRunning={isRunning}
+                groupedByPhase={groupedByPhase}
+                onToggleGroupByPhase={toggleGroupByPhase}
             />
 
             <div className={layoutStyles.workspace}>
@@ -1124,7 +1193,7 @@ const ScenarioEditorContent = () => {
                                             Group Selection
                                         </button>
                                     )}
-                                    {selectedNode?.data.isGroupContainer && (
+                                    {selectedNode?.data.isGroupContainer && !selectedNode?.data.isPhaseContainer && (
                                         <button
                                             onClick={ungroupSelectedNode}
                                             style={{
diff --git a/web-editor/src/components/ScenarioEditor/CustomNode.tsx b/web-editor/src/components/ScenarioEditor/CustomNode.tsx
index f3e8d3ae..ae64453c 100644
--- a/web-editor/src/components/ScenarioEditor/CustomNode.tsx
+++ b/web-editor/src/components/ScenarioEditor/CustomNode.tsx
@@ -1,9 +1,33 @@
 
 import { Handle, Position, type NodeProps, type Node } from '@xyflow/react';
-import { Box, CheckCircle, XCircle, AlertTriangle, Loader2, MinusCircle, RotateCw, GitBranch, Timer, Hourglass } from 'lucide-react';
+import { Box, CheckCircle, XCircle, AlertTriangle, Loader2, MinusCircle, RotateCw, GitBranch, Timer, Hourglass, Plane } from 'lucide-react';
 import styles from '../../styles/Node.module.css';
+import { getPhaseColor } from '../../utils/phaseColors';
 import type { NodeData } from '../../types/scenario';
 
+const ModifierBadges = ({ data }: { data: NodeData }) => (
+    <div className={styles.modifierBadges}>
+        {data.runInBackground && (
+            <div className={styles.backgroundBadge} title="Runs in background">
+                <Timer size={14} />
+                <span>bg</span>
+            </div>
+        )}
+        {data.ifCondition && data.ifCondition.trim() !== '' && (
+            <div className={styles.conditionBadge} title={`Condition: ${data.ifCondition}`}>
+                <GitBranch size={14} />
+                <span>if</span>
+            </div>
+        )}
+        {data.loop && (
+            <div className={styles.loopBadge} title={`Loop: ${JSON.stringify(data.loop)}`}>
+                <RotateCw size={14} />
+                <span>loop</span>
+            </div>
+        )}
+    </div>
+);
+
 export const CustomNode = ({ data, selected }: NodeProps<Node<NodeData>>) => {
     const isGroupContainer = data.isGroupContainer;
 
@@ -22,63 +46,60 @@ export const CustomNode = ({ data, selected }: NodeProps<Node<NodeData>>) => {
 
     const selectedClass = selected ? styles.selected : '';
 
+    // Render phase containers with phase-colored label bar
+    if (isGroupContainer && data.isPhaseContainer) {
+        const colors = getPhaseColor(data.phase as string);
+        return (
+            <div
+                className={`${styles.groupContainerLabel} ${styles.phaseContainerLabel} ${selectedClass}`}
+                style={{
+                    backgroundColor: colors.bg,
+                    borderColor: colors.border,
+                }}
+            >
+                <div className={styles.groupLabelContent}>
+                    <Plane size={14} aria-hidden="true" style={{ color: colors.text }} />
+                    <span style={{ color: colors.text }}>{data.label}</span>
+                </div>
+            </div>
+        );
+    }
+
     // Render group containers with label and badges overlay
     if (isGroupContainer) {
         return (
             <div className={`${styles.groupContainerLabel} ${selectedClass}`}>
                 <div className={styles.groupLabelContent}>
                     <span>{data.label}</span>
-                    <div className={styles.modifierBadges}>
-                        {data.runInBackground && (
-                            <div className={styles.backgroundBadge} title="Runs in background">
-                                <Timer size={14} />
-                                <span>bg</span>
-                            </div>
-                        )}
-                        {data.ifCondition && data.ifCondition.trim() !== '' && (
-                            <div className={styles.conditionBadge} title={`Condition: ${data.ifCondition}`}>
-                                <GitBranch size={14} />
-                                <span>if</span>
-                            </div>
-                        )}
-                        {data.loop && (
-                            <div className={styles.loopBadge} title={`Loop: ${JSON.stringify(data.loop)}`}>
-                                <RotateCw size={14} />
-                                <span>loop</span>
-                            </div>
-                        )}
-                    </div>
+                    <ModifierBadges data={data} />
                 </div>
             </div>
         );
     }
 
+    const phaseColors = data.phase ? getPhaseColor(data.phase) : null;
+
     return (
         <div className={`${styles.customNode} ${statusClass} ${selectedClass}`}>
             <Handle type="target" position={Position.Top} style={{ background: 'var(--rf-handle)' }} />
             <div className={styles.customNodeHeader}>
                 <Box size={16} className={styles.icon} />
                 <span>{data.label}</span>
-                <div className={styles.modifierBadges}>
-                    {data.runInBackground && (
-                        <div className={styles.backgroundBadge} title="Runs in background">
-                            <Timer size={14} />
-                            <span>bg</span>
-                        </div>
-                    )}
-                    {data.ifCondition && data.ifCondition.trim() !== '' && (
-                        <div className={styles.conditionBadge} title={`Condition: ${data.ifCondition}`}>
-                            <GitBranch size={14} />
-                            <span>if</span>
-                        </div>
-                    )}
-                    {data.loop && (
-                        <div className={styles.loopBadge} title={`Loop: ${JSON.stringify(data.loop)}`}>
-                            <RotateCw size={14} />
-                            <span>loop</span>
-                        </div>
-                    )}
-                </div>
+                {phaseColors && (
+                    <div
+                        className={styles.phaseBadge}
+                        title={`Flight phase: ${data.phase}`}
+                        style={{
+                            backgroundColor: phaseColors.bg,
+                            color: phaseColors.text,
+                            border: `1px solid ${phaseColors.border}`,
+                        }}
+                    >
+                        <Plane size={12} />
+                        <span>{data.phase}</span>
+                    </div>
+                )}
+                <ModifierBadges data={data} />
                 {data.status && (
                     <div className={styles.statusIndicator} data-testid={`status-${data.status}`}>
                         {data.status === 'success' && (
diff --git a/web-editor/src/components/ScenarioEditor/Header.tsx b/web-editor/src/components/ScenarioEditor/Header.tsx
index 10b62de5..1a3df910 100644
--- a/web-editor/src/components/ScenarioEditor/Header.tsx
+++ b/web-editor/src/components/ScenarioEditor/Header.tsx
@@ -1,4 +1,4 @@
-import { Activity, Moon, Sun, Layout, FilePlus, Save, Play, Loader2, Copy, Square } from 'lucide-react';
+import { Activity, Moon, Sun, Layout, FilePlus, Save, Play, Loader2, Copy, Square, Layers } from 'lucide-react';
 import styles from '../../styles/Header.module.css';
 import btnStyles from '../../styles/Button.module.css';
 
@@ -12,6 +12,8 @@ interface HeaderProps {
     onRun: () => void;
     onStop: () => void;
     isRunning: boolean;
+    groupedByPhase: boolean;
+    onToggleGroupByPhase: () => void;
 }
 
 export const Header = ({
@@ -24,6 +26,8 @@ export const Header = ({
     onRun,
     onStop,
     isRunning,
+    groupedByPhase,
+    onToggleGroupByPhase,
 }: HeaderProps) => {
     return (
         <header className={styles.header}>
@@ -39,6 +43,15 @@ export const Header = ({
                     <Layout size={16} />
                     Auto Layout
                 </button>
+                <button
+                    className={`${btnStyles.button} ${groupedByPhase ? btnStyles.active : ''}`}
+                    onClick={onToggleGroupByPhase}
+                    title={groupedByPhase ? 'Ungroup phase containers' : 'Group nodes by flight phase'}
+                    type="button"
+                >
+                    <Layers size={16} />
+                    {groupedByPhase ? 'Ungroup Phases' : 'Group by Phase'}
+                </button>
                 <button className={btnStyles.button} onClick={onNew} title="Create new scenario" type="button">
                     <FilePlus size={16} />
                     New
diff --git a/web-editor/src/components/ScenarioEditor/PropertiesPanel.tsx b/web-editor/src/components/ScenarioEditor/PropertiesPanel.tsx
index 01c2ad36..1d1ed6be 100644
--- a/web-editor/src/components/ScenarioEditor/PropertiesPanel.tsx
+++ b/web-editor/src/components/ScenarioEditor/PropertiesPanel.tsx
@@ -1,10 +1,11 @@
 import React, { useState, useMemo } from 'react';
-import { X, Link as LinkIcon, Unlink } from 'lucide-react';
+import { X, Link as LinkIcon, Unlink, Plane } from 'lucide-react';
 import type { Node } from '@xyflow/react';
 import layoutStyles from '../../styles/EditorLayout.module.css';
 import styles from '../../styles/SidebarPanel.module.css';
 import type { NodeData } from '../../types/scenario';
 import { useSidebarResize } from '../../hooks/useSidebarResize';
+import { getPhaseColor } from '../../utils/phaseColors';
 
 const DocstringViewer = ({ text }: { text: string }) => {
     const [expanded, setExpanded] = useState(false);
@@ -163,6 +164,25 @@ export const PropertiesPanel = ({ selectedNode, connectedNodes, allNodes, onClos
                     <h3>{selectedNode.data.label}</h3>
                     <div style={{ fontSize: '11px', color: 'var(--text-secondary)', marginBottom: '12px' }}>
                         <div style={{ fontFamily: 'monospace' }}>Node ID: {selectedNode.id}</div>
+                        {selectedNode.data.phase && (
+                            <div style={{ marginTop: '4px' }}>
+                                <span style={{
+                                    display: 'inline-flex',
+                                    alignItems: 'center',
+                                    gap: '4px',
+                                    padding: '2px 8px',
+                                    borderRadius: '10px',
+                                    backgroundColor: getPhaseColor(selectedNode.data.phase!).bg,
+                                    color: getPhaseColor(selectedNode.data.phase!).text,
+                                    border: `1px solid ${getPhaseColor(selectedNode.data.phase!).border}`,
+                                    fontSize: '11px',
+                                    fontWeight: 600
+                                }}>
+                                    <Plane size={12} aria-hidden />
+                                    {selectedNode.data.phase}
+                                </span>
+                            </div>
+                        )}
                     </div>
 
                     <div className={styles.paramItem}>
diff --git a/web-editor/src/components/ScenarioEditor/Toolbox.tsx b/web-editor/src/components/ScenarioEditor/Toolbox.tsx
index b9c446f6..ad2eb807 100644
--- a/web-editor/src/components/ScenarioEditor/Toolbox.tsx
+++ b/web-editor/src/components/ScenarioEditor/Toolbox.tsx
@@ -1,10 +1,13 @@
 import { useState, useMemo } from 'react';
 import { ChevronDown, ChevronRight, Box } from 'lucide-react';
 import styles from '../../styles/Toolbox.module.css';
+import { getPhaseColor, PHASE_LABELS, PHASE_ORDER } from '../../utils/phaseColors';
 import layoutStyles from '../../styles/EditorLayout.module.css';
 import type { Operation } from '../../types/scenario';
 
-const ToolboxGroup = ({ title, ops }: { title: string, ops: Operation[] }) => {
+type GroupBy = 'client' | 'phase';
+
+const ToolboxGroup = ({ title, ops, badge }: { title: string, ops: Operation[], badge?: { code: string } }) => {
     const [isExpanded, setIsExpanded] = useState(true);
 
     return (
@@ -16,6 +19,16 @@ const ToolboxGroup = ({ title, ops }: { title: string, ops: Operation[] }) => {
                 type="button"
             >
                 {isExpanded ? <ChevronDown size={14} /> : <ChevronRight size={14} />}
+                {badge && (
+                    <span
+                        className={styles.phaseBadge}
+                        style={{
+                            backgroundColor: getPhaseColor(badge.code).bg,
+                            color: getPhaseColor(badge.code).text,
+                            border: `1px solid ${getPhaseColor(badge.code).border}`,
+                        }}
+                    >{badge.code}</span>
+                )}
                 {title}
             </button>
             {isExpanded && (
@@ -24,7 +37,7 @@ const ToolboxGroup = ({ title, ops }: { title: string, ops: Operation[] }) => {
                         <div
                             key={op.id}
                             className={styles.nodeItem}
-                            title={op.name}
+                            title={op.phase ? `${op.name} [${op.phase}]` : op.name}
                             onDragStart={(event) => {
                                 event.dataTransfer.setData('application/reactflow', op.name);
                                 event.dataTransfer.setData('application/reactflow/id', op.id);
@@ -34,7 +47,19 @@ const ToolboxGroup = ({ title, ops }: { title: string, ops: Operation[] }) => {
                             tabIndex={0}
                         >
                             <Box size={16} color="#8b949e" />
-                            <span>{op.name}</span>
+                            <div className={styles.nodeItemContent}>
+                                <span>{op.name}</span>
+                                {op.phase && (
+                                    <span
+                                        className={styles.phaseBadge}
+                                        style={{
+                                            backgroundColor: getPhaseColor(op.phase).bg,
+                                            color: getPhaseColor(op.phase).text,
+                                            border: `1px solid ${getPhaseColor(op.phase).border}`,
+                                        }}
+                                    >{op.phase}</span>
+                                )}
+                            </div>
                         </div>
                     ))}
                 </div>
@@ -45,8 +70,9 @@ const ToolboxGroup = ({ title, ops }: { title: string, ops: Operation[] }) => {
 
 export const Toolbox = ({ operations, children }: { operations: Operation[], children?: React.ReactNode }) => {
     const [activeTab, setActiveTab] = useState<'toolbox' | 'scenarios'>('scenarios');
+    const [groupBy, setGroupBy] = useState<GroupBy>('client');
 
-    const groupedOperations = useMemo(() => {
+    const groupedByClient = useMemo(() => {
         const grouped = operations.reduce((acc, op) => {
             const groupName = op.category || 'General';
             if (!acc[groupName]) {
@@ -63,6 +89,34 @@ export const Toolbox = ({ operations, children }: { operations: Operation[], chi
         return { grouped, sortedKeys };
     }, [operations]);
 
+    const groupedByPhase = useMemo(() => {
+        const grouped = operations.reduce((acc, op) => {
+            const phase = op.phase || '_none';
+            if (!acc[phase]) {
+                acc[phase] = [];
+            }
+            acc[phase].push(op);
+            return acc;
+        }, {} as Record<string, Operation[]>);
+
+        // Sort keys: known phases in flight order, then unknown, then _none last
+        const sortedKeys = Object.keys(grouped).sort((a, b) => {
+            const ai = PHASE_ORDER.indexOf(a);
+            const bi = PHASE_ORDER.indexOf(b);
+            if (a === '_none') return 1;
+            if (b === '_none') return -1;
+            if (ai >= 0 && bi >= 0) return ai - bi;
+            if (ai >= 0) return -1;
+            if (bi >= 0) return 1;
+            return a.localeCompare(b);
+        });
+
+        for (const key of sortedKeys) {
+            grouped[key].sort((a, b) => a.name.localeCompare(b.name));
+        }
+        return { grouped, sortedKeys };
+    }, [operations]);
+
     return (
         <aside className={layoutStyles.sidebar}>
             <div className={styles.tabContainer}>
@@ -82,13 +136,32 @@ export const Toolbox = ({ operations, children }: { operations: Operation[], chi
 
             <div className={styles.nodeList}>
                 {activeTab === 'toolbox' ? (
-                    groupedOperations.sortedKeys.map(category => (
-                        <ToolboxGroup
-                            key={category}
-                            title={category}
-                            ops={groupedOperations.grouped[category]}
-                        />
-                    ))
+                    <>
+                        <div className={styles.groupByToggle}>
+                            <span className={styles.groupByLabel}>Group by</span>
+                            <button
+                                className={`${styles.toggleOption} ${groupBy === 'client' ? styles.toggleActive : ''}`}
+                                onClick={() => setGroupBy('client')}
+                            >Client</button>
+                            <button
+                                className={`${styles.toggleOption} ${groupBy === 'phase' ? styles.toggleActive : ''}`}
+                                onClick={() => setGroupBy('phase')}
+                            >Phase</button>
+                        </div>
+                        {groupBy === 'client'
+                            ? groupedByClient.sortedKeys.map(category => (
+                                <ToolboxGroup key={category} title={category} ops={groupedByClient.grouped[category]} />
+                            ))
+                            : groupedByPhase.sortedKeys.map(phase => (
+                                <ToolboxGroup
+                                    key={phase}
+                                    title={phase === '_none' ? 'No Phase' : (PHASE_LABELS[phase] || phase)}
+                                    ops={groupedByPhase.grouped[phase]}
+                                    badge={phase !== '_none' ? { code: phase } : undefined}
+                                />
+                            ))
+                        }
+                    </>
                 ) : (
                     children
                 )}
diff --git a/web-editor/src/components/ScenarioEditor/__tests__/Header.test.tsx b/web-editor/src/components/ScenarioEditor/__tests__/Header.test.tsx
index a7548be7..2d3f976a 100644
--- a/web-editor/src/components/ScenarioEditor/__tests__/Header.test.tsx
+++ b/web-editor/src/components/ScenarioEditor/__tests__/Header.test.tsx
@@ -13,6 +13,8 @@ describe('Header', () => {
         onRun: vi.fn(),
         onStop: vi.fn(),
         isRunning: false,
+        groupedByPhase: false,
+        onToggleGroupByPhase: vi.fn(),
     };
 
     it('renders correctly', () => {
diff --git a/web-editor/src/hooks/useScenarioGraph.ts b/web-editor/src/hooks/useScenarioGraph.ts
index c97a7de2..6646a269 100644
--- a/web-editor/src/hooks/useScenarioGraph.ts
+++ b/web-editor/src/hooks/useScenarioGraph.ts
@@ -12,39 +12,60 @@ import dagre from '@dagrejs/dagre';
 import type { Operation, NodeData } from '../types/scenario';
 import { LAYOUT_CONFIG, COMMON_NODE_DEFAULTS, COMMON_EDGE_OPTIONS, getGroupHeight, GROUP_CONFIG } from '../utils/layoutConfig';
 
-const getLayoutedElements = (nodes: Node<NodeData>[], edges: Edge[], direction = LAYOUT_CONFIG.direction) => {
+export const getLayoutedElements = (nodes: Node<NodeData>[], edges: Edge[], direction = LAYOUT_CONFIG.direction) => {
     const dagreGraph = new dagre.graphlib.Graph();
     dagreGraph.setDefaultEdgeLabel(() => ({}));
     dagreGraph.setGraph({ rankdir: direction, nodesep: LAYOUT_CONFIG.nodeSep, ranksep: LAYOUT_CONFIG.rankSep });
 
+    // Identify container IDs so we can exclude their children from dagre
+    const containerIds = new Set(nodes.filter(n => n.data.isGroupContainer).map(n => n.id));
+
+    // Pre-compute child counts for containers
+    const childCounts = new Map<string, number>();
+    for (const id of containerIds) {
+        childCounts.set(id, nodes.filter(n => n.parentId === id).length);
+    }
+
     for (const node of nodes) {
+        // Skip children of containers — they will be positioned relative to parent
+        if (node.parentId && containerIds.has(node.parentId)) continue;
+
         let width = LAYOUT_CONFIG.nodeWidth;
         let height = LAYOUT_CONFIG.nodeHeight;
 
         if (node.data.isGroupContainer) {
-            // Calculate dynamic height based on children
-            const childCount = nodes.filter(n => n.parentId === node.id).length;
-            height = getGroupHeight(childCount);
+            height = getGroupHeight(childCounts.get(node.id) ?? 0);
             width = GROUP_CONFIG.width;
         }
 
         dagreGraph.setNode(node.id, { width, height });
     }
 
+    // Only add edges between nodes that are in the dagre graph
     for (const edge of edges) {
-        dagreGraph.setEdge(edge.source, edge.target);
+        if (dagreGraph.hasNode(edge.source) && dagreGraph.hasNode(edge.target)) {
+            dagreGraph.setEdge(edge.source, edge.target);
+        }
     }
 
     dagre.layout(dagreGraph);
 
     const layoutedNodes = nodes.map((node) => {
+        // Children of containers keep their relative positions
+        if (node.parentId && containerIds.has(node.parentId)) {
+            return { ...node, ...COMMON_NODE_DEFAULTS };
+        }
+
         const nodeWithPosition = dagreGraph.node(node.id);
+        const isContainer = node.data.isGroupContainer;
+        const w = isContainer ? GROUP_CONFIG.width : LAYOUT_CONFIG.nodeWidth;
+        const h = isContainer ? getGroupHeight(childCounts.get(node.id) ?? 0) : LAYOUT_CONFIG.nodeHeight;
         return {
             ...node,
             ...COMMON_NODE_DEFAULTS,
             position: {
-                x: nodeWithPosition.x - (node.data.isGroupContainer ? GROUP_CONFIG.width : LAYOUT_CONFIG.nodeWidth) / 2,
-                y: nodeWithPosition.y - (node.data.isGroupContainer ? getGroupHeight(nodes.filter(n => n.parentId === node.id).length) : LAYOUT_CONFIG.nodeHeight) / 2,
+                x: nodeWithPosition.x - w / 2,
+                y: nodeWithPosition.y - h / 2,
             },
         };
     });
@@ -129,6 +150,7 @@ export const useScenarioGraph = (initialNodesParams: Node<NodeData>[] = [], init
                         label: type,
                         operationId: opId,
                         description: operation?.description,
+                        phase: operation?.phase,
                         parameters: operation?.parameters ? JSON.parse(JSON.stringify(operation.parameters)) : [], // Deep copy parameters
                     },
                 };
diff --git a/web-editor/src/styles/Button.module.css b/web-editor/src/styles/Button.module.css
index 8c379dc9..c23c0bb1 100644
--- a/web-editor/src/styles/Button.module.css
+++ b/web-editor/src/styles/Button.module.css
@@ -56,3 +56,14 @@
   background-color: var(--danger);
   color: white;
 }
+
+.active {
+  background-color: var(--accent-primary);
+  color: white;
+  border-color: var(--accent-primary);
+}
+
+.active:hover {
+  background-color: var(--accent-hover);
+  border-color: var(--accent-hover);
+}
diff --git a/web-editor/src/styles/Node.module.css b/web-editor/src/styles/Node.module.css
index e1eba623..721e2c80 100644
--- a/web-editor/src/styles/Node.module.css
+++ b/web-editor/src/styles/Node.module.css
@@ -106,6 +106,18 @@
   margin-left: auto;
 }
 
+/* Flight phase badge */
+.phaseBadge {
+  display: flex;
+  align-items: center;
+  gap: 3px;
+  padding: 2px 6px;
+  border-radius: 4px;
+  font-size: 10px;
+  font-weight: 600;
+  white-space: nowrap;
+}
+
 .loopBadge,
 .conditionBadge,
 .backgroundBadge {
@@ -177,3 +189,13 @@
   background-color: rgba(255, 255, 255, 0.98);
   box-shadow: 0 4px 8px rgba(0, 0, 0, 0.15);
 }
+
+/* Phase container label override */
+.phaseContainerLabel {
+  border-width: 2px;
+  border-style: solid;
+}
+
+.phaseContainerLabel:hover {
+  filter: brightness(1.05);
+}
diff --git a/web-editor/src/styles/Toolbox.module.css b/web-editor/src/styles/Toolbox.module.css
index 6613a70b..44e4d258 100644
--- a/web-editor/src/styles/Toolbox.module.css
+++ b/web-editor/src/styles/Toolbox.module.css
@@ -59,6 +59,26 @@
   min-width: 0;
 }
 
+.nodeItemContent {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  min-width: 0;
+  flex: 1;
+}
+
+.nodeItemContent span {
+  flex: initial;
+}
+
+.phaseBadge {
+  font-size: 9px;
+  padding: 1px 5px;
+  border-radius: 6px;
+  font-weight: 600;
+  width: fit-content;
+}
+
 .nodeItem svg {
   flex-shrink: 0;
 }
@@ -102,3 +122,44 @@
   border-bottom-color: var(--accent-primary);
   background-color: var(--bg-primary);
 }
+
+.groupByToggle {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  margin-bottom: 4px;
+}
+
+.groupByLabel {
+  font-size: 11px;
+  color: var(--text-tertiary);
+  margin-right: 4px;
+  white-space: nowrap;
+}
+
+.toggleOption {
+  font-size: 11px;
+  padding: 2px 8px;
+  border-radius: 4px;
+  border: 1px solid var(--border-color);
+  background: none;
+  color: var(--text-secondary);
+  cursor: pointer;
+  transition: all 0.15s ease;
+}
+
+.toggleOption:hover {
+  border-color: var(--accent-primary);
+  color: var(--text-primary);
+}
+
+.toggleActive {
+  background-color: var(--accent-primary);
+  color: #fff;
+  border-color: var(--accent-primary);
+}
+
+.toggleActive:hover {
+  background-color: var(--accent-primary);
+  color: #fff;
+}
diff --git a/web-editor/src/types/scenario.ts b/web-editor/src/types/scenario.ts
index 90f66285..5f7b83f8 100644
--- a/web-editor/src/types/scenario.ts
+++ b/web-editor/src/types/scenario.ts
@@ -12,6 +12,7 @@ export interface Operation {
     description: string;
     parameters: OperationParam[];
     category?: string;
+    phase?: string;
 }
 
 export interface NodeData extends Record<string, unknown> {
@@ -20,6 +21,7 @@ export interface NodeData extends Record<string, unknown> {
     operationId?: string;
     description?: string;
     parameters?: OperationParam[];
+    phase?: string;
     status?: 'success' | 'failure' | 'error' | 'running' | 'waiting' | 'skipped';
     result?: unknown;
     runInBackground?: boolean;
@@ -28,6 +30,7 @@ export interface NodeData extends Record<string, unknown> {
     needs?: string[];
     isGroupReference?: boolean;
     isGroupContainer?: boolean;
+    isPhaseContainer?: boolean;
     onShowResult?: (result: unknown) => void;
 }
 
@@ -69,6 +72,7 @@ export interface ScenarioDefinition {
 
 export interface StepResult {
     id: string;
+    phase?: string;
     status: 'success' | 'failure' | 'error';
     result: unknown;
     error?: string;
diff --git a/web-editor/src/utils/phaseColors.ts b/web-editor/src/utils/phaseColors.ts
new file mode 100644
index 00000000..96893f29
--- /dev/null
+++ b/web-editor/src/utils/phaseColors.ts
@@ -0,0 +1,52 @@
+/** Color mapping for flight phase codes. */
+const PHASE_COLORS: Record<string, { bg: string; text: string; border: string }> = {
+    FPL: { bg: 'rgba(99, 102, 241, 0.15)', text: '#6366f1', border: 'rgba(99, 102, 241, 0.4)' },     // Indigo — Flight Planning
+    PRF: { bg: 'rgba(59, 130, 246, 0.15)', text: '#3b82f6', border: 'rgba(59, 130, 246, 0.4)' },     // Blue — Pre-flight
+    ESD: { bg: 'rgba(6, 182, 212, 0.15)', text: '#06b6d4', border: 'rgba(6, 182, 212, 0.4)' },       // Cyan — Engine Start / Depart
+    TXO: { bg: 'rgba(168, 85, 247, 0.15)', text: '#a855f7', border: 'rgba(168, 85, 247, 0.4)' },     // Purple — Taxi Out
+    TOF: { bg: 'rgba(236, 72, 153, 0.15)', text: '#ec4899', border: 'rgba(236, 72, 153, 0.4)' },     // Pink — Takeoff
+    RTO: { bg: 'rgba(220, 38, 38, 0.15)', text: '#dc2626', border: 'rgba(220, 38, 38, 0.4)' },       // Red — Rejected Takeoff
+    ICL: { bg: 'rgba(245, 158, 11, 0.15)', text: '#f59e0b', border: 'rgba(245, 158, 11, 0.4)' },     // Amber — Initial Climb
+    ERC: { bg: 'rgba(132, 204, 22, 0.15)', text: '#84cc16', border: 'rgba(132, 204, 22, 0.4)' },     // Lime — En Route Climb
+    CRZ: { bg: 'rgba(34, 197, 94, 0.15)',  text: '#22c55e', border: 'rgba(34, 197, 94, 0.4)' },      // Green — Cruise
+    DES: { bg: 'rgba(20, 184, 166, 0.15)', text: '#14b8a6', border: 'rgba(20, 184, 166, 0.4)' },     // Teal — Descent
+    APR: { bg: 'rgba(249, 115, 22, 0.15)', text: '#f97316', border: 'rgba(249, 115, 22, 0.4)' },     // Orange — Approach
+    GAR: { bg: 'rgba(251, 191, 36, 0.15)', text: '#fbbf24', border: 'rgba(251, 191, 36, 0.4)' },     // Yellow — Go-around
+    LDG: { bg: 'rgba(239, 68, 68, 0.15)',  text: '#ef4444', border: 'rgba(239, 68, 68, 0.4)' },      // Red — Landing
+    TXI: { bg: 'rgba(168, 85, 247, 0.15)', text: '#a855f7', border: 'rgba(168, 85, 247, 0.4)' },     // Purple — Taxi In
+    AES: { bg: 'rgba(75, 85, 99, 0.15)', text: '#4b5563', border: 'rgba(75, 85, 99, 0.4)' },         // Gray — Arrival / Engine Shutdown
+    PST: { bg: 'rgba(107, 114, 128, 0.15)', text: '#6b7280', border: 'rgba(107, 114, 128, 0.4)' },   // Gray — Post-flight
+    FCL: { bg: 'rgba(156, 163, 175, 0.15)', text: '#9ca3af', border: 'rgba(156, 163, 175, 0.4)' },   // Light Gray — Flight Close
+    GND: { bg: 'rgba(120, 113, 108, 0.15)', text: '#78716c', border: 'rgba(120, 113, 108, 0.4)' },   // Stone — Ground Services
+};
+
+const DEFAULT_COLOR = { bg: 'rgba(107, 114, 128, 0.12)', text: '#6b7280', border: 'rgba(107, 114, 128, 0.3)' };
+
+export function getPhaseColor(phase: string) {
+    return PHASE_COLORS[phase] ?? DEFAULT_COLOR;
+}
+
+/** Human-readable labels for flight phase codes. */
+export const PHASE_LABELS: Record<string, string> = {
+    FPL: 'Flight Planning',
+    PRF: 'Pre-flight',
+    ESD: 'Engine Start / Depart',
+    TXO: 'Taxi Out',
+    TOF: 'Takeoff',
+    RTO: 'Rejected Takeoff',
+    ICL: 'Initial Climb',
+    ERC: 'En Route Climb',
+    CRZ: 'Cruise',
+    DES: 'Descent',
+    APR: 'Approach',
+    GAR: 'Go-around',
+    LDG: 'Landing',
+    TXI: 'Taxi In',
+    AES: 'Arrival / Engine Shutdown',
+    PST: 'Post-flight',
+    FCL: 'Flight Close',
+    GND: 'Ground Services',
+};
+
+/** Canonical ordering of phases (matches flight progression). */
+export const PHASE_ORDER = ['FPL', 'PRF', 'ESD', 'TXO', 'TOF', 'RTO', 'ICL', 'ERC', 'CRZ', 'DES', 'APR', 'GAR', 'LDG', 'TXI', 'AES', 'PST', 'FCL', 'GND'];
diff --git a/web-editor/src/utils/phaseGrouping.ts b/web-editor/src/utils/phaseGrouping.ts
new file mode 100644
index 00000000..a8584549
--- /dev/null
+++ b/web-editor/src/utils/phaseGrouping.ts
@@ -0,0 +1,191 @@
+import type { Node, Edge } from '@xyflow/react';
+import type { NodeData } from '../types/scenario';
+import { getPhaseColor, PHASE_LABELS, PHASE_ORDER } from './phaseColors';
+import { GROUP_CONFIG, getGroupHeight } from './layoutConfig';
+import { getLayoutedElements } from '../hooks/useScenarioGraph';
+
+/**
+ * Resolve phases for untagged nodes: if an untagged node sits between
+ * two nodes that share the same phase, it inherits that phase.
+ */
+const resolvePhases = (
+    topLevelSteps: Node<NodeData>[],
+    sequenceEdges: Edge[],
+): Map<string, string> => {
+    const predecessorMap = new Map<string, string>();
+    const successorMap = new Map<string, string>();
+    for (const e of sequenceEdges) {
+        predecessorMap.set(e.target, e.source);
+        successorMap.set(e.source, e.target);
+    }
+
+    const topLevelById = new Map(topLevelSteps.map(n => [n.id, n]));
+    const resolvedPhase = new Map<string, string>();
+    for (const node of topLevelSteps) {
+        if (node.data.phase) {
+            resolvedPhase.set(node.id, node.data.phase as string);
+        }
+    }
+
+    for (const node of topLevelSteps) {
+        if (resolvedPhase.has(node.id)) continue;
+
+        // Walk backwards to find nearest tagged predecessor
+        let predPhase: string | undefined;
+        let cur = node.id;
+        while (predecessorMap.has(cur)) {
+            cur = predecessorMap.get(cur)!;
+            const phase = resolvedPhase.get(cur) ?? (topLevelById.get(cur)?.data.phase as string | undefined);
+            if (phase) { predPhase = phase; break; }
+        }
+
+        // Walk forwards to find nearest tagged successor
+        let succPhase: string | undefined;
+        cur = node.id;
+        while (successorMap.has(cur)) {
+            cur = successorMap.get(cur)!;
+            const phase = resolvedPhase.get(cur) ?? (topLevelById.get(cur)?.data.phase as string | undefined);
+            if (phase) { succPhase = phase; break; }
+        }
+
+        if (predPhase && predPhase === succPhase) {
+            resolvedPhase.set(node.id, predPhase);
+        }
+    }
+
+    return resolvedPhase;
+};
+
+/**
+ * Build synthetic edges between phase containers and untagged top-level nodes
+ * so dagre stacks everything vertically.
+ */
+const buildSyntheticEdges = (
+    sequenceEdges: Edge[],
+    nodeToContainer: Map<string, string>,
+    newNodes: Node<NodeData>[],
+): Edge[] => {
+    const containerEdges: Edge[] = [];
+    const added = new Set<string>();
+
+    const addEdge = (source: string, target: string) => {
+        const key = `${source}->${target}`;
+        if (added.has(key)) return;
+        added.add(key);
+        containerEdges.push({
+            id: `phase_edge_${source}_${target}`,
+            source,
+            target,
+            type: 'default',
+        });
+    };
+
+    const topLevelIds = new Set(newNodes.filter(n => !n.parentId).map(n => n.id));
+
+    for (const edge of sequenceEdges) {
+        const srcContainer = nodeToContainer.get(edge.source);
+        const tgtContainer = nodeToContainer.get(edge.target);
+        const srcIsTopLevel = !srcContainer && topLevelIds.has(edge.source);
+        const tgtIsTopLevel = !tgtContainer && topLevelIds.has(edge.target);
+
+        if (srcContainer && tgtContainer && srcContainer !== tgtContainer) {
+            addEdge(srcContainer, tgtContainer);
+        } else if (srcIsTopLevel && tgtContainer) {
+            addEdge(edge.source, tgtContainer);
+        } else if (srcContainer && tgtIsTopLevel) {
+            addEdge(srcContainer, edge.target);
+        }
+    }
+
+    return containerEdges;
+};
+
+/** Apply phase grouping to a flat list of nodes, returning grouped + layouted nodes. */
+export const applyPhaseGrouping = (flatNodes: Node<NodeData>[], currentEdges: Edge[]): Node<NodeData>[] => {
+    const topLevelSteps = flatNodes.filter(
+        n => !n.data.isGroupContainer && !n.data.isPhaseContainer && !n.parentId
+    );
+
+    const sequenceEdges = currentEdges.filter(e => e.style?.strokeDasharray !== '5 5');
+    const resolvedPhase = resolvePhases(topLevelSteps, sequenceEdges);
+
+    // Group nodes by resolved phase
+    const phaseMap = new Map<string, Node<NodeData>[]>();
+    const noPhaseNodes: Node<NodeData>[] = [];
+    for (const node of topLevelSteps) {
+        const phase = resolvedPhase.get(node.id);
+        if (phase) {
+            if (!phaseMap.has(phase)) phaseMap.set(phase, []);
+            phaseMap.get(phase)!.push(node);
+        } else {
+            noPhaseNodes.push(node);
+        }
+    }
+
+    if (phaseMap.size === 0) return flatNodes;
+
+    // Existing user-created group containers and their children stay unchanged
+    const existingContainers = flatNodes.filter(
+        n => (n.data.isGroupContainer && !n.data.isPhaseContainer) ||
+             (n.parentId && flatNodes.some(p => p.id === n.parentId && p.data.isGroupContainer && !p.data.isPhaseContainer))
+    );
+
+    const newNodes: Node<NodeData>[] = [...existingContainers, ...noPhaseNodes];
+
+    const sortedPhases = [...phaseMap.keys()].sort(
+        (a, b) => (PHASE_ORDER.indexOf(a) === -1 ? 999 : PHASE_ORDER.indexOf(a)) -
+                  (PHASE_ORDER.indexOf(b) === -1 ? 999 : PHASE_ORDER.indexOf(b))
+    );
+
+    const nodeToContainer = new Map<string, string>();
+
+    for (const phase of sortedPhases) {
+        const phaseNodes = phaseMap.get(phase)!;
+        const containerId = `phase_container_${phase}`;
+        const colors = getPhaseColor(phase);
+        const label = PHASE_LABELS[phase] || phase;
+        const containerHeight = getGroupHeight(phaseNodes.length);
+
+        const containerNode: Node<NodeData> = {
+            id: containerId,
+            type: 'custom',
+            position: { x: 0, y: 0 },
+            data: {
+                label: `✈ ${label}`,
+                description: `Flight phase: ${label}`,
+                parameters: [],
+                isGroupContainer: true,
+                isPhaseContainer: true,
+                phase: phase,
+            },
+            style: {
+                background: colors.bg,
+                border: `2px solid ${colors.border}`,
+                borderRadius: '12px',
+                padding: '20px',
+                minWidth: `${GROUP_CONFIG.width}px`,
+                minHeight: `${containerHeight}px`,
+                width: `${GROUP_CONFIG.width}px`,
+                height: `${containerHeight}px`,
+            },
+        };
+        newNodes.push(containerNode);
+
+        phaseNodes.forEach((node, idx) => {
+            nodeToContainer.set(node.id, containerId);
+            newNodes.push({
+                ...node,
+                parentId: containerId,
+                position: {
+                    x: 80,
+                    y: GROUP_CONFIG.paddingTop + idx * (80 + 40),
+                },
+            });
+        });
+    }
+
+    const syntheticEdges = buildSyntheticEdges(sequenceEdges, nodeToContainer, newNodes);
+    const allEdgesForLayout = [...currentEdges, ...syntheticEdges];
+    const { nodes: layoutedNodes } = getLayoutedElements(newNodes, allEdgesForLayout, 'TB');
+    return layoutedNodes;
+};
diff --git a/web-editor/src/utils/scenarioConversion.ts b/web-editor/src/utils/scenarioConversion.ts
index 7ac30de5..68655e2e 100644
--- a/web-editor/src/utils/scenarioConversion.ts
+++ b/web-editor/src/utils/scenarioConversion.ts
@@ -123,6 +123,7 @@ export const convertYamlToGraph = (
                         stepId: groupStep.id || groupStep.step,
                         operationId: groupOperation?.id,
                         description: groupStep.description || groupOperation?.description || '',
+                        phase: groupOperation?.phase,
                         parameters: groupParameters
                     }
                 };
@@ -180,6 +181,7 @@ export const convertYamlToGraph = (
                     stepId: step.id,
                     operationId: operation?.id,
                     description: step.description || operation?.description || '',
+                    phase: operation?.phase,
                     parameters: parameters,
                     runInBackground: step.background,
                     ifCondition: step.if,
@@ -238,11 +240,19 @@ export const convertGraphToYaml = (
     const sequenceEdges = edges.filter(e => e.style?.strokeDasharray !== '5 5');
     const dependencyEdges = edges.filter(e => e.style?.strokeDasharray === '5 5');
 
-    // Identify group containers (nodes that are group references)
-    const groupContainerIds = new Set(nodes.filter(n => n.data.isGroupContainer).map(n => n.id));
+    // Identify group containers (nodes that are group references, NOT phase containers)
+    const groupContainerIds = new Set(nodes.filter(n => n.data.isGroupContainer && !n.data.isPhaseContainer).map(n => n.id));
+    const phaseContainerIds = new Set(nodes.filter(n => n.data.isPhaseContainer).map(n => n.id));
 
     // Filter out nodes that are inside group containers (they have a parentId that is a group container)
-    const topLevelNodes = nodes.filter(n => !n.parentId || !groupContainerIds.has(n.parentId));
+    // Phase container children are treated as top-level; phase containers themselves are excluded
+    const topLevelNodes = nodes.filter(n => {
+        if (n.data.isPhaseContainer) return false; // exclude phase containers
+        if (!n.parentId) return true; // top-level nodes
+        if (phaseContainerIds.has(n.parentId)) return true; // children of phase containers are top-level
+        if (groupContainerIds.has(n.parentId)) return false; // children of user groups are excluded
+        return true;
+    });
 
     // Sort nodes based on edges to determine order
     const targetIds = new Set(sequenceEdges.map(e => e.target).filter(id => topLevelNodes.some(n => n.id === id)));