fix: Compile reload diagnostics are now saved to VibeLog files

Assets/Tests/Editor/CompileSessionResultServiceTests.cs

@@ -1,8 +1,12 @@
 using System;
+using Newtonsoft.Json.Linq;
 using NUnit.Framework;
 using UnityEditor.Compilation;
 
+using io.github.hatayama.UnityCliLoop.Domain;
 using io.github.hatayama.UnityCliLoop.FirstPartyTools;
+using io.github.hatayama.UnityCliLoop.Infrastructure;
+using io.github.hatayama.UnityCliLoop.ToolContracts;
 
 namespace io.github.hatayama.UnityCliLoop.Tests.Editor
 {
@@ -138,5 +142,53 @@ public void CreateCompileResult_WhenForceCompileHasPreservedFailure_MapsDetailed
             Assert.That(response.Errors[0].File, Is.EqualTo("Assets/Scenes/SampleScene.unity"));
             Assert.That(response.Message, Does.Contain("externally"));
         }
+
+        [Test]
+        public void StoreCompileResult_WhenRequestAlreadyHasResult_WritesDuplicateVibeLogContext()
+        {
+            // Verifies duplicate compile result stores are detectable from Unity-side diagnostics.
+            UnityCliLoopEditorSessionStateService sessionStateService =
+                UnityCliLoopEditorSessionStateTestFactory.CreateService();
+            UnityCliLoopEditorSessionStateSnapshot originalSnapshot =
+                UnityCliLoopEditorSessionStateTestFactory.CaptureSnapshot(sessionStateService);
+
+            try
+            {
+                sessionStateService.ClearAll();
+                VibeLogger.ClearMemoryLogs();
+                UnityCliLoopCompileResult result = new UnityCliLoopCompileResult
+                {
+                    Success = true,
+                    ErrorCount = 0,
+                    WarningCount = 0,
+                };
+
+                CompileSessionResultService.StoreCompileResult(
+                    sessionStateService,
+                    "compile_duplicate_store_request",
+                    forceRecompile: false,
+                    result,
+                    "compile_duplicate_store_request");
+                CompileSessionResultService.StoreCompileResult(
+                    sessionStateService,
+                    "compile_duplicate_store_request",
+                    forceRecompile: false,
+                    result,
+                    "compile_duplicate_store_request");
+
+                JArray logs = JArray.Parse(VibeLogger.GetLogsForAi("compile_result_session_state_store_complete"));
+                Assert.That(logs, Has.Count.EqualTo(2));
+                JObject secondContext = (JObject)logs[1]["context"];
+                Assert.That(secondContext["duplicate_result_for_request"]?.Value<bool>(), Is.True);
+                Assert.That(secondContext["store_sequence"]?.Value<int>(), Is.EqualTo(2));
+                Assert.That(secondContext["pending_request_before"]?.Value<bool>(), Is.False);
+                Assert.That(secondContext["pending_request_cleared"]?.Value<bool>(), Is.False);
+            }
+            finally
+            {
+                VibeLogger.ClearMemoryLogs();
+                originalSnapshot.Restore(sessionStateService);
+            }
+        }
     }
 }

Assets/Tests/Editor/CompileStatusBridgeCommandTests.cs

@@ -3,6 +3,7 @@
 
 using io.github.hatayama.UnityCliLoop.Domain;
 using io.github.hatayama.UnityCliLoop.Infrastructure;
+using io.github.hatayama.UnityCliLoop.ToolContracts;
 
 namespace io.github.hatayama.UnityCliLoop.Tests.Editor
 {
@@ -26,6 +27,7 @@ public void SetUp()
         [TearDown]
         public void TearDown()
         {
+            VibeLogger.ClearMemoryLogs();
             _originalSnapshot.Restore(_sessionStateService);
         }
 
@@ -189,5 +191,96 @@ public void BuildResponse_WhenForceCompilePendingRequestHasNoResult_ReturnsNullM
             Assert.That(response.Result["ErrorCount"]?.Type, Is.EqualTo(JTokenType.Null));
             Assert.That(response.Result["Message"]?.Type, Is.EqualTo(JTokenType.Null));
         }
