See the following UI example of flow listing per dataset:

The compacting flow was scheduled later than the planned update.
Since it did not have to wait for anything much, it got executed earlier than the planned update, which is still waiting for the next schedule tick in almost an hour.
Still, we display the compacting above the in-progress update.

If we take a look at in-memory repository implementation that backs this listing, there is no sorting at all, and the order is dependent on the order of flow creation (time of initiation event):

    #[tracing::instrument(level = "debug", skip_all, fields(%dataset_id, ?filters, ?pagination))]
    fn get_all_flow_ids_by_dataset(
        &self,
        dataset_id: &DatasetID,
        filters: DatasetFlowFilters,
        pagination: FlowPaginationOpts,
    ) -> FlowIDStream {
        let flow_ids_page: Vec<_> = {
            let state = self.inner.as_state();
            let g = state.lock().unwrap();
            g.all_flows_by_dataset
                .get(dataset_id)
                .map(|dataset_flow_ids| {
                    dataset_flow_ids
                        .iter()
                        .rev()
                        .filter(|flow_id| g.matches_dataset_flow(**flow_id, &filters))
                        .skip(pagination.offset)
                        .take(pagination.limit)
                        .map(|flow_id| Ok(*flow_id))
                        .collect()
                })
                .unwrap_or_default()
        };

        Box::pin(futures::stream::iter(flow_ids_page))
    }

The expectations are:

• finished flows should be below any waiting or running
• currently running flows should be below any waiting
• 2 or more completed flows should be sorted by completion time, earliest below
• 2 or more running flows should be ordered by the time running started, earliest below
• 2 or more waiting flows should be ordered by the time the latest event was recorded (such as condition change), earliest below

Update: now we should also account for this in the Postgres & Sqlite implementations.