feat: report EM observation planning cycles

ClumsyPilot/ParkrobTrajplanner/tarjplanner_movementtest/TrajectoryObservationPipeline.cs

@@ -255,12 +255,15 @@ public sealed class TrajectoryObservationController
 public sealed class TrajectoryObservationLoopTick
 {
     internal TrajectoryObservationLoopTick(TrajectoryObservationObservation observation,
-        PlanningCycleResult latestCycle, TimeSpan latestPlanningElapsed, bool planningInFlight)
+        PlanningCycleResult latestCycle, TimeSpan latestPlanningElapsed, bool planningInFlight,
+        bool planningStarted, bool planningCompleted)
     {
         Observation = observation ?? throw new ArgumentNullException(nameof(observation));
         LatestCycle = latestCycle;
         LatestPlanningElapsed = latestPlanningElapsed;
         PlanningInFlight = planningInFlight;
+        PlanningStarted = planningStarted;
+        PlanningCompleted = planningCompleted;
     }
 
     public TrajectoryObservationObservation Observation { get; }
@@ -271,6 +274,10 @@ public sealed class TrajectoryObservationLoopTick
 
     public bool PlanningInFlight { get; }
 
+    public bool PlanningStarted { get; }
+
+    public bool PlanningCompleted { get; }
+
     public bool ShouldLog => true;
 }
 
@@ -293,28 +300,31 @@ public sealed class TrajectoryObservationLoop
         if (state == null) throw new ArgumentNullException(nameof(state));
         cancellationToken.ThrowIfCancellationRequested();
 
-        ConsumeCompletedPlanning(now);
+        bool planningCompleted = ConsumeCompletedPlanning(now);
+        bool planningStarted = false;
         if (planningTask == null && controller.ShouldStartCycle(now))
         {
+            planningStarted = true;
             planningStartedAtUtc = now;
             planningTask = controller.StartCycle(now, state, cancellationToken);
-            ConsumeCompletedPlanning(now);
+            planningCompleted |= ConsumeCompletedPlanning(now);
         }
 
         TrajectoryObservationObservation observation = controller.Observe(now, state);
         return new TrajectoryObservationLoopTick(observation, latestCycle, latestPlanningElapsed,
-            planningTask != null);
+            planningTask != null, planningStarted, planningCompleted);
     }
 
-    private void ConsumeCompletedPlanning(DateTimeOffset observedAtUtc)
+    private bool ConsumeCompletedPlanning(DateTimeOffset observedAtUtc)
     {
         Task<PlanningCycleResult> completed = planningTask;
-        if (completed == null || !completed.IsCompleted) return;
+        if (completed == null || !completed.IsCompleted) return false;
 
         latestCycle = completed.GetAwaiter().GetResult();
         TimeSpan elapsed = observedAtUtc - planningStartedAtUtc;
         latestPlanningElapsed = elapsed < TimeSpan.Zero ? TimeSpan.Zero : elapsed;
         planningTask = null;
+        return true;
     }
 }