+
+        [Test]
+        public void BuildResponse_WhenStatusIsQueried_WritesVibeLogContext()
+        {
+            // Verifies status polling leaves enough Unity-side context to correlate CLI wait diagnostics.
+            VibeLogger.ClearMemoryLogs();
+            string requestId = "compile_status_log_request_" + System.Guid.NewGuid().ToString("N");
+
+            GetCompileStatusResponse response = CompileStatusBridgeCommand.BuildResponse(
+                requestId,
+                isCompiling: true,
+                isUpdating: false,
+                isDomainReloadInProgress: false,
+                _sessionStateService);
+
+            Assert.That(response.Ready, Is.False);
+            JArray logs = JArray.Parse(VibeLogger.GetLogsForAi("compile_status_query_received"));
+            Assert.That(logs, Has.Count.EqualTo(1));
+            JObject context = (JObject)logs[0]["context"];
+            Assert.That(context["request_id"]?.ToString(), Is.EqualTo(requestId));
+            Assert.That(context["ready"]?.Value<bool>(), Is.False);
+            Assert.That(context["has_result"]?.Value<bool>(), Is.False);
+            Assert.That(context["is_compiling"]?.Value<bool>(), Is.True);
+            Assert.That(context["message"]?.ToString(), Does.Contain("still compiling"));
+        }
+
+        [Test]
+        public void BuildResponse_WhenReadyStatusRepeats_DoesNotRetainDuplicateSuppressionCache()
+        {
+            // Verifies completed status signatures do not stay in the duplicate-suppression cache.
+            VibeLogger.ClearMemoryLogs();
+            string requestId = "compile_status_ready_cache_request_" + System.Guid.NewGuid().ToString("N");
+
+            CompileStatusBridgeCommand.BuildResponse(
+                requestId,
+                isCompiling: true,
+                isUpdating: false,
+                isDomainReloadInProgress: false,
+                _sessionStateService);
+            CompileStatusBridgeCommand.BuildResponse(
+                requestId,
+                isCompiling: true,
+                isUpdating: false,
+                isDomainReloadInProgress: false,
+                _sessionStateService);
+            CompileStatusBridgeCommand.BuildResponse(
+                requestId,
+                isCompiling: false,
+                isUpdating: false,
+                isDomainReloadInProgress: false,
+                _sessionStateService);
+            CompileStatusBridgeCommand.BuildResponse(
+                requestId,
+                isCompiling: false,
+                isUpdating: false,
+                isDomainReloadInProgress: false,
+                _sessionStateService);
+
+            JArray logs = JArray.Parse(VibeLogger.GetLogsForAi("compile_status_query_received"));
+            Assert.That(logs, Has.Count.EqualTo(3));
+        }
+
+        [Test]
+        public void BuildResponse_WhenManyUniqueBusyRequestsAreQueried_BoundsDuplicateSuppressionCache()
+        {
+            // Verifies arbitrary status probes cannot grow the duplicate-suppression cache forever.
+            VibeLogger.ClearMemoryLogs();
+            const int requestCount = 257;
+            string requestPrefix = "compile_status_cache_request_" + System.Guid.NewGuid().ToString("N") + "_";
+
+            for (int index = 0; index < requestCount; index++)
+            {
+                CompileStatusBridgeCommand.BuildResponse(
+                    requestPrefix + index,
+                    isCompiling: true,
+                    isUpdating: false,
+                    isDomainReloadInProgress: false,
+                    _sessionStateService);
+            }
+
+            CompileStatusBridgeCommand.BuildResponse(
+                requestPrefix + "0",
+                isCompiling: true,
+                isUpdating: false,
+                isDomainReloadInProgress: false,
+                _sessionStateService);
+
+            JArray logs = JArray.Parse(
+                VibeLogger.GetLogsForAi("compile_status_query_received", maxCount: requestCount + 1));
+            Assert.That(logs, Has.Count.EqualTo(requestCount + 1));
+        }
     }
 }

Assets/Tests/Editor/VibeLoggerTests.cs

