feat(benchmark): Stop button that saves a partial report

Add BenchmarkProgress.RequestStop()/StopRequested and a 'CoreAI/Benchmarks/Stop Running Benchmark
(save partial)' menu item. The suite loop checks the flag between scenario reps and breaks
gracefully — the report for everything finished so far is still written (same path as the soft
time-budget stop), instead of the whole run vanishing with no artifacts when Play mode is exited
mid-scenario.

Author: NeoXider

Assets/CoreAI/Runtime/Core/Features/Benchmarking/BenchmarkProgress.cs

@@ -38,6 +38,23 @@ public static class BenchmarkProgress
         /// <summary>Fraction 0..1 for a progress bar.</summary>
         public static float Fraction => Total <= 0 ? 0f : (float)Completed / Total;
 
+        /// <summary>
+        /// Cooperative stop flag. A Stop button sets it via <see cref="RequestStop"/>; the suite loop
+        /// checks it between scenario reps and, when set, breaks GRACEFULLY — the report for everything
+        /// finished so far is still written (same path as the soft time-budget stop), instead of the run
+        /// vanishing with no artifacts when Play mode is exited mid-scenario.
+        /// </summary>
+        public static bool StopRequested { get; private set; }
+
+        /// <summary>Requests a graceful stop of the running suite (partial report is still saved).</summary>
+        public static void RequestStop()
+        {
+            lock (Gate)
+            {
+                StopRequested = true;
+            }
+        }
+
         /// <summary>
         /// True when the current scenario's elapsed/remaining wall-clock time is known and worth showing -
         /// a single long-running scenario (e.g. G6's free build alone, <see cref="Total"/> == 1) sits at a
@@ -66,6 +83,7 @@ public static void Begin(int total, string modelId)
             lock (Gate)
             {
                 IsRunning = true;
+                StopRequested = false;
                 Total = total < 0 ? 0 : total;
                 Completed = 0;
                 ModelId = modelId ?? "";

Assets/CoreAIBenchmark/Tests/PlayMode/Benchmarks/GameCreationBenchmarkPlayModeTests.cs

@@ -288,6 +288,18 @@ public IEnumerator GameCreationBenchmark_Suite()
                     int scenarioReps = scenario.RepsOverride ?? repetitions;
                     for (int rep = 1; rep <= scenarioReps; rep++)
                     {
+                        // Manual Stop button (BenchmarkProgress.RequestStop): break GRACEFULLY between reps so
+                        // the report for everything finished so far is still written, instead of losing the
+                        // whole run when Play mode is exited mid-scenario. Same graceful path as the budget gate.
+                        if (BenchmarkProgress.StopRequested)
+                        {
+                            budgetHit = true;
+                            Debug.LogWarning(
+                                $"[Benchmark] Stop requested after {report.Results.Count} scenario result(s); " +
+                                "stopping early and writing the report for everything finished so far.");
+                            break;
+                        }
+
                         // Start-gate on every rep (not just per scenario). The worst case for the NUnit
                         // backstop is NOT one timeout: the retry loop below reruns a hard-failed attempt
                         // up to maxAttempts times, each allowed the full per-scenario timeout (which the

Assets/CoreAiUnity/Tests/EditMode/GameCreationBenchmarkLauncher.cs

@@ -203,6 +203,28 @@ public static void OpenIndex()
             EditorUtility.RevealInFinder(index);
         }
 
+        [MenuItem("CoreAI/Benchmarks/Stop Running Benchmark (save partial)", priority = 90)]
+        public static void StopRunningBenchmark()
+        {
+            if (!BenchmarkProgress.IsRunning)
+            {
+                EditorUtility.DisplayDialog("CoreAI Benchmark", "No benchmark is currently running.", "OK");
+                return;
+            }
+
+            // Cooperative stop: the suite loop breaks between scenario reps and still writes the report for
+            // everything finished so far (partial), instead of the run vanishing with no artifacts.
+            BenchmarkProgress.RequestStop();
+            Debug.Log("[Benchmark] Stop requested — the suite will finish the current scenario, then save a "
+                      + "partial report and exit.");
+        }
+
+        [MenuItem("CoreAI/Benchmarks/Stop Running Benchmark (save partial)", validate = true)]
+        public static bool StopRunningBenchmarkValidate()
+        {
+            return BenchmarkProgress.IsRunning && !BenchmarkProgress.StopRequested;
+        }
+
         [MenuItem("CoreAI/Benchmarks/Build Model Comparison Report", priority = 140)]
         public static void BuildComparisonReport()
         {