@@ -0,0 +1,65 @@
+using System;
+using System.IO;
+using NUnit.Framework;
+
+using io.github.hatayama.UnityCliLoop.ToolContracts;
+
+namespace io.github.hatayama.UnityCliLoop.Tests.Editor
+{
+    /// <summary>
+    /// Tests VibeLogger append diagnostics without relying on the Unity request pipeline.
+    /// </summary>
+    [TestFixture]
+    public sealed class VibeLoggerTests
+    {
+        private const string LogFilePrefix = "unity_vibe";
+
+        [Test]
+        public void LogInfo_WhenExistingLogFileHasMalformedOldLine_DoesNotScanWholeFile()
+        {
+            // Verifies append integrity diagnostics inspect only the newly appended JSONL tail.
+            string logFilePath = CurrentLogFilePath();
+            string logDirectory = Path.GetDirectoryName(logFilePath);
+            Assert.That(logDirectory, Is.Not.Null);
+            Directory.CreateDirectory(logDirectory);
+
+            bool hadOriginalFile = File.Exists(logFilePath);
+            string originalContent = hadOriginalFile ? File.ReadAllText(logFilePath) : "";
+
+            try
+            {
+                File.WriteAllText(logFilePath, "{\"operation\":\"old_valid\"}\n{malformed_json\n");
+
+                VibeLoggerService logger = new VibeLoggerService();
+                logger.LogInfo(
+                    "vibe_logger_tail_validation_test",
+                    "Tail validation should ignore malformed historical content.");
+
+                string updatedContent = File.ReadAllText(logFilePath);
+                Assert.That(updatedContent, Does.Contain("vibe_logger_tail_validation_test"));
+                Assert.That(updatedContent, Does.Not.Contain("vibe_log_write_interleaving_detected"));
+            }
+            finally
+            {
+                if (hadOriginalFile)
+                {
+                    File.WriteAllText(logFilePath, originalContent);
+                }
+                else if (File.Exists(logFilePath))
+                {
+                    File.Delete(logFilePath);
+                }
+            }
+        }
+
+        private static string CurrentLogFilePath()
+        {
+            string projectRoot = Path.GetFullPath(Path.Combine(UnityEngine.Application.dataPath, ".."));
+            return Path.Combine(
+                projectRoot,
+                UnityCliLoopConstants.OUTPUT_ROOT_DIR,
+                UnityCliLoopConstants.VIBE_LOGS_DIR,
+                $"{LogFilePrefix}_{DateTime.UtcNow:yyyyMMdd}.json");
+        }
+    }
+}

Packages/src/Editor/FirstPartyTools/Compile/CompileController.cs

@@ -24,6 +24,7 @@ public class CompileController : IDisposable
         private bool _isForceCompile = false;
         private bool _reloadExternalSceneChanges = true;
         private CompileResultRecordingContext _resultRecordingContext = CompileResultRecordingContext.Disabled();
+        private DateTime _compileStartedAtUtc = DateTime.MinValue;
 
         /// <summary>
         /// Event that occurs when compilation is complete.
@@ -137,6 +138,7 @@ public async Task<CompileResult> TryCompileAsync(bool forceRecompile, Cancellati
             TaskCompletionSource<CompileResult> compileTask = new();
             _currentCompileTask = compileTask;
             _isForceCompile = forceRecompile;
+            _compileStartedAtUtc = DateTime.UtcNow;
             bool eventsRegistered = false;
             bool compileTaskTransferred = false;
 
@@ -542,9 +544,33 @@ public void ClearMessages()
         private void HandleCompileFinished(object context)
         {
             CompileResult result = CreateCompileResult();
+            VibeLogger.LogInfo(
+                "compile_finish_callback_received",
+                "Unity compilationFinished callback fired.",
+                BuildCompileFinishCallbackContext(result),
+                _resultRecordingContext.Enabled ? _resultRecordingContext.RequestId : null);
             CompleteCompileRequest(result, unregisterEvents: true);
         }
 
+        private object BuildCompileFinishCallbackContext(CompileResult result)
+        {
+            UnityEngine.Debug.Assert(result != null, "result must not be null");
+
+            DateTime utcNow = DateTime.UtcNow;
+            double elapsedMs = _compileStartedAtUtc == DateTime.MinValue
+                ? 0
+                : (utcNow - _compileStartedAtUtc).TotalMilliseconds;
+            return new
+            {
+                request_id = _resultRecordingContext.Enabled ? _resultRecordingContext.RequestId : "",
+                success = result.Success,
+                error_count = result.ErrorCount,
+                warning_count = result.WarningCount,
+                is_indeterminate = result.IsIndeterminate,
+                elapsed_ms = Math.Max(0, (int)elapsedMs)
+            };
+        }
+
         /// <summary>
         /// Handler for when assembly compilation is complete.
         /// </summary>
@@ -755,6 +781,7 @@ public void Cleanup()
             _isForceCompile = false;
             _reloadExternalSceneChanges = true;
             _resultRecordingContext = CompileResultRecordingContext.Disabled();
+            _compileStartedAtUtc = DateTime.MinValue;
         }
 
         /// <summary>

Packages/src/Editor/FirstPartyTools/Compile/CompileSessionResultService.cs

@@ -60,6 +60,10 @@ internal static void StoreCompileResult(
             Debug.Assert(!string.IsNullOrWhiteSpace(requestId), "requestId must not be null or whitespace");
             Debug.Assert(result != null, "result must not be null");
 
+            UnityCliLoopStoredCompileResult existingResult =
+                sessionStateService.GetCompileResult(requestId);
+            UnityCliLoopPendingCompileRequest pendingRequest =
+                sessionStateService.GetPendingCompileRequestForRequestId(requestId);
             result.ProjectRoot = UnityCliLoopPathResolver.GetProjectRoot();
             string resultJson = JsonConvert.SerializeObject(result, Formatting.None);
             sessionStateService.StoreCompileResult(
@@ -80,7 +84,10 @@ internal static void StoreCompileResult(
                     error_count = result.ErrorCount,
                     warning_count = result.WarningCount,
                     result_bytes = System.Text.Encoding.UTF8.GetByteCount(resultJson),
-                    pending_request_cleared = pendingRequestCleared
+                    store_sequence = existingResult.HasResult ? 2 : 1,
+                    pending_request_before = pendingRequest.HasRequest,
+                    pending_request_cleared = pendingRequestCleared,
+                    duplicate_result_for_request = existingResult.HasResult
                 },
                 correlationId);
         }

Packages/src/Editor/FirstPartyTools/Compile/CompileUseCase.cs

@@ -42,6 +42,7 @@ public async Task<UnityCliLoopCompileResult> CompileAsync(UnityCliLoopCompileReq
 
             PrepareResultStorage(request);
             string correlationId = ResolveCorrelationId(request);
+            LogCompileRequestReceived(request, correlationId);
 
             DateTime utcNow = DateTime.UtcNow;
             _sessionStateService.ClearExpiredCompileResult(utcNow);
@@ -245,10 +246,24 @@ private void MarkPendingCompileRequestIfNeeded(
             }
 
             Debug.Assert(!string.IsNullOrWhiteSpace(request.RequestId), "request.RequestId must not be null or whitespace");
+            UnityCliLoopPendingCompileRequest previousRequest =
+                _sessionStateService.GetPendingCompileRequest();
             _sessionStateService.MarkPendingCompileRequest(
                 request.RequestId,
                 request.ForceRecompile,
                 markedAtUtc);
+            VibeLogger.LogInfo(
+                "compile_request_registered_for_status_polling",
+                "Registered compile request for CLI status polling.",
+                new
+                {
+                    request_id = request.RequestId,
+                    pending_request_replaced =
+                        previousRequest.HasRequest && previousRequest.RequestId != request.RequestId,
+                    previous_request_id = previousRequest.HasRequest ? previousRequest.RequestId : "",
+                    force_recompile = request.ForceRecompile
+                },
+                request.RequestId);
         }
 
         private static string ResolveCorrelationId(UnityCliLoopCompileRequest request)
@@ -276,6 +291,27 @@ private static object BuildCompileLogContext(UnityCliLoopCompileRequest request)
             };
         }
 
+        private static void LogCompileRequestReceived(
+            UnityCliLoopCompileRequest request,
+            string correlationId)
+        {
+            Debug.Assert(request != null, "request must not be null");
+
+            VibeLogger.LogInfo(
+                "compile_request_received",
+                "Received compile request from CLI.",
+                new
+                {
+                    request_id = request.RequestId,
+                    force_recompile = request.ForceRecompile,
+                    wait_for_domain_reload = request.WaitForDomainReload,
+                    stop_on_external_scene_changes = !request.ReloadExternalSceneChanges,
+                    is_compiling = EditorApplication.isCompiling,
+                    is_updating = EditorApplication.isUpdating
+                },
+                correlationId);
+        }
+
         private static string CreateRequestId()
         {
             long unixTimeMilliseconds = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();